rpm  4.14.2.1
rpmpgp.h
Go to the documentation of this file.
1 #ifndef H_RPMPGP
2 #define H_RPMPGP
3 
13 #include <string.h>
14 #include <stdio.h>
15 #include <stdlib.h>
16 #include <assert.h>
17 #include <rpm/rpmtypes.h>
18 #include <rpm/rpmstring.h>
19 
20 #ifdef __cplusplus
21 extern "C" {
22 #endif
23 
26 typedef struct DIGEST_CTX_s * DIGEST_CTX;
27 typedef struct rpmDigestBundle_s * rpmDigestBundle;
28 
31 typedef struct pgpDig_s * pgpDig;
32 
35 typedef struct pgpDigParams_s * pgpDigParams;
36 
37 typedef uint8_t pgpKeyID_t[8];
38 typedef uint8_t pgpTime_t[4];
39 
47 typedef enum pgpTag_e {
60  PGPTAG_TRUST = 12,
66  PGPTAG_MDC = 19,
71 } pgpTag;
72 
107 typedef struct pgpPktPubkey_s {
108  uint8_t version;
109  pgpKeyID_t keyid;
110  uint8_t algo;
111 } pgpPktPubkey;
112 
113 
120 typedef enum pgpSigType_e {
138 } pgpSigType;
139 
163 typedef enum pgpPubkeyAlgo_e {
173 } pgpPubkeyAlgo;
174 
199 typedef enum pgpSymkeyAlgo_e {
212 } pgpSymkeyAlgo;
213 
229 typedef enum pgpCompressAlgo_e {
235 
259 typedef enum pgpHashAlgo_e {
270 } pgpHashAlgo;
271 
293 typedef struct pgpPktSigV3_s {
294  uint8_t version;
295  uint8_t hashlen;
296  uint8_t sigtype;
297  pgpTime_t time;
298  pgpKeyID_t signid;
299  uint8_t pubkey_algo;
300  uint8_t hash_algo;
301  uint8_t signhash16[2];
302 } * pgpPktSigV3;
303 
325 typedef struct pgpPktSigV4_s {
326  uint8_t version;
327  uint8_t sigtype;
328  uint8_t pubkey_algo;
329  uint8_t hash_algo;
330  uint8_t hashlen[2];
331 } * pgpPktSigV4;
332 
399 typedef enum pgpSubType_e {
438 } pgpSubType;
439 
460 typedef union pgpPktSig_u {
461  struct pgpPktSigV3_s v3;
462  struct pgpPktSigV4_s v4;
463 } * pgpPktSig;
464 
493 typedef struct pgpPktSymkey_s {
494  uint8_t version;
495  uint8_t symkey_algo;
496  uint8_t s2k[1];
497 } pgpPktSymkey;
498 
528 typedef struct pgpPktOnepass_s {
529  uint8_t version;
530  uint8_t sigtype;
531  uint8_t hash_algo;
532  uint8_t pubkey_algo;
533  pgpKeyID_t signid;
534  uint8_t nested;
535 } * pgpPktOnepass;
536 
609 typedef struct pgpPktKeyV3_s {
610  uint8_t version;
611  pgpTime_t time;
612  uint8_t valid[2];
613  uint8_t pubkey_algo;
614 } * pgpPktKeyV3;
615 
647 typedef struct pgpPktKeyV4_s {
648  uint8_t version;
649  pgpTime_t time;
650  uint8_t pubkey_algo;
651 } * pgpPktKeyV4;
652 
717 typedef union pgpPktKey_u {
718  struct pgpPktKeyV3_s v3;
719  struct pgpPktKeyV4_s v4;
720 } pgpPktKey;
721 
722 /* \ingroup rpmpgp
723  * 5.6. Compressed Data Packet (Tag 8)
724  *
725  * The Compressed Data packet contains compressed data. Typically, this
726  * packet is found as the contents of an encrypted packet, or following
727  * a Signature or One-Pass Signature packet, and contains literal data
728  * packets.
729  *
730  * The body of this packet consists of:
731  * - One octet that gives the algorithm used to compress the packet.
732  * - The remainder of the packet is compressed data.
733  *
734  * A Compressed Data Packet's body contains an block that compresses
735  * some set of packets. See section "Packet Composition" for details on
736  * how messages are formed.
737  *
738  * ZIP-compressed packets are compressed with raw RFC 1951 DEFLATE
739  * blocks. Note that PGP V2.6 uses 13 bits of compression. If an
740  * implementation uses more bits of compression, PGP V2.6 cannot
741  * decompress it.
742  *
743  * ZLIB-compressed packets are compressed with RFC 1950 ZLIB-style
744  * blocks.
745  */
746 typedef struct pgpPktCdata_s {
747  uint8_t compressalgo;
748  uint8_t data[1];
749 } pgpPktCdata;
750 
751 /* \ingroup rpmpgp
752  * 5.7. Symmetrically Encrypted Data Packet (Tag 9)
753  *
754  * The Symmetrically Encrypted Data packet contains data encrypted with
755  * a symmetric-key algorithm. When it has been decrypted, it will
756  * typically contain other packets (often literal data packets or
757  * compressed data packets).
758  *
759  * The body of this packet consists of:
760  * - Encrypted data, the output of the selected symmetric-key cipher
761  * operating in PGP's variant of Cipher Feedback (CFB) mode.
762  *
763  * The symmetric cipher used may be specified in an Public-Key or
764  * Symmetric-Key Encrypted Session Key packet that precedes the
765  * Symmetrically Encrypted Data Packet. In that case, the cipher
766  * algorithm octet is prefixed to the session key before it is
767  * encrypted. If no packets of these types precede the encrypted data,
768  * the IDEA algorithm is used with the session key calculated as the MD5
769  * hash of the passphrase.
770  *
771  * The data is encrypted in CFB mode, with a CFB shift size equal to the
772  * cipher's block size. The Initial Vector (IV) is specified as all
773  * zeros. Instead of using an IV, OpenPGP prefixes a 10-octet string to
774  * the data before it is encrypted. The first eight octets are random,
775  * and the 9th and 10th octets are copies of the 7th and 8th octets,
776  * respectively. After encrypting the first 10 octets, the CFB state is
777  * resynchronized if the cipher block size is 8 octets or less. The
778  * last 8 octets of ciphertext are passed through the cipher and the
779  * block boundary is reset.
780  *
781  * The repetition of 16 bits in the 80 bits of random data prefixed to
782  * the message allows the receiver to immediately check whether the
783  * session key is incorrect.
784  */
785 typedef struct pgpPktEdata_s {
786  uint8_t data[1];
787 } pgpPktEdata;
788 
789 /* \ingroup rpmpgp
790  * 5.8. Marker Packet (Obsolete Literal Packet) (Tag 10)
791  *
792  * An experimental version of PGP used this packet as the Literal
793  * packet, but no released version of PGP generated Literal packets with
794  * this tag. With PGP 5.x, this packet has been re-assigned and is
795  * reserved for use as the Marker packet.
796  *
797  * The body of this packet consists of:
798  * - The three octets 0x50, 0x47, 0x50 (which spell "PGP" in UTF-8).
799  *
800  * Such a packet MUST be ignored when received. It may be placed at the
801  * beginning of a message that uses features not available in PGP 2.6.x
802  * in order to cause that version to report that newer software is
803  * necessary to process the message.
804  */
805 /* \ingroup rpmpgp
806  * 5.9. Literal Data Packet (Tag 11)
807  *
808  * A Literal Data packet contains the body of a message; data that is
809  * not to be further interpreted.
810  *
811  * The body of this packet consists of:
812  * - A one-octet field that describes how the data is formatted.
813  *
814  * If it is a 'b' (0x62), then the literal packet contains binary data.
815  * If it is a 't' (0x74), then it contains text data, and thus may need
816  * line ends converted to local form, or other text-mode changes. RFC
817  * 1991 also defined a value of 'l' as a 'local' mode for machine-local
818  * conversions. This use is now deprecated.
819  * - File name as a string (one-octet length, followed by file name),
820  * if the encrypted data should be saved as a file.
821  *
822  * If the special name "_CONSOLE" is used, the message is considered to
823  * be "for your eyes only". This advises that the message data is
824  * unusually sensitive, and the receiving program should process it more
825  * carefully, perhaps avoiding storing the received data to disk, for
826  * example.
827  * - A four-octet number that indicates the modification date of the
828  * file, or the creation time of the packet, or a zero that
829  * indicates the present time.
830  * - The remainder of the packet is literal data.
831  *
832  * Text data is stored with <CR><LF> text endings (i.e. network-normal
833  * line endings). These should be converted to native line endings by
834  * the receiving software.
835  */
836 typedef struct pgpPktLdata_s {
837  uint8_t format;
838  uint8_t filenamelen;
839  uint8_t filename[1];
840 } pgpPktLdata;
841 
842 /* \ingroup rpmpgp
843  * 5.10. Trust Packet (Tag 12)
844  *
845  * The Trust packet is used only within keyrings and is not normally
846  * exported. Trust packets contain data that record the user's
847  * specifications of which key holders are trustworthy introducers,
848  * along with other information that implementing software uses for
849  * trust information.
850  *
851  * Trust packets SHOULD NOT be emitted to output streams that are
852  * transferred to other users, and they SHOULD be ignored on any input
853  * other than local keyring files.
854  */
855 typedef struct pgpPktTrust_s {
856  uint8_t flag;
857 } pgpPktTrust;
858 
859 /* \ingroup rpmpgp
860  * 5.11. User ID Packet (Tag 13)
861  *
862  * A User ID packet consists of data that is intended to represent the
863  * name and email address of the key holder. By convention, it includes
864  * an RFC 822 mail name, but there are no restrictions on its content.
865  * The packet length in the header specifies the length of the user id.
866  * If it is text, it is encoded in UTF-8.
867  *
868  */
869 typedef struct pgpPktUid_s {
870  uint8_t userid[1];
871 } pgpPktUid;
872 
875 union pgpPktPre_u {
877  pgpPktSig sig;
880  pgpPktKey key;
887 };
888 
891 typedef enum pgpArmor_e {
899 #define PGPARMOR_ERROR PGPARMOR_ERR_NO_BEGIN_PGP
908 } pgpArmor;
909 
912 typedef enum pgpArmorKey_e {
918 } pgpArmorKey;
919 
920 typedef enum pgpValType_e {
931 } pgpValType;
932 
938 };
939 
941 
948 const char * pgpValString(pgpValType type, uint8_t val);
949 
956 static inline
957 unsigned int pgpGrab(const uint8_t *s, size_t nbytes)
958 {
959  unsigned int i = 0;
960  assert(nbytes <= sizeof(unsigned int));
961  size_t nb = (nbytes <= sizeof(i) ? nbytes : sizeof(i));
962  while (nb--)
963  i = (i << 8) | *s++;
964  return i;
965 }
966 
973 char * pgpHexStr(const uint8_t *p, size_t plen);
974 
983 int pgpPubkeyFingerprint(const uint8_t * pkt, size_t pktlen,
984  uint8_t **fp, size_t *fplen);
985 
993 int pgpPubkeyKeyID(const uint8_t * pkt, size_t pktlen, pgpKeyID_t keyid);
994 
1003 int pgpPrtParams(const uint8_t *pkts, size_t pktlen, unsigned int pkttype,
1004  pgpDigParams * ret);
1005 
1015 int pgpPrtParamsSubkeys(const uint8_t *pkts, size_t pktlen,
1016  pgpDigParams mainkey, pgpDigParams **subkeys,
1017  int *subkeysCount);
1026 int pgpPrtPkts(const uint8_t *pkts, size_t pktlen, pgpDig dig, int printing);
1027 
1035 pgpArmor pgpReadPkts(const char * fn, uint8_t ** pkt, size_t * pktlen);
1036 
1044 pgpArmor pgpParsePkts(const char *armor, uint8_t ** pkt, size_t * pktlen);
1045 
1058 int pgpPubKeyCertLen(const uint8_t *pkts, size_t pktslen, size_t *certlen);
1059 
1067 char * pgpArmorWrap(int atype, const unsigned char * s, size_t ns);
1068 
1073 pgpDig pgpNewDig(void);
1074 
1079 void pgpCleanDig(pgpDig dig);
1080 
1086 pgpDig pgpFreeDig(pgpDig dig);
1087 
1094 pgpDigParams pgpDigGetParams(pgpDig dig, unsigned int pkttype);
1095 
1102 int pgpDigParamsCmp(pgpDigParams p1, pgpDigParams p2);
1103 
1110 unsigned int pgpDigParamsAlgo(pgpDigParams digp, unsigned int algotype);
1111 
1117 pgpDigParams pgpDigParamsFree(pgpDigParams digp);
1118 
1126 rpmRC pgpVerifySignature(pgpDigParams key, pgpDigParams sig, DIGEST_CTX hashctx);
1127 
1136 rpmRC pgpVerifySig(pgpDig dig, DIGEST_CTX hashctx);
1137 
1143 char *pgpIdentItem(pgpDigParams digp);
1144 
1152 int rpmInitCrypto(void);
1153 
1157 int rpmFreeCrypto(void);
1158 
1164 DIGEST_CTX rpmDigestDup(DIGEST_CTX octx);
1165 
1171 size_t rpmDigestLength(int hashalgo);
1172 
1180 DIGEST_CTX rpmDigestInit(int hashalgo, rpmDigestFlags flags);
1181 
1189 int rpmDigestUpdate(DIGEST_CTX ctx, const void * data, size_t len);
1190 
1202 int rpmDigestFinal(DIGEST_CTX ctx,
1203  void ** datap,
1204  size_t * lenp, int asAscii);
1205 
1210 rpmDigestBundle rpmDigestBundleNew(void);
1211 
1217 rpmDigestBundle rpmDigestBundleFree(rpmDigestBundle bundle);
1218 
1227 int rpmDigestBundleAdd(rpmDigestBundle bundle, int algo,
1228  rpmDigestFlags flags);
1229 
1238 int rpmDigestBundleAddID(rpmDigestBundle bundle, int algo, int id,
1239  rpmDigestFlags flags);
1240 
1248 int rpmDigestBundleUpdate(rpmDigestBundle bundle, const void *data, size_t len);
1249 
1260 int rpmDigestBundleFinal(rpmDigestBundle bundle, int id,
1261  void ** datap, size_t * lenp, int asAscii);
1262 
1269 DIGEST_CTX rpmDigestBundleDupCtx(rpmDigestBundle bundle, int id);
1270 
1271 #ifdef __cplusplus
1272 }
1273 #endif
1274 
1275 #endif /* H_RPMPGP */
5.5.1.
Definition: rpmpgp.h:609
uint8_t hash_algo
Definition: rpmpgp.h:329
pgpArmor pgpParsePkts(const char *armor, uint8_t **pkt, size_t *pktlen)
Parse armored OpenPGP packets from memory.
enum pgpPubkeyAlgo_e pgpPubkeyAlgo
9.1.
pgpDig pgpNewDig(void)
Create a container for parsed OpenPGP packet(s).
uint8_t hash_algo
Definition: rpmpgp.h:531
struct pgpPktSigV4_s * pgpPktSigV4
5.2.3.
struct pgpPktPubkey_s pgpPktPubkey
5.1.
pgpPktCdata cdata
Definition: rpmpgp.h:881
uint8_t pubkey_algo
Definition: rpmpgp.h:650
struct pgpPktKeyV3_s * pgpPktKeyV3
5.5.1.
pgpValType_e
Definition: rpmpgp.h:920
enum pgpSymkeyAlgo_e pgpSymkeyAlgo
9.2.
pgpPktOnepass onepass
Definition: rpmpgp.h:879
pgpTime_t time
Definition: rpmpgp.h:649
int pgpDigParamsCmp(pgpDigParams p1, pgpDigParams p2)
Compare OpenPGP packet parameters param p1 1st parameter container param p2 2nd parameter container r...
pgpTag_e
4.3.
Definition: rpmpgp.h:47
pgpArmor pgpReadPkts(const char *fn, uint8_t **pkt, size_t *pktlen)
Parse armored OpenPGP packets from a file.
uint8_t version
Definition: rpmpgp.h:294
uint8_t version
Definition: rpmpgp.h:610
rpmDigestBundle rpmDigestBundleFree(rpmDigestBundle bundle)
Free a digest bundle and all contained digest contexts.
pgpPubkeyAlgo_e
9.1.
Definition: rpmpgp.h:163
uint8_t version
Definition: rpmpgp.h:529
struct pgpPktKeyV4_s * pgpPktKeyV4
The version 4 format is similar to the version 3 format except for the absence of a validity period...
int rpmDigestFinal(DIGEST_CTX ctx, void **datap, size_t *lenp, int asAscii)
Return digest and destroy context.
struct DIGEST_CTX_s * DIGEST_CTX
Definition: rpmpgp.h:26
5.2.3.
Definition: rpmpgp.h:325
enum pgpCompressAlgo_e pgpCompressAlgo
9.3.
DIGEST_CTX rpmDigestBundleDupCtx(rpmDigestBundle bundle, int id)
Duplicate a digest context from a bundle.
DIGEST_CTX rpmDigestInit(int hashalgo, rpmDigestFlags flags)
Initialize digest.
uint8_t version
Definition: rpmpgp.h:108
pgpPktSig sig
Definition: rpmpgp.h:877
enum pgpArmorKey_e pgpArmorKey
uint8_t version
Definition: rpmpgp.h:326
pgpArmorKey_e
Definition: rpmpgp.h:912
uint8_t pubkey_algo
Definition: rpmpgp.h:532
pgpDig pgpFreeDig(pgpDig dig)
Destroy a container for parsed OpenPGP packet(s).
uint8_t flag
Definition: rpmpgp.h:856
struct pgpDig_s * pgpDig
Definition: rpmpgp.h:31
rpmRC pgpVerifySignature(pgpDigParams key, pgpDigParams sig, DIGEST_CTX hashctx)
Verify a PGP signature.
5.2.2.
Definition: rpmpgp.h:293
int pgpPubkeyKeyID(const uint8_t *pkt, size_t pktlen, pgpKeyID_t keyid)
Calculate OpenPGP public key Key ID.
5.5.3.
Definition: rpmpgp.h:717
struct pgpPktTrust_s pgpPktTrust
struct pgpPktEdata_s pgpPktEdata
uint8_t pgpKeyID_t[8]
Definition: rpmpgp.h:37
int rpmDigestBundleFinal(rpmDigestBundle bundle, int id, void **datap, size_t *lenp, int asAscii)
Return digest from a bundle and destroy context, see rpmDigestFinal().
static unsigned int pgpGrab(const uint8_t *s, size_t nbytes)
Return (native-endian) integer from big-endian representation.
Definition: rpmpgp.h:957
struct rpmDigestBundle_s * rpmDigestBundle
Definition: rpmpgp.h:27
uint8_t pubkey_algo
Definition: rpmpgp.h:328
rpmFlags rpmDigestFlags
Definition: rpmpgp.h:940
uint32_t rpmFlags
Definition: rpmtypes.h:42
pgpArmor_e
Definition: rpmpgp.h:891
struct pgpPktLdata_s pgpPktLdata
pgpPktPubkey pubkey
Definition: rpmpgp.h:876
enum pgpHashAlgo_e pgpHashAlgo
9.4.
enum pgpValType_e pgpValType
uint8_t version
Definition: rpmpgp.h:494
struct pgpPktUid_s pgpPktUid
uint8_t symkey_algo
Definition: rpmpgp.h:495
int rpmDigestUpdate(DIGEST_CTX ctx, const void *data, size_t len)
Update context with next plain text buffer.
DIGEST_CTX rpmDigestDup(DIGEST_CTX octx)
Duplicate a digest context.
uint8_t format
Definition: rpmpgp.h:837
uint8_t sigtype
Definition: rpmpgp.h:327
uint8_t hash_algo
Definition: rpmpgp.h:300
char * pgpHexStr(const uint8_t *p, size_t plen)
Return hex formatted representation of bytes.
pgpPktKey key
Definition: rpmpgp.h:880
pgpDigParams pgpDigParamsFree(pgpDigParams digp)
Destroy parsed OpenPGP packet parameter(s).
rpmDigestFlags_e
Bit(s) to control digest operation.
Definition: rpmpgp.h:936
pgpDigParams pgpDigGetParams(pgpDig dig, unsigned int pkttype)
Retrieve parameters for parsed OpenPGP packet(s).
union pgpPktKey_u pgpPktKey
5.5.3.
struct pgpPktCdata_s pgpPktCdata
rpmRC pgpVerifySig(pgpDig dig, DIGEST_CTX hashctx)
Verify a PGP signature.
int rpmDigestBundleUpdate(rpmDigestBundle bundle, const void *data, size_t len)
Update contexts within bundle with next plain text buffer.
rpmDigestBundle rpmDigestBundleNew(void)
Create a new digest bundle.
int pgpPubkeyFingerprint(const uint8_t *pkt, size_t pktlen, uint8_t **fp, size_t *fplen)
Calculate OpenPGP public key fingerprint.
enum pgpSubType_e pgpSubType
5.2.3.1.
uint8_t algo
Definition: rpmpgp.h:110
pgpTime_t time
Definition: rpmpgp.h:611
pgpSubType_e
5.2.3.1.
Definition: rpmpgp.h:399
pgpPktLdata ldata
Definition: rpmpgp.h:884
char * pgpArmorWrap(int atype, const unsigned char *s, size_t ns)
Wrap a OpenPGP packets in ascii armor for transport.
uint8_t nested
Definition: rpmpgp.h:534
uint8_t compressalgo
Definition: rpmpgp.h:747
pgpHashAlgo_e
9.4.
Definition: rpmpgp.h:259
pgpTime_t time
Definition: rpmpgp.h:297
struct pgpPktSigV3_s * pgpPktSigV3
5.2.2.
pgpKeyID_t signid
Definition: rpmpgp.h:298
pgpPktUid uid
Definition: rpmpgp.h:886
enum pgpTag_e pgpTag
4.3.
uint8_t pgpTime_t[4]
Definition: rpmpgp.h:38
unsigned int pgpDigParamsAlgo(pgpDigParams digp, unsigned int algotype)
Retrieve OpenPGP algorithm parameters param digp parameter container param algotype PGPVAL_HASHALGO /...
uint8_t version
Definition: rpmpgp.h:648
uint8_t pubkey_algo
Definition: rpmpgp.h:613
int rpmDigestBundleAddID(rpmDigestBundle bundle, int algo, int id, rpmDigestFlags flags)
Add a new type of digest to a bundle.
int rpmInitCrypto(void)
Perform cryptography initialization.
char * pgpIdentItem(pgpDigParams digp)
Return a string identification of a PGP signature/pubkey.
pgpPktEdata edata
Definition: rpmpgp.h:882
pgpSigType_e
5.2.1.
Definition: rpmpgp.h:120
uint8_t hashlen
Definition: rpmpgp.h:295
pgpPktTrust tdata
Definition: rpmpgp.h:885
uint8_t pubkey_algo
Definition: rpmpgp.h:299
5.2.
Definition: rpmpgp.h:460
pgpKeyID_t keyid
Definition: rpmpgp.h:109
struct pgpDigParams_s * pgpDigParams
Definition: rpmpgp.h:35
int rpmFreeCrypto(void)
Shutdown cryptography.
int pgpPubKeyCertLen(const uint8_t *pkts, size_t pktslen, size_t *certlen)
Return a length of the first public key certificate in a buffer given by pkts that contains one or mo...
struct pgpPktSymkey_s pgpPktSymkey
5.3.
pgpSymkeyAlgo_e
9.2.
Definition: rpmpgp.h:199
int pgpPrtParamsSubkeys(const uint8_t *pkts, size_t pktlen, pgpDigParams mainkey, pgpDigParams **subkeys, int *subkeysCount)
Parse subkey parameters from OpenPGP packet(s).
const char * pgpValString(pgpValType type, uint8_t val)
Return string representation of am OpenPGP value.
enum pgpSigType_e pgpSigType
5.2.1.
int pgpPrtParams(const uint8_t *pkts, size_t pktlen, unsigned int pkttype, pgpDigParams *ret)
Parse a OpenPGP packet(s).
union pgpPktSig_u * pgpPktSig
5.2.
uint8_t sigtype
Definition: rpmpgp.h:296
int rpmDigestBundleAdd(rpmDigestBundle bundle, int algo, rpmDigestFlags flags)
Add a new type of digest to a bundle.
void pgpCleanDig(pgpDig dig)
Release (malloc&#39;d) data from container.
pgpCompressAlgo_e
9.3.
Definition: rpmpgp.h:229
int pgpPrtPkts(const uint8_t *pkts, size_t pktlen, pgpDig dig, int printing)
Print/parse a OpenPGP packet(s).
The version 4 format is similar to the version 3 format except for the absence of a validity period...
Definition: rpmpgp.h:647
uint8_t sigtype
Definition: rpmpgp.h:530
pgpKeyID_t signid
Definition: rpmpgp.h:533
enum pgpArmor_e pgpArmor
uint8_t filenamelen
Definition: rpmpgp.h:838
enum rpmRC_e rpmRC
Package read return codes.
size_t rpmDigestLength(int hashalgo)
Obtain digest length in bytes.
pgpPktSymkey symkey
Definition: rpmpgp.h:878
struct pgpPktOnepass_s * pgpPktOnepass
5.4.