...
In our case, our message is 32 bits long, so we will need 32 values plus an addition 5 since we are going to start at the fifth byte in the sequence.
- Start with an 8-bit register initialized to the value 0x7C (0111 1100)
- Generate a number of values equal to the message size in bits by repeating the following operations once for each bit.
...
• The register value after these two operations is the sequence value to be stored. Perform these steps once for each bit in the message. If the message contains 40 32 bits for example (as with the F007TH message) then you will need to generate a sequence of 40 bytes. Because this sequence does not depend on the data message contents and can be pre-computed once and stored to save time.
...
| Start Value | Shift Right | XOR with 0x18 if MSB =1 (flip bits 3 and 4) | Xor | Value | |
|---|---|---|---|---|---|
| 1 | 0111 1100 (0x7C) | → 0011 1110 | NO | - | 0011 1110 (0x3e) |
| 2 | 0011 1110 (0x3e) | → 0001 1111 | NO | - | 0001 1111 (0x1f) |
| 3 | 0001 1111 (0x1f) | → 1000 1111 | YES | xor 0x18 | 1001 0111 (0x97) |
| 4 | 1001 0111 (0x97) | → 1100 1011 | YES | xor 0x18 | 1101 0011 (0xd3) |
| 5 | 1101 0011 (0xd3) | → 1110 1001 | YES | xor 0x18 | 1111 0001 (0xf1) |
| ... | |||||
| 32 | 1000 0110 (0x86) | → 0100 0011 | NO | - | 0100 0011 (0x43) |
| ... | |||||
| 37 | 0011 0001 (0x31) | → 1001 1000 | YES | xor 0x18 | 1000 000 (0x80) |
Values
2. Combines the LSFR sequence with message bits to form the final hash value
...
| Register Value | Index | Value | Value=1? | Calculation | New Register Value (xor with LSFR Sequence starting at the 5th (0xF1) |
|---|---|---|---|---|---|
| 00 | 23 -MSB | 1 | Yes | 00 xor f1 | f1 |
| f1 | 22 | 1 | Yes | f1 xor e0 | 11 |
| 11 | 21 | 1 | Yes | 11 xor 70 | 61 |
| ... | |||||
| 13 | 0 | 0 | No | - | 13 |
Checksum/Hash Source Code
| Code Block |
|---|
#define MESSAGE_SIZE 32
#define OFFSET 4
uint8_t LSFR_sequence[MESSAGE_SIZE] = {0};
void calculateLSFR() {
int i;
uint8_t reg = 0x7C;
uint8_t temp_reg = 0;
for (i = 0; i < MESSAGE_SIZE; i++) {
temp_reg = reg & 0x01;
reg >>= 1;
reg |= (temp_reg << 7);
if (temp_reg) {
reg ^= 0x18;
}
LSFR_sequence[i] = reg;
//printf("%02x\n", LSFR_sequence[i]);
}
}
uint8_t combineLSFR(uint8_t len, uint8_t *data) {
uint8_t hash_reg = 0; // not 0x64
int byte_idx, bit_idx;
uint8_t byte, bit;
//printf("***COMBINE\n");
for (byte_idx = 0; byte_idx < len; byte_idx++) {
for (bit_idx = 7; bit_idx >= 0; bit_idx--) {
bit = (data[byte_idx] & (1 << bit_idx)) >> bit_idx;
if (bit) {
hash_reg ^= LSFR_sequence[byte_idx * 8 + (7 - bit_idx) + OFFSET];
//printf("[%d]: %02x\n", byte_idx * 8 + (7 - bit_idx), hash_reg);
}
bit = 0;
}
}
return hash_reg;
}
uint8_t Checksum(int length, uint8_t *buff) {
calculateLSFR();
return combineLSFR(length, buff);
} |
...