LIBTASN1_VERSION

#define LIBTASN1_VERSION "0.3.8"

MAX_NAME_SIZE

#define MAX_NAME_SIZE 128	/* maximum number of characters of a name */

MAX_ERROR_DESCRIPTION_SIZE

#define MAX_ERROR_DESCRIPTION_SIZE 128	/* maximum number of characters */

asn1_retCode

  typedef int asn1_retCode;	/* type returned by libtasn1 functions */

ASN1_SUCCESS

#define ASN1_SUCCESS               0

ASN1_FILE_NOT_FOUND

#define ASN1_FILE_NOT_FOUND        1

ASN1_ELEMENT_NOT_FOUND

#define ASN1_ELEMENT_NOT_FOUND     2

ASN1_IDENTIFIER_NOT_FOUND

#define ASN1_IDENTIFIER_NOT_FOUND  3

ASN1_DER_ERROR

#define ASN1_DER_ERROR             4

ASN1_VALUE_NOT_FOUND

#define ASN1_VALUE_NOT_FOUND       5

ASN1_GENERIC_ERROR

#define ASN1_GENERIC_ERROR         6

ASN1_VALUE_NOT_VALID

#define ASN1_VALUE_NOT_VALID       7

ASN1_TAG_ERROR

#define ASN1_TAG_ERROR             8

ASN1_TAG_IMPLICIT

#define ASN1_TAG_IMPLICIT          9

ASN1_ERROR_TYPE_ANY

#define ASN1_ERROR_TYPE_ANY        10

ASN1_SYNTAX_ERROR

#define ASN1_SYNTAX_ERROR          11

ASN1_MEM_ERROR

#define ASN1_MEM_ERROR		   12

ASN1_MEM_ALLOC_ERROR

#define ASN1_MEM_ALLOC_ERROR	   13

ASN1_DER_OVERFLOW

#define ASN1_DER_OVERFLOW          14

ASN1_NAME_TOO_LONG

#define ASN1_NAME_TOO_LONG         15

ASN1_ARRAY_ERROR

#define ASN1_ARRAY_ERROR           16

ASN1_ELEMENT_NOT_EMPTY

#define ASN1_ELEMENT_NOT_EMPTY     17

ASN1_PRINT_NAME

#define ASN1_PRINT_NAME             1

ASN1_PRINT_NAME_TYPE

#define ASN1_PRINT_NAME_TYPE        2

ASN1_PRINT_NAME_TYPE_VALUE

#define ASN1_PRINT_NAME_TYPE_VALUE  3

ASN1_PRINT_ALL

#define ASN1_PRINT_ALL              4

ASN1_CLASS_UNIVERSAL

#define ASN1_CLASS_UNIVERSAL        0x00	/* old: 1 */

ASN1_CLASS_APPLICATION

#define ASN1_CLASS_APPLICATION      0x40	/* old: 2 */

ASN1_CLASS_CONTEXT_SPECIFIC

#define ASN1_CLASS_CONTEXT_SPECIFIC 0x80	/* old: 3 */

ASN1_CLASS_PRIVATE

#define ASN1_CLASS_PRIVATE          0xC0	/* old: 4 */

ASN1_CLASS_STRUCTURED

#define ASN1_CLASS_STRUCTURED       0x20

ASN1_TAG_BOOLEAN

#define ASN1_TAG_BOOLEAN          0x01

ASN1_TAG_INTEGER

#define ASN1_TAG_INTEGER          0x02

ASN1_TAG_SEQUENCE

#define ASN1_TAG_SEQUENCE         0x10

ASN1_TAG_SET

#define ASN1_TAG_SET              0x11

ASN1_TAG_OCTET_STRING

#define ASN1_TAG_OCTET_STRING     0x04

ASN1_TAG_BIT_STRING

#define ASN1_TAG_BIT_STRING       0x03

ASN1_TAG_UTCTime

#define ASN1_TAG_UTCTime          0x17

ASN1_TAG_GENERALIZEDTime

#define ASN1_TAG_GENERALIZEDTime  0x18

ASN1_TAG_OBJECT_ID

#define ASN1_TAG_OBJECT_ID        0x06

ASN1_TAG_ENUMERATED

#define ASN1_TAG_ENUMERATED       0x0A

ASN1_TAG_NULL

#define ASN1_TAG_NULL             0x05

ASN1_TAG_GENERALSTRING

#define ASN1_TAG_GENERALSTRING    0x1B

struct node_asn_struct

struct node_asn_struct {
    char *name;			/* Node name */
    unsigned int type;		/* Node type */
    unsigned char *value;	/* Node value */
    int value_len;
    struct node_asn_struct *down;	/* Pointer to the son node */
    struct node_asn_struct *right;	/* Pointer to the brother node */
    struct node_asn_struct *left;	/* Pointer to the next list element */
};

node_asn

  typedef struct node_asn_struct node_asn;

ASN1_TYPE

  typedef node_asn *ASN1_TYPE;

ASN1_TYPE_EMPTY

#define ASN1_TYPE_EMPTY  NULL

struct static_struct_asn

struct static_struct_asn {
    const char *name;			/* Node name */
    unsigned int type;		/* Node type */
    const void *value;	/* Node value */
};

ASN1_ARRAY_TYPE

  typedef struct static_struct_asn ASN1_ARRAY_TYPE;

asn1_parser2tree ()

asn1_retCode asn1_parser2tree               (const char *file_name,
                                             ASN1_TYPE *definitions,
                                             char *errorDescription);

Creates the structures needed to manage the definitions included in *FILE_NAME file.

asn1_parser2array ()

asn1_retCode asn1_parser2array              (const char *inputFileName,
                                             const char *outputFileName,
                                             const char *vectorName,
                                             char *errorDescription);

Creates a file containing a C vector to use to manage the definitions included in *INPUTFILENAME file. If *INPUTFILENAME is "/aa/bb/xx.yy" and OUTPUTFILENAME is NULL, the file created is "/aa/bb/xx_asn1_tab.c". If VECTORNAME is NULL the vector name will be "xx_asn1_tab".

asn1_array2tree ()

asn1_retCode asn1_array2tree                (const ASN1_ARRAY_TYPE *array,
                                             ASN1_TYPE *definitions,
                                             char *errorDescription);

Creates the structures needed to manage the ASN.1 definitions. array is a vector created by asn1_parser2array().

asn1_print_structure ()

void        asn1_print_structure            (FILE *out,
                                             ASN1_TYPE structure,
                                             const char *name,
                                             int mode);

Prints on the out file descriptor the structure's tree starting from the name element inside the structure structure.

asn1_create_element ()

asn1_retCode asn1_create_element            (ASN1_TYPE definitions,
                                             const char *source_name,
                                             ASN1_TYPE *element);

Creates a structure of type source_name. Example using "pkix.asn":

rc = asn1_create_structure(cert_def, "PKIX1.Certificate", certptr);

asn1_delete_structure ()

asn1_retCode asn1_delete_structure          (ASN1_TYPE *structure);

Deletes the structure *structure. At the end, *structure is set to ASN1_TYPE_EMPTY.

asn1_delete_element ()

asn1_retCode asn1_delete_element            (ASN1_TYPE structure,
                                             const char *element_name);

Deletes the element named *element_name inside *structure.

asn1_write_value ()

asn1_retCode asn1_write_value               (ASN1_TYPE node_root,
                                             const char *name,
                                             const void *ivalue,
                                             int len);

Set the value of one element inside a structure.

If an element is OPTIONAL and you want to delete it, you must use the value=NULL and len=0. Using "pkix.asn":

result=asn1_write_value(cert, "tbsCertificate.issuerUniqueID", NULL, 0);

Description for each type:

INTEGER: VALUE must contain a two's complement form integer.

value[0]=0xFF , len=1 -> integer=-1. value[0]=0xFF value[1]=0xFF , len=2 -> integer=-1. value[0]=0x01 , len=1 -> integer= 1. value[0]=0x00 value[1]=0x01 , len=2 -> integer= 1. value="123" , len=0 -> integer= 123.

ENUMERATED: As INTEGER (but only with not negative numbers).

BOOLEAN: VALUE must be the null terminated string "TRUE" or "FALSE" and LEN != 0.

value="TRUE" , len=1 -> boolean=TRUE. value="FALSE" , len=1 -> boolean=FALSE.

OBJECT IDENTIFIER: VALUE must be a null terminated string with each number separated by a dot (e.g. "1.2.3.543.1"). LEN != 0.

value="1 2 840 10040 4 3" , len=1 -> OID=dsa-with-sha.

UTCTime: VALUE must be a null terminated string in one of these formats: "YYMMDDhhmmssZ", "YYMMDDhhmmssZ", "YYMMDDhhmmss+hh'mm'", "YYMMDDhhmmss-hh'mm'", "YYMMDDhhmm+hh'mm'", or "YYMMDDhhmm-hh'mm'". LEN != 0.

value="9801011200Z" , len=1 -> time=Jannuary 1st, 1998 at 12h 00m Greenwich Mean Time

GeneralizedTime: VALUE must be in one of this format: "YYYYMMDDhhmmss.sZ", "YYYYMMDDhhmmss.sZ", "YYYYMMDDhhmmss.s+hh'mm'", "YYYYMMDDhhmmss.s-hh'mm'", "YYYYMMDDhhmm+hh'mm'", or "YYYYMMDDhhmm-hh'mm'" where ss.s indicates the seconds with any precision like "10.1" or "01.02". LEN != 0

value="2001010112001.12-0700" , len=1 -> time=Jannuary 1st, 2001 at 12h 00m 01.12s Pacific Daylight Time

OCTET STRING: VALUE contains the octet string and LEN is the number of octets.

value="$\backslash$x01$\backslash$x02$\backslash$x03" , len=3 -> three bytes octet string

GeneralString: VALUE contains the generalstring and LEN is the number of octets.

value="$\backslash$x01$\backslash$x02$\backslash$x03" , len=3 -> three bytes generalstring

BIT STRING: VALUE contains the bit string organized by bytes and LEN is the number of bits.

value="$\backslash$xCF" , len=6 -> bit string="110011" (six bits)

CHOICE: if NAME indicates a choice type, VALUE must specify one of the alternatives with a null terminated string. LEN != 0. Using "pkix.asn"\:

result=asn1_write_value(cert, "certificate1.tbsCertificate.subject", "rdnSequence", 1);

ANY: VALUE indicates the der encoding of a structure. LEN != 0.

SEQUENCE OF: VALUE must be the null terminated string "NEW" and LEN != 0. With this instruction another element is appended in the sequence. The name of this element will be "?1" if it's the first one, "?2" for the second and so on.

Using "pkix.asn"\:

result=asn1_write_value(cert, "certificate1.tbsCertificate.subject.rdnSequence", "NEW", 1);

SET OF: the same as SEQUENCE OF. Using "pkix.asn":

result=asn1_write_value(cert, "tbsCertificate.subject.rdnSequence.?LAST", "NEW", 1);

asn1_read_value ()

asn1_retCode asn1_read_value                (ASN1_TYPE root,
                                             const char *name,
                                             void *ivalue,
                                             int *len);

Returns the value of one element inside a structure.

If an element is OPTIONAL and the function "read_value" returns ASN1_ELEMENT_NOT_FOUND, it means that this element wasn't present in the der encoding that created the structure. The first element of a SEQUENCE_OF or SET_OF is named "?1". The second one "?2" and so on.

INTEGER: VALUE will contain a two's complement form integer.

integer=-1 -> value[0]=0xFF , len=1. integer=1 -> value[0]=0x01 , len=1.

ENUMERATED: As INTEGER (but only with not negative numbers).

BOOLEAN: VALUE will be the null terminated string "TRUE" or "FALSE" and LEN=5 or LEN=6.

OBJECT IDENTIFIER: VALUE will be a null terminated string with each number separated by a dot (i.e. "1.2.3.543.1").

LEN = strlen(VALUE)+1

UTCTime: VALUE will be a null terminated string in one of these formats: "YYMMDDhhmmss+hh'mm'" or "YYMMDDhhmmss-hh'mm'". LEN=strlen(VALUE)+1.

GeneralizedTime: VALUE will be a null terminated string in the same format used to set the value.

OCTET STRING: VALUE will contain the octet string and LEN will be the number of octets.

GeneralString: VALUE will contain the generalstring and LEN will be the number of octets.

BIT STRING: VALUE will contain the bit string organized by bytes and LEN will be the number of bits.

CHOICE: If NAME indicates a choice type, VALUE will specify the alternative selected.

ANY: If NAME indicates an any type, VALUE will indicate the DER encoding of the structure actually used.

asn1_number_of_elements ()

asn1_retCode asn1_number_of_elements        (ASN1_TYPE element,
                                             const char *name,
                                             int *num);

Counts the number of elements of a sub-structure called NAME with names equal to "?1","?2", ...

asn1_der_coding ()

asn1_retCode asn1_der_coding                (ASN1_TYPE element,
                                             const char *name,
                                             void *ider,
                                             int *len,
                                             char *ErrorDescription);

Creates the DER encoding for the NAME structure (inside *POINTER structure).

asn1_der_decoding ()

asn1_retCode asn1_der_decoding              (ASN1_TYPE *element,
                                             const void *ider,
                                             int len,
                                             char *errorDescription);

Fill the structure *ELEMENT with values of a DER encoding string. The sructure must just be created with function 'create_stucture'. If an error occurs during the decoding procedure, the *ELEMENT is deleted and set equal to ASN1_TYPE_EMPTY.

asn1_der_decoding_element ()

asn1_retCode asn1_der_decoding_element      (ASN1_TYPE *structure,
                                             const char *elementName,
                                             const void *ider,
                                             int len,
                                             char *errorDescription);

Fill the element named ELEMENTNAME with values of a DER encoding string. The sructure must just be created with function 'create_stucture'. The DER vector must contain the encoding string of the whole STRUCTURE. If an error occurs during the decoding procedure, the *STRUCTURE is deleted and set equal to ASN1_TYPE_EMPTY.

asn1_der_decoding_startEnd ()

asn1_retCode asn1_der_decoding_startEnd     (ASN1_TYPE element,
                                             const void *ider,
                                             int len,
                                             const char *name_element,
                                             int *start,
                                             int *end);

Find the start and end point of an element in a DER encoding string. I mean that if you have a der encoding and you have already used the function "asn1_der_decoding" to fill a structure, it may happen that you want to find the piece of string concerning an element of the structure.

Example: the sequence "tbsCertificate" inside an X509 certificate.

asn1_expand_any_defined_by ()

asn1_retCode asn1_expand_any_defined_by     (ASN1_TYPE definitions,
                                             ASN1_TYPE *element);

Expands every "ANY DEFINED BY" element of a structure created from a DER decoding process (asn1_der_decoding function). The element ANY must be defined by an OBJECT IDENTIFIER. The type used to expand the element ANY is the first one following the definition of the actual value of the OBJECT IDENTIFIER.

asn1_expand_octet_string ()

asn1_retCode asn1_expand_octet_string       (ASN1_TYPE definitions,
                                             ASN1_TYPE *element,
                                             const char *octetName,
                                             const char *objectName);

Expands an "OCTET STRING" element of a structure created from a DER decoding process (asn1_der_decoding function). The type used for expansion is the first one following the definition of the actual value of the OBJECT IDENTIFIER indicated by OBJECTNAME.

asn1_read_tag ()

asn1_retCode asn1_read_tag                  (node_asn *root,
                                             const char *name,
                                             int *tagValue,
                                             int *classValue);

Returns the TAG and the CLASS of one element inside a structure. CLASS can have one of these constants: ASN1_CLASS_APPLICATION, ASN1_CLASS_UNIVERSAL, ASN1_CLASS_PRIVATE or ASN1_CLASS_CONTEXT_SPECIFIC.

asn1_find_structure_from_oid ()

const char* asn1_find_structure_from_oid    (ASN1_TYPE definitions,
                                             const char *oidValue);

Search the structure that is defined just after an OID definition.

asn1_check_version ()

const char* asn1_check_version              (const char *req_version);

Check that the the version of the library is at minimum the requested one and return the version string; return NULL if the condition is not satisfied. If a NULL is passed to this function, no check is done, but the version string is simply returned.

See LIBTASN1_VERSION for a suitable req_version string.

libtasn1_strerror ()

const char* libtasn1_strerror               (asn1_retCode error);

This function is similar to strerror(). The only difference is that it accepts an error (number) returned by a libtasn1 function.

libtasn1_perror ()

void        libtasn1_perror                 (asn1_retCode error);

This function is like perror(). The only difference is that it accepts an error returned by a libtasn1 function.

asn1_get_tag_der ()

int         asn1_get_tag_der                (unsigned char *der,
                                             int der_len,
                                             unsigned char *cls,
                                             int *len,
                                             unsigned long *tag);

Decode the class and TAG from DER code.

asn1_octet_der ()

void        asn1_octet_der                  (unsigned char *str,
                                             int str_len,
                                             unsigned char *der,
                                             int *der_len);

Creates the DER coding for an OCTET type (length included).

asn1_get_octet_der ()

asn1_retCode asn1_get_octet_der             (unsigned char *der,
                                             int der_len,
                                             int *ret_len,
                                             unsigned char *str,
                                             int str_size,
                                             int *str_len);

Extract an OCTET SEQUENCE from DER data.

asn1_bit_der ()

void        asn1_bit_der                    (unsigned char *str,
                                             int bit_len,
                                             unsigned char *der,
                                             int *der_len);

Creates the DER coding for a BIT STRING type (length and pad included).

asn1_get_bit_der ()

asn1_retCode asn1_get_bit_der               (unsigned char *der,
                                             int der_len,
                                             int *ret_len,
                                             unsigned char *str,
                                             int str_size,
                                             int *bit_len);

Extract a BIT SEQUENCE from DER data.

asn1_length_der ()

void        asn1_length_der                 (long int len,
                                             unsigned char *ans,
                                             int *ans_len);

Creates the DER coding for the LEN parameter (only the length). The ans buffer is pre-allocated and must have room for the output.

asn1_find_node ()

ASN1_TYPE   asn1_find_node                  (ASN1_TYPE pointer,
                                             const char *name);

Searches for an element called NAME starting from POINTER. The name is composed by differents identifiers separated by dots. When *POINTER has a name, the first identifier must be the name of *POINTER, otherwise it must be the name of one child of *POINTER.

asn1_copy_node ()

asn1_retCode asn1_copy_node                 (ASN1_TYPE dst,
                                             const char *dst_name,
                                             ASN1_TYPE src,
                                             const char *src_name);

Create a deep copy of a ASN1_TYPE variable.