asn1types.c

IBE是一种非对称密码技术

/* Copyright 2003-2006, Voltage Security, all rights reserved.
 */

#include "vibe.h"
#include "environment.h"
#include "base.h"
#include "libctx.h"
#include "derhelp.h"
#include <openssl/asn1t.h>

#ifdef  OPENSSL_EXPORT_VAR_AS_FUNCTION

const ASN1_ITEM *Asn1ObjectId_it ()
{
  static const ASN1_EXTERN_FUNCS oidExternFuncs =
  {
    0,
    Asn1CommonNew,
    Asn1CommonFree,
    Asn1CommonClear,
    Asn1CommonDecode,
    Asn1CommonEncode
  };

  static const ASN1_ITEM local_it = {
    ASN1_ITYPE_EXTERN,
    6,
    0,
    0,
    (void *)&oidExternFuncs,
    sizeof (Asn1ObjectId),
    "Asn1ObjectId"
  };

  return (&local_it);
}

Asn1ObjectId *d2i_Asn1ObjectId (
   Asn1ObjectId **a,
   unsigned char **in,
   long len
   )
{
  return ((Asn1ObjectId *)ASN1_item_d2i (
    (ASN1_VALUE **)a, in, len, (Asn1ObjectId_it ())));
}

int i2d_Asn1ObjectId (
   Asn1ObjectId *a,
   unsigned char **out
   )
{
  return (ASN1_item_i2d (
    (ASN1_VALUE *)a, out, (Asn1ObjectId_it ())));
}

void Asn1ObjectId_free (
   Asn1ObjectId *a
   )
{
  ASN1_item_free ((ASN1_VALUE *)a, (Asn1ObjectId_it ()));
}

const ASN1_ITEM *Asn1Encoded_it ()
{
  static const ASN1_EXTERN_FUNCS encodedExternFuncs =
  {
    0,
    Asn1CommonNew,
    Asn1CommonFree,
    Asn1CommonClear,
    Asn1CommonDecode,
    Asn1CommonEncode
  };

  static const ASN1_ITEM local_it = {
    ASN1_ITYPE_EXTERN,
    0,
    0,
    0,
    (void *)&encodedExternFuncs,
    sizeof (Asn1Encoded),
    "Asn1Encoded"
  };

  return (&local_it);
}

Asn1Encoded *d2i_Asn1Encoded (
   Asn1Encoded **a,
   unsigned char **in,
   long len
   )
{
  return ((Asn1Encoded *)ASN1_item_d2i (
    (ASN1_VALUE **)a, in, len, (Asn1Encoded_it ())));
}

int i2d_Asn1Encoded (
   Asn1Encoded *a,
   unsigned char **out
   )
{
  return (ASN1_item_i2d (
    (ASN1_VALUE *)a, out, (Asn1Encoded_it ())));
}

void Asn1Encoded_free (
   Asn1Encoded *a
   )
{
  ASN1_item_free ((ASN1_VALUE *)a, (Asn1Encoded_it ()));
}

const ASN1_ITEM *Asn1EcPoint_it ()
{
  static const ASN1_EXTERN_FUNCS ecPointFuncs =
  {
    0,
    Asn1EcPointNew,
    Asn1EcPointFree,
    Asn1EcPointClear,
    Asn1EcPointDecode,
    Asn1EcPointEncode
  };

  static const ASN1_ITEM local_it = {
    ASN1_ITYPE_EXTERN,
    4,
    0,
    0,
    (void *)&ecPointFuncs,
    sizeof (Asn1EcPoint),
    "Asn1EcPoint"
  };

  return (&local_it);
}

Asn1EcPoint *d2i_Asn1EcPoint (
   Asn1EcPoint **a,
   unsigned char **in,
   long len
   )
{
  return ((Asn1EcPoint *)ASN1_item_d2i (
    (ASN1_VALUE **)a, in, len, (Asn1EcPoint_it ())));
}

int i2d_Asn1EcPoint (
   Asn1EcPoint *a,
   unsigned char **out
   )
{
  return (ASN1_item_i2d (
    (ASN1_VALUE *)a, out, (Asn1EcPoint_it ())));
}

void Asn1EcPoint_free (
   Asn1EcPoint *a
   )
{
  ASN1_item_free ((ASN1_VALUE *)a, (Asn1EcPoint_it ()));
}

const ASN1_ITEM *Asn1EncryptedContent_it ()
{
  static const ASN1_EXTERN_FUNCS encContentFuncs =
  {
    0,
    Asn1EncryptedContentNew,
    Asn1EncryptedContentFree,
    Asn1EncryptedContentClear,
    Asn1EncryptedContentDecode,
    Asn1EncryptedContentEncode
  };

  static const ASN1_ITEM local_it = {
    ASN1_ITYPE_EXTERN,
    4,
    0,
    0,
    (void *)&encContentFuncs,
    sizeof (Asn1EncryptedContent),
    "Asn1EncryptedContent"
  };

  return (&local_it);
}

Asn1EncryptedContent *d2i_Asn1EncryptedContent (
   Asn1EncryptedContent **a,
   unsigned char **in,
   long len
   )
{
  return ((Asn1EncryptedContent *)ASN1_item_d2i (
    (ASN1_VALUE **)a, in, len, (Asn1EncryptedContent_it ())));
}

int i2d_Asn1EncryptedContent (
   Asn1EncryptedContent *a,
   unsigned char **out
   )
{
  return (ASN1_item_i2d (
    (ASN1_VALUE *)a, out, (Asn1EncryptedContent_it ())));
}

void Asn1EncryptedContent_free (
   Asn1EncryptedContent *a
   )
{
  ASN1_item_free ((ASN1_VALUE *)a, (Asn1EncryptedContent_it ()));
}

#else

static const ASN1_EXTERN_FUNCS oidExternFuncs =  {
    0,
    Asn1CommonNew,
    Asn1CommonFree,
    Asn1CommonClear,
    Asn1CommonDecode,
    Asn1CommonEncode
};

const ASN1_ITEM Asn1ObjectId_it = {
    ASN1_ITYPE_EXTERN,
    6,
    0,
    0,
    (void *)&oidExternFuncs,
    sizeof (Asn1ObjectId),
    "Asn1ObjectId"
};


Asn1ObjectId *d2i_Asn1ObjectId (
   Asn1ObjectId **a,
   unsigned char **in,
   long len
   )
{
  return ((Asn1ObjectId *)ASN1_item_d2i (
    (ASN1_VALUE **)a, in, len, (&(Asn1ObjectId_it))));
}

int i2d_Asn1ObjectId (
   Asn1ObjectId *a,
   unsigned char **out
   )
{
  return (ASN1_item_i2d (
    (ASN1_VALUE *)a, out, (&(Asn1ObjectId_it))));
}

void Asn1ObjectId_free (
   Asn1ObjectId *a
   )
{
  ASN1_item_free ((ASN1_VALUE *)a, (&(Asn1ObjectId_it)));
}


static const ASN1_EXTERN_FUNCS encodedExternFuncs =  {
    0,
    Asn1CommonNew,
    Asn1CommonFree,
    Asn1CommonClear,
    Asn1CommonDecode,
    Asn1CommonEncode
};

const ASN1_ITEM Asn1Encoded_it = {
    ASN1_ITYPE_EXTERN,
    0,
    0,
    0,
    (void *)&encodedExternFuncs,
    sizeof (Asn1Encoded),
    "Asn1Encoded"
};
 

Asn1Encoded *d2i_Asn1Encoded (
   Asn1Encoded **a,
   unsigned char **in,
   long len
   )
{
  return ((Asn1Encoded *)ASN1_item_d2i (
    (ASN1_VALUE **)a, in, len, (&(Asn1Encoded_it))));
}

int i2d_Asn1Encoded (
   Asn1Encoded *a,
   unsigned char **out
   )
{
  return (ASN1_item_i2d (
    (ASN1_VALUE *)a, out, (&(Asn1Encoded_it))));
}

void Asn1Encoded_free (
   Asn1Encoded *a
   )
{
  ASN1_item_free ((ASN1_VALUE *)a, (&(Asn1Encoded_it)));
}


static const ASN1_EXTERN_FUNCS ecPointFuncs =  {
    0,
    Asn1EcPointNew,
    Asn1EcPointFree,
    Asn1EcPointClear,
    Asn1EcPointDecode,
    Asn1EcPointEncode
};
  
const ASN1_ITEM Asn1EcPoint_it = {
    ASN1_ITYPE_EXTERN,
    4,
    0,
    0,
    (void *)&ecPointFuncs,
    sizeof (Asn1EcPoint),
    "Asn1EcPoint"
};


Asn1EcPoint *d2i_Asn1EcPoint (
   Asn1EcPoint **a,
   unsigned char **in,
   long len
   )
{
  return ((Asn1EcPoint *)ASN1_item_d2i (
    (ASN1_VALUE **)a, in, len, (&(Asn1EcPoint_it))));
}

int i2d_Asn1EcPoint (
   Asn1EcPoint *a,
   unsigned char **out
   )
{
  return (ASN1_item_i2d (
    (ASN1_VALUE *)a, out, (&(Asn1EcPoint_it))));
}

void Asn1EcPoint_free (
   Asn1EcPoint *a
   )
{
  ASN1_item_free ((ASN1_VALUE *)a, (&(Asn1EcPoint_it)));
}


static const ASN1_EXTERN_FUNCS encContentFuncs = {
    0,
    Asn1EncryptedContentNew,
    Asn1EncryptedContentFree,
    Asn1EncryptedContentClear,
    Asn1EncryptedContentDecode,
    Asn1EncryptedContentEncode
};

const ASN1_ITEM Asn1EncryptedContent_it = {
    ASN1_ITYPE_EXTERN,
    4,
    0,
    0,
    (void *)&encContentFuncs,
    sizeof (Asn1EncryptedContent),
    "Asn1EncryptedContent"
};
   

Asn1EncryptedContent *d2i_Asn1EncryptedContent (
   Asn1EncryptedContent **a,
   unsigned char **in,
   long len
   )
{
  return ((Asn1EncryptedContent *)ASN1_item_d2i (
    (ASN1_VALUE **)a, in, len, (&(Asn1EncryptedContent_it) )));
}

int i2d_Asn1EncryptedContent (
   Asn1EncryptedContent *a,
   unsigned char **out
   )
{
  return (ASN1_item_i2d (
    (ASN1_VALUE *)a, out, (&(Asn1EncryptedContent_it) )));
}

void Asn1EncryptedContent_free (
   Asn1EncryptedContent *a
   )
{
  ASN1_item_free ((ASN1_VALUE *)a, (&(Asn1EncryptedContent_it)) );
}

#endif



Asn1ObjectId *Asn1ObjectId_new ()
{
  Asn1ObjectId *retVal = (Asn1ObjectId *)0;

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


int Asn1ObjectId_set (
   Asn1ObjectId *value,
   unsigned char *data,
   unsigned int len
   )
{
  return (Asn1CommonSet ((VoltAsn1String *)value, data, len));
}


Asn1Encoded *Asn1Encoded_new ()
{
  Asn1Encoded *retVal = (Asn1Encoded *)0;

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


int Asn1Encoded_setCreate (
   Asn1Encoded **value,
   unsigned char *data,
   unsigned int len
   )
{
  Asn1Encoded *newValue = (Asn1Encoded *)0;

  if ( (data == (unsigned char *)0) || (len == 0) )
    return (1);

  /* If there is no value, create one.
   */
  if (*value == (Asn1Encoded *)0)
  {
    Asn1CommonNew ((ASN1_VALUE **)&newValue, (const ASN1_ITEM *)0);
    if (newValue == (Asn1Encoded *)0)
      return (0);
    *value = newValue;
  }
  return (Asn1CommonSet ((VoltAsn1String *)(*value), data, len));
}


int Asn1Encoded_set (
   Asn1Encoded *value,
   unsigned char *data,
   unsigned int len
   )
{
  return (Asn1CommonSet ((VoltAsn1String *)value, data, len));
}


Asn1EcPoint *Asn1EcPoint_new ()
{
  Asn1EcPoint *retVal = (Asn1EcPoint *)0;

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


int Asn1EcPoint_set (
   Asn1EcPoint *value,
   unsigned int primeLen,
   unsigned char *xCoord,
   unsigned int xLen,
   unsigned char *yCoord,
   unsigned int yLen
   )
{
  if (value == (Asn1EcPoint *)0)
    return (0);

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

  if ( (xCoord == (unsigned char *)0) || (xLen == 0) )
    return (0);
  if ( (yCoord == (unsigned char *)0) || (yLen == 0) )
    return (0);
  if ( (xLen > primeLen) || (yLen > primeLen) )
    return (0);

  /* 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 (xLen);
    if (value->xCoord.data == (unsigned char *)0)
      return (0);

    Asn1Memcpy (value->xCoord.data, xCoord, xLen);
    value->xCoord.len = xLen;

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

    Asn1Memcpy (value->yCoord.data, yCoord, yLen);
    value->yCoord.len = primeLen;
  }
  else
  {
    value->xCoord.data = xCoord;
    value->xCoord.len = xLen;
    value->yCoord.data = yCoord;
    value->yCoord.len = yLen;
  }

  value->primeLen = primeLen;