contrib/pgcrypto/px-crypt.c

   1 /*
   2  * px-crypt.c
   3  *              Wrapper for various crypt algorithms.
   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-crypt.c
  30  */
  31
  32 #include "postgres.h"
  33
  34 #include "px.h"
  35 #include "px-crypt.h"
  36
  37
  38 static char *
  39 run_crypt_des(const char *psw, const char *salt,
  40                           char *buf, unsigned len)
  41 {
  42         char       *res;
  43
  44         res = px_crypt_des(psw, salt);
  45         if (strlen(res) > len - 1)
  46                 return NULL;
  47         strcpy(buf, res);
  48         return buf;
  49 }
  50
  51 static char *
  52 run_crypt_md5(const char *psw, const char *salt,
  53                           char *buf, unsigned len)
  54 {
  55         char       *res;
  56
  57         res = px_crypt_md5(psw, salt, buf, len);
  58         return res;
  59 }
  60
  61 static char *
  62 run_crypt_bf(const char *psw, const char *salt,
  63                          char *buf, unsigned len)
  64 {
  65         char       *res;
  66
  67         res = _crypt_blowfish_rn(psw, salt, buf, len);
  68         return res;
  69 }
  70
  71 struct px_crypt_algo
  72 {
  73         char       *id;
  74         unsigned        id_len;
  75         char       *(*crypt) (const char *psw, const char *salt,
  76                                                                           char *buf, unsigned len);
  77 };
  78
  79 static const struct px_crypt_algo
  80                         px_crypt_list[] = {
  81         {"$2a$", 4, run_crypt_bf},
  82         {"$2x$", 4, run_crypt_bf},
  83         {"$2$", 3, NULL},                       /* N/A */
  84         {"$1$", 3, run_crypt_md5},
  85         {"_", 1, run_crypt_des},
  86         {"", 0, run_crypt_des},
  87         {NULL, 0, NULL}
  88 };
  89
  90 char *
  91 px_crypt(const char *psw, const char *salt, char *buf, unsigned len)
  92 {
  93         const struct px_crypt_algo *c;
  94
  95         for (c = px_crypt_list; c->id; c++)
  96         {
  97                 if (!c->id_len)
  98                         break;
  99                 if (!strncmp(salt, c->id, c->id_len))
 100                         break;
 101         }
 102
 103         if (c->crypt == NULL)
 104                 return NULL;
 105
 106         return c->crypt(psw, salt, buf, len);
 107 }
 108
 109 /*
 110  * salt generators
 111  */
 112
 113 struct generator
 114 {
 115         char       *name;
 116         char       *(*gen) (unsigned long count, const char *input, int size,
 117                                                                         char *output, int output_size);
 118         int                     input_len;
 119         int                     def_rounds;
 120         int                     min_rounds;
 121         int                     max_rounds;
 122 };
 123
 124 static struct generator gen_list[] = {
 125         {"des", _crypt_gensalt_traditional_rn, 2, 0, 0, 0},
 126         {"md5", _crypt_gensalt_md5_rn, 6, 0, 0, 0},
 127         {"xdes", _crypt_gensalt_extended_rn, 3, PX_XDES_ROUNDS, 1, 0xFFFFFF},
 128         {"bf", _crypt_gensalt_blowfish_rn, 16, PX_BF_ROUNDS, 4, 31},
 129         {NULL, NULL, 0, 0, 0, 0}
 130 };
 131
 132 int
 133 px_gen_salt(const char *salt_type, char *buf, int rounds)
 134 {
 135         int                     res;
 136         struct generator *g;
 137         char       *p;
 138         char            rbuf[16];
 139
 140         for (g = gen_list; g->name; g++)
 141                 if (pg_strcasecmp(g->name, salt_type) == 0)
 142                         break;
 143
 144         if (g->name == NULL)
 145                 return PXE_UNKNOWN_SALT_ALGO;
 146
 147         if (g->def_rounds)
 148         {
 149                 if (rounds == 0)
 150                         rounds = g->def_rounds;
 151
 152                 if (rounds < g->min_rounds || rounds > g->max_rounds)
 153                         return PXE_BAD_SALT_ROUNDS;
 154         }
 155
 156         res = px_get_pseudo_random_bytes((uint8 *) rbuf, g->input_len);
 157         if (res < 0)
 158                 return res;
 159
 160         p = g->gen(rounds, rbuf, g->input_len, buf, PX_MAX_SALT_LEN);
 161         memset(rbuf, 0, sizeof(rbuf));
 162
 163         if (p == NULL)
 164                 return PXE_BAD_SALT_ROUNDS;
 165
 166         return strlen(p);
 167 }