Mercurial Mercurial > jdk-sandbox / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
jdk/src/java.base/share/classes/sun/security/tools/keytool/Main.java
changeset 39633 9dc7586be5f0
parent 39046 db1dddd32a8f
child 39886 a0a3c3b2636e
equal deleted inserted replaced
39570:f774415f91ad 39633:9dc7586be5f0 
    31 import java.security.KeyStoreException;
 
    31 import java.security.KeyStoreException;
 
    32 import java.security.MessageDigest;
 
    32 import java.security.MessageDigest;
 
    33 import java.security.Key;
 
    33 import java.security.Key;
 
    34 import java.security.PublicKey;
 
    34 import java.security.PublicKey;
 
    35 import java.security.PrivateKey;
 
    35 import java.security.PrivateKey;
 
    36 import java.security.Security;
 
       
    37 import java.security.Signature;
 
    36 import java.security.Signature;
 
    38 import java.security.Timestamp;
 
    37 import java.security.Timestamp;
 
    39 import java.security.UnrecoverableEntryException;
 
    38 import java.security.UnrecoverableEntryException;
 
    40 import java.security.UnrecoverableKeyException;
 
    39 import java.security.UnrecoverableKeyException;
 
    41 import java.security.Principal;
 
    40 import java.security.Principal;
 
    42 import java.security.Provider;
 
       
    43 import java.security.cert.Certificate;
 
    41 import java.security.cert.Certificate;
 
    44 import java.security.cert.CertificateFactory;
 
    42 import java.security.cert.CertificateFactory;
 
    45 import java.security.cert.CertStoreException;
 
    43 import java.security.cert.CertStoreException;
 
    46 import java.security.cert.CRL;
 
    44 import java.security.cert.CRL;
 
    47 import java.security.cert.X509Certificate;
 
    45 import java.security.cert.X509Certificate;
 
   126     // If you're calling KeyTool.main() directly in your own Java program,
 
   124     // If you're calling KeyTool.main() directly in your own Java program,
 
   127     // please programtically add any providers you need and do not specify
 
   125     // please programtically add any providers you need and do not specify
 
   128     // them through the command line.
 
   126     // them through the command line.
 
   129 
   127 
   130     private Set<Pair <String, String>> providers = null;
 
   128     private Set<Pair <String, String>> providers = null;
 
       
   129     private Set<Pair <String, String>> providerClasses = null;
 
   131     private String storetype = null;
 
   130     private String storetype = null;
 
   132     private boolean hasStoretypeOption = false;
 
   131     private boolean hasStoretypeOption = false;
 
   133     private String srcProviderName = null;
 
   132     private String srcProviderName = null;
 
   134     private String providerName = null;
 
   133     private String providerName = null;
 
   135     private String pathlist = null;
 
   134     private String pathlist = null;
 
   164     private List<String> v3ext = new ArrayList<>();
 
   163     private List<String> v3ext = new ArrayList<>();
 
   165 
   164 
   166     enum Command {
 
   165     enum Command {
 
   167         CERTREQ("Generates.a.certificate.request",
 
   166         CERTREQ("Generates.a.certificate.request",
 
   168             ALIAS, SIGALG, FILEOUT, KEYPASS, KEYSTORE, DNAME,
 
   167             ALIAS, SIGALG, FILEOUT, KEYPASS, KEYSTORE, DNAME,
 
   169             STOREPASS, STORETYPE, PROVIDERNAME, PROVIDERCLASS,
 
   168             STOREPASS, STORETYPE, PROVIDERNAME, ADDPROVIDER,
 
   170             PROVIDERARG, PROVIDERPATH, V, PROTECTED),
 
   169             PROVIDERCLASS, PROVIDERPATH, V, PROTECTED),
 
   171         CHANGEALIAS("Changes.an.entry.s.alias",
 
   170         CHANGEALIAS("Changes.an.entry.s.alias",
 
   172             ALIAS, DESTALIAS, KEYPASS, KEYSTORE, STOREPASS,
 
   171             ALIAS, DESTALIAS, KEYPASS, KEYSTORE, STOREPASS,
 
   173             STORETYPE, PROVIDERNAME, PROVIDERCLASS, PROVIDERARG,
 
   172             STORETYPE, PROVIDERNAME, ADDPROVIDER, PROVIDERCLASS,
 
   174             PROVIDERPATH, V, PROTECTED),
 
   173             PROVIDERPATH, V, PROTECTED),
 
   175         DELETE("Deletes.an.entry",
 
   174         DELETE("Deletes.an.entry",
 
   176             ALIAS, KEYSTORE, STOREPASS, STORETYPE,
 
   175             ALIAS, KEYSTORE, STOREPASS, STORETYPE,
 
   177             PROVIDERNAME, PROVIDERCLASS, PROVIDERARG,
 
   176             PROVIDERNAME, ADDPROVIDER, PROVIDERCLASS,
 
   178             PROVIDERPATH, V, PROTECTED),
 
   177             PROVIDERPATH, V, PROTECTED),
 
   179         EXPORTCERT("Exports.certificate",
 
   178         EXPORTCERT("Exports.certificate",
 
   180             RFC, ALIAS, FILEOUT, KEYSTORE, STOREPASS,
 
   179             RFC, ALIAS, FILEOUT, KEYSTORE, STOREPASS,
 
   181             STORETYPE, PROVIDERNAME, PROVIDERCLASS, PROVIDERARG,
 
   180             STORETYPE, PROVIDERNAME, ADDPROVIDER, PROVIDERCLASS,
 
   182             PROVIDERPATH, V, PROTECTED),
 
   181             PROVIDERPATH, V, PROTECTED),
 
   183         GENKEYPAIR("Generates.a.key.pair",
 
   182         GENKEYPAIR("Generates.a.key.pair",
 
   184             ALIAS, KEYALG, KEYSIZE, SIGALG, DESTALIAS, DNAME,
 
   183             ALIAS, KEYALG, KEYSIZE, SIGALG, DESTALIAS, DNAME,
 
   185             STARTDATE, EXT, VALIDITY, KEYPASS, KEYSTORE,
 
   184             STARTDATE, EXT, VALIDITY, KEYPASS, KEYSTORE,
 
   186             STOREPASS, STORETYPE, PROVIDERNAME, PROVIDERCLASS,
 
   185             STOREPASS, STORETYPE, PROVIDERNAME, ADDPROVIDER,
 
   187             PROVIDERARG, PROVIDERPATH, V, PROTECTED),
 
   186             PROVIDERCLASS, PROVIDERPATH, V, PROTECTED),
 
   188         GENSECKEY("Generates.a.secret.key",
 
   187         GENSECKEY("Generates.a.secret.key",
 
   189             ALIAS, KEYPASS, KEYALG, KEYSIZE, KEYSTORE,
 
   188             ALIAS, KEYPASS, KEYALG, KEYSIZE, KEYSTORE,
 
   190             STOREPASS, STORETYPE, PROVIDERNAME, PROVIDERCLASS,
 
   189             STOREPASS, STORETYPE, PROVIDERNAME, ADDPROVIDER,
 
   191             PROVIDERARG, PROVIDERPATH, V, PROTECTED),
 
   190             PROVIDERCLASS, PROVIDERPATH, V, PROTECTED),
 
   192         GENCERT("Generates.certificate.from.a.certificate.request",
 
   191         GENCERT("Generates.certificate.from.a.certificate.request",
 
   193             RFC, INFILE, OUTFILE, ALIAS, SIGALG, DNAME,
 
   192             RFC, INFILE, OUTFILE, ALIAS, SIGALG, DNAME,
 
   194             STARTDATE, EXT, VALIDITY, KEYPASS, KEYSTORE,
 
   193             STARTDATE, EXT, VALIDITY, KEYPASS, KEYSTORE,
 
   195             STOREPASS, STORETYPE, PROVIDERNAME, PROVIDERCLASS,
 
   194             STOREPASS, STORETYPE, PROVIDERNAME, ADDPROVIDER,
 
   196             PROVIDERARG, PROVIDERPATH, V, PROTECTED),
 
   195             PROVIDERCLASS, PROVIDERPATH, V, PROTECTED),
 
   197         IMPORTCERT("Imports.a.certificate.or.a.certificate.chain",
 
   196         IMPORTCERT("Imports.a.certificate.or.a.certificate.chain",
 
   198             NOPROMPT, TRUSTCACERTS, PROTECTED, ALIAS, FILEIN,
 
   197             NOPROMPT, TRUSTCACERTS, PROTECTED, ALIAS, FILEIN,
 
   199             KEYPASS, KEYSTORE, STOREPASS, STORETYPE,
 
   198             KEYPASS, KEYSTORE, STOREPASS, STORETYPE,
 
   200             PROVIDERNAME, PROVIDERCLASS, PROVIDERARG,
 
   199             PROVIDERNAME, ADDPROVIDER, PROVIDERCLASS,
 
   201             PROVIDERPATH, V),
 
   200             PROVIDERPATH, V),
 
   202         IMPORTPASS("Imports.a.password",
 
   201         IMPORTPASS("Imports.a.password",
 
   203             ALIAS, KEYPASS, KEYALG, KEYSIZE, KEYSTORE,
 
   202             ALIAS, KEYPASS, KEYALG, KEYSIZE, KEYSTORE,
 
   204             STOREPASS, STORETYPE, PROVIDERNAME, PROVIDERCLASS,
 
   203             STOREPASS, STORETYPE, PROVIDERNAME, ADDPROVIDER,
 
   205             PROVIDERARG, PROVIDERPATH, V, PROTECTED),
 
   204             PROVIDERCLASS, PROVIDERPATH, V, PROTECTED),
 
   206         IMPORTKEYSTORE("Imports.one.or.all.entries.from.another.keystore",
 
   205         IMPORTKEYSTORE("Imports.one.or.all.entries.from.another.keystore",
 
   207             SRCKEYSTORE, DESTKEYSTORE, SRCSTORETYPE,
 
   206             SRCKEYSTORE, DESTKEYSTORE, SRCSTORETYPE,
 
   208             DESTSTORETYPE, SRCSTOREPASS, DESTSTOREPASS,
 
   207             DESTSTORETYPE, SRCSTOREPASS, DESTSTOREPASS,
 
   209             SRCPROTECTED, DESTPROTECTED, SRCPROVIDERNAME, DESTPROVIDERNAME,
 
   208             SRCPROTECTED, DESTPROTECTED, SRCPROVIDERNAME, DESTPROVIDERNAME,
 
   210             SRCALIAS, DESTALIAS, SRCKEYPASS, DESTKEYPASS,
 
   209             SRCALIAS, DESTALIAS, SRCKEYPASS, DESTKEYPASS,
 
   211             NOPROMPT, PROVIDERCLASS, PROVIDERARG, PROVIDERPATH,
 
   210             NOPROMPT, ADDPROVIDER, PROVIDERCLASS, PROVIDERPATH,
 
   212             V),
 
   211             V),
 
   213         KEYPASSWD("Changes.the.key.password.of.an.entry",
 
   212         KEYPASSWD("Changes.the.key.password.of.an.entry",
 
   214             ALIAS, KEYPASS, NEW, KEYSTORE, STOREPASS,
 
   213             ALIAS, KEYPASS, NEW, KEYSTORE, STOREPASS,
 
   215             STORETYPE, PROVIDERNAME, PROVIDERCLASS, PROVIDERARG,
 
   214             STORETYPE, PROVIDERNAME, ADDPROVIDER, PROVIDERCLASS,
 
   216             PROVIDERPATH, V),
 
   215             PROVIDERPATH, V),
 
   217         LIST("Lists.entries.in.a.keystore",
 
   216         LIST("Lists.entries.in.a.keystore",
 
   218             RFC, ALIAS, KEYSTORE, STOREPASS, STORETYPE,
 
   217             RFC, ALIAS, KEYSTORE, STOREPASS, STORETYPE,
 
   219             PROVIDERNAME, PROVIDERCLASS, PROVIDERARG,
 
   218             PROVIDERNAME, ADDPROVIDER, PROVIDERCLASS,
 
   220             PROVIDERPATH, V, PROTECTED),
 
   219             PROVIDERPATH, V, PROTECTED),
 
   221         PRINTCERT("Prints.the.content.of.a.certificate",
 
   220         PRINTCERT("Prints.the.content.of.a.certificate",
 
   222             RFC, FILEIN, SSLSERVER, JARFILE, V),
 
   221             RFC, FILEIN, SSLSERVER, JARFILE, V),
 
   223         PRINTCERTREQ("Prints.the.content.of.a.certificate.request",
 
   222         PRINTCERTREQ("Prints.the.content.of.a.certificate.request",
 
   224             FILEIN, V),
 
   223             FILEIN, V),
 
   225         PRINTCRL("Prints.the.content.of.a.CRL.file",
 
   224         PRINTCRL("Prints.the.content.of.a.CRL.file",
 
   226             FILEIN, V),
 
   225             FILEIN, V),
 
   227         STOREPASSWD("Changes.the.store.password.of.a.keystore",
 
   226         STOREPASSWD("Changes.the.store.password.of.a.keystore",
 
   228             NEW, KEYSTORE, STOREPASS, STORETYPE, PROVIDERNAME,
 
   227             NEW, KEYSTORE, STOREPASS, STORETYPE, PROVIDERNAME,
 
   229             PROVIDERCLASS, PROVIDERARG, PROVIDERPATH, V),
 
   228             ADDPROVIDER, PROVIDERCLASS, PROVIDERPATH, V),
 
   230 
   229 
   231         // Undocumented start here, KEYCLONE is used a marker in -help;
 
   230         // Undocumented start here, KEYCLONE is used a marker in -help;
 
   232 
   231 
   233         KEYCLONE("Clones.a.key.entry",
 
   232         KEYCLONE("Clones.a.key.entry",
 
   234             ALIAS, DESTALIAS, KEYPASS, NEW, STORETYPE,
 
   233             ALIAS, DESTALIAS, KEYPASS, NEW, STORETYPE,
 
   235             KEYSTORE, STOREPASS, PROVIDERNAME, PROVIDERCLASS,
 
   234             KEYSTORE, STOREPASS, PROVIDERNAME, ADDPROVIDER,
 
   236             PROVIDERARG, PROVIDERPATH, V),
 
   235             PROVIDERCLASS, PROVIDERPATH, V),
 
   237         SELFCERT("Generates.a.self.signed.certificate",
 
   236         SELFCERT("Generates.a.self.signed.certificate",
 
   238             ALIAS, SIGALG, DNAME, STARTDATE, VALIDITY, KEYPASS,
 
   237             ALIAS, SIGALG, DNAME, STARTDATE, VALIDITY, KEYPASS,
 
   239             STORETYPE, KEYSTORE, STOREPASS, PROVIDERNAME,
 
   238             STORETYPE, KEYSTORE, STOREPASS, PROVIDERNAME,
 
   240             PROVIDERCLASS, PROVIDERARG, PROVIDERPATH, V),
 
   239             ADDPROVIDER, PROVIDERCLASS, PROVIDERPATH, V),
 
   241         GENCRL("Generates.CRL",
 
   240         GENCRL("Generates.CRL",
 
   242             RFC, FILEOUT, ID,
 
   241             RFC, FILEOUT, ID,
 
   243             ALIAS, SIGALG, EXT, KEYPASS, KEYSTORE,
 
   242             ALIAS, SIGALG, EXT, KEYPASS, KEYSTORE,
 
   244             STOREPASS, STORETYPE, PROVIDERNAME, PROVIDERCLASS,
 
   243             STOREPASS, STORETYPE, PROVIDERNAME, ADDPROVIDER,
 
   245             PROVIDERARG, PROVIDERPATH, V, PROTECTED),
 
   244             PROVIDERCLASS, PROVIDERPATH, V, PROTECTED),
 
   246         IDENTITYDB("Imports.entries.from.a.JDK.1.1.x.style.identity.database",
 
   245         IDENTITYDB("Imports.entries.from.a.JDK.1.1.x.style.identity.database",
 
   247             FILEIN, STORETYPE, KEYSTORE, STOREPASS, PROVIDERNAME,
 
   246             FILEIN, STORETYPE, KEYSTORE, STOREPASS, PROVIDERNAME,
 
   248             PROVIDERCLASS, PROVIDERARG, PROVIDERPATH, V);
 
   247             ADDPROVIDER, PROVIDERCLASS, PROVIDERPATH, V);
 
   249 
   248 
   250         final String description;
 
   249         final String description;
 
   251         final Option[] options;
 
   250         final Option[] options;
 
   252         final String name;
 
   251         final String name;
 
   253 
   252 
   287         Command.IMPORTPASS.setAltName("-importpassword");
 
   286         Command.IMPORTPASS.setAltName("-importpassword");
 
   288     }
 
   287     }
 
   289 
   288 
   290     enum Option {
 
   289     enum Option {
 
   291         ALIAS("alias", "<alias>", "alias.name.of.the.entry.to.process"),
 
   290         ALIAS("alias", "<alias>", "alias.name.of.the.entry.to.process"),
 
   292         DESTALIAS("destalias", "<destalias>", "destination.alias"),
 
   291         DESTALIAS("destalias", "<alias>", "destination.alias"),
 
   293         DESTKEYPASS("destkeypass", "<arg>", "destination.key.password"),
 
   292         DESTKEYPASS("destkeypass", "<arg>", "destination.key.password"),
 
   294         DESTKEYSTORE("destkeystore", "<destkeystore>", "destination.keystore.name"),
 
   293         DESTKEYSTORE("destkeystore", "<keystore>", "destination.keystore.name"),
 
   295         DESTPROTECTED("destprotected", null, "destination.keystore.password.protected"),
 
   294         DESTPROTECTED("destprotected", null, "destination.keystore.password.protected"),
 
   296         DESTPROVIDERNAME("destprovidername", "<destprovidername>", "destination.keystore.provider.name"),
 
   295         DESTPROVIDERNAME("destprovidername", "<name>", "destination.keystore.provider.name"),
 
   297         DESTSTOREPASS("deststorepass", "<arg>", "destination.keystore.password"),
 
   296         DESTSTOREPASS("deststorepass", "<arg>", "destination.keystore.password"),
 
   298         DESTSTORETYPE("deststoretype", "<deststoretype>", "destination.keystore.type"),
 
   297         DESTSTORETYPE("deststoretype", "<type>", "destination.keystore.type"),
 
   299         DNAME("dname", "<dname>", "distinguished.name"),
 
   298         DNAME("dname", "<name>", "distinguished.name"),
 
   300         EXT("ext", "<value>", "X.509.extension"),
 
   299         EXT("ext", "<value>", "X.509.extension"),
 
   301         FILEOUT("file", "<filename>", "output.file.name"),
 
   300         FILEOUT("file", "<file>", "output.file.name"),
 
   302         FILEIN("file", "<filename>", "input.file.name"),
 
   301         FILEIN("file", "<file>", "input.file.name"),
 
   303         ID("id", "<id:reason>", "Serial.ID.of.cert.to.revoke"),
 
   302         ID("id", "<id:reason>", "Serial.ID.of.cert.to.revoke"),
 
   304         INFILE("infile", "<filename>", "input.file.name"),
 
   303         INFILE("infile", "<file>", "input.file.name"),
 
   305         KEYALG("keyalg", "<keyalg>", "key.algorithm.name"),
 
   304         KEYALG("keyalg", "<alg>", "key.algorithm.name"),
 
   306         KEYPASS("keypass", "<arg>", "key.password"),
 
   305         KEYPASS("keypass", "<arg>", "key.password"),
 
   307         KEYSIZE("keysize", "<keysize>", "key.bit.size"),
 
   306         KEYSIZE("keysize", "<size>", "key.bit.size"),
 
   308         KEYSTORE("keystore", "<keystore>", "keystore.name"),
 
   307         KEYSTORE("keystore", "<keystore>", "keystore.name"),
 
   309         NEW("new", "<arg>", "new.password"),
 
   308         NEW("new", "<arg>", "new.password"),
 
   310         NOPROMPT("noprompt", null, "do.not.prompt"),
 
   309         NOPROMPT("noprompt", null, "do.not.prompt"),
 
   311         OUTFILE("outfile", "<filename>", "output.file.name"),
 
   310         OUTFILE("outfile", "<file>", "output.file.name"),
 
   312         PROTECTED("protected", null, "password.through.protected.mechanism"),
 
   311         PROTECTED("protected", null, "password.through.protected.mechanism"),
 
   313         PROVIDERARG("providerarg", "<arg>", "provider.argument"),
 
   312         PROVIDERCLASS("providerclass", "<class>\n[-providerarg <arg>]", "provider.class.option"),
 
   314         PROVIDERCLASS("providerclass", "<providerclass>", "provider.class.name"),
 
   313         ADDPROVIDER("addprovider", "<name>\n[-providerarg <arg>]", "addprovider.option"),
 
   315         PROVIDERNAME("providername", "<providername>", "provider.name"),
 
   314         PROVIDERNAME("providername", "<name>", "provider.name"),
 
   316         PROVIDERPATH("providerpath", "<pathlist>", "provider.classpath"),
 
   315         PROVIDERPATH("providerpath", "<list>", "provider.classpath"),
 
   317         RFC("rfc", null, "output.in.RFC.style"),
 
   316         RFC("rfc", null, "output.in.RFC.style"),
 
   318         SIGALG("sigalg", "<sigalg>", "signature.algorithm.name"),
 
   317         SIGALG("sigalg", "<alg>", "signature.algorithm.name"),
 
   319         SRCALIAS("srcalias", "<srcalias>", "source.alias"),
 
   318         SRCALIAS("srcalias", "<alias>", "source.alias"),
 
   320         SRCKEYPASS("srckeypass", "<arg>", "source.key.password"),
 
   319         SRCKEYPASS("srckeypass", "<arg>", "source.key.password"),
 
   321         SRCKEYSTORE("srckeystore", "<srckeystore>", "source.keystore.name"),
 
   320         SRCKEYSTORE("srckeystore", "<keystore>", "source.keystore.name"),
 
   322         SRCPROTECTED("srcprotected", null, "source.keystore.password.protected"),
 
   321         SRCPROTECTED("srcprotected", null, "source.keystore.password.protected"),
 
   323         SRCPROVIDERNAME("srcprovidername", "<srcprovidername>", "source.keystore.provider.name"),
 
   322         SRCPROVIDERNAME("srcprovidername", "<name>", "source.keystore.provider.name"),
 
   324         SRCSTOREPASS("srcstorepass", "<arg>", "source.keystore.password"),
 
   323         SRCSTOREPASS("srcstorepass", "<arg>", "source.keystore.password"),
 
   325         SRCSTORETYPE("srcstoretype", "<srcstoretype>", "source.keystore.type"),
 
   324         SRCSTORETYPE("srcstoretype", "<type>", "source.keystore.type"),
 
   326         SSLSERVER("sslserver", "<server[:port]>", "SSL.server.host.and.port"),
 
   325         SSLSERVER("sslserver", "<server[:port]>", "SSL.server.host.and.port"),
 
   327         JARFILE("jarfile", "<filename>", "signed.jar.file"),
 
   326         JARFILE("jarfile", "<file>", "signed.jar.file"),
 
   328         STARTDATE("startdate", "<startdate>", "certificate.validity.start.date.time"),
 
   327         STARTDATE("startdate", "<date>", "certificate.validity.start.date.time"),
 
   329         STOREPASS("storepass", "<arg>", "keystore.password"),
 
   328         STOREPASS("storepass", "<arg>", "keystore.password"),
 
   330         STORETYPE("storetype", "<storetype>", "keystore.type"),
 
   329         STORETYPE("storetype", "<type>", "keystore.type"),
 
   331         TRUSTCACERTS("trustcacerts", null, "trust.certificates.from.cacerts"),
 
   330         TRUSTCACERTS("trustcacerts", null, "trust.certificates.from.cacerts"),
 
   332         V("v", null, "verbose.output"),
 
   331         V("v", null, "verbose.output"),
 
   333         VALIDITY("validity", "<valDays>", "validity.number.of.days");
 
   332         VALIDITY("validity", "<days>", "validity.number.of.days");
 
   334 
   333 
   335         final String name, arg, description;
 
   334         final String name, arg, description;
 
   336         Option(String name, String arg, String description) {
 
   335         Option(String name, String arg, String description) {
 
   337             this.name = name;
 
   336             this.name = name;
 
   338             this.arg = arg;
 
   337             this.arg = arg;
 
   341         @Override
 
   340         @Override
 
   342         public String toString() {
 
   341         public String toString() {
 
   343             return "-" + name;
 
   342             return "-" + name;
 
   344         }
 
   343         }
 
   345     };
 
   344     };
 
   346 
       
   347     private static final Class<?>[] PARAM_STRING = { String.class };
 
       
   348 
   345 
   349     private static final String NONE = "NONE";
 
   346     private static final String NONE = "NONE";
 
   350     private static final String P11KEYSTORE = "PKCS11";
 
   347     private static final String P11KEYSTORE = "PKCS11";
 
   351     private static final String P12KEYSTORE = "PKCS12";
 
   348     private static final String P12KEYSTORE = "PKCS12";
 
   352     private final String keyAlias = "mykey";
 
   349     private final String keyAlias = "mykey";
 
   547                 sslserver = args[++i];
 
   544                 sslserver = args[++i];
 
   548             } else if (collator.compare(flags, "-jarfile") == 0) {
 
   545             } else if (collator.compare(flags, "-jarfile") == 0) {
 
   549                 jarfile = args[++i];
 
   546                 jarfile = args[++i];
 
   550             } else if (collator.compare(flags, "-srckeystore") == 0) {
 
   547             } else if (collator.compare(flags, "-srckeystore") == 0) {
 
   551                 srcksfname = args[++i];
 
   548                 srcksfname = args[++i];
 
   552             } else if ((collator.compare(flags, "-provider") == 0) ||
 
   549             } else if (collator.compare(flags, "-provider") == 0 ||
 
   553                         (collator.compare(flags, "-providerclass") == 0)) {
 
   550                         collator.compare(flags, "-providerclass") == 0) {
 
   554                 if (providers == null) {
 
   551                 if (providerClasses == null) {
 
   555                     providers = new HashSet<Pair <String, String>> (3);
 
   552                     providerClasses = new HashSet<Pair <String, String>> (3);
 
   556                 }
 
   553                 }
 
   557                 String providerClass = args[++i];
 
   554                 String providerClass = args[++i];
 
   558                 String providerArg = null;
 
   555                 String providerArg = null;
 
   559 
   556 
   560                 if (args.length > (i+1)) {
 
   557                 if (args.length > (i+1)) {
 
   563                         if (args.length == (i+2)) errorNeedArgument(flags);
 
   560                         if (args.length == (i+2)) errorNeedArgument(flags);
 
   564                         providerArg = args[i+2];
 
   561                         providerArg = args[i+2];
 
   565                         i += 2;
 
   562                         i += 2;
 
   566                     }
 
   563                     }
 
   567                 }
 
   564                 }
 
       
   565                 providerClasses.add(
 
       
   566                         Pair.of(providerClass, providerArg));
 
       
   567             } else if (collator.compare(flags, "-addprovider") == 0) {
 
       
   568                 if (providers == null) {
 
       
   569                     providers = new HashSet<Pair <String, String>> (3);
 
       
   570                 }
 
       
   571                 String provider = args[++i];
 
       
   572                 String providerArg = null;
 
       
   573 
       
   574                 if (args.length > (i+1)) {
 
       
   575                     flags = args[i+1];
 
       
   576                     if (collator.compare(flags, "-providerarg") == 0) {
 
       
   577                         if (args.length == (i+2)) errorNeedArgument(flags);
 
       
   578                         providerArg = args[i+2];
 
       
   579                         i += 2;
 
       
   580                     }
 
       
   581                 }
 
   568                 providers.add(
 
   582                 providers.add(
 
   569                         Pair.of(providerClass, providerArg));
 
   583                         Pair.of(provider, providerArg));
 
   570             }
 
   584             }
 
   571 
   585 
   572             /*
 
   586             /*
 
   573              * options
 
   587              * options
 
   574              */
 
   588              */
 
   615 
   629 
   616     boolean isKeyStoreRelated(Command cmd) {
 
   630     boolean isKeyStoreRelated(Command cmd) {
 
   617         return cmd != PRINTCERT && cmd != PRINTCERTREQ;
 
   631         return cmd != PRINTCERT && cmd != PRINTCERTREQ;
 
   618     }
 
   632     }
 
   619 
   633 
   620 
       
   621     /**
 
   634     /**
 
   622      * Execute the commands.
 
   635      * Execute the commands.
 
   623      */
 
   636      */
 
   624     void doCommands(PrintStream out) throws Exception {
 
   637     void doCommands(PrintStream out) throws Exception {
 
   625         if (storetype == null) {
 
   638         if (storetype == null) {
 
   701                 (rb.getString("Validity.must.be.greater.than.zero"));
 
   714                 (rb.getString("Validity.must.be.greater.than.zero"));
 
   702         }
 
   715         }
 
   703 
   716 
   704         // Try to load and install specified provider
 
   717         // Try to load and install specified provider
 
   705         if (providers != null) {
 
   718         if (providers != null) {
 
       
   719             for (Pair<String, String> provider : providers) {
 
       
   720                 try {
 
       
   721                     KeyStoreUtil.loadProviderByName(
 
       
   722                             provider.fst, provider.snd);
 
       
   723                     if (debug) {
 
       
   724                         System.out.println("loadProviderByName: " + provider.fst);
 
       
   725                     }
 
       
   726                 } catch (IllegalArgumentException e) {
 
       
   727                     throw new Exception(String.format(rb.getString(
 
       
   728                             "provider.name.not.found"), provider.fst));
 
       
   729                 }
 
       
   730             }
 
       
   731         }
 
       
   732         if (providerClasses != null) {
 
   706             ClassLoader cl = null;
 
   733             ClassLoader cl = null;
 
   707             if (pathlist != null) {
 
   734             if (pathlist != null) {
 
   708                 String path = null;
 
   735                 String path = null;
 
   709                 path = PathList.appendPath(
 
   736                 path = PathList.appendPath(
 
   710                         path, System.getProperty("java.class.path"));
 
   737                         path, System.getProperty("java.class.path"));
 
   715                 URL[] urls = PathList.pathToURLs(path);
 
   742                 URL[] urls = PathList.pathToURLs(path);
 
   716                 cl = new URLClassLoader(urls);
 
   743                 cl = new URLClassLoader(urls);
 
   717             } else {
 
   744             } else {
 
   718                 cl = ClassLoader.getSystemClassLoader();
 
   745                 cl = ClassLoader.getSystemClassLoader();
 
   719             }
 
   746             }
 
   720 
   747             for (Pair<String, String> provider : providerClasses) {
 
   721             for (Pair <String, String> provider: providers) {
 
   748                 try {
 
   722                 String provName = provider.fst;
 
   749                     KeyStoreUtil.loadProviderByClass(
 
   723                 Class<?> provClass;
 
   750                             provider.fst, provider.snd, cl);
 
   724                 if (cl != null) {
 
   751                     if (debug) {
 
   725                     provClass = cl.loadClass(provName);
 
   752                         System.out.println("loadProviderByClass: " + provider.fst);
 
   726                 } else {
 
   753                     }
 
   727                     provClass = Class.forName(provName);
 
   754                 } catch (ClassCastException cce) {
 
   728                 }
 
   755                     throw new Exception(String.format(rb.getString(
 
   729 
   756                             "provclass.not.a.provider"), provider.fst));
 
   730                 @SuppressWarnings("deprecation")
 
   757                 } catch (IllegalArgumentException e) {
 
   731                 Object obj = provClass.newInstance();
 
   758                     throw new Exception(String.format(rb.getString(
 
   732                 if (!(obj instanceof Provider)) {
 
   759                             "provider.class.not.found"), provider.fst), e.getCause());
 
   733                     MessageFormat form = new MessageFormat
 
   760                 }
 
   734                         (rb.getString("provName.not.a.provider"));
 
       
   735                     Object[] source = {provName};
 
       
   736                     throw new Exception(form.format(source));
 
       
   737                 }
 
       
   738                 Provider p = (Provider) obj;
 
       
   739                 String provArg = provider.snd;
 
       
   740                 if (provArg != null) {
 
       
   741                     p = p.configure(provArg);
 
       
   742                 }
 
       
   743                 Security.addProvider(p);
 
       
   744             }
 
   761             }
 
   745         }
 
   762         }
 
   746 
   763 
   747         if (command == LIST && verbose && rfc) {
 
   764         if (command == LIST && verbose && rfc) {
 
   748             System.err.println(rb.getString
 
   765             System.err.println(rb.getString
 
  4130             System.err.println(rb.getString(command.description));
 
  4147             System.err.println(rb.getString(command.description));
 
  4131             System.err.println();
 
  4148             System.err.println();
 
  4132             System.err.println(rb.getString("Options."));
 
  4149             System.err.println(rb.getString("Options."));
 
  4133             System.err.println();
 
  4150             System.err.println();
 
  4134 
  4151 
  4135             // Left and right sides of the options list
 
  4152             // Left and right sides of the options list. Both might
 
       
  4153             // contain "\n" and span multiple lines
 
  4136             String[] left = new String[command.options.length];
 
  4154             String[] left = new String[command.options.length];
 
  4137             String[] right = new String[command.options.length];
 
  4155             String[] right = new String[command.options.length];
 
  4138 
  4156 
  4139             // Check if there's an unknown option
 
       
  4140             boolean found = false;
 
       
  4141 
       
  4142             // Length of left side of options list
 
  4157             // Length of left side of options list
 
  4143             int lenLeft = 0;
 
  4158             int lenLeft = 0;
 
  4144             for (int j=0; j<left.length; j++) {
 
  4159 
       
  4160             for (int j = 0; j < command.options.length; j++) {
 
  4145                 Option opt = command.options[j];
 
  4161                 Option opt = command.options[j];
 
  4146                 left[j] = opt.toString();
 
  4162                 left[j] = opt.toString();
 
  4147                 if (opt.arg != null) left[j] += " " + opt.arg;
 
  4163                 if (opt.arg != null) {
 
  4148                 if (left[j].length() > lenLeft) {
 
  4164                     left[j] += " " + opt.arg;
 
  4149                     lenLeft = left[j].length();
 
  4165                 }
 
       
  4166                 String[] lefts = left[j].split("\n");
 
       
  4167                 for (String s : lefts) {
 
       
  4168                     if (s.length() > lenLeft) {
 
       
  4169                         lenLeft = s.length();
 
       
  4170                     }
 
  4150                 }
 
  4171                 }
 
  4151                 right[j] = rb.getString(opt.description);
 
  4172                 right[j] = rb.getString(opt.description);
 
  4152             }
 
  4173             }
 
  4153             for (int j=0; j<left.length; j++) {
 
  4174             for (int j = 0; j < left.length; j++) {
 
  4154                 System.err.printf(" %-" + lenLeft + "s  %s\n",
 
  4175                 String[] lefts = left[j].split("\n");
 
  4155                         left[j], right[j]);
 
  4176                 String[] rights = right[j].split("\n");
 
       
  4177                 for (int i = 0; i < lefts.length && i < rights.length; i++) {
 
       
  4178                     String s1 = i < lefts.length ? lefts[i] : "";
 
       
  4179                     String s2 = i < rights.length ? rights[i] : "";
 
       
  4180                     if (i == 0) {
 
       
  4181                         System.err.printf(" %-" + lenLeft + "s  %s\n", s1, s2);
 
       
  4182                     } else {
 
       
  4183                         System.err.printf("   %-" + lenLeft + "s  %s\n", s1, s2);
 
       
  4184                     }
 
       
  4185                 }
 
  4156             }
 
  4186             }
 
  4157             System.err.println();
 
  4187             System.err.println();
 
  4158             System.err.println(rb.getString(
 
  4188             System.err.println(rb.getString(
 
  4159                     "Use.keytool.help.for.all.available.commands"));
 
  4189                     "Use.keytool.help.for.all.available.commands"));
 
  4160         } else {
 
  4190         } else {
jdk-sandbox