/* | |
* X.509 base functions for creating certificates / CSRs | |
* | |
* Copyright (C) 2006-2015, ARM Limited, All Rights Reserved | |
* SPDX-License-Identifier: Apache-2.0 | |
* | |
* Licensed under the Apache License, Version 2.0 (the "License"); you may | |
* not use this file except in compliance with the License. | |
* You may obtain a copy of the License at | |
* | |
* http://www.apache.org/licenses/LICENSE-2.0 | |
* | |
* Unless required by applicable law or agreed to in writing, software | |
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT | |
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
* See the License for the specific language governing permissions and | |
* limitations under the License. | |
* | |
* This file is part of mbed TLS (https://tls.mbed.org) | |
*/ | |
#if !defined(MBEDTLS_CONFIG_FILE) | |
#include "mbedtls/config.h" | |
#else | |
#include MBEDTLS_CONFIG_FILE | |
#endif | |
#if defined(MBEDTLS_X509_CREATE_C) | |
#include "mbedtls/x509.h" | |
#include "mbedtls/asn1write.h" | |
#include "mbedtls/oid.h" | |
#include <string.h> | |
/* Structure linking OIDs for X.509 DN AttributeTypes to their | |
* string representations and default string encodings used by Mbed TLS. */ | |
typedef struct { | |
const char *name; /* String representation of AttributeType, e.g. | |
* "CN" or "emailAddress". */ | |
size_t name_len; /* Length of 'name', without trailing 0 byte. */ | |
const char *oid; /* String representation of OID of AttributeType, | |
* as per RFC 5280, Appendix A.1. */ | |
int default_tag; /* The default character encoding used for the | |
* given attribute type, e.g. | |
* MBEDTLS_ASN1_UTF8_STRING for UTF-8. */ | |
} x509_attr_descriptor_t; | |
#define ADD_STRLEN( s ) s, sizeof( s ) - 1 | |
/* X.509 DN attributes from RFC 5280, Appendix A.1. */ | |
static const x509_attr_descriptor_t x509_attrs[] = | |
{ | |
{ ADD_STRLEN( "CN" ), | |
MBEDTLS_OID_AT_CN, MBEDTLS_ASN1_UTF8_STRING }, | |
{ ADD_STRLEN( "commonName" ), | |
MBEDTLS_OID_AT_CN, MBEDTLS_ASN1_UTF8_STRING }, | |
{ ADD_STRLEN( "C" ), | |
MBEDTLS_OID_AT_COUNTRY, MBEDTLS_ASN1_PRINTABLE_STRING }, | |
{ ADD_STRLEN( "countryName" ), | |
MBEDTLS_OID_AT_COUNTRY, MBEDTLS_ASN1_PRINTABLE_STRING }, | |
{ ADD_STRLEN( "O" ), | |
MBEDTLS_OID_AT_ORGANIZATION, MBEDTLS_ASN1_UTF8_STRING }, | |
{ ADD_STRLEN( "organizationName" ), | |
MBEDTLS_OID_AT_ORGANIZATION, MBEDTLS_ASN1_UTF8_STRING }, | |
{ ADD_STRLEN( "L" ), | |
MBEDTLS_OID_AT_LOCALITY, MBEDTLS_ASN1_UTF8_STRING }, | |
{ ADD_STRLEN( "locality" ), | |
MBEDTLS_OID_AT_LOCALITY, MBEDTLS_ASN1_UTF8_STRING }, | |
{ ADD_STRLEN( "R" ), | |
MBEDTLS_OID_PKCS9_EMAIL, MBEDTLS_ASN1_IA5_STRING }, | |
{ ADD_STRLEN( "OU" ), | |
MBEDTLS_OID_AT_ORG_UNIT, MBEDTLS_ASN1_UTF8_STRING }, | |
{ ADD_STRLEN( "organizationalUnitName" ), | |
MBEDTLS_OID_AT_ORG_UNIT, MBEDTLS_ASN1_UTF8_STRING }, | |
{ ADD_STRLEN( "ST" ), | |
MBEDTLS_OID_AT_STATE, MBEDTLS_ASN1_UTF8_STRING }, | |
{ ADD_STRLEN( "stateOrProvinceName" ), | |
MBEDTLS_OID_AT_STATE, MBEDTLS_ASN1_UTF8_STRING }, | |
{ ADD_STRLEN( "emailAddress" ), | |
MBEDTLS_OID_PKCS9_EMAIL, MBEDTLS_ASN1_IA5_STRING }, | |
{ ADD_STRLEN( "serialNumber" ), | |
MBEDTLS_OID_AT_SERIAL_NUMBER, MBEDTLS_ASN1_PRINTABLE_STRING }, | |
{ ADD_STRLEN( "postalAddress" ), | |
MBEDTLS_OID_AT_POSTAL_ADDRESS, MBEDTLS_ASN1_PRINTABLE_STRING }, | |
{ ADD_STRLEN( "postalCode" ), | |
MBEDTLS_OID_AT_POSTAL_CODE, MBEDTLS_ASN1_PRINTABLE_STRING }, | |
{ ADD_STRLEN( "dnQualifier" ), | |
MBEDTLS_OID_AT_DN_QUALIFIER, MBEDTLS_ASN1_PRINTABLE_STRING }, | |
{ ADD_STRLEN( "title" ), | |
MBEDTLS_OID_AT_TITLE, MBEDTLS_ASN1_UTF8_STRING }, | |
{ ADD_STRLEN( "surName" ), | |
MBEDTLS_OID_AT_SUR_NAME, MBEDTLS_ASN1_UTF8_STRING }, | |
{ ADD_STRLEN( "SN" ), | |
MBEDTLS_OID_AT_SUR_NAME, MBEDTLS_ASN1_UTF8_STRING }, | |
{ ADD_STRLEN( "givenName" ), | |
MBEDTLS_OID_AT_GIVEN_NAME, MBEDTLS_ASN1_UTF8_STRING }, | |
{ ADD_STRLEN( "GN" ), | |
MBEDTLS_OID_AT_GIVEN_NAME, MBEDTLS_ASN1_UTF8_STRING }, | |
{ ADD_STRLEN( "initials" ), | |
MBEDTLS_OID_AT_INITIALS, MBEDTLS_ASN1_UTF8_STRING }, | |
{ ADD_STRLEN( "pseudonym" ), | |
MBEDTLS_OID_AT_PSEUDONYM, MBEDTLS_ASN1_UTF8_STRING }, | |
{ ADD_STRLEN( "generationQualifier" ), | |
MBEDTLS_OID_AT_GENERATION_QUALIFIER, MBEDTLS_ASN1_UTF8_STRING }, | |
{ ADD_STRLEN( "domainComponent" ), | |
MBEDTLS_OID_DOMAIN_COMPONENT, MBEDTLS_ASN1_IA5_STRING }, | |
{ ADD_STRLEN( "DC" ), | |
MBEDTLS_OID_DOMAIN_COMPONENT, MBEDTLS_ASN1_IA5_STRING }, | |
{ NULL, 0, NULL, MBEDTLS_ASN1_NULL } | |
}; | |
static const x509_attr_descriptor_t *x509_attr_descr_from_name( const char *name, size_t name_len ) | |
{ | |
const x509_attr_descriptor_t *cur; | |
for( cur = x509_attrs; cur->name != NULL; cur++ ) | |
if( cur->name_len == name_len && | |
strncmp( cur->name, name, name_len ) == 0 ) | |
break; | |
if ( cur->name == NULL ) | |
return( NULL ); | |
return( cur ); | |
} | |
int mbedtls_x509_string_to_names( mbedtls_asn1_named_data **head, const char *name ) | |
{ | |
int ret = 0; | |
const char *s = name, *c = s; | |
const char *end = s + strlen( s ); | |
const char *oid = NULL; | |
const x509_attr_descriptor_t* attr_descr = NULL; | |
int in_tag = 1; | |
char data[MBEDTLS_X509_MAX_DN_NAME_SIZE]; | |
char *d = data; | |
/* Clear existing chain if present */ | |
mbedtls_asn1_free_named_data_list( head ); | |
while( c <= end ) | |
{ | |
if( in_tag && *c == '=' ) | |
{ | |
if( ( attr_descr = x509_attr_descr_from_name( s, c - s ) ) == NULL ) | |
{ | |
ret = MBEDTLS_ERR_X509_UNKNOWN_OID; | |
goto exit; | |
} | |
oid = attr_descr->oid; | |
s = c + 1; | |
in_tag = 0; | |
d = data; | |
} | |
if( !in_tag && *c == '\\' && c != end ) | |
{ | |
c++; | |
/* Check for valid escaped characters */ | |
if( c == end || *c != ',' ) | |
{ | |
ret = MBEDTLS_ERR_X509_INVALID_NAME; | |
goto exit; | |
} | |
} | |
else if( !in_tag && ( *c == ',' || c == end ) ) | |
{ | |
mbedtls_asn1_named_data* cur = | |
mbedtls_asn1_store_named_data( head, oid, strlen( oid ), | |
(unsigned char *) data, | |
d - data ); | |
if(cur == NULL ) | |
{ | |
return( MBEDTLS_ERR_X509_ALLOC_FAILED ); | |
} | |
// set tagType | |
cur->val.tag = attr_descr->default_tag; | |
while( c < end && *(c + 1) == ' ' ) | |
c++; | |
s = c + 1; | |
in_tag = 1; | |
} | |
if( !in_tag && s != c + 1 ) | |
{ | |
*(d++) = *c; | |
if( d - data == MBEDTLS_X509_MAX_DN_NAME_SIZE ) | |
{ | |
ret = MBEDTLS_ERR_X509_INVALID_NAME; | |
goto exit; | |
} | |
} | |
c++; | |
} | |
exit: | |
return( ret ); | |
} | |
/* The first byte of the value in the mbedtls_asn1_named_data structure is reserved | |
* to store the critical boolean for us | |
*/ | |
int mbedtls_x509_set_extension( mbedtls_asn1_named_data **head, const char *oid, size_t oid_len, | |
int critical, const unsigned char *val, size_t val_len ) | |
{ | |
mbedtls_asn1_named_data *cur; | |
if( ( cur = mbedtls_asn1_store_named_data( head, oid, oid_len, | |
NULL, val_len + 1 ) ) == NULL ) | |
{ | |
return( MBEDTLS_ERR_X509_ALLOC_FAILED ); | |
} | |
cur->val.p[0] = critical; | |
memcpy( cur->val.p + 1, val, val_len ); | |
return( 0 ); | |
} | |
/* | |
* RelativeDistinguishedName ::= | |
* SET OF AttributeTypeAndValue | |
* | |
* AttributeTypeAndValue ::= SEQUENCE { | |
* type AttributeType, | |
* value AttributeValue } | |
* | |
* AttributeType ::= OBJECT IDENTIFIER | |
* | |
* AttributeValue ::= ANY DEFINED BY AttributeType | |
*/ | |
static int x509_write_name( unsigned char **p, unsigned char *start, mbedtls_asn1_named_data* cur_name) | |
{ | |
int ret; | |
size_t len = 0; | |
const char *oid = (const char*)cur_name->oid.p; | |
size_t oid_len = cur_name->oid.len; | |
const unsigned char *name = cur_name->val.p; | |
size_t name_len = cur_name->val.len; | |
// Write correct string tag and value | |
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tagged_string( p, start, | |
cur_name->val.tag, | |
(const char *) name, | |
name_len ) ); | |
// Write OID | |
// | |
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_oid( p, start, oid, | |
oid_len ) ); | |
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, len ) ); | |
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start, | |
MBEDTLS_ASN1_CONSTRUCTED | | |
MBEDTLS_ASN1_SEQUENCE ) ); | |
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, len ) ); | |
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start, | |
MBEDTLS_ASN1_CONSTRUCTED | | |
MBEDTLS_ASN1_SET ) ); | |
return( (int) len ); | |
} | |
int mbedtls_x509_write_names( unsigned char **p, unsigned char *start, | |
mbedtls_asn1_named_data *first ) | |
{ | |
int ret; | |
size_t len = 0; | |
mbedtls_asn1_named_data *cur = first; | |
while( cur != NULL ) | |
{ | |
MBEDTLS_ASN1_CHK_ADD( len, x509_write_name( p, start, cur ) ); | |
cur = cur->next; | |
} | |
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, len ) ); | |
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start, MBEDTLS_ASN1_CONSTRUCTED | | |
MBEDTLS_ASN1_SEQUENCE ) ); | |
return( (int) len ); | |
} | |
int mbedtls_x509_write_sig( unsigned char **p, unsigned char *start, | |
const char *oid, size_t oid_len, | |
unsigned char *sig, size_t size ) | |
{ | |
int ret; | |
size_t len = 0; | |
if( *p < start || (size_t)( *p - start ) < size ) | |
return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL ); | |
len = size; | |
(*p) -= len; | |
memcpy( *p, sig, len ); | |
if( *p - start < 1 ) | |
return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL ); | |
*--(*p) = 0; | |
len += 1; | |
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, len ) ); | |
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start, MBEDTLS_ASN1_BIT_STRING ) ); | |
// Write OID | |
// | |
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_algorithm_identifier( p, start, oid, | |
oid_len, 0 ) ); | |
return( (int) len ); | |
} | |
static int x509_write_extension( unsigned char **p, unsigned char *start, | |
mbedtls_asn1_named_data *ext ) | |
{ | |
int ret; | |
size_t len = 0; | |
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_raw_buffer( p, start, ext->val.p + 1, | |
ext->val.len - 1 ) ); | |
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, ext->val.len - 1 ) ); | |
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start, MBEDTLS_ASN1_OCTET_STRING ) ); | |
if( ext->val.p[0] != 0 ) | |
{ | |
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_bool( p, start, 1 ) ); | |
} | |
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_raw_buffer( p, start, ext->oid.p, | |
ext->oid.len ) ); | |
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, ext->oid.len ) ); | |
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start, MBEDTLS_ASN1_OID ) ); | |
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, len ) ); | |
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start, MBEDTLS_ASN1_CONSTRUCTED | | |
MBEDTLS_ASN1_SEQUENCE ) ); | |
return( (int) len ); | |
} | |
/* | |
* Extension ::= SEQUENCE { | |
* extnID OBJECT IDENTIFIER, | |
* critical BOOLEAN DEFAULT FALSE, | |
* extnValue OCTET STRING | |
* -- contains the DER encoding of an ASN.1 value | |
* -- corresponding to the extension type identified | |
* -- by extnID | |
* } | |
*/ | |
int mbedtls_x509_write_extensions( unsigned char **p, unsigned char *start, | |
mbedtls_asn1_named_data *first ) | |
{ | |
int ret; | |
size_t len = 0; | |
mbedtls_asn1_named_data *cur_ext = first; | |
while( cur_ext != NULL ) | |
{ | |
MBEDTLS_ASN1_CHK_ADD( len, x509_write_extension( p, start, cur_ext ) ); | |
cur_ext = cur_ext->next; | |
} | |
return( (int) len ); | |
} | |
#endif /* MBEDTLS_X509_CREATE_C */ |