keyedit.c

vc环境下的pgp源码

    PGPContextRef context = mainbPtr->pgpContext;
    struct pgpfileBones *filebPtr = mainbPtr->filebPtr;
    PGPError err,er2;

    *isprivate = FALSE;

    if( fileSpec ) {
        char pubringfile[ MAX_PATH+1 ];
		char *ringfile;

        err = PGPGetFullPathFromFileSpec( fileSpec, &ringfile );
        pgpAssertNoErr(err);

        if( hasExtension(ringfile, filebPtr->SKR_EXTENSION) )
        {
            PGPFileSpecRef pubFileSpec;

            *isprivate = TRUE;
            err = pgpGetCorrespondingPublicRingName( filebPtr, ringfile,
                    pubringfile );

            pgpAssertNoErr(err);
            err = PGPNewFileSpecFromFullPath(context, pubringfile,
                    &pubFileSpec);

            pgpAssertNoErr(err);
            err = PGPOpenKeyRingPair( context,
		    openFlags, pubFileSpec, fileSpec,
                    keyRingSet );

            er2 = PGPFreeFileSpec( pubFileSpec );
            pgpAssertNoErr(er2);
        } else
            *isprivate = FALSE;
	    err = PGPOpenKeyRing( context, openFlags,	
                    fileSpec, keyRingSet );

        if( IsPGPError(err) )
		{
            fprintf(filebPtr->pgpout,
                    LANG("Can't open key ring file '%s'\n"),
                    ringfile);
		}
        er2 = PGPFreeData( ringfile );
        pgpAssertNoErr(er2);

    } else {
        fprintf(filebPtr->pgpout, LANG("in default key ring\n\n"));

        err = PGPOpenDefaultKeyRings( context,
		openFlags, keyRingSet);

        if( IsPGPError(err) ) {
            fprintf(filebPtr->pgpout, LANG("Can't open default key rings\n"));
        }
    }
    return err;
}

/*
   Edit the userid and/or pass phrase for a key pair, and put them back
   into the ring files.
 */

int doKeyEdit(struct pgpmainBones *mainbPtr, const char *searchstr,
        PGPFileSpecRef pubFileSpec)
{
    PGPContextRef context = mainbPtr->pgpContext;
    struct pgpfileBones *filebPtr = mainbPtr->filebPtr;
    struct pgpenvBones *envbPtr = filebPtr->envbPtr;
    PGPEnv *env = envbPtr->m_env;
    PGPKeySetRef keyRingSet = NULL;
    PGPKeyListRef keylist = NULL;
    PGPKeyIterRef keyiter = NULL;
    PGPKeyRef key = NULL;
    PGPError err,er2;
    PGPInt32 pri;

    if( !searchstr || searchstr[0]=='\0' )
        return -1;

    fprintf(filebPtr->pgpout, LANG("\nEditing userid \"%s\" "),searchstr);
    if(pubFileSpec) {
        char *pubringfile;
        err = PGPGetFullPathFromFileSpec( pubFileSpec, &pubringfile );
        pgpAssertNoErr(err);
        fprintf(filebPtr->pgpout, LANG("in key ring: '%s'.\n\n"),pubringfile);
        er2 = PGPFreeData( pubringfile );
    }

    err = pgpOpenKeyringsFromPubringSpec( mainbPtr, pubFileSpec,
	    &keyRingSet, kPGPKeyRingOpenFlags_Mutable);
    if( IsPGPError(err) )
        return -1;

    mainbPtr->workingRingSet=keyRingSet;
    /*mainbPtr->workingGroupSet=NULL;*/
    err = pgpGetMatchingKeyList( mainbPtr, searchstr, kMatch_NotKeyServer,
            &keylist);
    pgpAssertNoErr(err);

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

    err = PGPKeyIterNext( keyiter, &key);
        /* pgp 2.6.2 does the edit on the first matching public key in the set
           but we believe that any user in the set should be edited. */

    if (key == NULL) {

        if(pubFileSpec) {
            char *pubringfile;
            err = PGPGetFullPathFromFileSpec( pubFileSpec, &pubringfile );
            pgpAssertNoErr(err);
            fprintf(filebPtr->pgpout,
                    LANG("\n\007Key not found in key ring '%s'.\n"),
                pubringfile);
            er2 = PGPFreeData( pubringfile );
        }

        if( keyiter != NULL)
            PGPFreeKeyIter( keyiter );
        if( keylist != NULL)
            PGPFreeKeyList( keylist );

        PGPFreeKeySet( keyRingSet );
        mainbPtr->workingRingSet = NULL;

        return -1;
    }

    while( key != NULL )
    {
        PGPBoolean ans,mine;
        PGPBoolean batchmode = pgpenvGetInt( env, PGPENV_BATCHMODE,
                &pri, &err );
        PGPBoolean issecret;
        char *passphrase;
        PGPUserIDRef userid;
        char useridstr[ kPGPMaxUserIDSize ];
        PGPInt32 actual;

        err = PGPGetPrimaryUserID( key, &userid);
        pgpAssertNoErr(err);
        err =  PGPGetUserIDStringBuffer( userid, kPGPUserIDPropName,
                256, useridstr, &actual );

        pgpAssertNoErr(err);

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

        err = pgpShowKeyBrief(filebPtr, key);
        pgpAssertNoErr(err);

        if( issecret ) {

            err = pgpGetValidPassphrase( mainbPtr, key, &passphrase, &mine );

            if( IsntPGPError(err) ) {
				fprintf(filebPtr->pgpout,
LANG("Use this key as an ultimately-trusted introducer (y/N)? "));

				ans = getyesno( filebPtr, 'n', batchmode );

				if(ans) {
					err = PGPSetKeyAxiomatic( key,
							PGPOPassphrase( context, passphrase ),
							PGPOLastOption( context ));
					pgpAssertNoErr(err);

					fprintf(filebPtr->pgpout,
LANG("Make this the default signing key (y/N)? "));
					ans = getyesno( filebPtr, 'n', batchmode );
					if(ans) {
						err = PGPSetDefaultPrivateKey(key);
						pgpAssertNoErr(err);
						err = PGPsdkSavePrefs( context );
						pgpAssertNoErr(err);
					}

				}
				else
				{	/* remove implicit trust */
					err = PGPUnsetKeyAxiomatic(key);
				}

                fprintf(filebPtr->pgpout, LANG("Current user ID: %s\n"),
                        useridstr );

                fprintf(filebPtr->pgpout, LANG(
                        "Do you want to add a new user ID (y/N)? "));
                ans = getyesno( filebPtr, 'n', batchmode );

                if(ans) {
                    PGPUserIDRef newuserid;
                    char newstr[ kPGPMaxUserIDSize ];
                    fprintf(filebPtr->pgpout,
                            LANG("Enter the new user ID: "));
                    fflush( filebPtr->pgpout );
                    pgpTtyGetString(newstr, kPGPMaxUserIDSize-1,
                            filebPtr->pgpout);

                    if( strlen( newstr ) == 0 ) {
                        PGPFreeData( passphrase );
                        pgpRemoveFromPointerList( mainbPtr->leaks,
                                passphrase );
                        return -1;
                    }

                    err = PGPAddUserID( key, newstr,
                            PGPOPassphrase( context, passphrase ),
                            PGPOLastOption( context ));
                    pgpAssertNoErr(err);

                    err = pgpGetKeyIterMatchingUserid( keyiter, newstr,
                            &newuserid );
                    pgpAssertNoErr(err);

                    /* if we gave a valid passphrase, then sdk should
                       already have signed the new userid.*/

                    fprintf(filebPtr->pgpout,
LANG("Make this user ID the primary user ID for this key (y/N)? "));
                    ans = getyesno( filebPtr, 'n', batchmode );

                    if( ans ) {
                        err = PGPSetPrimaryUserID( newuserid );
                        pgpAssertNoErr(err);
                    }
                }

                fprintf(filebPtr->pgpout,
                    LANG("Do you want to change your pass phrase (y/N)? "));
                ans = getyesno( filebPtr, 'n', batchmode );

                if(ans) {
                    char *newpassphrase;
                    PGPBoolean alsomine = FALSE;
                    err = pgpNextPassphrase( envbPtr->passwds,
                            &newpassphrase );

                    if( newpassphrase == NULL ) {
                        err = pgpPassphraseDialogCmdline( mainbPtr,
                                TRUE, NULL, &newpassphrase);

                        alsomine = TRUE;
                    }

                    err = PGPChangePassphrase( key,
                            PGPOPassphrase( context, passphrase ), /* old*/
                            PGPOPassphrase( context, newpassphrase ), /* new*/
                            PGPOLastOption( context ));
                    pgpAssertNoErr(err);

                    {
                        PGPSubKeyRef subKey;
                        //PGPKeyIterSeek(keyiter, key);
                        err = PGPKeyIterNextSubKey(keyiter, &subKey);

                        while( IsntPGPError( err ) ) {

                            if(!envbPtr->compatible) {
                                /* FUTURE functionality: show the user
                                   the subkey and ask whether to change
                                   the passphrase for this one.  This is
                                   to permit the signing and encryption
                                   passphrases to be different.

                                   To implement this functionality,
                                   want to do two things.  (1) create a
                                   function analogous to pgpShowKeyBrief()
                                   that will show the subKey.  Note,
                                   however, to hide the subkey id from
                                   the user.  (2) in key generation,
                                   also ask whether to have different
                                   passphrases.
                                 */
                                pgpFixBeforeShip("ask the user");
                                if(FALSE)
                                    goto next;
                            }
                            err = PGPChangeSubKeyPassphrase( subKey,
                               PGPOPassphrase( context, passphrase ),
                               PGPOPassphrase( context, newpassphrase ),
                               PGPOLastOption( context ));
                            pgpAssertNoErr(err);

                        next:
                            err = PGPKeyIterNextSubKey(keyiter, &subKey);
                        }
                    }

                    if(alsomine) {
                        PGPFreeData( newpassphrase );
                        pgpRemoveFromPointerList( mainbPtr->leaks,
                                newpassphrase );

                    }
                }

            } else {
                fprintf( filebPtr->pgpout,
                        LANG("No passphrase; secret key unavailable.\n"));

                issecret = FALSE;
            }
            if(mine) {
                PGPFreeData( passphrase );
                pgpRemoveFromPointerList( mainbPtr->leaks, passphrase );
            }
        }

        if( !issecret ) {
            fprintf(filebPtr->pgpout, LANG(
"No secret key available.  Editing public key trust parameter.\n"));
            err = pgpEditPublicTrustParameter( filebPtr, useridstr, key);
        }

        err = PGPKeyIterNext( keyiter, &key);
#ifndef SUPPORT_MULTIEDIT
        break;
#endif /* SUPPORT_MULTIEDIT */
    }
    if(err == kPGPError_EndOfIteration)
        err = kPGPError_NoErr;

    if( keyiter != NULL)
        PGPFreeKeyIter( keyiter );
    if( keylist != NULL)
        PGPFreeKeyList( keylist );

    if( PGPKeySetNeedsCommit( keyRingSet ) ) {
        PGPPropagateTrust( keyRingSet );
        err = PGPCommitKeyRingChanges( keyRingSet );
        pgpAssertNoErr(err);
    }
    PGPFreeKeySet( keyRingSet );
    mainbPtr->workingRingSet = NULL;

    return err;
}