Logo Search packages:      
Sourcecode: openssl version File versions  Download package

e_4758cca.c

/* Author: Maurice Gittens <maurice@gittens.nl>                       */
/* ====================================================================
 * Copyright (c) 1999 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
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer. 
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. All advertising materials mentioning features or use of this
 *    software must display the following acknowledgment:
 *    "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
 *
 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
 *    endorse or promote products derived from this software without
 *    prior written permission. For written permission, please contact
 *    licensing@OpenSSL.org.
 *
 * 5. Products derived from this software may not be called "OpenSSL"
 *    nor may "OpenSSL" appear in their names without prior written
 *    permission of the OpenSSL Project.
 *
 * 6. Redistributions of any form whatsoever must retain the following
 *    acknowledgment:
 *    "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
 *
 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 * ====================================================================
 *
 * This product includes cryptographic software written by Eric Young
 * (eay@cryptsoft.com).  This product includes software written by Tim
 * Hudson (tjh@cryptsoft.com).
 *
 */

#include <stdio.h>
#include <string.h>
#include <openssl/crypto.h>
#include <openssl/dso.h>
#include <openssl/x509.h>
#include <openssl/objects.h>
#include <openssl/engine.h>
#include <openssl/rand.h>
#ifndef OPENSSL_NO_RSA
#include <openssl/rsa.h>
#endif
#include <openssl/bn.h>

#ifndef OPENSSL_NO_HW
#ifndef OPENSSL_NO_HW_4758_CCA

#ifdef FLAT_INC
#include "hw_4758_cca.h"
#else
#include "vendor_defns/hw_4758_cca.h"
#endif

#include "e_4758cca_err.c"

static int ibm_4758_cca_destroy(ENGINE *e);
static int ibm_4758_cca_init(ENGINE *e);
static int ibm_4758_cca_finish(ENGINE *e);
static int ibm_4758_cca_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)(void));

/* rsa functions */
/*---------------*/
#ifndef OPENSSL_NO_RSA
static int cca_rsa_pub_enc(int flen, const unsigned char *from,
            unsigned char *to, RSA *rsa,int padding);
static int cca_rsa_priv_dec(int flen, const unsigned char *from,
            unsigned char *to, RSA *rsa,int padding);
static int cca_rsa_sign(int type, const unsigned char *m, unsigned int m_len,
            unsigned char *sigret, unsigned int *siglen, const RSA *rsa);
static int cca_rsa_verify(int dtype, const unsigned char *m, unsigned int m_len,
            unsigned char *sigbuf, unsigned int siglen, const RSA *rsa);

/* utility functions */
/*-----------------------*/
static EVP_PKEY *ibm_4758_load_privkey(ENGINE*, const char*,
            UI_METHOD *ui_method, void *callback_data);
static EVP_PKEY *ibm_4758_load_pubkey(ENGINE*, const char*,
            UI_METHOD *ui_method, void *callback_data);

static int getModulusAndExponent(const unsigned char *token, long *exponentLength,
            unsigned char *exponent, long *modulusLength,
            long *modulusFieldLength, unsigned char *modulus);
#endif

/* RAND number functions */
/*-----------------------*/
static int cca_get_random_bytes(unsigned char*, int );
static int cca_random_status(void);

#ifndef OPENSSL_NO_RSA
static void cca_ex_free(void *obj, void *item, CRYPTO_EX_DATA *ad,
            int idx,long argl, void *argp);
#endif

/* Function pointers for CCA verbs */
/*---------------------------------*/
#ifndef OPENSSL_NO_RSA
static F_KEYRECORDREAD keyRecordRead;
static F_DIGITALSIGNATUREGENERATE digitalSignatureGenerate;
static F_DIGITALSIGNATUREVERIFY digitalSignatureVerify;
static F_PUBLICKEYEXTRACT publicKeyExtract;
static F_PKAENCRYPT pkaEncrypt;
static F_PKADECRYPT pkaDecrypt;
#endif
static F_RANDOMNUMBERGENERATE randomNumberGenerate;

/* static variables */
/*------------------*/
static const char *CCA4758_LIB_NAME = NULL;
static const char *get_CCA4758_LIB_NAME(void)
      {
      if(CCA4758_LIB_NAME)
            return CCA4758_LIB_NAME;
      return CCA_LIB_NAME;
      }
static void free_CCA4758_LIB_NAME(void)
      {
      if(CCA4758_LIB_NAME)
            OPENSSL_free((void*)CCA4758_LIB_NAME);
      CCA4758_LIB_NAME = NULL;
      }
static long set_CCA4758_LIB_NAME(const char *name)
      {
      free_CCA4758_LIB_NAME();
      return (((CCA4758_LIB_NAME = BUF_strdup(name)) != NULL) ? 1 : 0);
      }
#ifndef OPENSSL_NO_RSA
static const char* n_keyRecordRead = CSNDKRR;
static const char* n_digitalSignatureGenerate = CSNDDSG;
static const char* n_digitalSignatureVerify = CSNDDSV;
static const char* n_publicKeyExtract = CSNDPKX;
static const char* n_pkaEncrypt = CSNDPKE;
static const char* n_pkaDecrypt = CSNDPKD;
#endif
static const char* n_randomNumberGenerate = CSNBRNG;

#ifndef OPENSSL_NO_RSA
static int hndidx = -1;
#endif
static DSO *dso = NULL;

/* openssl engine initialization structures */
/*------------------------------------------*/

#define CCA4758_CMD_SO_PATH         ENGINE_CMD_BASE
static const ENGINE_CMD_DEFN  cca4758_cmd_defns[] = {
      {CCA4758_CMD_SO_PATH,
            "SO_PATH",
            "Specifies the path to the '4758cca' shared library",
            ENGINE_CMD_FLAG_STRING},
      {0, NULL, NULL, 0}
      };

#ifndef OPENSSL_NO_RSA
static RSA_METHOD ibm_4758_cca_rsa =
      {
      "IBM 4758 CCA RSA method",
      cca_rsa_pub_enc,
      NULL,
      NULL,
      cca_rsa_priv_dec,
      NULL, /*rsa_mod_exp,*/
      NULL, /*mod_exp_mont,*/
      NULL, /* init */
      NULL, /* finish */
      RSA_FLAG_SIGN_VER,        /* flags */
      NULL, /* app_data */
      cca_rsa_sign, /* rsa_sign */
      cca_rsa_verify, /* rsa_verify */
      NULL /* rsa_keygen */
      };
#endif

static RAND_METHOD ibm_4758_cca_rand =
      {
      /* "IBM 4758 RAND method", */
      NULL, /* seed */
      cca_get_random_bytes, /* get random bytes from the card */
      NULL, /* cleanup */
      NULL, /* add */
      cca_get_random_bytes, /* pseudo rand */
      cca_random_status, /* status */
      };

static const char *engine_4758_cca_id = "4758cca";
static const char *engine_4758_cca_name = "IBM 4758 CCA hardware engine support";
#ifndef OPENSSL_NO_DYNAMIC_ENGINE 
/* Compatibility hack, the dynamic library uses this form in the path */
static const char *engine_4758_cca_id_alt = "4758_cca";
#endif

/* engine implementation */
/*-----------------------*/
static int bind_helper(ENGINE *e)
      {
      if(!ENGINE_set_id(e, engine_4758_cca_id) ||
                  !ENGINE_set_name(e, engine_4758_cca_name) ||
#ifndef OPENSSL_NO_RSA
                  !ENGINE_set_RSA(e, &ibm_4758_cca_rsa) ||
#endif
                  !ENGINE_set_RAND(e, &ibm_4758_cca_rand) ||
                  !ENGINE_set_destroy_function(e, ibm_4758_cca_destroy) ||
                  !ENGINE_set_init_function(e, ibm_4758_cca_init) ||
                  !ENGINE_set_finish_function(e, ibm_4758_cca_finish) ||
                  !ENGINE_set_ctrl_function(e, ibm_4758_cca_ctrl) ||
#ifndef OPENSSL_NO_RSA
                  !ENGINE_set_load_privkey_function(e, ibm_4758_load_privkey) ||
                  !ENGINE_set_load_pubkey_function(e, ibm_4758_load_pubkey) ||
#endif
                  !ENGINE_set_cmd_defns(e, cca4758_cmd_defns))
            return 0;
      /* Ensure the error handling is set up */
      ERR_load_CCA4758_strings();
      return 1;
      }

#ifdef OPENSSL_NO_DYNAMIC_ENGINE
static ENGINE *engine_4758_cca(void)
      {
      ENGINE *ret = ENGINE_new();
      if(!ret)
            return NULL;
      if(!bind_helper(ret))
            {
            ENGINE_free(ret);
            return NULL;
            }
      return ret;
      }

void ENGINE_load_4758cca(void)
      {
      ENGINE *e_4758 = engine_4758_cca();
      if (!e_4758) return;
      ENGINE_add(e_4758);
      ENGINE_free(e_4758);
      ERR_clear_error();   
      }
#endif

static int ibm_4758_cca_destroy(ENGINE *e)
      {
      ERR_unload_CCA4758_strings();
      free_CCA4758_LIB_NAME();
      return 1;
      }

static int ibm_4758_cca_init(ENGINE *e)
      {
      if(dso)
            {
            CCA4758err(CCA4758_F_IBM_4758_CCA_INIT,CCA4758_R_ALREADY_LOADED);
            goto err;
            }

      dso = DSO_load(NULL, get_CCA4758_LIB_NAME(), NULL, 0);
      if(!dso)
            {
            CCA4758err(CCA4758_F_IBM_4758_CCA_INIT,CCA4758_R_DSO_FAILURE);
            goto err;
            }

#ifndef OPENSSL_NO_RSA
      if(!(keyRecordRead = (F_KEYRECORDREAD)
                        DSO_bind_func(dso, n_keyRecordRead)) ||
                  !(randomNumberGenerate = (F_RANDOMNUMBERGENERATE)
                        DSO_bind_func(dso, n_randomNumberGenerate)) ||
                  !(digitalSignatureGenerate = (F_DIGITALSIGNATUREGENERATE)
                        DSO_bind_func(dso, n_digitalSignatureGenerate)) ||
                  !(digitalSignatureVerify = (F_DIGITALSIGNATUREVERIFY)
                        DSO_bind_func(dso, n_digitalSignatureVerify)) ||
                  !(publicKeyExtract = (F_PUBLICKEYEXTRACT)
                        DSO_bind_func(dso, n_publicKeyExtract)) ||
                  !(pkaEncrypt = (F_PKAENCRYPT)
                        DSO_bind_func(dso, n_pkaEncrypt)) ||
                  !(pkaDecrypt = (F_PKADECRYPT)
                        DSO_bind_func(dso, n_pkaDecrypt)))
            {
            CCA4758err(CCA4758_F_IBM_4758_CCA_INIT,CCA4758_R_DSO_FAILURE);
            goto err;
            }
#else
      if(!(randomNumberGenerate = (F_RANDOMNUMBERGENERATE)
                        DSO_bind_func(dso, n_randomNumberGenerate)))
            {
            CCA4758err(CCA4758_F_IBM_4758_CCA_INIT,CCA4758_R_DSO_FAILURE);
            goto err;
            }
#endif

#ifndef OPENSSL_NO_RSA
      hndidx = RSA_get_ex_new_index(0, "IBM 4758 CCA RSA key handle",
            NULL, NULL, cca_ex_free);
#endif

      return 1;
err:
      if(dso)
            DSO_free(dso);
      dso = NULL;

#ifndef OPENSSL_NO_RSA
      keyRecordRead = (F_KEYRECORDREAD)0;
      digitalSignatureGenerate = (F_DIGITALSIGNATUREGENERATE)0;
      digitalSignatureVerify = (F_DIGITALSIGNATUREVERIFY)0;
      publicKeyExtract = (F_PUBLICKEYEXTRACT)0;
      pkaEncrypt = (F_PKAENCRYPT)0;
      pkaDecrypt = (F_PKADECRYPT)0;
#endif
      randomNumberGenerate = (F_RANDOMNUMBERGENERATE)0;
      return 0;
      }

static int ibm_4758_cca_finish(ENGINE *e)
      {
      free_CCA4758_LIB_NAME();
      if(!dso)
            {
            CCA4758err(CCA4758_F_IBM_4758_CCA_FINISH,
                        CCA4758_R_NOT_LOADED);
            return 0;
            }
      if(!DSO_free(dso))
            {
            CCA4758err(CCA4758_F_IBM_4758_CCA_FINISH,
                        CCA4758_R_UNIT_FAILURE);
            return 0;
            }
      dso = NULL;
#ifndef OPENSSL_NO_RSA
      keyRecordRead = (F_KEYRECORDREAD)0;
      randomNumberGenerate = (F_RANDOMNUMBERGENERATE)0;
      digitalSignatureGenerate = (F_DIGITALSIGNATUREGENERATE)0;
      digitalSignatureVerify = (F_DIGITALSIGNATUREVERIFY)0;
      publicKeyExtract = (F_PUBLICKEYEXTRACT)0;
      pkaEncrypt = (F_PKAENCRYPT)0;
      pkaDecrypt = (F_PKADECRYPT)0;
#endif
      randomNumberGenerate = (F_RANDOMNUMBERGENERATE)0;
      return 1;
      }

static int ibm_4758_cca_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)(void))
      {
      int initialised = ((dso == NULL) ? 0 : 1);
      switch(cmd)
            {
      case CCA4758_CMD_SO_PATH:
            if(p == NULL)
                  {
                  CCA4758err(CCA4758_F_IBM_4758_CCA_CTRL,
                              ERR_R_PASSED_NULL_PARAMETER);
                  return 0;
                  }
            if(initialised)
                  {
                  CCA4758err(CCA4758_F_IBM_4758_CCA_CTRL,
                              CCA4758_R_ALREADY_LOADED);
                  return 0;
                  }
            return set_CCA4758_LIB_NAME((const char *)p);
      default:
            break;
            }
      CCA4758err(CCA4758_F_IBM_4758_CCA_CTRL,
                  CCA4758_R_COMMAND_NOT_IMPLEMENTED);
      return 0;
      }

#ifndef OPENSSL_NO_RSA

#define MAX_CCA_PKA_TOKEN_SIZE 2500

static EVP_PKEY *ibm_4758_load_privkey(ENGINE* e, const char* key_id,
                  UI_METHOD *ui_method, void *callback_data)
      {
      RSA *rtmp = NULL;
      EVP_PKEY *res = NULL;
      unsigned char* keyToken = NULL;
      unsigned char pubKeyToken[MAX_CCA_PKA_TOKEN_SIZE];
      long pubKeyTokenLength = MAX_CCA_PKA_TOKEN_SIZE;
      long keyTokenLength = MAX_CCA_PKA_TOKEN_SIZE;
      long returnCode;
      long reasonCode;
      long exitDataLength = 0;
      long ruleArrayLength = 0;
      unsigned char exitData[8];
      unsigned char ruleArray[8];
      unsigned char keyLabel[64];
      unsigned long keyLabelLength = strlen(key_id);
      unsigned char modulus[256];
      long modulusFieldLength = sizeof(modulus);
      long modulusLength = 0;
      unsigned char exponent[256];
      long exponentLength = sizeof(exponent);

      if (keyLabelLength > sizeof(keyLabel))
            {
            CCA4758err(CCA4758_F_IBM_4758_LOAD_PRIVKEY,
            CCA4758_R_SIZE_TOO_LARGE_OR_TOO_SMALL);
            return NULL;
            }

      memset(keyLabel,' ', sizeof(keyLabel));
      memcpy(keyLabel, key_id, keyLabelLength);

      keyToken = OPENSSL_malloc(MAX_CCA_PKA_TOKEN_SIZE + sizeof(long));
      if (!keyToken)
            {
            CCA4758err(CCA4758_F_IBM_4758_LOAD_PRIVKEY,
                        ERR_R_MALLOC_FAILURE);
            goto err;
            }

      keyRecordRead(&returnCode, &reasonCode, &exitDataLength,
            exitData, &ruleArrayLength, ruleArray, keyLabel,
            &keyTokenLength, keyToken+sizeof(long));

      if (returnCode)
            {
            CCA4758err(CCA4758_F_IBM_4758_LOAD_PRIVKEY,
                  CCA4758_R_FAILED_LOADING_PRIVATE_KEY);
            goto err;
            }

      publicKeyExtract(&returnCode, &reasonCode, &exitDataLength,
            exitData, &ruleArrayLength, ruleArray, &keyTokenLength,
            keyToken+sizeof(long), &pubKeyTokenLength, pubKeyToken);

      if (returnCode)
            {
            CCA4758err(CCA4758_F_IBM_4758_LOAD_PRIVKEY,
                  CCA4758_R_FAILED_LOADING_PRIVATE_KEY);
            goto err;
            }

      if (!getModulusAndExponent(pubKeyToken, &exponentLength,
                  exponent, &modulusLength, &modulusFieldLength,
                  modulus))
            {
            CCA4758err(CCA4758_F_IBM_4758_LOAD_PRIVKEY,
                  CCA4758_R_FAILED_LOADING_PRIVATE_KEY);
            goto err;
            }

      (*(long*)keyToken) = keyTokenLength;
      rtmp = RSA_new_method(e);
      RSA_set_ex_data(rtmp, hndidx, (char *)keyToken);

      rtmp->e = BN_bin2bn(exponent, exponentLength, NULL);
      rtmp->n = BN_bin2bn(modulus, modulusFieldLength, NULL);
      rtmp->flags |= RSA_FLAG_EXT_PKEY;

      res = EVP_PKEY_new();
      EVP_PKEY_assign_RSA(res, rtmp);

      return res;
err:
      if (keyToken)
            OPENSSL_free(keyToken);
      if (res)
            EVP_PKEY_free(res);
      if (rtmp)
            RSA_free(rtmp);
      return NULL;
      }

static EVP_PKEY *ibm_4758_load_pubkey(ENGINE* e, const char* key_id,
                  UI_METHOD *ui_method, void *callback_data)
      {
      RSA *rtmp = NULL;
      EVP_PKEY *res = NULL;
      unsigned char* keyToken = NULL;
      long keyTokenLength = MAX_CCA_PKA_TOKEN_SIZE;
      long returnCode;
      long reasonCode;
      long exitDataLength = 0;
      long ruleArrayLength = 0;
      unsigned char exitData[8];
      unsigned char ruleArray[8];
      unsigned char keyLabel[64];
      unsigned long keyLabelLength = strlen(key_id);
      unsigned char modulus[512];
      long modulusFieldLength = sizeof(modulus);
      long modulusLength = 0;
      unsigned char exponent[512];
      long exponentLength = sizeof(exponent);

      if (keyLabelLength > sizeof(keyLabel))
            {
            CCA4758err(CCA4758_F_IBM_4758_LOAD_PUBKEY,
                  CCA4758_R_SIZE_TOO_LARGE_OR_TOO_SMALL);
            return NULL;
            }

      memset(keyLabel,' ', sizeof(keyLabel));
      memcpy(keyLabel, key_id, keyLabelLength);

      keyToken = OPENSSL_malloc(MAX_CCA_PKA_TOKEN_SIZE + sizeof(long));
      if (!keyToken)
            {
            CCA4758err(CCA4758_F_IBM_4758_LOAD_PUBKEY,
                        ERR_R_MALLOC_FAILURE);
            goto err;
            }

      keyRecordRead(&returnCode, &reasonCode, &exitDataLength, exitData,
            &ruleArrayLength, ruleArray, keyLabel, &keyTokenLength,
            keyToken+sizeof(long));

      if (returnCode)
            {
            CCA4758err(CCA4758_F_IBM_4758_LOAD_PUBKEY,
                        ERR_R_MALLOC_FAILURE);
            goto err;
            }

      if (!getModulusAndExponent(keyToken+sizeof(long), &exponentLength,
                  exponent, &modulusLength, &modulusFieldLength, modulus))
            {
            CCA4758err(CCA4758_F_IBM_4758_LOAD_PUBKEY,
                  CCA4758_R_FAILED_LOADING_PUBLIC_KEY);
            goto err;
            }

      (*(long*)keyToken) = keyTokenLength;
      rtmp = RSA_new_method(e);
      RSA_set_ex_data(rtmp, hndidx, (char *)keyToken);
      rtmp->e = BN_bin2bn(exponent, exponentLength, NULL);
      rtmp->n = BN_bin2bn(modulus, modulusFieldLength, NULL);
      rtmp->flags |= RSA_FLAG_EXT_PKEY;
      res = EVP_PKEY_new();
      EVP_PKEY_assign_RSA(res, rtmp);

      return res;
err:
      if (keyToken)
            OPENSSL_free(keyToken);
      if (res)
            EVP_PKEY_free(res);
      if (rtmp)
            RSA_free(rtmp);
      return NULL;
      }

static int cca_rsa_pub_enc(int flen, const unsigned char *from,
                  unsigned char *to, RSA *rsa,int padding)
      {
      long returnCode;
      long reasonCode;
      long lflen = flen;
      long exitDataLength = 0;
      unsigned char exitData[8];
      long ruleArrayLength = 1;
      unsigned char ruleArray[8] = "PKCS-1.2";
      long dataStructureLength = 0;
      unsigned char dataStructure[8];
      long outputLength = RSA_size(rsa);
      long keyTokenLength;
      unsigned char* keyToken = (unsigned char*)RSA_get_ex_data(rsa, hndidx);

      keyTokenLength = *(long*)keyToken;
      keyToken+=sizeof(long);

      pkaEncrypt(&returnCode, &reasonCode, &exitDataLength, exitData,
            &ruleArrayLength, ruleArray, &lflen, (unsigned char*)from,
            &dataStructureLength, dataStructure, &keyTokenLength,
            keyToken, &outputLength, to);

      if (returnCode || reasonCode)
            return -(returnCode << 16 | reasonCode);
      return outputLength;
      }

static int cca_rsa_priv_dec(int flen, const unsigned char *from,
                  unsigned char *to, RSA *rsa,int padding)
      {
      long returnCode;
      long reasonCode;
      long lflen = flen;
      long exitDataLength = 0;
      unsigned char exitData[8];
      long ruleArrayLength = 1;
      unsigned char ruleArray[8] = "PKCS-1.2";
      long dataStructureLength = 0;
      unsigned char dataStructure[8];
      long outputLength = RSA_size(rsa);
      long keyTokenLength;
      unsigned char* keyToken = (unsigned char*)RSA_get_ex_data(rsa, hndidx);

      keyTokenLength = *(long*)keyToken;
      keyToken+=sizeof(long);

      pkaDecrypt(&returnCode, &reasonCode, &exitDataLength, exitData,
            &ruleArrayLength, ruleArray, &lflen, (unsigned char*)from,
            &dataStructureLength, dataStructure, &keyTokenLength,
            keyToken, &outputLength, to);

      return (returnCode | reasonCode) ? 0 : 1;
      }

#define SSL_SIG_LEN 36

static int cca_rsa_verify(int type, const unsigned char *m, unsigned int m_len,
            unsigned char *sigbuf, unsigned int siglen, const RSA *rsa)
      {
      long returnCode;
      long reasonCode;
      long lsiglen = siglen;
      long exitDataLength = 0;
      unsigned char exitData[8];
      long ruleArrayLength = 1;
      unsigned char ruleArray[8] = "PKCS-1.1";
      long keyTokenLength;
      unsigned char* keyToken = (unsigned char*)RSA_get_ex_data(rsa, hndidx);
      long length = SSL_SIG_LEN;
      long keyLength ;
      unsigned char *hashBuffer = NULL;
      X509_SIG sig;
      ASN1_TYPE parameter;
      X509_ALGOR algorithm;
      ASN1_OCTET_STRING digest;

      keyTokenLength = *(long*)keyToken;
      keyToken+=sizeof(long);

      if (type == NID_md5 || type == NID_sha1)
            {
            sig.algor = &algorithm;
            algorithm.algorithm = OBJ_nid2obj(type);

            if (!algorithm.algorithm)
                  {
                  CCA4758err(CCA4758_F_CCA_RSA_VERIFY,
                        CCA4758_R_UNKNOWN_ALGORITHM_TYPE);
                  return 0;
                  }

            if (!algorithm.algorithm->length)
                  {
                  CCA4758err(CCA4758_F_CCA_RSA_VERIFY,
                        CCA4758_R_ASN1_OID_UNKNOWN_FOR_MD);
                  return 0;
                  }

            parameter.type = V_ASN1_NULL;
            parameter.value.ptr = NULL;
            algorithm.parameter = &parameter;

            sig.digest = &digest;
            sig.digest->data = (unsigned char*)m;
            sig.digest->length = m_len;

            length = i2d_X509_SIG(&sig, NULL);
            }

      keyLength = RSA_size(rsa);

      if (length - RSA_PKCS1_PADDING > keyLength)
            {
            CCA4758err(CCA4758_F_CCA_RSA_VERIFY,
                  CCA4758_R_SIZE_TOO_LARGE_OR_TOO_SMALL);
            return 0;
            }

      switch (type)
            {
            case NID_md5_sha1 :
                  if (m_len != SSL_SIG_LEN)
                        {
                        CCA4758err(CCA4758_F_CCA_RSA_VERIFY,
                        CCA4758_R_SIZE_TOO_LARGE_OR_TOO_SMALL);
                        return 0;
                        }

                  hashBuffer = (unsigned char *)m;
                  length = m_len;
                  break;
            case NID_md5 :
                  {
                  unsigned char *ptr;
                  ptr = hashBuffer = OPENSSL_malloc(
                              (unsigned int)keyLength+1);
                  if (!hashBuffer)
                        {
                        CCA4758err(CCA4758_F_CCA_RSA_VERIFY,
                                    ERR_R_MALLOC_FAILURE);
                        return 0;
                        }

                  i2d_X509_SIG(&sig, &ptr);
                  }
                  break;
            case NID_sha1 :
                  {
                  unsigned char *ptr;
                  ptr = hashBuffer = OPENSSL_malloc(
                              (unsigned int)keyLength+1);
                  if (!hashBuffer)
                        {
                        CCA4758err(CCA4758_F_CCA_RSA_VERIFY,
                                    ERR_R_MALLOC_FAILURE);
                        return 0;
                        }
                  i2d_X509_SIG(&sig, &ptr);
                  }
                  break;
            default:
                  return 0;
            }

      digitalSignatureVerify(&returnCode, &reasonCode, &exitDataLength,
            exitData, &ruleArrayLength, ruleArray, &keyTokenLength,
            keyToken, &length, hashBuffer, &lsiglen, sigbuf);

      if (type == NID_sha1 || type == NID_md5)
            {
            OPENSSL_cleanse(hashBuffer, keyLength+1);
            OPENSSL_free(hashBuffer);
            }

      return ((returnCode || reasonCode) ? 0 : 1);
      }

#define SSL_SIG_LEN 36

static int cca_rsa_sign(int type, const unsigned char *m, unsigned int m_len,
            unsigned char *sigret, unsigned int *siglen, const RSA *rsa)
      {
      long returnCode;
      long reasonCode;
      long exitDataLength = 0;
      unsigned char exitData[8];
      long ruleArrayLength = 1;
      unsigned char ruleArray[8] = "PKCS-1.1";
      long outputLength=256;
      long outputBitLength;
      long keyTokenLength;
      unsigned char *hashBuffer = NULL;
      unsigned char* keyToken = (unsigned char*)RSA_get_ex_data(rsa, hndidx);
      long length = SSL_SIG_LEN;
      long keyLength ;
      X509_SIG sig;
      ASN1_TYPE parameter;
      X509_ALGOR algorithm;
      ASN1_OCTET_STRING digest;

      keyTokenLength = *(long*)keyToken;
      keyToken+=sizeof(long);

      if (type == NID_md5 || type == NID_sha1)
            {
            sig.algor = &algorithm;
            algorithm.algorithm = OBJ_nid2obj(type);

            if (!algorithm.algorithm)
                  {
                  CCA4758err(CCA4758_F_CCA_RSA_SIGN,
                        CCA4758_R_UNKNOWN_ALGORITHM_TYPE);
                  return 0;
                  }

            if (!algorithm.algorithm->length)
                  {
                  CCA4758err(CCA4758_F_CCA_RSA_SIGN,
                        CCA4758_R_ASN1_OID_UNKNOWN_FOR_MD);
                  return 0;
                  }

            parameter.type = V_ASN1_NULL;
            parameter.value.ptr = NULL;
            algorithm.parameter = &parameter;

            sig.digest = &digest;
            sig.digest->data = (unsigned char*)m;
            sig.digest->length = m_len;

            length = i2d_X509_SIG(&sig, NULL);
            }

      keyLength = RSA_size(rsa);

      if (length - RSA_PKCS1_PADDING > keyLength)
            {
            CCA4758err(CCA4758_F_CCA_RSA_SIGN,
                  CCA4758_R_SIZE_TOO_LARGE_OR_TOO_SMALL);
            return 0;
            }

      switch (type)
            {
            case NID_md5_sha1 :
                  if (m_len != SSL_SIG_LEN)
                        {
                        CCA4758err(CCA4758_F_CCA_RSA_SIGN,
                        CCA4758_R_SIZE_TOO_LARGE_OR_TOO_SMALL);
                        return 0;
                        }
                  hashBuffer = (unsigned char*)m;
                  length = m_len;
                  break;
            case NID_md5 :
                  {
                  unsigned char *ptr;
                  ptr = hashBuffer = OPENSSL_malloc(
                              (unsigned int)keyLength+1);
                  if (!hashBuffer)
                        {
                        CCA4758err(CCA4758_F_CCA_RSA_SIGN,
                                    ERR_R_MALLOC_FAILURE);
                        return 0;
                        }
                  i2d_X509_SIG(&sig, &ptr);
                  }
                  break;
            case NID_sha1 :
                  {
                  unsigned char *ptr;
                  ptr = hashBuffer = OPENSSL_malloc(
                              (unsigned int)keyLength+1);
                  if (!hashBuffer)
                        {
                        CCA4758err(CCA4758_F_CCA_RSA_SIGN,
                                    ERR_R_MALLOC_FAILURE);
                        return 0;
                        }
                  i2d_X509_SIG(&sig, &ptr);
                  }
                  break;
            default:
                  return 0;
            }

      digitalSignatureGenerate(&returnCode, &reasonCode, &exitDataLength,
            exitData, &ruleArrayLength, ruleArray, &keyTokenLength,
            keyToken, &length, hashBuffer, &outputLength, &outputBitLength,
            sigret);

      if (type == NID_sha1 || type == NID_md5)
            {
            OPENSSL_cleanse(hashBuffer, keyLength+1);
            OPENSSL_free(hashBuffer);
            }

      *siglen = outputLength;

      return ((returnCode || reasonCode) ? 0 : 1);
      }

static int getModulusAndExponent(const unsigned char*token, long *exponentLength,
            unsigned char *exponent, long *modulusLength, long *modulusFieldLength,
            unsigned char *modulus)
      {
      unsigned long len;

      if (*token++ != (char)0x1E) /* internal PKA token? */
            return 0;

      if (*token++) /* token version must be zero */
            return 0;

      len = *token++;
      len = len << 8;
      len |= (unsigned char)*token++;

      token += 4; /* skip reserved bytes */

      if (*token++ == (char)0x04)
            {
            if (*token++) /* token version must be zero */
                  return 0;

            len = *token++;
            len = len << 8;
            len |= (unsigned char)*token++;

            token+=2; /* skip reserved section */

            len = *token++;
            len = len << 8;
            len |= (unsigned char)*token++;

            *exponentLength = len;

            len = *token++;
            len = len << 8;
            len |= (unsigned char)*token++;

            *modulusLength = len;

            len = *token++;
            len = len << 8;
            len |= (unsigned char)*token++;

            *modulusFieldLength = len;

            memcpy(exponent, token, *exponentLength);
            token+= *exponentLength;

            memcpy(modulus, token, *modulusFieldLength);
            return 1;
            }
      return 0;
      }

#endif /* OPENSSL_NO_RSA */

static int cca_random_status(void)
      {
      return 1;
      }

static int cca_get_random_bytes(unsigned char* buf, int num)
      {
      long ret_code;
      long reason_code;
      long exit_data_length;
      unsigned char exit_data[4];
      unsigned char form[] = "RANDOM  ";
      unsigned char rand_buf[8];

      while(num >= (int)sizeof(rand_buf))
            {
            randomNumberGenerate(&ret_code, &reason_code, &exit_data_length,
                  exit_data, form, rand_buf);
            if (ret_code)
                  return 0;
            num -= sizeof(rand_buf);
            memcpy(buf, rand_buf, sizeof(rand_buf));
            buf += sizeof(rand_buf);
            }

      if (num)
            {
            randomNumberGenerate(&ret_code, &reason_code, NULL, NULL,
                  form, rand_buf);
            if (ret_code)
                  return 0;
            memcpy(buf, rand_buf, num);
            }

      return 1;
      }

#ifndef OPENSSL_NO_RSA
static void cca_ex_free(void *obj, void *item, CRYPTO_EX_DATA *ad, int idx,
            long argl, void *argp)
      {
      if (item)
            OPENSSL_free(item);
      }
#endif

/* Goo to handle building as a dynamic engine */
#ifndef OPENSSL_NO_DYNAMIC_ENGINE 
static int bind_fn(ENGINE *e, const char *id)
      {
      if(id && (strcmp(id, engine_4758_cca_id) != 0) &&
                  (strcmp(id, engine_4758_cca_id_alt) != 0))
            return 0;
      if(!bind_helper(e))
            return 0;
      return 1;
      }       
IMPLEMENT_DYNAMIC_CHECK_FN()
IMPLEMENT_DYNAMIC_BIND_FN(bind_fn)
#endif /* OPENSSL_NO_DYNAMIC_ENGINE */

#endif /* !OPENSSL_NO_HW_4758_CCA */
#endif /* !OPENSSL_NO_HW */

Generated by  Doxygen 1.6.0   Back to index