keyview.c

PGP—Pretty Good Privacy

    return err;
}

PGPError pgpShowKeyUserID( struct pgpfileBones *filebPtr, PGPKeyRef key )
{
    char useridstr[ kPGPMaxUserIDSize ];
    PGPError err;

    err = pgpGetUserIDStringFromKey( key, useridstr );

    fprintf( filebPtr->pgpout, LANG("\nKey for user ID \"%s\"\n"),
            useridstr );
    return err;
}


/*
  equivalent to PGP262's show_key(f,pos,0);
 */

PGPError pgpShowKeyBrief( struct pgpfileBones *filebPtr, PGPKeyRef key )
{
    struct pgpenvBones *envbPtr = filebPtr->envbPtr;
    PGPUInt32 numbits,subbits,algorithm;
    PGPTime creation;
    PGPUInt16 yyyy, mm, dd;
    char kstr[kPGPMaxKeyIDStringSize];
    PGPUserIDRef userid, alias;
    char useridstr[ kPGPMaxUserIDSize ], aliasstr[ kPGPMaxUserIDSize ];
    PGPKeyIterRef uiter;
    PGPSize actual;
    PGPError err;
    PGPBoolean compatible = envbPtr->compatible;

    /* what number of bits?*/
    err = PGPGetKeyNumber( key, kPGPKeyPropBits, &numbits );
    pgpAssertNoErr(err);

    err = pgpNewUserIDIterFromKey( key, &uiter );
    pgpAssertNoErr(err);

    /* what number of bits for the subkey(s)?... show the first one only.*/
    subbits=0;
    PGPGetKeyNumber(key, kPGPKeyPropAlgID, &algorithm);
    if( algorithm == kPGPPublicKeyAlgorithm_DSA )
    {
        PGPSubKeyRef subKey;
        PGPKeyIterSeek( uiter, key);
        err = PGPKeyIterNextSubKey(uiter, &subKey);
        if( IsntPGPError( err ) )
        {
            err = PGPGetSubKeyNumber(subKey, kPGPKeyPropBits, &subbits);
            pgpAssertNoErr(err);
        }
    }

    err = pgpGetKeyIDStringCompatFromKey( key, TRUE, compatible, kstr );
    pgpAssertNoErr(err);

    /* when was it created?*/
    err = PGPGetKeyTime ( key, kPGPKeyPropCreation, &creation );
    pgpAssertNoErr(err);
    PGPGetYMDFromPGPTime( creation, &yyyy, &mm, &dd);

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

    pgpAssertNoErr(err);

    fprintf( filebPtr->pgpout, LANG("\nKey for user ID: %s\n"), useridstr );
    if(compatible)
        fprintf( filebPtr->pgpout,
        LANG("%d-bit key, Key ID %s, created %4d/%02d/%02d"),
        numbits, kstr, yyyy, mm, dd );
    else {
        char *algstr;
        err = pgpGetKeyPKAlgIDString( key, &algstr );
        fprintf( filebPtr->pgpout,
        LANG("%d-bit %s key, Key ID %s, created %4d/%02d/%02d"),
        numbits, algstr, kstr, yyyy, mm, dd );
    }

    if(!compatible)
    {
        PGPTime expyTime;
        PGPBoolean isexp;
        PGPGetKeyBoolean( key, kPGPKeyPropIsExpired, &isexp );
        if(isexp) {
            fprintf( filebPtr->pgpout, LANG(". Key is expired"));
        } else {
            err = PGPGetKeyTime( key, kPGPKeyPropExpiration, &expyTime);
            pgpAssertNoErr(err);
            if(expyTime != kPGPExpirationTime_Never) {
                PGPGetYMDFromPGPTime( expyTime, &yyyy, &mm, &dd);
                fprintf( filebPtr->pgpout, LANG(", expires %4d/%02d/%02d"),
                        yyyy, mm, dd );
            }
        }
    }
    fprintf( filebPtr->pgpout, "\n");

    { /* print if key format is corrupted*/
        PGPBoolean isok;
        PGPGetKeyBoolean( key, kPGPKeyPropIsNotCorrupt, &isok );
        if( !isok )
            fprintf(filebPtr->pgpout, LANG("Bad key format\n"));
    }
    { /* print if it is revoked*/
        PGPBoolean isrev;
        PGPGetKeyBoolean( key, kPGPKeyPropIsRevoked, &isrev );
        if( isrev )
            fprintf(filebPtr->pgpout, LANG("Key has been revoked\n"));
    }
    { /* print if it is disabled*/
        PGPBoolean isdis;
        PGPGetKeyBoolean( key, kPGPKeyPropIsDisabled, &isdis );
        if( isdis )
            fprintf(filebPtr->pgpout, LANG("Key is disabled\n"));
    }
    if( !compatible )
    {
        PGPBoolean cansign,canencrypt;
        PGPBoolean x=FALSE;
        err = PGPGetKeyBoolean( key, kPGPKeyPropCanEncrypt, &canencrypt );
        pgpAssertNoErr(err);
        err = PGPGetKeyBoolean( key, kPGPKeyPropCanSign, &cansign );
        pgpAssertNoErr(err);
        if( cansign ) {
            fprintf( filebPtr->pgpout, LANG("Key can sign. "));
            x=TRUE;
        }
        if( !canencrypt ) {
            fprintf( filebPtr->pgpout,
                    LANG("Users cannot encrypt to this key. "));
            x=TRUE;
        }
        if(x)
            fprintf( filebPtr->pgpout, "\n");
    }


    err = PGPKeyIterRewindUserID( uiter );
    pgpAssertNoErr(err);

    err = PGPKeyIterNextUserID( uiter, &alias);
    pgpAssertNoErr(err);
    if( alias ) {
        while( alias ) {
            err = PGPGetUserIDStringBuffer( alias,
                    kPGPUserIDPropName, kPGPMaxUserIDSize,
                    aliasstr, &actual );
            pgpAssertNoErr(err);

            if( strcmp( useridstr, aliasstr ) !=0 )
                fprintf( filebPtr->pgpout, LANG("Also known as: %s\n"),
                        aliasstr);
            err = PGPKeyIterNextUserID( uiter, &alias );
            /* if err, there are no more*/
        }
    }
    if(uiter)
        PGPFreeKeyIter( uiter );

    return kPGPError_NoErr;
}

/*
   Look for the sig in the target key.
   returns: *outSig
        is the sig found. if not found, *outSig will be NULL.
 */
PGPError pgpKeyFindSig( PGPKeyRef key, PGPSigRef srchSig, PGPSigRef *outSig)
{
    PGPUserIDRef alias;
    PGPKeyIterRef uiter;
    PGPKeyID srchKID;
    PGPError err;
    PGPTime srchTime;

    *outSig = NULL;

    err = PGPGetKeyIDOfCertifier( srchSig, &srchKID );
    pgpAssertNoErr(err);
    err = PGPGetSigTime( srchSig, kPGPSigPropCreation, &srchTime );
    pgpAssertNoErr(err);

    err = pgpNewUserIDIterFromKey( key, &uiter );
    pgpAssertNoErr(err);

    err = PGPKeyIterRewindUserID( uiter );
    pgpAssertNoErr(err);

    err = PGPKeyIterNextUserID( uiter, &alias);
    pgpAssertNoErr(err);

    while( alias ) {
        PGPSigRef sig;
        PGPKeyID kid;

        err = PGPKeyIterRewindUIDSig( uiter );
        pgpAssertNoErr(err);
        err = PGPKeyIterNextUIDSig( uiter, &sig );
        pgpAssertNoErr(err);
        while( sig ) {
            PGPTime sigTime;
            err = PGPGetKeyIDOfCertifier( sig, &kid );
            pgpAssertNoErr(err);
            err = PGPGetSigTime(sig, kPGPSigPropCreation, &sigTime );
            pgpAssertNoErr(err);

            if( memcmp( &kid, &srchKID, sizeof( PGPKeyID )) && sigTime ==
                    srchTime )
            {
                *outSig = sig;
                return kPGPError_NoErr;
            }
            err = PGPKeyIterNextUIDSig( uiter, &sig );
            /*if error, no more sigs.*/
        }
        err = PGPKeyIterNextUserID( uiter, &alias );
        /* if err, there are no more*/
    }
    PGPFreeKeyIter( uiter );
    return err;
}

PGPError pgpShowKeyChanges( struct pgpfileBones *filebPtr, PGPKeyRef
        existingkey, PGPKeyRef newkey )
{
    /* equivalent to show_key(f,pos, SHOW_CHANGE); prints the differences
    between the key and the one seen on the keyring*/

    /*PGPSigRef sig;*/

    /*
       The SDK offers no easy way to search for or compare certs to one
        another
     */

    fprintf( filebPtr->pgpout, "pgpShowKeyChanges() stub\n" );

#if 0
    err = PGPKeyIterRewindUIDSig( iterContext );
    pgpAssertNoErr(err);
    err = PGPKeyIterNextUIDSig( iterContext, &sig );
    pgpAssertNoErr(err);
    while( sig ) {

    err = pgpKeyFindSig( key, PGPSigRef srchSig, PGPSigRef *outSig);
    }
#endif

    return kPGPError_NoErr;
}

/*
   equivalent to show_key(f,pos, SHOW_TRUST|SHOW_SIGS)
   and show_key(f,pos, SHOW_TRUST|SHOW_SIGS|SHOW_HASH)
 */
PGPError pgpShowKeyTrustAndValidity( struct pgpfileBones *filebPtr,
        PGPKeySetRef ringSet, PGPKeyIterRef iterContext, PGPKeyRef key,
        PGPBoolean showFingerprints )
{
    struct pgpenvBones *envbPtr = filebPtr->envbPtr;
    PGPUInt32 trust;
    PGPUInt32 validity;
    char kstr[kPGPMaxKeyIDStringSize];
    PGPUserIDRef userid;
    char useridstr[ kPGPMaxUserIDSize ];
    PGPSize actual;
    PGPKeyRef skey = NULL;
    PGPSigRef sig;
    PGPError err;
    PGPBoolean mine;
    PGPBoolean compatible = envbPtr->compatible;
    PGPSize keyIDLength;

    PGPSize trustLength = 9;
    PGPSize validityLength = 9;
    keyIDLength = ( compatible ? 8 : 10 );

    err = PGPGetKeyBoolean(key, kPGPKeyPropIsAxiomatic, &mine);
    pgpAssertNoErr(err);

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

    err = pgpGetKeyIDStringCompatFromKey( key, TRUE, compatible, kstr );
    pgpAssertNoErr(err);

    err = PGPGetPrimaryUserID( key, &userid);
    pgpAssertNoErr(err);

    /* print the key's stats */
    fprintf(filebPtr->pgpout, "%c ", mine ? '*' : ' ');
    fprintf( filebPtr->pgpout,"%s ", LANG(kstr));

    fprintf( filebPtr->pgpout,"%-*s ", trustLength,
            pgpTrustString( trust ) );

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

    while( userid ) {
        err = PGPGetUserIDStringBuffer( userid, kPGPUserIDPropName,
                kPGPMaxUserIDSize, useridstr, &actual );
        pgpAssertNoErr(err);
        fprintf( filebPtr->pgpout,"%-*s ", validityLength,
                pgpValidityString( validity ) );
        fprintf( filebPtr->pgpout,"%s\n", useridstr );

        /* get sigs */
        err = PGPKeyIterRewindUIDSig( iterContext );
        pgpAssertNoErr(err);
        err = PGPKeyIterNextUIDSig( iterContext, &sig );
        /*if err, there are none.*/

        /* for each signature */
        while( sig ) {

            /* print the certifier...*/
            err = pgpGetUserIDStringFromSig( ringSet, sig, compatible,
                    useridstr );

            if( IsntPGPError(err) ) {
                err = PGPGetSigCertifierKey( sig, ringSet, &skey );
                pgpAssertNoErr(err);

                err = PGPGetKeyNumber( skey, kPGPKeyPropTrust, &trust);
                pgpAssertNoErr(err);
                err = PGPGetKeyNumber( skey, kPGPKeyPropValidity, &validity);
                pgpAssertNoErr(err);

            } else if( err == kPGPError_ItemNotFound ) {
                trust = kPGPKeyTrust_Undefined;
                validity = kPGPValidity_Unknown;
            } else
                pgpAssertNoErr(err);

            fprintf( filebPtr->pgpout, "%c ",
                    (trust >= kPGPKeyTrust_Marginal && validity >=
                    kPGPValidity_Complete) ? 'c' : ' ');

            fprintf( filebPtr->pgpout, "%-*s ", keyIDLength,"");
            fprintf( filebPtr->pgpout, "%-*s ", trustLength,
                    pgpTrustString( trust ));

            fprintf( filebPtr->pgpout, "%-*s ", validityLength,"");
            fprintf( filebPtr->pgpout, " %-s\n", useridstr );

            err = PGPKeyIterNextUIDSig( iterContext, &sig );

        } /* end for each sig */


        err = PGPKeyIterNextUserID( iterContext, &userid);
        /*if err, no more userids for this key*/
        if(userid)
            fprintf( filebPtr->pgpout, "  %-*s %-*s ",
                    keyIDLength, "", trustLength, "");