opensslbntype.c

IBE是一种非对称密码技术

/* Copyright 2003-2006, Voltage Security, all rights reserved.
 */
#include "vibe.h"
#include "vibecrypto.h"
#include "environment.h"
#include "base.h"
#include "libctx.h"
#include "mpint.h"
#include "opensslbnwrap.h"
#include "errorctx.h"
#include "openssl/bn.h"

typedef struct ThreadLocalBNContextInfo
{
  struct ThreadLocalBNContextInfo*  next;
  VtLibCtx                          libCtx;
  Pointer                           threadLocalKey;
  int                               refCount;
} ThreadLocalBNContextInfo;

static ThreadLocalBNContextInfo*    gBNContextInfoList;

int VOLT_CALLING_CONV DeleteThreadLocalBNCtx (
  VoltThreadCtx *threadCtx,
  Pointer threadLocalData
)
{
  if (threadLocalData != (Pointer)0)
  {
    BN_CTX_free((BN_CTX*)threadLocalData);
  }
  
  return 0;
}

int VtMpIntImplOpenSSL (
   VtMpIntCtx *mpCtx,
   Pointer info,
   unsigned int flag
   )
{
  int status, status2;
  VoltMpIntCtx *ctx = (VoltMpIntCtx *)(*mpCtx);
  VtLibCtx libCtx;
  VoltThreadCtx* threadCtx;
  Pointer toolkitLock;
  ThreadLocalBNContextInfo* contextInfo;
  int acquiredLock = 0;
  //BN_CTX *bnCtx = (BN_CTX *)0;
  VOLT_DECLARE_FNCT_LINE (fnctLine)
  VOLT_DECLARE_ERROR_TYPE (errorType)

  do
  {
    VOLT_SET_ERROR_TYPE(errorType, VT_ERROR_TYPE_PRIMARY)
    
    /* Check the flag, it should be VOLT_MP_CTX_SET_TYPE_FLAG.
     */
    VOLT_SET_FNCT_LINE (fnctLine)
    status = VT_ERROR_INVALID_TYPE;
    if (flag != VOLT_MP_CTX_SET_TYPE_FLAG)
      break;

    /* The associated info should be NULL pointer.
     */
    VOLT_SET_FNCT_LINE (fnctLine)
    status = VT_ERROR_INVALID_ASSOCIATED_INFO;
    if (info != (Pointer)0)
      break;

    libCtx = ctx->voltObject.libraryCtx;
    threadCtx = libCtx->threadCtx;
    
    VOLT_SET_ERROR_TYPE(errorType, 0)

    VOLT_SET_FNCT_LINE (fnctLine)
    status = threadCtx->GetToolkitLock(threadCtx, &toolkitLock);
    if (status != 0)
      break;
      
    VOLT_SET_FNCT_LINE (fnctLine)
    status = threadCtx->AcquireLock(threadCtx, toolkitLock);
    if (status != 0)
      break;
    
    acquiredLock = 1;
    
    /* First search through list to see if there's already a
     * thread-local variable for this library context
     */
    contextInfo = gBNContextInfoList;
    while (contextInfo != (ThreadLocalBNContextInfo*)0)
    {
      if (contextInfo->libCtx == libCtx)
        break;
      contextInfo = contextInfo->next;
    }
  
    /* Create a new info entry if necessary */
    if (contextInfo == (ThreadLocalBNContextInfo*)0)
    {
      VOLT_SET_FNCT_LINE (fnctLine)
      contextInfo = (ThreadLocalBNContextInfo*)
        Z3Malloc(sizeof(ThreadLocalBNContextInfo));
      if (contextInfo == (ThreadLocalBNContextInfo*)0)
      {
        VOLT_SET_ERROR_TYPE(errorType, VT_ERROR_TYPE_PRIMARY)
        status = VT_ERROR_MEMORY;
        break;
      }
      
      Z2Memset(contextInfo, 0, sizeof(ThreadLocalBNContextInfo));

      contextInfo->libCtx = libCtx;
      
      /* Create the thread-local key. We do this per-libCtx,
       * because the thread-local key is associated with a
       * particular library context and cannot, in general,
       * be shared safely across multiple contexts.
       */
      VOLT_SET_FNCT_LINE(fnctLine)
      status = threadCtx->CreateThreadLocalKey(threadCtx,
        DeleteThreadLocalBNCtx, &contextInfo->threadLocalKey);
      if (status != 0)
        break;
      
      /* Link it into the BN context info list */
      contextInfo->next = gBNContextInfoList;
      gBNContextInfoList = contextInfo;
    }
    
    contextInfo->refCount++;

    #if 0
    status = VT_ERROR_MEMORY;
    bnCtx = BN_CTX_new ();
    if (bnCtx == (BN_CTX *)0)
      break;
    #endif
    
    /* Set the fields of the mpCtx.
     */
    ctx->MpIntImpl = VtMpIntImplOpenSSL;
    ctx->CreateMpInt = OpenSSLBnWrapCreateMpInt;
    ctx->DestroyMpInt = OpenSSLBnWrapDestroyMpInt;
    ctx->OctetStringToMpInt = OpenSSLBnWrapOctetStringToMpInt;
    ctx->IntToMpInt = OpenSSLBnWrapIntToMpInt;
    ctx->MpIntToMpInt = OpenSSLBnWrapMpIntToMpInt;
    ctx->MpIntToOctetString = OpenSSLBnWrapMpIntToOctetString;
    ctx->MpIntToInt = OpenSSLBnWrapMpIntToInt;
    ctx->Compare = OpenSSLBnWrapCompare;
    ctx->EvenOddZeroPositiveNegative =
      OpenSSLBnWrapEvenOddZeroPositiveNegative;
    ctx->GetBitLength = OpenSSLBnWrapGetBitLength;
    ctx->SetBit = OpenSSLBnWrapSetBit;
    ctx->GetBit = OpenSSLBnWrapGetBit;
    ctx->ShiftLeftBits = OpenSSLBnWrapShiftLeftBits;
    ctx->ShiftRightBits = OpenSSLBnWrapShiftRightBits;
    ctx->Add = OpenSSLBnWrapAdd;
    ctx->Subtract = OpenSSLBnWrapSubtract;
    ctx->Multiply = OpenSSLBnWrapMultiply;
    ctx->Square = OpenSSLBnWrapSquare;
    ctx->Divide = OpenSSLBnWrapDivide;
    ctx->GCD = OpenSSLBnWrapGCD;
    ctx->ModReduce = OpenSSLBnWrapModReduce;
    ctx->ModInvert = OpenSSLBnWrapModInvert;
    ctx->ModExp = OpenSSLBnWrapModExp;
    /* OpenSSL does not supply a CRT function, use the Volt version.
     */
    ctx->ModExpCRT = VoltModExpCRT;
    /* This implementation has no GeneratePrime.
     */

    ctx->localCtx = contextInfo->threadLocalKey;
    ctx->LocalCtxDestroy = OpenSSLBnWrapLocalCtxDestroy;

    status = 0;

  } while (0);

  if (acquiredLock)
  {
    status2 = threadCtx->ReleaseLock(threadCtx, toolkitLock);
  }
  
  VOLT_LOG_ERROR_COMPARE (
    status, libCtx, status, errorType,
    fnctLine, "VtMpIntImplOpenSSL", (char *)0)

  return (status);
}

void OpenSSLBnWrapLocalCtxDestroy (
   Pointer obj,
   Pointer ctx
   )
{
  int status;
  VtMpIntCtx mpCtx;
  VtLibCtx libCtx;
  VoltThreadCtx* threadCtx;
  Pointer toolkitLock;
  ThreadLocalBNContextInfo* contextInfo;
  ThreadLocalBNContextInfo* previousContextInfo;
  
  /* Anything to destroy?
   */
  if ( (obj == (Pointer)0) || (ctx == (Pointer)0) )
    return;

  mpCtx = (VtMpIntCtx) obj;
  
  libCtx = mpCtx->voltObject.libraryCtx;
  threadCtx = libCtx->threadCtx;
  
  status = threadCtx->GetToolkitLock(threadCtx, &toolkitLock);
  status = threadCtx->AcquireLock(threadCtx, toolkitLock);
  
  contextInfo = gBNContextInfoList;
  previousContextInfo = (ThreadLocalBNContextInfo*)0;
  while (contextInfo != (ThreadLocalBNContextInfo*)0)
  {
    if (contextInfo->libCtx == libCtx)
    {
      contextInfo->refCount--;
      if (contextInfo->refCount == 0)
      {
        status = threadCtx->DestroyThreadLocalKey(threadCtx,
          &contextInfo->threadLocalKey);
        if (previousContextInfo == (ThreadLocalBNContextInfo*)0)
          gBNContextInfoList = contextInfo->next;
        else
          previousContextInfo->next = contextInfo->next;
        Z2Free(contextInfo);
      }
      break;
    }
    previousContextInfo = contextInfo;
    contextInfo = contextInfo->next;
  }
  
  status = threadCtx->ReleaseLock(threadCtx, toolkitLock);
  //BN_CTX_free ((BN_CTX *)ctx);
}