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