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