Lattice .bek档案AES加密解密
//BEK.h
#ifndef __BEK_H__ #define __BEK_H__ #include<stdio.h> #include<stdlib.h> #include<stdbool.h> /////////////////////////////////////////////////////////////////////////// // CRC Tables /////////////////////////////////////////////////////////////////////////// static unsigned short crc_16_table[16] = { 0x0000, 0xCC01, 0xD801, 0x1400, 0xF001, 0x3C00, 0x2800, 0xE401, 0xA001, 0x6C00, 0x7800, 0xB401, 0x5000, 0x9C01, 0x8801, 0x4400 }; static char fliptab[] = { 0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0, 0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0, 0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8, 0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8, 0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4, 0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4, 0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC, 0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC, 0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2, 0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2, 0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA, 0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA, 0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6, 0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6, 0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE, 0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE, 0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1, 0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1, 0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9, 0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9, 0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5, 0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5, 0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED, 0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD, 0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3, 0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3, 0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB, 0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB, 0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7, 0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7, 0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF, 0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF }; unsigned char bek_content[4096] = { //bek内容 省略 }; #define blockSize 4 // Macro to find the product of x ({02}) and the argument to xtime modulo {1b} #define xtime(x) ((x<<1) ^ (((x>>7) & 1) * 0x1b)) // Macro to multiply numbers in the Galois Field(2^8) #define Multiply(x,y) (((y & 1) * x) ^ ((y>>1 & 1) * xtime(x)) ^ ((y>>2 & 1) * xtime(xtime(x))) ^ ((y>>3 & 1) * xtime(xtime(xtime(x)))) ^ ((y>>4 & 1) * xtime(xtime(xtime(xtime(x)))))) char pass_word_l[] = { 0x00,0x00,0x00,0x00,0x00,0x4C,0x41,0x54, 0x54,0x49,0x43,0x45,0x53,0x45,0x4D,0x49 }; // Data orientation D[0:7]. /** * @brief Move data to 0x1000, then check CRC value * @note none * @para none * @ret if CRC value not same, return false * @ if return error, you have to call Bus.Setting_Error_Message(E_UnknowFormat,0,0,0,0); and return * @ ex: * * if(!BEK_CRC_check()) * { * Bus.Setting_Error_Message(E_UnknowFormat,0,0,0,0); * return; * } * * if BEK_CRC_check() return true, it means Security_Key_128bits[] have decrypted content */ bool BEK_CRC_check(); /** * @brief Encrypt data * @note none * @para plaintext * @ret plaintext */ void Encrypt(); /** * @brief Encrypt data * @note none * @para plaintext * @ret encrypted */ void Decrypt(); /** * @brief You have to confrim the flag. If false, please don't program and return/ * @note none * @para none * @ret If BEK file encrypted OK, it will be set to true. */ bool Valid_BEK; //uint8_t tmp_content[1024]; unsigned char Security_Key_128bits[16]; unsigned char tmp_plaintext[128]; unsigned short int get_crc_16(int start, long loc, int n, char *bs ); int rounds; int keyLength; unsigned char plaintext[16], encrypted[16], state[4][4]; unsigned char roundKey[240], Key[32]; int get_SBox_Value(int num); int get_SBox_Inverse(int num); void Expand_Keys(); void Add_Round_Key(int round) ; void Sub_Bytes(); void Inv_Sub_Bytes(); void Shift_Rows(); void Inv_Shift_Rows(); void Mix_Columns(); void Inv_Mix_Columns(); #endif
BEK.c
#include "BEK.h" typedef unsigned short uint16_t; // Lookup Table for round constant word array // Contains the values given by x to the power (i-1) being powers of x ({02}) in the field Galois Field (28) int Rcon[255] = { 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb }; /* BEK::BEK() { rounds = 0; keyLength = 0; } BEK::~BEK(); */ bool BEK_CRC_check() { rounds = 0; keyLength = 0; Valid_BEK = false; /*************************************/ /***** Find Pending bit & CRC16*******/ /*************************************/ int u,p, find_ = 0; //Bus.Get_DDR_data( (uint8_t *)&bek_content , 0x0 , 1024 ); for (int i = 0; i < 1024; ++i) { u = i; p = 0; for (int j = 0; j < 14; ++j) { if (bek_content[u++]==0) p++; } if(p>=14) { find_ = i; break; } } //printf("p %X\n\r",p); //printf("find %X\n\r",find_); uint16_t file_crc16 = 0; file_crc16 = bek_content[find_ - 1] | (bek_content[find_ - 2]<<8); printf("file_crc16 %04X\n\r",file_crc16); uint16_t buffer_crc = 0; buffer_crc = get_crc_16(0, 0, find_- 2, bek_content); printf("buffer_crc %04X\n\r",buffer_crc); if (buffer_crc != file_crc16) { printf("BEK file not in buffer \n\r"); return false; } printf("BEK file in buffer \n\r"); /*************************************/ /***** Remove Header *****************/ /*************************************/ int check_header_length = 0; if ( (bek_content[0]==0xFF) && (bek_content[1]==00) ) { for (int i = 0; i < 1024; ++i) { if( (bek_content[i]==0x00) && (bek_content[i+1]==0xFF) ) {check_header_length = i+2; printf("BEK file CRC correct \n\r"); printf("Decrypt file............... \n\r"); break;} } } else { printf("BEK file CRC not correct \n\r"); return false; } printf("check_header_length %X\n\r",check_header_length); unsigned char leave_encrypted_data[128]; //Header CRC unsigned short Header_CRC = get_crc_16(0, 0, check_header_length, bek_content); printf("Header_CRC %X\n\r",Header_CRC); for (int i = 0; i < 80; ++i) { leave_encrypted_data[i] = bek_content[check_header_length++]; } /*************************************/ /***** Decrypted *********************/ /*************************************/ unsigned char tmp_plaintext[128]; int cr = 0; rounds = 128; // Calculate actual keyLength and rounds from the user input keyLength = rounds / 32; //if 128, keyLength = 4 rounds = keyLength + 6; //if 128, rounds = 10 printf("keyLength=0x%x，rounds=0x%x\n\r",keyLength,rounds); for (int j = 0; j < 5; ++j) { /* code */ //int t = 15; int t = 0; for (int i = 0; i < 16; ++i) { Key[i] = pass_word_l[i]; } //printf("Key1:"); for (int i = 0; i < 16; ++i) { //printf(" %02X", Key[i]); } //printf("\n\r"); for (int i = 0; i < 16; ++i) { encrypted[i] = leave_encrypted_data[i + j*16]; } // Expand_Keys before encryption Expand_Keys(); Decrypt(); //printf("\nDecrypted1: \n\r"); for (int i = 0; i < blockSize * 4; i++) { // printf("%02x ", plaintext[i]); } //printf("\n\r"); t = 0; for (int i = 0; i < 8; ++i) { Key[t++] = (char)(Header_CRC >> 8); Key[t++] = (char)(Header_CRC); } for (int i = 0; i < 16; ++i) { //encrypted[i] = String_[i]; encrypted[i] = plaintext[i]; } Expand_Keys(); Decrypt(); //printf("\nDecrypted2: \n\r"); //for (int i = 0; i < blockSize * 4; i++) //{ // printf("%02x ", plaintext[i]); //} //printf("\n\r"); //printf("\n\r"); for (int i = 0; i < 16; ++i) { tmp_plaintext[cr++] = plaintext[i]; } } for (int i = 0; i < 16; ++i) { Security_Key_128bits[i] = tmp_plaintext[i+0x10]; printf("Security_Key_128bits[%d]=0x%x\r\n",i,Security_Key_128bits[i]); } if ( (tmp_plaintext[0]<<8 | tmp_plaintext[1]) != Header_CRC) { printf("Decrypt fail! Header_CRC = 0x%x,calc = 0x%x\n\r",Header_CRC,(tmp_plaintext[0]<<8 | tmp_plaintext[1])); return false; } printf("Decrypt Done. Please check Security_Key_128bits[]\n\r"); Valid_BEK = true; return true; } /*uint8_t BEK::pass_word_l[16] = { 0x00,0x00,0x00,0x00,0x00,0x4C,0x41,0x54, 0x54,0x49,0x43,0x45,0x53,0x45,0x4D,0x49 }; */ /*uint8_t BEK::pass_word_l[16] = { 0x49,0x4D,0x45,0x53,0x45,0x43,0x49,0x54, 0x54,0x41,0x4C,0x00,0x00,0x00,0x00,0x00 }; */ //#define flip(c) fliptab[c] // Used for CRC calculation unsigned short int get_crc_16(int start, long loc, int n, char *bs ) { unsigned short int crc = start; int r; char data; while (n-->0) { //data=flip(bs.getbyte(loc)); //printf("1. %X\n", bs[loc]);//FFFFFF9C data = bs[loc] & 0xFF; //printf("2. %X\n",data); data= fliptab[0xFF & data]; //printf("3. %X\n",data); r = crc_16_table[crc & 0xF]; crc = (crc>>4) & 0x0FFF; crc = crc^r^crc_16_table[data & 0xF]; // calculate CRC for the upper 4 bits of data r = crc_16_table[crc & 0xF]; crc = (crc>>4) & 0x0FFF; crc = crc^r^crc_16_table[(data>>4) & 0xF]; //next data loc++; } return (crc); } // Returns Rijndael S-box value int get_SBox_Value(int num) { // lookup table int sbox[256] = { 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76, 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15, 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75, 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf, 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8, 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73, 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb, 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08, 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a, 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf, 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 }; return sbox[num]; } // Returns inverse Rijndael S-box value int get_SBox_Inverse(int num) { // lookup table int rsbox[256] = { 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb, 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb, 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e, 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25, 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92, 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84, 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06, 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b, 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73, 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e, 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b, 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4, 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f, 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef, 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61, 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d }; return rsbox[num]; } // Deduces round keys from the primary Key provided void Expand_Keys() { int i,j; unsigned char temp[4],k; // Use the primary Key for first round for(i = 0; i < keyLength; i++) { roundKey[i*4]=Key[i*4]; roundKey[i*4+1]=Key[i*4+1]; roundKey[i*4+2]=Key[i*4+2]; roundKey[i*4+3]=Key[i*4+3]; } // Each subsequent round key is deduced from previously deduced round keys while (i < (blockSize * (rounds+1))) { for(j=0;j<4;j++) { temp[j]=roundKey[(i-1) * 4 + j]; } if (i % keyLength == 0) { // Rotate the bytes in a word to the left. { k = temp[0]; temp[0] = temp[1]; temp[1] = temp[2]; temp[2] = temp[3]; temp[3] = k; } // Take a four-byte input and apply the S-box to each of the four bytes { temp[0]=get_SBox_Value(temp[0]); temp[1]=get_SBox_Value(temp[1]); temp[2]=get_SBox_Value(temp[2]); temp[3]=get_SBox_Value(temp[3]); } temp[0] = temp[0] ^ Rcon[i/keyLength]; } else if (keyLength > 6 && i % keyLength == 4) { { temp[0]=get_SBox_Value(temp[0]); temp[1]=get_SBox_Value(temp[1]); temp[2]=get_SBox_Value(temp[2]); temp[3]=get_SBox_Value(temp[3]); } } roundKey[i*4+0] = roundKey[(i-keyLength)*4+0] ^ temp[0]; roundKey[i*4+1] = roundKey[(i-keyLength)*4+1] ^ temp[1]; roundKey[i*4+2] = roundKey[(i-keyLength)*4+2] ^ temp[2]; roundKey[i*4+3] = roundKey[(i-keyLength)*4+3] ^ temp[3]; i++; } } // Add round key to state by XOR-ing void Add_Round_Key(int round) { int i,j; for (i = 0; i < 4; i++) { for(j = 0; j < 4; j++) { state[j][i] ^= roundKey[round * blockSize * 4 + i * blockSize + j]; } } } // Substitute state matrix values with corresponding S-box values void Sub_Bytes() { int i,j; for(i = 0; i < 4; i++) { for(j = 0; j < 4; j++) { state[i][j] = get_SBox_Value(state[i][j]); } } } // Same as Sub_Bytes, but uses reverse SBox void Inv_Sub_Bytes() { int i, j; for (i = 0; i<4; i++) { for (j = 0; j<4; j++) { state[i][j] = get_SBox_Inverse(state[i][j]); } } } // Shift the rows in the state to the left by the row number value void Shift_Rows() { unsigned char temp; // First row by 1 temp=state[1][0]; state[1][0]=state[1][1]; state[1][1]=state[1][2]; state[1][2]=state[1][3]; state[1][3]=temp; // Second row by 2 temp=state[2][0]; state[2][0]=state[2][2]; state[2][2]=temp; temp=state[2][1]; state[2][1]=state[2][3]; state[2][3]=temp; // Third row by 3 temp=state[3][0]; state[3][0]=state[3][3]; state[3][3]=state[3][2]; state[3][2]=state[3][1]; state[3][1]=temp; } // Same as Shift_Rows, but shifts right instead void Inv_Shift_Rows() { unsigned char temp; temp = state[1][3]; state[1][3] = state[1][2]; state[1][2] = state[1][1]; state[1][1] = state[1][0]; state[1][0] = temp; temp = state[2][0]; state[2][0] = state[2][2]; state[2][2] = temp; temp = state[2][1]; state[2][1] = state[2][3]; state[2][3] = temp; temp = state[3][0]; state[3][0] = state[3][1]; state[3][1] = state[3][2]; state[3][2] = state[3][3]; state[3][3] = temp; } // Mixes the columns of the state matrix void Mix_Columns() { int i; unsigned char x1, x2, x3; for (i = 0; i < 4; i++) { x1 = state[0][i]; x3 = state[0][i] ^ state[1][i] ^ state[2][i] ^ state[3][i]; x2 = state[0][i] ^ state[1][i]; x2 = xtime(x2); state[0][i] ^= x2 ^ x3; x2 = state[1][i] ^ state[2][i]; x2 = xtime(x2); state[1][i] ^= x2 ^ x3; x2 = state[2][i] ^ state[3][i]; x2 = xtime(x2); state[2][i] ^= x2 ^ x3; x2 = state[3][i] ^ x1; x2 = xtime(x2); state[3][i] ^= x2 ^ x3; } } // Inverse mixing of columns void Inv_Mix_Columns() { int i; unsigned char x1, x2, x3, x4; for (i = 0; i < 4; i++) { x1 = state[0][i]; x2 = state[1][i]; x3 = state[2][i]; x4 = state[3][i]; state[0][i] = Multiply(x1, 0x0e) ^ Multiply(x2, 0x0b) ^ Multiply(x3, 0x0d) ^ Multiply(x4, 0x09); state[1][i] = Multiply(x1, 0x09) ^ Multiply(x2, 0x0e) ^ Multiply(x3, 0x0b) ^ Multiply(x4, 0x0d); state[2][i] = Multiply(x1, 0x0d) ^ Multiply(x2, 0x09) ^ Multiply(x3, 0x0e) ^ Multiply(x4, 0x0b); state[3][i] = Multiply(x1, 0x0b) ^ Multiply(x2, 0x0d) ^ Multiply(x3, 0x09) ^ Multiply(x4, 0x0e); } } void Encrypt() { int i,j,round=0; // Copy plaintext to state array for (i = 0; i < 4; i++) { for (j = 0; j < 4; j++) { state[j][i] = plaintext[i * 4 + j]; } } // Add the first round key to the state before starting the rounds Add_Round_Key(0); // The first rounds-1 rounds are the same for (round = 1; round < rounds; round++) { Sub_Bytes(); Shift_Rows(); Mix_Columns(); Add_Round_Key(round); } // Last round has no Mix_Columns() Sub_Bytes(); Shift_Rows(); Add_Round_Key(rounds); // Copy the state array to output for (i = 0; i < 4; i++) { for(j = 0; j < 4; j++) { encrypted[i * 4 + j] = state[j][i]; } } } void Decrypt() { int i, j, round = 0; // Copy cyphertext to state array for (i = 0; i<4; i++) { for (j = 0; j<4; j++) { state[j][i] = encrypted[i * 4 + j]; } } Add_Round_Key(rounds); for (round = rounds - 1; round>0; round--) { Inv_Shift_Rows(); Inv_Sub_Bytes(); Add_Round_Key(round); Inv_Mix_Columns(); } Inv_Shift_Rows(); Inv_Sub_Bytes(); Add_Round_Key(0); // Copy the state array to output for (i = 0; i<4; i++) { for (j = 0; j<4; j++) { plaintext[i * 4 + j] = state[j][i]; } } } int main() { bool ret = true; if(false == BEK_CRC_check()) { printf("CRC err!"); } else { printf("CRC ok!"); } }
