Line data Source code
1 : /*
2 : * pgp-decrypt.c
3 : * OpenPGP decrypt.
4 : *
5 : * Copyright (c) 2005 Marko Kreen
6 : * All rights reserved.
7 : *
8 : * Redistribution and use in source and binary forms, with or without
9 : * modification, are permitted provided that the following conditions
10 : * are met:
11 : * 1. Redistributions of source code must retain the above copyright
12 : * notice, this list of conditions and the following disclaimer.
13 : * 2. Redistributions in binary form must reproduce the above copyright
14 : * notice, this list of conditions and the following disclaimer in the
15 : * documentation and/or other materials provided with the distribution.
16 : *
17 : * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 : * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 : * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 : * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21 : * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 : * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 : * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 : * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 : * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 : * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 : * SUCH DAMAGE.
28 : *
29 : * contrib/pgcrypto/pgp-decrypt.c
30 : */
31 :
32 : #include "postgres.h"
33 :
34 : #include "mbuf.h"
35 : #include "pgp.h"
36 : #include "px.h"
37 :
38 : #define NO_CTX_SIZE 0
39 : #define ALLOW_CTX_SIZE 1
40 : #define NO_COMPR 0
41 : #define ALLOW_COMPR 1
42 : #define NO_MDC 0
43 : #define NEED_MDC 1
44 :
45 : #define PKT_NORMAL 1
46 : #define PKT_STREAM 2
47 : #define PKT_CONTEXT 3
48 :
49 : #define MAX_CHUNK (16*1024*1024)
50 :
51 : static int
52 273 : parse_new_len(PullFilter *src, int *len_p)
53 : {
54 : uint8 b;
55 : int len;
56 273 : int pkttype = PKT_NORMAL;
57 :
58 273 : GETBYTE(src, b);
59 273 : if (b <= 191)
60 247 : len = b;
61 26 : else if (b >= 192 && b <= 223)
62 : {
63 10 : len = ((unsigned) (b) - 192) << 8;
64 10 : GETBYTE(src, b);
65 10 : len += 192 + b;
66 : }
67 16 : else if (b == 255)
68 : {
69 1 : GETBYTE(src, b);
70 1 : len = b;
71 1 : GETBYTE(src, b);
72 1 : len = (len << 8) | b;
73 1 : GETBYTE(src, b);
74 1 : len = (len << 8) | b;
75 1 : GETBYTE(src, b);
76 1 : len = (len << 8) | b;
77 : }
78 : else
79 : {
80 15 : len = 1 << (b & 0x1F);
81 15 : pkttype = PKT_STREAM;
82 : }
83 :
84 273 : if (len < 0 || len > MAX_CHUNK)
85 : {
86 0 : px_debug("parse_new_len: weird length");
87 0 : return PXE_PGP_CORRUPT_DATA;
88 : }
89 :
90 273 : *len_p = len;
91 273 : return pkttype;
92 : }
93 :
94 : static int
95 214 : parse_old_len(PullFilter *src, int *len_p, int lentype)
96 : {
97 : uint8 b;
98 : int len;
99 :
100 214 : GETBYTE(src, b);
101 214 : len = b;
102 :
103 214 : if (lentype == 1)
104 : {
105 102 : GETBYTE(src, b);
106 102 : len = (len << 8) | b;
107 : }
108 112 : else if (lentype == 2)
109 : {
110 0 : GETBYTE(src, b);
111 0 : len = (len << 8) | b;
112 0 : GETBYTE(src, b);
113 0 : len = (len << 8) | b;
114 0 : GETBYTE(src, b);
115 0 : len = (len << 8) | b;
116 : }
117 :
118 214 : if (len < 0 || len > MAX_CHUNK)
119 : {
120 0 : px_debug("parse_old_len: weird length");
121 0 : return PXE_PGP_CORRUPT_DATA;
122 : }
123 214 : *len_p = len;
124 214 : return PKT_NORMAL;
125 : }
126 :
127 : /* returns pkttype or 0 on eof */
128 : int
129 654 : pgp_parse_pkt_hdr(PullFilter *src, uint8 *tag, int *len_p, int allow_ctx)
130 : {
131 : int lentype;
132 : int res;
133 : uint8 *p;
134 :
135 : /* EOF is normal here, thus we don't use GETBYTE */
136 654 : res = pullf_read(src, 1, &p);
137 654 : if (res < 0)
138 0 : return res;
139 654 : if (res == 0)
140 175 : return 0;
141 :
142 479 : if ((*p & 0x80) == 0)
143 : {
144 2 : px_debug("pgp_parse_pkt_hdr: not pkt hdr");
145 2 : return PXE_PGP_CORRUPT_DATA;
146 : }
147 :
148 477 : if (*p & 0x40)
149 : {
150 260 : *tag = *p & 0x3f;
151 260 : res = parse_new_len(src, len_p);
152 : }
153 : else
154 : {
155 217 : lentype = *p & 3;
156 217 : *tag = (*p >> 2) & 0x0F;
157 217 : if (lentype == 3)
158 3 : res = allow_ctx ? PKT_CONTEXT : PXE_PGP_CORRUPT_DATA;
159 : else
160 214 : res = parse_old_len(src, len_p, lentype);
161 : }
162 477 : return res;
163 : }
164 :
165 : /*
166 : * Packet reader
167 : */
168 : struct PktData
169 : {
170 : int type;
171 : int len;
172 : };
173 :
174 : static int
175 2590 : pktreader_pull(void *priv, PullFilter *src, int len,
176 : uint8 **data_p, uint8 *buf, int buflen)
177 : {
178 : int res;
179 2590 : struct PktData *pkt = priv;
180 :
181 : /* PKT_CONTEXT means: whatever there is */
182 2590 : if (pkt->type == PKT_CONTEXT)
183 0 : return pullf_read(src, len, data_p);
184 :
185 2603 : while (pkt->len == 0)
186 : {
187 : /* this was last chunk in stream */
188 404 : if (pkt->type == PKT_NORMAL)
189 391 : return 0;
190 :
191 : /* next chunk in stream */
192 13 : res = parse_new_len(src, &pkt->len);
193 13 : if (res < 0)
194 0 : return res;
195 13 : pkt->type = res;
196 : }
197 :
198 2199 : if (len > pkt->len)
199 264 : len = pkt->len;
200 :
201 2199 : res = pullf_read(src, len, data_p);
202 2199 : if (res > 0)
203 2199 : pkt->len -= res;
204 :
205 2199 : return res;
206 : }
207 :
208 : static void
209 474 : pktreader_free(void *priv)
210 : {
211 474 : struct PktData *pkt = priv;
212 :
213 474 : px_memset(pkt, 0, sizeof(*pkt));
214 474 : pfree(pkt);
215 474 : }
216 :
217 : static struct PullFilterOps pktreader_filter = {
218 : NULL, pktreader_pull, pktreader_free
219 : };
220 :
221 : /* needs helper function to pass several parameters */
222 : int
223 474 : pgp_create_pkt_reader(PullFilter **pf_p, PullFilter *src, int len,
224 : int pkttype, PGP_Context *ctx)
225 : {
226 : int res;
227 474 : struct PktData *pkt = palloc_object(struct PktData);
228 :
229 474 : pkt->type = pkttype;
230 474 : pkt->len = len;
231 474 : res = pullf_create(pf_p, &pktreader_filter, pkt, src);
232 474 : if (res < 0)
233 0 : pfree(pkt);
234 474 : return res;
235 : }
236 :
237 : /*
238 : * Prefix check filter
239 : * https://tools.ietf.org/html/rfc4880#section-5.7
240 : * https://tools.ietf.org/html/rfc4880#section-5.13
241 : */
242 :
243 : static int
244 73 : prefix_init(void **priv_p, void *arg, PullFilter *src)
245 : {
246 73 : PGP_Context *ctx = arg;
247 : int len;
248 : int res;
249 : uint8 *buf;
250 : uint8 tmpbuf[PGP_MAX_BLOCK + 2];
251 :
252 73 : len = pgp_get_cipher_block_size(ctx->cipher_algo);
253 : /* Make sure we have space for prefix */
254 73 : if (len > PGP_MAX_BLOCK)
255 0 : return PXE_BUG;
256 :
257 73 : res = pullf_read_max(src, len + 2, &buf, tmpbuf);
258 73 : if (res < 0)
259 0 : return res;
260 73 : if (res != len + 2)
261 : {
262 0 : px_debug("prefix_init: short read");
263 0 : px_memset(tmpbuf, 0, sizeof(tmpbuf));
264 0 : return PXE_PGP_CORRUPT_DATA;
265 : }
266 :
267 73 : if (buf[len - 2] != buf[len] || buf[len - 1] != buf[len + 1])
268 : {
269 4 : px_debug("prefix_init: corrupt prefix");
270 : /* report error in pgp_decrypt() */
271 4 : ctx->corrupt_prefix = 1;
272 : }
273 73 : px_memset(tmpbuf, 0, sizeof(tmpbuf));
274 73 : return 0;
275 : }
276 :
277 : static struct PullFilterOps prefix_filter = {
278 : prefix_init, NULL, NULL
279 : };
280 :
281 :
282 : /*
283 : * Decrypt filter
284 : */
285 :
286 : static int
287 77 : decrypt_init(void **priv_p, void *arg, PullFilter *src)
288 : {
289 77 : PGP_CFB *cfb = arg;
290 :
291 77 : *priv_p = cfb;
292 :
293 : /* we need to write somewhere, so ask for a buffer */
294 77 : return 4096;
295 : }
296 :
297 : static int
298 815 : decrypt_read(void *priv, PullFilter *src, int len,
299 : uint8 **data_p, uint8 *buf, int buflen)
300 : {
301 815 : PGP_CFB *cfb = priv;
302 : uint8 *tmp;
303 : int res;
304 :
305 815 : res = pullf_read(src, len, &tmp);
306 815 : if (res > 0)
307 : {
308 740 : pgp_cfb_decrypt(cfb, tmp, res, buf);
309 740 : *data_p = buf;
310 : }
311 815 : return res;
312 : }
313 :
314 : struct PullFilterOps pgp_decrypt_filter = {
315 : decrypt_init, decrypt_read, NULL
316 : };
317 :
318 :
319 : /*
320 : * MDC hasher filter
321 : */
322 :
323 : static int
324 71 : mdc_init(void **priv_p, void *arg, PullFilter *src)
325 : {
326 71 : PGP_Context *ctx = arg;
327 :
328 71 : *priv_p = ctx;
329 71 : return pgp_load_digest(PGP_DIGEST_SHA1, &ctx->mdc_ctx);
330 : }
331 :
332 : static void
333 71 : mdc_free(void *priv)
334 : {
335 71 : PGP_Context *ctx = priv;
336 :
337 71 : if (ctx->use_mdcbuf_filter)
338 3 : return;
339 68 : px_md_free(ctx->mdc_ctx);
340 68 : ctx->mdc_ctx = NULL;
341 : }
342 :
343 : static int
344 65 : mdc_finish(PGP_Context *ctx, PullFilter *src, int len)
345 : {
346 : int res;
347 : uint8 hash[20];
348 : uint8 tmpbuf[20];
349 : uint8 *data;
350 :
351 : /* should not happen */
352 65 : if (ctx->use_mdcbuf_filter)
353 0 : return PXE_BUG;
354 :
355 : /* It's SHA1 */
356 65 : if (len != 20)
357 0 : return PXE_PGP_CORRUPT_DATA;
358 :
359 : /* mdc_read should not call px_md_update */
360 65 : ctx->in_mdc_pkt = 1;
361 :
362 : /* read data */
363 65 : res = pullf_read_max(src, len, &data, tmpbuf);
364 65 : if (res < 0)
365 0 : return res;
366 65 : if (res == 0)
367 : {
368 0 : px_debug("no mdc");
369 0 : return PXE_PGP_CORRUPT_DATA;
370 : }
371 :
372 : /* is the packet sane? */
373 65 : if (res != 20)
374 : {
375 0 : px_debug("mdc_finish: read failed, res=%d", res);
376 0 : return PXE_PGP_CORRUPT_DATA;
377 : }
378 :
379 : /*
380 : * ok, we got the hash, now check
381 : */
382 65 : px_md_finish(ctx->mdc_ctx, hash);
383 65 : res = memcmp(hash, data, 20);
384 65 : px_memset(hash, 0, 20);
385 65 : px_memset(tmpbuf, 0, sizeof(tmpbuf));
386 65 : if (res != 0)
387 : {
388 0 : px_debug("mdc_finish: mdc failed");
389 0 : return PXE_PGP_CORRUPT_DATA;
390 : }
391 65 : ctx->mdc_checked = 1;
392 65 : return 0;
393 : }
394 :
395 : static int
396 776 : mdc_read(void *priv, PullFilter *src, int len,
397 : uint8 **data_p, uint8 *buf, int buflen)
398 : {
399 : int res;
400 776 : PGP_Context *ctx = priv;
401 :
402 : /* skip this filter? */
403 776 : if (ctx->use_mdcbuf_filter || ctx->in_mdc_pkt)
404 137 : return pullf_read(src, len, data_p);
405 :
406 639 : res = pullf_read(src, len, data_p);
407 639 : if (res < 0)
408 0 : return res;
409 639 : if (res == 0)
410 : {
411 0 : px_debug("mdc_read: unexpected eof");
412 0 : return PXE_PGP_CORRUPT_DATA;
413 : }
414 639 : px_md_update(ctx->mdc_ctx, *data_p, res);
415 :
416 639 : return res;
417 : }
418 :
419 : static struct PullFilterOps mdc_filter = {
420 : mdc_init, mdc_read, mdc_free
421 : };
422 :
423 :
424 : /*
425 : * Combined Pkt reader and MDC hasher.
426 : *
427 : * For the case of SYMENCRYPTED_DATA_MDC packet, where
428 : * the data part has 'context length', which means
429 : * that data packet ends 22 bytes before end of parent
430 : * packet, which is silly.
431 : */
432 : #define MDCBUF_LEN 8192
433 : struct MDCBufData
434 : {
435 : PGP_Context *ctx;
436 : int eof;
437 : int buflen;
438 : int avail;
439 : uint8 *pos;
440 : int mdc_avail;
441 : uint8 mdc_buf[22];
442 : uint8 buf[MDCBUF_LEN];
443 : };
444 :
445 : static int
446 3 : mdcbuf_init(void **priv_p, void *arg, PullFilter *src)
447 : {
448 3 : PGP_Context *ctx = arg;
449 : struct MDCBufData *st;
450 :
451 3 : st = palloc0_object(struct MDCBufData);
452 3 : st->buflen = sizeof(st->buf);
453 3 : st->ctx = ctx;
454 3 : *priv_p = st;
455 :
456 : /* take over the work of mdc_filter */
457 3 : ctx->use_mdcbuf_filter = 1;
458 :
459 3 : return 0;
460 : }
461 :
462 : static int
463 3 : mdcbuf_finish(struct MDCBufData *st)
464 : {
465 : uint8 hash[20];
466 : int res;
467 :
468 3 : st->eof = 1;
469 :
470 3 : if (st->mdc_buf[0] != 0xD3 || st->mdc_buf[1] != 0x14)
471 : {
472 2 : px_debug("mdcbuf_finish: bad MDC pkt hdr");
473 2 : return PXE_PGP_CORRUPT_DATA;
474 : }
475 1 : px_md_update(st->ctx->mdc_ctx, st->mdc_buf, 2);
476 1 : px_md_finish(st->ctx->mdc_ctx, hash);
477 1 : res = memcmp(hash, st->mdc_buf + 2, 20);
478 1 : px_memset(hash, 0, 20);
479 1 : if (res)
480 : {
481 0 : px_debug("mdcbuf_finish: MDC does not match");
482 0 : res = PXE_PGP_CORRUPT_DATA;
483 : }
484 1 : return res;
485 : }
486 :
487 : static void
488 6 : mdcbuf_load_data(struct MDCBufData *st, uint8 *src, int len)
489 : {
490 6 : uint8 *dst = st->pos + st->avail;
491 :
492 6 : memcpy(dst, src, len);
493 6 : px_md_update(st->ctx->mdc_ctx, src, len);
494 6 : st->avail += len;
495 6 : }
496 :
497 : static void
498 3 : mdcbuf_load_mdc(struct MDCBufData *st, uint8 *src, int len)
499 : {
500 3 : memmove(st->mdc_buf + st->mdc_avail, src, len);
501 3 : st->mdc_avail += len;
502 3 : }
503 :
504 : static int
505 6 : mdcbuf_refill(struct MDCBufData *st, PullFilter *src)
506 : {
507 : uint8 *data;
508 : int res;
509 : int need;
510 :
511 : /* put avail data in start */
512 6 : if (st->avail > 0 && st->pos != st->buf)
513 3 : memmove(st->buf, st->pos, st->avail);
514 6 : st->pos = st->buf;
515 :
516 : /* read new data */
517 6 : need = st->buflen + 22 - st->avail - st->mdc_avail;
518 6 : res = pullf_read(src, need, &data);
519 6 : if (res < 0)
520 0 : return res;
521 6 : if (res == 0)
522 3 : return mdcbuf_finish(st);
523 :
524 : /* add to buffer */
525 3 : if (res >= 22)
526 : {
527 3 : mdcbuf_load_data(st, st->mdc_buf, st->mdc_avail);
528 3 : st->mdc_avail = 0;
529 :
530 3 : mdcbuf_load_data(st, data, res - 22);
531 3 : mdcbuf_load_mdc(st, data + res - 22, 22);
532 : }
533 : else
534 : {
535 0 : int canmove = st->mdc_avail + res - 22;
536 :
537 0 : if (canmove > 0)
538 : {
539 0 : mdcbuf_load_data(st, st->mdc_buf, canmove);
540 0 : st->mdc_avail -= canmove;
541 0 : memmove(st->mdc_buf, st->mdc_buf + canmove, st->mdc_avail);
542 : }
543 0 : mdcbuf_load_mdc(st, data, res);
544 : }
545 3 : return 0;
546 : }
547 :
548 : static int
549 10 : mdcbuf_read(void *priv, PullFilter *src, int len,
550 : uint8 **data_p, uint8 *buf, int buflen)
551 : {
552 10 : struct MDCBufData *st = priv;
553 : int res;
554 :
555 10 : if (!st->eof && len > st->avail)
556 : {
557 6 : res = mdcbuf_refill(st, src);
558 6 : if (res < 0)
559 2 : return res;
560 : }
561 :
562 8 : if (len > st->avail)
563 2 : len = st->avail;
564 :
565 8 : *data_p = st->pos;
566 8 : st->pos += len;
567 8 : st->avail -= len;
568 8 : return len;
569 : }
570 :
571 : static void
572 3 : mdcbuf_free(void *priv)
573 : {
574 3 : struct MDCBufData *st = priv;
575 :
576 3 : px_md_free(st->ctx->mdc_ctx);
577 3 : st->ctx->mdc_ctx = NULL;
578 3 : px_memset(st, 0, sizeof(*st));
579 3 : pfree(st);
580 3 : }
581 :
582 : static struct PullFilterOps mdcbuf_filter = {
583 : mdcbuf_init, mdcbuf_read, mdcbuf_free
584 : };
585 :
586 :
587 : /*
588 : * Decrypt separate session key
589 : */
590 : static int
591 4 : decrypt_key(PGP_Context *ctx, const uint8 *src, int len)
592 : {
593 : int res;
594 : uint8 algo;
595 : PGP_CFB *cfb;
596 :
597 4 : res = pgp_cfb_create(&cfb, ctx->s2k_cipher_algo,
598 4 : ctx->s2k.key, ctx->s2k.key_len, 0, NULL);
599 4 : if (res < 0)
600 0 : return res;
601 :
602 4 : pgp_cfb_decrypt(cfb, src, 1, &algo);
603 4 : src++;
604 4 : len--;
605 :
606 4 : pgp_cfb_decrypt(cfb, src, len, ctx->sess_key);
607 4 : pgp_cfb_free(cfb);
608 4 : ctx->sess_key_len = len;
609 4 : ctx->cipher_algo = algo;
610 :
611 4 : if (pgp_get_cipher_key_size(algo) != len)
612 : {
613 0 : px_debug("sesskey bad len: algo=%d, expected=%d, got=%d",
614 : algo, pgp_get_cipher_key_size(algo), len);
615 0 : return PXE_PGP_CORRUPT_DATA;
616 : }
617 4 : return 0;
618 : }
619 :
620 : /*
621 : * Handle key packet
622 : */
623 : static int
624 60 : parse_symenc_sesskey(PGP_Context *ctx, PullFilter *src)
625 : {
626 : uint8 *p;
627 : int res;
628 : uint8 tmpbuf[PGP_MAX_KEY + 2];
629 : uint8 ver;
630 :
631 60 : GETBYTE(src, ver);
632 60 : GETBYTE(src, ctx->s2k_cipher_algo);
633 60 : if (ver != 4)
634 : {
635 0 : px_debug("bad key pkt ver");
636 0 : return PXE_PGP_CORRUPT_DATA;
637 : }
638 :
639 : /*
640 : * read S2K info
641 : */
642 60 : res = pgp_s2k_read(src, &ctx->s2k);
643 60 : if (res < 0)
644 0 : return res;
645 60 : ctx->s2k_mode = ctx->s2k.mode;
646 60 : ctx->s2k_count = s2k_decode_count(ctx->s2k.iter);
647 60 : ctx->s2k_digest_algo = ctx->s2k.digest_algo;
648 :
649 : /*
650 : * generate key from password
651 : */
652 60 : res = pgp_s2k_process(&ctx->s2k, ctx->s2k_cipher_algo,
653 : ctx->sym_key, ctx->sym_key_len);
654 60 : if (res < 0)
655 0 : return res;
656 :
657 : /*
658 : * do we have separate session key?
659 : */
660 60 : res = pullf_read_max(src, PGP_MAX_KEY + 2, &p, tmpbuf);
661 60 : if (res < 0)
662 0 : return res;
663 :
664 60 : if (res == 0)
665 : {
666 : /*
667 : * no, s2k key is session key
668 : */
669 56 : memcpy(ctx->sess_key, ctx->s2k.key, ctx->s2k.key_len);
670 56 : ctx->sess_key_len = ctx->s2k.key_len;
671 56 : ctx->cipher_algo = ctx->s2k_cipher_algo;
672 56 : res = 0;
673 56 : ctx->use_sess_key = 0;
674 : }
675 : else
676 : {
677 : /*
678 : * yes, decrypt it
679 : */
680 4 : if (res < 17 || res > PGP_MAX_KEY + 1)
681 : {
682 0 : px_debug("expect key, but bad data");
683 0 : return PXE_PGP_CORRUPT_DATA;
684 : }
685 4 : ctx->use_sess_key = 1;
686 4 : res = decrypt_key(ctx, p, res);
687 : }
688 :
689 60 : px_memset(tmpbuf, 0, sizeof(tmpbuf));
690 60 : return res;
691 : }
692 :
693 : static int
694 2 : copy_crlf(MBuf *dst, uint8 *data, int len, int *got_cr)
695 : {
696 2 : uint8 *data_end = data + len;
697 : uint8 tmpbuf[1024];
698 2 : uint8 *tmp_end = tmpbuf + sizeof(tmpbuf);
699 : uint8 *p;
700 : int res;
701 :
702 2 : p = tmpbuf;
703 2 : if (*got_cr)
704 : {
705 0 : if (*data != '\n')
706 0 : *p++ = '\r';
707 0 : *got_cr = 0;
708 : }
709 47 : while (data < data_end)
710 : {
711 47 : if (*data == '\r')
712 : {
713 14 : if (data + 1 < data_end)
714 : {
715 12 : if (*(data + 1) == '\n')
716 7 : data++;
717 : }
718 : else
719 : {
720 2 : *got_cr = 1;
721 2 : break;
722 : }
723 : }
724 45 : *p++ = *data++;
725 45 : if (p >= tmp_end)
726 : {
727 0 : res = mbuf_append(dst, tmpbuf, p - tmpbuf);
728 0 : if (res < 0)
729 0 : return res;
730 0 : p = tmpbuf;
731 : }
732 : }
733 2 : if (p - tmpbuf > 0)
734 : {
735 2 : res = mbuf_append(dst, tmpbuf, p - tmpbuf);
736 2 : if (res < 0)
737 0 : return res;
738 : }
739 2 : px_memset(tmpbuf, 0, sizeof(tmpbuf));
740 2 : return 0;
741 : }
742 :
743 : static int
744 68 : parse_literal_data(PGP_Context *ctx, MBuf *dst, PullFilter *pkt)
745 : {
746 : int type;
747 : int name_len;
748 : int res;
749 : uint8 *buf;
750 : uint8 tmpbuf[4];
751 68 : int got_cr = 0;
752 :
753 68 : GETBYTE(pkt, type);
754 68 : GETBYTE(pkt, name_len);
755 :
756 : /* skip name */
757 91 : while (name_len > 0)
758 : {
759 23 : res = pullf_read(pkt, name_len, &buf);
760 23 : if (res < 0)
761 0 : return res;
762 23 : if (res == 0)
763 0 : break;
764 23 : name_len -= res;
765 : }
766 68 : if (name_len > 0)
767 : {
768 0 : px_debug("parse_literal_data: unexpected eof");
769 0 : return PXE_PGP_CORRUPT_DATA;
770 : }
771 :
772 : /* skip date */
773 68 : res = pullf_read_max(pkt, 4, &buf, tmpbuf);
774 68 : if (res != 4)
775 : {
776 0 : px_debug("parse_literal_data: unexpected eof");
777 0 : return PXE_PGP_CORRUPT_DATA;
778 : }
779 68 : px_memset(tmpbuf, 0, 4);
780 :
781 : /*
782 : * If called from an SQL function that returns text, pgp_decrypt() rejects
783 : * inputs not self-identifying as text.
784 : */
785 68 : if (ctx->text_mode)
786 63 : if (type != 't' && type != 'u')
787 : {
788 4 : px_debug("parse_literal_data: data type=%c", type);
789 4 : ctx->unexpected_binary = true;
790 : }
791 :
792 68 : ctx->unicode_mode = (type == 'u') ? 1 : 0;
793 :
794 : /* read data */
795 : while (1)
796 : {
797 157 : res = pullf_read(pkt, 32 * 1024, &buf);
798 157 : if (res <= 0)
799 68 : break;
800 :
801 89 : if (ctx->text_mode && ctx->convert_crlf)
802 2 : res = copy_crlf(dst, buf, res, &got_cr);
803 : else
804 87 : res = mbuf_append(dst, buf, res);
805 89 : if (res < 0)
806 0 : break;
807 : }
808 68 : if (res >= 0 && got_cr)
809 2 : res = mbuf_append(dst, (const uint8 *) "\r", 1);
810 68 : return res;
811 : }
812 :
813 : /* process_data_packets and parse_compressed_data call each other */
814 : static int process_data_packets(PGP_Context *ctx, MBuf *dst,
815 : PullFilter *src, int allow_compr, int need_mdc);
816 :
817 : static int
818 6 : parse_compressed_data(PGP_Context *ctx, MBuf *dst, PullFilter *pkt)
819 : {
820 : int res;
821 : uint8 type;
822 : PullFilter *pf_decompr;
823 : uint8 *discard_buf;
824 :
825 6 : GETBYTE(pkt, type);
826 :
827 6 : ctx->compress_algo = type;
828 6 : switch (type)
829 : {
830 0 : case PGP_COMPR_NONE:
831 0 : res = process_data_packets(ctx, dst, pkt, NO_COMPR, NO_MDC);
832 0 : break;
833 :
834 4 : case PGP_COMPR_ZIP:
835 : case PGP_COMPR_ZLIB:
836 4 : res = pgp_decompress_filter(&pf_decompr, ctx, pkt);
837 4 : if (res >= 0)
838 : {
839 4 : res = process_data_packets(ctx, dst, pf_decompr,
840 : NO_COMPR, NO_MDC);
841 4 : pullf_free(pf_decompr);
842 : }
843 4 : break;
844 :
845 2 : case PGP_COMPR_BZIP2:
846 2 : px_debug("parse_compressed_data: bzip2 unsupported");
847 : /* report error in pgp_decrypt() */
848 2 : ctx->unsupported_compr = 1;
849 :
850 : /*
851 : * Discard the compressed data, allowing it to first affect any
852 : * MDC digest computation.
853 : */
854 : while (1)
855 : {
856 3 : res = pullf_read(pkt, 32 * 1024, &discard_buf);
857 3 : if (res <= 0)
858 2 : break;
859 : }
860 :
861 2 : break;
862 :
863 0 : default:
864 0 : px_debug("parse_compressed_data: unknown compr type");
865 0 : res = PXE_PGP_CORRUPT_DATA;
866 : }
867 :
868 6 : return res;
869 : }
870 :
871 : static int
872 77 : process_data_packets(PGP_Context *ctx, MBuf *dst, PullFilter *src,
873 : int allow_compr, int need_mdc)
874 : {
875 : uint8 tag;
876 : int len,
877 : res;
878 77 : int got_data = 0;
879 77 : int got_mdc = 0;
880 77 : PullFilter *pkt = NULL;
881 :
882 : while (1)
883 : {
884 214 : res = pgp_parse_pkt_hdr(src, &tag, &len, ALLOW_CTX_SIZE);
885 214 : if (res <= 0)
886 74 : break;
887 :
888 :
889 : /* mdc packet should be last */
890 140 : if (got_mdc)
891 : {
892 0 : px_debug("process_data_packets: data after mdc");
893 0 : res = PXE_PGP_CORRUPT_DATA;
894 0 : break;
895 : }
896 :
897 : /*
898 : * Context length inside SYMENCRYPTED_DATA_MDC packet needs special
899 : * handling.
900 : */
901 140 : if (need_mdc && res == PKT_CONTEXT)
902 3 : res = pullf_create(&pkt, &mdcbuf_filter, ctx, src);
903 : else
904 137 : res = pgp_create_pkt_reader(&pkt, src, len, res, ctx);
905 140 : if (res < 0)
906 0 : break;
907 :
908 140 : switch (tag)
909 : {
910 68 : case PGP_PKT_LITERAL_DATA:
911 68 : got_data = 1;
912 68 : res = parse_literal_data(ctx, dst, pkt);
913 68 : break;
914 6 : case PGP_PKT_COMPRESSED_DATA:
915 6 : if (allow_compr == 0)
916 : {
917 0 : px_debug("process_data_packets: unexpected compression");
918 0 : res = PXE_PGP_CORRUPT_DATA;
919 : }
920 6 : else if (got_data)
921 : {
922 : /*
923 : * compr data must be alone
924 : */
925 0 : px_debug("process_data_packets: only one cmpr pkt allowed");
926 0 : res = PXE_PGP_CORRUPT_DATA;
927 : }
928 : else
929 : {
930 6 : got_data = 1;
931 6 : res = parse_compressed_data(ctx, dst, pkt);
932 : }
933 6 : break;
934 65 : case PGP_PKT_MDC:
935 65 : if (need_mdc == NO_MDC)
936 : {
937 0 : px_debug("process_data_packets: unexpected MDC");
938 0 : res = PXE_PGP_CORRUPT_DATA;
939 0 : break;
940 : }
941 :
942 65 : res = mdc_finish(ctx, pkt, len);
943 65 : if (res >= 0)
944 65 : got_mdc = 1;
945 65 : break;
946 1 : default:
947 1 : px_debug("process_data_packets: unexpected pkt tag=%d", tag);
948 1 : res = PXE_PGP_CORRUPT_DATA;
949 : }
950 :
951 140 : pullf_free(pkt);
952 140 : pkt = NULL;
953 :
954 140 : if (res < 0)
955 3 : break;
956 : }
957 :
958 77 : if (pkt)
959 0 : pullf_free(pkt);
960 :
961 77 : if (res < 0)
962 5 : return res;
963 :
964 72 : if (!got_data)
965 : {
966 0 : px_debug("process_data_packets: no data");
967 0 : res = PXE_PGP_CORRUPT_DATA;
968 : }
969 72 : if (need_mdc && !got_mdc && !ctx->use_mdcbuf_filter)
970 : {
971 0 : px_debug("process_data_packets: got no mdc");
972 0 : res = PXE_PGP_CORRUPT_DATA;
973 : }
974 72 : return res;
975 : }
976 :
977 : static int
978 2 : parse_symenc_data(PGP_Context *ctx, PullFilter *pkt, MBuf *dst)
979 : {
980 : int res;
981 2 : PGP_CFB *cfb = NULL;
982 2 : PullFilter *pf_decrypt = NULL;
983 2 : PullFilter *pf_prefix = NULL;
984 :
985 2 : res = pgp_cfb_create(&cfb, ctx->cipher_algo,
986 2 : ctx->sess_key, ctx->sess_key_len, 1, NULL);
987 2 : if (res < 0)
988 0 : goto out;
989 :
990 2 : res = pullf_create(&pf_decrypt, &pgp_decrypt_filter, cfb, pkt);
991 2 : if (res < 0)
992 0 : goto out;
993 :
994 2 : res = pullf_create(&pf_prefix, &prefix_filter, ctx, pf_decrypt);
995 2 : if (res < 0)
996 0 : goto out;
997 :
998 2 : res = process_data_packets(ctx, dst, pf_prefix, ALLOW_COMPR, NO_MDC);
999 :
1000 2 : out:
1001 2 : if (pf_prefix)
1002 2 : pullf_free(pf_prefix);
1003 2 : if (pf_decrypt)
1004 2 : pullf_free(pf_decrypt);
1005 2 : if (cfb)
1006 2 : pgp_cfb_free(cfb);
1007 :
1008 2 : return res;
1009 : }
1010 :
1011 : static int
1012 71 : parse_symenc_mdc_data(PGP_Context *ctx, PullFilter *pkt, MBuf *dst)
1013 : {
1014 : int res;
1015 71 : PGP_CFB *cfb = NULL;
1016 71 : PullFilter *pf_decrypt = NULL;
1017 71 : PullFilter *pf_prefix = NULL;
1018 71 : PullFilter *pf_mdc = NULL;
1019 : uint8 ver;
1020 :
1021 71 : GETBYTE(pkt, ver);
1022 71 : if (ver != 1)
1023 : {
1024 0 : px_debug("parse_symenc_mdc_data: pkt ver != 1");
1025 0 : return PXE_PGP_CORRUPT_DATA;
1026 : }
1027 :
1028 71 : res = pgp_cfb_create(&cfb, ctx->cipher_algo,
1029 71 : ctx->sess_key, ctx->sess_key_len, 0, NULL);
1030 71 : if (res < 0)
1031 0 : goto out;
1032 :
1033 71 : res = pullf_create(&pf_decrypt, &pgp_decrypt_filter, cfb, pkt);
1034 71 : if (res < 0)
1035 0 : goto out;
1036 :
1037 71 : res = pullf_create(&pf_mdc, &mdc_filter, ctx, pf_decrypt);
1038 71 : if (res < 0)
1039 0 : goto out;
1040 :
1041 71 : res = pullf_create(&pf_prefix, &prefix_filter, ctx, pf_mdc);
1042 71 : if (res < 0)
1043 0 : goto out;
1044 :
1045 71 : res = process_data_packets(ctx, dst, pf_prefix, ALLOW_COMPR, NEED_MDC);
1046 :
1047 71 : out:
1048 71 : if (pf_prefix)
1049 71 : pullf_free(pf_prefix);
1050 71 : if (pf_mdc)
1051 71 : pullf_free(pf_mdc);
1052 71 : if (pf_decrypt)
1053 71 : pullf_free(pf_decrypt);
1054 71 : if (cfb)
1055 71 : pgp_cfb_free(cfb);
1056 :
1057 71 : return res;
1058 : }
1059 :
1060 : /*
1061 : * skip over packet contents
1062 : */
1063 : int
1064 159 : pgp_skip_packet(PullFilter *pkt)
1065 : {
1066 159 : int res = 1;
1067 : uint8 *tmp;
1068 :
1069 472 : while (res > 0)
1070 313 : res = pullf_read(pkt, 32 * 1024, &tmp);
1071 159 : return res;
1072 : }
1073 :
1074 : /*
1075 : * expect to be at packet end, any data is error
1076 : */
1077 : int
1078 28 : pgp_expect_packet_end(PullFilter *pkt)
1079 : {
1080 : int res;
1081 : uint8 *tmp;
1082 :
1083 28 : res = pullf_read(pkt, 32 * 1024, &tmp);
1084 28 : if (res > 0)
1085 : {
1086 0 : px_debug("pgp_expect_packet_end: got data");
1087 0 : return PXE_PGP_CORRUPT_DATA;
1088 : }
1089 28 : return res;
1090 : }
1091 :
1092 : int
1093 75 : pgp_decrypt(PGP_Context *ctx, MBuf *msrc, MBuf *mdst)
1094 : {
1095 : int res;
1096 75 : PullFilter *src = NULL;
1097 75 : PullFilter *pkt = NULL;
1098 : uint8 tag;
1099 : int len;
1100 75 : int got_key = 0;
1101 75 : int got_data = 0;
1102 :
1103 75 : res = pullf_create_mbuf_reader(&src, msrc);
1104 :
1105 223 : while (res >= 0)
1106 : {
1107 216 : res = pgp_parse_pkt_hdr(src, &tag, &len, NO_CTX_SIZE);
1108 216 : if (res <= 0)
1109 68 : break;
1110 :
1111 148 : res = pgp_create_pkt_reader(&pkt, src, len, res, ctx);
1112 148 : if (res < 0)
1113 0 : break;
1114 :
1115 148 : res = PXE_PGP_CORRUPT_DATA;
1116 148 : switch (tag)
1117 : {
1118 0 : case PGP_PKT_MARKER:
1119 0 : res = pgp_skip_packet(pkt);
1120 0 : break;
1121 15 : case PGP_PKT_PUBENCRYPTED_SESSKEY:
1122 : /* fixme: skip those */
1123 15 : res = pgp_parse_pubenc_sesskey(ctx, pkt);
1124 15 : got_key = 1;
1125 15 : break;
1126 60 : case PGP_PKT_SYMENCRYPTED_SESSKEY:
1127 60 : if (got_key)
1128 :
1129 : /*
1130 : * Theoretically, there could be several keys, both public
1131 : * and symmetric, all of which encrypt same session key.
1132 : * Decrypt should try with each one, before failing.
1133 : */
1134 0 : px_debug("pgp_decrypt: using first of several keys");
1135 : else
1136 : {
1137 60 : got_key = 1;
1138 60 : res = parse_symenc_sesskey(ctx, pkt);
1139 : }
1140 60 : break;
1141 2 : case PGP_PKT_SYMENCRYPTED_DATA:
1142 2 : if (!got_key)
1143 0 : px_debug("pgp_decrypt: have data but no key");
1144 2 : else if (got_data)
1145 0 : px_debug("pgp_decrypt: got second data packet");
1146 : else
1147 : {
1148 2 : got_data = 1;
1149 2 : ctx->disable_mdc = 1;
1150 2 : res = parse_symenc_data(ctx, pkt, mdst);
1151 : }
1152 2 : break;
1153 71 : case PGP_PKT_SYMENCRYPTED_DATA_MDC:
1154 71 : if (!got_key)
1155 0 : px_debug("pgp_decrypt: have data but no key");
1156 71 : else if (got_data)
1157 0 : px_debug("pgp_decrypt: several data pkts not supported");
1158 : else
1159 : {
1160 71 : got_data = 1;
1161 71 : ctx->disable_mdc = 0;
1162 71 : res = parse_symenc_mdc_data(ctx, pkt, mdst);
1163 : }
1164 71 : break;
1165 0 : default:
1166 0 : px_debug("pgp_decrypt: unknown tag: 0x%02x", tag);
1167 : }
1168 148 : pullf_free(pkt);
1169 148 : pkt = NULL;
1170 : }
1171 :
1172 75 : if (pkt)
1173 0 : pullf_free(pkt);
1174 :
1175 75 : if (src)
1176 75 : pullf_free(src);
1177 :
1178 75 : if (res < 0)
1179 7 : return res;
1180 :
1181 : /*
1182 : * Report a failure of the prefix_init() "quick check" now, rather than
1183 : * upon detection, to hinder timing attacks. pgcrypto is not generally
1184 : * secure against timing attacks, but this helps.
1185 : */
1186 68 : if (!got_data || ctx->corrupt_prefix)
1187 0 : return PXE_PGP_CORRUPT_DATA;
1188 :
1189 : /*
1190 : * Code interpreting purportedly-decrypted data prior to this stage shall
1191 : * report no error other than PXE_PGP_CORRUPT_DATA. (PXE_BUG is okay so
1192 : * long as it remains unreachable.) This ensures that an attacker able to
1193 : * choose a ciphertext and receive a corresponding decryption error
1194 : * message cannot use that oracle to gather clues about the decryption
1195 : * key. See "An Attack on CFB Mode Encryption As Used By OpenPGP" by
1196 : * Serge Mister and Robert Zuccherato.
1197 : *
1198 : * A problematic value in the first octet of a Literal Data or Compressed
1199 : * Data packet may indicate a simple user error, such as the need to call
1200 : * pgp_sym_decrypt_bytea instead of pgp_sym_decrypt. Occasionally,
1201 : * though, it is the first symptom of the encryption key not matching the
1202 : * decryption key. When this was the only problem encountered, report a
1203 : * specific error to guide the user; otherwise, we will have reported
1204 : * PXE_PGP_CORRUPT_DATA before now. A key mismatch makes the other errors
1205 : * into red herrings, and this avoids leaking clues to attackers.
1206 : */
1207 68 : if (ctx->unsupported_compr)
1208 1 : return PXE_PGP_UNSUPPORTED_COMPR;
1209 67 : if (ctx->unexpected_binary)
1210 3 : return PXE_PGP_NOT_TEXT;
1211 :
1212 64 : return res;
1213 : }
|
