keyview.c

vc环境下的pgp源码

/*____________________________________________________________________________
    keyview.c

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

	PGP 6.5 Command Line 

    use the PGP SDK to view the keyring and report in PGP262 style.

    $Id: keyview.c,v 1.15 1999/05/21 20:38:29 sluu Exp $
____________________________________________________________________________*/

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

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

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

void pgpShowError( struct pgpfileBones *filebPtr, PGPError err, char
        *file, int line )
{
#if PGP_DEBUG
    char buffer[256];
    buffer[0] = 0;
    PGPGetErrorString(err, 255, buffer);
    buffer[255]=0;
    fprintf(filebPtr->pgpout,LANG("\nError: %s\n"),buffer);
    if(file)
        fprintf(filebPtr->pgpout,LANG("at %s:%d\n"),file,line);
#endif 
}

static const char *pgpTrustString( PGPInt32 trust )
{
    switch( trust )
    {
        case kPGPKeyTrust_Undefined: return LANG("undefined");
        case kPGPKeyTrust_Unknown:   return LANG("unknown");
        case kPGPKeyTrust_Never:     return LANG("untrusted");
        case kPGPKeyTrust_Marginal:  return LANG("marginal");
        case kPGPKeyTrust_Complete:  return LANG("complete");
        case kPGPKeyTrust_Ultimate:  return LANG("ultimate");
        default:                     return LANG("????????");
    }
}

static const char *pgpValidityString( PGPInt32 validity )
{
    switch( validity )
    {
        case kPGPValidity_Unknown:   return LANG("unknown");
        case kPGPValidity_Invalid:   return LANG("invalid");
        case kPGPValidity_Marginal:  return LANG("marginal");
        case kPGPValidity_Complete:  return LANG("complete");
        default:                     return LANG("????????");
    }
}

static const char *pgpPKAlgIDString( PGPInt32 algID )
{
    switch( algID ) {
        case kPGPPublicKeyAlgorithm_RSA:
            return LANG("RSA");
        case kPGPPublicKeyAlgorithm_RSAEncryptOnly:
            return LANG("RSA encrypt");
        case kPGPPublicKeyAlgorithm_RSASignOnly:
            return LANG("RSA sign");
        case kPGPPublicKeyAlgorithm_ElGamal:
            return LANG("DH");
        case kPGPPublicKeyAlgorithm_DSA:
            return LANG("DSS");
        default:
            return LANG("Unknown type");
    }
}

PGPError pgpGetKeyPKAlgIDString( PGPKeyRef key, char **str )
{
    PGPError err;
    PGPInt32 algID;

    err = PGPGetKeyNumber( key, kPGPKeyPropAlgID, &algID );

    *str = (char *)pgpPKAlgIDString( algID );
    return err;
}

PGPError pgpGetKeyTrustString( PGPKeyRef key, char **str )
{
    PGPInt32 trust;
    PGPError err;
    err = PGPGetKeyNumber( key, kPGPKeyPropTrust, &trust);
    pgpAssertNoErr(err);
    *str = (char *)pgpTrustString( trust );
    return err;
}

PGPError pgpGetKeyValidityString( PGPKeyRef key, char **str )
{
    PGPInt32 validity;
    PGPError err;
    err = PGPGetKeyNumber( key, kPGPKeyPropValidity, &validity);
    pgpAssertNoErr(err);
    *str = (char *)pgpValidityString( validity );
    return err;
}

PGPError pgpShowKeyTrust( struct pgpfileBones *filebPtr, PGPKeyRef key )
{
    PGPInt32 trust;
    PGPError err;

    err = PGPGetKeyNumber( key, kPGPKeyPropTrust, &trust);
    pgpAssertNoErr(err);

    switch( trust ) {
        case kPGPKeyTrust_Never:
            fprintf(filebPtr->pgpout,
LANG("This user is untrusted to certify other keys.\n"));
            break;
        case kPGPKeyTrust_Marginal:
            fprintf(filebPtr->pgpout,
LANG("This user is generally trusted to certify other keys.\n"));
            break;
        case kPGPKeyTrust_Complete:
            fprintf(filebPtr->pgpout,
LANG("This user is completely trusted to certify other keys.\n"));
            break;
        case kPGPKeyTrust_Ultimate:
            fprintf(filebPtr->pgpout,
LANG("This axiomatic key is ultimately trusted to certify other keys.\n"));
            break;
        default:
            /* Just don't say anything in this case */
            break;

    }
    return err;
}

PGPError pgpShowKeyValidity( struct pgpfileBones *filebPtr, PGPKeyRef key )
{
    PGPInt32 validity;
    PGPError err;
    err = PGPGetKeyNumber( key, kPGPKeyPropValidity, &validity);
    pgpAssertNoErr(err);
    switch( validity ) {
        case kPGPValidity_Invalid:
            fprintf(filebPtr->pgpout,
LANG("This key/userID association is not certified.\n"));
            break;
        case kPGPValidity_Marginal:
            fprintf(filebPtr->pgpout,
LANG("This key/userID association is marginally certified.\n"));
            break;
        case kPGPValidity_Complete:
            fprintf(filebPtr->pgpout,
LANG("This key/userID association is fully certified.\n"));
            break;
        default:
            /* Just don't say anything in this case */
            break;
    }
    return err;
}

#if 0
 /* for debugging, what are we looking at?? */
static void pgpShowCertDebug( struct pgpfileBones *filebPtr, PGPSigRef cert )
{
    PGPBoolean boo;
    PGPInt32 prop;

    PGPGetSigBoolean( cert, kPGPSigPropIsRevoked, &boo );
    fprintf( filebPtr->pgpout, "IsRevoked: %d\n", boo );

    PGPGetSigBoolean( cert, kPGPSigPropIsNotCorrupt, &boo );
    fprintf( filebPtr->pgpout, "IsNotCorrupt: %d\n", boo );

    PGPGetSigBoolean( cert, kPGPSigPropIsTried, &boo );
    fprintf( filebPtr->pgpout, "IsTried: %d\n", boo );

    PGPGetSigBoolean( cert, kPGPSigPropIsVerified, &boo );
    fprintf( filebPtr->pgpout, "IsVerified: %d\n", boo );

    PGPGetSigBoolean( cert, kPGPSigPropIsMySig, &boo );
    fprintf( filebPtr->pgpout, "IsMySig: %d\n", boo );

    PGPGetSigBoolean( cert, kPGPSigPropIsExportable, &boo );
    fprintf( filebPtr->pgpout, "IsExportable: %d\n", boo );

    PGPGetSigBoolean( cert, kPGPSigPropHasUnverifiedRevocation, &boo );
    fprintf( filebPtr->pgpout, "HasUnverifiedRevocation: %d\n", boo );

    PGPGetSigBoolean( cert, kPGPSigPropIsExpired, &boo );
    fprintf( filebPtr->pgpout, "IsExpired: %d\n", boo );

    PGPGetSigBoolean( cert, kPGPSigPropIsX509, &boo );
    fprintf( filebPtr->pgpout, "IsX509: %d\n", boo );


    PGPGetSigNumber( cert, kPGPSigPropAlgID, &prop );
    fprintf( filebPtr->pgpout, "AlgID: %d\n", prop );

    PGPGetSigNumber( cert, kPGPSigPropTrustLevel, &prop );
    fprintf( filebPtr->pgpout, "TrustLevel: %d\n", prop );

    PGPGetSigNumber( cert, kPGPSigPropTrustValue, &prop );
    fprintf( filebPtr->pgpout, "TrustValue: %d\n", prop );
}

 /* show in PGP 262 format */
static void pgpShowCert( struct pgpfileBones *filebPtr, PGPSigRef cert )
{
    /* String properties */
    kPGPSigPropKeyID                    = 120,
    kPGPSigPropX509Certificate          = 121,

    /* Number properties */
    kPGPSigPropAlgID                    = 140,
    kPGPSigPropTrustLevel               = 141,
    kPGPSigPropTrustValue               = 142,

    /* Time properties */
    kPGPSigPropCreation                 = 160,
    kPGPSigPropExpiration               = 161,

    /* PGPBoolean properties */
    kPGPSigPropIsRevoked                = 180,
    kPGPSigPropIsNotCorrupt             = 181,
    kPGPSigPropIsTried                  = 182,
    kPGPSigPropIsVerified               = 183,
    kPGPSigPropIsMySig                  = 184,
    kPGPSigPropIsExportable             = 185,
    kPGPSigPropHasUnverifiedRevocation  = 186,
    kPGPSigPropIsExpired                = 187,
    kPGPSigPropIsX509                   = 188,
}
#endif

 /* create a key iter from a singleton key, for iterating thru the userids.
    output: position the iter at the key.
  */
PGPError pgpNewUserIDIterFromKey( PGPKeyRef key, PGPKeyIterRef *newiter)
{
    PGPKeySetRef single = NULL;
    PGPKeyListRef keylist = NULL;
    PGPError err;

    err = PGPNewSingletonKeySet( key, &single );
    if( IsPGPError(err) )
        goto out;

    err = PGPOrderKeySet( single, kPGPAnyOrdering, &keylist );
    if( IsPGPError(err) )
        goto out;

    err = PGPNewKeyIter( keylist, newiter );
    if( IsPGPError(err) )
        goto out;

    /* it may not be correctly positioned, we have to rewind and next..*/
    err = PGPKeyIterRewind( *newiter );
    pgpAssertNoErr(err);

    err = PGPKeyIterNext( *newiter, &key);

    if( err == kPGPError_EndOfIteration )
        err = kPGPError_NoErr;
out:
    if(keylist)
        PGPFreeKeyList( keylist );
    if(single)
        PGPFreeKeySet( single );
    return err;
}

PGPError pgpGetKeyIDStringCompat( PGPKeyID const *kidPtr, PGPBoolean
        abbrev, PGPBoolean compat, char *kidstr )
{
    PGPError err;
    char kstr[kPGPMaxKeyIDStringSize];

    err = PGPGetKeyIDString( kidPtr, abbrev ? kPGPKeyIDString_Abbreviated
            : kPGPKeyIDString_Full, kstr );

    pgpAssertNoErr(err);

    if( compat && kstr[0]=='0' && kstr[1]=='x' )
        strcpy( kidstr, &kstr[2] );
    else
        strcpy( kidstr, kstr );
    return err;
}

PGPError pgpGetKeyIDStringCompatFromKey( PGPKeyRef key, PGPBoolean abbrev,
        PGPBoolean compat, char *kidstr )
{
    PGPError err;
    PGPKeyID kid;

    err = PGPGetKeyIDFromKey( key, &kid );
    pgpAssertNoErr(err);

    err = pgpGetKeyIDStringCompat( &kid, abbrev, compat, kidstr );
    return err;
}

PGPError pgpGetUserIDStringFromSig(PGPKeySetRef ringSet, PGPSigRef sig,
        PGPBoolean compat, char *useridstr )

{
    PGPError err;
    PGPSize actual;
    PGPKeyID kid;
    char kstr[kPGPMaxKeyIDStringSize];
    PGPKeyRef key;

    /* print the certifier...*/
    err = PGPGetSigCertifierKey( sig, ringSet, &key );

    if( IsntPGPError(err) ) {
        PGPUserIDRef userid;

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

        pgpAssertNoErr(err);

        /*PGPFreeUserID( userid );*/

        return kPGPError_NoErr;
    }

    err = PGPGetKeyIDOfCertifier( sig, &kid );
    pgpAssertNoErr(err);

    err = pgpGetKeyIDStringCompat( &kid, TRUE, compat, kstr );
    pgpAssertNoErr(err);
    sprintf( useridstr, "(KeyID: %s)", kstr);

    return kPGPError_ItemNotFound;
}

PGPError pgpGetUserIDStringFromKey( PGPKeyRef key, char *useridstr )
{
    PGPUserIDRef userid;
    PGPSize actual;
    PGPError err;

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

    pgpAssertNoErr(err);