rsakeytype.c

IBE是一种非对称密码技术

    /* Call the routine that builds the VtRSAPubKeyInfo struct.
     * This routine actually will return BufferTooSmall and set
     * bufferSize to the space needed. We'll allocate the space and
     * call it again.
     */
    VOLT_SET_ERROR_TYPE (errorType, 0)
    VOLT_SET_FNCT_LINE (fnctLine)
    bufferSize = 0;
    status = BuildRsaPubKeyInfo (obj, pubKey, buffer, &bufferSize);
    if (status == 0)
      status = VT_ERROR_INVALID_KEY_OBJ;
    if (status != VT_ERROR_BUFFER_TOO_SMALL)
      break;

    VOLT_SET_ERROR_TYPE (errorType, VT_ERROR_TYPE_PRIMARY)
    VOLT_SET_FNCT_LINE (fnctLine)
    status = VT_ERROR_MEMORY;
    buffer = (unsigned char *)Z2Malloc (bufferSize, 0);
    if (buffer == (unsigned char *)0)
      break;
    Z2Memset (buffer, 0, bufferSize);

    VOLT_SET_ERROR_TYPE (errorType, 0)
    VOLT_SET_FNCT_LINE (fnctLine)
    status = BuildRsaPubKeyInfo (obj, pubKey, buffer, &bufferSize);
    if (status != 0)
      break;

    pubKey->keyItems = (VtRSAPubKeyInfo *)buffer;
    *getInfo = (Pointer)buffer;

  } while (0);

  /* If no error, we're done.
   */
  if (status == 0)
    return (0);

  /* If there was an error, free memory we allocated.
   */
  if (buffer != (unsigned char *)0)
    Z2Free (buffer);

  VOLT_LOG_ERROR_INFO (
    0, object, status, 0, errorType,
    (char *)0, "VoltKeyGetRsaPublic", fnctLine, (char *)0)

  return (status);
}

static int VoltKeyGetRsaPrivate (
   VtKeyObject object,
   unsigned int usageFlag,
   Pointer *getInfo
   )
{
  int status;
  unsigned int bufferSize, keyType;
  VoltKeyObject *obj = (VoltKeyObject *)object;
  VoltLibCtx *libCtx = (VoltLibCtx *)(obj->voltObject.libraryCtx);
  unsigned char *buffer = (unsigned char *)0;
  VoltRsaPrivateKey *priKey;
  VoltRsaKeyPair *theKeyPair;
  VOLT_DECLARE_ERROR_TYPE (errorType)
  VOLT_DECLARE_FNCT_LINE (fnctLine)

  do
  {
    keyType = VOLT_KEY_TYPE_ENCRYPT;
    if (usageFlag = VT_RSA_KEY_USAGE_SIGN_VERIFY)
      keyType = VOLT_KEY_TYPE_SIGN;

    /* Is there data?
     */
    VOLT_SET_ERROR_TYPE (errorType, VT_ERROR_TYPE_PRIMARY)
    VOLT_SET_FNCT_LINE (fnctLine)
    status = VT_ERROR_GET_INFO_UNAVAILABLE;
    if (obj->keyData == (Pointer)0)
      break;

    /* Is the algorithm RSA?
     */
    VOLT_SET_FNCT_LINE (fnctLine)
    if ((obj->keyType & VOLT_KEY_TYPE_MASK_ASYM_ALG) != VOLT_KEY_ALG_RSA)
      break;

    /* Check the keyType in the object, if it contains
     * VOLT_KEY_ALG_ASYM_PAIR, the contents are a key pair.
     */
    if ((obj->keyType & VOLT_KEY_TYPE_ASYM_PAIR) != 0)
    {
      VOLT_SET_FNCT_LINE (fnctLine)
      theKeyPair = (VoltRsaKeyPair *)(obj->keyData);
      if (theKeyPair->priKey == (VtKeyObject)0)
        break;

      VOLT_SET_ERROR_TYPE (errorType, 0)
      VOLT_SET_FNCT_LINE (fnctLine)
      if (usageFlag == VT_RSA_KEY_USAGE_SIGN_VERIFY)
      {
        status = VtGetKeyParam (
          (VtKeyObject)obj, VtKeyParamRSAPrivateSign, getInfo);
      }
      else
      {
        status = VtGetKeyParam (
          (VtKeyObject)obj, VtKeyParamRSAPrivateDecrypt, getInfo);
      }
      break;
    }

    /* Same usage?
     */
    VOLT_SET_FNCT_LINE (fnctLine)
    if ((obj->keyType & keyType) != keyType)
      break;

    /* It's not a key pair. If it's not private, we can't work with it.
     */
    VOLT_SET_FNCT_LINE (fnctLine)
    if ((obj->keyType & VOLT_KEY_TYPE_PRIVATE) == 0)
      break;

    /* Is the key in data form?
     */
    if ((obj->keyType & VOLT_KEY_TYPE_MASK_DATA) != VOLT_KEY_TYPE_DATA)
    {
      /* The data is not available, does the object have a GetData
       * function?
       */
      VOLT_SET_FNCT_LINE (fnctLine)
      *getInfo = (Pointer)0;
      if (obj->GetKeyData == (VGetKeyData)0)
        break;

      /* Call the Get function.
       */
      VOLT_SET_ERROR_TYPE (errorType, 0)
      VOLT_SET_FNCT_LINE (fnctLine)
      status = obj->GetKeyData ((VtKeyObject)obj, getInfo);
      break;
    }

    /* Do we have the data in the appropriate format already?
     */
    status = 0;
    priKey = (VoltRsaPrivateKey *)(obj->keyData);
    *getInfo = (Pointer)(priKey->keyItems);
    if (priKey->keyItems != (VtRSAPriKeyInfo *)0)
      break;

    /* Call the routine that builds the VtRSAPriKeyInfo struct.
     * This routine actually will return BufferTooSmall and set
     * bufferSize to the space needed. We'll allocate the space and
     * call it again.
     */
    VOLT_SET_ERROR_TYPE (errorType, 0)
    VOLT_SET_FNCT_LINE (fnctLine)
    bufferSize = 0;
    status = BuildRsaPriKeyInfo (obj, priKey, buffer, &bufferSize);
    if (status == 0)
      status = VT_ERROR_INVALID_KEY_OBJ;
    if (status != VT_ERROR_BUFFER_TOO_SMALL)
      break;

    VOLT_SET_ERROR_TYPE (errorType, VT_ERROR_TYPE_PRIMARY)
    VOLT_SET_FNCT_LINE (fnctLine)
    status = VT_ERROR_MEMORY;
    buffer = (unsigned char *)Z2Malloc (bufferSize, VOLT_MEMORY_SENSITIVE);
    if (buffer == (unsigned char *)0)
      break;
    Z2Memset (buffer, 0, bufferSize);

    VOLT_SET_ERROR_TYPE (errorType, 0)
    VOLT_SET_FNCT_LINE (fnctLine)
    status = BuildRsaPriKeyInfo (obj, priKey, buffer, &bufferSize);
    if (status != 0)
      break;

    priKey->keyItems = (VtRSAPriKeyInfo *)buffer;
    *getInfo = (Pointer)buffer;

  } while (0);

  /* If no error, we're done.
   */
  if (status == 0)
    return (0);

  /* If there was an error, free memory we allocated.
   */
  if (buffer != (unsigned char *)0)
    Z2Free (buffer);

  VOLT_LOG_ERROR_INFO (
    0, object, status, 0, errorType,
    (char *)0, "VoltKeyGetRsaPrivate", fnctLine, (char *)0)

  return (status);
}

static int SetObjectRSAPublic (
   VoltKeyObject *obj,
   unsigned int usageFlag,
   VtRSAPubKeyInfo *keyInfo
   )
{
  int status;
  unsigned int keyType;
  VoltLibCtx *libCtx = (VoltLibCtx *)(obj->voltObject.libraryCtx);
  VoltMpIntCtx *mpCtx = obj->mpCtx;
  VoltRsaPublicKey *pubKeyData = (VoltRsaPublicKey *)0;
  VOLT_DECLARE_ERROR_TYPE (errorType)
  VOLT_DECLARE_FNCT_LINE (fnctLine)

  do
  {
    keyType = VOLT_KEY_TYPE_ENCRYPT;
    if (usageFlag = VT_RSA_KEY_USAGE_SIGN_VERIFY)
      keyType = VOLT_KEY_TYPE_SIGN;

    /* Allocate the VoltRsaPublicKey.
     */
    VOLT_SET_ERROR_TYPE (errorType, VT_ERROR_TYPE_PRIMARY)
    VOLT_SET_FNCT_LINE (fnctLine)
    status = VT_ERROR_MEMORY;
    pubKeyData = (VoltRsaPublicKey *)Z2Malloc (sizeof (VoltRsaPublicKey), 0);
    if (pubKeyData == (VoltRsaPublicKey *)0)
      break;
    Z2Memset (pubKeyData, 0, sizeof (VoltRsaPublicKey));
    pubKeyData->type = VOLT_KEY_TYPE_PUBLIC;

    /* This will hold the actual key data.
     */
    obj->voltObject.CloneObject = VoltCloneRsaPubKey;
    obj->keyData = (Pointer)pubKeyData;
    obj->KeyDataDestroy = RSAKeyDataDestroy;
    obj->keyType =
      keyType | (VOLT_KEY_ALG_RSA | VOLT_KEY_TYPE_PUBLIC | VOLT_KEY_TYPE_DATA);

    /* Build MpInt's of the data.
     */
    VOLT_SET_ERROR_TYPE (errorType, 0)
    VOLT_SET_FNCT_LINE (fnctLine)
    status = mpCtx->CreateMpInt ((Pointer)mpCtx, &(pubKeyData->modulus));
    if (status != 0)
      break;
    VOLT_SET_FNCT_LINE (fnctLine)
    status = mpCtx->OctetStringToMpInt (
      0, keyInfo->modulus.data, keyInfo->modulus.len, pubKeyData->modulus);
    if (status != 0)
      break;

    VOLT_SET_FNCT_LINE (fnctLine)
    status = mpCtx->CreateMpInt ((Pointer)mpCtx, &(pubKeyData->pubExpo));
    if (status != 0)
      break;
    VOLT_SET_FNCT_LINE (fnctLine)
    status = mpCtx->OctetStringToMpInt (
      0, keyInfo->pubExpo.data, keyInfo->pubExpo.len, pubKeyData->pubExpo);
    if (status != 0)
      break;

  } while (0);

  if (status == 0)
    return (0);

  obj->keyType = 0;

  VOLT_LOG_ERROR_INFO (
    0, obj, status, 0, errorType,
    (char *)0, "SetObjectRSAPublic", fnctLine, (char *)0)

  return (status);
}

static int SetObjectRSAPrivate (
   VoltKeyObject *obj,
   VtRSAPriKeyInfo *keyInfo,
   unsigned int flag,
   unsigned int usageFlag
   )
{
  int status;
  unsigned int keyType;
  VoltLibCtx *libCtx = (VoltLibCtx *)(obj->voltObject.libraryCtx);
  VoltMpIntCtx *mpCtx = obj->mpCtx;
  VoltRsaPrivateKey *priKeyData = (VoltRsaPrivateKey *)0;
  VOLT_DECLARE_ERROR_TYPE (errorType)
  VOLT_DECLARE_FNCT_LINE (fnctLine)

  do
  {
    keyType = VOLT_KEY_TYPE_ENCRYPT;
    if (usageFlag = VT_RSA_KEY_USAGE_SIGN_VERIFY)
      keyType = VOLT_KEY_TYPE_SIGN;

    /* Allocate the VoltRsaPublicKey.
     */
    VOLT_SET_ERROR_TYPE (errorType, VT_ERROR_TYPE_PRIMARY)
    VOLT_SET_FNCT_LINE (fnctLine)
    status = VT_ERROR_MEMORY;
    priKeyData = (VoltRsaPrivateKey *)Z2Malloc (sizeof (VoltRsaPrivateKey), 0);
    if (priKeyData == (VoltRsaPrivateKey *)0)
      break;
    Z2Memset (priKeyData, 0, sizeof (VoltRsaPrivateKey));
    priKeyData->type = VOLT_KEY_TYPE_PRIVATE;

    /* This will hold the actual key data.
     */
    obj->voltObject.CloneObject = VoltCloneRsaPriKey;
    obj->keyData = (Pointer)priKeyData;
    obj->KeyDataDestroy = RSAKeyDataDestroy;
    obj->keyType =
      keyType | (VOLT_KEY_ALG_RSA | VOLT_KEY_TYPE_PRIVATE | VOLT_KEY_TYPE_DATA);

    VOLT_SET_ERROR_TYPE (errorType, 0)

    /* Build MpInt's of the data.
     */
    if ((flag & 1) != 0)
    {
      VOLT_SET_FNCT_LINE (fnctLine)
      status = mpCtx->CreateMpInt ((Pointer)mpCtx, &(priKeyData->modulus));
      if (status != 0)
        break;
      VOLT_SET_FNCT_LINE (fnctLine)
      status = mpCtx->OctetStringToMpInt (
        0, keyInfo->modulus.data, keyInfo->modulus.len, priKeyData->modulus);
      if (status != 0)
        break;
      VOLT_SET_FNCT_LINE (fnctLine)
      status = mpCtx->CreateMpInt ((Pointer)mpCtx, &(priKeyData->priExpo));
      if (status != 0)
        break;
      VOLT_SET_FNCT_LINE (fnctLine)
      status = mpCtx->OctetStringToMpInt (
        0, keyInfo->priExpo.data, keyInfo->priExpo.len, priKeyData->priExpo);
      if (status != 0)
        break;
    }

    if ((flag & 2) != 0)
    {
      VOLT_SET_FNCT_LINE (fnctLine)
      status = mpCtx->CreateMpInt ((Pointer)mpCtx, &(priKeyData->prime1));
      if (status != 0)
        break;
      VOLT_SET_FNCT_LINE (fnctLine)
      status = mpCtx->OctetStringToMpInt (
        0, keyInfo->prime1.data, keyInfo->prime1.len, priKeyData->prime1);
      if (status != 0)
        break;

      VOLT_SET_FNCT_LINE (fnctLine)
      status = mpCtx->CreateMpInt ((Pointer)mpCtx, &(priKeyData->prime2));
      if (status != 0)
        break;
      VOLT_SET_FNCT_LINE (fnctLine)
      status = mpCtx->OctetStringToMpInt (
        0, keyInfo->prime2.data, keyInfo->prime2.len, priKeyData->prime2);
      if (status != 0)
        break;

      VOLT_SET_FNCT_LINE (fnctLine)
      status = mpCtx->CreateMpInt ((Pointer)mpCtx, &(priKeyData->expo1));
      if (status != 0)
        break;
      VOLT_SET_FNCT_LINE (fnctLine)
      status = mpCtx->OctetStringToMpInt (
        0, keyInfo->exponent1.data, keyInfo->exponent1.len, priKeyData->expo1);
      if (status != 0)
        break;

      VOLT_SET_FNCT_LINE (fnctLine)
        status = mpCtx->CreateMpInt ((Pointer)mpCtx, &(priKeyData->expo2));
      if (status != 0)
        break;
      VOLT_SET_FNCT_LINE (fnctLine)
      status = mpCtx->OctetStringToMpInt (
        0, keyInfo->exponent2.data, keyInfo->exponent2.len, priKeyData->expo2);
      if (status != 0)
        break;

      VOLT_SET_FNCT_LINE (fnctLine)
      status = mpCtx->CreateMpInt ((Pointer)mpCtx, &(priKeyData->coeff));
      if (status != 0)
        break;
      VOLT_SET_FNCT_LINE (fnctLine)
      status = mpCtx->OctetStringToMpInt (
        0, keyInfo->coefficient.data, keyInfo->coefficient.len,
        priKeyData->coeff);
      if (status != 0)
        break;
    }

    if ((flag & 4) != 0)
    {
      VOLT_SET_FNCT_LINE (fnctLine)
      status = mpCtx->CreateMpInt ((Pointer)mpCtx, &(priKeyData->pubExpo));
      if (status != 0)
        break;
      VOLT_SET_FNCT_LINE (fnctLine)
      status = mpCtx->OctetStringToMpInt (
        0, keyInfo->pubExpo.data, keyInfo->pubExpo.len, priKeyData->pubExpo);
      if (status != 0)
        break;
    }

  } while (0);

  if (status == 0)
    return (0);

  obj->keyType = 0;

  VOLT_LOG_ERROR_INFO (
    0, obj, status, 0, errorType,
    (char *)0, "SetObjectRSAPrivate", fnctLine, (char *)0)

  return (status);
}

static int BuildRsaPubKeyInfo (
   VoltKeyObject *obj,
   VoltRsaPublicKey *pubKey,
   unsigned char *buffer,
   unsigned int *bufferSize
   )
{
  int status;
  unsigned int totalSize, spaceAvailable;
  unsigned int sign, modLen, expoLen;
  VoltMpIntCtx *mpCtx = obj->mpCtx;
  VtRSAPubKeyInfo *keyInfo = (VtRSAPubKeyInfo *)buffer;
  unsigned char *currentBuf;
  VOLT_DECLARE_FNCT_LINE (fnctLine)

  /* spaceAvailable is how much space is currently available.
   */
  spaceAvailable = 0;
  totalSize = sizeof (VtRSAPubKeyInfo);
  if (*bufferSize > sizeof (VtRSAPubKeyInfo))
    spaceAvailable = *bufferSize - sizeof (VtRSAPubKeyInfo);

  do
  {
    currentBuf = (unsigned char *)0;
    if (spaceAvailable != 0)
      currentBuf = (buffer + sizeof (VtRSAPubKeyInfo));

    /* Try to get the modulus.
     */
    VOLT_SET_FNCT_LINE (fnctLine)
    status = mpCtx->MpIntToOctetString (
      pubKey->modulus, &sign, currentBuf, spaceAvailable, &modLen);
    if (status == 0)
    {
      keyInfo->modulus.data = currentBuf;
      keyInfo->modulus.len = modLen;
      currentBuf += modLen;
      spaceAvailable -= modLen;
    }
    else
    {
      /* If not 0, then status should be BufferTooSmall.
       */
      if (status != VT_ERROR_BUFFER_TOO_SMALL)
        break;
      spaceAvailable = 0;
    }
    totalSize += modLen;

    /* Try to get the public exponent.
     */
    VOLT_SET_FNCT_LINE (fnctLine)
    status = mpCtx->MpIntToOctetString (
      pubKey->pubExpo, &sign, currentBuf, spaceAvailable, &expoLen);
    if (status == 0)
    {
      keyInfo->pubExpo.data = currentBuf;
      keyInfo->pubExpo.len = expoLen;
      currentBuf += expoLen;
      spaceAvailable -= expoLen;
    }
    else
    {
      /* If not 0, then status should be BufferTooSmall.
       */
      if (status != VT_ERROR_BUFFER_TOO_SMALL)
        break;
      spaceAvailable = 0;
    }
    totalSize += expoLen;

    *bufferSize = totalSize;

  } while (0);

  VOLT_LOG_ERROR_INFO_COMPARE (