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