协议解析
A. 用于解析域名的协议是什么
用于解析域名的协议是：
域名解析协议 又名：DNS
B. 『各种网络协议详解书籍』
协议分析网
http://www.cnpaf.net/
不行就自己找rfc看吧
C. 如何用wireshark lua编写的协议解析器，查看http包的uri/url的query string里的参
Wireshark解析HTTP GET方法不会解析URI里Query字符串里的参数（通常由GET方式提交form数据），本文介绍用lua编写一个简单的协议解析器，让这些参数解析出来，并显示在wireshark协议解析窗口里。
首先编写以下解析器lua脚本（用文本编辑器编辑即可），取文件名为my_http_querystring_decoder.lua：
view plain
-- Decode param=value from query string of http request uri (http.request.uri)
-- Author: Huang Qiangxiong ([email protected])
-- change log:
-- 2010-07-01
-- Just can play.
------------------------------------------------------------------------------------------------
do
local querystring_decoder_proto = Proto("my_http_querystring_decoder",
"Decoded HTTP URI Query String [HQX's plugins]")
---- url decode (from www.lua.org guide)
function unescape (s)
s = string.gsub(s, "+", " ")
s = string.gsub(s, "%%(%x%x)", function (h)
return string.char(tonumber(h, 16))
end)
return s
end
---- convert string to hex string
function string2hex (s)
local hex = "";
for i=1, #s, 1 do
hex = hex .. string.format("%x", s:byte(i))
end
return hex
end
local f_http_uri = Field.new("http.request.uri")
---- my dissector
function querystring_decoder_proto.dissector(tvb, pinfo, tree)
local http_uri = f_http_uri()
-- ignore packages without "http.request.uri"
if not http_uri then return end
-- begin build my tree
local content = http_uri.value
local idx = content:find("?")
if not idx then return end -- not include query string, so stop parsing
local tab = ByteArray.new(string2hex(content)):tvb("Decoded HTTP URI Query String")
local tab_range = tab()
-- add proto item to tree
local subtree = tree:add(querystring_decoder_proto, tab_range)
-- add raw data to tree
subtree:add(tab_range, "[HTTP Request URI] (" .. tab_range:len() .. " bytes)"):add(tab_range, content)
-- add param value pair to tree
local pairs_tree = subtree:add(tab_range, "[Decoded Query String]")
local si = 1
local ei = idx
local count = 0
while ei do
si = ei + 1
ei = string.find(content, "&", si)
local xlen = (ei and (ei - si)) or (content:len() - si + 1)
if xlen > 0 then
pairs_tree:add(tab(si-1, xlen), unescape(content:sub(si, si+xlen-1)))
count = count + 1
end
end
pairs_tree:append_text(" (" .. count .. ")")
end
-- register this dissector
register_postdissector(querystring_decoder_proto)
end
然后修改wireshark安装目录下的init.lua文件：
（1）把disable_lua = true; do return end;这行注释掉：在前面加“--”
（2）然后在init.lua文件最后面加一句：dofile("my_http_querystring_decoder.lua")
OK大功告成，打开HTTP抓包，若其请求中URI带QueryString，则界面如下：
可以看到，在协议解析树上新增了Decoded HTTP URI Query String ... 节点。看该节点下[HTTP Request URI]为原始HTTP Request URI，[Decoded Query String]下为解开后的一个个参数（经过url decode）。而且在wireshark的“Packet Bytes”窗口里新增了一个“Decoded HTTP URI Query String”的数据tab，专门显示HTTP URI内容，用于显示参数在URL里的原始形式。
另外，如果要解析HTTP Body部分的参数（用POST方法提交form数据），请参考《用Wireshark lua编写的协议解析器查看Content-Type为application/x-www-form-urlencoded的HTTP抓包》（http://blog.csdn.net/jasonhwang/archive/2010/04/25/5525700.aspx）。
D. 什么是网络协议分析工具
网络协议分析工具，也就是用于TCP/IP网络协议分析的软件工具套件。 网络协议工具可以获得局域网内各节点计算机的大量基本信息，利用WinPcap过滤、捕获流经本地的局域网帧信息，可以加以分析和显示，系统还编辑、发送各种类型的信包，同时捕获、分析对发送信包的响应信包，从而观察发送信包后对方的相应响应。该系统的设计与实现对于TCP/IP网络协议的开发、调试和测试提供了一个有力的工具套件。
随着网络技术的快速发展，计算机网络正发挥着越来越大的作用。网络环境变得越来越复杂，与此同时，网络系统的安全问题也越来越重要，对网络系统和网络安全领域的开发、调试和测试的工具提出了更高的要求。
E. 用于解析域名的协议是 ( )。
域名解析协议 ：DNS
DNS 命名用于 Internet 等 TCP/IP 网络中，通过用户友好的名称查找计算机和服务。当用户在应用程序中输入 DNS 名称时，DNS 服务可以将此名称解析为与之相关的其他信息。
F. 都有哪些网络协议解析技术
如果对你有帮助的话给个采纳，谢谢
G. 怎么解析DL645通信协议
可以使用厂家提供的软件，或者用通用协议解析软件，如格西烽火通信测试软件等，自己编写DL645协议，可以方便解析出自己需要的数据。
H. 如何实现java解析网络协议报文
普通参数：
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
文件参数：
Content-Type: application/octet-stream
Content-Transfer-Encoding: binary
参数实体的最后一行是: --加上boundary加上--，最后换行，这里的 格式即为: --OCqxMF6-JxtxoMDHmoG5W5eY9MGRsTBp--。
模拟文件上传请求
public static void uploadFile(String fileName) {
try {
// 换行符
final String newLine = "\r\n";
final String boundaryPrefix = "--";
// 定义数据分隔线
String BOUNDARY = "========7d4a6d158c9";
// 服务器的域名
URL url = new URL("www.myhost.com");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
// 设置为POST情
conn.setRequestMethod("POST");
// 发送POST请求必须设置如下两行
conn.setDoOutput(true);
conn.setDoInput(true);
conn.setUseCaches(false);
// 设置请求头参数
conn.setRequestProperty("connection", "Keep-Alive");
conn.setRequestProperty("Charsert", "UTF-8");
conn.setRequestProperty("Content-Type", "multipart/form-data; boundary=" + BOUNDARY);
OutputStream out = new DataOutputStream(conn.getOutputStream());
// 上传文件
File file = new File(fileName);
StringBuilder sb = new StringBuilder();
sb.append(boundaryPrefix);
sb.append(BOUNDARY);
sb.append(newLine);
// 文件参数,photo参数名可以随意修改
sb.append("Content-Disposition: form-data;name=\"photo\";filename=\"" + fileName
+ "\"" + newLine);
sb.append("Content-Type:application/octet-stream");
// 参数头设置完以后需要两个换行，然后才是参数内容
sb.append(newLine);
sb.append(newLine);
// 将参数头的数据写入到输出流中
out.write(sb.toString().getBytes());
// 数据输入流,用于读取文件数据
DataInputStream in = new DataInputStream(new FileInputStream(
file));
byte[] bufferOut = new byte[1024];
int bytes = 0;
// 每次读1KB数据,并且将文件数据写入到输出流中
while ((bytes = in.read(bufferOut)) != -1) {
out.write(bufferOut, 0, bytes);
}
// 最后添加换行
out.write(newLine.getBytes());
in.close();
// 定义最后数据分隔线，即--加上BOUNDARY再加上--。
byte[] end_data = (newLine + boundaryPrefix + BOUNDARY + boundaryPrefix + newLine)
.getBytes();
// 写上结尾标识
out.write(end_data);
out.flush();
out.close();
// 定义BufferedReader输入流来读取URL的响应
// BufferedReader reader = new BufferedReader(new InputStreamReader(
// conn.getInputStream()));
// String line = null;
// while ((line = reader.readLine()) != null) {
// System.out.println(line);
// }
} catch (Exception e) {
System.out.println("发送POST请求出现异常！" + e);
e.printStackTrace();
}
}
I. 简述地址解析协议的工作过程
arp协议是“address
resolution
protocol”（地址解析协议）的缩写。在局域网中，网络中实际传输的是“帧”，帧里面是有目标主机的mac地址的。在以太网中，一个主机要和另一个主机进行直接通信，必须要知道目标主机的mac地址。但这个目标mac地址是如何获得的呢？它就是通过地址解析协议获得的。所谓“地址解析”就是主机在发送帧前将目标ip地址转换成目标mac地址的过程。arp协议的基本功能就是通过目标设备的ip地址，查询目标设备的mac地址，以保证通信的顺利进行。
我们以主机a（192.168.1.5）向主机b（192.168.1.1）发送数据为例。
当发送数据时，主机a会在自己的arp缓存表中寻找是否有目标ip地址。
如果找到了，也就知道了目标mac地址，直接把目标mac地址写入帧里面发送就可以了；
如果在arp缓存表中没有找到相对应的ip地址，主机a就会在网络上发送一个广播，目标mac地址是“ff.ff.ff.ff.ff.ff”，这表示向同一网段内的所有主机发出这样的询问：“192.168.1.1的mac地址是什么？”网络上其他主机并不响应arp询问，只有主机b接收到这个帧时，才向主机a做出这样的回应：“192.168.1.1的mac地址是00-aa-00-62-c6-09”。
这样，主机a就知道了主机b的mac地址，它就可以向主机b发送信息了。同时它还更新了自己的arp缓存表，下次再向主机b发送信息时，直接从arp缓存表里查找就可以了。
arp缓存表采用了老化机制，在一段时间内如果表中的某一行没有使用，就会被删除，这样可以大大减少arp缓存表的长度，加快查询速度。
J. http协议解析 请求行的信息怎么提取 c语言源码
实现步骤：
1）用Wireshark软件抓包得到test.pcap文件
2）程序：分析pcap文件头 -> 分析pcap_pkt头 -> 分析帧头 -> 分析ip头 -> 分析tcp头 -> 分析http信息
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<netinet/in.h>
#include<time.h>
#define BUFSIZE 10240
#define STRSIZE 1024
typedef long bpf_int32;
typedef unsigned long bpf_u_int32;
typedef unsigned short u_short;
typedef unsigned long u_int32;
typedef unsigned short u_int16;
typedef unsigned char u_int8;
//pacp文件头结构体
struct pcap_file_header
{
bpf_u_int32 magic; /* 0xa1b2c3d4 */
u_short version_major; /* magjor Version 2 */
u_short version_minor; /* magjor Version 4 */
bpf_int32 thiszone; /* gmt to local correction */
bpf_u_int32 sigfigs; /* accuracy of timestamps */
bpf_u_int32 snaplen; /* max length saved portion of each pkt */
bpf_u_int32 linktype; /* data link type (LINKTYPE_*) */
};
//时间戳
struct time_val
{
long tv_sec; /* seconds 含义同 time_t 对象的值 */
long tv_usec; /* and microseconds */
};
//pcap数据包头结构体
struct pcap_pkthdr
{
struct time_val ts; /* time stamp */
bpf_u_int32 caplen; /* length of portion present */
bpf_u_int32 len; /* length this packet (off wire) */
};
//数据帧头
typedef struct FramHeader_t
{ //Pcap捕获的数据帧头
u_int8 DstMAC[6]; //目的MAC地址
u_int8 SrcMAC[6]; //源MAC地址
u_short FrameType; //帧类型
} FramHeader_t;
//IP数据报头
typedef struct IPHeader_t
{ //IP数据报头
u_int8 Ver_HLen; //版本+报头长度
u_int8 TOS; //服务类型
u_int16 TotalLen; //总长度
u_int16 ID; //标识
u_int16 Flag_Segment; //标志+片偏移
u_int8 TTL; //生存周期
u_int8 Protocol; //协议类型
u_int16 Checksum; //头部校验和
u_int32 SrcIP; //源IP地址
u_int32 DstIP; //目的IP地址
} IPHeader_t;
//TCP数据报头
typedef struct TCPHeader_t
{ //TCP数据报头
u_int16 SrcPort; //源端口
u_int16 DstPort; //目的端口
u_int32 SeqNO; //序号
u_int32 AckNO; //确认号
u_int8 HeaderLen; //数据报头的长度(4 bit) + 保留(4 bit)
u_int8 Flags; //标识TCP不同的控制消息
u_int16 Window; //窗口大小
u_int16 Checksum; //校验和
u_int16 UrgentPointer; //紧急指针
}TCPHeader_t;
//
void match_http(FILE *fp, char *head_str, char *tail_str, char *buf, int total_len); //查找 http 信息函数
//
int main()
{
struct pcap_file_header *file_header;
struct pcap_pkthdr *ptk_header;
IPHeader_t *ip_header;
TCPHeader_t *tcp_header;
FILE *fp, *output;
int pkt_offset, i=0;
int ip_len, http_len, ip_proto;
int src_port, dst_port, tcp_flags;
char buf[BUFSIZE], my_time[STRSIZE];
char src_ip[STRSIZE], dst_ip[STRSIZE];
char host[STRSIZE], uri[BUFSIZE];
//初始化
file_header = (struct pcap_file_header *)malloc(sizeof(struct pcap_file_header));
ptk_header = (struct pcap_pkthdr *)malloc(sizeof(struct pcap_pkthdr));
ip_header = (IPHeader_t *)malloc(sizeof(IPHeader_t));
tcp_header = (TCPHeader_t *)malloc(sizeof(TCPHeader_t));
memset(buf, 0, sizeof(buf));
//
if((fp = fopen(“test.pcap”,”r”)) == NULL)
{
printf(“error: can not open pcap file\n”);
exit(0);
}
if((output = fopen(“output.txt”,”w+”)) == NULL)
{
printf(“error: can not open output file\n”);
exit(0);
}
//开始读数据包
pkt_offset = 24; //pcap文件头结构 24个字节
while(fseek(fp, pkt_offset, SEEK_SET) == 0) //遍历数据包
{
i++;
//pcap_pkt_header 16 byte
if(fread(ptk_header, 16, 1, fp) != 1) //读pcap数据包头结构
{
printf(“\nread end of pcap file\n”);
break;
}
pkt_offset += 16 + ptk_header->caplen; //下一个数据包的偏移值
strftime(my_time, sizeof(my_time), “%Y-%m-%d %T”, localtime(&(ptk_header->ts.tv_sec))); //获取时间
// printf(“%d: %s\n”, i, my_time);
//数据帧头 14字节
fseek(fp, 14, SEEK_CUR); //忽略数据帧头
//IP数据报头 20字节
if(fread(ip_header, sizeof(IPHeader_t), 1, fp) != 1)
{
printf(“%d: can not read ip_header\n”, i);
break;
}
inet_ntop(AF_INET, (void *)&(ip_header->SrcIP), src_ip, 16);
inet_ntop(AF_INET, (void *)&(ip_header->DstIP), dst_ip, 16);
ip_proto = ip_header->Protocol;
ip_len = ip_header->TotalLen; //IP数据报总长度
// printf(“%d: src=%s\n”, i, src_ip);
if(ip_proto != 0×06) //判断是否是 TCP 协议
{
continue;
}
//TCP头 20字节
if(fread(tcp_header, sizeof(TCPHeader_t), 1, fp) != 1)
{
printf(“%d: can not read ip_header\n”, i);
break;
}
src_port = ntohs(tcp_header->SrcPort);
dst_port = ntohs(tcp_header->DstPort);
tcp_flags = tcp_header->Flags;
// printf(“%d: src=%x\n”, i, tcp_flags);
if(tcp_flags == 0×18) // (PSH, ACK) 3路握手成功后
{
if(dst_port == 80) // HTTP GET请求
{
http_len = ip_len – 40; //http 报文长度
match_http(fp, “Host: “, “\r\n”, host, http_len); //查找 host 值
match_http(fp, “GET “, “HTTP”, uri, http_len); //查找 uri 值
sprintf(buf, “%d: %s src=%s:%d dst=%s:%d %s%s\r\n”, i, my_time, src_ip, src_port, dst_ip, dst_port, host, uri);
//printf(“%s”, buf);
if(fwrite(buf, strlen(buf), 1, output) != 1)
{
printf(“output file can not write”);
break;
}
}
}
} // end while
fclose(fp);
fclose(output);
return 0;
}
//查找 HTTP 信息
void match_http(FILE *fp, char *head_str, char *tail_str, char *buf, int total_len)
{
int i;
int http_offset;
int head_len, tail_len, val_len;
char head_tmp[STRSIZE], tail_tmp[STRSIZE];
//初始化
memset(head_tmp, 0, sizeof(head_tmp));
memset(tail_tmp, 0, sizeof(tail_tmp));
head_len = strlen(head_str);
tail_len = strlen(tail_str);
//查找 head_str
http_offset = ftell(fp); //记录下HTTP报文初始文件偏移
while((head_tmp[0] = fgetc(fp)) != EOF) //逐个字节遍历
{
if((ftell(fp) – http_offset) > total_len) //遍历完成
{
sprintf(buf, “can not find %s \r\n”, head_str);
exit(0);
}
if(head_tmp[0] == *head_str) //匹配到第一个字符
{
for(i=1; i<head_len; i++) //匹配 head_str 的其他字符
{
head_tmp[i]=fgetc(fp);
if(head_tmp[i] != *(head_str+i))
break;
}
if(i == head_len) //匹配 head_str 成功，停止遍历
break;
}
}
// printf(“head_tmp=%s \n”, head_tmp);
//查找 tail_str
val_len = 0;
while((tail_tmp[0] = fgetc(fp)) != EOF) //遍历
{
if((ftell(fp) – http_offset) > total_len) //遍历完成
{
sprintf(buf, “can not find %s \r\n”, tail_str);
exit(0);
}
buf[val_len++] = tail_tmp[0]; //用buf 存储 value 直到查找到 tail_str
if(tail_tmp[0] == *tail_str) //匹配到第一个字符
{
for(i=1; i<tail_len; i++) //匹配 head_str 的其他字符
{
tail_tmp[i]=fgetc(fp);
if(tail_tmp[i] != *(tail_str+i))
break;
}
if(i == tail_len) //匹配 head_str 成功，停止遍历
{
buf[val_len-1] = 0; //清除多余的一个字符
break;
}
}
}
// printf(“val=%s\n”, buf);
fseek(fp, http_offset, SEEK_SET); //将文件指针 回到初始偏移
}