scd: KEYINFO: Send LF for --data.
[gnupg.git] / g10 / packet.h
1 /* packet.h - OpenPGP packet definitions
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
3  *               2007 Free Software Foundation, Inc.
4  * Copyright (C) 2015 g10 Code GmbH
5  *
6  * This file is part of GnuPG.
7  *
8  * GnuPG is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * GnuPG is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, see <https://www.gnu.org/licenses/>.
20  */
21
22 #ifndef G10_PACKET_H
23 #define G10_PACKET_H
24
25 #include "../common/types.h"
26 #include "../common/iobuf.h"
27 #include "../common/strlist.h"
28 #include "dek.h"
29 #include "filter.h"
30 #include "../common/openpgpdefs.h"
31 #include "../common/userids.h"
32 #include "../common/util.h"
33
34 #define DEBUG_PARSE_PACKET 1
35
36 /* Maximum length of packets to avoid excessive memory allocation.  */
37 #define MAX_KEY_PACKET_LENGTH     (256 * 1024)
38 #define MAX_UID_PACKET_LENGTH     (  2 * 1024)
39 #define MAX_COMMENT_PACKET_LENGTH ( 64 * 1024)
40 #define MAX_ATTR_PACKET_LENGTH    ( 16 * 1024*1024)
41
42 /* Constants to allocate static MPI arrays.  */
43 #define PUBKEY_MAX_NPKEY  OPENPGP_MAX_NPKEY
44 #define PUBKEY_MAX_NSKEY  OPENPGP_MAX_NSKEY
45 #define PUBKEY_MAX_NSIG   OPENPGP_MAX_NSIG
46 #define PUBKEY_MAX_NENC   OPENPGP_MAX_NENC
47
48 /* Usage flags */
49 #define PUBKEY_USAGE_SIG     GCRY_PK_USAGE_SIGN  /* Good for signatures. */
50 #define PUBKEY_USAGE_ENC     GCRY_PK_USAGE_ENCR  /* Good for encryption. */
51 #define PUBKEY_USAGE_CERT    GCRY_PK_USAGE_CERT  /* Also good to certify keys.*/
52 #define PUBKEY_USAGE_AUTH    GCRY_PK_USAGE_AUTH  /* Good for authentication. */
53 #define PUBKEY_USAGE_UNKNOWN GCRY_PK_USAGE_UNKN  /* Unknown usage flag. */
54 #define PUBKEY_USAGE_NONE    256                 /* No usage given. */
55 #if  (GCRY_PK_USAGE_SIGN | GCRY_PK_USAGE_ENCR | GCRY_PK_USAGE_CERT \
56       | GCRY_PK_USAGE_AUTH | GCRY_PK_USAGE_UNKN) >= 256
57 # error Please choose another value for PUBKEY_USAGE_NONE
58 #endif
59
60 /* Helper macros.  */
61 #define is_RSA(a)     ((a)==PUBKEY_ALGO_RSA || (a)==PUBKEY_ALGO_RSA_E \
62                        || (a)==PUBKEY_ALGO_RSA_S )
63 #define is_ELGAMAL(a) ((a)==PUBKEY_ALGO_ELGAMAL_E)
64 #define is_DSA(a)     ((a)==PUBKEY_ALGO_DSA)
65
66 /* A pointer to the packet object.  */
67 typedef struct packet_struct PACKET;
68
69 /* PKT_GPG_CONTROL types */
70 typedef enum {
71     CTRLPKT_CLEARSIGN_START = 1,
72     CTRLPKT_PIPEMODE = 2,
73     CTRLPKT_PLAINTEXT_MARK =3
74 } ctrlpkttype_t;
75
76 typedef enum {
77     PREFTYPE_NONE = 0,
78     PREFTYPE_SYM = 1,
79     PREFTYPE_HASH = 2,
80     PREFTYPE_ZIP = 3,
81     PREFTYPE_AEAD = 4
82 } preftype_t;
83
84 typedef struct {
85     byte type;
86     byte value;
87 } prefitem_t;
88
89 /* A string-to-key specifier as defined in RFC 4880, Section 3.7.  */
90 typedef struct
91 {
92   int  mode;      /* Must be an integer due to the GNU modes 1001 et al.  */
93   byte hash_algo;
94   byte salt[8];
95   /* The *coded* (i.e., the serialized version) iteration count.  */
96   u32  count;
97 } STRING2KEY;
98
99 /* A symmetric-key encrypted session key packet as defined in RFC
100    4880, Section 5.3.  All fields are serialized.  */
101 typedef struct {
102   /* We support version 4 (rfc4880) and 5 (rfc4880bis).  */
103   byte version;
104   /* The cipher algorithm used to encrypt the session key.  Note that
105    * this may be different from the algorithm that is used to encrypt
106    * bulk data.  */
107   byte cipher_algo;
108   /* The AEAD algorithm or 0 for CFB encryption.  */
109   byte aead_algo;
110   /* The string-to-key specifier.  */
111   STRING2KEY s2k;
112   /* The length of SESKEY in bytes or 0 if this packet does not
113      encrypt a session key.  (In the latter case, the results of the
114      S2K function on the password is the session key. See RFC 4880,
115      Section 5.3.)  */
116   byte seskeylen;
117   /* The session key as encrypted by the S2K specifier.  For AEAD this
118    * includes the nonce and the authentication tag.  */
119   byte seskey[1];
120 } PKT_symkey_enc;
121
122 /* A public-key encrypted session key packet as defined in RFC 4880,
123    Section 5.1.  All fields are serialized.  */
124 typedef struct {
125   /* The 64-bit keyid.  */
126   u32     keyid[2];
127   /* The packet's version.  Currently, only version 3 is defined.  */
128   byte    version;
129   /* The algorithm used for the public key encryption scheme.  */
130   byte    pubkey_algo;
131   /* Whether to hide the key id.  This value is not directly
132      serialized.  */
133   byte    throw_keyid;
134   /* The session key.  */
135   gcry_mpi_t     data[PUBKEY_MAX_NENC];
136 } PKT_pubkey_enc;
137
138
139 /* An object to build a list of public-key encrypted session key.  */
140 struct pubkey_enc_list
141 {
142   struct pubkey_enc_list *next;
143   u32 keyid[2];
144   int pubkey_algo;
145   int result;
146   gcry_mpi_t data[PUBKEY_MAX_NENC];
147 };
148
149
150 /* A one-pass signature packet as defined in RFC 4880, Section
151    5.4.  All fields are serialized.  */
152 typedef struct {
153     u32     keyid[2];       /* The 64-bit keyid */
154     /* The signature's classification (RFC 4880, Section 5.2.1).  */
155     byte    sig_class;
156     byte    digest_algo;    /* algorithm used for digest */
157     byte    pubkey_algo;    /* algorithm used for public key scheme */
158     /* A message can be signed by multiple keys.  In this case, there
159        are n one-pass signature packets before the message to sign and
160        n signatures packets after the message.  It is conceivable that
161        someone wants to not only sign the message, but all of the
162        signatures.  Now we need to distinguish between signing the
163        message and signing the message plus the surrounding
164        signatures.  This is the point of this flag.  If set, it means:
165        I sign all of the data starting at the next packet.  */
166     byte    last;
167 } PKT_onepass_sig;
168
169
170 /* A v4 OpenPGP signature has a hashed and unhashed area containing
171    co-called signature subpackets (RFC 4880, Section 5.2.3).  These
172    areas are described by this data structure.  Use enum_sig_subpkt to
173    parse this area.  */
174 typedef struct {
175     size_t size;  /* allocated */
176     size_t len;   /* used (serialized) */
177     byte data[1]; /* the serialized subpackes (serialized) */
178 } subpktarea_t;
179
180 /* The in-memory representation of a designated revoker signature
181    subpacket (RFC 4880, Section 5.2.3.15).  */
182 struct revocation_key {
183   /* A bit field.  0x80 must be set.  0x40 means this information is
184      sensitive (and should not be uploaded to a keyserver by
185      default).  */
186   byte class;
187   /* The public-key algorithm ID.  */
188   byte algid;
189   /* The length of the fingerprint.  */
190   byte fprlen;
191   /* The fingerprint of the authorized key.  */
192   byte fpr[MAX_FINGERPRINT_LEN];
193 };
194
195
196 /* Object to keep information about a PKA DNS record. */
197 typedef struct
198 {
199   int valid;    /* An actual PKA record exists for EMAIL. */
200   int checked;  /* Set to true if the FPR has been checked against the
201                    actual key. */
202   char *uri;    /* Malloced string with the URI. NULL if the URI is
203                    not available.*/
204   unsigned char fpr[20]; /* The fingerprint as stored in the PKA RR. */
205   char email[1];/* The email address from the notation data. */
206 } pka_info_t;
207
208
209 /* A signature packet (RFC 4880, Section 5.2).  Only a subset of these
210    fields are directly serialized (these are marked as such); the rest
211    are read from the subpackets, which are not synthesized when
212    serializing this data structure (i.e., when using build_packet()).
213    Instead, the subpackets must be created by hand.  */
214 typedef struct
215 {
216   struct
217   {
218     unsigned checked:1;         /* Signature has been checked. */
219     unsigned valid:1;           /* Signature is good (if checked is set). */
220     unsigned chosen_selfsig:1;  /* A selfsig that is the chosen one. */
221     unsigned unknown_critical:1;
222     unsigned exportable:1;
223     unsigned revocable:1;
224     unsigned policy_url:1;  /* At least one policy URL is present */
225     unsigned notation:1;    /* At least one notation is present */
226     unsigned pref_ks:1;     /* At least one preferred keyserver is present */
227     unsigned expired:1;
228     unsigned pka_tried:1;   /* Set if we tried to retrieve the PKA record. */
229   } flags;
230   /* The key that allegedly generated this signature.  (Directly
231      serialized in v3 sigs; for v4 sigs, this must be explicitly added
232      as an issuer subpacket (5.2.3.5.)  */
233   u32     keyid[2];
234   /* When the signature was made (seconds since the Epoch).  (Directly
235      serialized in v3 sigs; for v4 sigs, this must be explicitly added
236      as a signature creation time subpacket (5.2.3.4).)  */
237   u32     timestamp;
238   u32     expiredate;     /* Expires at this date or 0 if not at all. */
239   /* The serialization format used / to use.  If 0, then defaults to
240      version 3.  (Serialized.)  */
241   byte    version;
242   /* The signature type. (See RFC 4880, Section 5.2.1.)  */
243   byte    sig_class;
244   /* Algorithm used for public key scheme (e.g., PUBKEY_ALGO_RSA).
245      (Serialized.)  */
246   byte    pubkey_algo;
247   /* Algorithm used for digest (e.g., DIGEST_ALGO_SHA1).
248      (Serialized.)  */
249   byte    digest_algo;
250   byte    trust_depth;
251   byte    trust_value;
252   const byte *trust_regexp;
253   struct revocation_key *revkey;
254   int numrevkeys;
255   int help_counter;          /* Used internally bu some functions.  */
256   pka_info_t *pka_info;      /* Malloced PKA data or NULL if not
257                                 available.  See also flags.pka_tried. */
258   char *signers_uid;         /* Malloced value of the SIGNERS_UID
259                               * subpacket or NULL.  This string has
260                               * already been sanitized.  */
261   subpktarea_t *hashed;      /* All subpackets with hashed data (v4 only). */
262   subpktarea_t *unhashed;    /* Ditto for unhashed data. */
263   /* First 2 bytes of the digest.  (Serialized.  Note: this is not
264      automatically filled in when serializing a signature!)  */
265   byte digest_start[2];
266   /* The signature.  (Serialized.)  */
267   gcry_mpi_t  data[PUBKEY_MAX_NSIG];
268   /* The message digest and its length (in bytes).  Note the maximum
269      digest length is 512 bits (64 bytes).  If DIGEST_LEN is 0, then
270      the digest's value has not been saved here.  */
271   byte digest[512 / 8];
272   int digest_len;
273 } PKT_signature;
274
275 #define ATTRIB_IMAGE 1
276
277 /* This is the cooked form of attributes.  */
278 struct user_attribute {
279   byte type;
280   const byte *data;
281   u32 len;
282 };
283
284
285 /* A user id (RFC 4880, Section 5.11) or a user attribute packet (RFC
286    4880, Section 5.12).  Only a subset of these fields are directly
287    serialized (these are marked as such); the rest are read from the
288    self-signatures in merge_keys_and_selfsig()).  */
289 typedef struct
290 {
291   int ref;              /* reference counter */
292   /* The length of NAME.  */
293   int len;
294   struct user_attribute *attribs;
295   int numattribs;
296   /* If this is not NULL, the packet is a user attribute rather than a
297      user id (See RFC 4880 5.12).  (Serialized.)  */
298   byte *attrib_data;
299   /* The length of ATTRIB_DATA.  */
300   unsigned long attrib_len;
301   byte *namehash;
302   int help_key_usage;
303   u32 help_key_expire;
304   int help_full_count;
305   int help_marginal_count;
306   u32 expiredate;       /* expires at this date or 0 if not at all */
307   prefitem_t *prefs;    /* list of preferences (may be NULL)*/
308   u32 created;          /* according to the self-signature */
309   u32 keyupdate;        /* From the ring trust packet.  */
310   char *updateurl;      /* NULL or the URL of the last update origin.  */
311   byte keyorg;          /* From the ring trust packet.  */
312   byte selfsigversion;
313   struct
314   {
315     unsigned int mdc:1;
316     unsigned int aead:1;
317     unsigned int ks_modify:1;
318     unsigned int compacted:1;
319     unsigned int primary:2; /* 2 if set via the primary flag, 1 if calculated */
320     unsigned int revoked:1;
321     unsigned int expired:1;
322   } flags;
323
324   char *mbox;   /* NULL or the result of mailbox_from_userid.  */
325
326   /* The text contained in the user id packet, which is normally the
327    * name and email address of the key holder (See RFC 4880 5.11).
328    * (Serialized.). For convenience an extra Nul is always appended.  */
329   char name[1];
330 } PKT_user_id;
331
332
333
334 struct revoke_info
335 {
336   /* revoked at this date */
337   u32 date;
338   /* the keyid of the revoking key (selfsig or designated revoker) */
339   u32 keyid[2];
340   /* the algo of the revoking key */
341   byte algo;
342 };
343
344
345 /* Information pertaining to secret keys. */
346 struct seckey_info
347 {
348   int is_protected:1;   /* The secret info is protected and must */
349                         /* be decrypted before use, the protected */
350                         /* MPIs are simply (void*) pointers to memory */
351                         /* and should never be passed to a mpi_xxx() */
352   int sha1chk:1;        /* SHA1 is used instead of a 16 bit checksum */
353   u16 csum;             /* Checksum for old protection modes.  */
354   byte algo;            /* Cipher used to protect the secret information. */
355   STRING2KEY s2k;       /* S2K parameter.  */
356   byte ivlen;           /* Used length of the IV.  */
357   byte iv[16];          /* Initialization vector for CFB mode.  */
358 };
359
360
361 /****************
362  * The in-memory representation of a public key (RFC 4880, Section
363  * 5.5).  Note: this structure contains significantly more information
364  * than is contained in an OpenPGP public key packet.  This
365  * information is derived from the self-signed signatures (by
366  * merge_keys_and_selfsig()) and is ignored when serializing the
367  * packet.  The fields that are actually written out when serializing
368  * this packet are marked as accordingly.
369  *
370  * We assume that secret keys have the same number of parameters as
371  * the public key and that the public parameters are the first items
372  * in the PKEY array.  Thus NPKEY is always less than NSKEY and it is
373  * possible to compare the secret and public keys by comparing the
374  * first NPKEY elements of the PKEY array.  Note that since GnuPG 2.1
375  * we don't use secret keys anymore directly because they are managed
376  * by gpg-agent.  However for parsing OpenPGP key files we need a way
377  * to temporary store those secret keys.  We do this by putting them
378  * into the public key structure and extending the PKEY field to NSKEY
379  * elements; the extra secret key information are stored in the
380  * SECKEY_INFO field.
381  */
382 typedef struct
383 {
384   /* When the key was created.  (Serialized.)  */
385   u32     timestamp;
386   u32     expiredate;     /* expires at this date or 0 if not at all */
387   u32     max_expiredate; /* must not expire past this date */
388   struct revoke_info revoked;
389   /* An OpenPGP packet consists of a header and a body.  This is the
390      size of the header.  If this is 0, an appropriate size is
391      automatically chosen based on the size of the body.
392      (Serialized.)  */
393   byte    hdrbytes;
394   /* The serialization format.  If 0, the default version (4) is used
395      when serializing.  (Serialized.)  */
396   byte    version;
397   byte    selfsigversion; /* highest version of all of the self-sigs */
398   /* The public key algorithm.  (Serialized.)  */
399   byte    pubkey_algo;
400   byte    pubkey_usage;   /* for now only used to pass it to getkey() */
401   byte    req_usage;      /* hack to pass a request to getkey() */
402   byte    fprlen;         /* 0 or length of FPR.  */
403   u32     has_expired;    /* set to the expiration date if expired */
404   /* keyid of the primary key.  Never access this value directly.
405      Instead, use pk_main_keyid().  */
406   u32     main_keyid[2];
407   /* keyid of this key.  Never access this value directly!  Instead,
408      use pk_keyid().  */
409   u32     keyid[2];
410   /* Fingerprint of the key.  Only valid if FPRLEN is not 0.  */
411   byte    fpr[MAX_FINGERPRINT_LEN];
412   prefitem_t *prefs;      /* list of preferences (may be NULL) */
413   struct
414   {
415     unsigned int mdc:1;           /* MDC feature set.  */
416     unsigned int aead:1;          /* AEAD feature set.  */
417     unsigned int disabled_valid:1;/* The next flag is valid.  */
418     unsigned int disabled:1;      /* The key has been disabled.  */
419     unsigned int primary:1;       /* This is a primary key.  */
420     unsigned int revoked:2;       /* Key has been revoked.
421                                      1 = revoked by the owner
422                                      2 = revoked by designated revoker.  */
423     unsigned int maybe_revoked:1; /* A designated revocation is
424                                      present, but without the key to
425                                      check it.  */
426     unsigned int valid:1;         /* Key (especially subkey) is valid.  */
427     unsigned int dont_cache:1;    /* Do not cache this key.  */
428     unsigned int backsig:2;       /* 0=none, 1=bad, 2=good.  */
429     unsigned int serialno_valid:1;/* SERIALNO below is valid.  */
430     unsigned int exact:1;         /* Found via exact (!) search.  */
431   } flags;
432   PKT_user_id *user_id;   /* If != NULL: found by that uid. */
433   struct revocation_key *revkey;
434   int     numrevkeys;
435   u32     trust_timestamp;
436   byte    trust_depth;
437   byte    trust_value;
438   byte    keyorg;         /* From the ring trust packet.  */
439   u32     keyupdate;      /* From the ring trust packet.  */
440   char    *updateurl;     /* NULL or the URL of the last update origin.  */
441   const byte *trust_regexp;
442   char    *serialno;      /* Malloced hex string or NULL if it is
443                              likely not on a card.  See also
444                              flags.serialno_valid.  */
445   /* If not NULL this malloced structure describes a secret key.
446      (Serialized.)  */
447   struct seckey_info *seckey_info;
448   /* The public key.  Contains pubkey_get_npkey (pubkey_algo) +
449      pubkey_get_nskey (pubkey_algo) MPIs.  (If pubkey_get_npkey
450      returns 0, then the algorithm is not understood and the PKEY
451      contains a single opaque MPI.)  (Serialized.)  */
452   gcry_mpi_t  pkey[PUBKEY_MAX_NSKEY]; /* Right, NSKEY elements.  */
453 } PKT_public_key;
454
455 /* Evaluates as true if the pk is disabled, and false if it isn't.  If
456    there is no disable value cached, fill one in. */
457 #define pk_is_disabled(a)                                       \
458   (((a)->flags.disabled_valid)?                                 \
459    ((a)->flags.disabled):(cache_disabled_value(ctrl,(a))))
460
461
462 typedef struct {
463     int  len;             /* length of data */
464     char data[1];
465 } PKT_comment;
466
467 /* A compression packet (RFC 4880, Section 5.6).  */
468 typedef struct {
469   /* Not used.  */
470   u32 len;
471   /* Whether the serialized version of the packet used / should use
472      the new format.  */
473   byte  new_ctb;
474   /* The compression algorithm.  */
475   byte  algorithm;
476   /* An iobuf holding the data to be decompressed.  (This is not used
477      for compression!)  */
478   iobuf_t buf;
479 } PKT_compressed;
480
481 /* A symmetrically encrypted data packet (RFC 4880, Section 5.7) or a
482    symmetrically encrypted integrity protected data packet (Section
483    5.13) */
484 typedef struct {
485   /* Remaining length of encrypted data. */
486   u32  len;
487   /* When encrypting in CFB mode, the first block size bytes of data
488    * are random data and the following 2 bytes are copies of the last
489    * two bytes of the random data (RFC 4880, Section 5.7).  This
490    * provides a simple check that the key is correct.  EXTRALEN is the
491    * size of this extra data or, in AEAD mode, the length of the
492    * headers and the tags.  This is used by build_packet when writing
493    * out the packet's header. */
494   int  extralen;
495   /* Whether the serialized version of the packet used / should use
496      the new format.  */
497   byte new_ctb;
498   /* Whether the packet has an indeterminate length (old format) or
499      was encoded using partial body length headers (new format).
500      Note: this is ignored when encrypting.  */
501   byte is_partial;
502   /* If 0, MDC is disabled.  Otherwise, the MDC method that was used
503      (only DIGEST_ALGO_SHA1 has ever been defined).  */
504   byte mdc_method;
505   /* If 0, AEAD is not used.  Otherwise, the used AEAD algorithm.
506    * MDC_METHOD (above) shall be zero if AEAD is used.  */
507   byte aead_algo;
508   /* The cipher algo for/from the AEAD packet.  0 for other encryption
509    * packets. */
510   byte cipher_algo;
511   /* The chunk byte from the AEAD packet.  */
512   byte chunkbyte;
513
514   /* An iobuf holding the data to be decrypted.  (This is not used for
515      encryption!)  */
516   iobuf_t buf;
517 } PKT_encrypted;
518
519 typedef struct {
520     byte hash[20];
521 } PKT_mdc;
522
523
524 /* Subtypes for the ring trust packet.  */
525 #define RING_TRUST_SIG 0  /* The classical signature cache.  */
526 #define RING_TRUST_KEY 1  /* A KEYORG on a primary key.      */
527 #define RING_TRUST_UID 2  /* A KEYORG on a user id.          */
528
529 /* The local only ring trust packet which OpenPGP declares as
530  * implementation defined.  GnuPG uses this to cache signature
531  * verification status and since 2.1.18 also to convey information
532  * about the origin of a key.  Note that this packet is not part
533  * struct packet_struct because we use it only local in the packet
534  * parser and builder. */
535 typedef struct {
536   unsigned int trustval;
537   unsigned int sigcache;
538   unsigned char subtype; /* The subtype of this ring trust packet.   */
539   unsigned char keyorg;  /* The origin of the key (KEYORG_*).        */
540   u32 keyupdate;         /* The wall time the key was last updated.  */
541   char *url;             /* NULL or the URL of the source.           */
542 } PKT_ring_trust;
543
544
545 /* A plaintext packet (see RFC 4880, 5.9).  */
546 typedef struct {
547   /* The length of data in BUF or 0 if unknown.  */
548   u32  len;
549   /* A buffer containing the data stored in the packet's body.  */
550   iobuf_t buf;
551   byte new_ctb;
552   byte is_partial;      /* partial length encoded */
553   /* The data's formatting.  This is either 'b', 't', 'u', 'l' or '1'
554      (however, the last two are deprecated).  */
555   int mode;
556   u32 timestamp;
557   /* The name of the file.  This can be at most 255 characters long,
558      since namelen is just a byte in the serialized format.  */
559   int  namelen;
560   char name[1];
561 } PKT_plaintext;
562
563 typedef struct {
564     int  control;
565     size_t datalen;
566     char data[1];
567 } PKT_gpg_control;
568
569 /* combine all packets into a union */
570 struct packet_struct {
571     pkttype_t pkttype;
572     union {
573         void *generic;
574         PKT_symkey_enc  *symkey_enc;    /* PKT_SYMKEY_ENC */
575         PKT_pubkey_enc  *pubkey_enc;    /* PKT_PUBKEY_ENC */
576         PKT_onepass_sig *onepass_sig;   /* PKT_ONEPASS_SIG */
577         PKT_signature   *signature;     /* PKT_SIGNATURE */
578         PKT_public_key  *public_key;    /* PKT_PUBLIC_[SUB]KEY */
579         PKT_public_key  *secret_key;    /* PKT_SECRET_[SUB]KEY */
580         PKT_comment     *comment;       /* PKT_COMMENT */
581         PKT_user_id     *user_id;       /* PKT_USER_ID */
582         PKT_compressed  *compressed;    /* PKT_COMPRESSED */
583         PKT_encrypted   *encrypted;     /* PKT_ENCRYPTED[_MDC] */
584         PKT_mdc         *mdc;           /* PKT_MDC */
585         PKT_plaintext   *plaintext;     /* PKT_PLAINTEXT */
586         PKT_gpg_control *gpg_control;   /* PKT_GPG_CONTROL */
587     } pkt;
588 };
589
590 #define init_packet(a) do { (a)->pkttype = 0;           \
591                             (a)->pkt.generic = NULL;    \
592                        } while(0)
593
594
595 /* A notation.  See RFC 4880, Section 5.2.3.16.  */
596 struct notation
597 {
598   /* The notation's name.  */
599   char *name;
600   /* If the notation is human readable, then the value is stored here
601      as a NUL-terminated string.  If it is not human readable a human
602      readable approximation of the binary value _may_ be stored
603      here.  */
604   char *value;
605   /* Sometimes we want to %-expand the value.  In these cases, we save
606      that transformed value here.  */
607   char *altvalue;
608   /* If the notation is not human readable, then the value is stored
609      here.  */
610   unsigned char *bdat;
611   /* The amount of data stored in BDAT.
612
613      Note: if this is 0 and BDAT is NULL, this does not necessarily
614      mean that the value is human readable.  It could be that we have
615      a 0-length value.  To determine whether the notation is human
616      readable, always check if VALUE is not NULL.  This works, because
617      if a human-readable value has a length of 0, we will still
618      allocate space for the NUL byte.  */
619   size_t blen;
620   struct
621   {
622     /* The notation is critical.  */
623     unsigned int critical:1;
624     /* The notation is human readable.  */
625     unsigned int human:1;
626     /* The notation should be deleted.  */
627     unsigned int ignore:1;
628   } flags;
629
630   /* A field to facilitate creating a list of notations.  */
631   struct notation *next;
632 };
633 typedef struct notation *notation_t;
634
635 /*-- mainproc.c --*/
636 void reset_literals_seen(void);
637 int proc_packets (ctrl_t ctrl, void *ctx, iobuf_t a );
638 int proc_signature_packets (ctrl_t ctrl, void *ctx, iobuf_t a,
639                             strlist_t signedfiles, const char *sigfile );
640 int proc_signature_packets_by_fd (ctrl_t ctrl,
641                                   void *anchor, IOBUF a, int signed_data_fd );
642 int proc_encryption_packets (ctrl_t ctrl, void *ctx, iobuf_t a);
643 int list_packets( iobuf_t a );
644
645 const byte *issuer_fpr_raw (PKT_signature *sig, size_t *r_len);
646 char *issuer_fpr_string (PKT_signature *sig);
647
648 /*-- parse-packet.c --*/
649
650
651 void register_known_notation (const char *string);
652
653 /* Sets the packet list mode to MODE (i.e., whether we are dumping a
654    packet or not).  Returns the current mode.  This allows for
655    temporarily suspending dumping by doing the following:
656
657      int saved_mode = set_packet_list_mode (0);
658      ...
659      set_packet_list_mode (saved_mode);
660 */
661 int set_packet_list_mode( int mode );
662
663
664 /* A context used with parse_packet.  */
665 struct parse_packet_ctx_s
666 {
667   iobuf_t inp;       /* The input stream with the packets.  */
668   struct packet_struct last_pkt; /* The last parsed packet.  */
669   int free_last_pkt; /* Indicates that LAST_PKT must be freed.  */
670   int skip_meta;     /* Skip ring trust packets.  */
671   unsigned int n_parsed_packets;        /* Number of parsed packets.  */
672 };
673 typedef struct parse_packet_ctx_s *parse_packet_ctx_t;
674
675 #define init_parse_packet(a,i) do { \
676     (a)->inp = (i);                 \
677     (a)->last_pkt.pkttype = 0;      \
678     (a)->last_pkt.pkt.generic= NULL;\
679     (a)->free_last_pkt = 0;         \
680     (a)->skip_meta = 0;             \
681     (a)->n_parsed_packets = 0;      \
682   } while (0)
683
684 #define deinit_parse_packet(a) do { \
685     if ((a)->free_last_pkt)         \
686       free_packet (NULL, (a));      \
687   } while (0)
688
689
690 #if DEBUG_PARSE_PACKET
691 /* There are debug functions and should not be used directly.  */
692 int dbg_search_packet (parse_packet_ctx_t ctx, PACKET *pkt,
693                        off_t *retpos, int with_uid,
694                        const char* file, int lineno  );
695 int dbg_parse_packet (parse_packet_ctx_t ctx, PACKET *ret_pkt,
696                       const char *file, int lineno);
697 int dbg_copy_all_packets( iobuf_t inp, iobuf_t out,
698                           const char* file, int lineno  );
699 int dbg_copy_some_packets( iobuf_t inp, iobuf_t out, off_t stopoff,
700                            const char* file, int lineno  );
701 int dbg_skip_some_packets( iobuf_t inp, unsigned n,
702                            const char* file, int lineno );
703 #define search_packet( a,b,c,d )   \
704              dbg_search_packet( (a), (b), (c), (d), __FILE__, __LINE__ )
705 #define parse_packet( a, b )  \
706              dbg_parse_packet( (a), (b), __FILE__, __LINE__ )
707 #define copy_all_packets( a,b )  \
708              dbg_copy_all_packets((a),(b), __FILE__, __LINE__ )
709 #define copy_some_packets( a,b,c ) \
710              dbg_copy_some_packets((a),(b),(c), __FILE__, __LINE__ )
711 #define skip_some_packets( a,b ) \
712              dbg_skip_some_packets((a),(b), __FILE__, __LINE__ )
713 #else
714 /* Return the next valid OpenPGP packet in *PKT.  (This function will
715  * skip any packets whose type is 0.)  CTX must have been setup prior to
716  * calling this function.
717  *
718  * Returns 0 on success, -1 if EOF is reached, and an error code
719  * otherwise.  In the case of an error, the packet in *PKT may be
720  * partially constructed.  As such, even if there is an error, it is
721  * necessary to free *PKT to avoid a resource leak.  To detect what
722  * has been allocated, clear *PKT before calling this function.  */
723 int parse_packet (parse_packet_ctx_t ctx, PACKET *pkt);
724
725 /* Return the first OpenPGP packet in *PKT that contains a key (either
726  * a public subkey, a public key, a secret subkey or a secret key) or,
727  * if WITH_UID is set, a user id.
728  *
729  * Saves the position in the pipeline of the start of the returned
730  * packet (according to iobuf_tell) in RETPOS, if it is not NULL.
731  *
732  * The return semantics are the same as parse_packet.  */
733 int search_packet (parse_packet_ctx_t ctx, PACKET *pkt,
734                    off_t *retpos, int with_uid);
735
736 /* Copy all packets (except invalid packets, i.e., those with a type
737  * of 0) from INP to OUT until either an error occurs or EOF is
738  * reached.
739  *
740  * Returns -1 when end of file is reached or an error code, if an
741  * error occurred.  (Note: this function never returns 0, because it
742  * effectively keeps going until it gets an EOF.)  */
743 int copy_all_packets (iobuf_t inp, iobuf_t out );
744
745 /* Like copy_all_packets, but stops at the first packet that starts at
746  * or after STOPOFF (as indicated by iobuf_tell).
747  *
748  * Example: if STOPOFF is 100, the first packet in INP goes from
749  * 0 to 110 and the next packet starts at offset 111, then the packet
750  * starting at offset 0 will be completely processed (even though it
751  * extends beyond STOPOFF) and the packet starting at offset 111 will
752  * not be processed at all.  */
753 int copy_some_packets (iobuf_t inp, iobuf_t out, off_t stopoff);
754
755 /* Skips the next N packets from INP.
756  *
757  * If parsing a packet returns an error code, then the function stops
758  * immediately and returns the error code.  Note: in the case of an
759  * error, this function does not indicate how many packets were
760  * successfully processed.  */
761 int skip_some_packets (iobuf_t inp, unsigned int n);
762 #endif
763
764 /* Parse a signature packet and store it in *SIG.
765
766    The signature packet is read from INP.  The OpenPGP header (the tag
767    and the packet's length) have already been read; the next byte read
768    from INP should be the first byte of the packet's contents.  The
769    packet's type (as extract from the tag) must be passed as PKTTYPE
770    and the packet's length must be passed as PKTLEN.  This is used as
771    the upper bound on the amount of data read from INP.  If the packet
772    is shorter than PKTLEN, the data at the end will be silently
773    skipped.  If an error occurs, an error code will be returned.  -1
774    means the EOF was encountered.  0 means parsing was successful.  */
775 int parse_signature( iobuf_t inp, int pkttype, unsigned long pktlen,
776                      PKT_signature *sig );
777
778 /* Given a subpacket area (typically either PKT_signature.hashed or
779    PKT_signature.unhashed), either:
780
781      - test whether there are any subpackets with the critical bit set
782        that we don't understand,
783
784      - list the subpackets, or,
785
786      - find a subpacket with a specific type.
787
788    REQTYPE indicates the type of operation.
789
790    If REQTYPE is SIGSUBPKT_TEST_CRITICAL, then this function checks
791    whether there are any subpackets that have the critical bit and
792    which GnuPG cannot handle.  If GnuPG understands all subpackets
793    whose critical bit is set, then this function returns simply
794    returns SUBPKTS.  If there is a subpacket whose critical bit is set
795    and which GnuPG does not understand, then this function returns
796    NULL and, if START is not NULL, sets *START to the 1-based index of
797    the subpacket that violates the constraint.
798
799    If REQTYPE is SIGSUBPKT_LIST_HASHED or SIGSUBPKT_LIST_UNHASHED, the
800    packets are dumped.  Note: if REQTYPE is SIGSUBPKT_LIST_HASHED,
801    this function does not check whether the hash is correct; this is
802    merely an indication of the section that the subpackets came from.
803
804    If REQTYPE is anything else, then this function interprets the
805    values as a subpacket type and looks for the first subpacket with
806    that type.  If such a packet is found, *CRITICAL (if not NULL) is
807    set if the critical bit was set, *RET_N is set to the offset of the
808    subpacket's content within the SUBPKTS buffer, *START is set to the
809    1-based index of the subpacket within the buffer, and returns
810    &SUBPKTS[*RET_N].
811
812    *START is the number of initial subpackets to not consider.  Thus,
813    if *START is 2, then the first 2 subpackets are ignored.  */
814 const byte *enum_sig_subpkt ( const subpktarea_t *subpkts,
815                               sigsubpkttype_t reqtype,
816                               size_t *ret_n, int *start, int *critical );
817
818 /* Shorthand for:
819
820      enum_sig_subpkt (buffer, reqtype, ret_n, NULL, NULL); */
821 const byte *parse_sig_subpkt ( const subpktarea_t *buffer,
822                                sigsubpkttype_t reqtype,
823                                size_t *ret_n );
824
825 /* This calls parse_sig_subpkt first on the hashed signature area in
826    SIG and then, if that returns NULL, calls parse_sig_subpkt on the
827    unhashed subpacket area in SIG.  */
828 const byte *parse_sig_subpkt2 ( PKT_signature *sig,
829                                 sigsubpkttype_t reqtype);
830
831 /* Returns whether the N byte large buffer BUFFER is sufficient to
832    hold a subpacket of type TYPE.  Note: the buffer refers to the
833    contents of the subpacket (not the header) and it must already be
834    initialized: for some subpackets, it checks some internal
835    constraints.
836
837    Returns 0 if the size is acceptable.  Returns -2 if the buffer is
838    definitely too short.  To check for an error, check whether the
839    return value is less than 0.  */
840 int parse_one_sig_subpkt( const byte *buffer, size_t n, int type );
841
842 /* Looks for revocation key subpackets (see RFC 4880 5.2.3.15) in the
843    hashed area of the signature packet.  Any that are found are added
844    to SIG->REVKEY and SIG->NUMREVKEYS is updated appropriately.  */
845 void parse_revkeys(PKT_signature *sig);
846
847 /* Extract the attributes from the buffer at UID->ATTRIB_DATA and
848    update UID->ATTRIBS and UID->NUMATTRIBS accordingly.  */
849 int parse_attribute_subpkts(PKT_user_id *uid);
850
851 /* Set the UID->NAME field according to the attributes.  MAX_NAMELEN
852    must be at least 71.  */
853 void make_attribute_uidname(PKT_user_id *uid, size_t max_namelen);
854
855 /* Allocate and initialize a new GPG control packet.  DATA is the data
856    to save in the packet.  */
857 PACKET *create_gpg_control ( ctrlpkttype_t type,
858                              const byte *data,
859                              size_t datalen );
860
861 /*-- build-packet.c --*/
862 int build_packet (iobuf_t out, PACKET *pkt);
863 gpg_error_t build_packet_and_meta (iobuf_t out, PACKET *pkt);
864 gpg_error_t gpg_mpi_write (iobuf_t out, gcry_mpi_t a, unsigned int *t_nwritten);
865 gpg_error_t gpg_mpi_write_nohdr (iobuf_t out, gcry_mpi_t a);
866 u32 calc_packet_length( PACKET *pkt );
867 void build_sig_subpkt( PKT_signature *sig, sigsubpkttype_t type,
868                         const byte *buffer, size_t buflen );
869 void build_sig_subpkt_from_sig (PKT_signature *sig, PKT_public_key *pksk);
870 int  delete_sig_subpkt(subpktarea_t *buffer, sigsubpkttype_t type );
871 void build_attribute_subpkt(PKT_user_id *uid,byte type,
872                             const void *buf,u32 buflen,
873                             const void *header,u32 headerlen);
874 struct notation *string_to_notation(const char *string,int is_utf8);
875 struct notation *blob_to_notation(const char *name,
876                                   const char *data, size_t len);
877 struct notation *sig_to_notation(PKT_signature *sig);
878 void free_notation(struct notation *notation);
879
880 /*-- free-packet.c --*/
881 void free_symkey_enc( PKT_symkey_enc *enc );
882 void free_pubkey_enc( PKT_pubkey_enc *enc );
883 void free_seckey_enc( PKT_signature *enc );
884 void release_public_key_parts( PKT_public_key *pk );
885 void free_public_key( PKT_public_key *key );
886 void free_attributes(PKT_user_id *uid);
887 void free_user_id( PKT_user_id *uid );
888 void free_comment( PKT_comment *rem );
889 void free_packet (PACKET *pkt, parse_packet_ctx_t parsectx);
890 prefitem_t *copy_prefs (const prefitem_t *prefs);
891 PKT_public_key *copy_public_key( PKT_public_key *d, PKT_public_key *s );
892 PKT_signature *copy_signature( PKT_signature *d, PKT_signature *s );
893 PKT_user_id *scopy_user_id (PKT_user_id *sd );
894 int cmp_public_keys( PKT_public_key *a, PKT_public_key *b );
895 int cmp_signatures( PKT_signature *a, PKT_signature *b );
896 int cmp_user_ids( PKT_user_id *a, PKT_user_id *b );
897
898
899 /*-- sig-check.c --*/
900 /* Check a signature.  This is shorthand for check_signature2 with
901    the unnamed arguments passed as NULL.  */
902 int check_signature (ctrl_t ctrl, PKT_signature *sig, gcry_md_hd_t digest);
903
904 /* Check a signature.  Looks up the public key from the key db.  (If
905  * R_PK is not NULL, it is stored at RET_PK.)  DIGEST contains a
906  * valid hash context that already includes the signed data.  This
907  * function adds the relevant meta-data to the hash before finalizing
908  * it and verifying the signature.  */
909 gpg_error_t check_signature2 (ctrl_t ctrl,
910                               PKT_signature *sig, gcry_md_hd_t digest,
911                               const void *extrahash, size_t extrahashlen,
912                               u32 *r_expiredate, int *r_expired, int *r_revoked,
913                               PKT_public_key **r_pk);
914
915
916 /*-- pubkey-enc.c --*/
917 gpg_error_t get_session_key (ctrl_t ctrl, struct pubkey_enc_list *k, DEK *dek);
918 gpg_error_t get_override_session_key (DEK *dek, const char *string);
919
920 /*-- compress.c --*/
921 int handle_compressed (ctrl_t ctrl, void *ctx, PKT_compressed *cd,
922                        int (*callback)(iobuf_t, void *), void *passthru );
923
924 /*-- encr-data.c --*/
925 int decrypt_data (ctrl_t ctrl, void *ctx, PKT_encrypted *ed, DEK *dek );
926
927 /*-- plaintext.c --*/
928 gpg_error_t get_output_file (const byte *embedded_name, int embedded_namelen,
929                              iobuf_t data, char **fnamep, estream_t *fpp);
930 int handle_plaintext( PKT_plaintext *pt, md_filter_context_t *mfx,
931                                         int nooutput, int clearsig );
932 int ask_for_detached_datafile( gcry_md_hd_t md, gcry_md_hd_t md2,
933                                const char *inname, int textmode );
934
935 /*-- sign.c --*/
936 int make_keysig_packet (ctrl_t ctrl,
937                         PKT_signature **ret_sig, PKT_public_key *pk,
938                         PKT_user_id *uid, PKT_public_key *subpk,
939                         PKT_public_key *pksk, int sigclass,
940                         u32 timestamp, u32 duration,
941                         int (*mksubpkt)(PKT_signature *, void *),
942                         void *opaque,
943                         const char *cache_nonce);
944 gpg_error_t update_keysig_packet (ctrl_t ctrl,
945                       PKT_signature **ret_sig,
946                       PKT_signature *orig_sig,
947                       PKT_public_key *pk,
948                       PKT_user_id *uid,
949                       PKT_public_key *subpk,
950                       PKT_public_key *pksk,
951                       int (*mksubpkt)(PKT_signature *, void *),
952                       void *opaque   );
953
954 /*-- keygen.c --*/
955 PKT_user_id *generate_user_id (kbnode_t keyblock, const char *uidstr);
956
957 #endif /*G10_PACKET_H*/