Deleted Added
sdiff udiff text old ( 78536 ) new ( 90929 )
full compact
crypto.c (78536) crypto.c (90929)
1/*
1/*
2 * Copyright (c) 1997 - 2001 Kungliga Tekniska H�gskolan
2 * Copyright (c) 1997 - 2002 Kungliga Tekniska H�gskolan
3 * (Royal Institute of Technology, Stockholm, Sweden).
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * 1. Redistributions of source code must retain the above copyright

--- 16 unchanged lines hidden (view full) ---

27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 */
33
34#include "krb5_locl.h"
3 * (Royal Institute of Technology, Stockholm, Sweden).
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * 1. Redistributions of source code must retain the above copyright

--- 16 unchanged lines hidden (view full) ---

27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 */
33
34#include "krb5_locl.h"
35RCSID("$Id: crypto.c,v 1.50 2001/05/14 06:14:45 assar Exp $");
36/* RCSID("$FreeBSD: head/crypto/heimdal/lib/krb5/crypto.c 78536 2001-06-21 02:21:57Z assar $"); */
35RCSID("$Id: crypto.c,v 1.60 2002/01/06 23:12:51 assar Exp $");
36/* RCSID("$FreeBSD: head/crypto/heimdal/lib/krb5/crypto.c 90929 2002-02-19 15:50:30Z nectar $"); */
37
38#undef CRYPTO_DEBUG
39#ifdef CRYPTO_DEBUG
40static void krb5_crypto_debug(krb5_context, int, size_t, krb5_keyblock*);
41#endif
42
43
44struct key_data {

--- 107 unchanged lines hidden (view full) ---

152
153static void
154DES_schedule(krb5_context context,
155 struct key_data *key)
156{
157 des_set_key(key->key->keyvalue.data, key->schedule->data);
158}
159
37
38#undef CRYPTO_DEBUG
39#ifdef CRYPTO_DEBUG
40static void krb5_crypto_debug(krb5_context, int, size_t, krb5_keyblock*);
41#endif
42
43
44struct key_data {

--- 107 unchanged lines hidden (view full) ---

152
153static void
154DES_schedule(krb5_context context,
155 struct key_data *key)
156{
157 des_set_key(key->key->keyvalue.data, key->schedule->data);
158}
159
160static void
161DES_string_to_key_int(unsigned char *data, size_t length, des_cblock *key)
162{
163 des_key_schedule schedule;
164 int i;
165 int reverse = 0;
166 unsigned char *p;
167
168 unsigned char swap[] = { 0x0, 0x8, 0x4, 0xc, 0x2, 0xa, 0x6, 0xe,
169 0x1, 0x9, 0x5, 0xd, 0x3, 0xb, 0x7, 0xf };
170 memset(key, 0, 8);
171
172 p = (unsigned char*)key;
173 for (i = 0; i < length; i++) {
174 unsigned char tmp = data[i];
175 if (!reverse)
176 *p++ ^= (tmp << 1);
177 else
178 *--p ^= (swap[tmp & 0xf] << 4) | swap[(tmp & 0xf0) >> 4];
179 if((i % 8) == 7)
180 reverse = !reverse;
181 }
182 des_set_odd_parity(key);
183 if(des_is_weak_key(key))
184 (*key)[7] ^= 0xF0;
185 des_set_key(key, schedule);
186 des_cbc_cksum((void*)data, key, length, schedule, key);
187 memset(schedule, 0, sizeof(schedule));
188 des_set_odd_parity(key);
189}
190
160static krb5_error_code
161DES_string_to_key(krb5_context context,
162 krb5_enctype enctype,
163 krb5_data password,
164 krb5_salt salt,
165 krb5_keyblock *key)
166{
191static krb5_error_code
192DES_string_to_key(krb5_context context,
193 krb5_enctype enctype,
194 krb5_data password,
195 krb5_salt salt,
196 krb5_keyblock *key)
197{
167 char *s;
198 unsigned char *s;
168 size_t len;
169 des_cblock tmp;
170
199 size_t len;
200 des_cblock tmp;
201
171 len = password.length + salt.saltvalue.length + 1;
202 len = password.length + salt.saltvalue.length;
172 s = malloc(len);
203 s = malloc(len);
173 if(s == NULL) {
204 if(len > 0 && s == NULL) {
174 krb5_set_error_string(context, "malloc: out of memory");
175 return ENOMEM;
176 }
177 memcpy(s, password.data, password.length);
178 memcpy(s + password.length, salt.saltvalue.data, salt.saltvalue.length);
205 krb5_set_error_string(context, "malloc: out of memory");
206 return ENOMEM;
207 }
208 memcpy(s, password.data, password.length);
209 memcpy(s + password.length, salt.saltvalue.data, salt.saltvalue.length);
179 s[len - 1] = '\0';
180 des_string_to_key(s, &tmp);
210 DES_string_to_key_int(s, len, &tmp);
181 key->keytype = enctype;
182 krb5_data_copy(&key->keyvalue, tmp, sizeof(tmp));
183 memset(&tmp, 0, sizeof(tmp));
184 memset(s, 0, len);
185 free(s);
186 return 0;
187}
188

--- 55 unchanged lines hidden (view full) ---

244 for (i = pw.length; i < pw.length + len; ++i)
245 password[i] = tolower((unsigned char)password[i]);
246 }
247 passlen = min(sizeof(password), pw.length + cell.length);
248 memcpy(&ivec, "kerberos", 8);
249 memcpy(&temp_key, "kerberos", 8);
250 des_set_odd_parity (&temp_key);
251 des_set_key (&temp_key, schedule);
211 key->keytype = enctype;
212 krb5_data_copy(&key->keyvalue, tmp, sizeof(tmp));
213 memset(&tmp, 0, sizeof(tmp));
214 memset(s, 0, len);
215 free(s);
216 return 0;
217}
218

--- 55 unchanged lines hidden (view full) ---

274 for (i = pw.length; i < pw.length + len; ++i)
275 password[i] = tolower((unsigned char)password[i]);
276 }
277 passlen = min(sizeof(password), pw.length + cell.length);
278 memcpy(&ivec, "kerberos", 8);
279 memcpy(&temp_key, "kerberos", 8);
280 des_set_odd_parity (&temp_key);
281 des_set_key (&temp_key, schedule);
252 des_cbc_cksum ((des_cblock *)password, &ivec, passlen, schedule, &ivec);
282 des_cbc_cksum (password, &ivec, passlen, schedule, &ivec);
253
254 memcpy(&temp_key, &ivec, 8);
255 des_set_odd_parity (&temp_key);
256 des_set_key (&temp_key, schedule);
283
284 memcpy(&temp_key, &ivec, 8);
285 des_set_odd_parity (&temp_key);
286 des_set_key (&temp_key, schedule);
257 des_cbc_cksum ((des_cblock *)password, key, passlen, schedule, &ivec);
287 des_cbc_cksum (password, key, passlen, schedule, &ivec);
258 memset(&schedule, 0, sizeof(schedule));
259 memset(&temp_key, 0, sizeof(temp_key));
260 memset(&ivec, 0, sizeof(ivec));
261 memset(password, 0, sizeof(password));
262
263 des_set_odd_parity (key);
264}
265

--- 89 unchanged lines hidden (view full) ---

355 for(i = 0; i < 3; i++){
356 memcpy(keys + i, tmp + i * 8, sizeof(keys[i]));
357 des_set_odd_parity(keys + i);
358 if(des_is_weak_key(keys + i))
359 xor(keys + i, (unsigned char*)"\0\0\0\0\0\0\0\xf0");
360 des_set_key(keys + i, s[i]);
361 }
362 memset(&ivec, 0, sizeof(ivec));
288 memset(&schedule, 0, sizeof(schedule));
289 memset(&temp_key, 0, sizeof(temp_key));
290 memset(&ivec, 0, sizeof(ivec));
291 memset(password, 0, sizeof(password));
292
293 des_set_odd_parity (key);
294}
295

--- 89 unchanged lines hidden (view full) ---

385 for(i = 0; i < 3; i++){
386 memcpy(keys + i, tmp + i * 8, sizeof(keys[i]));
387 des_set_odd_parity(keys + i);
388 if(des_is_weak_key(keys + i))
389 xor(keys + i, (unsigned char*)"\0\0\0\0\0\0\0\xf0");
390 des_set_key(keys + i, s[i]);
391 }
392 memset(&ivec, 0, sizeof(ivec));
363 des_ede3_cbc_encrypt((des_cblock *)tmp,
364 (des_cblock *)tmp, sizeof(tmp),
393 des_ede3_cbc_encrypt(tmp,
394 tmp, sizeof(tmp),
365 s[0], s[1], s[2], &ivec, DES_ENCRYPT);
366 memset(s, 0, sizeof(s));
367 memset(&ivec, 0, sizeof(ivec));
368 for(i = 0; i < 3; i++){
369 memcpy(keys + i, tmp + i * 8, sizeof(keys[i]));
370 des_set_odd_parity(keys + i);
371 if(des_is_weak_key(keys + i))
372 xor(keys + i, (unsigned char*)"\0\0\0\0\0\0\0\xf0");

--- 518 unchanged lines hidden (view full) ---

891 unsigned char *p = cksum->checksum.data;
892
893 krb5_generate_random_block(p, 8);
894 MD4_Init (&md4);
895 MD4_Update (&md4, p, 8);
896 MD4_Update (&md4, data, len);
897 MD4_Final (p + 8, &md4);
898 memset (&ivec, 0, sizeof(ivec));
395 s[0], s[1], s[2], &ivec, DES_ENCRYPT);
396 memset(s, 0, sizeof(s));
397 memset(&ivec, 0, sizeof(ivec));
398 for(i = 0; i < 3; i++){
399 memcpy(keys + i, tmp + i * 8, sizeof(keys[i]));
400 des_set_odd_parity(keys + i);
401 if(des_is_weak_key(keys + i))
402 xor(keys + i, (unsigned char*)"\0\0\0\0\0\0\0\xf0");

--- 518 unchanged lines hidden (view full) ---

921 unsigned char *p = cksum->checksum.data;
922
923 krb5_generate_random_block(p, 8);
924 MD4_Init (&md4);
925 MD4_Update (&md4, p, 8);
926 MD4_Update (&md4, data, len);
927 MD4_Final (p + 8, &md4);
928 memset (&ivec, 0, sizeof(ivec));
899 des_cbc_encrypt((des_cblock*)p,
900 (des_cblock*)p,
929 des_cbc_encrypt(p,
930 p,
901 24,
902 key->schedule->data,
903 &ivec,
904 DES_ENCRYPT);
905}
906
907static krb5_error_code
908RSA_MD4_DES_verify(krb5_context context,

--- 57 unchanged lines hidden (view full) ---

966 unsigned char *p = C->checksum.data;
967
968 krb5_generate_random_block(p, 8);
969 MD5_Init (&md5);
970 MD5_Update (&md5, p, 8);
971 MD5_Update (&md5, data, len);
972 MD5_Final (p + 8, &md5);
973 memset (&ivec, 0, sizeof(ivec));
931 24,
932 key->schedule->data,
933 &ivec,
934 DES_ENCRYPT);
935}
936
937static krb5_error_code
938RSA_MD4_DES_verify(krb5_context context,

--- 57 unchanged lines hidden (view full) ---

996 unsigned char *p = C->checksum.data;
997
998 krb5_generate_random_block(p, 8);
999 MD5_Init (&md5);
1000 MD5_Update (&md5, p, 8);
1001 MD5_Update (&md5, data, len);
1002 MD5_Final (p + 8, &md5);
1003 memset (&ivec, 0, sizeof(ivec));
974 des_cbc_encrypt((des_cblock*)p,
975 (des_cblock*)p,
1004 des_cbc_encrypt(p,
1005 p,
976 24,
977 key->schedule->data,
978 &ivec,
979 DES_ENCRYPT);
980}
981
982static krb5_error_code
983RSA_MD5_DES_verify(krb5_context context,

--- 44 unchanged lines hidden (view full) ---

1028 des_key_schedule *sched = key->schedule->data;
1029
1030 krb5_generate_random_block(p, 8);
1031 MD5_Init (&md5);
1032 MD5_Update (&md5, p, 8);
1033 MD5_Update (&md5, data, len);
1034 MD5_Final (p + 8, &md5);
1035 memset (&ivec, 0, sizeof(ivec));
1006 24,
1007 key->schedule->data,
1008 &ivec,
1009 DES_ENCRYPT);
1010}
1011
1012static krb5_error_code
1013RSA_MD5_DES_verify(krb5_context context,

--- 44 unchanged lines hidden (view full) ---

1058 des_key_schedule *sched = key->schedule->data;
1059
1060 krb5_generate_random_block(p, 8);
1061 MD5_Init (&md5);
1062 MD5_Update (&md5, p, 8);
1063 MD5_Update (&md5, data, len);
1064 MD5_Final (p + 8, &md5);
1065 memset (&ivec, 0, sizeof(ivec));
1036 des_ede3_cbc_encrypt((des_cblock*)p,
1037 (des_cblock*)p,
1066 des_ede3_cbc_encrypt(p,
1067 p,
1038 24,
1039 sched[0], sched[1], sched[2],
1040 &ivec,
1041 DES_ENCRYPT);
1042}
1043
1044static krb5_error_code
1045RSA_MD5_DES3_verify(krb5_context context,

--- 397 unchanged lines hidden (view full) ---

1443 krb5_data_alloc(&result->checksum, ct->checksumsize);
1444 (*ct->checksum)(context, dkey, data, len, usage, result);
1445 return 0;
1446}
1447
1448static krb5_error_code
1449create_checksum(krb5_context context,
1450 krb5_crypto crypto,
1068 24,
1069 sched[0], sched[1], sched[2],
1070 &ivec,
1071 DES_ENCRYPT);
1072}
1073
1074static krb5_error_code
1075RSA_MD5_DES3_verify(krb5_context context,

--- 397 unchanged lines hidden (view full) ---

1473 krb5_data_alloc(&result->checksum, ct->checksumsize);
1474 (*ct->checksum)(context, dkey, data, len, usage, result);
1475 return 0;
1476}
1477
1478static krb5_error_code
1479create_checksum(krb5_context context,
1480 krb5_crypto crypto,
1451 krb5_key_usage usage, /* not krb5_key_usage */
1481 unsigned usage, /* not krb5_key_usage */
1452 krb5_cksumtype type, /* 0 -> pick from crypto */
1453 void *data,
1454 size_t len,
1455 Checksum *result)
1456{
1457 struct checksum_type *ct = NULL;
1458
1459 if (type) {

--- 261 unchanged lines hidden (view full) ---

1721 void *ivec)
1722{
1723 struct checksum_type *c = _find_checksum (CKSUMTYPE_RSA_MD5);
1724 Checksum k1_c, k2_c, k3_c, cksum;
1725 struct key_data ke;
1726 krb5_keyblock kb;
1727 unsigned char t[4];
1728 RC4_KEY rc4_key;
1482 krb5_cksumtype type, /* 0 -> pick from crypto */
1483 void *data,
1484 size_t len,
1485 Checksum *result)
1486{
1487 struct checksum_type *ct = NULL;
1488
1489 if (type) {

--- 261 unchanged lines hidden (view full) ---

1751 void *ivec)
1752{
1753 struct checksum_type *c = _find_checksum (CKSUMTYPE_RSA_MD5);
1754 Checksum k1_c, k2_c, k3_c, cksum;
1755 struct key_data ke;
1756 krb5_keyblock kb;
1757 unsigned char t[4];
1758 RC4_KEY rc4_key;
1729 char *cdata = (char *)data;
1759 unsigned char *cdata = data;
1730 unsigned char k1_c_data[16], k2_c_data[16], k3_c_data[16];
1731
1732 t[0] = (usage >> 0) & 0xFF;
1733 t[1] = (usage >> 8) & 0xFF;
1734 t[2] = (usage >> 16) & 0xFF;
1735 t[3] = (usage >> 24) & 0xFF;
1736
1737 k1_c.checksum.length = sizeof(k1_c_data);

--- 39 unchanged lines hidden (view full) ---

1777 void *ivec)
1778{
1779 struct checksum_type *c = _find_checksum (CKSUMTYPE_RSA_MD5);
1780 Checksum k1_c, k2_c, k3_c, cksum;
1781 struct key_data ke;
1782 krb5_keyblock kb;
1783 unsigned char t[4];
1784 RC4_KEY rc4_key;
1760 unsigned char k1_c_data[16], k2_c_data[16], k3_c_data[16];
1761
1762 t[0] = (usage >> 0) & 0xFF;
1763 t[1] = (usage >> 8) & 0xFF;
1764 t[2] = (usage >> 16) & 0xFF;
1765 t[3] = (usage >> 24) & 0xFF;
1766
1767 k1_c.checksum.length = sizeof(k1_c_data);

--- 39 unchanged lines hidden (view full) ---

1807 void *ivec)
1808{
1809 struct checksum_type *c = _find_checksum (CKSUMTYPE_RSA_MD5);
1810 Checksum k1_c, k2_c, k3_c, cksum;
1811 struct key_data ke;
1812 krb5_keyblock kb;
1813 unsigned char t[4];
1814 RC4_KEY rc4_key;
1785 char *cdata = (char *)data;
1815 unsigned char *cdata = data;
1786 unsigned char k1_c_data[16], k2_c_data[16], k3_c_data[16];
1787 unsigned char cksum_data[16];
1788
1789 t[0] = (usage >> 0) & 0xFF;
1790 t[1] = (usage >> 8) & 0xFF;
1791 t[2] = (usage >> 16) & 0xFF;
1792 t[3] = (usage >> 24) & 0xFF;
1793

--- 151 unchanged lines hidden (view full) ---

1945 DES_CBC_encrypt_null_ivec,
1946};
1947static struct encryption_type enctype_arcfour_hmac_md5 = {
1948 ETYPE_ARCFOUR_HMAC_MD5,
1949 "arcfour-hmac-md5",
1950 1,
1951 8,
1952 &keytype_arcfour,
1816 unsigned char k1_c_data[16], k2_c_data[16], k3_c_data[16];
1817 unsigned char cksum_data[16];
1818
1819 t[0] = (usage >> 0) & 0xFF;
1820 t[1] = (usage >> 8) & 0xFF;
1821 t[2] = (usage >> 16) & 0xFF;
1822 t[3] = (usage >> 24) & 0xFF;
1823

--- 151 unchanged lines hidden (view full) ---

1975 DES_CBC_encrypt_null_ivec,
1976};
1977static struct encryption_type enctype_arcfour_hmac_md5 = {
1978 ETYPE_ARCFOUR_HMAC_MD5,
1979 "arcfour-hmac-md5",
1980 1,
1981 8,
1982 &keytype_arcfour,
1983 &checksum_hmac_md5,
1953 &checksum_hmac_md5_enc,
1984 &checksum_hmac_md5_enc,
1954 &checksum_hmac_md5_enc,
1955 F_SPECIAL,
1956 ARCFOUR_encrypt
1957};
1958static struct encryption_type enctype_des3_cbc_md5 = {
1959 ETYPE_DES3_CBC_MD5,
1960 "des3-cbc-md5",
1961 8,
1962 8,

--- 176 unchanged lines hidden (view full) ---

2139 return 0;
2140}
2141#endif
2142
2143krb5_error_code
2144krb5_keytype_to_enctypes (krb5_context context,
2145 krb5_keytype keytype,
2146 unsigned *len,
1985 F_SPECIAL,
1986 ARCFOUR_encrypt
1987};
1988static struct encryption_type enctype_des3_cbc_md5 = {
1989 ETYPE_DES3_CBC_MD5,
1990 "des3-cbc-md5",
1991 8,
1992 8,

--- 176 unchanged lines hidden (view full) ---

2169 return 0;
2170}
2171#endif
2172
2173krb5_error_code
2174krb5_keytype_to_enctypes (krb5_context context,
2175 krb5_keytype keytype,
2176 unsigned *len,
2147 int **val)
2177 krb5_enctype **val)
2148{
2149 int i;
2150 unsigned n = 0;
2178{
2179 int i;
2180 unsigned n = 0;
2151 int *ret;
2181 krb5_enctype *ret;
2152
2153 for (i = num_etypes - 1; i >= 0; --i) {
2154 if (etypes[i]->keytype->type == keytype
2155 && !(etypes[i]->flags & F_PSEUDO))
2156 ++n;
2157 }
2182
2183 for (i = num_etypes - 1; i >= 0; --i) {
2184 if (etypes[i]->keytype->type == keytype
2185 && !(etypes[i]->flags & F_PSEUDO))
2186 ++n;
2187 }
2158 ret = malloc(n * sizeof(int));
2188 ret = malloc(n * sizeof(*ret));
2159 if (ret == NULL && n != 0) {
2160 krb5_set_error_string(context, "malloc: out of memory");
2161 return ENOMEM;
2162 }
2163 n = 0;
2164 for (i = num_etypes - 1; i >= 0; --i) {
2165 if (etypes[i]->keytype->type == keytype
2166 && !(etypes[i]->flags & F_PSEUDO))

--- 8 unchanged lines hidden (view full) ---

2175 * First take the configured list of etypes for `keytype' if available,
2176 * else, do `krb5_keytype_to_enctypes'.
2177 */
2178
2179krb5_error_code
2180krb5_keytype_to_enctypes_default (krb5_context context,
2181 krb5_keytype keytype,
2182 unsigned *len,
2189 if (ret == NULL && n != 0) {
2190 krb5_set_error_string(context, "malloc: out of memory");
2191 return ENOMEM;
2192 }
2193 n = 0;
2194 for (i = num_etypes - 1; i >= 0; --i) {
2195 if (etypes[i]->keytype->type == keytype
2196 && !(etypes[i]->flags & F_PSEUDO))

--- 8 unchanged lines hidden (view full) ---

2205 * First take the configured list of etypes for `keytype' if available,
2206 * else, do `krb5_keytype_to_enctypes'.
2207 */
2208
2209krb5_error_code
2210krb5_keytype_to_enctypes_default (krb5_context context,
2211 krb5_keytype keytype,
2212 unsigned *len,
2183 int **val)
2213 krb5_enctype **val)
2184{
2185 int i, n;
2214{
2215 int i, n;
2186 int *ret;
2216 krb5_enctype *ret;
2187
2188 if (keytype != KEYTYPE_DES || context->etypes_des == NULL)
2189 return krb5_keytype_to_enctypes (context, keytype, len, val);
2190
2191 for (n = 0; context->etypes_des[n]; ++n)
2192 ;
2193 ret = malloc (n * sizeof(*ret));
2194 if (ret == NULL && n != 0) {

--- 46 unchanged lines hidden (view full) ---

2241encrypt_internal_derived(krb5_context context,
2242 krb5_crypto crypto,
2243 unsigned usage,
2244 void *data,
2245 size_t len,
2246 krb5_data *result,
2247 void *ivec)
2248{
2217
2218 if (keytype != KEYTYPE_DES || context->etypes_des == NULL)
2219 return krb5_keytype_to_enctypes (context, keytype, len, val);
2220
2221 for (n = 0; context->etypes_des[n]; ++n)
2222 ;
2223 ret = malloc (n * sizeof(*ret));
2224 if (ret == NULL && n != 0) {

--- 46 unchanged lines hidden (view full) ---

2271encrypt_internal_derived(krb5_context context,
2272 krb5_crypto crypto,
2273 unsigned usage,
2274 void *data,
2275 size_t len,
2276 krb5_data *result,
2277 void *ivec)
2278{
2249 size_t sz, block_sz, checksum_sz;
2279 size_t sz, block_sz, checksum_sz, total_sz;
2250 Checksum cksum;
2251 unsigned char *p, *q;
2252 krb5_error_code ret;
2253 struct key_data *dkey;
2280 Checksum cksum;
2281 unsigned char *p, *q;
2282 krb5_error_code ret;
2283 struct key_data *dkey;
2254 struct encryption_type *et = crypto->et;
2284 const struct encryption_type *et = crypto->et;
2255
2256 checksum_sz = CHECKSUMSIZE(et->keyed_checksum);
2257
2285
2286 checksum_sz = CHECKSUMSIZE(et->keyed_checksum);
2287
2258 sz = et->confoundersize + /* 4 - length */ len;
2288 sz = et->confoundersize + len;
2259 block_sz = (sz + et->blocksize - 1) &~ (et->blocksize - 1); /* pad */
2289 block_sz = (sz + et->blocksize - 1) &~ (et->blocksize - 1); /* pad */
2260 p = calloc(1, block_sz + checksum_sz);
2261 if(p == NULL)
2290 total_sz = block_sz + checksum_sz;
2291 p = calloc(1, total_sz);
2292 if(p == NULL) {
2293 krb5_set_error_string(context, "malloc: out of memory");
2262 return ENOMEM;
2294 return ENOMEM;
2295 }
2263
2264 q = p;
2265 krb5_generate_random_block(q, et->confoundersize); /* XXX */
2266 q += et->confoundersize;
2267 memcpy(q, data, len);
2268
2269 ret = create_checksum(context,
2270 crypto,
2271 INTEGRITY_USAGE(usage),
2272 et->keyed_checksum->type,
2273 p,
2274 block_sz,
2275 &cksum);
2276 if(ret == 0 && cksum.checksum.length != checksum_sz) {
2277 free_Checksum (&cksum);
2278 krb5_clear_error_string (context);
2279 ret = KRB5_CRYPTO_INTERNAL;
2280 }
2296
2297 q = p;
2298 krb5_generate_random_block(q, et->confoundersize); /* XXX */
2299 q += et->confoundersize;
2300 memcpy(q, data, len);
2301
2302 ret = create_checksum(context,
2303 crypto,
2304 INTEGRITY_USAGE(usage),
2305 et->keyed_checksum->type,
2306 p,
2307 block_sz,
2308 &cksum);
2309 if(ret == 0 && cksum.checksum.length != checksum_sz) {
2310 free_Checksum (&cksum);
2311 krb5_clear_error_string (context);
2312 ret = KRB5_CRYPTO_INTERNAL;
2313 }
2281 if(ret) {
2282 memset(p, 0, block_sz + checksum_sz);
2283 free(p);
2284 return ret;
2285 }
2314 if(ret)
2315 goto fail;
2286 memcpy(p + block_sz, cksum.checksum.data, cksum.checksum.length);
2287 free_Checksum (&cksum);
2288 ret = _get_derived_key(context, crypto, ENCRYPTION_USAGE(usage), &dkey);
2316 memcpy(p + block_sz, cksum.checksum.data, cksum.checksum.length);
2317 free_Checksum (&cksum);
2318 ret = _get_derived_key(context, crypto, ENCRYPTION_USAGE(usage), &dkey);
2289 if(ret) {
2290 memset(p, 0, block_sz + checksum_sz);
2291 free(p);
2292 return ret;
2293 }
2319 if(ret)
2320 goto fail;
2294 ret = _key_schedule(context, dkey);
2321 ret = _key_schedule(context, dkey);
2295 if(ret) {
2296 memset(p, 0, block_sz);
2297 free(p);
2298 return ret;
2299 }
2322 if(ret)
2323 goto fail;
2300#ifdef CRYPTO_DEBUG
2301 krb5_crypto_debug(context, 1, block_sz, dkey->key);
2302#endif
2324#ifdef CRYPTO_DEBUG
2325 krb5_crypto_debug(context, 1, block_sz, dkey->key);
2326#endif
2303 (*et->encrypt)(context, dkey, p, block_sz, 1, usage, ivec);
2327 ret = (*et->encrypt)(context, dkey, p, block_sz, 1, usage, ivec);
2328 if (ret)
2329 goto fail;
2304 result->data = p;
2330 result->data = p;
2305 result->length = block_sz + checksum_sz;
2331 result->length = total_sz;
2306 return 0;
2332 return 0;
2333 fail:
2334 memset(p, 0, total_sz);
2335 free(p);
2336 return ret;
2307}
2308
2337}
2338
2339
2309static krb5_error_code
2310encrypt_internal(krb5_context context,
2311 krb5_crypto crypto,
2312 void *data,
2313 size_t len,
2314 krb5_data *result,
2315 void *ivec)
2316{
2317 size_t sz, block_sz, checksum_sz;
2318 Checksum cksum;
2319 unsigned char *p, *q;
2320 krb5_error_code ret;
2340static krb5_error_code
2341encrypt_internal(krb5_context context,
2342 krb5_crypto crypto,
2343 void *data,
2344 size_t len,
2345 krb5_data *result,
2346 void *ivec)
2347{
2348 size_t sz, block_sz, checksum_sz;
2349 Checksum cksum;
2350 unsigned char *p, *q;
2351 krb5_error_code ret;
2321 struct encryption_type *et = crypto->et;
2352 const struct encryption_type *et = crypto->et;
2322
2323 checksum_sz = CHECKSUMSIZE(et->checksum);
2324
2325 sz = et->confoundersize + checksum_sz + len;
2326 block_sz = (sz + et->blocksize - 1) &~ (et->blocksize - 1); /* pad */
2327 p = calloc(1, block_sz);
2328 if(p == NULL) {
2329 krb5_set_error_string(context, "malloc: out of memory");

--- 11 unchanged lines hidden (view full) ---

2341 crypto,
2342 0,
2343 et->checksum->type,
2344 p,
2345 block_sz,
2346 &cksum);
2347 if(ret == 0 && cksum.checksum.length != checksum_sz) {
2348 krb5_clear_error_string (context);
2353
2354 checksum_sz = CHECKSUMSIZE(et->checksum);
2355
2356 sz = et->confoundersize + checksum_sz + len;
2357 block_sz = (sz + et->blocksize - 1) &~ (et->blocksize - 1); /* pad */
2358 p = calloc(1, block_sz);
2359 if(p == NULL) {
2360 krb5_set_error_string(context, "malloc: out of memory");

--- 11 unchanged lines hidden (view full) ---

2372 crypto,
2373 0,
2374 et->checksum->type,
2375 p,
2376 block_sz,
2377 &cksum);
2378 if(ret == 0 && cksum.checksum.length != checksum_sz) {
2379 krb5_clear_error_string (context);
2380 free_Checksum(&cksum);
2349 ret = KRB5_CRYPTO_INTERNAL;
2350 }
2381 ret = KRB5_CRYPTO_INTERNAL;
2382 }
2351 if(ret) {
2352 memset(p, 0, block_sz);
2353 free(p);
2354 free_Checksum(&cksum);
2355 return ret;
2356 }
2383 if(ret)
2384 goto fail;
2357 memcpy(p + et->confoundersize, cksum.checksum.data, cksum.checksum.length);
2358 free_Checksum(&cksum);
2359 ret = _key_schedule(context, &crypto->key);
2385 memcpy(p + et->confoundersize, cksum.checksum.data, cksum.checksum.length);
2386 free_Checksum(&cksum);
2387 ret = _key_schedule(context, &crypto->key);
2360 if(ret) {
2388 if(ret)
2389 goto fail;
2390#ifdef CRYPTO_DEBUG
2391 krb5_crypto_debug(context, 1, block_sz, crypto->key.key);
2392#endif
2393 ret = (*et->encrypt)(context, &crypto->key, p, block_sz, 1, 0, ivec);
2394 if (ret) {
2361 memset(p, 0, block_sz);
2362 free(p);
2363 return ret;
2364 }
2395 memset(p, 0, block_sz);
2396 free(p);
2397 return ret;
2398 }
2365#ifdef CRYPTO_DEBUG
2366 krb5_crypto_debug(context, 1, block_sz, crypto->key.key);
2367#endif
2368 (*et->encrypt)(context, &crypto->key, p, block_sz, 1, 0, ivec);
2369 result->data = p;
2370 result->length = block_sz;
2371 return 0;
2399 result->data = p;
2400 result->length = block_sz;
2401 return 0;
2402 fail:
2403 memset(p, 0, block_sz);
2404 free(p);
2405 return ret;
2372}
2373
2374static krb5_error_code
2375encrypt_internal_special(krb5_context context,
2376 krb5_crypto crypto,
2377 int usage,
2378 void *data,
2379 size_t len,
2380 krb5_data *result,
2381 void *ivec)
2382{
2383 struct encryption_type *et = crypto->et;
2384 size_t cksum_sz = CHECKSUMSIZE(et->checksum);
2385 size_t sz = len + cksum_sz + et->confoundersize;
2386 char *tmp, *p;
2406}
2407
2408static krb5_error_code
2409encrypt_internal_special(krb5_context context,
2410 krb5_crypto crypto,
2411 int usage,
2412 void *data,
2413 size_t len,
2414 krb5_data *result,
2415 void *ivec)
2416{
2417 struct encryption_type *et = crypto->et;
2418 size_t cksum_sz = CHECKSUMSIZE(et->checksum);
2419 size_t sz = len + cksum_sz + et->confoundersize;
2420 char *tmp, *p;
2421 krb5_error_code ret;
2387
2388 tmp = malloc (sz);
2389 if (tmp == NULL) {
2390 krb5_set_error_string(context, "malloc: out of memory");
2391 return ENOMEM;
2392 }
2393 p = tmp;
2394 memset (p, 0, cksum_sz);
2395 p += cksum_sz;
2396 krb5_generate_random_block(p, et->confoundersize);
2397 p += et->confoundersize;
2398 memcpy (p, data, len);
2422
2423 tmp = malloc (sz);
2424 if (tmp == NULL) {
2425 krb5_set_error_string(context, "malloc: out of memory");
2426 return ENOMEM;
2427 }
2428 p = tmp;
2429 memset (p, 0, cksum_sz);
2430 p += cksum_sz;
2431 krb5_generate_random_block(p, et->confoundersize);
2432 p += et->confoundersize;
2433 memcpy (p, data, len);
2399 (*et->encrypt)(context, &crypto->key, tmp, sz, TRUE, usage, ivec);
2434 ret = (*et->encrypt)(context, &crypto->key, tmp, sz, TRUE, usage, ivec);
2435 if (ret) {
2436 memset(tmp, 0, sz);
2437 free(tmp);
2438 return ret;
2439 }
2400 result->data = tmp;
2401 result->length = sz;
2402 return 0;
2403}
2404
2405static krb5_error_code
2406decrypt_internal_derived(krb5_context context,
2407 krb5_crypto crypto,

--- 34 unchanged lines hidden (view full) ---

2442 ret = _key_schedule(context, dkey);
2443 if(ret) {
2444 free(p);
2445 return ret;
2446 }
2447#ifdef CRYPTO_DEBUG
2448 krb5_crypto_debug(context, 0, len, dkey->key);
2449#endif
2440 result->data = tmp;
2441 result->length = sz;
2442 return 0;
2443}
2444
2445static krb5_error_code
2446decrypt_internal_derived(krb5_context context,
2447 krb5_crypto crypto,

--- 34 unchanged lines hidden (view full) ---

2482 ret = _key_schedule(context, dkey);
2483 if(ret) {
2484 free(p);
2485 return ret;
2486 }
2487#ifdef CRYPTO_DEBUG
2488 krb5_crypto_debug(context, 0, len, dkey->key);
2489#endif
2450 (*et->encrypt)(context, dkey, p, len, 0, usage, ivec);
2490 ret = (*et->encrypt)(context, dkey, p, len, 0, usage, ivec);
2491 if (ret) {
2492 free(p);
2493 return ret;
2494 }
2451
2452 cksum.checksum.data = p + len;
2453 cksum.checksum.length = checksum_sz;
2454 cksum.cksumtype = CHECKSUMTYPE(et->keyed_checksum);
2455
2456 ret = verify_checksum(context,
2457 crypto,
2458 INTEGRITY_USAGE(usage),

--- 41 unchanged lines hidden (view full) ---

2500 ret = _key_schedule(context, &crypto->key);
2501 if(ret) {
2502 free(p);
2503 return ret;
2504 }
2505#ifdef CRYPTO_DEBUG
2506 krb5_crypto_debug(context, 0, len, crypto->key.key);
2507#endif
2495
2496 cksum.checksum.data = p + len;
2497 cksum.checksum.length = checksum_sz;
2498 cksum.cksumtype = CHECKSUMTYPE(et->keyed_checksum);
2499
2500 ret = verify_checksum(context,
2501 crypto,
2502 INTEGRITY_USAGE(usage),

--- 41 unchanged lines hidden (view full) ---

2544 ret = _key_schedule(context, &crypto->key);
2545 if(ret) {
2546 free(p);
2547 return ret;
2548 }
2549#ifdef CRYPTO_DEBUG
2550 krb5_crypto_debug(context, 0, len, crypto->key.key);
2551#endif
2508 (*et->encrypt)(context, &crypto->key, p, len, 0, 0, ivec);
2552 ret = (*et->encrypt)(context, &crypto->key, p, len, 0, 0, ivec);
2553 if (ret) {
2554 free(p);
2555 return ret;
2556 }
2509 ret = krb5_data_copy(&cksum.checksum, p + et->confoundersize, checksum_sz);
2510 if(ret) {
2511 free(p);
2512 return ret;
2513 }
2514 memset(p + et->confoundersize, 0, checksum_sz);
2515 cksum.cksumtype = CHECKSUMTYPE(et->checksum);
2516 ret = verify_checksum(context, NULL, 0, p, len, &cksum);

--- 23 unchanged lines hidden (view full) ---

2540 krb5_data *result,
2541 void *ivec)
2542{
2543 struct encryption_type *et = crypto->et;
2544 size_t cksum_sz = CHECKSUMSIZE(et->checksum);
2545 size_t sz = len - cksum_sz - et->confoundersize;
2546 char *cdata = (char *)data;
2547 char *tmp;
2557 ret = krb5_data_copy(&cksum.checksum, p + et->confoundersize, checksum_sz);
2558 if(ret) {
2559 free(p);
2560 return ret;
2561 }
2562 memset(p + et->confoundersize, 0, checksum_sz);
2563 cksum.cksumtype = CHECKSUMTYPE(et->checksum);
2564 ret = verify_checksum(context, NULL, 0, p, len, &cksum);

--- 23 unchanged lines hidden (view full) ---

2588 krb5_data *result,
2589 void *ivec)
2590{
2591 struct encryption_type *et = crypto->et;
2592 size_t cksum_sz = CHECKSUMSIZE(et->checksum);
2593 size_t sz = len - cksum_sz - et->confoundersize;
2594 char *cdata = (char *)data;
2595 char *tmp;
2596 krb5_error_code ret;
2548
2549 tmp = malloc (sz);
2550 if (tmp == NULL) {
2551 krb5_set_error_string(context, "malloc: out of memory");
2552 return ENOMEM;
2553 }
2554
2597
2598 tmp = malloc (sz);
2599 if (tmp == NULL) {
2600 krb5_set_error_string(context, "malloc: out of memory");
2601 return ENOMEM;
2602 }
2603
2555 (*et->encrypt)(context, &crypto->key, data, len, FALSE, usage, ivec);
2604 ret = (*et->encrypt)(context, &crypto->key, data, len, FALSE, usage, ivec);
2605 if (ret) {
2606 free(tmp);
2607 return ret;
2608 }
2556
2557 memcpy (tmp, cdata + cksum_sz + et->confoundersize, sz);
2558
2559 result->data = tmp;
2560 result->length = sz;
2561 return 0;
2562}
2563

--- 87 unchanged lines hidden (view full) ---

2651 return krb5_decrypt(context, crypto, usage,
2652 e->cipher.data, e->cipher.length, result);
2653}
2654
2655/************************************************************
2656 * *
2657 ************************************************************/
2658
2609
2610 memcpy (tmp, cdata + cksum_sz + et->confoundersize, sz);
2611
2612 result->data = tmp;
2613 result->length = sz;
2614 return 0;
2615}
2616

--- 87 unchanged lines hidden (view full) ---

2704 return krb5_decrypt(context, crypto, usage,
2705 e->cipher.data, e->cipher.length, result);
2706}
2707
2708/************************************************************
2709 * *
2710 ************************************************************/
2711
2659#ifdef HAVE_OPENSSL_DES_H
2712#ifdef HAVE_OPENSSL
2660#include <openssl/rand.h>
2661
2662/* From openssl/crypto/rand/rand_lcl.h */
2663#define ENTROPY_NEEDED 20
2664static int
2665seed_something(void)
2666{
2667 int fd = -1;
2713#include <openssl/rand.h>
2714
2715/* From openssl/crypto/rand/rand_lcl.h */
2716#define ENTROPY_NEEDED 20
2717static int
2718seed_something(void)
2719{
2720 int fd = -1;
2668 size_t len;
2669 char buf[1024], seedfile[256];
2670
2671 /* If there is a seed file, load it. But such a file cannot be trusted,
2672 so use 0 for the entropy estimate */
2673 if (RAND_file_name(seedfile, sizeof(seedfile))) {
2674 fd = open(seedfile, O_RDONLY);
2675 if (fd >= 0) {
2676 read(fd, buf, sizeof(buf));
2677 /* Use the full buffer anyway */
2678 RAND_add(buf, sizeof(buf), 0.0);
2679 } else
2680 seedfile[0] = '\0';
2681 } else
2682 seedfile[0] = '\0';
2683
2684 /* Calling RAND_status() will try to use /dev/urandom if it exists so
2685 we do not have to deal with it. */
2686 if (RAND_status() != 1) {
2687 krb5_context context;
2721 char buf[1024], seedfile[256];
2722
2723 /* If there is a seed file, load it. But such a file cannot be trusted,
2724 so use 0 for the entropy estimate */
2725 if (RAND_file_name(seedfile, sizeof(seedfile))) {
2726 fd = open(seedfile, O_RDONLY);
2727 if (fd >= 0) {
2728 read(fd, buf, sizeof(buf));
2729 /* Use the full buffer anyway */
2730 RAND_add(buf, sizeof(buf), 0.0);
2731 } else
2732 seedfile[0] = '\0';
2733 } else
2734 seedfile[0] = '\0';
2735
2736 /* Calling RAND_status() will try to use /dev/urandom if it exists so
2737 we do not have to deal with it. */
2738 if (RAND_status() != 1) {
2739 krb5_context context;
2688 char *p;
2740 const char *p;
2689
2690 /* Try using egd */
2691 if (!krb5_init_context(&context)) {
2692 p = krb5_config_get_string(context, NULL, "libdefaults",
2693 "egd_socket", NULL);
2694 if (p != NULL)
2695 RAND_egd_bytes(p, ENTROPY_NEEDED);
2696 krb5_free_context(context);

--- 299 unchanged lines hidden (view full) ---

2996 const void *str,
2997 size_t len,
2998 krb5_enctype etype,
2999 krb5_keyblock *key)
3000{
3001 struct encryption_type *et = _find_enctype(etype);
3002 krb5_error_code ret;
3003 struct key_data kd;
2741
2742 /* Try using egd */
2743 if (!krb5_init_context(&context)) {
2744 p = krb5_config_get_string(context, NULL, "libdefaults",
2745 "egd_socket", NULL);
2746 if (p != NULL)
2747 RAND_egd_bytes(p, ENTROPY_NEEDED);
2748 krb5_free_context(context);

--- 299 unchanged lines hidden (view full) ---

3048 const void *str,
3049 size_t len,
3050 krb5_enctype etype,
3051 krb5_keyblock *key)
3052{
3053 struct encryption_type *et = _find_enctype(etype);
3054 krb5_error_code ret;
3055 struct key_data kd;
3056 size_t keylen = et->keytype->bits / 8;
3004 u_char *tmp;
3005
3006 if(et == NULL) {
3007 krb5_set_error_string (context, "encryption type %d not supported",
3008 etype);
3009 return KRB5_PROG_ETYPE_NOSUPP;
3010 }
3011 ALLOC(kd.key, 1);
3057 u_char *tmp;
3058
3059 if(et == NULL) {
3060 krb5_set_error_string (context, "encryption type %d not supported",
3061 etype);
3062 return KRB5_PROG_ETYPE_NOSUPP;
3063 }
3064 ALLOC(kd.key, 1);
3065 if(kd.key == NULL) {
3066 krb5_set_error_string (context, "malloc: out of memory");
3067 return ENOMEM;
3068 }
3069 ret = krb5_data_alloc(&kd.key->keyvalue, et->keytype->size);
3070 if(ret) {
3071 free(kd.key);
3072 return ret;
3073 }
3012 kd.key->keytype = etype;
3074 kd.key->keytype = etype;
3013 tmp = malloc (et->keytype->bits / 8);
3014 _krb5_n_fold(str, len, tmp, et->keytype->bits / 8);
3015 krb5_data_alloc(&kd.key->keyvalue, et->keytype->size);
3075 tmp = malloc (keylen);
3076 if(tmp == NULL) {
3077 krb5_free_keyblock(context, kd.key);
3078 krb5_set_error_string (context, "malloc: out of memory");
3079 return ENOMEM;
3080 }
3081 _krb5_n_fold(str, len, tmp, keylen);
3016 kd.schedule = NULL;
3082 kd.schedule = NULL;
3017 DES3_postproc (context, tmp, et->keytype->bits / 8, &kd); /* XXX */
3018 ret = derive_key(context,
3083 DES3_postproc (context, tmp, keylen, &kd); /* XXX */
3084 memset(tmp, 0, keylen);
3085 free(tmp);
3086 ret = derive_key(context,
3019 et,
3020 &kd,
3021 "kerberos", /* XXX well known constant */
3022 strlen("kerberos"));
3023 ret = krb5_copy_keyblock_contents(context, kd.key, key);
3024 free_key_data(context, &kd);
3025 return ret;
3026}

--- 147 unchanged lines hidden --- 		3087 et,
3088 &kd,
3089 "kerberos", /* XXX well known constant */
3090 strlen("kerberos"));
3091 ret = krb5_copy_keyblock_contents(context, kd.key, key);
3092 free_key_data(context, &kd);
3093 return ret;
3094}

--- 147 unchanged lines hidden ---