3 * Encrypting keys with passphrases
5 * (c) 1999 Straylight/Edgeware
8 /*----- Licensing notice --------------------------------------------------*
10 * This file is part of Catacomb.
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.
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.
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,
28 /*----- Header files ------------------------------------------------------*/
30 #include <mLib/dstr.h>
34 #include "passphrase.h"
37 #include "blowfish-cbc.h"
39 #include "rmd160-mgf.h"
40 #include "rmd160-hmac.h"
42 /*----- Main code ---------------------------------------------------------*/
46 * Choose a random 160-bit string %$R$%. Take the passphrase %$P$%, and
47 * the message %$m$%. Now, compute %$K_E \cat K_T = H(R \cat P)$%,
48 * %$y_0 = E_{K_E}(m)$% and %$\tau = T_{K_T}(y_0)$%. The ciphertext is
49 * %$y = N \cat \tau \cat y_0$%.
51 * This is not the original format. The original format was insecure, and
52 * has been replaced incompatibly.
55 /* --- @key_lock@ --- *
57 * Arguments: @key_data **kt@ = where to store the destination pointer
58 * @key_data *k@ = source key data block or null to use @*kt@
59 * @const void *e@ = secret to encrypt key with
60 * @size_t esz@ = size of the secret
64 * Use: Encrypts a key data block using a secret.
67 void key_lock(key_data
**kt
, key_data
*k
, const void *e
, size_t esz
)
70 octet b
[RMD160_HASHSZ
* 2];
78 /* --- Sanity check --- */
80 if (k
) key_incref(k
); else k
= *kt
;
81 assert(((void)"Key data is already encrypted",
82 (k
->e
& KF_ENCMASK
) != KENC_ENCRYPT
));
84 /* --- Format the stuff in the buffer --- */
86 DENSURE(&d
, RMD160_HASHSZ
* 2);
87 rand_get(RAND_GLOBAL
, d
.buf
, RMD160_HASHSZ
);
88 d
.len
+= RMD160_HASHSZ
* 2;
90 m
= (octet
*)d
.buf
+ RMD160_HASHSZ
* 2;
91 msz
= d
.len
- RMD160_HASHSZ
* 2;
93 /* --- Hash the passphrase to make a key --- */
95 rmd160_mgfkeybegin(&r
);
96 rmd160_mgfkeyadd(&r
, d
.buf
, RMD160_HASHSZ
);
97 rmd160_mgfkeyadd(&r
, e
, esz
);
98 rmd160_mgfencrypt(&r
, 0, b
, sizeof(b
));
101 /* --- Encrypt the plaintext --- */
103 blowfish_cbcinit(&c
, b
, RMD160_HASHSZ
, 0);
104 blowfish_cbcencrypt(&c
, m
, m
, msz
);
107 /* --- MAC the ciphertext --- */
109 rmd160_hmacinit(&mk
, b
+ RMD160_HASHSZ
, RMD160_HASHSZ
);
110 rmd160_macinit(&mc
, &mk
);
111 rmd160_machash(&mc
, m
, msz
);
112 rmd160_macdone(&mc
, d
.buf
+ RMD160_HASHSZ
);
119 *kt
= key_newencrypted(0, d
.buf
, d
.len
);
124 /* --- @key_unlock@ --- *
126 * Arguments: @key_data **kt@ = where to store the destination pointer
127 * @key_data *k@ = source key data block or null to use @*kt@
128 * @const void *e@ = secret to decrypt the block with
129 * @size_t esz@ = size of the secret
131 * Returns: Zero for success, or a @KERR_@ error code.
133 * Use: Unlocks a key using a secret.
136 int key_unlock(key_data
**kt
, key_data
*k
, const void *e
, size_t esz
)
138 octet b
[RMD160_HASHSZ
* 2];
149 /* --- Sanity check --- */
151 if (!k
) { k
= *kt
; drop
= 1; }
152 assert(((void)"Key data isn't encrypted",
153 (k
->e
& KF_ENCMASK
) == KENC_ENCRYPT
));
155 /* --- Check the size --- */
157 if (k
->u
.k
.sz
< RMD160_HASHSZ
* 2)
158 return (KERR_MALFORMED
);
159 sz
= k
->u
.k
.sz
- RMD160_HASHSZ
* 2;
161 /* --- Hash the passphrase to make a key --- */
163 rmd160_mgfkeybegin(&r
);
164 rmd160_mgfkeyadd(&r
, k
->u
.k
.k
, RMD160_HASHSZ
);
165 rmd160_mgfkeyadd(&r
, e
, esz
);
166 rmd160_mgfencrypt(&r
, 0, b
, sizeof(b
));
169 /* --- Verify the MAC --- */
171 rmd160_hmacinit(&mk
, b
+ RMD160_HASHSZ
, RMD160_HASHSZ
);
172 rmd160_macinit(&mc
, &mk
);
173 rmd160_machash(&mc
, k
->u
.k
.k
+ RMD160_HASHSZ
* 2, sz
);
174 rmd160_macdone(&mc
, b
+ RMD160_HASHSZ
);
175 if (memcmp(b
+ RMD160_HASHSZ
, k
->u
.k
.k
+ RMD160_HASHSZ
,
176 RMD160_HASHSZ
) != 0) {
183 /* --- Allocate a destination buffer --- */
187 /* --- Decrypt the key data --- */
189 blowfish_cbcinit(&c
, b
, RMD160_HASHSZ
, 0);
190 blowfish_cbcdecrypt(&c
, k
->u
.k
.k
+ RMD160_HASHSZ
* 2, p
, sz
);
193 /* --- Decode the key data into the destination buffer --- */
195 if ((kd
= key_decode(p
, sz
)) == 0) {
204 if (drop
) key_drop(k
);
207 /* --- Tidy up if things went wrong --- */
215 /* --- @key_plock@ --- *
217 * Arguments: @key_data **kt@ = where to store the destination pointer
218 * @key_data *k@ = source key data block or null to use @*kt@
219 * @const char *tag@ = tag to use for passphrase
221 * Returns: Zero if successful, a @KERR@ error code on failure.
223 * Use: Locks a key by encrypting it with a passphrase.
226 int key_plock(key_data
**kt
, key_data
*k
, const char *tag
)
230 if (passphrase_read(tag
, PMODE_VERIFY
, buf
, sizeof(buf
)))
232 key_lock(kt
, k
, buf
, strlen(buf
));
237 /* --- @key_punlock@ --- *
239 * Arguments: @key_data **kt@ = where to store the destination pointer
240 * @key_data *k@ = source key data block or null to use @*kt@
241 * @const char *tag@ = tag to use for passphrase
243 * Returns: Zero if it worked, a @KERR_@ error code on failure.
245 * Use: Unlocks a passphrase-locked key.
248 int key_punlock(key_data
**kt
, key_data
*k
, const char *tag
)
253 if (passphrase_read(tag
, PMODE_READ
, buf
, sizeof(buf
)))
255 rc
= key_unlock(kt
, k
, buf
, strlen(buf
));
257 if (rc
== KERR_BADPASS
|| !k
)
258 passphrase_cancel(tag
);
262 /*----- That's all, folks -------------------------------------------------*/