LCOV - code coverage report
Current view: top level - contrib/pgcrypto - pgp.c (source / functions) Hit Total Coverage
Test: PostgreSQL 13beta1 Lines: 108 141 76.6 %
Date: 2020-06-01 10:07:15 Functions: 22 25 88.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :  * pgp.c
       3             :  *    Various utility stuff.
       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.c
      30             :  */
      31             : 
      32             : #include "postgres.h"
      33             : 
      34             : #include "pgp.h"
      35             : #include "px.h"
      36             : 
      37             : /*
      38             :  * Defaults.
      39             :  */
      40             : static int  def_cipher_algo = PGP_SYM_AES_128;
      41             : static int  def_s2k_cipher_algo = -1;
      42             : static int  def_s2k_mode = PGP_S2K_ISALTED;
      43             : static int  def_s2k_count = -1;
      44             : static int  def_s2k_digest_algo = PGP_DIGEST_SHA1;
      45             : static int  def_compress_algo = PGP_COMPR_NONE;
      46             : static int  def_compress_level = 6;
      47             : static int  def_disable_mdc = 0;
      48             : static int  def_use_sess_key = 0;
      49             : static int  def_text_mode = 0;
      50             : static int  def_unicode_mode = 0;
      51             : static int  def_convert_crlf = 0;
      52             : 
      53             : struct digest_info
      54             : {
      55             :     const char *name;
      56             :     int         code;
      57             : };
      58             : 
      59             : struct cipher_info
      60             : {
      61             :     const char *name;
      62             :     int         code;
      63             :     const char *int_name;
      64             :     int         key_len;
      65             :     int         block_len;
      66             : };
      67             : 
      68             : static const struct digest_info digest_list[] = {
      69             :     {"md5", PGP_DIGEST_MD5},
      70             :     {"sha1", PGP_DIGEST_SHA1},
      71             :     {"sha-1", PGP_DIGEST_SHA1},
      72             :     {"ripemd160", PGP_DIGEST_RIPEMD160},
      73             :     {"sha256", PGP_DIGEST_SHA256},
      74             :     {"sha384", PGP_DIGEST_SHA384},
      75             :     {"sha512", PGP_DIGEST_SHA512},
      76             :     {NULL, 0}
      77             : };
      78             : 
      79             : static const struct cipher_info cipher_list[] = {
      80             :     {"3des", PGP_SYM_DES3, "3des-ecb", 192 / 8, 64 / 8},
      81             :     {"cast5", PGP_SYM_CAST5, "cast5-ecb", 128 / 8, 64 / 8},
      82             :     {"bf", PGP_SYM_BLOWFISH, "bf-ecb", 128 / 8, 64 / 8},
      83             :     {"blowfish", PGP_SYM_BLOWFISH, "bf-ecb", 128 / 8, 64 / 8},
      84             :     {"aes", PGP_SYM_AES_128, "aes-ecb", 128 / 8, 128 / 8},
      85             :     {"aes128", PGP_SYM_AES_128, "aes-ecb", 128 / 8, 128 / 8},
      86             :     {"aes192", PGP_SYM_AES_192, "aes-ecb", 192 / 8, 128 / 8},
      87             :     {"aes256", PGP_SYM_AES_256, "aes-ecb", 256 / 8, 128 / 8},
      88             :     {"twofish", PGP_SYM_TWOFISH, "twofish-ecb", 256 / 8, 128 / 8},
      89             :     {NULL, 0, NULL}
      90             : };
      91             : 
      92             : static const struct cipher_info *
      93         666 : get_cipher_info(int code)
      94             : {
      95             :     const struct cipher_info *i;
      96             : 
      97        3556 :     for (i = cipher_list; i->name; i++)
      98        3556 :         if (i->code == code)
      99         666 :             return i;
     100           0 :     return NULL;
     101             : }
     102             : 
     103             : int
     104          12 : pgp_get_digest_code(const char *name)
     105             : {
     106             :     const struct digest_info *i;
     107             : 
     108          18 :     for (i = digest_list; i->name; i++)
     109          18 :         if (pg_strcasecmp(i->name, name) == 0)
     110          12 :             return i->code;
     111           0 :     return PXE_PGP_UNSUPPORTED_HASH;
     112             : }
     113             : 
     114             : int
     115          28 : pgp_get_cipher_code(const char *name)
     116             : {
     117             :     const struct cipher_info *i;
     118             : 
     119         152 :     for (i = cipher_list; i->name; i++)
     120         152 :         if (pg_strcasecmp(i->name, name) == 0)
     121          28 :             return i->code;
     122           0 :     return PXE_PGP_UNSUPPORTED_CIPHER;
     123             : }
     124             : 
     125             : const char *
     126         458 : pgp_get_digest_name(int code)
     127             : {
     128             :     const struct digest_info *i;
     129             : 
     130         924 :     for (i = digest_list; i->name; i++)
     131         924 :         if (i->code == code)
     132         458 :             return i->name;
     133           0 :     return NULL;
     134             : }
     135             : 
     136             : const char *
     137           0 : pgp_get_cipher_name(int code)
     138             : {
     139           0 :     const struct cipher_info *i = get_cipher_info(code);
     140             : 
     141           0 :     if (i != NULL)
     142           0 :         return i->name;
     143           0 :     return NULL;
     144             : }
     145             : 
     146             : int
     147         210 : pgp_get_cipher_key_size(int code)
     148             : {
     149         210 :     const struct cipher_info *i = get_cipher_info(code);
     150             : 
     151         210 :     if (i != NULL)
     152         210 :         return i->key_len;
     153           0 :     return 0;
     154             : }
     155             : 
     156             : int
     157         220 : pgp_get_cipher_block_size(int code)
     158             : {
     159         220 :     const struct cipher_info *i = get_cipher_info(code);
     160             : 
     161         220 :     if (i != NULL)
     162         220 :         return i->block_len;
     163           0 :     return 0;
     164             : }
     165             : 
     166             : int
     167         236 : pgp_load_cipher(int code, PX_Cipher **res)
     168             : {
     169             :     int         err;
     170         236 :     const struct cipher_info *i = get_cipher_info(code);
     171             : 
     172         236 :     if (i == NULL)
     173           0 :         return PXE_PGP_CORRUPT_DATA;
     174             : 
     175         236 :     err = px_find_cipher(i->int_name, res);
     176         236 :     if (err == 0)
     177         236 :         return 0;
     178             : 
     179           0 :     return PXE_PGP_UNSUPPORTED_CIPHER;
     180             : }
     181             : 
     182             : int
     183         458 : pgp_load_digest(int code, PX_MD **res)
     184             : {
     185             :     int         err;
     186         458 :     const char *name = pgp_get_digest_name(code);
     187             : 
     188         458 :     if (name == NULL)
     189           0 :         return PXE_PGP_CORRUPT_DATA;
     190             : 
     191         458 :     err = px_find_digest(name, res);
     192         458 :     if (err == 0)
     193         458 :         return 0;
     194             : 
     195           0 :     return PXE_PGP_UNSUPPORTED_HASH;
     196             : }
     197             : 
     198             : int
     199         226 : pgp_init(PGP_Context **ctx_p)
     200             : {
     201             :     PGP_Context *ctx;
     202             : 
     203         226 :     ctx = px_alloc(sizeof *ctx);
     204         226 :     memset(ctx, 0, sizeof *ctx);
     205             : 
     206         226 :     ctx->cipher_algo = def_cipher_algo;
     207         226 :     ctx->s2k_cipher_algo = def_s2k_cipher_algo;
     208         226 :     ctx->s2k_mode = def_s2k_mode;
     209         226 :     ctx->s2k_count = def_s2k_count;
     210         226 :     ctx->s2k_digest_algo = def_s2k_digest_algo;
     211         226 :     ctx->compress_algo = def_compress_algo;
     212         226 :     ctx->compress_level = def_compress_level;
     213         226 :     ctx->disable_mdc = def_disable_mdc;
     214         226 :     ctx->use_sess_key = def_use_sess_key;
     215         226 :     ctx->unicode_mode = def_unicode_mode;
     216         226 :     ctx->convert_crlf = def_convert_crlf;
     217         226 :     ctx->text_mode = def_text_mode;
     218             : 
     219         226 :     *ctx_p = ctx;
     220         226 :     return 0;
     221             : }
     222             : 
     223             : int
     224         226 : pgp_free(PGP_Context *ctx)
     225             : {
     226         226 :     if (ctx->pub_key)
     227          40 :         pgp_key_free(ctx->pub_key);
     228         226 :     px_memset(ctx, 0, sizeof *ctx);
     229         226 :     px_free(ctx);
     230         226 :     return 0;
     231             : }
     232             : 
     233             : int
     234           2 : pgp_disable_mdc(PGP_Context *ctx, int disable)
     235             : {
     236           2 :     ctx->disable_mdc = disable ? 1 : 0;
     237           2 :     return 0;
     238             : }
     239             : 
     240             : int
     241          10 : pgp_set_sess_key(PGP_Context *ctx, int use)
     242             : {
     243          10 :     ctx->use_sess_key = use ? 1 : 0;
     244          10 :     return 0;
     245             : }
     246             : 
     247             : int
     248          10 : pgp_set_convert_crlf(PGP_Context *ctx, int doit)
     249             : {
     250          10 :     ctx->convert_crlf = doit ? 1 : 0;
     251          10 :     return 0;
     252             : }
     253             : 
     254             : int
     255           6 : pgp_set_s2k_mode(PGP_Context *ctx, int mode)
     256             : {
     257           6 :     int         err = PXE_OK;
     258             : 
     259           6 :     switch (mode)
     260             :     {
     261           6 :         case PGP_S2K_SIMPLE:
     262             :         case PGP_S2K_SALTED:
     263             :         case PGP_S2K_ISALTED:
     264           6 :             ctx->s2k_mode = mode;
     265           6 :             break;
     266           0 :         default:
     267           0 :             err = PXE_ARGUMENT_ERROR;
     268           0 :             break;
     269             :     }
     270           6 :     return err;
     271             : }
     272             : 
     273             : int
     274           4 : pgp_set_s2k_count(PGP_Context *ctx, int count)
     275             : {
     276           4 :     if (ctx->s2k_mode == PGP_S2K_ISALTED && count >= 1024 && count <= 65011712)
     277             :     {
     278           4 :         ctx->s2k_count = count;
     279           4 :         return PXE_OK;
     280             :     }
     281           0 :     return PXE_ARGUMENT_ERROR;
     282             : }
     283             : 
     284             : int
     285           8 : pgp_set_compress_algo(PGP_Context *ctx, int algo)
     286             : {
     287           8 :     switch (algo)
     288             :     {
     289           8 :         case PGP_COMPR_NONE:
     290             :         case PGP_COMPR_ZIP:
     291             :         case PGP_COMPR_ZLIB:
     292             :         case PGP_COMPR_BZIP2:
     293           8 :             ctx->compress_algo = algo;
     294           8 :             return 0;
     295             :     }
     296           0 :     return PXE_ARGUMENT_ERROR;
     297             : }
     298             : 
     299             : int
     300           2 : pgp_set_compress_level(PGP_Context *ctx, int level)
     301             : {
     302           2 :     if (level >= 0 && level <= 9)
     303             :     {
     304           2 :         ctx->compress_level = level;
     305           2 :         return 0;
     306             :     }
     307           0 :     return PXE_ARGUMENT_ERROR;
     308             : }
     309             : 
     310             : int
     311         226 : pgp_set_text_mode(PGP_Context *ctx, int mode)
     312             : {
     313         226 :     ctx->text_mode = mode;
     314         226 :     return 0;
     315             : }
     316             : 
     317             : int
     318          12 : pgp_set_cipher_algo(PGP_Context *ctx, const char *name)
     319             : {
     320          12 :     int         code = pgp_get_cipher_code(name);
     321             : 
     322          12 :     if (code < 0)
     323           0 :         return code;
     324          12 :     ctx->cipher_algo = code;
     325          12 :     return 0;
     326             : }
     327             : 
     328             : int
     329           0 : pgp_set_s2k_cipher_algo(PGP_Context *ctx, const char *name)
     330             : {
     331           0 :     int         code = pgp_get_cipher_code(name);
     332             : 
     333           0 :     if (code < 0)
     334           0 :         return code;
     335           0 :     ctx->s2k_cipher_algo = code;
     336           0 :     return 0;
     337             : }
     338             : 
     339             : int
     340           4 : pgp_set_s2k_digest_algo(PGP_Context *ctx, const char *name)
     341             : {
     342           4 :     int         code = pgp_get_digest_code(name);
     343             : 
     344           4 :     if (code < 0)
     345           0 :         return code;
     346           4 :     ctx->s2k_digest_algo = code;
     347           4 :     return 0;
     348             : }
     349             : 
     350             : int
     351         212 : pgp_get_unicode_mode(PGP_Context *ctx)
     352             : {
     353         212 :     return ctx->unicode_mode;
     354             : }
     355             : 
     356             : int
     357           0 : pgp_set_unicode_mode(PGP_Context *ctx, int mode)
     358             : {
     359           0 :     ctx->unicode_mode = mode ? 1 : 0;
     360           0 :     return 0;
     361             : }
     362             : 
     363             : int
     364         174 : pgp_set_symkey(PGP_Context *ctx, const uint8 *key, int len)
     365             : {
     366         174 :     if (key == NULL || len < 1)
     367           0 :         return PXE_ARGUMENT_ERROR;
     368         174 :     ctx->sym_key = key;
     369         174 :     ctx->sym_key_len = len;
     370         174 :     return 0;
     371             : }

Generated by: LCOV version 1.13