Big Picture
If you think of the 16 words arranged this way
1
2
3
4
5
6
7
8
9
10
11
12 13 14 15
Then loading into SSE registers
a = [ 0 1 2 3]
b = [ 4 5 6 7]
C = [ 8 9 10 11]
d = [ 12 13 14 15 ]
and using SSE code to do the mix operations mixes four columns at once. This
handles the first four mix calls.
The next four mix calls want to mix these columns instead
a = [ 0 1 2 3]
b = [ 5 6 7 4)
C = [ (10 11 8 9]
d = [15 12 13 14)
But note that these SSE variables are just shuffled versions of the prior ones.
One interface you could use might look like this:
static void one_round(uint32_t t[16]) {
m128i a = (mm_loadu_sil28((___m128i*)&t[0])
;
m128i b = mm_loadu_sil28((___m128i &t[4]);
code for mix
a
= _mm_shuffle_epi32(a, control_byte)
// code for mix
a
=
mm shuffle_epi32(a inverse_control_byte)
mm _storeu_sil28((_m128i*)&t[0], a)
mm_storeu_sil28((___m128i*)&t[4],b);
Testing
As with all cryptography, validating an implementation is a slog. If you got your
first P152 to work correctly, you can use it to slowly go through each step of that
algorithm to make sure each step of this one works as expected.
For example, the following code would test whether one_round was working
correctly. You could modify your code from your first P152 to run the same test,
and if they produce the same output, then it's looking good. If they don't, then
you have to run tests at a lower level.
unsigned char buf [64];
for (int i=0; i<64; i++)
buf[i] = i;
one round ( (uint32_t *)buf) ;
for (int i=0; i<64; i++)
printf ("802x", buf[i]);

#include &lt;stdio.h&gt; #include &lt;stdint.h&gt; #include &lt;s...

#include <stdio.h> #include <stdint.h> #include <s...