¿Es efectivo el enmascaramiento para frustrar los ataques de canal lateral?
Estoy trabajando con un código de criptografía de clave pública bigint. ¿Es seguro utilizar el enmascaramiento bit a bit para garantizar que el tiempo de cálculo y las direcciones de memoria a las que se accede sean independientes de los valores de los datos?
¿Es esta técnica vulnerable a los ataques de canal lateral en función del tiempo de instrucción, la potencia, las emisiones de RF u otras cosas que desconozco? (Como referencia, conozco técnicas como el cegamiento de RSA, la escalera EC Montgomery, el vaciado de caché y demás).
Ejemplo de código directo (C / C ++):
uint a = (...), b = (...);
if (a < b)
a += b;
Ahora traducido para usar el enmascaramiento de tiempo constante:
uint a = (...), b = (...);
uint mask = -(uint)(a < b);
a = ((a + b) & mask) | (a & ~mask);
Tenga en cuenta quea < b
es 0 o 1, y la máscara es 0x00000000 o 0xFFFFFFFF.
Del mismo modo, para una operación de alto nivel (C ++):
Integer x = (...);
if (x.isFoo())
x.doBar();
¿Es la siguiente una traducción segura aceptable?
Integer x = (...);
uint mask = -(uint)x.isFoo(); // Assume this is constant-time
Integer y(x); // Copy constructor
y.doBar(); // Assume this is constant-time
x.replace(y, mask); // Assume this uses masking