keyremove.c

vc环境下的pgp源码

/*____________________________________________________________________________
    keyremove.c

    Copyright(C) 1998,1999 Network Associates, Inc.
    All rights reserved.

    PGP 6.5 Command Line 

    use the PGP SDK to remove keys, signatures, and revoke keys and sigs.

    $Id: keyremove.c,v 1.13 1999/05/12 21:01:04 sluu Exp $
____________________________________________________________________________*/

#include <stdio.h>
#include <string.h>



#include "pgpBase.h"
#include "pgpKeys.h"
#include "pgpKeyServer.h"

#include "pgpErrors.h"
#include "pgpUtilities.h"
#include "pgpContext.h"

#include "usuals.h"
#include "pgp.h"
#include "globals.h"
#include "language.h"
#include "prototypes.h"
#include "pgpSDKPrefs.h"

#include "fileio.h"


/*
  remove keys from the key database associated with the keyset,
  but do it under user control.
 */
PGPError pgpUserChooseAndRemoveKeys( struct pgpmainBones *mainbPtr,
        PGPKeySetRef keySet)
{
    struct pgpfileBones *filebPtr = mainbPtr->filebPtr;
    struct pgpenvBones *envbPtr = mainbPtr->envbPtr;    
    PGPEnv *env = envbPtr->m_env;
    PGPContextRef context = mainbPtr->pgpContext;
    PGPError err,er2;
    PGPInt32 pri;
    PGPKeyListRef keylist = NULL;
    PGPKeyIterRef keyiter = NULL;
    PGPKeyRef key, defaultSigningKey = NULL;
    PGPBoolean batchmode = pgpenvGetInt( env, PGPENV_BATCHMODE, &pri, &err );
    PGPBoolean compatible = envbPtr->compatible;
    PGPSize removed;
    PGPByte *keyIDData = NULL;
    PGPSize  keyIDSize = 0;
    PGPKeyID keyID;
	PGPBoolean bIsPrivateKey = FALSE;
    pgpAssertNoErr(err);



    /* sort the result set..*/
    err = PGPOrderKeySet( keySet, kPGPAnyOrdering, &keylist );
    pgpAssertNoErr(err);

    err = PGPNewKeyIter( keylist, &keyiter );
    if(err) {
        pgpShowError(filebPtr, err, __FILE__, __LINE__);
        goto out;
    }

    err = PGPKeyIterRewind( keyiter );
    pgpAssertNoErr(err);

    err = PGPKeyIterNext( keyiter, &key);
    /*if error, no keys found.*/

    /* In incompatible mode, get default signing key from prefs. */
    if (!compatible) {
        err = PGPsdkPrefGetData( context, kPGPsdkPref_DefaultKeyID,
          (void **)&keyIDData, &keyIDSize );

        if (err==kPGPError_NoErr) {
            err = PGPImportKeyID( keyIDData, &keyID );
            pgpAssertNoErr(err);
            PGPFreeData( keyIDData );

            err = PGPGetKeyByKeyID(keySet, &keyID,
              kPGPPublicKeyAlgorithm_Invalid, &defaultSigningKey);
            pgpAssertNoErr(err);
        }
    }

    removed=0;
    while( key != NULL )
    {
        PGPUInt32 numuserids;
        PGPBoolean ans;

		if(mainbPtr->workingKeyServer)
		{	/* check to see if key returned by server in key set */
			if(!PGPKeySetIsMember(key, mainbPtr->workingRingSet))
			{
				err = PGPKeyIterNext(keyiter, &key);
                if(IsPGPError(err))
                    break;
				continue;
			}
		}
		else
		{
			/* check to see if key is private/public pair */
			PGPGetKeyBoolean(key, kPGPKeyPropIsSecret, &bIsPrivateKey);
			err = pgpCountKeyUserIDs( keyiter, &numuserids );
			pgpAssertNoErr(err);

		}
        err = pgpShowKeyBrief( filebPtr, key );

        if (!compatible) {
            if (defaultSigningKey != NULL && !mainbPtr->workingKeyServer) {
                if (PGPCompareKeys(key, defaultSigningKey,
                   kPGPUserIDOrdering) == 0) {
                   fprintf(filebPtr->pgpout,
LANG("\nWARNING: You are about to remove your default signing key!\n"));
                }
            }
        }

        ans=FALSE;
        if( numuserids > 1 && !mainbPtr->workingKeyServer) {
            fprintf( filebPtr->pgpout,
                    LANG("\nKey has more than one user ID.\n"));
					fprintf( filebPtr->pgpout,
                    LANG("Do you want to remove the whole key (y/N)? "));
            ans = getyesno( filebPtr, 'n', batchmode );
        }
        else 
        {
            /* if user has only one userid,*/
            fprintf( filebPtr->pgpout,
                LANG("\nAre you sure you want this key removed (y/N)? "));
            ans = getyesno( filebPtr, 'n', batchmode );
        }

        if( ans ) {
            PGPKeySetRef    single;

            err = PGPNewSingletonKeySet( key, &single );
            pgpAssertNoErr(err);

            if( mainbPtr->workingKeyServer ) {
                PGPKeySetRef    failed = NULL;
                PGPKeyID        keyid;
                
                /* save keyid of key that user wants to delete */
                err = PGPGetKeyIDFromKey(key, &keyid);
                pgpAssertNoErr(err);
                /* plainfilename not being used, so use it to store keyid 
                   of key to be deleted from server */
                err = PGPGetKeyIDString(&keyid, kPGPKeyIDString_Full,
                                        mainbPtr->plainfilename);
                pgpAssertNoErr(err);


                err = PGPDeleteFromKeyServer( mainbPtr->workingKeyServer,
                        single, &failed);

                if( IsPGPError(err) ) {
                    if(failed) {
                        pgpShowKeyBrief( filebPtr, key );
                        PGPFreeKeySet(failed);
                    }
                }
            } 
			else
			{
                if( mainbPtr->workingRingSet )
				{
					if(bIsPrivateKey)
					{
						fprintf( filebPtr->pgpout, 
						LANG("\nKey or user ID is also present in secret keyring.\n"));
						fprintf( filebPtr->pgpout, 
						LANG("Do you want to remove it from the secret keyring (y/N)? "));
						ans = getyesno( filebPtr, 'n', batchmode );
						if(!ans)
							err = kPGPError_UserAbort;

					}
					if(IsntPGPError(err))
                        err = PGPRemoveKeys( single, mainbPtr->workingRingSet );
				}
			}

            if( IsPGPError(err) )
                pgpShowError( filebPtr, err, 0,0);
            else
            {
                if(!compatible)
                {
                    fprintf( filebPtr->pgpout, mainbPtr->workingKeyServer ? 
                        LANG("Key removed from key server.\n") :
                        LANG("Key removed from key ring.\n"));
                }
                else
                {
                    fprintf( filebPtr->pgpout,
                        LANG("Key removed from key ring.\n"));
                }
            }
            PGPFreeKeySet( single );
            removed++;
        } 
		else if( numuserids > 1 )
		{
			PGPUserIDRef userid;
			char useridstr[ kPGPMaxUserIDSize ];
			PGPSize actual;

			/* list all userids associated with the key. */
			err = PGPKeyIterRewindUserID( keyiter );
			pgpAssertNoErr(err);
			err = PGPKeyIterNextUserID( keyiter, &userid);
			pgpAssertNoErr(err);

			if( userid ) {
				while( userid ) {
					err = PGPGetUserIDStringBuffer( userid,
							kPGPUserIDPropName, kPGPMaxUserIDSize, useridstr,
							&actual );

					fprintf( filebPtr->pgpout, LANG("Remove \"%s\" (y/N)? "),
							useridstr );

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

					if( ans ) {
						err = PGPRemoveUserID( userid );
						pgpAssertNoErr(err);
						removed++;
					}
					err = PGPKeyIterNextUserID( keyiter, &userid);
				}
				if(bIsPrivateKey && err == kPGPError_EndOfIteration && removed > 0)
				{
					fprintf( filebPtr->pgpout, 
					LANG("\nKey or user ID is also present in secret keyring.\n"));
					fprintf( filebPtr->pgpout, 
					LANG("Do you want to remove it from the secret keyring (y/N)? "));
					ans = getyesno( filebPtr, 'n', batchmode );
					if(!ans)
					{
						PGPRevertKeyRingChanges(keySet);
						err = kPGPError_UserAbort;
					}
					else
					{
						fprintf(filebPtr->pgpout,
									LANG("\nUser ID(s) removed from key ring.\n"));
					}
				}
			}
		}
		else
		{
			/* user cancelled delete operation */
            err = kPGPError_UserAbort;
            removed = 0;
		}

		break;
    }
    if(err == kPGPError_EndOfIteration && removed > 0)
        err = kPGPError_NoErr;

out:
    if( keyiter )
        er2 = PGPFreeKeyIter( keyiter );
    if( keylist )
        er2 = PGPFreeKeyList( keylist );
    return err;
}

/*
   Remove the first entry in key ring that has useridstr string in userid.
   Or it removes the first matching keyID from the ring.  A non-NULL
   keyID takes precedence over a useridstr specifier.  useridstr is a
   null-terminated C string.  If secringToo is TRUE, the secret keyring
   is also checked.
 */

int removeFromKeyring( struct pgpmainBones *mainbPtr, char *useridstr,
        char *ringFileName, char *origRingFileName)
{
    PGPContextRef context = mainbPtr->pgpContext;
    struct pgpfileBones *filebPtr = mainbPtr->filebPtr;
    struct pgpenvBones *envbPtr = filebPtr->envbPtr;
    PGPError			err;
    PGPKeySetRef		ringSet = kPGPInvalidRef;
    char				*ringFile = NULL;
    PGPKeySetRef		keysToRemove = kPGPInvalidRef;

	char				szTemp[MAX_PATH] = {'\0'};
	char				secringfilename[MAX_PATH] = {'\0'};
	char				pubringfilename[MAX_PATH] = {'\0'};
	PGPFileSpecRef		secRingFileSpec = kPGPInvalidRef;
	PGPFileSpecRef		pubRingFileSpec = kPGPInvalidRef;


	if(ringFileName == NULL)	/* use default key rings */
	{
		err = PGPOpenDefaultKeyRings(context, kPGPKeyRingOpenFlags_Mutable, &ringSet);
	}
	else
	{
		/* see if I can find corresponding key file to open as key pair */

		/* if file doesn't have an extension, try appending ".pkr" on it */
		char		*pszTemp = NULL;

		strcpy(szTemp, ringFileName);
		defaultExtension(filebPtr, szTemp, filebPtr->PKR_EXTENSION);

		if(hasExtension(szTemp, filebPtr->PKR_EXTENSION))
		{
			strcpy(pubringfilename, szTemp);
			if(!dropFilename(szTemp))
			{
				err = -1;
				goto done;