/*----------------------------------------------------------------------------*/
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;
}
