API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Sep 21st, 2019
86
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 11.94 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.  
  43. unsigned int T0[256] = {0};
  44. unsigned int T1[256] = {0};
  45. unsigned int T2[256] = {0};
  46. unsigned int T3[256] = {0};
  47.  
  48. void copyArray(unsigned char* origin, unsigned char* copied)
  49. {
  50. for (int i = 0; i < 16; i++)
  51. {
  52. copied[i] = origin[i];
  53. }
  54. }
  55. // Print
  56. void PrintFunc(unsigned char *state){
  57. for(int i = 0; i<16; i++){
  58. printf("%x, ",state[i]);
  59. }
  60. printf("\n");
  61. }
  62.  
  63. // Add roundkey
  64. void addRoundKey(unsigned char* State, unsigned char* key) {
  65. for (int i = 0; i < 16; i++) {State[i] ^= key[i];}
  66. }
  67.  
  68. void invAddRoundKey(unsigned char State, unsigned char key) {
  69. {State ^= key;}
  70. }
  71.  
  72.  
  73. // Sub bytes
  74. void subBytes(unsigned char* State){
  75. for (int i = 0; i < 16; i++){State[i] = S[State[i]];}
  76. }
  77.  
  78. void inverseSubBytes(unsigned char* State)
  79. {
  80. for (int i = 0; i < 16; i++)
  81. {
  82. State[i] = SI[State[i]];
  83. }
  84. }
  85.  
  86. void invByteSubBytes(unsigned char State){
  87. State = SI[State];
  88. }
  89.  
  90. // Bit multiplication
  91.  
  92. unsigned char mul2(unsigned char x)
  93. {
  94. if (x < 128){
  95. return (x << 1);
  96. }
  97. else
  98. {
  99. return (x << 1) ^ 0x1B;
  100. }
  101. }
  102.  
  103. unsigned char mul3(unsigned char x)
  104. {
  105. return mul2(x) ^ x;
  106. }
  107.  
  108.  
  109. void GenerateTtables(){
  110. //we generate the T-tables according to the slides.
  111. // they're handled as 32 bit unsigned integers.
  112.  
  113. for(int i = 0; i < 256; i++){
  114. T0[i] = mul2(S[i]) << 24 | S[i] << 16 | S[i] << 8 | mul3(S[i]);
  115. T1[i] = mul3(S[i]) << 24 | mul2(S[i]) << 16 | S[i] << 8 | S[i];
  116. T2[i] = S[i] << 24 | mul3(S[i]) << 16 | mul2(S[i]) << 8 | S[i];
  117. T3[i] = S[i] << 24 | S[i] << 16 | mul3(S[i]) << 8 | mul2(S[i]);
  118.  
  119. }
  120. }
  121.  
  122.  
  123. //AES round done with the T-tables
  124. void AESRound(unsigned char* state){
  125.  
  126. unsigned int res = T0[state[0]] ^ T1[(state[5])] ^T2[state[10]] ^T3[state[15]];
  127. unsigned int res2 = T0[state[4]] ^ T1[state[9]] ^T2[state[14]] ^T3[state[3]];
  128. unsigned int res3 = T0[state[8]] ^ T1[state[13]] ^T2[state[2]] ^T3[state[7]];
  129. unsigned int res4 = T0[state[12]] ^ T1[state[1]] ^T2[state[6]] ^T3[state[11]];
  130.  
  131. //first extract the relevant bits, and then use 0xff to get ONLY the bits we want.
  132. state[0] = (res >> 24) & 0xff;
  133. state[1] = (res >> 16) & 0xff;
  134. state[2] = (res >> 8) & 0xff;
  135. state[3] = res & 0xff;
  136.  
  137. state[4] = (res2 >> 24) & 0xff;
  138. state[5] = (res2 >> 16) & 0xff;
  139. state[6] = (res2 >> 8) & 0xff;
  140. state[7] = res2 & 0xff;
  141.  
  142. state[8] = (res3 >> 24) & 0xff;
  143. state[9] = (res3 >> 16) & 0xff;
  144. state[10] = (res3 >> 8) & 0xff;
  145. state[11] = res3 & 0xff;
  146.  
  147. state[12] = (res4 >> 24) & 0xff;
  148. state[13] = (res4 >> 16) & 0xff;
  149. state[14] = (res4 >> 8) & 0xff;
  150. state[15] = res4 & 0xff;
  151. }
  152.  
  153. void leftRotate(unsigned char* arr, int startIndex, int d)
  154. {
  155. for (int i = 0; i < d; i++)
  156. {
  157. unsigned char temp = arr[startIndex], i;
  158.  
  159. for (i = startIndex; i < startIndex+3; i++)
  160. {
  161. arr[i] = arr[i + 1];
  162. }
  163.  
  164. arr[i] = temp;
  165. }
  166. }
  167.  
  168. void shiftRows(unsigned char* State)
  169. {
  170. for (int i = 0; i < 4; i++)
  171. {
  172. leftRotate(State, i*4, i);
  173. }
  174. }
  175.  
  176. void invShiftRows(unsigned char* State)
  177. {
  178. for (int i = 1; i < 4; i++)
  179. {
  180. leftRotate(State, i*4, 3*i);
  181. }
  182. }
  183.  
  184.  
  185. void rotWord(unsigned char* state)
  186. {
  187. unsigned char holderVal = state[12];
  188. for (int i = 0; i < 3; i++)
  189. {
  190. state[12+i] = state[13+i];
  191. }
  192. state[15] = holderVal;
  193. }
  194.  
  195. void rowSubBytes(unsigned char* key)
  196. {
  197. for (int i = 0; i < 4; i++)
  198. {
  199. key[12+i] = S[key[12+i]];
  200. }
  201. }
  202.  
  203. void rowXor(unsigned char* key, unsigned char* holderState, int rconIndex)
  204. {
  205. for (int k = 0; k < 13; k = k + 4)
  206. {
  207. if (k == 0)
  208. {
  209. for (int i = 0; i < 4; i++)
  210. {
  211. if (i == 0)
  212. key[i] = holderState[i] ^ key[12+i] ^ rcon[rconIndex];
  213. else
  214. {
  215. key[i] = holderState[i] ^ key[12+i];
  216. }
  217. }
  218. }
  219. else
  220. {
  221. for (int i = 0; i < 4; i++)
  222. {
  223. key[k+i] = holderState[k+i] ^ key[k+i-4];
  224. }
  225. }
  226. }
  227. }
  228.  
  229. void inverseRowXor(unsigned char* key, int rconIndex)
  230. {
  231. for (int k = 3; k > -1; k--)
  232. {
  233. if (k != 0)
  234. {
  235. for (int i = 0; i < 4; i++)
  236. {
  237. key[i*4+k] = key[i*4+k] ^ key[i*4+k-1];
  238. }
  239. }
  240. }
  241. }
  242.  
  243. void xorColumnByIndex (unsigned char* first, int indexF, unsigned char* second, int indexS)
  244. {
  245. for (int i = 0; i < 4; i++)
  246. {
  247. first[indexF+i] = first[indexF+i] ^ second[indexS+i];
  248. }
  249. }
  250. void newKeyGenerate (unsigned char* key, int round, int inverse)
  251. {
  252. if (inverse == 0)
  253. {
  254. unsigned char holderState[16];
  255. copyArray(key, holderState);
  256.  
  257. rotWord(key);
  258. rowSubBytes(key);
  259. rowXor(key, holderState, round);
  260. }
  261. else
  262. {
  263. inverseRowXor(key, 0);
  264.  
  265. unsigned char holderState[16];
  266. copyArray(key, holderState);
  267. rotWord(holderState);
  268. rowSubBytes(holderState);
  269.  
  270. xorColumnByIndex(key,0,holderState,3);
  271. key[0] = key[0] ^ rcon[round];
  272. }
  273. }
  274.  
  275.  
  276. //function for the last special AES round
  277. //could have been done with the T-table however, we already have the functions so why not
  278.  
  279. void AESencrypt4rounds(unsigned char *state, unsigned char *key){
  280. addRoundKey(state,key);
  281. for(int i = 0; i < 3; i++){
  282. AESRound(state);
  283. newKeyGenerate(key,i,0);
  284. addRoundKey(state,key);
  285. //PrintFunc(state);
  286.  
  287. }
  288.  
  289. subBytes(state);
  290. shiftRows(state);
  291. newKeyGenerate(key,3,0);
  292. addRoundKey(state,key);
  293.  
  294. }
  295. unsigned char cipherTexts[256][16];
  296.  
  297. void GenerateCipherTexts(unsigned char* key){
  298. for(int i = 0; i < 256; i++){
  299. for(int x = 0; x < 16; x++){
  300. if(x == 0){
  301. cipherTexts[i][x] = (unsigned char) i; //casted behøves faktisk ikke, men just in case.
  302. }
  303. else{
  304. cipherTexts[i][x] = 0x0;
  305. }
  306.  
  307. }
  308.  
  309. unsigned char key_holder[16];
  310. unsigned char temp_for_encrypt[16];
  311. copyArray(key,key_holder); //dette er nødvendigt da vi i keyscheduelen OVERSKRIVER 'key' med den pågældende runde!!
  312. copyArray(cipherTexts[i],temp_for_encrypt);
  313. //for(int x = 0; x < 16; x++){printf("%x,",temp[x]);}printf("\n");
  314. AESencrypt4rounds(temp_for_encrypt,key_holder);
  315. //copyArray(temp_for_encrypt,cipherTexts[i]);
  316. for(int x = 0; x < 16; x++){
  317. cipherTexts[i][x] = temp_for_encrypt[x];
  318. }
  319.  
  320. //for(int x = 0; x < 16; x++){printf("%x,",cipherTexts[i][x]);}printf("\n");
  321.  
  322. }
  323. }
  324.  
  325. unsigned char key[] = {0x54,0x68,0x61,0x74,0x73,0x20,0x6d,0x79,0x20,0x4b,0x75,0x6e,0x67,0x20,0x46,0x75};
  326.  
  327. unsigned char key2[] = {0x1b,0x84,0x22,0x7a,0x90,0xfe,0x66,0x07,0xc3,0xa9,0xaa,0x17,0x81,0xb7,0x18,0x0f};
  328. unsigned char key3[] = {0x17,0x4a,0x22,0x14,0x40,0x35,0x64,0x75,0xdc,0xe3,0xa0,0x37,0xa3,0x17,0xed,0x4b};
  329. unsigned char key4[] = {0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c};
  330. unsigned char state[] = {0x54,0x77,0x6f,0x20,0x4f,0x6e,0x65,0x20,0x4e,0x69,0x6e,0x65,0x20,0x54,0x77,0x6f};
  331.  
  332. unsigned char stateex1[] = {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0};
  333. unsigned char keyone[] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
  334. unsigned char stateex2[] = {0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0};
  335. unsigned char stateexff[] = {0xff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0};
  336. int main(void) {
  337.  
  338. GenerateTtables();
  339. GenerateCipherTexts(keyone);
  340. unsigned char tempCiphertexts[16];
  341. unsigned char potentialKeys[16][256];
  342.  
  343.  
  344.  
  345. for (int c = 0; c < 16; c++){
  346. // different key (byte)
  347. for (unsigned char j = 0x00; j = 0xff; j++){
  348.  
  349.  
  350. }
  351.  
  352. for(int i = 0; i < 256; i++){
  353. copyArray(cipherTexts[i],tempCiphertexts);
  354. invAddRoundKey(cipherTexts[i], );
  355. invShiftRows(cipherTexts[i]);
  356. inverseSubBytes(cipherTexts[i]);
  357.  
  358. }
  359.  
  360. }
  361.  
  362.  
  363.  
  364.  
  365.  
  366.  
  367.  
  368.  
  369.  
  370. /*
  371. //encrypt all plaintexts to become ciphertext
  372.  
  373. for(int k = 0; k < 256; k++){
  374. for(int x = 0; x < 16; x++){
  375. printf("%x, ",cipherTexts[k][x]);
  376. }
  377. printf("\n ");
  378. }
  379. printf("\n PRINT CHECK \n");
  380. AESencrypt4rounds(stateexff,keyzero);
  381. PrintFunc(stateexff);
  382.  
  383. unsigned char zerosumcheck = cipherTexts[0][1];;
  384. for(int i = 1; i < 256; i++){
  385. zerosumcheck ^= cipherTexts[i][1];
  386. }
  387.  
  388. printf("\n RESULT : %x\n",zerosumcheck);
  389.  
  390.  
  391. */
  392. return EXIT_SUCCESS;
  393.  
  394. }
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!