rpm: rpmpgp.h Source File

rpm 4.11.1-rc1

- Main Page
- Related Pages
- Modules
- Data Structures
- Files

- File List
- Globals

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 <rpm/rpmtypes.h>
17 #include <rpm/rpmstring.h>
18
19 #ifdef __cplusplus
20 extern "C" {
21 #endif
22
25 typedef struct DIGEST_CTX_s * DIGEST_CTX;
26 typedef struct rpmDigestBundle_s * rpmDigestBundle;
27
30 typedef struct pgpDig_s * pgpDig;
31
34 typedef struct pgpDigParams_s * pgpDigParams;
35
36 typedef uint8_t pgpKeyID_t[8];
37 typedef uint8_t pgpTime_t[4];
38
46 typedef enum pgpTag_e {
47 PGPTAG_RESERVED = 0,
48 PGPTAG_PUBLIC_SESSION_KEY = 1,
49 PGPTAG_SIGNATURE = 2,
50 PGPTAG_SYMMETRIC_SESSION_KEY= 3,
51 PGPTAG_ONEPASS_SIGNATURE = 4,
52 PGPTAG_SECRET_KEY = 5,
53 PGPTAG_PUBLIC_KEY = 6,
54 PGPTAG_SECRET_SUBKEY = 7,
55 PGPTAG_COMPRESSED_DATA = 8,
56 PGPTAG_SYMMETRIC_DATA = 9,
57 PGPTAG_MARKER = 10,
58 PGPTAG_LITERAL_DATA = 11,
59 PGPTAG_TRUST = 12,
60 PGPTAG_USER_ID = 13,
61 PGPTAG_PUBLIC_SUBKEY = 14,
62 PGPTAG_COMMENT_OLD = 16,
63 PGPTAG_PHOTOID = 17,
64 PGPTAG_ENCRYPTED_MDC = 18,
65 PGPTAG_MDC = 19,
66 PGPTAG_PRIVATE_60 = 60,
67 PGPTAG_COMMENT = 61,
68 PGPTAG_PRIVATE_62 = 62,
69 PGPTAG_CONTROL = 63
70 } pgpTag;
71
106 typedef struct pgpPktPubkey_s {
107 uint8_t version;
108 pgpKeyID_t keyid;
109 uint8_t algo;
110 } pgpPktPubkey;
111
112
119 typedef enum pgpSigType_e {
120 PGPSIGTYPE_BINARY = 0x00,
121 PGPSIGTYPE_TEXT = 0x01,
122 PGPSIGTYPE_STANDALONE = 0x02,
123 PGPSIGTYPE_GENERIC_CERT = 0x10,
125 PGPSIGTYPE_PERSONA_CERT = 0x11,
127 PGPSIGTYPE_CASUAL_CERT = 0x12,
129 PGPSIGTYPE_POSITIVE_CERT = 0x13,
131 PGPSIGTYPE_SUBKEY_BINDING = 0x18,
132 PGPSIGTYPE_SIGNED_KEY = 0x1F,
133 PGPSIGTYPE_KEY_REVOKE = 0x20,
134 PGPSIGTYPE_SUBKEY_REVOKE = 0x28,
135 PGPSIGTYPE_CERT_REVOKE = 0x30,
136 PGPSIGTYPE_TIMESTAMP = 0x40
137 } pgpSigType;
138
162 typedef enum pgpPubkeyAlgo_e {
163 PGPPUBKEYALGO_RSA = 1,
164 PGPPUBKEYALGO_RSA_ENCRYPT = 2,
165 PGPPUBKEYALGO_RSA_SIGN = 3,
166 PGPPUBKEYALGO_ELGAMAL_ENCRYPT = 16,
167 PGPPUBKEYALGO_DSA = 17,
168 PGPPUBKEYALGO_EC = 18,
169 PGPPUBKEYALGO_ECDSA = 19,
170 PGPPUBKEYALGO_ELGAMAL = 20,
171 PGPPUBKEYALGO_DH = 21
172 } pgpPubkeyAlgo;
173
198 typedef enum pgpSymkeyAlgo_e {
199 PGPSYMKEYALGO_PLAINTEXT = 0,
200 PGPSYMKEYALGO_IDEA = 1,
201 PGPSYMKEYALGO_TRIPLE_DES = 2,
202 PGPSYMKEYALGO_CAST5 = 3,
203 PGPSYMKEYALGO_BLOWFISH = 4,
204 PGPSYMKEYALGO_SAFER = 5,
205 PGPSYMKEYALGO_DES_SK = 6,
206 PGPSYMKEYALGO_AES_128 = 7,
207 PGPSYMKEYALGO_AES_192 = 8,
208 PGPSYMKEYALGO_AES_256 = 9,
209 PGPSYMKEYALGO_TWOFISH = 10,
210 PGPSYMKEYALGO_NOENCRYPT = 110
211 } pgpSymkeyAlgo;
212
228 typedef enum pgpCompressAlgo_e {
229 PGPCOMPRESSALGO_NONE = 0,
230 PGPCOMPRESSALGO_ZIP = 1,
231 PGPCOMPRESSALGO_ZLIB = 2,
232 PGPCOMPRESSALGO_BZIP2 = 3
233 } pgpCompressAlgo;
234
256 typedef enum pgpHashAlgo_e {
257 PGPHASHALGO_MD5 = 1,
258 PGPHASHALGO_SHA1 = 2,
259 PGPHASHALGO_RIPEMD160 = 3,
260 PGPHASHALGO_MD2 = 5,
261 PGPHASHALGO_TIGER192 = 6,
262 PGPHASHALGO_HAVAL_5_160 = 7,
263 PGPHASHALGO_SHA256 = 8,
264 PGPHASHALGO_SHA384 = 9,
265 PGPHASHALGO_SHA512 = 10,
266 PGPHASHALGO_SHA224 = 11,
267 } pgpHashAlgo;
268
290 typedef struct pgpPktSigV3_s {
291 uint8_t version;
292 uint8_t hashlen;
293 uint8_t sigtype;
294 pgpTime_t time;
295 pgpKeyID_t signid;
296 uint8_t pubkey_algo;
297 uint8_t hash_algo;
298 uint8_t signhash16[2];
299 } * pgpPktSigV3;
300
322 typedef struct pgpPktSigV4_s {
323 uint8_t version;
324 uint8_t sigtype;
325 uint8_t pubkey_algo;
326 uint8_t hash_algo;
327 uint8_t hashlen[2];
328 } * pgpPktSigV4;
329
396 typedef enum pgpSubType_e {
397 PGPSUBTYPE_NONE = 0,
398 PGPSUBTYPE_SIG_CREATE_TIME = 2,
399 PGPSUBTYPE_SIG_EXPIRE_TIME = 3,
400 PGPSUBTYPE_EXPORTABLE_CERT = 4,
401 PGPSUBTYPE_TRUST_SIG = 5,
402 PGPSUBTYPE_REGEX = 6,
403 PGPSUBTYPE_REVOCABLE = 7,
404 PGPSUBTYPE_KEY_EXPIRE_TIME = 9,
405 PGPSUBTYPE_ARR = 10,
406 PGPSUBTYPE_PREFER_SYMKEY = 11,
407 PGPSUBTYPE_REVOKE_KEY = 12,
408 PGPSUBTYPE_ISSUER_KEYID = 16,
409 PGPSUBTYPE_NOTATION = 20,
410 PGPSUBTYPE_PREFER_HASH = 21,
411 PGPSUBTYPE_PREFER_COMPRESS = 22,
412 PGPSUBTYPE_KEYSERVER_PREFERS= 23,
413 PGPSUBTYPE_PREFER_KEYSERVER = 24,
414 PGPSUBTYPE_PRIMARY_USERID = 25,
415 PGPSUBTYPE_POLICY_URL = 26,
416 PGPSUBTYPE_KEY_FLAGS = 27,
417 PGPSUBTYPE_SIGNER_USERID = 28,
418 PGPSUBTYPE_REVOKE_REASON = 29,
419 PGPSUBTYPE_FEATURES = 30,
420 PGPSUBTYPE_EMBEDDED_SIG = 32,
422 PGPSUBTYPE_INTERNAL_100 = 100,
423 PGPSUBTYPE_INTERNAL_101 = 101,
424 PGPSUBTYPE_INTERNAL_102 = 102,
425 PGPSUBTYPE_INTERNAL_103 = 103,
426 PGPSUBTYPE_INTERNAL_104 = 104,
427 PGPSUBTYPE_INTERNAL_105 = 105,
428 PGPSUBTYPE_INTERNAL_106 = 106,
429 PGPSUBTYPE_INTERNAL_107 = 107,
430 PGPSUBTYPE_INTERNAL_108 = 108,
431 PGPSUBTYPE_INTERNAL_109 = 109,
432 PGPSUBTYPE_INTERNAL_110 = 110,
434 PGPSUBTYPE_CRITICAL = 128
435 } pgpSubType;
436
457 typedef union pgpPktSig_u {
458 struct pgpPktSigV3_s v3;
459 struct pgpPktSigV4_s v4;
460 } * pgpPktSig;
461
490 typedef struct pgpPktSymkey_s {
491 uint8_t version;
492 uint8_t symkey_algo;
493 uint8_t s2k[1];
494 } pgpPktSymkey;
495
525 typedef struct pgpPktOnepass_s {
526 uint8_t version;
527 uint8_t sigtype;
528 uint8_t hash_algo;
529 uint8_t pubkey_algo;
530 pgpKeyID_t signid;
531 uint8_t nested;
532 } * pgpPktOnepass;
533
606 typedef struct pgpPktKeyV3_s {
607 uint8_t version;
608 pgpTime_t time;
609 uint8_t valid[2];
610 uint8_t pubkey_algo;
611 } * pgpPktKeyV3;
612
644 typedef struct pgpPktKeyV4_s {
645 uint8_t version;
646 pgpTime_t time;
647 uint8_t pubkey_algo;
648 } * pgpPktKeyV4;
649
714 typedef union pgpPktKey_u {
715 struct pgpPktKeyV3_s v3;
716 struct pgpPktKeyV4_s v4;
717 } pgpPktKey;
718
719 /* \ingroup rpmpgp
720 * 5.6. Compressed Data Packet (Tag 8)
721 *
722 * The Compressed Data packet contains compressed data. Typically, this
723 * packet is found as the contents of an encrypted packet, or following
724 * a Signature or One-Pass Signature packet, and contains literal data
725 * packets.
726 *
727 * The body of this packet consists of:
728 * - One octet that gives the algorithm used to compress the packet.
729 * - The remainder of the packet is compressed data.
730 *
731 * A Compressed Data Packet's body contains an block that compresses
732 * some set of packets. See section "Packet Composition" for details on
733 * how messages are formed.
734 *
735 * ZIP-compressed packets are compressed with raw RFC 1951 DEFLATE
736 * blocks. Note that PGP V2.6 uses 13 bits of compression. If an
737 * implementation uses more bits of compression, PGP V2.6 cannot
738 * decompress it.
739 *
740 * ZLIB-compressed packets are compressed with RFC 1950 ZLIB-style
741 * blocks.
742 */
743 typedef struct pgpPktCdata_s {
744 uint8_t compressalgo;
745 uint8_t data[1];
746 } pgpPktCdata;
747
748 /* \ingroup rpmpgp
749 * 5.7. Symmetrically Encrypted Data Packet (Tag 9)
750 *
751 * The Symmetrically Encrypted Data packet contains data encrypted with
752 * a symmetric-key algorithm. When it has been decrypted, it will
753 * typically contain other packets (often literal data packets or
754 * compressed data packets).
755 *
756 * The body of this packet consists of:
757 * - Encrypted data, the output of the selected symmetric-key cipher
758 * operating in PGP's variant of Cipher Feedback (CFB) mode.
759 *
760 * The symmetric cipher used may be specified in an Public-Key or
761 * Symmetric-Key Encrypted Session Key packet that precedes the
762 * Symmetrically Encrypted Data Packet. In that case, the cipher
763 * algorithm octet is prefixed to the session key before it is
764 * encrypted. If no packets of these types precede the encrypted data,
765 * the IDEA algorithm is used with the session key calculated as the MD5
766 * hash of the passphrase.
767 *
768 * The data is encrypted in CFB mode, with a CFB shift size equal to the
769 * cipher's block size. The Initial Vector (IV) is specified as all
770 * zeros. Instead of using an IV, OpenPGP prefixes a 10-octet string to
771 * the data before it is encrypted. The first eight octets are random,
772 * and the 9th and 10th octets are copies of the 7th and 8th octets,
773 * respectively. After encrypting the first 10 octets, the CFB state is
774 * resynchronized if the cipher block size is 8 octets or less. The
775 * last 8 octets of ciphertext are passed through the cipher and the
776 * block boundary is reset.
777 *
778 * The repetition of 16 bits in the 80 bits of random data prefixed to
779 * the message allows the receiver to immediately check whether the
780 * session key is incorrect.
781 */
782 typedef struct pgpPktEdata_s {
783 uint8_t data[1];
784 } pgpPktEdata;
785
786 /* \ingroup rpmpgp
787 * 5.8. Marker Packet (Obsolete Literal Packet) (Tag 10)
788 *
789 * An experimental version of PGP used this packet as the Literal
790 * packet, but no released version of PGP generated Literal packets with
791 * this tag. With PGP 5.x, this packet has been re-assigned and is
792 * reserved for use as the Marker packet.
793 *
794 * The body of this packet consists of:
795 * - The three octets 0x50, 0x47, 0x50 (which spell "PGP" in UTF-8).
796 *
797 * Such a packet MUST be ignored when received. It may be placed at the
798 * beginning of a message that uses features not available in PGP 2.6.x
799 * in order to cause that version to report that newer software is
800 * necessary to process the message.
801 */
802 /* \ingroup rpmpgp
803 * 5.9. Literal Data Packet (Tag 11)
804 *
805 * A Literal Data packet contains the body of a message; data that is
806 * not to be further interpreted.
807 *
808 * The body of this packet consists of:
809 * - A one-octet field that describes how the data is formatted.
810 *
811 * If it is a 'b' (0x62), then the literal packet contains binary data.
812 * If it is a 't' (0x74), then it contains text data, and thus may need
813 * line ends converted to local form, or other text-mode changes. RFC
814 * 1991 also defined a value of 'l' as a 'local' mode for machine-local
815 * conversions. This use is now deprecated.
816 * - File name as a string (one-octet length, followed by file name),
817 * if the encrypted data should be saved as a file.
818 *
819 * If the special name "_CONSOLE" is used, the message is considered to
820 * be "for your eyes only". This advises that the message data is
821 * unusually sensitive, and the receiving program should process it more
822 * carefully, perhaps avoiding storing the received data to disk, for
823 * example.
824 * - A four-octet number that indicates the modification date of the
825 * file, or the creation time of the packet, or a zero that
826 * indicates the present time.
827 * - The remainder of the packet is literal data.
828 *
829 * Text data is stored with <CR><LF> text endings (i.e. network-normal
830 * line endings). These should be converted to native line endings by
831 * the receiving software.
832 */
833 typedef struct pgpPktLdata_s {
834 uint8_t format;
835 uint8_t filenamelen;
836 uint8_t filename[1];
837 } pgpPktLdata;
838
839 /* \ingroup rpmpgp
840 * 5.10. Trust Packet (Tag 12)
841 *
842 * The Trust packet is used only within keyrings and is not normally
843 * exported. Trust packets contain data that record the user's
844 * specifications of which key holders are trustworthy introducers,
845 * along with other information that implementing software uses for
846 * trust information.
847 *
848 * Trust packets SHOULD NOT be emitted to output streams that are
849 * transferred to other users, and they SHOULD be ignored on any input
850 * other than local keyring files.
851 */
852 typedef struct pgpPktTrust_s {
853 uint8_t flag;
854 } pgpPktTrust;
855
856 /* \ingroup rpmpgp
857 * 5.11. User ID Packet (Tag 13)
858 *
859 * A User ID packet consists of data that is intended to represent the
860 * name and email address of the key holder. By convention, it includes
861 * an RFC 822 mail name, but there are no restrictions on its content.
862 * The packet length in the header specifies the length of the user id.
863 * If it is text, it is encoded in UTF-8.
864 *
865 */
866 typedef struct pgpPktUid_s {
867 uint8_t userid[1];
868 } pgpPktUid;
869
872 union pgpPktPre_u {
873 pgpPktPubkey pubkey;
874 pgpPktSig sig;
875 pgpPktSymkey symkey;
876 pgpPktOnepass onepass;
877 pgpPktKey key;
878 pgpPktCdata cdata;
879 pgpPktEdata edata;
881 pgpPktLdata ldata;
882 pgpPktTrust tdata;
883 pgpPktUid uid;
884 };
885
888 typedef enum pgpArmor_e {
889 PGPARMOR_ERR_CRC_CHECK = -7,
890 PGPARMOR_ERR_BODY_DECODE = -6,
891 PGPARMOR_ERR_CRC_DECODE = -5,
892 PGPARMOR_ERR_NO_END_PGP = -4,
893 PGPARMOR_ERR_UNKNOWN_PREAMBLE_TAG = -3,
894 PGPARMOR_ERR_UNKNOWN_ARMOR_TYPE = -2,
895 PGPARMOR_ERR_NO_BEGIN_PGP = -1,
896 #define PGPARMOR_ERROR PGPARMOR_ERR_NO_BEGIN_PGP
897 PGPARMOR_NONE = 0,
898 PGPARMOR_MESSAGE = 1,
899 PGPARMOR_PUBKEY = 2,
900 PGPARMOR_SIGNATURE = 3,
901 PGPARMOR_SIGNED_MESSAGE = 4,
902 PGPARMOR_FILE = 5,
903 PGPARMOR_PRIVKEY = 6,
904 PGPARMOR_SECKEY = 7
905 } pgpArmor;
906
909 typedef enum pgpArmorKey_e {
910 PGPARMORKEY_VERSION = 1,
911 PGPARMORKEY_COMMENT = 2,
912 PGPARMORKEY_MESSAGEID = 3,
913 PGPARMORKEY_HASH = 4,
914 PGPARMORKEY_CHARSET = 5
915 } pgpArmorKey;
916
917 typedef enum pgpValType_e {
918 PGPVAL_TAG = 1,
919 PGPVAL_ARMORBLOCK = 2,
920 PGPVAL_ARMORKEY = 3,
921 PGPVAL_SIGTYPE = 4,
922 PGPVAL_SUBTYPE = 5,
923 PGPVAL_PUBKEYALGO = 6,
924 PGPVAL_SYMKEYALGO = 7,
925 PGPVAL_COMPRESSALGO = 8,
926 PGPVAL_HASHALGO = 9,
927 PGPVAL_SERVERPREFS = 10,
928 } pgpValType;
929
933 enum rpmDigestFlags_e {
934 RPMDIGEST_NONE = 0
935 };
936
937 typedef rpmFlags rpmDigestFlags;
938
945 const char * pgpValString(pgpValType type, uint8_t val);
946
953 static inline
954 unsigned int pgpGrab(const uint8_t *s, size_t nbytes)
955 {
956 size_t i = 0;
957 size_t nb = (nbytes <= sizeof(i) ? nbytes : sizeof(i));
958 while (nb--)
959 i = (i << 8) | *s++;
960 return i;
961 }
962
969 char * pgpHexStr(const uint8_t *p, size_t plen);
970
979 int pgpPubkeyFingerprint(const uint8_t * pkt, size_t pktlen,
980 pgpKeyID_t keyid);
981
989 int pgpExtractPubkeyFingerprint(const char * b64pkt, pgpKeyID_t keyid);
990
999 int pgpPrtParams(const uint8_t *pkts, size_t pktlen, unsigned int pkttype,
1000 pgpDigParams * ret);
1001
1010 int pgpPrtPkts(const uint8_t *pkts, size_t pktlen, pgpDig dig, int printing);
1011
1019 pgpArmor pgpReadPkts(const char * fn, uint8_t ** pkt, size_t * pktlen);
1020
1028 pgpArmor pgpParsePkts(const char *armor, uint8_t ** pkt, size_t * pktlen);
1029
1037 char * pgpArmorWrap(int atype, const unsigned char * s, size_t ns);
1038
1043 pgpDig pgpNewDig(void);
1044
1049 void pgpCleanDig(pgpDig dig);
1050
1056 pgpDig pgpFreeDig(pgpDig dig);
1057
1064 pgpDigParams pgpDigGetParams(pgpDig dig, unsigned int pkttype);
1065
1072 int pgpDigParamsCmp(pgpDigParams p1, pgpDigParams p2);
1073
1080 unsigned int pgpDigParamsAlgo(pgpDigParams digp, unsigned int algotype);
1081
1087 pgpDigParams pgpDigParamsFree(pgpDigParams digp);
1088
1096 rpmRC pgpVerifySignature(pgpDigParams key, pgpDigParams sig, DIGEST_CTX hashctx);
1097
1106 rpmRC pgpVerifySig(pgpDig dig, DIGEST_CTX hashctx);
1107
1113 char *pgpIdentItem(pgpDigParams digp);
1114
1122 int rpmInitCrypto(void);
1123
1127 int rpmFreeCrypto(void);
1128
1134 DIGEST_CTX rpmDigestDup(DIGEST_CTX octx);
1135
1141 size_t rpmDigestLength(int hashalgo);
1142
1150 DIGEST_CTX rpmDigestInit(int hashalgo, rpmDigestFlags flags);
1151
1159 int rpmDigestUpdate(DIGEST_CTX ctx, const void * data, size_t len);
1160
1172 int rpmDigestFinal(DIGEST_CTX ctx,
1173 void ** datap,
1174 size_t * lenp, int asAscii);
1175
1180 rpmDigestBundle rpmDigestBundleNew(void);
1181
1187 rpmDigestBundle rpmDigestBundleFree(rpmDigestBundle bundle);
1188
1196 int rpmDigestBundleAdd(rpmDigestBundle bundle, int algo,
1197 rpmDigestFlags flags);
1198
1206 int rpmDigestBundleUpdate(rpmDigestBundle bundle, const void *data, size_t len);
1207
1218 int rpmDigestBundleFinal(rpmDigestBundle bundle,
1219 int algo, void ** datap, size_t * lenp, int asAscii);
1220
1227 DIGEST_CTX rpmDigestBundleDupCtx(rpmDigestBundle bundle, int algo);
1228
1229 #ifdef __cplusplus
1230 }
1231 #endif
1232
1233 #endif /* H_RPMPGP */