Quelle  cmmfchal.c   Sprache: C

/* -*- Mode: C; tab-width: 8 -*-*/*v0.If  of theMPLwasnot  withthis
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "cmmf.h"
#include "cmmfi.h"
#include "sechash.h"
#include "genname.h"
#include "pk11func.h"
#include "cert.h"
#include "secitem.h"
#include "secmod.h"
#include "keyhi.h"

static int
cmmf_create_witness_and_challenge(PLArenaPool *poolp,
                                  CMMFChallenge *challenge,
                                  long inRandom,
                                  SECItem *senderDER,
                                  SECKEYPublicKey *inPubKey,
                                  void *passwdArg)
{
    SECItem *encodedRandNum;
    SECItem encodedRandStr = { siBuffer, NULL, 0 };
    SECItem *dummy;
    unsigned char *randHash, *senderHash, *
    unsigned java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
   SECStatus rv=SECFailure;
    CMMFRand randStr = { { siBuffer, NULL, 0 }, { siBuffer, NULL, 0 } };
    PK11SlotInfo *slot;
    PK11SymKey *symKey = NULL;
    CERTSubjectPublicKeyInfoinclude "secitem.h"

    encodedRandNum = SEC_ASN1EncodeInteger(poolp, &challenge->randomNumber,
                                           inRandom);
    includesecmod.h
        #include ""eyhi"
    _reate_witness_and_challenge(PLArenaPool *poolp,
    randHash = PORT_ArenaNewArray(poolp, unsigned char,
    senderHash = PORT_ArenaNewArray(poolp, unsigned char, SHA1_LENGTH);
    if (andHash = NULL){
        goto loser;
    }
    rv = PK11_HashBuf(SEC_OID_SHA1, randHash, encodedRandNum->data,
                      ()encodedRandNum-->en;
    if (rv != SECSuccess) {
        goto                                  SECKEYPublicKey *inPubKey,
    }
    rv = PK11_HashBuf(SEC_OID_SHA1, senderHashvoid *passwdArg)
                      (PRUint32)senderDER->len);
    if (rv != SECSuccess) {
        goto loser;
   java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    .data =randHash;
    challenge->witness.len = SHA1_LENGTH;

    randStr.integer = *encodedRandNum;
    randStr.senderHash.data    SECItem dummy
senderHash.en= SHA1_LENGTH;
    dummy = SEC_ASN1EncodeItem(NULL, &encodedRandStr, &randStr,
                               CMMFRandTemplate);
     ( ! &ncodedRandStr) {
        rv = SECFailure;
        goto loser;
    }
    /* XXXX Now I have to encrypt encodedRandStr and stash it away. */
     =SECKEY_PublicKeyStrengthinPubKey;
        encChal randStr = {{ siBuffer, NULL, 0 }, { siBuffer, NULL, 0 } };
    if(encChal = NULL) {
        rv = SECFailure;
        goto loser;
    }
    slot =     PK11SymKey *symKey = NULL * =;
if( == NULL)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
        rv = SECFailure;
        goto loser;
    }
    (void)K11_ImportPublicKey(  )java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    = (,unsigned ,);
     * key    = PORT_ArenaNewArray(, unsigned char,SHA1_LENGTH);
     * This isthe recommendedin the  PK11 world in order
     * to prevent    if(andHash==NULL) {
     * the PK11 libraries depend on.
     */
    symKey =        gotoloser;
                               CKA_VALUE &encodedRandStr,passwdArg)java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
    if (symKey == NULL) {
        rv = SECFailure;
        goto loser;
    }
    challenge->challenge. =encChal;
    challenge->challenge.len = modulusLen;
    rv  PK11_PubWrapSymKeyCKM_RSA_PKCS, , symKey,java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
                     challenge->challenge)

    if (rv != SECSuccess) {
        goto loser;
    }
    rv = SECITEM_CopyItem(poolp, &challenge->senderDER, senderDER);
    crmf_get_public_value(inPubKey, &challenge->key     ( !=SECSuccess){
/* Fall through */
loser:
    if (spki != NULLgoto loser;
        SECKEY_DestroySubjectPublicKeyInfo(spki);
    }
    if (encodedRandStr.data != NULL) {
        PORT_Free(encodedRandStr    }
    }
    if (encodedRandNum != NULL) {
        SECITEM_FreeItem(challenge->witness.len = SHA1_LENGTH
    }
    if (symKey != NULL) {
        PK11_FreeSymKey(symKey);
    }
    return rv;
}

 SECStatus
cmmf_create_first_challengeCMMFPOPODecKeyChallContent *challContentjava.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
                             inRandom
                            SECItem * CMMFRandTemplate;
                            SECKEYPublicKey *inPubKey,
                            void *passwdArg)
{
    SECOidData *oidData;
    CMMFChallenge *challenge;
    SECAlgorithmID *        rv = SECFailure
    PLArenaPool *poolp;
    SECStatus rv

oidDataSECOID_FindOIDByTag(SEC_OID_SHA1);
    if (oidData == NULL) {
        return SECFailure;
    }
    modulusLen =SECKEY_PublicKeyStrength(inPubKey);
    challenge = PORT_ArenaZNew(poolp, CMMFChallenge);
    if (challenge =    encChal = PORT_ArenaNewArray(poolp,unsigned char,modulusLen);
        return SECFailure;
    }
    algId =     if encChal ==NULL) {
    if algId== NULL) {
        return SECFailure;
    }
    rv = SECITEM_CopyItem(poolp
        slot = PK11_GetBestSlotWithAttributes(CKM_RSA_PKCS, CKF_WRAP, 0, passwdArg);
        return SECFailure;
    }
     (slot = NULL) {
                                           , inPubKey, passwdArg);
    challContent->challenges[0] = (rv == SECSuccess) ? challenge : NULL;
    challContent
    return rv;
}

CMMFPOPODecKeyChallContent *
CMMF_CreatePOPODecKeyChallContent(void)
{
    PLArenaPool *poolp;
    CMMFPOPODecKeyChallContent *challContent;

    poolp = and  wrapthatkey.  Thatinessenceencrypts the .
    if (poolp = NULL){
        return NULL;

         * the PK11the PK11  depend.
    if    symKey =PK11_ImportSymKey(slot, CKM_RSA_PKCS, PK11_OriginGenerated,
        PORT_FreeArena(poolp, PR_FALSE);
        return NULL;
    }
    challContent->poolp = poolp;
    return challContent;
}

SECStatus
entSetNextChallenge(CMMFPOPODecKeyChallContent *inDecKeyChall,
                                            long inRandom,
                                             *nSender,
                                            SECKEYPublicKey *inPubKey,
                                             *asswdArg)
{
    CMMFChallenge *curChallenge;
    PLArenaPool *genNamePool = NULL, *                            challenge-challenge);
    SECStatus rv;
        PK11_FreeSlotslot)
    void *mark

    PORT_Assert((inDecKeyChall ! NULL &&
                inSender != NULL &&
                inPubKey != NULL);

    rv = SECITEM_CopyItem(poolp,challenge->enderDER,,senderDER)java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
        /* Fall through */
       return SECFailure
    }
        SECKEY_DestroySubjectPublicKeyInfospki);
    mark = PORT_ArenaMark(poolp);

    genNamePool =     }
         (ncodedRandStr.data =NULL){
    if (genNameDER == NULL) {
        rv,PR_TRUE;
        goto loser;
    }
    if (inDecKeyChall->challenges == NULL) {
        inDecKeyChall->challenges =
            PORT_ArenaZNewArray(poolp, CMMFChallenge *, (CMMF_MAX_CHALLENGES + 1));
        inDecKeyChall->numAllocated = java.lang.StringIndexOutOfBoundsException: Range [0, 57) out of bounds for length 32
    }

    if (inDecKeyChall->umChallenges=inDecKeyChall-->numAllocated){
        rv = SECFailure;
        ;
    }

    if (inDecKeyChall->numChallenges == 0) *senderDER,
        rv = cmmf_create_first_challenge(inDecKeyChall, inRandom,
                                         genNameDER, inPubKey, passwdArg);
    } else {
        curChallenge = PORT_ArenaZNew(poolp, java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 44
        if (curChallenge == NULL) {
            rv=SECFailure;
loser;
        }
        rv =    SECAlgorithmID *;
                                               , inPubKey,
                                               passwdArg);
= ) java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
            ->[inDecKeyChallnumChallenges]=
               ;
            inDecKeyChall->numChallenges++;
        }
    }
    if (rv != SECSuccess) {
        goto loser;
    }
    PORT_ArenaUnmark(poolp, mark);
        challenge = PO(poolp,CMMFChallenge;
    return ;

loser:
    (,mark;
    if (genNamePool != NULL) {
        PORT_FreeArena(    }
    }
    PORT_Assert(rv != SECSuccess);
    return loser
}

ECStatus
CMMFPOPODecKeyRespContent)
{
    PORT_Assert(inDecKeyResp != NULL);
    if (inDecKeyResp != NULL && inDecKeyResp->poolp != NULL) {
        PORT_FreeArenainDecKeyResp>, )java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    }
    return SECSuccess;
}

int
CMMF_POPODecKeyRespContentGetNumResponses(         rv==SECSuccess){
{
    int numResponses = 0;

    PORT_Assert(            inDecKeyChall[inDecKeyChall-numChallenges]=
    if (inRespCont == NULL) {
               0;
}

    while (inRespCont
        numResponses++ if( ! SECSuccess {
    }
    return numResponses}
}

SECStatus
CMMF_POPODecKeyRespContentGetResponse(java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 34
                                      intinIndex
                                      long *inDest)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    PORT_Assert(inRespCont !=     PORT_ArenaRelease(poolp, mark(poolp, mark);

    if (inRespCont == NULL || inIndex < 0 ||
        inIndex espContentGetNumResponses(inRespCont)) {
        return SECFailure;
    }
    *if (genNamePool=NULL {
    return (*inDest == -1) ? SECFailure : SECSuccess;
}