//------------------------------------------------------
void decryption()
{
int i,temp[16],output_1[16],output_2[16];
printf("Decryption :");
printf("Round 1:");
AddRoundKey(Cipher_txt,temp,key[2]);
display("After Add Round Key2:",temp,16);
ShiftRow(temp);
display("After Shift Row:",temp,16);
InverseSubstituteNibble(temp,16,output_1);
display("After Inverse Nibble Substitution:",output_1,16);
printf("Round 2:");
AddRoundKey(output_1,output_1,key[1]);
display("After Add Round Key1:",output_1,16);
MixColumn(output_1,DecMatrix,output_1);
display("After Inverse Mix Column:",output_1,16);
ShiftRow(output_1);
display("After Inverse Shift Row:",output_1,16);
InverseSubstituteNibble(output_1,16,output_2);
display("After Inverse Nibble Substitution:",output_2,16);
AddRoundKey(output_2,output_2,key[0]);
display("Decrypted text:",output_2,16);
}
//------------------------------------------------------
void encryption()
{
int i,temp[16],output_1[16],output_2[16];
printf("Encryption:");
AddRoundKey(plain_txt,temp,key[0]);
display("After Add Round Key0",temp,16);
printf("Round 1:");
SubstituteNibble(temp,16,output_1);
display("After Substitution of Nibble",output_1,16);
ShiftRow(output_1);
display("After Shift Row:",output_1,16);
MixColumn(output_1,EncMatrix,output_1);
display("After Mix Column:",output_1,16);
AddRoundKey(output_1,output_1,key[1]);
display("After Add Round Key1:",output_1,16);
printf("Round 2:");
SubstituteNibble(output_1,16,output_2);
display("After Substitution of Nibble",output_2,16);
ShiftRow(output_2);
display("After Shift Row:",output_2,16);
AddRoundKey(output_2,Cipher_txt,key[2]);
display("Cipher text:",Cipher_txt,16);
}
/*-------------------------------------------------------------------
* Rijndael encryption function. Takes 16-byte input and creates
* 16-byte output (using round keys already derived from 16-byte
* key).
*-----------------------------------------------------------------*/
void RijndaelEncrypt( u8 input[16], u8 output[16] )
{
u8 state[4][4];
int i, r;
/* initialise state array from input byte string */
for (i=0; i<16; i++)
state[i & 0x3][i>>2] = input[i];
/* add first round_key */
KeyAdd(state, roundKeys, 0);
/* do lots of full rounds */
for (r=1; r<=9; r++) {
ByteSub(state);
ShiftRow(state);
MixColumn(state);
KeyAdd(state, roundKeys, r);
}
/* final round */
ByteSub(state);
ShiftRow(state);
KeyAdd(state, roundKeys, r);
/* produce output byte string from state array */
for (i=0; i<16; i++) {
output[i] = state[i & 0x3][i>>2];
}
return;
} /* end of function RijndaelEncrypt */
int rijndaelDecryptRound (word8 a[4][MAXBC], int keyBits, int blockBits,
word8 rk[MAXROUNDS+1][4][MAXBC], int rounds)
/* Decrypt only a certain number of rounds.
* Only used in the Intermediate Value Known Answer Test.
* Operations rearranged such that the intermediate values
* of decryption correspond with the intermediate values
* of encryption.
*/
{
int r, BC, ROUNDS;
switch (blockBits) {
case 128: BC = 4; break;
case 192: BC = 6; break;
case 256: BC = 8; break;
default : return (-2);
}
switch (keyBits >= blockBits ? keyBits : blockBits) {
case 128: ROUNDS = 10; break;
case 192: ROUNDS = 12; break;
case 256: ROUNDS = 14; break;
default : return (-3); /* this cannot happen */
}
/* make number of rounds sane */
if (rounds > ROUNDS) rounds = ROUNDS;
/* First the special round:
* without InvMixColumn
* with extra KeyAddition
*/
KeyAddition(a,rk[ROUNDS],BC);
Substitution(a,Si,BC);
ShiftRow(a,1,BC);
/* ROUNDS-1 ordinary rounds
*/
for(r = ROUNDS-1; r > rounds; r--) {
KeyAddition(a,rk[r],BC);
InvMixColumn(a,BC);
Substitution(a,Si,BC);
ShiftRow(a,1,BC);
}
if (rounds == 0) {
/* End with the extra key addition
*/
KeyAddition(a,rk[0],BC);
}
return 0;
}
bit16 SAES_Decrypt(QVector<bit16> KeyExpanInv, bit16 CiphertextInv)
{
bit16 PT1 = CiphertextInv ^ KeyExpanInv[2];
bit16 PT2 = ShiftRow(PT1);
bit16 PT3 = InverseNibSub(PT2);
bit16 PT4 = PT3 ^ KeyExpanInv[1];
bit16 PT5 = MixColumnInverse(PT4);
bit16 PT6 = ShiftRow(PT5);
bit16 PT7 = InverseNibSub(PT6);
bit16 PT8 = PT7 ^ KeyExpanInv[0];
return PT8;
}
bit16 SAES_Encrypt(QVector<bit16> KeyExpan, bit16 Plaintext)
{
bit16 CT1 = Plaintext ^ KeyExpan[0];
bit16 CT2 = NibSub(CT1);
bit16 CT3 = ShiftRow(CT2);
bit16 CT4 = MixColumn(CT3);
bit16 CT5 = CT4 ^ KeyExpan[1];
bit16 CT6 = NibSub(CT5);
bit16 CT7 = ShiftRow(CT6);
bit16 CT8 = CT7 ^ KeyExpan[2];
return CT8;
}
int _rijndaelDecrypt (word8 a[4][MAXBC], int keyBits, int blockBits, word8 rk[MAXROUNDS+1][4][MAXBC])
{
int r, BC, ROUNDS;
switch (blockBits) {
case 128: BC = 4; break;
case 192: BC = 6; break;
case 256: BC = 8; break;
default : return (-2);
}
switch (keyBits >= blockBits ? keyBits : blockBits) {
case 128: ROUNDS = 10; break;
case 192: ROUNDS = 12; break;
case 256: ROUNDS = 14; break;
default : return (-3); /* this cannot happen */
}
/* To decrypt: apply the inverse operations of the encrypt routine,
* in opposite order
*
* (KeyAddition is an involution: it 's equal to its inverse)
* (the inverse of Substitution with table S is Substitution with the inverse table of S)
* (the inverse of Shiftrow is Shiftrow over a suitable distance)
*/
/* First the special round:
* without InvMixColumn
* with extra KeyAddition
*/
KeyAddition(a,rk[ROUNDS],BC);
Substitution(a,Si,BC);
ShiftRow(a,1,BC);
/* ROUNDS-1 ordinary rounds
*/
for(r = ROUNDS-1; r > 0; r--) {
KeyAddition(a,rk[r],BC);
InvMixColumn(a,BC);
Substitution(a,Si,BC);
ShiftRow(a,1,BC);
}
/* End with the extra key addition
*/
KeyAddition(a,rk[0],BC);
return 0;
}
int rijndaelEncryptRound (word8 a[4][MAXBC], int keyBits, int blockBits,
word8 rk[MAXROUNDS+1][4][MAXBC], int rounds)
/* Encrypt only a certain number of rounds.
* Only used in the Intermediate Value Known Answer Test.
*/
{
int r, BC, ROUNDS;
switch (blockBits) {
case 128: BC = 4; break;
case 192: BC = 6; break;
case 256: BC = 8; break;
default : return (-2);
}
switch (keyBits >= blockBits ? keyBits : blockBits) {
case 128: ROUNDS = 10; break;
case 192: ROUNDS = 12; break;
case 256: ROUNDS = 14; break;
default : return (-3); /* this cannot happen */
}
/* make number of rounds sane */
if (rounds > ROUNDS) rounds = ROUNDS;
/* begin with a key addition
*/
KeyAddition(a,rk[0],BC);
/* at most ROUNDS-1 ordinary rounds
*/
for(r = 1; (r <= rounds) && (r < ROUNDS); r++) {
Substitution(a,S,BC);
ShiftRow(a,0,BC);
MixColumn(a,BC);
KeyAddition(a,rk[r],BC);
}
/* if necessary, do the last, special, round:
*/
if (rounds == ROUNDS) {
Substitution(a,S,BC);
ShiftRow(a,0,BC);
KeyAddition(a,rk[ROUNDS],BC);
}
return 0;
}
FReply FGridSlotExtension::HandleShiftRow(int32 ShiftAmount)
{
BeginTransaction(LOCTEXT("MoveWidget", "Move Widget"));
for ( FWidgetReference& Selection : SelectionCache )
{
ShiftRow(Selection.GetPreview(), ShiftAmount);
ShiftRow(Selection.GetTemplate(), ShiftAmount);
}
EndTransaction();
FBlueprintEditorUtils::MarkBlueprintAsModified(Blueprint);
return FReply::Handled();
}
//加密运算,inputSize必须为128,192,256位
void Encrypt(RijndaelContextPtr context,void* input)
{
unsigned int round;
//明文的最大长度
unsigned long state[8] = {0};
unsigned char* inputStringPtr = (unsigned char*)input;
unsigned int nb = context->nb;
//经过这个过程，由a0 a1 a2 a3 a4 a5组成的字节序列就组成了
// a0 a4 a8 a12 a16 ...
// a1 a5 a9 a13 a17 ...
// a2 a6 a10 a14 a18 ...
// a3 a7 a11 a15 a19 ...
//这样的字节矩阵
state[0] = GETINT32(inputStringPtr,0,nb);
state[1] = GETINT32(inputStringPtr,1,nb);
state[2] = GETINT32(inputStringPtr,2,nb);
state[3] = GETINT32(inputStringPtr,3,nb);
if (nb >= (KeySize_192/4))
{
state[4] = GETINT32(inputStringPtr,4,nb);
state[5] = GETINT32(inputStringPtr,5,nb);
}
if (nb >= (KeySize_256/4))
{
state[6] = GETINT32(inputStringPtr,6,nb);
state[7] = GETINT32(inputStringPtr,7,nb);
}
AddRoundKey(context,0,state);
for (round = 1; round<context->nr; round++)
{
SubByte(context,state);
ShiftRow(context,state);
MixColumn(context,state);
AddRoundKey(context,round,state);
}
SubByte(context,state);
ShiftRow(context,state);
AddRoundKey(context,context->nr,state);
//就这个格式输出的密文，其实也没有关系的
//将格式纠正
StateToChars((unsigned char*)input,state,context->nb);
}
int _rijndaelEncrypt (word8 a[4][MAXBC], int keyBits, int blockBits, word8 rk[MAXROUNDS+1][4][MAXBC])
{
/* Encryption of one block.
*/
int r, BC, ROUNDS;
switch (blockBits) {
case 128: BC = 4; break;
case 192: BC = 6; break;
case 256: BC = 8; break;
default : return (-2);
}
switch (keyBits >= blockBits ? keyBits : blockBits) {
case 128: ROUNDS = 10; break;
case 192: ROUNDS = 12; break;
case 256: ROUNDS = 14; break;
default : return (-3); /* this cannot happen */
}
/* begin with a key addition
*/
KeyAddition(a,rk[0],BC);
/* ROUNDS-1 ordinary rounds
*/
for(r = 1; r < ROUNDS; r++) {
Substitution(a,S,BC);
ShiftRow(a,0,BC);
MixColumn(a,BC);
KeyAddition(a,rk[r],BC);
}
/* Last round is special: there is no MixColumn
*/
Substitution(a,S,BC);
ShiftRow(a,0,BC);
KeyAddition(a,rk[ROUNDS],BC);
return 0;
}
int rijndaelDecryptRound (word8 a[4][4],
word8 rk[MAXROUNDS+1][4][4], int rounds)
/* Decrypt only a certain number of rounds.
* Only used in the Intermediate Value Known Answer Test.
* Operations rearranged such that the intermediate values
* of decryption correspond with the intermediate values
* of encryption.
*/
{
int r;
/* make number of rounds sane */
if (rounds > ROUNDS) rounds = ROUNDS;
/* First the special round:
* without InvMixColumn
* with extra KeyAddition
*/
KeyAddition(a,rk[ROUNDS],4);
Substitution(a,Si,4);
ShiftRow(a,1,4);
/* ROUNDS-1 ordinary rounds
*/
for(r = ROUNDS-1; r > rounds; r--) {
KeyAddition(a,rk[r],4);
InvMixColumn(a,4);
Substitution(a,Si,4);
ShiftRow(a,1,4);
}
if (rounds == 0) {
/* End with the extra key addition
*/
KeyAddition(a,rk[0],4);
}
return 0;
}
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---------------------------------------
}
