理解http中cookie！C/C++实现网络的HTTP cookie

HTTP嗅探（HTTP Sniffing）是一种网络监控技术，通过截获并分析网络上传输的HTTP数据包来获取敏感信息或进行攻击。其中，嗅探器（Sniffer）是一种用于嗅探HTTP流量的工具。

在HTTP嗅探中，cookie是一种常用的敏感信息。Cookie是由服务器发送到用户浏览器并存储在本地的一种小型数据片段。它通常用于跟踪用户会话状态，保存用户登录信息等。因此，cookie对于攻击者来说具有很高的价值。

当攻击者进行HTTP嗅探时，他们可以通过嗅探器截获并分析网络上传输的HTTP数据包。在分析数据包时，攻击者可以查找包含cookie信息的请求和响应数据包。攻击者可以使用各种技术来提取和分析cookie，例如使用抓包工具（如Wireshark）或编写自定义的脚本来提取和分析数据包。

一旦攻击者获取到用户的cookie，他们可以采取不同的行动。一种常见的做法是使用“会话劫持”攻击，通过利用获取到的cookie来冒充用户身份并与服务器进行交互。攻击者可以借此访问用户的个人资料、执行敏感操作或窃取用户的身份信息等。

理解 HTTP 嗅探 cookie?

HTTP 嗅探是指在网络中截获和分析 HTTP 请求和响应的过程，而 Cookie 是 HTTP 响应中的一个重要部分。理解 HTTP 嗅探 Cookie，需要先了解以下几个概念：

• HTTP 请求和响应：HTTP（Hypertext Transfer
  Protocol）是互联网上应用最广泛的一种协议，它用于客户端和服务器之间的通信。HTTP 请求由客户端发起，包含请求方法（如
  GET、POST 等）、请求 URL 和 HTTP 协议版本等信息。HTTP 响应由服务器返回，包含 HTTP
  协议版本、状态码、消息和请求的资源等。
• Cookie：Cookie 是一种存储在客户端的文本文件，用于保存用户的一些个人信息和访问偏好。服务器可以通过在 HTTP 响应中设置
  Cookie，来实现对客户端的识别和跟踪。
• Set-Cookie 和 Cookie：HTTP 响应头中有两个与 Cookie 相关的字段，分别是 Set-Cookie 和
  Cookie。Set-Cookie 由服务器发送，用于在客户端创建一个新的 Cookie。Cookie 由客户端发送，包含在 HTTP
  请求的头部中，表示客户端已经存储的服务器设置的 Cookie。

在进行 HTTP 嗅探时，可以通过分析 HTTP 请求和响应中的 Cookie 字段，了解客户端和服务器之间的交互过程。例如，服务器可能会设置一个包含用户 ID 的 Cookie，客户端在后续请求中会将这个 Cookie 发送给服务器，服务器通过这个 Cookie 来识别用户。这样，即使用户在浏览器中删除了 Cookie，服务器仍然可以通过 HTTP 嗅探来获取这些信息。

需要注意的是，HTTP 嗅探可能会引发隐私安全问题，因此在实际应用中要谨慎使用。通常，浏览器会提供设置来允许或禁止存储 Cookie，用户可以根据自己的需求进行选择。

网络开发中的cookie是什么？

Cookie是后端可以存储在用户浏览器中的微小数据。用户跟踪、个性化以及最重要的身份验证是cookie最常见的用例。

Cookie有很多隐私问题，多年来一直受到严格的监管。

在这篇文章中，您将学习如何在前端和后端创建和使用HTTP cookie。

• 设置后端

后端的例子是Python中的Flask。如果您想继续，请创建一个新的Python虚拟环境，移动到其中，然后安装Flask：

mkdir cookies && cd $_

python3 -m venv venv
source venv/bin/activate

pip install Flask
1
2
3
4
5
6

在项目文件夹中创建一个名为flask_app.py的新文件，并使用我的示例在本地进行实验。

from flask import Flask, make_response

app = Flask(__name__)


@app.route("/index/", methods=["GET"])
def index():
    response = make_response("Here, take some cookie!")
    response.headers["Set-Cookie"] = "myfirstcookie=somecookievalue"
    return response
1
2
3
4
5
6
7
8
9
10

这里所说的后端是指cookie可以通过以下方式创建：

后端的实际应用程序代码（Python、JavaScript、PHP、Java）

响应请求的Web服务器（Nginx、Apache）

为此，后端在响应中设置一个名为Set Cookie的HTTP标头，该标头具有由键/值对组成的相应字符串，以及可选属性：

Set-Cookie: myfirstcookie=somecookievalue
1

何时何地创建这些cookie取决于要求。

所以，cookie是简单的字符串。请考虑Python with Flask中的这个例子。使用以下代码在项目文件夹中创建一个名为flask_app.py的Python文件：

然后运行应用程序：

FLASK_ENV=development FLASK_APP=flask_app.py flask run
1

当该应用程序正在运行，并且用户访问http://127.0.0.1:5000/index/后端使用键/值对设置名为Set-Cookie的响应标头。（127.0.0.1:5000是开发中Flask应用程序的默认侦听地址/端口）。

Set Cookie标头是了解如何创建Cookie的关键：

response.headers["Set-Cookie"] = "myfirstcookie=somecookievalue"
1

• 如何查看cookie？

在命令行上，您还可以使用curl查看后端设置了哪些cookie：

curl -I http://127.0.0.1:5000/index/
1

Cookie 的工作原理?

在 HTTP 协议中，Cookie是一种保存在用户浏览器端的文本文件，它会在用户访问某个网站时由该网站的服务器发送到浏览器并保存在本地。当用户再次访问同一网站时，浏览器会将 Cookie 携带并发送到服务器。Cookie 的目的主要是为了保存用户的一些会话信息，方便用户下次再次来到本网站时使用，提高用户体验。

Cookie 包含了一些与用户相关的信息，如用户的 ID、密码、浏览过的网页、停留的时间等，用于辨别用户身份。Cookie 的名称通常以"user@domain"的格式命名，其中"user"表示用户 ID，"domain"表示网站域名。

• Cookie 的工作原理如下：

1.当用户访问某个网站时，该网站的服务器会向用户的浏览器发送 Cookie。
2.浏览器会将 Cookie 存储在本地，并在下次访问同一网站时将 Cookie 携带并发送到服务器。
3.服务器接收到 Cookie 后，可以根据其中的信息判断用户身份，并根据需要进行相应的操作，如显示个性化内容或自动登录等。
1
2
3

然而，Cookie 也引发了一些安全和隐私方面的问题，如跨站脚本攻击（XSS）和隐私泄露等。为确保 Cookie 的安全使用，网站开发者需要采取一定的措施，如设置 HttpOnly 标志以保护 Cookie 不被脚本访问，或使用安全的传输协议（如 HTTPS）以加密 Cookie 等。同时，用户也可以通过浏览器设置来管理和控制 Cookie，如选择允许或拒绝某些 Cookie，或清除所有的 Cookie 等。

C/C++实现网络的HTTP cookie

...
void pcap_fatal(const char *failed_in, const char *errbuf);
char is_ip(const struct pcap_pkthdr *header, const u_char *packet);
char is_tcp(const struct pcap_pkthdr *header, const u_char *packet);
char is_http(const struct pcap_pkthdr *header, const u_char *packet);
void *get_tcp_payload_addr(const struct pcap_pkthdr *header, const u_char *packet);
u_int get_tcp_payload_size(const struct pcap_pkthdr *header, const u_char *packet);
...
typedef struct
{
    char *interface;
    char filter_exp[15];
} Arguments;

struct HTTP_cookie
{
    char *id;
    char *val;
    struct HTTP_cookie *next;
};

typedef struct HTTP_cookie HTTP_cookie;

typedef struct
{
    char *ip_src;
    char *host_dst;
    char *resource;
    char *request_type;
    HTTP_cookie *cookies;
} Host_cookies;

/* ---------- Prototypes ---------- */

error_t parse_opt(int key, char *arg, struct argp_state *state);
void signal_handler(int signal);

void got_packet(u_char *args, const struct pcap_pkthdr *header, const u_char *packet);

void display_raw_data(Host_cookies *host_cookies);
void display_csv_data(Host_cookies *host_cookies);
...
void got_packet(u_char *args, const struct pcap_pkthdr *header, const u_char *packet)
{
...

    /* While there are cookies */
    while (tok_cookie != NULL)
    {
        current_cookie = (HTTP_cookie *) malloc(sizeof(HTTP_cookie));

        if (current_cookie == NULL)
        {
            fprintf(stderr, "[x] Out of memory\n");
            pcap_close(handle);
            exit(EXIT_FAILURE);
        }

        current_cookie->id = strtok_r(tok_cookie, "=", &saveptr2);
        current_cookie->val = strtok_r(NULL, "=", &saveptr2);
        current_cookie->next = NULL;

        if (previous_cookie == NULL)
            host_cookies.cookies = current_cookie;
        else
            previous_cookie->next = current_cookie;

        previous_cookie = current_cookie;
        tok_cookie = strtok_r(NULL, " ;", &saveptr);
    }

    ip_src.s_addr = ip->ip_src_addr;
    host_cookies.ip_src = inet_ntoa(ip_src);

    host_cookies.host_dst = strstr(http_payload, "Host:");
    host_cookies.host_dst += 6;
    host_cookies.host_dst = strtok(host_cookies.host_dst, "\r\t\r\t");

...

    if (host_cookies.cookies != NULL)
        display_data(&host_cookies);
}
char is_http(const struct pcap_pkthdr *header, const u_char *packet)
{
...

    http_payload_addr = get_tcp_payload_addr(header, packet);
    http_payload_size = get_tcp_payload_size(header, packet);

    memcpy(http_payload, http_payload_addr, http_payload_size);

    if ((strstr(http_payload, " HTTP/")) == NULL)
        return 0;
    else
        return 1;
}
...
static struct argp_option options[] = {
    {"interface", 'i', "INTERFACE", 0, "Network interface to use"},
    {"port", 'p', "PORT", 0, "Network port to listen (default: 80)"},
    {"csv", 'C', 0, 0, "Display the cookies as CSV data"},
    {0}
};
...
int main (int argc, char ** argv)
{
...

    argp_parse(&argp, argc, argv, 0, 0, &arguments);

    signal(SIGINT, signal_handler);
    signal(SIGTERM, signal_handler);

    if (arguments.interface == NULL)
    {
        dev = pcap_lookupdev(errbuf);

        if (dev == NULL)
        {
            fprintf(stderr, "[x] Couldn't find the default network adaptor: %s\n", errbuf);
            exit(EXIT_FAILURE);
        }
    }
    else
        dev = arguments.interface;

    printf("[*] Device : %s\n", dev);

    if (pcap_lookupnet(dev, &net, &mask, errbuf) == -1)
    {
        fprintf(stderr, "[!] Couldn't get the netmask for device %s: %s\n", dev, errbuf);
        net = mask = 0;
    }

    handle = pcap_open_live(dev, BUFSIZ, 1, 1000, errbuf);

    if (handle == NULL)
    {
        fprintf(stderr, "[x] Couldn't open device %s: %s\n", dev, errbuf);
        exit(EXIT_FAILURE);
    }

    if ((pcap_compile(handle, &fp, arguments.filter_exp, 0, net)) == -1)
    {
        fprintf(stderr, "[x] Couldn't parse filter %s: %s\n", arguments.filter_exp, pcap_geterr(handle));
        pcap_close(handle);
        exit(EXIT_FAILURE);
    }

    if ((pcap_setfilter(handle, &fp)) == -1)
    {
        fprintf(stderr, "[x] Couldn't install filter %s: %s\n", arguments.filter_exp, pcap_geterr(handle));
        pcap_close(handle);
        exit(EXIT_FAILURE);
    }

    printf("[*] Filter : %s\n", arguments.filter_exp);
    printf("[*] Start sniffing ...\n");

    if ((pcap_loop(handle, -1, got_packet, NULL) == -1))
    {
        fprintf(stderr, "[x] Error while reading the packets\n");
        pcap_close(handle);
        exit(EXIT_FAILURE);
    }
...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168

If you need the complete source code, please add the WeChat number (c17865354792)

以下是默认输出的示例：

Host: www.html-kit.com
IP sources: 192.168.20.22
Resource: /tools/cookietester/
Request type: GET

TestCookie_Name_202310045556 = TestCookie_Value_155556
TestCookie_Name_202310045620 = TestCookie_Value_155620
1
2
3
4
5
6
7

使用选项-C，每条输出行将遵循以下结构：

host;ip_source;resource_requested;request_type;cookie_1_name;cookie_1_value;cookie_2_name;cookie_2_value;...
1

以下是一个示例：

www.html-kit.com;192.168.20.22;/tools/cookietester/;GET;TestCookie_Name_202310045556;TestCookie_Value_155556;TestCookie_Name_202310045620;TestCookie_Value_155620
1

总结

为了防止HTTP嗅探和cookie被盗，可以采用一些安全措施。例如，使用HTTPS协议来加密网络传输数据，这可以防止嗅探器截获敏感信息。此外，使用安全的密码策略，及时清理cookie中的敏感信息，限制cookie的存储时间和访问权限等也可以提高安全性。另外，使用多因素身份验证和定期更换密码等常见的安全措施也可以减少攻击者获取cookie的可能性。

Welcome to follow WeChat official account【程序猿编码】

参考：RFC 6265