Ignore:
Timestamp:
11/14/06 13:56:01 (14 years ago)
Author:
Perry Lorier <perry@…>
Branches:
4.0.1-hotfixes, cachetimestamps, develop, dpdk-ndag, etsilive, getfragoff, help, libtrace4, master, ndag_format, pfring, rc-4.0.1, rc-4.0.2, rc-4.0.3, rc-4.0.4, ringdecrementfix, ringperformance, ringtimestampfixes
Children:
2595c4d
Parents:
35e0869
Message:

Fix lots of little warnings

File:
1 edited

Legend:

Unmodified
Added
Removed
  • tools/traceanon/rijndael.c

    rc631f0f ra7282fb  
    1 // $Id$
    2 
    3 //
     1/* $Id$ */
     2
     3/*
    44// File : rijndael.cpp
    55// Creation date : Sun Nov 5 2000 03:22:10 CEST
     
    1010// This code is public domain.
    1111// Based on the Vincent Rijmen and K.U.Leuven implementation 2.4.
    12 //
    13 
    14 //
     12*/
     13
     14/*
    1515// Original Copyright notice:
    1616//
     
    2828//
    2929//    This code is placed in the public domain.
    30 //
    31 
    32 //
     30*/
     31
     32/*
    3333// This implementation works on 128 , 192 , 256 bit keys
    3434// and on 128 bit blocks
    35 //
     35*/
    3636
    3737#define _RIJNDAEL_CPP_
     
    971971
    972972
    973 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     973/*////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    974974// API
    975 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     975//////////////////////////////////////////////////////////////////////////////////////////////////////////////// */
    976976
    977977int rijndael_init(Mode mode,Direction dir,const UINT8 * key,KeyLength keyLen,UINT8 * initVector)
     
    982982        UINT32 j;
    983983
    984         // Not initialized yet
     984        /* Not initialized yet */
    985985        m_state = Invalid;
    986986
    987         // Check the mode
     987        /* Check the mode */
    988988        if((mode != CBC) && (mode != ECB) && (mode != CFB1))return RIJNDAEL_UNSUPPORTED_MODE;
    989989        m_mode = mode;
    990990
    991         // And the direction
     991        /* And the direction */
    992992        if((dir != Encrypt) && (dir != Decrypt))return RIJNDAEL_UNSUPPORTED_DIRECTION;
    993993        m_direction = dir;
    994994
    995         // Allow to set an init vector
     995        /* Allow to set an init vector */
    996996        if(initVector)
    997997        {
    998                 // specified init vector
     998                /* specified init vector */
    999999                for(i = 0;i < MAX_IV_SIZE;i++)
    10001000                {
     
    10021002                }
    10031003        } else {
    1004                 // zero init vector
     1004                /* zero init vector */
    10051005                for(i = 0;i < MAX_IV_SIZE;i++)
    10061006                {
     
    10101010
    10111011
    1012         // And check the key length
     1012        /* And check the key length */
    10131013        switch(keyLen)
    10141014        {
     
    10291029                        break;
    10301030        }
    1031         // The number of rounds is calculated as
     1031        /* The number of rounds is calculated as
    10321032        // m_uRounds = (m_uKeyLenInBits / 32) + 6;
     1033        */
    10331034
    10341035        if(!key)return RIJNDAEL_BAD_KEY;
     
    11541155                        }
    11551156                        padLen = 16 - (inputOctets - 16*numBlocks);
    1156                         //                      assert(padLen > 0 && padLen <= 16);
    11571157                        memcpy(block, input, 16 - padLen);
    11581158                        memset(block + 16 - padLen, padLen, padLen);
     
    11731173                        }
    11741174                        padLen = 16 - (inputOctets - 16*numBlocks);
    1175                         //                      assert(padLen > 0 && padLen <= 16); // DO SOMETHING HERE ?
    11761175                        for (i = 0; i < 16 - padLen; i++) {
    11771176                                block[i] = input[i] ^ iv[i];
     
    13581357}
    13591358
    1360 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     1359/*////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    13611360// ALGORITHM
    1362 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     1361////////////////////////////////////////////////////////////////////////////////////////////////////////////////// */
    13631362
    13641363
     
    13691368        int t = 0;
    13701369
    1371         // Calculate the necessary round keys
    1372         // The number of calculations depends on keyBits and blockBits
     1370        /* Calculate the necessary round keys */
     1371        /* The number of calculations depends on keyBits and blockBits */
    13731372        int uKeyColumns = m_uRounds - 6;
    13741373
    13751374        UINT8 tempKey[_MAX_KEY_COLUMNS][4];
    13761375
    1377         // Copy the input key to the temporary key matrix
     1376        /* Copy the input key to the temporary key matrix */
    13781377
    13791378        for(j = 0;j < uKeyColumns;j++)
     
    13831382
    13841383
    1385         // copy values into round key array
     1384        /* copy values into round key array */
    13861385        for(j = 0;(j < uKeyColumns) && (r <= m_uRounds); )
    13871386        {
     
    15401539        UINT8 temp[4][4];
    15411540
    1542         *((UINT32*)temp[0]) = *((UINT32*)(a   )) ^ *((UINT32*)m_expandedKey[m_uRounds][0]);
    1543         *((UINT32*)temp[1]) = *((UINT32*)(a+ 4)) ^ *((UINT32*)m_expandedKey[m_uRounds][1]);
    1544         *((UINT32*)temp[2]) = *((UINT32*)(a+ 8)) ^ *((UINT32*)m_expandedKey[m_uRounds][2]);
    1545         *((UINT32*)temp[3]) = *((UINT32*)(a+12)) ^ *((UINT32*)m_expandedKey[m_uRounds][3]);
    1546 
    1547         *((UINT32*)(b   )) = *((UINT32*)T5[temp[0][0]])
    1548                 ^ *((UINT32*)T6[temp[3][1]])
    1549                 ^ *((UINT32*)T7[temp[2][2]])
    1550                 ^ *((UINT32*)T8[temp[1][3]]);
    1551         *((UINT32*)(b+ 4)) = *((UINT32*)T5[temp[1][0]])
    1552                 ^ *((UINT32*)T6[temp[0][1]])
    1553                 ^ *((UINT32*)T7[temp[3][2]])
    1554                 ^ *((UINT32*)T8[temp[2][3]]);
     1541        *((UINT32*)temp[0]) = *((const UINT32*)(a   )) ^ *((const UINT32*)m_expandedKey[m_uRounds][0]);
     1542        *((UINT32*)temp[1]) = *((const UINT32*)(a+ 4)) ^ *((const UINT32*)m_expandedKey[m_uRounds][1]);
     1543        *((UINT32*)temp[2]) = *((const UINT32*)(a+ 8)) ^ *((const UINT32*)m_expandedKey[m_uRounds][2]);
     1544        *((UINT32*)temp[3]) = *((const UINT32*)(a+12)) ^ *((const UINT32*)m_expandedKey[m_uRounds][3]);
     1545
     1546        *((UINT32*)(b   )) = *((const UINT32*)T5[temp[0][0]])
     1547                ^ *((const UINT32*)T6[temp[3][1]])
     1548                ^ *((const UINT32*)T7[temp[2][2]])
     1549                ^ *((const UINT32*)T8[temp[1][3]]);
     1550        *((UINT32*)(b+ 4)) = *((const UINT32*)T5[temp[1][0]])
     1551                ^ *((const UINT32*)T6[temp[0][1]])
     1552                ^ *((const UINT32*)T7[temp[3][2]])
     1553                ^ *((const UINT32*)T8[temp[2][3]]);
    15551554        *((UINT32*)(b+ 8)) = *((UINT32*)T5[temp[2][0]])
    1556                 ^ *((UINT32*)T6[temp[1][1]])
    1557                 ^ *((UINT32*)T7[temp[0][2]])
    1558                 ^ *((UINT32*)T8[temp[3][3]]);
     1555                ^ *((const UINT32*)T6[temp[1][1]])
     1556                ^ *((const UINT32*)T7[temp[0][2]])
     1557                ^ *((const UINT32*)T8[temp[3][3]]);
    15591558        *((UINT32*)(b+12)) = *((UINT32*)T5[temp[3][0]])
    1560                 ^ *((UINT32*)T6[temp[2][1]])
    1561                 ^ *((UINT32*)T7[temp[1][2]])
    1562                 ^ *((UINT32*)T8[temp[0][3]]);
     1559                ^ *((const UINT32*)T6[temp[2][1]])
     1560                ^ *((const UINT32*)T7[temp[1][2]])
     1561                ^ *((const UINT32*)T8[temp[0][3]]);
    15631562        for(r = m_uRounds-1; r > 1; r--)
    15641563        {
Note: See TracChangeset for help on using the changeset viewer.