rsubdomain 1.2.13

A high-performance subdomain brute-force tool written in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

use pnet::{
    packet::{
        arp::{ArpHardwareTypes, ArpOperations},
        ethernet::EtherTypes,
        Packet,
    },
    util::MacAddr,
};
use std::net::Ipv4Addr;

fn main() {
    // debug options
    std::env::set_var("RUST_BACKTRACE", "1");

    // get all the interfaces and everything

    let interfac = pnet::datalink::interfaces()[1].clone();
    println!("the interface name is {}", interfac.name);
    let mut etherbuff = [0u8; 42];
    let mut arpbuff = [0u8; 28];

    let (mut tx, _rx) = match pnet::datalink::channel(&interfac, Default::default()) {
        Ok(pnet::datalink::Channel::Ethernet(tx, rx)) => (tx, rx),
        Ok(_) => panic!("Unhandled channel type"),
        Err(e) => panic!(
            "An error occurred when creating the datalink channel: {}",
            e
        ),
    };
    let mut my_arp_packet = pnet::packet::arp::MutableArpPacket::new(&mut arpbuff)
        .expect("could not create arp packet");
    my_arp_packet.set_operation(ArpOperations::Request);
    my_arp_packet.set_hardware_type(ArpHardwareTypes::Ethernet);
    my_arp_packet.set_protocol_type(EtherTypes::Ipv4);
    my_arp_packet.set_hw_addr_len(6);
    my_arp_packet.set_proto_addr_len(4);
    my_arp_packet.set_sender_hw_addr(interfac.mac.unwrap());
    my_arp_packet.set_sender_proto_addr(Ipv4Addr::new(192, 168, 100, 16));
    my_arp_packet.set_target_proto_addr(Ipv4Addr::new(192, 168, 100, 14));

    let mut my_ethernet_packet =
        pnet::packet::ethernet::MutableEthernetPacket::new(&mut etherbuff).unwrap();

    my_ethernet_packet.set_destination(MacAddr::broadcast());
    my_ethernet_packet.set_source(MacAddr::new(0x9c, 0x29, 0x76, 0x7a, 0x70, 0x7e));
    my_ethernet_packet.set_ethertype(EtherTypes::Arp); // for ethernet
    my_ethernet_packet.set_payload(my_arp_packet.packet());

    let _ = tx.send_to(&etherbuff, Some(interfac.clone()));
}