Page MenuHomec4science
Files F62028940

case_generator.c
No OneTemporary
Actions

File Metadata

Created
Fri, May 10, 11:36

case_generator.c
View Options

#include<stdio.h>
#include <stdlib.h>
#include<time.h>
unsigned char 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
};
unsigned char isbox[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
};
unsigned char rcon[18]={0x0,0x1,0x2,0x4,0x8,0x10,0x20,0x40,0x80,0x1B,0x36,0x6C,0xD8,0xAB,0x4D,0x9A,0x2F,0x5E};
void rotate(unsigned char *in) {
unsigned char a,c;
a = in[0];
for(c=0;c<3;c++)
in[c] = in[c + 1];
in[3] = a;
}
/* This is the core key expansion, which, given a 4-byte value,
* does some scrambling */
void schedule_core(unsigned char *in, unsigned char i) {
char a;
/* Rotate the input 8 bits to the left */
rotate(in);
/* Apply Rijndael's s-box on all 4 bytes */
for(a = 0; a < 4; a++)
in[a] = sbox[in[a]];
/* On just the first byte, add 2^i to the byte */
in[0] ^= rcon[i];
}
void expand_key(unsigned char *in) {
unsigned char t[4];
/* c is 16 because the first sub-key is the user-supplied key */
unsigned int c = 16;
unsigned char i = 1;
unsigned char a;
/* We need 17 sets of sixteen bytes each for 128-bit mode */
while(c < 272) {
/* Copy the temporary variable over from the last 4-byte
* block */
for(a = 0; a < 4; a++)
t[a] = in[a + c - 4];
/* Every four blocks (of four bytes),
* do a complex calculation */
if(c % 16 == 0) {
schedule_core(t,i);
i++;
}
for(a = 0; a < 4; a++) {
in[c] = in[c - 16] ^ t[a];
c++;
}
}
}
unsigned char gmul2( unsigned char c)
{
unsigned char b;
b = c & 0x80;
c <<= 1;
if(b == 0x80) {
c ^= 0x1b;
}
return c;
}
unsigned char gmul4( unsigned char c)
{
unsigned char b;
b = c & 0x80;
c <<= 1;
if(b == 0x80) {
c ^= 0x1b;
}
b = c & 0x80;
c <<= 1;
if(b == 0x80) {
c ^= 0x1b;
}
return c;
}
void Mcol (unsigned char* CT)
{
unsigned char y1,y2,y3,y4,q0,q1,q2,q3;
int i;
for(i=0;i<16;i+=4) {
y1 = gmul2(CT[i+0]) ^ CT[i+2] ;
y2 = gmul2(CT[i+1]) ^ CT[i+3] ;
y3 = gmul2(CT[i+2]) ^ CT[i+0] ;
y4 = gmul2(CT[i+3]) ^ CT[i+1] ;
q0 = y1^y2^CT[i+1]; q1= y2^y3^CT[i+2]; q2 = y3^y4^CT[i+3]; q3= y4^y1^CT[i+0];
CT[i+0]=q0; CT[i+1]=q1;CT[i+2]=q2;CT[i+3]=q3;
}
}
void IMcol (unsigned char* CT) {
unsigned char y0,y1,y2,y3,y4,q0,q1,q2,q3;
int i;
for(i=0;i<16;i+=4) {
y3 = gmul4 (CT[i+0] ^ CT[i+2]) ^ CT[i+0]; y2 = gmul4(CT[i+1] ^ CT[i+3]) ^ CT[i+1] ;
y1 = gmul4 (CT[i+0] ^ CT[i+2]) ^ CT[i+2]; y0 = gmul4(CT[i+1] ^ CT[i+3]) ^ CT[i+3] ;
CT[i+0]=y3; CT[i+1]=y2; CT[i+2]=y1; CT[i+3]=y0;
y1 = gmul2(CT[i+0]) ^ CT[i+2] ;
y2 = gmul2(CT[i+1]) ^ CT[i+3] ;
y3 = gmul2(CT[i+2]) ^ CT[i+0] ;
y4 = gmul2(CT[i+3]) ^ CT[i+1] ;
q0 = y1^y2^CT[i+1]; q1= y2^y3^CT[i+2]; q2 = y3^y4^CT[i+3]; q3= y4^y1^CT[i+0];
CT[i+0]=q0; CT[i+1]=q1;CT[i+2]=q2;CT[i+3]=q3;
}
}
void SRow (unsigned char* CT) {
unsigned char t1,t2;
t1 = CT[1]; CT[1]=CT[5]; CT[5]=CT[9]; CT[9]=CT[13];CT[13]=t1;
t1 = CT[2]; CT[2]=CT[10]; t2= CT[6]; CT[6]=CT[14]; CT[10]= t1; CT[14] = t2;
t1 = CT[15]; CT[15]=CT[11]; CT[11]=CT[7]; CT[7] = CT[3]; CT[3]=t1;
}
void ISRow (unsigned char* CT) {
unsigned char t1,t2;
t1 = CT[13]; CT[13]=CT[9]; CT[9]=CT[5]; CT[5]=CT[1];CT[1]=t1;
t1 = CT[2]; CT[2]=CT[10]; t2= CT[6]; CT[6]=CT[14]; CT[10]= t1; CT[14] = t2;
t1 = CT[3]; CT[3]=CT[7]; CT[7]=CT[11]; CT[11] = CT[15]; CT[15]=t1;
}
void SByte (unsigned char* CT) {
int i;
for(i=0;i<16;i++) CT[i] = sbox[ CT[i] ];
}
void ISByte (unsigned char* CT) {
int i;
for(i=0;i<16;i++) CT[i] = isbox[ CT[i] ];
}
void show(unsigned char * CT) {
}
/* Comment out the following with above to easily remove show calls
void show(unsigned char* CT) {
int i;
for(i=0;i<16;i++){printf("%02x ",CT[i]); if (i%4==3) printf(" ");}
printf("\n");
}
*/
void RFunc (unsigned char* CT) {
SByte(CT);
SRow(CT);
show(CT);
Mcol(CT);
show(CT);
}
void IRFunc (unsigned char* CT) {
show(CT);
IMcol(CT);
show(CT);
ISRow(CT);
ISByte(CT);
show(CT);
}
void Fork_enc(unsigned char* Key,unsigned char* T, unsigned char* PT, unsigned char* CT, unsigned char* IT, unsigned char* DecKey) {
int i,round;
unsigned char RKey[272];
for(i=0;i<16;i++) RKey [i]=Key[i];
expand_key(RKey);
for(i=0;i<16;i++) DecKey[i] = RKey[160+i];
//printf("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n");
for(i=0;i<17;i++)show(RKey+16*i);
//printf("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n");
for(i=0;i<16;i++)CT[i]=PT[i];
for(round=0;round<=4;round++) {
for(i=0;i<16;i++) CT[i] ^= (RKey[i+round*16]^T[i]);
//show(CT);
RFunc(CT);
//show(CT);
//printf("=====\n");
}
//printf("================================================\n");
for(i=0;i<16;i++)IT[i]=CT[i];
for(round=5;round<=9;round++) {
for(i=0;i<16;i++) CT[i] ^= (RKey[i+round*16]^T[i]);
RFunc(CT);
//show(CT);
//printf("=====\n");
}
for(i=0;i<16;i++) CT[i] ^= (RKey[i+10*16]^T[i]); //CT1
//show(CT);
//printf("================================================\n");
//printf("%02x %02x %02x \n", IT[0],T[0], RKey[176]);
for(round=11;round<=15;round++) {
for(i=0;i<16;i++) IT[i] ^= (RKey[i+round*16]^T[i]);
//show(IT);
RFunc(IT);
//show(IT);
//printf("=====\n");
}
for(i=0;i<16;i++) IT[i] ^= (RKey[i+16*16]^T[i]); //CT2
show(IT);
//printf("================================================\n");
}
void Fork_dec0(unsigned char* Key,unsigned char* T, unsigned char* CT, unsigned char* PT ) {
int i,round;
unsigned char RKey[272];
for(i=0;i<16;i++) RKey [i]=Key[i];
expand_key(RKey);
for(i=0;i<16;i++)PT[i]=CT[i];
for(round=10;round>=1;round--){
show(RKey + round*16);
for(i=0;i<16;i++) PT[i] ^= (RKey[i+round*16]^T[i]);
IRFunc(PT);
//printf("=====\n");
}
show(RKey);
for(i=0;i<16;i++) PT[i] ^= (RKey[i+0*16]^T[i]); //PT
show(PT);
}
void Fork_rec0(unsigned char* Key,unsigned char* T, unsigned char* IT, unsigned char* CT ) {
int i,round;
unsigned char RKey[272];
for(i=0;i<16;i++) RKey [i]=Key[i];
expand_key(RKey);
for(i=0;i<16;i++)IT[i]=CT[i];
for(round=10;round>=6;round--) {
for(i=0;i<16;i++) IT[i] ^= (RKey[i+round*16]^T[i]);
show(RKey + round*16);
IRFunc(IT);
//printf("=====\n");
}
for(i=0;i<16;i++) IT[i] ^= (RKey[i+5*16]^T[i]);
show(RKey + 5*16);
show(IT);
//printf("=====\n");
for(round=11;round<=15;round++) {
for(i=0;i<16;i++) IT[i] ^= (RKey[i+round*16]^T[i]);
show(RKey + round*16);
RFunc(IT);
//printf("=====\n");
}
for(i=0;i<16;i++) IT[i] ^= (RKey[i+round*16]^T[i]);
show(RKey + round*16);
show(IT);
//printf("=====\n");
}
void save_enc(FILE *in, FILE* out, unsigned char* Key, unsigned char* Tweak, unsigned char* PT, unsigned char* CT, unsigned char* IT) {
int i;
for(i=0;i<16;i++) fprintf(in, "%02X", PT[i]); fprintf(in, "\n");
for(i=0;i<16;i++) fprintf(in, "%02X", Key[i]); fprintf(in, "\n");
for(i=0;i<8;i++) fprintf(in, "%02X", Tweak[i]); fprintf(in, "\n");
fprintf(in, "%01X", 0); fprintf(in, "\n");
for(i=0;i<16;i++) fprintf(out, "%02X", CT[i]); fprintf(out, "\n");
for(i=0;i<16;i++) fprintf(out, "%02X", IT[i]); fprintf(out, "\n");
}
void save_dec(FILE *in, FILE* out, unsigned char* DecKey, unsigned char* Tweak, unsigned char* PT, unsigned char* CT) {
int i;
for(i=0;i<16;i++) fprintf(in, "%02X", CT[i]); fprintf(in, "\n");
for(i=0;i<16;i++) fprintf(in, "%02X", DecKey[i]); fprintf(in, "\n");
for(i=0;i<8;i++) fprintf(in, "%02X", Tweak[i]); fprintf(in, "\n");
fprintf(in, "%01X", 1); fprintf(in, "\n");
for(i=0;i<16;i++) fprintf(out, "%02X", PT[i]); fprintf(out, "\n");
}
void save_rec(FILE *in, FILE* out, unsigned char* DecKey, unsigned char* Tweak, unsigned char* IT, unsigned char* CT) {
int i;
for(i=0;i<16;i++) fprintf(in, "%02X", CT[i]); fprintf(in, "\n");
for(i=0;i<16;i++) fprintf(in, "%02X", DecKey[i]); fprintf(in, "\n");
for(i=0;i<8;i++) fprintf(in, "%02X", Tweak[i]); fprintf(in, "\n");
fprintf(in, "%01X", 2); fprintf(in, "\n");
for(i=0;i<16;i++) fprintf(out, "%02X", IT[i]); fprintf(out, "\n");
}
void tweak_expand(unsigned char* Tweak, unsigned char* T) {
int i;
for(i=0;i<16;i++) {
if(i%4==0)
T[i] = Tweak[i/4];
else if(i%4==1)
T[i] = Tweak[i/4+4];
else
T[i] = 0;
}
}
void random_testcase_gen(unsigned char* Key, unsigned char* Tweak, unsigned char* T, unsigned char* PT, unsigned char* CT, unsigned char* IT, unsigned char* DecKey) {
int i;
for(i = 0; i < 16; i++) sprintf(Key + i, "%X", rand() % 16);
for(i = 0; i < 8; i++) sprintf(Tweak + i, "%X", rand() % 16);
for(i = 0; i < 16; i++) sprintf(PT + i, "%X", rand() % 16);
tweak_expand(Tweak, T);
Fork_enc(Key, T, PT, CT, IT, DecKey);
}
void main()
{
FILE *in = fopen("Testinput.txt", "w");
FILE *out = fopen("Testoutput.txt", "w");
int i,j;
// unsigned char Key[16]={0x2b, 0x7e, 0x15, 0x16, 0x28 , 0xae , 0xd2 , 0xa6 , 0xab , 0xf7 , 0x15 , 0x88 , 0x09 , 0xcf , 0x4f , 0x3c};
// unsigned char PT[16]= {0x32, 0x43, 0xf6, 0xa8, 0x88 , 0x5a , 0x30 , 0x8d , 0x31 , 0x31 , 0x98 , 0xa2 , 0xe0 , 0x37 , 0x07 , 0x34};
unsigned char Key[16]={0x84 , 0x81 , 0x85 , 0xdf , 0xa9 , 0x51 , 0xf1 , 0x1e , 0x13 , 0x97 , 0x24 , 0x8a , 0x6a , 0x69 , 0x8b , 0x17};
unsigned char PT[16]= {0xad , 0x40 , 0xa8 , 0x96 , 0xb1 , 0xc7 , 0xea , 0xa0 , 0x52 , 0xb1 , 0xa7 , 0x0b , 0xd6 , 0x45 , 0xdb , 0x66};
unsigned char CT0[16]= {0x77 , 0x6f , 0xd5 , 0x14 , 0xcf , 0xe2 , 0x89 , 0x9a , 0x06 , 0x5c , 0xcd , 0xa5 , 0x4c , 0x44 , 0xe5 , 0x65};
unsigned char Tweak[8]={0x12,0x23,0x34,0x45,0x56,0x67,0x78,0x83};
unsigned char T[16], CT[16], IT[16], P0[16], P1[16], R[16], DecKey[16];
tweak_expand(Tweak, T);
// for(i=0;i<16;i++) if(i%4<2) T[i]=Tweak[k++]; else T[i]=0;
Fork_enc(Key,T,PT,CT,IT,DecKey);
save_enc(in, out, Key, Tweak, PT, CT, IT);
Fork_dec0(Key,T,CT0,P0);
save_dec(in, out, DecKey, Tweak, P0, CT0);
Fork_rec0(Key,T,IT,CT0);
save_rec(in, out, DecKey, Tweak, IT, CT0);
for(j=0; j<100; j++) {
random_testcase_gen(Key, Tweak, T, PT, CT, IT, DecKey);
save_enc(in, out, Key, Tweak, PT, CT, IT);
random_testcase_gen(Key, Tweak, T, PT, CT, IT, DecKey);
save_dec(in, out, DecKey, Tweak, PT, CT);
random_testcase_gen(Key, Tweak, T, PT, CT, IT, DecKey);
save_rec(in, out, DecKey, Tweak, IT, CT);
}
fclose(in);
fclose(out);
}

Event Timeline

c4science · Help