fix leak properly this time...
[openssl.git] / crypto / engine / eng_openssl.c
1 /* crypto/engine/eng_openssl.c */
2 /* Written by Geoff Thorpe (geoff@geoffthorpe.net) for the OpenSSL
3  * project 2000.
4  */
5 /* ====================================================================
6  * Copyright (c) 1999-2001 The OpenSSL Project.  All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer. 
14  *
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in
17  *    the documentation and/or other materials provided with the
18  *    distribution.
19  *
20  * 3. All advertising materials mentioning features or use of this
21  *    software must display the following acknowledgment:
22  *    "This product includes software developed by the OpenSSL Project
23  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
24  *
25  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
26  *    endorse or promote products derived from this software without
27  *    prior written permission. For written permission, please contact
28  *    licensing@OpenSSL.org.
29  *
30  * 5. Products derived from this software may not be called "OpenSSL"
31  *    nor may "OpenSSL" appear in their names without prior written
32  *    permission of the OpenSSL Project.
33  *
34  * 6. Redistributions of any form whatsoever must retain the following
35  *    acknowledgment:
36  *    "This product includes software developed by the OpenSSL Project
37  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
38  *
39  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
40  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
41  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
42  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
43  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
44  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
45  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
46  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
48  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
49  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
50  * OF THE POSSIBILITY OF SUCH DAMAGE.
51  * ====================================================================
52  *
53  * This product includes cryptographic software written by Eric Young
54  * (eay@cryptsoft.com).  This product includes software written by Tim
55  * Hudson (tjh@cryptsoft.com).
56  *
57  */
58 /* ====================================================================
59  * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
60  * ECDH support in OpenSSL originally developed by 
61  * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
62  */
63
64
65 #include <stdio.h>
66 #include <openssl/crypto.h>
67 #include "cryptlib.h"
68 #include <openssl/engine.h>
69 #include <openssl/dso.h>
70 #include <openssl/pem.h>
71 #include <openssl/evp.h>
72 #include <openssl/rand.h>
73 #ifndef OPENSSL_NO_RSA
74 #include <openssl/rsa.h>
75 #endif
76 #ifndef OPENSSL_NO_DSA
77 #include <openssl/dsa.h>
78 #endif
79 #ifndef OPENSSL_NO_DH
80 #include <openssl/dh.h>
81 #endif
82
83 #include <openssl/hmac.h>
84 #include <openssl/x509v3.h>
85
86 /* This testing gunk is implemented (and explained) lower down. It also assumes
87  * the application explicitly calls "ENGINE_load_openssl()" because this is no
88  * longer automatic in ENGINE_load_builtin_engines(). */
89 #define TEST_ENG_OPENSSL_RC4
90 #define TEST_ENG_OPENSSL_PKEY
91 /* #define TEST_ENG_OPENSSL_HMAC */
92 /* #define TEST_ENG_OPENSSL_HMAC_INIT */
93 /* #define TEST_ENG_OPENSSL_RC4_OTHERS */
94 #define TEST_ENG_OPENSSL_RC4_P_INIT
95 /* #define TEST_ENG_OPENSSL_RC4_P_CIPHER */
96 #define TEST_ENG_OPENSSL_SHA
97 /* #define TEST_ENG_OPENSSL_SHA_OTHERS */
98 /* #define TEST_ENG_OPENSSL_SHA_P_INIT */
99 /* #define TEST_ENG_OPENSSL_SHA_P_UPDATE */
100 /* #define TEST_ENG_OPENSSL_SHA_P_FINAL */
101
102 /* Now check what of those algorithms are actually enabled */
103 #ifdef OPENSSL_NO_RC4
104 #undef TEST_ENG_OPENSSL_RC4
105 #undef TEST_ENG_OPENSSL_RC4_OTHERS
106 #undef TEST_ENG_OPENSSL_RC4_P_INIT
107 #undef TEST_ENG_OPENSSL_RC4_P_CIPHER
108 #endif
109 #if defined(OPENSSL_NO_SHA) || defined(OPENSSL_NO_SHA0) || defined(OPENSSL_NO_SHA1)
110 #undef TEST_ENG_OPENSSL_SHA
111 #undef TEST_ENG_OPENSSL_SHA_OTHERS
112 #undef TEST_ENG_OPENSSL_SHA_P_INIT
113 #undef TEST_ENG_OPENSSL_SHA_P_UPDATE
114 #undef TEST_ENG_OPENSSL_SHA_P_FINAL 
115 #endif
116
117 #ifdef TEST_ENG_OPENSSL_RC4
118 static int openssl_ciphers(ENGINE *e, const EVP_CIPHER **cipher,
119                                 const int **nids, int nid);
120 #endif
121 #ifdef TEST_ENG_OPENSSL_SHA
122 static int openssl_digests(ENGINE *e, const EVP_MD **digest,
123                                 const int **nids, int nid);
124 #endif
125
126 #ifdef TEST_ENG_OPENSSL_PKEY
127 static EVP_PKEY *openssl_load_privkey(ENGINE *eng, const char *key_id,
128         UI_METHOD *ui_method, void *callback_data);
129 #endif
130
131 #ifdef TEST_ENG_OPENSSL_HMAC
132 static int ossl_register_hmac_meth(void);
133 static int ossl_pkey_meths(ENGINE *e, EVP_PKEY_METHOD **pmeth,
134         const int **nids, int nid);
135 #endif
136
137 /* The constants used when creating the ENGINE */
138 static const char *engine_openssl_id = "openssl";
139 static const char *engine_openssl_name = "Software engine support";
140
141 /* This internal function is used by ENGINE_openssl() and possibly by the
142  * "dynamic" ENGINE support too */
143 static int bind_helper(ENGINE *e)
144         {
145         if(!ENGINE_set_id(e, engine_openssl_id)
146                         || !ENGINE_set_name(e, engine_openssl_name)
147 #ifndef TEST_ENG_OPENSSL_NO_ALGORITHMS
148 #ifndef OPENSSL_NO_RSA
149                         || !ENGINE_set_RSA(e, RSA_get_default_method())
150 #endif
151 #ifndef OPENSSL_NO_DSA
152                         || !ENGINE_set_DSA(e, DSA_get_default_method())
153 #endif
154 #ifndef OPENSSL_NO_ECDH
155                         || !ENGINE_set_ECDH(e, ECDH_OpenSSL())
156 #endif
157 #ifndef OPENSSL_NO_ECDSA
158                         || !ENGINE_set_ECDSA(e, ECDSA_OpenSSL())
159 #endif
160 #ifndef OPENSSL_NO_DH
161                         || !ENGINE_set_DH(e, DH_get_default_method())
162 #endif
163                         || !ENGINE_set_RAND(e, RAND_SSLeay())
164 #ifdef TEST_ENG_OPENSSL_RC4
165                         || !ENGINE_set_ciphers(e, openssl_ciphers)
166 #endif
167 #ifdef TEST_ENG_OPENSSL_SHA
168                         || !ENGINE_set_digests(e, openssl_digests)
169 #endif
170 #endif
171 #ifdef TEST_ENG_OPENSSL_PKEY
172                         || !ENGINE_set_load_privkey_function(e, openssl_load_privkey)
173 #endif
174 #ifdef TEST_ENG_OPENSSL_HMAC
175                         || !ossl_register_hmac_meth()
176                         || !ENGINE_set_pkey_meths(e, ossl_pkey_meths)
177 #endif
178                         )
179                 return 0;
180         /* If we add errors to this ENGINE, ensure the error handling is setup here */
181         /* openssl_load_error_strings(); */
182         return 1;
183         }
184
185 static ENGINE *engine_openssl(void)
186         {
187         ENGINE *ret = ENGINE_new();
188         if(!ret)
189                 return NULL;
190         if(!bind_helper(ret))
191                 {
192                 ENGINE_free(ret);
193                 return NULL;
194                 }
195         return ret;
196         }
197
198 void ENGINE_load_openssl(void)
199         {
200         ENGINE *toadd = engine_openssl();
201         if(!toadd) return;
202         ENGINE_add(toadd);
203         /* If the "add" worked, it gets a structural reference. So either way,
204          * we release our just-created reference. */
205         ENGINE_free(toadd);
206         ERR_clear_error();
207         }
208
209 /* This stuff is needed if this ENGINE is being compiled into a self-contained
210  * shared-library. */
211 #ifdef ENGINE_DYNAMIC_SUPPORT
212 static int bind_fn(ENGINE *e, const char *id)
213         {
214         if(id && (strcmp(id, engine_openssl_id) != 0))
215                 return 0;
216         if(!bind_helper(e))
217                 return 0;
218         return 1;
219         }
220 IMPLEMENT_DYNAMIC_CHECK_FN()
221 IMPLEMENT_DYNAMIC_BIND_FN(bind_fn)
222 #endif /* ENGINE_DYNAMIC_SUPPORT */
223
224 #ifdef TEST_ENG_OPENSSL_RC4
225 /* This section of code compiles an "alternative implementation" of two modes of
226  * RC4 into this ENGINE. The result is that EVP_CIPHER operation for "rc4"
227  * should under normal circumstances go via this support rather than the default
228  * EVP support. There are other symbols to tweak the testing;
229  *    TEST_ENC_OPENSSL_RC4_OTHERS - print a one line message to stderr each time
230  *        we're asked for a cipher we don't support (should not happen).
231  *    TEST_ENG_OPENSSL_RC4_P_INIT - print a one line message to stderr each time
232  *        the "init_key" handler is called.
233  *    TEST_ENG_OPENSSL_RC4_P_CIPHER - ditto for the "cipher" handler.
234  */
235 #include <openssl/rc4.h>
236 #define TEST_RC4_KEY_SIZE               16
237 static int test_cipher_nids[] = {NID_rc4,NID_rc4_40};
238 static int test_cipher_nids_number = 2;
239 typedef struct {
240         unsigned char key[TEST_RC4_KEY_SIZE];
241         RC4_KEY ks;
242         } TEST_RC4_KEY;
243 #define test(ctx) ((TEST_RC4_KEY *)(ctx)->cipher_data)
244 static int test_rc4_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
245                         const unsigned char *iv, int enc)
246         {
247 #ifdef TEST_ENG_OPENSSL_RC4_P_INIT
248         fprintf(stderr, "(TEST_ENG_OPENSSL_RC4) test_init_key() called\n");
249 #endif
250         memcpy(&test(ctx)->key[0],key,EVP_CIPHER_CTX_key_length(ctx));
251         RC4_set_key(&test(ctx)->ks,EVP_CIPHER_CTX_key_length(ctx),
252                 test(ctx)->key);
253         return 1;
254         }
255 static int test_rc4_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
256                       const unsigned char *in, size_t inl)
257         {
258 #ifdef TEST_ENG_OPENSSL_RC4_P_CIPHER
259         fprintf(stderr, "(TEST_ENG_OPENSSL_RC4) test_cipher() called\n");
260 #endif
261         RC4(&test(ctx)->ks,inl,in,out);
262         return 1;
263         }
264 static const EVP_CIPHER test_r4_cipher=
265         {
266         NID_rc4,
267         1,TEST_RC4_KEY_SIZE,0,
268         EVP_CIPH_VARIABLE_LENGTH,
269         test_rc4_init_key,
270         test_rc4_cipher,
271         NULL,
272         sizeof(TEST_RC4_KEY),
273         NULL,
274         NULL,
275         NULL,
276         NULL
277         };
278 static const EVP_CIPHER test_r4_40_cipher=
279         {
280         NID_rc4_40,
281         1,5 /* 40 bit */,0,
282         EVP_CIPH_VARIABLE_LENGTH,
283         test_rc4_init_key,
284         test_rc4_cipher,
285         NULL,
286         sizeof(TEST_RC4_KEY),
287         NULL, 
288         NULL,
289         NULL,
290         NULL
291         };
292 static int openssl_ciphers(ENGINE *e, const EVP_CIPHER **cipher,
293                         const int **nids, int nid)
294         {
295         if(!cipher)
296                 {
297                 /* We are returning a list of supported nids */
298                 *nids = test_cipher_nids;
299                 return test_cipher_nids_number;
300                 }
301         /* We are being asked for a specific cipher */
302         if(nid == NID_rc4)
303                 *cipher = &test_r4_cipher;
304         else if(nid == NID_rc4_40)
305                 *cipher = &test_r4_40_cipher;
306         else
307                 {
308 #ifdef TEST_ENG_OPENSSL_RC4_OTHERS
309                 fprintf(stderr, "(TEST_ENG_OPENSSL_RC4) returning NULL for "
310                                 "nid %d\n", nid);
311 #endif
312                 *cipher = NULL;
313                 return 0;
314                 }
315         return 1;
316         }
317 #endif
318
319 #ifdef TEST_ENG_OPENSSL_SHA
320 /* Much the same sort of comment as for TEST_ENG_OPENSSL_RC4 */
321 #include <openssl/sha.h>
322 static int test_digest_nids[] = {NID_sha1};
323 static int test_digest_nids_number = 1;
324 static int test_sha1_init(EVP_MD_CTX *ctx)
325         {
326 #ifdef TEST_ENG_OPENSSL_SHA_P_INIT
327         fprintf(stderr, "(TEST_ENG_OPENSSL_SHA) test_sha1_init() called\n");
328 #endif
329         return SHA1_Init(ctx->md_data);
330         }
331 static int test_sha1_update(EVP_MD_CTX *ctx,const void *data,size_t count)
332         {
333 #ifdef TEST_ENG_OPENSSL_SHA_P_UPDATE
334         fprintf(stderr, "(TEST_ENG_OPENSSL_SHA) test_sha1_update() called\n");
335 #endif
336         return SHA1_Update(ctx->md_data,data,count);
337         }
338 static int test_sha1_final(EVP_MD_CTX *ctx,unsigned char *md)
339         {
340 #ifdef TEST_ENG_OPENSSL_SHA_P_FINAL
341         fprintf(stderr, "(TEST_ENG_OPENSSL_SHA) test_sha1_final() called\n");
342 #endif
343         return SHA1_Final(md,ctx->md_data);
344         }
345 static const EVP_MD test_sha_md=
346         {
347         NID_sha1,
348         NID_sha1WithRSAEncryption,
349         SHA_DIGEST_LENGTH,
350         0,
351         test_sha1_init,
352         test_sha1_update,
353         test_sha1_final,
354         NULL,
355         NULL,
356         EVP_PKEY_RSA_method,
357         SHA_CBLOCK,
358         sizeof(EVP_MD *)+sizeof(SHA_CTX),
359         };
360 static int openssl_digests(ENGINE *e, const EVP_MD **digest,
361                         const int **nids, int nid)
362         {
363         if(!digest)
364                 {
365                 /* We are returning a list of supported nids */
366                 *nids = test_digest_nids;
367                 return test_digest_nids_number;
368                 }
369         /* We are being asked for a specific digest */
370         if(nid == NID_sha1)
371                 *digest = &test_sha_md;
372         else
373                 {
374 #ifdef TEST_ENG_OPENSSL_SHA_OTHERS
375                 fprintf(stderr, "(TEST_ENG_OPENSSL_SHA) returning NULL for "
376                                 "nid %d\n", nid);
377 #endif
378                 *digest = NULL;
379                 return 0;
380                 }
381         return 1;
382         }
383 #endif
384
385 #ifdef TEST_ENG_OPENSSL_PKEY
386 static EVP_PKEY *openssl_load_privkey(ENGINE *eng, const char *key_id,
387         UI_METHOD *ui_method, void *callback_data)
388         {
389         BIO *in;
390         EVP_PKEY *key;
391         fprintf(stderr, "(TEST_ENG_OPENSSL_PKEY)Loading Private key %s\n", key_id);
392         in = BIO_new_file(key_id, "r");
393         if (!in)
394                 return NULL;
395         key = PEM_read_bio_PrivateKey(in, NULL, 0, NULL);
396         BIO_free(in);
397         return key;
398         }
399 #endif
400
401 #ifdef TEST_ENG_OPENSSL_HMAC
402
403 /* Experimental HMAC redirection implementation: mainly copied from
404  * hm_pmeth.c
405  */
406
407 /* HMAC pkey context structure */
408
409 typedef struct
410         {
411         const EVP_MD *md;       /* MD for HMAC use */
412         ASN1_OCTET_STRING ktmp; /* Temp storage for key */
413         HMAC_CTX ctx;
414         } OSSL_HMAC_PKEY_CTX;
415
416 static int ossl_hmac_init(EVP_PKEY_CTX *ctx)
417         {
418         OSSL_HMAC_PKEY_CTX *hctx;
419         hctx = OPENSSL_malloc(sizeof(OSSL_HMAC_PKEY_CTX));
420         if (!hctx)
421                 return 0;
422         hctx->md = NULL;
423         hctx->ktmp.data = NULL;
424         hctx->ktmp.length = 0;
425         hctx->ktmp.flags = 0;
426         hctx->ktmp.type = V_ASN1_OCTET_STRING;
427         HMAC_CTX_init(&hctx->ctx);
428         EVP_PKEY_CTX_set_data(ctx, hctx);
429         EVP_PKEY_CTX_set0_keygen_info(ctx, NULL, 0);
430 #ifdef TEST_ENG_OPENSSL_HMAC_INIT
431         fprintf(stderr, "(TEST_ENG_OPENSSL_HMAC) ossl_hmac_init() called\n");
432 #endif
433         return 1;
434         }
435
436 static int ossl_hmac_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src)
437         {
438         OSSL_HMAC_PKEY_CTX *sctx, *dctx;
439         if (!ossl_hmac_init(dst))
440                 return 0;
441         sctx = EVP_PKEY_CTX_get_data(src);
442         dctx = EVP_PKEY_CTX_get_data(dst);
443         dctx->md = sctx->md;
444         HMAC_CTX_init(&dctx->ctx);
445         if (!HMAC_CTX_copy(&dctx->ctx, &sctx->ctx))
446                 return 0;
447         if (sctx->ktmp.data)
448                 {
449                 if (!ASN1_OCTET_STRING_set(&dctx->ktmp,
450                                         sctx->ktmp.data, sctx->ktmp.length))
451                         return 0;
452                 }
453         return 1;
454         }
455
456 static void ossl_hmac_cleanup(EVP_PKEY_CTX *ctx)
457         {
458         OSSL_HMAC_PKEY_CTX *hctx;
459         hctx = EVP_PKEY_CTX_get_data(ctx);
460         HMAC_CTX_cleanup(&hctx->ctx);
461         if (hctx->ktmp.data)
462                 {
463                 if (hctx->ktmp.length)
464                         OPENSSL_cleanse(hctx->ktmp.data, hctx->ktmp.length);
465                 OPENSSL_free(hctx->ktmp.data);
466                 hctx->ktmp.data = NULL;
467                 }
468         OPENSSL_free(hctx);
469         }
470
471 static int ossl_hmac_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
472         {
473         ASN1_OCTET_STRING *hkey = NULL;
474         OSSL_HMAC_PKEY_CTX *hctx = EVP_PKEY_CTX_get_data(ctx);
475         if (!hctx->ktmp.data)
476                 return 0;
477         hkey = ASN1_OCTET_STRING_dup(&hctx->ktmp);
478         if (!hkey)
479                 return 0;
480         EVP_PKEY_assign(pkey, EVP_PKEY_HMAC, hkey);
481         
482         return 1;
483         }
484
485 static int ossl_int_update(EVP_MD_CTX *ctx,const void *data,size_t count)
486         {
487         OSSL_HMAC_PKEY_CTX *hctx = EVP_PKEY_CTX_get_data(ctx->pctx);
488         if (!HMAC_Update(&hctx->ctx, data, count))
489                 return 0;
490         return 1;
491         }
492
493 static int ossl_hmac_signctx_init(EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx)
494         {
495         EVP_MD_CTX_set_flags(mctx, EVP_MD_CTX_FLAG_NO_INIT);
496         mctx->update = ossl_int_update;
497         return 1;
498         }
499
500 static int ossl_hmac_signctx(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
501                                         EVP_MD_CTX *mctx)
502         {
503         unsigned int hlen;
504         OSSL_HMAC_PKEY_CTX *hctx = EVP_PKEY_CTX_get_data(ctx);
505         int l = EVP_MD_CTX_size(mctx);
506
507         if (l < 0)
508                 return 0;
509         *siglen = l;
510         if (!sig)
511                 return 1;
512
513         if (!HMAC_Final(&hctx->ctx, sig, &hlen))
514                 return 0;
515         *siglen = (size_t)hlen;
516         return 1;
517         }
518
519 static int ossl_hmac_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
520         {
521         OSSL_HMAC_PKEY_CTX *hctx = EVP_PKEY_CTX_get_data(ctx);
522         EVP_PKEY *pk;
523         ASN1_OCTET_STRING *key;
524         switch (type)
525                 {
526
527                 case EVP_PKEY_CTRL_SET_MAC_KEY:
528                 if ((!p2 && p1 > 0) || (p1 < -1))
529                         return 0;
530                 if (!ASN1_OCTET_STRING_set(&hctx->ktmp, p2, p1))
531                         return 0;
532                 break;
533
534                 case EVP_PKEY_CTRL_MD:
535                 hctx->md = p2;
536                 break;
537
538                 case EVP_PKEY_CTRL_DIGESTINIT:
539                 pk = EVP_PKEY_CTX_get0_pkey(ctx);
540                 key = EVP_PKEY_get0(pk);
541                 if (!HMAC_Init_ex(&hctx->ctx, key->data, key->length, hctx->md,
542                                 NULL))
543                         return 0;
544                 break;
545
546                 default:
547                 return -2;
548
549                 }
550         return 1;
551         }
552
553 static int ossl_hmac_ctrl_str(EVP_PKEY_CTX *ctx,
554                         const char *type, const char *value)
555         {
556         if (!value)
557                 {
558                 return 0;
559                 }
560         if (!strcmp(type, "key"))
561                 {
562                 void *p = (void *)value;
563                 return ossl_hmac_ctrl(ctx, EVP_PKEY_CTRL_SET_MAC_KEY,
564                                 -1, p);
565                 }
566         if (!strcmp(type, "hexkey"))
567                 {
568                 unsigned char *key;
569                 int r;
570                 long keylen;
571                 key = string_to_hex(value, &keylen);
572                 if (!key)
573                         return 0;
574                 r = ossl_hmac_ctrl(ctx, EVP_PKEY_CTRL_SET_MAC_KEY, keylen, key);
575                 OPENSSL_free(key);
576                 return r;
577                 }
578         return -2;
579         }
580
581 static EVP_PKEY_METHOD *ossl_hmac_meth;
582
583 static int ossl_register_hmac_meth(void)
584         {
585         EVP_PKEY_METHOD *meth;
586         meth = EVP_PKEY_meth_new(EVP_PKEY_HMAC, 0);
587         if (!meth)
588                 return 0;
589         EVP_PKEY_meth_set_init(meth, ossl_hmac_init);
590         EVP_PKEY_meth_set_copy(meth, ossl_hmac_copy);
591         EVP_PKEY_meth_set_cleanup(meth, ossl_hmac_cleanup);
592
593         EVP_PKEY_meth_set_keygen(meth, 0, ossl_hmac_keygen);
594
595         EVP_PKEY_meth_set_signctx(meth, ossl_hmac_signctx_init,
596                                                 ossl_hmac_signctx);
597
598         EVP_PKEY_meth_set_ctrl(meth, ossl_hmac_ctrl, ossl_hmac_ctrl_str);
599         ossl_hmac_meth = meth;
600         return 1;
601         }
602
603 static int ossl_pkey_meths(ENGINE *e, EVP_PKEY_METHOD **pmeth,
604         const int **nids, int nid)
605
606         {
607         static int ossl_pkey_nids[] = 
608                 {
609                 EVP_PKEY_HMAC,
610                 0
611                 };
612         if (!pmeth)
613                 {
614                 *nids = ossl_pkey_nids;
615                 return 1;
616                 }
617
618         if (nid == EVP_PKEY_HMAC)
619                 {
620                 *pmeth = ossl_hmac_meth;
621                 return 1;
622                 }
623
624         *pmeth = NULL;
625         return 0;
626         }
627
628
629 #endif