• 利用Openssl写一个简陋的https劫持

    背景

    前面说过可以使用WinDivert+MITM搞一手流量透明，现在转发流量的项目已经有了，虽然只有第一部分(后面的代码分析可能会鸽了，代码已经看完了也大概知道了原理，但是不想写)，然后需要知道https流量劫持怎么处理，于是在互联网的帮助下找到了这个，虽然他也是转发，但是原文已经找不到了，所以象征的贴一下，还有一个是模拟ssl握手的项目。

    开整

    这部分涉及到很多知识，可能会提及，也可能不会，不会的可能比较大。

    下面是https代理的原理，如果你使用windows下面的internet setting设置，主机会发送一个connect请求，告诉代理服务器，我要请求的域名是什么。

     前面的流量转发中是直接重定向了443端口的流量，而不是使用代理的模式，这里是不会有connect请求的，那mitm怎么知道我要访问的网站是什么？

    来看看使用windows代理时的情况，首先是128给144发了一个connect请求，告诉144我要找百度，然后代理服务器知道它要找百度，于是问网关，可以告诉弟弟百度的地址吗？之后拿着这个地址去和百度建立连接。

     数据传输的方式如下所示，不过原作者是burp suite，这里是mitm。

    http://p8.qhimg.com/t01c852271242287cd3.png

     那直接转发端口的是如何知道访问域名的呢？其实tls中会携带要访问的域名信息，如下所示，所以在tls say hello的时候也同样可以获取到目的域名。

    好了，前面说了一堆，主要想表达的是需要对tls的servername进行解析得到对应的域名，这里由于tls的结构没有现成的，所以很随便的获取到对应的域名，相当不规范。

    1. //获取访问的域名
    2. 		int size = recv(server_sock, buf, 0x100, MSG_PEEK);
    3. 		for (int i = 0x50; i < size; i++)//
    4. 		{
    5. 			int len = buf[i];
    6. 			if (len&& len < size - 0x50)
    7. 			{
    8. 				if (strlen(buf + i + 1) == len)
    9. 				{
    10. 					struct hostent* phost = gethostbyname(buf + i + 1);
    11. 					if (phost)
    12. 					{
    13. 						strcpy(hostName, buf + i + 1);
    14. 						int count = 0;
    15. 						int len = strlen(hostName) - 1;
    16. 						for (int j = len; j > 0; j--)
    17. 						{
    18. 							if (hostName[j] == '.')
    19. 								count++;
    20. 							if (count == 2)
    21. 							{
    22. 								pHostName = hostName + j + 1;
    23. 								break;
    24. 							}
    25. 						}
    26. 						if (count == 1)
    27. 						{
    28. 							pHostName = hostName;
    29. 						}
    30. 						SOCKADDR_IN client_sin;
    31. 						memset((void*)& client_sin, 0, sizeof(SOCKADDR_IN));
    32. 						memcpy(&client_sin.sin_addr, phost->h_addr_list[0], phost->h_length);
    33. 						strcpy(target_host, inet_ntoa(client_sin.sin_addr));
    34. 						break;
    35. 					}
    36. 				}
    37. 			}
    38. 		}
    39. 		if (!pHostName || !pHostName[0] )
    40. 		{
    41. 			printf("anlyze domian failed !\n");
    42. 			return;
    43. 		}

    证书的问题

    这里需要注意的是，如果直接拿到这个代码去搞，会被chrome警告为不可信链接，需要在源主机安装自己的根证书，具体根证书和服务器证书看这。

    好了，默认大家都知道根证书和服务器证书的关系，但是就算你安装根证书，还是会有问题，一样会被chrome警告。

     那怎么玩？主要是chrome比别人要严格一点，它还会校验dns的域名信息，你好需要加上下面的拓展信息就行了

    1. keyUsage = nonRepudiation, digitalSignature, keyEncipherment
    2. extendedKeyUsage = serverAuth, clientAuth
    3. subjectAltName=@SubjectAlternativeName
    4.  
    5. [ SubjectAlternativeName ]
    6. DNS.1=baidu.com
    7. DNS.2=www.baidu.com

    openssl x509 。。。。。。。。最后加上这个 -extfile http.ext

    1. //对指定域名生成证书，就第一次需要生成，之后继续沿用就行了
    2. 		char tmp[0x100] = { 0 };
    3. 		char  CERT_FILE[0x100] = { 0 };
    4. 		sprintf(CERT_FILE, "server%s.crt", pHostName);
    5. 		EnterCriticalSection(&g_critical);
    6. 		if (OpenFile(CERT_FILE, (LPOFSTRUCT)tmp, OF_EXIST) == -1)
    7. 		{
    8. 			LeaveCriticalSection(&g_critical);
    9. 			//生成证书文件，使用命令行的方式
    10. 			//首先写文件到http.ext里面
    11. 			char httpExtPath[0x100] = { 0 };
    12. 			sprintf(httpExtPath, "http%s.ext", pHostName);
    13. 			CopyFile("http.ext", httpExtPath, FALSE);
    14. 			FILE* fp = fopen(httpExtPath, "a+");
    15. 			fprintf(fp, "DNS.1=%s\n", pHostName);
    16. 			fprintf(fp, "DNS.2=*.%s", pHostName);
    17.  
    18. 			fclose(fp);
    19.  
    20. 			char ServerCrt[0x100] = { 0 };
    21. 			//openssl x509 -req -in server.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out server.crt -days 3650 -sha256 -extfile http.ext
    22. 			sprintf(ServerCrt, "openssl x509 -req -in server.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out server%s.crt -days 3650 -sha256 -extfile http%s.ext", pHostName, pHostName);
    23. 			WinExec(ServerCrt, FALSE);
    24. 		}
    25. 		else
    26. 		{
    27. 			LeaveCriticalSection(&g_critical);
    28. 		}

    生成证书的方式，这里会给每一个域名发一个证书，考虑到访问同一个域名的问题，这里整了一个临界区。

    1. openssl genrsa -out server.key 1024
    2. openssl req -new -key server.key -out server.csr
    3. openssl genrsa -out ca.key 1024
    4. openssl req -new -key ca.key -out ca.csr
    5. openssl x509 -req -in ca.csr -signkey ca.key -out ca.crt
    6. openssl x509 -req -in server.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out server.crt -days 3650 -sha256 -extfile http.ext

    结果

    访问百度和QQ都不会提示证书有问题，但是会发现网站启动的很慢，而且这里生成的x509也不是在内存中生成，而是先写到文件在读取，效率会有问题，你问我为什么不使用openssl直接生成一个证书，还不是因为菜，所以只能效率低就低吧，能跑就行。

    代码：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6.  
    7. #pragma comment(lib, "libeay32.lib")
    8. #pragma comment(lib, "ssleay32.lib")
    9. #pragma comment(lib, "Ws2_32.lib")
    10.  
    11.  
    12. #define KEY_FILE "server.key"
    13. #define MAX_USER 50 //最大鏈接量
    14.  
    15. struct timeval timeout = { 0, 1000000 };
    16.  
    17. CRITICAL_SECTION g_critical;
    18. SOCKET Server_Socket_Init()
    19. {
    20. 	WSADATA wsa;
    21.  
    22. 	WSAStartup(0x0202, &wsa);
    23.  
    24. 	SOCKET sock = socket(AF_INET, SOCK_STREAM, 0);
    25. 	if (INVALID_SOCKET == sock)
    26. 	{
    27. 		printf("Create socket as a server error");
    28. 		return INVALID_SOCKET;
    29. 	}
    30.  
    31. 	
    32. 	int on = 1;
    33. 	if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char*)& on, sizeof(on)) < 0)
    34. 	{
    35. 		printf("reuseaddr  error");
    36. 	}
    37.  
    38. 	SOCKADDR_IN server_sin;
    39. 	memset((void*)& server_sin, 0, sizeof(SOCKADDR_IN));
    40. 	server_sin.sin_family = AF_INET;
    41. 	server_sin.sin_addr.S_un.S_addr = INADDR_ANY;
    42. 	server_sin.sin_port = htons(8080);
    43.  
    44. 	int ret = bind(sock, (struct sockaddr*) & server_sin, sizeof(SOCKADDR_IN));
    45. 	if (SOCKET_ERROR == ret)
    46. 	{
    47. 		shutdown(sock, 2);
    48. 		printf("bind error: %d\n", GetLastError());
    49. 		return INVALID_SOCKET;
    50. 	}
    51.  
    52. 	ret = listen(sock, MAX_USER);
    53. 	if (SOCKET_ERROR == ret)
    54. 	{
    55. 		printf("listen error.\n");
    56. 		return INVALID_SOCKET;
    57. 	}
    58.  
    59. 	printf("Listening on all local ip address, waiting for connect...\n");
    60.  
    61. 	return sock;
    62. }
    63.  
    64. void SSL_Error(char* custom_string) {
    65. 	char error_buffer[256] = { 0 };
    66.  
    67. 	printf("%s, ", custom_string);
    68. 	ERR_error_string(ERR_get_error(), error_buffer);
    69. 	printf("%s\n", error_buffer);
    70. }
    71.  
    72. SSL* Server_SSL_Init(char * CERT_FILE) {
    73. 	// 加载SSL环境
    74. 	SSL_CTX* server_ctx = SSL_CTX_new(SSLv23_server_method());
    75. 	if (NULL == server_ctx)
    76. 	{
    77. 		SSL_Error("Init ssl ctx error");
    78. 		return NULL;
    79. 	}
    80.  
    81. 	// 设置证书文件的口令
    82. 	//SSL_CTX_set_default_passwd_cb_userdata(server_ctx, "木有密碼");
    83.  
    84. 	// 加载证书
    85. 	if (SSL_CTX_use_certificate_file(server_ctx, CERT_FILE, SSL_FILETYPE_PEM) <= 0)
    86. 	{
    87. 		SSL_Error("Load cert file error");
    88. 		return NULL;
    89. 	}
    90.  
    91. 	// 加载私钥
    92. 	if (SSL_CTX_use_PrivateKey_file(server_ctx, KEY_FILE, SSL_FILETYPE_PEM) <= 0)
    93. 	{
    94. 		SSL_Error("Load cert file error");
    95. 		return NULL;
    96. 	}
    97.  
    98. 	// 检查私钥和证书是否匹配
    99. 	if (!SSL_CTX_check_private_key(server_ctx))
    100. 	{
    101. 		printf("Private key does not match the certificate public key\n");
    102. 		return NULL;
    103. 	}
    104.  
    105. 	SSL* ssl = SSL_new(server_ctx);
    106. 	if (NULL == ssl)
    107. 	{
    108. 		SSL_Error("Create ssl error");
    109. 		return NULL;
    110. 	}
    111.  
    112. 	return ssl;
    113. }
    114.  
    115. SOCKET Client_Socket_Init(char * target_host) {
    116. 	SOCKET client_sock = socket(AF_INET, SOCK_STREAM, 0);
    117.  
    118. 	if (INVALID_SOCKET == client_sock) 
    119. 	{
    120. 		printf("create socket as a client error.\n");
    121. 		return -1;
    122. 	}
    123.  
    124. 	SOCKADDR_IN client_sin;
    125. 	memset((void*)& client_sin, 0, sizeof(SOCKADDR_IN));
    126.  
    127. 	client_sin.sin_family = AF_INET;
    128. 	client_sin.sin_addr.S_un.S_addr = inet_addr(target_host);
    129. 	client_sin.sin_port = htons(443);
    130.  
    131. 	int ret = connect(client_sock, (struct sockaddr*) & client_sin, sizeof(SOCKADDR_IN));
    132. 	if (SOCKET_ERROR == ret)
    133. 	{
    134. 		printf("connect to real server %s error \n", target_host);
    135. 		return INVALID_SOCKET;
    136. 	}
    137.  
    138. 	printf("connect to real server success!\n");
    139.  
    140. 	return client_sock;
    141. }
    142.  
    143. SSL* Client_SSL_Init() {
    144. 	SSL_CTX* client_ctx;
    145.  
    146. 	client_ctx = SSL_CTX_new(SSLv23_client_method());
    147.  
    148. 	if (NULL == client_ctx) {
    149. 		SSL_Error((char *)"Init ssl ctx error");
    150. 		return NULL;
    151. 	}
    152.  
    153. 	SSL* ssl = SSL_new(client_ctx);
    154. 	if (NULL == ssl) {
    155. 		SSL_Error((char *)"Create ssl error");
    156. 		return NULL;
    157. 	}
    158.  
    159. 	return ssl;
    160. }
    161.  
    162. typedef struct _CONDATA
    163. {
    164. 	char target_host[20];
    165. 	SOCKET server_sock;
    166. 	SSL* server_ssl;
    167. }CONDATA,*PCONDATA;
    168. typedef struct _TRANSFER
    169. {
    170. 	SSL* client_ssl;
    171. 	SSL* server_ssl;
    172. }TRANSFER, * PTRANSFER;
    173.  
    174. void transfer(LPVOID argument)
    175. {
    176. 	fd_set fd_read;
    177. 	timeval time_out;
    178. 	char buffer[4096] = { 0 };
    179. 	PTRANSFER  pData = (PTRANSFER)argument;
    180. 	int socket_to_client = SSL_get_fd(pData->client_ssl);
    181. 	int socket_to_server = SSL_get_fd(pData->server_ssl);
    182. 	while (TRUE) 
    183. 	{
    184. 		int max;
    185.  
    186. 		FD_ZERO(&fd_read);
    187. 		FD_SET(socket_to_server, &fd_read);
    188. 		FD_SET(socket_to_client, &fd_read);
    189. 		max = socket_to_client > socket_to_server ? socket_to_client + 1
    190. 			: socket_to_server + 1;
    191.  
    192. 		int ret = select(max, &fd_read, NULL, NULL, &timeout);
    193. 		if (ret < 0) {
    194. 			SSL_Error("Fail to select!");
    195. 			break;
    196. 		}
    197. 		else if (ret == 0) {
    198. 			continue;
    199. 		}
    200. 		if (FD_ISSET(socket_to_client, &fd_read)) {
    201. 			memset(buffer, 0, sizeof(buffer));
    202. 			ret = SSL_read(pData->client_ssl, buffer, sizeof(buffer));
    203. 			if (ret > 0) {
    204. 				if (ret != SSL_write(pData->server_ssl, buffer, ret)) {
    205. 					SSL_Error("Fail to write to server!");
    206. 					break;
    207. 				}
    208. 				else {
    209. 					//printf("%s\n", buffer);
    210. 				}
    211. 			}
    212. 			else {
    213. 				SSL_Error("Fail to read from client!");
    214. 				break;
    215. 			}
    216. 		}
    217. 		if (FD_ISSET(socket_to_server, &fd_read)) {
    218. 			memset(buffer, 0, sizeof(buffer));
    219. 			ret = SSL_read(pData->server_ssl, buffer, sizeof(buffer));
    220. 			if (ret > 0) {
    221. 				if (ret != SSL_write(pData->client_ssl, buffer, ret)) {
    222. 					SSL_Error("Fail to write to client!");
    223. 					break;
    224. 				}
    225. 				else {
    226. 					//printf("%s\n", buffer);
    227. 				}
    228. 			}
    229. 			else {
    230. 				SSL_Error("Fail to read from server!");
    231. 				break;
    232. 			}
    233. 		}
    234. 	}
    235.  
    236. 	SSL_shutdown(pData->server_ssl);
    237. 	SSL_shutdown(pData->client_ssl);
    238.  
    239. 	SSL_free(pData->server_ssl);
    240. 	SSL_free(pData->client_ssl);
    241.  
    242. 	free(argument);
    243. }
    244.  
    245. void WINAPI GetHttpsPacket(LPVOID argument) {
    246. 	char *pHostName = NULL;
    247. 	char buf[0x100] = { 0 };
    248. 	char hostName[0x100] = { 0 };
    249. 	char target_host[20] = { 0 };
    250.  
    251. 	SOCKET server_sock = (SOCKET)(*(SOCKET*)argument);
    252. 	__try 
    253. 	{
    254. 		//获取访问的域名
    255. 		int size = recv(server_sock, buf, 0x100, MSG_PEEK);
    256. 		for (int i = 0x50; i < size; i++)//
    257. 		{
    258. 			int len = buf[i];
    259. 			if (len&& len < size - 0x50)
    260. 			{
    261. 				if (strlen(buf + i + 1) == len)
    262. 				{
    263. 					struct hostent* phost = gethostbyname(buf + i + 1);
    264. 					if (phost)
    265. 					{
    266. 						strcpy(hostName, buf + i + 1);
    267. 						int count = 0;
    268. 						int len = strlen(hostName) - 1;
    269. 						for (int j = len; j > 0; j--)
    270. 						{
    271. 							if (hostName[j] == '.')
    272. 								count++;
    273. 							if (count == 2)
    274. 							{
    275. 								pHostName = hostName + j + 1;
    276. 								break;
    277. 							}
    278. 						}
    279. 						if (count == 1)
    280. 						{
    281. 							pHostName = hostName;
    282. 						}
    283. 						SOCKADDR_IN client_sin;
    284. 						memset((void*)& client_sin, 0, sizeof(SOCKADDR_IN));
    285. 						memcpy(&client_sin.sin_addr, phost->h_addr_list[0], phost->h_length);
    286. 						strcpy(target_host, inet_ntoa(client_sin.sin_addr));
    287. 						break;
    288. 					}
    289. 				}
    290. 			}
    291. 		}
    292. 		if (!pHostName || !pHostName[0] )
    293. 		{
    294. 			printf("anlyze domian failed !\n");
    295. 			return;
    296. 		}
    297.  
    298. 		//对指定域名生成证书，就第一次需要生成，之后继续沿用就行了
    299. 		char tmp[0x100] = { 0 };
    300. 		char  CERT_FILE[0x100] = { 0 };
    301. 		sprintf(CERT_FILE, "server%s.crt", pHostName);
    302. 		EnterCriticalSection(&g_critical);
    303. 		if (OpenFile(CERT_FILE, (LPOFSTRUCT)tmp, OF_EXIST) == -1)
    304. 		{
    305. 			LeaveCriticalSection(&g_critical);
    306. 			//生成证书文件，使用命令行的方式
    307. 			//首先写文件到http.ext里面
    308. 			char httpExtPath[0x100] = { 0 };
    309. 			sprintf(httpExtPath, "http%s.ext", pHostName);
    310. 			CopyFile("http.ext", httpExtPath, FALSE);
    311. 			FILE* fp = fopen(httpExtPath, "a+");
    312. 			fprintf(fp, "DNS.1=%s\n", pHostName);
    313. 			fprintf(fp, "DNS.2=*.%s", pHostName);
    314.  
    315. 			fclose(fp);
    316.  
    317. 			char ServerCrt[0x100] = { 0 };
    318. 			//openssl x509 -req -in server.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out server.crt -days 3650 -sha256 -extfile http.ext
    319. 			sprintf(ServerCrt, "openssl x509 -req -in server.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out server%s.crt -days 3650 -sha256 -extfile http%s.ext", pHostName, pHostName);
    320. 			WinExec(ServerCrt, FALSE);
    321. 		}
    322. 		else
    323. 		{
    324. 			LeaveCriticalSection(&g_critical);
    325. 		}
    326.  
    327. 		SSL* server_ssl = Server_SSL_Init(CERT_FILE);
    328. 		if (NULL == server_ssl)//初始化ssl失败
    329. 		{
    330. 			SSL_Error("server_ssl error\n");
    331. 			return;
    332. 		}
    333. 		SSL_set_fd(server_ssl, server_sock);
    334. 		int ret = SSL_accept(server_ssl);
    335. 		if (-1 == ret)//接受数据失败
    336. 		{
    337. 			SSL_Error("server_ssl SSL_accept error\n");
    338. 			return;
    339. 		}
    340.  
    341.  
    342. 		// 生成SSL，作为客户端
    343. 		SSL* client_ssl = Client_SSL_Init();
    344. 		if (NULL == client_ssl)
    345. 		{
    346. 			SSL_Error((char*)"client_ssl error");
    347. 			return;
    348. 		}
    349. 		//向真实主机发起请求
    350. 		SOCKET client_sock = Client_Socket_Init(target_host);
    351. 		if (INVALID_SOCKET == client_sock)
    352. 		{
    353. 			SSL_Error((char*)"client_sock error");
    354. 			return;
    355. 		}
    356. 		SSL_set_fd(client_ssl, client_sock);
    357. 		ret = SSL_connect(client_ssl);
    358. 		if (-1 == ret)
    359. 		{
    360. 			SSL_Error("SSL_connect error\n");
    361. 			return;
    362. 		}
    363.  
    364. 		PTRANSFER data = (PTRANSFER)malloc(sizeof(TRANSFER));
    365. 		if (data)
    366. 		{
    367. 			data->client_ssl = client_ssl;
    368. 			data->server_ssl = server_ssl;
    369. 		}
    370. 		HANDLE h_thread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)transfer, data, 0, NULL);
    371. 		if (h_thread)
    372. 			CloseHandle(h_thread);
    373. 	}
    374. 	__except (EXCEPTION_EXECUTE_HANDLER) {}
    375. 	
    376. 	return;
    377. }
    378.  
    379. int main()
    380. {
    381. 	InitializeCriticalSection(&g_critical);//初始化临界区
    382. 	SOCKET server_sock = Server_Socket_Init();//初始化一個監聽443端口套接字
    383. 	if (INVALID_SOCKET == server_sock)
    384. 		return -1;
    385.  
    386. 	//初始化openssl
    387. 	SSL_library_init();
    388. 	SSL_load_error_strings();
    389.  
    390.  
    391. 	// 开始接受连接
    392. 	SOCKET client_sock; // 来自被攻击者的socket
    393. 	SOCKADDR_IN client_sin;
    394. 	int sin_len = sizeof(SOCKADDR_IN);
    395. 	memset((void*)& client_sin, 0, sizeof(SOCKADDR_IN));
    396.  
    397. 	while (TRUE) {
    398. 		client_sock = accept(server_sock, (struct sockaddr*) & client_sin, &sin_len);
    399.  
    400. 		printf("connect from %s\n", inet_ntoa(client_sin.sin_addr));
    401.  
    402. 		if (SOCKET_ERROR == client_sock) 
    403. 		{
    404. 			printf("accept error.\n");
    405. 			continue;
    406. 		}
    407.  
    408. 		DWORD thread_id = 0;
    409. 		HANDLE h_thread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)GetHttpsPacket, (LPVOID)& client_sock, 0, &thread_id);
    410.  
    411. 		if (h_thread)
    412. 			CloseHandle(h_thread);
    413.  
    414. 		
    415. 	}
    416.  
    417. 	closesocket(server_sock);
    418. 	WSACleanup();
    419.  
    420. 	DeleteCriticalSection(&g_critical);
    421.  
    422. 	return 0;
    423. }
  • 相关阅读:
    three.js学习笔记(二十二)——混合HTML和WebGL
    统计字符串中单词的个数--空格间隔
    uniapp搜索框防抖、自动获取焦点
    Meta携手亚马逊共建PyTorch ，抵抗Tensorflow
    网络程序设计——VC的多线程编程（线程与进程）
    [激光器原理与应用-9]： 开关电源主要指标
    Java中的this关键字
    Java中Servlet的生命周期
    使用ceph-deploy部署Ceph集群
    【Solution】一文学会微信扫码登录
  • 原文地址：https://blog.csdn.net/lyshark_lyshark/article/details/126792461