Back to index

lightning-sunbird  0.9+nobinonly
Functions
pk11pqg.h File Reference
#include "blapit.h"
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions

SEC_BEGIN_PROTOS SECStatus PK11_PQG_ParamGen (unsigned int j, PQGParams **pParams, PQGVerify **pVfy)
SECStatus PK11_PQG_ParamGenSeedLen (unsigned int j, unsigned int seedBytes, PQGParams **pParams, PQGVerify **pVfy)
SECStatus PK11_PQG_VerifyParams (const PQGParams *params, const PQGVerify *vfy, SECStatus *result)
void PK11_PQG_DestroyParams (PQGParams *params)
void PK11_PQG_DestroyVerify (PQGVerify *vfy)
PQGParams * PK11_PQG_NewParams (const SECItem *prime, const SECItem *subPrime, const SECItem *base)
SECStatus PK11_PQG_GetPrimeFromParams (const PQGParams *params, SECItem *prime)
SECStatus PK11_PQG_GetSubPrimeFromParams (const PQGParams *params, SECItem *subPrime)
SECStatus PK11_PQG_GetBaseFromParams (const PQGParams *params, SECItem *base)
PQGVerify * PK11_PQG_NewVerify (unsigned int counter, const SECItem *seed, const SECItem *h)
unsigned int PK11_PQG_GetCounterFromVerify (const PQGVerify *verify)
SECStatus PK11_PQG_GetSeedFromVerify (const PQGVerify *verify, SECItem *seed)
SECStatus PK11_PQG_GetHFromVerify (const PQGVerify *verify, SECItem *h)

Function Documentation

void PK11_PQG_DestroyParams ( PQGParams *  params)

Definition at line 302 of file pk11pqg.c.

                                          {
     PQG_DestroyParams(params);
     return;
}
void PK11_PQG_DestroyVerify ( PQGVerify *  vfy)

Definition at line 311 of file pk11pqg.c.

                                       {
    PQG_DestroyVerify(vfy);
    return;
}
SECStatus PK11_PQG_GetBaseFromParams ( const PQGParams *  params,
SECItem *  base 
)

Definition at line 353 of file pk11pqg.c.

unsigned int PK11_PQG_GetCounterFromVerify ( const PQGVerify *  verify)

Definition at line 374 of file pk11pqg.c.

SECStatus PK11_PQG_GetHFromVerify ( const PQGVerify *  verify,
SECItem *  h 
)

Definition at line 393 of file pk11pqg.c.

                                                              {
    return PQG_GetHFromVerify(verify, h);
}
SECStatus PK11_PQG_GetPrimeFromParams ( const PQGParams *  params,
SECItem *  prime 
)

Definition at line 333 of file pk11pqg.c.

                                                                      {
    return PQG_GetPrimeFromParams(params, prime);
}
SECStatus PK11_PQG_GetSeedFromVerify ( const PQGVerify *  verify,
SECItem *  seed 
)

Definition at line 383 of file pk11pqg.c.

                                                                   {
    return PQG_GetSeedFromVerify(verify, seed);
}
SECStatus PK11_PQG_GetSubPrimeFromParams ( const PQGParams *  params,
SECItem *  subPrime 
)

Definition at line 343 of file pk11pqg.c.

                                                                            {
    return PQG_GetSubPrimeFromParams(params, subPrime);
}
PQGParams* PK11_PQG_NewParams ( const SECItem *  prime,
const SECItem *  subPrime,
const SECItem *  base 
)

Definition at line 322 of file pk11pqg.c.

                                                                {
    return PQG_NewParams(prime, subPrime, base);
}
PQGVerify* PK11_PQG_NewVerify ( unsigned int  counter,
const SECItem *  seed,
const SECItem *  h 
)

Definition at line 364 of file pk11pqg.c.

                                                                    {
    return PQG_NewVerify(counter, seed, h);
}
SEC_BEGIN_PROTOS SECStatus PK11_PQG_ParamGen ( unsigned int  j,
PQGParams **  pParams,
PQGVerify **  pVfy 
)

Definition at line 206 of file pk11pqg.c.

{
    return PK11_PQG_ParamGenSeedLen(j, 0, pParams, pVfy);
}
SECStatus PK11_PQG_ParamGenSeedLen ( unsigned int  j,
unsigned int  seedBytes,
PQGParams **  pParams,
PQGVerify **  pVfy 
)

Definition at line 56 of file pk11pqg.c.

{
    PK11SlotInfo *slot = NULL;
    CK_ATTRIBUTE genTemplate[5];
    CK_ATTRIBUTE *attrs = genTemplate;
    int count = sizeof(genTemplate)/sizeof(genTemplate[0]);
    CK_MECHANISM mechanism;
    CK_OBJECT_HANDLE objectID = CK_INVALID_HANDLE;
    CK_RV crv;
    CK_ATTRIBUTE pTemplate[] = {
       { CKA_PRIME, NULL, 0 },
       { CKA_SUBPRIME, NULL, 0 },
       { CKA_BASE, NULL, 0 },
    };
    CK_ATTRIBUTE vTemplate[] = {
       { CKA_NETSCAPE_PQG_COUNTER, NULL, 0 },
       { CKA_NETSCAPE_PQG_SEED, NULL, 0 },
       { CKA_NETSCAPE_PQG_H, NULL, 0 },
    };
    int pTemplateCount = sizeof(pTemplate)/sizeof(pTemplate[0]);
    int vTemplateCount = sizeof(vTemplate)/sizeof(vTemplate[0]);
    PRArenaPool *parena = NULL;
    PRArenaPool *varena = NULL;
    PQGParams *params = NULL;
    PQGVerify *verify = NULL;
    CK_ULONG primeBits = PQG_INDEX_TO_PBITS(j);
    CK_ULONG seedBits = seedBytes*8;

    *pParams = NULL;
    *pVfy =  NULL;

    if (primeBits == (CK_ULONG)-1) {
       PORT_SetError(SEC_ERROR_INVALID_ARGS);
       goto loser;
    }
    PK11_SETATTRS(attrs, CKA_PRIME_BITS,&primeBits,sizeof(primeBits)); attrs++;
    if (seedBits != 0) {
       PK11_SETATTRS(attrs, CKA_NETSCAPE_PQG_SEED_BITS, 
                                   &seedBits, sizeof(seedBits)); attrs++;
    }
    count = attrs - genTemplate;
    PR_ASSERT(count <= sizeof(genTemplate)/sizeof(CK_ATTRIBUTE));

    slot = PK11_GetInternalSlot();
    if (slot == NULL) {
       /* set error */
       goto loser;
    }

    /* Initialize the Key Gen Mechanism */
    mechanism.mechanism = CKM_DSA_PARAMETER_GEN;
    mechanism.pParameter = NULL;
    mechanism.ulParameterLen = 0;

    PK11_EnterSlotMonitor(slot);
    crv = PK11_GETTAB(slot)->C_GenerateKey(slot->session,
                      &mechanism, genTemplate, count, &objectID);
    PK11_ExitSlotMonitor(slot);

    if (crv != CKR_OK) {
       PORT_SetError( PK11_MapError(crv) );
       goto loser;
    }

    parena = PORT_NewArena(60);
    if (!parena) {
       goto loser;
    }        

    crv = PK11_GetAttributes(parena, slot, objectID, pTemplate, pTemplateCount);
    if (crv != CKR_OK) {
       PORT_SetError( PK11_MapError(crv) );
       goto loser;
    }


    params = (PQGParams *)PORT_ArenaAlloc(parena,sizeof(PQGParams));
    if (params == NULL) {
       goto loser;
    }

    /* fill in Params */
    params->arena = parena;
    params->prime.type = siUnsignedInteger;
    params->prime.data = pTemplate[0].pValue;
    params->prime.len = pTemplate[0].ulValueLen;
    params->subPrime.type = siUnsignedInteger;
    params->subPrime.data = pTemplate[1].pValue;
    params->subPrime.len = pTemplate[1].ulValueLen;
    params->base.type = siUnsignedInteger;
    params->base.data = pTemplate[2].pValue;
    params->base.len = pTemplate[2].ulValueLen;


    varena = PORT_NewArena(60);
    if (!varena) {
       goto loser;
    }        

    crv = PK11_GetAttributes(varena, slot, objectID, vTemplate, vTemplateCount);
    if (crv != CKR_OK) {
       PORT_SetError( PK11_MapError(crv) );
       goto loser;
    }


    verify = (PQGVerify *)PORT_ArenaAlloc(varena,sizeof(PQGVerify));
    if (verify == NULL) {
       goto loser;
    }
    /* fill in Params */
    verify->arena = varena;
    verify->counter = (unsigned int)(*(CK_ULONG*)vTemplate[0].pValue);
    verify->seed.type = siUnsignedInteger;
    verify->seed.data = vTemplate[1].pValue;
    verify->seed.len = vTemplate[1].ulValueLen;
    verify->h.type = siUnsignedInteger;
    verify->h.data = vTemplate[2].pValue;
    verify->h.len = vTemplate[2].ulValueLen;

    PK11_DestroyObject(slot,objectID);
    PK11_FreeSlot(slot);

    *pParams = params;
    *pVfy =  verify;

    return SECSuccess;

loser:
    if (objectID != CK_INVALID_HANDLE) {
       PK11_DestroyObject(slot,objectID);
    }
    if (parena != NULL) {
       PORT_FreeArena(parena,PR_FALSE);
    }
    if (varena != NULL) {
       PORT_FreeArena(varena,PR_FALSE);
    }
    if (slot) {
       PK11_FreeSlot(slot);
    }
    return SECFailure;
}
SECStatus PK11_PQG_VerifyParams ( const PQGParams *  params,
const PQGVerify *  vfy,
SECStatus result 
)

Definition at line 223 of file pk11pqg.c.

{
    CK_ATTRIBUTE keyTempl[] = {
       { CKA_CLASS, NULL, 0 },
       { CKA_KEY_TYPE, NULL, 0 },
       { CKA_PRIME, NULL, 0 },
       { CKA_SUBPRIME, NULL, 0 },
       { CKA_BASE, NULL, 0 },
       { CKA_TOKEN, NULL, 0 },
       { CKA_NETSCAPE_PQG_COUNTER, NULL, 0 },
       { CKA_NETSCAPE_PQG_SEED, NULL, 0 },
       { CKA_NETSCAPE_PQG_H, NULL, 0 },
    };
    CK_ATTRIBUTE *attrs;
    CK_BBOOL ckfalse = CK_FALSE;
    CK_OBJECT_CLASS class = CKO_KG_PARAMETERS;
    CK_KEY_TYPE keyType = CKK_DSA;
    SECStatus rv = SECSuccess;
    PK11SlotInfo *slot;
    int keyCount;
    CK_OBJECT_HANDLE objectID;
    CK_ULONG counter;
    CK_RV crv;

    attrs = keyTempl;
    PK11_SETATTRS(attrs, CKA_CLASS, &class, sizeof(class)); attrs++;
    PK11_SETATTRS(attrs, CKA_KEY_TYPE, &keyType, sizeof(keyType)); attrs++;
    PK11_SETATTRS(attrs, CKA_PRIME, params->prime.data, 
                                          params->prime.len); attrs++;
    PK11_SETATTRS(attrs, CKA_SUBPRIME, params->subPrime.data, 
                                          params->subPrime.len); attrs++;
    PK11_SETATTRS(attrs, CKA_BASE,params->base.data,params->base.len); attrs++;
    PK11_SETATTRS(attrs, CKA_TOKEN, &ckfalse, sizeof(ckfalse)); attrs++;
    if (vfy) {
       counter = vfy->counter;
       PK11_SETATTRS(attrs, CKA_NETSCAPE_PQG_COUNTER, 
                     &counter, sizeof(counter)); attrs++;
       PK11_SETATTRS(attrs, CKA_NETSCAPE_PQG_SEED, 
                     vfy->seed.data, vfy->seed.len); attrs++;
       PK11_SETATTRS(attrs, CKA_NETSCAPE_PQG_H, 
                     vfy->h.data, vfy->h.len); attrs++;
    }

    keyCount = attrs - keyTempl;
    PORT_Assert(keyCount <= sizeof(keyTempl)/sizeof(keyTempl[0]));


    slot = PK11_GetInternalSlot();
    if (slot == NULL) {
       return SECFailure;
    }

    PK11_EnterSlotMonitor(slot);
    crv = PK11_GETTAB(slot)->C_CreateObject(slot->session, keyTempl, keyCount, 
                                                        &objectID);
    PK11_ExitSlotMonitor(slot);

    /* throw away the keys, we only wanted the return code */
    PK11_DestroyObject(slot,objectID);
    PK11_FreeSlot(slot);

    *result = SECSuccess;
    if (crv == CKR_ATTRIBUTE_VALUE_INVALID) {
       *result = SECFailure;
    } else if (crv != CKR_OK) {
       PORT_SetError( PK11_MapError(crv) );
       rv = SECFailure;
    }
    return rv;

}