Inside Bitcoin

251        s->slice[3] = L20 ^ L22;
252        s->slice[2] = L25 ^ L29;
253        s->slice[1] = ~(L13 ^ L27);
254        s->slice[0] = ~(L6 ^ L23);
255    }
256}
257
258#define BIT_RANGE(from,to) (((1 << ((to) - (from))) - 1) << (from))
259
260#define BIT_RANGE_LEFT(x,from,to,shift) (((x) & BIT_RANGE((from), (to))) << (shift))
261#define BIT_RANGE_RIGHT(x,from,to,shift) (((x) & BIT_RANGE((from), (to))) >> (shift))
262
263static void ShiftRows(AES_state* s) {
264    int i;
265    for (i = 0; i < 8; i++) {
266        uint16_t v = s->slice[i];
267        s->slice[i] =
268            (v & BIT_RANGE(0, 4)) |
269            BIT_RANGE_LEFT(v, 4, 5, 3) | BIT_RANGE_RIGHT(v, 5, 8, 1) |
270            BIT_RANGE_LEFT(v, 8, 10, 2) | BIT_RANGE_RIGHT(v, 10, 12, 2) |
271            BIT_RANGE_LEFT(v, 12, 15, 1) | BIT_RANGE_RIGHT(v, 15, 16, 3);
272    }
273}
274
275static void InvShiftRows(AES_state* s) {
276    int i;
277    for (i = 0; i < 8; i++) {
278        uint16_t v = s->slice[i];
279        s->slice[i] =
280            (v & BIT_RANGE(0, 4)) |
281            BIT_RANGE_LEFT(v, 4, 7, 1) | BIT_RANGE_RIGHT(v, 7, 8, 3) |
282            BIT_RANGE_LEFT(v, 8, 10, 2) | BIT_RANGE_RIGHT(v, 10, 12, 2) |
283            BIT_RANGE_LEFT(v, 12, 13, 3) | BIT_RANGE_RIGHT(v, 13, 16, 1);
284    }
285}
286
287#define ROT(x,b) (((x) >> ((b) * 4)) | ((x) << ((4-(b)) * 4)))
288
289static void MixColumns(AES_state* s, int inv) {
290    /* The MixColumns transform treats the bytes of the columns of the state as
291     * coefficients of a 3rd degree polynomial over GF(2^8) and multiplies them
292     * by the fixed polynomial a(x) = {03}x^3 + {01}x^2 + {01}x + {02}, modulo
293     * x^4 + {01}.
294     *
295     * In the inverse transform, we multiply by the inverse of a(x),
296     * a^-1(x) = {0b}x^3 + {0d}x^2 + {09}x + {0e}. This is equal to
297     * a(x) * ({04}x^2 + {05}), so we can reuse the forward transform's code
298     * (found in OpenSSL's bsaes-x86_64.pl, attributed to Jussi Kivilinna)
299     *
300     * In the bitsliced representation, a multiplication of every column by x
301     * mod x^4 + 1 is simply a right rotation.
302     */
303
304    /* Shared for both directions is a multiplication by a(x), which can be
305     * rewritten as (x^3 + x^2 + x) + {02}*(x^3 + {01}).
306     *
307     * First compute s into the s? variables, (x^3 + {01}) * s into the s?_01
308     * variables and (x^3 + x^2 + x)*s into the s?_123 variables.
309     */
310    uint16_t s0 = s->slice[0], s1 = s->slice[1], s2 = s->slice[2], s3 = s->slice[3];
311    uint16_t s4 = s->slice[4], s5 = s->slice[5], s6 = s->slice[6], s7 = s->slice[7];
312    uint16_t s0_01 = s0 ^ ROT(s0, 1), s0_123 = ROT(s0_01, 1) ^ ROT(s0, 3);
313    uint16_t s1_01 = s1 ^ ROT(s1, 1), s1_123 = ROT(s1_01, 1) ^ ROT(s1, 3);
314    uint16_t s2_01 = s2 ^ ROT(s2, 1), s2_123 = ROT(s2_01, 1) ^ ROT(s2, 3);
315    uint16_t s3_01 = s3 ^ ROT(s3, 1), s3_123 = ROT(s3_01, 1) ^ ROT(s3, 3);
316    uint16_t s4_01 = s4 ^ ROT(s4, 1), s4_123 = ROT(s4_01, 1) ^ ROT(s4, 3);
317    uint16_t s5_01 = s5 ^ ROT(s5, 1), s5_123 = ROT(s5_01, 1) ^ ROT(s5, 3);
318    uint16_t s6_01 = s6 ^ ROT(s6, 1), s6_123 = ROT(s6_01, 1) ^ ROT(s6, 3);
319    uint16_t s7_01 = s7 ^ ROT(s7, 1), s7_123 = ROT(s7_01, 1) ^ ROT(s7, 3);
320    /* Now compute s = s?_123 + {02} * s?_01. */
321    s->slice[0] = s7_01 ^ s0_123;
322    s->slice[1] = s7_01 ^ s0_01 ^ s1_123;
323    s->slice[2] = s1_01 ^ s2_123;
324    s->slice[3] = s7_01 ^ s2_01 ^ s3_123;
325    s->slice[4] = s7_01 ^ s3_01 ^ s4_123;
326    s->slice[5] = s4_01 ^ s5_123;
327    s->slice[6] = s5_01 ^ s6_123;
328    s->slice[7] = s6_01 ^ s7_123;
329    if (inv) {
330        /* In the reverse direction, we further need to multiply by
331         * {04}x^2 + {05}, which can be written as {04} * (x^2 + {01}) + {01}.
332         *
333         * First compute (x^2 + {01}) * s into the t?_02 variables: */
334        uint16_t t0_02 = s->slice[0] ^ ROT(s->slice[0], 2);
335        uint16_t t1_02 = s->slice[1] ^ ROT(s->slice[1], 2);
336        uint16_t t2_02 = s->slice[2] ^ ROT(s->slice[2], 2);
337        uint16_t t3_02 = s->slice[3] ^ ROT(s->slice[3], 2);
338        uint16_t t4_02 = s->slice[4] ^ ROT(s->slice[4], 2);
339        uint16_t t5_02 = s->slice[5] ^ ROT(s->slice[5], 2);
340        uint16_t t6_02 = s->slice[6] ^ ROT(s->slice[6], 2);
341        uint16_t t7_02 = s->slice[7] ^ ROT(s->slice[7], 2);
342        /* And then update s += {04} * t?_02 */
343        s->slice[0] ^= t6_02;
344        s->slice[1] ^= t6_02 ^ t7_02;
345        s->slice[2] ^= t0_02 ^ t7_02;
346        s->slice[3] ^= t1_02 ^ t6_02;
347        s->slice[4] ^= t2_02 ^ t6_02 ^ t7_02;
348        s->slice[5] ^= t3_02 ^ t7_02;
349        s->slice[6] ^= t4_02;
350        s->slice[7] ^= t5_02;
351    }
352}
353
354static void AddRoundKey(AES_state* s, const AES_state* round) {
355    int b;
356    for (b = 0; b < 8; b++) {
357        s->slice[b] ^= round->slice[b];
358    }
359}
360
361/** column_0(s) = column_c(a) */
362static void GetOneColumn(AES_state* s, const AES_state* a, int c) {
363    int b;
364    for (b = 0; b < 8; b++) {
365        s->slice[b] = (a->slice[b] >> c) & 0x1111;
366    }
367}
368
369/** column_c1(r) |= (column_0(s) ^= column_c2(a)) */
370static void KeySetupColumnMix(AES_state* s, AES_state* r, const AES_state* a, int c1, int c2) {
371    int b;
372    for (b = 0; b < 8; b++) {
373        r->slice[b] |= ((s->slice[b] ^= ((a->slice[b] >> c2) & 0x1111)) & 0x1111) << c1;
374    }
375}
376
377/** Rotate the rows in s one position upwards, and xor in r */
378static void KeySetupTransform(AES_state* s, const AES_state* r) {
379    int b;
380    for (b = 0; b < 8; b++) {
381        s->slice[b] = ((s->slice[b] >> 4) | (s->slice[b] << 12)) ^ r->slice[b];
382    }
383}
384
385/* Multiply the cells in s by x, as polynomials over GF(2) mod x^8 + x^4 + x^3 + x + 1 */
386static void MultX(AES_state* s) {
387    uint16_t top = s->slice[7];
388    s->slice[7] = s->slice[6];
389    s->slice[6] = s->slice[5];
390    s->slice[5] = s->slice[4];
391    s->slice[4] = s->slice[3] ^ top;
392    s->slice[3] = s->slice[2] ^ top;
393    s->slice[2] = s->slice[1];
394    s->slice[1] = s->slice[0] ^ top;
395    s->slice[0] = top;
396}
397
398/** Expand the cipher key into the key schedule.
399 *
400 *  state must be a pointer to an array of size nrounds + 1.
401 *  key must be a pointer to 4 * nkeywords bytes.
402 *
403 *  AES128 uses nkeywords = 4, nrounds = 10
404 *  AES192 uses nkeywords = 6, nrounds = 12
405 *  AES256 uses nkeywords = 8, nrounds = 14
406 */
407static void AES_setup(AES_state* rounds, const uint8_t* key, int nkeywords, int nrounds)
408{
409    int i;
410
411    /* The one-byte round constant */
412    AES_state rcon = {{1,0,0,0,0,0,0,0}};
413    /* The number of the word being generated, modulo nkeywords */
414    int pos = 0;
415    /* The column representing the word currently being processed */
416    AES_state column;
417
418    for (i = 0; i < nrounds + 1; i++) {
419        int b;
420        for (b = 0; b < 8; b++) {
421            rounds[i].slice[b] = 0;
422        }
423    }
424
425    /* The first nkeywords round columns are just taken from the key directly. */
426    for (i = 0; i < nkeywords; i++) {
427        int r;
428        for (r = 0; r < 4; r++) {
429            LoadByte(&rounds[i >> 2], *(key++), r, i & 3);
430        }
431    }
432
433    GetOneColumn(&column, &rounds[(nkeywords - 1) >> 2], (nkeywords - 1) & 3);
434
435    for (i = nkeywords; i < 4 * (nrounds + 1); i++) {
436        /* Transform column */
437        if (pos == 0) {
438            SubBytes(&column, 0);
439            KeySetupTransform(&column, &rcon);
440            MultX(&rcon);
441        } else if (nkeywords > 6 && pos == 4) {
442            SubBytes(&column, 0);
443        }
444        if (++pos == nkeywords) pos = 0;
445        KeySetupColumnMix(&column, &rounds[i >> 2], &rounds[(i - nkeywords) >> 2], i & 3, (i - nkeywords) & 3);
446    }
447}
448
449static void AES_encrypt(const AES_state* rounds, int nrounds, unsigned char* cipher16, const unsigned char* plain16) {
450    AES_state s = {{0}};
451    int round;
452
453    LoadBytes(&s, plain16);
454    AddRoundKey(&s, rounds++);
455
456    for (round = 1; round < nrounds; round++) {
457        SubBytes(&s, 0);
458        ShiftRows(&s);
459        MixColumns(&s, 0);
460        AddRoundKey(&s, rounds++);
461    }
462
463    SubBytes(&s, 0);
464    ShiftRows(&s);
465    AddRoundKey(&s, rounds);
466
467    SaveBytes(cipher16, &s);
468}
469
470static void AES_decrypt(const AES_state* rounds, int nrounds, unsigned char* plain16, const unsigned char* cipher16) {
471    /* Most AES decryption implementations use the alternate scheme
472     * (the Equivalent Inverse Cipher), which allows for more code reuse between
473     * the encryption and decryption code, but requires separate setup for both.
474     */
475    AES_state s = {{0}};
476    int round;
477
478    rounds += nrounds;
479
480    LoadBytes(&s, cipher16);
481    AddRoundKey(&s, rounds--);
482
483    for (round = 1; round < nrounds; round++) {
484        InvShiftRows(&s);
485        SubBytes(&s, 1);
486        AddRoundKey(&s, rounds--);
487        MixColumns(&s, 1);
488    }
489
490    InvShiftRows(&s);
491    SubBytes(&s, 1);
492    AddRoundKey(&s, rounds);
493
494    SaveBytes(plain16, &s);
495}
496
497void AES128_init(AES128_ctx* ctx, const unsigned char* key16) {
498    AES_setup(ctx->rk, key16, 4, 10);
499}
500