keyadd.c

vc环境下的pgp源码

                pgpAssertNoErr(err);

                if( isrev ) {
                    err = PGPGetSigUserVal( cert, &val );
                    if( val != (PGPUserValue) kMark_Revocation ) {
                        fprintf(  filebPtr->pgpout, LANG(
"New revocation from keyID %s on userid %s\n"), kstr, useridstr);
                        if(newRevokeCount)
                            (*newRevokeCount)++;
                    }
                } else {
                    err = PGPGetSigUserVal( cert, &val );
                    if( val != (PGPUserValue) kMark_Ordinary ) {
                        fprintf(  filebPtr->pgpout, LANG(
"New signature from keyID %s on userid %s\n"), kstr, useridstr);
                        if(newSigCount)
                            (*newSigCount)++;
                    }
                }
                err = PGPKeyIterNextUIDSig( iterContext, &cert );
                /*if err, there are no more.*/
            }
        }
next:
        err = PGPKeyIterNextUserID( iterContext, &alias);
    }
    if(err == kPGPError_EndOfIteration)
        err = kPGPError_NoErr;
    return err;
}

PGPError pgpShowKeyMarked( struct pgpfileBones *filebPtr, PGPKeyIterRef
        iterContext, PGPKeyRef key, PGPSize *newKeyCount, PGPSize
        *newUIDCount, PGPSize *newSigCount, PGPSize *newRevokeCount )
{
    PGPError err;
    PGPUserIDRef alias;
    struct pgpenvBones *envbPtr = filebPtr->envbPtr;
    PGPEnv *env = envbPtr->m_env;
    PGPInt32 pri;
    PGPBoolean batchmode = pgpenvGetInt( env, PGPENV_BATCHMODE, &pri, &err );
    PGPBoolean verbose = pgpenvGetInt( env, PGPENV_VERBOSE, &pri, &err );
    PGPUserValue val;
    PGPBoolean iskrev,issec;
    PGPBoolean compatible = envbPtr->compatible;
    PGPInt32 interactive = envbPtr->interactiveAdd;

    if(newKeyCount)
        *newKeyCount = 0;
    if(newUIDCount)
        *newUIDCount = 0;
    if(newSigCount)
        *newSigCount = 0;
    if(newRevokeCount)
        *newRevokeCount = 0;

    err = PGPGetKeyBoolean( key, kPGPKeyPropIsRevoked, &iskrev );
    pgpAssertNoErr(err);

    err = PGPGetKeyBoolean( key, kPGPKeyPropIsSecret, &issec );
    pgpAssertNoErr(err);

    err = PGPGetKeyUserVal( key, &val );
    if( iskrev ) {
        if( ( (PGPInt32)val & kMark_Revocation ) ) {
            if(verbose)
                fprintf( filebPtr->pgpout, LANG("\nNew revocation\n") );
            if(newRevokeCount)
                (*newRevokeCount)++;
        }
    } else {
        if( ( (PGPInt32)val & kMark_Ordinary ) ) {
            if(verbose)
                fprintf( filebPtr->pgpout, LANG("\nnew key\n") );

            /* new key. return early.*/
            if(newKeyCount)
                (*newKeyCount)++;
            /*return kPGPError_NoErr;*/
        }
    }

    if( issec ) {
        if( ( (PGPInt32)val & kMark_Secret ) ) {
            if(verbose)
                fprintf( filebPtr->pgpout, LANG("\nNew secret key\n") );
            if(newKeyCount)
                (*newKeyCount)++;
        }
    }

    err = PGPKeyIterRewindUserID( iterContext );
    pgpAssertNoErr(err);

    err = PGPKeyIterNextUserID( iterContext, &alias);

    while( alias ) {
        PGPSize actual;
        char useridstr[ kPGPMaxUserIDSize ];

        err = PGPGetUserIDStringBuffer( alias, kPGPUserIDPropName,
                kPGPMaxUserIDSize, useridstr, &actual );

        pgpAssertNoErr(err);

        err = PGPGetUserIDUserVal( alias, &val);
        pgpAssertNoErr(err);
        if( val != (PGPUserValue) kMark_Ordinary ) {
            PGPBoolean ans;

            if( interactive ) {
                fprintf( filebPtr->pgpout, LANG("\nNew userid: \"%s\".\n"),
                        useridstr);
                fprintf( filebPtr->pgpout,
                        LANG("\nWill be added to the following key:\n"));
                pgpShowKeyBrief( filebPtr, key );
                fprintf( filebPtr->pgpout, LANG("Add this userid (y/N)? "));
                fflush( filebPtr->pgpout );
                ans = getyesno( filebPtr, 'n', batchmode );
            }
            if( interactive && !ans ) {
                err = PGPRemoveUserID( alias );
                pgpAssertNoErr(err);
            } else
                if(newUIDCount)
                    (*newUIDCount)++;
        } else {
            PGPSigRef cert;

            err = PGPKeyIterRewindUIDSig( iterContext );
            pgpAssertNoErr(err);
            err = PGPKeyIterNextUIDSig( iterContext, &cert );
            /*if err, there are none.*/
            while( cert ) {
                PGPKeyID kid;
                char kstr[kPGPMaxKeyIDStringSize];
                PGPBoolean isrev;

                err = PGPGetKeyIDOfCertifier( cert, &kid );
                pgpAssertNoErr(err);
                err = pgpGetKeyIDStringCompat( &kid, TRUE, compatible,
                        kstr );
                pgpAssertNoErr(err);

                err = PGPGetSigBoolean( cert, kPGPSigPropIsRevoked, &isrev );
                pgpAssertNoErr(err);

                if( isrev ) {
                    err = PGPGetSigUserVal( cert, &val );
                    if( val == (PGPUserValue) kMark_Revocation ) {
                        fprintf(  filebPtr->pgpout, LANG(
"New revocation from keyID %s on userid %s\n"), kstr, useridstr);
                        if(newRevokeCount)
                            (*newRevokeCount)++;
                    }
                } else {
                    err = PGPGetSigUserVal( cert, &val );
                    if( val == (PGPUserValue) kMark_Ordinary ) {
                        fprintf(  filebPtr->pgpout, LANG(
"New signature from keyID %s on userid %s\n"), kstr, useridstr);
                        if(newSigCount)
                            (*newSigCount)++;
                    }
                }
                err = PGPKeyIterNextUIDSig( iterContext, &cert );
                /*if err, there are no more.*/
            }
        }
        err = PGPKeyIterNextUserID( iterContext, &alias);
    }
    if(err == kPGPError_EndOfIteration)
        err = kPGPError_NoErr;
    return err;
}

PGPError pgpShowKeySetUnmarked( struct pgpfileBones *filebPtr,
        PGPKeySetRef keySet, PGPSize *newKeyCount, PGPSize *newUIDCount,
        PGPSize *newSigCount, PGPSize *newRevokeCount )
{
    PGPError err,er2;
    PGPKeyRef key;
    PGPKeyListRef keylist;
    PGPKeyIterRef iter;
    *newKeyCount = 0;
    *newUIDCount = 0;
    *newSigCount = 0;
    *newRevokeCount = 0;

    err = PGPOrderKeySet( keySet, kPGPAnyOrdering, &keylist );
    pgpAssertNoErr(err);
    err = PGPNewKeyIter( keylist, &iter );
    pgpAssertNoErr(err);
    err = PGPKeyIterRewind( iter );
    pgpAssertNoErr(err);

    PGPKeyIterNext( iter, &key);
    /*if err, there are none.*/
    while( key )
    {
        PGPSize keyc, uidc, sigc, rvkc;
        err = pgpShowKeyUnmarked( filebPtr, iter, key, &keyc, &uidc,
                &sigc, &rvkc );
        (*newKeyCount) += uidc;
        (*newUIDCount) += uidc;
        (*newSigCount) += sigc;
        (*newRevokeCount) += rvkc;
        if(err)
            break;
        PGPKeyIterNext( iter, &key);
        /*if err, there are no more.*/
    }

    er2 = PGPFreeKeyIter( iter );
    pgpAssertNoErr(err);
    er2 = PGPFreeKeyList( keylist );
    pgpAssertNoErr(err);

    return err;
}

PGPError pgpShowKeySetMarked( struct pgpfileBones *filebPtr, PGPKeySetRef
        keySet, PGPSize *newKeyCount, PGPSize *newUIDCount, PGPSize
        *newSigCount, PGPSize *newRevokeCount )
{
    PGPError err;
    PGPKeyRef key;
    PGPKeyListRef keylist = NULL;
    PGPKeyIterRef keyiter = NULL;
    *newKeyCount = 0;
    *newUIDCount = 0;
    *newSigCount = 0;
    *newRevokeCount = 0;

    err = PGPOrderKeySet( keySet, kPGPAnyOrdering, &keylist );
    pgpAssertNoErr(err);
    err = PGPNewKeyIter( keylist, &keyiter );
    pgpAssertNoErr(err);
    err = PGPKeyIterRewind( keyiter );
    pgpAssertNoErr(err);

    PGPKeyIterNext( keyiter, &key);
    /*if err, there are none.*/
    while( key )
    {
        PGPSize keyc, uidc, sigc, rvkc;
        err = pgpShowKeyMarked( filebPtr, keyiter, key, &keyc, &uidc,
                &sigc, &rvkc );
        (*newKeyCount) += uidc;
        (*newUIDCount) += uidc;
        (*newSigCount) += sigc;
        (*newRevokeCount) += rvkc;
        if(err)
            break;
        PGPKeyIterNext( keyiter, &key);
        /*if err, there are no more.*/
    }

    if( keyiter )
        PGPFreeKeyIter( keyiter );
    if( keylist )
        PGPFreeKeyList( keylist );
    pgpAssertNoErr(err);

    return err;
}

/*
   Examines the keys in keyset and updates the corresponding certs in
   ringSet that are uncertified.
   It is not assumed that parameter keyset comes from the same key
   database as ringSet.
 */

PGPError pgpProcessUncertifiedKeys( struct pgpmainBones *mainbPtr,
        PGPKeySetRef keyset )
{
    struct pgpfileBones *filebPtr = mainbPtr->filebPtr;
    PGPKeyRef key,origkey;
    PGPKeyID keyid;
    PGPKeyIterRef keyiter = NULL;
    PGPKeyListRef keylist = NULL;
    PGPError err;
    PGPBoolean ask_first_latch = TRUE;

    pgpAssertAddrValid( mainbPtr, struct pgpmainBones );
    pgpAssertAddrValid( mainbPtr->workingRingSet, PGPKeySetRef );

    err = PGPOrderKeySet( keyset, kPGPAnyOrdering, &keylist);
    pgpAssertNoErr(err);
    err = PGPNewKeyIter( keylist, &keyiter );
    pgpAssertNoErr(err);

    /* Sign unverifiable keys by hand */
    err = PGPKeyIterRewind( keyiter );
    pgpAssertNoErr(err);
    err = PGPKeyIterNext( keyiter, &key);
    pgpAssertNoErr(err);
    while( key ) {
        PGPBoolean issec;

        PGPGetKeyBoolean( key, kPGPKeyPropIsSecret, &issec );
        if(issec)
            goto next;

        err = PGPGetKeyIDFromKey( key, &keyid );
        if( IsPGPError(err) )  {
            pgpShowError( filebPtr, err,__FILE__,__LINE__ );
            goto next;
        }
        err = PGPGetKeyByKeyID( mainbPtr->workingRingSet, &keyid,
                kPGPPublicKeyAlgorithm_Invalid, &origkey );
        if( IsPGPError(err) ) {
            if( err != kPGPError_ItemNotFound )
                pgpShowError( filebPtr, err,__FILE__,__LINE__ );
            goto next;
        }
        /*mainbPtr->workingRingSet=ringSet;*/
        /*mainbPtr->workingGroupSet=NULL;*/
        err=askToSign( mainbPtr, origkey, ask_first_latch );
        switch(err) {
            case kPGPError_NoErr:
                break;
            case kPGPError_UserAbort:
                /*err = kPGPError_NoErr;*/
                goto done;
            case kPGPError_ItemAlreadyExists:
                goto next;
            default:
                pgpShowError( filebPtr, err,__FILE__,__LINE__ );
                goto done;
        }
        ask_first_latch = FALSE; /* should stay false now */
next:
        err = PGPKeyIterNext( keyiter, &key );
        /*if err, there are no more*/
    }
    if( err == kPGPError_EndOfIteration )
        err = kPGPError_NoErr;
done:
    if( keyiter )
        PGPFreeKeyIter( keyiter );
    if( keylist )
        PGPFreeKeyList( keylist );
    return err;
}

/*
   Examines the keys in keyset and updates the trust of corresponding
   keys in ringSet.

   It is not assumed that parameter keyset comes from the same key
   database as ringSet.
 */
PGPError pgpProcessUntrustedKeys( struct pgpmainBones *mainbPtr,
        PGPKeySetRef keyset, PGPKeySetRef ringSet )
{
    struct pgpfileBones *filebPtr = mainbPtr->filebPtr;
    PGPKeyRef key,origkey;
    PGPKeyID keyid;
    PGPKeyIterRef keyiter = NULL;
    PGPKeyListRef keylist = NULL;
    PGPError err;

    err = PGPOrderKeySet( keyset, kPGPAnyOrdering, &keylist);
    pgpAssertNoErr(err);
    err = PGPNewKeyIter( keylist, &keyiter );
    pgpAssertNoErr(err);

    for(;;) {
        PGPBoolean endloop;

        /* loop while there are any (at least marginally valid) keys
           whose trust has not been set. */

        /* while keys still with undefined trust, allow wetware editing
           of trust parameter (avoid iterating main ringSet due to ldap
           servers and potential size of set) */

        endloop = TRUE;
        err = PGPKeyIterRewind( keyiter );
        pgpAssertNoErr(err);
        err = PGPKeyIterNext( keyiter, &key);
        while( key ) {
            PGPInt32 validity;
            PGPUserValue val;

            err = PGPGetKeyIDFromKey( key, &keyid );
            if( err )  {
                pgpShowError( filebPtr, err,__FILE__,__LINE__ );
                goto next;
            }

            err = PGPGetKeyByKeyID( ringSet, &keyid,
                    kPGPPublicKeyAlgorithm_Invalid, &origkey );

            if( err ) {
                pgpShowError( filebPtr, err,__FILE__,__LINE__ );
                goto next;
            }

            err = PGPGetKeyNumber( key, kPGPKeyPropValidity, &validity);
            pgpAssertNoErr(err);