Ruby 2.0.0p353(2013-11-22revision43784)

- Main Page
- Modules
- Data Structures
- Files

- File List
- Globals

openssl_missing.c
Go to the documentation of this file.
1 /*
2 * $Id: openssl_missing.c 32230 2011-06-26 01:32:03Z emboss $
3 * 'OpenSSL for Ruby' project
4 * Copyright (C) 2001-2002 Michal Rokos <m.rokos@sh.cvut.cz>
5 * All rights reserved.
6 */
7 /*
8 * This program is licenced under the same licence as Ruby.
9 * (See the file 'LICENCE'.)
10 */
11 #include RUBY_EXTCONF_H
12
13 #if defined(HAVE_OPENSSL_ENGINE_H) && defined(HAVE_ST_ENGINE)
14 # include <openssl/engine.h>
15 #endif
16 #include <openssl/x509_vfy.h>
17
18 #if !defined(OPENSSL_NO_HMAC)
19 #include <string.h> /* memcpy() */
20 #include <openssl/hmac.h>
21
22 #include "openssl_missing.h"
23
24 #if !defined(HAVE_HMAC_CTX_COPY)
25 void
26 HMAC_CTX_copy(HMAC_CTX *out, HMAC_CTX *in)
27 {
28 if (!out || !in) return;
29 memcpy(out, in, sizeof(HMAC_CTX));
30
31 EVP_MD_CTX_copy(&out->md_ctx, &in->md_ctx);
32 EVP_MD_CTX_copy(&out->i_ctx, &in->i_ctx);
33 EVP_MD_CTX_copy(&out->o_ctx, &in->o_ctx);
34 }
35 #endif /* HAVE_HMAC_CTX_COPY */
36 #endif /* NO_HMAC */
37
38 #if !defined(HAVE_X509_STORE_SET_EX_DATA)
39 int X509_STORE_set_ex_data(X509_STORE *str, int idx, void *data)
40 {
41 return CRYPTO_set_ex_data(&str->ex_data, idx, data);
42 }
43 #endif
44
45 #if !defined(HAVE_X509_STORE_GET_EX_DATA)
46 void *X509_STORE_get_ex_data(X509_STORE *str, int idx)
47 {
48 return CRYPTO_get_ex_data(&str->ex_data, idx);
49 }
50 #endif
51
52 #if !defined(HAVE_EVP_MD_CTX_CREATE)
53 EVP_MD_CTX *
54 EVP_MD_CTX_create(void)
55 {
56 EVP_MD_CTX *ctx = OPENSSL_malloc(sizeof(EVP_MD_CTX));
57 if (!ctx) return NULL;
58
59 memset(ctx, 0, sizeof(EVP_MD_CTX));
60
61 return ctx;
62 }
63 #endif
64
65 #if !defined(HAVE_EVP_MD_CTX_CLEANUP)
66 int
67 EVP_MD_CTX_cleanup(EVP_MD_CTX *ctx)
68 {
69 /* FIXME!!! */
70 memset(ctx, 0, sizeof(EVP_MD_CTX));
71
72 return 1;
73 }
74 #endif
75
76 #if !defined(HAVE_EVP_MD_CTX_DESTROY)
77 void
78 EVP_MD_CTX_destroy(EVP_MD_CTX *ctx)
79 {
80 EVP_MD_CTX_cleanup(ctx);
81 OPENSSL_free(ctx);
82 }
83 #endif
84
85 #if !defined(HAVE_EVP_MD_CTX_INIT)
86 void
87 EVP_MD_CTX_init(EVP_MD_CTX *ctx)
88 {
89 memset(ctx, 0, sizeof(EVP_MD_CTX));
90 }
91 #endif
92
93 #if !defined(HAVE_HMAC_CTX_INIT)
94 void
95 HMAC_CTX_init(HMAC_CTX *ctx)
96 {
97 EVP_MD_CTX_init(&ctx->i_ctx);
98 EVP_MD_CTX_init(&ctx->o_ctx);
99 EVP_MD_CTX_init(&ctx->md_ctx);
100 }
101 #endif
102
103 #if !defined(HAVE_HMAC_CTX_CLEANUP)
104 void
105 HMAC_CTX_cleanup(HMAC_CTX *ctx)
106 {
107 EVP_MD_CTX_cleanup(&ctx->i_ctx);
108 EVP_MD_CTX_cleanup(&ctx->o_ctx);
109 EVP_MD_CTX_cleanup(&ctx->md_ctx);
110 memset(ctx, 0, sizeof(HMAC_CTX));
111 }
112 #endif
113
114 #if !defined(HAVE_EVP_CIPHER_CTX_COPY)
115 /*
116 * this function does not exist in OpenSSL yet... or ever?.
117 * a future version may break this function.
118 * tested on 0.9.7d.
119 */
120 int
121 EVP_CIPHER_CTX_copy(EVP_CIPHER_CTX *out, EVP_CIPHER_CTX *in)
122 {
123 memcpy(out, in, sizeof(EVP_CIPHER_CTX));
124
125 #if defined(HAVE_ENGINE_ADD) && defined(HAVE_ST_ENGINE)
126 if (in->engine) ENGINE_add(out->engine);
127 if (in->cipher_data) {
128 out->cipher_data = OPENSSL_malloc(in->cipher->ctx_size);
129 memcpy(out->cipher_data, in->cipher_data, in->cipher->ctx_size);
130 }
131 #endif
132
133 return 1;
134 }
135 #endif
136
137 #if !defined(HAVE_X509_CRL_SET_VERSION)
138 int
139 X509_CRL_set_version(X509_CRL *x, long version)
140 {
141 if (x == NULL || x->crl == NULL) return 0;
142 if (x->crl->version == NULL) {
143 x->crl->version = M_ASN1_INTEGER_new();
144 if (x->crl->version == NULL) return 0;
145 }
146 return ASN1_INTEGER_set(x->crl->version, version);
147 }
148 #endif
149
150 #if !defined(HAVE_X509_CRL_SET_ISSUER_NAME)
151 int
152 X509_CRL_set_issuer_name(X509_CRL *x, X509_NAME *name)
153 {
154 if (x == NULL || x->crl == NULL) return 0;
155 return X509_NAME_set(&x->crl->issuer, name);
156 }
157 #endif
158
159 #if !defined(HAVE_X509_CRL_SORT)
160 int
161 X509_CRL_sort(X509_CRL *c)
162 {
163 int i;
164 X509_REVOKED *r;
165 /* sort the data so it will be written in serial
166 * number order */
167 sk_X509_REVOKED_sort(c->crl->revoked);
168 for (i=0; i<sk_X509_REVOKED_num(c->crl->revoked); i++) {
169 r=sk_X509_REVOKED_value(c->crl->revoked, i);
170 r->sequence=i;
171 }
172 return 1;
173 }
174 #endif
175
176 #if !defined(HAVE_X509_CRL_ADD0_REVOKED)
177 static int
178 OSSL_X509_REVOKED_cmp(const X509_REVOKED * const *a, const X509_REVOKED * const *b)
179 {
180 return(ASN1_STRING_cmp(
181 (ASN1_STRING *)(*a)->serialNumber,
182 (ASN1_STRING *)(*b)->serialNumber));
183 }
184
185 int
186 X509_CRL_add0_revoked(X509_CRL *crl, X509_REVOKED *rev)
187 {
188 X509_CRL_INFO *inf;
189
190 inf = crl->crl;
191 if (!inf->revoked)
192 inf->revoked = sk_X509_REVOKED_new(OSSL_X509_REVOKED_cmp);
193 if (!inf->revoked || !sk_X509_REVOKED_push(inf->revoked, rev))
194 return 0;
195 return 1;
196 }
197 #endif
198
199 #if !defined(HAVE_BN_MOD_SQR)
200 int
201 BN_mod_sqr(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx)
202 {
203 if (!BN_sqr(r, (BIGNUM*)a, ctx)) return 0;
204 return BN_mod(r, r, m, ctx);
205 }
206 #endif
207
208 #if !defined(HAVE_BN_MOD_ADD) || !defined(HAVE_BN_MOD_SUB)
209 int BN_nnmod(BIGNUM *r, const BIGNUM *m, const BIGNUM *d, BN_CTX *ctx)
210 {
211 if (!BN_mod(r,m,d,ctx)) return 0;
212 if (!r->neg) return 1;
213 return (d->neg ? BN_sub : BN_add)(r, r, d);
214 }
215 #endif
216
217 #if !defined(HAVE_BN_MOD_ADD)
218 int
219 BN_mod_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m, BN_CTX *ctx)
220 {
221 if (!BN_add(r, a, b)) return 0;
222 return BN_nnmod(r, r, m, ctx);
223 }
224 #endif
225
226 #if !defined(HAVE_BN_MOD_SUB)
227 int
228 BN_mod_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m, BN_CTX *ctx)
229 {
230 if (!BN_sub(r, a, b)) return 0;
231 return BN_nnmod(r, r, m, ctx);
232 }
233 #endif
234
235 #if !defined(HAVE_BN_RAND_RANGE) || !defined(HAVE_BN_PSEUDO_RAND_RANGE)
236 static int
237 bn_rand_range(int pseudo, BIGNUM *r, BIGNUM *range)
238 {
239 int (*bn_rand)(BIGNUM *, int, int, int) = pseudo ? BN_pseudo_rand : BN_rand;
240 int n;
241
242 if (range->neg || BN_is_zero(range)) return 0;
243
244 n = BN_num_bits(range);
245
246 if (n == 1) {
247 if (!BN_zero(r)) return 0;
248 } else if (!BN_is_bit_set(range, n - 2) && !BN_is_bit_set(range, n - 3)) {
249 do {
250 if (!bn_rand(r, n + 1, -1, 0)) return 0;
251 if (BN_cmp(r ,range) >= 0) {
252 if (!BN_sub(r, r, range)) return 0;
253 if (BN_cmp(r, range) >= 0)
254 if (!BN_sub(r, r, range)) return 0;
255 }
256 } while (BN_cmp(r, range) >= 0);
257 } else {
258 do {
259 if (!bn_rand(r, n, -1, 0)) return 0;
260 } while (BN_cmp(r, range) >= 0);
261 }
262
263 return 1;
264 }
265 #endif
266
267 #if !defined(HAVE_BN_RAND_RANGE)
268 int
269 BN_rand_range(BIGNUM *r, BIGNUM *range)
270 {
271 return bn_rand_range(0, r, range);
272 }
273 #endif
274
275 #if !defined(HAVE_BN_PSEUDO_RAND_RANGE)
276 int
277 BN_pseudo_rand_range(BIGNUM *r, BIGNUM *range)
278 {
279 return bn_rand_range(1, r, range);
280 }
281 #endif
282
283 #if !defined(HAVE_CONF_GET1_DEFAULT_CONFIG_FILE)
284 #define OPENSSL_CONF "openssl.cnf"
285 char *
286 CONF_get1_default_config_file(void)
287 {
288 char *file;
289 int len;
290
291 file = getenv("OPENSSL_CONF");
292 if (file) return BUF_strdup(file);
293 len = strlen(X509_get_default_cert_area());
294 #ifndef OPENSSL_SYS_VMS
295 len++;
296 #endif
297 len += strlen(OPENSSL_CONF);
298 file = OPENSSL_malloc(len + 1);
299 if (!file) return NULL;
300 strcpy(file,X509_get_default_cert_area());
301 #ifndef OPENSSL_SYS_VMS
302 strcat(file,"/");
303 #endif
304 strcat(file,OPENSSL_CONF);
305
306 return file;
307 }
308 #endif
309
310 #if !defined(HAVE_PEM_DEF_CALLBACK)
311 #define OSSL_PASS_MIN_LENGTH 4
312 int
313 PEM_def_callback(char *buf, int num, int w, void *key)
314 {
315 int i,j;
316 const char *prompt;
317
318 if (key) {
319 i = strlen(key);
320 i = (i > num) ? num : i;
321 memcpy(buf, key, i);
322 return i;
323 }
324
325 prompt = EVP_get_pw_prompt();
326 if (prompt == NULL) prompt = "Enter PEM pass phrase:";
327 for (;;) {
328 i = EVP_read_pw_string(buf, num, prompt, w);
329 if (i != 0) {
330 memset(buf, 0, (unsigned int)num);
331 return(-1);
332 }
333 j = strlen(buf);
334 if (j < OSSL_PASS_MIN_LENGTH) {
335 fprintf(stderr,
336 "phrase is too short, needs to be at least %d chars\n",
337 OSSL_PASS_MIN_LENGTH);
338 }
339 else break;
340 }
341 return j;
342 }
343 #endif
344
345 #if !defined(HAVE_ASN1_PUT_EOC)
346 int
347 ASN1_put_eoc(unsigned char **pp)
348 {
349 unsigned char *p = *pp;
350 *p++ = 0;
351 *p++ = 0;
352 *pp = p;
353 return 2;
354 }
355 #endif
356
data
VALUE data
Definition: tcltklib.c:3368
inf
struct invoke_info inf
Definition: tcltklib.c:8574
n
ssize_t n
Definition: bigdecimal.c:5655
BN_rand_range
int BN_rand_range(BIGNUM *r, BIGNUM *range)
Definition: openssl_missing.c:269
int
VP_EXPORT int
Definition: bigdecimal.c:5050
strlen
size_t strlen(const char *)
p
Win32OLEIDispatch * p
Definition: win32ole.c:786
OSSL_X509_REVOKED_cmp
static int OSSL_X509_REVOKED_cmp(const X509_REVOKED *const *a, const X509_REVOKED *const *b)
Definition: openssl_missing.c:178
out
C_block * out
Definition: crypt.c:308
i
ssize_t i
Definition: bigdecimal.c:5655
EVP_MD_CTX_destroy
void EVP_MD_CTX_destroy(EVP_MD_CTX *ctx)
Definition: openssl_missing.c:78
a
Real * a
Definition: bigdecimal.c:1182
in
int const char * in
Definition: crypt.c:639
HMAC_CTX_copy
void HMAC_CTX_copy(HMAC_CTX *out, HMAC_CTX *in)
Definition: openssl_missing.c:26
openssl_missing.h
X509_STORE_get_ex_data
void * X509_STORE_get_ex_data(X509_STORE *str, int idx)
Definition: openssl_missing.c:46
BN_mod_add
int BN_mod_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m, BN_CTX *ctx)
Definition: openssl_missing.c:219
r
r
Definition: bigdecimal.c:1196
BN_mod_sqr
int BN_mod_sqr(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx)
Definition: openssl_missing.c:201
d
d
Definition: strlcat.c:58
strcpy
strcpy(cmd2, cmd)
X509_CRL_sort
int X509_CRL_sort(X509_CRL *c)
Definition: openssl_missing.c:161
memset
memset(y->frac+ix+1, 0,(y->Prec-(ix+1))*sizeof(BDIGIT))
m
BDIGIT m
Definition: bigdecimal.c:5085
str
static VALUE char * str
Definition: tcltklib.c:3547
OPENSSL_CONF
#define OPENSSL_CONF
Definition: openssl_missing.c:284
idx
int idx
Definition: tcltklib.c:9716
range
#define range(low, item, hi)
Definition: date_strftime.c:21
buf
unsigned char buf[MIME_BUF_SIZE]
Definition: nkf.c:4308
X509_CRL_set_issuer_name
int X509_CRL_set_issuer_name(X509_CRL *x, X509_NAME *name)
Definition: openssl_missing.c:152
key
static int VALUE key
Definition: tkutil.c:265
PEM_def_callback
int PEM_def_callback(char *buf, int num, int w, void *key)
Definition: openssl_missing.c:313
memcpy
memcpy(buf+1, str, len)
EVP_MD_CTX_create
EVP_MD_CTX * EVP_MD_CTX_create(void)
Definition: openssl_missing.c:54
BN_pseudo_rand_range
int BN_pseudo_rand_range(BIGNUM *r, BIGNUM *range)
Definition: openssl_missing.c:277
X509_STORE_set_ex_data
int X509_STORE_set_ex_data(X509_STORE *str, int idx, void *data)
Definition: openssl_missing.c:39
OSSL_PASS_MIN_LENGTH
#define OSSL_PASS_MIN_LENGTH
Definition: openssl_missing.c:311
getenv
char * getenv()
EVP_MD_CTX_init
void EVP_MD_CTX_init(EVP_MD_CTX *ctx)
Definition: openssl_missing.c:87
bn_rand_range
static int bn_rand_range(int pseudo, BIGNUM *r, BIGNUM *range)
Definition: openssl_missing.c:237
b
Real * b
Definition: bigdecimal.c:1182
c
VpDivd * c
Definition: bigdecimal.c:1205
HMAC_CTX_init
void HMAC_CTX_init(HMAC_CTX *ctx)
Definition: openssl_missing.c:95
X509_CRL_add0_revoked
int X509_CRL_add0_revoked(X509_CRL *crl, X509_REVOKED *rev)
Definition: openssl_missing.c:186
ASN1_put_eoc
int ASN1_put_eoc(unsigned char **pp)
Definition: openssl_missing.c:347
EVP_MD_CTX_cleanup
int EVP_MD_CTX_cleanup(EVP_MD_CTX *ctx)
Definition: openssl_missing.c:67
BN_mod_sub
int BN_mod_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m, BN_CTX *ctx)
Definition: openssl_missing.c:228
CONF_get1_default_config_file
char * CONF_get1_default_config_file(void)
Definition: openssl_missing.c:286
version
static void version(void)
Definition: nkf.c:898
EVP_CIPHER_CTX_copy
int EVP_CIPHER_CTX_copy(EVP_CIPHER_CTX *out, EVP_CIPHER_CTX *in)
Definition: openssl_missing.c:121
X509_CRL_set_version
int X509_CRL_set_version(X509_CRL *x, long version)
Definition: openssl_missing.c:139
NULL
#define NULL
Definition: _sdbm.c:103
name
const char * name
Definition: nkf.c:208
HMAC_CTX_cleanup
void HMAC_CTX_cleanup(HMAC_CTX *ctx)
Definition: openssl_missing.c:105
BN_nnmod
int BN_nnmod(BIGNUM *r, const BIGNUM *m, const BIGNUM *d, BN_CTX *ctx)
Definition: openssl_missing.c:209
len
size_t len
Definition: tcltklib.c:3568