LCOV - code coverage report
Current view: top level - contrib/pgcrypto - pgp-decrypt.c (source / functions) Hit Total Coverage
Test: PostgreSQL 13beta1 Lines: 438 559 78.4 %
Date: 2020-06-01 08:06:25 Functions: 31 31 100.0 %
Legend: Lines: hit not hit

          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         530 : parse_new_len(PullFilter *src, int *len_p)
      53             : {
      54             :     uint8       b;
      55             :     int         len;
      56         530 :     int         pkttype = PKT_NORMAL;
      57             : 
      58         530 :     GETBYTE(src, b);
      59         530 :     if (b <= 191)
      60         488 :         len = b;
      61          42 :     else if (b >= 192 && b <= 223)
      62             :     {
      63          16 :         len = ((unsigned) (b) - 192) << 8;
      64          16 :         GETBYTE(src, b);
      65          16 :         len += 192 + b;
      66             :     }
      67          26 :     else if (b == 255)
      68             :     {
      69           0 :         GETBYTE(src, b);
      70           0 :         len = b;
      71           0 :         GETBYTE(src, b);
      72           0 :         len = (len << 8) | b;
      73           0 :         GETBYTE(src, b);
      74           0 :         len = (len << 8) | b;
      75           0 :         GETBYTE(src, b);
      76           0 :         len = (len << 8) | b;
      77             :     }
      78             :     else
      79             :     {
      80          26 :         len = 1 << (b & 0x1F);
      81          26 :         pkttype = PKT_STREAM;
      82             :     }
      83             : 
      84         530 :     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         530 :     *len_p = len;
      91         530 :     return pkttype;
      92             : }
      93             : 
      94             : static int
      95         426 : parse_old_len(PullFilter *src, int *len_p, int lentype)
      96             : {
      97             :     uint8       b;
      98             :     int         len;
      99             : 
     100         426 :     GETBYTE(src, b);
     101         426 :     len = b;
     102             : 
     103         426 :     if (lentype == 1)
     104             :     {
     105         204 :         GETBYTE(src, b);
     106         204 :         len = (len << 8) | b;
     107             :     }
     108         222 :     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         426 :     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         426 :     *len_p = len;
     124         426 :     return PKT_NORMAL;
     125             : }
     126             : 
     127             : /* returns pkttype or 0 on eof */
     128             : int
     129        1286 : 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        1286 :     res = pullf_read(src, 1, &p);
     137        1286 :     if (res < 0)
     138           0 :         return res;
     139        1286 :     if (res == 0)
     140         346 :         return 0;
     141             : 
     142         940 :     if ((*p & 0x80) == 0)
     143             :     {
     144           0 :         px_debug("pgp_parse_pkt_hdr: not pkt hdr");
     145           0 :         return PXE_PGP_CORRUPT_DATA;
     146             :     }
     147             : 
     148         940 :     if (*p & 0x40)
     149             :     {
     150         508 :         *tag = *p & 0x3f;
     151         508 :         res = parse_new_len(src, len_p);
     152             :     }
     153             :     else
     154             :     {
     155         432 :         lentype = *p & 3;
     156         432 :         *tag = (*p >> 2) & 0x0F;
     157         432 :         if (lentype == 3)
     158           6 :             res = allow_ctx ? PKT_CONTEXT : PXE_PGP_CORRUPT_DATA;
     159             :         else
     160         426 :             res = parse_old_len(src, len_p, lentype);
     161             :     }
     162         940 :     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        5064 : pktreader_pull(void *priv, PullFilter *src, int len,
     176             :                uint8 **data_p, uint8 *buf, int buflen)
     177             : {
     178             :     int         res;
     179        5064 :     struct PktData *pkt = priv;
     180             : 
     181             :     /* PKT_CONTEXT means: whatever there is */
     182        5064 :     if (pkt->type == PKT_CONTEXT)
     183           0 :         return pullf_read(src, len, data_p);
     184             : 
     185        5086 :     while (pkt->len == 0)
     186             :     {
     187             :         /* this was last chunk in stream */
     188         790 :         if (pkt->type == PKT_NORMAL)
     189         768 :             return 0;
     190             : 
     191             :         /* next chunk in stream */
     192          22 :         res = parse_new_len(src, &pkt->len);
     193          22 :         if (res < 0)
     194           0 :             return res;
     195          22 :         pkt->type = res;
     196             :     }
     197             : 
     198        4296 :     if (len > pkt->len)
     199         512 :         len = pkt->len;
     200             : 
     201        4296 :     res = pullf_read(src, len, data_p);
     202        4296 :     if (res > 0)
     203        4296 :         pkt->len -= res;
     204             : 
     205        4296 :     return res;
     206             : }
     207             : 
     208             : static void
     209         934 : pktreader_free(void *priv)
     210             : {
     211         934 :     struct PktData *pkt = priv;
     212             : 
     213         934 :     px_memset(pkt, 0, sizeof(*pkt));
     214         934 :     px_free(pkt);
     215         934 : }
     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         934 : pgp_create_pkt_reader(PullFilter **pf_p, PullFilter *src, int len,
     224             :                       int pkttype, PGP_Context *ctx)
     225             : {
     226             :     int         res;
     227         934 :     struct PktData *pkt = px_alloc(sizeof(*pkt));
     228             : 
     229         934 :     pkt->type = pkttype;
     230         934 :     pkt->len = len;
     231         934 :     res = pullf_create(pf_p, &pktreader_filter, pkt, src);
     232         934 :     if (res < 0)
     233           0 :         px_free(pkt);
     234         934 :     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         142 : prefix_init(void **priv_p, void *arg, PullFilter *src)
     245             : {
     246         142 :     PGP_Context *ctx = arg;
     247             :     int         len;
     248             :     int         res;
     249             :     uint8      *buf;
     250             :     uint8       tmpbuf[PGP_MAX_BLOCK + 2];
     251             : 
     252         142 :     len = pgp_get_cipher_block_size(ctx->cipher_algo);
     253         142 :     if (len > sizeof(tmpbuf))
     254           0 :         return PXE_BUG;
     255             : 
     256         142 :     res = pullf_read_max(src, len + 2, &buf, tmpbuf);
     257         142 :     if (res < 0)
     258           0 :         return res;
     259         142 :     if (res != len + 2)
     260             :     {
     261           0 :         px_debug("prefix_init: short read");
     262           0 :         px_memset(tmpbuf, 0, sizeof(tmpbuf));
     263           0 :         return PXE_PGP_CORRUPT_DATA;
     264             :     }
     265             : 
     266         142 :     if (buf[len - 2] != buf[len] || buf[len - 1] != buf[len + 1])
     267             :     {
     268           4 :         px_debug("prefix_init: corrupt prefix");
     269             :         /* report error in pgp_decrypt() */
     270           4 :         ctx->corrupt_prefix = 1;
     271             :     }
     272         142 :     px_memset(tmpbuf, 0, sizeof(tmpbuf));
     273         142 :     return 0;
     274             : }
     275             : 
     276             : static struct PullFilterOps prefix_filter = {
     277             :     prefix_init, NULL, NULL
     278             : };
     279             : 
     280             : 
     281             : /*
     282             :  * Decrypt filter
     283             :  */
     284             : 
     285             : static int
     286         150 : decrypt_init(void **priv_p, void *arg, PullFilter *src)
     287             : {
     288         150 :     PGP_CFB    *cfb = arg;
     289             : 
     290         150 :     *priv_p = cfb;
     291             : 
     292             :     /* we need to write somewhere, so ask for a buffer */
     293         150 :     return 4096;
     294             : }
     295             : 
     296             : static int
     297        1618 : decrypt_read(void *priv, PullFilter *src, int len,
     298             :              uint8 **data_p, uint8 *buf, int buflen)
     299             : {
     300        1618 :     PGP_CFB    *cfb = priv;
     301             :     uint8      *tmp;
     302             :     int         res;
     303             : 
     304        1618 :     res = pullf_read(src, len, &tmp);
     305        1618 :     if (res > 0)
     306             :     {
     307        1468 :         pgp_cfb_decrypt(cfb, tmp, res, buf);
     308        1468 :         *data_p = buf;
     309             :     }
     310        1618 :     return res;
     311             : }
     312             : 
     313             : struct PullFilterOps pgp_decrypt_filter = {
     314             :     decrypt_init, decrypt_read, NULL
     315             : };
     316             : 
     317             : 
     318             : /*
     319             :  * MDC hasher filter
     320             :  */
     321             : 
     322             : static int
     323         138 : mdc_init(void **priv_p, void *arg, PullFilter *src)
     324             : {
     325         138 :     PGP_Context *ctx = arg;
     326             : 
     327         138 :     *priv_p = ctx;
     328         138 :     return pgp_load_digest(PGP_DIGEST_SHA1, &ctx->mdc_ctx);
     329             : }
     330             : 
     331             : static void
     332         138 : mdc_free(void *priv)
     333             : {
     334         138 :     PGP_Context *ctx = priv;
     335             : 
     336         138 :     if (ctx->use_mdcbuf_filter)
     337           6 :         return;
     338         132 :     px_md_free(ctx->mdc_ctx);
     339         132 :     ctx->mdc_ctx = NULL;
     340             : }
     341             : 
     342             : static int
     343         130 : mdc_finish(PGP_Context *ctx, PullFilter *src, int len)
     344             : {
     345             :     int         res;
     346             :     uint8       hash[20];
     347             :     uint8       tmpbuf[20];
     348             :     uint8      *data;
     349             : 
     350             :     /* should not happen */
     351         130 :     if (ctx->use_mdcbuf_filter)
     352           0 :         return PXE_BUG;
     353             : 
     354             :     /* It's SHA1 */
     355         130 :     if (len != 20)
     356           0 :         return PXE_PGP_CORRUPT_DATA;
     357             : 
     358             :     /* mdc_read should not call px_md_update */
     359         130 :     ctx->in_mdc_pkt = 1;
     360             : 
     361             :     /* read data */
     362         130 :     res = pullf_read_max(src, len, &data, tmpbuf);
     363         130 :     if (res < 0)
     364           0 :         return res;
     365         130 :     if (res == 0)
     366             :     {
     367           0 :         px_debug("no mdc");
     368           0 :         return PXE_PGP_CORRUPT_DATA;
     369             :     }
     370             : 
     371             :     /* is the packet sane? */
     372         130 :     if (res != 20)
     373             :     {
     374           0 :         px_debug("mdc_finish: read failed, res=%d", res);
     375           0 :         return PXE_PGP_CORRUPT_DATA;
     376             :     }
     377             : 
     378             :     /*
     379             :      * ok, we got the hash, now check
     380             :      */
     381         130 :     px_md_finish(ctx->mdc_ctx, hash);
     382         130 :     res = memcmp(hash, data, 20);
     383         130 :     px_memset(hash, 0, 20);
     384         130 :     px_memset(tmpbuf, 0, sizeof(tmpbuf));
     385         130 :     if (res != 0)
     386             :     {
     387           0 :         px_debug("mdc_finish: mdc failed");
     388           0 :         return PXE_PGP_CORRUPT_DATA;
     389             :     }
     390         130 :     ctx->mdc_checked = 1;
     391         130 :     return 0;
     392             : }
     393             : 
     394             : static int
     395        1540 : mdc_read(void *priv, PullFilter *src, int len,
     396             :          uint8 **data_p, uint8 *buf, int buflen)
     397             : {
     398             :     int         res;
     399        1540 :     PGP_Context *ctx = priv;
     400             : 
     401             :     /* skip this filter? */
     402        1540 :     if (ctx->use_mdcbuf_filter || ctx->in_mdc_pkt)
     403         274 :         return pullf_read(src, len, data_p);
     404             : 
     405        1266 :     res = pullf_read(src, len, data_p);
     406        1266 :     if (res < 0)
     407           0 :         return res;
     408        1266 :     if (res == 0)
     409             :     {
     410           0 :         px_debug("mdc_read: unexpected eof");
     411           0 :         return PXE_PGP_CORRUPT_DATA;
     412             :     }
     413        1266 :     px_md_update(ctx->mdc_ctx, *data_p, res);
     414             : 
     415        1266 :     return res;
     416             : }
     417             : 
     418             : static struct PullFilterOps mdc_filter = {
     419             :     mdc_init, mdc_read, mdc_free
     420             : };
     421             : 
     422             : 
     423             : /*
     424             :  * Combined Pkt reader and MDC hasher.
     425             :  *
     426             :  * For the case of SYMENCRYPTED_DATA_MDC packet, where
     427             :  * the data part has 'context length', which means
     428             :  * that data packet ends 22 bytes before end of parent
     429             :  * packet, which is silly.
     430             :  */
     431             : #define MDCBUF_LEN 8192
     432             : struct MDCBufData
     433             : {
     434             :     PGP_Context *ctx;
     435             :     int         eof;
     436             :     int         buflen;
     437             :     int         avail;
     438             :     uint8      *pos;
     439             :     int         mdc_avail;
     440             :     uint8       mdc_buf[22];
     441             :     uint8       buf[MDCBUF_LEN];
     442             : };
     443             : 
     444             : static int
     445           6 : mdcbuf_init(void **priv_p, void *arg, PullFilter *src)
     446             : {
     447           6 :     PGP_Context *ctx = arg;
     448             :     struct MDCBufData *st;
     449             : 
     450           6 :     st = px_alloc(sizeof(*st));
     451           6 :     memset(st, 0, sizeof(*st));
     452           6 :     st->buflen = sizeof(st->buf);
     453           6 :     st->ctx = ctx;
     454           6 :     *priv_p = st;
     455             : 
     456             :     /* take over the work of mdc_filter */
     457           6 :     ctx->use_mdcbuf_filter = 1;
     458             : 
     459           6 :     return 0;
     460             : }
     461             : 
     462             : static int
     463           6 : mdcbuf_finish(struct MDCBufData *st)
     464             : {
     465             :     uint8       hash[20];
     466             :     int         res;
     467             : 
     468           6 :     st->eof = 1;
     469             : 
     470           6 :     if (st->mdc_buf[0] != 0xD3 || st->mdc_buf[1] != 0x14)
     471             :     {
     472           4 :         px_debug("mdcbuf_finish: bad MDC pkt hdr");
     473           4 :         return PXE_PGP_CORRUPT_DATA;
     474             :     }
     475           2 :     px_md_update(st->ctx->mdc_ctx, st->mdc_buf, 2);
     476           2 :     px_md_finish(st->ctx->mdc_ctx, hash);
     477           2 :     res = memcmp(hash, st->mdc_buf + 2, 20);
     478           2 :     px_memset(hash, 0, 20);
     479           2 :     if (res)
     480             :     {
     481           0 :         px_debug("mdcbuf_finish: MDC does not match");
     482           0 :         res = PXE_PGP_CORRUPT_DATA;
     483             :     }
     484           2 :     return res;
     485             : }
     486             : 
     487             : static void
     488          12 : mdcbuf_load_data(struct MDCBufData *st, uint8 *src, int len)
     489             : {
     490          12 :     uint8      *dst = st->pos + st->avail;
     491             : 
     492          12 :     memcpy(dst, src, len);
     493          12 :     px_md_update(st->ctx->mdc_ctx, src, len);
     494          12 :     st->avail += len;
     495          12 : }
     496             : 
     497             : static void
     498           6 : mdcbuf_load_mdc(struct MDCBufData *st, uint8 *src, int len)
     499             : {
     500           6 :     memmove(st->mdc_buf + st->mdc_avail, src, len);
     501           6 :     st->mdc_avail += len;
     502           6 : }
     503             : 
     504             : static int
     505          12 : 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          12 :     if (st->avail > 0 && st->pos != st->buf)
     513           6 :         memmove(st->buf, st->pos, st->avail);
     514          12 :     st->pos = st->buf;
     515             : 
     516             :     /* read new data */
     517          12 :     need = st->buflen + 22 - st->avail - st->mdc_avail;
     518          12 :     res = pullf_read(src, need, &data);
     519          12 :     if (res < 0)
     520           0 :         return res;
     521          12 :     if (res == 0)
     522           6 :         return mdcbuf_finish(st);
     523             : 
     524             :     /* add to buffer */
     525           6 :     if (res >= 22)
     526             :     {
     527           6 :         mdcbuf_load_data(st, st->mdc_buf, st->mdc_avail);
     528           6 :         st->mdc_avail = 0;
     529             : 
     530           6 :         mdcbuf_load_data(st, data, res - 22);
     531           6 :         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           6 :     return 0;
     546             : }
     547             : 
     548             : static int
     549          20 : mdcbuf_read(void *priv, PullFilter *src, int len,
     550             :             uint8 **data_p, uint8 *buf, int buflen)
     551             : {
     552          20 :     struct MDCBufData *st = priv;
     553             :     int         res;
     554             : 
     555          20 :     if (!st->eof && len > st->avail)
     556             :     {
     557          12 :         res = mdcbuf_refill(st, src);
     558          12 :         if (res < 0)
     559           4 :             return res;
     560             :     }
     561             : 
     562          16 :     if (len > st->avail)
     563           4 :         len = st->avail;
     564             : 
     565          16 :     *data_p = st->pos;
     566          16 :     st->pos += len;
     567          16 :     st->avail -= len;
     568          16 :     return len;
     569             : }
     570             : 
     571             : static void
     572           6 : mdcbuf_free(void *priv)
     573             : {
     574           6 :     struct MDCBufData *st = priv;
     575             : 
     576           6 :     px_md_free(st->ctx->mdc_ctx);
     577           6 :     st->ctx->mdc_ctx = NULL;
     578           6 :     px_memset(st, 0, sizeof(*st));
     579           6 :     px_free(st);
     580           6 : }
     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           8 : decrypt_key(PGP_Context *ctx, const uint8 *src, int len)
     592             : {
     593             :     int         res;
     594             :     uint8       algo;
     595             :     PGP_CFB    *cfb;
     596             : 
     597          16 :     res = pgp_cfb_create(&cfb, ctx->s2k_cipher_algo,
     598           8 :                          ctx->s2k.key, ctx->s2k.key_len, 0, NULL);
     599           8 :     if (res < 0)
     600           0 :         return res;
     601             : 
     602           8 :     pgp_cfb_decrypt(cfb, src, 1, &algo);
     603           8 :     src++;
     604           8 :     len--;
     605             : 
     606           8 :     pgp_cfb_decrypt(cfb, src, len, ctx->sess_key);
     607           8 :     pgp_cfb_free(cfb);
     608           8 :     ctx->sess_key_len = len;
     609           8 :     ctx->cipher_algo = algo;
     610             : 
     611           8 :     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           8 :     return 0;
     618             : }
     619             : 
     620             : /*
     621             :  * Handle key packet
     622             :  */
     623             : static int
     624         116 : 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         116 :     GETBYTE(src, ver);
     632         116 :     GETBYTE(src, ctx->s2k_cipher_algo);
     633         116 :     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         116 :     res = pgp_s2k_read(src, &ctx->s2k);
     643         116 :     if (res < 0)
     644           0 :         return res;
     645         116 :     ctx->s2k_mode = ctx->s2k.mode;
     646         116 :     ctx->s2k_count = s2k_decode_count(ctx->s2k.iter);
     647         116 :     ctx->s2k_digest_algo = ctx->s2k.digest_algo;
     648             : 
     649             :     /*
     650             :      * generate key from password
     651             :      */
     652         116 :     res = pgp_s2k_process(&ctx->s2k, ctx->s2k_cipher_algo,
     653             :                           ctx->sym_key, ctx->sym_key_len);
     654         116 :     if (res < 0)
     655           0 :         return res;
     656             : 
     657             :     /*
     658             :      * do we have separate session key?
     659             :      */
     660         116 :     res = pullf_read_max(src, PGP_MAX_KEY + 2, &p, tmpbuf);
     661         116 :     if (res < 0)
     662           0 :         return res;
     663             : 
     664         116 :     if (res == 0)
     665             :     {
     666             :         /*
     667             :          * no, s2k key is session key
     668             :          */
     669         108 :         memcpy(ctx->sess_key, ctx->s2k.key, ctx->s2k.key_len);
     670         108 :         ctx->sess_key_len = ctx->s2k.key_len;
     671         108 :         ctx->cipher_algo = ctx->s2k_cipher_algo;
     672         108 :         res = 0;
     673         108 :         ctx->use_sess_key = 0;
     674             :     }
     675             :     else
     676             :     {
     677             :         /*
     678             :          * yes, decrypt it
     679             :          */
     680           8 :         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           8 :         ctx->use_sess_key = 1;
     686           8 :         res = decrypt_key(ctx, p, res);
     687             :     }
     688             : 
     689         116 :     px_memset(tmpbuf, 0, sizeof(tmpbuf));
     690         116 :     return res;
     691             : }
     692             : 
     693             : static int
     694           4 : copy_crlf(MBuf *dst, uint8 *data, int len, int *got_cr)
     695             : {
     696           4 :     uint8      *data_end = data + len;
     697             :     uint8       tmpbuf[1024];
     698           4 :     uint8      *tmp_end = tmpbuf + sizeof(tmpbuf);
     699             :     uint8      *p;
     700             :     int         res;
     701             : 
     702           4 :     p = tmpbuf;
     703           4 :     if (*got_cr)
     704             :     {
     705           0 :         if (*data != '\n')
     706           0 :             *p++ = '\r';
     707           0 :         *got_cr = 0;
     708             :     }
     709          94 :     while (data < data_end)
     710             :     {
     711          94 :         if (*data == '\r')
     712             :         {
     713          28 :             if (data + 1 < data_end)
     714             :             {
     715          24 :                 if (*(data + 1) == '\n')
     716          14 :                     data++;
     717             :             }
     718             :             else
     719             :             {
     720           4 :                 *got_cr = 1;
     721           4 :                 break;
     722             :             }
     723             :         }
     724          90 :         *p++ = *data++;
     725          90 :         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           4 :     if (p - tmpbuf > 0)
     734             :     {
     735           4 :         res = mbuf_append(dst, tmpbuf, p - tmpbuf);
     736           4 :         if (res < 0)
     737           0 :             return res;
     738             :     }
     739           4 :     px_memset(tmpbuf, 0, sizeof(tmpbuf));
     740           4 :     return 0;
     741             : }
     742             : 
     743             : static int
     744         136 : 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         136 :     int         got_cr = 0;
     752             : 
     753         136 :     GETBYTE(pkt, type);
     754         136 :     GETBYTE(pkt, name_len);
     755             : 
     756             :     /* skip name */
     757         184 :     while (name_len > 0)
     758             :     {
     759          48 :         res = pullf_read(pkt, name_len, &buf);
     760          48 :         if (res < 0)
     761           0 :             return res;
     762          48 :         if (res == 0)
     763           0 :             break;
     764          48 :         name_len -= res;
     765             :     }
     766         136 :     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         136 :     res = pullf_read_max(pkt, 4, &buf, tmpbuf);
     774         136 :     if (res != 4)
     775             :     {
     776           0 :         px_debug("parse_literal_data: unexpected eof");
     777           0 :         return PXE_PGP_CORRUPT_DATA;
     778             :     }
     779         136 :     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         136 :     if (ctx->text_mode)
     786         130 :         if (type != 't' && type != 'u')
     787             :         {
     788           8 :             px_debug("parse_literal_data: data type=%c", type);
     789           8 :             ctx->unexpected_binary = true;
     790             :         }
     791             : 
     792         136 :     ctx->unicode_mode = (type == 'u') ? 1 : 0;
     793             : 
     794             :     /* read data */
     795             :     while (1)
     796             :     {
     797         306 :         res = pullf_read(pkt, 32 * 1024, &buf);
     798         306 :         if (res <= 0)
     799         136 :             break;
     800             : 
     801         170 :         if (ctx->text_mode && ctx->convert_crlf)
     802           4 :             res = copy_crlf(dst, buf, res, &got_cr);
     803             :         else
     804         166 :             res = mbuf_append(dst, buf, res);
     805         170 :         if (res < 0)
     806           0 :             break;
     807             :     }
     808         136 :     if (res >= 0 && got_cr)
     809           4 :         res = mbuf_append(dst, (const uint8 *) "\r", 1);
     810         136 :     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          10 : 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          10 :     GETBYTE(pkt, type);
     826             : 
     827          10 :     ctx->compress_algo = type;
     828          10 :     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           6 :         case PGP_COMPR_ZIP:
     835             :         case PGP_COMPR_ZLIB:
     836           6 :             res = pgp_decompress_filter(&pf_decompr, ctx, pkt);
     837           6 :             if (res >= 0)
     838             :             {
     839           6 :                 res = process_data_packets(ctx, dst, pf_decompr,
     840             :                                            NO_COMPR, NO_MDC);
     841           6 :                 pullf_free(pf_decompr);
     842             :             }
     843           6 :             break;
     844             : 
     845           4 :         case PGP_COMPR_BZIP2:
     846           4 :             px_debug("parse_compressed_data: bzip2 unsupported");
     847             :             /* report error in pgp_decrypt() */
     848           4 :             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           6 :                 res = pullf_read(pkt, 32 * 1024, &discard_buf);
     857           6 :                 if (res <= 0)
     858           4 :                     break;
     859             :             }
     860             : 
     861           4 :             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          10 :     return res;
     869             : }
     870             : 
     871             : static int
     872         148 : 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         148 :     int         got_data = 0;
     879         148 :     int         got_mdc = 0;
     880         148 :     PullFilter *pkt = NULL;
     881             : 
     882             :     while (1)
     883             :     {
     884         420 :         res = pgp_parse_pkt_hdr(src, &tag, &len, ALLOW_CTX_SIZE);
     885         420 :         if (res <= 0)
     886         142 :             break;
     887             : 
     888             : 
     889             :         /* mdc packet should be last */
     890         278 :         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         278 :         if (need_mdc && res == PKT_CONTEXT)
     902           6 :             res = pullf_create(&pkt, &mdcbuf_filter, ctx, src);
     903             :         else
     904         272 :             res = pgp_create_pkt_reader(&pkt, src, len, res, ctx);
     905         278 :         if (res < 0)
     906           0 :             break;
     907             : 
     908         278 :         switch (tag)
     909             :         {
     910         136 :             case PGP_PKT_LITERAL_DATA:
     911         136 :                 got_data = 1;
     912         136 :                 res = parse_literal_data(ctx, dst, pkt);
     913         136 :                 break;
     914          10 :             case PGP_PKT_COMPRESSED_DATA:
     915          10 :                 if (allow_compr == 0)
     916             :                 {
     917           0 :                     px_debug("process_data_packets: unexpected compression");
     918           0 :                     res = PXE_PGP_CORRUPT_DATA;
     919             :                 }
     920          10 :                 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          10 :                     got_data = 1;
     931          10 :                     res = parse_compressed_data(ctx, dst, pkt);
     932             :                 }
     933          10 :                 break;
     934         130 :             case PGP_PKT_MDC:
     935         130 :                 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         130 :                 res = mdc_finish(ctx, pkt, len);
     943         130 :                 if (res >= 0)
     944         130 :                     got_mdc = 1;
     945         130 :                 break;
     946           2 :             default:
     947           2 :                 px_debug("process_data_packets: unexpected pkt tag=%d", tag);
     948           2 :                 res = PXE_PGP_CORRUPT_DATA;
     949             :         }
     950             : 
     951         278 :         pullf_free(pkt);
     952         278 :         pkt = NULL;
     953             : 
     954         278 :         if (res < 0)
     955           6 :             break;
     956             :     }
     957             : 
     958         148 :     if (pkt)
     959           0 :         pullf_free(pkt);
     960             : 
     961         148 :     if (res < 0)
     962           6 :         return res;
     963             : 
     964         142 :     if (!got_data)
     965             :     {
     966           0 :         px_debug("process_data_packets: no data");
     967           0 :         res = PXE_PGP_CORRUPT_DATA;
     968             :     }
     969         142 :     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         142 :     return res;
     975             : }
     976             : 
     977             : static int
     978           4 : parse_symenc_data(PGP_Context *ctx, PullFilter *pkt, MBuf *dst)
     979             : {
     980             :     int         res;
     981           4 :     PGP_CFB    *cfb = NULL;
     982           4 :     PullFilter *pf_decrypt = NULL;
     983           4 :     PullFilter *pf_prefix = NULL;
     984             : 
     985           8 :     res = pgp_cfb_create(&cfb, ctx->cipher_algo,
     986           4 :                          ctx->sess_key, ctx->sess_key_len, 1, NULL);
     987           4 :     if (res < 0)
     988           0 :         goto out;
     989             : 
     990           4 :     res = pullf_create(&pf_decrypt, &pgp_decrypt_filter, cfb, pkt);
     991           4 :     if (res < 0)
     992           0 :         goto out;
     993             : 
     994           4 :     res = pullf_create(&pf_prefix, &prefix_filter, ctx, pf_decrypt);
     995           4 :     if (res < 0)
     996           0 :         goto out;
     997             : 
     998           4 :     res = process_data_packets(ctx, dst, pf_prefix, ALLOW_COMPR, NO_MDC);
     999             : 
    1000           4 : out:
    1001           4 :     if (pf_prefix)
    1002           4 :         pullf_free(pf_prefix);
    1003           4 :     if (pf_decrypt)
    1004           4 :         pullf_free(pf_decrypt);
    1005           4 :     if (cfb)
    1006           4 :         pgp_cfb_free(cfb);
    1007             : 
    1008           4 :     return res;
    1009             : }
    1010             : 
    1011             : static int
    1012         138 : parse_symenc_mdc_data(PGP_Context *ctx, PullFilter *pkt, MBuf *dst)
    1013             : {
    1014             :     int         res;
    1015         138 :     PGP_CFB    *cfb = NULL;
    1016         138 :     PullFilter *pf_decrypt = NULL;
    1017         138 :     PullFilter *pf_prefix = NULL;
    1018         138 :     PullFilter *pf_mdc = NULL;
    1019             :     uint8       ver;
    1020             : 
    1021         138 :     GETBYTE(pkt, ver);
    1022         138 :     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         276 :     res = pgp_cfb_create(&cfb, ctx->cipher_algo,
    1029         138 :                          ctx->sess_key, ctx->sess_key_len, 0, NULL);
    1030         138 :     if (res < 0)
    1031           0 :         goto out;
    1032             : 
    1033         138 :     res = pullf_create(&pf_decrypt, &pgp_decrypt_filter, cfb, pkt);
    1034         138 :     if (res < 0)
    1035           0 :         goto out;
    1036             : 
    1037         138 :     res = pullf_create(&pf_mdc, &mdc_filter, ctx, pf_decrypt);
    1038         138 :     if (res < 0)
    1039           0 :         goto out;
    1040             : 
    1041         138 :     res = pullf_create(&pf_prefix, &prefix_filter, ctx, pf_mdc);
    1042         138 :     if (res < 0)
    1043           0 :         goto out;
    1044             : 
    1045         138 :     res = process_data_packets(ctx, dst, pf_prefix, ALLOW_COMPR, NEED_MDC);
    1046             : 
    1047         138 : out:
    1048         138 :     if (pf_prefix)
    1049         138 :         pullf_free(pf_prefix);
    1050         138 :     if (pf_mdc)
    1051         138 :         pullf_free(pf_mdc);
    1052         138 :     if (pf_decrypt)
    1053         138 :         pullf_free(pf_decrypt);
    1054         138 :     if (cfb)
    1055         138 :         pgp_cfb_free(cfb);
    1056             : 
    1057         138 :     return res;
    1058             : }
    1059             : 
    1060             : /*
    1061             :  * skip over packet contents
    1062             :  */
    1063             : int
    1064         318 : pgp_skip_packet(PullFilter *pkt)
    1065             : {
    1066         318 :     int         res = 1;
    1067             :     uint8      *tmp;
    1068             : 
    1069         944 :     while (res > 0)
    1070         626 :         res = pullf_read(pkt, 32 * 1024, &tmp);
    1071         318 :     return res;
    1072             : }
    1073             : 
    1074             : /*
    1075             :  * expect to be at packet end, any data is error
    1076             :  */
    1077             : int
    1078          54 : pgp_expect_packet_end(PullFilter *pkt)
    1079             : {
    1080             :     int         res;
    1081             :     uint8      *tmp;
    1082             : 
    1083          54 :     res = pullf_read(pkt, 32 * 1024, &tmp);
    1084          54 :     if (res > 0)
    1085             :     {
    1086           0 :         px_debug("pgp_expect_packet_end: got data");
    1087           0 :         return PXE_PGP_CORRUPT_DATA;
    1088             :     }
    1089          54 :     return res;
    1090             : }
    1091             : 
    1092             : int
    1093         144 : pgp_decrypt(PGP_Context *ctx, MBuf *msrc, MBuf *mdst)
    1094             : {
    1095             :     int         res;
    1096         144 :     PullFilter *src = NULL;
    1097         144 :     PullFilter *pkt = NULL;
    1098             :     uint8       tag;
    1099             :     int         len;
    1100         144 :     int         got_key = 0;
    1101         144 :     int         got_data = 0;
    1102             : 
    1103         144 :     res = pullf_create_mbuf_reader(&src, msrc);
    1104             : 
    1105         430 :     while (res >= 0)
    1106             :     {
    1107         422 :         res = pgp_parse_pkt_hdr(src, &tag, &len, NO_CTX_SIZE);
    1108         422 :         if (res <= 0)
    1109         136 :             break;
    1110             : 
    1111         286 :         res = pgp_create_pkt_reader(&pkt, src, len, res, ctx);
    1112         286 :         if (res < 0)
    1113           0 :             break;
    1114             : 
    1115         286 :         res = PXE_PGP_CORRUPT_DATA;
    1116         286 :         switch (tag)
    1117             :         {
    1118           0 :             case PGP_PKT_MARKER:
    1119           0 :                 res = pgp_skip_packet(pkt);
    1120           0 :                 break;
    1121          28 :             case PGP_PKT_PUBENCRYPTED_SESSKEY:
    1122             :                 /* fixme: skip those */
    1123          28 :                 res = pgp_parse_pubenc_sesskey(ctx, pkt);
    1124          28 :                 got_key = 1;
    1125          28 :                 break;
    1126         116 :             case PGP_PKT_SYMENCRYPTED_SESSKEY:
    1127         116 :                 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         116 :                     got_key = 1;
    1138         116 :                     res = parse_symenc_sesskey(ctx, pkt);
    1139             :                 }
    1140         116 :                 break;
    1141           4 :             case PGP_PKT_SYMENCRYPTED_DATA:
    1142           4 :                 if (!got_key)
    1143           0 :                     px_debug("pgp_decrypt: have data but no key");
    1144           4 :                 else if (got_data)
    1145           0 :                     px_debug("pgp_decrypt: got second data packet");
    1146             :                 else
    1147             :                 {
    1148           4 :                     got_data = 1;
    1149           4 :                     ctx->disable_mdc = 1;
    1150           4 :                     res = parse_symenc_data(ctx, pkt, mdst);
    1151             :                 }
    1152           4 :                 break;
    1153         138 :             case PGP_PKT_SYMENCRYPTED_DATA_MDC:
    1154         138 :                 if (!got_key)
    1155           0 :                     px_debug("pgp_decrypt: have data but no key");
    1156         138 :                 else if (got_data)
    1157           0 :                     px_debug("pgp_decrypt: several data pkts not supported");
    1158             :                 else
    1159             :                 {
    1160         138 :                     got_data = 1;
    1161         138 :                     ctx->disable_mdc = 0;
    1162         138 :                     res = parse_symenc_mdc_data(ctx, pkt, mdst);
    1163             :                 }
    1164         138 :                 break;
    1165           0 :             default:
    1166           0 :                 px_debug("pgp_decrypt: unknown tag: 0x%02x", tag);
    1167             :         }
    1168         286 :         pullf_free(pkt);
    1169         286 :         pkt = NULL;
    1170             :     }
    1171             : 
    1172         144 :     if (pkt)
    1173           0 :         pullf_free(pkt);
    1174             : 
    1175         144 :     if (src)
    1176         144 :         pullf_free(src);
    1177             : 
    1178         144 :     if (res < 0)
    1179           8 :         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         136 :     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         136 :     if (ctx->unsupported_compr)
    1208           2 :         return PXE_PGP_UNSUPPORTED_COMPR;
    1209         134 :     if (ctx->unexpected_binary)
    1210           6 :         return PXE_PGP_NOT_TEXT;
    1211             : 
    1212         128 :     return res;
    1213             : }

Generated by: LCOV version 1.13