void AES_CPU_Impl_O0::EncryptBlock(UINT8 *dst, const UINT8 *src) { UINT8 m_state[m_Nb][4]; for( UINT32 i = 0; i < 4; i++ ) for( UINT32 j = 0; j < 4; j++ ) m_state[j][i] = src[i*4 + j]; // Add the First round key to the state before starting the rounds. AddRoundKey(m_state, 0); // There will be m_Nr rounds. // The first m_Nr-1 rounds are identical. // These m_Nr-1 rounds are executed in the loop below. for( UINT32 round = 1; round < m_Nr; round++ ) { SubBytes(m_state); ShiftRows(m_state); MixColumns(m_state); AddRoundKey(m_state, round); } // The last round is given below. // The MixColumns function is not here in the last round. SubBytes(m_state); ShiftRows(m_state); AddRoundKey(m_state, m_Nr); for( UINT32 i = 0; i < 4; i++ ) for( UINT32 j = 0; j < 4; j++ ) dst[i*4 + j] = m_state[j][i]; }
/////////////////////////////////////////////////////////////////////////////// // 函数名: AES_Init // 描述: 初始化,在此执行扩展密钥操作。 // 输入参数: pKey -- 原始密钥,其长度必须为 AES_KEY_LENGTH/8 字节。 // 输出参数: 无。 // 返回值: 无。 /////////////////////////////////////////////////////////////////////////////// void AES_Init(const void *pKey) { // 扩展密钥 unsigned char i; unsigned char *pRoundKey; unsigned char Rcon[4] = {0x01, 0x00, 0x00, 0x00}; memcpy(g_roundKeyTable, pKey, 4*Nk); pRoundKey = &g_roundKeyTable[4*Nk]; for (i = Nk; i < Nb*(Nr+1); pRoundKey += 4, i++) { memcpy(pRoundKey, pRoundKey - 4, 4); if (i % Nk == 0) { RotationWord(pRoundKey); SubBytes(pRoundKey, 4, 0); XorBytes(pRoundKey, Rcon, 4); Rcon[0] = GfMultBy02(Rcon[0]); } else if (Nk > 6 && i % Nk == Nb) { SubBytes(pRoundKey, 4, 0); } XorBytes(pRoundKey, pRoundKey - 4*Nk, 4); } }
//============================================================================== void Decrypt( uint8_t *keyblok, uint8_t *buff, uint8_t *result) //Функция расшифровывания { uint8_t i,j; //Счетчики KeyExpansion( keyblok, DECRYPT); //Вычисление раундовых ключей for(i=j=0; i<Nb; i++, j+=4) s[i]= pack((uint8_t *)&buff[j]); //Заполнение промежуточного массива i=0; AddRoundKey(s , rkey , 0); ////Операция исключающее или с раундовым ключем for(i=1; i< Nr; i++) { ShiftRows((uint8_t*)s, DECRYPT); SubBytes((uint8_t*)s, DECRYPT); AddRoundKey(s, rkey, i); MixColums(s, Nb, DECRYPT); } ShiftRows((uint8_t*)s, DECRYPT); SubBytes((uint8_t*)s, DECRYPT); AddRoundKey(s, rkey, Nr); for(i=j=0;i<Nb;i++,j+=4) unpack(s[i], (uint8_t*)& result[j]); }
void AES_enc(BYTE* input, BYTE* output,BYTE *w,BYTE Nr) { DWORD i; DWORD round; BYTE gState[4][4]; AES_Memset(&gState[0][0],0,16); for( i=0;i<4*NB;i++) { gState[i%4][i/4]=input[i]; } AddRoundKey(0,w,gState); for ( round = 1; round <= (Nr - 1); round++) { SubBytes(gState); ShiftRows(gState); MixColumns(gState); AddRoundKey(round,w,gState); } // main round loop SubBytes(gState); ShiftRows(gState); AddRoundKey(Nr,w,gState); // output = state for (i = 0; i < (4 * NB); i++) { output[i] = gState[i % 4][ i / 4]; } }
void aes_cipher(ctx_aes* aes, uint8_t* input, uint8_t* output) // encipher 16-bit input { // state = input int i; int round; memset(&aes->State[0][0],0,16); for (i = 0; i < (4 * aes->Nb); i++)// { aes->State[i % 4][ i / 4] = input[i]; } AddRoundKey(aes, 0); for (round = 1; round <= (aes->Nr - 1); round++) // main round loop { SubBytes(aes); ShiftRows(aes); MixColumns(aes); AddRoundKey(aes, round); } // main round loop SubBytes(aes); ShiftRows(aes); AddRoundKey(aes, aes->Nr); // output = state for (i = 0; i < (4 * aes->Nb); i++) { output[i] = aes->State[i % 4][ i / 4]; } } // Cipher()
void Cipher(unsigned char* input, unsigned char* output) // encipher 16-bit input { // state = input int i, round; memset(&State[0][0],0,16); for (i = 0; i < (4 * Nb); i++)// { State[i % 4][ i / 4] = input[i]; //State[i / 4][ i % 4] = input[i]; } //Dump(); AddRoundKey(0); for (round = 1; round <= (Nr - 1); round++) // main round loop { SubBytes(); ShiftRows(); MixColumns(); AddRoundKey(round); } // main round loop SubBytes(); ShiftRows(); AddRoundKey(Nr); // output = state for (i = 0; i < (4 * Nb); i++) { output[i] = State[i % 4][ i / 4]; } } // Cipher()
/** * @brief Encrypts 16 bytes of data. * * Based on Advanced Encryption Standard specification. * * @param dataToEncrypt Data to encrypt, must be at least 16 bytes in size. * @param result Destination to store encrypted data, must be at least 16 bytes in size. * @param numRounds Number of rounds. * @param roundKey Round key. */ void ThreadMessageItemEncrypt::Cipher(unsigned char * dataToEncrypt,unsigned char * result, unsigned char numRounds, unsigned char * roundKey) { // Copy data into state for manipulation for(size_t r = 0;r<EncryptKey::WORD_SIZE;r++) { for(size_t c = 0;c<EncryptKey::WORD_SIZE;c++) { state[r][c] = dataToEncrypt[r+(c*EncryptKey::WORD_SIZE)]; } } // Perform encryption operations XorRoundKey(0,roundKey); for(size_t r = 1; r<numRounds; r++) { SubBytes(); ShiftRowsLeft(); MixColumns(); XorRoundKey(r,roundKey); } SubBytes(); ShiftRowsLeft(); XorRoundKey(numRounds,roundKey); // Copy state into data now that we have finished for(int r = 0;r<EncryptKey::WORD_SIZE;r++) { for(int c = 0;c<EncryptKey::WORD_SIZE;c++) { result[r+(c*EncryptKey::WORD_SIZE)] = state[r][c]; } } }
void Cipher() { int i, j, round=0; for(i=0; i<4; i++) { for(j=0; j<4; j++) { state[j][i] = in[i*4 + j]; } } AddRoundKey(0); for(round=1; round<Nr; round++) { SubBytes(); ShiftRows(); MixColumns(); AddRoundKey(round); } SubBytes(); ShiftRows(); AddRoundKey(Nr); for(i=0; i<4; i++) { for(j=0; j<4; j++) { out[i*4+j]=state[j][i]; } } }
// Cipher is the main function that encrypts the PlainText. void Cipher(unsigned char out[16], unsigned char in[16], unsigned char RoundKey[240], int Nr) { unsigned char state[4][4]; int i,j,round=0; //Copy the input PlainText to state array. for(i=0;i<4;i++) { for(j=0;j<4;j++) { state[j][i] = in[i*4 + j]; } } // Add the First round key to the state before starting the rounds. AddRoundKey(state, RoundKey, 0); #ifdef DEBUG_PRINTOUT std::cerr << " ka="; printState(state); std::cerr << std::endl; #endif // There will be Nr rounds. // The first Nr-1 rounds are identical. // These Nr-1 rounds are executed in the loop below. for(round=1;round<Nr;round++) { SubBytes(state); #ifdef DEBUG_PRINTOUT std::cerr << " sb="; printState(state); std::cerr << std::endl; #endif ShiftRows(state); MixColumns(state); #ifdef DEBUG_PRINTOUT std::cerr << " mc="; printState(state); std::cerr << std::endl; #endif AddRoundKey(state, RoundKey, round); #ifdef DEBUG_PRINTOUT std::cerr << " ka="; printState(state); std::cerr << std::endl; #endif } // The last round is given below. // The MixColumns function is not here in the last round. SubBytes(state); ShiftRows(state); #ifdef DEBUG_PRINTOUT std::cerr << " sr="; printState(state); std::cerr << std::endl; #endif AddRoundKey(state, RoundKey, Nr); #ifdef DEBUG_PRINTOUT std::cerr << " ka="; printState(state); std::cerr << std::endl; #endif // The encryption process is over. // Copy the state array to output array. for(i=0;i<4;i++) { for(j=0;j<4;j++) { out[i*4+j]=state[j][i]; } } }
// Cipher is the main function that encrypts the PlainText. void Cipher() { int i,j,round=0; //Copy the input PlainText to state array. for(i=0;i<4;i++) { for(j=0;j<4;j++) { state[j][i] = in[i*4 + j]; } } // Add the First round key to the state before starting the rounds. AddRoundKey(0); // There will be Nr rounds. // The first Nr-1 rounds are identical. // These Nr-1 rounds are executed in the loop below. for(round=1;round<Nr;round++) { SubBytes(); ShiftRows(); MixColumns(); AddRoundKey(round); // for(i=0;i<4;i++) // { // for(j=0;j<4;j++) // { // // out[i*4+j]=state[j][i]; // printf("%02x",state[j][i]); // } // } printf("\n"); } // The last round is given below. // The MixColumns function is not here in the last round. SubBytes(); ShiftRows(); AddRoundKey(Nr); // The encryption process is over. // Copy the state array to output array. for(i=0;i<4;i++) { for(j=0;j<4;j++) { out[i*4+j]=state[j][i]; } } }
/* apply Q-permutation to x */ void Q(hashState *ctx, u8 x[ROWS][COLS1024]) { u8 i; Variant v = ctx->columns==8?Q512:Q1024; #ifndef TURN_OFF_PRINTING printf(":: BEGIN Q\n"); printf("Input:\n"); PrintState(ctx, x); #endif for (i = 0; i < ctx->rounds; i++) { AddRoundConstant(x, ctx->columns, i, v); #ifndef TURN_OFF_PRINTING printf("t=%d (AddRoundConstant):\n", i); PrintState(ctx, x); #endif SubBytes(x, ctx->columns); #ifndef TURN_OFF_PRINTING printf("t=%d (SubBytes):\n", i); PrintState(ctx, x); #endif ShiftBytes(x, ctx->columns, v); #ifndef TURN_OFF_PRINTING printf("t=%d (ShiftBytes):\n", i); PrintState(ctx, x); #endif MixBytes(x, ctx->columns); #ifndef TURN_OFF_PRINTING printf("t=%d (MixBytes):\n", i); PrintState(ctx, x); #endif } #ifndef TURN_OFF_PRINTING printf(":: END Q\n\n"); #endif }
unsigned char* AES::Cipher(unsigned char* input) { unsigned char state[4][4]; int i,r,c; for(r=0; r<4; r++) { for(c=0; c<4 ;c++) { state[r][c] = input[c*4+r]; } } AddRoundKey(state,w[0]); for(i=1; i<=10; i++) { SubBytes(state); ShiftRows(state); if(i!=10)MixColumns(state); AddRoundKey(state,w[i]); } for(r=0; r<4; r++) { for(c=0; c<4 ;c++) { input[c*4+r] = state[r][c]; } } return input; }
int main(){ unsigned int temp[]={0x19a09ae9,0x3df4c6f8,0xe3e28d48,0xbe2b2a08}; SubBytes(temp); int i=0; for(i=0;i<4;i++) printf("%08x\n",temp[i]); return 0; }
void SubWord(uint32_t in) { uint8_t the_bytes[4]; bytes(in, the_bytes); SubBytes(the_bytes); in = word(the_bytes[0], the_bytes[1], the_bytes[2], the_bytes[3]); }
static void Cipher(uint8x16_t RoundKey_v[]) { uint8_t round = 0; AddRoundKey(RoundKey_v[0]); for(round = 1; round < rounds; ++round) { SubBytes(); ShiftRows(); MixColumns(); AddRoundKey(RoundKey_v[round]); } SubBytes(); ShiftRows(); AddRoundKey(RoundKey_v[rounds]); }
void RijndaelEncrypt( uint8_t state[AES_BLOCK_SIZE], uint8_t eKey[AES_MAX_KEY_SIZE],int32_t Nr ) { int32_t round = 0; AddRoundKey(state,eKey,round); for ( round = 1; round < Nr; ++round ) { SubBytes(state); ShiftRows(state); MixColumns(state); AddRoundKey(state,eKey,round); } SubBytes(state); ShiftRows(state); AddRoundKey(state,eKey,Nr); }
// this is the function that takes a block of plaintext and the key schedule // and encrypts it. the next level of abstraction would be to implement block // modes using this function on each block void EncryptBlock(uint8_t* block, uint8_t* key_schedule) { // the state is always 128 bits for AES. we are going to represent that as // an array of 16 bytes. conceptually it can be useful to think of it as a // 4x4 matrix // // step 1 of the cipher is to initialize the state as the input block of // plaintext. we are just going to operate directly on the input block // step 2 is to do an initial round key addition. the first round key is // added by a simple bitwise xor operation AddRoundKey(block, key_schedule[0, (4*4) - 1]); // step 3 is Nr-1 rounds where Nr is the total number of rounds we will be // performing. Nr is 10, 12, and 14 for keysizes of 128, 192, and 256 // respectively. for (uint8_t round = 0; round < (10 - 1); round++) { // the round function consists of four operations // // SubBytes subsitutes bytes in the state based on the standardized // substitution boxes or S-Boxes SubBytes(block); // ShiftRows cyclically shifts each of the last three rows of state // over by a different offset ShiftRows(block); // MixColumns does some math on the state, column by column MixColumns(block); // finally, we add the next round key to the state AddRoundKey(block, key_schedule[round * (4*4), (round + 1) * 4 - 1]); } // step 4 is the final round. the only difference is that we do not // perform the MixColumns operation on this one SubBytes(block); ShiftRows(block); AddRoundKey(block, key_schedule[10 * (4*4), (10 + 1) * (4*4) - 1]); // all of that fiddling with the state leaves us with the encrypted // block }
// Subbytes void GenSubBytesTab() { SubBytesTab[0] = 0x63; // InvSubBytesTab[0x63] = 0; for (int i = 1; i < 256; i++) { BYTE y = SubBytes((BYTE) i); SubBytesTab[i] = y; InvSubBytesTab[y] = i; } }
// encrypt is the main function that encrypts the PlainText. void encrypt(uint8_t *out, uint8_t *in, uint8_t *expanded_key) { int i,j,round=0; uint8_t state[4][4]; int Nr = 128/32+6;// replace 128 by 192, 256 for larger keys //Copy the input PlainText to state array. for(i=0; i<4; i++) { for(j=0; j<4; j++) { state[j][i] = in[i*4 + j]; } } // Add the First round key to the state before starting the rounds. AddRoundKey(0,state,expanded_key); // There will be Nr rounds. // The first Nr-1 rounds are identical. // These Nr-1 rounds are executed in the loop below. for(round=1; round<Nr; round++) { SubBytes(state); ShiftRows(state); MixColumns(state); AddRoundKey(round,state,expanded_key); } // The last round is given below. // The MixColumns function is not here in the last round. SubBytes(state); ShiftRows(state); AddRoundKey(Nr,state,expanded_key); // The encryption process is over. // Copy the state array to output array. for(i=0; i<4; i++) { for(j=0; j<4; j++) { out[i*4+j]=state[j][i]; } } }
/* * This method performs encrypt operation given plaintext. * It read tables from tf and plaintext from fp. * Encrypts plainetxt using key */ void ProcessEncrypt(char *key, FILE *tf, FILE *fp) { table_check = 0; ProcessTableCheck(tf); char buf[16]; int ret = fread(buf, 1, 16, fp); if (ret < 16) { fprintf(stderr, "Input size for encryption can not be less than 16 bytes\n"); exit(1); } int i, Nr = 10, Nb = 4, round; unsigned char **state = (unsigned char **) malloc( sizeof(unsigned char *) * 4); for (i = 0; i < 4; i++) state[i] = (unsigned char *) malloc(sizeof(unsigned char) * 4); copyInStateArray(state, buf); unsigned char **word = doProcessKeyExpand(key); printOut(state, "input", 0); AddRoundKey(state, word, 0); printWord(word, "k_sch", 0, 0); for (round = 1; round < Nr; round++) { printOut(state, "start", round); SubBytes(state); printOut(state, "s_box", round); ShiftRows(state); printOut(state, "s_row", round); MixColumns(state, P); printOut(state, "m_col", round); AddRoundKey(state, word, round * Nb); printWord(word, "k_sch", round * Nb, round); } printOut(state, "start", round); SubBytes(state); printOut(state, "s_box", round); ShiftRows(state); printOut(state, "s_row", round); AddRoundKey(state, word, Nr * Nb); printWord(word, "k_sch", Nr * Nb, round); printOut(state, "output", round); }
void AES_Cipher(void *_ctx, u1 *data) { char r; AES_CTX *ctx = (AES_CTX *)_ctx; u4 *w = ctx->W; AddRoundKey((u4 *)data, w); w += 4; for(r = 1;r < ctx->Nr;r++) { SubBytes(data); ShiftRows(data); MixColumns(data); AddRoundKey((u4 *)data, w); w += 4; } SubBytes(data); ShiftRows(data); AddRoundKey((u4 *)data, w); }
static void buildAESCircuit(GarbledCircuit *gc, block *inputLabels) { GarblingContext ctxt; int q = 50000; //Just an upper bound int r = 50000; int *addKeyInputs = calloc(2 * m, sizeof(int)); int *addKeyOutputs = calloc(m, sizeof(int)); int *subBytesOutputs = calloc(m, sizeof(int)); int *shiftRowsOutputs = calloc(m, sizeof(int)); int *mixColumnOutputs = calloc(m, sizeof(int)); block *outputMap = allocate_blocks(2 * m); createEmptyGarbledCircuit(gc, n, m, q, r, inputLabels); startBuilding(gc, &ctxt); countToN(addKeyInputs, 256); for (int round = 0; round < roundLimit; round++) { AddRoundKey(gc, &ctxt, addKeyInputs, addKeyOutputs); for (int i = 0; i < 16; i++) { SubBytes(gc, &ctxt, addKeyOutputs + 8 * i, subBytesOutputs + 8 * i); } ShiftRows(gc, &ctxt, subBytesOutputs, shiftRowsOutputs); for (int i = 0; i < 4; i++) { if (round != roundLimit - 1) MixColumns(gc, &ctxt, shiftRowsOutputs + i * 32, mixColumnOutputs + 32 * i); } for (int i = 0; i < 128; i++) { addKeyInputs[i] = mixColumnOutputs[i]; addKeyInputs[i + 128] = (round + 2) * 128 + i; } } finishBuilding(gc, &ctxt, outputMap, mixColumnOutputs); /* writeCircuitToFile(gc, AES_CIRCUIT_FILE_NAME); */ free(addKeyInputs); free(addKeyOutputs); free(subBytesOutputs); free(shiftRowsOutputs); free(mixColumnOutputs); free(outputMap); }
int main(int argc, char** argv){ print(state); KeySchedule(); AddRoundKey(); for(iteracja = 1; iteracja < ROUND_cnt; ++iteracja){ SubBytes(); ShiftRows(); MixColumns(); print(state); AddRoundKey(); } SubBytes(); ShiftRows() AddRoundKey(); print(state); /*encrypted*/ AddRoundKey(); InvShiftRows(); InvSubBytes(); for(iteracja = ROUND_cnt-1; iteracja > 0; --iteracja){ AddRoundKey(); InvMixColumns(); InvShiftRows(); InvSubBytes(); } AddRoundKey(); print(state); return 0; }
void ExpansionCle(char cle[], char unsigned cleEtendue[TAILLEMATRICE*(NBROUND+1)][TAILLEMATRICE]){ int caractere, round, ligne; unsigned char wMoinsUn[TAILLEMATRICE][TAILLEMATRICE]={0}; unsigned char wMoinsQuatre[TAILLEMATRICE]; memset(cleEtendue, 0, TAILLEMATRICE*NBROUND); for (caractere=0; caractere<strlen(cle); caractere++){ cleEtendue[(caractere/TAILLEMATRICE)%TAILLEMATRICE][caractere%TAILLEMATRICE]=cle[caractere]; } for(round=1; round<=NBROUND*TAILLEMATRICE; round++){ for(ligne=0; ligne<TAILLEMATRICE; ligne++){ wMoinsQuatre[ligne]=cleEtendue[(round+TAILLEMATRICE-1)-4][ligne]; wMoinsUn[1][ligne]=cleEtendue[(round+TAILLEMATRICE-1)-1][ligne]; } if((round-1)%TAILLEMATRICE==0){ RotWord(wMoinsUn); SubBytes(wMoinsUn); } for(ligne=0; ligne<TAILLEMATRICE; ligne++){ cleEtendue[TAILLEMATRICE+round-1][ligne]=wMoinsQuatre[ligne]^wMoinsUn[1][ligne]; if((round-1)%TAILLEMATRICE==0){ (cleEtendue[TAILLEMATRICE+round-1][ligne])^=(Rcon[((round-1)/4)][ligne]);} } } }
void test_SubBytes(void) { int i; unsigned char expected[] = { 0x63, 0x7c, 0x77, 0x7b, 0xca, 0x82, 0xc9, 0x7d, 0xb7, 0xfd, 0x93, 0x26, 0x04, 0xc7, 0x23, 0xc3}; unsigned char actual[] = { 0x00, 0x01, 0x02, 0x03, 0x10, 0x11, 0x12, 0x13, 0x20, 0x21, 0x22, 0x23, 0x30, 0x31, 0x32, 0x33}; SubBytes(actual); for (i = 0; i < 4*4; i++) { CU_ASSERT_INT_EQ(expected[i], actual[i]); } }
/////////////////////////////////////////////////////////////////////////////// // 函数名: BlockDecrypt // 描述: 对单块数据解密。 // 输入参数: pState -- 状态数据。 // 输出参数: pState -- 解密后的状态数据。 // 返回值: 无。 /////////////////////////////////////////////////////////////////////////////// static void BlockDecrypt(unsigned char *pState) { unsigned char i; AddRoundKey(pState, &g_roundKeyTable[4*Nb*Nr]); for (i = Nr; i > 0; i--) // i = [Nr, 1] { ShiftRows(pState, 1); SubBytes(pState, 4*Nb, 1); AddRoundKey(pState, &g_roundKeyTable[4*Nb*(i-1)]); if (i != 1) { MixColumns(pState, 1); } } // 为了节省代码,合并到循化执行 // ShiftRows(pState, 1); // SubBytes(pState, 4*Nb, 1); // AddRoundKey(pState, g_roundKeyTable); }
/* * One AES round */ void AES_round( word P, word K, word C) { int i,j; unsigned char state[4][4]; // Convert the 16 byte sequence to a 4x4 matrix for(i=0; i<4; i++) for(j=0; j<4; j++) state[i][j] = P[ 4 * j + i ]; // Apply keyless AES round SubBytes ( state ); ShiftRows ( state ); MixColumns( state ); // Convert the 4x4 matrix to 16-byte sequence for(i=0; i<4; i++) for(j=0; j<4; j++) C[ 4 * j + i ] = state[i][j]; // Xor the key for(i=0; i<16; i++) C[i] ^= K[i]; }
/////////////////////////////////////////////////////////////////////////////// // 函数名: BlockEncrypt // 描述: 对单块数据加密。 // 输入参数: pState -- 状态数据。 // 输出参数: pState -- 加密后的状态数据。 // 返回值: 无。 /////////////////////////////////////////////////////////////////////////////// static void BlockEncrypt(unsigned char *pState) { unsigned char i; AddRoundKey(pState, g_roundKeyTable); for (i = 1; i <= Nr; i++) // i = [1, Nr] { SubBytes(pState, 4*Nb, 0); ShiftRows(pState, 0); if (i != Nr) { MixColumns(pState, 0); } AddRoundKey(pState, &g_roundKeyTable[4*Nb*i]); } // 为了节省代码,合并到循化执行 // SubBytes(pState, 4*Nb); // ShiftRows(pState, 0); // AddRoundKey(pState, &g_roundKeyTable[4*Nb*Nr]); }
// La fonction cipher sert a chiffrer le bloc de message void Cipher(unsigned char *C, unsigned char M[], unsigned char Key[], int Nr) { int i,j,round=0; unsigned char T[16],U[16], V[16],W[16]; unsigned char RoundKey[240]; //On fabrique les clefs de ronde KeyExpansion( RoundKey, Key, 10); //On copide le messge dans le bloc d'etat for(i=0;i<4;i++) { for(j=0;j<4;j++) { W[4*j+i] = M[4*j + i]; } } // for (i=0; i<4;i++) { // for (j=16; j<24; j++) { // if (!(j%4)) // printf(" "); // printf("%02x ", RoundKey[j*4 + i]); // } // printf("\n"); // } //printf("\n"); // AddKey de la premiere clef AddRoundKey(T,W,RoundKey,0); // Il y a Nr rondes. // Les Nr-1 premieres rondes sont identiques // Ces Nr-1 rondes sont effectuées dans la boucle for ci-dessous for(round=1;round<Nr;round++) { SubBytes(U,T); ShiftRows(V,U); MixColumns(W,V); AddRoundKey(T,W,RoundKey,round); } // Derniere ronde // La fonction MixColumns n'est pas dans la derniere ronde SubBytes(U,T); ShiftRows(V,U); AddRoundKey(W,V,RoundKey,Nr); // Le processus de chiffremen est fini // On copie le bloc d'etat du message dans le bloc de message chiffre for(i=0;i<4;i++) { for(j=0;j<4;j++) { C[j*4+i]=W[4*j+i]; } } }
void chiffrerBloc(unsigned char mat[TAILLEMATRICE][TAILLEMATRICE], unsigned char cleEtendue[TAILLEMATRICE*(NBROUND+1)][TAILLEMATRICE]){ int ligne, colonne, round; // Traitement du bloc for(round=0; round<NBROUND; round++){ /*//DEBUG BLOC EN CLAIR ------------------------------------------ printf("\nBLOC EN CLAIR \n"); for (ligne=0; ligne<TAILLEMATRICE; ligne++){ for (colonne=0; colonne<TAILLEMATRICE; colonne++){ printf("0x%.2X\t" ,mat[colonne][ligne]); } printf("\n"); } printf("\n---------------------------------\n"); // FIN DEBUG BLOC EN CLAIR---------------------------------------*/ AddRoundKey(cleEtendue,round,mat); /*//DEBUG ADDROUNDKEY---------------------------------------------- printf("\nADDROUNDKEY [%d] \n",round); for (ligne=0; ligne<TAILLEMATRICE; ligne++){ for (colonne=0; colonne<TAILLEMATRICE; colonne++){ printf("0x%.2X\t" ,mat[colonne][ligne]); } printf("\n"); } printf("\n---------------------------------\n"); // FIN DEBUG BLOC EN CLAIR---------------------------------------*/ SubBytes(mat); /*//DEBUG SUBBYTES------------------------------------------ printf("DEBUG SUBBYTES[%d] \n",round); for (ligne=0; ligne<TAILLEMATRICE; ligne++){ for (colonne=0; colonne<TAILLEMATRICE; colonne++){ printf("0x%.2X\t" ,mat[colonne][ligne]); } printf("\n"); } printf("\n---------------------------------\n"); // FIN DEBUG SUBBYTES---------------------------------------*/ ShiftRow(mat); /*//DEBUG SHIFTROW------------------------------------------ printf("DEBUG SHIFTROW[%d] \n",round); for (ligne=0; ligne<TAILLEMATRICE; ligne++){ for (colonne=0; colonne<TAILLEMATRICE; colonne++){ printf("0x%.2X\t" ,mat[colonne][ligne]); } printf("\n"); } printf("\n---------------------------------\n"); // FIN DEBUG SHIFTROW---------------------------------------*/ if(round!=(NBROUND-1)) { MixColumns(mat); /* //DEBUG MIXCOLUMNS------------------------------------------ printf("DEBUG MIXCOLUMNS [%d] \n",round); for (ligne=0; ligne<TAILLEMATRICE; ligne++){ for (colonne=0; colonne<TAILLEMATRICE; colonne++){ printf("0x%.2X\t" ,mat[colonne][ligne]); } printf("\n"); } printf("\n---------------------------------\n"); // FIN DEBUG MIXCOLUMNS---------------------------------------*/ } } AddRoundKey(cleEtendue,round,mat); //DEBUG MESSAGE CRYPTE EN HEXA------------------------------------------ printf("BLOC CHIFFRE EN HEXA \n",round); for (ligne=0; ligne<TAILLEMATRICE; ligne++){ for (colonne=0; colonne<TAILLEMATRICE; colonne++){ printf("0x%.2X\t" ,mat[colonne][ligne]); } printf("\n"); } // FIN DEBUG MESSAGE CRYPTE EN HEXA--------------------------------------- }