Extrait de SNI (Server Name Indication) de client TLS bonjour

Comment voulez-vous extraire l'Indication du Nom du Serveur à partir d'un Client TLS message Hello. Je suis actuellement de la difficulté à comprendre ce très cryptique RFC 3546 sur TLS Extensions, dans lequel la SNI est défini.

Choses que j'ai entendu jusqu'à présent:

L'hôte est encodés en utf-8 et lisible lorsque vous utf8 enocde la mémoire tampon.
Theres un octet avant de l'hôte, qui détermine sa longueur.

Si je pouvais trouver la position exacte de la longueur en octets, de l'extraction de la SNI serait assez simple. Mais comment faire pour que les octets en premier lieu?

La simple approche vous essayez de prendre est le mal. Vous devez analyser la demande et notamment de ses extensions et puis, vous obtenez les données à partir de l'extension correspondante.
Ouais, j'en suis certain, mais je ne sais pas vraiment comment l'analyser. Voulez-vous comprendre comment la poignée de main TLS fonctionne?
Bien sûr, je ne nous vous offrons une bibliothèque sur la sécurité comme l'un de nos produits principaux. Vous devez ouvrir le RFC ( tools.ietf.org/html/rfc5246 ) et le mettre en œuvre.
Haha, eh bien je vous remercie, c'est comme 100 pages de pure tech. Je suppose que les choses deviennent intéressantes sur page 41. C'est là que les extensions sont mentionnés, qui sont décrits dans la RFC 3546. Oh mon dieu, Oh mon. 😀
Hey regarde, une autre réponse où Eugene est de vendre un 20 mille dollars, produit une réponse. Je suppose en pointant les gens à un énorme RFC et de rendre la tâche se sentir écrasante majorité redoutable est une tactique de vente?

OriginalL'auteur buschtoens | 2013-07-24

Je l'ai fait en sniproxy, l'examen d'un client TLS bonjour paquets dans Wireshark lors de la lecture de cette RFC est une très bonne façon d'aller. Il n'est pas trop dur, juste beaucoup de champs de longueur variable que vous avez à passer et vérifier vérifier si vous avez le bon type de l'élément.

Je travaille sur mes tests, et ont cette annoté échantillon de paquet qui pourraient vous aider:

const unsigned char good_data_2[] = {
    //TLS record
    0x16, //Content Type: Handshake
    0x03, 0x01, //Version: TLS 1.0
    0x00, 0x6c, //Length (use for bounds checking)
        //Handshake
        0x01, //Handshake Type: Client Hello
        0x00, 0x00, 0x68, //Length (use for bounds checking)
        0x03, 0x03, //Version: TLS 1.2
        //Random (32 bytes fixed length)
        0xb6, 0xb2, 0x6a, 0xfb, 0x55, 0x5e, 0x03, 0xd5,
        0x65, 0xa3, 0x6a, 0xf0, 0x5e, 0xa5, 0x43, 0x02,
        0x93, 0xb9, 0x59, 0xa7, 0x54, 0xc3, 0xdd, 0x78,
        0x57, 0x58, 0x34, 0xc5, 0x82, 0xfd, 0x53, 0xd1,
        0x00, //Session ID Length (skip past this much)
        0x00, 0x04, //Cipher Suites Length (skip past this much)
            0x00, 0x01, //NULL-MD5
            0x00, 0xff, //RENEGOTIATION INFO SCSV
        0x01, //Compression Methods Length (skip past this much)
            0x00, //NULL
        0x00, 0x3b, //Extensions Length (use for bounds checking)
            //Extension
            0x00, 0x00, //Extension Type: Server Name (check extension type)
            0x00, 0x0e, //Length (use for bounds checking)
            0x00, 0x0c, //Server Name Indication Length
                0x00, //Server Name Type: host_name (check server name type)
                0x00, 0x09, //Length (length of your data)
                //"localhost" (data your after)
                0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x68, 0x6f, 0x73, 0x74,
            //Extension
            0x00, 0x0d, //Extension Type: Signature Algorithms (check extension type)
            0x00, 0x20, //Length (skip past since this is the wrong extension)
            //Data
            0x00, 0x1e, 0x06, 0x01, 0x06, 0x02, 0x06, 0x03,
            0x05, 0x01, 0x05, 0x02, 0x05, 0x03, 0x04, 0x01,
            0x04, 0x02, 0x04, 0x03, 0x03, 0x01, 0x03, 0x02,
            0x03, 0x03, 0x02, 0x01, 0x02, 0x02, 0x02, 0x03,
            //Extension
            0x00, 0x0f, //Extension Type: Heart Beat (check extension type)
            0x00, 0x01, //Length (skip past since this is the wrong extension)
            0x01 //Mode: Peer allows to send requests
};

Cool, merci pour ce partage. +1
C'est nettement plus élaboré que mon original à la moitié de la réponse. Une tique. 😀
Super, je suis venu ici parce que je voulais avoir un non-décryptage simple TLS transitaire basé sur la SNI. Donc, avec sniproxy qui est déjà fait.

OriginalL'auteur dlundquist

5

Utiliser WireShark et de capturer uniquement le protocole TLS (SSL) des paquets par l'ajout d'un filtre tcp port 443. Ensuite, trouver un Client "Bonjour" Message. Vous pouvez voir ses données brutes ci-dessous.

Développez Secure Socket Layer->TLSv1.2 Record Layer: Handshake Protocol: Client Hello->...

et vous verrez Extension: server_name->Server Name Indication extension. Le nom du serveur dans la poignée de main package n'est pas chiffré.

http://i.stack.imgur.com/qt0gu.png

Nous sommes à la recherche pour les programmes de façon à déterminer la SNI. Cependant, cela peut être intéressant pour certaines personnes, néanmoins, merci donc de ne pas les supprimer.

OriginalL'auteur LYF
1

J'ai remarqué que le nom de domaine est toujours préfixer par deux à zéro octets et une longueur en octets. C'est peut-être 24 bits non signé entier, mais je ne peux pas le tester, que mon serveur DNS ne permettent pas à des noms de domaine au-delà de 77 caractères.

Sur ces connaissances, je suis venu avec cette (Node.js) code.
```
function getSNI(buf) {
  var sni = null
    , regex = /^(?:[a-z0-9-]+\.)+[a-z]+$/i;
  for(var b = 0, prev, start, end, str; b < buf.length; b++) {
    if(prev === 0 && buf[b] === 0) {
      start = b + 2;
      end   = start + buf[b + 1];
      if(start < end && end < buf.length) {
        str = buf.toString("utf8", start, end);
        if(regex.test(str)) {
          sni = str;
          continue;
        }
      }
    }
    prev = buf[b];
  }
  return sni;
}
```
Ce code se présente pour une séquence de deux octets zéro. Si il en trouve un, il suppose que l'octet suivant est un paramètre longueur. Il vérifie si la longueur est toujours à la limite de la mémoire tampon, et si c'est la séquence d'octets en UTF-8. Plus tard, on pourrait RegEx le tableau et d'en extraire le domaine.

Fonctionne étonnamment bien! Encore, j'ai remarqué quelque chose d'étrange.
```
'�\n�\u0014\u0000�\u0000�\u00009\u00008�\u000f�\u0005\u0000�\u00005�\u0007�\t�\u0011�\u0013\u0000E\u0000D\u0000f\u00003\u00002�\f�\u000e�\u0002�\u0004\u0000�\u0000A\u0000\u0005\u0000\u0004\u0000/�\b�\u0012\u0000\u0016\u0000\u0013�\r�\u0003��\u0000\n'
'\u0000\u0015\u0000\u0000\u0012test.cubixcraft.de'
'test.cubixcraft.de'
'\u0000\b\u0000\u0006\u0000\u0017\u0000\u0018\u0000\u0019'
'\u0000\u0005\u0001\u0000\u0000'
```
Toujours, n'importe quel sous-domaine que je veux, le domaine est ciblé à deux reprises. Il semble que la SNI champ est imbriqué dans un autre domaine.

Je suis ouvert aux suggestions et des améliorations! 🙂

J'ai tourné cela en un Nœud du module, pour tout le monde, qui s'en soucie: sni.

Raison pour downvote?
Je ne pense pas que les expressions régulières sont le meilleur moyen d'extraire des données à partir d'un fichier binaire protocole cryptographique. Le Client Hello message comprend 32 octets de données aléatoires qui pourraient correspondre à votre regexp.
Je ne sais pas qu'elle mérite un downvote, je veux dire qu'il a trouvé une solution. J'ai rencontré le même, mais comme dlundquist notes, je ne vais pas compter sur elle étant conforme ou exclure la possibilité d'octets aléatoires à polluer la regex match. Il ne fait toutefois travailler.

OriginalL'auteur buschtoens

Pour toute personne intéressée, c'est une version provisoire du code C/C++. Il a travaillé jusqu'à présent. La fonction retourne la position du nom du serveur dans le tableau d'octets contenant le Client et Bonjour la longueur du nom dans la len paramètre.

char *get_TLS_SNI(unsigned char *bytes, int* len)
{
    unsigned char *curr;
    unsigned char sidlen = bytes[43];
    curr = bytes + 1 + 43 + sidlen;
    unsigned short cslen = ntohs(*(unsigned short*)curr);
    curr += 2 + cslen;
    unsigned char cmplen = *curr;
    curr += 1 + cmplen;
    unsigned char *maxchar = curr + 2 + ntohs(*(unsigned short*)curr);
    curr += 2;
    unsigned short ext_type = 1;
    unsigned short ext_len;
    while(curr < maxchar && ext_type != 0)
    {
        ext_type = ntohs(*(unsigned short*)curr);
        curr += 2;
        ext_len = ntohs(*(unsigned short*)curr);
        curr += 2;
        if(ext_type == 0)
        {
            curr += 3;
            unsigned short namelen = ntohs(*(unsigned short*)curr);
            curr += 2;
            *len = namelen;
            return (char*)curr;
        }
        else curr += ext_len;
    }
    if (curr != maxchar) throw std::exception("incomplete SSL Client Hello");
    return NULL; //SNI was not present
}

OriginalL'auteur Æðelstan

Vous devez vous connecter pour publier un commentaire.