1 /* 2 * Copyright (C) 2008 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package org.apache.harmony.xnet.provider.jsse; 18 19 import java.io.FileDescriptor; 20 import java.io.IOException; 21 import java.net.SocketTimeoutException; 22 import java.nio.ByteOrder; 23 import java.security.MessageDigest; 24 import java.security.NoSuchAlgorithmException; 25 import java.security.SignatureException; 26 import java.security.cert.Certificate; 27 import java.security.cert.CertificateEncodingException; 28 import java.security.cert.CertificateException; 29 import java.security.cert.X509Certificate; 30 import java.util.ArrayList; 31 import java.util.HashMap; 32 import java.util.LinkedHashMap; 33 import java.util.List; 34 import java.util.Map; 35 import javax.crypto.BadPaddingException; 36 import javax.net.ssl.SSLException; 37 import javax.security.auth.x500.X500Principal; 38 import libcore.io.Memory; 39 40 /** 41 * Provides the Java side of our JNI glue for OpenSSL. 42 */ 43 public final class NativeCrypto { 44 45 // --- OpenSSL library initialization -------------------------------------- 46 static { 47 clinit(); 48 } 49 50 private native static void clinit(); 51 52 // --- ENGINE functions ---------------------------------------------------- 53 public static native void ENGINE_load_dynamic(); 54 55 public static native int ENGINE_by_id(String id); 56 57 public static native int ENGINE_add(int e); 58 59 public static native int ENGINE_init(int e); 60 61 public static native int ENGINE_finish(int e); 62 63 public static native int ENGINE_free(int e); 64 65 public static native int ENGINE_load_private_key(int e, String key_id); 66 67 // --- DSA/RSA public/private key handling functions ----------------------- 68 69 public static native int EVP_PKEY_new_DSA(byte[] p, byte[] q, byte[] g, 70 byte[] pub_key, byte[] priv_key); 71 72 public static native int EVP_PKEY_new_RSA(byte[] n, byte[] e, byte[] d, byte[] p, byte[] q, 73 byte[] dmp1, byte[] dmq1, byte[] iqmp); 74 75 public static native int EVP_PKEY_size(int pkey); 76 77 public static native int EVP_PKEY_type(int pkey); 78 79 public static native void EVP_PKEY_free(int pkey); 80 81 public static native int EVP_PKEY_cmp(int pkey1, int pkey2); 82 83 public static native byte[] i2d_PKCS8_PRIV_KEY_INFO(int pkey); 84 85 public static native int d2i_PKCS8_PRIV_KEY_INFO(byte[] data); 86 87 public static native byte[] i2d_PUBKEY(int pkey); 88 89 public static native int d2i_PUBKEY(byte[] data); 90 91 public static native int RSA_generate_key_ex(int modulusBits, byte[] publicExponent); 92 93 public static native int RSA_size(int pkey); 94 95 public static native int RSA_private_encrypt(int flen, byte[] from, byte[] to, int pkey, 96 int padding); 97 98 public static native int RSA_public_decrypt(int flen, byte[] from, byte[] to, int pkey, 99 int padding) throws BadPaddingException, SignatureException; 100 101 public static native int RSA_public_encrypt(int flen, byte[] from, byte[] to, int pkey, 102 int padding); 103 104 public static native int RSA_private_decrypt(int flen, byte[] from, byte[] to, int pkey, 105 int padding) throws BadPaddingException, SignatureException; 106 107 /** 108 * @return array of {n, e} 109 */ 110 public static native byte[][] get_RSA_public_params(int rsa); 111 112 /** 113 * @return array of {n, e, d, p, q, dmp1, dmq1, iqmp} 114 */ 115 public static native byte[][] get_RSA_private_params(int rsa); 116 117 public static native int DSA_generate_key(int primeBits, byte[] seed, byte[] g, byte[] p, 118 byte[] q); 119 120 /** 121 * @return array of {g, p, q, y(pub), x(priv)} 122 */ 123 public static native byte[][] get_DSA_params(int dsa); 124 125 public static native byte[] i2d_RSAPublicKey(int rsa); 126 127 public static native byte[] i2d_RSAPrivateKey(int rsa); 128 129 public static native byte[] i2d_DSAPublicKey(int dsa); 130 131 public static native byte[] i2d_DSAPrivateKey(int dsa); 132 133 // --- Message digest functions -------------- 134 135 public static native int EVP_get_digestbyname(String name); 136 137 public static native int EVP_MD_size(int evp_md); 138 139 public static native int EVP_MD_block_size(int evp_md); 140 141 // --- Message digest context functions -------------- 142 143 public static native void EVP_MD_CTX_destroy(int ctx); 144 145 public static native int EVP_MD_CTX_copy(int ctx); 146 147 // --- Digest handling functions ------------------------------------------- 148 149 public static native int EVP_DigestInit(int evp_md); 150 151 public static native void EVP_DigestUpdate(int ctx, byte[] buffer, int offset, int length); 152 153 public static native int EVP_DigestFinal(int ctx, byte[] hash, int offset); 154 155 // --- Signature handling functions ---------------------------------------- 156 157 public static native int EVP_SignInit(String algorithm); 158 159 public static native void EVP_SignUpdate(int ctx, byte[] buffer, 160 int offset, int length); 161 162 public static native int EVP_SignFinal(int ctx, byte[] signature, int offset, int key); 163 164 public static native int EVP_VerifyInit(String algorithm); 165 166 public static native void EVP_VerifyUpdate(int ctx, byte[] buffer, 167 int offset, int length); 168 169 public static native int EVP_VerifyFinal(int ctx, byte[] signature, 170 int offset, int length, int key); 171 172 173 // --- Block ciphers ------------------------------------------------------- 174 175 public static native int EVP_get_cipherbyname(String string); 176 177 public static native int EVP_CipherInit_ex(int cipherNid, byte[] key, byte[] iv, 178 boolean encrypting); 179 180 public static native int EVP_CipherUpdate(int ctx, byte[] out, int outOffset, byte[] in, 181 int inOffset); 182 183 public static native int EVP_CipherFinal_ex(int ctx, byte[] out, int outOffset); 184 185 public static native void EVP_CIPHER_CTX_cleanup(int ctx); 186 187 // --- RAND seeding -------------------------------------------------------- 188 189 public static final int RAND_SEED_LENGTH_IN_BYTES = 1024; 190 191 public static native void RAND_seed(byte[] seed); 192 193 public static native int RAND_load_file(String filename, long max_bytes); 194 195 public static native void RAND_bytes(byte[] output); 196 197 // --- X509_NAME ----------------------------------------------------------- 198 199 public static int X509_NAME_hash(X500Principal principal) { 200 return X509_NAME_hash(principal, "SHA1"); 201 } 202 public static int X509_NAME_hash_old(X500Principal principal) { 203 return X509_NAME_hash(principal, "MD5"); 204 } 205 private static int X509_NAME_hash(X500Principal principal, String algorithm) { 206 try { 207 byte[] digest = MessageDigest.getInstance(algorithm).digest(principal.getEncoded()); 208 return Memory.peekInt(digest, 0, ByteOrder.LITTLE_ENDIAN); 209 } catch (NoSuchAlgorithmException e) { 210 throw new AssertionError(e); 211 } 212 } 213 214 // --- SSL handling -------------------------------------------------------- 215 216 private static final String SUPPORTED_PROTOCOL_SSLV3 = "SSLv3"; 217 private static final String SUPPORTED_PROTOCOL_TLSV1 = "TLSv1"; 218 private static final String SUPPORTED_PROTOCOL_TLSV1_1 = "TLSv1.1"; 219 private static final String SUPPORTED_PROTOCOL_TLSV1_2 = "TLSv1.2"; 220 221 public static final Map<String, String> OPENSSL_TO_STANDARD_CIPHER_SUITES 222 = new HashMap<String, String>(); 223 public static final Map<String, String> STANDARD_TO_OPENSSL_CIPHER_SUITES 224 = new LinkedHashMap<String, String>(); 225 226 private static void add(String standard, String openssl) { 227 OPENSSL_TO_STANDARD_CIPHER_SUITES.put(openssl, standard); 228 STANDARD_TO_OPENSSL_CIPHER_SUITES.put(standard, openssl); 229 } 230 231 /** 232 * TLS_EMPTY_RENEGOTIATION_INFO_SCSV is RFC 5746's renegotiation 233 * indication signaling cipher suite value. It is not a real 234 * cipher suite. It is just an indication in the default and 235 * supported cipher suite lists indicates that the implementation 236 * supports secure renegotiation. 237 * 238 * In the RI, its presence means that the SCSV is sent in the 239 * cipher suite list to indicate secure renegotiation support and 240 * its absense means to send an empty TLS renegotiation info 241 * extension instead. 242 * 243 * However, OpenSSL doesn't provide an API to give this level of 244 * control, instead always sending the SCSV and always including 245 * the empty renegotiation info if TLS is used (as opposed to 246 * SSL). So we simply allow TLS_EMPTY_RENEGOTIATION_INFO_SCSV to 247 * be passed for compatibility as to provide the hint that we 248 * support secure renegotiation. 249 */ 250 public static final String TLS_EMPTY_RENEGOTIATION_INFO_SCSV 251 = "TLS_EMPTY_RENEGOTIATION_INFO_SCSV"; 252 253 static { 254 // Note these are added in priority order 255 add("SSL_RSA_WITH_RC4_128_MD5", "RC4-MD5"); 256 add("SSL_RSA_WITH_RC4_128_SHA", "RC4-SHA"); 257 add("TLS_RSA_WITH_AES_128_CBC_SHA", "AES128-SHA"); 258 add("TLS_RSA_WITH_AES_256_CBC_SHA", "AES256-SHA"); 259 add("TLS_ECDH_ECDSA_WITH_RC4_128_SHA", "ECDH-ECDSA-RC4-SHA"); 260 add("TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA", "ECDH-ECDSA-AES128-SHA"); 261 add("TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA", "ECDH-ECDSA-AES256-SHA"); 262 add("TLS_ECDH_RSA_WITH_RC4_128_SHA", "ECDH-RSA-RC4-SHA"); 263 add("TLS_ECDH_RSA_WITH_AES_128_CBC_SHA", "ECDH-RSA-AES128-SHA"); 264 add("TLS_ECDH_RSA_WITH_AES_256_CBC_SHA", "ECDH-RSA-AES256-SHA"); 265 add("TLS_ECDHE_ECDSA_WITH_RC4_128_SHA", "ECDHE-ECDSA-RC4-SHA"); 266 add("TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA", "ECDHE-ECDSA-AES128-SHA"); 267 add("TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA", "ECDHE-ECDSA-AES256-SHA"); 268 add("TLS_ECDHE_RSA_WITH_RC4_128_SHA", "ECDHE-RSA-RC4-SHA"); 269 add("TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA", "ECDHE-RSA-AES128-SHA"); 270 add("TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA", "ECDHE-RSA-AES256-SHA"); 271 add("TLS_DHE_RSA_WITH_AES_128_CBC_SHA", "DHE-RSA-AES128-SHA"); 272 add("TLS_DHE_RSA_WITH_AES_256_CBC_SHA", "DHE-RSA-AES256-SHA"); 273 add("TLS_DHE_DSS_WITH_AES_128_CBC_SHA", "DHE-DSS-AES128-SHA"); 274 add("TLS_DHE_DSS_WITH_AES_256_CBC_SHA", "DHE-DSS-AES256-SHA"); 275 add("SSL_RSA_WITH_3DES_EDE_CBC_SHA", "DES-CBC3-SHA"); 276 add("TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA", "ECDH-ECDSA-DES-CBC3-SHA"); 277 add("TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA", "ECDH-RSA-DES-CBC3-SHA"); 278 add("TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA", "ECDHE-ECDSA-DES-CBC3-SHA"); 279 add("TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA", "ECDHE-RSA-DES-CBC3-SHA"); 280 add("SSL_DHE_RSA_WITH_3DES_EDE_CBC_SHA", "EDH-RSA-DES-CBC3-SHA"); 281 add("SSL_DHE_DSS_WITH_3DES_EDE_CBC_SHA", "EDH-DSS-DES-CBC3-SHA"); 282 add("SSL_RSA_WITH_DES_CBC_SHA", "DES-CBC-SHA"); 283 add("SSL_DHE_RSA_WITH_DES_CBC_SHA", "EDH-RSA-DES-CBC-SHA"); 284 add("SSL_DHE_DSS_WITH_DES_CBC_SHA", "EDH-DSS-DES-CBC-SHA"); 285 add("SSL_RSA_EXPORT_WITH_RC4_40_MD5", "EXP-RC4-MD5"); 286 add("SSL_RSA_EXPORT_WITH_DES40_CBC_SHA", "EXP-DES-CBC-SHA"); 287 add("SSL_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA", "EXP-EDH-RSA-DES-CBC-SHA"); 288 add("SSL_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA", "EXP-EDH-DSS-DES-CBC-SHA"); 289 add("SSL_RSA_WITH_NULL_MD5", "NULL-MD5"); 290 add("SSL_RSA_WITH_NULL_SHA", "NULL-SHA"); 291 add("TLS_ECDH_ECDSA_WITH_NULL_SHA", "ECDH-ECDSA-NULL-SHA"); 292 add("TLS_ECDH_RSA_WITH_NULL_SHA", "ECDH-RSA-NULL-SHA"); 293 add("TLS_ECDHE_ECDSA_WITH_NULL_SHA", "ECDHE-ECDSA-NULL-SHA"); 294 add("TLS_ECDHE_RSA_WITH_NULL_SHA", "ECDHE-RSA-NULL-SHA"); 295 add("SSL_DH_anon_WITH_RC4_128_MD5", "ADH-RC4-MD5"); 296 add("TLS_DH_anon_WITH_AES_128_CBC_SHA", "ADH-AES128-SHA"); 297 add("TLS_DH_anon_WITH_AES_256_CBC_SHA", "ADH-AES256-SHA"); 298 add("SSL_DH_anon_WITH_3DES_EDE_CBC_SHA", "ADH-DES-CBC3-SHA"); 299 add("SSL_DH_anon_WITH_DES_CBC_SHA", "ADH-DES-CBC-SHA"); 300 add("TLS_ECDH_anon_WITH_RC4_128_SHA", "AECDH-RC4-SHA"); 301 add("TLS_ECDH_anon_WITH_AES_128_CBC_SHA", "AECDH-AES128-SHA"); 302 add("TLS_ECDH_anon_WITH_AES_256_CBC_SHA", "AECDH-AES256-SHA"); 303 add("TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA", "AECDH-DES-CBC3-SHA"); 304 add("SSL_DH_anon_EXPORT_WITH_RC4_40_MD5", "EXP-ADH-RC4-MD5"); 305 add("SSL_DH_anon_EXPORT_WITH_DES40_CBC_SHA", "EXP-ADH-DES-CBC-SHA"); 306 add("TLS_ECDH_anon_WITH_NULL_SHA", "AECDH-NULL-SHA"); 307 308 // No Kerberos in Android 309 // add("TLS_KRB5_WITH_RC4_128_SHA", "KRB5-RC4-SHA"); 310 // add("TLS_KRB5_WITH_RC4_128_MD5", "KRB5-RC4-MD5"); 311 // add("TLS_KRB5_WITH_3DES_EDE_CBC_SHA", "KRB5-DES-CBC3-SHA"); 312 // add("TLS_KRB5_WITH_3DES_EDE_CBC_MD5", "KRB5-DES-CBC3-MD5"); 313 // add("TLS_KRB5_WITH_DES_CBC_SHA", "KRB5-DES-CBC-SHA"); 314 // add("TLS_KRB5_WITH_DES_CBC_MD5", "KRB5-DES-CBC-MD5"); 315 // add("TLS_KRB5_EXPORT_WITH_RC4_40_SHA", "EXP-KRB5-RC4-SHA"); 316 // add("TLS_KRB5_EXPORT_WITH_RC4_40_MD5", "EXP-KRB5-RC4-MD5"); 317 // add("TLS_KRB5_EXPORT_WITH_DES_CBC_40_SHA", "EXP-KRB5-DES-CBC-SHA"); 318 // add("TLS_KRB5_EXPORT_WITH_DES_CBC_40_MD5", "EXP-KRB5-DES-CBC-MD5"); 319 320 // not implemented by either RI or OpenSSL 321 // add("SSL_DH_DSS_EXPORT_WITH_DES40_CBC_SHA", null); 322 // add("SSL_DH_RSA_EXPORT_WITH_DES40_CBC_SHA", null); 323 324 // EXPORT1024 suites were never standardized but were widely implemented. 325 // OpenSSL 0.9.8c and later have disabled TLS1_ALLOW_EXPERIMENTAL_CIPHERSUITES 326 // add("SSL_RSA_EXPORT1024_WITH_DES_CBC_SHA", "EXP1024-DES-CBC-SHA"); 327 // add("SSL_RSA_EXPORT1024_WITH_RC4_56_SHA", "EXP1024-RC4-SHA"); 328 329 // No RC2 330 // add("SSL_RSA_EXPORT_WITH_RC2_CBC_40_MD5", "EXP-RC2-CBC-MD5"); 331 // add("TLS_KRB5_EXPORT_WITH_RC2_CBC_40_SHA", "EXP-KRB5-RC2-CBC-SHA"); 332 // add("TLS_KRB5_EXPORT_WITH_RC2_CBC_40_MD5", "EXP-KRB5-RC2-CBC-MD5"); 333 334 // PSK is Private Shared Key - didn't exist in Froyo's openssl - no JSSE equivalent 335 // add(null, "PSK-3DES-EDE-CBC-SHA"); 336 // add(null, "PSK-AES128-CBC-SHA"); 337 // add(null, "PSK-AES256-CBC-SHA"); 338 // add(null, "PSK-RC4-SHA"); 339 340 // Signaling Cipher Suite Value for secure renegotiation handled as special case. 341 // add("TLS_EMPTY_RENEGOTIATION_INFO_SCSV", null); 342 } 343 344 private static final String[] SUPPORTED_CIPHER_SUITES; 345 static { 346 int size = STANDARD_TO_OPENSSL_CIPHER_SUITES.size(); 347 SUPPORTED_CIPHER_SUITES = new String[size + 1]; 348 STANDARD_TO_OPENSSL_CIPHER_SUITES.keySet().toArray(SUPPORTED_CIPHER_SUITES); 349 SUPPORTED_CIPHER_SUITES[size] = TLS_EMPTY_RENEGOTIATION_INFO_SCSV; 350 } 351 352 // EVP_PKEY types from evp.h and objects.h 353 public static final int EVP_PKEY_RSA = 6; // NID_rsaEcnryption 354 public static final int EVP_PKEY_DSA = 116; // NID_dsa 355 public static final int EVP_PKEY_DH = 28; // NID_dhKeyAgreement 356 public static final int EVP_PKEY_EC = 408; // NID_X9_62_id_ecPublicKey 357 358 // RSA padding modes from rsa.h 359 public static final int RSA_PKCS1_PADDING = 1; 360 public static final int RSA_NO_PADDING = 3; 361 362 // SSL mode from ssl.h 363 public static final long SSL_MODE_HANDSHAKE_CUTTHROUGH = 0x00000040L; 364 365 // SSL options from ssl.h 366 public static final long SSL_OP_NO_TICKET = 0x00004000L; 367 public static final long SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION = 0x00010000L; 368 public static final long SSL_OP_NO_SSLv3 = 0x02000000L; 369 public static final long SSL_OP_NO_TLSv1 = 0x04000000L; 370 public static final long SSL_OP_NO_TLSv1_1 = 0x10000000L; 371 public static final long SSL_OP_NO_TLSv1_2 = 0x08000000L; 372 373 public static native int SSL_CTX_new(); 374 375 public static String[] getDefaultCipherSuites() { 376 return new String[] { 377 "SSL_RSA_WITH_RC4_128_MD5", 378 "SSL_RSA_WITH_RC4_128_SHA", 379 "TLS_RSA_WITH_AES_128_CBC_SHA", 380 "TLS_RSA_WITH_AES_256_CBC_SHA", 381 "TLS_ECDH_ECDSA_WITH_RC4_128_SHA", 382 "TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA", 383 "TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA", 384 "TLS_ECDH_RSA_WITH_RC4_128_SHA", 385 "TLS_ECDH_RSA_WITH_AES_128_CBC_SHA", 386 "TLS_ECDH_RSA_WITH_AES_256_CBC_SHA", 387 "TLS_ECDHE_ECDSA_WITH_RC4_128_SHA", 388 "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA", 389 "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA", 390 "TLS_ECDHE_RSA_WITH_RC4_128_SHA", 391 "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA", 392 "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA", 393 "TLS_DHE_RSA_WITH_AES_128_CBC_SHA", 394 "TLS_DHE_RSA_WITH_AES_256_CBC_SHA", 395 "TLS_DHE_DSS_WITH_AES_128_CBC_SHA", 396 "TLS_DHE_DSS_WITH_AES_256_CBC_SHA", 397 "SSL_RSA_WITH_3DES_EDE_CBC_SHA", 398 "TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA", 399 "TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA", 400 "TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA", 401 "TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA", 402 "SSL_DHE_RSA_WITH_3DES_EDE_CBC_SHA", 403 "SSL_DHE_DSS_WITH_3DES_EDE_CBC_SHA", 404 "SSL_RSA_WITH_DES_CBC_SHA", 405 "SSL_DHE_RSA_WITH_DES_CBC_SHA", 406 "SSL_DHE_DSS_WITH_DES_CBC_SHA", 407 "SSL_RSA_EXPORT_WITH_RC4_40_MD5", 408 "SSL_RSA_EXPORT_WITH_DES40_CBC_SHA", 409 "SSL_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA", 410 "SSL_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA", 411 TLS_EMPTY_RENEGOTIATION_INFO_SCSV 412 }; 413 } 414 415 public static String[] getSupportedCipherSuites() { 416 return SUPPORTED_CIPHER_SUITES.clone(); 417 } 418 419 public static native void SSL_CTX_free(int ssl_ctx); 420 421 public static native void SSL_CTX_set_session_id_context(int ssl_ctx, byte[] sid_ctx); 422 423 public static native int SSL_new(int ssl_ctx) throws SSLException; 424 425 public static byte[][] encodeCertificates(Certificate[] certificates) 426 throws CertificateEncodingException { 427 byte[][] certificateBytes = new byte[certificates.length][]; 428 for (int i = 0; i < certificates.length; i++) { 429 certificateBytes[i] = certificates[i].getEncoded(); 430 } 431 return certificateBytes; 432 } 433 434 public static native void SSL_use_certificate(int ssl, byte[][] asn1DerEncodedCertificateChain); 435 436 public static native void SSL_use_OpenSSL_PrivateKey(int ssl, int pkey); 437 438 public static native void SSL_use_PrivateKey(int ssl, byte[] pkcs8EncodedPrivateKey); 439 440 public static native void SSL_check_private_key(int ssl) throws SSLException; 441 442 public static byte[][] encodeIssuerX509Principals(X509Certificate[] certificates) 443 throws CertificateEncodingException { 444 byte[][] principalBytes = new byte[certificates.length][]; 445 for (int i = 0; i < certificates.length; i++) { 446 principalBytes[i] = certificates[i].getIssuerX500Principal().getEncoded(); 447 } 448 return principalBytes; 449 } 450 451 public static native void SSL_set_client_CA_list(int ssl, byte[][] asn1DerEncodedX500Principals); 452 453 public static native long SSL_get_mode(int ssl); 454 455 public static native long SSL_set_mode(int ssl, long mode); 456 457 public static native long SSL_clear_mode(int ssl, long mode); 458 459 public static native long SSL_get_options(int ssl); 460 461 public static native long SSL_set_options(int ssl, long options); 462 463 public static native long SSL_clear_options(int ssl, long options); 464 465 public static String[] getDefaultProtocols() { 466 return new String[] { SUPPORTED_PROTOCOL_SSLV3, 467 SUPPORTED_PROTOCOL_TLSV1, 468 }; 469 } 470 471 public static String[] getSupportedProtocols() { 472 return new String[] { SUPPORTED_PROTOCOL_SSLV3, 473 SUPPORTED_PROTOCOL_TLSV1, 474 SUPPORTED_PROTOCOL_TLSV1_1, 475 SUPPORTED_PROTOCOL_TLSV1_2, 476 }; 477 } 478 479 public static void setEnabledProtocols(int ssl, String[] protocols) { 480 checkEnabledProtocols(protocols); 481 // openssl uses negative logic letting you disable protocols. 482 // so first, assume we need to set all (disable all) and clear none (enable none). 483 // in the loop, selectively move bits from set to clear (from disable to enable) 484 long optionsToSet = (SSL_OP_NO_SSLv3 | SSL_OP_NO_TLSv1 | SSL_OP_NO_TLSv1_1 | SSL_OP_NO_TLSv1_2); 485 long optionsToClear = 0; 486 for (int i = 0; i < protocols.length; i++) { 487 String protocol = protocols[i]; 488 if (protocol.equals(SUPPORTED_PROTOCOL_SSLV3)) { 489 optionsToSet &= ~SSL_OP_NO_SSLv3; 490 optionsToClear |= SSL_OP_NO_SSLv3; 491 } else if (protocol.equals(SUPPORTED_PROTOCOL_TLSV1)) { 492 optionsToSet &= ~SSL_OP_NO_TLSv1; 493 optionsToClear |= SSL_OP_NO_TLSv1; 494 } else if (protocol.equals(SUPPORTED_PROTOCOL_TLSV1_1)) { 495 optionsToSet &= ~SSL_OP_NO_TLSv1_1; 496 optionsToClear |= SSL_OP_NO_TLSv1_1; 497 } else if (protocol.equals(SUPPORTED_PROTOCOL_TLSV1_2)) { 498 optionsToSet &= ~SSL_OP_NO_TLSv1_2; 499 optionsToClear |= SSL_OP_NO_TLSv1_2; 500 } else { 501 // error checked by checkEnabledProtocols 502 throw new IllegalStateException(); 503 } 504 } 505 506 SSL_set_options(ssl, optionsToSet); 507 SSL_clear_options(ssl, optionsToClear); 508 } 509 510 public static String[] checkEnabledProtocols(String[] protocols) { 511 if (protocols == null) { 512 throw new IllegalArgumentException("protocols == null"); 513 } 514 for (int i = 0; i < protocols.length; i++) { 515 String protocol = protocols[i]; 516 if (protocol == null) { 517 throw new IllegalArgumentException("protocols[" + i + "] == null"); 518 } 519 if ((!protocol.equals(SUPPORTED_PROTOCOL_SSLV3)) 520 && (!protocol.equals(SUPPORTED_PROTOCOL_TLSV1)) 521 && (!protocol.equals(SUPPORTED_PROTOCOL_TLSV1_1)) 522 && (!protocol.equals(SUPPORTED_PROTOCOL_TLSV1_2))) { 523 throw new IllegalArgumentException("protocol " + protocol 524 + " is not supported"); 525 } 526 } 527 return protocols; 528 } 529 530 public static native void SSL_set_cipher_lists(int ssl, String[] ciphers); 531 532 public static void setEnabledCipherSuites(int ssl, String[] cipherSuites) { 533 checkEnabledCipherSuites(cipherSuites); 534 List<String> opensslSuites = new ArrayList<String>(); 535 for (int i = 0; i < cipherSuites.length; i++) { 536 String cipherSuite = cipherSuites[i]; 537 if (cipherSuite.equals(TLS_EMPTY_RENEGOTIATION_INFO_SCSV)) { 538 continue; 539 } 540 String openssl = STANDARD_TO_OPENSSL_CIPHER_SUITES.get(cipherSuite); 541 String cs = (openssl == null) ? cipherSuite : openssl; 542 opensslSuites.add(cs); 543 } 544 SSL_set_cipher_lists(ssl, opensslSuites.toArray(new String[opensslSuites.size()])); 545 } 546 547 public static String[] checkEnabledCipherSuites(String[] cipherSuites) { 548 if (cipherSuites == null) { 549 throw new IllegalArgumentException("cipherSuites == null"); 550 } 551 // makes sure all suites are valid, throwing on error 552 for (int i = 0; i < cipherSuites.length; i++) { 553 String cipherSuite = cipherSuites[i]; 554 if (cipherSuite == null) { 555 throw new IllegalArgumentException("cipherSuites[" + i + "] == null"); 556 } 557 if (cipherSuite.equals(TLS_EMPTY_RENEGOTIATION_INFO_SCSV)) { 558 continue; 559 } 560 if (STANDARD_TO_OPENSSL_CIPHER_SUITES.containsKey(cipherSuite)) { 561 continue; 562 } 563 if (OPENSSL_TO_STANDARD_CIPHER_SUITES.containsKey(cipherSuite)) { 564 // TODO log warning about using backward compatability 565 continue; 566 } 567 throw new IllegalArgumentException("cipherSuite " + cipherSuite + " is not supported."); 568 } 569 return cipherSuites; 570 } 571 572 /* 573 * See the OpenSSL ssl.h header file for more information. 574 */ 575 public static final int SSL_VERIFY_NONE = 0x00; 576 public static final int SSL_VERIFY_PEER = 0x01; 577 public static final int SSL_VERIFY_FAIL_IF_NO_PEER_CERT = 0x02; 578 579 public static native void SSL_set_verify(int sslNativePointer, int mode); 580 581 public static native void SSL_set_session(int sslNativePointer, int sslSessionNativePointer) 582 throws SSLException; 583 584 public static native void SSL_set_session_creation_enabled( 585 int sslNativePointer, boolean creationEnabled) throws SSLException; 586 587 public static native void SSL_set_tlsext_host_name(int sslNativePointer, String hostname) 588 throws SSLException; 589 public static native String SSL_get_servername(int sslNativePointer); 590 591 /** 592 * Enables NPN for all SSL connections in the context. 593 * 594 * <p>For clients this causes the NPN extension to be included in the 595 * ClientHello message. 596 * 597 * <p>For servers this causes the NPN extension to be included in the 598 * ServerHello message. The NPN extension will not be included in the 599 * ServerHello response if the client didn't include it in the ClientHello 600 * request. 601 * 602 * <p>In either case the caller should pass a non-null byte array of NPN 603 * protocols to {@link #SSL_do_handshake}. 604 */ 605 public static native void SSL_CTX_enable_npn(int sslCtxNativePointer); 606 607 /** 608 * Disables NPN for all SSL connections in the context. 609 */ 610 public static native void SSL_CTX_disable_npn(int sslCtxNativePointer); 611 612 /** 613 * Returns the sslSessionNativePointer of the negotiated session 614 */ 615 public static native int SSL_do_handshake(int sslNativePointer, 616 FileDescriptor fd, 617 SSLHandshakeCallbacks shc, 618 int timeoutMillis, 619 boolean client_mode, 620 byte[] npnProtocols) 621 throws SSLException, SocketTimeoutException, CertificateException; 622 623 public static native byte[] SSL_get_npn_negotiated_protocol(int sslNativePointer); 624 625 /** 626 * Currently only intended for forcing renegotiation for testing. 627 * Not used within OpenSSLSocketImpl. 628 */ 629 public static native void SSL_renegotiate(int sslNativePointer) throws SSLException; 630 631 /** 632 * Returns the local ASN.1 DER encoded X509 certificates. 633 */ 634 public static native byte[][] SSL_get_certificate(int sslNativePointer); 635 636 /** 637 * Returns the peer ASN.1 DER encoded X509 certificates. 638 */ 639 public static native byte[][] SSL_get_peer_cert_chain(int sslNativePointer); 640 641 /** 642 * Reads with the native SSL_read function from the encrypted data stream 643 * @return -1 if error or the end of the stream is reached. 644 */ 645 public static native int SSL_read(int sslNativePointer, 646 FileDescriptor fd, 647 SSLHandshakeCallbacks shc, 648 byte[] b, int off, int len, int readTimeoutMillis) 649 throws IOException; 650 651 /** 652 * Writes with the native SSL_write function to the encrypted data stream. 653 */ 654 public static native void SSL_write(int sslNativePointer, 655 FileDescriptor fd, 656 SSLHandshakeCallbacks shc, 657 byte[] b, int off, int len, int writeTimeoutMillis) 658 throws IOException; 659 660 public static native void SSL_interrupt(int sslNativePointer); 661 public static native void SSL_shutdown(int sslNativePointer, 662 FileDescriptor fd, 663 SSLHandshakeCallbacks shc) throws IOException; 664 665 public static native void SSL_free(int sslNativePointer); 666 667 public static native byte[] SSL_SESSION_session_id(int sslSessionNativePointer); 668 669 public static native long SSL_SESSION_get_time(int sslSessionNativePointer); 670 671 public static native String SSL_SESSION_get_version(int sslSessionNativePointer); 672 673 public static native String SSL_SESSION_cipher(int sslSessionNativePointer); 674 675 public static native void SSL_SESSION_free(int sslSessionNativePointer); 676 677 public static native byte[] i2d_SSL_SESSION(int sslSessionNativePointer); 678 679 public static native int d2i_SSL_SESSION(byte[] data); 680 681 /** 682 * A collection of callbacks from the native OpenSSL code that are 683 * related to the SSL handshake initiated by SSL_do_handshake. 684 */ 685 public interface SSLHandshakeCallbacks { 686 /** 687 * Verify that we trust the certificate chain is trusted. 688 * 689 * @param asn1DerEncodedCertificateChain A chain of ASN.1 DER encoded certificates 690 * @param authMethod auth algorithm name 691 * 692 * @throws CertificateException if the certificate is untrusted 693 */ 694 public void verifyCertificateChain(byte[][] asn1DerEncodedCertificateChain, String authMethod) 695 throws CertificateException; 696 697 /** 698 * Called on an SSL client when the server requests (or 699 * requires a certificate). The client can respond by using 700 * SSL_use_certificate and SSL_use_PrivateKey to set a 701 * certificate if has an appropriate one available, similar to 702 * how the server provides its certificate. 703 * 704 * @param keyTypes key types supported by the server, 705 * convertible to strings with #keyType 706 * @param asn1DerEncodedX500Principals CAs known to the server 707 */ 708 public void clientCertificateRequested(byte[] keyTypes, 709 byte[][] asn1DerEncodedX500Principals) 710 throws CertificateEncodingException, SSLException; 711 712 /** 713 * Called when SSL handshake is completed. Note that this can 714 * be after SSL_do_handshake returns when handshake cutthrough 715 * is enabled. 716 */ 717 public void handshakeCompleted(); 718 } 719 } 720
