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