Subversion Repositories Kolibri OS

Rev

Rev 8472 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1.  
  2. /* Author: turbocat2001*/
  3.  
  4. #include <stdio.h>
  5. #include "tea.c"
  6. #include <string.h>
  7. #include <stdint.h>
  8. #include <stdlib.h>
  9. #include "lang_en.c"
  10. #include <conio.h>
  11.  
  12. #define ENCRYPT 1      
  13. #define DECRYPT 2
  14.  
  15. typedef unsigned char flag;
  16. uint32_t key[4];
  17.  
  18. long size_orig_file(FILE* file)
  19. {
  20.     fseek(file, 0, SEEK_END);
  21.     long size = ftell(file);
  22.     fseek(file, 0, SEEK_SET);  
  23.     return size;
  24. }
  25.  
  26. long size_xcrypt_file(FILE* file)
  27. {
  28.     fseek(file, 0, SEEK_END);
  29.     long size = ftell(file);
  30.     fseek(file, 0, SEEK_SET);
  31.     if(size%8==0)
  32.     {
  33.         return size;
  34.     }
  35.     else
  36.     {
  37.         return (size/8+1)*8;
  38.     }
  39. }
  40.  
  41. void xcrypt_file_speed(char *in_file, char* out_file, char arg)
  42. {
  43.     FILE *input, *output;
  44.    
  45.     if((input = fopen(in_file,"rb"))==NULL)
  46.     {
  47.         printf(FILE_NOT_FOUND, in_file);
  48.         exit(1);
  49.     }
  50.    
  51.     output = fopen(out_file,"wb");
  52.  
  53.     long size_f=size_xcrypt_file(input);                              
  54.     uint8_t size_diff;
  55.     size_diff=(uint8_t)(size_f-size_orig_file(input));
  56.     uint32_t *buff;
  57.     buff=malloc(size_f);
  58.     if(!buff)
  59.     {
  60.         puts(MEMORY_ERROR);
  61.         exit(-1);
  62.     }
  63.        
  64.     if(arg==ENCRYPT)
  65.     {                        
  66.         printf(LOAD_IN_RAM,in_file);
  67.         fread(buff, 1,size_f, input);
  68.         printf(FILE_ENCRYPTION);
  69.            
  70.         for(long i=0; i<(size_f/4); i=i+2)
  71.         {
  72.             TEA_encrypt(buff+i,key);
  73.         }
  74.            
  75.         printf(RECORD_ENCRYPT_DATA);
  76.         fwrite(&size_diff,1, 1, output);      
  77.         fwrite(buff,1,size_f, output);        
  78.         fclose(input);                        
  79.         fclose(output);                        
  80.         printf(DATA_ENCRYPT,in_file,out_file);
  81.         exit(0);
  82.     }
  83.    
  84.     else if(arg==DECRYPT)
  85.     {                    
  86.         long size_f=size_orig_file(input);
  87.         printf(LOAD_IN_RAM,in_file);
  88.         fread(&size_diff,1,1,input);          
  89.         fread(buff,1,size_f-1, input);        
  90.         printf(FILE_DECRYPTION);  
  91.              
  92.         for(long i=0; i<size_f/4; i=i+2)
  93.         {
  94.             TEA_decrypt(buff+i,key);        
  95.         }
  96.      
  97.         printf(RECORD_DECRYPT_DATA);
  98.         fwrite(buff,1,size_f-size_diff-1, output);
  99.         fclose(input);
  100.         fclose(output);
  101.         printf(DATA_DECRYPT,in_file,out_file);
  102.         exit(0);
  103.     }
  104. }
  105.  
  106. void xcrypt_file(char *in_file, char* out_file, char arg)
  107. {
  108.     uint32_t temp_block[2];  
  109.     FILE *input, *output;
  110.    
  111.     if((input = fopen(in_file,"rb"))==NULL)
  112.     {
  113.         printf(FILE_NOT_FOUND, in_file);
  114.         exit(1);
  115.     }
  116.  
  117.     output = fopen(out_file,"wb");
  118.    
  119.     register long size_f=size_xcrypt_file(input);                
  120.     uint8_t size_diff=(uint8_t)(size_f-size_orig_file(input));
  121.    
  122.     if(arg==ENCRYPT){                                  
  123.         fwrite(&size_diff,1,1,output);
  124.         printf(FILE_ENCRYPTION);          
  125.        
  126.         while(!feof(input))
  127.         {
  128.             memset(temp_block, 0x00, 2);
  129.             fread(temp_block, sizeof(uint32_t), 2, input) ;
  130.             TEA_encrypt(temp_block,key);
  131.             fwrite(temp_block, sizeof(uint32_t),2, output);
  132.         }
  133.        
  134.         fclose(input);
  135.         fclose(output);
  136.         printf(DATA_ENCRYPT,in_file,out_file);
  137.         exit(0);
  138.  
  139.     }
  140.     else if(arg==DECRYPT){
  141.         size_f = size_orig_file(input);
  142.         fread(&size_diff,1,1,input);
  143.         size_f=size_f-size_diff-1;
  144.         printf(FILE_DECRYPTION);
  145.            
  146.         while(!feof(input))      
  147.         {
  148.             fread(temp_block, sizeof(uint32_t), 2, input);
  149.             TEA_decrypt(temp_block,key);
  150.            
  151.             if(size_f>=8)
  152.             {
  153.                 fwrite(temp_block,sizeof(uint32_t),2,output);
  154.             }
  155.             else
  156.             {    
  157.                 fwrite(temp_block,1,size_f,output);
  158.             }
  159.  
  160.             size_f=size_f-8;
  161.            
  162.             if(size_f<0)
  163.             {
  164.                 size_f=0;
  165.             }    
  166.         }
  167.  
  168.         fclose(input);
  169.         fclose(output);
  170.         printf(DATA_DECRYPT,in_file,out_file);
  171.         exit(0);
  172.     }
  173. }
  174.  
  175.  
  176.  
  177. void str_to_strkey(char *str, char str_key[4][9])
  178. {
  179.     int count=0;
  180.     for(int i=0; i<4; i++)
  181.     {
  182.         int j=0;
  183.         while (j<8)
  184.         {
  185.             str_key[i][j]=str[count];
  186.             count++;
  187.             j++;
  188.         }
  189.     }
  190. }
  191.  
  192. int valid_key(char *str)                        
  193. {
  194.     int count=0;
  195.     char hex[]={"abcdefABCDEF0123456789"};
  196.     for(int i=0; i<32; i++)
  197.     {
  198.         if(strchr(hex,str[i])!=NULL)
  199.         {
  200.             count++;
  201.         }
  202.      }
  203.      if(count==32){return 1;}
  204.      else{ return 0;}
  205. }
  206.  
  207.  
  208. void key_con_read(char *str)      
  209. {
  210.     char str_key[4][9];
  211.     if(valid_key(str)&&(strlen(str)==32))
  212.     {
  213.         for(int i=0; i<4; i++)
  214.         {
  215.             str_to_strkey(str, str_key);        
  216.             key[i]=(uint32_t)strtol(str_key[i],NULL,16);
  217.         }
  218.  
  219.     }
  220.  
  221.     else
  222.     {
  223.         printf(INVALID_KEY_FORMAT);
  224.         exit(-1);
  225.     }
  226. }
  227.  
  228. void key_file_read(char *key_file)                  
  229. {
  230.     FILE *keyfile;
  231.     if((keyfile = fopen(key_file,"rb"))==NULL)
  232.     {
  233.         printf(FILE_NOT_FOUND, key_file);
  234.         exit(-1);
  235.     }
  236.  
  237.     if(size_orig_file(keyfile)==16)    
  238.     {
  239.     fread(key,sizeof(uint32_t),4, keyfile);    
  240.     }
  241.     else
  242.     {
  243.         printf(INVALID_KEY_FORMAT);
  244.         exit(-1);
  245.     }
  246.  
  247.     fclose(keyfile);
  248. }
  249.  
  250.  
  251. void findopt(int argc, char *argv[],char *in_file, char *out_file)
  252. {
  253.     char found=0;
  254.     for(int j=3; j<argc; j++)
  255.     {
  256.         if(!strcmp(argv[j],"-k"))
  257.         {
  258.             found=1;
  259.             key_con_read(argv[j+1]);
  260.             break;
  261.         }
  262.         else if(!strcmp(argv[j],"-K"))
  263.         {
  264.             found=1;
  265.             key_file_read(argv[j+1]);
  266.             break;
  267.         }
  268.     }
  269.  
  270.     if(!found)
  271.     {
  272.         printf(NO_KEY_OR_KEYFILE);
  273.         exit(-1);
  274.     }
  275.  
  276.  
  277.     for(int i=3;i<argc; i++){
  278.         if(!strcmp(argv[i],"-e"))
  279.         {
  280.            if(!strcmp(argv[i+1],"normal")){xcrypt_file(in_file, out_file, ENCRYPT);}
  281.            if(!strcmp(argv[i+1],"speed")){xcrypt_file_speed(in_file, out_file, ENCRYPT);}
  282.         }
  283.         if(!strcmp(argv[i],"-d"))
  284.         {
  285.            if(!strcmp(argv[i+1],"normal")){xcrypt_file(in_file, out_file, DECRYPT);}
  286.            if(!strcmp(argv[i+1],"speed")){xcrypt_file_speed(in_file, out_file, DECRYPT);}
  287.         }
  288.     }
  289.     printf(INVALID_ARG);
  290.     exit(0);
  291. }
  292.  
  293. void key_write_in_file(char *keyfilename)
  294. {
  295.     FILE *keyfile;
  296.     if((keyfile = fopen(strcat(keyfilename, ".key"), "wb"))==NULL)
  297.     {
  298.         printf(INCORRECT_FILE, keyfilename);
  299.         exit(-1);
  300.     }
  301.     fwrite(key,sizeof(uint8_t), 16, keyfile);
  302.     printf(KEY_RECORD_IN_FILE, keyfilename);
  303.     fclose(keyfile);
  304.     exit(0);
  305.  
  306. }
  307.  
  308.  
  309. int main(int argc, char **argv)
  310. {
  311.    con_init_console_dll();
  312.    con_set_title("TEAtool\0");
  313.    if(argc==7)
  314.    {
  315.          findopt(argc,argv, argv[1],argv[2]);
  316.    }
  317.    else if(argc==2 && !strcmp(argv[1],"-a"))
  318.    {
  319.        show_about();
  320.        exit(0);
  321.    }
  322.  
  323.    else if(argc==2 && !strcmp(argv[1],"-h"))
  324.    {
  325.        show_help();
  326.        exit(0);
  327.    }
  328.  
  329.    else if(argc==4 && !strcmp(argv[1],"-r"))
  330.    {
  331.        key_con_read(argv[2]);
  332.        key_write_in_file(argv[3]);
  333.    }
  334.  
  335.  
  336.    else
  337.    {
  338.        printf(INVALID_ARG);
  339.        exit(0);
  340.    }
  341.  
  342.     return 0;
  343.  
  344. }
  345.  
  346.