Some of the ENGINE file names were changed for 8.3 filename uniqueness
[openssl.git] / crypto / engine / hw_atalla.c
index 8bf702a..89149e1 100644 (file)
@@ -3,7 +3,7 @@
  * project 2000.
  */
 /* ====================================================================
- * Copyright (c) 1999 The OpenSSL Project.  All rights reserved.
+ * Copyright (c) 1999-2001 The OpenSSL Project.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -71,6 +71,7 @@
 #include "vendor_defns/atalla.h"
 #endif
 
+static int atalla_destroy(ENGINE *e);
 static int atalla_init(ENGINE *e);
 static int atalla_finish(ENGINE *e);
 static int atalla_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)());
@@ -79,12 +80,15 @@ static int atalla_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)());
 static int atalla_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
                const BIGNUM *m, BN_CTX *ctx);
 
+#ifndef OPENSSL_NO_RSA
 /* RSA stuff */
 static int atalla_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa);
+#endif
 /* This function is aliased to mod_exp (with the mont stuff dropped). */
 static int atalla_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
                const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
 
+#ifndef OPENSSL_NO_DSA
 /* DSA stuff */
 static int atalla_dsa_mod_exp(DSA *dsa, BIGNUM *rr, BIGNUM *a1,
                BIGNUM *p1, BIGNUM *a2, BIGNUM *p2, BIGNUM *m,
@@ -92,12 +96,15 @@ static int atalla_dsa_mod_exp(DSA *dsa, BIGNUM *rr, BIGNUM *a1,
 static int atalla_mod_exp_dsa(DSA *dsa, BIGNUM *r, BIGNUM *a,
                const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx,
                BN_MONT_CTX *m_ctx);
+#endif
 
+#ifndef OPENSSL_NO_DH
 /* DH stuff */
 /* This function is alised to mod_exp (with the DH and mont dropped). */
 static int atalla_mod_exp_dh(const DH *dh, BIGNUM *r,
                const BIGNUM *a, const BIGNUM *p,
                const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
+#endif
 
 /* The definitions for control commands specific to this engine */
 #define ATALLA_CMD_SO_PATH             ENGINE_CMD_BASE
@@ -109,6 +116,7 @@ static const ENGINE_CMD_DEFN atalla_cmd_defns[] = {
        {0, NULL, NULL, 0}
        };
 
+#ifndef OPENSSL_NO_RSA
 /* Our internal RSA_METHOD that we provide pointers to */
 static RSA_METHOD atalla_rsa =
        {
@@ -126,7 +134,9 @@ static RSA_METHOD atalla_rsa =
        NULL,
        NULL
        };
+#endif
 
+#ifndef OPENSSL_NO_DSA
 /* Our internal DSA_METHOD that we provide pointers to */
 static DSA_METHOD atalla_dsa =
        {
@@ -141,7 +151,9 @@ static DSA_METHOD atalla_dsa =
        0, /* flags */
        NULL /* app_data */
        };
+#endif
 
+#ifndef OPENSSL_NO_DH
 /* Our internal DH_METHOD that we provide pointers to */
 static DH_METHOD atalla_dh =
        {
@@ -154,36 +166,107 @@ static DH_METHOD atalla_dh =
        0,
        NULL
        };
+#endif
+
+#ifndef OPENSSL_NO_ERR
+/* Error function codes for use in atalla operation */
+#define ATALLA_F_ATALLA_INIT                   100
+#define ATALLA_F_ATALLA_FINISH                 101
+#define ATALLA_F_ATALLA_CTRL                   102
+#define ATALLA_F_ATALLA_MOD_EXP                        103
+#define ATALLA_F_ATALLA_RSA_MOD_EXP            104
+/* Error reason codes */
+#define ATALLA_R_ALREADY_LOADED                        105
+#define ATALLA_R_NOT_LOADED                    106
+#define ATALLA_R_UNIT_FAILURE                  107
+#define ATALLA_R_CTRL_COMMAND_NOT_IMPLEMENTED  108
+#define ATALLA_R_BN_CTX_FULL                   109
+#define ATALLA_R_BN_EXPAND_FAIL                        110
+#define ATALLA_R_REQUEST_FAILED                        111
+#define ATALLA_R_MISSING_KEY_COMPONENTS                112
+static ERR_STRING_DATA atalla_str_functs[] =
+       {
+       /* This first element is changed to match the dynamic 'lib' number */
+{ERR_PACK(0,0,0),                              "atalla engine code"},
+{ERR_PACK(0,ATALLA_F_ATALLA_INIT,0),           "atalla_init"},
+{ERR_PACK(0,ATALLA_F_ATALLA_FINISH,0),         "atalla_finish"},
+{ERR_PACK(0,ATALLA_F_ATALLA_CTRL,0),           "atalla_ctrl"},
+{ERR_PACK(0,ATALLA_F_ATALLA_MOD_EXP,0),                "atalla_mod_exp"},
+{ERR_PACK(0,ATALLA_F_ATALLA_RSA_MOD_EXP,0),"atalla_rsa_mod_exp"},
+{ATALLA_R_ALREADY_LOADED               ,"already loaded"},
+{ATALLA_R_UNIT_FAILURE                 ,"unit failure"},
+{ATALLA_R_NOT_LOADED,                  "not loaded"},
+{ATALLA_R_CTRL_COMMAND_NOT_IMPLEMENTED ,"control command not implemented"},
+{ATALLA_R_BN_CTX_FULL                  ,"BN_CTX full"},
+{ATALLA_R_BN_EXPAND_FAIL               ,"BN_expand failed"},
+{ATALLA_R_REQUEST_FAILED               ,"request failed"},
+{ATALLA_R_MISSING_KEY_COMPONENTS       ,"missing key components"},
+{0,NULL}
+       };
+/* The library number we obtain dynamically from the ERR code */
+static int atalla_err_lib = -1;
+#define ATALLAerr(f,r) ERR_PUT_error(atalla_err_lib,(f),(r),__FILE__,__LINE__)
+static void atalla_load_error_strings(void)
+       {
+       if (atalla_err_lib < 0)
+               {
+               if((atalla_err_lib = ERR_get_next_error_library()) <= 0)
+                       return;
+               atalla_str_functs[0].error = ERR_PACK(atalla_err_lib, 0, 0);
+               ERR_load_strings(atalla_err_lib,atalla_str_functs);
+               }
+       }
+static void atalla_unload_error_strings(void)
+       {
+       if (atalla_err_lib >= 0)
+               {
+               ERR_unload_strings(atalla_err_lib,atalla_str_functs);
+               atalla_err_lib = -1;
+               }
+       }
+#else
+#define ATALLAerr(f,r)                                 /* NOP */
+static void atalla_load_error_strings(void) { }                /* NOP */
+static void atalla_unload_error_strings(void) { }      /* NOP */
+#endif
 
 /* Constants used when creating the ENGINE */
 static const char *engine_atalla_id = "atalla";
 static const char *engine_atalla_name = "Atalla hardware engine support";
 
-/* As this is only ever called once, there's no need for locking
- * (indeed - the lock will already be held by our caller!!!) */
-ENGINE *ENGINE_atalla()
+/* This internal function is used by ENGINE_atalla() and possibly by the
+ * "dynamic" ENGINE support too */
+static int bind_helper(ENGINE *e)
        {
+#ifndef OPENSSL_NO_RSA
        const RSA_METHOD *meth1;
+#endif
+#ifndef OPENSSL_NO_DSA
        const DSA_METHOD *meth2;
+#endif
+#ifndef OPENSSL_NO_DH
        const DH_METHOD *meth3;
-       ENGINE *ret = ENGINE_new();
-       if(!ret)
-               return NULL;
-       if(!ENGINE_set_id(ret, engine_atalla_id) ||
-                       !ENGINE_set_name(ret, engine_atalla_name) ||
-                       !ENGINE_set_RSA(ret, &atalla_rsa) ||
-                       !ENGINE_set_DSA(ret, &atalla_dsa) ||
-                       !ENGINE_set_DH(ret, &atalla_dh) ||
-                       !ENGINE_set_BN_mod_exp(ret, atalla_mod_exp) ||
-                       !ENGINE_set_init_function(ret, atalla_init) ||
-                       !ENGINE_set_finish_function(ret, atalla_finish) ||
-                       !ENGINE_set_ctrl_function(ret, atalla_ctrl) ||
-                       !ENGINE_set_cmd_defns(ret, atalla_cmd_defns))
-               {
-               ENGINE_free(ret);
-               return NULL;
-               }
+#endif
+       if(!ENGINE_set_id(e, engine_atalla_id) ||
+                       !ENGINE_set_name(e, engine_atalla_name) ||
+#ifndef OPENSSL_NO_RSA
+                       !ENGINE_set_RSA(e, &atalla_rsa) ||
+#endif
+#ifndef OPENSSL_NO_DSA
+                       !ENGINE_set_DSA(e, &atalla_dsa) ||
+#endif
+#ifndef OPENSSL_NO_DH
+                       !ENGINE_set_DH(e, &atalla_dh) ||
+#endif
+                       !ENGINE_set_BN_mod_exp(e, atalla_mod_exp) ||
+                       !ENGINE_set_destroy_function(e, atalla_destroy) ||
+                       !ENGINE_set_init_function(e, atalla_init) ||
+                       !ENGINE_set_finish_function(e, atalla_finish) ||
+                       !ENGINE_set_ctrl_function(e, atalla_ctrl) ||
+                       !ENGINE_set_cmd_defns(e, atalla_cmd_defns))
+               return 0;
 
+#ifndef OPENSSL_NO_RSA
        /* We know that the "PKCS1_SSLeay()" functions hook properly
         * to the atalla-specific mod_exp and mod_exp_crt so we use
         * those functions. NB: We don't use ENGINE_openssl() or
@@ -196,18 +279,41 @@ ENGINE *ENGINE_atalla()
        atalla_rsa.rsa_pub_dec = meth1->rsa_pub_dec;
        atalla_rsa.rsa_priv_enc = meth1->rsa_priv_enc;
        atalla_rsa.rsa_priv_dec = meth1->rsa_priv_dec;
+#endif
 
+#ifndef OPENSSL_NO_DSA
        /* Use the DSA_OpenSSL() method and just hook the mod_exp-ish
         * bits. */
        meth2 = DSA_OpenSSL();
        atalla_dsa.dsa_do_sign = meth2->dsa_do_sign;
        atalla_dsa.dsa_sign_setup = meth2->dsa_sign_setup;
        atalla_dsa.dsa_do_verify = meth2->dsa_do_verify;
+#endif
 
+#ifndef OPENSSL_NO_DH
        /* Much the same for Diffie-Hellman */
        meth3 = DH_OpenSSL();
        atalla_dh.generate_key = meth3->generate_key;
        atalla_dh.compute_key = meth3->compute_key;
+#endif
+
+       /* Ensure the atalla error handling is set up */
+       atalla_load_error_strings();
+       return 1;
+       }
+
+/* As this is only ever called once, there's no need for locking
+ * (indeed - the lock will already be held by our caller!!!) */
+ENGINE *ENGINE_atalla(void)
+       {
+       ENGINE *ret = ENGINE_new();
+       if(!ret)
+               return NULL;
+       if(!bind_helper(ret))
+               {
+               ENGINE_free(ret);
+               return NULL;
+               }
        return ret;
        }
 
@@ -238,6 +344,16 @@ static const char *ATALLA_F1 = "ASI_GetHardwareConfig";
 static const char *ATALLA_F2 = "ASI_RSAPrivateKeyOpFn";
 static const char *ATALLA_F3 = "ASI_GetPerformanceStatistics";
 
+/* Destructor (complements the "ENGINE_atalla()" constructor) */
+static int atalla_destroy(ENGINE *e)
+       {
+       /* Unload the atalla error strings so any error state including our
+        * functs or reasons won't lead to a segfault (they simply get displayed
+        * without corresponding string data because none will be found). */
+       atalla_unload_error_strings();
+       return 1;
+       }
+
 /* (de)initialisation functions. */
 static int atalla_init(ENGINE *e)
        {
@@ -250,7 +366,7 @@ static int atalla_init(ENGINE *e)
 
        if(atalla_dso != NULL)
                {
-               ENGINEerr(ENGINE_F_ATALLA_INIT,ENGINE_R_ALREADY_LOADED);
+               ATALLAerr(ATALLA_F_ATALLA_INIT,ATALLA_R_ALREADY_LOADED);
                goto err;
                }
        /* Attempt to load libatasi.so/atasi.dll/whatever. Needs to be
@@ -263,7 +379,7 @@ static int atalla_init(ENGINE *e)
        atalla_dso = DSO_load(NULL, ATALLA_LIBNAME, NULL, 0);
        if(atalla_dso == NULL)
                {
-               ENGINEerr(ENGINE_F_ATALLA_INIT,ENGINE_R_DSO_FAILURE);
+               ATALLAerr(ATALLA_F_ATALLA_INIT,ATALLA_R_NOT_LOADED);
                goto err;
                }
        if(!(p1 = (tfnASI_GetHardwareConfig *)DSO_bind_func(
@@ -273,7 +389,7 @@ static int atalla_init(ENGINE *e)
                        !(p3 = (tfnASI_GetPerformanceStatistics *)DSO_bind_func(
                                atalla_dso, ATALLA_F3)))
                {
-               ENGINEerr(ENGINE_F_ATALLA_INIT,ENGINE_R_DSO_FAILURE);
+               ATALLAerr(ATALLA_F_ATALLA_INIT,ATALLA_R_NOT_LOADED);
                goto err;
                }
        /* Copy the pointers */
@@ -284,7 +400,7 @@ static int atalla_init(ENGINE *e)
         * running. */
        if(p1(0L, config_buf) != 0)
                {
-               ENGINEerr(ENGINE_F_ATALLA_INIT,ENGINE_R_UNIT_FAILURE);
+               ATALLAerr(ATALLA_F_ATALLA_INIT,ATALLA_R_UNIT_FAILURE);
                goto err;
                }
        /* Everything's fine. */
@@ -302,12 +418,12 @@ static int atalla_finish(ENGINE *e)
        {
        if(atalla_dso == NULL)
                {
-               ENGINEerr(ENGINE_F_ATALLA_FINISH,ENGINE_R_NOT_LOADED);
+               ATALLAerr(ATALLA_F_ATALLA_FINISH,ATALLA_R_NOT_LOADED);
                return 0;
                }
        if(!DSO_free(atalla_dso))
                {
-               ENGINEerr(ENGINE_F_ATALLA_FINISH,ENGINE_R_DSO_FAILURE);
+               ATALLAerr(ATALLA_F_ATALLA_FINISH,ATALLA_R_UNIT_FAILURE);
                return 0;
                }
        atalla_dso = NULL;
@@ -325,12 +441,12 @@ static int atalla_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)())
        case ATALLA_CMD_SO_PATH:
                if(p == NULL)
                        {
-                       ENGINEerr(ENGINE_F_ATALLA_CTRL,ERR_R_PASSED_NULL_PARAMETER);
+                       ATALLAerr(ATALLA_F_ATALLA_CTRL,ERR_R_PASSED_NULL_PARAMETER);
                        return 0;
                        }
                if(initialised)
                        {
-                       ENGINEerr(ENGINE_F_ATALLA_CTRL,ENGINE_R_ALREADY_LOADED);
+                       ATALLAerr(ATALLA_F_ATALLA_CTRL,ATALLA_R_ALREADY_LOADED);
                        return 0;
                        }
                ATALLA_LIBNAME = (const char *)p;
@@ -338,7 +454,7 @@ static int atalla_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)())
        default:
                break;
                }
-       ENGINEerr(ENGINE_F_ATALLA_CTRL,ENGINE_R_CTRL_COMMAND_NOT_IMPLEMENTED);
+       ATALLAerr(ATALLA_F_ATALLA_CTRL,ATALLA_R_CTRL_COMMAND_NOT_IMPLEMENTED);
        return 0;
        }
 
@@ -361,10 +477,10 @@ static int atalla_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
        to_return = 0; /* expect failure */
 
        if(!atalla_dso)
-       {
-               ENGINEerr(ENGINE_F_ATALLA_MOD_EXP,ENGINE_R_NOT_LOADED);
+               {
+               ATALLAerr(ATALLA_F_ATALLA_MOD_EXP,ATALLA_R_NOT_LOADED);
                goto err;
-       }
+               }
        /* Prepare the params */
        BN_CTX_start(ctx);
        modulus = BN_CTX_get(ctx);
@@ -372,16 +488,16 @@ static int atalla_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
        argument = BN_CTX_get(ctx);
        result = BN_CTX_get(ctx);
        if (!result)
-       {
-               ENGINEerr(ENGINE_F_ATALLA_MOD_EXP,ENGINE_R_BN_CTX_FULL);
+               {
+               ATALLAerr(ATALLA_F_ATALLA_MOD_EXP,ATALLA_R_BN_CTX_FULL);
                goto err;
-       }
+               }
        if(!bn_wexpand(modulus, m->top) || !bn_wexpand(exponent, m->top) ||
           !bn_wexpand(argument, m->top) || !bn_wexpand(result, m->top))
-       {
-               ENGINEerr(ENGINE_F_ATALLA_MOD_EXP,ENGINE_R_BN_EXPAND_FAIL);
+               {
+               ATALLAerr(ATALLA_F_ATALLA_MOD_EXP,ATALLA_R_BN_EXPAND_FAIL);
                goto err;
-       }
+               }
        /* Prepare the key-data */
        memset(&keydata, 0,sizeof keydata);
        numbytes = BN_num_bytes(m);
@@ -401,10 +517,10 @@ static int atalla_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
        if(p_Atalla_RSAPrivateKeyOpFn(&keydata, (unsigned char *)result->d,
                        (unsigned char *)argument->d,
                        keydata.modulus.len) != 0)
-       {
-               ENGINEerr(ENGINE_F_ATALLA_MOD_EXP,ENGINE_R_REQUEST_FAILED);
+               {
+               ATALLAerr(ATALLA_F_ATALLA_MOD_EXP,ATALLA_R_REQUEST_FAILED);
                goto err;
-       }
+               }
        /* Convert the response */
        BN_bin2bn((unsigned char *)result->d, numbytes, r);
        to_return = 1;
@@ -413,21 +529,22 @@ err:
        return to_return;
        }
 
+#ifndef OPENSSL_NO_RSA
 static int atalla_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa)
        {
        BN_CTX *ctx = NULL;
        int to_return = 0;
 
        if(!atalla_dso)
-       {
-               ENGINEerr(ENGINE_F_ATALLA_RSA_MOD_EXP,ENGINE_R_NOT_LOADED);
+               {
+               ATALLAerr(ATALLA_F_ATALLA_RSA_MOD_EXP,ATALLA_R_NOT_LOADED);
                goto err;
-       }
+               }
        if((ctx = BN_CTX_new()) == NULL)
                goto err;
        if(!rsa->d || !rsa->n)
                {
-               ENGINEerr(ENGINE_F_ATALLA_RSA_MOD_EXP,ENGINE_R_MISSING_KEY_COMPONENTS);
+               ATALLAerr(ATALLA_F_ATALLA_RSA_MOD_EXP,ATALLA_R_MISSING_KEY_COMPONENTS);
                goto err;
                }
        to_return = atalla_mod_exp(r0, I, rsa->d, rsa->n, ctx);
@@ -436,7 +553,9 @@ err:
                BN_CTX_free(ctx);
        return to_return;
        }
+#endif
 
+#ifndef OPENSSL_NO_DSA
 /* This code was liberated and adapted from the commented-out code in
  * dsa_ossl.c. Because of the unoptimised form of the Atalla acceleration
  * (it doesn't have a CRT form for RSA), this function means that an
@@ -464,13 +583,13 @@ end:
        return to_return;
        }
 
-
 static int atalla_mod_exp_dsa(DSA *dsa, BIGNUM *r, BIGNUM *a,
                const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx,
                BN_MONT_CTX *m_ctx)
        {
        return atalla_mod_exp(r, a, p, m, ctx);
        }
+#endif
 
 /* This function is aliased to mod_exp (with the mont stuff dropped). */
 static int atalla_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
@@ -479,6 +598,7 @@ static int atalla_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
        return atalla_mod_exp(r, a, p, m, ctx);
        }
 
+#ifndef OPENSSL_NO_DH
 /* This function is aliased to mod_exp (with the dh and mont dropped). */
 static int atalla_mod_exp_dh(const DH *dh, BIGNUM *r,
                const BIGNUM *a, const BIGNUM *p,
@@ -486,6 +606,22 @@ static int atalla_mod_exp_dh(const DH *dh, BIGNUM *r,
        {
        return atalla_mod_exp(r, a, p, m, ctx);
        }
+#endif
+
+/* This stuff is needed if this ENGINE is being compiled into a self-contained
+ * shared-library. */
+#ifdef ENGINE_DYNAMIC_SUPPORT
+static int bind_fn(ENGINE *e, const char *id)
+       {
+       if(id && (strcmp(id, engine_atalla_id) != 0))
+               return 0;
+       if(!bind_helper(e))
+               return 0;
+       return 1;
+       }
+IMPLEMENT_DYNAMIC_CHECK_FN()
+IMPLEMENT_DYNAMIC_BIND_FN(bind_fn)
+#endif /* ENGINE_DYNAMIC_SUPPORT */
 
 #endif /* !OPENSSL_NO_HW_ATALLA */
 #endif /* !OPENSSL_NO_HW */