226 lines
7.9 KiB
C
226 lines
7.9 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
#include <errno.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
static uint16_t get_le16(const uint8_t *p)
|
|
{
|
|
return (uint16_t)p[0] | ((uint16_t)p[1] << 8);
|
|
}
|
|
|
|
static uint32_t get_le32(const uint8_t *p)
|
|
{
|
|
return (uint32_t)p[0] | ((uint32_t)p[1] << 8) |
|
|
((uint32_t)p[2] << 16) | ((uint32_t)p[3] << 24);
|
|
}
|
|
|
|
static uint32_t get_be32(const uint8_t *p)
|
|
{
|
|
return ((uint32_t)p[0] << 24) | ((uint32_t)p[1] << 16) |
|
|
((uint32_t)p[2] << 8) | (uint32_t)p[3];
|
|
}
|
|
|
|
static uint32_t get_goodix_image_crc(const uint8_t *p)
|
|
{
|
|
return ((uint32_t)p[2] << 24) | ((uint32_t)p[3] << 16) |
|
|
((uint32_t)p[0] << 8) | (uint32_t)p[1];
|
|
}
|
|
|
|
static uint32_t crc32_mpeg2(const uint8_t *data, size_t length)
|
|
{
|
|
uint32_t crc = UINT32_MAX;
|
|
size_t i;
|
|
|
|
for (i = 0; i < length; i++) {
|
|
unsigned int bit;
|
|
|
|
crc ^= (uint32_t)data[i] << 24;
|
|
for (bit = 0; bit < 8; bit++)
|
|
crc = (crc & UINT32_C(0x80000000))
|
|
? (crc << 1) ^ UINT32_C(0x04c11db7)
|
|
: crc << 1;
|
|
}
|
|
return crc;
|
|
}
|
|
|
|
static void analyze_crc_candidate(const char *name, const uint8_t *data,
|
|
size_t size, size_t offset, size_t span)
|
|
{
|
|
const uint8_t *stored;
|
|
uint32_t calculated;
|
|
uint32_t be;
|
|
uint32_t le;
|
|
uint32_t goodix;
|
|
|
|
printf("CRC candidate %s: offset=%zu length=%zu", name, offset, span);
|
|
if (span < 4u || offset > size || span > size - offset) {
|
|
printf(" OUT_OF_RANGE\n");
|
|
return;
|
|
}
|
|
|
|
stored = data + offset + span - 4u;
|
|
calculated = crc32_mpeg2(data + offset, span - 4u);
|
|
be = get_be32(stored);
|
|
le = get_le32(stored);
|
|
goodix = get_goodix_image_crc(stored);
|
|
|
|
printf(" data=%zu raw=%02x%02x%02x%02x calc=%08x",
|
|
span - 4u, stored[0], stored[1], stored[2], stored[3],
|
|
calculated);
|
|
if (calculated == be)
|
|
printf(" MATCH_BE");
|
|
if (calculated == le)
|
|
printf(" MATCH_LE");
|
|
if (calculated == goodix)
|
|
printf(" MATCH_GOODIX_2301");
|
|
if (calculated != be && calculated != le && calculated != goodix)
|
|
printf(" NO_MATCH");
|
|
putchar('\n');
|
|
}
|
|
|
|
static void dump_edge(const char *label, const uint8_t *data, size_t length)
|
|
{
|
|
size_t i;
|
|
|
|
printf("%s (%zu bytes):", label, length);
|
|
for (i = 0; i < length; i++) {
|
|
if ((i % 16) == 0)
|
|
printf("\n ");
|
|
printf("%02x%c", data[i], (i % 16) == 15 ? '\n' : ' ');
|
|
}
|
|
if ((length % 16) != 0)
|
|
putchar('\n');
|
|
}
|
|
|
|
static int read_file(const char *path, uint8_t **out, size_t *out_length)
|
|
{
|
|
FILE *file;
|
|
long end;
|
|
uint8_t *data;
|
|
|
|
file = fopen(path, "rb");
|
|
if (!file)
|
|
return -errno;
|
|
if (fseek(file, 0, SEEK_END) != 0 || (end = ftell(file)) < 0 ||
|
|
fseek(file, 0, SEEK_SET) != 0) {
|
|
fclose(file);
|
|
return -EIO;
|
|
}
|
|
data = malloc(end > 0 ? (size_t)end : 1u);
|
|
if (!data) {
|
|
fclose(file);
|
|
return -ENOMEM;
|
|
}
|
|
if (end > 0 && fread(data, 1, (size_t)end, file) != (size_t)end) {
|
|
free(data);
|
|
fclose(file);
|
|
return -EIO;
|
|
}
|
|
if (fclose(file) != 0) {
|
|
free(data);
|
|
return -EIO;
|
|
}
|
|
*out = data;
|
|
*out_length = (size_t)end;
|
|
return 0;
|
|
}
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
const char *path = argc > 1 ? argv[1] : "capture_plaintext.bin";
|
|
uint8_t *data = NULL;
|
|
size_t size = 0;
|
|
uint16_t declared;
|
|
size_t expected_total;
|
|
size_t edge;
|
|
int ret;
|
|
|
|
ret = read_file(path, &data, &size);
|
|
if (ret) {
|
|
fprintf(stderr, "%s: %s\n", path, strerror(-ret));
|
|
return EXIT_FAILURE;
|
|
}
|
|
if (size < 3) {
|
|
fprintf(stderr, "%s: file is shorter than the 3-byte header\n", path);
|
|
free(data);
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
declared = get_le16(data + 1);
|
|
expected_total = 3u + (size_t)declared;
|
|
printf("file: %s\n", path);
|
|
printf("command: 0x%02x\n", data[0]);
|
|
printf("declared_length: %u (0x%04x)\n", declared, declared);
|
|
printf("file_size: %zu\n", size);
|
|
printf("expected_total: %zu\n", expected_total);
|
|
printf("length_match: %s\n", size == expected_total ? "yes" : "no");
|
|
|
|
edge = size < 32u ? size : 32u;
|
|
dump_edge("first", data, edge);
|
|
dump_edge("last", data + size - edge, edge);
|
|
|
|
printf("controlled CRC scope candidates:\n");
|
|
analyze_crc_candidate("A", data, size, 3u, 7685u);
|
|
analyze_crc_candidate("B", data, size, 8u, 7680u);
|
|
analyze_crc_candidate("C", data, size, 3u, 7686u);
|
|
analyze_crc_candidate("D", data, size, 8u, 7684u);
|
|
|
|
if (declared >= 6u && expected_total <= size) {
|
|
const uint8_t *frame_payload = data + 3u;
|
|
size_t frame_payload_length = declared;
|
|
const uint8_t *image_data = frame_payload + 5u;
|
|
size_t image_data_length = frame_payload_length - 6u;
|
|
const uint8_t *frame_trailer = frame_payload +
|
|
frame_payload_length - 1u;
|
|
uint8_t sum = 0;
|
|
size_t i;
|
|
|
|
printf("frame_payload_offset: 3\n");
|
|
printf("frame_payload_length: %zu\n", frame_payload_length);
|
|
printf("image_data_offset: 8\n");
|
|
printf("image_data_length (DLL length - 6): %zu\n",
|
|
image_data_length);
|
|
printf("frame_trailer: 0x%02x\n", *frame_trailer);
|
|
|
|
for (i = 0; i < expected_total - 1u; i++)
|
|
sum = (uint8_t)(sum + data[i]);
|
|
printf("checksum_candidate target_AA: 0x%02x\n",
|
|
(uint8_t)(UINT8_C(0xaa) - sum));
|
|
printf("checksum_candidate target_00: 0x%02x\n",
|
|
(uint8_t)(0u - sum));
|
|
printf("sum_with_trailer_mod256: 0x%02x\n",
|
|
(uint8_t)(sum + *frame_trailer));
|
|
|
|
if (image_data_length >= 4u) {
|
|
const uint8_t *crc_bytes = image_data +
|
|
image_data_length - 4u;
|
|
uint32_t calculated = crc32_mpeg2(
|
|
image_data, image_data_length - 4u);
|
|
|
|
printf("image_bytes_before_crc: %zu\n",
|
|
image_data_length - 4u);
|
|
printf("image_crc_raw: %02x %02x %02x %02x\n",
|
|
crc_bytes[0], crc_bytes[1],
|
|
crc_bytes[2], crc_bytes[3]);
|
|
printf("crc32_mpeg2_calculated: 0x%08x\n", calculated);
|
|
printf("crc_candidate_be: 0x%08x%s\n",
|
|
get_be32(crc_bytes),
|
|
calculated == get_be32(crc_bytes) ? " MATCH" : "");
|
|
printf("crc_candidate_le: 0x%08x%s\n",
|
|
get_le32(crc_bytes),
|
|
calculated == get_le32(crc_bytes) ? " MATCH" : "");
|
|
printf("crc_candidate_goodix_2301: 0x%08x%s\n",
|
|
get_goodix_image_crc(crc_bytes),
|
|
calculated == get_goodix_image_crc(crc_bytes)
|
|
? " MATCH" : "");
|
|
}
|
|
} else {
|
|
printf("frame analysis skipped: declared length is incomplete\n");
|
|
}
|
|
|
|
free(data);
|
|
return EXIT_SUCCESS;
|
|
}
|