rpmpgp.h

Go to the documentation of this file.

#ifndef H_RPMPGP
#define H_RPMPGP
 
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <rpm/rpmtypes.h>
#include <rpm/rpmstring.h>
#include <rpm/rpmcrypto.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct pgpDigParams_s * pgpDigParams;
 
 
#define PGP_KEYID_LEN 8
 
typedef uint8_t pgpKeyID_t[PGP_KEYID_LEN];
typedef uint8_t pgpTime_t[4];
 
typedef enum pgpTag_e {
    PGPTAG_RESERVED     =  0, 
    PGPTAG_PUBLIC_SESSION_KEY   =  1, 
    PGPTAG_SIGNATURE        =  2, 
    PGPTAG_SYMMETRIC_SESSION_KEY=  3, 
    PGPTAG_ONEPASS_SIGNATURE    =  4, 
    PGPTAG_SECRET_KEY       =  5, 
    PGPTAG_PUBLIC_KEY       =  6, 
    PGPTAG_SECRET_SUBKEY    =  7, 
    PGPTAG_COMPRESSED_DATA  =  8, 
    PGPTAG_SYMMETRIC_DATA   =  9, 
    PGPTAG_MARKER       = 10, 
    PGPTAG_LITERAL_DATA     = 11, 
    PGPTAG_TRUST        = 12, 
    PGPTAG_USER_ID      = 13, 
    PGPTAG_PUBLIC_SUBKEY    = 14, 
    PGPTAG_COMMENT_OLD      = 16, 
    PGPTAG_PHOTOID      = 17, 
    PGPTAG_ENCRYPTED_MDC    = 18, 
    PGPTAG_MDC          = 19, 
    PGPTAG_PRIVATE_60       = 60, 
    PGPTAG_COMMENT      = 61, 
    PGPTAG_PRIVATE_62       = 62, 
    PGPTAG_CONTROL      = 63  
} pgpTag;
 
typedef struct pgpPktPubkey_s {
    uint8_t version;    
    pgpKeyID_t keyid;   
    uint8_t algo;       
} pgpPktPubkey;
 
 
typedef enum pgpSigType_e {
    PGPSIGTYPE_BINARY        = 0x00, 
    PGPSIGTYPE_TEXT      = 0x01, 
    PGPSIGTYPE_STANDALONE    = 0x02, 
    PGPSIGTYPE_GENERIC_CERT  = 0x10,
    PGPSIGTYPE_PERSONA_CERT  = 0x11,
    PGPSIGTYPE_CASUAL_CERT   = 0x12,
    PGPSIGTYPE_POSITIVE_CERT     = 0x13,
    PGPSIGTYPE_SUBKEY_BINDING    = 0x18, 
    PGPSIGTYPE_SIGNED_KEY    = 0x1F, 
    PGPSIGTYPE_KEY_REVOKE    = 0x20, 
    PGPSIGTYPE_SUBKEY_REVOKE     = 0x28, 
    PGPSIGTYPE_CERT_REVOKE   = 0x30, 
    PGPSIGTYPE_TIMESTAMP     = 0x40  
} pgpSigType;
 
typedef enum pgpPubkeyAlgo_e {
    PGPPUBKEYALGO_RSA       =  1,   
    PGPPUBKEYALGO_RSA_ENCRYPT   =  2,   
    PGPPUBKEYALGO_RSA_SIGN  =  3,   
    PGPPUBKEYALGO_ELGAMAL_ENCRYPT = 16, 
    PGPPUBKEYALGO_DSA       = 17,   
    PGPPUBKEYALGO_EC        = 18,   
    PGPPUBKEYALGO_ECDSA     = 19,   
    PGPPUBKEYALGO_ELGAMAL   = 20,   
    PGPPUBKEYALGO_DH        = 21,   
    PGPPUBKEYALGO_EDDSA     = 22    
} pgpPubkeyAlgo;
 
typedef enum pgpSymkeyAlgo_e {
    PGPSYMKEYALGO_PLAINTEXT =  0,   
    PGPSYMKEYALGO_IDEA      =  1,   
    PGPSYMKEYALGO_TRIPLE_DES    =  2,   
    PGPSYMKEYALGO_CAST5     =  3,   
    PGPSYMKEYALGO_BLOWFISH  =  4,   
    PGPSYMKEYALGO_SAFER     =  5,   
    PGPSYMKEYALGO_DES_SK    =  6,   
    PGPSYMKEYALGO_AES_128   =  7,   
    PGPSYMKEYALGO_AES_192   =  8,   
    PGPSYMKEYALGO_AES_256   =  9,   
    PGPSYMKEYALGO_TWOFISH   = 10,   
    PGPSYMKEYALGO_NOENCRYPT = 110   
} pgpSymkeyAlgo;
 
typedef enum pgpCompressAlgo_e {
    PGPCOMPRESSALGO_NONE    =  0,   
    PGPCOMPRESSALGO_ZIP     =  1,   
    PGPCOMPRESSALGO_ZLIB    =  2,   
    PGPCOMPRESSALGO_BZIP2   =  3    
} pgpCompressAlgo;
 
typedef enum pgpHashAlgo_e {
    PGPHASHALGO_MD5     =  1,   
    PGPHASHALGO_SHA1        =  2,   
    PGPHASHALGO_RIPEMD160   =  3,   
    PGPHASHALGO_MD2     =  5,   
    PGPHASHALGO_TIGER192    =  6,   
    PGPHASHALGO_HAVAL_5_160 =  7,   
    PGPHASHALGO_SHA256      =  8,   
    PGPHASHALGO_SHA384      =  9,   
    PGPHASHALGO_SHA512      = 10,   
    PGPHASHALGO_SHA224      = 11,   
} pgpHashAlgo;
 
typedef enum pgpCurveId_e {
    PGPCURVE_NIST_P_256     =  1,   
    PGPCURVE_NIST_P_384     =  2,   
    PGPCURVE_NIST_P_521     =  3,   
    PGPCURVE_BRAINPOOL_P256R1   =  4,   
    PGPCURVE_BRAINPOOL_P512R1   =  5,   
    PGPCURVE_ED25519        =  6,   
    PGPCURVE_CURVE25519     =  7,   
} pgpCurveId;
 
typedef struct pgpPktSigV3_s {
    uint8_t version;    
    uint8_t hashlen;    
    uint8_t sigtype;    
    pgpTime_t time; 
    pgpKeyID_t signid;  
    uint8_t pubkey_algo;    
    uint8_t hash_algo;  
    uint8_t signhash16[2];  
} * pgpPktSigV3;
 
typedef struct pgpPktSigV4_s {
    uint8_t version;    
    uint8_t sigtype;    
    uint8_t pubkey_algo;    
    uint8_t hash_algo;  
    uint8_t hashlen[2]; 
} * pgpPktSigV4;
 
typedef enum pgpSubType_e {
    PGPSUBTYPE_NONE     =   0, 
    PGPSUBTYPE_SIG_CREATE_TIME  =   2, 
    PGPSUBTYPE_SIG_EXPIRE_TIME  =   3, 
    PGPSUBTYPE_EXPORTABLE_CERT  =   4, 
    PGPSUBTYPE_TRUST_SIG    =   5, 
    PGPSUBTYPE_REGEX        =   6, 
    PGPSUBTYPE_REVOCABLE    =   7, 
    PGPSUBTYPE_KEY_EXPIRE_TIME  =   9, 
    PGPSUBTYPE_ARR      =  10, 
    PGPSUBTYPE_PREFER_SYMKEY    =  11, 
    PGPSUBTYPE_REVOKE_KEY   =  12, 
    PGPSUBTYPE_ISSUER_KEYID =  16, 
    PGPSUBTYPE_NOTATION     =  20, 
    PGPSUBTYPE_PREFER_HASH  =  21, 
    PGPSUBTYPE_PREFER_COMPRESS  =  22, 
    PGPSUBTYPE_KEYSERVER_PREFERS=  23, 
    PGPSUBTYPE_PREFER_KEYSERVER =  24, 
    PGPSUBTYPE_PRIMARY_USERID   =  25, 
    PGPSUBTYPE_POLICY_URL   =  26, 
    PGPSUBTYPE_KEY_FLAGS    =  27, 
    PGPSUBTYPE_SIGNER_USERID    =  28, 
    PGPSUBTYPE_REVOKE_REASON    =  29, 
    PGPSUBTYPE_FEATURES     =  30, 
    PGPSUBTYPE_EMBEDDED_SIG =  32, 
    PGPSUBTYPE_INTERNAL_100 = 100, 
    PGPSUBTYPE_INTERNAL_101 = 101, 
    PGPSUBTYPE_INTERNAL_102 = 102, 
    PGPSUBTYPE_INTERNAL_103 = 103, 
    PGPSUBTYPE_INTERNAL_104 = 104, 
    PGPSUBTYPE_INTERNAL_105 = 105, 
    PGPSUBTYPE_INTERNAL_106 = 106, 
    PGPSUBTYPE_INTERNAL_107 = 107, 
    PGPSUBTYPE_INTERNAL_108 = 108, 
    PGPSUBTYPE_INTERNAL_109 = 109, 
    PGPSUBTYPE_INTERNAL_110 = 110, 
    PGPSUBTYPE_CRITICAL     = 128  
} pgpSubType;
 
typedef union pgpPktSig_u {
    struct pgpPktSigV3_s v3;
    struct pgpPktSigV4_s v4;
} * pgpPktSig;
 
typedef struct pgpPktSymkey_s {
    uint8_t version;    
    uint8_t symkey_algo;
    uint8_t s2k[1];
} pgpPktSymkey;
 
typedef struct pgpPktOnepass_s {
    uint8_t version;    
    uint8_t sigtype;    
    uint8_t hash_algo;  
    uint8_t pubkey_algo;    
    pgpKeyID_t signid;  
    uint8_t nested;
} * pgpPktOnepass;
 
typedef struct pgpPktKeyV3_s {
    uint8_t version;    
    pgpTime_t time; 
    uint8_t valid[2];   
    uint8_t pubkey_algo;    
} * pgpPktKeyV3;
 
typedef struct pgpPktKeyV4_s {
    uint8_t version;    
    pgpTime_t time; 
    uint8_t pubkey_algo;    
} * pgpPktKeyV4;
 
typedef union pgpPktKey_u {
    struct pgpPktKeyV3_s v3;
    struct pgpPktKeyV4_s v4;
} pgpPktKey;
 
typedef struct pgpPktCdata_s {
    uint8_t compressalgo;
    uint8_t data[1];
} pgpPktCdata;
 
typedef struct pgpPktEdata_s {
    uint8_t data[1];
} pgpPktEdata;
 
typedef struct pgpPktLdata_s {
    uint8_t format;
    uint8_t filenamelen;
    uint8_t filename[1];
} pgpPktLdata;
 
typedef struct pgpPktTrust_s {
    uint8_t flag;
} pgpPktTrust;
 
typedef struct pgpPktUid_s {
    uint8_t userid[1];
} pgpPktUid;
 
union pgpPktPre_u {
    pgpPktPubkey pubkey;    
    pgpPktSig sig;      
    pgpPktSymkey symkey;    
    pgpPktOnepass onepass;  
    pgpPktKey key;      
    pgpPktCdata cdata;      
    pgpPktEdata edata;      
    pgpPktLdata ldata;      
    pgpPktTrust tdata;      
    pgpPktUid uid;      
};
 
typedef enum pgpArmor_e {
    PGPARMOR_ERR_CRC_CHECK      = -7,
    PGPARMOR_ERR_BODY_DECODE        = -6,
    PGPARMOR_ERR_CRC_DECODE     = -5,
    PGPARMOR_ERR_NO_END_PGP     = -4,
    PGPARMOR_ERR_UNKNOWN_PREAMBLE_TAG   = -3,
    PGPARMOR_ERR_UNKNOWN_ARMOR_TYPE = -2,
    PGPARMOR_ERR_NO_BEGIN_PGP       = -1,
#define PGPARMOR_ERROR  PGPARMOR_ERR_NO_BEGIN_PGP
    PGPARMOR_NONE       =  0,
    PGPARMOR_MESSAGE        =  1, 
    PGPARMOR_PUBKEY     =  2, 
    PGPARMOR_SIGNATURE      =  3, 
    PGPARMOR_SIGNED_MESSAGE =  4, 
    PGPARMOR_FILE       =  5, 
    PGPARMOR_PRIVKEY        =  6, 
    PGPARMOR_SECKEY     =  7  
} pgpArmor;
 
typedef enum pgpArmorKey_e {
    PGPARMORKEY_VERSION     = 1, 
    PGPARMORKEY_COMMENT     = 2, 
    PGPARMORKEY_MESSAGEID   = 3, 
    PGPARMORKEY_HASH        = 4, 
    PGPARMORKEY_CHARSET     = 5  
} pgpArmorKey;
 
typedef enum pgpValType_e {
    PGPVAL_TAG          = 1,
    PGPVAL_ARMORBLOCK       = 2,
    PGPVAL_ARMORKEY     = 3,
    PGPVAL_SIGTYPE      = 4,
    PGPVAL_SUBTYPE      = 5,
    PGPVAL_PUBKEYALGO       = 6,
    PGPVAL_SYMKEYALGO       = 7,
    PGPVAL_COMPRESSALGO     = 8,
    PGPVAL_HASHALGO     = 9,
    PGPVAL_SERVERPREFS      = 10,
} pgpValType;
 
const char * pgpValString(pgpValType type, uint8_t val);
 
static inline
unsigned int pgpGrab(const uint8_t *s, size_t nbytes)
{
    size_t i = 0;
    size_t nb = (nbytes <= sizeof(i) ? nbytes : sizeof(i));
    while (nb--)
    i = (i << 8) | *s++;
    return i;
}
 
int pgpPubkeyFingerprint(const uint8_t * pkt, size_t pktlen,
             uint8_t **fp, size_t *fplen);
 
int pgpPubkeyKeyID(const uint8_t * pkt, size_t pktlen, pgpKeyID_t keyid);
 
int pgpPrtParams(const uint8_t *pkts, size_t pktlen, unsigned int pkttype,
         pgpDigParams * ret);
 
int pgpPrtParams2(const uint8_t *pkts, size_t pktlen, unsigned int pkttype,
         pgpDigParams * ret, char **lints);
 
int pgpPrtParamsSubkeys(const uint8_t *pkts, size_t pktlen,
            pgpDigParams mainkey, pgpDigParams **subkeys,
            int *subkeysCount);
 
pgpArmor pgpReadPkts(const char * fn, uint8_t ** pkt, size_t * pktlen);
 
pgpArmor pgpParsePkts(const char *armor, uint8_t ** pkt, size_t * pktlen);
 
int pgpPubKeyCertLen(const uint8_t *pkts, size_t pktslen, size_t *certlen);
 
rpmRC pgpPubKeyLint(const uint8_t *pkts, size_t pktslen, char **explanation);
 
char * pgpArmorWrap(int atype, const unsigned char * s, size_t ns);
 
int pgpDigParamsCmp(pgpDigParams p1, pgpDigParams p2);
 
unsigned int pgpDigParamsAlgo(pgpDigParams digp, unsigned int algotype);
 
const uint8_t *pgpDigParamsSignID(pgpDigParams digp);
 
const char *pgpDigParamsUserID(pgpDigParams digp);
 
int pgpDigParamsVersion(pgpDigParams digp);
 
uint32_t pgpDigParamsCreationTime(pgpDigParams digp);
 
pgpDigParams pgpDigParamsFree(pgpDigParams digp);
 
rpmRC pgpVerifySignature(pgpDigParams key, pgpDigParams sig, DIGEST_CTX hashctx);
 
rpmRC pgpVerifySignature2(pgpDigParams key, pgpDigParams sig, DIGEST_CTX hashctx,
                          char **lints);
 
int pgpSignatureType(pgpDigParams sig);
 
char *pgpIdentItem(pgpDigParams digp);
 
#ifdef __cplusplus
}
#endif
 
#endif  /* H_RPMPGP */