asn1types.c

IBE是一种非对称密码技术

  return (1);
}


int Asn1EcPointNew (
   ASN1_VALUE **obj,
   const ASN1_ITEM *asn1Item
   )
{
  Asn1EcPoint *retVal = (Asn1EcPoint *)0;

  if (obj == (ASN1_VALUE **)0)
    return (0);
  *obj = (ASN1_VALUE *)0;

  /* Build an empty Asn1EcPoint struct.
   */
  retVal = (Asn1EcPoint *)OPENSSL_malloc (sizeof (Asn1EcPoint));
  if (retVal == (Asn1EcPoint *)0)
    return (0);

  retVal->base.length = 0;
  retVal->base.type = 0;
  retVal->base.data = (unsigned char *)0;
  retVal->base.flags = 0;
  retVal->vFlags = 0;
  retVal->primeLen = 0;
  retVal->xCoord.data = (unsigned char *)0;
  retVal->xCoord.len = 0;
  retVal->yCoord.data = (unsigned char *)0;
  retVal->yCoord.len = 0;
  *obj = (ASN1_VALUE *)retVal;

  return (1);
}


void Asn1EcPointFree (
   ASN1_VALUE **obj,
   const ASN1_ITEM *asn1Item
   )
{
  /* Anything to free?
   */
  if (obj == (ASN1_VALUE **)0)
    return;
  if (*obj == (ASN1_VALUE *)0)
    return;

  Asn1EcPointClear (obj, asn1Item);

  OPENSSL_free (*obj);
  *obj = (ASN1_VALUE *)0;
}


void Asn1EcPointClear (
   ASN1_VALUE **obj,
   const ASN1_ITEM *asn1Item
   )
{
  Asn1EcPoint *value;

  /* Anything to free?
   */
  if (obj == (ASN1_VALUE **)0)
    return;
  if (*obj == (ASN1_VALUE *)0)
    return;

  value = (Asn1EcPoint *)(*obj);

  /* If copy by value, overwrite and free.
   */
  if ((value->vFlags & VOLT_ASN1_COPY_MASK) == VOLT_ASN1_COPY_DATA)
  {
    if (value->base.data != (unsigned char *)0)
    {
      Asn1Memset (value->base.data, 0, (unsigned int)(value->base.length));
      OPENSSL_free (value->base.data);
    }
    if (value->xCoord.data != (unsigned char *)0)
    {
      Asn1Memset (value->xCoord.data, 0, value->xCoord.len);
      OPENSSL_free (value->xCoord.data);
    }
    if (value->yCoord.data != (unsigned char *)0)
    {
      Asn1Memset (value->yCoord.data, 0, value->yCoord.len);
      OPENSSL_free (value->yCoord.data);
    }
  }

  value->base.data = (unsigned char *)0;
  value->base.length = 0;
  value->xCoord.data = (unsigned char *)0;
  value->xCoord.len = 0;
  value->yCoord.data = (unsigned char *)0;
  value->yCoord.len = 0;
  value->primeLen = 0;
}


int Asn1EcPointDecode (
   ASN1_VALUE **obj,
   const unsigned char **input,
   long length,
   const ASN1_ITEM *asn1Item,
   int tag,
   int aclass,
   char opt,
   ASN1_TLC *ctx
   )
{
  int status, asn1Ret;
  unsigned int lengthLen, valueLen, totalLen, primeLen, theTag;
  UInt32 lenLo, lenHi;
  Asn1EcPoint *value = (Asn1EcPoint *)0;
  unsigned char *encoding = (unsigned char *)(*input);

  if (obj == (ASN1_VALUE **)0)
    return (0);
  if (*obj != (ASN1_VALUE *)0)
    value = (Asn1EcPoint *)(*obj);

  Asn1EcPointClear (obj, asn1Item);

  /* What are the lengths?
   */
  status = VoltDecodeTagAndLen (
    (VoltLibCtx *)0, encoding, length, &theTag, &lengthLen, &lenLo, &lenHi,
    sizeof (unsigned int));
  if (status != 0)
    return (0);

  valueLen = (unsigned int)lenLo;

  /* Is the encoding big enough for the alleged lengths?
   */
  totalLen = lengthLen + valueLen + 1;
  if (length < (long)totalLen)
    return (0);

  /* valueLen must = (2 * primeLen) + 1, hence, it must be odd.
   */
  if ((valueLen & 1) == 0)
    return (0);

  /* Make sure the tag is OCTET STRING (or the proper IMPLICIT tag if
   * necessary).
   */
  theTag = 4;
  if (tag != -1)
    theTag = aclass | tag;
  if (encoding[0] != theTag)
    return (0);

  /* The first byte of the value must be 4 (It's not an OCTET STRING
   * tag, but coincidence).
   */
  encoding += lengthLen + 1;
  if (encoding[0] != 4)
    return (0);

  encoding++;
  primeLen = (valueLen - 1) / 2;

  /* The OpenSSL engine requires moving the input pointer along.
   */
  (*input) += totalLen;

  /* Is there an object? If not, create one.
   */
  if (value == (Asn1EcPoint *)0)
  {
    asn1Ret = Asn1EcPointNew ((ASN1_VALUE **)&value, asn1Item);
    if (asn1Ret != 1)
      return (0);
    *obj = (ASN1_VALUE *)value;
  }

  value->vFlags |= VOLT_ASN1_COPY_FLAG_FIXED;

  /* If copy by ref, copy the addresses, if copy by value, allocate and
   * copy.
   */
  if ((value->vFlags & VOLT_ASN1_COPY_MASK) == VOLT_ASN1_COPY_DATA)
  {
    value->xCoord.data = (unsigned char *)OPENSSL_malloc (primeLen);
    if (value->xCoord.data == (unsigned char *)0)
      return (0);

    Asn1Memcpy (value->xCoord.data, encoding, primeLen);
    encoding += primeLen;

    value->yCoord.data = (unsigned char *)OPENSSL_malloc (primeLen);
    if (value->yCoord.data == (unsigned char *)0)
      return (0);

    Asn1Memcpy (value->yCoord.data, encoding, primeLen);
  }
  else
  {
    value->xCoord.data = encoding;
    encoding += primeLen;
    value->yCoord.data = encoding;
  }

  value->xCoord.len = primeLen;
  value->yCoord.len = primeLen;

  /* Clear the context.
   */
  ctx->valid = 0;
  ctx->ret = 0;
  ctx->plen = 0;
  ctx->ptag = 0;
  ctx->pclass = 0;
  ctx->hdrlen = 0;

  return (1);
}


int Asn1EcPointEncode (
   ASN1_VALUE **obj,
   unsigned char **output,
   const ASN1_ITEM *asn1Item,
   int tag,
   int aclass
   )
{
  unsigned int valueLen, totalLen, theTag, index, offset;
  Asn1EcPoint *value = (Asn1EcPoint *)(*obj);  
  unsigned char *encoding;

  value->vFlags |= VOLT_ASN1_COPY_FLAG_FIXED;

  if (value->primeLen == 0)
    return (0);

  /* Encode the tag and length.
   */
  valueLen = (2 * value->primeLen) + 1;
  totalLen =
    valueLen + VoltDetermineDerLengthLen ((UInt32)valueLen, (UInt32)0) + 1;

  /* If there's no pointer to output, just indicate the length.
   */
  if (output == (unsigned char **)0)
    return (totalLen);

  /* If the caller supplied no buffer, don't do anything.
   */
  if (*output == (unsigned char *)0)
    return (0);

  encoding = *output;

  /* Write the tag and len.
   */
  theTag = 4;
  if (tag != -1)
    theTag = aclass | tag;
  encoding += VoltWriteDerTagAndLen (
    encoding, theTag, (UInt32)valueLen, (UInt32)0);

  /* Write the leading 4 (not the tag, the coincidence).
   */
  encoding[0] = 4;
  encoding++;

  /* Copy the coordinates into the buffer. If the length is < primeLen,
   * place leading 00 bytes.
   */
  offset = value->primeLen - value->xCoord.len;
  for (index = 0; index < offset; ++index)
    encoding[index] = 0;
  Asn1Memcpy (encoding + offset, value->xCoord.data, value->xCoord.len);
  encoding += value->primeLen;
  offset = value->primeLen - value->yCoord.len;
  for (index = 0; index < offset; ++index)
    encoding[index] = 0;
  Asn1Memcpy (encoding, value->yCoord.data, value->yCoord.len);

  /* The OpenSSL engine requires moving the output pointer along.
   */
  (*output) += totalLen;
  return (totalLen);
}


Asn1EncryptedContent *Asn1EncryptedContent_new ()
{
  Asn1EncryptedContent *retVal = (Asn1EncryptedContent *)0;

  Asn1EncryptedContentNew ((ASN1_VALUE **)&retVal, (const ASN1_ITEM *)0);
  return (retVal);
}


int Asn1EncryptedContent_set (
   Asn1EncryptedContent *value,
   VtLibCtx libCtx,
   VtAlgorithmImpl *AlgImpl,
   Pointer algImplInfo,
   VtKeyParam *KeyParam,
   Pointer keyParamInfo,
   VtRandomObject random,
   unsigned char *data,
   unsigned int dataLen
   )
{
  int status;

  if (value == (Asn1EncryptedContent *)0)
    return (0);

  Asn1EncryptedContentClear ((ASN1_VALUE **)&value, (ASN1_ITEM *)0);
  value->vFlags |= VOLT_ASN1_COPY_FLAG_FIXED;

  /* Did the caller pass in an alg object or do we need to build our
   * own?
   */
  if (AlgImpl == (VtAlgorithmImpl *)0)
  {
    value->cipherObj = (VtAlgorithmObject)algImplInfo;
  }
  else
  {
    /* Build an encryption object using the input.
     */
    status = VtCreateAlgorithmObject (
      libCtx, AlgImpl, algImplInfo, &(value->cipherObj));
    if (status != 0)
      return (0);

    value->state |= VOLT_ENC_CONTENT_STATE_ALG;
  }

  /* Did the caller pass in a key object or do we need to build our own?
   */
  if (KeyParam == (VtKeyParam *)0)
  {
    value->keyObj = (VtKeyObject)keyParamInfo;
  }
  else
  {
    /* Build a key object using the input.
     */
    status = VtCreateKeyObject (
      libCtx, (VtKeyImpl *)0, (Pointer)0, &(value->keyObj));
    if (status != 0)
      return (0);

    status = VtSetKeyParam (value->keyObj, KeyParam, keyParamInfo);
    if (status != 0)
      return (0);

    value->state |= VOLT_ENC_CONTENT_STATE_KEY;
  }

  value->random = random;

  value->state |= VOLT_ENC_CONTENT_STATE_SET;
  if ( (data == (unsigned char *)0) || (dataLen == 0) )
    return (1);

  /* If copy by ref, copy the addresses, if copy by value, allocate and
   * copy.
   */
  if ((value->vFlags & VOLT_ASN1_COPY_MASK) == VOLT_ASN1_COPY_DATA)
  {
    value->base.data = (unsigned char *)OPENSSL_malloc (dataLen);
    if (value->base.data == (unsigned char *)0)
      return (0);
    Asn1Memcpy (value->base.data, data, dataLen);
  }
  else
  {
    value->base.data = data;
  }

  value->base.length = (int)dataLen;

  return (1);
}

int Asn1EncryptedContentNew (
   ASN1_VALUE **obj,
   const ASN1_ITEM *asn1Item
   )
{
  Asn1EncryptedContent *retVal = (Asn1EncryptedContent *)0;

  if (obj == (ASN1_VALUE **)0)
    return (0);
  *obj = (ASN1_VALUE *)0;

  /* Build an empty Asn1EncryptedContent struct.
   */
  retVal = (Asn1EncryptedContent *)OPENSSL_malloc (
    sizeof (Asn1EncryptedContent));
  if (retVal == (Asn1EncryptedContent *)0)
    return (0);

  retVal->vFlags = 0;
  retVal->state = VOLT_ENC_CONTENT_STATE_CREATE;
  retVal->cipherObj = (VtAlgorithmObject)0;
  retVal->keyObj = (VtKeyObject)0;
  retVal->random = (VtRandomObject)0;
  retVal->base.length = 0;
  retVal->base.type = 0;
  retVal->base.data = (unsigned char *)0;
  retVal->base.flags = 0;
  *obj = (ASN1_VALUE *)retVal;

  return (1);
}

void Asn1EncryptedContentFree (
   ASN1_VALUE **obj,
   const ASN1_ITEM *asn1Item
   )
{
  /* Anything to free?
   */
  if (obj == (ASN1_VALUE **)0)
    return;
  if (*obj == (ASN1_VALUE *)0)
    return;

  Asn1EncryptedContentClear (obj, asn1Item);

  OPENSSL_free (*obj);
  *obj = (ASN1_VALUE *)0;
}

void Asn1EncryptedContentClear (
   ASN1_VALUE **obj,
   const ASN1_ITEM *asn1Item
   )
{
  Asn1EncryptedContent *value;

  /* Anything to free?
   */
  if (obj == (ASN1_VALUE **)0)
    return;
  if (*obj == (ASN1_VALUE *)0)
    return;

  value = (Asn1EncryptedContent *)(*obj);

  /* If copy by value, overwrite and free.
   */
  if ((value->vFlags & VOLT_ASN1_COPY_MASK) == VOLT_ASN1_COPY_DATA)
  {
    if (value->base.data != (unsigned char *)0)
    {
      Asn1Memset (value->base.data, 0, (unsigned int)(value->base.length));
      OPENSSL_free (value->base.data);
    }
  }
  value->base.data = (unsigned char *)0;
  value->base.length = 0;

  /* Destroy the encryption and key objects if we created them. Don't
   * destroy the random object (only a reference was stored). Also, the
   * data to transform was copied as reference as well, don't free it.
   */
  if ((value->state & VOLT_ENC_CONTENT_STATE_ALG) != 0)
    VtDestroyAlgorithmObject (&(value->cipherObj));
  else
    value->cipherObj = (VtAlgorithmObject)0;
  if ((value->state & VOLT_ENC_CONTENT_STATE_KEY) != 0)
    VtDestroyKeyObject (&(value->keyObj));
  else
    value->keyObj = (VtKeyObject)0;
  value->random = (VtRandomObject)0;
  value->state = VOLT_ENC_CONTENT_STATE_CREATE;
}

int Asn1EncryptedContentDecode (
   ASN1_VALUE **obj,
   const unsigned char **input,
   long length,
   const ASN1_ITEM *asn1Item,
   int tag,
   int aclass,
   char opt,
   ASN1_TLC *ctx
   )
{
  int status;
  unsigned int lengthLen, valueLen, totalLen, decryptLen, theTag;
  UInt32 lenLo, lenHi;
  Asn1EncryptedContent *value = (Asn1EncryptedContent *)0;
  unsigned char *encoding = (unsigned char *)(*input);

  if (obj == (ASN1_VALUE **)0)
    return (0);
  value = (Asn1EncryptedContent *)(*obj);

  /* Is there an object? If not, error
   */
  if (value == (Asn1EncryptedContent *)0)
    return (0);

  value->vFlags |= VOLT_ASN1_COPY_FLAG_FIXED;

  /* We can call this if the object is SET or has been initialized for
   * Decryption/Decoding. Use totalLen as a temp variable.
   */
  totalLen = VOLT_ENC_CONTENT_STATE_MASK & value->state;
  if (totalLen == VOLT_ENC_CONTENT_STATE_INIT_E)
    return (0);

  if (totalLen == VOLT_ENC_CONTENT_STATE_SET)
  {
    if (value->cipherObj != (VtAlgorithmObject)0)
    {
      status = VtDecryptInit (value->cipherObj, value->keyObj);
      if (status != 0)
        return (0);
      value->state ^= totalLen;
      value->state |= VOLT_ENC_CONTENT_STATE_INIT_D;
    }
  }

  /* What are the lengths?