int decode_function_m31(char *publicKey1, char *publicKey2, char *encryptStr, int encryptStrLen, char *source) { mpnumber pubKey1, cipher, decipher; mpbarrett mpbar; unsigned char encryptStrHex[256+1]; char publicKey1Hex[256+1]; char temp[256+1]; unsigned char buff[1024]; memset(encryptStrHex, 0, 256+1); Str2Hex__((unsigned char*)encryptStr, 128, encryptStrHex); memset(publicKey1Hex, 0, 256+1); Str2Hex__((unsigned char*)publicKey1, 128, publicKey1Hex); mpnzero(&pubKey1); mpnzero(&cipher); mpnzero(&decipher); mpbzero(&mpbar); mpnsethex(&pubKey1, publicKey2); mpnsethex(&cipher, encryptStrHex); mpbsethex(&mpbar, publicKey1Hex); if( rsapub( &mpbar ,&pubKey1 , &cipher, &decipher) ) return -1; memset(temp, 0, 256+1); getHexFromMPW(decipher.size, decipher.data, temp); memset(buff, 0, 1024); Hex2Str__((unsigned char*)temp, 256, buff); memcpy(source, buff, 128); return 1; }
int main (int argc, char **argv) { random_update (); #define HMAC(k, m) \ do { \ u_char digest[sha1::hashsize]; \ sha1_hmac (digest, k, sizeof (k) - 1, m, sizeof (m) - 1); \ warn << "k = " << k << "\nm = " << m << "\n" \ << hexdump (digest, sizeof (digest)) << "\n"; \ } while (0) #define HMAC2(k, k2, m) \ do { \ u_char digest[sha1::hashsize]; \ sha1_hmac_2 (digest, k, sizeof (k) - 1, k2, sizeof (k2) - 1, \ m, sizeof (m) - 1); \ warn << "k = " << k << "\nm = " << m << "\n" \ << hexdump (digest, sizeof (digest)) << "\n"; \ } while (0) #if 0 HMAC ("Jefe", "what do ya want for nothing?"); HMAC ("\014\014\014\014\014\014\014\014\014\014\014\014\014\014\014\014\014\014\014\014", "Test With Truncation"); //HMAC2 ("Je", "fe", "what do ya want for nothing?"); #endif bigint p ("c81698301db5fdba3c5fecfdd97ca952c1f0df3500740a567ecdb561555c8a34d0affcc99ae7a38b42d144373ae2f68b48064373b5baef7d25782fd07dc4b35f", 16); bigint q ("d32d977062a62dccfc4a37a21b03fca098973b72860002a3c05084060fbaa81b5c0fc636902a2959fb5ffd3d8a4969fbe9e15037c35477c9789da0b74ef32e3f", 16); bigint n ("a50e41c593b3b866bc4c72d0476611baab9bd54a22c62e11f536f87861ce592e7a101aea8652d3b949e66271b4497f91a861404eb5f3cba23f22b9b46fadda6cd327e3773eb23795e73ee06c16e5df18cf12e812fcd1bdbf3a4d7cca4fecd95fcbf248ac0534a3ebc67ebb06f9ca77d3ce1a5c4920da6d211b5f242e80d03661", 16); rsa_pub rsapub (n); str m ("a random string"); bigint c = rsapub.encrypt (m); rsa_priv rsapriv (p, q); m = rsapriv.decrypt (c, m.len ()); warn << "m " << m << "\n"; rsa_priv x (rsa_keygen (1024)); bigint pt (random_bigint (1019)); bigint ct, pt2; BENCH (100000, ct = x.encrypt (pt)); BENCH (1000, pt = x.decrypt (ct)); #if 0 warn << pt.getstr (10) << "\n"; ct = x.encrypt (pt); warn << ct.getstr (10) << "\n";; pt2 = x.decrypt (ct); warn << pt2.getstr (10) << "\n"; #endif rabin_priv xx (rabin_keygen (1280, 2)); str pt3 ("plaintext message"); BENCH (100000, ct = xx.encrypt (pt3)); BENCH (1000, pt3 = xx.decrypt (ct, sizeof (pt3))); #if 0 BENCH (100, ct = x.sign (pt3)); BENCH (1000, x.verify (pt3, ct)); BENCH (1000, ct = x.encrypt (pt3)); #endif return 0; }
int main(int argc, char * argv[]) { int i = 0, failures = 0; char buf[8192] = {0}; rsakp keypair; mpnumber m, cipher, decipher; randomGeneratorContext rngc; if (randomGeneratorContextInit(&rngc, randomGeneratorDefault()) == 0) { /* First we do the fixed value verification */ rsakpInit(&keypair); mpbsethex(&keypair.n, rsa_n); mpnsethex(&keypair.e, rsa_e); mpnsethex(&keypair.d, rsa_d); mpnzero(&m); mpnzero(&cipher); mpnzero(&decipher); if ( argv[1][0] == '-' && argv[1][1] == 'm') { mpnsetbin(&m, (argv[1] + 2), strlen(argv[1]) - 2); } else if ( argv[1][0] == '-' && argv[1][1] == 'h') { _hex_snprintf(buf, strlen(argv[1]) - 2, argv[1] + 2, sizeof(char)); mpnsethex(&m, buf); } printf("message:%s\n", argv[1] + 2); hex_dump((char *) m.data, m.size << 2); printf("\npublic:%d\n", (int) * keypair.e.data); hex_dump((char *) keypair.e.data, keypair.e.size << 2); /* it's safe to cast the keypair to a public key */ if ( rsapub(&keypair.n, &keypair.e, &m, &cipher) ) { failures++; } printf("\ncipher:\n"); hex_dump((char *) cipher.data, cipher.size << 2); i = mpntobin(buf, &cipher, 0); printf("\ncipher mpntobin:%d\n", i); hex_dump(buf, i); if ( rsapri(&keypair.n, &keypair.d, &cipher, &decipher) ) { failures++; } printf("\ndecipher:%s\n", (char *) decipher.data); hex_dump((char *) decipher.data, decipher.size << 2); _hex_snprintf(buf, decipher.size * sizeof(mpw), (char *) decipher.data, sizeof(mpw)); printf("\n_snprintf (%dbytes):\n%s\n", decipher.size << 2, buf); i = mpntobin(buf, &decipher, 0); printf("\nmpntobin:%d\n", i); hex_dump(buf, i); i = mpntobin(buf, &decipher, (strlen(argv[1])-2)); printf("\nmpntobin intercept:%d\n%s\n", i, buf); hex_dump(buf, i); mpntohex(buf, & decipher); printf("\nmpntohex:(%d)%s\n", decipher.size << 2, buf); mpnfree(&decipher); mpnfree(&cipher); mpnfree(&m); rsakpFree(&keypair); randomGeneratorContextFree(&rngc); } return failures; }
int main( int argc, char **argv ) { FILE *secblock; unsigned char packetType; unsigned short packetLen; unsigned char buffer[4096]; unsigned char hexrep[8192]; // for CRT computation mpbarrett psubone, qsubone; // for testing mpnumber m, cipher, decipher, holder; rsakp keypair; size_t bits = 2048; size_t pbits = (bits+1) >> 1; size_t qbits = (bits - pbits); size_t psize = MP_BITS_TO_WORDS(pbits+MP_WBITS-1); size_t qsize = MP_BITS_TO_WORDS(qbits+MP_WBITS-1); size_t pqsize = psize+qsize; mpw* temp = (mpw*) malloc((16*pqsize+6)*sizeof(mpw)); if( argc < 2 ) { printf( "usage: %s <secblock>\n", argv[0] ); exit( 1 ); } mpbzero(&psubone); mpbzero(&qsubone); secblock = fopen(argv[1], "rb"); if( secblock == NULL ) { printf( "Can't open %s\n", argv[1] ); exit(0); } packetType = fgetc(secblock); packetLen = 0; //big endianness... big16read(&packetLen, secblock); printf( "Packet type: 0x%02X\n", packetType ); printf( "Packet length: %04d\n", (int) packetLen ); // skip ahead six bytes, this includes key generation time and other attributes fread( buffer, 6, 1, secblock); rsakpInit(&keypair); big16read(&packetLen, secblock); printf( "n Packet length: %02d bits, %02d bytes\n", (int) packetLen, (int) bytesFromMpn(packetLen) ); printf( "offset: %x\n", ftell( secblock ) ); fread( buffer, bytesFromMpn(packetLen), 1, secblock ); mpbsetbin(&keypair.n, buffer, bytesFromMpn(packetLen)); mpprintln(packetLen/32, keypair.n.modl); big16read(&packetLen, secblock); printf( "e Packet length: %02d bits, %02d bytes\n", (int) packetLen, (int) bytesFromMpn(packetLen) ); printf( "offset: %x\n", ftell( secblock ) ); fread( buffer, bytesFromMpn(packetLen), 1, secblock ); mpnsetbin(&keypair.e, buffer, bytesFromMpn(packetLen)); mpprintln(keypair.e.size, keypair.e.data); packetType = fgetc(secblock); if( packetType == 0 ) { printf( "secret data is plaintext\n" ); } else { printf( "secret data is encrypted\n" ); } big16read(&packetLen, secblock); printf( "d Packet length: %02d bits, %02d bytes\n", (int) packetLen, (int) bytesFromMpn(packetLen) ); printf( "offset: %x\n", ftell( secblock ) ); fread( buffer, bytesFromMpn(packetLen), 1, secblock ); mpnsetbin(&keypair.d, buffer, bytesFromMpn(packetLen)); mpprintln(keypair.d.size, keypair.d.data); big16read(&packetLen, secblock); printf( "p Packet length: %02d bits, %02d bytes\n", (int) packetLen, (int) bytesFromMpn(packetLen) ); printf( "offset: %x\n", ftell( secblock ) ); fread( buffer, bytesFromMpn(packetLen), 1, secblock ); mpbsetbin(&keypair.p, buffer, bytesFromMpn(packetLen)); mpprintln(packetLen/32, keypair.p.modl); big16read(&packetLen, secblock); printf( "q Packet length: %02d bits, %02d bytes\n", (int) packetLen, (int) bytesFromMpn(packetLen) ); printf( "offset: %x\n", ftell( secblock ) ); fread( buffer, bytesFromMpn(packetLen), 1, secblock ); mpbsetbin(&keypair.q, buffer, bytesFromMpn(packetLen)); mpprintln(packetLen/32, keypair.q.modl); big16read(&packetLen, secblock); printf( "mystery packet length: %02d bits, %02d bytes\n", (int) packetLen, (int) bytesFromMpn(packetLen) ); printf( "offset: %x\n", ftell( secblock ) ); fread( buffer, bytesFromMpn(packetLen), 1, secblock ); mpnzero(&holder); mpnsetbin(&holder, buffer, bytesFromMpn(packetLen)); mpprintln(holder.size, holder.data); fread( buffer, 4, 1, secblock ); // advance by two bytes printf( "offset: %x\n", ftell( secblock ) ); fread( buffer, bytesFromMpn(packetLen), 1, secblock ); printf( "%s\n", buffer ); #ifdef USE_CRT // compute CRT elements /* compute p-1 */ mpbsubone(&keypair.p, temp); mpbset(&psubone, psize, temp); /* compute q-1 */ mpbsubone(&keypair.q, temp); mpbset(&qsubone, qsize, temp); /* compute dp = d mod (p-1) */ mpnsize(&keypair.dp, psize); mpbmod_w(&psubone, keypair.d.data, keypair.dp.data, temp); /* compute dq = d mod (q-1) */ mpnsize(&keypair.dq, qsize); mpbmod_w(&qsubone, keypair.d.data, keypair.dq.data, temp); /* compute qi = inv(q) mod p */ mpninv(&keypair.qi, (mpnumber*) &keypair.q, (mpnumber*) &keypair.p); #endif // now test mpnzero(&m); mpnzero(&cipher); mpnzero(&decipher); mpnsethex(&m, "d436e99569fd32a7c8a05bbc90d32c49"); printf( "Original: " ); mpprintln(m.size, m.data); rsapub(&keypair.n, &keypair.e, &m, &cipher); printf( "Encrypted: " ); mpprintln(cipher.size, cipher.data); #ifdef USE_CRT rsapricrt(&keypair.n, &keypair.p, &keypair.q, &keypair.dp, &keypair.dq, &keypair.qi, &cipher, &decipher); #else rsapri(&keypair.n, &keypair.d, &cipher, &decipher); #endif printf( "Recovered: " ); mpprintln(decipher.size, decipher.data); if (mpnex(m.size, m.data, decipher.size, decipher.data)) printf ( "results don't match\n" ); else printf ( "before and after encyrption sizes match\n" ); printf( "special test routine for STM32 validation\n" ); mpnzero(&cipher); mpnzero(&decipher); mpnsethex(&cipher, "6fa1bf55e15b47f4662f86e8fc7fadf0dc02c603c20c1090096fdbeafbd56897794ee106d0fcd8a58392ee7e14fd4e15b49c4adb02f0eebeb9587e9823e9e11048c1754c5e6ba273a08c35dd68f72bf4758b8c31dee196f683298cdbd259c28976c1459058c37be29b52589f3919dcb41cf57fd0c64796a056702be8c1f7574a005cad8b0aedb8f833d1fcfe5383b6d6695d766cc1a9a3413f7609fa18b0a1214486f8fec17febd3f4cbc177dd6f26568b715249853280c570e2ef8519f51fe78fb1978061a48fcc6730fb24e365120b54e6f4e2c3815997176167456b2a2b8f1a13b66967765fc42d4aeec2b4f8211e54ba9cbbbbfdd8ac7b2f20af8d44cd68" ); printf( "Decrypting: " ); mpprintln(cipher.size, cipher.data); rsapub(&keypair.n, &keypair.e, &cipher, &decipher); printf( "Recovered: " ); mpprintln(decipher.size, decipher.data); free(temp); return 0; }
void doInteraction() { char *cmd; // i/o opRec oprec; unsigned char dataStr[256]; // aes aesParam aesparam; byte aesSrc[16]; byte aesDst[16]; // rsa rsakp keypair; mpnumber m, cipher, signature; // sha1 byte digest[20]; char digestHex[41]; sha1Param sha1param; int i; oprec.data = dataStr; oprec.dataLen = MAXDATLEN; while(1) { // reset the data string for( i = 0; i < MAXDATLEN; i++ ) { oprec.data[i] = '0'; } oprec.dataLen = MAXDATLEN; // grab the string and parse it cmd = getString(); if(parseString(cmd, &oprec) != 1) { oprec.dataLen = MAXDATLEN; continue; } switch(oprec.cipherType) { case CH_AES: for( i = 0; i < 16; i++ ) { aesSrc[i] = 0; } if(aesSetup(&aesparam, AESkeyTable[oprec.keyIndex].key, 128, oprec.opType == CH_ENCRYPT ? ENCRYPT : DECRYPT )) continue; fromhex(aesSrc, oprec.data); if( oprec.opType == CH_ENCRYPT ) { if( aesEncrypt(&aesparam, (uint32_t *)aesDst, (uint32_t *)aesSrc) ) continue; } else { if( aesDecrypt(&aesparam, (uint32_t *)aesDst, (uint32_t *)aesSrc) ) continue; } for( i = 0; i < 16; i++ ) { printf("%02X", aesDst[i] ); } printf( "\n" ); break; case CH_SGN: // init sha1 if( sha1Reset( &sha1param ) ) continue; if( sha1Update( &sha1param, oprec.data, oprec.dataLen )) continue; if( sha1Digest( &sha1param, digest ) ) continue; // digest now contains the 160-bit message we want to sign toHex(digest, digestHex, 20); // digestHex now has the correct large number representation of the message #if TESTING fprintf( stderr, "sha1 of message: %s\n", digestHex ); #endif // init rsa rsakpInit(&keypair); mpbsethex(&keypair.n, RSAkeyTable[oprec.keyIndex].rsa_n); mpnsethex(&keypair.e, RSAkeyTable[oprec.keyIndex].rsa_e); mpbsethex(&keypair.p, RSAkeyTable[oprec.keyIndex].rsa_p); mpbsethex(&keypair.q, RSAkeyTable[oprec.keyIndex].rsa_q); mpnsethex(&keypair.dp, RSAkeyTable[oprec.keyIndex].rsa_dp); mpnsethex(&keypair.dq, RSAkeyTable[oprec.keyIndex].rsa_dq); mpnsethex(&keypair.qi, RSAkeyTable[oprec.keyIndex].rsa_qi); mpnzero(&m); mpnzero(&cipher); mpnzero(&signature); mpnsethex(&m, digestHex); // we are now all set to do the signing // need to: // write signing alg here // make test case // this link is very helpful in writing this code: // http://tools.ietf.org/html/rfc3447#page-12 rsapricrt(&keypair.n, &keypair.p, &keypair.q, &keypair.dp, &keypair.dq, &keypair.qi, &m, &signature); for( i = 0; i < signature.size; i++ ) { printf("%08X", signature.data[i] ); } printf( "\n" ); #if TESTING mpnfree(&m); mpnzero(&m); rsapub(&keypair.n, &keypair.e, &signature, &m); for( i = 0; i < m.size; i++ ) { printf("%08X", m.data[i] ); } printf( "\n" ); #endif rsakpFree(&keypair); break; case CH_VRF: rsakpInit(&keypair); mpbsethex(&keypair.n, RSAkeyTable[oprec.keyIndex].rsa_n); mpnsethex(&keypair.e, RSAkeyTable[oprec.keyIndex].rsa_e); mpbsethex(&keypair.p, RSAkeyTable[oprec.keyIndex].rsa_p); mpbsethex(&keypair.q, RSAkeyTable[oprec.keyIndex].rsa_q); mpnsethex(&keypair.dp, RSAkeyTable[oprec.keyIndex].rsa_dp); mpnsethex(&keypair.dq, RSAkeyTable[oprec.keyIndex].rsa_dq); mpnsethex(&keypair.qi, RSAkeyTable[oprec.keyIndex].rsa_qi); mpnzero(&m); mpnzero(&cipher); mpnzero(&signature); mpnsethex(&m, oprec.data); rsapub(&keypair.n, &keypair.e, &m, &cipher); for( i = 0; i < cipher.size; i++ ) printf("%08X", cipher.data[i]); printf( "\n" ); break; case CH_SHA: // init sha1 if( sha1Reset( &sha1param ) ) continue; if( sha1Update( &sha1param, oprec.data, oprec.dataLen )) continue; if( sha1Digest( &sha1param, digest ) ) continue; // digest now contains the 160-bit message we want to sign toHex(digest, digestHex, 20); printf( "%s\n", digestHex ); break; default: fprintf( stderr, "unknown cipher type caught.\n" ); } // switch // prevent the leak! #if (TESTING == 0) if( cmd != NULL ) free(cmd); #endif } // while }
int main() { int failures = 0; rsakp keypair; mpnumber m, cipher, decipher; randomGeneratorContext rngc; if (randomGeneratorContextInit(&rngc, randomGeneratorDefault()) == 0) { /* First we do the fixed value verification */ rsakpInit(&keypair); mpbsethex(&keypair.n, rsa_n); mpnsethex(&keypair.e, rsa_e); mpbsethex(&keypair.p, rsa_p); mpbsethex(&keypair.q, rsa_q); mpnsethex(&keypair.dp, rsa_d1); mpnsethex(&keypair.dq, rsa_d2); mpnsethex(&keypair.qi, rsa_c); mpnzero(&m); mpnzero(&cipher); mpnzero(&decipher); mpnsethex(&m, rsa_m); /* it's safe to cast the keypair to a public key */ if (rsapub(&keypair.n, &keypair.e, &m, &cipher)) failures++; if (rsapricrt(&keypair.n, &keypair.p, &keypair.q, &keypair.dp, &keypair.dq, &keypair.qi, &cipher, &decipher)) failures++; if (mpnex(m.size, m.data, decipher.size, decipher.data)) failures++; mpnfree(&decipher); mpnfree(&cipher); mpnfree(&m); rsakpFree(&keypair); mpnzero(&m); mpnzero(&cipher); mpnzero(&decipher); /* Now we generate a keypair and do some tests on it */ rsakpMake(&keypair, &rngc, 512); /* generate a random m in the range 0 < m < n */ mpbnrnd(&keypair.n, &rngc, &m); /* it's safe to cast the keypair to a public key */ if (rsapub(&keypair.n, &keypair.e, &m, &cipher)) failures++; if (rsapricrt(&keypair.n, &keypair.p, &keypair.q, &keypair.dp, &keypair.dq, &keypair.qi, &cipher, &decipher)) failures++; if (mpnex(m.size, m.data, decipher.size, decipher.data)) failures++; rsakpFree(&keypair); } return failures; }