Ignore:
Timestamp:
May 1, 2009, 12:30:57 AM (15 years ago)
Author:
katerina
Message:

Fix gcc 4.4 compiler warnings. Release 2.5.5.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/rijndael-api-fst.c

    r1 r230  
    2323#ifdef SH_ENCRYPT
    2424
    25 #include "rijndael-alg-fst.h"
    2625#include "rijndael-api-fst.h"
    2726
    … …  
    124123                 RIJ_BYTE *input, int inputLen, RIJ_BYTE *outBuffer) {
    125124  int i, k, numBlocks;
    126   word8 block[16], iv[4][4];
     125  union {
     126    word32 bloc4[4];
     127    word8  block[16];
     128  } bb;
     129  union {
     130    word32 i4[4];
     131    word8  iv[4][4];
     132  } iu;
    127133 
    128134  if (cipher == NULL ||
    … …  
    151157     */
    152158#if STRICT_ALIGN
    153     memcpy(iv, cipher->IV, 16);
    154     ((word32*)block)[0] = ((word32*)iv)[0] ^ ((word32*)input)[0];
    155     ((word32*)block)[1] = ((word32*)iv)[1] ^ ((word32*)input)[1];
    156     ((word32*)block)[2] = ((word32*)iv)[2] ^ ((word32*)input)[2];
    157     ((word32*)block)[3] = ((word32*)iv)[3] ^ ((word32*)input)[3];
     159    memcpy(iu.iv, cipher->IV, 16);
     160    bb.bloc4[0] = iu.i4[0] ^ ((word32*)input)[0];
     161    bb.bloc4[1] = iu.i4[1] ^ ((word32*)input)[1];
     162    bb.bloc4[2] = iu.i4[2] ^ ((word32*)input)[2];
     163    bb.bloc4[3] = iu.i4[3] ^ ((word32*)input)[3];
    158164#else  /* !STRICT_ALIGN */
    159165    ((word32*)block)[0] = ((word32*)cipher->IV)[0] ^ ((word32*)input)[0];
    … …  
    162168    ((word32*)block)[3] = ((word32*)cipher->IV)[3] ^ ((word32*)input)[3];
    163169#endif /* ?STRICT_ALIGN */
    164     rijndaelEncrypt(block, outBuffer, key->keySched, key->ROUNDS);
     170    rijndaelEncrypt(bb.block, outBuffer, key->keySched, key->ROUNDS);
    165171    input += 16;
    166172    for (i = numBlocks - 1; i > 0; i--) {
    167       ((word32*)block)[0] = ((word32*)outBuffer)[0] ^ ((word32*)input)[0];
    168       ((word32*)block)[1] = ((word32*)outBuffer)[1] ^ ((word32*)input)[1];
    169       ((word32*)block)[2] = ((word32*)outBuffer)[2] ^ ((word32*)input)[2];
    170       ((word32*)block)[3] = ((word32*)outBuffer)[3] ^ ((word32*)input)[3];
     173      bb.bloc4[0] = ((word32*)outBuffer)[0] ^ ((word32*)input)[0];
     174      bb.bloc4[1] = ((word32*)outBuffer)[1] ^ ((word32*)input)[1];
     175      bb.bloc4[2] = ((word32*)outBuffer)[2] ^ ((word32*)input)[2];
     176      bb.bloc4[3] = ((word32*)outBuffer)[3] ^ ((word32*)input)[3];
    171177      outBuffer += 16;
    172       rijndaelEncrypt(block, outBuffer, key->keySched, key->ROUNDS);
     178      rijndaelEncrypt(bb.block, outBuffer, key->keySched, key->ROUNDS);
    173179      input += 16;
    174180    }
    … …  
    177183  case MODE_CFB1:
    178184#if STRICT_ALIGN
    179     memcpy(iv, cipher->IV, 16);
     185    memcpy(iu.iv, cipher->IV, 16);
    180186#else  /* !STRICT_ALIGN */
    181187    *((word32*)iv[0]) = *((word32*)(cipher->IV   ));
    … …  
    186192    for (i = numBlocks; i > 0; i--) {
    187193      for (k = 0; k < 128; k++) {
    188         *((word32*) block    ) = *((word32*)iv[0]);
    189         *((word32*)(block+ 4)) = *((word32*)iv[1]);
    190         *((word32*)(block+ 8)) = *((word32*)iv[2]);
    191         *((word32*)(block+12)) = *((word32*)iv[3]);
    192         rijndaelEncrypt(block, block, key->keySched, key->ROUNDS);
    193         outBuffer[k/8] ^= (block[0] & 0x80) >> (k & 7);
    194         iv[0][0] = (iv[0][0] << 1) | (iv[0][1] >> 7);
    195         iv[0][1] = (iv[0][1] << 1) | (iv[0][2] >> 7);
    196         iv[0][2] = (iv[0][2] << 1) | (iv[0][3] >> 7);
    197         iv[0][3] = (iv[0][3] << 1) | (iv[1][0] >> 7);
    198         iv[1][0] = (iv[1][0] << 1) | (iv[1][1] >> 7);
    199         iv[1][1] = (iv[1][1] << 1) | (iv[1][2] >> 7);
    200         iv[1][2] = (iv[1][2] << 1) | (iv[1][3] >> 7);
    201         iv[1][3] = (iv[1][3] << 1) | (iv[2][0] >> 7);
    202         iv[2][0] = (iv[2][0] << 1) | (iv[2][1] >> 7);
    203         iv[2][1] = (iv[2][1] << 1) | (iv[2][2] >> 7);
    204         iv[2][2] = (iv[2][2] << 1) | (iv[2][3] >> 7);
    205         iv[2][3] = (iv[2][3] << 1) | (iv[3][0] >> 7);
    206         iv[3][0] = (iv[3][0] << 1) | (iv[3][1] >> 7);
    207         iv[3][1] = (iv[3][1] << 1) | (iv[3][2] >> 7);
    208         iv[3][2] = (iv[3][2] << 1) | (iv[3][3] >> 7);
    209         iv[3][3] = (iv[3][3] << 1) | ((outBuffer[k/8] >> (7-(k&7))) & 1);
     194        bb.bloc4[0] = iu.i4[0];
     195        bb.bloc4[1] = iu.i4[1];
     196        bb.bloc4[2] = iu.i4[2];
     197        bb.bloc4[3] = iu.i4[3];
     198        rijndaelEncrypt(bb.block, bb.block, key->keySched, key->ROUNDS);
     199        outBuffer[k/8] ^= (bb.block[0] & 0x80) >> (k & 7);
     200        iu.iv[0][0] = (iu.iv[0][0] << 1) | (iu.iv[0][1] >> 7);
     201        iu.iv[0][1] = (iu.iv[0][1] << 1) | (iu.iv[0][2] >> 7);
     202        iu.iv[0][2] = (iu.iv[0][2] << 1) | (iu.iv[0][3] >> 7);
     203        iu.iv[0][3] = (iu.iv[0][3] << 1) | (iu.iv[1][0] >> 7);
     204        iu.iv[1][0] = (iu.iv[1][0] << 1) | (iu.iv[1][1] >> 7);
     205        iu.iv[1][1] = (iu.iv[1][1] << 1) | (iu.iv[1][2] >> 7);
     206        iu.iv[1][2] = (iu.iv[1][2] << 1) | (iu.iv[1][3] >> 7);
     207        iu.iv[1][3] = (iu.iv[1][3] << 1) | (iu.iv[2][0] >> 7);
     208        iu.iv[2][0] = (iu.iv[2][0] << 1) | (iu.iv[2][1] >> 7);
     209        iu.iv[2][1] = (iu.iv[2][1] << 1) | (iu.iv[2][2] >> 7);
     210        iu.iv[2][2] = (iu.iv[2][2] << 1) | (iu.iv[2][3] >> 7);
     211        iu.iv[2][3] = (iu.iv[2][3] << 1) | (iu.iv[3][0] >> 7);
     212        iu.iv[3][0] = (iu.iv[3][0] << 1) | (iu.iv[3][1] >> 7);
     213        iu.iv[3][1] = (iu.iv[3][1] << 1) | (iu.iv[3][2] >> 7);
     214        iu.iv[3][2] = (iu.iv[3][2] << 1) | (iu.iv[3][3] >> 7);
     215        iu.iv[3][3] = (iu.iv[3][3] << 1) | ((outBuffer[k/8] >> (7-(k&7))) & 1);
    210216      }
    211217    }
    … …  
    222228                 RIJ_BYTE *input, int inputLen, RIJ_BYTE *outBuffer) {
    223229  int i, k, numBlocks;
    224   word8 block[16], iv[4][4];
     230  union {
     231    word32 bloc4[4];
     232    word8  block[16];
     233  } bb;
     234  union {
     235    word32 i4[4];
     236    word8  iv[4][4];
     237  } iu;
    225238 
    226239  if (cipher == NULL ||
    … …  
    246259  case MODE_CBC:
    247260#if STRICT_ALIGN
    248     memcpy(iv, cipher->IV, 16);
    249 #else
    250     *((word32*)iv[0]) = *((word32*)(cipher->IV   ));
    251     *((word32*)iv[1]) = *((word32*)(cipher->IV+ 4));
    252     *((word32*)iv[2]) = *((word32*)(cipher->IV+ 8));
    253     *((word32*)iv[3]) = *((word32*)(cipher->IV+12));
     261    memcpy(iu.iv, cipher->IV, 16);
     262#else
     263    *((word32*)iu.i4[0]) = *((word32*)(cipher->IV   ));
     264    *((word32*)iu.i4[1]) = *((word32*)(cipher->IV+ 4));
     265    *((word32*)iu.i4[2]) = *((word32*)(cipher->IV+ 8));
     266    *((word32*)iu.i4[3]) = *((word32*)(cipher->IV+12));
    254267#endif
    255268    for (i = numBlocks; i > 0; i--) {
    256       rijndaelDecrypt(input, block, key->keySched, key->ROUNDS);
    257       ((word32*)block)[0] ^= *((word32*)iv[0]);
    258       ((word32*)block)[1] ^= *((word32*)iv[1]);
    259       ((word32*)block)[2] ^= *((word32*)iv[2]);
    260       ((word32*)block)[3] ^= *((word32*)iv[3]);
     269      rijndaelDecrypt(input, bb.block, key->keySched, key->ROUNDS);
     270      bb.bloc4[0] ^= iu.i4[0];
     271      bb.bloc4[1] ^= iu.i4[1];
     272      bb.bloc4[2] ^= iu.i4[2];
     273      bb.bloc4[3] ^= iu.i4[3];
    261274#if STRICT_ALIGN
    262       memcpy(iv, input, 16);
    263       memcpy(outBuffer, block, 16);
     275      memcpy(iu.iv, input, 16);
     276      memcpy(outBuffer, bb.block, 16);
    264277#else
    265278      *((word32*)iv[0]) = ((word32*)input)[0]; ((word32*)outBuffer)[0] = ((word32*)block)[0];
    … …  
    275288  case MODE_CFB1:
    276289#if STRICT_ALIGN
    277     memcpy(iv, cipher->IV, 16);
     290    memcpy(iu.iv, cipher->IV, 16);
    278291#else
    279292    *((word32*)iv[0]) = *((word32*)(cipher->IV));
    … …  
    284297    for (i = numBlocks; i > 0; i--) {
    285298      for (k = 0; k < 128; k++) {
    286         *((word32*) block    ) = *((word32*)iv[0]);
    287         *((word32*)(block+ 4)) = *((word32*)iv[1]);
    288         *((word32*)(block+ 8)) = *((word32*)iv[2]);
    289         *((word32*)(block+12)) = *((word32*)iv[3]);
    290         rijndaelEncrypt(block, block, key->keySched, key->ROUNDS);
    291         iv[0][0] = (iv[0][0] << 1) | (iv[0][1] >> 7);
    292         iv[0][1] = (iv[0][1] << 1) | (iv[0][2] >> 7);
    293         iv[0][2] = (iv[0][2] << 1) | (iv[0][3] >> 7);
    294         iv[0][3] = (iv[0][3] << 1) | (iv[1][0] >> 7);
    295         iv[1][0] = (iv[1][0] << 1) | (iv[1][1] >> 7);
    296         iv[1][1] = (iv[1][1] << 1) | (iv[1][2] >> 7);
    297         iv[1][2] = (iv[1][2] << 1) | (iv[1][3] >> 7);
    298         iv[1][3] = (iv[1][3] << 1) | (iv[2][0] >> 7);
    299         iv[2][0] = (iv[2][0] << 1) | (iv[2][1] >> 7);
    300         iv[2][1] = (iv[2][1] << 1) | (iv[2][2] >> 7);
    301         iv[2][2] = (iv[2][2] << 1) | (iv[2][3] >> 7);
    302         iv[2][3] = (iv[2][3] << 1) | (iv[3][0] >> 7);
    303         iv[3][0] = (iv[3][0] << 1) | (iv[3][1] >> 7);
    304         iv[3][1] = (iv[3][1] << 1) | (iv[3][2] >> 7);
    305         iv[3][2] = (iv[3][2] << 1) | (iv[3][3] >> 7);
    306         iv[3][3] = (iv[3][3] << 1) | ((input[k/8] >> (7-(k&7))) & 1);
    307         outBuffer[k/8] ^= (block[0] & 0x80) >> (k & 7);
     299        bb.bloc4[0] = iu.i4[0];
     300        bb.bloc4[1] = iu.i4[1];
     301        bb.bloc4[2] = iu.i4[2];
     302        bb.bloc4[3] = iu.i4[3];
     303        rijndaelEncrypt(bb.block, bb.block, key->keySched, key->ROUNDS);
     304        iu.iv[0][0] = (iu.iv[0][0] << 1) | (iu.iv[0][1] >> 7);
     305        iu.iv[0][1] = (iu.iv[0][1] << 1) | (iu.iv[0][2] >> 7);
     306        iu.iv[0][2] = (iu.iv[0][2] << 1) | (iu.iv[0][3] >> 7);
     307        iu.iv[0][3] = (iu.iv[0][3] << 1) | (iu.iv[1][0] >> 7);
     308        iu.iv[1][0] = (iu.iv[1][0] << 1) | (iu.iv[1][1] >> 7);
     309        iu.iv[1][1] = (iu.iv[1][1] << 1) | (iu.iv[1][2] >> 7);
     310        iu.iv[1][2] = (iu.iv[1][2] << 1) | (iu.iv[1][3] >> 7);
     311        iu.iv[1][3] = (iu.iv[1][3] << 1) | (iu.iv[2][0] >> 7);
     312        iu.iv[2][0] = (iu.iv[2][0] << 1) | (iu.iv[2][1] >> 7);
     313        iu.iv[2][1] = (iu.iv[2][1] << 1) | (iu.iv[2][2] >> 7);
     314        iu.iv[2][2] = (iu.iv[2][2] << 1) | (iu.iv[2][3] >> 7);
     315        iu.iv[2][3] = (iu.iv[2][3] << 1) | (iu.iv[3][0] >> 7);
     316        iu.iv[3][0] = (iu.iv[3][0] << 1) | (iu.iv[3][1] >> 7);
     317        iu.iv[3][1] = (iu.iv[3][1] << 1) | (iu.iv[3][2] >> 7);
     318        iu.iv[3][2] = (iu.iv[3][2] << 1) | (iu.iv[3][3] >> 7);
     319        iu.iv[3][3] = (iu.iv[3][3] << 1) | ((input[k/8] >> (7-(k&7))) & 1);
     320        outBuffer[k/8] ^= (bb.block[0] & 0x80) >> (k & 7);
    308321      }
    309322    }
    … …  
    316329  return 128*numBlocks;
    317330}
    318 
     331#ifdef INTERMEDIATE_VALUE_KAT
     332/**
     333 *      cipherUpdateRounds:
     334 *
     335 *      Encrypts/Decrypts exactly one full block a specified number of rounds.
     336 *      Only used in the Intermediate Value Known Answer Test. 
     337 *
     338 *      Returns:
     339 *              TRUE - on success
     340 *              BAD_CIPHER_STATE - cipher in bad state (e.g., not initialized)
     341 */
     342int cipherUpdateRounds(cipherInstance *cipher, keyInstance *key,
     343                RIJ_BYTE *input, int inputLen, RIJ_BYTE *outBuffer, int rounds) {
     344        int j;
     345        word8 block[4][4];
     346
     347        if (cipher == NULL || key == NULL) {
     348                return BAD_CIPHER_STATE;
     349        }
     350
     351        for (j = 3; j >= 0; j--) {
     352                /* parse input stream into rectangular array */
     353                *((word32*)block[j]) = *((word32*)(input+4*j));
     354        }
     355
     356        switch (key->direction) {
     357        case DIR_ENCRYPT:
     358                rijndaelEncryptRound(block, key->keySched, key->ROUNDS, rounds);
     359                break;
     360               
     361        case DIR_DECRYPT:
     362                rijndaelDecryptRound(block, key->keySched, key->ROUNDS, rounds);
     363                break;
     364               
     365        default:
     366                return BAD_KEY_DIR;
     367        }
     368
     369        for (j = 3; j >= 0; j--) {
     370                /* parse rectangular array into output ciphertext bytes */
     371                *((word32*)(outBuffer+4*j)) = *((word32*)block[j]);
     372        }
     373       
     374        return TRUE;
     375}
     376#endif /* INTERMEDIATE_VALUE_KAT */
    319377#endif
Note: See TracChangeset for help on using the changeset viewer.