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 i, failures = 0; dlkp_p keypair; mpnumber hm, r, s, k, e_r, e_s; for (i = 0; i < NVECTORS; i++) { dlkp_pInit(&keypair); mpbsethex(&keypair.param.p, table[i].p); mpbsethex(&keypair.param.q, table[i].q); mpnsethex(&keypair.param.g, table[i].g); mpnsethex(&keypair.y, table[i].y); mpnzero(&hm); mpnsethex(&hm, table[i].m); mpnzero(&e_r); mpnzero(&e_s); mpnsethex(&e_r, table[i].r); mpnsethex(&e_s, table[i].s); mpnzero(&r); mpnzero(&s); /* first test, verify the signature result from NIST FIPS 186-1 */ if (!dsavrfy(&keypair.param.p, &keypair.param.q, &keypair.param.g, &hm, &keypair.y, &e_r, &e_s)) failures++; mpnfree(&s); mpnfree(&r); mpnfree(&hm); mpnfree(&e_s); mpnfree(&e_r); dlkp_pFree(&keypair); } return failures; }
int main(int argc, char *argv[]) { poptContext optCon = poptGetContext(argv[0], argc, argv, optionsTable, 0); mpbarrett q; mpnumber s; size_t qsize; mpw* qtemp; mpw* qwksp; int rc; int i; while ((rc = poptGetNextOpt(optCon)) > 0) { switch (rc) { default: /*@switchbreak@*/ break; } } mpbzero(&q); mpbsethex(&q, dsa_q); qsize = q.size; qtemp = malloc((13*qsize+13) * sizeof(*qtemp)); qwksp = qtemp+2*qsize; for (i = 0; i < 9; i++) { if (dsa_s[i] == NULL) break; fprintf(stderr, "================================================== %d\n", i); fprintf(stderr, " s: %s\n", dsa_s[i]); mpnzero(&s); mpnsethex(&s, dsa_s[i]); fprintf(stderr, "-------------------------------------------------- %d\n", i); rc = Xmpbinv_w(&q, s.size, s.data, qtemp, qwksp); fprintf(stderr, "BeeCrypt: "); mpfprintln(stderr, qsize, qtemp); fprintf(stderr, "-------------------------------------------------- %d\n", i); rc = Ympbinv_w(&q, s.size, s.data, qtemp, qwksp); fprintf(stderr, " Knuth: "); mpfprintln(stderr, qsize, qtemp); fprintf(stderr, "-------------------------------------------------- %d\n", i); rc = Zmpbinv_w(&q, s.size, s.data, qtemp, qwksp); fprintf(stderr, " Brent: "); mpfprintln(stderr, qsize, qtemp); fprintf(stderr, "-------------------------------------------------- %d\n", i); fprintf(stderr, " q: %s\n", dsa_q); fprintf(stderr, " s: %s\n", dsa_s[i]); fprintf(stderr, " GOOD: %s\n", dsa_w_good[i]); fprintf(stderr, " BAD: %s\n", dsa_w_bad[i]); } return 0; }
int main() { dldp_p params; mpnumber gq; javalong start, now; int iterations = 0; dldp_pInit(¶ms); mpbsethex(¶ms.p, hp); mpbsethex(¶ms.q, hq); mpnsethex(¶ms.g, hg); mpnzero(&gq); /* get starting time */ start = timestamp(); do { mpbnpowmod(¶ms.p, ¶ms.g, (mpnumber*) ¶ms.q, &gq); now = timestamp(); iterations++; } while (now < (start + (SECONDS * ONE_SECOND))); mpnfree(&gq); printf("(%d bits ^ %d bits) mod (%d bits): %d times in %d seconds\n", (int) mpbits(params.g.size, params.g.data), (int) mpbits(params.q.size, params.q.modl), (int) mpbits(params.p.size, params.p.modl), iterations, SECONDS); dldp_pFree(¶ms); 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; }
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 argc, char *argv[]) { pgpImplVecs_t * testImplVecs = &rpmnssImplVecs; pgpDig dig; pgpDigParams pubp; rpmbc bc; int printing = -1; int rc; pgpImplVecs = &rpmbcImplVecs; dig = pgpDigNew(RPMVSF_DEFAULT, 0); pubp = pgpGetPubkey(dig); bc = dig->impl; mpbzero(&bc->p); mpbsethex(&bc->p, fips_p); mpbzero(&bc->q); mpbsethex(&bc->q, fips_q); mpnzero(&bc->g); mpnsethex(&bc->g, fips_g); mpnzero(&bc->y); mpnsethex(&bc->y, fips_y); mpnzero(&bc->r); mpnsethex(&bc->r, fips_r); mpnzero(&bc->s); mpnsethex(&bc->s, fips_s); mpnzero(&bc->hm); mpnsethex(&bc->hm, fips_hm); pubp->pubkey_algo = PGPPUBKEYALGO_DSA; /* XXX assert? */ rc = pgpImplVerify(dig); fprintf(stderr, "=============================== DSA FIPS-186-1: rc %d\n", rc); dig = pgpDigFree(dig); pgpImplVecs = testImplVecs; dig = pgpDigNew(RPMVSF_DEFAULT, 0); pubp = pgpGetPubkey(dig); _pgp_debug = 1; _pgp_print = 1; fprintf(stderr, "=============================== DSA Public Key\n"); if ((rc = doit(DSApub, dig, printing)) != 0) fprintf(stderr, "==> FAILED: rc %d\n", rc); fprintf(stderr, "=============================== DSA Signature of \"%s\"\n", str); if ((rc = doit(DSAsig, dig, printing)) != 0) fprintf(stderr, "==> FAILED: rc %d\n", rc); { DIGEST_CTX ctx = rpmDigestInit(PGPHASHALGO_SHA1, RPMDIGEST_NONE); pgpDigParams dsig = pgpGetSignature(dig); rpmDigestUpdate(ctx, str, strlen(str)); rpmDigestUpdate(ctx, dsig->hash, dsig->hashlen); (void) pgpImplSetDSA(ctx, dig, dsig); } pubp->pubkey_algo = PGPPUBKEYALGO_DSA; /* XXX assert? */ rc = pgpImplVerify(dig); fprintf(stderr, "=============================== DSA verify: rc %d\n", rc); dig = pgpDigFree(dig); pgpImplVecs = testImplVecs; dig = pgpDigNew(RPMVSF_DEFAULT, 0); pubp = pgpGetPubkey(dig); _pgp_debug = 1; _pgp_print = 1; fprintf(stderr, "=============================== RSA Public Key\n"); if ((rc = doit(RSApub, dig, printing)) != 0) fprintf(stderr, "==> FAILED: rc %d\n", rc); fprintf(stderr, "=============================== RSA Signature of \"%s\"\n", str); if ((rc = doit(RSAsig, dig, printing)) != 0) fprintf(stderr, "==> FAILED: rc %d\n", rc); { DIGEST_CTX ctx = rpmDigestInit(PGPHASHALGO_SHA1, RPMDIGEST_NONE); pgpDigParams dsig = pgpGetSignature(dig); rpmDigestUpdate(ctx, str, strlen(str)); rpmDigestUpdate(ctx, dsig->hash, dsig->hashlen); (void) pgpImplSetRSA(ctx, dig, dsig); } pubp->pubkey_algo = PGPPUBKEYALGO_RSA; /* XXX assert? */ rc = pgpImplVerify(dig); fprintf(stderr, "=============================== RSA verify: rc %d\n", rc); dig = pgpDigFree(dig); pgpImplVecs = testImplVecs; dig = pgpDigNew(RPMVSF_DEFAULT, 0); pubp = pgpGetPubkey(dig); _pgp_debug = 1; _pgp_print = 1; fprintf(stderr, "=============================== ECDSA Public Key\n"); if ((rc = doit(ECDSApub, dig, printing)) != 0) fprintf(stderr, "==> FAILED: rc %d\n", rc); fprintf(stderr, "=============================== ECDSA Signature of \"%s\"\n", str); if ((rc = doit(ECDSAsig, dig, printing)) != 0) fprintf(stderr, "==> FAILED: rc %d\n", rc); { DIGEST_CTX ctx = rpmDigestInit(PGPHASHALGO_SHA256, RPMDIGEST_NONE); pgpDigParams dsig = pgpGetSignature(dig); rpmDigestUpdate(ctx, str, strlen(str)); rpmDigestUpdate(ctx, dsig->hash, dsig->hashlen); (void) pgpImplSetECDSA(ctx, dig, dsig); } pubp->pubkey_algo = PGPPUBKEYALGO_ECDSA; /* XXX assert? */ rc = pgpImplVerify(dig); fprintf(stderr, "=============================== ECDSA verify: rc %d\n", rc); dig = pgpDigFree(dig); if (pgpImplVecs == &rpmsslImplVecs) NSS_Shutdown(); return rc; }
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; }