tcp - ¿Cómo interpretas esta frase?

binary protocols

Question

¿Cómo interpretas esta frase?

Checksum
Este es el valor para hacer cero al agregar los 8 bits más bajos desde el encabezado a la suma de comprobación.

Con esta descripción de protocolo:

Protocolo
Consisten en encabezado (1 byte) + longitud de datos (1 byte) + datos de comando (13 bytes) + suma de verificación (1 bytes) + ID de conexión (1 byte).

(Literalmente copié esta descripción del protocolo, así que no sé por qué hay 1 bytes (en plural). Pero puedo decir que es solo un byte)

Aquí hay algunos ejemplos de paquetes TCP de este protocolo:

HE:DL:------------Command Data -------------:CS:ID
02:0d:be:ef:03:06:00:19:d3:02:00:00:60:00:00:ed:01
02:0d:be:ef:03:06:00:cd:d2:02:00:00:20:00:00:7a:01
02:0d:be:ef:03:06:00:10:f6:02:00:ba:30:00:00:49:01
02:0d:be:ef:03:06:00:c8:d8:02:00:20:30:00:00:49:01
// Requested Packets
02:0d:be:ef:03:06:00:13:d3:01:00:02:30:01:00:21:01
02:0d:be:ef:03:06:00:c2:ff:02:00:90:10:00:00:d8:01

Dónde

• HE es el encabezado (que se fija a 0x02 )
• DL es DataLength (que siempre es 0x0d , porque los paquetes tienen la misma longitud)
• CS es el CheckSum (de lo que se trata mi pregunta)
• ID es el ID de conexión (parece ser siempre 01 en mis pruebas)

No puedo entender cómo se calcula la suma de comprobación. Espero haber dado suficiente información.

Gracias por adelantado.

Answer 1

Creo que solo hay un error en la descripción. Parece que suman todos los bytes entre el encabezado y la suma de comprobación. Y la suma de comprobación es solo un número que borra los 8 bits más bajos. Entonces, para el primer ejemplo, la suma de todos los bytes entre el encabezado y la suma de comprobación es 0x0313. O

0x0313 0000 0011 0001 0011
0x00ED 0000 0000 1110 1101

Cuando está alineado así, puedes ver claramente que estarás poniendo a cero los 8 bits más bajos y regresarás:

0x0400 0000 0100 0000 0000

No especificó un idioma, pero también podría calcular rápidamente su propia suma de comprobación haciendo (0 XOR calculateSum) + 1.

Answer 2

Si suma todos los números hexadecimales en el encabezado, DataLength, CommandData y CheckSum, hace 1024.

Por ejemplo, aquí está la suma del segundo ejemplo (salté el 0x00):

0x02+0x0d+0xbe+0xef+0x03+0x06+0xcd+0xd2+0x02+0x20+0x7a = 1024

Captura de pantalla (suma es solo una función de JavaScript que escribí para sumar los valores hexadecimales automáticamente):

EDITAR: No necesariamente sumará a 1024; en cambio, si es válido, sumará a un número donde los 8 bits inferiores son 0, como 1024 (100 00000000 ), 768 (11 00000000 ) y 1280 (101 00000000 ) .

Answer 3

Solo por diversión, tomé esto como un ejercicio al escribir un analizador binario simple usando Boost Spirit (c ++). Incluí la conversión del formato de pregunta y la verificación de suma de comprobación.

Hice que el analizador sintáctico reconociera la longitud de datos real y la elección arbitraria del contenedor STL para los datos del paquete. Salida a continuación:

#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/karma.hpp>
#include <boost/spirit/include/phoenix.hpp>
#include <boost/fusion/include/adapt_struct.hpp>

namespace qi=boost::spirit::qi;
namespace karma=boost::spirit::karma;
namespace phx=boost::phoenix;

typedef unsigned char uchar;
static const auto inbyte  = qi::uint_parser<unsigned char, 16, 2, 2>();
static const auto outbyte = karma::right_align(2,''0'') [ karma::hex ];

// for some reason the alignment doesn''t ''take'' with the above, so HACK:
#define outbyte karma::right_align(2,''0'') [ karma::hex ]

struct packet_t
{
    enum { HEADER = 0x02 };
    uchar checksum, id;

    typedef std::string data_t;
    /// the following work without modification:
    // typedef std::vector<uchar> data_t; 
    // typedef std::list<int> data_t; 
    data_t data;

    uchar do_checksum() const 
    { 
        return (uchar) -std::accumulate(data.begin(), data.end(), 
            HEADER + data.size()); 
    }

    bool is_valid() const 
    { return checksum == do_checksum(); }
};

BOOST_FUSION_ADAPT_STRUCT(packet_t,
        (packet_t::data_t, data) (uchar, checksum) (uchar, id)); 

int main()
{
    static const std::string input = 
        "02:0d:be:ef:03:06:00:19:d3:02:00:00:60:00:00:ed:01/n"
        "02:0d:be:ef:03:06:00:cd:d2:02:00:00:20:00:00:7a:01/n"
        "02:0d:be:ef:03:06:00:10:f6:02:00:ba:30:00:00:49:01/n"
        "02:0d:be:ef:03:06:00:c8:d8:02:00:20:30:00:00:49:01/n"
        "02:08:c8:d8:02:00:20:30:00:00:49:01/n"; // failure test case

    // convert hex to bytes
    std::vector<std::vector<char> > rawpackets;
    if (!qi::parse(input.begin(), input.end(), (inbyte % '':'') % qi::eol, rawpackets))
        { std::cerr << "bailing" << std::endl; return 255; }

    // std::cout << karma::format(karma::eps << outbyte % '':'' % karma::eol, rawpackets) << std::endl;

    // analyze & checksum packets
    for (auto raw: rawpackets)
    {
        std::cout << karma::format(karma::eps << outbyte % '':'', raw);

        using namespace qi;
        rule<decltype(raw.begin()), packet_t(), locals<uchar> > parser;
        parser %= byte_(packet_t::HEADER)
                > omit[ byte_ [ _a = _1 ] ] // datalen
                > repeat(_a)[byte_]         // data
                > byte_                     // checksum
                > byte_;                    // id

        packet_t packet;
        if (!parse(raw.begin(), raw.end(), parser, packet))
            { std::cerr << " bailing" << std::endl; return 255; }

        std::cout << " do_checksum():/t" << karma::format(outbyte, packet.do_checksum());
        std::cout << " is_valid():/t"    << std::boolalpha << packet.is_valid() << std::endl;
    }

    return 0;
}

Salida

02:0d:be:ef:03:06:00:19:d3:02:00:00:60:00:00:ed:01 do_checksum():   ed is_valid():  true
02:0d:be:ef:03:06:00:cd:d2:02:00:00:20:00:00:7a:01 do_checksum():   7a is_valid():  true
02:0d:be:ef:03:06:00:10:f6:02:00:ba:30:00:00:49:01 do_checksum():   49 is_valid():  true
02:0d:be:ef:03:06:00:c8:d8:02:00:20:30:00:00:49:01 do_checksum():   49 is_valid():  true
02:08:c8:d8:02:00:20:30:00:00:49:01 do_checksum():  04 is_valid():  false

Answer 4

Tú

1. Sume todos los bytes antes del campo de suma de verificación.
2. Extraiga los 8 bits bajos de la suma
3. Encuentre el valor ("valor para hacer cero") que, cuando se agrega a la suma calculada se convierte en 0 (es decir, resuelve "x + suma calculada = 0")

De todos modos, este código C calcula la suma correcta para todos sus 4 ejemplos:

uint8_t silly_chksum(const uint8_t *data, size_t len)
{
  size_t i;
  unsigned int chk = -1;
  for(i = 0; i < len ;i++)
    {
        chk += data[i];
    }

    return ~(chk & 0xff);
}