Décoder un websocket cadre

Je suis en train de décoder un websocket image, mais je ne suis pas de succès quand il s'agit de décodage de l'étendue de la charge utile. Voici ce que j'ai fait jusqu'à présent:

char *in = data;
char *buffer;
unsigned int i;
unsigned char mask[4];
unsigned int packet_length = 0;
int rc;

/* Expect a finished text frame. */
assert(in[0] == '\x81');
packet_length = ((unsigned char) in[1]) & 0x7f;

mask[0] = in[2];
mask[1] = in[3];
mask[2] = in[4];
mask[3] = in[5];

if (packet_length <= 125) {           **//This decoding works**
     /* Unmask the payload. */
    for (i = 0; i < packet_length; i++)
        in[6 + i] ^= mask[i % 4];
    rc = asprintf(&buffer, "%.*s", packet_length, in + 6);
} else
    if (packet_length == 126) {       **//This decosing does NOT work**
        /* Unmask the payload. */
        for (i = 0; i < packet_length; i++)
          in[8 + i] ^= mask[i % 4];
        rc = asprintf(&buffer, "%.*s", packet_length, in + 8);
}

Ce que je fais mal? Comment puis-je encoder l'étendue de la charge utile?

InformationsquelleAutor Filipe Santos | 2012-02-07
  1. 6

    Si packet_length est de 126, 2 octets donner la longueur de la lecture des données.

    Si packet_length est de 127, le 8 octets suivants donnent la longueur de données à lire.

    Le masque est contenue dans les 4 octets suivants (d'après la longueur).

    Le message décodé suit cette.

    La données de cadrage section de la spec a une illustration intéressante de ce.

    Si vous re-commander votre code à quelque chose comme

    • Lire packet_length
    • Vérifier packet_length de 126 ou 127. Réaffecter packet_length à la valeur de la suite 2/4 octets si nécessaire.
    • Lire masque (les 4 octets après packet_length, y compris tout supplément de 2 ou 8 octets lus pour l'étape ci-dessus).
    • Décoder le message (tout ce qui est après le masque).

    puis les choses devraient fonctionner.

    • fait une petite correction: 127 dans la longueur les 8 octets suivants tenir la charge utile longueur (pas 4)
    • oups, merci pour le spotting qui
    InformationsquelleAutor simonc
  2. 5

    Le point de friction est à > 125 octets de charge utile.

    Le format est assez simple, permet de dire que vous envoyer dix un en JavaScript:

    ws.send("a".repeat(10))

    Le serveur va recevoir:

    bytes[16]=818a8258a610e339c771e339c771e339
    • octet 0: Le 0x81 est juste un indicateur à un message reçu
    • octet 1: la 0x8a est la longueur, il suffit de soustraire les 80 à partir d'elle, 0x0A == 10
    • octet 2, 3, 4, 5: 4 octets xor clé pour déchiffrer la charge utile
    • le reste: charge utile

    Mais maintenant, disons que vous envoyez 126 un en JavaScript:

    ws.send("a".repeat(126))

    Le serveur va recevoir:

    bytes[134]=81fe007ee415f1e5857490848574908485749084857490848574908485749084857490848574908485749084857490848574908485749084857490848574908485749084857490848574908485749084857490848574908485749084857490848574908485749084857490848574908485749084857490848574908485749084857490848574

    Si la longueur de la charge utile est > 125, l'octet 1 aura la valeur 0xfe, le changement de format, puis à:

    • octet 0: Le 0x81 est juste un indicateur à un message reçu
    • octet 1: sera 0xfe
    • octet 2, 3: la longueur de la charge utile en tant que uint16 nombre
    • octet 4, 5, 6, 7: les 4 octets xor clé pour déchiffrer la charge utile
    • le reste: charge utile

    Exemple de code en C#:

    List<byte[]> decodeWebsocketFrame(Byte[] bytes)
{
    List<Byte[]> ret = new List<Byte[]>();
    int offset = 0;
    while (offset + 6 < bytes.Length)
    {
        //format: 0==ascii/binary 1=length-0x80, byte 2,3,4,5=key, 6+len=message, repeat with offset for next...
        int len = bytes[offset + 1] - 0x80;

        if (len <= 125)
        {

            //String data = Encoding.UTF8.GetString(bytes);
            //Debug.Log("len=" + len + "bytes[" + bytes.Length + "]=" + ByteArrayToString(bytes) + " data[" + data.Length + "]=" + data);
            Debug.Log("len=" + len + " offset=" + offset);
            Byte[] key = new Byte[] { bytes[offset + 2], bytes[offset + 3], bytes[offset + 4], bytes[offset + 5] };
            Byte[] decoded = new Byte[len];
            for (int i = 0; i < len; i++)
            {
                int realPos = offset + 6 + i;
                decoded[i] = (Byte)(bytes[realPos] ^ key[i % 4]);
            }
            offset += 6 + len;
            ret.Add(decoded);
        } else
        {
            int a = bytes[offset + 2];
            int b = bytes[offset + 3];
            len = (a << 8) + b;
            //Debug.Log("Length of ws: " + len);

            Byte[] key = new Byte[] { bytes[offset + 4], bytes[offset + 5], bytes[offset + 6], bytes[offset + 7] };
            Byte[] decoded = new Byte[len];
            for (int i = 0; i < len; i++)
            {
                int realPos = offset + 8 + i;
                decoded[i] = (Byte)(bytes[realPos] ^ key[i % 4]);
            }

            offset += 8 + len;
            ret.Add(decoded);
        }
    }
    return ret;
}
    • Merci de ne pas faire de l'arithmétique avec Hex!
    InformationsquelleAutor lama12345