Ingeniería inversa con un cheksum

[ricardinjo]

Hola, buenos días. Sé que este este no es el sitio más adecuado para este tema así que si por favor sabéis algún foro o algún subapartado de este foro donde puedan ayudarme os lo agradecería. De todos formas lo dejo por aquí también para ver si a alguien se le ocurre cómo calcular este cheksum de un esclavo que se comunica por LIN bus.
80 00 00 4F
80 01 00 8B
80 02 00 DE
80 03 00 1A
80 04 00 74
80 05 00 B0
80 06 00 E5
80 07 00 21
80 08 00 39
80 09 00 FD
80 0A 00 A8
80 0B 00 6C
80 0C 00 02
80 0D 00 C6
80 0E 00 93
80 0F 00 57
He probado un montón de cosas pero no doy con el 4 byte de cada trama.
Un saludo y gracias de antemano.

[KILLERJC]

Version de LIN ? Identificador? El largo es de 3 bytes (entonces es LIN 2.x)?

Lo que estamos viendo que es? datos de un esclavo con su checksum ?

[ricardinjo]

Pues supongo que la version de LIN es 2.0 pero el cheksum no se calcular con complemento a 1 o a 2.
El identificador es el 80 pues otro módulo tiene el 81 otro 82...
Lo que estáis viendo en lo que responde el esclavo al maestro y el ultimo byte es el cheksum.
ya lo he encontrado se trata de una combinación de sumas XOR entre bits del byte 1 (por lo menos en este caso lo hare así)

bit 0 : ~(bit1 ^ bit2)
bit 1:  ~(bit2 ^ bit3)
bit 2:  ~(bit3 ^ bit0)
bit 3:  ~(bit3 ^ bit3 ^ bit0)  -> esta es la mas rara de todas pero así sale
bit 4:    (bit3 ^ bit2 ^ bit1)
bit 5:    (bit3 ^ bit2)
bit 6:  ~(bit3 ^ bit0)
bit 7:    (bit1 ^ bit0)

[KILLERJC]

El identificador es el 80 pues otro módulo tiene el 81 otro 82...

Eso me causa ruido... Ya que el ID son los 6 bits de menos peso y se genera 2 bits de paridad con esos 6 bits.

El ID completo va a estar formado por "P1+P0+ID"
Donde P0: esta dado por b0 XOR b1 XOR b2 XOR b4
Donde P1: esta dado por NOT(b1 XOR b3 XOR b4 XOR b5)

Si fuera el ID fuera 000 000. Entonces P1 = 1 y P0 = 0

Por eso tendrias 0x80  ( 10 000000)

Si tuvieras ID 1 ( 000 001) Tendrias P1 = 1 y P0 = 1.. Por lo tanto tu ID seria 0xC1 (11 000001)

Otro numero no te daría 0x81..

Entonces debería suponer que la respuesta que estas obteniendo en realidad ese 0x80 es un dato. Y serian 3 bytes de datos ¿?. Y no estaría incluido el ID ahí.

Existen 2 tipos de checksum,
El común, que solo tiene en cuenta los datos, y si pasa de los 0x100, es restar 0xFF. Luego al final invertirlo. Este no es .... ya que el negado de 0x80  no es... Y si contamos a 0x80 como ID no es el negado de 0x00

El extendido, que también tiene en cuenta el byte de ID (conjunto con los bits de paridad), que se realiza de la misma forma que el anterior nomas que ahora tambien sumamos el byte del ID. Y luego negamos.

Pero al tratar de encontrar un ID que posea esos 3 bytes y me de ese checksum, no hay forma que me de un campo de ID valido.

El protocolo es el protocolo, se respeta porque sino no funciona ninguna comunicación. Entonces solo me queda pensar en las siguientes opciones.

- Lo especificado por el protocolo es mentira total y nadie lo respeta (muy raro).
- Algún protocolo parecido al LIN pero cambiado la parte del checksum, lo cual también es raro.
- Los datos que incluiste están incompletos. No coinciden con lo especificado por el protocolo. Falta información.


Otras no me quedan.... Incluso buscando códigos de checksum de LIN te encontras con:

Código: C

1. for (i = 0; i < lenght; i++)
2.         {
3.                 result += data_ptr[i];
4.                 if (result > 0xFF)
5.                 {
6.                         result -= 0xFF;
7.                 } else
8.                 {
9.                         /* do nothing */
10.                 }
11.         }
12.         return (~result);