← Back to branch summary

~zooko/cryptopp/trunk

« back to all changes in this revision

Viewing changes to whrlpool.cpp

  • Committer: weidai
  • Date: 2010-06-18 01:52:34 UTC
  • Revision ID: svn-v4:57ff6487-cd31-0410-9ec3-f628ee90f5f0:trunk/c5:485
avoid SecBlock of arrays

Show diffs side-by-side

added added

removed removed

Lines of Context:
whrlpool.cpp
1
 
// Whrlpool.cpp - modified by Kevin Springle from
 
1
// whrlpool.cpp - originally modified by Kevin Springle from
2
2
// Paulo Barreto and Vincent Rijmen's public domain code, whirlpool.c.
3
 
// Any modifications are placed in the public domain
4
 
// Updated to Whirlpool version 3.0 by Wei Dai
 
3
// Updated to Whirlpool version 3.0, optimized and SSE version added by Wei Dai
 
4
// All modifications are placed in the public domain
5
5
 
6
6
// This is the original introductory comment:
7
7
 
64
64
 */
65
65
 
66
66
#include "pch.h"
67
 
 
68
 
#ifdef WORD64_AVAILABLE
69
 
 
70
67
#include "whrlpool.h"
71
68
#include "misc.h"
 
69
#include "cpu.h"
72
70
 
73
71
NAMESPACE_BEGIN(CryptoPP)
74
72
 
94
92
        m_data[m_data.size()-2] = GetBitCountHi();
95
93
        m_data[m_data.size()-1] = GetBitCountLo();
96
94
 
97
 
        Transform(m_digest, m_data);
98
 
        CorrectEndianess(m_digest, m_digest, DigestSize());
99
 
        memcpy(hash, m_digest, size);
 
95
        Transform(m_state, m_data);
 
96
        CorrectEndianess(m_state, m_state, DigestSize());
 
97
        memcpy(hash, m_state, size);
100
98
 
101
99
        Restart();              // reinit for next use
102
100
}
113
111
 * employed).
114
112
 */
115
113
 
116
 
static const word64 C0[256] = {
 
114
#if CRYPTOPP_BOOL_SSE2_ASM_AVAILABLE
 
115
CRYPTOPP_ALIGN_DATA(16) static const word64 Whirlpool_C[4*256+R] CRYPTOPP_SECTION_ALIGN16 = {
 
116
#else
 
117
static const word64 Whirlpool_C[4*256+R] = {
 
118
#endif
117
119
    W64LIT(0x18186018c07830d8), W64LIT(0x23238c2305af4626), W64LIT(0xc6c63fc67ef991b8), W64LIT(0xe8e887e8136fcdfb),
118
120
    W64LIT(0x878726874ca113cb), W64LIT(0xb8b8dab8a9626d11), W64LIT(0x0101040108050209), W64LIT(0x4f4f214f426e9e0d),
119
121
    W64LIT(0x3636d836adee6c9b), W64LIT(0xa6a6a2a6590451ff), W64LIT(0xd2d26fd2debdb90c), W64LIT(0xf5f5f3f5fb06f70e),
177
179
    W64LIT(0x16165816b04e2ca6), W64LIT(0x3a3ae83acdd274f7), W64LIT(0x6969b9696fd0d206), W64LIT(0x09092409482d1241),
178
180
    W64LIT(0x7070dd70a7ade0d7), W64LIT(0xb6b6e2b6d954716f), W64LIT(0xd0d067d0ceb7bd1e), W64LIT(0xeded93ed3b7ec7d6),
179
181
    W64LIT(0xcccc17cc2edb85e2), W64LIT(0x424215422a578468), W64LIT(0x98985a98b4c22d2c), W64LIT(0xa4a4aaa4490e55ed),
180
 
    W64LIT(0x2828a0285d885075), W64LIT(0x5c5c6d5cda31b886), W64LIT(0xf8f8c7f8933fed6b), W64LIT(0x8686228644a411c2),
181
 
};
 
182
        W64LIT(0x2828a0285d885075), W64LIT(0x5c5c6d5cda31b886), W64LIT(0xf8f8c7f8933fed6b), W64LIT(0x8686228644a411c2),
182
183
 
183
 
static const word64 C1[256] = {
184
 
    W64LIT(0xd818186018c07830), W64LIT(0x2623238c2305af46), W64LIT(0xb8c6c63fc67ef991), W64LIT(0xfbe8e887e8136fcd),
 
184
        W64LIT(0xd818186018c07830), W64LIT(0x2623238c2305af46), W64LIT(0xb8c6c63fc67ef991), W64LIT(0xfbe8e887e8136fcd),
185
185
    W64LIT(0xcb878726874ca113), W64LIT(0x11b8b8dab8a9626d), W64LIT(0x0901010401080502), W64LIT(0x0d4f4f214f426e9e),
186
186
    W64LIT(0x9b3636d836adee6c), W64LIT(0xffa6a6a2a6590451), W64LIT(0x0cd2d26fd2debdb9), W64LIT(0x0ef5f5f3f5fb06f7),
187
187
    W64LIT(0x967979f979ef80f2), W64LIT(0x306f6fa16f5fcede), W64LIT(0x6d91917e91fcef3f), W64LIT(0xf852525552aa07a4),
245
245
    W64LIT(0xd77070dd70a7ade0), W64LIT(0x6fb6b6e2b6d95471), W64LIT(0x1ed0d067d0ceb7bd), W64LIT(0xd6eded93ed3b7ec7),
246
246
    W64LIT(0xe2cccc17cc2edb85), W64LIT(0x68424215422a5784), W64LIT(0x2c98985a98b4c22d), W64LIT(0xeda4a4aaa4490e55),
247
247
    W64LIT(0x752828a0285d8850), W64LIT(0x865c5c6d5cda31b8), W64LIT(0x6bf8f8c7f8933fed), W64LIT(0xc28686228644a411),
248
 
};
249
248
 
250
 
static const word64 C2[256] = {
251
 
    W64LIT(0x30d818186018c078), W64LIT(0x462623238c2305af), W64LIT(0x91b8c6c63fc67ef9), W64LIT(0xcdfbe8e887e8136f),
 
249
        W64LIT(0x30d818186018c078), W64LIT(0x462623238c2305af), W64LIT(0x91b8c6c63fc67ef9), W64LIT(0xcdfbe8e887e8136f),
252
250
    W64LIT(0x13cb878726874ca1), W64LIT(0x6d11b8b8dab8a962), W64LIT(0x0209010104010805), W64LIT(0x9e0d4f4f214f426e),
253
251
    W64LIT(0x6c9b3636d836adee), W64LIT(0x51ffa6a6a2a65904), W64LIT(0xb90cd2d26fd2debd), W64LIT(0xf70ef5f5f3f5fb06),
254
252
    W64LIT(0xf2967979f979ef80), W64LIT(0xde306f6fa16f5fce), W64LIT(0x3f6d91917e91fcef), W64LIT(0xa4f852525552aa07),
312
310
    W64LIT(0xe0d77070dd70a7ad), W64LIT(0x716fb6b6e2b6d954), W64LIT(0xbd1ed0d067d0ceb7), W64LIT(0xc7d6eded93ed3b7e),
313
311
    W64LIT(0x85e2cccc17cc2edb), W64LIT(0x8468424215422a57), W64LIT(0x2d2c98985a98b4c2), W64LIT(0x55eda4a4aaa4490e),
314
312
    W64LIT(0x50752828a0285d88), W64LIT(0xb8865c5c6d5cda31), W64LIT(0xed6bf8f8c7f8933f), W64LIT(0x11c28686228644a4),
315
 
};
316
313
 
317
 
static const word64 C3[256] = {
318
 
    W64LIT(0x7830d818186018c0), W64LIT(0xaf462623238c2305), W64LIT(0xf991b8c6c63fc67e), W64LIT(0x6fcdfbe8e887e813),
 
314
        W64LIT(0x7830d818186018c0), W64LIT(0xaf462623238c2305), W64LIT(0xf991b8c6c63fc67e), W64LIT(0x6fcdfbe8e887e813),
319
315
    W64LIT(0xa113cb878726874c), W64LIT(0x626d11b8b8dab8a9), W64LIT(0x0502090101040108), W64LIT(0x6e9e0d4f4f214f42),
320
316
    W64LIT(0xee6c9b3636d836ad), W64LIT(0x0451ffa6a6a2a659), W64LIT(0xbdb90cd2d26fd2de), W64LIT(0x06f70ef5f5f3f5fb),
321
317
    W64LIT(0x80f2967979f979ef), W64LIT(0xcede306f6fa16f5f), W64LIT(0xef3f6d91917e91fc), W64LIT(0x07a4f852525552aa),
379
375
    W64LIT(0xade0d77070dd70a7), W64LIT(0x54716fb6b6e2b6d9), W64LIT(0xb7bd1ed0d067d0ce), W64LIT(0x7ec7d6eded93ed3b),
380
376
    W64LIT(0xdb85e2cccc17cc2e), W64LIT(0x578468424215422a), W64LIT(0xc22d2c98985a98b4), W64LIT(0x0e55eda4a4aaa449),
381
377
    W64LIT(0x8850752828a0285d), W64LIT(0x31b8865c5c6d5cda), W64LIT(0x3fed6bf8f8c7f893), W64LIT(0xa411c28686228644),
382
 
};
383
378
 
384
 
static const word64 rc[R] = {
385
379
        W64LIT(0x1823c6e887b8014f),
386
380
        W64LIT(0x36a6d2f5796f9152),
387
381
        W64LIT(0x60bc9b8ea30c7b35),
397
391
// Whirlpool basic transformation. Transforms state based on block.
398
392
void Whirlpool::Transform(word64 *digest, const word64 *block)
399
393
{
 
394
#if CRYPTOPP_BOOL_SSE2_ASM_AVAILABLE
 
395
        if (HasISSE())
 
396
        {
 
397
                // MMX version has the same structure as C version below
 
398
#ifdef __GNUC__
 
399
        #if CRYPTOPP_BOOL_X64
 
400
                word64 workspace[16];
 
401
        #endif
 
402
        __asm__ __volatile__
 
403
        (
 
404
                ".intel_syntax noprefix;"
 
405
                AS_PUSH_IF86(   bx)
 
406
                AS2(    mov             AS_REG_6, WORD_REG(ax))
 
407
#else
 
408
        #if _MSC_VER < 1300
 
409
                AS_PUSH_IF86(   bx)
 
410
        #endif
 
411
                AS2(    lea             AS_REG_6, [Whirlpool_C])
 
412
                AS2(    mov             WORD_REG(cx), digest)
 
413
                AS2(    mov             WORD_REG(dx), block)
 
414
#endif
 
415
#if CRYPTOPP_BOOL_X86
 
416
                AS2(    mov             eax, esp)
 
417
                AS2(    and             esp, -16)
 
418
                AS2(    sub             esp, 16*8)
 
419
                AS1(    push    eax)
 
420
        #define SSE2_workspace  esp+WORD_SZ
 
421
#else
 
422
        #define SSE2_workspace  %3
 
423
#endif
 
424
                AS2(    xor             esi, esi)
 
425
                ASL(0)
 
426
                AS2(    movq    mm0, [WORD_REG(cx)+8*WORD_REG(si)])
 
427
                AS2(    movq    [SSE2_workspace+8*WORD_REG(si)], mm0)           // k
 
428
                AS2(    pxor    mm0, [WORD_REG(dx)+8*WORD_REG(si)])
 
429
                AS2(    movq    [SSE2_workspace+64+8*WORD_REG(si)], mm0)        // s
 
430
                AS2(    movq    [WORD_REG(cx)+8*WORD_REG(si)], mm0)
 
431
                AS1(    inc             WORD_REG(si))
 
432
                AS2(    cmp             WORD_REG(si), 8)
 
433
                ASJ(    jne,    0, b)
 
434
 
 
435
                AS2(    xor             esi, esi)
 
436
                ASL(1)
 
437
 
 
438
#define KSL0(a, b)      AS2(movq        mm##a, b)
 
439
#define KSL1(a, b)      AS2(pxor        mm##a, b)
 
440
 
 
441
#define KSL(op, i, a, b, c, d)  \
 
442
        AS2(mov         eax, [SSE2_workspace+8*i])\
 
443
        AS2(movzx       edi, al)\
 
444
        KSL##op(a, [AS_REG_6+3*2048+8*WORD_REG(di)])\
 
445
        AS2(movzx       edi, ah)\
 
446
        KSL##op(b, [AS_REG_6+2*2048+8*WORD_REG(di)])\
 
447
        AS2(shr         eax, 16)\
 
448
        AS2(movzx       edi, al)\
 
449
        AS2(shr         eax, 8)\
 
450
        KSL##op(c, [AS_REG_6+1*2048+8*WORD_REG(di)])\
 
451
        KSL##op(d, [AS_REG_6+0*2048+8*WORD_REG(ax)])
 
452
 
 
453
#define KSH0(a, b)      \
 
454
        ASS(pshufw      mm##a, mm##a, 1, 0, 3, 2)\
 
455
        AS2(pxor        mm##a, b)
 
456
#define KSH1(a, b)      \
 
457
        AS2(pxor        mm##a, b)
 
458
#define KSH2(a, b)      \
 
459
        AS2(pxor        mm##a, b)\
 
460
        AS2(movq        [SSE2_workspace+8*a], mm##a)
 
461
 
 
462
#define KSH(op, i, a, b, c, d)  \
 
463
        AS2(mov         eax, [SSE2_workspace+8*((i+4)-8*((i+4)/8))+4])\
 
464
        AS2(movzx       edi, al)\
 
465
        KSH##op(a, [AS_REG_6+3*2048+8*WORD_REG(di)])\
 
466
        AS2(movzx       edi, ah)\
 
467
        KSH##op(b, [AS_REG_6+2*2048+8*WORD_REG(di)])\
 
468
        AS2(shr         eax, 16)\
 
469
        AS2(movzx       edi, al)\
 
470
        AS2(shr         eax, 8)\
 
471
        KSH##op(c, [AS_REG_6+1*2048+8*WORD_REG(di)])\
 
472
        KSH##op(d, [AS_REG_6+0*2048+8*WORD_REG(ax)])
 
473
 
 
474
#define TSL(op, i, a, b, c, d)  \
 
475
        AS2(mov         eax, [SSE2_workspace+64+8*i])\
 
476
        AS2(movzx       edi, al)\
 
477
        KSL##op(a, [AS_REG_6+3*2048+8*WORD_REG(di)])\
 
478
        AS2(movzx       edi, ah)\
 
479
        KSL##op(b, [AS_REG_6+2*2048+8*WORD_REG(di)])\
 
480
        AS2(shr         eax, 16)\
 
481
        AS2(movzx       edi, al)\
 
482
        AS2(shr         eax, 8)\
 
483
        KSL##op(c, [AS_REG_6+1*2048+8*WORD_REG(di)])\
 
484
        KSL##op(d, [AS_REG_6+0*2048+8*WORD_REG(ax)])
 
485
 
 
486
#define TSH0(a, b)      \
 
487
        ASS(pshufw      mm##a, mm##a, 1, 0, 3, 2)\
 
488
        AS2(pxor        mm##a, [SSE2_workspace+8*a])\
 
489
        AS2(pxor        mm##a, b)
 
490
#define TSH1(a, b)      \
 
491
        AS2(pxor        mm##a, b)
 
492
#define TSH2(a, b)      \
 
493
        AS2(pxor        mm##a, b)\
 
494
        AS2(movq        [SSE2_workspace+64+8*a], mm##a)
 
495
#define TSH3(a, b)      \
 
496
        AS2(pxor        mm##a, b)\
 
497
        AS2(pxor        mm##a, [WORD_REG(cx)+8*a])\
 
498
        AS2(movq        [WORD_REG(cx)+8*a], mm##a)
 
499
 
 
500
#define TSH(op, i, a, b, c, d)  \
 
501
        AS2(mov         eax, [SSE2_workspace+64+8*((i+4)-8*((i+4)/8))+4])\
 
502
        AS2(movzx       edi, al)\
 
503
        TSH##op(a, [AS_REG_6+3*2048+8*WORD_REG(di)])\
 
504
        AS2(movzx       edi, ah)\
 
505
        TSH##op(b, [AS_REG_6+2*2048+8*WORD_REG(di)])\
 
506
        AS2(shr         eax, 16)\
 
507
        AS2(movzx       edi, al)\
 
508
        AS2(shr         eax, 8)\
 
509
        TSH##op(c, [AS_REG_6+1*2048+8*WORD_REG(di)])\
 
510
        TSH##op(d, [AS_REG_6+0*2048+8*WORD_REG(ax)])
 
511
 
 
512
                KSL(0, 4, 3, 2, 1, 0)
 
513
                KSL(0, 0, 7, 6, 5, 4)
 
514
                KSL(1, 1, 0, 7, 6, 5)
 
515
                KSL(1, 2, 1, 0, 7, 6)
 
516
                KSL(1, 3, 2, 1, 0, 7)
 
517
                KSL(1, 5, 4, 3, 2, 1)
 
518
                KSL(1, 6, 5, 4, 3, 2)
 
519
                KSL(1, 7, 6, 5, 4, 3)
 
520
                KSH(0, 0, 7, 6, 5, 4)
 
521
                KSH(0, 4, 3, 2, 1, 0)
 
522
                KSH(1, 1, 0, 7, 6, 5)
 
523
                KSH(1, 2, 1, 0, 7, 6)
 
524
                KSH(1, 5, 4, 3, 2, 1)
 
525
                KSH(1, 6, 5, 4, 3, 2)
 
526
                KSH(2, 3, 2, 1, 0, 7)
 
527
                KSH(2, 7, 6, 5, 4, 3)
 
528
 
 
529
                AS2(    pxor    mm0, [AS_REG_6 + 8*1024 + WORD_REG(si)*8])
 
530
                AS2(    movq    [SSE2_workspace], mm0)
 
531
 
 
532
                TSL(0, 4, 3, 2, 1, 0)
 
533
                TSL(0, 0, 7, 6, 5, 4)
 
534
                TSL(1, 1, 0, 7, 6, 5)
 
535
                TSL(1, 2, 1, 0, 7, 6)
 
536
                TSL(1, 3, 2, 1, 0, 7)
 
537
                TSL(1, 5, 4, 3, 2, 1)
 
538
                TSL(1, 6, 5, 4, 3, 2)
 
539
                TSL(1, 7, 6, 5, 4, 3)
 
540
                TSH(0, 0, 7, 6, 5, 4)
 
541
                TSH(0, 4, 3, 2, 1, 0)
 
542
                TSH(1, 1, 0, 7, 6, 5)
 
543
                TSH(1, 2, 1, 0, 7, 6)
 
544
                TSH(1, 5, 4, 3, 2, 1)
 
545
                TSH(1, 6, 5, 4, 3, 2)
 
546
 
 
547
                AS1(    inc             WORD_REG(si))
 
548
                AS2(    cmp             WORD_REG(si), 10)
 
549
                ASJ(    je,             2, f)
 
550
 
 
551
                TSH(2, 3, 2, 1, 0, 7)
 
552
                TSH(2, 7, 6, 5, 4, 3)
 
553
 
 
554
                ASJ(    jmp,    1, b)
 
555
                ASL(2)
 
556
 
 
557
                TSH(3, 3, 2, 1, 0, 7)
 
558
                TSH(3, 7, 6, 5, 4, 3)
 
559
 
 
560
#undef KSL
 
561
#undef KSH
 
562
#undef TSL
 
563
#undef TSH
 
564
 
 
565
                AS_POP_IF86(    sp)
 
566
                AS1(    emms)
 
567
 
 
568
#if defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER < 1300)
 
569
                AS_POP_IF86(    bx)
 
570
#endif
 
571
#ifdef __GNUC__
 
572
                ".att_syntax prefix;"
 
573
                        :
 
574
                        : "a" (Whirlpool_C), "c" (digest), "d" (block)
 
575
        #if CRYPTOPP_BOOL_X64
 
576
                        , "r" (workspace)
 
577
        #endif
 
578
                        : "%esi", "%edi", "memory", "cc"
 
579
        #if CRYPTOPP_BOOL_X64
 
580
                        , "%r9"
 
581
        #endif
 
582
                );
 
583
#endif
 
584
        }
 
585
        else
 
586
#endif          // #ifdef CRYPTOPP_X86_ASM_AVAILABLE
 
587
        {
400
588
        word64 s[8];    // the cipher state
401
589
        word64 k[8];    // the round key
402
590
 
403
591
        // Compute and apply K^0 to the cipher state
404
592
        // Also apply part of the Miyaguchi-Preneel compression function
405
 
        digest[0] = s[0] = block[0] ^ (k[0] = digest[0]);
406
 
        digest[1] = s[1] = block[1] ^ (k[1] = digest[1]);
407
 
        digest[2] = s[2] = block[2] ^ (k[2] = digest[2]);
408
 
        digest[3] = s[3] = block[3] ^ (k[3] = digest[3]);
409
 
        digest[4] = s[4] = block[4] ^ (k[4] = digest[4]);
410
 
        digest[5] = s[5] = block[5] ^ (k[5] = digest[5]);
411
 
        digest[6] = s[6] = block[6] ^ (k[6] = digest[6]);
412
 
        digest[7] = s[7] = block[7] ^ (k[7] = digest[7]);
 
593
        for (int i=0; i<8; i++)
 
594
                digest[i] = s[i] = block[i] ^ (k[i] = digest[i]);
 
595
 
 
596
#define KSL(op, i, a, b, c, d)  \
 
597
        t = (word32)k[i];\
 
598
        w##a = Whirlpool_C[3*256 + (byte)t] ^ (op ? w##a : 0);\
 
599
        t >>= 8;\
 
600
        w##b = Whirlpool_C[2*256 + (byte)t] ^ (op ? w##b : 0);\
 
601
        t >>= 8;\
 
602
        w##c = Whirlpool_C[1*256 + (byte)t] ^ (op ? w##c : 0);\
 
603
        t >>= 8;\
 
604
        w##d = Whirlpool_C[0*256 + t]       ^ (op ? w##d : 0);
 
605
 
 
606
#define KSH(op, i, a, b, c, d)  \
 
607
        t = (word32)(k[(i+4)%8]>>32);\
 
608
        w##a = Whirlpool_C[3*256 + (byte)t] ^ (op ? w##a : rotrFixed(w##a, 32));\
 
609
        if (op==2) k[a] = w##a;\
 
610
        t >>= 8;\
 
611
        w##b = Whirlpool_C[2*256 + (byte)t] ^ (op ? w##b : rotrFixed(w##b, 32));\
 
612
        if (op==2) k[b] = w##b;\
 
613
        t >>= 8;\
 
614
        w##c = Whirlpool_C[1*256 + (byte)t] ^ (op ? w##c : rotrFixed(w##c, 32));\
 
615
        if (op==2) k[c] = w##c;\
 
616
        t >>= 8;\
 
617
        w##d = Whirlpool_C[0*256 + t]       ^ (op ? w##d : rotrFixed(w##d, 32));\
 
618
        if (op==2) k[d] = w##d;\
 
619
 
 
620
#define TSL(op, i, a, b, c, d)  \
 
621
        t = (word32)s[i];\
 
622
        w##a = Whirlpool_C[3*256 + (byte)t] ^ (op ? w##a : 0);\
 
623
        t >>= 8;\
 
624
        w##b = Whirlpool_C[2*256 + (byte)t] ^ (op ? w##b : 0);\
 
625
        t >>= 8;\
 
626
        w##c = Whirlpool_C[1*256 + (byte)t] ^ (op ? w##c : 0);\
 
627
        t >>= 8;\
 
628
        w##d = Whirlpool_C[0*256 + t]       ^ (op ? w##d : 0);
 
629
 
 
630
#define TSH_OP(op, a, b)        \
 
631
        w##a = Whirlpool_C[b*256 + (byte)t] ^ (op ? w##a : rotrFixed(w##a, 32) ^ k[a]);\
 
632
        if (op==2) s[a] = w##a;\
 
633
        if (op==3) digest[a] ^= w##a;\
 
634
 
 
635
#define TSH(op, i, a, b, c, d)  \
 
636
        t = (word32)(s[(i+4)%8]>>32);\
 
637
        TSH_OP(op, a, 3);\
 
638
        t >>= 8;\
 
639
        TSH_OP(op, b, 2);\
 
640
        t >>= 8;\
 
641
        TSH_OP(op, c, 1);\
 
642
        t >>= 8;\
 
643
        TSH_OP(op, d, 0);\
413
644
 
414
645
        // Iterate over all rounds:
415
 
        for (int r = 0; r < R; r++)
 
646
        int r=0;
 
647
        while (true)
416
648
        {
417
649
                word64 w0, w1, w2, w3, w4, w5, w6, w7;  // temporary storage
418
 
                word64 t;
419
 
 
420
 
                // Compute K^r from K^{r-1}:
421
 
#define K(i,j) GETBYTE(k[(i+j+1)%8], j)
422
 
#define KS(i) \
423
 
        t = C0[K(i,3)] ^ C1[K(i,2)] ^ C2[K(i,1)] ^ C3[K(i,0)]; \
424
 
        w##i = rotrFixed(t, 32) ^ C0[K(i,7)] ^ C1[K(i,6)] ^ C2[K(i,5)] ^ C3[K(i,4)];
425
 
 
426
 
                KS(0); KS(1); KS(2); KS(3); KS(4); KS(5); KS(6); KS(7);
427
 
                k[0] = w0 ^ rc[r];
428
 
                k[1] = w1; k[2] = w2; k[3] = w3; k[4] = w4; k[5] = w5; k[6] = w6; k[7] = w7;
429
 
 
430
 
                // Apply the r-th round transformation:
431
 
#define S(i,j) GETBYTE(s[(i+j+1)%8], j)
432
 
#define TS(i) \
433
 
        t = C0[S(i,3)] ^ C1[S(i,2)] ^ C2[S(i,1)] ^ C3[S(i,0)]; \
434
 
        w##i = rotrFixed(t, 32) ^ C0[S(i,7)] ^ C1[S(i,6)] ^ C2[S(i,5)] ^ C3[S(i,4)] ^ k[i];
435
 
 
436
 
                TS(0); TS(1); TS(2); TS(3); TS(4); TS(5); TS(6); TS(7);
437
 
                s[0] = w0; s[1] = w1; s[2] = w2; s[3] = w3; s[4] = w4; s[5] = w5; s[6] = w6; s[7] = w7;
438
 
        }
439
 
 
440
 
        // Apply the rest of the Miyaguchi-Preneel compression function:
441
 
        digest[0] ^= s[0];
442
 
        digest[1] ^= s[1];
443
 
        digest[2] ^= s[2];
444
 
        digest[3] ^= s[3];
445
 
        digest[4] ^= s[4];
446
 
        digest[5] ^= s[5];
447
 
        digest[6] ^= s[6];
448
 
        digest[7] ^= s[7];
 
650
                word32 t;
 
651
 
 
652
                KSL(0, 4, 3, 2, 1, 0)
 
653
                KSL(0, 0, 7, 6, 5, 4)
 
654
                KSL(1, 1, 0, 7, 6, 5)
 
655
                KSL(1, 2, 1, 0, 7, 6)
 
656
                KSL(1, 3, 2, 1, 0, 7)
 
657
                KSL(1, 5, 4, 3, 2, 1)
 
658
                KSL(1, 6, 5, 4, 3, 2)
 
659
                KSL(1, 7, 6, 5, 4, 3)
 
660
                KSH(0, 0, 7, 6, 5, 4)
 
661
                KSH(0, 4, 3, 2, 1, 0)
 
662
                KSH(1, 1, 0, 7, 6, 5)
 
663
                KSH(1, 2, 1, 0, 7, 6)
 
664
                KSH(1, 5, 4, 3, 2, 1)
 
665
                KSH(1, 6, 5, 4, 3, 2)
 
666
                KSH(2, 3, 2, 1, 0, 7)
 
667
                KSH(2, 7, 6, 5, 4, 3)
 
668
 
 
669
                k[0] ^= Whirlpool_C[1024+r];
 
670
 
 
671
                TSL(0, 4, 3, 2, 1, 0)
 
672
                TSL(0, 0, 7, 6, 5, 4)
 
673
                TSL(1, 1, 0, 7, 6, 5)
 
674
                TSL(1, 2, 1, 0, 7, 6)
 
675
                TSL(1, 3, 2, 1, 0, 7)
 
676
                TSL(1, 5, 4, 3, 2, 1)
 
677
                TSL(1, 6, 5, 4, 3, 2)
 
678
                TSL(1, 7, 6, 5, 4, 3)
 
679
                TSH(0, 0, 7, 6, 5, 4)
 
680
                TSH(0, 4, 3, 2, 1, 0)
 
681
                TSH(1, 1, 0, 7, 6, 5)
 
682
                TSH(1, 2, 1, 0, 7, 6)
 
683
                TSH(1, 5, 4, 3, 2, 1)
 
684
                TSH(1, 6, 5, 4, 3, 2)
 
685
 
 
686
                if (++r < R)
 
687
                {
 
688
                        TSH(2, 3, 2, 1, 0, 7)
 
689
                        TSH(2, 7, 6, 5, 4, 3)
 
690
                }
 
691
                else
 
692
                {
 
693
                        TSH(3, 3, 2, 1, 0, 7)
 
694
                        TSH(3, 7, 6, 5, 4, 3)
 
695
                        break;
 
696
                }
 
697
        }
 
698
        }
449
699
}
450
700
 
451
701
NAMESPACE_END
452
 
 
453
 
#endif // WORD64_AVAILABLE