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