cross_socket/packet/
builder.rs

1use crate::datalink;
2use crate::packet;
3use crate::packet::{ethernet, ip};
4use pnet::packet::Packet;
5use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
6
7/// Packet builder for building full packet.
8#[derive(Clone, Debug)]
9pub struct PacketBuilder {
10    packet: Vec<u8>,
11}
12
13impl PacketBuilder {
14    /// Constructs a new PacketBuilder
15    pub fn new() -> Self {
16        PacketBuilder { packet: Vec::new() }
17    }
18    /// Return packet bytes
19    pub fn packet(&self) -> Vec<u8> {
20        self.packet.clone()
21    }
22    /// Retern IP packet bytes (without ethernet header)
23    pub fn ip_packet(&self) -> Vec<u8> {
24        if self.packet.len() < packet::ethernet::ETHERNET_HEADER_LEN {
25            return Vec::new();
26        }
27        self.packet[packet::ethernet::ETHERNET_HEADER_LEN..].to_vec()
28    }
29    /// Set ethernet header
30    pub fn set_ethernet(&mut self, packet_builder: packet::ethernet::EthernetPacketBuilder) {
31        if self.packet.len() < packet::ethernet::ETHERNET_HEADER_LEN {
32            self.packet.resize(packet::ethernet::ETHERNET_HEADER_LEN, 0);
33        }
34        self.packet[0..packet::ethernet::ETHERNET_HEADER_LEN]
35            .copy_from_slice(&packet_builder.build());
36    }
37    /// Set arp header
38    pub fn set_arp(&mut self, packet_builder: packet::arp::ArpPacketBuilder) {
39        let arp_packet = packet_builder.build();
40        if self.packet.len() < packet::ethernet::ETHERNET_HEADER_LEN + arp_packet.len() {
41            self.packet
42                .resize(packet::ethernet::ETHERNET_HEADER_LEN + arp_packet.len(), 0);
43        }
44        self.packet[packet::ethernet::ETHERNET_HEADER_LEN
45            ..packet::ethernet::ETHERNET_HEADER_LEN + arp_packet.len()]
46            .copy_from_slice(&arp_packet);
47    }
48    /// Set IPv4 header
49    pub fn set_ipv4(&mut self, packet_builder: packet::ipv4::Ipv4PacketBuilder) {
50        let ipv4_packet = packet_builder.build();
51        if self.packet.len() < packet::ethernet::ETHERNET_HEADER_LEN + ipv4_packet.len() {
52            self.packet
53                .resize(packet::ethernet::ETHERNET_HEADER_LEN + ipv4_packet.len(), 0);
54        }
55        self.packet[packet::ethernet::ETHERNET_HEADER_LEN
56            ..packet::ethernet::ETHERNET_HEADER_LEN + ipv4_packet.len()]
57            .copy_from_slice(&ipv4_packet);
58    }
59    /// Set IPv6 header
60    pub fn set_ipv6(&mut self, packet_builder: packet::ipv6::Ipv6PacketBuilder) {
61        let ipv6_packet = packet_builder.build();
62        if self.packet.len() < packet::ethernet::ETHERNET_HEADER_LEN + ipv6_packet.len() {
63            self.packet
64                .resize(packet::ethernet::ETHERNET_HEADER_LEN + ipv6_packet.len(), 0);
65        }
66        self.packet[packet::ethernet::ETHERNET_HEADER_LEN
67            ..packet::ethernet::ETHERNET_HEADER_LEN + ipv6_packet.len()]
68            .copy_from_slice(&ipv6_packet);
69    }
70    /// Set ICMP header
71    pub fn set_icmp(&mut self, packet_builder: packet::icmp::IcmpPacketBuilder) {
72        let icmp_packet = packet_builder.build();
73        if self.packet.len()
74            < packet::ethernet::ETHERNET_HEADER_LEN
75                + packet::ipv4::IPV4_HEADER_LEN
76                + icmp_packet.len()
77        {
78            self.packet.resize(
79                packet::ethernet::ETHERNET_HEADER_LEN
80                    + packet::ipv4::IPV4_HEADER_LEN
81                    + icmp_packet.len(),
82                0,
83            );
84        }
85        self.packet[packet::ethernet::ETHERNET_HEADER_LEN + packet::ipv4::IPV4_HEADER_LEN
86            ..packet::ethernet::ETHERNET_HEADER_LEN
87                + packet::ipv4::IPV4_HEADER_LEN
88                + icmp_packet.len()]
89            .copy_from_slice(&icmp_packet);
90    }
91    /// Set ICMPv6 header
92    pub fn set_icmpv6(&mut self, packet_builder: packet::icmpv6::Icmpv6PacketBuilder) {
93        let icmpv6_packet = packet_builder.build();
94        if self.packet.len()
95            < packet::ethernet::ETHERNET_HEADER_LEN
96                + packet::ipv6::IPV6_HEADER_LEN
97                + icmpv6_packet.len()
98        {
99            self.packet.resize(
100                packet::ethernet::ETHERNET_HEADER_LEN
101                    + packet::ipv6::IPV6_HEADER_LEN
102                    + icmpv6_packet.len(),
103                0,
104            );
105        }
106        self.packet[packet::ethernet::ETHERNET_HEADER_LEN + packet::ipv6::IPV6_HEADER_LEN
107            ..packet::ethernet::ETHERNET_HEADER_LEN
108                + packet::ipv6::IPV6_HEADER_LEN
109                + icmpv6_packet.len()]
110            .copy_from_slice(&icmpv6_packet);
111    }
112    /// Set TCP header and payload
113    pub fn set_tcp(&mut self, packet_builder: packet::tcp::TcpPacketBuilder) {
114        let tcp_packet = packet_builder.build();
115        if packet_builder.dst_ip.is_ipv4() {
116            if self.packet.len()
117                < packet::ethernet::ETHERNET_HEADER_LEN
118                    + packet::ipv4::IPV4_HEADER_LEN
119                    + tcp_packet.len()
120            {
121                self.packet.resize(
122                    packet::ethernet::ETHERNET_HEADER_LEN
123                        + packet::ipv4::IPV4_HEADER_LEN
124                        + tcp_packet.len(),
125                    0,
126                );
127            }
128            self.packet[packet::ethernet::ETHERNET_HEADER_LEN + packet::ipv4::IPV4_HEADER_LEN
129                ..packet::ethernet::ETHERNET_HEADER_LEN
130                    + packet::ipv4::IPV4_HEADER_LEN
131                    + tcp_packet.len()]
132                .copy_from_slice(&tcp_packet);
133        } else if packet_builder.dst_ip.is_ipv6() {
134            if self.packet.len()
135                < packet::ethernet::ETHERNET_HEADER_LEN
136                    + packet::ipv6::IPV6_HEADER_LEN
137                    + tcp_packet.len()
138            {
139                self.packet.resize(
140                    packet::ethernet::ETHERNET_HEADER_LEN
141                        + packet::ipv6::IPV6_HEADER_LEN
142                        + tcp_packet.len(),
143                    0,
144                );
145            }
146            self.packet[packet::ethernet::ETHERNET_HEADER_LEN + packet::ipv6::IPV6_HEADER_LEN
147                ..packet::ethernet::ETHERNET_HEADER_LEN
148                    + packet::ipv6::IPV6_HEADER_LEN
149                    + tcp_packet.len()]
150                .copy_from_slice(&tcp_packet);
151        }
152    }
153    /// Set UDP header and payload
154    pub fn set_udp(&mut self, packet_builder: packet::udp::UdpPacketBuilder) {
155        let udp_packet = packet_builder.build();
156        if packet_builder.dst_ip.is_ipv4() {
157            if self.packet.len()
158                < packet::ethernet::ETHERNET_HEADER_LEN
159                    + packet::ipv4::IPV4_HEADER_LEN
160                    + udp_packet.len()
161            {
162                self.packet.resize(
163                    packet::ethernet::ETHERNET_HEADER_LEN
164                        + packet::ipv4::IPV4_HEADER_LEN
165                        + udp_packet.len(),
166                    0,
167                );
168            }
169            self.packet[packet::ethernet::ETHERNET_HEADER_LEN + packet::ipv4::IPV4_HEADER_LEN
170                ..packet::ethernet::ETHERNET_HEADER_LEN
171                    + packet::ipv4::IPV4_HEADER_LEN
172                    + udp_packet.len()]
173                .copy_from_slice(&udp_packet);
174        } else if packet_builder.dst_ip.is_ipv6() {
175            if self.packet.len()
176                < packet::ethernet::ETHERNET_HEADER_LEN
177                    + packet::ipv6::IPV6_HEADER_LEN
178                    + udp_packet.len()
179            {
180                self.packet.resize(
181                    packet::ethernet::ETHERNET_HEADER_LEN
182                        + packet::ipv6::IPV6_HEADER_LEN
183                        + udp_packet.len(),
184                    0,
185                );
186            }
187            self.packet[packet::ethernet::ETHERNET_HEADER_LEN + packet::ipv6::IPV6_HEADER_LEN
188                ..packet::ethernet::ETHERNET_HEADER_LEN
189                    + packet::ipv6::IPV6_HEADER_LEN
190                    + udp_packet.len()]
191                .copy_from_slice(&udp_packet);
192        }
193    }
194}
195
196/// Higher level packet build option.
197/// For building packet, use PacketBuilder or protocol specific packet builder.
198#[derive(Clone, Debug)]
199pub struct PacketBuildOption {
200    pub src_mac: datalink::MacAddr,
201    pub dst_mac: datalink::MacAddr,
202    pub ether_type: ethernet::EtherType,
203    pub src_ip: IpAddr,
204    pub dst_ip: IpAddr,
205    pub src_port: Option<u16>,
206    pub dst_port: Option<u16>,
207    pub ip_protocol: Option<ip::IpNextLevelProtocol>,
208    pub payload: Vec<u8>,
209    pub use_tun: bool,
210}
211
212impl PacketBuildOption {
213    /// Constructs a new PacketBuildOption
214    pub fn new() -> Self {
215        PacketBuildOption {
216            src_mac: datalink::MacAddr::zero(),
217            dst_mac: datalink::MacAddr::zero(),
218            ether_type: ethernet::EtherType::Ipv4,
219            src_ip: IpAddr::V4(std::net::Ipv4Addr::new(0, 0, 0, 0)),
220            dst_ip: IpAddr::V4(std::net::Ipv4Addr::new(0, 0, 0, 0)),
221            src_port: None,
222            dst_port: None,
223            ip_protocol: None,
224            payload: Vec::new(),
225            use_tun: false,
226        }
227    }
228}
229
230/// Build ARP Packet from PacketBuildOption
231pub fn build_full_arp_packet(packet_builder: PacketBuildOption) -> Vec<u8> {
232    let src_ip: Ipv4Addr = match packet_builder.src_ip {
233        IpAddr::V4(ipv4_addr) => ipv4_addr,
234        _ => return Vec::new(),
235    };
236    let dst_ip: Ipv4Addr = match packet_builder.dst_ip {
237        IpAddr::V4(ipv4_addr) => ipv4_addr,
238        _ => return Vec::new(),
239    };
240    let mut ethernet_buffer =
241        [0u8; packet::ethernet::ETHERNET_HEADER_LEN + packet::arp::ARP_HEADER_LEN];
242    let mut ethernet_packet: pnet::packet::ethernet::MutableEthernetPacket =
243        pnet::packet::ethernet::MutableEthernetPacket::new(&mut ethernet_buffer).unwrap();
244    packet::ethernet::build_ethernet_arp_packet(
245        &mut ethernet_packet,
246        packet_builder.src_mac.clone(),
247    );
248    let mut arp_buffer = [0u8; packet::arp::ARP_HEADER_LEN];
249    let mut arp_packet = pnet::packet::arp::MutableArpPacket::new(&mut arp_buffer).unwrap();
250    packet::arp::build_arp_packet(
251        &mut arp_packet,
252        packet_builder.src_mac,
253        packet_builder.dst_mac,
254        src_ip,
255        dst_ip,
256    );
257    ethernet_packet.set_payload(arp_packet.packet());
258    ethernet_packet.packet().to_vec()
259}
260
261/// Build ICMP Packet from PacketBuildOption. Build full packet with ethernet and ipv4 header.
262pub fn build_full_icmp_packet(packet_builder: PacketBuildOption) -> Vec<u8> {
263    let src_ip: Ipv4Addr = match packet_builder.src_ip {
264        IpAddr::V4(ipv4_addr) => ipv4_addr,
265        _ => return Vec::new(),
266    };
267    let dst_ip: Ipv4Addr = match packet_builder.dst_ip {
268        IpAddr::V4(ipv4_addr) => ipv4_addr,
269        _ => return Vec::new(),
270    };
271    let mut ethernet_buffer = [0u8; packet::ethernet::ETHERNET_HEADER_LEN
272        + packet::ipv4::IPV4_HEADER_LEN
273        + packet::icmp::ICMPV4_HEADER_LEN];
274    let mut ethernet_packet: pnet::packet::ethernet::MutableEthernetPacket =
275        pnet::packet::ethernet::MutableEthernetPacket::new(&mut ethernet_buffer).unwrap();
276    packet::ethernet::build_ethernet_packet(
277        &mut ethernet_packet,
278        packet_builder.src_mac.clone(),
279        packet_builder.dst_mac.clone(),
280        packet_builder.ether_type,
281    );
282    let mut ipv4_buffer = [0u8; packet::ipv4::IPV4_HEADER_LEN + packet::icmp::ICMPV4_HEADER_LEN];
283    let mut ipv4_packet = pnet::packet::ipv4::MutableIpv4Packet::new(&mut ipv4_buffer).unwrap();
284    packet::ipv4::build_ipv4_packet(
285        &mut ipv4_packet,
286        src_ip,
287        dst_ip,
288        packet_builder.ip_protocol.unwrap(),
289    );
290    let mut icmp_buffer = [0u8; packet::icmp::ICMPV4_HEADER_LEN];
291    let mut icmp_packet =
292        pnet::packet::icmp::echo_request::MutableEchoRequestPacket::new(&mut icmp_buffer).unwrap();
293    packet::icmp::build_icmp_echo_packet(&mut icmp_packet);
294    ipv4_packet.set_payload(icmp_packet.packet());
295    ethernet_packet.set_payload(ipv4_packet.packet());
296    if packet_builder.use_tun {
297        ethernet_packet.packet()[packet::ethernet::ETHERNET_HEADER_LEN..].to_vec()
298    }else {
299        ethernet_packet.packet().to_vec()
300    }
301}
302
303/// Build ICMP Packet
304pub fn build_icmp_packet() -> Vec<u8> {
305    let mut icmp_buffer = [0u8; packet::icmp::ICMPV4_HEADER_LEN];
306    let mut icmp_packet =
307        pnet::packet::icmp::echo_request::MutableEchoRequestPacket::new(&mut icmp_buffer).unwrap();
308    packet::icmp::build_icmp_echo_packet(&mut icmp_packet);
309    icmp_packet.packet().to_vec()
310}
311
312/// Build ICMPv6 Packet from PacketBuildOption. Build full packet with ethernet and ipv6 header.
313pub fn build_full_icmpv6_packet(packet_builder: PacketBuildOption) -> Vec<u8> {
314    let src_ip: Ipv6Addr = match packet_builder.src_ip {
315        IpAddr::V6(ipv6_addr) => ipv6_addr,
316        _ => return Vec::new(),
317    };
318    let dst_ip: Ipv6Addr = match packet_builder.dst_ip {
319        IpAddr::V6(ipv6_addr) => ipv6_addr,
320        _ => return Vec::new(),
321    };
322    let mut ethernet_buffer = [0u8; packet::ethernet::ETHERNET_HEADER_LEN
323        + packet::ipv6::IPV6_HEADER_LEN
324        + packet::icmpv6::ICMPV6_HEADER_LEN];
325    let mut ethernet_packet: pnet::packet::ethernet::MutableEthernetPacket =
326        pnet::packet::ethernet::MutableEthernetPacket::new(&mut ethernet_buffer).unwrap();
327    packet::ethernet::build_ethernet_packet(
328        &mut ethernet_packet,
329        packet_builder.src_mac.clone(),
330        packet_builder.dst_mac.clone(),
331        packet_builder.ether_type,
332    );
333    let mut ipv6_buffer = [0u8; packet::ipv6::IPV6_HEADER_LEN + packet::icmpv6::ICMPV6_HEADER_LEN];
334    let mut ipv6_packet = pnet::packet::ipv6::MutableIpv6Packet::new(&mut ipv6_buffer).unwrap();
335    packet::ipv6::build_ipv6_packet(
336        &mut ipv6_packet,
337        src_ip,
338        dst_ip,
339        packet_builder.ip_protocol.unwrap(),
340    );
341    let mut icmpv6_buffer = [0u8; packet::icmpv6::ICMPV6_HEADER_LEN];
342    let mut icmpv6_packet =
343        pnet::packet::icmpv6::echo_request::MutableEchoRequestPacket::new(&mut icmpv6_buffer)
344            .unwrap();
345    packet::icmpv6::build_icmpv6_echo_packet(&mut icmpv6_packet, src_ip, dst_ip);
346    ipv6_packet.set_payload(icmpv6_packet.packet());
347    ethernet_packet.set_payload(ipv6_packet.packet());
348    if packet_builder.use_tun {
349        ethernet_packet.packet()[packet::ethernet::ETHERNET_HEADER_LEN..].to_vec()
350    }else {
351        ethernet_packet.packet().to_vec()
352    }
353}
354
355/// Build ICMPv6 Packet from PacketBuildOption
356pub fn build_icmpv6_packet(packet_builder: PacketBuildOption) -> Vec<u8> {
357    let src_ip: Ipv6Addr = match packet_builder.src_ip {
358        IpAddr::V6(ipv6_addr) => ipv6_addr,
359        _ => return Vec::new(),
360    };
361    let dst_ip: Ipv6Addr = match packet_builder.dst_ip {
362        IpAddr::V6(ipv6_addr) => ipv6_addr,
363        _ => return Vec::new(),
364    };
365    let mut icmpv6_buffer = [0u8; packet::icmpv6::ICMPV6_HEADER_LEN];
366    let mut icmpv6_packet =
367        pnet::packet::icmpv6::echo_request::MutableEchoRequestPacket::new(&mut icmpv6_buffer)
368            .unwrap();
369    packet::icmpv6::build_icmpv6_echo_packet(&mut icmpv6_packet, src_ip, dst_ip);
370    icmpv6_packet.packet().to_vec()
371}
372
373/// Build TCP Packet from PacketBuildOption. Build full packet with Ethernet and IP header.
374pub fn build_full_tcp_syn_packet(packet_builder: PacketBuildOption) -> Vec<u8> {
375    match packet_builder.src_ip {
376        IpAddr::V4(src_ip) => match packet_builder.dst_ip {
377            IpAddr::V4(dst_ip) => {
378                let mut ethernet_buffer = [0u8; packet::ethernet::ETHERNET_HEADER_LEN
379                    + packet::ipv4::IPV4_HEADER_LEN
380                    + packet::tcp::TCP_HEADER_LEN
381                    + packet::tcp::TCP_DEFAULT_OPTION_LEN];
382                let mut ethernet_packet: pnet::packet::ethernet::MutableEthernetPacket =
383                    pnet::packet::ethernet::MutableEthernetPacket::new(&mut ethernet_buffer)
384                        .unwrap();
385                packet::ethernet::build_ethernet_packet(
386                    &mut ethernet_packet,
387                    packet_builder.src_mac.clone(),
388                    packet_builder.dst_mac.clone(),
389                    packet_builder.ether_type,
390                );
391                let mut ipv4_buffer = [0u8; packet::ipv4::IPV4_HEADER_LEN
392                    + packet::tcp::TCP_HEADER_LEN
393                    + packet::tcp::TCP_DEFAULT_OPTION_LEN];
394                let mut ipv4_packet =
395                    pnet::packet::ipv4::MutableIpv4Packet::new(&mut ipv4_buffer).unwrap();
396                packet::ipv4::build_ipv4_packet(
397                    &mut ipv4_packet,
398                    src_ip,
399                    dst_ip,
400                    packet_builder.ip_protocol.unwrap(),
401                );
402                let mut tcp_buffer =
403                    [0u8; packet::tcp::TCP_HEADER_LEN + packet::tcp::TCP_DEFAULT_OPTION_LEN];
404                let mut tcp_packet =
405                    pnet::packet::tcp::MutableTcpPacket::new(&mut tcp_buffer).unwrap();
406                packet::tcp::build_tcp_packet(
407                    &mut tcp_packet,
408                    packet_builder.src_ip,
409                    packet_builder.src_port.unwrap(),
410                    packet_builder.dst_ip,
411                    packet_builder.dst_port.unwrap(),
412                );
413                ipv4_packet.set_payload(tcp_packet.packet());
414                ethernet_packet.set_payload(ipv4_packet.packet());
415                if packet_builder.use_tun {
416                    ethernet_packet.packet()[packet::ethernet::ETHERNET_HEADER_LEN..].to_vec()
417                }else {
418                    ethernet_packet.packet().to_vec()
419                }
420            }
421            IpAddr::V6(_) => return Vec::new(),
422        },
423        IpAddr::V6(src_ip) => match packet_builder.dst_ip {
424            IpAddr::V4(_) => return Vec::new(),
425            IpAddr::V6(dst_ip) => {
426                let mut ethernet_buffer = [0u8; packet::ethernet::ETHERNET_HEADER_LEN
427                    + packet::ipv6::IPV6_HEADER_LEN
428                    + packet::tcp::TCP_HEADER_LEN
429                    + packet::tcp::TCP_DEFAULT_OPTION_LEN];
430                let mut ethernet_packet: pnet::packet::ethernet::MutableEthernetPacket =
431                    pnet::packet::ethernet::MutableEthernetPacket::new(&mut ethernet_buffer)
432                        .unwrap();
433                packet::ethernet::build_ethernet_packet(
434                    &mut ethernet_packet,
435                    packet_builder.src_mac.clone(),
436                    packet_builder.dst_mac.clone(),
437                    packet_builder.ether_type,
438                );
439                let mut ipv6_buffer = [0u8; packet::ipv6::IPV6_HEADER_LEN
440                    + packet::tcp::TCP_HEADER_LEN
441                    + packet::tcp::TCP_DEFAULT_OPTION_LEN];
442                let mut ipv6_packet =
443                    pnet::packet::ipv6::MutableIpv6Packet::new(&mut ipv6_buffer).unwrap();
444                packet::ipv6::build_ipv6_packet(
445                    &mut ipv6_packet,
446                    src_ip,
447                    dst_ip,
448                    packet_builder.ip_protocol.unwrap(),
449                );
450                let mut tcp_buffer =
451                    [0u8; packet::tcp::TCP_HEADER_LEN + packet::tcp::TCP_DEFAULT_OPTION_LEN];
452                let mut tcp_packet =
453                    pnet::packet::tcp::MutableTcpPacket::new(&mut tcp_buffer).unwrap();
454                packet::tcp::build_tcp_packet(
455                    &mut tcp_packet,
456                    packet_builder.src_ip,
457                    packet_builder.src_port.unwrap(),
458                    packet_builder.dst_ip,
459                    packet_builder.dst_port.unwrap(),
460                );
461                ipv6_packet.set_payload(tcp_packet.packet());
462                ethernet_packet.set_payload(ipv6_packet.packet());
463                if packet_builder.use_tun {
464                    ethernet_packet.packet()[packet::ethernet::ETHERNET_HEADER_LEN..].to_vec()
465                }else {
466                    ethernet_packet.packet().to_vec()
467                }
468            }
469        },
470    }
471}
472
473/// Build TCP Packet from PacketBuildOption
474pub fn build_tcp_syn_packet(packet_builder: PacketBuildOption) -> Vec<u8> {
475    let mut tcp_buffer = [0u8; packet::tcp::TCP_HEADER_LEN + packet::tcp::TCP_DEFAULT_OPTION_LEN];
476    let mut tcp_packet = pnet::packet::tcp::MutableTcpPacket::new(&mut tcp_buffer).unwrap();
477    packet::tcp::build_tcp_packet(
478        &mut tcp_packet,
479        packet_builder.src_ip,
480        packet_builder.src_port.unwrap(),
481        packet_builder.dst_ip,
482        packet_builder.dst_port.unwrap(),
483    );
484    tcp_packet.packet().to_vec()
485}
486
487/// Build UDP Packet from PacketBuildOption. Build full packet with Ethernet and IP header.
488pub fn build_full_udp_packet(packet_builder: PacketBuildOption) -> Vec<u8> {
489    match packet_builder.src_ip {
490        IpAddr::V4(src_ip) => match packet_builder.dst_ip {
491            IpAddr::V4(dst_ip) => {
492                let mut ethernet_buffer = [0u8; packet::ethernet::ETHERNET_HEADER_LEN
493                    + packet::ipv4::IPV4_HEADER_LEN
494                    + packet::udp::UDP_HEADER_LEN];
495                let mut ethernet_packet: pnet::packet::ethernet::MutableEthernetPacket =
496                    pnet::packet::ethernet::MutableEthernetPacket::new(&mut ethernet_buffer)
497                        .unwrap();
498                packet::ethernet::build_ethernet_packet(
499                    &mut ethernet_packet,
500                    packet_builder.src_mac.clone(),
501                    packet_builder.dst_mac.clone(),
502                    packet_builder.ether_type,
503                );
504                let mut ipv4_buffer =
505                    [0u8; packet::ipv4::IPV4_HEADER_LEN + packet::udp::UDP_HEADER_LEN];
506                let mut ipv4_packet =
507                    pnet::packet::ipv4::MutableIpv4Packet::new(&mut ipv4_buffer).unwrap();
508                packet::ipv4::build_ipv4_packet(
509                    &mut ipv4_packet,
510                    src_ip,
511                    dst_ip,
512                    packet_builder.ip_protocol.unwrap(),
513                );
514                let mut udp_buffer = [0u8; packet::udp::UDP_HEADER_LEN];
515                let mut udp_packet =
516                    pnet::packet::udp::MutableUdpPacket::new(&mut udp_buffer).unwrap();
517                packet::udp::build_udp_packet(
518                    &mut udp_packet,
519                    packet_builder.src_ip,
520                    packet_builder.src_port.unwrap(),
521                    packet_builder.dst_ip,
522                    packet_builder.dst_port.unwrap(),
523                );
524                ipv4_packet.set_payload(udp_packet.packet());
525                ethernet_packet.set_payload(ipv4_packet.packet());
526                if packet_builder.use_tun {
527                    ethernet_packet.packet()[packet::ethernet::ETHERNET_HEADER_LEN..].to_vec()
528                }else {
529                    ethernet_packet.packet().to_vec()
530                }
531            }
532            IpAddr::V6(_) => return Vec::new(),
533        },
534        IpAddr::V6(src_ip) => match packet_builder.dst_ip {
535            IpAddr::V4(_) => return Vec::new(),
536            IpAddr::V6(dst_ip) => {
537                let mut ethernet_buffer = [0u8; packet::ethernet::ETHERNET_HEADER_LEN
538                    + packet::ipv6::IPV6_HEADER_LEN
539                    + packet::udp::UDP_HEADER_LEN];
540                let mut ethernet_packet: pnet::packet::ethernet::MutableEthernetPacket =
541                    pnet::packet::ethernet::MutableEthernetPacket::new(&mut ethernet_buffer)
542                        .unwrap();
543                packet::ethernet::build_ethernet_packet(
544                    &mut ethernet_packet,
545                    packet_builder.src_mac.clone(),
546                    packet_builder.dst_mac.clone(),
547                    packet_builder.ether_type,
548                );
549                let mut ipv6_buffer =
550                    [0u8; packet::ipv6::IPV6_HEADER_LEN + packet::udp::UDP_HEADER_LEN];
551                let mut ipv6_packet =
552                    pnet::packet::ipv6::MutableIpv6Packet::new(&mut ipv6_buffer).unwrap();
553                packet::ipv6::build_ipv6_packet(
554                    &mut ipv6_packet,
555                    src_ip,
556                    dst_ip,
557                    packet_builder.ip_protocol.unwrap(),
558                );
559                let mut udp_buffer = [0u8; packet::udp::UDP_HEADER_LEN];
560                let mut udp_packet =
561                    pnet::packet::udp::MutableUdpPacket::new(&mut udp_buffer).unwrap();
562                packet::udp::build_udp_packet(
563                    &mut udp_packet,
564                    packet_builder.src_ip,
565                    packet_builder.src_port.unwrap(),
566                    packet_builder.dst_ip,
567                    packet_builder.dst_port.unwrap(),
568                );
569                ipv6_packet.set_payload(udp_packet.packet());
570                ethernet_packet.set_payload(ipv6_packet.packet());
571                if packet_builder.use_tun {
572                    ethernet_packet.packet()[packet::ethernet::ETHERNET_HEADER_LEN..].to_vec()
573                }else {
574                    ethernet_packet.packet().to_vec()
575                }
576            }
577        },
578    }
579}
580
581/// Build UDP Packet from PacketBuildOption
582pub fn build_udp_packet(packet_builder: PacketBuildOption) -> Vec<u8> {
583    let mut udp_buffer = [0u8; packet::udp::UDP_HEADER_LEN];
584    let mut udp_packet = pnet::packet::udp::MutableUdpPacket::new(&mut udp_buffer).unwrap();
585    packet::udp::build_udp_packet(
586        &mut udp_packet,
587        packet_builder.src_ip,
588        packet_builder.src_port.unwrap(),
589        packet_builder.dst_ip,
590        packet_builder.dst_port.unwrap(),
591    );
592    udp_packet.packet().to_vec()
593}
cross_socket/packet/builder.rs

cross_socket/packet/
builder.rs
