O mascaramento é eficaz para impedir ataques de canal lateral?

Estou trabalhando com algum código de criptografia de chave pública bigint. É seguro usar máscara de bits para garantir que o tempo de cálculo e os endereços de memória acessados sejam independentes dos valores dos dados?

Essa técnica é vulnerável a ataques de canal lateral com base no tempo das instruções, na potência, nas emissões de RF ou em outras coisas que eu desconheço? (Para referência, conheço técnicas como ocultação de RSA, escada EC Montgomery, descarga de cache e outras coisas.)

Exemplo de código direto (C / C ++):

uint a = (...), b = (...);
if (a < b)
    a += b;

Agora traduzido para usar mascaramento de tempo constante:

uint a = (...), b = (...);
uint mask = -(uint)(a < b);
a = ((a + b) & mask) | (a & ~mask);

Observe quea < b é 0 ou 1 e a máscara é 0x00000000 ou 0xFFFFFFFF.

Da mesma forma, para uma operação de alto nível (C ++):

Integer x = (...);
if (x.isFoo())
    x.doBar();

A tradução a seguir é aceitável e segura?

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