chiark - git - mdw - catacomb/blob - key/key-pass.c

   1 /* -*-c-*-
   2  *
   3  * Encrypting keys with passphrases
   4  *
   5  * (c) 1999 Straylight/Edgeware
   6  */
   7
   8 /*----- Licensing notice --------------------------------------------------*
   9  *
  10  * This file is part of Catacomb.
  11  *
  12  * Catacomb is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU Library General Public License as
  14  * published by the Free Software Foundation; either version 2 of the
  15  * License, or (at your option) any later version.
  16  *
  17  * Catacomb is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU Library General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Library General Public
  23  * License along with Catacomb; if not, write to the Free
  24  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  25  * MA 02111-1307, USA.
  26  */
  27
  28 /*----- Header files ------------------------------------------------------*/
  29
  30 #include <mLib/dstr.h>
  31
  32 #include "ct.h"
  33 #include "key-data.h"
  34 #include "paranoia.h"
  35 #include "passphrase.h"
  36 #include "rand.h"
  37
  38 #include "blowfish-cbc.h"
  39 #include "rmd160.h"
  40 #include "rmd160-mgf.h"
  41 #include "rmd160-hmac.h"
  42
  43 /*----- Main code ---------------------------------------------------------*/
  44
  45 /* --- Format --- *
  46  *
  47  * Choose a random 160-bit string %$R$%.  Take the passphrase %$P$%, and
  48  * the message %$m$%.  Now, compute %$K_E \cat K_T = H(R \cat P)$%,
  49  * %$y_0 = E_{K_E}(m)$% and %$\tau = T_{K_T}(y_0)$%.  The ciphertext is
  50  * %$y = N \cat \tau \cat y_0$%.
  51  *
  52  * This is not the original format.  The original format was insecure, and
  53  * has been replaced incompatibly.
  54  */
  55
  56 /* --- @key_lock@ --- *
  57  *
  58  * Arguments:   @key_data **kt@ = where to store the destination pointer
  59  *              @key_data *k@ = source key data block or null to use @*kt@
  60  *              @const void *e@ = secret to encrypt key with
  61  *              @size_t esz@ = size of the secret
  62  *
  63  * Returns:     ---
  64  *
  65  * Use:         Encrypts a key data block using a secret.
  66  */
  67
  68 void key_lock(key_data **kt, key_data *k, const void *e, size_t esz)
  69 {
  70   dstr d = DSTR_INIT;
  71   octet b[RMD160_HASHSZ * 2];
  72   octet *m;
  73   size_t msz;
  74   rmd160_mgfctx r;
  75   blowfish_cbcctx c;
  76   rmd160_mackey mk;
  77   rmd160_macctx mc;
  78
  79   /* --- Sanity check --- */
  80
  81   if (k) key_incref(k); else k = *kt;
  82   assert(((void)"Key data is already encrypted",
  83           (k->e & KF_ENCMASK) != KENC_ENCRYPT));
  84
  85   /* --- Format the stuff in the buffer --- */
  86
  87   DENSURE(&d, RMD160_HASHSZ * 2);
  88   rand_get(RAND_GLOBAL, d.buf, RMD160_HASHSZ);
  89   d.len += RMD160_HASHSZ * 2;
  90   key_encode(k, &d, 0);
  91   m = (octet *)d.buf + RMD160_HASHSZ * 2;
  92   msz = d.len - RMD160_HASHSZ * 2;
  93
  94   /* --- Hash the passphrase to make a key --- */
  95
  96   rmd160_mgfkeybegin(&r);
  97   rmd160_mgfkeyadd(&r, d.buf, RMD160_HASHSZ);
  98   rmd160_mgfkeyadd(&r, e, esz);
  99   rmd160_mgfencrypt(&r, 0, b, sizeof(b));
 100   BURN(r);
 101
 102   /* --- Encrypt the plaintext --- */
 103
 104   blowfish_cbcinit(&c, b, RMD160_HASHSZ, 0);
 105   blowfish_cbcencrypt(&c, m, m, msz);
 106   BURN(c);
 107
 108   /* --- MAC the ciphertext --- */
 109
 110   rmd160_hmacinit(&mk, b + RMD160_HASHSZ, RMD160_HASHSZ);
 111   rmd160_macinit(&mc, &mk);
 112   rmd160_machash(&mc, m, msz);
 113   rmd160_macdone(&mc, d.buf + RMD160_HASHSZ);
 114   BURN(mk);
 115   BURN(mc);
 116
 117   /* --- Done --- */
 118
 119   BURN(b);
 120   *kt = key_newencrypted(0, d.buf, d.len);
 121   key_drop(k);
 122   dstr_destroy(&d);
 123 }
 124
 125 /* --- @key_unlock@ --- *
 126  *
 127  * Arguments:   @key_data **kt@ = where to store the destination pointer
 128  *              @key_data *k@ = source key data block or null to use @*kt@
 129  *              @const void *e@ = secret to decrypt the block with
 130  *              @size_t esz@ = size of the secret
 131  *
 132  * Returns:     Zero for success, or a @KERR_@ error code.
 133  *
 134  * Use:         Unlocks a key using a secret.
 135  */
 136
 137 int key_unlock(key_data **kt, key_data *k, const void *e, size_t esz)
 138 {
 139   octet b[RMD160_HASHSZ * 2];
 140   octet *p = 0;
 141   int rc;
 142   int drop = 0;
 143   key_data *kd;
 144   rmd160_mgfctx r;
 145   blowfish_cbcctx c;
 146   rmd160_mackey mk;
 147   rmd160_macctx mc;
 148   size_t sz;
 149
 150   /* --- Sanity check --- */
 151
 152   if (!k) { k = *kt; drop = 1; }
 153   assert(((void)"Key data isn't encrypted",
 154           (k->e & KF_ENCMASK) == KENC_ENCRYPT));
 155
 156   /* --- Check the size --- */
 157
 158   if (k->u.k.sz < RMD160_HASHSZ * 2)
 159     return (KERR_MALFORMED);
 160   sz = k->u.k.sz - RMD160_HASHSZ * 2;
 161
 162   /* --- Hash the passphrase to make a key --- */
 163
 164   rmd160_mgfkeybegin(&r);
 165   rmd160_mgfkeyadd(&r, k->u.k.k, RMD160_HASHSZ);
 166   rmd160_mgfkeyadd(&r, e, esz);
 167   rmd160_mgfencrypt(&r, 0, b, sizeof(b));
 168   BURN(r);
 169
 170   /* --- Verify the MAC --- */
 171
 172   rmd160_hmacinit(&mk, b + RMD160_HASHSZ, RMD160_HASHSZ);
 173   rmd160_macinit(&mc, &mk);
 174   rmd160_machash(&mc, k->u.k.k + RMD160_HASHSZ * 2, sz);
 175   rmd160_macdone(&mc, b + RMD160_HASHSZ);
 176   if (!ct_memeq(b + RMD160_HASHSZ,
 177                 k->u.k.k + RMD160_HASHSZ, RMD160_HASHSZ)) {
 178     rc = KERR_BADPASS;
 179     goto fail;
 180   }
 181   BURN(mk);
 182   BURN(mc);
 183
 184   /* --- Allocate a destination buffer --- */
 185
 186   p = xmalloc(sz);
 187
 188   /* --- Decrypt the key data --- */
 189
 190   blowfish_cbcinit(&c, b, RMD160_HASHSZ, 0);
 191   blowfish_cbcdecrypt(&c, k->u.k.k + RMD160_HASHSZ * 2, p, sz);
 192   BURN(c);
 193
 194   /* --- Decode the key data into the destination buffer --- */
 195
 196   if ((kd = key_decode(p, sz)) == 0) {
 197     rc = KERR_MALFORMED;
 198     goto fail;
 199   }
 200   *kt = kd;
 201
 202   /* --- Done --- */
 203
 204   xfree(p);
 205   if (drop) key_drop(k);
 206   return (0);
 207
 208   /* --- Tidy up if things went wrong --- */
 209
 210 fail:
 211   BURN(b);
 212   xfree(p);
 213   return (rc);
 214 }
 215
 216 /* --- @key_plock@ --- *
 217  *
 218  * Arguments:   @key_data **kt@ = where to store the destination pointer
 219  *              @key_data *k@ = source key data block or null to use @*kt@
 220  *              @const char *tag@ = tag to use for passphrase
 221  *
 222  * Returns:     Zero if successful, a @KERR@ error code on failure.
 223  *
 224  * Use:         Locks a key by encrypting it with a passphrase.
 225  */
 226
 227 int key_plock(key_data **kt, key_data *k, const char *tag)
 228 {
 229   char buf[256];
 230
 231   if (passphrase_read(tag, PMODE_VERIFY, buf, sizeof(buf)))
 232     return (KERR_IO);
 233   key_lock(kt, k, buf, strlen(buf));
 234   BURN(buf);
 235   return (0);
 236 }
 237
 238 /* --- @key_punlock@ --- *
 239  *
 240  * Arguments:   @key_data **kt@ = where to store the destination pointer
 241  *              @key_data *k@ = source key data block or null to use @*kt@
 242  *              @const char *tag@ = tag to use for passphrase
 243  *
 244  * Returns:     Zero if it worked, a @KERR_@ error code on failure.
 245  *
 246  * Use:         Unlocks a passphrase-locked key.
 247  */
 248
 249 int key_punlock(key_data **kt, key_data *k, const char *tag)
 250 {
 251   char buf[256];
 252   int rc;
 253
 254   if (passphrase_read(tag, PMODE_READ, buf, sizeof(buf)))
 255     return (KERR_IO);
 256   rc = key_unlock(kt, k, buf, strlen(buf));
 257   BURN(buf);
 258   if (rc == KERR_BADPASS || !k)
 259     passphrase_cancel(tag);
 260   return (rc);
 261 }
 262
 263 /*----- That's all, folks -------------------------------------------------*/