En el desarrollo industrial, a menudo necesitas guardar información crítica (como el total de ventas del día o el factor de calibración de un sensor) en una memoria EEPROM externa a través de un bus I2C o SPI. El problema es que estos buses viajan por pistas de cobre expuestas en la PCB. Cualquiera con un osciloscopio o un programador de memorias de $5 dólares puede leer y modificar esos valores en texto plano.
Para microcontroladores de bajos recursos, implementar un algoritmo AES de 256 bits puede consumir demasiada memoria Flash y RAM. Aquí es donde brilla el Cifrado XOR (Exclusive OR). Es una técnica de "enmascaramiento" ultraligera que utiliza el operador bit a bit ^ de C. No es criptografía de grado militar, pero detendrá al 95% de los atacantes casuales.
El operador XOR (^) compara bit a bit. Si los bits son iguales, el resultado es 0. Si son diferentes, el resultado es 1. Lo verdaderamente poderoso es su propiedad matemática reversible: Si aplicas XOR a un dato con una llave secreta, obtienes basura ilegible. Si a esa basura le vuelves a aplicar XOR con la misma llave secreta, mágicamente recuperas el dato original.
En C, podemos tratar cualquier estructura de datos (como un struct de ventas) como un simple arreglo de bytes (uint8_t *). Al iterar sobre este arreglo y aplicar XOR byte por byte, transformamos la información directamente en su propia ubicación de memoria (In-Place), ahorrando RAM.
Ejercicio 1: Programa una función genérica en C que reciba un puntero a cualquier estructura de datos y aplique una máscara XOR iterativa. Úsala para cifrar y luego descifrar un registro de ventas.
#include <stdint.h>
#include <stdio.h>
// --- 1. CONFIGURACIÓN DE SEGURIDAD ---
// Llave de 8 bits. En un sistema real, no la dejes "hardcodeada" a la vista.
// Se puede derivar del número de serie único del STM32/ESP32.
#define LLAVE_SECRETA_XOR 0xA5
// --- 2. ESTRUCTURA DEL REGISTRO ---
typedef struct {
uint32_t id_despacho;
uint32_t total_litros_x100; // 2050 = 20.50 Litros
uint32_t total_cobrado_cent; // 50000 = $500.00 MXN
} RegistroVenta_t;
// --- 3. FUNCIÓN DE ENMASCARAMIENTO (Cifrado/Descifrado) ---
// Convierte el struct a un arreglo de bytes y aplica XOR a cada uno.
void procesar_mascara_xor(uint8_t *puntero_datos, uint16_t longitud_bytes) {
for (uint16_t i = 0; i < longitud_bytes; i++) {
puntero_datos[i] = puntero_datos[i] ^ LLAVE_SECRETA_XOR;
}
}
int main(void) {
// Generamos un registro simulado al final de un servicio
RegistroVenta_t venta_actual = {
.id_despacho = 9801,
.total_litros_x100 = 2050,
.total_cobrado_cent = 50000
};
printf("1. DATOS ORIGINALES EN RAM:\n");
printf(" ID: %u | Litros: %u | Cobro: %u\n\n",
venta_actual.id_despacho,
venta_actual.total_litros_x100,
venta_actual.total_cobrado_cent);
// Convertimos la dirección del struct a puntero de bytes
uint8_t *ptr_byte = (uint8_t *)&venta_actual;
uint16_t tamanio = sizeof(RegistroVenta_t);
// --- CIFRADO ---
procesar_mascara_xor(ptr_byte, tamanio);
printf("2. DATOS ENMASCARADOS (Listos para enviar a EEPROM I2C):\n");
// Al imprimir como enteros, parecerán números aleatorios sin sentido
printf(" ID: %u | Litros: %u | Cobro: %u\n\n",
venta_actual.id_despacho,
venta_actual.total_litros_x100,
venta_actual.total_cobrado_cent);
// --- DESCIFRADO ---
// Simulamos que leímos la memoria EEPROM y recuperamos la "basura".
// Aplicar la misma función exacta revierte el proceso.
procesar_mascara_xor(ptr_byte, tamanio);
printf("3. DATOS RECUPERADOS (Después de lectura):\n");
printf(" ID: %u | Litros: %u | Cobro: %u\n",
venta_actual.id_despacho,
venta_actual.total_litros_x100,
venta_actual.total_cobrado_cent);
return 0;
}
Objetivo del día: Protección Antifraude de Registros Financieros.
En el sector del Gas LP industrial, el fraude es un riesgo real. Si utilizas un chip de memoria EEPROM (como el 24LC256) soldado a tu placa PCB con KiCad para guardar el totalizador histórico de ventas o los parámetros de calibración del caudalímetro, esos datos son vulnerables. Un operario deshonesto podría conectar unas pinzas de prueba al chip I2C mientras el equipo está apagado y reescribir los valores directamente desde una laptop para cuadrar una caja con faltantes.
Al implementar el Cifrado XOR antes de la llamada de escritura al bus I2C/SPI, aseguras que los datos almacenados en el silicio sean incomprensibles. Si el operario lee la memoria, verá basura hexadecimal. Si intenta modificar el total de litros inyectando un número fijo, el microcontrolador al arrancar aplicará XOR sobre ese número inyectado, generando un valor corrupto que fallará las pruebas de CRC del POST (Día 56), bloqueando la máquina y evidenciando el intento de manipulación.
^) es la base matemática de las técnicas de ofuscación de datos.uint8_t * proporciona una capa de seguridad esencial y de muy bajo costo computacional.1. ¿Qué pasaría con los datos si por error defines tu `LLAVE_SECRETA_XOR` como `0x00` (Cero)?
Respuesta: El enmascaramiento fallará por completo. Según la tabla de verdad, cualquier bit procesado con XOR contra un 0 resulta en el mismo bit original (1 ^ 0 = 1, y 0 ^ 0 = 0). Los datos pasarán intactos a la memoria EEPROM, dejándolos en texto plano y vulnerables.
2. Si este método es tan rápido, ¿por qué no se usa en lugar del AES-256 para transferencias bancarias en internet?
Respuesta: Porque el cifrado XOR con llave estática es débil ante el "Criptoanálisis de Texto Plano Conocido". Si un atacante sabe exactamente cuántos litros despachaste (porque miró la pantalla LCD) y luego extrae la memoria EEPROM para ver el texto cifrado, puede aplicar la operación inversa (Dato ^ Cifrado = Llave) para descubrir tu llave secreta al instante y luego modificar lo que quiera. El XOR es ofuscación contra "curiosos", no criptografía de alta seguridad.