1 /* 2 * Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 /* 27 * NOTE: this file was copied from javax.net.ssl.KeyManagerFactory 28 */ 29 30 package com.sun.net.ssl; 31 32 import java.security.*; 33 34 /** 35 * This class acts as a factory for key managers based on a 36 * source of key material. Each key manager manages a specific 37 * type of key material for use by secure sockets. The key 38 * material is based on a KeyStore and/or provider specific sources. 39 * 40 * @deprecated As of JDK 1.4, this implementation-specific class was 41 * replaced by {@link javax.net.ssl.KeyManagerFactory}. 42 */ 43 @Deprecated 44 public class KeyManagerFactory { 45 // The provider 46 private Provider provider; 47 48 // The provider implementation (delegate) 49 private KeyManagerFactorySpi factorySpi; 50 51 // The name of the key management algorithm. 52 private String algorithm; 53 54 /** 55 * <p>The default KeyManager can be changed by setting the value of the 56 * {@code sun.ssl.keymanager.type} security property to the desired name. 57 * 58 * @return the default type as specified by the 59 * {@code sun.ssl.keymanager.type} security property, or an 60 * implementation-specific default if no such property exists. 61 * 62 * @see java.security.Security security properties 63 */ 64 public final static String getDefaultAlgorithm() { 65 String type; 66 type = AccessController.doPrivileged(new PrivilegedAction<>() { 67 public String run() { 68 return Security.getProperty("sun.ssl.keymanager.type"); 69 } 70 }); 71 if (type == null) { 72 type = "SunX509"; 73 } 74 return type; 75 76 } 77 78 /** 79 * Creates a KeyManagerFactory object. 80 * 81 * @param factorySpi the delegate 82 * @param provider the provider 83 * @param algorithm the algorithm 84 */ 85 protected KeyManagerFactory(KeyManagerFactorySpi factorySpi, 86 Provider provider, String algorithm) { 87 this.factorySpi = factorySpi; 88 this.provider = provider; 89 this.algorithm = algorithm; 90 } 91 92 /** 93 * Returns the algorithm name of this <code>KeyManagerFactory</code> object. 94 * 95 * <p>This is the same name that was specified in one of the 96 * <code>getInstance</code> calls that created this 97 * <code>KeyManagerFactory</code> object. 98 * 99 * @return the algorithm name of this <code>KeyManagerFactory</code> object. 100 */ 101 public final String getAlgorithm() { 102 return this.algorithm; 103 } 104 105 /** 106 * Generates a <code>KeyManagerFactory</code> object that implements the 107 * specified key management algorithm. 108 * If the default provider package provides an implementation of the 109 * requested key management algorithm, an instance of 110 * <code>KeyManagerFactory</code> containing that implementation is 111 * returned. If the algorithm is not available in the default provider 112 * package, other provider packages are searched. 113 * 114 * @param algorithm the standard name of the requested 115 * algorithm. 116 * 117 * @return the new <code>KeyManagerFactory</code> object 118 * 119 * @exception NoSuchAlgorithmException if the specified algorithm is not 120 * available in the default provider package or any of the other provider 121 * packages that were searched. 122 */ 123 public static final KeyManagerFactory getInstance(String algorithm) 124 throws NoSuchAlgorithmException 125 { 126 try { 127 Object[] objs = SSLSecurity.getImpl(algorithm, "KeyManagerFactory", 128 (String) null); 129 return new KeyManagerFactory((KeyManagerFactorySpi)objs[0], 130 (Provider)objs[1], 131 algorithm); 132 } catch (NoSuchProviderException e) { 133 throw new NoSuchAlgorithmException(algorithm + " not found"); 134 } 135 } 136 137 /** 138 * Generates a <code>KeyManagerFactory</code> object for the specified 139 * key management algorithm from the specified provider. 140 * 141 * @param algorithm the standard name of the requested 142 * algorithm. 143 * @param provider the name of the provider 144 * 145 * @return the new <code>KeyManagerFactory</code> object 146 * 147 * @exception NoSuchAlgorithmException if the specified algorithm is not 148 * available from the specified provider. 149 * @exception NoSuchProviderException if the specified provider has not 150 * been configured. 151 */ 152 public static final KeyManagerFactory getInstance(String algorithm, 153 String provider) 154 throws NoSuchAlgorithmException, NoSuchProviderException 155 { 156 if (provider == null || provider.length() == 0) 157 throw new IllegalArgumentException("missing provider"); 158 Object[] objs = SSLSecurity.getImpl(algorithm, "KeyManagerFactory", 159 provider); 160 return new KeyManagerFactory((KeyManagerFactorySpi)objs[0], 161 (Provider)objs[1], algorithm); 162 } 163 164 /** 165 * Generates a <code>KeyManagerFactory</code> object for the specified 166 * key management algorithm from the specified provider. 167 * 168 * @param algorithm the standard name of the requested 169 * algorithm. 170 * @param provider an instance of the provider 171 * 172 * @return the new <code>KeyManagerFactory</code> object 173 * 174 * @exception NoSuchAlgorithmException if the specified algorithm is not 175 * available from the specified provider. 176 */ 177 public static final KeyManagerFactory getInstance(String algorithm, 178 Provider provider) 179 throws NoSuchAlgorithmException 180 { 181 if (provider == null) 182 throw new IllegalArgumentException("missing provider"); 183 Object[] objs = SSLSecurity.getImpl(algorithm, "KeyManagerFactory", 184 provider); 185 return new KeyManagerFactory((KeyManagerFactorySpi)objs[0], 186 (Provider)objs[1], algorithm); 187 } 188 189 /** 190 * Returns the provider of this <code>KeyManagerFactory</code> object. 191 * 192 * @return the provider of this <code>KeyManagerFactory</code> object 193 */ 194 public final Provider getProvider() { 195 return this.provider; 196 } 197 198 199 /** 200 * Initializes this factory with a source of key material. The 201 * provider may also include a provider-specific source 202 * of key material. 203 * 204 * @param ks the key store or null 205 * @param password the password for recovering keys 206 */ 207 public void init(KeyStore ks, char[] password) 208 throws KeyStoreException, NoSuchAlgorithmException, 209 UnrecoverableKeyException { 210 factorySpi.engineInit(ks, password); 211 } 212 213 /** 214 * Returns one key manager for each type of key material. 215 * @return the key managers 216 */ 217 public KeyManager[] getKeyManagers() { 218 return factorySpi.engineGetKeyManagers(); 219 } 220 }