IPC 共享通俗讲解及其安全风险

IPC 共享，指的是进程间通信（IPC，Inter-Process Communication）中的数据共享方式。简单来说，它允许多个进程（程序）相互交换信息或共享数据。

为什么需要 IPC 共享？

在计算机中，进程是相互独立的，每个进程有自己的一片内存空间。默认情况下，一个进程不能访问另一个进程的数据。

但有时候，我们需要多个进程协作，比如：
✅ 浏览器的多个进程：Chrome 浏览器会为不同的标签页创建不同的进程，但这些进程需要共享一些数据，比如书签、历史记录等。
✅ 数据库访问：多个进程可能同时访问一个数据库，它们需要同步数据，防止冲突。
✅ 生产者-消费者模型：一个进程负责生产数据（生产者），另一个进程消费数据（消费者），它们需要共享一块数据区域进行交互。

如果没有 IPC 共享，每个进程只能“各过各的”，无法互相协作。所以，IPC 共享的本质就是让多个进程能高效、安全地共享数据。

IPC 共享的几种方式

IPC 共享有多种不同的实现方式，常见的有：

IPC 方式	适用场景	共享特点
共享内存（Shared Memory）	需要高效共享大数据	直接在一块内存区域共享数据，最快的方式
消息队列（Message Queue）	进程之间需要排队发送消息	进程通过队列发送和接收消息
管道（Pipe）/命名管道（FIFO）	父子进程通信或单向通信	通过文件流方式传输数据，适合小数据
信号（Signal）	进程间通知和中断	进程可以向另一个进程发送信号，如 `SIGTERM` 终止进程
套接字（Socket）	远程进程通信（网络）	适用于网络或本地进程通信

下面详细介绍常见的 IPC 共享方式👇

1. 共享内存（Shared Memory）

概念

共享内存就是开辟一块特殊的内存区域，让多个进程可以访问这块区域，从而实现数据共享。

类比

就像家里有一个共享的“白板”，大家都可以在上面写字、擦除、修改信息，而不需要通过“邮寄”来交换数据。

特点

✅ 速度最快：直接读写内存，没有中间环节。
✅ 适合大数据传输：可以共享大块数据，而不像消息队列那样受限于队列长度。
❌ 需要同步机制：多个进程同时读写可能会产生冲突，需要使用**信号量（Semaphore）或互斥锁（Mutex）**来避免数据不一致。

示例

一个进程写入共享内存，另一个进程读取：

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <string.h>

int main() {
    key_t key = 1234;  // 共享内存的键
    int shmid = shmget(key, 1024, IPC_CREAT | 0666); // 创建共享内存

    char *data = (char*) shmat(shmid, NULL, 0);  // 连接到共享内存
    strcpy(data, "Hello, IPC Shared Memory!");  // 写入数据

    printf("写入共享内存: %s\n", data);
    shmdt(data); // 断开共享内存
}

另一个进程读取：

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>

int main() {
    key_t key = 1234; 
    int shmid = shmget(key, 1024, 0666); // 连接已有的共享内存

    char *data = (char*) shmat(shmid, NULL, 0);
    printf("从共享内存读取: %s\n", data);

    shmdt(data); // 断开共享内存
    shmctl(shmid, IPC_RMID, NULL); // 删除共享内存
}

执行流程：

第一个进程 创建共享内存，并写入 "Hello, IPC Shared Memory!"。
第二个进程 读取共享内存，得到相同数据。
共享内存仍然存在，直到显式删除。

2. 消息队列（Message Queue）

概念

消息队列就像一个“消息邮箱”，进程可以向里面发送消息，另一个进程可以从里面取出消息。

类比

你和朋友不能直接说话（不同进程），但可以用一个邮箱互相留信件（消息队列）。

特点

✅ 可以实现异步通信：一个进程发送消息后，不需要等对方处理完毕。
✅ 数据安全，不会被覆盖：不像共享内存那样需要额外同步机制。
❌ 速度比共享内存慢：因为涉及到内核队列管理。

示例

进程 1 发送消息：

#include <stdio.h>
#include <sys/msg.h>
#include <string.h>

struct msg_buffer {
    long msg_type;
    char msg_text[100];
};

int main() {
    key_t key = 1234;
    int msgid = msgget(key, IPC_CREAT | 0666); // 创建消息队列

    struct msg_buffer message;
    message.msg_type = 1;
    strcpy(message.msg_text, "Hello, IPC Message Queue!");

    msgsnd(msgid, &message, sizeof(message.msg_text), 0); // 发送消息
    printf("发送消息: %s\n", message.msg_text);
}

进程 2 读取消息：

#include <stdio.h>
#include <sys/msg.h>

struct msg_buffer {
    long msg_type;
    char msg_text[100];
};

int main() {
    key_t key = 1234;
    int msgid = msgget(key, 0666); // 连接已有消息队列

    struct msg_buffer message;
    msgrcv(msgid, &message, sizeof(message.msg_text), 1, 0); // 读取消息
    printf("收到消息: %s\n", message.msg_text);

    msgctl(msgid, IPC_RMID, NULL); // 删除消息队列
}

执行流程：

进程 1 发送 "Hello, IPC Message Queue!" 到消息队列。
进程 2 读取该消息，并从队列中移除。
消息队列仍然存在，直到显式删除。

3. 管道（Pipe）/命名管道（FIFO）

概念

管道是一种流式通信方式，允许一个进程将数据输出到管道中，另一个进程从管道中读取数据。管道有两种类型：匿名管道和命名管道。

匿名管道：通常用于父子进程间的通信，不能跨进程。
命名管道（FIFO）：是管道的一种特殊形式，它存在于文件系统中，可以用于任何进程之间的通信。

类比

可以将管道想象成一个单向水管，一个进程（生产者）通过管道将数据输入，另一个进程（消费者）从管道另一端读取数据。命名管道则类似于一个带有“名字”的水管，任何进程都可以连接到它。

特点

✅ 简单易用：适合进程之间单向的数据传输。
✅ 同步性强：一个进程必须等待另一个进程从管道中读取数据。
❌ 只能通过文件描述符访问：需要使用文件操作进行数据的读取和写入。
❌ 适合小数据传输：管道的缓冲区通常较小，适合传输少量数据。

示例

进程 1 写入管道：

#include <stdio.h>
#include <unistd.h>
#include <string.h>

int main() {
    int pipefd[2];
    char *message = "Hello, IPC Pipe!";
    
    pipe(pipefd);  // 创建管道
    write(pipefd[1], message, strlen(message));  // 向管道写入数据

    close(pipefd[1]);  // 关闭写端
    return 0;
}

进程 2 读取管道：

#include <stdio.h>
#include <unistd.h>

int main() {
    int pipefd[2];
    char buffer[128];

    pipe(pipefd);  // 创建管道

    // 启动进程 1 写入数据
    read(pipefd[0], buffer, sizeof(buffer));  // 从管道读取数据
    printf("读取管道消息: %s\n", buffer);

    close(pipefd[0]);  // 关闭读端
    return 0;
}

执行流程：

进程 1 向管道的写端写入数据 "Hello, IPC Pipe!"。
进程 2 从管道的读端读取并输出数据。
管道在进程结束后仍然存在，直到显式关闭或程序终止。

4. 信号（Signal）

概念

信号是一种轻量级的进程间通信机制，通常用于通知进程某个事件或处理特定的中断。信号在操作系统中用于传递控制信息（如终止、暂停等）。

类比

信号可以想象为“敲门”，当一个进程收到信号时，就会对这个信号做出相应的反应。例如，接到“停止”信号，进程可以选择退出。

特点

✅ 高效：信号的传递通常是即时的，不需要复杂的同步机制。
✅ 轻量级：它仅传递信号的标识符，不需要传输大量数据。
❌ 不适用于传递大量数据：信号通常只携带一个数字或简短的信息。
❌ 需要处理程序：进程必须有信号处理器来接收和响应信号。

示例

发送信号：

kill -SIGTERM <pid>  # 向指定进程发送 SIGTERM 信号，通知其退出

捕获信号：

#include <stdio.h>
#include <signal.h>

void handle_signal(int sig) {
    if (sig == SIGINT) {
        printf("捕获到 SIGINT 信号！\n");
    }
}

int main() {
    signal(SIGINT, handle_signal);  // 注册信号处理器

    while (1) {
        printf("等待信号...\n");
        sleep(1);  // 模拟进程在运行
    }
    return 0;
}

执行流程：

使用 kill 命令向某个进程发送信号。
进程捕获信号并执行相应的处理逻辑（如打印消息、退出等）。

5. 套接字（Socket）

概念

套接字是一种用于进程间通信的网络编程接口，允许不同计算机或同一计算机上的不同进程进行通信。套接字可以使用 TCP（传输控制协议）或 UDP（用户数据报协议）进行数据传输，适合进行远程进程通信。

类比

套接字就像是一个“电话”，两个进程通过它建立连接，进行双向的通讯。就像拨打电话时双方通过电话交换信息一样，套接字使得网络上的进程可以互相“通话”。

特点

✅ 适用于远程通信：可以在不同机器上的进程之间进行通信。
✅ 支持双向通信：一旦建立连接，双方可以进行双向数据传输。
❌ 通信延迟较高：相比本地进程间的通信，网络通信通常会有较高的延迟。

示例

服务器端代码（监听客户端连接）：

#include <stdio.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <string.h>

int main() {
    int sockfd, client_sock;
    struct sockaddr_in server, client;
    
    sockfd = socket(AF_INET, SOCK_STREAM, 0);  // 创建 TCP 套接字
    server.sin_family = AF_INET;
    server.sin_addr.s_addr = INADDR_ANY;
    server.sin_port = htons(8888);
    
    bind(sockfd, (struct sockaddr*)&server, sizeof(server));  // 绑定端口
    listen(sockfd, 3);  // 监听端口

    int c = sizeof(struct sockaddr_in);
    client_sock = accept(sockfd, (struct sockaddr*)&client, &c);  // 接受连接

    char *message = "Hello, Client!";
    send(client_sock, message, strlen(message), 0);  // 发送数据

    close(client_sock);  // 关闭客户端连接
    close(sockfd);  // 关闭服务器套接字
    return 0;
}

客户端代码（连接服务器并接收数据）：

#include <stdio.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <string.h>

int main() {
    int sockfd;
    struct sockaddr_in server;
    char buffer[2000];

    sockfd = socket(AF_INET, SOCK_STREAM, 0);  // 创建套接字
    server.sin_family = AF_INET;
    server.sin_port = htons(8888);
    server.sin_addr.s_addr = inet_addr("127.0.0.1");  // 连接本机

    connect(sockfd, (struct sockaddr*)&server, sizeof(server));  // 连接服务器

    recv(sockfd, buffer, sizeof(buffer), 0);  // 接收服务器数据
    printf("收到服务器消息: %s\n", buffer);

    close(sockfd);  // 关闭套接字
    return 0;
}

执行流程：

服务器 创建套接字并监听端口。
客户端 连接到服务器并接收信息。
数据通过套接字进行双向传输。

渗透测试中的 IPC 共享攻击手法

在渗透测试（Penetration Testing）中，IPC 共享可以被用于信息收集、权限提升、进程注入、横向移动等攻击场景。攻击者可以利用 IPC 机制在进程间传递恶意数据、绕过安全检测、劫持敏感信息，甚至利用共享内存进行隐蔽的通信。

可能的攻击手法如下：

本地提权：利用 IPC 读取高权限进程数据，如数据库密码、API 密钥。
横向移动：攻击者可以利用 IPC 在不同进程中传播恶意数据，提高控制范围。
隐蔽通信：恶意软件可以通过共享内存或消息队列作为后门，绕过常规流量检测。
恶意注入：利用共享内存和 LD_PRELOAD 劫持合法进程的执行逻辑。

总结

IPC 共享的方式各有优缺点：

共享内存（Shared Memory）：最快，适合大数据，但需要同步机制。
消息队列（Message Queue）：适合进程间异步通信，但速度不如共享内存。
管道（Pipe）：适合父子进程，单向通信。
信号（Signal）：适合进程间简单通知，如终止、暂停等。
套接字（Socket）：用于远程进程通信（网络）。

IPC 方式	可能的安全风险
共享内存（SHM）	未设置权限，攻击者可读写，劫持进程数据或注入恶意代码
消息队列（MQ）	无安全验证，可能导致信息泄露或被篡改
管道（FIFO）	进程数据可能被窃听，某些情况下可进行劫持
信号（Signal）	低权限进程可向高权限进程发送恶意信号，如 `SIGKILL`
套接字（Socket）	本地/远程通信可能被劫持，用于流量注入或MITM攻击

IPC 共享是现代操作系统中非常重要的功能，帮助多个进程高效、可靠地共享数据。不同的 IPC 方式适用于不同的场景，从共享内存到套接字，每种方式都有其特点和适用情况。在多进程和多线程应用中，理解并掌握 IPC 的使用，能够极大提升系统的协同能力和性能。

原文 https://blog.csdn.net/2301_79518550/article/details/145483871