Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | Download | RSS feed

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