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