819 lines
18 KiB
C
Executable File
819 lines
18 KiB
C
Executable File
/*
|
||
**********************************************************************************************************************
|
||
* eGon
|
||
* the Embedded GO-ON Bootloader System
|
||
* eGON arm boot sub-system
|
||
*
|
||
* Copyright(C), 2006-2014, Allwinner Technology Co., Ltd.
|
||
* All Rights Reserved
|
||
*
|
||
* File :
|
||
*
|
||
* By : Jerry
|
||
*
|
||
* Version : V2.00
|
||
*
|
||
* Date :
|
||
*
|
||
* Descript:
|
||
**********************************************************************************************************************
|
||
*/
|
||
#include "common.h"
|
||
#include "linux/ctype.h"
|
||
#include "openssl_ext.h"
|
||
#include <asm/arch/ss.h>
|
||
|
||
extern void sid_read_rotpk(void *dst) ;
|
||
int sunxi_bytes_merge(u8 *dst, u32 dst_len, u8 *src, uint src_len);
|
||
/*
|
||
************************************************************************************************************
|
||
*
|
||
* function
|
||
*
|
||
* name :
|
||
*
|
||
* parmeters :
|
||
*
|
||
* return :
|
||
*
|
||
* note :
|
||
*
|
||
*
|
||
************************************************************************************************************
|
||
*/
|
||
static int __asn1_probe_data_head(u8 *buf, sunxi_asn1_t *asn1)
|
||
{
|
||
u8 *tmp_buf = buf;
|
||
int index;
|
||
int len, len_bytes;
|
||
|
||
asn1->head = tmp_buf[0];
|
||
asn1->head_len = 2;
|
||
//获取长度
|
||
len = tmp_buf[1];
|
||
if(len & 0x80) //超过1个字节表示长度
|
||
{
|
||
len_bytes = len & 0x7f;
|
||
if((!len_bytes) || (len_bytes>4))
|
||
{
|
||
printf("len_bytes(%d) is 0 or larger than 4, cant be probe\n", len_bytes);
|
||
|
||
return -1;
|
||
}
|
||
asn1->head_len += len_bytes;
|
||
index = 2;
|
||
len = 0;
|
||
while(--len_bytes);
|
||
{
|
||
len += tmp_buf[index++];
|
||
len *= 256;
|
||
}
|
||
len |= tmp_buf[index];
|
||
|
||
}
|
||
asn1->data = buf + asn1->head_len;
|
||
asn1->data_len = len;
|
||
|
||
return 0;
|
||
}
|
||
/*
|
||
************************************************************************************************************
|
||
*
|
||
* function
|
||
*
|
||
* name :
|
||
*
|
||
* parmeters :
|
||
*
|
||
* return :
|
||
*
|
||
* note :
|
||
*
|
||
*
|
||
************************************************************************************************************
|
||
*/
|
||
static int __sunxi_publickey_dipatch(sunxi_key_t *pkey, u8 *buf, u32 len)
|
||
{
|
||
u8 *tmp_buf = buf;
|
||
int ret;
|
||
sunxi_asn1_t asn1;
|
||
|
||
ret = __asn1_probe_data_head(tmp_buf, &asn1);
|
||
if(ret < 0) //
|
||
{
|
||
printf("publickey_dipatch err: head is not a sequence\n");
|
||
|
||
return -1;
|
||
}
|
||
tmp_buf += asn1.head_len; //跳过sequnce头部
|
||
ret = __asn1_probe_data_head(tmp_buf, &asn1);
|
||
if((ret) || (asn1.head != 0x2)) //
|
||
{
|
||
printf("publickey_dipatch err: step 2\n");
|
||
|
||
return -2;
|
||
}
|
||
pkey->n = malloc(asn1.data_len);
|
||
memcpy(pkey->n, asn1.data, asn1.data_len);
|
||
pkey->n_len = asn1.data_len;
|
||
|
||
tmp_buf = asn1.data + asn1.data_len;
|
||
ret = __asn1_probe_data_head(tmp_buf, &asn1);
|
||
if((ret) || (asn1.head != 0x2))
|
||
{
|
||
printf("publickey_dipatch err: step 3\n");
|
||
|
||
return -3;
|
||
}
|
||
|
||
pkey->e = malloc(asn1.data_len);
|
||
memcpy(pkey->e, asn1.data, asn1.data_len);
|
||
pkey->e_len = asn1.data_len;
|
||
|
||
return 0;
|
||
}
|
||
/*
|
||
************************************************************************************************************
|
||
*
|
||
* function
|
||
*
|
||
* name :
|
||
*
|
||
* parmeters :
|
||
*
|
||
* return :
|
||
*
|
||
* note :
|
||
*
|
||
*
|
||
************************************************************************************************************
|
||
*/
|
||
static int __certif_probe_signdata(u8 *dst_buf, u32 dst_len_max, u8 *src_buf, u32 src_len)
|
||
{
|
||
u8 *tmp_buf = src_buf;
|
||
int ret;
|
||
sunxi_asn1_t asn1;
|
||
|
||
ret = __asn1_probe_data_head(tmp_buf, &asn1);
|
||
if(ret < 0) //
|
||
{
|
||
printf("certif_decode err: head is not a sequence\n");
|
||
|
||
return -1;
|
||
}
|
||
tmp_buf += asn1.head_len; //跳过sequnce头部
|
||
ret = __asn1_probe_data_head(tmp_buf, &asn1);
|
||
if(ret)
|
||
{
|
||
printf("certif_decode err: step 1\n");
|
||
|
||
return -2;
|
||
}
|
||
|
||
if(asn1.data_len > dst_len_max)
|
||
{
|
||
printf("sign data len (0x%x) is longer then buffer size (0x%x)\n", asn1.data_len, dst_len_max);
|
||
|
||
return -1;
|
||
}
|
||
memcpy(dst_buf, tmp_buf, asn1.data_len + asn1.head_len);
|
||
|
||
return asn1.data_len + asn1.head_len;
|
||
}
|
||
/*
|
||
************************************************************************************************************
|
||
*
|
||
* function
|
||
*
|
||
* name :
|
||
*
|
||
* parmeters :
|
||
*
|
||
* return :
|
||
*
|
||
* note :
|
||
*
|
||
*
|
||
************************************************************************************************************
|
||
*/
|
||
static uint __merge_extension_value(u8 **dst_buf, u8 *src_buf, uint src_buf_len)
|
||
{
|
||
u8 *tmp_buf = src_buf;
|
||
sunxi_asn1_t asn1;
|
||
int ret;
|
||
uint tmp_len;
|
||
|
||
ret = __asn1_probe_data_head(tmp_buf, &asn1);
|
||
if(ret < 0) //
|
||
{
|
||
printf("__merge_extension_value err: head is not a sequence\n");
|
||
|
||
return 0;
|
||
}
|
||
|
||
if(asn1.data_len + asn1.head_len > src_buf_len)
|
||
{
|
||
printf("__merge_extension_value err: the data source len is too short\n");
|
||
|
||
return 0;
|
||
}
|
||
*dst_buf = malloc((asn1.data_len + 1)/2);
|
||
memset(*dst_buf, 0, (asn1.data_len + 1)/2);
|
||
tmp_len = asn1.data_len;
|
||
if(tmp_len > 512) //rsakey
|
||
{
|
||
u8 *src = asn1.data;
|
||
if((src[0] == '0') && (src[1] == '0'))
|
||
{
|
||
src += 2;
|
||
}
|
||
if(sunxi_bytes_merge(*dst_buf, asn1.data_len, src, 512))
|
||
{
|
||
printf("__merge_extension_value err1: in sunxi_bytes_merge\n");
|
||
|
||
return 0;
|
||
}
|
||
if(sunxi_bytes_merge(*dst_buf + 512/2, asn1.data_len, src + 512, asn1.data_len - 512 - (src-asn1.data)))
|
||
{
|
||
printf("__merge_extension_value err2: in sunxi_bytes_merge\n");
|
||
|
||
return 0;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if(sunxi_bytes_merge(*dst_buf, asn1.data_len, asn1.data, asn1.data_len))
|
||
{
|
||
printf("__merge_extension_value err1: in sunxi_bytes_merge\n");
|
||
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
//memcpy(*dst_buf, asn1.data, asn1.data_len);
|
||
|
||
return (asn1.data_len + 1)/2;
|
||
}
|
||
/*
|
||
************************************************************************************************************
|
||
*
|
||
* function
|
||
*
|
||
* name :
|
||
*
|
||
* parmeters :
|
||
*
|
||
* return :
|
||
*
|
||
* note :
|
||
*
|
||
*
|
||
************************************************************************************************************
|
||
*/
|
||
int sunxi_certif_create(X509 **certif, u8 *buf, int len)
|
||
{
|
||
u8 *p = buf;
|
||
|
||
*certif = d2i_X509(NULL, (const unsigned char **)&p, len);
|
||
if(*certif == NULL)
|
||
{
|
||
printf("x509_create: cant get a certif\n");
|
||
|
||
return -1;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
/*
|
||
************************************************************************************************************
|
||
*
|
||
* function
|
||
*
|
||
* name :
|
||
*
|
||
* parmeters :
|
||
*
|
||
* return :
|
||
*
|
||
* note :
|
||
*
|
||
*
|
||
************************************************************************************************************
|
||
*/
|
||
int sunxi_certif_free(X509 *certif)
|
||
{
|
||
if(certif)
|
||
{
|
||
X509_free(certif);
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
/*
|
||
************************************************************************************************************
|
||
*
|
||
* function
|
||
*
|
||
* name :
|
||
*
|
||
* parmeters :
|
||
*
|
||
* return :
|
||
*
|
||
* note :
|
||
*
|
||
*
|
||
************************************************************************************************************
|
||
*/
|
||
int sunxi_certif_probe_serial_num(X509 *x)
|
||
{
|
||
ASN1_INTEGER *bs = NULL;
|
||
long serial_num = 0;
|
||
|
||
bs = X509_get_serialNumber(x);
|
||
if(bs->length <= 4)
|
||
{
|
||
serial_num = ASN1_INTEGER_get(bs);
|
||
printf("SERIANL NUMBER: 0x%x\n", (unsigned int)serial_num);
|
||
}
|
||
else
|
||
{
|
||
printf("SERIANL NUMBER: Unknown\n");
|
||
}
|
||
|
||
return 0 ;
|
||
}
|
||
/*
|
||
************************************************************************************************************
|
||
*
|
||
* function
|
||
*
|
||
* name :
|
||
*
|
||
* parmeters :
|
||
*
|
||
* return :
|
||
*
|
||
* note :
|
||
*
|
||
*
|
||
************************************************************************************************************
|
||
*/
|
||
int sunxi_certif_probe_version(X509 *x)
|
||
{
|
||
long version = 0;
|
||
|
||
version = X509_get_version(x);
|
||
printf("Version: 0x%0x\n", (unsigned int)version);
|
||
|
||
return 0;
|
||
}
|
||
/*
|
||
************************************************************************************************************
|
||
*
|
||
* function
|
||
*
|
||
* name :
|
||
*
|
||
* parmeters :
|
||
*
|
||
* return :
|
||
*
|
||
* note :
|
||
*
|
||
*
|
||
************************************************************************************************************
|
||
*/
|
||
#define BUFF_NAME_MAX 128
|
||
#define BUFF_VALUE_MAX 3072
|
||
|
||
int sunxi_certif_probe_extension(X509 *x, sunxi_certif_info_t *sunxi_certif)
|
||
{
|
||
int extension_count = X509_get_ext_count(x);
|
||
X509_EXTENSION *extension;
|
||
int i, len;
|
||
ASN1_OBJECT *obj;
|
||
u8 buff_name[BUFF_NAME_MAX];
|
||
u8 buff_value[BUFF_VALUE_MAX];
|
||
|
||
//printf("extension_count=%d\n", extension_count);
|
||
sunxi_certif->extension.extension_num = extension_count;
|
||
|
||
for(i = 0; i < extension_count; i++)
|
||
{
|
||
//printf("************%d***************\n", i);
|
||
//printf("extension name:\n");
|
||
extension=sk_X509_EXTENSION_value(x->cert_info->extensions, i);
|
||
if(!extension)
|
||
{
|
||
printf("get extersion %d fail\n", i);
|
||
|
||
return -1;
|
||
}
|
||
obj = X509_EXTENSION_get_object(extension);
|
||
if(!obj)
|
||
{
|
||
printf("get extersion obj %d fail\n", i);
|
||
|
||
return -1;
|
||
}
|
||
memset(buff_name, 0, BUFF_NAME_MAX);
|
||
//while((*(volatile int *)0)!=12);
|
||
//len = OBJ_obj2txt(buff_name, BUFF_NAME_MAX, obj, 0);
|
||
len = OBJ_obj2name((char *)buff_name, BUFF_NAME_MAX, obj);
|
||
if(!len)
|
||
{
|
||
printf("extersion %d name length is 0\n", i);
|
||
}
|
||
else
|
||
{
|
||
//printf("name len=%d\n", len);
|
||
sunxi_certif->extension.name[i] = malloc(len + 1);
|
||
memcpy(sunxi_certif->extension.name[i], buff_name, len);
|
||
sunxi_certif->extension.name[i][len] = '\0';
|
||
sunxi_certif->extension.name_len[i] = len;
|
||
|
||
//xdump(sunxi_certif->extension.name[i], len);
|
||
}
|
||
|
||
memset(buff_value,0,BUFF_NAME_MAX);
|
||
len = ASN1_STRING_mem((char *)buff_value, extension->value);
|
||
if(!len)
|
||
{
|
||
printf("extersion %d value length is 0\n", i);
|
||
}
|
||
else
|
||
{
|
||
//xdump(buff_value, len);
|
||
len = __merge_extension_value(&sunxi_certif->extension.value[i], buff_value, len);
|
||
if(!len)
|
||
{
|
||
printf("get extension value failed\n");
|
||
|
||
return -1;
|
||
}
|
||
sunxi_certif->extension.value_len[i] = len;
|
||
//printf("value len=%d\n", len);
|
||
|
||
//ndump(sunxi_certif->extension.value[i], len);
|
||
}
|
||
//printf("<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>\n");
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
/*
|
||
************************************************************************************************************
|
||
*
|
||
* function
|
||
*
|
||
* name :
|
||
*
|
||
* parmeters :
|
||
*
|
||
* return :
|
||
*
|
||
* note :
|
||
*
|
||
*
|
||
************************************************************************************************************
|
||
*/
|
||
int sunxi_certif_probe_pubkey(X509 *x, sunxi_key_t *pubkey)
|
||
{
|
||
EVP_PKEY *pkey = NULL;
|
||
int keylen;
|
||
char *buff_tmp;
|
||
// int sig_nid;
|
||
u8 keybuff[512];
|
||
|
||
pkey = X509_get_pubkey(x);
|
||
if (pkey == NULL)
|
||
{
|
||
printf("cant find the public key %s %d\n", __FILE__, __LINE__);
|
||
|
||
return -1;
|
||
}
|
||
// if(pkey->type == 6)
|
||
// {
|
||
// printf("it is rsaEncryption\n");
|
||
// }
|
||
// else
|
||
// {
|
||
// printf("unknown encryption\n");
|
||
//
|
||
// //return -1;
|
||
// }
|
||
// sig_nid = OBJ_obj2nid(x->sig_alg->algorithm);
|
||
memset(keybuff, 0, 512);
|
||
buff_tmp = (char *)keybuff;
|
||
keylen = i2d_PublicKey(pkey, (unsigned char **)&buff_tmp);
|
||
if(keylen <= 0)
|
||
{
|
||
printf("The public key is invalid\n");
|
||
|
||
return -1;
|
||
}
|
||
if(__sunxi_publickey_dipatch(pubkey, keybuff, keylen))
|
||
{
|
||
printf("get public failed\n");
|
||
|
||
return -1;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
/*
|
||
************************************************************************************************************
|
||
*
|
||
* function
|
||
*
|
||
* name :
|
||
*
|
||
* parmeters :
|
||
*
|
||
* return :
|
||
*
|
||
* note :
|
||
*
|
||
*
|
||
************************************************************************************************************
|
||
*/
|
||
void sunxi_certif_mem_reset(void)
|
||
{
|
||
reset_OBJ_nid2ln_reset();
|
||
reset_CRYPTO_reset();
|
||
reset_BIO_reset();
|
||
reset_D2I_reset();
|
||
}
|
||
/*
|
||
************************************************************************************************************
|
||
*
|
||
* function
|
||
*
|
||
* name :
|
||
*
|
||
* parmeters :
|
||
*
|
||
* return :
|
||
*
|
||
* note :
|
||
*
|
||
*
|
||
************************************************************************************************************
|
||
*/
|
||
int sunxi_certif_probe_signature(X509 *x, u8 *sign)
|
||
{
|
||
memcpy(sign, x->signature->data, x->signature->length);
|
||
|
||
return 0;
|
||
}
|
||
|
||
/*
|
||
************************************************************************************************************
|
||
*
|
||
* function
|
||
*
|
||
* name :
|
||
*
|
||
* parmeters : buf: 证书存放起始 len：数据长度
|
||
*
|
||
* return :
|
||
*
|
||
* note : 证书自校验
|
||
*
|
||
*
|
||
************************************************************************************************************
|
||
*/
|
||
int sunxi_certif_verify_itself(sunxi_certif_info_t *sunxi_certif, u8 *buf, u32 len)
|
||
{
|
||
X509 *certif;
|
||
int ret;
|
||
u8 hash_of_certif[256];
|
||
u8 hash_of_sign[256];
|
||
|
||
u8 sign_in_certif[256];
|
||
u8 *p_sign_to_calc;
|
||
u32 sign_src_len;
|
||
|
||
//内存初始化
|
||
sunxi_certif_mem_reset();
|
||
//创建证书
|
||
ret = sunxi_certif_create(&certif, buf, len);
|
||
if(ret < 0)
|
||
{
|
||
printf("fail to create a certif\n");
|
||
|
||
return -1;
|
||
}
|
||
//获取证书公钥
|
||
ret = sunxi_certif_probe_pubkey(certif, &sunxi_certif->pubkey);
|
||
if(ret)
|
||
{
|
||
printf("fail to probe the public key\n");
|
||
|
||
return -1;
|
||
}
|
||
//获取证书签名
|
||
ret = sunxi_certif_probe_signature(certif, sign_in_certif);
|
||
if(ret)
|
||
{
|
||
printf("fail to probe the sign value\n");
|
||
|
||
return -1;
|
||
}
|
||
//获取需要签名内容
|
||
//计算sha256时，必须保证内存起始位置16字节对齐，这里采取了32字节对齐
|
||
p_sign_to_calc = malloc(4096); //证书中待签名内容肯定不超过4k
|
||
//获取待签名内容
|
||
memset(p_sign_to_calc, 0, 4096);
|
||
sign_src_len = __certif_probe_signdata(p_sign_to_calc, 4096, buf, len);
|
||
if(sign_src_len <= 0)
|
||
{
|
||
printf("certif_probe_signdata err\n");
|
||
|
||
return -1;
|
||
}
|
||
//计算待签名内容的hash
|
||
memset(hash_of_certif, 0, sizeof(hash_of_certif));
|
||
ret = sunxi_sha_calc(hash_of_certif, sizeof(hash_of_certif), p_sign_to_calc, sign_src_len);
|
||
if(ret)
|
||
{
|
||
printf("sunxi_sha_calc: calc sha256 with hardware err\n");
|
||
|
||
return -1;
|
||
}
|
||
//计算证书中签名的rsa
|
||
memset(hash_of_sign, 0, sizeof(hash_of_sign));
|
||
ret = sunxi_rsa_calc(sunxi_certif->pubkey.n+1, sunxi_certif->pubkey.n_len-1,
|
||
sunxi_certif->pubkey.e, sunxi_certif->pubkey.e_len,
|
||
hash_of_sign, sizeof(hash_of_sign),
|
||
sign_in_certif, sizeof(sign_in_certif));
|
||
if(ret)
|
||
{
|
||
printf("sunxi_rsa_calc: calc rsa2048 with hardware err\n");
|
||
|
||
return -1;
|
||
}
|
||
// printf(">>>>>>>>>>>>>>hash_of_certif\n");
|
||
// ndump(hash_of_certif, 32);
|
||
// printf("<<<<<<<<<<<<<<\n");
|
||
// printf(">>>>>>>>>>>>>>hash_of_sign\n");
|
||
// ndump(hash_of_sign, 32);
|
||
// printf("<<<<<<<<<<<<<<\n");
|
||
if(memcmp(hash_of_certif, hash_of_sign, 32))
|
||
{
|
||
printf("certif verify failed\n");
|
||
|
||
return -1;
|
||
}
|
||
ret = sunxi_certif_probe_extension(certif, sunxi_certif);
|
||
if(ret)
|
||
{
|
||
printf("sunxi_rsa_calc: probe extension failed\n");
|
||
|
||
return -1;
|
||
}
|
||
|
||
sunxi_certif_free(certif);
|
||
|
||
return 0;
|
||
}
|
||
/*
|
||
************************************************************************************************************
|
||
*
|
||
* function
|
||
*
|
||
* name :
|
||
*
|
||
* parmeters : buf: 证书存放起始 len：数据长度
|
||
*
|
||
* return :
|
||
*
|
||
* note : 证书自校验
|
||
*
|
||
*
|
||
************************************************************************************************************
|
||
*/
|
||
int sunxi_certif_probe_ext(sunxi_certif_info_t *sunxi_certif, u8 *buf, u32 len)
|
||
{
|
||
X509 *certif;
|
||
int ret;
|
||
//内存初始化
|
||
sunxi_certif_mem_reset();
|
||
//创建证书
|
||
ret = sunxi_certif_create(&certif, buf, len);
|
||
if(ret < 0)
|
||
{
|
||
printf("fail to create a certif\n");
|
||
|
||
return -1;
|
||
}
|
||
ret = sunxi_certif_probe_extension(certif, sunxi_certif);
|
||
if(ret)
|
||
{
|
||
printf("sunxi_rsa_calc: probe extension failed\n");
|
||
|
||
return -1;
|
||
}
|
||
sunxi_certif_free(certif);
|
||
|
||
return 0;
|
||
}
|
||
/*
|
||
************************************************************************************************************
|
||
*
|
||
* function
|
||
*
|
||
* name :
|
||
*
|
||
* parmeters :
|
||
*
|
||
* return :
|
||
*
|
||
* note : 对于一个序列，按照高4+低4,合并成为一个新的字节，比如
|
||
* 0x41(A) 0x31(1) 合并成为0xa1
|
||
*
|
||
************************************************************************************************************
|
||
*/
|
||
static int __sample_atoi(u8 ch, u8 *dst)
|
||
{
|
||
u8 ret_c;
|
||
|
||
if(isdigit(ch))
|
||
ret_c = ch - '0';
|
||
else if(isupper(ch))
|
||
ret_c = ch - 'A' + 10;
|
||
else if(islower(ch))
|
||
ret_c = ch - 'a' + 10;
|
||
else
|
||
{
|
||
printf("sample_atoi err: ch 0x%02x is not a digit or hex ch\n", ch);
|
||
return -1;
|
||
}
|
||
*dst = ret_c;
|
||
|
||
return 0;
|
||
}
|
||
|
||
int sunxi_bytes_merge(u8 *dst, u32 dst_len, u8 *src, uint src_len)
|
||
{
|
||
int i=0, j;
|
||
u8 c_h, c_l;
|
||
|
||
if((src_len>>1) > dst_len)
|
||
{
|
||
printf("bytes merge failed, the dst buffer is too short\n");
|
||
|
||
return -1;
|
||
}
|
||
if(src_len & 0x01) //奇数
|
||
{
|
||
src_len --;
|
||
if(__sample_atoi(src[i], &dst[0]))
|
||
{
|
||
return -1;
|
||
}
|
||
i++;
|
||
}
|
||
|
||
for(j=i;i<src_len;i+=2, j++)
|
||
{
|
||
c_h = src[i];
|
||
c_l = src[i+1];
|
||
|
||
if(__sample_atoi(src[i], &c_h))
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
if(__sample_atoi(src[i+1], &c_l))
|
||
{
|
||
return -1;
|
||
}
|
||
dst[j] = (c_h << 4) | c_l;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
/*
|
||
************************************************************************************************************
|
||
*
|
||
* function
|
||
*
|
||
* name :
|
||
*
|
||
* parmeters : buf: 证书存放起始 len：数据长度
|
||
*
|
||
* return :
|
||
*
|
||
* note : 证书自校验
|
||
*
|
||
*
|
||
************************************************************************************************************
|
||
*/
|
||
int sunxi_certif_dump(sunxi_certif_info_t *sunxi_certif)
|
||
{
|
||
return 0;
|
||
}
|
||
|