mirror of
https://github.com/dolphin-emu/dolphin.git
synced 2024-11-15 05:47:56 -07:00
3053fea160
On a few of our buildbot instances, we get warnings about the usage of deprecated functions. We should correct these, especially if we're delegating to system versions of the libraries if they're available. However, in order to do that, we need to update our library variant from 2.1.1 so that the non-deprecated alternatives are actually available.
380 lines
12 KiB
C
380 lines
12 KiB
C
/*
|
|
* 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 */
|