LCOV - code coverage report
Current view: top level - contrib/pgcrypto - px.c (source / functions) Hit Total Coverage
Test: PostgreSQL 18devel Lines: 101 116 87.1 %
Date: 2024-10-10 04:14:55 Functions: 14 14 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :  * px.c
       3             :  *      Various cryptographic stuff for PostgreSQL.
       4             :  *
       5             :  * Copyright (c) 2001 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/px.c
      30             :  */
      31             : 
      32             : #include "postgres.h"
      33             : 
      34             : #include "px.h"
      35             : 
      36             : struct error_desc
      37             : {
      38             :     int         err;
      39             :     const char *desc;
      40             : };
      41             : 
      42             : static const struct error_desc px_err_list[] = {
      43             :     {PXE_OK, "Everything ok"},
      44             :     {PXE_NO_HASH, "No such hash algorithm"},
      45             :     {PXE_NO_CIPHER, "No such cipher algorithm"},
      46             :     {PXE_BAD_OPTION, "Unknown option"},
      47             :     {PXE_BAD_FORMAT, "Badly formatted type"},
      48             :     {PXE_KEY_TOO_BIG, "Key was too big"},
      49             :     {PXE_CIPHER_INIT, "Cipher cannot be initialized"},
      50             :     {PXE_HASH_UNUSABLE_FOR_HMAC, "This hash algorithm is unusable for HMAC"},
      51             :     {PXE_BUG, "pgcrypto bug"},
      52             :     {PXE_ARGUMENT_ERROR, "Illegal argument to function"},
      53             :     {PXE_UNKNOWN_SALT_ALGO, "Unknown salt algorithm"},
      54             :     {PXE_BAD_SALT_ROUNDS, "Incorrect number of rounds"},
      55             :     {PXE_NO_RANDOM, "Failed to generate strong random bits"},
      56             :     {PXE_DECRYPT_FAILED, "Decryption failed"},
      57             :     {PXE_ENCRYPT_FAILED, "Encryption failed"},
      58             :     {PXE_PGP_CORRUPT_DATA, "Wrong key or corrupt data"},
      59             :     {PXE_PGP_CORRUPT_ARMOR, "Corrupt ascii-armor"},
      60             :     {PXE_PGP_UNSUPPORTED_COMPR, "Unsupported compression algorithm"},
      61             :     {PXE_PGP_UNSUPPORTED_CIPHER, "Unsupported cipher algorithm"},
      62             :     {PXE_PGP_UNSUPPORTED_HASH, "Unsupported digest algorithm"},
      63             :     {PXE_PGP_COMPRESSION_ERROR, "Compression error"},
      64             :     {PXE_PGP_NOT_TEXT, "Not text data"},
      65             :     {PXE_PGP_UNEXPECTED_PKT, "Unexpected packet in key data"},
      66             :     {PXE_PGP_MATH_FAILED, "Math operation failed"},
      67             :     {PXE_PGP_SHORT_ELGAMAL_KEY, "Elgamal keys must be at least 1024 bits long"},
      68             :     {PXE_PGP_UNKNOWN_PUBALGO, "Unknown public-key encryption algorithm"},
      69             :     {PXE_PGP_WRONG_KEY, "Wrong key"},
      70             :     {PXE_PGP_MULTIPLE_KEYS,
      71             :     "Several keys given - pgcrypto does not handle keyring"},
      72             :     {PXE_PGP_EXPECT_PUBLIC_KEY, "Refusing to encrypt with secret key"},
      73             :     {PXE_PGP_EXPECT_SECRET_KEY, "Cannot decrypt with public key"},
      74             :     {PXE_PGP_NOT_V4_KEYPKT, "Only V4 key packets are supported"},
      75             :     {PXE_PGP_KEYPKT_CORRUPT, "Corrupt key packet"},
      76             :     {PXE_PGP_NO_USABLE_KEY, "No encryption key found"},
      77             :     {PXE_PGP_NEED_SECRET_PSW, "Need password for secret key"},
      78             :     {PXE_PGP_BAD_S2K_MODE, "Bad S2K mode"},
      79             :     {PXE_PGP_UNSUPPORTED_PUBALGO, "Unsupported public key algorithm"},
      80             :     {PXE_PGP_MULTIPLE_SUBKEYS, "Several subkeys not supported"},
      81             : 
      82             :     {0, NULL},
      83             : };
      84             : 
      85             : /*
      86             :  * Call ereport(ERROR, ...), with an error code and message corresponding to
      87             :  * the PXE_* error code given as argument.
      88             :  *
      89             :  * This is similar to px_strerror(err), but for some errors, we fill in the
      90             :  * error code and detail fields more appropriately.
      91             :  */
      92             : void
      93          38 : px_THROW_ERROR(int err)
      94             : {
      95          38 :     if (err == PXE_NO_RANDOM)
      96             :     {
      97           0 :         ereport(ERROR,
      98             :                 (errcode(ERRCODE_INTERNAL_ERROR),
      99             :                  errmsg("could not generate a random number")));
     100             :     }
     101             :     else
     102             :     {
     103             :         /* For other errors, use the message from the above list. */
     104          38 :         ereport(ERROR,
     105             :                 (errcode(ERRCODE_EXTERNAL_ROUTINE_INVOCATION_EXCEPTION),
     106             :                  errmsg("%s", px_strerror(err))));
     107             :     }
     108             : }
     109             : 
     110             : const char *
     111          52 : px_strerror(int err)
     112             : {
     113             :     const struct error_desc *e;
     114             : 
     115         996 :     for (e = px_err_list; e->desc; e++)
     116         996 :         if (e->err == err)
     117          52 :             return e->desc;
     118           0 :     return "Bad error code";
     119             : }
     120             : 
     121             : /* memset that must not be optimized away */
     122             : void
     123        5956 : px_memset(void *ptr, int c, size_t len)
     124             : {
     125        5956 :     memset(ptr, c, len);
     126        5956 : }
     127             : 
     128             : const char *
     129         394 : px_resolve_alias(const PX_Alias *list, const char *name)
     130             : {
     131        5100 :     while (list->name)
     132             :     {
     133        4810 :         if (pg_strcasecmp(list->alias, name) == 0)
     134         104 :             return list->name;
     135        4706 :         list++;
     136             :     }
     137         290 :     return name;
     138             : }
     139             : 
     140             : static void (*debug_handler) (const char *) = NULL;
     141             : 
     142             : void
     143         234 : px_set_debug_handler(void (*handler) (const char *))
     144             : {
     145         234 :     debug_handler = handler;
     146         234 : }
     147             : 
     148             : void
     149          28 : px_debug(const char *fmt,...)
     150             : {
     151             :     va_list     ap;
     152             : 
     153          28 :     va_start(ap, fmt);
     154          28 :     if (debug_handler)
     155             :     {
     156             :         char        buf[512];
     157             : 
     158          16 :         vsnprintf(buf, sizeof(buf), fmt, ap);
     159          16 :         debug_handler(buf);
     160             :     }
     161          28 :     va_end(ap);
     162          28 : }
     163             : 
     164             : /*
     165             :  * combo - cipher + padding (+ checksum)
     166             :  */
     167             : 
     168             : static unsigned
     169         118 : combo_encrypt_len(PX_Combo *cx, unsigned dlen)
     170             : {
     171         118 :     return dlen + 512;
     172             : }
     173             : 
     174             : static unsigned
     175          34 : combo_decrypt_len(PX_Combo *cx, unsigned dlen)
     176             : {
     177          34 :     return dlen;
     178             : }
     179             : 
     180             : static int
     181         152 : combo_init(PX_Combo *cx, const uint8 *key, unsigned klen,
     182             :            const uint8 *iv, unsigned ivlen)
     183             : {
     184             :     int         err;
     185             :     unsigned    ks,
     186             :                 ivs;
     187         152 :     PX_Cipher  *c = cx->cipher;
     188         152 :     uint8      *ivbuf = NULL;
     189             :     uint8      *keybuf;
     190             : 
     191         152 :     ks = px_cipher_key_size(c);
     192             : 
     193         152 :     ivs = px_cipher_iv_size(c);
     194         152 :     if (ivs > 0)
     195             :     {
     196         152 :         ivbuf = palloc0(ivs);
     197         152 :         if (ivlen > ivs)
     198           0 :             memcpy(ivbuf, iv, ivs);
     199         152 :         else if (ivlen > 0)
     200          22 :             memcpy(ivbuf, iv, ivlen);
     201             :     }
     202             : 
     203         152 :     if (klen > ks)
     204           0 :         klen = ks;
     205         152 :     keybuf = palloc0(ks);
     206         152 :     memcpy(keybuf, key, klen);
     207             : 
     208         152 :     err = px_cipher_init(c, keybuf, klen, ivbuf);
     209             : 
     210         152 :     if (ivbuf)
     211         152 :         pfree(ivbuf);
     212         152 :     pfree(keybuf);
     213             : 
     214         152 :     return err;
     215             : }
     216             : 
     217             : static int
     218         118 : combo_encrypt(PX_Combo *cx, const uint8 *data, unsigned dlen,
     219             :               uint8 *res, unsigned *rlen)
     220             : {
     221         118 :     return px_cipher_encrypt(cx->cipher, cx->padding, data, dlen, res, rlen);
     222             : }
     223             : 
     224             : static int
     225          34 : combo_decrypt(PX_Combo *cx, const uint8 *data, unsigned dlen,
     226             :               uint8 *res, unsigned *rlen)
     227             : {
     228          34 :     return px_cipher_decrypt(cx->cipher, cx->padding, data, dlen, res, rlen);
     229             : }
     230             : 
     231             : static void
     232         152 : combo_free(PX_Combo *cx)
     233             : {
     234         152 :     if (cx->cipher)
     235         152 :         px_cipher_free(cx->cipher);
     236         152 :     px_memset(cx, 0, sizeof(*cx));
     237         152 :     pfree(cx);
     238         152 : }
     239             : 
     240             : /* PARSER */
     241             : 
     242             : static int
     243         154 : parse_cipher_name(char *full, char **cipher, char **pad)
     244             : {
     245             :     char       *p,
     246             :                *p2,
     247             :                *q;
     248             : 
     249         154 :     *cipher = full;
     250         154 :     *pad = NULL;
     251             : 
     252         154 :     p = strchr(full, '/');
     253         154 :     if (p != NULL)
     254          38 :         *p++ = 0;
     255         192 :     while (p != NULL)
     256             :     {
     257          38 :         if ((q = strchr(p, '/')) != NULL)
     258           0 :             *q++ = 0;
     259             : 
     260          38 :         if (!*p)
     261             :         {
     262           0 :             p = q;
     263           0 :             continue;
     264             :         }
     265          38 :         p2 = strchr(p, ':');
     266          38 :         if (p2 != NULL)
     267             :         {
     268          38 :             *p2++ = 0;
     269          38 :             if (strcmp(p, "pad") == 0)
     270          38 :                 *pad = p2;
     271             :             else
     272           0 :                 return PXE_BAD_OPTION;
     273             :         }
     274             :         else
     275           0 :             return PXE_BAD_FORMAT;
     276             : 
     277          38 :         p = q;
     278             :     }
     279         154 :     return 0;
     280             : }
     281             : 
     282             : /* provider */
     283             : 
     284             : int
     285         154 : px_find_combo(const char *name, PX_Combo **res)
     286             : {
     287             :     int         err;
     288             :     char       *buf,
     289             :                *s_cipher,
     290             :                *s_pad;
     291             : 
     292             :     PX_Combo   *cx;
     293             : 
     294         154 :     cx = palloc0(sizeof(*cx));
     295         154 :     buf = pstrdup(name);
     296             : 
     297         154 :     err = parse_cipher_name(buf, &s_cipher, &s_pad);
     298         154 :     if (err)
     299             :     {
     300           0 :         pfree(buf);
     301           0 :         pfree(cx);
     302           0 :         return err;
     303             :     }
     304             : 
     305         154 :     err = px_find_cipher(s_cipher, &cx->cipher);
     306         154 :     if (err)
     307           2 :         goto err1;
     308             : 
     309         152 :     if (s_pad != NULL)
     310             :     {
     311          38 :         if (strcmp(s_pad, "pkcs") == 0)
     312           0 :             cx->padding = 1;
     313          38 :         else if (strcmp(s_pad, "none") == 0)
     314          38 :             cx->padding = 0;
     315             :         else
     316           0 :             goto err1;
     317             :     }
     318             :     else
     319         114 :         cx->padding = 1;
     320             : 
     321         152 :     cx->init = combo_init;
     322         152 :     cx->encrypt = combo_encrypt;
     323         152 :     cx->decrypt = combo_decrypt;
     324         152 :     cx->encrypt_len = combo_encrypt_len;
     325         152 :     cx->decrypt_len = combo_decrypt_len;
     326         152 :     cx->free = combo_free;
     327             : 
     328         152 :     pfree(buf);
     329             : 
     330         152 :     *res = cx;
     331             : 
     332         152 :     return 0;
     333             : 
     334           2 : err1:
     335           2 :     if (cx->cipher)
     336           0 :         px_cipher_free(cx->cipher);
     337           2 :     pfree(cx);
     338           2 :     pfree(buf);
     339           2 :     return PXE_NO_CIPHER;
     340             : }

Generated by: LCOV version 1.14