1/* Demo of how to construct your own engine and using it.  The basis of this
2   engine is RSAref, an old reference of the RSA algorithm which can still
3   be found a little here and there. */
4
5#include <stdio.h>
6#include <string.h>
7#include "./source/global.h"
8#include "./source/rsaref.h"
9#include "./source/rsa.h"
10#include "./source/des.h"
11#include <openssl/err.h>
12#define OPENSSL_NO_MD2
13#define OPENSSL_NO_MD5
14#include <openssl/evp.h>
15#include <openssl/bn.h>
16#include <openssl/engine.h>
17
18#define RSAREF_LIB_NAME "rsaref engine"
19#include "rsaref_err.c"
20
21/*****************************************************************************
22 *** Function declarations and global variable definitions                 ***
23 *****************************************************************************/
24
25/*****************************************************************************
26 * Constants used when creating the ENGINE
27 **/
28static const char *engine_rsaref_id = "rsaref";
29static const char *engine_rsaref_name = "RSAref engine support";
30
31/*****************************************************************************
32 * Functions to handle the engine
33 **/
34static int rsaref_destroy(ENGINE *e);
35static int rsaref_init(ENGINE *e);
36static int rsaref_finish(ENGINE *e);
37#if 0
38static int rsaref_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)());
39#endif
40
41/*****************************************************************************
42 * Engine commands
43 **/
44static const ENGINE_CMD_DEFN rsaref_cmd_defns[] = {
45	{0, NULL, NULL, 0}
46	};
47
48/*****************************************************************************
49 * RSA functions
50 **/
51static int rsaref_private_decrypt(int len, const unsigned char *from,
52	unsigned char *to, RSA *rsa, int padding);
53static int rsaref_private_encrypt(int len, const unsigned char *from,
54	unsigned char *to, RSA *rsa, int padding);
55static int rsaref_public_encrypt(int len, const unsigned char *from,
56	unsigned char *to, RSA *rsa, int padding);
57static int rsaref_public_decrypt(int len, const unsigned char *from,
58	unsigned char *to, RSA *rsa, int padding);
59static int bnref_mod_exp(BIGNUM *r,const BIGNUM *a,const BIGNUM *p,const BIGNUM *m,
60			  BN_CTX *ctx, BN_MONT_CTX *m_ctx);
61static int rsaref_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa);
62
63/*****************************************************************************
64 * Our RSA method
65 **/
66static RSA_METHOD rsaref_rsa =
67{
68  "RSAref PKCS#1 RSA",
69  rsaref_public_encrypt,
70  rsaref_public_decrypt,
71  rsaref_private_encrypt,
72  rsaref_private_decrypt,
73  rsaref_mod_exp,
74  bnref_mod_exp,
75  NULL,
76  NULL,
77  0,
78  NULL,
79  NULL,
80  NULL
81};
82
83/*****************************************************************************
84 * Symetric cipher and digest function registrars
85 **/
86static int rsaref_ciphers(ENGINE *e, const EVP_CIPHER **cipher,
87	const int **nids, int nid);
88static int rsaref_digests(ENGINE *e, const EVP_MD **digest,
89	const int **nids, int nid);
90
91static int rsaref_cipher_nids[] =
92	{ NID_des_cbc, NID_des_ede3_cbc, NID_desx_cbc, 0 };
93static int rsaref_digest_nids[] =
94	{ NID_md2, NID_md5, 0 };
95
96/*****************************************************************************
97 * DES functions
98 **/
99static int cipher_des_cbc_init(EVP_CIPHER_CTX *ctx, const unsigned char *key,
100	const unsigned char *iv, int enc);
101static int cipher_des_cbc_code(EVP_CIPHER_CTX *ctx, unsigned char *out,
102	const unsigned char *in, unsigned int inl);
103static int cipher_des_cbc_clean(EVP_CIPHER_CTX *);
104static int cipher_des_ede3_cbc_init(EVP_CIPHER_CTX *ctx, const unsigned char *key,
105	const unsigned char *iv, int enc);
106static int cipher_des_ede3_cbc_code(EVP_CIPHER_CTX *ctx, unsigned char *out,
107	const unsigned char *in, unsigned int inl);
108static int cipher_des_ede3_cbc_clean(EVP_CIPHER_CTX *);
109static int cipher_desx_cbc_init(EVP_CIPHER_CTX *ctx, const unsigned char *key,
110	const unsigned char *iv, int enc);
111static int cipher_desx_cbc_code(EVP_CIPHER_CTX *ctx, unsigned char *out,
112	const unsigned char *in, unsigned int inl);
113static int cipher_desx_cbc_clean(EVP_CIPHER_CTX *);
114
115/*****************************************************************************
116 * Our DES ciphers
117 **/
118static const EVP_CIPHER cipher_des_cbc =
119	{
120	NID_des_cbc,
121	8, 8, 8,
122	0 | EVP_CIPH_CBC_MODE,
123	cipher_des_cbc_init,
124	cipher_des_cbc_code,
125	cipher_des_cbc_clean,
126	sizeof(DES_CBC_CTX),
127	NULL,
128	NULL,
129	NULL,
130	NULL
131	};
132
133static const EVP_CIPHER cipher_des_ede3_cbc =
134	{
135	NID_des_ede3_cbc,
136	8, 24, 8,
137	0 | EVP_CIPH_CBC_MODE,
138	cipher_des_ede3_cbc_init,
139	cipher_des_ede3_cbc_code,
140	cipher_des_ede3_cbc_clean,
141	sizeof(DES3_CBC_CTX),
142	NULL,
143	NULL,
144	NULL,
145	NULL
146	};
147
148static const EVP_CIPHER cipher_desx_cbc =
149	{
150	NID_desx_cbc,
151	8, 24, 8,
152	0 | EVP_CIPH_CBC_MODE,
153	cipher_desx_cbc_init,
154	cipher_desx_cbc_code,
155	cipher_desx_cbc_clean,
156	sizeof(DESX_CBC_CTX),
157	NULL,
158	NULL,
159	NULL,
160	NULL
161	};
162
163/*****************************************************************************
164 * MD functions
165 **/
166static int digest_md2_init(EVP_MD_CTX *ctx);
167static int digest_md2_update(EVP_MD_CTX *ctx,const void *data,
168	unsigned long count);
169static int digest_md2_final(EVP_MD_CTX *ctx,unsigned char *md);
170static int digest_md5_init(EVP_MD_CTX *ctx);
171static int digest_md5_update(EVP_MD_CTX *ctx,const void *data,
172	unsigned long count);
173static int digest_md5_final(EVP_MD_CTX *ctx,unsigned char *md);
174
175/*****************************************************************************
176 * Our MD digests
177 **/
178static const EVP_MD digest_md2 =
179	{
180	NID_md2,
181	NID_md2WithRSAEncryption,
182	16,
183	0,
184	digest_md2_init,
185	digest_md2_update,
186	digest_md2_final,
187	NULL,
188	NULL,
189	EVP_PKEY_RSA_method,
190	16,
191	sizeof(MD2_CTX)
192	};
193
194static const EVP_MD digest_md5 =
195	{
196	NID_md5,
197	NID_md5WithRSAEncryption,
198	16,
199	0,
200	digest_md5_init,
201	digest_md5_update,
202	digest_md5_final,
203	NULL,
204	NULL,
205	EVP_PKEY_RSA_method,
206	64,
207	sizeof(MD5_CTX)
208	};
209
210/*****************************************************************************
211 *** Function definitions                                                  ***
212 *****************************************************************************/
213
214/*****************************************************************************
215 * Functions to handle the engine
216 **/
217
218static int bind_rsaref(ENGINE *e)
219	{
220	const RSA_METHOD *meth1;
221	if(!ENGINE_set_id(e, engine_rsaref_id)
222		|| !ENGINE_set_name(e, engine_rsaref_name)
223		|| !ENGINE_set_RSA(e, &rsaref_rsa)
224		|| !ENGINE_set_ciphers(e, rsaref_ciphers)
225		|| !ENGINE_set_digests(e, rsaref_digests)
226		|| !ENGINE_set_destroy_function(e, rsaref_destroy)
227		|| !ENGINE_set_init_function(e, rsaref_init)
228		|| !ENGINE_set_finish_function(e, rsaref_finish)
229		/* || !ENGINE_set_ctrl_function(e, rsaref_ctrl) */
230		/* || !ENGINE_set_cmd_defns(e, rsaref_cmd_defns) */)
231		return 0;
232
233	/* Ensure the rsaref error handling is set up */
234	ERR_load_RSAREF_strings();
235	return 1;
236	}
237
238#ifdef ENGINE_DYNAMIC_SUPPORT
239static int bind_helper(ENGINE *e, const char *id)
240	{
241	if(id && (strcmp(id, engine_rsaref_id) != 0))
242		return 0;
243	if(!bind_rsaref(e))
244		return 0;
245	return 1;
246	}
247IMPLEMENT_DYNAMIC_CHECK_FN()
248IMPLEMENT_DYNAMIC_BIND_FN(bind_helper)
249#else
250static ENGINE *engine_rsaref(void)
251	{
252	ENGINE *ret = ENGINE_new();
253	if(!ret)
254		return NULL;
255	if(!bind_rsaref(ret))
256		{
257		ENGINE_free(ret);
258		return NULL;
259		}
260	return ret;
261	}
262
263void ENGINE_load_rsaref(void)
264	{
265	/* Copied from eng_[openssl|dyn].c */
266	ENGINE *toadd = engine_rsaref();
267	if(!toadd) return;
268	ENGINE_add(toadd);
269	ENGINE_free(toadd);
270	ERR_clear_error();
271	}
272#endif
273
274/* Initiator which is only present to make sure this engine looks available */
275static int rsaref_init(ENGINE *e)
276	{
277	return 1;
278	}
279
280/* Finisher which is only present to make sure this engine looks available */
281static int rsaref_finish(ENGINE *e)
282	{
283	return 1;
284	}
285
286/* Destructor (complements the "ENGINE_ncipher()" constructor) */
287static int rsaref_destroy(ENGINE *e)
288	{
289	ERR_unload_RSAREF_strings();
290	return 1;
291	}
292
293/*****************************************************************************
294 * RSA functions
295 **/
296
297static int rsaref_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa)
298	{
299	RSAREFerr(RSAREF_F_RSAREF_MOD_EXP,ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
300	return(0);
301	}
302
303static int bnref_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
304			  const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx)
305	{
306	RSAREFerr(RSAREF_F_BNREF_MOD_EXP,ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
307	return(0);
308	}
309
310/* unsigned char *to:  [max]    */
311static int RSAref_bn2bin(BIGNUM *from, unsigned char *to, int max)
312	{
313	int i;
314
315	i=BN_num_bytes(from);
316	if (i > max)
317		{
318		RSAREFerr(RSAREF_F_RSAREF_BN2BIN,RSAREF_R_LEN);
319		return(0);
320		}
321
322	memset(to,0,(unsigned int)max);
323	if (!BN_bn2bin(from,&(to[max-i])))
324		return(0);
325	return(1);
326	}
327
328#ifdef undef
329/* unsigned char *from:  [max]    */
330static BIGNUM *RSAref_bin2bn(unsigned char *from, BIGNUM *to, int max)
331	{
332	int i;
333	BIGNUM *ret;
334
335	for (i=0; i<max; i++)
336		if (from[i]) break;
337
338	ret=BN_bin2bn(&(from[i]),max-i,to);
339	return(ret);
340	}
341
342static int RSAref_Public_ref2eay(RSArefPublicKey *from, RSA *to)
343	{
344	to->n=RSAref_bin2bn(from->m,NULL,RSAref_MAX_LEN);
345	to->e=RSAref_bin2bn(from->e,NULL,RSAref_MAX_LEN);
346	if ((to->n == NULL) || (to->e == NULL)) return(0);
347	return(1);
348	}
349#endif
350
351static int RSAref_Public_eay2ref(RSA *from, R_RSA_PUBLIC_KEY *to)
352	{
353	to->bits=BN_num_bits(from->n);
354	if (!RSAref_bn2bin(from->n,to->modulus,MAX_RSA_MODULUS_LEN)) return(0);
355	if (!RSAref_bn2bin(from->e,to->exponent,MAX_RSA_MODULUS_LEN)) return(0);
356	return(1);
357	}
358
359#ifdef undef
360static int RSAref_Private_ref2eay(RSArefPrivateKey *from, RSA *to)
361	{
362	if ((to->n=RSAref_bin2bn(from->m,NULL,RSAref_MAX_LEN)) == NULL)
363		return(0);
364	if ((to->e=RSAref_bin2bn(from->e,NULL,RSAref_MAX_LEN)) == NULL)
365		return(0);
366	if ((to->d=RSAref_bin2bn(from->d,NULL,RSAref_MAX_LEN)) == NULL)
367		return(0);
368	if ((to->p=RSAref_bin2bn(from->prime[0],NULL,RSAref_MAX_PLEN)) == NULL)
369		return(0);
370	if ((to->q=RSAref_bin2bn(from->prime[1],NULL,RSAref_MAX_PLEN)) == NULL)
371		return(0);
372	if ((to->dmp1=RSAref_bin2bn(from->pexp[0],NULL,RSAref_MAX_PLEN))
373		== NULL)
374		return(0);
375	if ((to->dmq1=RSAref_bin2bn(from->pexp[1],NULL,RSAref_MAX_PLEN))
376		== NULL)
377		return(0);
378	if ((to->iqmp=RSAref_bin2bn(from->coef,NULL,RSAref_MAX_PLEN)) == NULL)
379		return(0);
380	return(1);
381	}
382#endif
383
384static int RSAref_Private_eay2ref(RSA *from, R_RSA_PRIVATE_KEY *to)
385	{
386	to->bits=BN_num_bits(from->n);
387	if (!RSAref_bn2bin(from->n,to->modulus,MAX_RSA_MODULUS_LEN)) return(0);
388	if (!RSAref_bn2bin(from->e,to->publicExponent,MAX_RSA_MODULUS_LEN)) return(0);
389	if (!RSAref_bn2bin(from->d,to->exponent,MAX_RSA_MODULUS_LEN)) return(0);
390	if (!RSAref_bn2bin(from->p,to->prime[0],MAX_RSA_PRIME_LEN)) return(0);
391	if (!RSAref_bn2bin(from->q,to->prime[1],MAX_RSA_PRIME_LEN)) return(0);
392	if (!RSAref_bn2bin(from->dmp1,to->primeExponent[0],MAX_RSA_PRIME_LEN)) return(0);
393	if (!RSAref_bn2bin(from->dmq1,to->primeExponent[1],MAX_RSA_PRIME_LEN)) return(0);
394	if (!RSAref_bn2bin(from->iqmp,to->coefficient,MAX_RSA_PRIME_LEN)) return(0);
395	return(1);
396	}
397
398static int rsaref_private_decrypt(int len, const unsigned char *from, unsigned char *to,
399	     RSA *rsa, int padding)
400	{
401	int i,outlen= -1;
402	R_RSA_PRIVATE_KEY RSAkey;
403
404	if (!RSAref_Private_eay2ref(rsa,&RSAkey))
405		goto err;
406	if ((i=RSAPrivateDecrypt(to,(unsigned int *)&outlen,(unsigned char *)from,len,&RSAkey)) != 0)
407		{
408		RSAREFerr(RSAREF_F_RSAREF_PRIVATE_DECRYPT,i);
409		outlen= -1;
410		}
411err:
412	memset(&RSAkey,0,sizeof(RSAkey));
413	return(outlen);
414	}
415
416static int rsaref_private_encrypt(int len, const unsigned char *from, unsigned char *to,
417	     RSA *rsa, int padding)
418	{
419	int i,outlen= -1;
420	R_RSA_PRIVATE_KEY RSAkey;
421
422	if (padding != RSA_PKCS1_PADDING)
423		{
424		RSAREFerr(RSAREF_F_RSAREF_PRIVATE_ENCRYPT, RSA_R_UNKNOWN_PADDING_TYPE);
425		goto err;
426	}
427	if (!RSAref_Private_eay2ref(rsa,&RSAkey))
428		goto err;
429	if ((i=RSAPrivateEncrypt(to,(unsigned int *)&outlen,(unsigned char *)from,len,&RSAkey)) != 0)
430		{
431		RSAREFerr(RSAREF_F_RSAREF_PRIVATE_ENCRYPT,i);
432		outlen= -1;
433		}
434err:
435	memset(&RSAkey,0,sizeof(RSAkey));
436	return(outlen);
437	}
438
439static int rsaref_public_decrypt(int len, const unsigned char *from, unsigned char *to,
440	     RSA *rsa, int padding)
441	{
442	int i,outlen= -1;
443	R_RSA_PUBLIC_KEY RSAkey;
444
445	if (!RSAref_Public_eay2ref(rsa,&RSAkey))
446		goto err;
447	if ((i=RSAPublicDecrypt(to,(unsigned int *)&outlen,(unsigned char *)from,len,&RSAkey)) != 0)
448		{
449		RSAREFerr(RSAREF_F_RSAREF_PUBLIC_DECRYPT,i);
450		outlen= -1;
451		}
452err:
453	memset(&RSAkey,0,sizeof(RSAkey));
454	return(outlen);
455	}
456
457static int rsaref_public_encrypt(int len, const unsigned char *from, unsigned char *to,
458	     RSA *rsa, int padding)
459	{
460	int outlen= -1;
461	int i;
462	R_RSA_PUBLIC_KEY RSAkey;
463	R_RANDOM_STRUCT rnd;
464	unsigned char buf[16];
465
466	if (padding != RSA_PKCS1_PADDING && padding != RSA_SSLV23_PADDING)
467		{
468		RSAREFerr(RSAREF_F_RSAREF_PUBLIC_ENCRYPT, RSA_R_UNKNOWN_PADDING_TYPE);
469		goto err;
470		}
471
472	R_RandomInit(&rnd);
473	R_GetRandomBytesNeeded((unsigned int *)&i,&rnd);
474	while (i > 0)
475		{
476		if (RAND_bytes(buf,16) <= 0)
477			goto err;
478		R_RandomUpdate(&rnd,buf,(unsigned int)((i>16)?16:i));
479		i-=16;
480		}
481
482	if (!RSAref_Public_eay2ref(rsa,&RSAkey))
483		goto err;
484	if ((i=RSAPublicEncrypt(to,(unsigned int *)&outlen,(unsigned char *)from,len,&RSAkey,&rnd)) != 0)
485		{
486		RSAREFerr(RSAREF_F_RSAREF_PUBLIC_ENCRYPT,i);
487		outlen= -1;
488		goto err;
489		}
490err:
491	memset(&RSAkey,0,sizeof(RSAkey));
492	R_RandomFinal(&rnd);
493	memset(&rnd,0,sizeof(rnd));
494	return(outlen);
495	}
496
497/*****************************************************************************
498 * Symetric cipher and digest function registrars
499 **/
500static int rsaref_ciphers(ENGINE *e, const EVP_CIPHER **cipher,
501	const int **nids, int nid)
502	{
503	int ok = 1;
504	if(!cipher)
505		{
506		/* We are returning a list of supported nids */
507		*nids = rsaref_cipher_nids;
508		return (sizeof(rsaref_cipher_nids)-1)/sizeof(rsaref_cipher_nids[0]);
509		}
510	/* We are being asked for a specific cipher */
511	switch (nid)
512		{
513	case NID_des_cbc:
514		*cipher = &cipher_des_cbc; break;
515	case NID_des_ede3_cbc:
516		*cipher = &cipher_des_ede3_cbc; break;
517	case NID_desx_cbc:
518		*cipher = &cipher_desx_cbc; break;
519	default:
520		ok = 0;
521		*cipher = NULL;
522		break;
523		}
524	return ok;
525	}
526static int rsaref_digests(ENGINE *e, const EVP_MD **digest,
527	const int **nids, int nid)
528	{
529	int ok = 1;
530	if(!digest)
531		{
532		/* We are returning a list of supported nids */
533		*nids = rsaref_digest_nids;
534		return (sizeof(rsaref_digest_nids)-1)/sizeof(rsaref_digest_nids[0]);
535		}
536	/* We are being asked for a specific digest */
537	switch (nid)
538		{
539	case NID_md2:
540		*digest = &digest_md2; break;
541	case NID_md5:
542		*digest = &digest_md5; break;
543	default:
544		ok = 0;
545		*digest = NULL;
546		break;
547		}
548	return ok;
549	}
550
551/*****************************************************************************
552 * DES functions
553 **/
554#undef data
555#define data(ctx) ((DES_CBC_CTX *)(ctx)->cipher_data)
556static int cipher_des_cbc_init(EVP_CIPHER_CTX *ctx, const unsigned char *key,
557	const unsigned char *iv, int enc)
558	{
559	DES_CBCInit(data(ctx), (unsigned char *)key, (unsigned char *)iv, enc);
560	return 1;
561	}
562static int cipher_des_cbc_code(EVP_CIPHER_CTX *ctx, unsigned char *out,
563	const unsigned char *in, unsigned int inl)
564	{
565	int ret = DES_CBCUpdate(data(ctx), out, (unsigned char *)in, inl);
566	switch (ret)
567		{
568	case RE_LEN:
569		RSAREFerr(RSAREF_F_CIPHER_DES_CBC_CODE,RSAREF_R_LENGTH_NOT_BLOCK_ALIGNED);
570		break;
571	case 0:
572		break;
573	default:
574		RSAREFerr(RSAREF_F_CIPHER_DES_CBC_CODE,RSAREF_R_UNKNOWN_FAULT);
575		}
576	return !ret;
577	}
578static int cipher_des_cbc_clean(EVP_CIPHER_CTX *ctx)
579	{
580	memset(data(ctx), 0, ctx->cipher->ctx_size);
581	return 1;
582	}
583
584#undef data
585#define data(ctx) ((DES3_CBC_CTX *)(ctx)->cipher_data)
586static int cipher_des_ede3_cbc_init(EVP_CIPHER_CTX *ctx, const unsigned char *key,
587	const unsigned char *iv, int enc)
588	{
589	DES3_CBCInit(data(ctx), (unsigned char *)key, (unsigned char *)iv,
590		enc);
591	return 1;
592	}
593static int cipher_des_ede3_cbc_code(EVP_CIPHER_CTX *ctx, unsigned char *out,
594	const unsigned char *in, unsigned int inl)
595	{
596	int ret = DES3_CBCUpdate(data(ctx), out, (unsigned char *)in, inl);
597	switch (ret)
598		{
599	case RE_LEN:
600		RSAREFerr(RSAREF_F_CIPHER_DES_CBC_CODE,RSAREF_R_LENGTH_NOT_BLOCK_ALIGNED);
601		break;
602	case 0:
603		break;
604	default:
605		RSAREFerr(RSAREF_F_CIPHER_DES_CBC_CODE,RSAREF_R_UNKNOWN_FAULT);
606		}
607	return !ret;
608	}
609static int cipher_des_ede3_cbc_clean(EVP_CIPHER_CTX *ctx)
610	{
611	memset(data(ctx), 0, ctx->cipher->ctx_size);
612	return 1;
613	}
614
615#undef data
616#define data(ctx) ((DESX_CBC_CTX *)(ctx)->cipher_data)
617static int cipher_desx_cbc_init(EVP_CIPHER_CTX *ctx, const unsigned char *key,
618	const unsigned char *iv, int enc)
619	{
620	DESX_CBCInit(data(ctx), (unsigned char *)key, (unsigned char *)iv,
621		enc);
622	return 1;
623	}
624static int cipher_desx_cbc_code(EVP_CIPHER_CTX *ctx, unsigned char *out,
625	const unsigned char *in, unsigned int inl)
626	{
627	int ret = DESX_CBCUpdate(data(ctx), out, (unsigned char *)in, inl);
628	switch (ret)
629		{
630	case RE_LEN:
631		RSAREFerr(RSAREF_F_CIPHER_DES_CBC_CODE,RSAREF_R_LENGTH_NOT_BLOCK_ALIGNED);
632		break;
633	case 0:
634		break;
635	default:
636		RSAREFerr(RSAREF_F_CIPHER_DES_CBC_CODE,RSAREF_R_UNKNOWN_FAULT);
637		}
638	return !ret;
639	}
640static int cipher_desx_cbc_clean(EVP_CIPHER_CTX *ctx)
641	{
642	memset(data(ctx), 0, ctx->cipher->ctx_size);
643	return 1;
644	}
645
646/*****************************************************************************
647 * MD functions
648 **/
649#undef data
650#define data(ctx) ((MD2_CTX *)(ctx)->md_data)
651static int digest_md2_init(EVP_MD_CTX *ctx)
652	{
653	MD2Init(data(ctx));
654	return 1;
655	}
656static int digest_md2_update(EVP_MD_CTX *ctx,const void *data,
657	unsigned long count)
658	{
659	MD2Update(data(ctx), (unsigned char *)data, (unsigned int)count);
660	return 1;
661	}
662static int digest_md2_final(EVP_MD_CTX *ctx,unsigned char *md)
663	{
664	MD2Final(md, data(ctx));
665	return 1;
666	}
667
668#undef data
669#define data(ctx) ((MD5_CTX *)(ctx)->md_data)
670static int digest_md5_init(EVP_MD_CTX *ctx)
671	{
672	MD5Init(data(ctx));
673	return 1;
674	}
675static int digest_md5_update(EVP_MD_CTX *ctx,const void *data,
676	unsigned long count)
677	{
678	MD5Update(data(ctx), (unsigned char *)data, (unsigned int)count);
679	return 1;
680	}
681static int digest_md5_final(EVP_MD_CTX *ctx,unsigned char *md)
682	{
683	MD5Final(md, data(ctx));
684	return 1;
685	}
686