rijndael-api-fst.c revision 121257
1331766Sken/* $KAME: rijndael-api-fst.c,v 1.10 2001/05/27 09:34:18 itojun Exp $ */ 2331766Sken 3331766Sken/* 4331766Sken * rijndael-api-fst.c v2.3 April '2000 5331766Sken * 6331766Sken * Optimised ANSI C code 7331766Sken * 8331766Sken * authors: v1.0: Antoon Bosselaers 9331766Sken * v2.0: Vincent Rijmen 10331766Sken * v2.1: Vincent Rijmen 11331766Sken * v2.2: Vincent Rijmen 12331766Sken * v2.3: Paulo Barreto 13331766Sken * v2.4: Vincent Rijmen 14331766Sken * 15331766Sken * This code is placed in the public domain. 16331766Sken */ 17331766Sken 18331766Sken#include <sys/cdefs.h> 19331766Sken__FBSDID("$FreeBSD: head/sys/crypto/rijndael/rijndael-api-fst.c 121257 2003-10-19 21:28:34Z ume $"); 20331766Sken 21331766Sken#include <sys/param.h> 22331766Sken#include <sys/types.h> 23331766Sken#ifdef _KERNEL 24331766Sken#include <sys/systm.h> 25331766Sken#else 26331766Sken#include <string.h> 27331766Sken#endif 28331766Sken#include <crypto/rijndael/rijndael-alg-fst.h> 29331766Sken#include <crypto/rijndael/rijndael-api-fst.h> 30331766Sken#include <crypto/rijndael/rijndael_local.h> 31331766Sken 32331766Sken#ifndef TRUE 33331766Sken#define TRUE 1 34331766Sken#endif 35331766Sken 36331766Skentypedef u_int8_t BYTE; 37331766Sken 38331766Skenint rijndael_makeKey(keyInstance *key, BYTE direction, int keyLen, char *keyMaterial) { 39331766Sken u8 k[RIJNDAEL_MAXKC][4]; 40331766Sken int i; 41331766Sken char *keyMat; 42331766Sken 43331766Sken if (key == NULL) { 44331766Sken return BAD_KEY_INSTANCE; 45331766Sken } 46331766Sken 47331766Sken if ((direction == DIR_ENCRYPT) || (direction == DIR_DECRYPT)) { 48331766Sken key->direction = direction; 49331766Sken } else { 50331766Sken return BAD_KEY_DIR; 51331766Sken } 52331766Sken 53331766Sken if ((keyLen == 128) || (keyLen == 192) || (keyLen == 256)) { 54331766Sken key->keyLen = keyLen; 55331766Sken } else { 56331766Sken return BAD_KEY_MAT; 57331766Sken } 58331766Sken 59331766Sken if (keyMaterial != NULL) { 60331766Sken bcopy(keyMaterial, key->keyMaterial, keyLen/8); 61331766Sken } 62331766Sken 63331766Sken key->ROUNDS = keyLen/32 + 6; 64331766Sken 65331766Sken /* initialize key schedule: */ 66331766Sken keyMat = key->keyMaterial; 67331766Sken for (i = 0; i < key->keyLen/8; i++) { 68331766Sken k[i >> 2][i & 3] = (u8)keyMat[i]; 69331766Sken } 70331766Sken rijndaelKeySched(k, key->keySched, key->ROUNDS); 71331766Sken if (direction == DIR_DECRYPT) { 72331766Sken rijndaelKeyEncToDec(key->keySched, key->ROUNDS); 73331766Sken } 74331766Sken 75331766Sken return TRUE; 76331766Sken} 77331766Sken 78331766Skenint rijndael_cipherInit(cipherInstance *cipher, BYTE mode, char *IV) { 79331766Sken if ((mode == MODE_ECB) || (mode == MODE_CBC) || (mode == MODE_CFB1)) { 80331766Sken cipher->mode = mode; 81331766Sken } else { 82331766Sken return BAD_CIPHER_MODE; 83331766Sken } 84331766Sken if (IV != NULL) { 85331766Sken bcopy(IV, cipher->IV, MAX_IV_SIZE); 86331766Sken } else { 87331766Sken bzero(cipher->IV, MAX_IV_SIZE); 88331766Sken } 89331766Sken return TRUE; 90331766Sken} 91331766Sken 92331766Skenint rijndael_blockEncrypt(cipherInstance *cipher, keyInstance *key, 93331766Sken BYTE *input, int inputLen, BYTE *outBuffer) { 94331766Sken int i, k, numBlocks; 95331766Sken u8 block[16], iv[4][4]; 96331766Sken 97331766Sken if (cipher == NULL || 98331766Sken key == NULL || 99331766Sken key->direction == DIR_DECRYPT) { 100331766Sken return BAD_CIPHER_STATE; 101331766Sken } 102331766Sken if (input == NULL || inputLen <= 0) { 103331766Sken return 0; /* nothing to do */ 104331766Sken } 105331766Sken 106331766Sken numBlocks = inputLen/128; 107331766Sken 108331766Sken switch (cipher->mode) { 109331766Sken case MODE_ECB: 110331766Sken for (i = numBlocks; i > 0; i--) { 111331766Sken rijndaelEncrypt(input, outBuffer, key->keySched, key->ROUNDS); 112331766Sken input += 16; 113331766Sken outBuffer += 16; 114331766Sken } 115331766Sken break; 116331766Sken 117331766Sken case MODE_CBC: 118331766Sken#if 1 /*STRICT_ALIGN*/ 119331766Sken bcopy(cipher->IV, block, 16); 120331766Sken bcopy(input, iv, 16); 121331766Sken ((u32*)block)[0] ^= ((u32*)iv)[0]; 122331766Sken ((u32*)block)[1] ^= ((u32*)iv)[1]; 123331766Sken ((u32*)block)[2] ^= ((u32*)iv)[2]; 124331766Sken ((u32*)block)[3] ^= ((u32*)iv)[3]; 125331766Sken#else 126331766Sken ((u32*)block)[0] = ((u32*)cipher->IV)[0] ^ ((u32*)input)[0]; 127331766Sken ((u32*)block)[1] = ((u32*)cipher->IV)[1] ^ ((u32*)input)[1]; 128331766Sken ((u32*)block)[2] = ((u32*)cipher->IV)[2] ^ ((u32*)input)[2]; 129331766Sken ((u32*)block)[3] = ((u32*)cipher->IV)[3] ^ ((u32*)input)[3]; 130331766Sken#endif 131331766Sken rijndaelEncrypt(block, outBuffer, key->keySched, key->ROUNDS); 132331766Sken input += 16; 133331766Sken for (i = numBlocks - 1; i > 0; i--) { 134331766Sken#if 1 /*STRICT_ALIGN*/ 135331766Sken bcopy(outBuffer, block, 16); 136331766Sken bcopy(input, iv, 16); 137331766Sken ((u32*)block)[0] ^= ((u32*)iv)[0]; 138331766Sken ((u32*)block)[1] ^= ((u32*)iv)[1]; 139331766Sken ((u32*)block)[2] ^= ((u32*)iv)[2]; 140331766Sken ((u32*)block)[3] ^= ((u32*)iv)[3]; 141331766Sken#else 142331766Sken ((u32*)block)[0] = ((u32*)outBuffer)[0] ^ ((u32*)input)[0]; 143331766Sken ((u32*)block)[1] = ((u32*)outBuffer)[1] ^ ((u32*)input)[1]; 144331766Sken ((u32*)block)[2] = ((u32*)outBuffer)[2] ^ ((u32*)input)[2]; 145331766Sken ((u32*)block)[3] = ((u32*)outBuffer)[3] ^ ((u32*)input)[3]; 146331766Sken#endif 147331766Sken outBuffer += 16; 148331766Sken rijndaelEncrypt(block, outBuffer, key->keySched, key->ROUNDS); 149331766Sken input += 16; 150331766Sken } 151331766Sken break; 152331766Sken 153331766Sken case MODE_CFB1: 154331766Sken#if 1 /*STRICT_ALIGN*/ 155331766Sken bcopy(cipher->IV, iv, 16); 156331766Sken#else /* !STRICT_ALIGN */ 157331766Sken *((u32*)iv[0]) = *((u32*)(cipher->IV )); 158331766Sken *((u32*)iv[1]) = *((u32*)(cipher->IV+ 4)); 159331766Sken *((u32*)iv[2]) = *((u32*)(cipher->IV+ 8)); 160331766Sken *((u32*)iv[3]) = *((u32*)(cipher->IV+12)); 161331766Sken#endif /* ?STRICT_ALIGN */ 162331766Sken for (i = numBlocks; i > 0; i--) { 163331766Sken for (k = 0; k < 128; k++) { 164331766Sken *((u32*) block ) = *((u32*)iv[0]); 165331766Sken *((u32*)(block+ 4)) = *((u32*)iv[1]); 166331766Sken *((u32*)(block+ 8)) = *((u32*)iv[2]); 167331766Sken *((u32*)(block+12)) = *((u32*)iv[3]); 168331766Sken rijndaelEncrypt(block, block, key->keySched, key->ROUNDS); 169331766Sken outBuffer[k/8] ^= (block[0] & 0x80) >> (k & 7); 170331766Sken iv[0][0] = (iv[0][0] << 1) | (iv[0][1] >> 7); 171331766Sken iv[0][1] = (iv[0][1] << 1) | (iv[0][2] >> 7); 172331766Sken iv[0][2] = (iv[0][2] << 1) | (iv[0][3] >> 7); 173331766Sken iv[0][3] = (iv[0][3] << 1) | (iv[1][0] >> 7); 174331766Sken iv[1][0] = (iv[1][0] << 1) | (iv[1][1] >> 7); 175331766Sken iv[1][1] = (iv[1][1] << 1) | (iv[1][2] >> 7); 176331766Sken iv[1][2] = (iv[1][2] << 1) | (iv[1][3] >> 7); 177331766Sken iv[1][3] = (iv[1][3] << 1) | (iv[2][0] >> 7); 178331766Sken iv[2][0] = (iv[2][0] << 1) | (iv[2][1] >> 7); 179331766Sken iv[2][1] = (iv[2][1] << 1) | (iv[2][2] >> 7); 180331766Sken iv[2][2] = (iv[2][2] << 1) | (iv[2][3] >> 7); 181331766Sken iv[2][3] = (iv[2][3] << 1) | (iv[3][0] >> 7); 182331766Sken iv[3][0] = (iv[3][0] << 1) | (iv[3][1] >> 7); 183331766Sken iv[3][1] = (iv[3][1] << 1) | (iv[3][2] >> 7); 184331766Sken iv[3][2] = (iv[3][2] << 1) | (iv[3][3] >> 7); 185331766Sken iv[3][3] = (iv[3][3] << 1) | ((outBuffer[k/8] >> (7-(k&7))) & 1); 186331766Sken } 187331766Sken } 188331766Sken break; 189331766Sken 190331766Sken default: 191331766Sken return BAD_CIPHER_STATE; 192331766Sken } 193331766Sken 194331766Sken return 128*numBlocks; 195331766Sken} 196331766Sken 197331766Sken/** 198331766Sken * Encrypt data partitioned in octets, using RFC 2040-like padding. 199331766Sken * 200331766Sken * @param input data to be encrypted (octet sequence) 201331766Sken * @param inputOctets input length in octets (not bits) 202331766Sken * @param outBuffer encrypted output data 203331766Sken * 204331766Sken * @return length in octets (not bits) of the encrypted output buffer. 205331766Sken */ 206331766Skenint rijndael_padEncrypt(cipherInstance *cipher, keyInstance *key, 207331766Sken BYTE *input, int inputOctets, BYTE *outBuffer) { 208331766Sken int i, numBlocks, padLen; 209331766Sken u8 block[16], *iv, *cp; 210331766Sken 211331766Sken if (cipher == NULL || 212331766Sken key == NULL || 213331766Sken key->direction == DIR_DECRYPT) { 214331766Sken return BAD_CIPHER_STATE; 215331766Sken } 216331766Sken if (input == NULL || inputOctets <= 0) { 217331766Sken return 0; /* nothing to do */ 218331766Sken } 219331766Sken 220331766Sken numBlocks = inputOctets/16; 221331766Sken 222331766Sken switch (cipher->mode) { 223331766Sken case MODE_ECB: 224331766Sken for (i = numBlocks; i > 0; i--) { 225331766Sken rijndaelEncrypt(input, outBuffer, key->keySched, key->ROUNDS); 226331766Sken input += 16; 227331766Sken outBuffer += 16; 228331766Sken } 229331766Sken padLen = 16 - (inputOctets - 16*numBlocks); 230331766Sken if (padLen <= 0 || padLen > 16) 231331766Sken return BAD_CIPHER_STATE; 232331766Sken bcopy(input, block, 16 - padLen); 233331766Sken for (cp = block + 16 - padLen; cp < block + 16; cp++) 234331766Sken *cp = padLen; 235331766Sken rijndaelEncrypt(block, outBuffer, key->keySched, key->ROUNDS); 236331766Sken break; 237331766Sken 238331766Sken case MODE_CBC: 239331766Sken iv = cipher->IV; 240331766Sken for (i = numBlocks; i > 0; i--) { 241331766Sken ((u32*)block)[0] = ((u32*)input)[0] ^ ((u32*)iv)[0]; 242331766Sken ((u32*)block)[1] = ((u32*)input)[1] ^ ((u32*)iv)[1]; 243331766Sken ((u32*)block)[2] = ((u32*)input)[2] ^ ((u32*)iv)[2]; 244331766Sken ((u32*)block)[3] = ((u32*)input)[3] ^ ((u32*)iv)[3]; 245331766Sken rijndaelEncrypt(block, outBuffer, key->keySched, key->ROUNDS); 246331766Sken iv = outBuffer; 247331766Sken input += 16; 248331766Sken outBuffer += 16; 249331766Sken } 250331766Sken padLen = 16 - (inputOctets - 16*numBlocks); 251331766Sken if (padLen <= 0 || padLen > 16) 252331766Sken return BAD_CIPHER_STATE; 253331766Sken for (i = 0; i < 16 - padLen; i++) { 254331766Sken block[i] = input[i] ^ iv[i]; 255331766Sken } 256331766Sken for (i = 16 - padLen; i < 16; i++) { 257331766Sken block[i] = (BYTE)padLen ^ iv[i]; 258331766Sken } 259331766Sken rijndaelEncrypt(block, outBuffer, key->keySched, key->ROUNDS); 260331766Sken break; 261331766Sken 262331766Sken default: 263331766Sken return BAD_CIPHER_STATE; 264331766Sken } 265331766Sken 266331766Sken return 16*(numBlocks + 1); 267331766Sken} 268331766Sken 269331766Skenint rijndael_blockDecrypt(cipherInstance *cipher, keyInstance *key, 270331766Sken BYTE *input, int inputLen, BYTE *outBuffer) { 271331766Sken int i, k, numBlocks; 272331766Sken u8 block[16], iv[4][4]; 273331766Sken 274331766Sken if (cipher == NULL || 275331766Sken key == NULL || 276331766Sken (cipher->mode != MODE_CFB1 && key->direction == DIR_ENCRYPT)) { 277331766Sken return BAD_CIPHER_STATE; 278331766Sken } 279331766Sken if (input == NULL || inputLen <= 0) { 280331766Sken return 0; /* nothing to do */ 281331766Sken } 282331766Sken 283331766Sken numBlocks = inputLen/128; 284331766Sken 285331766Sken switch (cipher->mode) { 286331766Sken case MODE_ECB: 287331766Sken for (i = numBlocks; i > 0; i--) { 288331766Sken rijndaelDecrypt(input, outBuffer, key->keySched, key->ROUNDS); 289331766Sken input += 16; 290331766Sken outBuffer += 16; 291331766Sken } 292331766Sken break; 293331766Sken 294331766Sken case MODE_CBC: 295331766Sken#if 1 /*STRICT_ALIGN */ 296331766Sken bcopy(cipher->IV, iv, 16); 297331766Sken#else 298331766Sken *((u32*)iv[0]) = *((u32*)(cipher->IV )); 299331766Sken *((u32*)iv[1]) = *((u32*)(cipher->IV+ 4)); 300331766Sken *((u32*)iv[2]) = *((u32*)(cipher->IV+ 8)); 301331766Sken *((u32*)iv[3]) = *((u32*)(cipher->IV+12)); 302331766Sken#endif 303331766Sken for (i = numBlocks; i > 0; i--) { 304331766Sken rijndaelDecrypt(input, block, key->keySched, key->ROUNDS); 305331766Sken ((u32*)block)[0] ^= *((u32*)iv[0]); 306331766Sken ((u32*)block)[1] ^= *((u32*)iv[1]); 307331766Sken ((u32*)block)[2] ^= *((u32*)iv[2]); 308331766Sken ((u32*)block)[3] ^= *((u32*)iv[3]); 309331766Sken#if 1 /*STRICT_ALIGN*/ 310331766Sken bcopy(input, iv, 16); 311331766Sken bcopy(block, outBuffer, 16); 312331766Sken#else 313331766Sken *((u32*)iv[0]) = ((u32*)input)[0]; ((u32*)outBuffer)[0] = ((u32*)block)[0]; 314331766Sken *((u32*)iv[1]) = ((u32*)input)[1]; ((u32*)outBuffer)[1] = ((u32*)block)[1]; 315331766Sken *((u32*)iv[2]) = ((u32*)input)[2]; ((u32*)outBuffer)[2] = ((u32*)block)[2]; 316331766Sken *((u32*)iv[3]) = ((u32*)input)[3]; ((u32*)outBuffer)[3] = ((u32*)block)[3]; 317331766Sken#endif 318331766Sken input += 16; 319331766Sken outBuffer += 16; 320331766Sken } 321331766Sken break; 322331766Sken 323331766Sken case MODE_CFB1: 324331766Sken#if 1 /*STRICT_ALIGN */ 325331766Sken bcopy(cipher->IV, iv, 16); 326331766Sken#else 327331766Sken *((u32*)iv[0]) = *((u32*)(cipher->IV)); 328331766Sken *((u32*)iv[1]) = *((u32*)(cipher->IV+ 4)); 329331766Sken *((u32*)iv[2]) = *((u32*)(cipher->IV+ 8)); 330331766Sken *((u32*)iv[3]) = *((u32*)(cipher->IV+12)); 331331766Sken#endif 332331766Sken for (i = numBlocks; i > 0; i--) { 333331766Sken for (k = 0; k < 128; k++) { 334331766Sken *((u32*) block ) = *((u32*)iv[0]); 335331766Sken *((u32*)(block+ 4)) = *((u32*)iv[1]); 336331766Sken *((u32*)(block+ 8)) = *((u32*)iv[2]); 337331766Sken *((u32*)(block+12)) = *((u32*)iv[3]); 338331766Sken rijndaelEncrypt(block, block, key->keySched, key->ROUNDS); 339331766Sken iv[0][0] = (iv[0][0] << 1) | (iv[0][1] >> 7); 340331766Sken iv[0][1] = (iv[0][1] << 1) | (iv[0][2] >> 7); 341331766Sken iv[0][2] = (iv[0][2] << 1) | (iv[0][3] >> 7); 342331766Sken iv[0][3] = (iv[0][3] << 1) | (iv[1][0] >> 7); 343331766Sken iv[1][0] = (iv[1][0] << 1) | (iv[1][1] >> 7); 344331766Sken iv[1][1] = (iv[1][1] << 1) | (iv[1][2] >> 7); 345331766Sken iv[1][2] = (iv[1][2] << 1) | (iv[1][3] >> 7); 346331766Sken iv[1][3] = (iv[1][3] << 1) | (iv[2][0] >> 7); 347331766Sken iv[2][0] = (iv[2][0] << 1) | (iv[2][1] >> 7); 348331766Sken iv[2][1] = (iv[2][1] << 1) | (iv[2][2] >> 7); 349331766Sken iv[2][2] = (iv[2][2] << 1) | (iv[2][3] >> 7); 350331766Sken iv[2][3] = (iv[2][3] << 1) | (iv[3][0] >> 7); 351331766Sken iv[3][0] = (iv[3][0] << 1) | (iv[3][1] >> 7); 352331766Sken iv[3][1] = (iv[3][1] << 1) | (iv[3][2] >> 7); 353331766Sken iv[3][2] = (iv[3][2] << 1) | (iv[3][3] >> 7); 354331766Sken iv[3][3] = (iv[3][3] << 1) | ((input[k/8] >> (7-(k&7))) & 1); 355331766Sken outBuffer[k/8] ^= (block[0] & 0x80) >> (k & 7); 356331766Sken } 357331766Sken } 358331766Sken break; 359331766Sken 360331766Sken default: 361331766Sken return BAD_CIPHER_STATE; 362331766Sken } 363331766Sken 364331766Sken return 128*numBlocks; 365331766Sken} 366331766Sken 367331766Skenint rijndael_padDecrypt(cipherInstance *cipher, keyInstance *key, 368331766Sken BYTE *input, int inputOctets, BYTE *outBuffer) { 369 int i, numBlocks, padLen; 370 u8 block[16]; 371 u32 iv[4]; 372 373 if (cipher == NULL || 374 key == NULL || 375 key->direction == DIR_ENCRYPT) { 376 return BAD_CIPHER_STATE; 377 } 378 if (input == NULL || inputOctets <= 0) { 379 return 0; /* nothing to do */ 380 } 381 if (inputOctets % 16 != 0) { 382 return BAD_DATA; 383 } 384 385 numBlocks = inputOctets/16; 386 387 switch (cipher->mode) { 388 case MODE_ECB: 389 /* all blocks but last */ 390 for (i = numBlocks - 1; i > 0; i--) { 391 rijndaelDecrypt(input, outBuffer, key->keySched, key->ROUNDS); 392 input += 16; 393 outBuffer += 16; 394 } 395 /* last block */ 396 rijndaelDecrypt(input, block, key->keySched, key->ROUNDS); 397 padLen = block[15]; 398 if (padLen >= 16) { 399 return BAD_DATA; 400 } 401 for (i = 16 - padLen; i < 16; i++) { 402 if (block[i] != padLen) { 403 return BAD_DATA; 404 } 405 } 406 bcopy(block, outBuffer, 16 - padLen); 407 break; 408 409 case MODE_CBC: 410 bcopy(cipher->IV, iv, 16); 411 /* all blocks but last */ 412 for (i = numBlocks - 1; i > 0; i--) { 413 rijndaelDecrypt(input, block, key->keySched, key->ROUNDS); 414 ((u32*)block)[0] ^= iv[0]; 415 ((u32*)block)[1] ^= iv[1]; 416 ((u32*)block)[2] ^= iv[2]; 417 ((u32*)block)[3] ^= iv[3]; 418 bcopy(input, iv, 16); 419 bcopy(block, outBuffer, 16); 420 input += 16; 421 outBuffer += 16; 422 } 423 /* last block */ 424 rijndaelDecrypt(input, block, key->keySched, key->ROUNDS); 425 ((u32*)block)[0] ^= iv[0]; 426 ((u32*)block)[1] ^= iv[1]; 427 ((u32*)block)[2] ^= iv[2]; 428 ((u32*)block)[3] ^= iv[3]; 429 padLen = block[15]; 430 if (padLen <= 0 || padLen > 16) { 431 return BAD_DATA; 432 } 433 for (i = 16 - padLen; i < 16; i++) { 434 if (block[i] != padLen) { 435 return BAD_DATA; 436 } 437 } 438 bcopy(block, outBuffer, 16 - padLen); 439 break; 440 441 default: 442 return BAD_CIPHER_STATE; 443 } 444 445 return 16*numBlocks - padLen; 446} 447 448#ifdef INTERMEDIATE_VALUE_KAT 449/** 450 * cipherUpdateRounds: 451 * 452 * Encrypts/Decrypts exactly one full block a specified number of rounds. 453 * Only used in the Intermediate Value Known Answer Test. 454 * 455 * Returns: 456 * TRUE - on success 457 * BAD_CIPHER_STATE - cipher in bad state (e.g., not initialized) 458 */ 459int rijndael_cipherUpdateRounds(cipherInstance *cipher, keyInstance *key, 460 BYTE *input, int inputLen, BYTE *outBuffer, int rounds) { 461 int j; 462 u8 block[4][4]; 463 464 if (cipher == NULL || key == NULL) { 465 return BAD_CIPHER_STATE; 466 } 467 468 for (j = 3; j >= 0; j--) { 469 /* parse input stream into rectangular array */ 470 *((u32*)block[j]) = *((u32*)(input+4*j)); 471 } 472 473 switch (key->direction) { 474 case DIR_ENCRYPT: 475 rijndaelEncryptRound(block, key->keySched, key->ROUNDS, rounds); 476 break; 477 478 case DIR_DECRYPT: 479 rijndaelDecryptRound(block, key->keySched, key->ROUNDS, rounds); 480 break; 481 482 default: 483 return BAD_KEY_DIR; 484 } 485 486 for (j = 3; j >= 0; j--) { 487 /* parse rectangular array into output ciphertext bytes */ 488 *((u32*)(outBuffer+4*j)) = *((u32*)block[j]); 489 } 490 491 return TRUE; 492} 493#endif /* INTERMEDIATE_VALUE_KAT */ 494