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