]>
Commit | Line | Data |
---|---|---|
056cc163 | 1 | /* crypto/engine/hw_cluster_labs.c */ |
ae5c8664 MC |
2 | /* |
3 | * Written by Jan Tschirschwitz (jan.tschirschwitz@cluster-labs.com for the | |
4 | * OpenSSL project 2000. | |
056cc163 RL |
5 | */ |
6 | /* ==================================================================== | |
7 | * Copyright (c) 1999 The OpenSSL Project. All rights reserved. | |
8 | * | |
9 | * Redistribution and use in source and binary forms, with or without | |
10 | * modification, are permitted provided that the following conditions | |
11 | * are met: | |
12 | * | |
13 | * 1. Redistributions of source code must retain the above copyright | |
ae5c8664 | 14 | * notice, this list of conditions and the following disclaimer. |
056cc163 RL |
15 | * |
16 | * 2. Redistributions in binary form must reproduce the above copyright | |
17 | * notice, this list of conditions and the following disclaimer in | |
18 | * the documentation and/or other materials provided with the | |
19 | * distribution. | |
20 | * | |
21 | * 3. All advertising materials mentioning features or use of this | |
22 | * software must display the following acknowledgment: | |
23 | * "This product includes software developed by the OpenSSL Project | |
24 | * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" | |
25 | * | |
26 | * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to | |
27 | * endorse or promote products derived from this software without | |
28 | * prior written permission. For written permission, please contact | |
29 | * licensing@OpenSSL.org. | |
30 | * | |
31 | * 5. Products derived from this software may not be called "OpenSSL" | |
32 | * nor may "OpenSSL" appear in their names without prior written | |
33 | * permission of the OpenSSL Project. | |
34 | * | |
35 | * 6. Redistributions of any form whatsoever must retain the following | |
36 | * acknowledgment: | |
37 | * "This product includes software developed by the OpenSSL Project | |
38 | * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" | |
39 | * | |
40 | * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY | |
41 | * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
42 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | |
43 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR | |
44 | * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
45 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | |
46 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | |
47 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | |
49 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | |
50 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED | |
51 | * OF THE POSSIBILITY OF SUCH DAMAGE. | |
52 | * ==================================================================== | |
53 | * | |
54 | * This product includes cryptographic software written by Eric Young | |
55 | * (eay@cryptsoft.com). This product includes software written by Tim | |
56 | * Hudson (tjh@cryptsoft.com). | |
57 | * | |
58 | */ | |
59 | ||
ae5c8664 | 60 | #define MSC_VER /* only used cryptic.h */ |
056cc163 RL |
61 | |
62 | #include <stdio.h> | |
63 | #include <openssl/crypto.h> | |
64 | #include <openssl/dso.h> | |
65 | #include <openssl/des.h> | |
66 | #include <openssl/engine.h> | |
67 | ||
68 | #ifndef NO_HW | |
ae5c8664 | 69 | # ifndef NO_HW_CLUSTER_LABS |
056cc163 | 70 | |
ae5c8664 MC |
71 | # ifdef FLAT_INC |
72 | # include "cluster_labs.h" | |
73 | # else | |
74 | # include "vendor_defns/cluster_labs.h" | |
75 | # endif | |
056cc163 | 76 | |
ae5c8664 MC |
77 | # define CL_LIB_NAME "cluster_labs engine" |
78 | # include "hw_cluster_labs_err.c" | |
056cc163 RL |
79 | |
80 | static int cluster_labs_destroy(ENGINE *e); | |
81 | static int cluster_labs_init(ENGINE *e); | |
82 | static int cluster_labs_finish(ENGINE *e); | |
ae5c8664 MC |
83 | static int cluster_labs_ctrl(ENGINE *e, int cmd, long i, void *p, |
84 | void (*f) ()); | |
056cc163 RL |
85 | |
86 | /* BIGNUM stuff */ | |
87 | /* This function is aliased to mod_exp (with the mont stuff dropped). */ | |
ae5c8664 MC |
88 | static int cluster_labs_mod_exp_mont(BIGNUM *r, const BIGNUM *a, |
89 | const BIGNUM *p, const BIGNUM *m, | |
90 | BN_CTX *ctx, BN_MONT_CTX *m_ctx); | |
91 | ||
056cc163 | 92 | /* RSA stuff */ |
ae5c8664 | 93 | # ifndef OPENSSL_NO_RSA |
056cc163 | 94 | static int cluster_labs_rsa_pub_enc(int flen, const unsigned char *from, |
ae5c8664 | 95 | unsigned char *to, RSA *rsa, int padding); |
056cc163 | 96 | static int cluster_labs_rsa_pub_dec(int flen, const unsigned char *from, |
ae5c8664 MC |
97 | unsigned char *to, RSA *rsa, int padding); |
98 | static int cluster_labs_rsa_priv_enc(int flen, const unsigned char *from, | |
99 | unsigned char *to, RSA *rsa, | |
100 | int padding); | |
101 | static int cluster_labs_rsa_priv_dec(int flen, const unsigned char *from, | |
102 | unsigned char *to, RSA *rsa, | |
103 | int padding); | |
056cc163 | 104 | static int cluster_labs_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa); |
ae5c8664 | 105 | # endif |
056cc163 RL |
106 | |
107 | /* DSA stuff */ | |
ae5c8664 MC |
108 | # ifndef OPENSSL_NO_DSA |
109 | static DSA_SIG *cluster_labs_dsa_sign(const unsigned char *dgst, int dlen, | |
110 | DSA *dsa); | |
056cc163 | 111 | static int cluster_labs_dsa_verify(const unsigned char *dgst, int dgst_len, |
ae5c8664 | 112 | DSA_SIG *sig, DSA *dsa); |
056cc163 | 113 | static int cluster_labs_dsa_mod_exp(DSA *dsa, BIGNUM *rr, BIGNUM *a1, |
ae5c8664 MC |
114 | BIGNUM *p1, BIGNUM *a2, BIGNUM *p2, |
115 | BIGNUM *m, BN_CTX *ctx, | |
116 | BN_MONT_CTX *in_mont); | |
056cc163 | 117 | static int cluster_labs_mod_exp_dsa(DSA *dsa, BIGNUM *r, BIGNUM *a, |
ae5c8664 MC |
118 | const BIGNUM *p, const BIGNUM *m, |
119 | BN_CTX *ctx, BN_MONT_CTX *m_ctx); | |
120 | # endif | |
121 | ||
056cc163 | 122 | /* DH stuff */ |
ae5c8664 | 123 | # ifndef OPENSSL_NO_DH |
056cc163 | 124 | /* This function is alised to mod_exp (with the DH and mont dropped). */ |
ae5c8664 MC |
125 | static int cluster_labs_mod_exp_dh(const DH *dh, BIGNUM *r, const BIGNUM *a, |
126 | const BIGNUM *p, const BIGNUM *m, | |
127 | BN_CTX *ctx, BN_MONT_CTX *m_ctx); | |
128 | # endif | |
129 | ||
130 | /* RANDOM stuff */ | |
056cc163 RL |
131 | static int cluster_labs_rand_bytes(unsigned char *buf, int num); |
132 | ||
133 | /* The definitions for control commands specific to this engine */ | |
ae5c8664 MC |
134 | # define CLUSTER_LABS_CMD_SO_PATH ENGINE_CMD_BASE |
135 | static const ENGINE_CMD_DEFN cluster_labs_cmd_defns[] = { | |
136 | {CLUSTER_LABS_CMD_SO_PATH, | |
137 | "SO_PATH", | |
138 | "Specifies the path to the 'cluster labs' shared library", | |
139 | ENGINE_CMD_FLAG_STRING}, | |
140 | {0, NULL, NULL, 0} | |
141 | }; | |
056cc163 RL |
142 | |
143 | /* Our internal RSA_METHOD that we provide pointers to */ | |
ae5c8664 MC |
144 | # ifndef OPENSSL_NO_RSA |
145 | static RSA_METHOD cluster_labs_rsa = { | |
146 | "Cluster Labs RSA method", | |
147 | cluster_labs_rsa_pub_enc, /* rsa_pub_enc */ | |
148 | cluster_labs_rsa_pub_dec, /* rsa_pub_dec */ | |
149 | cluster_labs_rsa_priv_enc, /* rsa_priv_enc */ | |
150 | cluster_labs_rsa_priv_dec, /* rsa_priv_dec */ | |
151 | cluster_labs_rsa_mod_exp, /* rsa_mod_exp */ | |
152 | cluster_labs_mod_exp_mont, /* bn_mod_exp */ | |
153 | NULL, /* init */ | |
154 | NULL, /* finish */ | |
155 | 0, /* flags */ | |
156 | NULL, /* apps_data */ | |
157 | NULL, /* rsa_sign */ | |
158 | NULL /* rsa_verify */ | |
159 | }; | |
160 | # endif | |
056cc163 RL |
161 | |
162 | /* Our internal DSA_METHOD that we provide pointers to */ | |
ae5c8664 MC |
163 | # ifndef OPENSSL_NO_DSA |
164 | static DSA_METHOD cluster_labs_dsa = { | |
165 | "Cluster Labs DSA method", | |
166 | cluster_labs_dsa_sign, /* dsa_do_sign */ | |
167 | NULL, /* dsa_sign_setup */ | |
168 | cluster_labs_dsa_verify, /* dsa_do_verify */ | |
169 | cluster_labs_dsa_mod_exp, /* dsa_mod_exp */ | |
170 | cluster_labs_mod_exp_dsa, /* bn_mod_exp */ | |
171 | NULL, /* init */ | |
172 | NULL, /* finish */ | |
173 | 0, /* flags */ | |
174 | NULL /* app_data */ | |
175 | }; | |
176 | # endif | |
056cc163 RL |
177 | |
178 | /* Our internal DH_METHOD that we provide pointers to */ | |
ae5c8664 MC |
179 | # ifndef OPENSSL_NO_DH |
180 | static DH_METHOD cluster_labs_dh = { | |
181 | "Cluster Labs DH method", | |
182 | NULL, /* generate key */ | |
183 | NULL, /* compute key */ | |
184 | cluster_labs_mod_exp_dh, /* bn_mod_exp */ | |
185 | NULL, /* init */ | |
186 | NULL, /* finish */ | |
187 | 0, /* flags */ | |
188 | NULL /* app_data */ | |
189 | }; | |
190 | # endif | |
191 | ||
192 | static RAND_METHOD cluster_labs_rand = { | |
193 | /* "Cluster Labs RAND method", */ | |
194 | NULL, /* seed */ | |
195 | cluster_labs_rand_bytes, /* bytes */ | |
196 | NULL, /* cleanup */ | |
197 | NULL, /* add */ | |
198 | cluster_labs_rand_bytes, /* pseudorand */ | |
199 | NULL, /* status */ | |
200 | }; | |
056cc163 RL |
201 | |
202 | static const char *engine_cluster_labs_id = "cluster_labs"; | |
ae5c8664 MC |
203 | static const char *engine_cluster_labs_name = |
204 | "Cluster Labs hardware engine support"; | |
056cc163 RL |
205 | |
206 | /* engine implementation */ | |
ae5c8664 | 207 | /* ---------------------*/ |
056cc163 | 208 | static int bind_helper(ENGINE *e) |
ae5c8664 MC |
209 | { |
210 | ||
211 | if (!ENGINE_set_id(e, engine_cluster_labs_id) || | |
212 | !ENGINE_set_name(e, engine_cluster_labs_name) || | |
213 | # ifndef OPENSSL_NO_RSA | |
214 | !ENGINE_set_RSA(e, &cluster_labs_rsa) || | |
215 | # endif | |
216 | # ifndef OPENSSL_NO_DSA | |
217 | !ENGINE_set_DSA(e, &cluster_labs_dsa) || | |
218 | # endif | |
219 | # ifndef OPENSSL_NO_DH | |
220 | !ENGINE_set_DH(e, &cluster_labs_dh) || | |
221 | # endif | |
222 | !ENGINE_set_RAND(e, &cluster_labs_rand) || | |
223 | !ENGINE_set_destroy_function(e, cluster_labs_destroy) || | |
224 | !ENGINE_set_init_function(e, cluster_labs_init) || | |
225 | !ENGINE_set_finish_function(e, cluster_labs_finish) || | |
226 | !ENGINE_set_ctrl_function(e, cluster_labs_ctrl) || | |
227 | !ENGINE_set_cmd_defns(e, cluster_labs_cmd_defns)) | |
228 | return 0; | |
229 | /* Ensure the error handling is set up */ | |
230 | ERR_load_CL_strings(); | |
231 | return 1; | |
232 | } | |
233 | ||
234 | # ifndef ENGINE_DYNAMIC_SUPPORT | |
056cc163 | 235 | static ENGINE *engine_cluster_labs(void) |
ae5c8664 MC |
236 | { |
237 | ENGINE *ret = ENGINE_new(); | |
238 | ||
239 | if (!ret) | |
240 | return NULL; | |
241 | if (!bind_helper(ret)) { | |
242 | ENGINE_free(ret); | |
243 | return NULL; | |
244 | } | |
245 | return ret; | |
246 | } | |
247 | ||
248 | # ifdef ENGINE_DYNAMIC_SUPPORT | |
37e27219 | 249 | static |
ae5c8664 | 250 | # endif |
056cc163 | 251 | void ENGINE_load_cluster_labs(void) |
ae5c8664 | 252 | { |
056cc163 | 253 | |
ae5c8664 | 254 | ENGINE *cluster_labs = engine_cluster_labs(); |
056cc163 | 255 | |
ae5c8664 MC |
256 | if (!cluster_labs) |
257 | return; | |
258 | ENGINE_add(cluster_labs); | |
259 | ENGINE_free(cluster_labs); | |
260 | ERR_clear_error(); | |
261 | } | |
262 | # endif /* !ENGINE_DYNAMIC_SUPPORT */ | |
056cc163 | 263 | |
ae5c8664 MC |
264 | static int cluster_labs_destroy(ENGINE *e) |
265 | { | |
056cc163 | 266 | |
ae5c8664 MC |
267 | ERR_unload_CL_strings(); |
268 | return 1; | |
269 | } | |
056cc163 | 270 | |
ae5c8664 MC |
271 | /* |
272 | * This is a process-global DSO handle used for loading and unloading the | |
273 | * Cluster Labs library. NB: This is only set (or unset) during an init() or | |
274 | * finish() call (reference counts permitting) and they're operating with | |
275 | * global locks, so this should be thread-safe implicitly. | |
276 | */ | |
056cc163 RL |
277 | static DSO *cluster_labs_dso = NULL; |
278 | ||
ae5c8664 MC |
279 | /* |
280 | * These are the function pointers that are (un)set when the library has | |
281 | * successfully (un)loaded. | |
282 | */ | |
283 | static cl_engine_init *p_cl_engine_init = NULL; | |
284 | static cl_mod_exp *p_cl_mod_exp = NULL; | |
285 | static cl_mod_exp_crt *p_cl_mod_exp_crt = NULL; | |
286 | static cl_rsa_mod_exp *p_cl_rsa_mod_exp = NULL; | |
287 | static cl_rsa_priv_enc *p_cl_rsa_priv_enc = NULL; | |
288 | static cl_rsa_priv_dec *p_cl_rsa_priv_dec = NULL; | |
289 | static cl_rsa_pub_enc *p_cl_rsa_pub_enc = NULL; | |
290 | static cl_rsa_pub_dec *p_cl_rsa_pub_dec = NULL; | |
291 | static cl_rand_bytes *p_cl_rand_bytes = NULL; | |
292 | static cl_dsa_sign *p_cl_dsa_sign = NULL; | |
293 | static cl_dsa_verify *p_cl_dsa_verify = NULL; | |
056cc163 RL |
294 | |
295 | int cluster_labs_init(ENGINE *e) | |
ae5c8664 MC |
296 | { |
297 | ||
298 | cl_engine_init *p1; | |
299 | cl_mod_exp *p2; | |
300 | cl_mod_exp_crt *p3; | |
301 | cl_rsa_mod_exp *p4; | |
302 | cl_rsa_priv_enc *p5; | |
303 | cl_rsa_priv_dec *p6; | |
304 | cl_rsa_pub_enc *p7; | |
305 | cl_rsa_pub_dec *p8; | |
306 | cl_rand_bytes *p20; | |
307 | cl_dsa_sign *p30; | |
308 | cl_dsa_verify *p31; | |
309 | ||
310 | /* engine already loaded */ | |
311 | if (cluster_labs_dso != NULL) { | |
312 | CLerr(CL_F_CLUSTER_LABS_INIT, CL_R_ALREADY_LOADED); | |
313 | goto err; | |
314 | } | |
315 | /* try to load engine */ | |
316 | cluster_labs_dso = DSO_load(NULL, CLUSTER_LABS_LIB_NAME, NULL, 0); | |
317 | if (cluster_labs_dso == NULL) { | |
318 | CLerr(CL_F_CLUSTER_LABS_INIT, CL_R_DSO_FAILURE); | |
319 | goto err; | |
320 | } | |
321 | /* bind functions */ | |
322 | if (! | |
323 | (p1 = | |
324 | (cl_engine_init *) DSO_bind_func(cluster_labs_dso, CLUSTER_LABS_F1)) | |
325 | || !(p2 = (cl_mod_exp *) DSO_bind_func(cluster_labs_dso, CLUSTER_LABS_F2)) | |
326 | || !(p3 = (cl_mod_exp_crt *) DSO_bind_func(cluster_labs_dso, CLUSTER_LABS_F3)) | |
327 | || !(p4 = (cl_rsa_mod_exp *) DSO_bind_func(cluster_labs_dso, CLUSTER_LABS_F4)) | |
328 | || !(p5 = | |
329 | (cl_rsa_priv_enc *) DSO_bind_func(cluster_labs_dso, CLUSTER_LABS_F5)) | |
330 | || !(p6 = | |
331 | (cl_rsa_priv_dec *) DSO_bind_func(cluster_labs_dso, CLUSTER_LABS_F6)) | |
332 | || !(p7 = (cl_rsa_pub_enc *) DSO_bind_func(cluster_labs_dso, CLUSTER_LABS_F7)) | |
333 | || !(p8 = (cl_rsa_pub_dec *) DSO_bind_func(cluster_labs_dso, CLUSTER_LABS_F8)) | |
334 | || !(p20 = | |
335 | (cl_rand_bytes *) DSO_bind_func(cluster_labs_dso, CLUSTER_LABS_F20)) | |
336 | || !(p30 = (cl_dsa_sign *) DSO_bind_func(cluster_labs_dso, CLUSTER_LABS_F30)) | |
337 | || !(p31 = | |
338 | (cl_dsa_verify *) DSO_bind_func(cluster_labs_dso, CLUSTER_LABS_F31))) { | |
339 | CLerr(CL_F_CLUSTER_LABS_INIT, CL_R_DSO_FAILURE); | |
340 | goto err; | |
341 | } | |
342 | ||
343 | /* copy function pointers */ | |
344 | p_cl_engine_init = p1; | |
345 | p_cl_mod_exp = p2; | |
346 | p_cl_mod_exp_crt = p3; | |
347 | p_cl_rsa_mod_exp = p4; | |
348 | p_cl_rsa_priv_enc = p5; | |
349 | p_cl_rsa_priv_dec = p6; | |
350 | p_cl_rsa_pub_enc = p7; | |
351 | p_cl_rsa_pub_dec = p8; | |
352 | p_cl_rand_bytes = p20; | |
353 | p_cl_dsa_sign = p30; | |
354 | p_cl_dsa_verify = p31; | |
355 | ||
356 | /* cluster labs engine init */ | |
357 | if (p_cl_engine_init() == 0) { | |
358 | CLerr(CL_F_CLUSTER_LABS_INIT, CL_R_INIT_FAILED); | |
359 | goto err; | |
360 | } | |
361 | ||
362 | return (1); | |
363 | ||
364 | err: | |
365 | /* reset all pointers */ | |
366 | if (cluster_labs_dso) | |
367 | DSO_free(cluster_labs_dso); | |
368 | ||
369 | cluster_labs_dso = NULL; | |
370 | p_cl_engine_init = NULL; | |
371 | p_cl_mod_exp = NULL; | |
372 | p_cl_mod_exp_crt = NULL; | |
373 | p_cl_rsa_mod_exp = NULL; | |
374 | p_cl_rsa_priv_enc = NULL; | |
375 | p_cl_rsa_priv_dec = NULL; | |
376 | p_cl_rsa_pub_enc = NULL; | |
377 | p_cl_rsa_pub_dec = NULL; | |
378 | p_cl_rand_bytes = NULL; | |
379 | p_cl_dsa_sign = NULL; | |
380 | p_cl_dsa_verify = NULL; | |
381 | ||
382 | return (0); | |
383 | } | |
056cc163 RL |
384 | |
385 | static int cluster_labs_finish(ENGINE *e) | |
ae5c8664 MC |
386 | { |
387 | ||
388 | if (cluster_labs_dso == NULL) { | |
389 | CLerr(CL_F_CLUSTER_LABS_FINISH, CL_R_NOT_LOADED); | |
390 | return 0; | |
391 | } | |
392 | if (!DSO_free(cluster_labs_dso)) { | |
393 | CLerr(CL_F_CLUSTER_LABS_FINISH, CL_R_DSO_FAILURE); | |
394 | return 0; | |
395 | } | |
396 | ||
397 | cluster_labs_dso = NULL; | |
398 | p_cl_engine_init = NULL; | |
399 | p_cl_mod_exp = NULL; | |
400 | p_cl_rsa_mod_exp = NULL; | |
401 | p_cl_mod_exp_crt = NULL; | |
402 | p_cl_rsa_priv_enc = NULL; | |
403 | p_cl_rsa_priv_dec = NULL; | |
404 | p_cl_rsa_pub_enc = NULL; | |
405 | p_cl_rsa_pub_dec = NULL; | |
406 | p_cl_rand_bytes = NULL; | |
407 | p_cl_dsa_sign = NULL; | |
408 | p_cl_dsa_verify = NULL; | |
409 | ||
410 | return (1); | |
411 | ||
412 | } | |
413 | ||
414 | static int cluster_labs_ctrl(ENGINE *e, int cmd, long i, void *p, | |
415 | void (*f) ()) | |
416 | { | |
417 | int initialised = ((cluster_labs_dso == NULL) ? 0 : 1); | |
418 | ||
419 | switch (cmd) { | |
420 | case CLUSTER_LABS_CMD_SO_PATH: | |
421 | if (p == NULL) { | |
422 | CLerr(CL_F_CLUSTER_LABS_CTRL, ERR_R_PASSED_NULL_PARAMETER); | |
423 | return 0; | |
424 | } | |
425 | if (initialised) { | |
426 | CLerr(CL_F_CLUSTER_LABS_CTRL, CL_R_ALREADY_LOADED); | |
427 | return 0; | |
428 | } | |
429 | CLUSTER_LABS_LIB_NAME = (const char *)p; | |
430 | return 1; | |
431 | default: | |
432 | break; | |
433 | } | |
434 | CLerr(CL_F_CLUSTER_LABS_CTRL, CL_R_COMMAND_NOT_IMPLEMENTED); | |
435 | return 0; | |
436 | } | |
056cc163 RL |
437 | |
438 | static int cluster_labs_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, | |
ae5c8664 MC |
439 | const BIGNUM *m, BN_CTX *ctx) |
440 | { | |
441 | ||
442 | if (cluster_labs_dso == NULL) { | |
443 | CLerr(CL_F_CLUSTER_LABS_MOD_EXP, CL_R_NOT_LOADED); | |
444 | return 0; | |
445 | } | |
446 | if (p_cl_mod_exp == NULL) { | |
447 | CLerr(CL_F_CLUSTER_LABS_MOD_EXP, CL_R_FUNCTION_NOT_BINDED); | |
448 | return 0; | |
449 | } | |
450 | ||
451 | return p_cl_mod_exp(r, a, p, m, ctx); | |
452 | ||
453 | } | |
454 | ||
056cc163 | 455 | static int cluster_labs_mod_exp_crt(BIGNUM *r, BIGNUM *a, const BIGNUM *p, |
ae5c8664 MC |
456 | const BIGNUM *q, const BIGNUM *dmp1, |
457 | const BIGNUM *dmq1, const BIGNUM *iqmp, | |
458 | BN_CTX *ctx) | |
459 | { | |
460 | ||
461 | if (cluster_labs_dso == NULL) { | |
462 | CLerr(CL_F_CLUSTER_LABS_MOD_EXP_CRT, CL_R_NOT_LOADED); | |
463 | return 0; | |
464 | } | |
465 | if (p_cl_mod_exp_crt == NULL) { | |
466 | CLerr(CL_F_CLUSTER_LABS_MOD_EXP_CRT, CL_R_FUNCTION_NOT_BINDED); | |
467 | return 0; | |
468 | } | |
469 | ||
470 | return p_cl_mod_exp_crt(r, a, p, q, dmp1, dmq1, iqmp, ctx); | |
471 | ||
472 | } | |
473 | ||
056cc163 | 474 | static int cluster_labs_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa) |
ae5c8664 MC |
475 | { |
476 | ||
477 | if (cluster_labs_dso == NULL) { | |
478 | CLerr(CL_F_CLUSTER_LABS_RSA_MOD_EXP, CL_R_NOT_LOADED); | |
479 | return 0; | |
480 | } | |
481 | if (p_cl_rsa_mod_exp == NULL) { | |
482 | CLerr(CL_F_CLUSTER_LABS_RSA_MOD_EXP, CL_R_FUNCTION_NOT_BINDED); | |
483 | return 0; | |
484 | } | |
485 | ||
486 | return p_cl_rsa_mod_exp(r0, I, rsa); | |
487 | ||
488 | } | |
489 | ||
490 | static DSA_SIG *cluster_labs_dsa_sign(const unsigned char *dgst, int dlen, | |
491 | DSA *dsa) | |
492 | { | |
493 | ||
494 | if (cluster_labs_dso == NULL) { | |
495 | CLerr(CL_F_CLUSTER_LABS_DSA_SIGN, CL_R_NOT_LOADED); | |
496 | return 0; | |
497 | } | |
498 | if (p_cl_dsa_sign == NULL) { | |
499 | CLerr(CL_F_CLUSTER_LABS_DSA_SIGN, CL_R_FUNCTION_NOT_BINDED); | |
500 | return 0; | |
501 | } | |
502 | ||
503 | return p_cl_dsa_sign(dgst, dlen, dsa); | |
504 | ||
505 | } | |
506 | ||
056cc163 | 507 | static int cluster_labs_dsa_verify(const unsigned char *dgst, int dgst_len, |
ae5c8664 MC |
508 | DSA_SIG *sig, DSA *dsa) |
509 | { | |
510 | ||
511 | if (cluster_labs_dso == NULL) { | |
512 | CLerr(CL_F_CLUSTER_LABS_DSA_VERIFY, CL_R_NOT_LOADED); | |
513 | return 0; | |
514 | } | |
515 | ||
516 | if (p_cl_dsa_verify == NULL) { | |
517 | CLerr(CL_F_CLUSTER_LABS_DSA_VERIFY, CL_R_FUNCTION_NOT_BINDED); | |
518 | return 0; | |
519 | } | |
520 | ||
521 | return p_cl_dsa_verify(dgst, dgst_len, sig, dsa); | |
522 | ||
523 | } | |
056cc163 RL |
524 | |
525 | static int cluster_labs_dsa_mod_exp(DSA *dsa, BIGNUM *rr, BIGNUM *a1, | |
ae5c8664 MC |
526 | BIGNUM *p1, BIGNUM *a2, BIGNUM *p2, |
527 | BIGNUM *m, BN_CTX *ctx, | |
528 | BN_MONT_CTX *in_mont) | |
529 | { | |
530 | BIGNUM t; | |
531 | int status = 0; | |
532 | ||
533 | BN_init(&t); | |
534 | /* let rr = a1 ^ p1 mod m */ | |
535 | if (!cluster_labs_mod_exp(rr, a1, p1, m, ctx)) | |
536 | goto end; | |
537 | /* let t = a2 ^ p2 mod m */ | |
538 | if (!cluster_labs_mod_exp(&t, a2, p2, m, ctx)) | |
539 | goto end; | |
540 | /* let rr = rr * t mod m */ | |
541 | if (!BN_mod_mul(rr, rr, &t, m, ctx)) | |
542 | goto end; | |
543 | status = 1; | |
544 | end: | |
545 | BN_free(&t); | |
546 | ||
547 | return (1); | |
548 | ||
549 | } | |
056cc163 RL |
550 | |
551 | static int cluster_labs_mod_exp_dsa(DSA *dsa, BIGNUM *r, BIGNUM *a, | |
ae5c8664 MC |
552 | const BIGNUM *p, const BIGNUM *m, |
553 | BN_CTX *ctx, BN_MONT_CTX *m_ctx) | |
554 | { | |
555 | return cluster_labs_mod_exp(r, a, p, m, ctx); | |
556 | } | |
557 | ||
056cc163 | 558 | /* This function is aliased to mod_exp (with the mont stuff dropped). */ |
ae5c8664 MC |
559 | static int cluster_labs_mod_exp_mont(BIGNUM *r, const BIGNUM *a, |
560 | const BIGNUM *p, const BIGNUM *m, | |
561 | BN_CTX *ctx, BN_MONT_CTX *m_ctx) | |
562 | { | |
563 | return cluster_labs_mod_exp(r, a, p, m, ctx); | |
564 | } | |
056cc163 RL |
565 | |
566 | /* This function is aliased to mod_exp (with the dh and mont dropped). */ | |
ae5c8664 MC |
567 | static int cluster_labs_mod_exp_dh(const DH *dh, BIGNUM *r, const BIGNUM *a, |
568 | const BIGNUM *p, const BIGNUM *m, | |
569 | BN_CTX *ctx, BN_MONT_CTX *m_ctx) | |
570 | { | |
571 | return cluster_labs_mod_exp(r, a, p, m, ctx); | |
572 | } | |
056cc163 RL |
573 | |
574 | static int cluster_labs_rsa_pub_enc(int flen, const unsigned char *from, | |
ae5c8664 MC |
575 | unsigned char *to, RSA *rsa, int padding) |
576 | { | |
577 | ||
578 | if (cluster_labs_dso == NULL) { | |
579 | CLerr(CL_F_CLUSTER_LABS_RSA_PUB_ENC, CL_R_NOT_LOADED); | |
580 | return 0; | |
581 | } | |
582 | if (p_cl_rsa_priv_enc == NULL) { | |
583 | CLerr(CL_F_CLUSTER_LABS_RSA_PUB_ENC, CL_R_FUNCTION_NOT_BINDED); | |
584 | return 0; | |
585 | } | |
586 | ||
587 | return p_cl_rsa_pub_enc(flen, from, to, rsa, padding); | |
588 | ||
589 | } | |
590 | ||
056cc163 | 591 | static int cluster_labs_rsa_pub_dec(int flen, const unsigned char *from, |
ae5c8664 MC |
592 | unsigned char *to, RSA *rsa, int padding) |
593 | { | |
594 | ||
595 | if (cluster_labs_dso == NULL) { | |
596 | CLerr(CL_F_CLUSTER_LABS_RSA_PUB_DEC, CL_R_NOT_LOADED); | |
597 | return 0; | |
598 | } | |
599 | if (p_cl_rsa_priv_enc == NULL) { | |
600 | CLerr(CL_F_CLUSTER_LABS_RSA_PUB_DEC, CL_R_FUNCTION_NOT_BINDED); | |
601 | return 0; | |
602 | } | |
603 | ||
604 | return p_cl_rsa_pub_dec(flen, from, to, rsa, padding); | |
605 | ||
606 | } | |
607 | ||
608 | static int cluster_labs_rsa_priv_enc(int flen, const unsigned char *from, | |
609 | unsigned char *to, RSA *rsa, int padding) | |
610 | { | |
611 | ||
612 | if (cluster_labs_dso == NULL) { | |
613 | CLerr(CL_F_CLUSTER_LABS_RSA_PRIV_ENC, CL_R_NOT_LOADED); | |
614 | return 0; | |
615 | } | |
616 | ||
617 | if (p_cl_rsa_priv_enc == NULL) { | |
618 | CLerr(CL_F_CLUSTER_LABS_RSA_PRIV_ENC, CL_R_FUNCTION_NOT_BINDED); | |
619 | return 0; | |
620 | } | |
621 | ||
622 | return p_cl_rsa_priv_enc(flen, from, to, rsa, padding); | |
623 | ||
624 | } | |
625 | ||
626 | static int cluster_labs_rsa_priv_dec(int flen, const unsigned char *from, | |
627 | unsigned char *to, RSA *rsa, int padding) | |
628 | { | |
629 | ||
630 | if (cluster_labs_dso == NULL) { | |
631 | CLerr(CL_F_CLUSTER_LABS_RSA_PRIV_DEC, CL_R_NOT_LOADED); | |
632 | return 0; | |
633 | } | |
634 | if (p_cl_rsa_priv_dec == NULL) { | |
635 | CLerr(CL_F_CLUSTER_LABS_RSA_PRIV_DEC, CL_R_FUNCTION_NOT_BINDED); | |
636 | return 0; | |
637 | } | |
638 | ||
639 | return p_cl_rsa_priv_dec(flen, from, to, rsa, padding); | |
640 | ||
641 | } | |
056cc163 RL |
642 | |
643 | /************************************************************************************ | |
644 | * Symmetric algorithms | |
645 | ************************************************************************************/ | |
646 | /* this will be come soon! */ | |
647 | ||
648 | /************************************************************************************ | |
649 | * Random generator | |
650 | ************************************************************************************/ | |
651 | ||
ae5c8664 MC |
652 | static int cluster_labs_rand_bytes(unsigned char *buf, int num) |
653 | { | |
056cc163 | 654 | |
ae5c8664 MC |
655 | if (cluster_labs_dso == NULL) { |
656 | CLerr(CL_F_CLUSTER_LABS_RAND_BYTES, CL_R_NOT_LOADED); | |
657 | return 0; | |
658 | } | |
659 | if (p_cl_mod_exp_crt == NULL) { | |
660 | CLerr(CL_F_CLUSTER_LABS_RAND_BYTES, CL_R_FUNCTION_NOT_BINDED); | |
661 | return 0; | |
662 | } | |
056cc163 | 663 | |
ae5c8664 | 664 | return p_cl_rand_bytes(buf, num); |
056cc163 RL |
665 | |
666 | } | |
667 | ||
ae5c8664 MC |
668 | /* |
669 | * This stuff is needed if this ENGINE is being compiled into a | |
670 | * self-contained shared-library. | |
671 | */ | |
672 | # ifdef ENGINE_DYNAMIC_SUPPORT | |
056cc163 | 673 | static int bind_fn(ENGINE *e, const char *id) |
ae5c8664 MC |
674 | { |
675 | fprintf(stderr, "bind_fn CLUSTER_LABS\n"); | |
676 | if (id && (strcmp(id, engine_cluster_labs_id) != 0)) { | |
677 | fprintf(stderr, "bind_fn return(0) first\n"); | |
678 | return 0; | |
679 | } | |
680 | if (!bind_helper(e)) { | |
681 | fprintf(stderr, "bind_fn return(1) first\n"); | |
682 | return 0; | |
683 | } | |
684 | fprintf(stderr, "bind_fn return(1)\n"); | |
685 | return 1; | |
686 | } | |
056cc163 | 687 | |
ae5c8664 MC |
688 | IMPLEMENT_DYNAMIC_CHECK_FN() |
689 | IMPLEMENT_DYNAMIC_BIND_FN(bind_fn) | |
690 | # endif /* ENGINE_DYNAMIC_SUPPORT */ | |
691 | # endif /* !NO_HW_CLUSTER_LABS */ | |
692 | #endif /* !NO_HW */ |