OpenSSL之ASN1用法

ASN.1 – Abstract Syntax Notation dot one，抽象记法1，在大部分的书写场合会简写为ASN1。它描述了一种对数据进行表示、编码、传输和解码的数据格式。它提供了一整套正规的格式用于描述对象的结构，而不管语言上如何执行及这些数据的具体指代，也不用去管到底是什么样的应用程序。
ASN1有很多实现版本，OpenSSL主要采用DER格式。

本文假设你已经安装好了OpenSSL，并且持有一份1.1.1的源码。
ASN1相关的头文件为asn1.h、asn1t.h、源文件在crypto/asn1目录中。

主要结构：

struct asn1_string_st {
    int length;
    int type;
    unsigned char *data;
    long flags;
};

这个结构负责管理ANS1大多数数据类型的内存组织方式，字段含义：
length —— 管理的数据长度。
type —— 管理的数据类型。
data —— 数据指针。
flags —— 标志位，跟具体数据类型有关。

管理的数据类型：

typedef struct asn1_string_st ASN1_INTEGER;
typedef struct asn1_string_st ASN1_ENUMERATED;
typedef struct asn1_string_st ASN1_BIT_STRING;
typedef struct asn1_string_st ASN1_OCTET_STRING;
typedef struct asn1_string_st ASN1_PRINTABLESTRING;
typedef struct asn1_string_st ASN1_T61STRING;
typedef struct asn1_string_st ASN1_IA5STRING;
typedef struct asn1_string_st ASN1_GENERALSTRING;
typedef struct asn1_string_st ASN1_UNIVERSALSTRING;
typedef struct asn1_string_st ASN1_BMPSTRING;
typedef struct asn1_string_st ASN1_UTCTIME;
typedef struct asn1_string_st ASN1_TIME;
typedef struct asn1_string_st ASN1_GENERALIZEDTIME;
typedef struct asn1_string_st ASN1_VISIBLESTRING;
typedef struct asn1_string_st ASN1_UTF8STRING;
typedef struct asn1_string_st ASN1_STRING;

主要数据类型的取值：

# define V_ASN1_EOC                      0
# define V_ASN1_BOOLEAN                  1 /**/
# define V_ASN1_INTEGER                  2
# define V_ASN1_BIT_STRING               3
# define V_ASN1_OCTET_STRING             4
# define V_ASN1_NULL                     5
# define V_ASN1_OBJECT                   6
# define V_ASN1_OBJECT_DESCRIPTOR        7
# define V_ASN1_EXTERNAL                 8
# define V_ASN1_REAL                     9
# define V_ASN1_ENUMERATED               10
# define V_ASN1_UTF8STRING               12
# define V_ASN1_SEQUENCE                 16
# define V_ASN1_SET                      17
# define V_ASN1_NUMERICSTRING            18 /**/
# define V_ASN1_PRINTABLESTRING          19
# define V_ASN1_T61STRING                20
# define V_ASN1_TELETEXSTRING            20/* alias */
# define V_ASN1_VIDEOTEXSTRING           21 /**/
# define V_ASN1_IA5STRING                22
# define V_ASN1_UTCTIME                  23
# define V_ASN1_GENERALIZEDTIME          24 /**/
# define V_ASN1_GRAPHICSTRING            25 /**/
# define V_ASN1_ISO64STRING              26 /**/
# define V_ASN1_VISIBLESTRING            26/* alias */
# define V_ASN1_GENERALSTRING            27 /**/
# define V_ASN1_UNIVERSALSTRING          28 /**/
# define V_ASN1_BMPSTRING                30

其它一些类型的定义：

typedef int ASN1_BOOLEAN;
typedef int ASN1_NULL;
struct asn1_object_st {
    const char *sn, *ln;
    int nid;
    int length;
    const unsigned char *data;
    int flags;
};
typedef struct asn1_object_st ASN1_OBJECT;

数据类型转换的ITEM定义：

在OpenSSL的实现中，每个数据类型都有一个ITEM结构，它负责定义这个数据类型的编解码规则。

struct ASN1_ITEM_st {
    char itype;                 /* The item type, primitive, SEQUENCE, CHOICE
                                 * or extern */
    long utype;                 /* underlying type */
    const ASN1_TEMPLATE *templates; /* If SEQUENCE or CHOICE this contains
                                     * the contents */
    long tcount;                /* Number of templates if SEQUENCE or CHOICE */
    const void *funcs;          /* functions that handle this type */
    long size;                  /* Structure size (usually) */
    const char *sname;          /* Structure name */
};
typedef struct ASN1_ITEM_st ASN1_ITEM;
typedef const ASN1_ITEM ASN1_ITEM_EXP;

相关字段含义如下：
itype —— 定义ITEM自身的类型，取值：

#define ASN1_ITYPE_PRIMITIVE            0x0
#define ASN1_ITYPE_SEQUENCE             0x1
#define ASN1_ITYPE_CHOICE               0x2
#define ASN1_ITYPE_EXTERN               0x4
#define ASN1_ITYPE_MSTRING              0x5
#define ASN1_ITYPE_NDEF_SEQUENCE        0x6

utype —— 定义管理的数据类型，取值前面有说明，例如V_ASN1_INTEGER。
templates —— 数据处理方法模板数组指针。
tcount —— 模板数组的个数。
funcs —— 回调方法指针。
size —— 负责数据结构的大小。
sname —— 指向数据结构的名称。

数据类型的函数声明和实现：

前面讲到，对每个数据类型来说，OpenSSL需要一个对应的ITEM结构，下面这几个宏为每个数据类型声明ITEM结构，同时也声明了相应的助记函数。如下：

# define DECLARE_ASN1_FUNCTIONS(type) DECLARE_ASN1_FUNCTIONS_name(type, type)

# define DECLARE_ASN1_FUNCTIONS_name(type, name) \
        DECLARE_ASN1_ALLOC_FUNCTIONS_name(type, name) \
        DECLARE_ASN1_ENCODE_FUNCTIONS(type, name, name)

# define DECLARE_ASN1_ALLOC_FUNCTIONS_name(type, name) \
        type *name##_new(void); \
        void name##_free(type *a);

# define DECLARE_ASN1_ENCODE_FUNCTIONS(type, itname, name) \
        type *d2i_##name(type **a, const unsigned char **in, long len); \
        int i2d_##name(type *a, unsigned char **out); \
        DECLARE_ASN1_ITEM(itname)

#  define DECLARE_ASN1_ITEM(name) \
        OPENSSL_EXTERN const ASN1_ITEM name##_it;

#  define ASN1_ITEM_ref(iptr) (&(iptr##_it))
#  define ASN1_ITEM_rptr(ref) (&(ref##_it))

拿 DECLARE_ASN1_FUNCTIONS(ASN1_INTEGER) 来说，宏定义展开形式为：

ASN1_INTEGER *ASN1_INTEGER_new(void); 
void ASN1_INTEGER_free(ASN1_INTEGER *a);
type *d2i_ASN1_INTEGER(ASN1_INTEGER **a, const unsigned char **in, long len); 
int i2d_ASN1_INTEGER(ASN1_INTEGER *a, unsigned char **out); 
const ASN1_ITEM ASN1_INTEGER_it;

还有几个宏负责为数据类型实现相应的助记函数。如下：

# define IMPLEMENT_ASN1_FUNCTIONS(stname) IMPLEMENT_ASN1_FUNCTIONS_fname(stname, stname, stname)

# define IMPLEMENT_ASN1_FUNCTIONS_name(stname, itname) IMPLEMENT_ASN1_FUNCTIONS_fname(stname, itname, itname)

# define IMPLEMENT_ASN1_FUNCTIONS_fname(stname, itname, fname) \
        IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname) \
        IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname)

# define IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname) \
        stname *fname##_new(void) \
        { \
                return (stname *)ASN1_item_new(ASN1_ITEM_rptr(itname)); \
        } \
        void fname##_free(stname *a) \
        { \
                ASN1_item_free((ASN1_VALUE *)a, ASN1_ITEM_rptr(itname)); \
        }

# define IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname) \
        stname *d2i_##fname(stname **a, const unsigned char **in, long len) \
        { \
                return (stname *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, ASN1_ITEM_rptr(itname));\
        } \
        int i2d_##fname(stname *a, unsigned char **out) \
        { \
                return ASN1_item_i2d((ASN1_VALUE *)a, out, ASN1_ITEM_rptr(itname));\
        }

拿 IMPLEMENT_ASN1_ITEM(ASN1_INTEGER) 来说，其展开形式为：

ASN1_INTEGER *ASN1_INTEGER_new(void)
{
    return (ASN1_INTEGER*)ASN1_item_new(ASN1_ITEM_rptr(ASN1_INTEGER));
}
void ASN1_INTEGER_free(ASN1_INTEGER *a)
{
    ASN1_item_free((ASN1_VALUE *)a, ASN1_ITEM_rptr(ASN1_INTEGER));
}
ASN1_INTEGER *d2i_ASN1_INTEGER(ASN1_INTEGER **a, const unsigned char **in, long len)
{
    return (ASN1_INTEGER*)ASN1_item_d2i((ASN1_VALUE **)a, in, len, ASN1_ITEM_rptr(ASN1_INTEGER));
}
int i2d_ASN1_INTEGER(ASN1_INTEGER *a, unsigned char **out)
{
    return ASN1_item_i2d((ASN1_VALUE *)a, out, ASN1_ITEM_rptr(ASN1_INTEGER));
}

可以看到，展开形式所实现的助记函数实际上是对ASN1内部几个函数的封装调用，对提供上层数据类型与内部类型的转换，其中ASN1_VALUE是类型上下转换的纽带，它是个万能指针：
typedef struct ASN1_VALUE_st ASN1_VALUE;

在asn1.h中，对基本数据类型声明了助记函数：

DECLARE_ASN1_FUNCTIONS(ASN1_INTEGER)
DECLARE_ASN1_FUNCTIONS(ASN1_ENUMERATED)
DECLARE_ASN1_FUNCTIONS(ASN1_BIT_STRING)
DECLARE_ASN1_FUNCTIONS(ASN1_OCTET_STRING)
DECLARE_ASN1_FUNCTIONS(ASN1_NULL)
DECLARE_ASN1_FUNCTIONS(ASN1_UTCTIME)
DECLARE_ASN1_FUNCTIONS(ASN1_GENERALIZEDTIME)
DECLARE_ASN1_FUNCTIONS(ASN1_TIME)
DECLARE_ASN1_FUNCTIONS(ASN1_UTF8STRING)

可是我暂时还没有找到对基本数据类型助记函数的宏实现。

自定义结构体支持：

OpenSSL的ASN1编码处理依赖ASN1_ITEM对象，对基本类型来说，OpenSSL本身已经做了声明和初使化，所以可以直接以相关函数中使用。然而对于自定义结构体，需要开发者来定义ASN1_ITEM对象和规则，有一些宏可以提供帮助，摘录部分如下：

# define ASN1_SEQUENCE(tname) \
        static const ASN1_TEMPLATE tname##_seq_tt[]

# define ASN1_SEQUENCE_END(stname) ASN1_SEQUENCE_END_name(stname, stname)

# define ASN1_SEQUENCE_END_name(stname, tname) \
        ;\
        ASN1_ITEM_start(tname) \
                ASN1_ITYPE_SEQUENCE,\
                V_ASN1_SEQUENCE,\
                tname##_seq_tt,\
                sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\
                NULL,\
                sizeof(stname),\
                #tname \
        ASN1_ITEM_end(tname)

#  define ASN1_ITEM_start(itname) \
        const ASN1_ITEM itname##_it = {
#  define ASN1_ITEM_end(itname)                 \
                };

# define ASN1_SIMPLE(stname, field, type) ASN1_EX_TYPE(0,0, stname, field, type)

# define ASN1_EX_TYPE(flags, tag, stname, field, type) { \
        (flags), (tag), offsetof(stname, field),\
        #field, ASN1_ITEM_ref(type) }

在ASN1_ITEM结构中，ASN1_TEMPLATE的结构定义如下：

struct ASN1_TEMPLATE_st {
    unsigned long flags;        /* Various flags */
    long tag;                   /* tag, not used if no tagging */
    unsigned long offset;       /* Offset of this field in structure */
    const char *field_name;     /* Field name */
    ASN1_ITEM_EXP *item;        /* Relevant ASN1_ITEM or ASN1_ADB */
};
typedef struct ASN1_TEMPLATE_st ASN1_TEMPLATE;

主要字段含义：
offset —— 字段在父结构中的偏移。
field_name —— 字段名称。
item —— 指向字段对应结构类型的ASN1_ITEM对象。

举例定义如下的自定义结构：

typedef  struct X509V4_VALID_st
{
    ASN1_GENERALIZEDTIME *notBefore;
    ASN1_GENERALIZEDTIME *notAfter;
} X509V4_VALID;
DECLARE_ASN1_FUNCTIONS(X509V4_VALID)

ASN1_SEQUENCE(X509V4_VALID) =
{
    ASN1_SIMPLE(X509V4_VALID, notBefore, ASN1_GENERALIZEDTIME),
    ASN1_SIMPLE(X509V4_VALID, notAfter, ASN1_GENERALIZEDTIME)
} 
ASN1_SEQUENCE_END(X509V4_VALID)
IMPLEMENT_ASN1_FUNCTIONS(X509V4_VALID)

将宏展开，为：

static const ASN1_TEMPLATE X509V4_VALID_seq_tt[] = 
{
    { 0, 0, offsetof(X509V4_VALID, notBefore), notBefore, ASN1_ITEM_ref(ASN1_GENERALIZEDTIME) },
    { 0, 0, offsetof(X509V4_VALID, notAfter), notAfter, ASN1_ITEM_ref(ASN1_GENERALIZEDTIME) }
};
const ASN1_ITEM X509V4_VALID_it = {
    ASN1_ITYPE_SEQUENCE,\
    V_ASN1_SEQUENCE,\
    X509V4_VALID_seq_tt,\
    sizeof(X509V4_VALID_seq_tt) / sizeof(ASN1_TEMPLATE),\
    NULL,\
    sizeof(X509V4_VALID,),\
    X509V4_VALID \
};

常用函数：

ASN1_VALUE *ASN1_item_new(const ASN1_ITEM *it);
void ASN1_item_free(ASN1_VALUE *val, const ASN1_ITEM *it);
根据ITEM对象创建和释放对应的数据类型。

ASN1_VALUE *ASN1_item_d2i(ASN1_VALUE **val, const unsigned char **in, long len, const ASN1_ITEM *it);
根据ITEM对象将DER编码转换为二进制结构。
成功返回有效指针，成功返回NULL。
如果val为NULL，将内部分配内存，但必须由外部使用者释放。
其内部实现为：

{
    ASN1_TLC c;
    ASN1_VALUE *ptmpval = NULL;
    if (!pval)
        pval = &ptmpval;
    asn1_tlc_clear_nc(&c);
    if (ASN1_item_ex_d2i(pval, in, len, it, -1, 0, 0, &c) > 0)
        return *pval;
    return NULL;
}

可以看到内部做了为val传入NULL的兼容性处理。

int ASN1_item_i2d(ASN1_VALUE *val, unsigned char **out, const ASN1_ITEM *it);
根据ITEM对象将二进制结构转换为DER编码。
成功返回DER编码长度，失败返回负数。
如果*out为NULL，将内部分配内存，但内存必须由外部使用者释放。若**out为NULL，将仅返回长度，这用于试探长度的场景。
其内部实现为：

{
    if (out && !*out) {
        unsigned char *p, *buf;
        int len;

        len = ASN1_item_ex_i2d(&val, NULL, it, -1, flags);
        if (len <= 0)
            return len;
        if ((buf = OPENSSL_malloc(len)) == NULL) {
            ASN1err(ASN1_F_ASN1_ITEM_FLAGS_I2D, ERR_R_MALLOC_FAILURE);
            return -1;
        }
        p = buf;
        ASN1_item_ex_i2d(&val, &p, it, -1, flags);
        *out = buf;
        return len;
    }

    return ASN1_item_ex_i2d(&val, out, it, -1, flags);
}

可以看到内部做了为out和*out传入NULL的兼容性处理。在out传入NULL的情况下，无法接收缓冲区，只能返回长度。

void *ASN1_item_d2i_bio(const ASN1_ITEM *it, BIO *in, void *x);
根据ITEM对象将DER编码转换为二进制结构，输入的DER编码来源于BIO对象。
成功返回有效指针，成功返回NULL。
事实上，本函数是对ASN1_item_d2i()的封装调用。
其内部实现为：

{
    const unsigned char *p;
    void *ret = NULL;
    int len;

    BUF_MEM *b = NULL;
    len = asn1_d2i_read_bio(in, &b);
    if (len < 0)
        goto err;

    p = (const unsigned char *)b->data;
    ret = ASN1_item_d2i(x, &p, len, it);
 err:
    BUF_MEM_free(b);
    return ret;
}

void *ASN1_item_d2i_fp(const ASN1_ITEM *it, FILE *in, void *x);
ASN1_item_d2i_bio()的FILE版本。

ASN1_item_d2i_bio()和ASN1_item_d2i_fp() 这两个函数关于输出参数x的类型定义是不恰当的，后面讲的 ASN1_d2i_bio()和ASN1_d2i_bio() 有修复这个问题。

int ASN1_item_i2d_bio(const ASN1_ITEM *it, BIO *out, void *x);
根据ITEM对象将二进制结构转换为DER编码，输出到BIO对象中。
成功返回DER编码长度，失败返回负数。
如果*out为NULL，将内部分配内存，但内存必须由外部使用者释放。事实上，本函数是对ASN1_item_i2d()的封装调用。
其内部实现为：

{
    int i, j = 0, n, ret = 1;

    unsigned char *b = NULL;
    n = ASN1_item_i2d(x, &b, it);
    if (b == NULL) {
        ASN1err(ASN1_F_ASN1_ITEM_I2D_BIO, ERR_R_MALLOC_FAILURE);
        return 0;
    }

    for (;;) {
        i = BIO_write(out, &(b[j]), n);
        if (i == n)
            break;
        if (i <= 0) {
            ret = 0;
            break;
        }
        j += i;
        n -= i;
    }
    OPENSSL_free(b);
    return ret;
}

int ASN1_item_i2d_fp(const ASN1_ITEM *it, FILE *out, void *x);
ASN1_item_i2d_bio()的FILE版本。

其实上，以上函数由于直接需要ASN1_ITEM做为参数，很少在程序中直接使用，而是由DECLARE_ASN1_FUNCTIONS宏声明的变体，或者下面介绍的函数代替。

void *ASN1_d2i_bio(void *(*xnew) (void), d2i_of_void *d2i, BIO *in, void **x);
从BIO对象读取DER编码数据，转换为对应的二进制结构，具体的转换依赖d2i函数指针。
成功返回有效指针，失改返回NULL。
其内部实现为：

{
    BUF_MEM *b = NULL;
    int len = asn1_d2i_read_bio(in, &b);
    if (len < 0)
        goto err;
    const unsigned char *p = (unsigned char *)b->data;
    void *ret = d2i(x, &p, len);
 err:
    BUF_MEM_free(b);
    return ret;
}

void *ASN1_d2i_fp(void *(*xnew) (void), d2i_of_void *d2i, FILE *in, void **x);
ASN1_d2i_bio()的FILE版本。

int ASN1_i2d_bio(i2d_of_void *i2d, BIO *out, unsigned char *x);
将二进制结构转换为DER编码，输出到BIO中，具体的转换依赖i2d函数指针。
成功返回1，失败返回0。
其内部实现为：

{
    int ret = 1;

    int n = i2d(x, NULL);
    if (n <= 0)
        return 0;

    char* b = OPENSSL_malloc(n);
    unsigned char *p = (unsigned char *)b;
    i2d(x, &p);

    int i, j = 0;
    for (;;) {
        i = BIO_write(out, &(b[j]), n);
        if (i == n)
            break;
        if (i <= 0) {
            ret = 0;
            break;
        }
        j += i;
        n -= i;
    }
    OPENSSL_free(b);
    return ret;
}

int ASN1_i2d_fp(i2d_of_void *i2d, FILE *out, void *x);
ASN1_i2d_bio() 的FILE版本。

上面d2i_of_void 和 i2d_of_void 函数的签名为：

# define D2I_OF(type) type *(*)(type **,const unsigned char **,long)
# define I2D_OF(type) int (*)(type *,unsigned char **)

通常为数据类型的转换助记函数。

int ASN1_INTEGER_set(ASN1_INTEGER *a, long v);
将v值设置到a中。成功返回1，失败返回0。
long ASN1_INTEGER_get(const ASN1_INTEGER *a);
获取a中存储的整数值。失败返回-1。
int ASN1_ENUMERATED_set(ASN1_ENUMERATED *a, long v);
将v值设置到a中。成功返回1，失败返回0。
long ASN1_ENUMERATED_get(const ASN1_ENUMERATED *a);
获取a中存储的枚举值。失败返回-1。
int ASN1_STRING_set(ASN1_STRING *str, const void *data, int len);
将data和len指向的串值设置到str中。成功返回1，失败返回0。
unsigned char *ASN1_STRING_data(ASN1_STRING *x);
获取x的字符串首指针。成功返回有效指针，失败返回NULL。
int ASN1_STRING_length(const ASN1_STRING *x);
获取x的字符串长度。

int i2a_ASN1_INTEGER(BIO *bp, const ASN1_INTEGER *a);
将ASN1_INTEGER转换为ASC码，输出到bp中。成功返回1，失败返回0。
int a2i_ASN1_INTEGER(BIO *bp, ASN1_INTEGER *bs, char *buf, int size);
将bp中的ASC码转换为ASN1_INTEGER，buf存放BIO的ASC码。成功返回1，失败返回0。
int i2a_ASN1_ENUMERATED(BIO *bp, const ASN1_ENUMERATED *a);
将ASN1_ENUMERATED转换为ASC码，输出到bp中。成功返回1，失败返回0。
int a2i_ASN1_ENUMERATED(BIO *bp, ASN1_ENUMERATED *bs, char *buf, int size);
将bp中的ASC码转换为ASN1_ENUMERATED，buf存放BIO的ASC码。成功返回1，失败返回0。
int i2a_ASN1_STRING(BIO *bp, const ASN1_STRING *a, int type);
将a中的字符串转换为ASC码输出到bp中，type不起作用。返回转换的ASC字符串长度。
int a2i_ASN1_STRING(BIO *bp, ASN1_STRING *bs, char *buf, int size);
将bp中的ASC码转换为ASN1_STRING，buf存放BIO的ASC码。成功返回1，失败返回0。

ASN1_OBJECT *ASN1_OBJECT_new(void);
分配OID对象。
void ASN1_OBJECT_free(ASN1_OBJECT *a);
释放OID对象。

OID的编码规为：第一个八位组采用公式：first_arc* 40+second_arc。如果一个数大于127,就采用多个8位表示，最高位用1表示后续还有octet,用0表示后续没有。成功返回OID编码的字节数。

int a2d_ASN1_OBJECT(unsigned char *out, int olen, const char *buf, int num);
计算由ASC字符串指定的OID的DER编码。返回编码的字节数。所果事先需要知道编码的长度来分配内存，可以设置out为NULL，olen为0，获取编码字节长度，根据该长度再去分配内存。

ASN1_OBJECT *d2i_ASN1_OBJECT(ASN1_OBJECT **a, const unsigned char **pp, long length);
将DER编码转换为OID对象。成功返回有效指针。
int i2d_ASN1_OBJECT(const ASN1_OBJECT *a, unsigned char **pp);
将OID对象换转为DER编码。返回DER编码的长度。
int i2a_ASN1_OBJECT(BIO *bp, const ASN1_OBJECT *a);
将DER编码转换为ASC字符串，结果输出到bp中。返回ASC字符串长度。

使用举例：

下面这个例子测试了很多函数的用法，请自行放开注释并测试。

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>

#include <openssl/asn1.h>
#include <openssl/asn1t.h>

namespace dakuang {}

void printHex(const char* pBuf, int nLen)
{
    for (int i = 0; i < nLen; ++i)
    {
        printf("%02x", (unsigned char)pBuf[i]);
    }
    printf("\n");
}

int main(int argc, char* argv[])
{
/*
    int len = a2d_ASN1_OBJECT(NULL, 0, "1.2.840.10040.4.1", -1);
    printf("len:%d \n", len);
    char* pBuf = (char*)malloc(len);
    int ret = a2d_ASN1_OBJECT((unsigned char *)pBuf, len, "1.2.840.10040.4.1", -1);
    printf("ret:%d \n", ret);
    printf("buf => ");
    printHex(pBuf, len);
    free(pBuf);
*/

/*
    BIO* bp = BIO_new(BIO_s_mem());
    BIO_write(bp, "0FAB08BBDDEECC", 14);
    ASN1_INTEGER* i = ASN1_INTEGER_new();
    char sBuf[50] = {0};
    int ret = a2i_ASN1_INTEGER(bp, i, sBuf, 50);
    printf("ret:%d \n", ret);
    long l = ASN1_INTEGER_get(i);
    printf("l:[%ld] \n", l);
    ASN1_INTEGER_free(i);
    BIO_free(bp);
*/

/*
    BIO* bp = BIO_new(BIO_s_mem());
    BIO_write(bp, "B2E2CAD4", 8);
    ASN1_STRING* str = ASN1_STRING_new();
    char sBuf[50] = {0};
    int ret = a2i_ASN1_STRING(bp, str, sBuf, 50);
    printf("ret:%d \n", ret);
    int len = ASN1_STRING_length(str);
    printf("len:%d \n", len);
    printf("buf => ");
    printHex(sBuf, len);
    unsigned char* p = ASN1_STRING_data(str);
    printf("str:[%s] \n", p);
    ASN1_STRING_free(str);
    BIO_free(bp);
*/

/*
    ASN1_INTEGER* i = ASN1_INTEGER_new();
    int ret = ASN1_INTEGER_set(i, 123);
    printf("ret:%d \n", ret);
    long l = ASN1_INTEGER_get(i);
    printf("l:[%ld] \n", l);
    ASN1_INTEGER_free(i);
*/

/*
    ASN1_STRING* str = ASN1_STRING_new();
    int ret = ASN1_STRING_set(str, "abc", 3);
    printf("ret:%d \n", ret);
    unsigned char* p = ASN1_STRING_data(str);
    printf("str:[%s] \n", p);
    ASN1_STRING_free(str);
*/

/*
    ASN1_STRING* str = ASN1_STRING_new();
    int ret = ASN1_STRING_set(str, "abc", 3);
    printf("ret:%d \n", ret);
    BIO* bp = BIO_new(BIO_s_file());
    BIO_set_fp(bp, stdout, BIO_NOCLOSE);
    ret = i2a_ASN1_STRING(bp, str, 0);
    printf("ret:%d \n", ret);
    BIO_free(bp);
    ASN1_STRING_free(str);
*/

/*
    BIO* out = BIO_new_file("int.cer","w");
    ASN1_INTEGER* a = ASN1_INTEGER_new();
    ASN1_INTEGER_set(a, 100);
    int ret = ASN1_i2d_bio((i2d_of_void*)i2d_ASN1_INTEGER, out, (unsigned char*)a);
    printf("ret:%d \n", ret);
    BIO_free(out);
*/

/*
    BIO* in = BIO_new_file("int.cer","r");
    ASN1_INTEGER* a = ASN1_INTEGER_new();
    ASN1_d2i_bio(NULL, (d2i_of_void *)d2i_ASN1_INTEGER, in, (void**)&a);
    long l = ASN1_INTEGER_get(a);
    printf("l:[%ld] \n", l);
    ASN1_INTEGER_free(a);
    BIO_free(in);
*/

/*
    char buf[50] = {0};
    int ret = a2d_ASN1_OBJECT((unsigned char*)buf, 50, "1.2.3.4", -1);
    printf("ret:%d \n", ret);
    printf("buf => ");
    printHex(buf, ret);
    ASN1_OBJECT* o = ASN1_OBJECT_new();
    printf("o:[%p] \n", o);
    d2i_ASN1_OBJECT(&o, (const unsigned char**)&buf, ret);
    ret = i2d_ASN1_OBJECT(o, (unsigned char**)&buf);
    printf("ret:%d \n", ret);
    BIO* bp = BIO_new(BIO_s_file());
    BIO_set_fp(bp, stdout, BIO_NOCLOSE);
    ret = i2a_ASN1_OBJECT(bp, o);
    printf("ret:%d \n", ret);
    BIO_free(bp);
    ASN1_OBJECT_free(o);
*/
    return 0;
}
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 217,826评论 6赞 506
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 92,968评论 3赞 395
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 164,234评论 0赞 354
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 58,562评论 1赞 293
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 67,611评论 6赞 392
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 51,482评论 1赞 302
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 40,271评论 3赞 418
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 39,166评论 0赞 276
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 45,608评论 1赞 314
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 37,814评论 3赞 336
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 39,926评论 1赞 348
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 35,644评论 5赞 346
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 41,249评论 3赞 329
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 31,866评论 0赞 22
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,991评论 1赞 269
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 48,063评论 3赞 370
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 44,871评论 2赞 354

推荐阅读更多精彩内容

  • openssl相关数据结构的设计
    hash表 数据结构：使用链表数组实现 相关接口 内存分配 内存相关数据结构 内存操作相关接口 CRYPTO_me...
    镜中无我阅读 556评论 0赞 0
  • openssl编程RSA
    转：http://caisenchen.blog.163.com/blog/static/552865502008...
    right_33cb阅读 4,347评论 0赞 4
  • OpenSSL之大数用法
    大数一般指的是位数很多的数。计算机表示的数的大小是有限的，精度也是有限的，它不能支持大数运算。密码学中采用了很多大...
    大匡先生阅读 3,762评论 0赞 1
  • OpenSSL之随机数用法
    随机数是一种无规律的数，但是真正做到完全无规律也较困难，所以一般将它称之为伪随机数。随机数在密码学用的很多，比如S...
    大匡先生阅读 7,750评论 0赞 2
  • 2019-11-28 173
    16宿命：用概率思维提高你的胜算 以前的我是风险厌恶者，不喜欢去冒险，但是人生放弃了冒险，也就放弃了无数的可能。 ...
    yichen大刀阅读 6,050评论 0赞 4