抓包分析YY音频

YY的音频数据传输是P2P协议，音频的编码为AAC，下面抓去的音频编码的信息和频谱信息。

音频编码为AAC，采样为44K,码率24kb/s。音频编码在24kb/s码率能达到15K的音质。值得大家学习啊。

1.准备工具

procexp.exe      分析YY的进程信息

Procmon.exe      分析YY的网络数据包

wireshark.exe    分析网络包的内容

2.分析YY的进程信息

使用procexp分析YY的大致信息，比如进程号，网络连接等

3.分析YY的网络传输信息

使用procmon分析YY的网络数据，根据上面的得到的进程ID设置过滤，只接受YY的UDP数据包

过滤后得到数据包如下：

从上面的数据可以看到端口为8456的UDP接受数据最多，可以看出这个端口接受的就是P2P音频数据。

4.使用wireshark抓取P2P音频数据包

设置wireshark的过滤器，只抓去端口为8456的UDP数据包

抓去的数据如下：

查看UDP数据流，这里面存的就是YY的音频数据。从下面的数据看不出来具体的音频编码。

不急，我们多看几个数据包就会发现，他们都有固定的数据头，紧接着都刚好是0xff|0xf1(这个刚好是aac ADTS的同步头)。所以我们可以按照这个思路分析下去。

5. 使用代码分析pcap抓去的数据包

详细分析参考代码：

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <WinSock2.h>
4. #include <assert.h>
5. ///
6. typedef unsigned int  bpf_u_int32;
7. typedef unsigned char u_char;
8. typedef unsigned short  u_short;
9. typedef unsigned int u_int;
10. typedef int bpf_int32;
11. /*
12. Pcap文件分析如下：
13. +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
14. |Pcap Header    |Packet Header  |Packet Body    |Packet Header  |Packet Body    |
15. +-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
16. */
17. /*
18. Pcap文件头
19. +-------+-------+-------+-------+
20. |       Magic 4B                |
21. +-------+-------+-------+-------+
22. |   Major 2B    |  Minor 2B     |
23. +-------+-------+-------+-------+
24. |       ThisZone 4B             |
25. +-------+-------+-------+-------+
26. |       SigFigs 4B              |
27. +-------+-------+-------+-------+
28. |       SnapLen 4B              |
29. +-------+-------+-------+-------+
30. |       LinkType 4B             |
31. +-------+-------+-------+-------+
32. Pcap文件头24B各字段说明：
33. Magic：4B：0x1A 2B 3C 4D:用来标示文件的开始
34. Major：2B，0x02 00:当前文件主要的版本号
35. Minor：2B，0x04 00当前文件次要的版本号
36. ThisZone：4B当地的标准时间；全零
37. SigFigs：4B时间戳的精度；全零
38. SnapLen：4B最大的存储长度
39. LinkType：4B链路类型
40. 常用类型：
41. 0            BSD loopback devices, except for later OpenBSD
42. 1            Ethernet, and Linux loopback devices
43. 6            802.5 Token Ring
44. 7            ARCnet
45. 8            SLIP
46. 9            PPP
47. */
48. typedef struct pcap_file_header {
49. bpf_u_int32 magic;
50. u_short version_major;
51. u_short version_minor;
52. bpf_int32 thiszone;
53. bpf_u_int32 sigfigs;
54. bpf_u_int32 snaplen;
55. bpf_u_int32 linktype;
56. }pcap_file_header;
57. /*
58. Packet 包头和Packet数据组成
59. +-------+-------+
60. |Packet Header  |
61. +-------+-------+
62. |Packet Body    |
63. +-------+-------+
64. Paket 包头
65. +-------+-------+-------+-------+
66. |       Timestamp 4B            |
67. +-------+-------+-------+-------+
68. |       Timestamp 4B            |
69. +-------+-------+-------+-------+
70. |       Caplen 4B               |
71. +-------+-------+-------+-------+
72. |       Len 4B                  |
73. +-------+-------+-------+-------+
74. 字段说明：
75. Timestamp：时间戳高位，精确到seconds
76. Timestamp：时间戳低位，精确到microseconds
77. Caplen：当前数据区的长度，即抓取到的数据帧长度，由此可以得到下一个数据帧的位置。
78. Len：离线数据长度：网络中实际数据帧的长度，一般不大于caplen，多数情况下和Caplen数值相等。
79. Packet 数据：即 Packet（通常就是链路层的数据帧）具体内容，长度就是Caplen，这个长度的后面，就是当前PCAP文件中存放的下一个Packet数据包，也就 是说：PCAP文件里面并没有规定捕获的Packet数据包之间有什么间隔字符串，下一组数据在文件中的起始位置。我们需要靠第一个Packet包确定。
80. */
81. typedef struct  timestamp{
82. bpf_u_int32 timestamp_s;
83. bpf_u_int32 timestamp_ms;
84. }timestamp;
85. typedef struct pcap_header{
86. timestamp ts;
87. bpf_u_int32 capture_len;
88. bpf_u_int32 len;
89. }pcap_header;
90. //help funtion
91. void  printPcapHeader(pcap_file_header * ph)
92. {
93. printf("=====================\n"
94. "magic:0x%0x\n"
95. "version_major:%u\n"
96. "version_minor:%u\n"
97. "thiszone:%d\n"
98. "sigfigs:%u\n"
99. "snaplen:%u\n"
100. "linktype:%u\n"
101. "=====================\n",
102. ph->magic,
103. ph->version_major,
104. ph->version_minor,
105. ph->thiszone,
106. ph->sigfigs,
107. ph->snaplen,
108. ph->linktype);
109. }
110. void printPacketHeader(pcap_header * ph)
111. {
112. printf("=====================\n"
113. "ts.timestamp_s:%u\n"
114. "ts.timestamp_ms:%u\n"
115. "capture_len:%u\n"
116. "len:%d\n"
117. "=====================\n",
118. ph->ts.timestamp_s,
119. ph->ts.timestamp_ms,
120. ph->capture_len,
121. ph->len);
122. }
123. //////////////////////////////////////////////////////////////////////////
124. /*
125. UDP包分析
126. */
127. /* 4字节的IP地址 */
128. typedef struct ip_address{
129. u_char byte1;
130. u_char byte2;
131. u_char byte3;
132. u_char byte4;
133. }ip_address;
134. /* IPv4头 */
135. typedef struct ip_header{
136. u_char  ver_ihl;        // 版本 (4 bits) + 首部长度 (4 bits)  /// 首部长度
137. u_char  tos;            // 服务类型(Type of service)
138. u_short tlen;           // 总长(Total length)
139. u_short identification; // 标识(Identification)
140. u_short flags_fo;       // 标志位(Flags) (3 bits) + 段偏移量(Fragment offset) (13 bits)
141. u_char  ttl;            // 存活时间(Time to live)
142. u_char  proto;          // 协议(Protocol)
143. u_short crc;            // 首部校验和(Header checksum)
144. ip_address  saddr;      // 源地址(Source address)
145. ip_address  daddr;      // 目的地址(Destination address)
146. u_int   op_pad;         // 选项与填充(Option + Padding)
147. }ip_header;
148. /* UDP头 */
149. typedef struct udp_header{
150. u_short sport;          // 源端口(Source port)
151. u_short dport;          // 目的端口(Destination port)
152. u_short len;            // UDP数据包长度(Datagram length)   /// UDP总长度
153. u_short crc;            // 校验和(Checksum)
154. }udp_header;
155. u_char pkt_data[65536];
156. int main()
157. {
158. FILE * fp = fopen("yy.p2p.packet_long.pcap", "rb");
159. if (!fp)
160. {
161. fprintf(stderr, "open file error\n");
162. return -1;
163. }
164. FILE * aacfp = fopen("yy.p2p.packet_long.pcap.aac", "wb");
165. if (!fp)
166. {
167. fprintf(stderr, "open file error\n");
168. return -1;
169. }
170. //1. Read pcap file header
171. pcap_file_header pfh;
172. fread(&pfh, 1, sizeof(pfh), fp);
173. printPcapHeader(&pfh);
174. //2. Read pcap packet
175. while (!feof(fp))
176. {
177. pcap_header ph;
178. if (fread(&ph, 1, sizeof(ph), fp) != sizeof(ph))
179. break;
180. printPacketHeader(&ph);
181. if (fread(pkt_data, 1, ph.capture_len, fp) != ph.capture_len)
182. break;
183. //3. 分析消息包内容
184. //fseek(fp, ph.capture_len, 1);
185. // 获取IP数据包头的位置
186. ip_header *ih = (ip_header *)(pkt_data + 14); // 14以太网头部长度
187. // 只处理UDP包
188. if (ih->proto != 0x11)
189. continue;
190. // 获取UDP首部的位置
191. u_int ip_len = (ih->ver_ihl & 0x0f) * 4;
192. udp_header * uh = (udp_header *)((u_char *)ih + ip_len);
193. //
194. u_short sport = ntohs(uh->sport);
195. u_short dport = ntohs(uh->dport);
196. u_short udplen = ntohs(uh->len);
197. if(sport != 8455) // yy源端口为8455
198. continue;
199. /* 打印IP地址和UDP端口 */
200. printf("%d.%d.%d.%d.%d -> %d.%d.%d.%d.%d\n",
201. ih->saddr.byte1,
202. ih->saddr.byte2,
203. ih->saddr.byte3,
204. ih->saddr.byte4,
205. sport,
206. ih->daddr.byte1,
207. ih->daddr.byte2,
208. ih->daddr.byte3,
209. ih->daddr.byte4,
210. dport);
211. //
212. u_char * udp_data = (u_char *)uh + 8;
213. //u_char * aac_data = udp_data + 34;
214. //u_short  aac_len = udplen - 8 - 34;
215. u_char * aac_data = pkt_data + 14 + ip_len + 8 + 34;
216. int  aac_len = ph.capture_len - (14 + ip_len + 8 + 34);
217. //assert(aac_len > 0);
218. if (aac_len <= 0) continue;   /// 只有 yy头，没有aac数据
219. assert(aac_len < ph.capture_len);
220. printf("aac len = %d pkt_len = %d\n", aac_len, ph.capture_len);
221. assert(aac_data[0] == 0xff && aac_data[1] == 0xf1);
222. fwrite(aac_data, 1, aac_len, aacfp);
223. }
224. fclose(fp);
225. fclose(aacfp);
226. return 0;
227. }