/**
* 以太网
*/
class Ethernet {
static readonly size = 14;
get Destination(): string {
return [
this.view.getUint8(0),
this.view.getUint8(1),
this.view.getUint8(2),
this.view.getUint8(3),
this.view.getUint8(4),
this.view.getUint8(5),
]
.map((it) => it.toString(16))
.join(":");
}
get Source(): string {
return [
this.view.getUint8(6),
this.view.getUint8(7),
this.view.getUint8(8),
this.view.getUint8(9),
this.view.getUint8(10),
this.view.getUint8(11),
]
.map((it) => it.toString(16))
.join(":");
}
get Type(): number {
return this.view.getUint16(12);
}
view: DataView;
constructor(ethernetBytes: number[]) {
this.view = new DataView(Uint8Array.from(ethernetBytes).buffer);
}
}
/**
* 解析IP头
*/
class IP {
//See also: http://mars.netanya.ac.il/~unesco/cdrom/booklet/HTML/NETWORKING/node020.html
static readonly size = 20;
/**
* ## 版本号
* - 数据报属于哪个协议版本。
*/
get Version(): number {
return this.view.getUint8(0) >> 4;
}
set Version(value: number) {
if (value > 0xf) throw new Error("value 不能超过4-bit(15).");
this.view.setUint8(0, (value << 4) | this.HeaderLength);
}
/**
* - 标头中32位字的数量(DWORD)
* - 因为这是4位，所以最大报头长度为15个字（即60个字节）
* - 标头至少为20个字节，但Option(0 or more words)可能会使它更大
*/
get HeaderLength(): number {
return this.view.getUint8(0) & 0xf;
}
set HeaderLength(value: number) {
if (value > 0xf) throw new Error("value 不能超过4-bits.");
this.view.setUint8(0, value | (this.Version << 4));
}
/**
* ## 服务种类
* - 包含一个3位优先级字段（今天将被忽略），4个服务位和1个未使用位。
* - 四个服务位可以是：
- 1000-最小化延迟
- 0100-最大化吞吐量
- 0010-最大化可靠性
- 0001-最小化金钱成本
*/
get TypeOfService(): number {
return this.view.getUint8(1);
}
set TypeOfService(value: number) {
if (value > 0xff) throw new Error("value 不能超过8-bits.");
this.view.setUint8(1, value);
}
/**
* ## 总长度
* - 数据报的总长度（以字节为单位）。
* - 我们知道数据从头开始的位置
* - 我们通过计算“Total Length-Header Length”知道DATA的大小
* - Total Length使用(WORD)储存,最多存0xFFFF(65535)字节
* - 但是物理层可能不允许这么多字节的数据包大小
* - 因此，IP有时必须对数据包进行分段。
* - 当IP数据报被分段时，每个分段都被视为一个单独的数据报。
* - 它在最终目的地而不是在路由器处重新组装！
* - 每个片段都有自己的header
* - 标识号被复制到每个片段中。See also: MF/DF/FragmentOffset
*/
get TotalLength(): number {
return this.view.getUint16(2);
}
set TotalLength(value: number) {
if (value > 0xffff) throw new Error("value 不能超过16-bits.");
this.view.setUint16(2, value);
}
/**
* ## 身份证明
* - 唯一标识数据报
* - 通常每次发送数据报时加1。
* - 数据报的所有片段都包含相同的标识值。
* - 这使目标主机可以确定哪个片段属于哪个数据报。
*/
get Identification(): number {
return this.view.getUint16(4);
}
set Identification(value: number) {
if (value > 0xffff) throw new Error("value 不能超过16-bits.");
this.view.setUint16(4, value);
}
/**
* ## Don't fragment 不要碎片
* - 如果为1，则表示“请勿分段”。
* - 如果IP必须分片数据包并且该位置1，则IP丢弃数据报。
*/
get DF(): number {
return (this.view.getUint8(6) >> 6 & 1;
}
set DF(value: number) {
if (value !== 0 && value !== 1) throw new Error("value 只能为1或者0.");
if (value === this.DF) return;
this.view.setUint8(6, this.view.getUint8(6) ^ (1 << 6));
}
/**
* ## More Fragment 片段标志
* - 如果该位为0，则表示这是最后一个片段
* - IP标头的所有其他字段与第一个数据包相同（校验和除外）
* - 路由器看到3个单独的数据包。在最终目的地上将数据包传递到上层之前重新组装数据包
* - 片段标志(MF)0和偏移量(FragmentOffset)0表示数据报未分片
*/
get MF(): number {
return (this.view.getUint8(6) >> 5 & 1;
}
set MF(value: number) {
if (value !== 0 && value !== 1) throw new Error("value 只能为1或者0.");
if (value === this.MF) return;
this.view.setUint8(6, this.view.getUint8(6) ^ (1 << 5));
}
/**
* ## 碎片偏移
* - 片段标志(MF)0和偏移量(FragmentOffset)0表示数据报未分片
* - 片段偏移量以8字节（QWORD）为单位进行测量。这是因为片段偏移字段比总长度字段短3位（并且2^3为8）。
*/
get FragmentOffset(): number {
return this.view.getUint16(6) & 0x1fff;
}
set FragmentOffset(value: number) {
if (value > 0x1fff) throw new Error("value 不能超过13-bits.");
// 删除旧址在设置新值
this.view.setUint16(6, value | (this.DF << 14) | (this.MF << 13));
}
/**
* ## 生存时间
* - 路由器上限
* - 通常设置为32或64。
* - 每个处理数据报的路由器都会递减，
* - 当TTL达到0时，路由器将丢弃该数据报。
*/
get TimeToLive(): number {
return this.view.getUint8(8);
}
set TimeToLive(value: number) {
if (value > 0xff) throw new Error("value 不能超过8-bits.");
this.view.setUint8(8, value);
}
/**
* ## 协议
* - 告诉IP将数据报发送到哪里。
* - 6表示TCP
* - 17表示UDP
*/
get Protocol(): number {
return this.view.getUint8(9);
}
setProtocol(value: number) {
if (value > 0xff) throw new Error("value 不能超过8-bits.");
this.view.setUint8(9, value);
}
/**
* ## 标头校验和
* - 仅覆盖标题，不覆盖数据。
*/
get HeaderChecksum(): number {
return this.view.getUint16(10);
}
set HeaderChecksum(value: number) {
if (value > 0xffff) throw new Error("value 不能超过16-bits.");
this.view.setUint16(10, value);
}
updateHeaderChecksum() {
this.HeaderChecksum = 0;
let offset = 0;
const a = [];
while (offset < this.view.byteLength) {
a.push(this.view.getUint16(offset));
offset += 2;
}
const v = a.reduce<number>((acc, it) => {
acc += it;
if (acc > 0xffff) {
// 进位
const leftmost = acc >> 16;
acc = (acc ^ (leftmost << 16)) + leftmost;
}
return acc;
}, 0);
this.HeaderChecksum = ~v;
}
checkHeaderChecksum(): boolean {
let offset = 0;
const a = [];
while (offset < this.view.byteLength) {
a.push(this.view.getUint16(offset));
offset += 2;
}
const v = a.reduce<number>((acc, it) => {
acc += it;
if (acc > 0xffff) {
// 进位
const leftmost = acc >> 16;
acc = (acc ^ (leftmost << 16)) + leftmost;
}
return acc;
}, 0);
return 0 === ~v;
}
/**
* 源IP地址
*/
get Source(): number {
return this.view.getUint32(12);
}
set Source(value: number) {
if (value > 0xffffffff) throw new Error("value 不能超过32-bits.");
this.view.setUint32(12, value);
}
/**
* 这只是[Source]的字符串形式
*/
get SourceString(): string {
return [
this.view.getUint8(12),
this.view.getUint8(13),
this.view.getUint8(14),
this.view.getUint8(15),
].join(".");
}
/**
* 以字符串的形式设置[Source]
* @param value 如: "192.168.1.6"
*/
set SourceString(value: string) {
const a: string[] = value.split(".");
if (a.length !== 4)
throw new Error(`setSourceString value Error: (${value})`);
const inta: number[] = a.map((it) => {
const r = parseInt(it, 10);
if (r > 0xff) throw new Error(`码点(${it})不能超过8-bits.`);
return r;
});
this.view.setUint8(12, inta[0]);
this.view.setUint8(13, inta[1]);
this.view.setUint8(14, inta[2]);
this.view.setUint8(15, inta[3]);
}
/**
* 目的IP地址
*/
get Destination(): number {
return this.view.getUint32(16);
}
set Destination(value: number) {
if (value > 0xffffffff) throw new Error("value 不能超过32-bits.");
this.view.setUint32(16, value);
}
/**
* 这只是[Destination]的字符串形式
*/
get DestinationString(): string {
return [
this.view.getUint8(16),
this.view.getUint8(17),
this.view.getUint8(18),
this.view.getUint8(19),
].join(".");
}
/**
* 以字符串的形式设置
* @param value 如: "192.168.1.6"
*/
setDestinationString(value: string) {
const a: string[] = value.split(".");
if (a.length !== 4)
throw new Error(`setDestinationString value Error: (${value})`);
const inta: number[] = a.map((it) => {
const r = parseInt(it, 10);
if (r > 0xff) throw new Error(`码点(${it})不能超过8-bits.`);
return r;
});
this.view.setUint8(16, inta[0]);
this.view.setUint8(17, inta[1]);
this.view.setUint8(18, inta[2]);
this.view.setUint8(19, inta[3]);
}
view: DataView;
constructor(ipBytes: number[]) {
this.view = new DataView(Uint8Array.from(ipBytes).buffer);
}
toString(): string {
return `
0100 .... = Version: ${this.Version}
.... 0101 = Header Length: ${this.HeaderLength * 4} bytes (${this.HeaderLength})
Type Of Service: 0x0${this.TypeOfService.toString(16)}
Total Length: ${this.TotalLength}
Identification: 0x${this.Identification.toString(16)} (${this.Identification})
Df: ${this.DF}
MF: ${this.MF}
Fragment offset: ${this.FragmentOffset}
Time to live: ${this.TimeToLive}
Protocol: ${
this.Protocol == 6 ? "TCP" : this.Protocol == 17 ? "UDP" : "Other"
} (${this.Protocol})
Header checksum: 0x${this.HeaderChecksum.toString(16)}
Source: ${this.SourceString}
Destination: ${this.DestinationString}
`.trim();
}
}
/**
* ## User Datagram Protocol 用户数据报协议
* - UDP是一种简单的无连接协议。它不提供可靠性；它只是将数据发送到IP层
*/
class UDP {
static readonly size = 8;
get SourcePort(): number {
return this.view.getUint16(0);
}
set SourcePort(value: number) {
if (value > 0xffff) throw new Error("value 不能超过16-bits.");
this.view.setUint16(0, value);
}
get DestinationPort(): number {
return this.view.getUint16(2);
}
set DestinationPort(value: number) {
if (value > 0xffff) throw new Error("value 不能超过16-bits.");
this.view.setUint16(2, value);
}
/**
* - 长度是报头和数据的字节数
* - header是8个字节
* - IP数据报的最大大小为65535字节，IP报头减去20字节===>剩余65515字节用于数据。但是，UDP标头为8个字节，剩下65507个字节用于最大数量的用户数据。(不确定)
*/
get Length(): number {
return this.view.getUint16(4);
}
set Length(value: number) {
if (value > 0xffff) throw new Error("value 不能超过16-bits.");
this.view.setUint16(4, value);
}
get Checksum(): number {
return this.view.getUint16(6);
}
set Checksum(value: number) {
if (value > 0xffff) throw new Error("value 不能超过16-bits.");
this.view.setUint16(5, value);
}
/**
* 计算校验和
*/
updateChecksum() {
this.Checksum = 0;
const dataSize = this.view.byteLength - UDP.size;
const byteLength = 20 + (dataSize % 2 !== 0 ? 0 : dataSize);
const pseudoHeader = new DataView(new ArrayBuffer(byteLength));
pseudoHeader.setUint32(0, this.ip.Source);
pseudoHeader.setUint32(4, this.ip.Destination);
pseudoHeader.setUint16(8, this.ip.Protocol);
pseudoHeader.setUint16(10, this.Length);
pseudoHeader.setUint16(12, this.SourcePort);
pseudoHeader.setUint16(14, this.DestinationPort);
pseudoHeader.setUint16(16, this.Length);
pseudoHeader.setUint16(18, this.Checksum);
if (dataSize % 2 === 0) {
for (let i = 0; i < dataSize - 1; i++) {
pseudoHeader.setUint8(20 + i, this.view.getUint8(UDP.size + i));
}
}
let offset = 0;
const a = [];
while (offset < pseudoHeader.byteLength) {
a.push(pseudoHeader.getUint16(offset));
offset += 2;
}
const v = a.reduce<number>((acc, it) => {
acc += it;
if (acc > 0xffff) {
// 进位
const leftmost = acc >> 16;
acc = (acc ^ (leftmost << 16)) + leftmost;
}
return acc;
}, 0);
this.Checksum = ~v;
}
view: DataView;
constructor(public readonly ip: IP, udpBytes: number[]) {
this.view = new DataView(Uint8Array.from(udpBytes).buffer);
}
}
/**
* ## Transmission Control Protocol 传输控制协议
* - 不可靠的网络上可靠的端到端字节流。
*/
class TCP {
/**
* TCP标头必须至少包含20字节（5个字）的固定格式信息以及一个可选部分（该部分始终为4字节的整数倍）
*/
static readonly size = 20;
/**
*
* - 端口是用于进程间通信的逻辑地址。端口在一台主机内（甚至在一台进程内）提供多个目的地。
* - 低于256的端口号是“知名”端口，例如：FTP 21，TELNET 23，SMTP 25，HTTP 80，POP3 110。
* - 低于1024的端口号保留用于系统服务。只允许管理员（例如Unix中的root）分配他们
* - 用户进程可以使用1024到65535（2 ^ 16-1）之间的端口号，而无需任何特殊许可。
* - 可以通过组合[SourceIPAddress.PortNumber，DestinationIPAddress.PortNumber]来标识定义通信通道端点的套接字对。
* - IP号码加端口号构成一个TSAP-传输服务访问点（有时也称为套接字）。
*/
get SourcePort(): number {
return this.view.getUint16(0);
}
set SourcePort(value: number) {
if (value > 0xffff) throw new Error("value 不能超过16-bits.");
this.view.setUint16(0, value);
}
get DestinationPort(): number {
return this.view.getUint16(2);
}
set DestinationPort(value: number) {
if (value > 0xffff) throw new Error("value 不能超过16-bits.");
this.view.setUint16(2, value);
}
/**
* ## 序列号
* - 一个32位数字(DWORD)
* - 数据的每个字节都有编号。
* - TCP段的序列号是该段中第一个数据字节的ID号
* - 它不需要从1开始！
* - 有效序列号的范围是0到4,294,967,295(0x0000,0000-0xFFFF,FFFF)
*/
get SequenceNumber(): number {
return this.view.getUint32(4);
}
set SequenceNumber(value: number) {
if (value > 0xffffffff) throw new Error("value 不能超过32-bits.");
this.view.setUint32(4, value);
}
/**
* ## 确认号
* - 一个32位数字(DWORD)
* - 指定发送者期望的下一个字节的编号(而不是正确接收的最后一个字节!)
* - 通常将数据从接收方发送到发送方
* - 如果此确认段在特定时间内未到达，则发送方重新传输前一个段（计时器）
*/
get AcknowledgmentNumber(): number {
return this.view.getUint32(8);
}
set AcknowledgmentNumber(value: number) {
if (value > 0xffffffff) throw new Error("value 不能超过32-bits.");
this.view.setUint32(8, value);
}
/**
* TCP标头中的标头长度数（32位）。此信息是必需的，因为标题有时可能超过4个字。仅4位分配给TCP标头长度字段。因此，最长为15个字（60个字节）
*/
get TCPHeaderLength(): number {
return this.view.getUint8(12) >> 4;
}
set TCPHeaderLength(value: number) {
if (value > 0xf) throw new Error("value 不能超过4-bits.");
this.view.setUint8(12, value << 4);
}
/**
* ## Urgent
* - 紧急指针有效，与当前序列号的字节偏移，在当前序列号处可以找到紧急数据（中断消息）。当中止rlogin或telnet连接或ftp数据传输时，使用紧急模式。
*/
get URG(): number {
return this.view.getUint8(13) >> 5 & 1;
}
set URG(value: number) {
if (value !== 0 && value !== 1) throw new Error("value 只能为1或者0.");
if (value === this.URG) return;
this.view.setUint8(13, this.view.getUint8(13) ^ (1 << 5));
}
/**
* ## Acknowledgment 确认编号有效
* - 如果ACK = 0，则此段中没有确认
*/
get ACK(): number {
return this.view.getUint8(13) >> 4 & 1;
}
set ACK(value: number) {
if (value !== 0 && value !== 1) throw new Error("value 只能为1或者0.");
if (value === this.ACK) return;
this.view.setUint8(13, this.view.getUint8(13) ^ (1 << 4));
}
/**
* ## Push 接收方应尽快将此数据传递给应用程序
* - 接收方被请求在到达时将数据传递给应用程序，而不是缓冲它。
*/
get PSH(): number {
return this.view.getUint8(13) >> 3 & 1;
}
set PSH(value: number) {
if (value !== 0 && value !== 1) throw new Error("value 只能为1或者0.");
if (value === this.PSH) return;
this.view.setUint8(13, this.view.getUint8(13) ^ (1 << 3));
}
/**
* ## Reset 重置（关闭）连接。
*/
get RST(): number {
return this.view.getUint8(13) >> 2 & 1;
}
set RST(value: number) {
if (value !== 0 && value !== 1) throw new Error("value 只能为1或者0.");
if (value === this.RST) return;
this.view.setUint8(13, this.view.getUint8(13) ^ (1 << 2));
}
/**
* ## Syn 同步序列号以开始连接
*/
get SYN(): number {
return this.view.getUint8(13) >> 1 & 1;
}
set SYN(value: number) {
if (value !== 0 && value !== 1) throw new Error("value 只能为1或者0.");
if (value === this.RST) return;
this.view.setUint8(13, this.view.getUint8(13) ^ (1 << 1));
}
/**
* ## 发送方已完成数据发送
*/
get FIN(): number {
return this.view.getUint8(13) & 1;
}
set FIN(value: number) {
if (value !== 0 && value !== 1) throw new Error("value 只能为1或者0.");
if (value === this.RST) return;
this.view.setUint8(13, this.view.getUint8(13) ^ 1);
}
/**
* 此字节的发送者愿意接受的数据字节数，从确认字段中指示的字节数开始。窗口大小为0表示已收到直到确认编号1为止的字节，但是此刻接收器无法接受更多数据。稍后，如果接收方准备好接收更多数据，则他发送具有相同确认号和非零窗口大小的段（如果丢失该段，则发送方每隔一定的时间探测接收方）。
*/
get WindowSize(): number {
return this.view.getUint16(14);
}
set WindowSize(value: number) {
if (value > 0xffff) throw new Error("value 不能超过16-bits.");
this.view.setUint16(14, value);
}
/**
* 整个段的16位校验和（加上伪IP标头）。
*/
get Checksum(): number {
return this.view.getUint16(16);
}
set Checksum(value: number) {
if (value > 0xffff) throw new Error("value 不能超过16-bits.");
this.view.setUint16(16, value);
}
get UrgentPointer(): number {
return this.view.getUint16(18);
}
set UrgentPointer(value: number) {
if (value > 0xffff) throw new Error("value 不能超过16-bits.");
this.view.setUint16(18, value);
}
view: DataView;
constructor(public readonly ip: IP, udpBytes: number[]) {
this.view = new DataView(Uint8Array.from(udpBytes).buffer);
}
}
class Data {
get data(): Uint8Array {
return new Uint8Array(this.view.buffer);
}
set data(value: Uint8Array) {
this.view = new DataView(value.buffer);
}
view: DataView;
constructor(dataBytes: number[]) {
this.view = new DataView(Uint8Array.from(dataBytes).buffer);
}
}
class Packet {
ethernet: Ethernet;
ip: IP;
udp?: UDP;
tcp?: TCP;
data: Data;
#_view!: DataView;
get view(): DataView {
for (let i = 0; i < IP.size; i++)
this.#_view.setUint8(Ethernet.size + i, this.ip.view.getUint8(i));
if (this.udp)
for (let i = 0; i < UDP.size; i++)
this.#_view.setUint8(
Ethernet.size + IP.size + i,
this.ip.view.getUint8(i)
);
return this.#_view;
}
set view(value: DataView) {
this.#_view = value;
}
constructor(packetBytes: number[]) {
this.view = new DataView(Uint8Array.from(packetBytes).buffer);
this.ethernet = new Ethernet(packetBytes);
this.ip = new IP(packetBytes.slice(Ethernet.size));
let procSize = 0;
if (this.ip.Protocol === 6) {
this.tcp = new TCP(this.ip, packetBytes.slice(Ethernet.size + IP.size));
procSize = TCP.size;
} else if (this.ip.Protocol === 17) {
this.udp = new UDP(this.ip, packetBytes.slice(Ethernet.size + IP.size));
procSize = UDP.size;
}
this.data = new Data(packetBytes.slice(Ethernet.size + IP.size + procSize));
}
}
const udpData =
"70 89 cc ee 84 2c 3c 2c 30 a6 a2 d0 08 00 45 80 00 7b c9 5b 00 00 80 11 00 00 c0 a8 01 06 b7 e8 7f f4 0f a5 1f 40 00 67 c7 76 02 39 3d 03 e3 4c 72 61 dc 91 5f 04 00 00 00 01 01 01 00 00 69 a1 00 00 00 00 00 00 00 00 da d2 8d 74 3e 33 16 50 ea 46 c0 cf 22 9c 93 7d 7e b3 91 89 e0 c5 b9 e4 22 b6 e6 e9 78 d8 0b 28 6e 42 6d f1 d8 44 43 b1 7f 1b f0 a5 aa a7 d6 e9 4a 07 49 e8 a0 88 a0 42 15 e2 a9 da 21 ed da af 03";
const tcpData =
"70 89 cc ee 84 2c 3c 2c 30 a6 a2 d0 08 00 45 00 00 68 9b b7 40 00 80 06 00 00 c0 a8 01 06 31 eb 6b da c8 41 0e 96 48 d2 73 52 24 9a 12 8b 50 18 ff ff 5f ce 00 00 54 4c 42 42 30 31 d5 01 18 00 00 7e 0b 84 80 58 0e 03 00 00 00 61 61 61 00 ff ff ff ff 01 00 00 00 00 00 00 54 4c 42 42 30 31 73 03 10 00 00 7f 00 00 00 00 00 00 00 00 00 00 00 00 1e 03 04 00";
const p = new Packet(
tcpData
.trim()
.split(/s+/)
.map((it) => parseInt(it, 16))
);