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