← Back to branch summary

~andersk/ubuntu/oneiric/openssl/spurious-reboot

« back to all changes in this revision

Viewing changes to demos/engines/rsaref/rsaref.c

  • Committer: Bazaar Package Importer
  • Author(s): Christoph Martin
  • Date: 2004-05-24 17:02:29 UTC
  • Revision ID: james.westby@ubuntu.com-20040524170229-ixlo08bbbly0xied
Tags: upstream-0.9.7d
Import upstream version 0.9.7d

Show diffs side-by-side

added added

removed removed

Lines of Context:
demos/engines/rsaref/rsaref.c
 
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
 **/
 
28
static const char *engine_rsaref_id = "rsaref";
 
29
static const char *engine_rsaref_name = "RSAref engine support";
 
30
 
 
31
/*****************************************************************************
 
32
 * Functions to handle the engine
 
33
 **/
 
34
static int rsaref_destroy(ENGINE *e);
 
35
static int rsaref_init(ENGINE *e);
 
36
static int rsaref_finish(ENGINE *e);
 
37
#if 0
 
38
static int rsaref_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)()); 
 
39
#endif
 
40
 
 
41
/*****************************************************************************
 
42
 * Engine commands
 
43
 **/
 
44
static const ENGINE_CMD_DEFN rsaref_cmd_defns[] = {
 
45
        {0, NULL, NULL, 0}
 
46
        };
 
47
 
 
48
/*****************************************************************************
 
49
 * RSA functions
 
50
 **/
 
51
static int rsaref_private_decrypt(int len, const unsigned char *from,
 
52
        unsigned char *to, RSA *rsa, int padding);
 
53
static int rsaref_private_encrypt(int len, const unsigned char *from,
 
54
        unsigned char *to, RSA *rsa, int padding);
 
55
static int rsaref_public_encrypt(int len, const unsigned char *from,
 
56
        unsigned char *to, RSA *rsa, int padding);
 
57
static int rsaref_public_decrypt(int len, const unsigned char *from,
 
58
        unsigned char *to, RSA *rsa, int padding);
 
59
static int bnref_mod_exp(BIGNUM *r,const BIGNUM *a,const BIGNUM *p,const BIGNUM *m,
 
60
                          BN_CTX *ctx, BN_MONT_CTX *m_ctx);
 
61
static int rsaref_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa);
 
62
 
 
63
/*****************************************************************************
 
64
 * Our RSA method
 
65
 **/
 
66
static 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
 **/
 
86
static int rsaref_ciphers(ENGINE *e, const EVP_CIPHER **cipher,
 
87
        const int **nids, int nid);
 
88
static int rsaref_digests(ENGINE *e, const EVP_MD **digest,
 
89
        const int **nids, int nid);
 
90
 
 
91
static int rsaref_cipher_nids[] =
 
92
        { NID_des_cbc, NID_des_ede3_cbc, NID_desx_cbc, 0 };
 
93
static int rsaref_digest_nids[] =
 
94
        { NID_md2, NID_md5, 0 };
 
95
 
 
96
/*****************************************************************************
 
97
 * DES functions
 
98
 **/
 
99
static int cipher_des_cbc_init(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 
100
        const unsigned char *iv, int enc);
 
101
static int cipher_des_cbc_code(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
102
        const unsigned char *in, unsigned int inl);
 
103
static int cipher_des_cbc_clean(EVP_CIPHER_CTX *);
 
104
static int cipher_des_ede3_cbc_init(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 
105
        const unsigned char *iv, int enc);
 
106
static int cipher_des_ede3_cbc_code(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
107
        const unsigned char *in, unsigned int inl);
 
108
static int cipher_des_ede3_cbc_clean(EVP_CIPHER_CTX *);
 
109
static int cipher_desx_cbc_init(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 
110
        const unsigned char *iv, int enc);
 
111
static int cipher_desx_cbc_code(EVP_CIPHER_CTX *ctx, unsigned char *out,
 
112
        const unsigned char *in, unsigned int inl);
 
113
static int cipher_desx_cbc_clean(EVP_CIPHER_CTX *);
 
114
 
 
115
/*****************************************************************************
 
116
 * Our DES ciphers
 
117
 **/
 
118
static 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
 
 
133
static 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
 
 
148
static 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
 **/
 
166
static int digest_md2_init(EVP_MD_CTX *ctx);
 
167
static int digest_md2_update(EVP_MD_CTX *ctx,const void *data,
 
168
        unsigned long count);
 
169
static int digest_md2_final(EVP_MD_CTX *ctx,unsigned char *md);
 
170
static int digest_md5_init(EVP_MD_CTX *ctx);
 
171
static int digest_md5_update(EVP_MD_CTX *ctx,const void *data,
 
172
        unsigned long count);
 
173
static int digest_md5_final(EVP_MD_CTX *ctx,unsigned char *md);
 
174
 
 
175
/*****************************************************************************
 
176
 * Our MD digests
 
177
 **/
 
178
static 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
 
 
194
static 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
 
 
218
static 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
 
239
static 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
        }       
 
247
IMPLEMENT_DYNAMIC_CHECK_FN()
 
248
IMPLEMENT_DYNAMIC_BIND_FN(bind_helper)
 
249
#else
 
250
static 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
 
 
263
void 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 */
 
275
static int rsaref_init(ENGINE *e)
 
276
        {
 
277
        return 1;
 
278
        }
 
279
 
 
280
/* Finisher which is only present to make sure this engine looks available */
 
281
static int rsaref_finish(ENGINE *e)
 
282
        {
 
283
        return 1;
 
284
        }
 
285
 
 
286
/* Destructor (complements the "ENGINE_ncipher()" constructor) */
 
287
static int rsaref_destroy(ENGINE *e)
 
288
        {
 
289
        ERR_unload_RSAREF_strings();
 
290
        return 1;
 
291
        }
 
292
 
 
293
/*****************************************************************************
 
294
 * RSA functions
 
295
 **/
 
296
 
 
297
static 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
 
 
303
static 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]    */
 
311
static 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]    */
 
330
static 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
 
 
342
static 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
 
 
351
static 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
 
360
static 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
 
 
384
static 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
 
 
398
static 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
                }
 
411
err:
 
412
        memset(&RSAkey,0,sizeof(RSAkey));
 
413
        return(outlen);
 
414
        }
 
415
 
 
416
static 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
                }
 
434
err:
 
435
        memset(&RSAkey,0,sizeof(RSAkey));
 
436
        return(outlen);
 
437
        }
 
438
 
 
439
static 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
                }
 
452
err:
 
453
        memset(&RSAkey,0,sizeof(RSAkey));
 
454
        return(outlen);
 
455
        }
 
456
 
 
457
static 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
                }
 
490
err:
 
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
 **/
 
500
static 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
        }
 
526
static 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)
 
556
static 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
        }
 
562
static 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
        }
 
578
static 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)
 
586
static 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
        }
 
593
static 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
        }
 
609
static 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)
 
617
static 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
        }
 
624
static 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
        }
 
640
static 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)
 
651
static int digest_md2_init(EVP_MD_CTX *ctx)
 
652
        {
 
653
        MD2Init(data(ctx));
 
654
        return 1;
 
655
        }
 
656
static 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
        }
 
662
static 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)
 
670
static int digest_md5_init(EVP_MD_CTX *ctx)
 
671
        {
 
672
        MD5Init(data(ctx));
 
673
        return 1;
 
674
        }
 
675
static 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
        }
 
681
static int digest_md5_final(EVP_MD_CTX *ctx,unsigned char *md)
 
682
        {
 
683
        MD5Final(md, data(ctx));
 
684
        return 1;
 
685
        }