Esempio n. 1
0
File: main.c Progetto: jgh33/RC5
/**7、    主函数测试
 
 主函数
 */
int main(void)
{
    TWOBYTEINT ChildKeyS[2*r+2]; //64bit
    TWOBYTEINT ChildKey1[26]={0x9b9a};
    //{0xe25b,0x4338,0x36ab,0xd59f,0x9b9a,0xc0f1,0xdc4f,
    // 0xc0d2,0xf03a,0xff5a,0x771f,0x5952,0xb797,0x28ad,
    //0x5c9a,0xfd9a,0xbd4b,0x3b12,0xd198,0x17f8,0x7f19,
    //0x458e,0x1629,0xaa8a,0xb609,0x9b3c};//{123,434,1,123,1,34,123,56,123,8};
    BYTE KeyK[b];//8bit=byte
    InitialKey(KeyK,b); //生成初始密钥
    int k;
    generateChildKey(KeyK,ChildKeyS); //根据初始密钥生成子密钥
//    TWOBYTEINT Source[]={'1','2','1','1'};//测试明文
    char arr[] = "what can i do for you?";
    unsigned long ll = strlen(arr);
    int m;
    for (m=0; NoOfData * m < ll; m++) {
        TWOBYTEINT Source[4] = {arr[4 * m], arr[4 * m + 1], arr[4 * m + 2], arr[4 * m + 3]};
        printf("加密以前的明文:");
        for (k=0;k<NoOfData;k++)
        {
            
            printf("%.4X ",Source[k]); //16进制输出
            printf("%c ",Source[k]); //16进制输出
        }
        printf("\n");
        TWOBYTEINT Dest[NoOfData]; //用来存储密文
        for(k=0;k<26;k++)
        {
            ChildKey1[k]=ChildKeyS[k];//如果此处自定义简单的数值为加密密钥,则可以解密出密文
            printf("%.4X ",ChildKey1[k]);
            
        }
        Encipher(Source,Dest,ChildKey1); //加密
        printf("\n");
        printf("加密以后的密文:");
        for (k=0;k<NoOfData;k++)
        {
            printf("%.4X ",Dest[k]);
            printf("%c ",Dest[k]);
        }
        printf("\n");
        TWOBYTEINT Data[NoOfData]={0}; //用来存储解密后的密文
        Decipher(Dest,Data,ChildKey1); //解密
        printf("解密以后的明文:");
        for (k=0;k<NoOfData;k++)
        {
            printf("%.4X ",Data[k]);
            printf("%c ",Data[k]);
        }
        printf("\n\n\n\n");

    }
    
    //printf("sizeof unsigned short int: %d",sizeof(unsigned short int));
    system("pause\n");
}
Esempio n. 2
0
char RetrieveKeyInfo(int level_input, const char* name_, unsigned long hardwareID, const char* origkey_, struct KeyInformation* keyinfo, HWND hwndDlg, UINT control_id)
{
    unsigned short keydatecreated=0, keyotherinfo[5]= {0,0,0,0,0};
    unsigned long keytemplateID=0;

    HWND log=(HWND)0;
    char log_msg[1024]="";
    char name[1024]="";
    char serial[1024]="";
    char* origkey=serial;
    strcpy(origkey, origkey_);
    strcpy(name, name_);
    bool firstlog=true;

    bool keystring=false;
    char keystring_text[256]="";

    struct CipherKeyStruct *cipherkey;
    char cooked[512]="";
    int x, v3=0, shortv3=0;
    int level=level_input;

    if(hwndDlg && control_id)
        log=GetDlgItem(hwndDlg, control_id);

    if(level>=14)
    {
        shortv3=1;
        level=level-13;
        //ShortV3 keys can have signature levels 1 through 10 now
        if(level<1 || level>10)
            return 0;
    }
    else if(level>=5)
    {
        v3=1; //TODO: remove?
        level=level-4;
        //V3 keys can now have signature levels 1 through 9
        if(level<1 || level>9)
            return 0;
    }
    else if(level!=0)
    {
        //V2 keys can only have signature levels 1 through 4
        if(level<1 || level>4)
            return 0;
    }

    bool key_appears_nameless=false;
    const char* nameless_check=origkey;
    while(*nameless_check=='0' || *nameless_check=='-')
        nameless_check++;
    if(*nameless_check=='2' && shortv3)
        key_appears_nameless=true;

    if(!name[0] || key_appears_nameless) //nameless key?
    {
        if(!shortv3)
        {
            AddLogMessage(log, "Only ShortV3 Keys can be nameless...", true);
            return 0;
        }
        //remove prepended zero bytes
        while(*origkey=='0' || *origkey=='-')
            origkey++;
        //check for the nameless identifier
        if(*origkey!='2')
        {
            AddLogMessage(log, "Key does not appear to be nameless...", true);
            return 0;
        }
        //retrieve the name
        int count1=0,count2=0;
        for(; count2<6; count1++)
            if(origkey[count1]!='-')
            {
                name[count2]=origkey[count1];
                count2++;
            }
        origkey+=count1;
        sprintf(log_msg, "Nameless Key:\r\nName=%s, Key=%s", name, origkey);
        AddLogMessage(log, log_msg, true);
        firstlog=false;
    }

    if(level==0) ///Analyse unsigned keys
    {
        unsigned long k[2]= {0};
        const char *c=origkey;
        int digits=0;
        char cc;
        while(digits<8 && *c)
        {
            cc=hexdigit(*c++);
            if(cc>=0)
            {
                digits++;
                k[0]=(k[0]<<4)|cc;
            }
        }
        while(digits<16 && *c)
        {
            cc=hexdigit(*c++);
            if(cc>=0)
            {
                digits++;
                k[1]=(k[1]<<4)|cc;
            }
        }
        if(log)
        {
            ByteArray2String((unsigned char*)k, log_msg, sizeof(unsigned long)*2, 20);
            AddLogMessage(log, "Enciphered KeyBytes (Len: 8):", true);
            AddLogMessage(log, log_msg, false);
        }
        CookText(cooked, name);
        cipherkey=CreateCipherKey(cooked, strlen(cooked));
        Decipher(cipherkey, (char*)k, sizeof(unsigned long)*2);
        if(log)
        {
            ByteArray2String((unsigned char*)k, log_msg, sizeof(unsigned long)*2, 20);
            AddLogMessage(log, "Deciphered KeyBytes:", false);
            AddLogMessage(log, log_msg, false);
        }
        ReleaseCipherKey(cipherkey);
        keytemplateID=k[0];
        keydatecreated=(unsigned short)(k[1]>>16);
        keyotherinfo[0]=(unsigned short)(k[1]&0xFFFF);
    }