bmw/bmw_large_speed.c

   1 /* bmw_large_speed.c */
   2 /*
   3     This file is part of the ARM-Crypto-Lib.
   4     Copyright (C) 2006-2010  Daniel Otte (daniel.otte@rub.de)
   5
   6     This program is free software: you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation, either version 3 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18 */
  19 /*
  20  * \file    bmw_large.c
  21  * \author  Daniel Otte
  22  * \email   daniel.otte@rub.de
  23  * \date    2009-04-27
  24  * \license GPLv3 or later
  25  *
  26  */
  27
  28 #include <stdint.h>
  29 #include <string.h>
  30 #include "bmw_large.h"
  31
  32 #define SHL64(a,n)  ((a)<<(n))
  33 #define SHR64(a,n)  ((a)>>(n))
  34 #define ROTL64(a,n) (((a)<<(n))|((a)>>(64-(n))))
  35 #define ROTR64(a,n) (((a)>>(n))|((a)<<(64-(n))))
  36
  37 #define TWEAK   1
  38 #define BUG24   0
  39 #define F0_HACK 0
  40
  41 #define DEBUG   0
  42
  43 #if DEBUG
  44  #include "cli.h"
  45
  46  void ctx_dump(const bmw_large_ctx_t* ctx){
  47         uint8_t i;
  48         cli_putstr("\r\n==== ctx dump ====");
  49         for(i=0; i<16;++i){
  50                 cli_putstr("\r\n h[");
  51                 cli_hexdump(&i, 1);
  52                 cli_putstr("] = ");
  53                 cli_hexdump_rev(&(ctx->h[i]), 8);
  54         }
  55         cli_putstr("\r\n counter = ");
  56         cli_hexdump(&(ctx->counter), 4);
  57  }
  58
  59  void dump_x(const uint64_t* q, uint8_t elements, char x){
  60         uint8_t i;
  61         cli_putstr("\r\n==== ");
  62         cli_putc(x);
  63         cli_putstr(" dump ====");
  64         for(i=0; i<elements;++i){
  65                 cli_putstr("\r\n ");
  66                 cli_putc(x);
  67                 cli_putstr("[");
  68                 cli_hexdump(&i, 1);
  69                 cli_putstr("] = ");
  70                 cli_hexdump_rev(&(q[i]), 8);
  71         }
  72  }
  73 #else
  74  #define ctx_dump(x)
  75  #define dump_x(a,b,c)
  76 #endif
  77
  78 #define S64_0(x) ( (SHR64((x),   1)) ^ \
  79                        (SHL64((x),   3)) ^ \
  80                        (ROTL64((x),  4)) ^ \
  81                        (ROTR64((x), 27)) )
  82
  83 #define S64_1(x) ( (SHR64((x),   1)) ^ \
  84                        (SHL64((x),   2)) ^ \
  85                        (ROTL64((x), 13)) ^ \
  86                        (ROTR64((x), 21)) )
  87
  88 #define S64_2(x) ( (SHR64((x),   2)) ^ \
  89                        (SHL64((x),   1)) ^ \
  90                        (ROTL64((x), 19)) ^ \
  91                        (ROTR64((x), 11)) )
  92
  93 #define S64_3(x) ( (SHR64((x),   2)) ^ \
  94                        (SHL64((x),   2)) ^ \
  95                        (ROTL64((x), 28)) ^ \
  96                        (ROTR64((x),  5)) )
  97
  98 #define S64_4(x) ( (SHR64((x),   1)) ^ x)
  99
 100 #define S64_5(x) ( (SHR64((x),   2)) ^ x)
 101
 102 #define R64_1(x)    (ROTL64((x),  5))
 103 #define R64_2(x)    (ROTL64((x), 11))
 104 #define R64_3(x)    (ROTL64((x), 27))
 105 #define R64_4(x)    (ROTL64((x), 32))
 106 #define R64_5(x)    (ROTR64((x), 27))
 107 #define R64_6(x)    (ROTR64((x), 21))
 108 #define R64_7(x)    (ROTR64((x), 11))
 109
 110 /*
 111 #define K    0x0555555555555555LL
 112 #define MASK 0xFFFFFFFFFFFFFFFFLL
 113 static
 114 uint64_t k_lut[] PROGMEM = {
 115         16LL*K, 17LL*K, 18LL*K, 19LL*K,
 116         20LL*K, 21LL*K, 22LL*K, 23LL*K,
 117         24LL*K, 25LL*K, 26LL*K, 27LL*K,
 118         28LL*K, 29LL*K, 30LL*K, 31LL*K };
 119 */
 120 /* the same as above but precomputed to avoid compiler warnings */
 121 static const
 122 uint64_t k_lut[] = {
 123         0x5555555555555550LL, 0x5aaaaaaaaaaaaaa5LL, 0x5ffffffffffffffaLL,
 124         0x655555555555554fLL, 0x6aaaaaaaaaaaaaa4LL, 0x6ffffffffffffff9LL,
 125         0x755555555555554eLL, 0x7aaaaaaaaaaaaaa3LL, 0x7ffffffffffffff8LL,
 126         0x855555555555554dLL, 0x8aaaaaaaaaaaaaa2LL, 0x8ffffffffffffff7LL,
 127         0x955555555555554cLL, 0x9aaaaaaaaaaaaaa1LL, 0x9ffffffffffffff6LL,
 128         0xa55555555555554bLL };
 129
 130 static
 131 uint64_t bmw_large_expand1(uint8_t j, const uint64_t* q, const void* m, const void* h){
 132         uint64_t r;
 133         /* r = 0x0555555555555555LL*(j+16); */
 134         r  = (   ROTL64(((uint64_t*)m)[(j)&0xf],   ((j+ 0)&0xf)+1)
 135                + ROTL64(((uint64_t*)m)[(j+3)&0xf], ((j+ 3)&0xf)+1)
 136                + k_lut[j]
 137                - ROTL64(((uint64_t*)m)[(j+10)&0xf],((j+10)&0xf)+1)
 138              ) ^ ((uint64_t*)h)[(j+7)&0xf];
 139         r += S64_1(q[j+ 0]) + S64_2(q[j+ 1]) + S64_3(q[j+ 2]) + S64_0(q[j+ 3]) +
 140                  S64_1(q[j+ 4]) + S64_2(q[j+ 5]) + S64_3(q[j+ 6]) + S64_0(q[j+ 7]) +
 141                  S64_1(q[j+ 8]) + S64_2(q[j+ 9]) + S64_3(q[j+10]) + S64_0(q[j+11]) +
 142                  S64_1(q[j+12]) + S64_2(q[j+13]) + S64_3(q[j+14]) + S64_0(q[j+15]);
 143
 144         return r;
 145 }
 146
 147 static
 148 uint64_t bmw_large_expand2(uint8_t j, const uint64_t* q, const void* m, const void* h){
 149         uint64_t r=0;
 150         r  = (   ROTL64(((uint64_t*)m)[(j)&0xf],   ((j+ 0)&0xf)+1)
 151                + ROTL64(((uint64_t*)m)[(j+3)&0xf], ((j+ 3)&0xf)+1)
 152                + k_lut[j]
 153                - ROTL64(((uint64_t*)m)[(j+10)&0xf],((j+10)&0xf)+1)
 154              ) ^ ((uint64_t*)h)[(j+7)&0xf];
 155         r += (q[j+ 0]) + R64_1(q[j+ 1]) + (q[j+ 2]) + R64_2(q[j+ 3]) +
 156                  (q[j+ 4]) + R64_3(q[j+ 5]) + (q[j+ 6]) + R64_4(q[j+ 7]) +
 157                  (q[j+ 8]) + R64_5(q[j+ 9]) + (q[j+10]) + R64_6(q[j+11]) +
 158                  (q[j+12]) + R64_7(q[j+13]) + S64_4(q[j+14]) + S64_5(q[j+15]);
 159
 160         return r;
 161 }
 162
 163 #if F0_HACK==2
 164 /* to understand this implementation take a look at f0-opt-table.txt */
 165 static uint16_t hack_table[5] = { 0x0311, 0xDDB3, 0x2A79, 0x07AA, 0x51C2 };
 166 static uint8_t  offset_table[5]  = { 4+16, 6+16, 9+16, 12+16, 13+16 };
 167
 168
 169 static
 170 void bmw_large_f0(uint64_t* q, const uint64_t* h, const void* m){
 171         uint16_t hack_reg;
 172         uint8_t i,j,c;
 173         uint64_t(*s[])(uint64_t)={ bmw_large_s0, bmw_large_s1, bmw_large_s2,
 174                                    bmw_large_s3, bmw_large_s4 };
 175         for(i=0; i<16; ++i){
 176                 ((uint64_t*)h)[i] ^= ((uint64_t*)m)[i];
 177         }
 178         dump_x(h, 16, 'T');
 179         memset(q, 0, 8*16);
 180         c=4;
 181         do{
 182                 i=15;
 183                 j = offset_table[c];
 184                 hack_reg = hack_table[c];
 185                 do{
 186                         if(hack_reg&1){
 187                                 q[i]-= h[j&15];
 188                         }else{
 189                                 q[i]+= h[j&15];
 190                         }
 191                         --j;
 192                         hack_reg>>= 1;
 193                 }while(i--!=0);
 194         }while(c--!=0);
 195         dump_x(q, 16, 'W');
 196         for(i=0; i<16; ++i){
 197                 q[i] = s[i%5](q[i]);
 198         }
 199 #if TWEAK
 200         for(i=0; i<16; ++i){
 201                 ((uint64_t*)h)[i] ^= ((uint64_t*)m)[i];
 202         }
 203         for(i=0; i<16; ++i){
 204                 q[i] += h[(i+1)&0xf];
 205         }
 206 #endif /* TWEAK */
 207 }
 208 #endif /* F0_HACK==2 */
 209
 210 #if F0_HACK==1
 211 static
 212 uint8_t f0_lut[] PROGMEM ={
 213          5<<1, ( 7<<1)+1, (10<<1)+0, (13<<1)+0, (14<<1)+0,
 214          6<<1, ( 8<<1)+1, (11<<1)+0, (14<<1)+0, (15<<1)+1,
 215          0<<1, ( 7<<1)+0, ( 9<<1)+0, (12<<1)+1, (15<<1)+0,
 216          0<<1, ( 1<<1)+1, ( 8<<1)+0, (10<<1)+1, (13<<1)+0,
 217          1<<1, ( 2<<1)+0, ( 9<<1)+0, (11<<1)+1, (14<<1)+1,
 218          3<<1, ( 2<<1)+1, (10<<1)+0, (12<<1)+1, (15<<1)+0,
 219          4<<1, ( 0<<1)+1, ( 3<<1)+1, (11<<1)+1, (13<<1)+0,
 220          1<<1, ( 4<<1)+1, ( 5<<1)+1, (12<<1)+1, (14<<1)+1,
 221          2<<1, ( 5<<1)+1, ( 6<<1)+1, (13<<1)+0, (15<<1)+1,
 222          0<<1, ( 3<<1)+1, ( 6<<1)+0, ( 7<<1)+1, (14<<1)+0,
 223          8<<1, ( 1<<1)+1, ( 4<<1)+1, ( 7<<1)+1, (15<<1)+0,
 224          8<<1, ( 0<<1)+1, ( 2<<1)+1, ( 5<<1)+1, ( 9<<1)+0,
 225          1<<1, ( 3<<1)+0, ( 6<<1)+1, ( 9<<1)+1, (10<<1)+0,
 226          2<<1, ( 4<<1)+0, ( 7<<1)+0, (10<<1)+0, (11<<1)+0,
 227          3<<1, ( 5<<1)+1, ( 8<<1)+0, (11<<1)+1, (12<<1)+1,
 228         12<<1, ( 4<<1)+1, ( 6<<1)+1, ( 9<<1)+1, (13<<1)+0
 229 };
 230
 231 static
 232 void bmw_large_f0(uint64_t* q, const uint64_t* h, const void* m){
 233         uint8_t i,j=-1,v,sign,l=0;
 234         uint64_t(*s[])(uint64_t)={ bmw_large_s0, bmw_large_s1, bmw_large_s2,
 235                                    bmw_large_s3, bmw_large_s4 };
 236         for(i=0; i<16; ++i){
 237                 ((uint64_t*)h)[i] ^= ((uint64_t*)m)[i];
 238         }
 239         dump_x(h, 16, 'T');
 240 //      memset(q, 0, 4*16);
 241         for(i=0; i<5*16; ++i){
 242                 v = pgm_read_byte(f0_lut+i);
 243                 sign = v&1;
 244                 v >>=1;
 245                 if(i==l){
 246                         j++;
 247                         l+=5;
 248                         q[j] = h[v];
 249                         continue;
 250                 }
 251                 if(sign){
 252                         q[j] -= h[v];
 253                 }else{
 254                         q[j] += h[v];
 255                 }
 256         }
 257         dump_x(q, 16, 'W');
 258         for(i=0; i<16; ++i){
 259                 q[i] = s[i%5](q[i]);
 260         }
 261 #if TWEAK
 262         for(i=0; i<16; ++i){
 263                 ((uint64_t*)h)[i] ^= ((uint64_t*)m)[i];
 264         }
 265         for(i=0; i<16; ++i){
 266                 q[i] += h[(i+1)&0xf];
 267         }
 268 #endif /* TWEAK */
 269 }
 270 #endif /* F0_HACK==1 */
 271
 272 #if F0_HACK==0
 273 static
 274 void bmw_large_f0(uint64_t* q, const uint64_t* h, const void* m){
 275         uint8_t i;
 276         for(i=0; i<16; ++i){
 277                 ((uint64_t*)h)[i] ^= ((uint64_t*)m)[i];
 278         }
 279 //      dump_x(t, 16, 'T');
 280         q[ 0] = (h[ 5] - h[ 7] + h[10] + h[13] + h[14]);
 281         q[ 1] = (h[ 6] - h[ 8] + h[11] + h[14] - h[15]);
 282         q[ 2] = (h[ 0] + h[ 7] + h[ 9] - h[12] + h[15]);
 283         q[ 3] = (h[ 0] - h[ 1] + h[ 8] - h[10] + h[13]);
 284         q[ 4] = (h[ 1] + h[ 2] + h[ 9] - h[11] - h[14]);
 285         q[ 5] = (h[ 3] - h[ 2] + h[10] - h[12] + h[15]);
 286         q[ 6] = (h[ 4] - h[ 0] - h[ 3] - h[11] + h[13]);
 287         q[ 7] = (h[ 1] - h[ 4] - h[ 5] - h[12] - h[14]);
 288         q[ 8] = (h[ 2] - h[ 5] - h[ 6] + h[13] - h[15]);
 289         q[ 9] = (h[ 0] - h[ 3] + h[ 6] - h[ 7] + h[14]);
 290         q[10] = (h[ 8] - h[ 1] - h[ 4] - h[ 7] + h[15]);
 291         q[11] = (h[ 8] - h[ 0] - h[ 2] - h[ 5] + h[ 9]);
 292         q[12] = (h[ 1] + h[ 3] - h[ 6] - h[ 9] + h[10]);
 293         q[13] = (h[ 2] + h[ 4] + h[ 7] + h[10] + h[11]);
 294         q[14] = (h[ 3] - h[ 5] + h[ 8] - h[11] - h[12]);
 295         q[15] = (h[12] - h[ 4] - h[ 6] - h[ 9] + h[13]);
 296         dump_x(q, 16, 'W');
 297         q[ 0] = S64_0(q[ 0]); q[ 1] = S64_1(q[ 1]); q[ 2] = S64_2(q[ 2]); q[ 3] = S64_3(q[ 3]); q[ 4] = S64_4(q[ 4]);
 298         q[ 5] = S64_0(q[ 5]); q[ 6] = S64_1(q[ 6]); q[ 7] = S64_2(q[ 7]); q[ 8] = S64_3(q[ 8]); q[ 9] = S64_4(q[ 9]);
 299         q[10] = S64_0(q[10]); q[11] = S64_1(q[11]); q[12] = S64_2(q[12]); q[13] = S64_3(q[13]); q[14] = S64_4(q[14]);
 300         q[15] = S64_0(q[15]);
 301
 302         for(i=0; i<16; ++i){
 303                 ((uint64_t*)h)[i] ^= ((uint64_t*)m)[i];
 304         }
 305         for(i=0; i<16; ++i){
 306                 q[i] += h[(i+1)&0xf];
 307         }
 308 }
 309 #endif /* F0_HACK==0 */
 310
 311 static
 312 void bmw_large_f1(uint64_t* q, const void* m, const uint64_t* h){
 313         uint8_t i;
 314         q[16] = bmw_large_expand1(0, q, m, h);
 315         q[17] = bmw_large_expand1(1, q, m, h);
 316         for(i=2; i<16; ++i){
 317                 q[16+i] = bmw_large_expand2(i, q, m, h);
 318         }
 319 }
 320
 321 static
 322 void bmw_large_f2(uint64_t* h, const uint64_t* q, const void* m){
 323         uint64_t xl=0, xh;
 324         uint8_t i;
 325         for(i=16;i<24;++i){
 326                 xl ^= q[i];
 327         }
 328         xh = xl;
 329         for(i=24;i<32;++i){
 330                 xh ^= q[i];
 331         }
 332 #if DEBUG
 333         cli_putstr("\r\n XL = ");
 334         cli_hexdump_rev(&xl, 4);
 335         cli_putstr("\r\n XH = ");
 336         cli_hexdump_rev(&xh, 4);
 337 #endif
 338         memcpy(h, m, 16*8);
 339         h[0] ^= SHL64(xh, 5) ^ SHR64(q[16], 5);
 340         h[1] ^= SHR64(xh, 7) ^ SHL64(q[17], 8);
 341         h[2] ^= SHR64(xh, 5) ^ SHL64(q[18], 5);
 342         h[3] ^= SHR64(xh, 1) ^ SHL64(q[19], 5);
 343         h[4] ^= SHR64(xh, 3) ^ q[20];
 344         h[5] ^= SHL64(xh, 6) ^ SHR64(q[21], 6);
 345         h[6] ^= SHR64(xh, 4) ^ SHL64(q[22], 6);
 346         h[7] ^= SHR64(xh,11) ^ SHL64(q[23], 2);
 347         for(i=0; i<8; ++i){
 348                 h[i] += xl ^ q[24+i] ^ q[i];
 349         }
 350         for(i=0; i<8; ++i){
 351                 h[8+i] ^= xh ^ q[24+i];
 352                 h[8+i] += ROTL64(h[(4+i)%8],i+9);
 353         }
 354         h[ 8] += SHL64(xl, 8) ^ q[23] ^ q[ 8];
 355         h[ 9] += SHR64(xl, 6) ^ q[16] ^ q[ 9];
 356         h[10] += SHL64(xl, 6) ^ q[17] ^ q[10];
 357         h[11] += SHL64(xl, 4) ^ q[18] ^ q[11];
 358         h[12] += SHR64(xl, 3) ^ q[19] ^ q[12];
 359         h[13] += SHR64(xl, 4) ^ q[20] ^ q[13];
 360         h[14] += SHR64(xl, 7) ^ q[21] ^ q[14];
 361         h[15] += SHR64(xl, 2) ^ q[22] ^ q[15];
 362 }
 363
 364 void bmw_large_nextBlock(bmw_large_ctx_t* ctx, const void* block){
 365         uint64_t q[32];
 366         dump_x(block, 16, 'M');
 367         bmw_large_f0(q, ctx->h, block);
 368         dump_x(q, 16, 'Q');
 369         bmw_large_f1(q, block, ctx->h);
 370         dump_x(q, 32, 'Q');
 371         bmw_large_f2(ctx->h, q, block);
 372         ctx->counter += 1;
 373         ctx_dump(ctx);
 374 }
 375
 376 void bmw_large_lastBlock(bmw_large_ctx_t* ctx, const void* block, uint16_t length_b){
 377         uint8_t buffer[128];
 378         while(length_b >= BMW_LARGE_BLOCKSIZE){
 379                 bmw_large_nextBlock(ctx, block);
 380                 length_b -= BMW_LARGE_BLOCKSIZE;
 381                 block = (uint8_t*)block + BMW_LARGE_BLOCKSIZE_B;
 382         }
 383         memset(buffer, 0, 128);
 384         memcpy(buffer, block, (length_b+7)/8);
 385         buffer[length_b>>3] |= 0x80 >> (length_b&0x07);
 386         if(length_b+1>128*8-64){
 387                 bmw_large_nextBlock(ctx, buffer);
 388                 memset(buffer, 0, 128-8);
 389                 ctx->counter -= 1;
 390         }
 391         *((uint64_t*)&(buffer[128-8])) = (uint64_t)(ctx->counter*1024LL)+(uint64_t)length_b;
 392         bmw_large_nextBlock(ctx, buffer);
 393 #if TWEAK
 394         uint8_t i;
 395         uint64_t q[32];
 396         memset(buffer, 0xaa, 128);
 397         for(i=0; i<16; ++i){
 398                 buffer[8*i] = i + 0xa0;
 399         }
 400         bmw_large_f0(q, (uint64_t*)buffer, ctx->h);
 401         bmw_large_f1(q, ctx->h, (uint64_t*)buffer);
 402         bmw_large_f2((uint64_t*)buffer, q, ctx->h);
 403         memcpy(ctx->h, buffer, 128);
 404 #endif
 405 }
 406
 407 void bmw384_init(bmw384_ctx_t* ctx){
 408         uint8_t i;
 409         ctx->h[0] = 0x0001020304050607LL;
 410         for(i=1; i<16; ++i){
 411                 ctx->h[i] = ctx->h[i-1]+ 0x0808080808080808LL;
 412         }
 413 #if BUG24
 414         ctx->h[6] = 0x3031323324353637LL;
 415 #endif
 416         ctx->counter=0;
 417         ctx_dump(ctx);
 418 }
 419
 420 void bmw512_init(bmw512_ctx_t* ctx){
 421         uint8_t i;
 422         ctx->h[0] = 0x8081828384858687LL;
 423         for(i=1; i<16; ++i){
 424                 ctx->h[i] = ctx->h[i-1]+ 0x0808080808080808LL;
 425         }
 426         ctx->counter=0;
 427         ctx_dump(ctx);
 428 }
 429
 430 void bmw384_nextBlock(bmw384_ctx_t* ctx, const void* block){
 431         bmw_large_nextBlock(ctx, block);
 432 }
 433
 434 void bmw512_nextBlock(bmw512_ctx_t* ctx, const void* block){
 435         bmw_large_nextBlock(ctx, block);
 436 }
 437
 438 void bmw384_lastBlock(bmw384_ctx_t* ctx, const void* block, uint16_t length_b){
 439         bmw_large_lastBlock(ctx, block, length_b);
 440 }
 441
 442 void bmw512_lastBlock(bmw512_ctx_t* ctx, const void* block, uint16_t length_b){
 443         bmw_large_lastBlock(ctx, block, length_b);
 444 }
 445
 446 void bmw384_ctx2hash(void* dest, const bmw384_ctx_t* ctx){
 447         memcpy(dest, &(ctx->h[10]), 384/8);
 448 }
 449
 450 void bmw512_ctx2hash(void* dest, const bmw512_ctx_t* ctx){
 451         memcpy(dest, &(ctx->h[8]), 512/8);
 452 }
 453
 454 void bmw384(void* dest, const void* msg, uint32_t length_b){
 455         bmw_large_ctx_t ctx;
 456         bmw384_init(&ctx);
 457         while(length_b>=BMW_LARGE_BLOCKSIZE){
 458                 bmw_large_nextBlock(&ctx, msg);
 459                 length_b -= BMW_LARGE_BLOCKSIZE;
 460                 msg = (uint8_t*)msg + BMW_LARGE_BLOCKSIZE_B;
 461         }
 462         bmw_large_lastBlock(&ctx, msg, length_b);
 463         bmw384_ctx2hash(dest, &ctx);
 464 }
 465
 466 void bmw512(void* dest, const void* msg, uint32_t length_b){
 467         bmw_large_ctx_t ctx;
 468         bmw512_init(&ctx);
 469         while(length_b>=BMW_LARGE_BLOCKSIZE){
 470                 bmw_large_nextBlock(&ctx, msg);
 471                 length_b -= BMW_LARGE_BLOCKSIZE;
 472                 msg = (uint8_t*)msg + BMW_LARGE_BLOCKSIZE_B;
 473         }
 474         bmw_large_lastBlock(&ctx, msg, length_b);
 475         bmw512_ctx2hash(dest, &ctx);
 476 }
 477