x |= MAC_computed[i] − MAC_computed[i];
Shouldn't one side or the other (of the minus operation) be MAC_received[i]?
(Lesson learned: LaTex is not the best language to write code in.)
x |= MAC received[i] − MAC computed[i];
x |= (MAC received[i] != MAC computed[i]);
x |= (MAC received[i] ^ MAC computed[i]);
* Possible break: If we have a separate sign bit, then we might have 0 and -0, which would subtract to give 0. Don't know of any machine/compiler that does that though.
Relevant portion of assembly (no optimizations):
cmpl $1, -20(%rbp)
movzbl %al, %eax
orl %eax, -4(%rbp)
Most other architectures have one of:
1) condition codes that you can use to predicate an "or $r1, $r1, 1" (e.g., ARM)
2) compare instructions that put a 1 or a 0 in a result register, which can be directly ORed in. (e.g., MIPS)
Of course, that code only works if you are either not writing in C89 or if your compiler and ISA conspire to always return exactly one from true boolean expressions. It is my understanding that the C89 standard only requires "nonzero," so you might need "a |= (b != c) ? 1 : 0;*" instead.
YMMV depending on compiler and architecture, but the 2 or 3 platforms I tried without passing any opti flags were branchless.
But that doesn't matter, because over switched "local" networks (read: from one end of a data center to another), the thresholds are in nanoseconds; everything is timeable. Attackers will spend the $30 to get a machine in the same hosting center as you as soon as the other attacks get less trivial.