cpp: Add ostream operators for import result
[gpgme.git] / src / data-identify.c
1 /* data-identify.c - Try to identify the data
2  * Copyright (C) 2013, 2016 g10 Code GmbH
3  *
4  * This file is part of GPGME.
5  *
6  * GPGME is free software; you can redistribute it and/or modify it
7  * under the terms of the GNU Lesser General Public License as
8  * published by the Free Software Foundation; either version 2.1 of
9  * the License, or (at your option) any later version.
10  *
11  * GPGME is distributed in the hope that it will be useful, but
12  * WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this program; if not, see <https://gnu.org/licenses/>.
18  * SPDX-License-Identifier: LGPL-2.1-or-later
19  */
20
21 #if HAVE_CONFIG_H
22 # include <config.h>
23 #endif
24
25 #include <stdlib.h>
26 #include <string.h>
27
28 #include "gpgme.h"
29 #include "data.h"
30 #include "util.h"
31 #include "parsetlv.h"
32
33
34 /* The size of the sample data we take for detection.  */
35 #define SAMPLE_SIZE 2048
36
37
38 /* OpenPGP packet types.  */
39 enum
40   {
41     PKT_NONE          = 0,
42     PKT_PUBKEY_ENC    = 1,  /* Public key encrypted packet. */
43     PKT_SIGNATURE     = 2,  /* Secret key encrypted packet. */
44     PKT_SYMKEY_ENC    = 3,  /* Session key packet. */
45     PKT_ONEPASS_SIG   = 4,  /* One pass sig packet. */
46     PKT_SECRET_KEY    = 5,  /* Secret key. */
47     PKT_PUBLIC_KEY    = 6,  /* Public key. */
48     PKT_SECRET_SUBKEY = 7,  /* Secret subkey. */
49     PKT_COMPRESSED    = 8,  /* Compressed data packet. */
50     PKT_ENCRYPTED     = 9,  /* Conventional encrypted data. */
51     PKT_MARKER        = 10, /* Marker packet. */
52     PKT_PLAINTEXT     = 11, /* Literal data packet. */
53     PKT_RING_TRUST    = 12, /* Keyring trust packet. */
54     PKT_USER_ID       = 13, /* User id packet. */
55     PKT_PUBLIC_SUBKEY = 14, /* Public subkey. */
56     PKT_OLD_COMMENT   = 16, /* Comment packet from an OpenPGP draft. */
57     PKT_ATTRIBUTE     = 17, /* PGP's attribute packet. */
58     PKT_ENCRYPTED_MDC = 18, /* Integrity protected encrypted data. */
59     PKT_MDC           = 19, /* Manipulation detection code packet. */
60   };
61
62
63 static inline unsigned long
64 buf32_to_ulong (const void *buffer)
65 {
66   const unsigned char *p = buffer;
67
68   return (((unsigned long)p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3]);
69 }
70
71
72 /* Parse the next openpgp packet.  This function assumes a valid
73  * OpenPGP packet at the address pointed to by BUFPTR which has a
74  * maximum length as stored at BUFLEN.  Return the header information
75  * of that packet and advance the pointer stored at BUFPTR to the next
76  * packet; also adjust the length stored at BUFLEN to match the
77  * remaining bytes. If there are no more packets, store NULL at
78  * BUFPTR.  Return an non-zero error code on failure or the following
79  * data on success:
80  *
81  *  R_PKTTYPE = The packet type.
82  *  R_NTOTAL  = The total number of bytes of this packet
83  *
84  * If GPG_ERR_TRUNCATED is returned, a packet type is anyway stored at
85  * R_PKTTYPE but R_NOTAL won't have a usable value,
86  */
87 static gpg_error_t
88 next_openpgp_packet (unsigned char const **bufptr, size_t *buflen,
89                      int *r_pkttype, size_t *r_ntotal)
90 {
91   const unsigned char *buf = *bufptr;
92   size_t len = *buflen;
93   int c, ctb, pkttype;
94   unsigned long pktlen;
95
96   if (!len)
97     return gpg_error (GPG_ERR_NO_DATA);
98
99   /* First some blacklisting.  */
100   if (len >= 4 && !memcmp (buf, "\x89PNG", 4))
101     return gpg_error (GPG_ERR_INV_PACKET); /* This is a PNG file.  */
102
103   /* Start parsing.  */
104   ctb = *buf++; len--;
105   if ( !(ctb & 0x80) )
106     return gpg_error (GPG_ERR_INV_PACKET); /* Invalid CTB. */
107
108   if ((ctb & 0x40))  /* New style (OpenPGP) CTB.  */
109     {
110       pkttype = (ctb & 0x3f);
111       if (!len)
112         return gpg_error (GPG_ERR_INV_PACKET); /* No 1st length byte. */
113       c = *buf++; len--;
114       if ( c < 192 )
115         pktlen = c;
116       else if ( c < 224 )
117         {
118           pktlen = (c - 192) * 256;
119           if (!len)
120             return gpg_error (GPG_ERR_INV_PACKET); /* No 2nd length byte. */
121           c = *buf++; len--;
122           pktlen += c + 192;
123         }
124       else if (c == 255)
125         {
126           if (len < 4)
127             return gpg_error (GPG_ERR_INV_PACKET); /* No length bytes. */
128           pktlen = buf32_to_ulong (buf);
129           buf += 4;
130           len -= 4;
131         }
132       else /* Partial length encoding. */
133         {
134           pktlen = 0;
135         }
136     }
137   else /* Old style CTB.  */
138     {
139       int lenbytes;
140
141       pktlen = 0;
142       pkttype = (ctb>>2)&0xf;
143       lenbytes = ((ctb&3)==3)? 0 : (1<<(ctb & 3));
144       if (len < lenbytes)
145         return gpg_error (GPG_ERR_INV_PACKET); /* Not enough length bytes.  */
146       for (; lenbytes; lenbytes--)
147         {
148           pktlen <<= 8;
149           pktlen |= *buf++; len--;
150         }
151     }
152
153   /* Do some basic sanity check.  */
154   switch (pkttype)
155     {
156     case PKT_PUBKEY_ENC:
157     case PKT_SIGNATURE:
158     case PKT_SYMKEY_ENC:
159     case PKT_ONEPASS_SIG:
160     case PKT_SECRET_KEY:
161     case PKT_PUBLIC_KEY:
162     case PKT_SECRET_SUBKEY:
163     case PKT_COMPRESSED:
164     case PKT_ENCRYPTED:
165     case PKT_MARKER:
166     case PKT_PLAINTEXT:
167     case PKT_RING_TRUST:
168     case PKT_USER_ID:
169     case PKT_PUBLIC_SUBKEY:
170     case PKT_OLD_COMMENT:
171     case PKT_ATTRIBUTE:
172     case PKT_ENCRYPTED_MDC:
173     case PKT_MDC:
174       break; /* Okay these are allowed packets. */
175     default:
176       return gpg_error (GPG_ERR_UNEXPECTED);
177     }
178
179   if (pktlen > len)
180     {
181       /* Packet length header too long.  This is possible because we
182        * may have only a truncated image.  */
183       *r_pkttype = pkttype;
184       *r_ntotal = 0;
185       *bufptr = NULL;
186       return gpg_error (GPG_ERR_TRUNCATED);
187     }
188
189   *r_pkttype = pkttype;
190   *r_ntotal = (buf - *bufptr) + pktlen;
191
192   *bufptr = buf + pktlen;
193   *buflen = len - pktlen;
194   if (!*buflen)
195     *bufptr = NULL;
196
197   return 0;
198 }
199
200
201 /* Detection of PGP binary data.  This function parses an OpenPGP
202  * message.  This parser is robust enough to work on a truncated
203  * version.  Returns a GPGME_DATA_TYPE_.  */
204 static gpgme_data_type_t
205 pgp_binary_detection (const void *image_arg, size_t imagelen)
206 {
207   gpg_error_t err = 0;
208   const unsigned char *image = image_arg;
209   size_t n;
210   int pkttype;
211   int anypacket = 0;
212   int allsignatures = 0;
213
214   while (!err && image)
215     {
216       err = next_openpgp_packet (&image, &imagelen, &pkttype, &n);
217       if (gpg_err_code (err) == GPG_ERR_TRUNCATED)
218         ;
219       else if (err)
220         break;
221
222       /* Skip all leading marker packets.  */
223       if (!anypacket && pkttype == PKT_MARKER)
224         continue;
225
226       if (pkttype == PKT_SIGNATURE)
227         {
228           if (!anypacket)
229             allsignatures = 1;
230         }
231       else
232         allsignatures = 0;
233
234       switch (pkttype)
235         {
236         case PKT_SIGNATURE:
237           break;  /* We decide later.  */
238
239         case PKT_PLAINTEXT:
240           /* Old style signature format: {sig}+,plaintext */
241           if (allsignatures)
242             return GPGME_DATA_TYPE_PGP_SIGNED;
243           break;
244
245         case PKT_ONEPASS_SIG:
246           return GPGME_DATA_TYPE_PGP_SIGNED;
247
248         case PKT_SECRET_KEY:
249         case PKT_PUBLIC_KEY:
250           return GPGME_DATA_TYPE_PGP_KEY;
251
252         case PKT_SECRET_SUBKEY:
253         case PKT_PUBLIC_SUBKEY:
254           return GPGME_DATA_TYPE_PGP_OTHER;
255         case PKT_PUBKEY_ENC:
256         case PKT_SYMKEY_ENC:
257           return GPGME_DATA_TYPE_PGP_ENCRYPTED;
258
259         case PKT_COMPRESSED:
260           /* If this is the first packet we assume that that a signed
261            * packet follows.  We do not want to uncompress it here due
262            * to the need of a lot of code and the potential DoS. */
263           if (!anypacket)
264             return GPGME_DATA_TYPE_PGP_SIGNED;
265           return GPGME_DATA_TYPE_PGP_OTHER;
266
267         default:
268           return GPGME_DATA_TYPE_PGP_OTHER;
269         }
270       anypacket = 1;
271     }
272
273   if (allsignatures)
274     return  GPGME_DATA_TYPE_PGP_SIGNATURE;
275
276   return GPGME_DATA_TYPE_UNKNOWN;
277 }
278
279
280 /* This is probably an armored "PGP MESSAGE" which can encode
281  * different PGP data types.  STRING is modified after a call to this
282  * function. */
283 static gpgme_data_type_t
284 inspect_pgp_message (char *string)
285 {
286   struct b64state state;
287   size_t nbytes;
288
289   if (_gpgme_b64dec_start (&state, ""))
290     return GPGME_DATA_TYPE_INVALID; /* oops */
291
292   if (_gpgme_b64dec_proc (&state, string, strlen (string), &nbytes))
293     {
294       _gpgme_b64dec_finish (&state);
295       return GPGME_DATA_TYPE_UNKNOWN; /* bad encoding etc. */
296     }
297   _gpgme_b64dec_finish (&state);
298   string[nbytes] = 0; /* Better append a Nul. */
299
300   return pgp_binary_detection (string, nbytes);
301 }
302
303
304 /* Note that DATA may be binary but a final nul is required so that
305    string operations will find a terminator.
306
307    Returns: GPGME_DATA_TYPE_xxxx */
308 static gpgme_data_type_t
309 basic_detection (char *data, size_t datalen)
310 {
311   tlvinfo_t ti;
312   const char *s;
313   size_t n;
314   int maybe_p12 = 0;
315
316   if (datalen < 24) /* Object is probably too short for detection.  */
317     return GPGME_DATA_TYPE_UNKNOWN;
318
319   /* This is a common example of a CMS object - it is obvious that we
320      only need to read a few bytes to get to the OID:
321   30 82 0B 59 06 09 2A 86 48 86 F7 0D 01 07 02 A0 82 0B 4A 30 82 0B 46 02
322   ----------- ++++++++++++++++++++++++++++++++
323   SEQUENCE    OID (signedData)
324   (2 byte len)
325
326     A PKCS#12 message is:
327
328   30 82 08 59 02 01 03 30 82 08 1F 06 09 2A 86 48 86 F7 0D 01 07 01 A0 82
329   ----------- ++++++++ ----------- ++++++++++++++++++++++++++++++++
330   SEQUENCE    INTEGER  SEQUENCE    OID (data)
331
332     A X.509 certificate is:
333
334   30 82 05 B8 30 82 04 A0 A0 03 02 01 02 02 07 15 46 A0 BF 30 07 39 30 0D
335   ----------- +++++++++++ ----- ++++++++ --------------------------
336   SEQUENCE    SEQUENCE    [0]   INTEGER  INTEGER                    SEQU
337               (tbs)            (version) (s/n)                      (Algo)
338
339     Thus we need to read at least 22 bytes, we add 2 bytes to cope with
340     length headers stored with 4 bytes.
341   */
342
343
344   s = data;
345   n = datalen;
346
347   if (parse_tlv (&s, &n, &ti))
348     goto try_pgp; /* Not properly BER encoded.  */
349   if (!(ti.cls == ASN1_CLASS_UNIVERSAL && ti.tag == ASN1_TAG_SEQUENCE
350         && ti.is_cons))
351     goto try_pgp; /* A CMS object always starts with a sequence.  */
352
353   if (parse_tlv (&s, &n, &ti))
354     goto try_pgp; /* Not properly BER encoded.  */
355   if (ti.cls == ASN1_CLASS_UNIVERSAL && ti.tag == ASN1_TAG_SEQUENCE
356       && ti.is_cons && n >= ti.length)
357     {
358       if (parse_tlv (&s, &n, &ti))
359         goto try_pgp;
360       if (!(ti.cls == ASN1_CLASS_CONTEXT && ti.tag == 0
361             && ti.is_cons && ti.length == 3 && n >= ti.length))
362         goto try_pgp;
363
364       if (parse_tlv (&s, &n, &ti))
365         goto try_pgp;
366       if (!(ti.cls == ASN1_CLASS_UNIVERSAL && ti.tag == ASN1_TAG_INTEGER
367             && !ti.is_cons && ti.length == 1 && n && (*s == 1 || *s == 2)))
368         goto try_pgp;
369       s++;
370       n--;
371       if (!(ti.cls == ASN1_CLASS_UNIVERSAL && ti.tag == ASN1_TAG_INTEGER
372             && !ti.is_cons))
373         goto try_pgp;
374       /* Because the now following S/N may be larger than the sample
375          data we have, we stop parsing here and don't check for the
376          algorithm ID.  */
377       return GPGME_DATA_TYPE_X509_CERT;
378     }
379   if (ti.cls == ASN1_CLASS_UNIVERSAL && ti.tag == ASN1_TAG_INTEGER
380       && !ti.is_cons && ti.length == 1 && n && *s == 3)
381     {
382       maybe_p12 = 1;
383       s++;
384       n--;
385       if (parse_tlv (&s, &n, &ti))
386         goto try_pgp;
387       if (!(ti.cls == ASN1_CLASS_UNIVERSAL && ti.tag == ASN1_TAG_SEQUENCE
388             && ti.is_cons))
389         goto try_pgp;
390       if (parse_tlv (&s, &n, &ti))
391         goto try_pgp;
392     }
393   if (ti.cls == ASN1_CLASS_UNIVERSAL && ti.tag == ASN1_TAG_OBJECT_ID
394       && !ti.is_cons && ti.length && n >= ti.length)
395     {
396       if (ti.length == 9)
397         {
398           if (!memcmp (s, "\x2A\x86\x48\x86\xF7\x0D\x01\x07\x01", 9))
399             {
400               /* Data.  */
401               return (maybe_p12 ? GPGME_DATA_TYPE_PKCS12
402                       /*     */ : GPGME_DATA_TYPE_CMS_OTHER);
403             }
404           if (!memcmp (s, "\x2A\x86\x48\x86\xF7\x0D\x01\x07\x02", 9))
405             {
406               /* Signed Data.  */
407               return (maybe_p12 ? GPGME_DATA_TYPE_PKCS12
408                       /*     */ : GPGME_DATA_TYPE_CMS_SIGNED);
409             }
410           if (!memcmp (s, "\x2A\x86\x48\x86\xF7\x0D\x01\x07\x03", 9))
411             return GPGME_DATA_TYPE_CMS_ENCRYPTED; /* Enveloped Data.  */
412           if (!memcmp (s, "\x2A\x86\x48\x86\xF7\x0D\x01\x07\x05", 9))
413             return GPGME_DATA_TYPE_CMS_OTHER; /* Digested Data.  */
414           if (!memcmp (s, "\x2A\x86\x48\x86\xF7\x0D\x01\x07\x06", 9))
415             return GPGME_DATA_TYPE_CMS_OTHER; /* Encrypted Data.  */
416         }
417       else if (ti.length == 11)
418         {
419           if (!memcmp (s, "\x2A\x86\x48\x86\xF7\x0D\x01\x09\x10\x01\x02", 11))
420             return GPGME_DATA_TYPE_CMS_OTHER; /* Auth Data.  */
421         }
422     }
423
424
425  try_pgp:
426   /* Check whether this might be a non-armored PGP message.  We need
427      to do this before checking for armor lines, so that we don't get
428      fooled by armored messages inside a signed binary PGP message.  */
429   if ((data[0] & 0x80))
430     {
431       /* That might be a binary PGP message.  At least it is not plain
432          ASCII.  Of course this might be certain lead-in text of
433          armored CMS messages.  However, I am not sure whether this is
434          at all defined and in any case it is uncommon.  Thus we don't
435          do any further plausibility checks but stupidly assume no CMS
436          armored data will follow.  */
437       return pgp_binary_detection (data, datalen);
438     }
439
440   /* Now check whether there are armor lines.  */
441   for (s = data; s && *s; s = (*s=='\n')?(s+1):((s=strchr (s,'\n'))?(s+1):s))
442     {
443       if (!strncmp (s, "-----BEGIN ", 11))
444         {
445           if (!strncmp (s+11, "SIGNED ", 7))
446             return GPGME_DATA_TYPE_CMS_SIGNED;
447           if (!strncmp (s+11, "ENCRYPTED ", 10))
448             return GPGME_DATA_TYPE_CMS_ENCRYPTED;
449           if (!strncmp (s+11, "PGP ", 4))
450             {
451               if (!strncmp (s+15, "SIGNATURE", 9))
452                 return GPGME_DATA_TYPE_PGP_SIGNATURE;
453               if (!strncmp (s+15, "SIGNED MESSAGE", 14))
454                 return GPGME_DATA_TYPE_PGP_SIGNED;
455               if (!strncmp (s+15, "PUBLIC KEY BLOCK", 16))
456                 return GPGME_DATA_TYPE_PGP_KEY;
457               if (!strncmp (s+15, "PRIVATE KEY BLOCK", 17))
458                 return GPGME_DATA_TYPE_PGP_KEY;
459               if (!strncmp (s+15, "SECRET KEY BLOCK", 16))
460                 return GPGME_DATA_TYPE_PGP_KEY;
461               if (!strncmp (s+15, "ARMORED FILE", 12))
462                 return GPGME_DATA_TYPE_UNKNOWN;
463
464               return inspect_pgp_message (data);
465             }
466           if (!strncmp (s+11, "CERTIFICATE", 11))
467             return GPGME_DATA_TYPE_X509_CERT;
468           if (!strncmp (s+11, "PKCS12", 6))
469             return GPGME_DATA_TYPE_PKCS12;
470           return GPGME_DATA_TYPE_CMS_OTHER; /* Not PGP, thus we assume CMS.  */
471         }
472     }
473
474   return GPGME_DATA_TYPE_UNKNOWN;
475 }
476
477
478 /* Try to detect the type of the data.  Note that this function works
479    only on seekable data objects.  The function tries to reset the
480    file pointer but there is no guarantee that it will work.
481
482    FIXME: We may want to add internal buffering so that this function
483    can be implemented for almost all kind of data objects.
484  */
485 gpgme_data_type_t
486 gpgme_data_identify (gpgme_data_t dh, int reserved)
487 {
488   gpgme_data_type_t result;
489   char *sample;
490   int n;
491   gpgme_off_t off;
492
493   (void)reserved;
494
495   /* Check whether we can seek the data object.  */
496   off = gpgme_data_seek (dh, 0, SEEK_CUR);
497   if (off == (gpgme_off_t)(-1))
498     return GPGME_DATA_TYPE_INVALID;
499
500   /* Allocate a buffer and read the data. */
501   sample = malloc (SAMPLE_SIZE);
502   if (!sample)
503     return GPGME_DATA_TYPE_INVALID; /* Ooops.  */
504   n = gpgme_data_read (dh, sample, SAMPLE_SIZE - 1);
505   if (n < 0)
506     {
507       free (sample);
508       return GPGME_DATA_TYPE_INVALID; /* Ooops.  */
509     }
510   sample[n] = 0;  /* (Required for our string functions.)  */
511
512   result = basic_detection (sample, n);
513   free (sample);
514   gpgme_data_seek (dh, off, SEEK_SET);
515
516   return result;
517 }