Qt: Add testTofuSignCount
[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 /* This is probably an armored "PGP MESSAGE" which can encode
275  * different PGP data types.  STRING is modified after a call to this
276  * fucntion. */
277 static gpgme_data_type_t
278 inspect_pgp_message (char *string)
279 {
280   struct b64state state;
281   size_t nbytes;
282
283   if (_gpgme_b64dec_start (&state, ""))
284     return GPGME_DATA_TYPE_INVALID; /* oops */
285
286   if (_gpgme_b64dec_proc (&state, string, strlen (string), &nbytes))
287     {
288       _gpgme_b64dec_finish (&state);
289       return GPGME_DATA_TYPE_UNKNOWN; /* bad encoding etc. */
290     }
291   _gpgme_b64dec_finish (&state);
292   string[nbytes] = 0; /* Better append a Nul. */
293
294   return pgp_binary_detection (string, nbytes);
295 }
296
297
298 /* Note that DATA may be binary but a final nul is required so that
299    string operations will find a terminator.
300
301    Returns: GPGME_DATA_TYPE_xxxx */
302 static gpgme_data_type_t
303 basic_detection (char *data, size_t datalen)
304 {
305   tlvinfo_t ti;
306   const char *s;
307   size_t n;
308   int maybe_p12 = 0;
309
310   if (datalen < 24) /* Object is probably too short for detection.  */
311     return GPGME_DATA_TYPE_UNKNOWN;
312
313   /* This is a common example of a CMS object - it is obvious that we
314      only need to read a few bytes to get to the OID:
315   30 82 0B 59 06 09 2A 86 48 86 F7 0D 01 07 02 A0 82 0B 4A 30 82 0B 46 02
316   ----------- ++++++++++++++++++++++++++++++++
317   SEQUENCE    OID (signedData)
318   (2 byte len)
319
320     A PKCS#12 message is:
321
322   30 82 08 59 02 01 03 30 82 08 1F 06 09 2A 86 48 86 F7 0D 01 07 01 A0 82
323   ----------- ++++++++ ----------- ++++++++++++++++++++++++++++++++
324   SEQUENCE    INTEGER  SEQUENCE    OID (data)
325
326     A X.509 certificate is:
327
328   30 82 05 B8 30 82 04 A0 A0 03 02 01 02 02 07 15 46 A0 BF 30 07 39 30 0D
329   ----------- +++++++++++ ----- ++++++++ --------------------------
330   SEQUENCE    SEQUENCE    [0]   INTEGER  INTEGER                    SEQU
331               (tbs)            (version) (s/n)                      (Algo)
332
333     Thus we need to read at least 22 bytes, we add 2 bytes to cope with
334     length headers stored with 4 bytes.
335   */
336
337
338   s = data;
339   n = datalen;
340
341   if (parse_tlv (&s, &n, &ti))
342     goto try_pgp; /* Not properly BER encoded.  */
343   if (!(ti.cls == ASN1_CLASS_UNIVERSAL && ti.tag == ASN1_TAG_SEQUENCE
344         && ti.is_cons))
345     goto try_pgp; /* A CMS object always starts with a sequence.  */
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 && n >= ti.length)
351     {
352       if (parse_tlv (&s, &n, &ti))
353         goto try_pgp;
354       if (!(ti.cls == ASN1_CLASS_CONTEXT && ti.tag == 0
355             && ti.is_cons && ti.length == 3 && n >= ti.length))
356         goto try_pgp;
357
358       if (parse_tlv (&s, &n, &ti))
359         goto try_pgp;
360       if (!(ti.cls == ASN1_CLASS_UNIVERSAL && ti.tag == ASN1_TAG_INTEGER
361             && !ti.is_cons && ti.length == 1 && n && (*s == 1 || *s == 2)))
362         goto try_pgp;
363       s++;
364       n--;
365       if (!(ti.cls == ASN1_CLASS_UNIVERSAL && ti.tag == ASN1_TAG_INTEGER
366             && !ti.is_cons))
367         goto try_pgp;
368       /* Because the now following S/N may be larger than the sample
369          data we have, we stop parsing here and don't check for the
370          algorithm ID.  */
371       return GPGME_DATA_TYPE_X509_CERT;
372     }
373   if (ti.cls == ASN1_CLASS_UNIVERSAL && ti.tag == ASN1_TAG_INTEGER
374       && !ti.is_cons && ti.length == 1 && n && *s == 3)
375     {
376       maybe_p12 = 1;
377       s++;
378       n--;
379       if (parse_tlv (&s, &n, &ti))
380         goto try_pgp;
381       if (!(ti.cls == ASN1_CLASS_UNIVERSAL && ti.tag == ASN1_TAG_SEQUENCE
382             && ti.is_cons))
383         goto try_pgp;
384       if (parse_tlv (&s, &n, &ti))
385         goto try_pgp;
386     }
387   if (ti.cls == ASN1_CLASS_UNIVERSAL && ti.tag == ASN1_TAG_OBJECT_ID
388       && !ti.is_cons && ti.length && n >= ti.length)
389     {
390       if (ti.length == 9)
391         {
392           if (!memcmp (s, "\x2A\x86\x48\x86\xF7\x0D\x01\x07\x01", 9))
393             {
394               /* Data.  */
395               return (maybe_p12 ? GPGME_DATA_TYPE_PKCS12
396                       /*     */ : GPGME_DATA_TYPE_CMS_OTHER);
397             }
398           if (!memcmp (s, "\x2A\x86\x48\x86\xF7\x0D\x01\x07\x02", 9))
399             {
400               /* Signed Data.  */
401               return (maybe_p12 ? GPGME_DATA_TYPE_PKCS12
402                       /*     */ : GPGME_DATA_TYPE_CMS_SIGNED);
403             }
404           if (!memcmp (s, "\x2A\x86\x48\x86\xF7\x0D\x01\x07\x03", 9))
405             return GPGME_DATA_TYPE_CMS_ENCRYPTED; /* Enveloped Data.  */
406           if (!memcmp (s, "\x2A\x86\x48\x86\xF7\x0D\x01\x07\x05", 9))
407             return GPGME_DATA_TYPE_CMS_OTHER; /* Digested Data.  */
408           if (!memcmp (s, "\x2A\x86\x48\x86\xF7\x0D\x01\x07\x06", 9))
409             return GPGME_DATA_TYPE_CMS_OTHER; /* Encrypted Data.  */
410         }
411       else if (ti.length == 11)
412         {
413           if (!memcmp (s, "\x2A\x86\x48\x86\xF7\x0D\x01\x09\x10\x01\x02", 11))
414             return GPGME_DATA_TYPE_CMS_OTHER; /* Auth Data.  */
415         }
416     }
417
418
419  try_pgp:
420   /* Check whether this might be a non-armored PGP message.  We need
421      to do this before checking for armor lines, so that we don't get
422      fooled by armored messages inside a signed binary PGP message.  */
423   if ((data[0] & 0x80))
424     {
425       /* That might be a binary PGP message.  At least it is not plain
426          ASCII.  Of course this might be certain lead-in text of
427          armored CMS messages.  However, I am not sure whether this is
428          at all defined and in any case it is uncommon.  Thus we don't
429          do any further plausibility checks but stupidly assume no CMS
430          armored data will follow.  */
431       return pgp_binary_detection (data, datalen);
432     }
433
434   /* Now check whether there are armor lines.  */
435   for (s = data; s && *s; s = (*s=='\n')?(s+1):((s=strchr (s,'\n'))?(s+1):s))
436     {
437       if (!strncmp (s, "-----BEGIN ", 11))
438         {
439           if (!strncmp (s+11, "SIGNED ", 7))
440             return GPGME_DATA_TYPE_CMS_SIGNED;
441           if (!strncmp (s+11, "ENCRYPTED ", 10))
442             return GPGME_DATA_TYPE_CMS_ENCRYPTED;
443           if (!strncmp (s+11, "PGP ", 4))
444             {
445               if (!strncmp (s+15, "SIGNATURE", 9))
446                 return GPGME_DATA_TYPE_PGP_SIGNATURE;
447               if (!strncmp (s+15, "SIGNED MESSAGE", 14))
448                 return GPGME_DATA_TYPE_PGP_SIGNED;
449               if (!strncmp (s+15, "PUBLIC KEY BLOCK", 16))
450                 return GPGME_DATA_TYPE_PGP_KEY;
451               if (!strncmp (s+15, "PRIVATE KEY BLOCK", 17))
452                 return GPGME_DATA_TYPE_PGP_KEY;
453               if (!strncmp (s+15, "SECRET KEY BLOCK", 16))
454                 return GPGME_DATA_TYPE_PGP_KEY;
455               if (!strncmp (s+15, "ARMORED FILE", 12))
456                 return GPGME_DATA_TYPE_UNKNOWN;
457
458               return inspect_pgp_message (data);
459             }
460           if (!strncmp (s+11, "CERTIFICATE", 11))
461             return GPGME_DATA_TYPE_X509_CERT;
462           if (!strncmp (s+11, "PKCS12", 6))
463             return GPGME_DATA_TYPE_PKCS12;
464           return GPGME_DATA_TYPE_CMS_OTHER; /* Not PGP, thus we assume CMS.  */
465         }
466     }
467
468   return GPGME_DATA_TYPE_UNKNOWN;
469 }
470
471
472 /* Try to detect the type of the data.  Note that this function works
473    only on seekable data objects.  The function tries to reset the
474    file pointer but there is no guarantee that it will work.
475
476    FIXME: We may want to add internal buffering so that this function
477    can be implemented for allmost all kind of data objects.
478  */
479 gpgme_data_type_t
480 gpgme_data_identify (gpgme_data_t dh, int reserved)
481 {
482   gpgme_data_type_t result;
483   char *sample;
484   int n;
485   gpgme_off_t off;
486
487   /* Check whether we can seek the data object.  */
488   off = gpgme_data_seek (dh, 0, SEEK_CUR);
489   if (off == (gpgme_off_t)(-1))
490     return GPGME_DATA_TYPE_INVALID;
491
492   /* Allocate a buffer and read the data. */
493   sample = malloc (SAMPLE_SIZE);
494   if (!sample)
495     return GPGME_DATA_TYPE_INVALID; /* Ooops.  */
496   n = gpgme_data_read (dh, sample, SAMPLE_SIZE - 1);
497   if (n < 0)
498     {
499       free (sample);
500       return GPGME_DATA_TYPE_INVALID; /* Ooops.  */
501     }
502   sample[n] = 0;  /* (Required for our string functions.)  */
503
504   result = basic_detection (sample, n);
505   free (sample);
506   gpgme_data_seek (dh, off, SEEK_SET);
507
508   return result;
509 }