Mix/Src/crypto.c

/* Mixmaster version 3  --  (C) 1999 Anonymizer Inc.

   Mixmaster may be redistributed and modified under certain conditions.
   This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
   ANY KIND, either express or implied. See the file COPYRIGHT for
   details.

   Interface to cryptographic library
   $Id: crypto.c,v 1.7 2002/09/18 23:26:16 rabbi Exp $ */


#include "mix3.h"
#include "crypto.h"
#include <assert.h>
#include <string.h>
#include <time.h>

#ifdef USE_OPENSSL
int digestmem_md5(byte *b, int n, BUFFER *md)
{
  byte m[MD5_DIGEST_LENGTH];

  MD5(b, n, m);
  buf_reset(md);
  buf_append(md, m, MD5_DIGEST_LENGTH);
  return (0);
}

int digest_md5(BUFFER *b, BUFFER *md)
{
  return (digestmem_md5(b->data, b->length, md));
}

int isdigest_md5(BUFFER *b, BUFFER *md)
{
  int ret;
  BUFFER *newmd;

  newmd = buf_new();
  digest_md5(b, newmd);
  ret = buf_eq(md, newmd);
  buf_free(newmd);
  return (ret);
}

static int digestmem_sha1(byte *b, int n, BUFFER *md)
{
  byte m[SHA_DIGEST_LENGTH];

  SHA1(b, n, m);
  buf_reset(md);
  buf_append(md, m, SHA_DIGEST_LENGTH);
  return (0);
}

int digest_sha1(BUFFER *b, BUFFER *md)
{
  return (digestmem_sha1(b->data, b->length, md));
}

static int digestmem_rmd160(byte *b, int n, BUFFER *md)
{
  byte m[RIPEMD160_DIGEST_LENGTH];

  RIPEMD160(b, n, m);
  buf_reset(md);
  buf_append(md, m, RIPEMD160_DIGEST_LENGTH);
  return (0);
}

int digest_rmd160(BUFFER *b, BUFFER *md)
{
  return (digestmem_rmd160(b->data, b->length, md));
}

#ifdef USE_RSA
#define MAX_RSA_MODULUS_LEN 128

static int read_seckey(BUFFER *buf, SECKEY *key, const byte id[])
{
  BUFFER *md;
  int bits;
  int len, plen;
  byte *ptr;
  int err = 0;

  md = buf_new();
  bits = buf->data[0] + 256 * buf->data[1];
  len = (bits + 7) / 8;
  plen = (len + 1) / 2;

  /* due to encryption, buffer size is multiple of 8 */
  if (3 * len + 5 * plen + 8 < buf->length || 3 * len + 5 * plen > buf->length)
    return (-1);

  ptr = buf->data + 2;

  key->n = BN_bin2bn(ptr, len, NULL);
  buf_append(md, ptr, len);
  ptr += len;

  key->e = BN_bin2bn(ptr, len, NULL);
  buf_append(md, ptr, len);
  ptr += len;

  key->d = BN_bin2bn(ptr, len, NULL);
  ptr += len;

  key->p = BN_bin2bn(ptr, plen, NULL);
  ptr += plen;

  key->q = BN_bin2bn(ptr, plen, NULL);
  ptr += plen;

  key->dmp1 = BN_bin2bn(ptr, plen, NULL);
  ptr += plen;

  key->dmq1 = BN_bin2bn(ptr, plen, NULL);
  ptr += plen;

  key->iqmp = BN_bin2bn(ptr, plen, NULL);
  ptr += plen;

  digest_md5(md, md);
  if (id)
    err = (memcmp(id, md->data, 16) == 0) ? 0 : -1;
  buf_free(md);
  return (err);
}

static int read_pubkey(BUFFER *buf, PUBKEY *key, const byte id[])
{
  BUFFER *md;
  int bits;
  int len;
  byte *ptr;
  int err = 0;

  md = buf_new();
  bits = buf->data[0] + 256 * buf->data[1];
  len = (bits + 7) / 8;

  if (2 * len + 2 != buf->length)
    return (-1);

  ptr = buf->data + 2;

  key->n = BN_bin2bn(ptr, len, NULL);
  buf_append(md, ptr, len);
  ptr += len;

  key->e = BN_bin2bn(ptr, len, NULL);
  buf_append(md, ptr, len);
  ptr += len;

  digest_md5(md, md);
  if (id)
    err = (memcmp(id, md->data, 16) == 0) ? 0 : -1;
  buf_free(md);
  return (err);
}

static int write_seckey(BUFFER *sk, SECKEY *key, byte keyid[])
{
  byte l[128];
  int n;
  BUFFER *b, *temp;

  b = buf_new();
  temp = buf_new();

  n = BN_bn2bin(key->n, l);
  assert(n <= 128);
  if (n < 128)
    buf_appendzero(b, 128 - n);
  buf_append(b, l, n);

  n = BN_bn2bin(key->e, l);
  assert(n <= 128);
  if (n < 128)
    buf_appendzero(b, 128 - n);
  buf_append(b, l, n);

  digest_md5(b, temp);
  memcpy(keyid, temp->data, 16);

  buf_appendc(sk, 0);
  buf_appendc(sk, 4);
  buf_cat(sk, b);

  n = BN_bn2bin(key->d, l);
  assert(n <= 128);
  if (n < 128)
    buf_appendzero(sk, 128 - n);
  buf_append(sk, l, n);

  n = BN_bn2bin(key->p, l);
  assert(n <= 64);
  if (n < 64)
    buf_appendzero(sk, 64 - n);
  buf_append(sk, l, n);

  n = BN_bn2bin(key->q, l);
  assert(n <= 64);
  if (n < 64)
    buf_appendzero(sk, 64 - n);
  buf_append(sk, l, n);

  n = BN_bn2bin(key->dmp1, l);
  assert(n <= 64);
  if (n < 64)
    buf_appendzero(sk, 64 - n);
  buf_append(sk, l, n);

  n = BN_bn2bin(key->dmq1, l);
  assert(n <= 64);
  if (n < 64)
    buf_appendzero(sk, 64 - n);
  buf_append(sk, l, n);

  n = BN_bn2bin(key->iqmp, l);
  assert(n <= 64);
  if (n < 64)
    buf_appendzero(sk, 64 - n);
  buf_append(sk, l, n);

  buf_pad(sk, 712);             /* encrypt needs a block size multiple of 8 */

  buf_free(temp);
  buf_free(b);
  return (0);
}

static int write_pubkey(BUFFER *pk, PUBKEY *key, byte keyid[])
{
  byte l[128];
  int n;

  buf_appendc(pk, 0);
  buf_appendc(pk, 4);
  n = BN_bn2bin(key->n, l);
  assert(n <= 128);
  if (n < 128)
    buf_appendzero(pk, 128 - n);
  buf_append(pk, l, n);
  n = BN_bn2bin(key->e, l);
  assert(n <= 128);
  if (n < 128)
    buf_appendzero(pk, 128 - n);
  buf_append(pk, l, n);
  return (0);
}

int seckeytopub(BUFFER *pub, BUFFER *sec, byte keyid[])
{
  RSA *k;
  int err = 0;

  k = RSA_new();
  err = read_seckey(sec, k, keyid);
  if (err == 0)
    err = write_pubkey(pub, k, keyid);
  RSA_free(k);
  return (err);
}

int check_pubkey(BUFFER *buf, const byte id[])
{
  RSA *tmp;
  int ret;

  tmp = RSA_new();
  ret = read_pubkey(buf, tmp, id);
  RSA_free(tmp);
  return (ret);
}

int check_seckey(BUFFER *buf, const byte id[])
{
  RSA *tmp;
  int ret;

  tmp = RSA_new();
  ret = read_seckey(buf, tmp, id);
  RSA_free(tmp);
  return (ret);
}

int v2createkey(void)
{
  RSA *k;
  BUFFER *b, *ek, *iv;
  int err;
  FILE *f;
  byte keyid[16];
  char line[33];

  b = buf_new();
  ek = buf_new();
  iv = buf_new();

  errlog(NOTICE, "Generating RSA key.\n");
  k = RSA_generate_key(1024, 65537, NULL, NULL);
  err = write_seckey(b, k, keyid);
  RSA_free(k);
  if (err == 0) {
    f = mix_openfile(SECRING, "a");
    if (f != NULL) {
      time_t now = time(NULL);
      struct tm *gt;
      gt = gmtime(&now);
      strftime(line, LINELEN, "%Y-%m-%d", gt);
      fprintf(f, "%s\nCreated: %s\n", begin_key, line);
      if (KEYLIFETIME) {
        now += KEYLIFETIME;
        gt = gmtime(&now);
        strftime(line, LINELEN, "%Y-%m-%d", gt);
        fprintf(f, "Expires: %s\n", line);
      }
      id_encode(keyid, line);
      buf_appends(ek, PASSPHRASE);
      digest_md5(ek, ek);
      buf_setrnd(iv, 8);
      buf_crypt(b, ek, iv, ENCRYPT);
      encode(b, 40);
      encode(iv, 0);
      fprintf(f, "%s\n0\n%s\n", line, iv->data);
      buf_write(b, f);
      fprintf(f, "%s\n\n", end_key);
      fclose(f);
    } else
      err = -1;
  }
  if (err != 0)
    errlog(ERRORMSG, "Key generation failed.\n");

  buf_free(b);
  buf_free(ek);
  buf_free(iv);
  return (err);
}

int pk_decrypt(BUFFER *in, BUFFER *keybuf)
{
  int err = 0;
  BUFFER *out;
  RSA *key;

  out = buf_new();
  key = RSA_new();
  read_seckey(keybuf, key, NULL);

  buf_prepare(out, in->length);
  out->length = RSA_private_decrypt(in->length, in->data, out->data, key,
                                    RSA_PKCS1_PADDING);
  if (out->length == -1)
    err = -1, out->length = 0;

  RSA_free(key);
  buf_move(in, out);
  buf_free(out);
  return (err);
}

int pk_encrypt(BUFFER *in, BUFFER *keybuf)
{
  BUFFER *out;
  RSA *key;
  int err = 0;

  out = buf_new();
  key = RSA_new();
  read_pubkey(keybuf, key, NULL);

  buf_prepare(out, RSA_size(key));
  out->length = RSA_public_encrypt(in->length, in->data, out->data, key,
                                   RSA_PKCS1_PADDING);
  if (out->length == -1)
    out->length = 0, err = -1;
  buf_move(in, out);
  buf_free(out);
  RSA_free(key);
  return (err);
}
#endif /* USE_RSA */

int buf_crypt(BUFFER *buf, BUFFER *key, BUFFER *iv, int enc)
{
  des_key_schedule ks1;
  des_key_schedule ks2;
  des_key_schedule ks3;
  des_cblock i;

  assert(enc == ENCRYPT || enc == DECRYPT);
  assert((key->length == 16 || key->length == 24) && iv->length == 8);
  assert(buf->length % 8 == 0);

  memcpy(i, iv->data, 8);       /* leave iv buffer unchanged */
  des_set_key((const_des_cblock *) key->data, ks1);
  des_set_key((const_des_cblock *) (key->data + 8), ks2);
  if (key->length == 16)
    des_set_key((const_des_cblock *) key->data, ks3);
  else
    des_set_key((const_des_cblock *) (key->data + 16), ks3);
  des_ede3_cbc_encrypt(buf->data, buf->data, buf->length, ks1, ks2, ks3,
                       &i, enc);
  return (0);
}

int buf_3descrypt(BUFFER *buf, BUFFER *key, BUFFER *iv, int enc)
{
  int n = 0;
  des_key_schedule ks1;
  des_key_schedule ks2;
  des_key_schedule ks3;

  assert(enc == ENCRYPT || enc == DECRYPT);
  assert(key->length == 24 && iv->length == 8);

  des_set_key((const_des_cblock *) key->data, ks1);
  des_set_key((const_des_cblock *) (key->data + 8), ks2);
  des_set_key((const_des_cblock *) (key->data + 16), ks3);
  des_ede3_cfb64_encrypt(buf->data, buf->data, buf->length, ks1, ks2, ks3,
                        (des_cblock *) iv->data, &n, enc);
  return (0);
}

int buf_bfcrypt(BUFFER *buf, BUFFER *key, BUFFER *iv, int enc)
{
  int n = 0;
  BF_KEY ks;

  if (key == NULL || key->length == 0)
    return (-1);

  assert(enc == ENCRYPT || enc == DECRYPT);
  assert(key->length == 16 && iv->length == 8);
  BF_set_key(&ks, key->length, key->data);
  BF_cfb64_encrypt(buf->data, buf->data, buf->length, &ks, iv->data, &n,
                     enc == ENCRYPT ? BF_ENCRYPT : BF_DECRYPT);
  return (0);
}

int buf_castcrypt(BUFFER *buf, BUFFER *key, BUFFER *iv, int enc)
{
  int n = 0;
  CAST_KEY ks;

  if (key == NULL || key->length == 0)
    return (-1);

  assert(enc == ENCRYPT || enc == DECRYPT);
  assert(key->length == 16 && iv->length == 8);
  CAST_set_key(&ks, 16, key->data);
  CAST_cfb64_encrypt(buf->data, buf->data, buf->length, &ks, iv->data, &n,
                     enc == ENCRYPT ? CAST_ENCRYPT : CAST_DECRYPT);
  return (0);
}

#ifdef USE_AES
int buf_aescrypt(BUFFER *buf, BUFFER *key, BUFFER *iv, int enc)
{
  int n = 0;
  AES_KEY ks;

  if (key == NULL || key->length == 0)
    return (-1);

  assert(enc == ENCRYPT || enc == DECRYPT);
  assert((key->length == 16 || key->length == 24 || key->length == 32) && iv->length == 16);
  AES_set_encrypt_key(key->data, key->length<<3, &ks);
  AES_cfb128_encrypt(buf->data, buf->data, buf->length, &ks, iv->data, &n,
                     enc == ENCRYPT ? AES_ENCRYPT : AES_DECRYPT);
  return (0);
}
#endif /* USE_AES */

#ifdef USE_IDEA
int buf_ideacrypt(BUFFER *buf, BUFFER *key, BUFFER *iv, int enc)
{
  int n = 0;
  IDEA_KEY_SCHEDULE ks;

  if (key == NULL || key->length == 0)
    return (-1);

  assert(enc == ENCRYPT || enc == DECRYPT);
  assert(key->length == 16 && iv->length == 8);
  idea_set_encrypt_key(key->data, &ks);
  idea_cfb64_encrypt(buf->data, buf->data, buf->length, &ks, iv->data, &n,
                     enc == ENCRYPT ? IDEA_ENCRYPT : IDEA_DECRYPT);
  return (0);
}
#endif /* USE_IDEA */
#endif /* USE_OPENSSL */
1	/* Mixmaster version 3 -- (C) 1999 Anonymizer Inc.
2
3	Mixmaster may be redistributed and modified under certain conditions.
4	This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
5	ANY KIND, either express or implied. See the file COPYRIGHT for
6	details.
7
8	Interface to cryptographic library
9	$Id: crypto.c,v 1.7 2002/09/18 23:26:16 rabbi Exp $ */
10
11
12	#include "mix3.h"
13	#include "crypto.h"
14	#include <assert.h>
15	#include <string.h>
16	#include <time.h>
17
18	#ifdef USE_OPENSSL
19	int digestmem_md5(byte b, int n, BUFFER md)
20	{
21	byte m[MD5_DIGEST_LENGTH];
22
23	MD5(b, n, m);
24	buf_reset(md);
25	buf_append(md, m, MD5_DIGEST_LENGTH);
26	return (0);
27	}
28
29	int digest_md5(BUFFER b, BUFFER md)
30	{
31	return (digestmem_md5(b->data, b->length, md));
32	}
33
34	int isdigest_md5(BUFFER b, BUFFER md)
35	{
36	int ret;
37	BUFFER *newmd;
38
39	newmd = buf_new();
40	digest_md5(b, newmd);
41	ret = buf_eq(md, newmd);
42	buf_free(newmd);
43	return (ret);
44	}
45
46	static int digestmem_sha1(byte b, int n, BUFFER md)
47	{
48	byte m[SHA_DIGEST_LENGTH];
49
50	SHA1(b, n, m);
51	buf_reset(md);
52	buf_append(md, m, SHA_DIGEST_LENGTH);
53	return (0);
54	}
55
56	int digest_sha1(BUFFER b, BUFFER md)
57	{
58	return (digestmem_sha1(b->data, b->length, md));
59	}
60
61	static int digestmem_rmd160(byte b, int n, BUFFER md)
62	{
63	byte m[RIPEMD160_DIGEST_LENGTH];
64
65	RIPEMD160(b, n, m);
66	buf_reset(md);
67	buf_append(md, m, RIPEMD160_DIGEST_LENGTH);
68	return (0);
69	}
70
71	int digest_rmd160(BUFFER b, BUFFER md)
72	{
73	return (digestmem_rmd160(b->data, b->length, md));
74	}
75
76	#ifdef USE_RSA
77	#define MAX_RSA_MODULUS_LEN 128
78
79	static int read_seckey(BUFFER buf, SECKEY key, const byte id[])
80	{
81	BUFFER *md;
82	int bits;
83	int len, plen;
84	byte *ptr;
85	int err = 0;
86
87	md = buf_new();
88	bits = buf->data[0] + 256 * buf->data[1];
89	len = (bits + 7) / 8;
90	plen = (len + 1) / 2;
91
92	/* due to encryption, buffer size is multiple of 8 */
93	if (3 * len + 5 * plen + 8 < buf->length \|\| 3 * len + 5 * plen > buf->length)
94	return (-1);
95
96	ptr = buf->data + 2;
97
98	key->n = BN_bin2bn(ptr, len, NULL);
99	buf_append(md, ptr, len);
100	ptr += len;
101
102	key->e = BN_bin2bn(ptr, len, NULL);
103	buf_append(md, ptr, len);
104	ptr += len;
105
106	key->d = BN_bin2bn(ptr, len, NULL);
107	ptr += len;
108
109	key->p = BN_bin2bn(ptr, plen, NULL);
110	ptr += plen;
111
112	key->q = BN_bin2bn(ptr, plen, NULL);
113	ptr += plen;
114
115	key->dmp1 = BN_bin2bn(ptr, plen, NULL);
116	ptr += plen;
117
118	key->dmq1 = BN_bin2bn(ptr, plen, NULL);
119	ptr += plen;
120
121	key->iqmp = BN_bin2bn(ptr, plen, NULL);
122	ptr += plen;
123
124	digest_md5(md, md);
125	if (id)
126	err = (memcmp(id, md->data, 16) == 0) ? 0 : -1;
127	buf_free(md);
128	return (err);
129	}
130
131	static int read_pubkey(BUFFER buf, PUBKEY key, const byte id[])
132	{
133	BUFFER *md;
134	int bits;
135	int len;
136	byte *ptr;
137	int err = 0;
138
139	md = buf_new();
140	bits = buf->data[0] + 256 * buf->data[1];
141	len = (bits + 7) / 8;
142
143	if (2 * len + 2 != buf->length)
144	return (-1);
145
146	ptr = buf->data + 2;
147
148	key->n = BN_bin2bn(ptr, len, NULL);
149	buf_append(md, ptr, len);
150	ptr += len;
151
152	key->e = BN_bin2bn(ptr, len, NULL);
153	buf_append(md, ptr, len);
154	ptr += len;
155
156	digest_md5(md, md);
157	if (id)
158	err = (memcmp(id, md->data, 16) == 0) ? 0 : -1;
159	buf_free(md);
160	return (err);
161	}
162
163	static int write_seckey(BUFFER sk, SECKEY key, byte keyid[])
164	{
165	byte l[128];
166	int n;
167	BUFFER b, temp;
168
169	b = buf_new();
170	temp = buf_new();
171
172	n = BN_bn2bin(key->n, l);
173	assert(n <= 128);
174	if (n < 128)
175	buf_appendzero(b, 128 - n);
176	buf_append(b, l, n);
177
178	n = BN_bn2bin(key->e, l);
179	assert(n <= 128);
180	if (n < 128)
181	buf_appendzero(b, 128 - n);
182	buf_append(b, l, n);
183
184	digest_md5(b, temp);
185	memcpy(keyid, temp->data, 16);
186
187	buf_appendc(sk, 0);
188	buf_appendc(sk, 4);
189	buf_cat(sk, b);
190
191	n = BN_bn2bin(key->d, l);
192	assert(n <= 128);
193	if (n < 128)
194	buf_appendzero(sk, 128 - n);
195	buf_append(sk, l, n);
196
197	n = BN_bn2bin(key->p, l);
198	assert(n <= 64);
199	if (n < 64)
200	buf_appendzero(sk, 64 - n);
201	buf_append(sk, l, n);
202
203	n = BN_bn2bin(key->q, l);
204	assert(n <= 64);
205	if (n < 64)
206	buf_appendzero(sk, 64 - n);
207	buf_append(sk, l, n);
208
209	n = BN_bn2bin(key->dmp1, l);
210	assert(n <= 64);
211	if (n < 64)
212	buf_appendzero(sk, 64 - n);
213	buf_append(sk, l, n);
214
215	n = BN_bn2bin(key->dmq1, l);
216	assert(n <= 64);
217	if (n < 64)
218	buf_appendzero(sk, 64 - n);
219	buf_append(sk, l, n);
220
221	n = BN_bn2bin(key->iqmp, l);
222	assert(n <= 64);
223	if (n < 64)
224	buf_appendzero(sk, 64 - n);
225	buf_append(sk, l, n);
226
227	buf_pad(sk, 712); /* encrypt needs a block size multiple of 8 */
228
229	buf_free(temp);
230	buf_free(b);
231	return (0);
232	}
233
234	static int write_pubkey(BUFFER pk, PUBKEY key, byte keyid[])
235	{
236	byte l[128];
237	int n;
238
239	buf_appendc(pk, 0);
240	buf_appendc(pk, 4);
241	n = BN_bn2bin(key->n, l);
242	assert(n <= 128);
243	if (n < 128)
244	buf_appendzero(pk, 128 - n);
245	buf_append(pk, l, n);
246	n = BN_bn2bin(key->e, l);
247	assert(n <= 128);
248	if (n < 128)
249	buf_appendzero(pk, 128 - n);
250	buf_append(pk, l, n);
251	return (0);
252	}
253
254	int seckeytopub(BUFFER pub, BUFFER sec, byte keyid[])
255	{
256	RSA *k;
257	int err = 0;
258
259	k = RSA_new();
260	err = read_seckey(sec, k, keyid);
261	if (err == 0)
262	err = write_pubkey(pub, k, keyid);
263	RSA_free(k);
264	return (err);
265	}
266
267	int check_pubkey(BUFFER *buf, const byte id[])
268	{
269	RSA *tmp;
270	int ret;
271
272	tmp = RSA_new();
273	ret = read_pubkey(buf, tmp, id);
274	RSA_free(tmp);
275	return (ret);
276	}
277
278	int check_seckey(BUFFER *buf, const byte id[])
279	{
280	RSA *tmp;
281	int ret;
282
283	tmp = RSA_new();
284	ret = read_seckey(buf, tmp, id);
285	RSA_free(tmp);
286	return (ret);
287	}
288
289	int v2createkey(void)
290	{
291	RSA *k;
292	BUFFER b, ek, *iv;
293	int err;
294	FILE *f;
295	byte keyid[16];
296	char line[33];
297
298	b = buf_new();
299	ek = buf_new();
300	iv = buf_new();
301
302	errlog(NOTICE, "Generating RSA key.\n");
303	k = RSA_generate_key(1024, 65537, NULL, NULL);
304	err = write_seckey(b, k, keyid);
305	RSA_free(k);
306	if (err == 0) {
307	f = mix_openfile(SECRING, "a");
308	if (f != NULL) {
309	time_t now = time(NULL);
310	struct tm *gt;
311	gt = gmtime(&now);
312	strftime(line, LINELEN, "%Y-%m-%d", gt);
313	fprintf(f, "%s\nCreated: %s\n", begin_key, line);
314	if (KEYLIFETIME) {
315	now += KEYLIFETIME;
316	gt = gmtime(&now);
317	strftime(line, LINELEN, "%Y-%m-%d", gt);
318	fprintf(f, "Expires: %s\n", line);
319	}
320	id_encode(keyid, line);
321	buf_appends(ek, PASSPHRASE);
322	digest_md5(ek, ek);
323	buf_setrnd(iv, 8);
324	buf_crypt(b, ek, iv, ENCRYPT);
325	encode(b, 40);
326	encode(iv, 0);
327	fprintf(f, "%s\n0\n%s\n", line, iv->data);
328	buf_write(b, f);
329	fprintf(f, "%s\n\n", end_key);
330	fclose(f);
331	} else
332	err = -1;
333	}
334	if (err != 0)
335	errlog(ERRORMSG, "Key generation failed.\n");
336
337	buf_free(b);
338	buf_free(ek);
339	buf_free(iv);
340	return (err);
341	}
342
343	int pk_decrypt(BUFFER in, BUFFER keybuf)
344	{
345	int err = 0;
346	BUFFER *out;
347	RSA *key;
348
349	out = buf_new();
350	key = RSA_new();
351	read_seckey(keybuf, key, NULL);
352
353	buf_prepare(out, in->length);
354	out->length = RSA_private_decrypt(in->length, in->data, out->data, key,
355	RSA_PKCS1_PADDING);
356	if (out->length == -1)
357	err = -1, out->length = 0;
358
359	RSA_free(key);
360	buf_move(in, out);
361	buf_free(out);
362	return (err);
363	}
364
365	int pk_encrypt(BUFFER in, BUFFER keybuf)
366	{
367	BUFFER *out;
368	RSA *key;
369	int err = 0;
370
371	out = buf_new();
372	key = RSA_new();
373	read_pubkey(keybuf, key, NULL);
374
375	buf_prepare(out, RSA_size(key));
376	out->length = RSA_public_encrypt(in->length, in->data, out->data, key,
377	RSA_PKCS1_PADDING);
378	if (out->length == -1)
379	out->length = 0, err = -1;
380	buf_move(in, out);
381	buf_free(out);
382	RSA_free(key);
383	return (err);
384	}
385	#endif /* USE_RSA */
386
387	int buf_crypt(BUFFER buf, BUFFER key, BUFFER *iv, int enc)
388	{
389	des_key_schedule ks1;
390	des_key_schedule ks2;
391	des_key_schedule ks3;
392	des_cblock i;
393
394	assert(enc == ENCRYPT \|\| enc == DECRYPT);
395	assert((key->length == 16 \|\| key->length == 24) && iv->length == 8);
396	assert(buf->length % 8 == 0);
397
398	memcpy(i, iv->data, 8); /* leave iv buffer unchanged */
399	des_set_key((const_des_cblock *) key->data, ks1);
400	des_set_key((const_des_cblock *) (key->data + 8), ks2);
401	if (key->length == 16)
402	des_set_key((const_des_cblock *) key->data, ks3);
403	else
404	des_set_key((const_des_cblock *) (key->data + 16), ks3);
405	des_ede3_cbc_encrypt(buf->data, buf->data, buf->length, ks1, ks2, ks3,
406	&i, enc);
407	return (0);
408	}
409
410	int buf_3descrypt(BUFFER buf, BUFFER key, BUFFER *iv, int enc)
411	{
412	int n = 0;
413	des_key_schedule ks1;
414	des_key_schedule ks2;
415	des_key_schedule ks3;
416
417	assert(enc == ENCRYPT \|\| enc == DECRYPT);
418	assert(key->length == 24 && iv->length == 8);
419
420	des_set_key((const_des_cblock *) key->data, ks1);
421	des_set_key((const_des_cblock *) (key->data + 8), ks2);
422	des_set_key((const_des_cblock *) (key->data + 16), ks3);
423	des_ede3_cfb64_encrypt(buf->data, buf->data, buf->length, ks1, ks2, ks3,
424	(des_cblock *) iv->data, &n, enc);
425	return (0);
426	}
427
428	int buf_bfcrypt(BUFFER buf, BUFFER key, BUFFER *iv, int enc)
429	{
430	int n = 0;
431	BF_KEY ks;
432
433	if (key == NULL \|\| key->length == 0)
434	return (-1);
435
436	assert(enc == ENCRYPT \|\| enc == DECRYPT);
437	assert(key->length == 16 && iv->length == 8);
438	BF_set_key(&ks, key->length, key->data);
439	BF_cfb64_encrypt(buf->data, buf->data, buf->length, &ks, iv->data, &n,
440	enc == ENCRYPT ? BF_ENCRYPT : BF_DECRYPT);
441	return (0);
442	}
443
444	int buf_castcrypt(BUFFER buf, BUFFER key, BUFFER *iv, int enc)
445	{
446	int n = 0;
447	CAST_KEY ks;
448
449	if (key == NULL \|\| key->length == 0)
450	return (-1);
451
452	assert(enc == ENCRYPT \|\| enc == DECRYPT);
453	assert(key->length == 16 && iv->length == 8);
454	CAST_set_key(&ks, 16, key->data);
455	CAST_cfb64_encrypt(buf->data, buf->data, buf->length, &ks, iv->data, &n,
456	enc == ENCRYPT ? CAST_ENCRYPT : CAST_DECRYPT);
457	return (0);
458	}
459
460	#ifdef USE_AES
461	int buf_aescrypt(BUFFER buf, BUFFER key, BUFFER *iv, int enc)
462	{
463	int n = 0;
464	AES_KEY ks;
465
466	if (key == NULL \|\| key->length == 0)
467	return (-1);
468
469	assert(enc == ENCRYPT \|\| enc == DECRYPT);
470	assert((key->length == 16 \|\| key->length == 24 \|\| key->length == 32) && iv->length == 16);
471	AES_set_encrypt_key(key->data, key->length<<3, &ks);
472	AES_cfb128_encrypt(buf->data, buf->data, buf->length, &ks, iv->data, &n,
473	enc == ENCRYPT ? AES_ENCRYPT : AES_DECRYPT);
474	return (0);
475	}
476	#endif /* USE_AES */
477
478	#ifdef USE_IDEA
479	int buf_ideacrypt(BUFFER buf, BUFFER key, BUFFER *iv, int enc)
480	{
481	int n = 0;
482	IDEA_KEY_SCHEDULE ks;
483
484	if (key == NULL \|\| key->length == 0)
485	return (-1);
486
487	assert(enc == ENCRYPT \|\| enc == DECRYPT);
488	assert(key->length == 16 && iv->length == 8);
489	idea_set_encrypt_key(key->data, &ks);
490	idea_cfb64_encrypt(buf->data, buf->data, buf->length, &ks, iv->data, &n,
491	enc == ENCRYPT ? IDEA_ENCRYPT : IDEA_DECRYPT);
492	return (0);
493	}
494	#endif /* USE_IDEA */
495	#endif /* USE_OPENSSL */