third_party/mbedtls/repo/library/oid.c

   1 /**
   2  * \file oid.c
   3  *
   4  * \brief Object Identifier (OID) database
   5  *
   6  *  Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
   7  *  SPDX-License-Identifier: Apache-2.0
   8  *
   9  *  Licensed under the Apache License, Version 2.0 (the "License"); you may
  10  *  not use this file except in compliance with the License.
  11  *  You may obtain a copy of the License at
  12  *
  13  *  http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  *  Unless required by applicable law or agreed to in writing, software
  16  *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  17  *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  *  See the License for the specific language governing permissions and
  19  *  limitations under the License.
  20  *
  21  *  This file is part of mbed TLS (https://tls.mbed.org)
  22  */
  23
  24 #if !defined(MBEDTLS_CONFIG_FILE)
  25 #include "mbedtls/config.h"
  26 #else
  27 #include MBEDTLS_CONFIG_FILE
  28 #endif
  29
  30 #if defined(MBEDTLS_OID_C)
  31
  32 #include "mbedtls/oid.h"
  33 #include "mbedtls/rsa.h"
  34
  35 #include <stdio.h>
  36 #include <string.h>
  37
  38 #if defined(MBEDTLS_PLATFORM_C)
  39 #include "mbedtls/platform.h"
  40 #else
  41 #define mbedtls_snprintf snprintf
  42 #endif
  43
  44 /*
  45  * Macro to automatically add the size of #define'd OIDs
  46  */
  47 #define ADD_LEN(s)      s, MBEDTLS_OID_SIZE(s)
  48
  49 /*
  50  * Macro to generate an internal function for oid_XXX_from_asn1() (used by
  51  * the other functions)
  52  */
  53 #define FN_OID_TYPED_FROM_ASN1( TYPE_T, NAME, LIST )                    \
  54     static const TYPE_T * oid_ ## NAME ## _from_asn1(                   \
  55                                       const mbedtls_asn1_buf *oid )     \
  56     {                                                                   \
  57         const TYPE_T *p = (LIST);                                       \
  58         const mbedtls_oid_descriptor_t *cur =                           \
  59             (const mbedtls_oid_descriptor_t *) p;                       \
  60         if( p == NULL || oid == NULL ) return( NULL );                  \
  61         while( cur->asn1 != NULL ) {                                    \
  62             if( cur->asn1_len == oid->len &&                            \
  63                 memcmp( cur->asn1, oid->p, oid->len ) == 0 ) {          \
  64                 return( p );                                            \
  65             }                                                           \
  66             p++;                                                        \
  67             cur = (const mbedtls_oid_descriptor_t *) p;                 \
  68         }                                                               \
  69         return( NULL );                                                 \
  70     }
  71
  72 /*
  73  * Macro to generate a function for retrieving a single attribute from the
  74  * descriptor of an mbedtls_oid_descriptor_t wrapper.
  75  */
  76 #define FN_OID_GET_DESCRIPTOR_ATTR1(FN_NAME, TYPE_T, TYPE_NAME, ATTR1_TYPE, ATTR1) \
  77 int FN_NAME( const mbedtls_asn1_buf *oid, ATTR1_TYPE * ATTR1 )                  \
  78 {                                                                       \
  79     const TYPE_T *data = oid_ ## TYPE_NAME ## _from_asn1( oid );        \
  80     if( data == NULL ) return( MBEDTLS_ERR_OID_NOT_FOUND );            \
  81     *ATTR1 = data->descriptor.ATTR1;                                    \
  82     return( 0 );                                                        \
  83 }
  84
  85 /*
  86  * Macro to generate a function for retrieving a single attribute from an
  87  * mbedtls_oid_descriptor_t wrapper.
  88  */
  89 #define FN_OID_GET_ATTR1(FN_NAME, TYPE_T, TYPE_NAME, ATTR1_TYPE, ATTR1) \
  90 int FN_NAME( const mbedtls_asn1_buf *oid, ATTR1_TYPE * ATTR1 )                  \
  91 {                                                                       \
  92     const TYPE_T *data = oid_ ## TYPE_NAME ## _from_asn1( oid );        \
  93     if( data == NULL ) return( MBEDTLS_ERR_OID_NOT_FOUND );            \
  94     *ATTR1 = data->ATTR1;                                               \
  95     return( 0 );                                                        \
  96 }
  97
  98 /*
  99  * Macro to generate a function for retrieving two attributes from an
 100  * mbedtls_oid_descriptor_t wrapper.
 101  */
 102 #define FN_OID_GET_ATTR2(FN_NAME, TYPE_T, TYPE_NAME, ATTR1_TYPE, ATTR1,     \
 103                          ATTR2_TYPE, ATTR2)                                 \
 104 int FN_NAME( const mbedtls_asn1_buf *oid, ATTR1_TYPE * ATTR1,               \
 105                                           ATTR2_TYPE * ATTR2 )              \
 106 {                                                                           \
 107     const TYPE_T *data = oid_ ## TYPE_NAME ## _from_asn1( oid );            \
 108     if( data == NULL ) return( MBEDTLS_ERR_OID_NOT_FOUND );                 \
 109     *(ATTR1) = data->ATTR1;                                                 \
 110     *(ATTR2) = data->ATTR2;                                                 \
 111     return( 0 );                                                            \
 112 }
 113
 114 /*
 115  * Macro to generate a function for retrieving the OID based on a single
 116  * attribute from a mbedtls_oid_descriptor_t wrapper.
 117  */
 118 #define FN_OID_GET_OID_BY_ATTR1(FN_NAME, TYPE_T, LIST, ATTR1_TYPE, ATTR1)   \
 119 int FN_NAME( ATTR1_TYPE ATTR1, const char **oid, size_t *olen )             \
 120 {                                                                           \
 121     const TYPE_T *cur = (LIST);                                             \
 122     while( cur->descriptor.asn1 != NULL ) {                                 \
 123         if( cur->ATTR1 == (ATTR1) ) {                                       \
 124             *oid = cur->descriptor.asn1;                                    \
 125             *olen = cur->descriptor.asn1_len;                               \
 126             return( 0 );                                                    \
 127         }                                                                   \
 128         cur++;                                                              \
 129     }                                                                       \
 130     return( MBEDTLS_ERR_OID_NOT_FOUND );                                    \
 131 }
 132
 133 /*
 134  * Macro to generate a function for retrieving the OID based on two
 135  * attributes from a mbedtls_oid_descriptor_t wrapper.
 136  */
 137 #define FN_OID_GET_OID_BY_ATTR2(FN_NAME, TYPE_T, LIST, ATTR1_TYPE, ATTR1,   \
 138                                 ATTR2_TYPE, ATTR2)                          \
 139 int FN_NAME( ATTR1_TYPE ATTR1, ATTR2_TYPE ATTR2, const char **oid ,         \
 140              size_t *olen )                                                 \
 141 {                                                                           \
 142     const TYPE_T *cur = (LIST);                                             \
 143     while( cur->descriptor.asn1 != NULL ) {                                 \
 144         if( cur->ATTR1 == (ATTR1) && cur->ATTR2 == (ATTR2) ) {              \
 145             *oid = cur->descriptor.asn1;                                    \
 146             *olen = cur->descriptor.asn1_len;                               \
 147             return( 0 );                                                    \
 148         }                                                                   \
 149         cur++;                                                              \
 150     }                                                                       \
 151     return( MBEDTLS_ERR_OID_NOT_FOUND );                                   \
 152 }
 153
 154 /*
 155  * For X520 attribute types
 156  */
 157 typedef struct {
 158     mbedtls_oid_descriptor_t    descriptor;
 159     const char          *short_name;
 160 } oid_x520_attr_t;
 161
 162 static const oid_x520_attr_t oid_x520_attr_type[] =
 163 {
 164     {
 165         { ADD_LEN( MBEDTLS_OID_AT_CN ),          "id-at-commonName",               "Common Name" },
 166         "CN",
 167     },
 168     {
 169         { ADD_LEN( MBEDTLS_OID_AT_COUNTRY ),     "id-at-countryName",              "Country" },
 170         "C",
 171     },
 172     {
 173         { ADD_LEN( MBEDTLS_OID_AT_LOCALITY ),    "id-at-locality",                 "Locality" },
 174         "L",
 175     },
 176     {
 177         { ADD_LEN( MBEDTLS_OID_AT_STATE ),       "id-at-state",                    "State" },
 178         "ST",
 179     },
 180     {
 181         { ADD_LEN( MBEDTLS_OID_AT_ORGANIZATION ),"id-at-organizationName",         "Organization" },
 182         "O",
 183     },
 184     {
 185         { ADD_LEN( MBEDTLS_OID_AT_ORG_UNIT ),    "id-at-organizationalUnitName",   "Org Unit" },
 186         "OU",
 187     },
 188     {
 189         { ADD_LEN( MBEDTLS_OID_PKCS9_EMAIL ),    "emailAddress",                   "E-mail address" },
 190         "emailAddress",
 191     },
 192     {
 193         { ADD_LEN( MBEDTLS_OID_AT_SERIAL_NUMBER ),"id-at-serialNumber",            "Serial number" },
 194         "serialNumber",
 195     },
 196     {
 197         { ADD_LEN( MBEDTLS_OID_AT_POSTAL_ADDRESS ),"id-at-postalAddress",          "Postal address" },
 198         "postalAddress",
 199     },
 200     {
 201         { ADD_LEN( MBEDTLS_OID_AT_POSTAL_CODE ), "id-at-postalCode",               "Postal code" },
 202         "postalCode",
 203     },
 204     {
 205         { ADD_LEN( MBEDTLS_OID_AT_SUR_NAME ),    "id-at-surName",                  "Surname" },
 206         "SN",
 207     },
 208     {
 209         { ADD_LEN( MBEDTLS_OID_AT_GIVEN_NAME ),  "id-at-givenName",                "Given name" },
 210         "GN",
 211     },
 212     {
 213         { ADD_LEN( MBEDTLS_OID_AT_INITIALS ),    "id-at-initials",                 "Initials" },
 214         "initials",
 215     },
 216     {
 217         { ADD_LEN( MBEDTLS_OID_AT_GENERATION_QUALIFIER ), "id-at-generationQualifier", "Generation qualifier" },
 218         "generationQualifier",
 219     },
 220     {
 221         { ADD_LEN( MBEDTLS_OID_AT_TITLE ),       "id-at-title",                    "Title" },
 222         "title",
 223     },
 224     {
 225         { ADD_LEN( MBEDTLS_OID_AT_DN_QUALIFIER ),"id-at-dnQualifier",              "Distinguished Name qualifier" },
 226         "dnQualifier",
 227     },
 228     {
 229         { ADD_LEN( MBEDTLS_OID_AT_PSEUDONYM ),   "id-at-pseudonym",                "Pseudonym" },
 230         "pseudonym",
 231     },
 232     {
 233         { ADD_LEN( MBEDTLS_OID_DOMAIN_COMPONENT ), "id-domainComponent",           "Domain component" },
 234         "DC",
 235     },
 236     {
 237         { ADD_LEN( MBEDTLS_OID_AT_UNIQUE_IDENTIFIER ), "id-at-uniqueIdentifier",    "Unique Identifier" },
 238         "uniqueIdentifier",
 239     },
 240     {
 241         { NULL, 0, NULL, NULL },
 242         NULL,
 243     }
 244 };
 245
 246 FN_OID_TYPED_FROM_ASN1(oid_x520_attr_t, x520_attr, oid_x520_attr_type)
 247 FN_OID_GET_ATTR1(mbedtls_oid_get_attr_short_name, oid_x520_attr_t, x520_attr, const char *, short_name)
 248
 249 /*
 250  * For X509 extensions
 251  */
 252 typedef struct {
 253     mbedtls_oid_descriptor_t    descriptor;
 254     int                 ext_type;
 255 } oid_x509_ext_t;
 256
 257 static const oid_x509_ext_t oid_x509_ext[] =
 258 {
 259     {
 260         { ADD_LEN( MBEDTLS_OID_BASIC_CONSTRAINTS ),    "id-ce-basicConstraints",    "Basic Constraints" },
 261         MBEDTLS_OID_X509_EXT_BASIC_CONSTRAINTS,
 262     },
 263     {
 264         { ADD_LEN( MBEDTLS_OID_KEY_USAGE ),            "id-ce-keyUsage",            "Key Usage" },
 265         MBEDTLS_OID_X509_EXT_KEY_USAGE,
 266     },
 267     {
 268         { ADD_LEN( MBEDTLS_OID_EXTENDED_KEY_USAGE ),   "id-ce-extKeyUsage",         "Extended Key Usage" },
 269         MBEDTLS_OID_X509_EXT_EXTENDED_KEY_USAGE,
 270     },
 271     {
 272         { ADD_LEN( MBEDTLS_OID_SUBJECT_ALT_NAME ),     "id-ce-subjectAltName",      "Subject Alt Name" },
 273         MBEDTLS_OID_X509_EXT_SUBJECT_ALT_NAME,
 274     },
 275     {
 276         { ADD_LEN( MBEDTLS_OID_NS_CERT_TYPE ),         "id-netscape-certtype",      "Netscape Certificate Type" },
 277         MBEDTLS_OID_X509_EXT_NS_CERT_TYPE,
 278     },
 279     {
 280         { ADD_LEN( MBEDTLS_OID_CERTIFICATE_POLICIES ), "id-ce-certificatePolicies", "Certificate Policies" },
 281         MBEDTLS_OID_X509_EXT_CERTIFICATE_POLICIES,
 282     },
 283     {
 284         { NULL, 0, NULL, NULL },
 285         0,
 286     },
 287 };
 288
 289 FN_OID_TYPED_FROM_ASN1(oid_x509_ext_t, x509_ext, oid_x509_ext)
 290 FN_OID_GET_ATTR1(mbedtls_oid_get_x509_ext_type, oid_x509_ext_t, x509_ext, int, ext_type)
 291
 292 static const mbedtls_oid_descriptor_t oid_ext_key_usage[] =
 293 {
 294     { ADD_LEN( MBEDTLS_OID_SERVER_AUTH ),      "id-kp-serverAuth",       "TLS Web Server Authentication" },
 295     { ADD_LEN( MBEDTLS_OID_CLIENT_AUTH ),      "id-kp-clientAuth",       "TLS Web Client Authentication" },
 296     { ADD_LEN( MBEDTLS_OID_CODE_SIGNING ),     "id-kp-codeSigning",      "Code Signing" },
 297     { ADD_LEN( MBEDTLS_OID_EMAIL_PROTECTION ), "id-kp-emailProtection",  "E-mail Protection" },
 298     { ADD_LEN( MBEDTLS_OID_TIME_STAMPING ),    "id-kp-timeStamping",     "Time Stamping" },
 299     { ADD_LEN( MBEDTLS_OID_OCSP_SIGNING ),     "id-kp-OCSPSigning",      "OCSP Signing" },
 300     { ADD_LEN( MBEDTLS_OID_WISUN_FAN ),        "id-kp-wisun-fan-device", "Wi-SUN Alliance Field Area Network (FAN)" },
 301     { NULL, 0, NULL, NULL },
 302 };
 303
 304 FN_OID_TYPED_FROM_ASN1(mbedtls_oid_descriptor_t, ext_key_usage, oid_ext_key_usage)
 305 FN_OID_GET_ATTR1(mbedtls_oid_get_extended_key_usage, mbedtls_oid_descriptor_t, ext_key_usage, const char *, description)
 306
 307 static const mbedtls_oid_descriptor_t oid_certificate_policies[] =
 308 {
 309     { ADD_LEN( MBEDTLS_OID_ANY_POLICY ),      "anyPolicy",       "Any Policy" },
 310     { NULL, 0, NULL, NULL },
 311 };
 312
 313 FN_OID_TYPED_FROM_ASN1(mbedtls_oid_descriptor_t, certificate_policies, oid_certificate_policies)
 314 FN_OID_GET_ATTR1(mbedtls_oid_get_certificate_policies, mbedtls_oid_descriptor_t, certificate_policies, const char *, description)
 315
 316 #if defined(MBEDTLS_MD_C)
 317 /*
 318  * For SignatureAlgorithmIdentifier
 319  */
 320 typedef struct {
 321     mbedtls_oid_descriptor_t    descriptor;
 322     mbedtls_md_type_t           md_alg;
 323     mbedtls_pk_type_t           pk_alg;
 324 } oid_sig_alg_t;
 325
 326 static const oid_sig_alg_t oid_sig_alg[] =
 327 {
 328 #if defined(MBEDTLS_RSA_C)
 329 #if defined(MBEDTLS_MD2_C)
 330     {
 331         { ADD_LEN( MBEDTLS_OID_PKCS1_MD2 ),        "md2WithRSAEncryption",     "RSA with MD2" },
 332         MBEDTLS_MD_MD2,      MBEDTLS_PK_RSA,
 333     },
 334 #endif /* MBEDTLS_MD2_C */
 335 #if defined(MBEDTLS_MD4_C)
 336     {
 337         { ADD_LEN( MBEDTLS_OID_PKCS1_MD4 ),        "md4WithRSAEncryption",     "RSA with MD4" },
 338         MBEDTLS_MD_MD4,      MBEDTLS_PK_RSA,
 339     },
 340 #endif /* MBEDTLS_MD4_C */
 341 #if defined(MBEDTLS_MD5_C)
 342     {
 343         { ADD_LEN( MBEDTLS_OID_PKCS1_MD5 ),        "md5WithRSAEncryption",     "RSA with MD5" },
 344         MBEDTLS_MD_MD5,      MBEDTLS_PK_RSA,
 345     },
 346 #endif /* MBEDTLS_MD5_C */
 347 #if defined(MBEDTLS_SHA1_C)
 348     {
 349         { ADD_LEN( MBEDTLS_OID_PKCS1_SHA1 ),       "sha-1WithRSAEncryption",   "RSA with SHA1" },
 350         MBEDTLS_MD_SHA1,     MBEDTLS_PK_RSA,
 351     },
 352 #endif /* MBEDTLS_SHA1_C */
 353 #if defined(MBEDTLS_SHA256_C)
 354     {
 355         { ADD_LEN( MBEDTLS_OID_PKCS1_SHA224 ),     "sha224WithRSAEncryption",  "RSA with SHA-224" },
 356         MBEDTLS_MD_SHA224,   MBEDTLS_PK_RSA,
 357     },
 358     {
 359         { ADD_LEN( MBEDTLS_OID_PKCS1_SHA256 ),     "sha256WithRSAEncryption",  "RSA with SHA-256" },
 360         MBEDTLS_MD_SHA256,   MBEDTLS_PK_RSA,
 361     },
 362 #endif /* MBEDTLS_SHA256_C */
 363 #if defined(MBEDTLS_SHA512_C)
 364     {
 365         { ADD_LEN( MBEDTLS_OID_PKCS1_SHA384 ),     "sha384WithRSAEncryption",  "RSA with SHA-384" },
 366         MBEDTLS_MD_SHA384,   MBEDTLS_PK_RSA,
 367     },
 368     {
 369         { ADD_LEN( MBEDTLS_OID_PKCS1_SHA512 ),     "sha512WithRSAEncryption",  "RSA with SHA-512" },
 370         MBEDTLS_MD_SHA512,   MBEDTLS_PK_RSA,
 371     },
 372 #endif /* MBEDTLS_SHA512_C */
 373 #if defined(MBEDTLS_SHA1_C)
 374     {
 375         { ADD_LEN( MBEDTLS_OID_RSA_SHA_OBS ),      "sha-1WithRSAEncryption",   "RSA with SHA1" },
 376         MBEDTLS_MD_SHA1,     MBEDTLS_PK_RSA,
 377     },
 378 #endif /* MBEDTLS_SHA1_C */
 379 #endif /* MBEDTLS_RSA_C */
 380 #if defined(MBEDTLS_ECDSA_C)
 381 #if defined(MBEDTLS_SHA1_C)
 382     {
 383         { ADD_LEN( MBEDTLS_OID_ECDSA_SHA1 ),       "ecdsa-with-SHA1",      "ECDSA with SHA1" },
 384         MBEDTLS_MD_SHA1,     MBEDTLS_PK_ECDSA,
 385     },
 386 #endif /* MBEDTLS_SHA1_C */
 387 #if defined(MBEDTLS_SHA256_C)
 388     {
 389         { ADD_LEN( MBEDTLS_OID_ECDSA_SHA224 ),     "ecdsa-with-SHA224",    "ECDSA with SHA224" },
 390         MBEDTLS_MD_SHA224,   MBEDTLS_PK_ECDSA,
 391     },
 392     {
 393         { ADD_LEN( MBEDTLS_OID_ECDSA_SHA256 ),     "ecdsa-with-SHA256",    "ECDSA with SHA256" },
 394         MBEDTLS_MD_SHA256,   MBEDTLS_PK_ECDSA,
 395     },
 396 #endif /* MBEDTLS_SHA256_C */
 397 #if defined(MBEDTLS_SHA512_C)
 398     {
 399         { ADD_LEN( MBEDTLS_OID_ECDSA_SHA384 ),     "ecdsa-with-SHA384",    "ECDSA with SHA384" },
 400         MBEDTLS_MD_SHA384,   MBEDTLS_PK_ECDSA,
 401     },
 402     {
 403         { ADD_LEN( MBEDTLS_OID_ECDSA_SHA512 ),     "ecdsa-with-SHA512",    "ECDSA with SHA512" },
 404         MBEDTLS_MD_SHA512,   MBEDTLS_PK_ECDSA,
 405     },
 406 #endif /* MBEDTLS_SHA512_C */
 407 #endif /* MBEDTLS_ECDSA_C */
 408 #if defined(MBEDTLS_RSA_C)
 409     {
 410         { ADD_LEN( MBEDTLS_OID_RSASSA_PSS ),        "RSASSA-PSS",           "RSASSA-PSS" },
 411         MBEDTLS_MD_NONE,     MBEDTLS_PK_RSASSA_PSS,
 412     },
 413 #endif /* MBEDTLS_RSA_C */
 414     {
 415         { NULL, 0, NULL, NULL },
 416         MBEDTLS_MD_NONE, MBEDTLS_PK_NONE,
 417     },
 418 };
 419
 420 FN_OID_TYPED_FROM_ASN1(oid_sig_alg_t, sig_alg, oid_sig_alg)
 421 FN_OID_GET_DESCRIPTOR_ATTR1(mbedtls_oid_get_sig_alg_desc, oid_sig_alg_t, sig_alg, const char *, description)
 422 FN_OID_GET_ATTR2(mbedtls_oid_get_sig_alg, oid_sig_alg_t, sig_alg, mbedtls_md_type_t, md_alg, mbedtls_pk_type_t, pk_alg)
 423 FN_OID_GET_OID_BY_ATTR2(mbedtls_oid_get_oid_by_sig_alg, oid_sig_alg_t, oid_sig_alg, mbedtls_pk_type_t, pk_alg, mbedtls_md_type_t, md_alg)
 424 #endif /* MBEDTLS_MD_C */
 425
 426 /*
 427  * For PublicKeyInfo (PKCS1, RFC 5480)
 428  */
 429 typedef struct {
 430     mbedtls_oid_descriptor_t    descriptor;
 431     mbedtls_pk_type_t           pk_alg;
 432 } oid_pk_alg_t;
 433
 434 static const oid_pk_alg_t oid_pk_alg[] =
 435 {
 436     {
 437         { ADD_LEN( MBEDTLS_OID_PKCS1_RSA ),      "rsaEncryption",   "RSA" },
 438         MBEDTLS_PK_RSA,
 439     },
 440     {
 441         { ADD_LEN( MBEDTLS_OID_EC_ALG_UNRESTRICTED ),  "id-ecPublicKey",   "Generic EC key" },
 442         MBEDTLS_PK_ECKEY,
 443     },
 444     {
 445         { ADD_LEN( MBEDTLS_OID_EC_ALG_ECDH ),          "id-ecDH",          "EC key for ECDH" },
 446         MBEDTLS_PK_ECKEY_DH,
 447     },
 448     {
 449         { NULL, 0, NULL, NULL },
 450         MBEDTLS_PK_NONE,
 451     },
 452 };
 453
 454 FN_OID_TYPED_FROM_ASN1(oid_pk_alg_t, pk_alg, oid_pk_alg)
 455 FN_OID_GET_ATTR1(mbedtls_oid_get_pk_alg, oid_pk_alg_t, pk_alg, mbedtls_pk_type_t, pk_alg)
 456 FN_OID_GET_OID_BY_ATTR1(mbedtls_oid_get_oid_by_pk_alg, oid_pk_alg_t, oid_pk_alg, mbedtls_pk_type_t, pk_alg)
 457
 458 #if defined(MBEDTLS_ECP_C)
 459 /*
 460  * For namedCurve (RFC 5480)
 461  */
 462 typedef struct {
 463     mbedtls_oid_descriptor_t    descriptor;
 464     mbedtls_ecp_group_id        grp_id;
 465 } oid_ecp_grp_t;
 466
 467 static const oid_ecp_grp_t oid_ecp_grp[] =
 468 {
 469 #if defined(MBEDTLS_ECP_DP_SECP192R1_ENABLED)
 470     {
 471         { ADD_LEN( MBEDTLS_OID_EC_GRP_SECP192R1 ), "secp192r1",    "secp192r1" },
 472         MBEDTLS_ECP_DP_SECP192R1,
 473     },
 474 #endif /* MBEDTLS_ECP_DP_SECP192R1_ENABLED */
 475 #if defined(MBEDTLS_ECP_DP_SECP224R1_ENABLED)
 476     {
 477         { ADD_LEN( MBEDTLS_OID_EC_GRP_SECP224R1 ), "secp224r1",    "secp224r1" },
 478         MBEDTLS_ECP_DP_SECP224R1,
 479     },
 480 #endif /* MBEDTLS_ECP_DP_SECP224R1_ENABLED */
 481 #if defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED)
 482     {
 483         { ADD_LEN( MBEDTLS_OID_EC_GRP_SECP256R1 ), "secp256r1",    "secp256r1" },
 484         MBEDTLS_ECP_DP_SECP256R1,
 485     },
 486 #endif /* MBEDTLS_ECP_DP_SECP256R1_ENABLED */
 487 #if defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)
 488     {
 489         { ADD_LEN( MBEDTLS_OID_EC_GRP_SECP384R1 ), "secp384r1",    "secp384r1" },
 490         MBEDTLS_ECP_DP_SECP384R1,
 491     },
 492 #endif /* MBEDTLS_ECP_DP_SECP384R1_ENABLED */
 493 #if defined(MBEDTLS_ECP_DP_SECP521R1_ENABLED)
 494     {
 495         { ADD_LEN( MBEDTLS_OID_EC_GRP_SECP521R1 ), "secp521r1",    "secp521r1" },
 496         MBEDTLS_ECP_DP_SECP521R1,
 497     },
 498 #endif /* MBEDTLS_ECP_DP_SECP521R1_ENABLED */
 499 #if defined(MBEDTLS_ECP_DP_SECP192K1_ENABLED)
 500     {
 501         { ADD_LEN( MBEDTLS_OID_EC_GRP_SECP192K1 ), "secp192k1",    "secp192k1" },
 502         MBEDTLS_ECP_DP_SECP192K1,
 503     },
 504 #endif /* MBEDTLS_ECP_DP_SECP192K1_ENABLED */
 505 #if defined(MBEDTLS_ECP_DP_SECP224K1_ENABLED)
 506     {
 507         { ADD_LEN( MBEDTLS_OID_EC_GRP_SECP224K1 ), "secp224k1",    "secp224k1" },
 508         MBEDTLS_ECP_DP_SECP224K1,
 509     },
 510 #endif /* MBEDTLS_ECP_DP_SECP224K1_ENABLED */
 511 #if defined(MBEDTLS_ECP_DP_SECP256K1_ENABLED)
 512     {
 513         { ADD_LEN( MBEDTLS_OID_EC_GRP_SECP256K1 ), "secp256k1",    "secp256k1" },
 514         MBEDTLS_ECP_DP_SECP256K1,
 515     },
 516 #endif /* MBEDTLS_ECP_DP_SECP256K1_ENABLED */
 517 #if defined(MBEDTLS_ECP_DP_BP256R1_ENABLED)
 518     {
 519         { ADD_LEN( MBEDTLS_OID_EC_GRP_BP256R1 ),   "brainpoolP256r1","brainpool256r1" },
 520         MBEDTLS_ECP_DP_BP256R1,
 521     },
 522 #endif /* MBEDTLS_ECP_DP_BP256R1_ENABLED */
 523 #if defined(MBEDTLS_ECP_DP_BP384R1_ENABLED)
 524     {
 525         { ADD_LEN( MBEDTLS_OID_EC_GRP_BP384R1 ),   "brainpoolP384r1","brainpool384r1" },
 526         MBEDTLS_ECP_DP_BP384R1,
 527     },
 528 #endif /* MBEDTLS_ECP_DP_BP384R1_ENABLED */
 529 #if defined(MBEDTLS_ECP_DP_BP512R1_ENABLED)
 530     {
 531         { ADD_LEN( MBEDTLS_OID_EC_GRP_BP512R1 ),   "brainpoolP512r1","brainpool512r1" },
 532         MBEDTLS_ECP_DP_BP512R1,
 533     },
 534 #endif /* MBEDTLS_ECP_DP_BP512R1_ENABLED */
 535     {
 536         { NULL, 0, NULL, NULL },
 537         MBEDTLS_ECP_DP_NONE,
 538     },
 539 };
 540
 541 FN_OID_TYPED_FROM_ASN1(oid_ecp_grp_t, grp_id, oid_ecp_grp)
 542 FN_OID_GET_ATTR1(mbedtls_oid_get_ec_grp, oid_ecp_grp_t, grp_id, mbedtls_ecp_group_id, grp_id)
 543 FN_OID_GET_OID_BY_ATTR1(mbedtls_oid_get_oid_by_ec_grp, oid_ecp_grp_t, oid_ecp_grp, mbedtls_ecp_group_id, grp_id)
 544 #endif /* MBEDTLS_ECP_C */
 545
 546 #if defined(MBEDTLS_CIPHER_C)
 547 /*
 548  * For PKCS#5 PBES2 encryption algorithm
 549  */
 550 typedef struct {
 551     mbedtls_oid_descriptor_t    descriptor;
 552     mbedtls_cipher_type_t       cipher_alg;
 553 } oid_cipher_alg_t;
 554
 555 static const oid_cipher_alg_t oid_cipher_alg[] =
 556 {
 557     {
 558         { ADD_LEN( MBEDTLS_OID_DES_CBC ),              "desCBC",       "DES-CBC" },
 559         MBEDTLS_CIPHER_DES_CBC,
 560     },
 561     {
 562         { ADD_LEN( MBEDTLS_OID_DES_EDE3_CBC ),         "des-ede3-cbc", "DES-EDE3-CBC" },
 563         MBEDTLS_CIPHER_DES_EDE3_CBC,
 564     },
 565     {
 566         { NULL, 0, NULL, NULL },
 567         MBEDTLS_CIPHER_NONE,
 568     },
 569 };
 570
 571 FN_OID_TYPED_FROM_ASN1(oid_cipher_alg_t, cipher_alg, oid_cipher_alg)
 572 FN_OID_GET_ATTR1(mbedtls_oid_get_cipher_alg, oid_cipher_alg_t, cipher_alg, mbedtls_cipher_type_t, cipher_alg)
 573 #endif /* MBEDTLS_CIPHER_C */
 574
 575 #if defined(MBEDTLS_MD_C)
 576 /*
 577  * For digestAlgorithm
 578  */
 579 typedef struct {
 580     mbedtls_oid_descriptor_t    descriptor;
 581     mbedtls_md_type_t           md_alg;
 582 } oid_md_alg_t;
 583
 584 static const oid_md_alg_t oid_md_alg[] =
 585 {
 586 #if defined(MBEDTLS_MD2_C)
 587     {
 588         { ADD_LEN( MBEDTLS_OID_DIGEST_ALG_MD2 ),       "id-md2",       "MD2" },
 589         MBEDTLS_MD_MD2,
 590     },
 591 #endif /* MBEDTLS_MD2_C */
 592 #if defined(MBEDTLS_MD4_C)
 593     {
 594         { ADD_LEN( MBEDTLS_OID_DIGEST_ALG_MD4 ),       "id-md4",       "MD4" },
 595         MBEDTLS_MD_MD4,
 596     },
 597 #endif /* MBEDTLS_MD4_C */
 598 #if defined(MBEDTLS_MD5_C)
 599     {
 600         { ADD_LEN( MBEDTLS_OID_DIGEST_ALG_MD5 ),       "id-md5",       "MD5" },
 601         MBEDTLS_MD_MD5,
 602     },
 603 #endif /* MBEDTLS_MD5_C */
 604 #if defined(MBEDTLS_SHA1_C)
 605     {
 606         { ADD_LEN( MBEDTLS_OID_DIGEST_ALG_SHA1 ),      "id-sha1",      "SHA-1" },
 607         MBEDTLS_MD_SHA1,
 608     },
 609 #endif /* MBEDTLS_SHA1_C */
 610 #if defined(MBEDTLS_SHA256_C)
 611     {
 612         { ADD_LEN( MBEDTLS_OID_DIGEST_ALG_SHA224 ),    "id-sha224",    "SHA-224" },
 613         MBEDTLS_MD_SHA224,
 614     },
 615     {
 616         { ADD_LEN( MBEDTLS_OID_DIGEST_ALG_SHA256 ),    "id-sha256",    "SHA-256" },
 617         MBEDTLS_MD_SHA256,
 618     },
 619 #endif /* MBEDTLS_SHA256_C */
 620 #if defined(MBEDTLS_SHA512_C)
 621     {
 622         { ADD_LEN( MBEDTLS_OID_DIGEST_ALG_SHA384 ),    "id-sha384",    "SHA-384" },
 623         MBEDTLS_MD_SHA384,
 624     },
 625     {
 626         { ADD_LEN( MBEDTLS_OID_DIGEST_ALG_SHA512 ),    "id-sha512",    "SHA-512" },
 627         MBEDTLS_MD_SHA512,
 628     },
 629 #endif /* MBEDTLS_SHA512_C */
 630 #if defined(MBEDTLS_RIPEMD160_C)
 631     {
 632         { ADD_LEN( MBEDTLS_OID_DIGEST_ALG_RIPEMD160 ),       "id-ripemd160",       "RIPEMD-160" },
 633         MBEDTLS_MD_RIPEMD160,
 634     },
 635 #endif /* MBEDTLS_RIPEMD160_C */
 636     {
 637         { NULL, 0, NULL, NULL },
 638         MBEDTLS_MD_NONE,
 639     },
 640 };
 641
 642 FN_OID_TYPED_FROM_ASN1(oid_md_alg_t, md_alg, oid_md_alg)
 643 FN_OID_GET_ATTR1(mbedtls_oid_get_md_alg, oid_md_alg_t, md_alg, mbedtls_md_type_t, md_alg)
 644 FN_OID_GET_OID_BY_ATTR1(mbedtls_oid_get_oid_by_md, oid_md_alg_t, oid_md_alg, mbedtls_md_type_t, md_alg)
 645
 646 /*
 647  * For HMAC digestAlgorithm
 648  */
 649 typedef struct {
 650     mbedtls_oid_descriptor_t    descriptor;
 651     mbedtls_md_type_t           md_hmac;
 652 } oid_md_hmac_t;
 653
 654 static const oid_md_hmac_t oid_md_hmac[] =
 655 {
 656 #if defined(MBEDTLS_SHA1_C)
 657     {
 658         { ADD_LEN( MBEDTLS_OID_HMAC_SHA1 ),      "hmacSHA1",      "HMAC-SHA-1" },
 659         MBEDTLS_MD_SHA1,
 660     },
 661 #endif /* MBEDTLS_SHA1_C */
 662 #if defined(MBEDTLS_SHA256_C)
 663     {
 664         { ADD_LEN( MBEDTLS_OID_HMAC_SHA224 ),    "hmacSHA224",    "HMAC-SHA-224" },
 665         MBEDTLS_MD_SHA224,
 666     },
 667     {
 668         { ADD_LEN( MBEDTLS_OID_HMAC_SHA256 ),    "hmacSHA256",    "HMAC-SHA-256" },
 669         MBEDTLS_MD_SHA256,
 670     },
 671 #endif /* MBEDTLS_SHA256_C */
 672 #if defined(MBEDTLS_SHA512_C)
 673     {
 674         { ADD_LEN( MBEDTLS_OID_HMAC_SHA384 ),    "hmacSHA384",    "HMAC-SHA-384" },
 675         MBEDTLS_MD_SHA384,
 676     },
 677     {
 678         { ADD_LEN( MBEDTLS_OID_HMAC_SHA512 ),    "hmacSHA512",    "HMAC-SHA-512" },
 679         MBEDTLS_MD_SHA512,
 680     },
 681 #endif /* MBEDTLS_SHA512_C */
 682     {
 683         { NULL, 0, NULL, NULL },
 684         MBEDTLS_MD_NONE,
 685     },
 686 };
 687
 688 FN_OID_TYPED_FROM_ASN1(oid_md_hmac_t, md_hmac, oid_md_hmac)
 689 FN_OID_GET_ATTR1(mbedtls_oid_get_md_hmac, oid_md_hmac_t, md_hmac, mbedtls_md_type_t, md_hmac)
 690 #endif /* MBEDTLS_MD_C */
 691
 692 #if defined(MBEDTLS_PKCS12_C)
 693 /*
 694  * For PKCS#12 PBEs
 695  */
 696 typedef struct {
 697     mbedtls_oid_descriptor_t    descriptor;
 698     mbedtls_md_type_t           md_alg;
 699     mbedtls_cipher_type_t       cipher_alg;
 700 } oid_pkcs12_pbe_alg_t;
 701
 702 static const oid_pkcs12_pbe_alg_t oid_pkcs12_pbe_alg[] =
 703 {
 704     {
 705         { ADD_LEN( MBEDTLS_OID_PKCS12_PBE_SHA1_DES3_EDE_CBC ), "pbeWithSHAAnd3-KeyTripleDES-CBC", "PBE with SHA1 and 3-Key 3DES" },
 706         MBEDTLS_MD_SHA1,      MBEDTLS_CIPHER_DES_EDE3_CBC,
 707     },
 708     {
 709         { ADD_LEN( MBEDTLS_OID_PKCS12_PBE_SHA1_DES2_EDE_CBC ), "pbeWithSHAAnd2-KeyTripleDES-CBC", "PBE with SHA1 and 2-Key 3DES" },
 710         MBEDTLS_MD_SHA1,      MBEDTLS_CIPHER_DES_EDE_CBC,
 711     },
 712     {
 713         { NULL, 0, NULL, NULL },
 714         MBEDTLS_MD_NONE, MBEDTLS_CIPHER_NONE,
 715     },
 716 };
 717
 718 FN_OID_TYPED_FROM_ASN1(oid_pkcs12_pbe_alg_t, pkcs12_pbe_alg, oid_pkcs12_pbe_alg)
 719 FN_OID_GET_ATTR2(mbedtls_oid_get_pkcs12_pbe_alg, oid_pkcs12_pbe_alg_t, pkcs12_pbe_alg, mbedtls_md_type_t, md_alg, mbedtls_cipher_type_t, cipher_alg)
 720 #endif /* MBEDTLS_PKCS12_C */
 721
 722 #define OID_SAFE_SNPRINTF                               \
 723     do {                                                \
 724         if( ret < 0 || (size_t) ret >= n )              \
 725             return( MBEDTLS_ERR_OID_BUF_TOO_SMALL );    \
 726                                                         \
 727         n -= (size_t) ret;                              \
 728         p += (size_t) ret;                              \
 729     } while( 0 )
 730
 731 /* Return the x.y.z.... style numeric string for the given OID */
 732 int mbedtls_oid_get_numeric_string( char *buf, size_t size,
 733                             const mbedtls_asn1_buf *oid )
 734 {
 735     int ret;
 736     size_t i, n;
 737     unsigned int value;
 738     char *p;
 739
 740     p = buf;
 741     n = size;
 742
 743     /* First byte contains first two dots */
 744     if( oid->len > 0 )
 745     {
 746         ret = mbedtls_snprintf( p, n, "%d.%d", oid->p[0] / 40, oid->p[0] % 40 );
 747         OID_SAFE_SNPRINTF;
 748     }
 749
 750     value = 0;
 751     for( i = 1; i < oid->len; i++ )
 752     {
 753         /* Prevent overflow in value. */
 754         if( ( ( value << 7 ) >> 7 ) != value )
 755             return( MBEDTLS_ERR_OID_BUF_TOO_SMALL );
 756
 757         value <<= 7;
 758         value += oid->p[i] & 0x7F;
 759
 760         if( !( oid->p[i] & 0x80 ) )
 761         {
 762             /* Last byte */
 763             ret = mbedtls_snprintf( p, n, ".%d", value );
 764             OID_SAFE_SNPRINTF;
 765             value = 0;
 766         }
 767     }
 768
 769     return( (int) ( size - n ) );
 770 }
 771
 772 #endif /* MBEDTLS_OID_C */