OSX/libsecurity_ssl/lib/sslCipherSpecs.c

   1 /*
   2  * Copyright (c) 1999-2001,2005-2014 Apple Inc. All Rights Reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. Please obtain a copy of the License at
  10  * http://www.opensource.apple.com/apsl/ and read it before using this
  11  * file.
  12  *
  13  * The Original Code and all software distributed under the License are
  14  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  15  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  16  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  18  * Please see the License for the specific language governing rights and
  19  * limitations under the License.
  20  *
  21  * @APPLE_LICENSE_HEADER_END@
  22  */
  23
  24 /*
  25  * cipherSpecs.c - SSLCipherSpec declarations
  26  */
  27
  28 #include "sslBuildFlags.h"
  29 #include "sslContext.h"
  30 #include "sslCipherSpecs.h"
  31 #include "sslDebug.h"
  32 #include "sslMemory.h"
  33 #include "sslDebug.h"
  34 #include "sslPriv.h"
  35
  36 #include <tls_handshake.h>
  37
  38 #include <string.h>
  39 #include <assert.h>
  40 #include <Security/SecBase.h>
  41
  42 #include <TargetConditionals.h>
  43
  44
  45 /* SecureTransport needs it's own copy of KnownCipherSuites for now, there is a copy in coreTLS,
  46    that is exported, but it actually should only included the "default" not the supported */
  47
  48 #define ENABLE_ECDH                 1
  49 #define ENABLE_AES_GCM              1
  50 #define ENABLE_PSK                  1
  51 #define ENABLE_CHACHA20_POLY1305    1
  52 #define ENABLE_AES_CCM              0
  53
  54
  55 static const uint16_t STKnownCipherSuites[] = {
  56 #if ENABLE_AES_GCM
  57     TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
  58     TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
  59 #endif
  60     TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384,
  61     TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256,
  62     TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
  63     TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
  64     TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA,
  65 #if ENABLE_AES_GCM
  66     TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
  67     TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
  68 #endif
  69     TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384,
  70     TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256,
  71     TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
  72     TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,
  73     TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA,
  74 #if ENABLE_ECDH
  75 #if ENABLE_AES_GCM
  76     TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384,
  77     TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256,
  78 #endif
  79     TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384,
  80     TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256,
  81     TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA,
  82     TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA,
  83     TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA,
  84 #if ENABLE_AES_GCM
  85     TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384,
  86     TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256,
  87 #endif
  88     TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384,
  89     TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256,
  90     TLS_ECDH_RSA_WITH_AES_256_CBC_SHA,
  91     TLS_ECDH_RSA_WITH_AES_128_CBC_SHA,
  92     TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA,
  93 #endif
  94
  95 #if ENABLE_AES_GCM
  96     TLS_DHE_RSA_WITH_AES_256_GCM_SHA384,
  97     TLS_DHE_RSA_WITH_AES_128_GCM_SHA256,
  98 #endif // ENABLE_AES_GCM
  99     TLS_DHE_RSA_WITH_AES_256_CBC_SHA256,
 100     TLS_DHE_RSA_WITH_AES_128_CBC_SHA256,
 101     TLS_DHE_RSA_WITH_AES_256_CBC_SHA,
 102     TLS_DHE_RSA_WITH_AES_128_CBC_SHA,
 103     SSL_DHE_RSA_WITH_3DES_EDE_CBC_SHA,
 104
 105 #if ENABLE_AES_GCM
 106     TLS_RSA_WITH_AES_256_GCM_SHA384,
 107     TLS_RSA_WITH_AES_128_GCM_SHA256,
 108 #endif
 109     TLS_RSA_WITH_AES_256_CBC_SHA256,
 110     TLS_RSA_WITH_AES_128_CBC_SHA256,
 111     TLS_RSA_WITH_AES_256_CBC_SHA,
 112     TLS_RSA_WITH_AES_128_CBC_SHA,
 113     SSL_RSA_WITH_3DES_EDE_CBC_SHA,
 114
 115     /* TLS 1.3 ciphersuites */
 116 #if ENABLE_AES_GCM
 117     TLS_AES_128_GCM_SHA256,
 118     TLS_AES_256_GCM_SHA384,
 119 #endif
 120 #if ENABLE_CHACHA20_POLY1305
 121     TLS_CHACHA20_POLY1305_SHA256,
 122 #endif
 123 #if ENABLE_AES_CCM
 124     TLS_AES_128_CCM_SHA256,
 125     TLS_AES_128_CCM_8_SHA256,
 126 #endif
 127
 128     /* Unsafe ciphersuites */
 129
 130 #if ENABLE_AES_GCM
 131     TLS_DH_anon_WITH_AES_256_GCM_SHA384,
 132     TLS_DH_anon_WITH_AES_128_GCM_SHA256,
 133 #endif
 134     TLS_DH_anon_WITH_AES_128_CBC_SHA256,
 135     TLS_DH_anon_WITH_AES_256_CBC_SHA256,
 136     TLS_DH_anon_WITH_AES_128_CBC_SHA,
 137     TLS_DH_anon_WITH_AES_256_CBC_SHA,
 138     SSL_DH_anon_WITH_3DES_EDE_CBC_SHA,
 139
 140     TLS_ECDHE_ECDSA_WITH_NULL_SHA,
 141     TLS_ECDHE_RSA_WITH_NULL_SHA,
 142 #if ENABLE_ECDH
 143     TLS_ECDH_ECDSA_WITH_NULL_SHA,
 144     TLS_ECDH_RSA_WITH_NULL_SHA,
 145 #endif
 146
 147 #if ENABLE_PSK
 148     TLS_PSK_WITH_AES_256_CBC_SHA384,
 149     TLS_PSK_WITH_AES_128_CBC_SHA256,
 150     TLS_PSK_WITH_AES_256_CBC_SHA,
 151     TLS_PSK_WITH_AES_128_CBC_SHA,
 152     TLS_PSK_WITH_3DES_EDE_CBC_SHA,
 153     TLS_PSK_WITH_NULL_SHA384,
 154     TLS_PSK_WITH_NULL_SHA256,
 155     TLS_PSK_WITH_NULL_SHA,
 156 #endif
 157
 158     TLS_RSA_WITH_NULL_SHA256,
 159     SSL_RSA_WITH_NULL_SHA,
 160     SSL_RSA_WITH_NULL_MD5
 161 };
 162
 163 static const unsigned STCipherSuiteCount = sizeof(STKnownCipherSuites)/sizeof(STKnownCipherSuites[0]);
 164
 165 #define CiphersuitesTLS13 \
 166     TLS_AES_128_GCM_SHA256, \
 167     TLS_AES_256_GCM_SHA384, \
 168     TLS_CHACHA20_POLY1305_SHA256
 169
 170 #define CiphersuitesPFS \
 171     TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384, \
 172     TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, \
 173     TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384, \
 174     TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256, \
 175     TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA, \
 176     TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, \
 177     TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256, \
 178     TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384, \
 179     TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256, \
 180     TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384, \
 181     TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256, \
 182     TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA, \
 183     TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA, \
 184     TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256
 185
 186 #define CiphersuitesNonPFS \
 187     TLS_RSA_WITH_AES_256_GCM_SHA384, \
 188     TLS_RSA_WITH_AES_128_GCM_SHA256, \
 189     TLS_RSA_WITH_AES_256_CBC_SHA256, \
 190     TLS_RSA_WITH_AES_128_CBC_SHA256, \
 191     TLS_RSA_WITH_AES_256_CBC_SHA, \
 192     TLS_RSA_WITH_AES_128_CBC_SHA
 193
 194 #define CiphersuitesTLS10 \
 195     TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, \
 196     TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA, \
 197     TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA, \
 198     TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA, \
 199     TLS_RSA_WITH_AES_256_CBC_SHA, \
 200     TLS_RSA_WITH_AES_128_CBC_SHA
 201
 202 #define CiphersuitesTLS10_3DES \
 203     TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA, \
 204     TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA, \
 205     SSL_RSA_WITH_3DES_EDE_CBC_SHA
 206
 207 #define CiphersuitesDHE \
 208     TLS_DHE_RSA_WITH_AES_256_GCM_SHA384, \
 209     TLS_DHE_RSA_WITH_AES_128_GCM_SHA256, \
 210     TLS_DHE_RSA_WITH_AES_256_CBC_SHA256, \
 211     TLS_DHE_RSA_WITH_AES_128_CBC_SHA256, \
 212     TLS_DHE_RSA_WITH_AES_256_CBC_SHA, \
 213     TLS_DHE_RSA_WITH_AES_128_CBC_SHA, \
 214     SSL_DHE_RSA_WITH_3DES_EDE_CBC_SHA
 215
 216
 217 #define DefineTLSCiphersuiteGroupList(XXX, ...) \
 218 static const SSLCipherSuite List##XXX[] = { \
 219     __VA_ARGS__ \
 220 };
 221
 222 DefineTLSCiphersuiteGroupList(kSSLCiphersuiteGroupDefault,
 223                               CiphersuitesTLS13,
 224                               CiphersuitesPFS);
 225 DefineTLSCiphersuiteGroupList(kSSLCiphersuiteGroupCompatibility,
 226                               CiphersuitesNonPFS,
 227                               CiphersuitesTLS10,
 228                               CiphersuitesTLS10_3DES);
 229 DefineTLSCiphersuiteGroupList(kSSLCiphersuiteGroupLegacy,
 230                               CiphersuitesDHE);
 231 DefineTLSCiphersuiteGroupList(kSSLCiphersuiteGroupATS,
 232                               CiphersuitesTLS13,
 233                               CiphersuitesPFS);
 234 DefineTLSCiphersuiteGroupList(kSSLCiphersuiteGroupATSCompatibility,
 235                               CiphersuitesNonPFS);
 236
 237 typedef struct tls_ciphersuite_definition {
 238     SSLCipherSuite ciphersuite;
 239     SSLProtocol min_version;
 240     SSLProtocol max_version;
 241     char ciphersuite_name[64];
 242 } *tls_ciphersuite_definition_t;
 243
 244 #define DefineTLSCiphersuiteDefinition(XXX, MIN_VERSION, MAX_VERSION) \
 245 { \
 246     .ciphersuite = XXX, \
 247     .ciphersuite_name = "##XXX", \
 248     .min_version = MIN_VERSION, \
 249     .max_version = MAX_VERSION, \
 250 }
 251
 252 static const struct tls_ciphersuite_definition tls_ciphersuite_definitions[] = {
 253     // TLS 1.3 ciphersuites
 254     DefineTLSCiphersuiteDefinition(TLS_AES_128_GCM_SHA256,                          kTLSProtocol13, kTLSProtocolMaxSupported),
 255     DefineTLSCiphersuiteDefinition(TLS_AES_256_GCM_SHA384,                          kTLSProtocol13, kTLSProtocolMaxSupported),
 256     DefineTLSCiphersuiteDefinition(TLS_CHACHA20_POLY1305_SHA256,                    kTLSProtocol13, kTLSProtocolMaxSupported),
 257
 258     // RFC 7905: ChaCha20-Poly1305 Cipher Suites for Transport Layer Security (TLS)
 259     DefineTLSCiphersuiteDefinition(TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256,   kTLSProtocol12, kTLSProtocol12),
 260     DefineTLSCiphersuiteDefinition(TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,     kTLSProtocol12, kTLSProtocol12),
 261
 262     // RFC 5289: TLS Elliptic Curve Cipher Suites with SHA-256/384 and AES Galois Counter Mode (GCM)
 263     DefineTLSCiphersuiteDefinition(TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,         kTLSProtocol12, kTLSProtocol12),
 264     DefineTLSCiphersuiteDefinition(TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,         kTLSProtocol12, kTLSProtocol12),
 265     DefineTLSCiphersuiteDefinition(TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384,         kTLSProtocol12, kTLSProtocol12),
 266     DefineTLSCiphersuiteDefinition(TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256,         kTLSProtocol12, kTLSProtocol12),
 267     DefineTLSCiphersuiteDefinition(TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,           kTLSProtocol12, kTLSProtocol12),
 268     DefineTLSCiphersuiteDefinition(TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,           kTLSProtocol12, kTLSProtocol12),
 269     DefineTLSCiphersuiteDefinition(TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384,           kTLSProtocol12, kTLSProtocol12),
 270     DefineTLSCiphersuiteDefinition(TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256,           kTLSProtocol12, kTLSProtocol12),
 271
 272     // RFC 5288: AES Galois Counter Mode (GCM) Cipher Suites for TLS
 273     DefineTLSCiphersuiteDefinition(TLS_RSA_WITH_AES_256_GCM_SHA384,                 kTLSProtocol12, kTLSProtocol12),
 274     DefineTLSCiphersuiteDefinition(TLS_RSA_WITH_AES_128_GCM_SHA256,                 kTLSProtocol12, kTLSProtocol12),
 275     DefineTLSCiphersuiteDefinition(TLS_DHE_RSA_WITH_AES_256_GCM_SHA384,             kTLSProtocol12, kTLSProtocol12),
 276     DefineTLSCiphersuiteDefinition(TLS_DHE_RSA_WITH_AES_128_GCM_SHA256,             kTLSProtocol12, kTLSProtocol12),
 277
 278     // RFC 5246: The Transport Layer Security (TLS) Protocol Version 1.2
 279     DefineTLSCiphersuiteDefinition(TLS_RSA_WITH_AES_256_CBC_SHA256,                 kTLSProtocol12, kTLSProtocol12),
 280     DefineTLSCiphersuiteDefinition(TLS_RSA_WITH_AES_128_CBC_SHA256,                 kTLSProtocol12, kTLSProtocol12),
 281     DefineTLSCiphersuiteDefinition(SSL_DHE_RSA_WITH_3DES_EDE_CBC_SHA,               kTLSProtocol12, kTLSProtocol12),
 282     DefineTLSCiphersuiteDefinition(SSL_RSA_WITH_3DES_EDE_CBC_SHA,                   kTLSProtocol12, kTLSProtocol12),
 283     DefineTLSCiphersuiteDefinition(TLS_DHE_RSA_WITH_AES_256_CBC_SHA256,             kTLSProtocol12, kTLSProtocol12),
 284     DefineTLSCiphersuiteDefinition(TLS_DHE_RSA_WITH_AES_128_CBC_SHA256,             kTLSProtocol12, kTLSProtocol12),
 285
 286     // RFC 4492: Elliptic Curve Cryptography (ECC) Cipher Suites for Transport Layer Security (TLS)
 287     DefineTLSCiphersuiteDefinition(TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,            kTLSProtocol1,  kTLSProtocol11),
 288     DefineTLSCiphersuiteDefinition(TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,            kTLSProtocol1,  kTLSProtocol11),
 289     DefineTLSCiphersuiteDefinition(TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,              kTLSProtocol1,  kTLSProtocol11),
 290     DefineTLSCiphersuiteDefinition(TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,              kTLSProtocol1,  kTLSProtocol11),
 291     DefineTLSCiphersuiteDefinition(TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA,           kTLSProtocol1,  kTLSProtocol11),
 292     DefineTLSCiphersuiteDefinition(TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA,             kTLSProtocol1,  kTLSProtocol11),
 293
 294     // RFC 3268: Advanced Encryption Standard (AES) Ciphersuites for Transport Layer Security (TLS)
 295     DefineTLSCiphersuiteDefinition(TLS_RSA_WITH_AES_256_CBC_SHA,                    kTLSProtocol1,  kTLSProtocol11),
 296     DefineTLSCiphersuiteDefinition(TLS_RSA_WITH_AES_128_CBC_SHA,                    kTLSProtocol1,  kTLSProtocol11),
 297     DefineTLSCiphersuiteDefinition(TLS_RSA_WITH_AES_256_CBC_SHA,                    kTLSProtocol1,  kTLSProtocol11),
 298     DefineTLSCiphersuiteDefinition(TLS_DHE_RSA_WITH_AES_256_CBC_SHA,                kTLSProtocol1,  kTLSProtocol11),
 299     DefineTLSCiphersuiteDefinition(TLS_RSA_WITH_AES_128_CBC_SHA,                    kTLSProtocol1,  kTLSProtocol11),
 300     DefineTLSCiphersuiteDefinition(TLS_DHE_RSA_WITH_AES_128_CBC_SHA,                kTLSProtocol1,  kTLSProtocol11),
 301     DefineTLSCiphersuiteDefinition(TLS_DHE_RSA_WITH_AES_256_CBC_SHA,                kTLSProtocol1,  kTLSProtocol11),
 302     DefineTLSCiphersuiteDefinition(TLS_DHE_RSA_WITH_AES_128_CBC_SHA,                kTLSProtocol1,  kTLSProtocol11),
 303 };
 304
 305 // Size of the definition list
 306 static const size_t tls_ciphersuite_definitions_length = \
 307     sizeof(tls_ciphersuite_definitions) / sizeof(struct tls_ciphersuite_definition);
 308
 309 // Remove macro definitions
 310 #undef CiphersuitesTLS13
 311 #undef CiphersuitesPFS
 312 #undef CiphersuitesNonPFS
 313 #undef CiphersuitesTLS10_3DES
 314 #undef CiphersuitesTLS10
 315 #undef CiphersuitesDHE
 316 #undef DefineTLSCiphersuiteGroupList
 317 #undef DefineTLSCiphersuiteDefinition
 318
 319 const SSLCipherSuite *
 320 SSLCiphersuiteGroupToCiphersuiteList(SSLCiphersuiteGroup group, size_t *listSize)
 321 {
 322     if (listSize == NULL) {
 323         return NULL;
 324     }
 325
 326     const SSLCipherSuite *ciphersuites = NULL;
 327     size_t count = 0;
 328
 329 #define CASE_CONFIG(GROUPNAME) \
 330     case GROUPNAME: \
 331         ciphersuites = List##GROUPNAME; \
 332         count = sizeof(List##GROUPNAME) / sizeof(SSLCipherSuite); \
 333         break;
 334
 335     switch (group) {
 336         CASE_CONFIG(kSSLCiphersuiteGroupDefault);
 337         CASE_CONFIG(kSSLCiphersuiteGroupCompatibility);
 338         CASE_CONFIG(kSSLCiphersuiteGroupLegacy);
 339         CASE_CONFIG(kSSLCiphersuiteGroupATS);
 340         CASE_CONFIG(kSSLCiphersuiteGroupATSCompatibility);
 341     }
 342
 343 #undef CASE_CONFIG
 344
 345     if (ciphersuites != NULL) {
 346         *listSize = count;
 347         return ciphersuites;
 348     }
 349
 350     *listSize = 0;
 351     return NULL;
 352 }
 353
 354 SSLProtocol
 355 SSLCiphersuiteMinimumTLSVersion(SSLCipherSuite ciphersuite)
 356 {
 357     for (size_t i = 0; i < tls_ciphersuite_definitions_length; i++) {
 358         if (tls_ciphersuite_definitions[i].ciphersuite == ciphersuite) {
 359             return tls_ciphersuite_definitions[i].min_version;
 360         }
 361     }
 362     return kSSLProtocolUnknown;
 363 }
 364
 365 SSLProtocol
 366 SSLCiphersuiteMaximumTLSVersion(SSLCipherSuite ciphersuite)
 367 {
 368     for (size_t i = 0; i < tls_ciphersuite_definitions_length; i++) {
 369         if (tls_ciphersuite_definitions[i].ciphersuite == ciphersuite) {
 370             return tls_ciphersuite_definitions[i].max_version;
 371         }
 372     }
 373     return kSSLProtocolUnknown;
 374 }
 375
 376 /*
 377  * Convert an array of uint16_t
 378  * to an array of SSLCipherSuites.
 379  */
 380 static OSStatus
 381 cipherSuitesToCipherSuites(
 382                           size_t                                numCipherSuites,
 383                           const uint16_t        *cipherSuites,
 384                           SSLCipherSuite                *ciphers,               /* RETURNED */
 385                           size_t                                *numCiphers)    /* IN/OUT */
 386 {
 387     size_t i;
 388         if(*numCiphers < numCipherSuites) {
 389                 return errSSLBufferOverflow;
 390         }
 391
 392     /* NOTE: this is required to go from uint16_t to SSLCipherSuite
 393        which is either 32 or 16 bits, depending on the platform */
 394     for(i=0;i<numCipherSuites; i++) {
 395         ciphers[i]=cipherSuites[i];
 396     }
 397         *numCiphers = numCipherSuites;
 398         return errSecSuccess;
 399 }
 400
 401 /***
 402  *** Publically exported functions declared in SecureTransport.h
 403  ***/
 404
 405 /*
 406  * Determine number and values of all of the SSLCipherSuites we support.
 407  * Caller allocates output buffer for SSLGetSupportedCiphers() and passes in
 408  * its size in *numCiphers. If supplied buffer is too small, errSSLBufferOverflow
 409  * will be returned.
 410  */
 411 OSStatus
 412 SSLGetNumberSupportedCiphers (SSLContextRef     ctx,
 413                                                           size_t                *numCiphers)
 414 {
 415         if((ctx == NULL) || (numCiphers == NULL)) {
 416                 return errSecParam;
 417         }
 418         *numCiphers = STCipherSuiteCount;
 419         return errSecSuccess;
 420 }
 421
 422 OSStatus
 423 SSLGetSupportedCiphers           (SSLContextRef         ctx,
 424                                                           SSLCipherSuite        *ciphers,               /* RETURNED */
 425                                                           size_t                        *numCiphers)    /* IN/OUT */
 426 {
 427         if((ctx == NULL) || (ciphers == NULL) || (numCiphers == NULL)) {
 428                 return errSecParam;
 429         }
 430         return cipherSuitesToCipherSuites(STCipherSuiteCount,
 431                 STKnownCipherSuites,
 432                 ciphers,
 433                 numCiphers);
 434 }
 435
 436 /*
 437  * Specify a (typically) restricted set of SSLCipherSuites to be enabled by
 438  * the current SSLContext. Can only be called when no session is active. Default
 439  * set of enabled SSLCipherSuites is NOT the same as the complete set of supported
 440  * SSLCipherSuites as obtained by SSLGetSupportedCiphers().
 441  */
 442 OSStatus
 443 SSLSetEnabledCiphers            (SSLContextRef                  ctx,
 444                                                          const SSLCipherSuite   *ciphers,
 445                                                          size_t                                 numCiphers)
 446 {
 447     uint16_t *cs;
 448
 449         if((ctx == NULL) || (ciphers == NULL) || (numCiphers == 0)) {
 450                 return errSecParam;
 451         }
 452
 453         if(sslIsSessionActive(ctx)) {
 454                 /* can't do this with an active session */
 455                 return errSecBadReq;
 456         }
 457
 458     int matchCount = 0;
 459     for(int i=0; i<numCiphers; i++) {
 460         for (int j=0; j < STCipherSuiteCount; j++) {
 461             if (STKnownCipherSuites[j] == ciphers[i]) {
 462                 matchCount++;
 463                 break;
 464             }
 465         }
 466     }
 467
 468     // If the caller specified no ciphersuites that we actually support, return an error code.
 469     if (matchCount == 0) {
 470         return errSecParam;
 471     }
 472
 473     cs = (uint16_t *)sslMalloc(matchCount * sizeof(uint16_t));
 474     if(cs == NULL) {
 475                 return errSecAllocate;
 476         }
 477
 478     matchCount = 0;
 479     for(int i=0; i<numCiphers; i++) {
 480         for (int j=0; j < STCipherSuiteCount; j++) {
 481             if (STKnownCipherSuites[j] == ciphers[i]) {
 482                 cs[matchCount++] = ciphers[i];
 483                 break;
 484             }
 485         }
 486     }
 487
 488
 489     OSStatus result = tls_handshake_set_ciphersuites(ctx->hdsk, cs, (unsigned) matchCount);
 490
 491     sslFree(cs);
 492
 493     return result;
 494 }
 495
 496 /*
 497  * Determine number and values of all of the SSLCipherSuites currently enabled.
 498  * Caller allocates output buffer for SSLGetEnabledCiphers() and passes in
 499  * its size in *numCiphers. If supplied buffer is too small, errSSLBufferOverflow
 500  * will be returned.
 501  */
 502 OSStatus
 503 SSLGetNumberEnabledCiphers      (SSLContextRef                  ctx,
 504                                                          size_t                                 *numCiphers)
 505 {
 506         if((ctx == NULL) || (numCiphers == NULL)) {
 507                 return errSecParam;
 508         }
 509
 510     unsigned n;
 511     const uint16_t *ciphersuites;
 512     int err;
 513
 514     err = tls_handshake_get_ciphersuites(ctx->hdsk, &ciphersuites, &n);
 515
 516     if(err) {
 517         return err;
 518     } else {
 519         *numCiphers = n;
 520         return errSecSuccess;
 521     }
 522 }
 523
 524 OSStatus
 525 SSLGetEnabledCiphers            (SSLContextRef                  ctx,
 526                                                          SSLCipherSuite                 *ciphers,               /* RETURNED */
 527                                                          size_t                                 *numCiphers)    /* IN/OUT */
 528 {
 529         if((ctx == NULL) || (ciphers == NULL) || (numCiphers == NULL)) {
 530                 return errSecParam;
 531         }
 532
 533     unsigned n;
 534     const uint16_t *ciphersuites;
 535     int err;
 536
 537     err = tls_handshake_get_ciphersuites(ctx->hdsk, &ciphersuites, &n);
 538
 539     if(err) {
 540         return err;
 541     } else {
 542         return cipherSuitesToCipherSuites(n,
 543                                           ciphersuites,
 544                                           ciphers,
 545                                           numCiphers);
 546     }
 547 }
 548
 549 OSStatus
 550 SSLSetSessionTicketsEnabled     (SSLContextRef          context,
 551                                  Boolean                enabled)
 552 {
 553     if (context == NULL) {
 554         return errSecParam;
 555     }
 556
 557     return tls_handshake_set_session_ticket_enabled(context->hdsk, enabled);
 558 }