Ignore:
Timestamp:
Feb 26, 2010, 1:27:59 AM (12 years ago)
Author:
Sven Rech
Message:

more speed for bruteforcing by using unsafe code in AES and DES (just temporary)

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/NativeCryptography/NativeCryptography.h

    r1192 r1193  
    1111        {
    1212        private:
    13                 static void arrayToCArray(array<unsigned char>^ a, unsigned char *ca, int length)
    14                 {
    15                         int counter;
    16                         int l = (a->Length < length) ? a->Length : length;
    17                         for (counter = 0; counter < l; counter++)
    18                                 ca[counter] = a[counter];
    19                         for (; counter < length; counter++)
    20                                 ca[counter] = 0;
    21                 }
    22 
    23                 static void carrayToArray(array<unsigned char>^ a, unsigned char *ca, int length)
    24                 {
    25                         int counter;
    26                         for (counter = 0; counter < length; counter++)
    27                                 a[counter] = ca[counter];
    28                 }
    29 
    3013                static void xorBlockAES(int *t1, int *t2)
    3114                {
     
    4326
    4427        public:
    45                 static array<unsigned char>^ decryptAES(array<unsigned char>^ input, array<unsigned char>^ key, const int bits, const int length, const int mode)
     28                static array<unsigned char>^ decryptAES(unsigned char* input, unsigned char* key, const int bits, const int length, const int mode)
    4629                {
    4730                        const int blockSize = 16;
     
    5033                                numBlocks++;
    5134
    52                         unsigned char* inp = (unsigned char*)malloc(numBlocks*blockSize);
    5335                        unsigned char* outp = (unsigned char*)malloc(numBlocks*blockSize);
    54                         unsigned char ckey[32];
    5536
    56                         arrayToCArray(input, inp, numBlocks*blockSize);                 
    57                         arrayToCArray(key, ckey, bits/8);
     37                        AES_KEY aeskey;                 
     38                        if (mode == 2)  //CFB
     39                        {
     40                                AES_set_encrypt_key(key, bits, &aeskey);
     41                                unsigned char iv[blockSize];
     42                                for (int i = 0; i < blockSize; i++)
     43                                {
     44                                        iv[i] = 0;
     45                                }
    5846
    59                         AES_KEY aeskey;
    60                         AES_set_decrypt_key(ckey, bits, &aeskey);
    61                         AES_decrypt(inp, outp, &aeskey);
    62                         for (int c = 1; c < numBlocks; c++)
     47                                AES_encrypt(iv, outp, &aeskey);
     48                                xorBlockAES((int*)(outp), (int*)(input));
     49
     50                                for (int c = 0; c < numBlocks-1; c++)
     51                                {
     52                                        AES_encrypt((input+c*blockSize), outp+(c+1)*blockSize, &aeskey);                                       
     53                                        xorBlockAES((int*)(outp+(c+1)*blockSize), (int*)(input+(c+1)*blockSize));
     54                                }
     55                        }
     56                        else
    6357                        {
    64                                 AES_decrypt((inp+c*blockSize), outp+c*blockSize, &aeskey);
    65                                 if (mode == 1)          //CBC
    66                                         xorBlockAES((int*)(outp+c*blockSize), (int*)(inp+(c-1)*blockSize));
     58                                AES_set_decrypt_key(key, bits, &aeskey);
     59                                AES_decrypt(input, outp, &aeskey);
     60                                for (int c = 1; c < numBlocks; c++)
     61                                {
     62                                        AES_decrypt((input+c*blockSize), outp+c*blockSize, &aeskey);
     63                                        if (mode == 1)          //CBC
     64                                                xorBlockAES((int*)(outp+c*blockSize), (int*)(input+(c-1)*blockSize));                           
     65                                }
    6766                        }
    6867
    6968                        array<unsigned char>^ output = gcnew array<unsigned char>(length);
    70                         carrayToArray(output, outp, length);
    71                         free(inp);
    72                         free(outp);                     
     69                        for (int c = 0; c < length; c++)
     70                                output[c] = outp[c];
     71
    7372                        return output;
    7473                }
    7574
    76                 static array<unsigned char>^ decryptDES(array<unsigned char>^ input, array<unsigned char>^ key, const int length, const int mode)
     75                static array<unsigned char>^ decryptDES(unsigned char* input, unsigned char* key, const int length, const int mode)
    7776                {
    7877                        const int blockSize = 8;
     
    8180                                numBlocks++;
    8281
    83                         unsigned char* inp = (unsigned char*)malloc(numBlocks*blockSize);
    8482                        unsigned char* outp = (unsigned char*)malloc(numBlocks*blockSize);
    85                         unsigned char ckey[8];
    86 
    87                         arrayToCArray(input, inp, numBlocks*blockSize);                 
    88                         arrayToCArray(key, ckey, 8);                   
    8983
    9084                        DES_key_schedule deskey;
    91                         DES_set_key_unchecked(&ckey, &deskey);
    92                         DES_ecb_encrypt((const_DES_cblock*)inp, (const_DES_cblock*)outp, &deskey, DES_DECRYPT);
    93                         for (int c = 1; c < numBlocks; c++)
     85                        DES_set_key_unchecked((const_DES_cblock*)key, &deskey);
     86
     87                        if (mode == 2)  //CFB
     88                        {                               
     89                                unsigned char iv[blockSize];
     90                                for (int i = 0; i < blockSize; i++)
     91                                {
     92                                        iv[i] = 0;
     93                                }
     94
     95                                DES_ecb_encrypt((const_DES_cblock*)iv, (const_DES_cblock*)outp, &deskey, DES_ENCRYPT);
     96                                xorBlockAES((int*)(outp), (int*)(input));
     97
     98                                for (int c = 0; c < numBlocks-1; c++)
     99                                {
     100                                        DES_ecb_encrypt((const_DES_cblock*)(input+c*blockSize), (const_DES_cblock*)(outp+(c+1)*blockSize), &deskey, DES_ENCRYPT);
     101                                        xorBlockDES((int*)(outp+(c+1)*blockSize), (int*)(input+(c+1)*blockSize));
     102                                }
     103                        }
     104                        else
    94105                        {
    95                                 DES_ecb_encrypt((const_DES_cblock*)(inp+c*blockSize), (const_DES_cblock*)(outp+c*blockSize), &deskey, DES_DECRYPT);
    96                                 if (mode == 1)          //CBC
    97                                         xorBlockDES((int*)(outp+c*blockSize), (int*)(inp+(c-1)*blockSize));
     106                                DES_ecb_encrypt((const_DES_cblock*)input, (const_DES_cblock*)outp, &deskey, DES_DECRYPT);
     107                                for (int c = 1; c < numBlocks; c++)
     108                                {
     109                                        DES_ecb_encrypt((const_DES_cblock*)(input+c*blockSize), (const_DES_cblock*)(outp+c*blockSize), &deskey, DES_DECRYPT);
     110                                        if (mode == 1)          //CBC
     111                                                xorBlockDES((int*)(outp+c*blockSize), (int*)(input+(c-1)*blockSize));
     112                                }
    98113                        }
    99114
    100115                        array<unsigned char>^ output = gcnew array<unsigned char>(length);
    101                         carrayToArray(output, outp, length);
    102                         free(inp);
    103                         free(outp);                     
     116                        for (int c = 0; c < length; c++)
     117                                output[c] = outp[c];
     118
    104119                        return output;
    105120                }
Note: See TracChangeset for help on using the changeset viewer.