Package com.chilkatsoft.chilkat2

Class JavaKeyStore

java.lang.Object
com.chilkatsoft.chilkat2.ChilkatObject
com.chilkatsoft.chilkat2.JavaKeyStore
All Implemented Interfaces:
AutoCloseable
public class JavaKeyStore extends ChilkatObject
<section class="javakeystore-summary">

Load, inspect, modify, convert, and save Java keystore data.

Chilkat.JavaKeyStore is the Chilkat class for working with Java keystore data. It supports private-key entries with aliases and certificate chains, trusted certificate entries, and secret-key entries. It can load and save keystores, import private-key entries from PFX, add trusted certificates and symmetric keys, retrieve private keys and certificate chains, manage aliases, change private-key passwords, and convert keystore contents to PEM, PFX, or JWK Set format.

Load and save keystores

Read Java keystore data into memory, inspect or modify its contents, and save the updated keystore when changes are complete.

Private-key entries

Work with private keys stored under aliases, including their associated certificate chains and entry-specific passwords.

Trusted certificates

Add, retrieve, and manage trusted certificate entries used for trust stores, TLS validation, and Java-based security configuration.

Secret-key entries

Store and retrieve symmetric secret keys when the keystore is used for application key material in addition to certificates.

Import and convert

Import private-key entries from PFX/P12 and export or convert keystore contents to PEM, PFX, or JWK Set format.

Alias management

Enumerate aliases, locate entries, rename or manage entry names, and organize keys and certificates by application-specific identifiers.

Common pattern: Load the keystore with its store password, locate the needed entry by alias, retrieve the private key, certificate chain, trusted certificate, or secret key, then save the keystore or export the selected material in the format required by the target system. Use JavaKeyStore when the data is organized as a Java keystore; use Cert, PrivateKey, Pfx, or TrustedRoots when working directly with individual certificate or key objects.

For an extended overview, see JavaKeyStore Class Overview.

</section>

Instances hold a native Chilkat object: close them with ChilkatObject.close() (try-with-resources) when done; an unclosed instance is freed when it becomes unreachable.

See Also:
Online reference

  • Constructor Details

    • JavaKeyStore

      public JavaKeyStore()
      Creates a new JavaKeyStore object.

  • Method Details

    • getNumPrivateKeys

      public int getNumPrivateKeys()
      Returns the number of private-key entries currently contained in the keystore. Each private-key entry has an alias, a protected private key, and an associated certificate chain. Valid private-key indexes range from 0 through NumPrivateKeys - 1.Entry password versus store password: The private key in each entry may have its own password. That entry password is supplied to methods such as privateKeyAt(String, int, PrivateKey) and privateKeyOf(String, String, boolean, PrivateKey). It is distinct from the store password used when loading or saving the complete keystore.
      Returns:
      the value of the NumPrivateKeys property (read-only)

    • getNumSecretKeys

      public int getNumSecretKeys()
      Returns the number of symmetric secret-key entries currently contained in the keystore. Examples include AES, HMAC, Blowfish, and ChaCha key material. Valid indexes range from 0 through NumSecretKeys - 1.JCEKS entry type: Secret-key entries require the JCEKS format; the traditional JKS format stores private-key entries and trusted-certificate entries but does not provide the JCEKS secret-key entry type.
      Returns:
      the value of the NumSecretKeys property (read-only)

    • getNumTrustedCerts

      public int getNumTrustedCerts()
      Returns the number of trusted-certificate entries currently contained in the keystore. Each entry contains one certificate and an alias. Valid indexes range from 0 through NumTrustedCerts - 1.A trusted entry is not necessarily a root CA: Java keystores can mark any certificate as trusted. The application or Java security configuration decides what that trust means; this class does not validate the certificate merely because it is stored as a trusted-certificate entry.
      Returns:
      the value of the NumTrustedCerts property (read-only)

    • getRequireCompleteChain

      public boolean getRequireCompleteChain()
      Controls whether a complete certificate chain is required when a private-key entry is added. The default is true. When enabled, addPrivateKey(Cert, String, String) and addPfx(Pfx, String, String) fail if Chilkat cannot build the chain through the issuing certificates to a root or self-signed certificate. When set to false, an incomplete chain may be stored.Providing missing issuers: Call useCertVault(XmlCertVault) to make additional certificates available for chain construction. Trusted CA roots supplied through Chilkat trusted-root facilities may also help complete the chain. This property affects chain construction while adding entries; it does not perform application trust-policy validation.
      Returns:
      the value of the RequireCompleteChain property

    • setRequireCompleteChain

      public void setRequireCompleteChain​(boolean value)
      Sets the RequireCompleteChain property; see getRequireCompleteChain().
      Parameters:
      value - the new value

    • getVerifyKeyedDigest

      public boolean getVerifyKeyedDigest()
      Controls validation of the keystore-level integrity digest when a JKS or JCEKS store is loaded. The default is true. In this mode, the load method uses the supplied store password to verify that the serialized keystore has not been altered and that the password is appropriate for the store.

      When set to false, a load method may be called with an empty password to read the store without validating its integrity digest.

      Security consequence: Disabling this check does not decrypt private or secret key entries and does not make their entry passwords unnecessary. It only skips store-level integrity verification, so corrupted or modified keystore data may be accepted. Leave this property enabled for normal use.

      Returns:
      the value of the VerifyKeyedDigest property

    • setVerifyKeyedDigest

      public void setVerifyKeyedDigest​(boolean value)
      Sets the VerifyKeyedDigest property; see getVerifyKeyedDigest().
      Parameters:
      value - the new value

    • addPfx

      public void addPfx​(Pfx pfx, String aliasName, String password)
      Imports the private-key entries found in the Pfx object supplied in pfx. One Java keystore private-key entry is added for each private key in the PFX/PKCS #12 data. Certificates from the PFX are used to construct the certificate chain associated with each imported private key.

      aliasName specifies the alias for the first imported private key. If it is empty, Chilkat chooses an alias in this order:

      1. The subject common name of the private key certificate.
      2. The subject email address.
      3. The PKCS #12 friendly-name attribute.
      4. The certificate serial number.

      If the PFX contains additional private keys, their aliases are chosen automatically using the same preference order. password becomes the entry password used to protect the imported private keys in the Java keystore.

      What is not imported: Standalone certificates from the PFX are not added as trusted-certificate entries. They are used only as possible members of private-key certificate chains. Call addTrustedCert(Cert, String) separately when a certificate should become an explicit trust entry.Chain completion: If getRequireCompleteChain() is enabled, the method fails when any imported private-key chain cannot be completed. useCertVault(XmlCertVault) can supply additional issuer certificates.

      Parameters:
      pfx - the pfx argument (not null)
      aliasName - the aliasName argument (not null)
      password - the password argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • addPrivateKey

      public void addPrivateKey​(Cert cert, String aliasName, String password)
      Adds a private-key entry using the certificate in cert. The Cert object must have access to its associated private key. Chilkat obtains that private key and builds the certificate chain beginning with cert.

      aliasName is the entry alias. If it is empty, Chilkat chooses an alias from the certificate in this order: subject common name, subject email address, then certificate serial number. password is the password used to protect the private key inside the keystore.

      Certificate-chain construction: A private-key entry consists of the private key and the certificate chain for its public key. If getRequireCompleteChain() is enabled, the method fails unless the chain can be completed. Use useCertVault(XmlCertVault) when additional issuer certificates are needed.

      Parameters:
      cert - the cert argument (not null)
      aliasName - the aliasName argument (not null)
      password - the password argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • addSecretKey

      public void addSecretKey​(String encodedKeyBytes, String encoding, String algorithm, String aliasName, String password)
      Adds a symmetric secret-key entry. encodedKeyBytes contains the key bytes encoded as text, and encoding names that encoding, such as hex, base64, or base64url. algorithm records the key algorithm, such as AES, HMAC_SHA256, or CHACHA. aliasName is the alias, and password is the password used to protect the key entry.

      The algorithm value describes the intended key type; it does not transform the supplied key bytes. For example, a 128-bit AES key is supplied as exactly 16 decoded bytes and algorithm is set to AES.

      JCEKS and legacy protection: Secret-key entries are stored in JCEKS form. JCEKS protects these entries using the legacy PBEWithMD5AndTripleDES mechanism defined by that format. Use this format when interoperability requires JCEKS, and protect both the entry password and the resulting file.

      Parameters:
      encodedKeyBytes - the encodedKeyBytes argument (not null)
      encoding - the encoding argument (not null)
      algorithm - the algorithm argument (not null)
      aliasName - the aliasName argument (not null)
      password - the password argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • addTrustedCert

      public void addTrustedCert​(Cert cert, String aliasName)
      Adds cert as a trusted-certificate entry under the alias supplied in aliasName. A trusted-certificate entry contains the certificate only; it does not contain a private key or a certificate chain.Trust is an application decision: Adding a certificate as a trusted entry does not prove that it is a CA certificate, validate its signature chain, or make it universally trustworthy. It records that the keystore owner intends to trust that certificate for the consuming Java application or security configuration.
      Parameters:
      cert - the cert argument (not null)
      aliasName - the aliasName argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • certChainAt

      public void certChainAt​(int index, CertChain certChain)
      Loads certChain with the certificate chain belonging to the private-key entry at zero-based index index. Valid indexes range from 0 through getNumPrivateKeys() - 1. The first certificate contains the public key corresponding to the private key; subsequent certificates are issuing certificates toward the root.
      Parameters:
      index - the index argument
      certChain - the certChain argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • certChainOf

      public void certChainOf​(String aliasName, boolean caseSensitive, CertChain certChain)
      Searches the private-key entries for an alias equal to aliasName and loads the matching certificate chain into certChain. caseSensitive controls whether the alias comparison is case-sensitive. The first certificate in the chain contains the public key corresponding to the private key.Alias case behavior: Java keystore implementations can differ in alias case handling. Avoid aliases that differ only by case, even when a case-sensitive search is requested.
      Parameters:
      aliasName - the aliasName argument (not null)
      caseSensitive - the caseSensitive argument
      certChain - the certChain argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • changePassword

      public void changePassword​(int index, String oldPassword, String newPassword)
      Changes the password protecting the private-key entry at index. Indexing begins at 0. oldPassword is the current entry password and newPassword is the new entry password.This does not change only the store password: A JKS/JCEKS store can have one password for store-level integrity and separate passwords for private-key entries. To migrate a keystore from one common password to another, load it using the old store password, call this method for each private-key entry that uses the old password, and then save the store using the new store password.
      Parameters:
      index - the index argument
      oldPassword - the oldPassword argument (not null)
      newPassword - the newPassword argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • getPrivateKeyAlias

      public String getPrivateKeyAlias​(int index)
      Returns the alias of the private-key entry at index. Indexing begins at 0; valid indexes range from 0 through getNumPrivateKeys() - 1.Alias portability: Java keystore alias case behavior is implementation-dependent. Avoid creating aliases that differ only by letter case, even when a Chilkat lookup method offers a case-sensitive option.
      Parameters:
      index - the index argument
      Returns:
      the result (never null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • getSecretKey

      public String getSecretKey​(String password, int index, String encoding)
      Recovers the secret-key entry at index and returns its raw key bytes encoded using encoding. password is the password protecting that entry. Indexing begins at 0. Common output encodings include hex, base64, and base64url.Secret material: The returned text represents the actual symmetric key bytes, not a fingerprint or identifier. Avoid writing it to logs, command histories, or unprotected configuration files.
      Parameters:
      password - the password argument (not null)
      index - the index argument
      encoding - the encoding argument (not null)
      Returns:
      the result (never null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • getSecretKeyAlias

      public String getSecretKeyAlias​(int index)
      Returns the alias of the secret-key entry at index. Indexing begins at 0; valid indexes range from 0 through getNumSecretKeys() - 1.
      Parameters:
      index - the index argument
      Returns:
      the result (never null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • getTrustedCertAlias

      public String getTrustedCertAlias​(int index)
      Returns the alias of the trusted-certificate entry at index. Indexing begins at 0; valid indexes range from 0 through getNumTrustedCerts() - 1.
      Parameters:
      index - the index argument
      Returns:
      the result (never null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • loadBd

      public void loadBd​(String password, BinData bd)
      Loads a JKS or JCEKS keystore from the bytes currently contained in bd. password is the store password used for integrity verification when getVerifyKeyedDigest() is enabled.
      Parameters:
      password - the password argument (not null)
      bd - the bd argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • loadEncoded

      public void loadEncoded​(String password, String jksEncData, String encoding)
      Decodes the serialized keystore text in jksEncData using the binary encoding named by encoding, then loads the resulting JKS or JCEKS bytes. Common encodings include base64, hex, and base64url. password is the store password used for integrity verification.Encoding is not encryption: encoding describes how binary keystore bytes are represented as text. It does not name the keystore format and does not protect the data cryptographically.
      Parameters:
      password - the password argument (not null)
      jksEncData - the jksEncData argument (not null)
      encoding - the encoding argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • loadFile

      public void loadFile​(String password, String path)
      Loads a JKS or JCEKS keystore from the file at path. password is the store password used to verify the keystore-level integrity digest when getVerifyKeyedDigest() is enabled.JKS/JCEKS versus PKCS #12: This class is intended for the proprietary Java JKS and JCEKS formats. Modern Java releases use PKCS #12 as the default keystore type; use Chilkat.Pfx when the input is a .p12 or .pfx container.
      Parameters:
      password - the password argument (not null)
      path - the path argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • loadJwkSet

      public void loadJwkSet​(String password, JsonObject jwkSet)
      Loads supported keys from the JWK Set in jwkSet into this Java keystore object. password is used to protect imported private-key and secret-key entries. A JWK kid value is used as the entry alias when present.JWK Set structure: jwkSet should contain a JSON object with a keys array. Private asymmetric JWKs contain private parameters such as d; symmetric JWKs use kty: "oct" and contain the key in k. Treat the input as sensitive whenever it contains private or symmetric key material.
      Parameters:
      password - the password argument (not null)
      jwkSet - the jwkSet argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • privateKeyAt

      public void privateKeyAt​(String password, int index, PrivateKey privKey)
      Loads privKey with the private key at zero-based index index. password is the password protecting that private-key entry. Valid indexes range from 0 through getNumPrivateKeys() - 1.Use the entry password: password is not necessarily the password used to load the complete keystore. Java keystores can protect each private-key entry with a different password.
      Parameters:
      password - the password argument (not null)
      index - the index argument
      privKey - the privKey argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • privateKeyOf

      public void privateKeyOf​(String password, String aliasName, boolean caseSensitive, PrivateKey privKey)
      Searches the private-key entries for an alias equal to aliasName and loads the matching private key into privKey. password is the password protecting that key entry, and caseSensitive controls whether the alias comparison is case-sensitive.
      Parameters:
      password - the password argument (not null)
      aliasName - the aliasName argument (not null)
      caseSensitive - the caseSensitive argument
      privKey - the privKey argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • removeEntry

      public void removeEntry​(int entryType, int index)
      Removes an entry selected by type and zero-based index. entryType uses the following documented values:

      entryType Entry selected

      1 Trusted-certificate entry; index indexes the trusted-certificate list.

      2 Private-key entry; index indexes the private-key list.

      index is an index within the selected entry category, not an index across all entries in the keystore.

      In-memory change: This method modifies the current object. Call toFile(String, String), toBd(String, BinData), or another To* method to persist the updated keystore.

      Parameters:
      entryType - the entryType argument
      index - the index argument
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • setAlias

      public void setAlias​(int entryType, int index, String aliasName)
      Changes the alias of an entry selected by type and zero-based index. entryType uses the following documented values:

      entryType Entry selected

      1 Trusted-certificate entry; index indexes the trusted-certificate list.

      2 Private-key entry; index indexes the private-key list.

      aliasName is the new alias. The index is relative to the selected category, not the complete set of keystore entries.

      Choose aliases carefully: Aliases identify entries within a Java keystore, but case sensitivity is implementation-dependent. Use unique aliases that do not differ only by case.

      Parameters:
      entryType - the entryType argument
      index - the index argument
      aliasName - the aliasName argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • toBd

      public void toBd​(String password, BinData bd)
      Serializes the current Java keystore and writes the complete JKS or JCEKS file image to bd. password is the store password used to create the keystore-level integrity digest.Separate entry protection: Private-key and secret-key entries may have passwords distinct from the store password. Serializing with password does not automatically change those entry passwords.
      Parameters:
      password - the password argument (not null)
      bd - the bd argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • toEncodedString

      public String toEncodedString​(String password, String encoding)
      Serializes the current Java keystore and returns the resulting JKS or JCEKS bytes encoded as text using encoding. Common choices include base64, hex, and base64url. password is the store password used to create the keystore-level integrity digest.
      Parameters:
      password - the password argument (not null)
      encoding - the encoding argument (not null)
      Returns:
      the result (never null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • toFile

      public void toFile​(String password, String path)
      Serializes the current Java keystore and writes the complete JKS or JCEKS file image to path. password is the store password used to create the keystore-level integrity digest.Password roles: The store password may differ from the passwords protecting individual private-key or secret-key entries. Saving with a new store password does not automatically change each entry password; use changePassword(int, String, String) for private-key entries when needed.
      Parameters:
      password - the password argument (not null)
      path - the path argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • toJwkSet

      public void toJwkSet​(String password, StringBuilder sbJwkSet)
      Exports supported private-key and secret-key entries as a JSON Web Key Set and writes the JSON to sbJwkSet. password is used to recover protected key entries. Each exported JWK receives a kid value derived from the keystore alias.Sensitive output: A JWK containing private parameter d or symmetric parameter k contains secret key material. Protect the resulting JSON as carefully as the original keystore and do not log or transmit it over an untrusted channel.
      Parameters:
      password - the password argument (not null)
      sbJwkSet - the sbJwkSet argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • toPemObj

      public void toPemObj​(String password, Pem pemObj)
      Converts the keystore material supported by the Pem class and loads the result into pemObj. password is used to decrypt private-key entries during the conversion.Output handling: The destination Pem object receives the converted material in memory. Its own export methods and properties control whether later PEM text is encrypted and how it is formatted. Treat unencrypted private-key PEM as sensitive data.
      Parameters:
      password - the password argument (not null)
      pemObj - the pemObj argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • toPfxObj

      public void toPfxObj​(String password, Pfx pfxObj)
      Converts the certificates and recoverable private-key entries in the Java keystore and loads the result into pfxObj. password is used to decrypt private-key entries during the conversion.Conversion password: password is an input password for recovering the Java keystore entries. It is not automatically the password that will protect a later serialized PFX; use the destination Pfx export method to choose the PFX password.
      Parameters:
      password - the password argument (not null)
      pfxObj - the pfxObj argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • trustedCertAt

      public void trustedCertAt​(int index, Cert cert)
      Loads cert with the trusted certificate at the zero-based index index. Valid indexes range from 0 through getNumTrustedCerts() - 1. The returned certificate is the single certificate stored in the trust entry and has no private key merely by virtue of being trusted.
      Parameters:
      index - the index argument
      cert - the cert argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • trustedCertOf

      public void trustedCertOf​(String aliasName, boolean caseSensitive, Cert cert)
      Searches the trusted-certificate entries for an alias equal to aliasName and loads the matching certificate into cert. caseSensitive controls whether the alias comparison is case-sensitive.
      Parameters:
      aliasName - the aliasName argument (not null)
      caseSensitive - the caseSensitive argument
      cert - the cert argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • useCertVault

      public void useCertVault​(XmlCertVault vault)
      Adds vault to the certificate sources Chilkat searches when it needs issuer certificates to build a private-key certificate chain. This is useful before calling addPrivateKey(Cert, String, String) or addPfx(Pfx, String, String) when the supplied certificate material does not already contain the complete chain.Lookup source only: Registering a certificate vault does not copy all vault certificates into the Java keystore and does not create trusted-certificate entries. Certificates are consulted only as candidates for chain construction.
      Parameters:
      vault - the vault argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why