package sun.security.tools.jarsigner.resources;

import java.util.ListResourceBundle;

public final class jarsigner extends ListResourceBundle {
    protected final Object[][] getContents() {
        return new Object[][] {
            { "...Signer", ">>> Signer" },
            { "...TSA", ">>> TSA" },
            { ".Directory.entries.", "(Directory entries)" },
            { ".Invalid.TSA.certificate.chain.", "[Invalid TSA certificate chain: " },
            { ".Invalid.certificate.chain.", "[Invalid certificate chain: " },
            { ".Signature.related.entries.", "(Signature related entries)" },
            { ".Unsigned.entries.", "(Unsigned entries)" },
            { ".X.not.signed.by.specified.alias.es.", "  X = not signed by specified alias(es)" },
            { ".add.provider.option", "[-addprovider <name>        add security provider by name (e.g. SunPKCS11)" },
            { ".adding.", "   adding: " },
            { ".and.d.more.", "(and %d more)" },
            { ".certchain.file.name.of.alternative.certchain.file", "[-certchain <file>]         name of alternative certchain file" },
            { ".certs.display.certificates.when.verbose.and.verifying", "[-certs]                    display certificates when verbose and verifying" },
            { ".certs.revocation.check", "[-revCheck]                 Enable certificate revocation check" },
            { ".conf.url.specify.a.pre.configured.options.file", "[-conf <url>]               specify a pre-configured options file" },
            { ".digestalg.algorithm.name.of.digest.algorithm", "[-digestalg <algorithm>]    name of digest algorithm" },
            { ".internalsf.include.the.SF.file.inside.the.signature.block", "[-internalsf]               include the .SF file inside the signature block" },
            { ".jarsigner.verify.options.jar.file.alias.", "       jarsigner -verify [options] jar-file [alias...]" },
            { ".jarsigner.version", "       jarsigner -version" },
            { ".k.at.least.one.certificate.was.found.in.keystore", "  k = at least one certificate was found in keystore" },
            { ".keypass.can.not.be.specified.if.storetype.is.{0}", "-keypass can not be specified if -storetype is {0}" },
            { ".keypass.password.password.for.private.key.if.different.", "[-keypass <password>]       password for private key (if different)" },
            { ".keystore.must.be.NONE.if.storetype.is.{0}", "-keystore must be NONE if -storetype is {0}" },
            { ".keystore.url.keystore.location", "[-keystore <url>]           keystore location" },
            { ".m.entry.is.listed.in.manifest", "  m = entry is listed in manifest" },
            { ".print.this.help.message", "[-? -h --help]              Print this help message" },
            { ".protected.keystore.has.protected.authentication.path", "[-protected]                keystore has protected authentication path" },
            { ".providerArg.option.1", "  [-providerArg <arg>]] ... configure argument for -addprovider" },
            { ".providerArg.option.2", "  [-providerArg <arg>]] ... configure argument for -providerClass" },
            { ".providerClass.option", "[-providerClass <class>     add security provider by fully-qualified class name" },
            { ".providerName.name.provider.name", "[-providerName <name>]      provider name" },
            { ".providerPath.option", "[-providerPath <list>]      provider classpath" },
            { ".q.unsigned.entry", "  ? = unsigned entry" },
            { ".s.signature.was.verified.", "  s = signature was verified " },
            { ".sectionsonly.don.t.compute.hash.of.entire.manifest", "[-sectionsonly]             don't compute hash of entire manifest" },
            { ".sigalg.algorithm.name.of.signature.algorithm", "[-sigalg <algorithm>]       name of signature algorithm" },
            { ".sigfile.file.name.of.SF.DSA.file", "[-sigfile <file>]           name of .SF/.DSA file" },
            { ".signedjar.file.name.of.signed.JAR.file", "[-signedjar <file>]         name of signed JAR file" },
            { ".signing.", "  signing: " },
            { ".storepass.password.password.for.keystore.integrity", "[-storepass <password>]     password for keystore integrity" },
            { ".storetype.type.keystore.type", "[-storetype <type>]         keystore type" },
            { ".strict.treat.warnings.as.errors", "[-strict]                   treat warnings as errors" },
            { ".suboptions.can.be.all.grouped.or.summary", "                            suboptions can be all, grouped or summary" },
            { ".tsa.url.location.of.the.Timestamping.Authority", "[-tsa <url>]                location of the Timestamping Authority" },
            { ".tsacert.alias.public.key.certificate.for.Timestamping.Authority", "[-tsacert <alias>]          public key certificate for Timestamping Authority" },
            { ".tsadigestalg.algorithm.of.digest.data.in.timestamping.request", "[-tsadigestalg <algorithm>] algorithm of digest data in timestamping request" },
            { ".tsapolicyid.tsapolicyid.for.Timestamping.Authority", "[-tsapolicyid <oid>]        TSAPolicyID for Timestamping Authority" },
            { ".updating.", " updating: " },
            { ".verbose.suboptions.verbose.output.when.signing.verifying.", "[-verbose[:suboptions]]     verbose output when signing/verifying." },
            { ".verify.verify.a.signed.JAR.file", "[-verify]                   verify a signed JAR file" },
            { ".version.print.the.program.version", "[-version]                  print the program version" },
            { ".{0}.extension.does.not.support.code.signing.", "[{0} extension does not support code signing]" },
            { "6SPACE", "      " },
            { "COMMA", ", " },
            { "Cannot.find.environment.variable.", "Cannot find environment variable: " },
            { "Cannot.find.file.", "Cannot find file: " },
            { "Cannot.restore.certchain.from.file.specified", "Cannot restore certchain from file specified" },
            { "Certificate.chain.not.found.for.alias.alias.must.reference.a.valid.KeyStore.key.entry.containing.a.private.key.and", "Certificate chain not found for: {0}.  {1} must reference a valid KeyStore key entry containing a private key and corresponding public key certificate chain." },
            { "Certificate.chain.not.found.in.the.file.specified.", "Certificate chain not found in the file specified." },
            { "Certificate.not.found.for.alias.alias.must.reference.a.valid.KeyStore.entry.containing.an.X.509.public.key.certificate.for.the", "Certificate not found for: {0}.  {1} must reference a valid KeyStore entry containing an X.509 public key certificate for the Timestamping Authority." },
            { "Enter.Passphrase.for.keystore.", "Enter Passphrase for keystore: " },
            { "Enter.key.password.for.alias.", "Enter key password for {0}: " },
            { "Error.", "Error: " },
            { "File.specified.by.certchain.does.not.exist", "File specified by -certchain does not exist" },
            { "If.keystore.is.not.password.protected.then.storepass.and.keypass.must.not.be.specified", "If keystore is not password protected, then -storepass and -keypass must not be specified" },
            { "If.protected.is.specified.then.storepass.and.keypass.must.not.be.specified", "If -protected is specified, then -storepass and -keypass must not be specified" },
            { "Illegal.option.", "Illegal option: " },
            { "Only.one.alias.can.be.specified", "Only one alias can be specified" },
            { "Option.lacks.argument", "Option lacks argument" },
            { "Please.specify.alias.name", "Please specify alias name" },
            { "Please.specify.jarfile.name", "Please specify jarfile name" },
            { "Please.type.jarsigner.help.for.usage", "Please type jarsigner --help for usage" },
            { "Re.run.with.the.verbose.and.certs.options.for.more.details.", "Re-run with the -verbose and -certs options for more details." },
            { "SPACE", " " },
            { "TSA.certificate.", "TSA certificate: " },
            { "TSA.location.", "TSA location: " },
            { "The.1.algorithm.specified.for.the.2.option.is.considered.a.security.risk..This.algorithm.will.be.disabled.in.a.future.update.", "The %1$s algorithm specified for the %2$s option is considered a security risk. This algorithm will be disabled in a future update." },
            { "The.1.algorithm.specified.for.the.2.option.is.considered.a.security.risk.and.is.disabled.", "The %1$s algorithm specified for the %2$s option is considered a security risk and is disabled." },
            { "The.digest.algorithm.1.is.considered.a.security.risk..This.algorithm.will.be.disabled.in.a.future.update.", "The %1$s digest algorithm is considered a security risk. This algorithm will be disabled in a future update." },
            { "The.full.keyAlgName.signing.key.is.considered.a.security.risk..It.will.be.disabled.in.a.future.update.", "The %s signing key is considered a security risk. It will be disabled in a future update." },
            { "The.full.keyAlgName.signing.key.is.considered.a.security.risk.and.is.disabled.", "The %s signing key is considered a security risk and is disabled." },
            { "The.signature.algorithm.1.is.considered.a.security.risk..This.algorithm.will.be.disabled.in.a.future.update.", "The %1$s signature algorithm is considered a security risk. This algorithm will be disabled in a future update." },
            { "The.signer.certificate.has.expired.", "The signer certificate has expired." },
            { "The.signer.certificate.is.not.yet.valid.", "The signer certificate is not yet valid." },
            { "The.signer.certificate.s.ExtendedKeyUsage.extension.doesn.t.allow.code.signing.", "The signer certificate's ExtendedKeyUsage extension doesn't allow code signing." },
            { "The.signer.certificate.s.KeyUsage.extension.doesn.t.allow.code.signing.", "The signer certificate's KeyUsage extension doesn't allow code signing." },
            { "The.signer.certificate.s.NetscapeCertType.extension.doesn.t.allow.code.signing.", "The signer certificate's NetscapeCertType extension doesn't allow code signing." },
            { "The.signer.certificate.will.expire.on.1.", "The signer certificate will expire on %1$tY-%1$tm-%1$td." },
            { "The.signer.certificate.will.expire.within.six.months.", "The signer certificate will expire within six months." },
            { "The.signer.s.certificate.chain.is.invalid.reason.1", "The signer's certificate chain is invalid. Reason: %s" },
            { "The.signer.s.certificate.is.self.signed.", "The signer's certificate is self-signed." },
            { "The.timestamp.digest.algorithm.1.is.considered.a.security.risk..This.algorithm.will.be.disabled.in.a.future.update.", "The %1$s timestamp digest algorithm is considered a security risk. This algorithm will be disabled in a future update." },
            { "The.timestamp.expired.1.but.usable.2", "The timestamp expired on %1$tY-%1$tm-%1$td. However, the JAR will be valid until the signer certificate expires on %2$tY-%2$tm-%2$td." },
            { "The.timestamp.has.expired.", "The timestamp has expired." },
            { "The.timestamp.will.expire.on.1.", "The timestamp will expire on %1$tY-%1$tm-%1$td." },
            { "The.timestamp.will.expire.within.one.year.on.1", "The timestamp will expire within one year on %1$tY-%1$tm-%1$td." },
            { "The.timestamp.will.expire.within.one.year.on.1.but.2", "The timestamp will expire within one year on %1$tY-%1$tm-%1$td. However, the JAR will be valid until the signer certificate expires on %2$tY-%2$tm-%2$td." },
            { "The.tsa.certificate.chain.is.invalid.reason.1", "The TSA certificate chain is invalid. Reason: %s" },
            { "This.jar.contains.entries.whose.certificate.chain.is.invalid.reason.1", "This jar contains entries whose certificate chain is invalid. Reason: %s" },
            { "This.jar.contains.entries.whose.signer.certificate.has.expired.", "This jar contains entries whose signer certificate has expired. " },
            { "This.jar.contains.entries.whose.signer.certificate.is.not.yet.valid.", "This jar contains entries whose signer certificate is not yet valid. " },
            { "This.jar.contains.entries.whose.signer.certificate.is.self.signed.", "This jar contains entries whose signer certificate is self-signed." },
            { "This.jar.contains.entries.whose.signer.certificate.s.ExtendedKeyUsage.extension.doesn.t.allow.code.signing.", "This jar contains entries whose signer certificate's ExtendedKeyUsage extension doesn't allow code signing." },
            { "This.jar.contains.entries.whose.signer.certificate.s.KeyUsage.extension.doesn.t.allow.code.signing.", "This jar contains entries whose signer certificate's KeyUsage extension doesn't allow code signing." },
            { "This.jar.contains.entries.whose.signer.certificate.s.NetscapeCertType.extension.doesn.t.allow.code.signing.", "This jar contains entries whose signer certificate's NetscapeCertType extension doesn't allow code signing." },
            { "This.jar.contains.entries.whose.signer.certificate.will.expire.within.six.months.", "This jar contains entries whose signer certificate will expire within six months. " },
            { "This.jar.contains.entries.whose.tsa.certificate.chain.is.invalid.reason.1", "This jar contains entries whose TSA certificate chain is invalid. Reason: %s" },
            { "This.jar.contains.signed.entries.that.s.not.signed.by.alias.in.this.keystore.", "This jar contains signed entries that are not signed by alias in this keystore." },
            { "This.jar.contains.signed.entries.which.is.not.signed.by.the.specified.alias.es.", "This jar contains signed entries which are not signed by the specified alias(es)." },
            { "This.jar.contains.unsigned.entries.which.have.not.been.integrity.checked.", "This jar contains unsigned entries which have not been integrity-checked. " },
            { "Unknown.password.type.", "Unknown password type: " },
            { "Usage.jarsigner.options.jar.file.alias", "Usage: jarsigner [options] jar-file alias" },
            { "Warning.", "Warning: " },
            { "X", "X" },
            { "attempt.to.rename.jarFile.to.origJar.failed", "attempt to rename {0} to {1} failed" },
            { "attempt.to.rename.signedJarFile.to.jarFile.failed", "attempt to rename {0} to {1} failed" },
            { "bad.timestamp.verifying", "This jar contains signatures that include an invalid timestamp. Without a valid timestamp, users may not be able to validate this jar after any of the signer certificates expire (as early as %1$tY-%1$tm-%1$td).\nRerun jarsigner with -J-Djava.security.debug=jar for more information." },
            { "certificate.exception.", "certificate exception: " },
            { "certificate.expired.on", "certificate expired on {0}" },
            { "certificate.is.not.valid.until", "certificate is not valid until {0}" },
            { "certificate.is.valid.from", "certificate is valid from {0} to {1}" },
            { "certificate.will.expire.on", "certificate will expire on {0}" },
            { "codesigners.different.for.entry.1.when.reading.jarfile.and.jarinputstream", "Code signers are different for entry %s when reading from JarFile and JarInputStream" },
            { "entry.1.is.signed.in.jarfile.but.is.not.signed.in.jarinputstream", "Entry %s is signed in JarFile but is not signed in JarInputStream" },
            { "entry.1.is.signed.in.jarinputstream.but.is.not.signed.in.jarfile", "Entry %s is signed in JarInputStream but is not signed in JarFile" },
            { "entry.1.present.in.jarfile.but.unreadable", "Entry %s is present in JarFile but unreadable" },
            { "entry.1.present.when.reading.jarfile.but.missing.via.jarinputstream", "Entry %s is present when reading via JarFile but missing when reading via JarInputStream" },
            { "entry.1.present.when.reading.jarinputstream.but.missing.via.jarfile", "Entry %s is present when reading via JarInputStream but missing when reading via JarFile" },
            { "entry.was.signed.on", "entry was signed on {0}" },
            { "event.crl.check", "Downloading CRL from %s ..." },
            { "event.ocsp.check", "Contacting OCSP server at %s ..." },
            { "external.file.attributes.detected", "POSIX file permission and/or symlink attributes detected. These attributes are ignored when signing and are not protected by the signature." },
            { "found.non.X.509.certificate.in.signer.s.chain", "found non-X.509 certificate in signer's chain" },
            { "history.nobk", "- Missing block file for signature-related file META-INF/%s.SF" },
            { "history.nonexistent.entries", "    Warning: nonexistent signed entries: " },
            { "history.nosf", "- Missing signature-related file META-INF/%s.SF" },
            { "history.unparsable", "- Unparsable signature-related file %s" },
            { "history.with.ts", "- Signed by \"%1$s\"\n    Digest algorithm: %2$s\n    Signature algorithm: %3$s, %4$s\n  Timestamped by \"%6$s\" on %5$tc\n    Timestamp digest algorithm: %7$s\n    Timestamp signature algorithm: %8$s, %9$s" },
            { "history.without.ts", "- Signed by \"%1$s\"\n    Digest algorithm: %2$s\n    Signature algorithm: %3$s, %4$s" },
            { "invalid.timestamp.signing", "The timestamp is invalid. Without a valid timestamp, users may not be able to validate this jar after the signer certificate's expiration date (%1$tY-%1$tm-%1$td)." },
            { "jar.contains.internal.inconsistencies.result.in.different.contents.via.jarfile.and.jarinputstream", "This JAR file contains internal inconsistencies that may result in different contents when reading via JarFile and JarInputStream:" },
            { "jar.is.unsigned", "jar is unsigned." },
            { "jar.signed.", "jar signed." },
            { "jar.signed.with.signer.errors.", "jar signed, with signer errors." },
            { "jar.treated.unsigned", "WARNING: Signature is either not parsable or not verifiable, and the jar will be treated as unsigned. For more information, re-run jarsigner with debug enabled (-J-Djava.security.debug=jar)." },
            { "jar.treated.unsigned.see.weak", "The jar will be treated as unsigned, because it is signed with a weak algorithm that is now disabled.\n\nRe-run jarsigner with the -verbose option for more details." },
            { "jar.treated.unsigned.see.weak.verbose", "WARNING: The jar will be treated as unsigned, because it is signed with a weak algorithm that is now disabled by the security property:" },
            { "jar.verified.", "jar verified." },
            { "jar.verified.with.signer.errors.", "jar verified, with signer errors." },
            { "jarsigner.", "jarsigner: " },
            { "jarsigner.error.", "jarsigner error: " },
            { "k", "k" },
            { "key.associated.with.alias.not.a.private.key", "key associated with {0} not a private key" },
            { "key.bit", "%s key" },
            { "key.bit.disabled", "%s key (disabled)" },
            { "key.bit.weak", "%s key (weak)" },
            { "keystore.load.", "keystore load: " },
            { "m", "m" },
            { "manifest.attribute.1.differs.jarfile.value.2.jarinputstream.value.3", "Manifest main attribute %1$s differs: JarFile value = %2$s, JarInputStream value = %3$s" },
            { "manifest.attribute.1.present.when.reading.jarfile.but.missing.via.jarinputstream", "Manifest main attribute %s is present when reading via JarFile but missing when reading via JarInputStream" },
            { "manifest.attribute.1.present.when.reading.jarinputstream.but.missing.via.jarfile", "Manifest main attribute %s is present when reading via JarInputStream but missing when reading via JarFile" },
            { "manifest.missing.when.reading.jarfile", "Manifest is missing when reading via JarFile" },
            { "manifest.missing.when.reading.jarinputstream", "Manifest is missing when reading via JarInputStream" },
            { "multiple.manifest.warning.", "Duplicate manifest entries were detected in the jar file. JarSigner operated on only one, and the others have been discarded." },
            { "no.manifest.", "no manifest." },
            { "no.response.from.the.Timestamping.Authority.", "no response from the Timestamping Authority. When connecting from behind a firewall an HTTP or HTTPS proxy may need to be specified. Supply the following options to jarsigner:" },
            { "no.timestamp.signing", "No -tsa or -tsacert is provided and this jar is not timestamped. Without a timestamp, users may not be able to validate this jar after the signer certificate's expiration date (%1$tY-%1$tm-%1$td)." },
            { "no.timestamp.verifying", "This jar contains signatures that do not include a timestamp. Without a timestamp, users may not be able to validate this jar after any of the signer certificates expire (as early as %1$tY-%1$tm-%1$td)." },
            { "nonexistent.entries.found", "This jar contains signed entries for files that do not exist. See the -verbose output for more details." },
            { "or", "or" },
            { "provclass.not.a.provider", "%s not a provider" },
            { "provider.class.not.found", "Provider \"%s\" not found" },
            { "provider.name.not.found", "Provider named \"%s\" not found" },
            { "q", "?" },
            { "requesting.a.signature.timestamp", "requesting a signature timestamp" },
            { "s", "s" },
            { "signature.filename.must.consist.of.the.following.characters.A.Z.0.9.or.", "signature filename must consist of the following characters: A-Z, 0-9, _ or -" },
            { "signature.verification.failed.on.entry.1.when.reading.via.jarfile", "Signature verification failed on entry %s when reading via JarFile" },
            { "signature.verification.failed.on.entry.1.when.reading.via.jarinputstream", "Signature verification failed on entry %s when reading via JarInputStream" },
            { "signer.cert.expired.1.but.timestamp.good.2.", "The signer certificate expired on %1$tY-%1$tm-%1$td. However, the JAR will be valid until the timestamp expires on %2$tY-%2$tm-%2$td." },
            { "size.bit.alg", "%1$d-bit %2$s" },
            { "trusted.certificate", "trusted certificate" },
            { "unable.to.create.", "unable to create: " },
            { "unable.to.instantiate.keystore.class.", "unable to instantiate keystore class: " },
            { "unable.to.open.jar.file.", "unable to open jar file: " },
            { "unable.to.read.password.", "unable to read password: " },
            { "unable.to.recover.key.from.keystore", "unable to recover key from keystore" },
            { "unable.to.sign.jar.", "unable to sign jar: " },
            { "with.algparams.disabled", "%1$s using %2$s (disabled)" },
            { "with.algparams.weak", "%1$s using %2$s (weak)" },
            { "with.disabled", "%s (disabled)" },
            { "with.weak", "%s (weak)" },
            { "you.must.enter.key.password", "you must enter key password" },
        };
    }
}
