/*----------------------------------------------------------------------------*/ zrtp_status_t zrtp_prepare_pkt(zrtp_global_t* zrtp) { bnInit(); bnBegin(&zrtp->one); bnSetQ(&zrtp->one, 1); bnBegin(&zrtp->G); bnSetQ(&zrtp->G, 2); return zrtp_status_ok; }
/* Functions */ void bnBegin(struct BigNum *bn) { static int bninit = 0; if (!bninit) { bnInit(); bninit = 1; } bn->ptr = 0; bn->size = 0; bn->allocated = 0; }
int main(void) { struct BigNum p, q, d, u; int i; clock_t interval; static unsigned const sizetable[] = { 384, 512, 513, 514, 515, 768, 1024, 1536, 2048, 0 }; unsigned const *sizeptr = sizetable; bnInit(); bnRandSeed(1); bnBegin(&p); bnBegin(&q); bnBegin(&d); bnBegin(&u); while (*sizeptr) { printf("Generating a %u-bit RSA key\n", *sizeptr); interval = clock(); i = genRsaKey(&p, &q, &d, &u, *sizeptr, 17, stdout); interval = clock() - interval; printf("genRsaKey returned %d. %ld.%06ld s\n", i, interval / 1000000, interval % 1000000); fputs("p = ", stdout); bnPrint(stdout, &p); fputs("\nq = ", stdout); bnPrint(stdout, &q); fputs("\nd = ", stdout); bnPrint(stdout, &d); fputs("\nu = ", stdout); bnPrint(stdout, &u); putchar('\n'); sizeptr++; } bnEnd(&p); bnEnd(&q); bnEnd(&d); bnEnd(&u); return 0; }
/* * Turn the algorithm-specific parts of a public key into a PGPPubKey * structure. A public key's DSA-specific part is: * * 0 2+i MPI for prime * 2+i 2+t MPI for order * 4+i+t 2+u MPI for generator * 6+i+t+u 2+v MPI for public key * 8+i+t+u+v */ PGPPubKey * dsaPubFromBuf( PGPContextRef context, PGPByte const * buf, size_t size, PGPError * error) { PGPPubKey *pubkey; DSApub *pub; unsigned i, t, u, v; int w; PGPError err = kPGPError_OutOfMemory; PGPMemoryMgrRef mgr = PGPGetContextMemoryMgr( context ); bnInit(); w = pgpBnParse(buf, size, 4, &i, &t, &u, &v); if (w < 0) { *error = (PGPError)w; return NULL; } if (t <= i+2 || (buf[t-1] & 1) == 0) { /* Too small or even prime p */ *error = kPGPError_MalformedKeyComponent; return NULL; } if (u <= t+2 || (buf[u-1] & 1) == 0) { /* Too small or even order q */ *error = kPGPError_MalformedKeyComponent; return NULL; } pub = (DSApub *)pgpContextMemAlloc( context, sizeof(*pub), kPGPMemoryMgrFlags_Clear); if (pub) { pubkey = (PGPPubKey *)pgpContextMemAlloc( context, sizeof(*pubkey), kPGPMemoryMgrFlags_Clear); if (pubkey) { pubkey->context = context; bnBegin(&pub->p, mgr, FALSE ); bnBegin(&pub->q, mgr, FALSE ); bnBegin(&pub->g, mgr, FALSE ); bnBegin(&pub->y, mgr, FALSE ); if (bnInsertBigBytes(&pub->p, buf+i+2, 0, t-i-2) >= 0 && bnInsertBigBytes(&pub->q, buf+t+2, 0, u-t-2) >= 0 && bnInsertBigBytes(&pub->g, buf+u+2, 0, v-u-2) >= 0 && bnInsertBigBytes(&pub->y, buf+v+2, 0, w-v-2) >= 0) { if (dsaKeyTooBig (pub, NULL)) { err = kPGPError_KeyTooLarge; } else { dsaFillPubkey(pubkey, pub); *error = 0; return pubkey; } } /* Failed = clean up and return NULL */ bnEnd(&pub->p); bnEnd(&pub->q); bnEnd(&pub->g); bnEnd(&pub->y); pgpContextMemFree( context, pubkey); } pgpContextMemFree( context, pub); } *error = err; return NULL; }