API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Sep 23rd, 2019
118
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 13.85 KB | None | 0 0
raw download clone embed print report
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4.  
  5. unsigned char rcon[] = {0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80,0x1b,0x36};
  6. unsigned char S[] = {
  7. 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
  8. 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
  9. 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
  10. 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
  11. 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
  12. 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
  13. 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
  14. 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
  15. 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
  16. 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
  17. 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
  18. 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
  19. 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
  20. 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
  21. 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
  22. 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 };
  23.  
  24. unsigned char SI[] = {
  25. 0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
  26. 0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,
  27. 0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
  28. 0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,
  29. 0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
  30. 0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
  31. 0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
  32. 0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
  33. 0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
  34. 0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
  35. 0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
  36. 0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
  37. 0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
  38. 0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
  39. 0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
  40. 0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D };
  41.  
  42. unsigned int T0[256] = {0};
  43. unsigned int T1[256] = {0};
  44. unsigned int T2[256] = {0};
  45. unsigned int T3[256] = {0};
  46.  
  47. void copyArray(unsigned char* origin, unsigned char* copied)
  48. {
  49. for (int i = 0; i < 16; i++)
  50. {
  51. copied[i] = origin[i];
  52. }
  53. }
  54. // Print
  55. void PrintFunc(unsigned char *state){
  56. for(int i = 0; i<16; i++){
  57. printf("%x, ",state[i]);
  58. }
  59. printf("\n");
  60. }
  61.  
  62. // Add roundkey
  63. void addRoundKey(unsigned char* State, unsigned char* key) {
  64. for (int i = 0; i < 16; i++) {State[i] ^= key[i];}
  65. }
  66.  
  67. // Sub bytes
  68. void subBytes(unsigned char* State){
  69. for (int i = 0; i < 16; i++){State[i] = S[State[i]];}
  70. }
  71.  
  72. // Bit multiplication
  73.  
  74. unsigned char mul2(unsigned char x)
  75. {
  76. if (x < 128){
  77. return (x << 1);
  78. }
  79. else
  80. {
  81. return (x << 1) ^ 0x1B;
  82. }
  83. }
  84.  
  85. unsigned char mul3(unsigned char x)
  86. {
  87. return mul2(x) ^ x;
  88. }
  89.  
  90.  
  91. void GenerateTtables(){
  92. //we generate the T-tables according to the slides.
  93. // they're handled as 32 bit unsigned integers.
  94.  
  95. for(int i = 0; i < 256; i++){
  96. T0[i] = mul2(S[i]) << 24 | S[i] << 16 | S[i] << 8 | mul3(S[i]);
  97. T1[i] = mul3(S[i]) << 24 | mul2(S[i]) << 16 | S[i] << 8 | S[i];
  98. T2[i] = S[i] << 24 | mul3(S[i]) << 16 | mul2(S[i]) << 8 | S[i];
  99. T3[i] = S[i] << 24 | S[i] << 16 | mul3(S[i]) << 8 | mul2(S[i]);
  100.  
  101. }
  102. }
  103.  
  104.  
  105. //AES round done with the T-tables
  106. void AESRound(unsigned char* state){
  107.  
  108. unsigned int res = T0[state[0]] ^ T1[(state[5])] ^T2[state[10]] ^T3[state[15]];
  109. unsigned int res2 = T0[state[4]] ^ T1[state[9]] ^T2[state[14]] ^T3[state[3]];
  110. unsigned int res3 = T0[state[8]] ^ T1[state[13]] ^T2[state[2]] ^T3[state[7]];
  111. unsigned int res4 = T0[state[12]] ^ T1[state[1]] ^T2[state[6]] ^T3[state[11]];
  112.  
  113. //first extract the relevant bits, and then use 0xff to get ONLY the bits we want.
  114. state[0] = (res >> 24) & 0xff;
  115. state[1] = (res >> 16) & 0xff;
  116. state[2] = (res >> 8) & 0xff;
  117. state[3] = res & 0xff;
  118.  
  119. state[4] = (res2 >> 24) & 0xff;
  120. state[5] = (res2 >> 16) & 0xff;
  121. state[6] = (res2 >> 8) & 0xff;
  122. state[7] = res2 & 0xff;
  123.  
  124. state[8] = (res3 >> 24) & 0xff;
  125. state[9] = (res3 >> 16) & 0xff;
  126. state[10] = (res3 >> 8) & 0xff;
  127. state[11] = res3 & 0xff;
  128.  
  129. state[12] = (res4 >> 24) & 0xff;
  130. state[13] = (res4 >> 16) & 0xff;
  131. state[14] = (res4 >> 8) & 0xff;
  132. state[15] = res4 & 0xff;
  133. }
  134.  
  135. void leftRotate(unsigned char* arr, int startIndex, int d)
  136. {
  137. for (int i = 0; i < d; i++)
  138. {
  139. unsigned char temp = arr[startIndex], i;
  140.  
  141. for (i = startIndex; i < startIndex+3; i++)
  142. {
  143. arr[i] = arr[i + 1];
  144. }
  145.  
  146. arr[i] = temp;
  147. }
  148. }
  149.  
  150. void shiftRows(unsigned char* State)
  151. {
  152. for (int i = 0; i < 4; i++)
  153. {
  154. leftRotate(State, i*4, i);
  155. }
  156. }
  157.  
  158.  
  159. void rotWord(unsigned char* state)
  160. {
  161. unsigned char holderVal = state[12];
  162. for (int i = 0; i < 3; i++)
  163. {
  164. state[12+i] = state[13+i];
  165. }
  166. state[15] = holderVal;
  167. }
  168.  
  169. void rowSubBytes(unsigned char* key)
  170. {
  171. for (int i = 0; i < 4; i++)
  172. {
  173. key[12+i] = S[key[12+i]];
  174. }
  175. }
  176.  
  177. void rowXor(unsigned char* key, unsigned char* holderState, int rconIndex)
  178. {
  179. for (int k = 0; k < 13; k = k + 4)
  180. {
  181. if (k == 0)
  182. {
  183. for (int i = 0; i < 4; i++)
  184. {
  185. if (i == 0)
  186. key[i] = holderState[i] ^ key[12+i] ^ rcon[rconIndex];
  187. else
  188. {
  189. key[i] = holderState[i] ^ key[12+i];
  190. }
  191. }
  192. }
  193. else
  194. {
  195. for (int i = 0; i < 4; i++)
  196. {
  197. key[k+i] = holderState[k+i] ^ key[k+i-4];
  198. }
  199. }
  200. }
  201. }
  202.  
  203. void inverseRowXor(unsigned char* key, int rconIndex)
  204. {
  205. for (int k = 3; k > -1; k--)
  206. {
  207. if (k != 0)
  208. {
  209. for (int i = 0; i < 4; i++)
  210. {
  211. key[i*4+k] = key[i*4+k] ^ key[i*4+k-1];
  212. }
  213. }
  214. }
  215. }
  216.  
  217. void xorColumnByIndex (unsigned char* first, int indexF, unsigned char* second, int indexS)
  218. {
  219. for (int i = 0; i < 4; i++)
  220. {
  221. first[indexF+i] = first[indexF+i] ^ second[indexS+i];
  222. }
  223. }
  224. void newKeyGenerate (unsigned char* key, int round, int inverse)
  225. {
  226. if (inverse == 0)
  227. {
  228. unsigned char holderState[16];
  229. copyArray(key, holderState);
  230.  
  231. rotWord(key);
  232. rowSubBytes(key);
  233. rowXor(key, holderState, round);
  234. }
  235. else
  236. {
  237. inverseRowXor(key, 0);
  238.  
  239. unsigned char holderState[16];
  240. copyArray(key, holderState);
  241. rotWord(holderState);
  242. rowSubBytes(holderState);
  243.  
  244. xorColumnByIndex(key,0,holderState,3);
  245. key[0] = key[0] ^ rcon[round];
  246. }
  247. }
  248.  
  249. void shift(unsigned char* src, int shifts){
  250. for(int i = 0; i < shifts; i++){
  251. int temper = src[0];
  252. for(int i = 0;i < 3 ;i++) {
  253. src[i] = src[i+1];
  254. }
  255. src[3] = temper;
  256. }
  257. }
  258.  
  259. void shiftRowsActual(unsigned char* src){
  260. unsigned char r0[4] = {0};
  261. unsigned char r1[4] = {0};
  262. unsigned char r2[4] = {0};
  263. unsigned char r3[4] = {0};
  264.  
  265. for (int i = 0; i < 4; i++){
  266. r0[i] = src[i*4];
  267. r1[i] = src[i*4+1];
  268. r2[i] = src[i*4+2];
  269. r3[i] = src[i*4+3];
  270. }
  271. shift(r1,1);
  272. shift(r2,2);
  273. shift(r3,3);
  274.  
  275. for (int i = 0; i < 4; i++){
  276. src[i*4] = r0[i];
  277. src[i*4+1] = r1[i];
  278. src[i*4+2] = r2[i];
  279. src[i*4+3] = r3[i];
  280. }
  281. }
  282. //function for the last special AES round
  283. //could have been done with the T-table however, we already have the functions so why not
  284.  
  285. void AESencrypt4rounds(unsigned char *state, unsigned char *key){
  286. addRoundKey(state,key);
  287. for(int i = 0; i < 3; i++){
  288. AESRound(state);
  289. newKeyGenerate(key,i,0);
  290. addRoundKey(state,key);
  291. //PrintFunc(state);
  292.  
  293. }
  294. printf("PRINTING");
  295. PrintFunc(state);
  296.  
  297. subBytes(state);
  298. //shiftRows(state);
  299. shiftRowsActual(state);
  300.  
  301. //printf("LAST CHECK ROUND: \n ");
  302. //PrintFunc(state);
  303. newKeyGenerate(key,3,0);
  304. //PrintFunc(key);
  305. addRoundKey(state,key);
  306.  
  307. }
  308. unsigned char cipherTexts[256][16] = {0};
  309.  
  310. void GenerateCipherTexts(unsigned char* key){
  311. for(int i = 0; i < 256; i++){
  312. for(int x = 0; x < 16; x++){
  313. if(x == 0){
  314. cipherTexts[i][x] = (unsigned char) i; //casted behøves faktisk ikke, men just in case.
  315. }
  316. else{
  317. cipherTexts[i][x] = 0x00;
  318. }
  319.  
  320. }
  321.  
  322. unsigned char key_holder[16];
  323. unsigned char temp_for_encrypt[16];
  324. copyArray(key,key_holder); //dette er nødvendigt da vi i keyscheduelen OVERSKRIVER 'key' med den pågældende runde!!
  325. copyArray(cipherTexts[i],temp_for_encrypt);
  326. //for(int x = 0; x < 16; x++){printf("%x,",temp[x]);}printf("\n");
  327. AESencrypt4rounds(temp_for_encrypt,key_holder);
  328. //copyArray(temp_for_encrypt,cipherTexts[i]);
  329. for(int x = 0; x < 16; x++){
  330. cipherTexts[i][x] = temp_for_encrypt[x];
  331. }
  332.  
  333. //for(int x = 0; x < 16; x++){printf("%x,",cipherTexts[i][x]);}printf("\n");
  334.  
  335. }
  336. }
  337.  
  338. unsigned char invByteSubBytes(unsigned char cipherbyte){
  339. return SI[cipherbyte];
  340. }
  341.  
  342. unsigned char key[] = {0x54,0x68,0x61,0x74,0x73,0x20,0x6d,0x79,0x20,0x4b,0x75,0x6e,0x67,0x20,0x46,0x75};
  343.  
  344. unsigned char key2[] = {0x1b,0x84,0x22,0x7a,0x90,0xfe,0x66,0x07,0xc3,0xa9,0xaa,0x17,0x81,0xb7,0x18,0x0f};
  345. unsigned char key3[] = {0x17,0x4a,0x22,0x14,0x40,0x35,0x64,0x75,0xdc,0xe3,0xa0,0x37,0xa3,0x17,0xed,0x4b};
  346. unsigned char key4[] = {0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c};
  347. unsigned char state[] = {0x54,0x77,0x6f,0x20,0x4f,0x6e,0x65,0x20,0x4e,0x69,0x6e,0x65,0x20,0x54,0x77,0x6f};
  348.  
  349. unsigned char stateex000[] = {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0};
  350. unsigned char keyone[] = {0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01};
  351. unsigned char keyonetoF[] = {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0xa,0xb,0xc,0xd,0xe,0xf};
  352. unsigned char stateex1[] = {0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0};
  353. unsigned char stateex22[] = {0x00,0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88,0x99,0xaa,0xbb,0xcc,0xdd,0xee,0xff};
  354. unsigned char stateexff[] = {0xff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0};
  355. int main(void) {
  356.  
  357. GenerateTtables();
  358. GenerateCipherTexts(keyonetoF);
  359. //unsigned char tempCiphertexts[16];
  360. unsigned char potentialKeys[16][256] = {0};
  361. //unsigned char (*potentialKeys)[256];
  362. //potentialKeys = malloc(sizeof(unsigned char[16][256]));
  363. for(int c = 0; c < 16; c++){
  364. //unsigned char hexVal = 0x0;
  365. for(int j = 0; j < 256; j++){ //hex value forloop
  366. unsigned char xorval = 0x0;
  367. for(int a = 0; a < 256; a++){ //all cipher text for loop
  368. //unsigned char temp;
  369. unsigned char temp = (unsigned char) j ^ cipherTexts[a][c];
  370. //printf("VALUE OF TEMP %x \n",temp);
  371. temp = invByteSubBytes(temp); //overskriver temp værdi med pågældende værdi i inverse s-box
  372. //printf("INV VALUE OF TEMP %x \n",temp);
  373. xorval ^= temp;
  374. //printf("%x !!!!!!!!!!! \n",j);
  375.  
  376.  
  377. }
  378. if(xorval == 0){
  379. //så append for det pågældende byte //dvs. hvis c = 0, så er vi på byte 0,
  380. //og så har vi fundet en candidate key byte for byte 0
  381. potentialKeys[c][j] = j;
  382.  
  383. }
  384.  
  385.  
  386. }
  387. }
  388.  
  389. for(int k = 0; k < 16; k++){
  390. for(int x = 0; x < 256; x++){
  391. printf("%x",potentialKeys[k][x]);
  392. }
  393. printf("\n ");
  394. }
  395.  
  396. for(int k = 0; k < 256; k++){
  397. for(int x = 0; x < 16; x++){
  398. printf("%x ",cipherTexts[k][x]);
  399. }
  400. printf("\n ");
  401. }
  402.  
  403.  
  404. printf("\n PRINT CHECK \n");
  405. AESencrypt4rounds(stateex1,keyonetoF);
  406.  
  407. PrintFunc(stateex1);
  408.  
  409.  
  410.  
  411.  
  412. /*
  413. for(int k = 0; k < 256; k++){
  414. for(int x = 0; x < 16; x++){
  415. printf("%x",cipherTexts[k][x]);
  416. }
  417. printf("\n ");
  418. }
  419.  
  420.  
  421. printf("\n PRINT CHECK \n");
  422. AESencrypt4rounds(stateexff,keyzero);
  423. PrintFunc(stateexff);
  424.  
  425.  
  426. unsigned char zerosumcheck = cipherTexts[0][1];;
  427. for(int i = 1; i < 256; i++){
  428. zerosumcheck ^= cipherTexts[i][1];
  429. }
  430.  
  431. printf("\n RESULT : %x \n",zerosumcheck);
  432. unsigned char dank = 0x0;
  433. printf("RES %x \n", dank+10);
  434.  
  435. unsigned char hexVal = 0x0;
  436. for(int j = 0; j < 256; j++){
  437. printf("::::::: %x :::::: \n", hexVal+j);
  438. }
  439. */
  440. return EXIT_SUCCESS;
  441.  
  442. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!