~ubuntu-branches/ubuntu/oneiric/psi/oneiric

« back to all changes in this revision

Viewing changes to src/openssl/evp.h

  • Committer: Bazaar Package Importer
  • Author(s): Jan Niehusmann
  • Date: 2005-01-10 17:41:43 UTC
  • mfrom: (1.2.1 upstream) (2.1.2 hoary)
  • Revision ID: james.westby@ubuntu.com-20050110174143-ltocv5zapl6blf5d
Tags: 0.9.3-1
* New upstream release
* Cleaned up debian/rules (some things are done by upstream Makefiles now)
* Fixed some lintian warnings:
  - removed executable bit from some .png files
  - moved psi.desktop to /usr/share/applications
* Updated menu files

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
/* crypto/evp/evp.h */
2
 
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3
 
 * All rights reserved.
4
 
 *
5
 
 * This package is an SSL implementation written
6
 
 * by Eric Young (eay@cryptsoft.com).
7
 
 * The implementation was written so as to conform with Netscapes SSL.
8
 
 * 
9
 
 * This library is free for commercial and non-commercial use as long as
10
 
 * the following conditions are aheared to.  The following conditions
11
 
 * apply to all code found in this distribution, be it the RC4, RSA,
12
 
 * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
13
 
 * included with this distribution is covered by the same copyright terms
14
 
 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15
 
 * 
16
 
 * Copyright remains Eric Young's, and as such any Copyright notices in
17
 
 * the code are not to be removed.
18
 
 * If this package is used in a product, Eric Young should be given attribution
19
 
 * as the author of the parts of the library used.
20
 
 * This can be in the form of a textual message at program startup or
21
 
 * in documentation (online or textual) provided with the package.
22
 
 * 
23
 
 * Redistribution and use in source and binary forms, with or without
24
 
 * modification, are permitted provided that the following conditions
25
 
 * are met:
26
 
 * 1. Redistributions of source code must retain the copyright
27
 
 *    notice, this list of conditions and the following disclaimer.
28
 
 * 2. Redistributions in binary form must reproduce the above copyright
29
 
 *    notice, this list of conditions and the following disclaimer in the
30
 
 *    documentation and/or other materials provided with the distribution.
31
 
 * 3. All advertising materials mentioning features or use of this software
32
 
 *    must display the following acknowledgement:
33
 
 *    "This product includes cryptographic software written by
34
 
 *     Eric Young (eay@cryptsoft.com)"
35
 
 *    The word 'cryptographic' can be left out if the rouines from the library
36
 
 *    being used are not cryptographic related :-).
37
 
 * 4. If you include any Windows specific code (or a derivative thereof) from 
38
 
 *    the apps directory (application code) you must include an acknowledgement:
39
 
 *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40
 
 * 
41
 
 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42
 
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43
 
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44
 
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45
 
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46
 
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47
 
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48
 
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49
 
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50
 
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51
 
 * SUCH DAMAGE.
52
 
 * 
53
 
 * The licence and distribution terms for any publically available version or
54
 
 * derivative of this code cannot be changed.  i.e. this code cannot simply be
55
 
 * copied and put under another distribution licence
56
 
 * [including the GNU Public Licence.]
57
 
 */
58
 
 
59
 
#ifndef HEADER_ENVELOPE_H
60
 
#define HEADER_ENVELOPE_H
61
 
 
62
 
#ifdef OPENSSL_ALGORITHM_DEFINES
63
 
# include "opensslconf.h"
64
 
#else
65
 
# define OPENSSL_ALGORITHM_DEFINES
66
 
# include "opensslconf.h"
67
 
# undef OPENSSL_ALGORITHM_DEFINES
68
 
#endif
69
 
 
70
 
#ifndef NO_BIO
71
 
#include "bio.h"
72
 
#endif
73
 
#ifndef NO_MD2
74
 
#include "md2.h"
75
 
#endif
76
 
#ifndef NO_MD4
77
 
#include "md4.h"
78
 
#endif
79
 
#ifndef NO_MD5
80
 
#include "md5.h"
81
 
#endif
82
 
#ifndef NO_SHA
83
 
#include "sha.h"
84
 
#endif
85
 
#ifndef NO_RIPEMD
86
 
#include "ripemd.h"
87
 
#endif
88
 
#ifndef NO_DES
89
 
#include "des.h"
90
 
#endif
91
 
#ifndef NO_RC4
92
 
#include "rc4.h"
93
 
#endif
94
 
#ifndef NO_RC2
95
 
#include "rc2.h"
96
 
#endif
97
 
#ifndef NO_RC5
98
 
#include "rc5.h"
99
 
#endif
100
 
#ifndef NO_BF
101
 
#include "blowfish.h"
102
 
#endif
103
 
#ifndef NO_CAST
104
 
#include "cast.h"
105
 
#endif
106
 
#ifndef NO_IDEA
107
 
#include "idea.h"
108
 
#endif
109
 
#ifndef NO_MDC2
110
 
#include "mdc2.h"
111
 
#endif
112
 
 
113
 
#define EVP_RC2_KEY_SIZE                16
114
 
#define EVP_RC4_KEY_SIZE                16
115
 
#define EVP_BLOWFISH_KEY_SIZE           16
116
 
#define EVP_CAST5_KEY_SIZE              16
117
 
#define EVP_RC5_32_12_16_KEY_SIZE       16
118
 
#define EVP_MAX_MD_SIZE                 (16+20) /* The SSLv3 md5+sha1 type */
119
 
#define EVP_MAX_KEY_LENGTH              24
120
 
#define EVP_MAX_IV_LENGTH               8
121
 
 
122
 
#define PKCS5_SALT_LEN                  8
123
 
/* Default PKCS#5 iteration count */
124
 
#define PKCS5_DEFAULT_ITER              2048
125
 
 
126
 
#ifndef NO_RSA
127
 
#include "rsa.h"
128
 
#endif
129
 
 
130
 
#ifndef NO_DSA
131
 
#include "dsa.h"
132
 
#endif
133
 
 
134
 
#ifndef NO_DH
135
 
#include "dh.h"
136
 
#endif
137
 
 
138
 
#include "objects.h"
139
 
 
140
 
#define EVP_PK_RSA      0x0001
141
 
#define EVP_PK_DSA      0x0002
142
 
#define EVP_PK_DH       0x0004
143
 
#define EVP_PKT_SIGN    0x0010
144
 
#define EVP_PKT_ENC     0x0020
145
 
#define EVP_PKT_EXCH    0x0040
146
 
#define EVP_PKS_RSA     0x0100
147
 
#define EVP_PKS_DSA     0x0200
148
 
#define EVP_PKT_EXP     0x1000 /* <= 512 bit key */
149
 
 
150
 
#define EVP_PKEY_NONE   NID_undef
151
 
#define EVP_PKEY_RSA    NID_rsaEncryption
152
 
#define EVP_PKEY_RSA2   NID_rsa
153
 
#define EVP_PKEY_DSA    NID_dsa
154
 
#define EVP_PKEY_DSA1   NID_dsa_2
155
 
#define EVP_PKEY_DSA2   NID_dsaWithSHA
156
 
#define EVP_PKEY_DSA3   NID_dsaWithSHA1
157
 
#define EVP_PKEY_DSA4   NID_dsaWithSHA1_2
158
 
#define EVP_PKEY_DH     NID_dhKeyAgreement
159
 
 
160
 
#ifdef  __cplusplus
161
 
extern "C" {
162
 
#endif
163
 
 
164
 
/* Type needs to be a bit field
165
 
 * Sub-type needs to be for variations on the method, as in, can it do
166
 
 * arbitrary encryption.... */
167
 
typedef struct evp_pkey_st
168
 
        {
169
 
        int type;
170
 
        int save_type;
171
 
        int references;
172
 
        union   {
173
 
                char *ptr;
174
 
#ifndef NO_RSA
175
 
                struct rsa_st *rsa;     /* RSA */
176
 
#endif
177
 
#ifndef NO_DSA
178
 
                struct dsa_st *dsa;     /* DSA */
179
 
#endif
180
 
#ifndef NO_DH
181
 
                struct dh_st *dh;       /* DH */
182
 
#endif
183
 
                } pkey;
184
 
        int save_parameters;
185
 
        STACK_OF(X509_ATTRIBUTE) *attributes; /* [ 0 ] */
186
 
        } EVP_PKEY;
187
 
 
188
 
#define EVP_PKEY_MO_SIGN        0x0001
189
 
#define EVP_PKEY_MO_VERIFY      0x0002
190
 
#define EVP_PKEY_MO_ENCRYPT     0x0004
191
 
#define EVP_PKEY_MO_DECRYPT     0x0008
192
 
 
193
 
#if 0
194
 
/* This structure is required to tie the message digest and signing together.
195
 
 * The lookup can be done by md/pkey_method, oid, oid/pkey_method, or
196
 
 * oid, md and pkey.
197
 
 * This is required because for various smart-card perform the digest and
198
 
 * signing/verification on-board.  To handle this case, the specific
199
 
 * EVP_MD and EVP_PKEY_METHODs need to be closely associated.
200
 
 * When a PKEY is created, it will have a EVP_PKEY_METHOD associated with it.
201
 
 * This can either be software or a token to provide the required low level
202
 
 * routines.
203
 
 */
204
 
typedef struct evp_pkey_md_st
205
 
        {
206
 
        int oid;
207
 
        EVP_MD *md;
208
 
        EVP_PKEY_METHOD *pkey;
209
 
        } EVP_PKEY_MD;
210
 
 
211
 
#define EVP_rsa_md2() \
212
 
                EVP_PKEY_MD_add(NID_md2WithRSAEncryption,\
213
 
                        EVP_rsa_pkcs1(),EVP_md2())
214
 
#define EVP_rsa_md5() \
215
 
                EVP_PKEY_MD_add(NID_md5WithRSAEncryption,\
216
 
                        EVP_rsa_pkcs1(),EVP_md5())
217
 
#define EVP_rsa_sha0() \
218
 
                EVP_PKEY_MD_add(NID_shaWithRSAEncryption,\
219
 
                        EVP_rsa_pkcs1(),EVP_sha())
220
 
#define EVP_rsa_sha1() \
221
 
                EVP_PKEY_MD_add(NID_sha1WithRSAEncryption,\
222
 
                        EVP_rsa_pkcs1(),EVP_sha1())
223
 
#define EVP_rsa_ripemd160() \
224
 
                EVP_PKEY_MD_add(NID_ripemd160WithRSA,\
225
 
                        EVP_rsa_pkcs1(),EVP_ripemd160())
226
 
#define EVP_rsa_mdc2() \
227
 
                EVP_PKEY_MD_add(NID_mdc2WithRSA,\
228
 
                        EVP_rsa_octet_string(),EVP_mdc2())
229
 
#define EVP_dsa_sha() \
230
 
                EVP_PKEY_MD_add(NID_dsaWithSHA,\
231
 
                        EVP_dsa(),EVP_mdc2())
232
 
#define EVP_dsa_sha1() \
233
 
                EVP_PKEY_MD_add(NID_dsaWithSHA1,\
234
 
                        EVP_dsa(),EVP_sha1())
235
 
 
236
 
typedef struct evp_pkey_method_st
237
 
        {
238
 
        char *name;
239
 
        int flags;
240
 
        int type;               /* RSA, DSA, an SSLeay specific constant */
241
 
        int oid;                /* For the pub-key type */
242
 
        int encrypt_oid;        /* pub/priv key encryption */
243
 
 
244
 
        int (*sign)();
245
 
        int (*verify)();
246
 
        struct  {
247
 
                int
248
 
                int (*set)();   /* get and/or set the underlying type */
249
 
                int (*get)();
250
 
                int (*encrypt)();
251
 
                int (*decrypt)();
252
 
                int (*i2d)();
253
 
                int (*d2i)();
254
 
                int (*dup)();
255
 
                } pub,priv;
256
 
        int (*set_asn1_parameters)();
257
 
        int (*get_asn1_parameters)();
258
 
        } EVP_PKEY_METHOD;
259
 
#endif
260
 
 
261
 
#ifndef EVP_MD
262
 
typedef struct env_md_st
263
 
        {
264
 
        int type;
265
 
        int pkey_type;
266
 
        int md_size;
267
 
        void (*init)();
268
 
        void (*update)();
269
 
        void (*final)();
270
 
 
271
 
        int (*sign)();
272
 
        int (*verify)();
273
 
        int required_pkey_type[5]; /*EVP_PKEY_xxx */
274
 
        int block_size;
275
 
        int ctx_size; /* how big does the ctx need to be */
276
 
        } EVP_MD;
277
 
 
278
 
 
279
 
 
280
 
#define EVP_PKEY_NULL_method    NULL,NULL,{0,0,0,0}
281
 
 
282
 
#ifndef NO_DSA
283
 
#define EVP_PKEY_DSA_method     DSA_sign,DSA_verify, \
284
 
                                {EVP_PKEY_DSA,EVP_PKEY_DSA2,EVP_PKEY_DSA3, \
285
 
                                        EVP_PKEY_DSA4,0}
286
 
#else
287
 
#define EVP_PKEY_DSA_method     EVP_PKEY_NULL_method
288
 
#endif
289
 
 
290
 
#ifndef NO_RSA
291
 
#define EVP_PKEY_RSA_method     RSA_sign,RSA_verify, \
292
 
                                {EVP_PKEY_RSA,EVP_PKEY_RSA2,0,0}
293
 
#define EVP_PKEY_RSA_ASN1_OCTET_STRING_method \
294
 
                                RSA_sign_ASN1_OCTET_STRING, \
295
 
                                RSA_verify_ASN1_OCTET_STRING, \
296
 
                                {EVP_PKEY_RSA,EVP_PKEY_RSA2,0,0}
297
 
#else
298
 
#define EVP_PKEY_RSA_method     EVP_PKEY_NULL_method
299
 
#define EVP_PKEY_RSA_ASN1_OCTET_STRING_method EVP_PKEY_NULL_method
300
 
#endif
301
 
 
302
 
#endif /* !EVP_MD */
303
 
 
304
 
typedef struct env_md_ctx_st
305
 
        {
306
 
        const EVP_MD *digest;
307
 
        union   {
308
 
                unsigned char base[4];
309
 
#ifndef NO_MD2
310
 
                MD2_CTX md2;
311
 
#endif
312
 
#ifndef NO_MD5
313
 
                MD5_CTX md5;
314
 
#endif
315
 
#ifndef NO_MD4
316
 
                MD4_CTX md4;
317
 
#endif
318
 
#ifndef NO_RIPEMD
319
 
                RIPEMD160_CTX ripemd160;
320
 
#endif
321
 
#ifndef NO_SHA
322
 
                SHA_CTX sha;
323
 
#endif
324
 
#ifndef NO_MDC2
325
 
                MDC2_CTX mdc2;
326
 
#endif
327
 
                } md;
328
 
        } EVP_MD_CTX;
329
 
 
330
 
typedef struct evp_cipher_st EVP_CIPHER;
331
 
typedef struct evp_cipher_ctx_st EVP_CIPHER_CTX;
332
 
 
333
 
struct evp_cipher_st
334
 
        {
335
 
        int nid;
336
 
        int block_size;
337
 
        int key_len;            /* Default value for variable length ciphers */
338
 
        int iv_len;
339
 
        unsigned long flags;    /* Various flags */
340
 
        int (*init)(EVP_CIPHER_CTX *ctx, const unsigned char *key,
341
 
                    const unsigned char *iv, int enc);  /* init key */
342
 
        int (*do_cipher)(EVP_CIPHER_CTX *ctx, unsigned char *out,
343
 
                         const unsigned char *in, unsigned int inl);/* encrypt/decrypt data */
344
 
        int (*cleanup)(EVP_CIPHER_CTX *); /* cleanup ctx */
345
 
        int ctx_size;           /* how big the ctx needs to be */
346
 
        int (*set_asn1_parameters)(EVP_CIPHER_CTX *, ASN1_TYPE *); /* Populate a ASN1_TYPE with parameters */
347
 
        int (*get_asn1_parameters)(EVP_CIPHER_CTX *, ASN1_TYPE *); /* Get parameters from a ASN1_TYPE */
348
 
        int (*ctrl)(EVP_CIPHER_CTX *, int type, int arg, void *ptr); /* Miscellaneous operations */
349
 
        void *app_data;         /* Application data */
350
 
        };
351
 
 
352
 
/* Values for cipher flags */
353
 
 
354
 
/* Modes for ciphers */
355
 
 
356
 
#define         EVP_CIPH_STREAM_CIPHER          0x0
357
 
#define         EVP_CIPH_ECB_MODE               0x1
358
 
#define         EVP_CIPH_CBC_MODE               0x2
359
 
#define         EVP_CIPH_CFB_MODE               0x3
360
 
#define         EVP_CIPH_OFB_MODE               0x4
361
 
#define         EVP_CIPH_MODE                   0x7
362
 
/* Set if variable length cipher */
363
 
#define         EVP_CIPH_VARIABLE_LENGTH        0x8
364
 
/* Set if the iv handling should be done by the cipher itself */
365
 
#define         EVP_CIPH_CUSTOM_IV              0x10
366
 
/* Set if the cipher's init() function should be called if key is NULL */
367
 
#define         EVP_CIPH_ALWAYS_CALL_INIT       0x20
368
 
/* Call ctrl() to init cipher parameters */
369
 
#define         EVP_CIPH_CTRL_INIT              0x40
370
 
/* Don't use standard key length function */
371
 
#define         EVP_CIPH_CUSTOM_KEY_LENGTH      0x80
372
 
 
373
 
/* ctrl() values */
374
 
 
375
 
#define         EVP_CTRL_INIT                   0x0
376
 
#define         EVP_CTRL_SET_KEY_LENGTH         0x1
377
 
#define         EVP_CTRL_GET_RC2_KEY_BITS       0x2
378
 
#define         EVP_CTRL_SET_RC2_KEY_BITS       0x3
379
 
#define         EVP_CTRL_GET_RC5_ROUNDS         0x4
380
 
#define         EVP_CTRL_SET_RC5_ROUNDS         0x5
381
 
 
382
 
typedef struct evp_cipher_info_st
383
 
        {
384
 
        const EVP_CIPHER *cipher;
385
 
        unsigned char iv[EVP_MAX_IV_LENGTH];
386
 
        } EVP_CIPHER_INFO;
387
 
 
388
 
struct evp_cipher_ctx_st
389
 
        {
390
 
        const EVP_CIPHER *cipher;
391
 
        int encrypt;            /* encrypt or decrypt */
392
 
        int buf_len;            /* number we have left */
393
 
 
394
 
        unsigned char  oiv[EVP_MAX_IV_LENGTH];  /* original iv */
395
 
        unsigned char  iv[EVP_MAX_IV_LENGTH];   /* working iv */
396
 
        unsigned char buf[EVP_MAX_IV_LENGTH];   /* saved partial block */
397
 
        int num;                                /* used by cfb/ofb mode */
398
 
 
399
 
        void *app_data;         /* application stuff */
400
 
        int key_len;            /* May change for variable length cipher */
401
 
        union   {
402
 
#ifndef NO_RC4
403
 
                struct
404
 
                        {
405
 
                        unsigned char key[EVP_RC4_KEY_SIZE];
406
 
                        RC4_KEY ks;     /* working key */
407
 
                        } rc4;
408
 
#endif
409
 
#ifndef NO_DES
410
 
                des_key_schedule des_ks;/* key schedule */
411
 
                struct
412
 
                        {
413
 
                        des_key_schedule ks;/* key schedule */
414
 
                        des_cblock inw;
415
 
                        des_cblock outw;
416
 
                        } desx_cbc;
417
 
                struct
418
 
                        {
419
 
                        des_key_schedule ks1;/* key schedule */
420
 
                        des_key_schedule ks2;/* key schedule (for ede) */
421
 
                        des_key_schedule ks3;/* key schedule (for ede3) */
422
 
                        } des_ede;
423
 
#endif
424
 
#ifndef NO_IDEA
425
 
                IDEA_KEY_SCHEDULE idea_ks;/* key schedule */
426
 
#endif
427
 
#ifndef NO_RC2
428
 
                struct {
429
 
                        int key_bits;   /* effective key bits */
430
 
                        RC2_KEY ks;/* key schedule */
431
 
                } rc2;
432
 
#endif
433
 
#ifndef NO_RC5
434
 
                struct {
435
 
                        int rounds;     /* number of rounds */
436
 
                        RC5_32_KEY ks;/* key schedule */
437
 
                } rc5;
438
 
#endif
439
 
#ifndef NO_BF
440
 
                BF_KEY bf_ks;/* key schedule */
441
 
#endif
442
 
#ifndef NO_CAST
443
 
                CAST_KEY cast_ks;/* key schedule */
444
 
#endif
445
 
                } c;
446
 
        };
447
 
 
448
 
typedef struct evp_Encode_Ctx_st
449
 
        {
450
 
        int num;        /* number saved in a partial encode/decode */
451
 
        int length;     /* The length is either the output line length
452
 
                         * (in input bytes) or the shortest input line
453
 
                         * length that is ok.  Once decoding begins,
454
 
                         * the length is adjusted up each time a longer
455
 
                         * line is decoded */
456
 
        unsigned char enc_data[80];     /* data to encode */
457
 
        int line_num;   /* number read on current line */
458
 
        int expect_nl;
459
 
        } EVP_ENCODE_CTX;
460
 
 
461
 
/* Password based encryption function */
462
 
typedef int (EVP_PBE_KEYGEN)(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
463
 
                ASN1_TYPE *param, EVP_CIPHER *cipher,
464
 
                EVP_MD *md, int en_de);
465
 
 
466
 
#ifndef NO_RSA
467
 
#define EVP_PKEY_assign_RSA(pkey,rsa) EVP_PKEY_assign((pkey),EVP_PKEY_RSA,\
468
 
                                        (char *)(rsa))
469
 
#endif
470
 
 
471
 
#ifndef NO_DSA
472
 
#define EVP_PKEY_assign_DSA(pkey,dsa) EVP_PKEY_assign((pkey),EVP_PKEY_DSA,\
473
 
                                        (char *)(dsa))
474
 
#endif
475
 
 
476
 
#ifndef NO_DH
477
 
#define EVP_PKEY_assign_DH(pkey,dh) EVP_PKEY_assign((pkey),EVP_PKEY_DH,\
478
 
                                        (char *)(dh))
479
 
#endif
480
 
 
481
 
/* Add some extra combinations */
482
 
#define EVP_get_digestbynid(a) EVP_get_digestbyname(OBJ_nid2sn(a))
483
 
#define EVP_get_digestbyobj(a) EVP_get_digestbynid(OBJ_obj2nid(a))
484
 
#define EVP_get_cipherbynid(a) EVP_get_cipherbyname(OBJ_nid2sn(a))
485
 
#define EVP_get_cipherbyobj(a) EVP_get_cipherbynid(OBJ_obj2nid(a))
486
 
 
487
 
#define EVP_MD_type(e)                  ((e)->type)
488
 
#define EVP_MD_pkey_type(e)             ((e)->pkey_type)
489
 
#define EVP_MD_size(e)                  ((e)->md_size)
490
 
#define EVP_MD_block_size(e)            ((e)->block_size)
491
 
 
492
 
#define EVP_MD_CTX_md(e)                ((e)->digest)
493
 
#define EVP_MD_CTX_size(e)              EVP_MD_size((e)->digest)
494
 
#define EVP_MD_CTX_block_size(e)        EVP_MD_block_size((e)->digest)
495
 
#define EVP_MD_CTX_type(e)              EVP_MD_type((e)->digest)
496
 
 
497
 
#define EVP_CIPHER_nid(e)               ((e)->nid)
498
 
#define EVP_CIPHER_block_size(e)        ((e)->block_size)
499
 
#define EVP_CIPHER_key_length(e)        ((e)->key_len)
500
 
#define EVP_CIPHER_iv_length(e)         ((e)->iv_len)
501
 
#define EVP_CIPHER_flags(e)             ((e)->flags)
502
 
#define EVP_CIPHER_mode(e)              ((e)->flags) & EVP_CIPH_MODE)
503
 
 
504
 
#define EVP_CIPHER_CTX_cipher(e)        ((e)->cipher)
505
 
#define EVP_CIPHER_CTX_nid(e)           ((e)->cipher->nid)
506
 
#define EVP_CIPHER_CTX_block_size(e)    ((e)->cipher->block_size)
507
 
#define EVP_CIPHER_CTX_key_length(e)    ((e)->key_len)
508
 
#define EVP_CIPHER_CTX_iv_length(e)     ((e)->cipher->iv_len)
509
 
#define EVP_CIPHER_CTX_get_app_data(e)  ((e)->app_data)
510
 
#define EVP_CIPHER_CTX_set_app_data(e,d) ((e)->app_data=(char *)(d))
511
 
#define EVP_CIPHER_CTX_type(c)         EVP_CIPHER_type(EVP_CIPHER_CTX_cipher(c))
512
 
#define EVP_CIPHER_CTX_flags(e)         ((e)->cipher->flags)
513
 
#define EVP_CIPHER_CTX_mode(e)          ((e)->cipher->flags & EVP_CIPH_MODE)
514
 
 
515
 
#define EVP_ENCODE_LENGTH(l)    (((l+2)/3*4)+(l/48+1)*2+80)
516
 
#define EVP_DECODE_LENGTH(l)    ((l+3)/4*3+80)
517
 
 
518
 
#define EVP_SignInit(a,b)               EVP_DigestInit(a,b)
519
 
#define EVP_SignUpdate(a,b,c)           EVP_DigestUpdate(a,b,c)
520
 
#define EVP_VerifyInit(a,b)             EVP_DigestInit(a,b)
521
 
#define EVP_VerifyUpdate(a,b,c)         EVP_DigestUpdate(a,b,c)
522
 
#define EVP_OpenUpdate(a,b,c,d,e)       EVP_DecryptUpdate(a,b,c,d,e)
523
 
#define EVP_SealUpdate(a,b,c,d,e)       EVP_EncryptUpdate(a,b,c,d,e)    
524
 
 
525
 
#ifdef CONST_STRICT
526
 
void BIO_set_md(BIO *,const EVP_MD *md);
527
 
#else
528
 
# define BIO_set_md(b,md)               BIO_ctrl(b,BIO_C_SET_MD,0,(char *)md)
529
 
#endif
530
 
#define BIO_get_md(b,mdp)               BIO_ctrl(b,BIO_C_GET_MD,0,(char *)mdp)
531
 
#define BIO_get_md_ctx(b,mdcp)     BIO_ctrl(b,BIO_C_GET_MD_CTX,0,(char *)mdcp)
532
 
#define BIO_get_cipher_status(b)        BIO_ctrl(b,BIO_C_GET_CIPHER_STATUS,0,NULL)
533
 
#define BIO_get_cipher_ctx(b,c_pp)      BIO_ctrl(b,BIO_C_GET_CIPHER_CTX,0,(char *)c_pp)
534
 
 
535
 
#define EVP_Cipher(c,o,i,l)     (c)->cipher->do_cipher((c),(o),(i),(l))
536
 
 
537
 
#define EVP_add_cipher_alias(n,alias) \
538
 
        OBJ_NAME_add((alias),OBJ_NAME_TYPE_CIPHER_METH|OBJ_NAME_ALIAS,(n))
539
 
#define EVP_add_digest_alias(n,alias) \
540
 
        OBJ_NAME_add((alias),OBJ_NAME_TYPE_MD_METH|OBJ_NAME_ALIAS,(n))
541
 
#define EVP_delete_cipher_alias(alias) \
542
 
        OBJ_NAME_remove(alias,OBJ_NAME_TYPE_CIPHER_METH|OBJ_NAME_ALIAS);
543
 
#define EVP_delete_digest_alias(alias) \
544
 
        OBJ_NAME_remove(alias,OBJ_NAME_TYPE_MD_METH|OBJ_NAME_ALIAS);
545
 
 
546
 
 
547
 
int     EVP_MD_CTX_copy(EVP_MD_CTX *out,EVP_MD_CTX *in);  
548
 
void    EVP_DigestInit(EVP_MD_CTX *ctx, const EVP_MD *type);
549
 
void    EVP_DigestUpdate(EVP_MD_CTX *ctx,const void *d,
550
 
                         unsigned int cnt);
551
 
void    EVP_DigestFinal(EVP_MD_CTX *ctx,unsigned char *md,unsigned int *s);
552
 
 
553
 
int     EVP_read_pw_string(char *buf,int length,const char *prompt,int verify);
554
 
void    EVP_set_pw_prompt(char *prompt);
555
 
char *  EVP_get_pw_prompt(void);
556
 
 
557
 
int     EVP_BytesToKey(const EVP_CIPHER *type, EVP_MD *md,
558
 
                const unsigned char *salt, const unsigned char *data, int datal,
559
 
                int count, unsigned char *key, unsigned char *iv);
560
 
 
561
 
int     EVP_EncryptInit(EVP_CIPHER_CTX *ctx,const EVP_CIPHER *type,
562
 
                unsigned char *key, unsigned char *iv);
563
 
int     EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out,
564
 
                int *outl, unsigned char *in, int inl);
565
 
int     EVP_EncryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl);
566
 
 
567
 
int     EVP_DecryptInit(EVP_CIPHER_CTX *ctx,const EVP_CIPHER *type,
568
 
                unsigned char *key, unsigned char *iv);
569
 
int     EVP_DecryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out,
570
 
                int *outl, unsigned char *in, int inl);
571
 
int     EVP_DecryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *outm, int *outl);
572
 
 
573
 
int     EVP_CipherInit(EVP_CIPHER_CTX *ctx,const EVP_CIPHER *type,
574
 
                       unsigned char *key,unsigned char *iv,int enc);
575
 
int     EVP_CipherUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out,
576
 
                int *outl, unsigned char *in, int inl);
577
 
int     EVP_CipherFinal(EVP_CIPHER_CTX *ctx, unsigned char *outm, int *outl);
578
 
 
579
 
int     EVP_SignFinal(EVP_MD_CTX *ctx,unsigned char *md,unsigned int *s,
580
 
                EVP_PKEY *pkey);
581
 
 
582
 
int     EVP_VerifyFinal(EVP_MD_CTX *ctx,unsigned char *sigbuf,
583
 
                unsigned int siglen,EVP_PKEY *pkey);
584
 
 
585
 
int     EVP_OpenInit(EVP_CIPHER_CTX *ctx,EVP_CIPHER *type,unsigned char *ek,
586
 
                int ekl,unsigned char *iv,EVP_PKEY *priv);
587
 
int     EVP_OpenFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl);
588
 
 
589
 
int     EVP_SealInit(EVP_CIPHER_CTX *ctx, EVP_CIPHER *type, unsigned char **ek,
590
 
                int *ekl, unsigned char *iv,EVP_PKEY **pubk, int npubk);
591
 
void    EVP_SealFinal(EVP_CIPHER_CTX *ctx,unsigned char *out,int *outl);
592
 
 
593
 
void    EVP_EncodeInit(EVP_ENCODE_CTX *ctx);
594
 
void    EVP_EncodeUpdate(EVP_ENCODE_CTX *ctx,unsigned char *out,
595
 
                int *outl,unsigned char *in,int inl);
596
 
void    EVP_EncodeFinal(EVP_ENCODE_CTX *ctx,unsigned char *out,int *outl);
597
 
int     EVP_EncodeBlock(unsigned char *t, const unsigned char *f, int n);
598
 
 
599
 
void    EVP_DecodeInit(EVP_ENCODE_CTX *ctx);
600
 
int     EVP_DecodeUpdate(EVP_ENCODE_CTX *ctx,unsigned char *out,int *outl,
601
 
                unsigned char *in, int inl);
602
 
int     EVP_DecodeFinal(EVP_ENCODE_CTX *ctx, unsigned
603
 
                char *out, int *outl);
604
 
int     EVP_DecodeBlock(unsigned char *t, const unsigned char *f, int n);
605
 
 
606
 
void    ERR_load_EVP_strings(void );
607
 
 
608
 
void EVP_CIPHER_CTX_init(EVP_CIPHER_CTX *a);
609
 
int EVP_CIPHER_CTX_cleanup(EVP_CIPHER_CTX *a);
610
 
int EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *x, int keylen);
611
 
int EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr);
612
 
 
613
 
#ifndef NO_BIO
614
 
BIO_METHOD *BIO_f_md(void);
615
 
BIO_METHOD *BIO_f_base64(void);
616
 
BIO_METHOD *BIO_f_cipher(void);
617
 
BIO_METHOD *BIO_f_reliable(void);
618
 
void BIO_set_cipher(BIO *b,const EVP_CIPHER *c,unsigned char *k,
619
 
        unsigned char *i, int enc);
620
 
#endif
621
 
 
622
 
EVP_MD *EVP_md_null(void);
623
 
#ifndef NO_MD2
624
 
EVP_MD *EVP_md2(void);
625
 
#endif
626
 
#ifndef NO_MD4
627
 
EVP_MD *EVP_md4(void);
628
 
#endif
629
 
#ifndef NO_MD5
630
 
EVP_MD *EVP_md5(void);
631
 
#endif
632
 
#ifndef NO_SHA
633
 
EVP_MD *EVP_sha(void);
634
 
EVP_MD *EVP_sha1(void);
635
 
EVP_MD *EVP_dss(void);
636
 
EVP_MD *EVP_dss1(void);
637
 
#endif
638
 
#ifndef NO_MDC2
639
 
EVP_MD *EVP_mdc2(void);
640
 
#endif
641
 
#ifndef NO_RIPEMD
642
 
EVP_MD *EVP_ripemd160(void);
643
 
#endif
644
 
EVP_CIPHER *EVP_enc_null(void);         /* does nothing :-) */
645
 
#ifndef NO_DES
646
 
EVP_CIPHER *EVP_des_ecb(void);
647
 
EVP_CIPHER *EVP_des_ede(void);
648
 
EVP_CIPHER *EVP_des_ede3(void);
649
 
EVP_CIPHER *EVP_des_cfb(void);
650
 
EVP_CIPHER *EVP_des_ede_cfb(void);
651
 
EVP_CIPHER *EVP_des_ede3_cfb(void);
652
 
EVP_CIPHER *EVP_des_ofb(void);
653
 
EVP_CIPHER *EVP_des_ede_ofb(void);
654
 
EVP_CIPHER *EVP_des_ede3_ofb(void);
655
 
EVP_CIPHER *EVP_des_cbc(void);
656
 
EVP_CIPHER *EVP_des_ede_cbc(void);
657
 
EVP_CIPHER *EVP_des_ede3_cbc(void);
658
 
EVP_CIPHER *EVP_desx_cbc(void);
659
 
#endif
660
 
#ifndef NO_RC4
661
 
EVP_CIPHER *EVP_rc4(void);
662
 
EVP_CIPHER *EVP_rc4_40(void);
663
 
#endif
664
 
#ifndef NO_IDEA
665
 
EVP_CIPHER *EVP_idea_ecb(void);
666
 
EVP_CIPHER *EVP_idea_cfb(void);
667
 
EVP_CIPHER *EVP_idea_ofb(void);
668
 
EVP_CIPHER *EVP_idea_cbc(void);
669
 
#endif
670
 
#ifndef NO_RC2
671
 
EVP_CIPHER *EVP_rc2_ecb(void);
672
 
EVP_CIPHER *EVP_rc2_cbc(void);
673
 
EVP_CIPHER *EVP_rc2_40_cbc(void);
674
 
EVP_CIPHER *EVP_rc2_64_cbc(void);
675
 
EVP_CIPHER *EVP_rc2_cfb(void);
676
 
EVP_CIPHER *EVP_rc2_ofb(void);
677
 
#endif
678
 
#ifndef NO_BF
679
 
EVP_CIPHER *EVP_bf_ecb(void);
680
 
EVP_CIPHER *EVP_bf_cbc(void);
681
 
EVP_CIPHER *EVP_bf_cfb(void);
682
 
EVP_CIPHER *EVP_bf_ofb(void);
683
 
#endif
684
 
#ifndef NO_CAST
685
 
EVP_CIPHER *EVP_cast5_ecb(void);
686
 
EVP_CIPHER *EVP_cast5_cbc(void);
687
 
EVP_CIPHER *EVP_cast5_cfb(void);
688
 
EVP_CIPHER *EVP_cast5_ofb(void);
689
 
#endif
690
 
#ifndef NO_RC5
691
 
EVP_CIPHER *EVP_rc5_32_12_16_cbc(void);
692
 
EVP_CIPHER *EVP_rc5_32_12_16_ecb(void);
693
 
EVP_CIPHER *EVP_rc5_32_12_16_cfb(void);
694
 
EVP_CIPHER *EVP_rc5_32_12_16_ofb(void);
695
 
#endif
696
 
void OpenSSL_add_all_algorithms(void);
697
 
void OpenSSL_add_all_ciphers(void);
698
 
void OpenSSL_add_all_digests(void);
699
 
#define SSLeay_add_all_algorithms() OpenSSL_add_all_algorithms()
700
 
#define SSLeay_add_all_ciphers() OpenSSL_add_all_ciphers()
701
 
#define SSLeay_add_all_digests() OpenSSL_add_all_digests()
702
 
 
703
 
int EVP_add_cipher(EVP_CIPHER *cipher);
704
 
int EVP_add_digest(EVP_MD *digest);
705
 
 
706
 
const EVP_CIPHER *EVP_get_cipherbyname(const char *name);
707
 
const EVP_MD *EVP_get_digestbyname(const char *name);
708
 
void EVP_cleanup(void);
709
 
 
710
 
int             EVP_PKEY_decrypt(unsigned char *dec_key,unsigned char *enc_key,
711
 
                        int enc_key_len,EVP_PKEY *private_key);
712
 
int             EVP_PKEY_encrypt(unsigned char *enc_key,
713
 
                        unsigned char *key,int key_len,EVP_PKEY *pub_key);
714
 
int             EVP_PKEY_type(int type);
715
 
int             EVP_PKEY_bits(EVP_PKEY *pkey);
716
 
int             EVP_PKEY_size(EVP_PKEY *pkey);
717
 
int             EVP_PKEY_assign(EVP_PKEY *pkey,int type,char *key);
718
 
#ifndef NO_RSA
719
 
int             EVP_PKEY_set1_RSA(EVP_PKEY *pkey,RSA *key);
720
 
RSA *           EVP_PKEY_get1_RSA(EVP_PKEY *pkey);
721
 
#endif
722
 
#ifndef NO_DSA
723
 
int             EVP_PKEY_set1_DSA(EVP_PKEY *pkey,DSA *key);
724
 
DSA *           EVP_PKEY_get1_DSA(EVP_PKEY *pkey);
725
 
#endif
726
 
#ifndef NO_DH
727
 
int             EVP_PKEY_set1_DH(EVP_PKEY *pkey,DH *key);
728
 
DH *            EVP_PKEY_get1_DH(EVP_PKEY *pkey);
729
 
#endif
730
 
EVP_PKEY *      EVP_PKEY_new(void);
731
 
void            EVP_PKEY_free(EVP_PKEY *pkey);
732
 
EVP_PKEY *      d2i_PublicKey(int type,EVP_PKEY **a, unsigned char **pp,
733
 
                        long length);
734
 
int             i2d_PublicKey(EVP_PKEY *a, unsigned char **pp);
735
 
 
736
 
EVP_PKEY *      d2i_PrivateKey(int type,EVP_PKEY **a, unsigned char **pp,
737
 
                        long length);
738
 
EVP_PKEY *      d2i_AutoPrivateKey(EVP_PKEY **a, unsigned char **pp,
739
 
                        long length);
740
 
int             i2d_PrivateKey(EVP_PKEY *a, unsigned char **pp);
741
 
 
742
 
int EVP_PKEY_copy_parameters(EVP_PKEY *to,EVP_PKEY *from);
743
 
int EVP_PKEY_missing_parameters(EVP_PKEY *pkey);
744
 
int EVP_PKEY_save_parameters(EVP_PKEY *pkey,int mode);
745
 
int EVP_PKEY_cmp_parameters(EVP_PKEY *a,EVP_PKEY *b);
746
 
 
747
 
int EVP_CIPHER_type(const EVP_CIPHER *ctx);
748
 
 
749
 
/* calls methods */
750
 
int EVP_CIPHER_param_to_asn1(EVP_CIPHER_CTX *c, ASN1_TYPE *type);
751
 
int EVP_CIPHER_asn1_to_param(EVP_CIPHER_CTX *c, ASN1_TYPE *type);
752
 
 
753
 
/* These are used by EVP_CIPHER methods */
754
 
int EVP_CIPHER_set_asn1_iv(EVP_CIPHER_CTX *c,ASN1_TYPE *type);
755
 
int EVP_CIPHER_get_asn1_iv(EVP_CIPHER_CTX *c,ASN1_TYPE *type);
756
 
 
757
 
/* PKCS5 password based encryption */
758
 
int PKCS5_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
759
 
                         ASN1_TYPE *param, EVP_CIPHER *cipher, EVP_MD *md,
760
 
                         int en_de);
761
 
int PKCS5_PBKDF2_HMAC_SHA1(const char *pass, int passlen,
762
 
                           unsigned char *salt, int saltlen, int iter,
763
 
                           int keylen, unsigned char *out);
764
 
int PKCS5_v2_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
765
 
                         ASN1_TYPE *param, EVP_CIPHER *cipher, EVP_MD *md,
766
 
                         int en_de);
767
 
 
768
 
void PKCS5_PBE_add(void);
769
 
 
770
 
int EVP_PBE_CipherInit (ASN1_OBJECT *pbe_obj, const char *pass, int passlen,
771
 
             ASN1_TYPE *param, EVP_CIPHER_CTX *ctx, int en_de);
772
 
int EVP_PBE_alg_add(int nid, EVP_CIPHER *cipher, EVP_MD *md,
773
 
                    EVP_PBE_KEYGEN *keygen);
774
 
void EVP_PBE_cleanup(void);
775
 
 
776
 
/* BEGIN ERROR CODES */
777
 
/* The following lines are auto generated by the script mkerr.pl. Any changes
778
 
 * made after this point may be overwritten when the script is next run.
779
 
 */
780
 
 
781
 
/* Error codes for the EVP functions. */
782
 
 
783
 
/* Function codes. */
784
 
#define EVP_F_D2I_PKEY                                   100
785
 
#define EVP_F_EVP_CIPHERINIT                             123
786
 
#define EVP_F_EVP_CIPHER_CTX_CTRL                        124
787
 
#define EVP_F_EVP_CIPHER_CTX_SET_KEY_LENGTH              122
788
 
#define EVP_F_EVP_DECRYPTFINAL                           101
789
 
#define EVP_F_EVP_MD_CTX_COPY                            110
790
 
#define EVP_F_EVP_OPENINIT                               102
791
 
#define EVP_F_EVP_PBE_ALG_ADD                            115
792
 
#define EVP_F_EVP_PBE_CIPHERINIT                         116
793
 
#define EVP_F_EVP_PKCS82PKEY                             111
794
 
#define EVP_F_EVP_PKCS8_SET_BROKEN                       112
795
 
#define EVP_F_EVP_PKEY2PKCS8                             113
796
 
#define EVP_F_EVP_PKEY_COPY_PARAMETERS                   103
797
 
#define EVP_F_EVP_PKEY_DECRYPT                           104
798
 
#define EVP_F_EVP_PKEY_ENCRYPT                           105
799
 
#define EVP_F_EVP_PKEY_GET1_DH                           119
800
 
#define EVP_F_EVP_PKEY_GET1_DSA                          120
801
 
#define EVP_F_EVP_PKEY_GET1_RSA                          121
802
 
#define EVP_F_EVP_PKEY_NEW                               106
803
 
#define EVP_F_EVP_SIGNFINAL                              107
804
 
#define EVP_F_EVP_VERIFYFINAL                            108
805
 
#define EVP_F_PKCS5_PBE_KEYIVGEN                         117
806
 
#define EVP_F_PKCS5_V2_PBE_KEYIVGEN                      118
807
 
#define EVP_F_RC2_MAGIC_TO_METH                          109
808
 
#define EVP_F_RC5_CTRL                                   125
809
 
 
810
 
/* Reason codes. */
811
 
#define EVP_R_BAD_DECRYPT                                100
812
 
#define EVP_R_BN_DECODE_ERROR                            112
813
 
#define EVP_R_BN_PUBKEY_ERROR                            113
814
 
#define EVP_R_CIPHER_PARAMETER_ERROR                     122
815
 
#define EVP_R_CTRL_NOT_IMPLEMENTED                       132
816
 
#define EVP_R_CTRL_OPERATION_NOT_IMPLEMENTED             133
817
 
#define EVP_R_DECODE_ERROR                               114
818
 
#define EVP_R_DIFFERENT_KEY_TYPES                        101
819
 
#define EVP_R_ENCODE_ERROR                               115
820
 
#define EVP_R_EVP_PBE_CIPHERINIT_ERROR                   119
821
 
#define EVP_R_EXPECTING_AN_RSA_KEY                       127
822
 
#define EVP_R_EXPECTING_A_DH_KEY                         128
823
 
#define EVP_R_EXPECTING_A_DSA_KEY                        129
824
 
#define EVP_R_INITIALIZATION_ERROR                       134
825
 
#define EVP_R_INPUT_NOT_INITIALIZED                      111
826
 
#define EVP_R_INVALID_KEY_LENGTH                         130
827
 
#define EVP_R_IV_TOO_LARGE                               102
828
 
#define EVP_R_KEYGEN_FAILURE                             120
829
 
#define EVP_R_MISSING_PARAMETERS                         103
830
 
#define EVP_R_NO_CIPHER_SET                              131
831
 
#define EVP_R_NO_DSA_PARAMETERS                          116
832
 
#define EVP_R_NO_SIGN_FUNCTION_CONFIGURED                104
833
 
#define EVP_R_NO_VERIFY_FUNCTION_CONFIGURED              105
834
 
#define EVP_R_PKCS8_UNKNOWN_BROKEN_TYPE                  117
835
 
#define EVP_R_PUBLIC_KEY_NOT_RSA                         106
836
 
#define EVP_R_UNKNOWN_PBE_ALGORITHM                      121
837
 
#define EVP_R_UNSUPORTED_NUMBER_OF_ROUNDS                135
838
 
#define EVP_R_UNSUPPORTED_CIPHER                         107
839
 
#define EVP_R_UNSUPPORTED_KEYLENGTH                      123
840
 
#define EVP_R_UNSUPPORTED_KEY_DERIVATION_FUNCTION        124
841
 
#define EVP_R_UNSUPPORTED_KEY_SIZE                       108
842
 
#define EVP_R_UNSUPPORTED_PRF                            125
843
 
#define EVP_R_UNSUPPORTED_PRIVATE_KEY_ALGORITHM          118
844
 
#define EVP_R_UNSUPPORTED_SALT_TYPE                      126
845
 
#define EVP_R_WRONG_FINAL_BLOCK_LENGTH                   109
846
 
#define EVP_R_WRONG_PUBLIC_KEY_TYPE                      110
847
 
 
848
 
#ifdef  __cplusplus
849
 
}
850
 
#endif
851
 
#endif
852