git.sur5r.net Git - freertos/blob - FreeRTOS-Labs/Source/mbedtls/library/oid.c

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