API tools faq
paste
Advertisement
PianistaMichal

Mini_AES_1.1

PianistaMichal
Nov 20th, 2014
182
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 8.09 KB | None | 0 0
raw download clone embed print report
  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<string.h>
  4. #include<math.h>
  5.  
  6. //FUNKCJA ZMIENIA CHAR NA BIT
  7. unsigned char_to_bit(const char *ciag){
  8.     int a=0,wynik=0;
  9.     for(a=0;a<strlen(ciag);a++)wynik+=pow((float)2,(int)strlen(ciag)-1-a)*(ciag[a]-'0');
  10.     return wynik;
  11. }
  12. char *bit_to_char(unsigned bit){
  13.     int a=0,b;
  14.     char *liczba;
  15.  
  16.     while(pow((float)2,a)<bit){
  17.         a++;
  18.         if(pow((float)2,a)>bit){
  19.             a--;
  20.             break;
  21.         }
  22.     }
  23.     liczba=(char*)malloc(sizeof(*liczba)*(a+2));
  24.     for(b=0;b<=a;b++){
  25.         if(bit>=pow((float)2,(a-b))){
  26.             liczba[b]='1';
  27.             bit-=pow((float)2,(a-b));
  28.         }
  29.         else liczba[b]='0';
  30.     }
  31.     liczba[a+1]='\0';
  32.     return liczba;
  33. }
  34. ////FUNKCJA DZIELENIE 2 CIAGOW BITOWYCH
  35. ////DZIALA
  36. ////ZWRACA WYNIK DZIELENIA
  37. //char *dziel(char *ciag1,char* ciag2){
  38. //  int a,b,c;
  39. //  int test=0;
  40. //  char *ciag1_kopia=(char*)malloc(sizeof(*ciag1_kopia)*7);
  41. //  char *schowek=(char*)malloc(sizeof(*schowek)*4);
  42. //
  43. //  strcpy(ciag1_kopia,ciag1);
  44. //  //schowek zwracany przypisanie w przypadku mniejszego ciagu
  45. //  //przechowuje 4 ostatnie bity ciag1_kopia
  46. //  for(a=0;a<4;a++){
  47. //      schowek[a]=ciag1_kopia[a+3];
  48. //  }
  49. //  //petla liczaca przesuniecie 2 maks
  50. //  for(a=0;a<3;a++){
  51. //      /*test=0;
  52. //      for(b=0;b<a;b++){
  53. //          if(ciag1_kopia[b]=='1'){
  54. //              test=1;
  55. //              break;
  56. //          }
  57. //      }
  58. //      if(test==0){
  59. //          for(b=0;b<5;b++){
  60. //              if(ciag1_kopia[b+a]-ciag2[b]==1){test=1;break;}
  61. //              if(ciag1_kopia[b+a]-ciag2[b]==-1)break;
  62. //          }
  63. //      }
  64. //      if(test){
  65. //          for(c=0;c<a;c++)if(ciag1_kopia[c]=='1'){ciag1_kopia[c]='0';ciag1_kopia[c+1]+=1;}
  66. //          for(b=0;b<5;b++){
  67. //              ciag1_kopia[b+a]-=ciag2[b];
  68. //              if(ciag1_kopia[b+a]==-1)ciag1_kopia[b+a]=49;
  69. //              else ciag1_kopia[b+a]+='0';
  70. //
  71. //          }
  72. //      }*/
  73. //      if(ciag1_kopia[a]!='0'){
  74. //          for(b=0;b<5;b++){
  75. //              ciag1_kopia[b+a]-=ciag2[b];
  76. //              if(ciag1_kopia[b+a]==-1)ciag1_kopia[b+a]=49;
  77. //              else ciag1_kopia[b+a]+='0';
  78. //          }
  79. //      }
  80. //      for(b=0;b<4;b++)schowek[b]=ciag1_kopia[b+3];
  81. //  }
  82. //  //free(ciag1_kopia);
  83. //  return schowek;
  84. //}
  85. //
  86. ////FUNKCJA MNOZENIE 2 CIAGOW BITOWYCH
  87. ////DZIALA
  88. ////ZWRACA WYNIK MNOZENIA 2 CIAGOW
  89. //unsigned mnoz(const unsigned ciag, const unsigned ciag3){
  90. //  char suma[4][7];
  91. //  char *ciag1=(char*)malloc(sizeof(*ciag1)*4);
  92. //  char *ciag2=(char*)malloc(sizeof(*ciag2)*4);
  93. //  int a, b;
  94. //  char *wynik=(char*)malloc(sizeof(*wynik)*7);
  95. //  bit_to_char(ciag,&ciag1);
  96. //  bit_to_char(ciag3,&ciag2);
  97. //
  98. // 
  99. //
  100. //  for (a = 0; a < 4; a++){
  101. //      for (b = 0; b < 7; b++){
  102. //          if (a > b)suma[a][b] = '0';
  103. //          else if(b-a>=0 && b-a<4) suma[a][b] = ((ciag1[b-a] - '0') * (ciag2[b - a] - '0')) + '0';
  104. //          else suma[a][b] = '0';
  105. //      }
  106. //  }
  107. //
  108. //  for (a = 0; a < 7; a++){
  109. //      wynik[a] = 0;
  110. //      for (b = 0; b < 4; b++){
  111. //          wynik[a] += suma[b][a]-'0';
  112. //      }
  113. //      wynik[a] = (wynik[a] % 2)+'0';
  114. //  }
  115. //  free(ciag1);
  116. //  free(ciag2);
  117. //  return char_to_bit(dziel(wynik,"10011"));
  118. //}
  119.  
  120. //FUNKCJA MNOZENIE DWOCH MACIERZY
  121. void mnoz_mac(const unsigned macierz[2][2],const unsigned macierz2[2][2],unsigned macierz_wynik[2][2]){
  122.     //printf("%d\n%d\n%d\n%d",macierz[0][0],macierz2[0][0],macierz[0][1],macierz2[1][0]);
  123.     macierz_wynik[0][0]=((macierz[0][0]*macierz2[0][0])%15)^((macierz[0][1]*macierz2[1][0])%15);
  124.     macierz_wynik[1][0]=((macierz[1][0]*macierz2[0][0])%15)^((macierz[1][1],macierz2[1][0])%15);
  125.     macierz_wynik[0][1]=((macierz[0][0]*macierz2[0][1])%15)^((macierz[0][1],macierz2[1][1])%15);
  126.     macierz_wynik[1][1]=((macierz[1][0]*macierz2[0][1])%15)^((macierz[1][1],macierz2[1][1])%15);
  127. }
  128.  
  129. //FUNKCJA DODAWANIE 2 MACIERZY
  130. void dod_mac(const unsigned macierz[2][2],const unsigned macierz2[2][2], unsigned macierz_wynik[2][2]){
  131.     int a,b;
  132.     for(a=0;a<2;a++){
  133.         for(b=0;b<2;b++){
  134.             macierz_wynik[a][b]=macierz[a][b]^macierz2[a][b];
  135.         }
  136.     }
  137. }
  138.  
  139. //FUNKCJA ZK
  140. void zk(unsigned macierz[2][2]){
  141.     unsigned schowek;
  142.     schowek=macierz[1][1];
  143.     macierz[1][1]=macierz[1][0];
  144.     macierz[1][0]=schowek;
  145. }
  146.  
  147. //FUNKCJA MM
  148. void mm(unsigned macierz[2][2]){
  149.     unsigned macierz_m[2][2];
  150.     unsigned macierz2[2][2];
  151.     int a,b;
  152.     for(a=0;a<2;a++){
  153.         for(b=0;b<2;b++){
  154.             macierz2[a][b]=macierz[a][b];
  155.         }
  156.     }
  157.     macierz_m[0][0]=char_to_bit("0011");
  158.     macierz_m[1][0]=char_to_bit("0010");
  159.     macierz_m[0][1]=char_to_bit("0010");
  160.     macierz_m[1][1]=char_to_bit("0011");
  161.     mnoz_mac(macierz_m,macierz2,macierz);
  162. }
  163.  
  164. //FUNKCJA SBOX
  165. //TYP=1-SZYFROWANIE
  166. //TYP=2-DESZYFROWANIE
  167. unsigned sbox(const int typ,const unsigned bit){
  168.     //typ E
  169.     if(typ==0){
  170.         if(bit==0)return char_to_bit("1110");
  171.         if(bit==1)return char_to_bit("0100");
  172.         if(bit==2)return char_to_bit("1101");
  173.         if(bit==3)return char_to_bit("0001");
  174.         if(bit==4)return char_to_bit("0010");
  175.         if(bit==5)return char_to_bit("1111");
  176.         if(bit==6)return char_to_bit("1011");
  177.         if(bit==7)return char_to_bit("1000");
  178.         if(bit==8)return char_to_bit("0011");
  179.         if(bit==9)return char_to_bit("1010");
  180.         if(bit==10)return char_to_bit("0110");
  181.         if(bit==11)return char_to_bit("1100");
  182.         if(bit==12)return char_to_bit("0101");
  183.         if(bit==13)return char_to_bit("1001");
  184.         if(bit==14)return char_to_bit("0000");
  185.         if(bit==15)return char_to_bit("0111");
  186.     }
  187.     else{
  188.         if(bit==0)return char_to_bit("1110");
  189.         if(bit==1)return char_to_bit("0011");
  190.         if(bit==2)return char_to_bit("0100");
  191.         if(bit==3)return char_to_bit("1000");
  192.         if(bit==4)return char_to_bit("0001");
  193.         if(bit==5)return char_to_bit("1100");
  194.         if(bit==6)return char_to_bit("1010");
  195.         if(bit==7)return char_to_bit("1111");
  196.         if(bit==8)return char_to_bit("0111");
  197.         if(bit==9)return char_to_bit("1101");
  198.         if(bit==10)return char_to_bit("1001");
  199.         if(bit==11)return char_to_bit("0110");
  200.         if(bit==12)return char_to_bit("1011");
  201.         if(bit==13)return char_to_bit("0010");
  202.         if(bit==14)return char_to_bit("0000");
  203.         if(bit==15)return char_to_bit("0101");
  204.     }
  205. }
  206. //FUNKCJA FgBOX
  207. void fgbox(unsigned macierz[2][2],int typ){
  208.     int a,b;
  209.     for(a=0;a<2;a++){
  210.         for(b=0;b<2;b++){
  211.             macierz[a][b]=sbox(typ,macierz[a][b]);
  212.         }
  213.     }
  214. }
  215.  
  216. //FUNKCJA TWORZENIE MACIERZY
  217. //DZIALA
  218. void tworzenie(unsigned macierz[2][2],char *ciag){
  219.     char schowek[4][5];
  220.     int a,b;
  221.  
  222.     for(a=0;a<4;a++){
  223.         for(b=0;b<4;b++){
  224.             schowek[a][b]=ciag[a*4+b];
  225.         }
  226.         schowek[a][4]='\0';
  227.     }  
  228.  
  229.     macierz[0][0]=char_to_bit(schowek[0]);
  230.     macierz[0][1]=char_to_bit(schowek[1]);
  231.     macierz[1][0]=char_to_bit(schowek[2]);
  232.     macierz[1][1]=char_to_bit(schowek[3]);
  233. }
  234.  
  235. int main(void){
  236.     //DEKLARACJA ZMIENNYCH
  237.     char *k0="1011001011110110";
  238.     char *t="0011110011000011";
  239.     //1 wymiar-k0,lub t
  240.     //2 wymiar-wiersz
  241.     //3 wymiar-kolumna
  242.     //4 wymiar-ciag znakow
  243.     unsigned test=2;
  244.     unsigned test2=3;
  245.     unsigned klucz[3][2][2];
  246.     unsigned wiad[2][2];
  247.     unsigned mac_a[2][2];
  248.     int a,b,c;
  249.     char *wynik=(char*)malloc(sizeof(*wynik)*7);
  250.     //ALOKACJA PAMIECI I PODSTAWOWE PRZYPISYWANIE
  251.     //TWORZENIE MACIERZY
  252.     tworzenie(klucz[0],k0);
  253.     tworzenie(wiad,t);
  254.     //KLUCZ RUNDY 0
  255.     //GENEROWANIE KLUCZA 1 RUNDY
  256.     klucz[1][0][0]=(sbox(0,klucz[0][1][1])^1)^klucz[0][0][0];
  257.     klucz[1][1][0]=klucz[0][1][0]^klucz[1][0][0];
  258.     klucz[1][0][1]=klucz[0][0][1]^klucz[1][1][0];
  259.     klucz[1][1][1]=klucz[0][1][1]^klucz[1][0][1];
  260.     //GENEROWANIE KLUCZA 2 RUNDY
  261.     klucz[2][0][0]=(sbox(0,klucz[1][1][1])^2)^klucz[1][0][0];
  262.     klucz[2][1][0]=klucz[1][1][0]^klucz[2][0][0];
  263.     klucz[2][0][1]=klucz[1][0][1]^klucz[2][1][0];
  264.     klucz[2][1][1]=klucz[1][1][1]^klucz[2][0][1];
  265.     //DODAWANIE KLUCZA 0 RUNDY DO WIADOMOSCI
  266.     dod_mac(klucz[0],wiad,mac_a);
  267.     //ZASTOSOWANIE FUNKCJI FSBOX
  268.     fgbox(mac_a,0);
  269.     //ZASTOSOWANIE FUNKCJI ZK
  270.     zk(mac_a);
  271.     //ZASTOSOWANIE FUNKCJI MM
  272.     mm(mac_a);
  273.     dod_mac(mac_a,klucz[1],mac_a);
  274.     fgbox(mac_a,0);
  275.     zk(mac_a);
  276.     dod_mac(mac_a,klucz[2],mac_a);
  277.  
  278.     printf("=====DANE ZASZYFROWANE=====\n\n");
  279.     for(a=0;a<2;a++){
  280.         for(b=0;b<2;b++){
  281.             if(mac_a[a][b]<=7)printf("0");
  282.             fputs(bit_to_char(mac_a[a][b]),stdout);
  283.         }
  284.     }
  285.     printf("\n\n");
  286.     dod_mac(mac_a,klucz[2],mac_a);
  287.     zk(mac_a);
  288.     fgbox(mac_a,1);
  289.     dod_mac(mac_a,klucz[1],mac_a);
  290.     mm(mac_a);
  291.     zk(mac_a);
  292.     fgbox(mac_a,1);
  293.     printf("test");
  294.     dod_mac(mac_a,klucz[0],mac_a);
  295.  
  296.     printf("=====DANE ODSZYFROWANE=====\n\n");
  297.     for(a=0;a<2;a++){
  298.         for(b=0;b<2;b++){
  299.             if(mac_a[a][b]<=7)printf("0");
  300.             fputs(bit_to_char(mac_a[a][b]),stdout);
  301.         }
  302.     }
  303.     printf("\n\n");
  304.     system("pause");
  305.     return 0;
  306. }
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!