--- product: Chilkat product_version: 11.7.0 language: pascal language_label: Lazarus Pascal class: JavaKeyStore license: bundle deprecated: false reference_html: https://www.chilkatsoft.com/refdoc/pascal_JavaKeyStoreRef.html --- # Chilkat JavaKeyStore — Lazarus Pascal — v11.7.0 > Chilkat 11.7.0 · language=pascal · class=JavaKeyStore > Other versions: replace `11.7.0` in this URL. Other languages: `https://www.chilkatsoft.com/ai-docs/v/11.7.0//classes/JavaKeyStore.md`. > Language-wide rules (install, unlock, error model, strings/bytes): `https://www.chilkatsoft.com/ai-docs/v/11.7.0/pascal/guide.md`. ## Purpose **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](https://www.chilkatsoft.com/javakeystore_class_overview.asp). ## Object creation, unlocking and error handling **Create / Free** ```pascal uses Chilkat.JavaKeyStore; var obj: TJavaKeyStore; begin obj := TJavaKeyStore.Create; try if not obj.IsValid then raise Exception.Create('Failed to create a TJavaKeyStore instance.'); // ... use obj ... finally obj.Free; end; end; ``` `constructor Create;` Allocates the underlying CkJavaKeyStore object and returns a new TJavaKeyStore instance. Simply adding **Chilkat.JavaKeyStore** to the unit's `uses` clause is enough to locate and bind to the Chilkat shared library (DLL / .so / .dylib) at runtime — no separate load step is required. Check `obj.IsValid` after calling `Create`; it is `False` if the underlying library could not be found/loaded or the object could not be allocated (for example, when unlicensed). `destructor Destroy; override;` Every TJavaKeyStore created by calling `Create` should eventually be released by calling `.Free` (inherited from `TObject`). The destructor automatically disposes the underlying CkJavaKeyStore handle. A native (unmanaged) memory leak occurs if the object is never freed. Call `Global.UnlockBundle` once at the start of the program, before using this or any other Chilkat class. Any string unlocks a fully functional 30-day trial; a purchased unlock code is used in production. See `guide.md` for the exact code in Lazarus Pascal. ## Members common to every Chilkat class Documented once per language in `common-members.md`; listed here so this page is self-contained. | Property | Signature | Access | Meaning | |---|---|---|---| | `DebugLogFilePath` | `property DebugLogFilePath: string read GetDebugLogFilePath write SetDebugLogFilePath;` | read/write | If set to a file path, this property logs the LastErrorText of each Chilkat method or property call to the specified file. | | `LastErrorHtml` | `property LastErrorHtml: string read GetLastErrorHtml;` | read-only | Provides HTML-formatted information about the last called method or property. | | `LastErrorText` | `property LastErrorText: string read GetLastErrorText;` | read-only | Provides plain text information about the last called method or property. | | `LastErrorXml` | `property LastErrorXml: string read GetLastErrorXml;` | read-only | Provides XML-formatted information about the last called method or property. | | `LastMethodSuccess` | `property LastMethodSuccess: Boolean read GetLastMethodSuccess write SetLastMethodSuccess;` | read/write | Indicates the success or failure of the most recent method call: `True` means success, `False` means failure. | | `VerboseLogging` | `property VerboseLogging: Boolean read GetVerboseLogging write SetVerboseLogging;` | read/write | If set to `True`, then the contents of LastErrorText (or LastErrorXml, or LastErrorHtml) may contain more verbose information. | | `Version` | `property Version: string read GetVersion;` | read-only | Version of the component/library, such as "10.1.0" | ## Member index | Member | Kind | Signature | |---|---|---| | `NumPrivateKeys` | property, read-only | `property NumPrivateKeys: Integer read GetNumPrivateKeys;` | | `NumSecretKeys` | property, read-only | `property NumSecretKeys: Integer read GetNumSecretKeys;` | | `NumTrustedCerts` | property, read-only | `property NumTrustedCerts: Integer read GetNumTrustedCerts;` | | `RequireCompleteChain` | property, read/write | `property RequireCompleteChain: Boolean read GetRequireCompleteChain write SetRequireCompleteChain;` | | `VerifyKeyedDigest` | property, read/write | `property VerifyKeyedDigest: Boolean read GetVerifyKeyedDigest write SetVerifyKeyedDigest;` | | `AddPfx` | method | `// pfx is a TPfx object. function AddPfx(pfx: TChilkatBase;     const aliasName: string;     const password: string): Boolean;` | | `AddPrivateKey` | method | `// cert is a TCert object. function AddPrivateKey(cert: TChilkatBase;     const aliasName: string;     const password: string): Boolean;` | | `AddSecretKey` | method | `function AddSecretKey(const encodedKeyBytes: string;     const encoding: string;     const algorithm: string;     const aliasName: string;     const password: string): Boolean;` | | `AddTrustedCert` | method | `// cert is a TCert object. function AddTrustedCert(cert: TChilkatBase;     const aliasName: string): Boolean;` | | `CertChainAt` | method | `// certChain is a TCertChain object. function CertChainAt(index: Integer;     certChain: TChilkatBase): Boolean;` | | `CertChainOf` | method | `// certChain is a TCertChain object. function CertChainOf(const aliasName: string;     caseSensitive: Boolean;     certChain: TChilkatBase): Boolean;` | | `ChangePassword` | method | `function ChangePassword(index: Integer;     const oldPassword: string;     const newPassword: string): Boolean;` | | `GetPrivateKeyAlias` | method | `function GetPrivateKeyAlias(index: Integer): string;` | | `GetSecretKey` | method | `function GetSecretKey(const password: string;     index: Integer;     const encoding: string): string;` | | `GetSecretKeyAlias` | method | `function GetSecretKeyAlias(index: Integer): string;` | | `GetTrustedCertAlias` | method | `function GetTrustedCertAlias(index: Integer): string;` | | `LoadBd` | method | `// bd is a TBinData object. function LoadBd(const password: string;     bd: TChilkatBase): Boolean;` | | `LoadEncoded` | method | `function LoadEncoded(const password: string;     const jksEncData: string;     const encoding: string): Boolean;` | | `LoadFile` | method | `function LoadFile(const password: string;     const path: string): Boolean;` | | `LoadJwkSet` | method | `// jwkSet is a TJsonObject object. function LoadJwkSet(const password: string;     jwkSet: TChilkatBase): Boolean;` | | `PrivateKeyAt` | method | `// privKey is a TPrivateKey object. function PrivateKeyAt(const password: string;     index: Integer;     privKey: TChilkatBase): Boolean;` | | `PrivateKeyOf` | method | `// privKey is a TPrivateKey object. function PrivateKeyOf(const password: string;     const aliasName: string;     caseSensitive: Boolean;     privKey: TChilkatBase): Boolean;` | | `RemoveEntry` | method | `function RemoveEntry(entryType: Integer;     index: Integer): Boolean;` | | `SetAlias` | method | `function SetAlias(entryType: Integer;     index: Integer;     const aliasName: string): Boolean;` | | `ToBd` | method | `// bd is a TBinData object. function ToBd(const password: string;     bd: TChilkatBase): Boolean;` | | `ToEncodedString` | method | `function ToEncodedString(const password: string;     const encoding: string): string;` | | `ToFile` | method | `function ToFile(const password: string;     const path: string): Boolean;` | | `ToJwkSet` | method | `// sbJwkSet is a TStringBuilder object. function ToJwkSet(const password: string;     sbJwkSet: TChilkatBase): Boolean;` | | `ToPemObj` | method | `// pemObj is a TPem object. function ToPemObj(const password: string;     pemObj: TChilkatBase): Boolean;` | | `ToPfxObj` | method | `// pfxObj is a TPfx object. function ToPfxObj(const password: string;     pfxObj: TChilkatBase): Boolean;` | | `TrustedCertAt` | method | `// cert is a TCert object. function TrustedCertAt(index: Integer;     cert: TChilkatBase): Boolean;` | | `TrustedCertOf` | method | `// cert is a TCert object. function TrustedCertOf(const aliasName: string;     caseSensitive: Boolean;     cert: TChilkatBase): Boolean;` | | `UseCertVault` | method | `// vault is a TXmlCertVault object. function UseCertVault(vault: TChilkatBase): Boolean;` | ## Properties ### JavaKeyStore.NumPrivateKeys `Chilkat 11.7.0 · pascal · JavaKeyStore · NumPrivateKeys · property · read-only · since 9.5.0.44` ```pascal property NumPrivateKeys: Integer read 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` and `PrivateKeyOf`. It is distinct from the store password used when loading or saving the complete keystore. ### JavaKeyStore.NumSecretKeys `Chilkat 11.7.0 · pascal · JavaKeyStore · NumSecretKeys · property · read-only · since 9.5.0.66` ```pascal property NumSecretKeys: Integer read 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. ### JavaKeyStore.NumTrustedCerts `Chilkat 11.7.0 · pascal · JavaKeyStore · NumTrustedCerts · property · read-only · since 9.5.0.44` ```pascal property NumTrustedCerts: Integer read 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. ### JavaKeyStore.RequireCompleteChain `Chilkat 11.7.0 · pascal · JavaKeyStore · RequireCompleteChain · property · read/write · since 9.5.0.44` ```pascal property RequireCompleteChain: Boolean read GetRequireCompleteChain write SetRequireCompleteChain; ``` Controls whether a complete certificate chain is required when a private-key entry is added. The default is `True`. When enabled, `AddPrivateKey` and `AddPfx` 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` 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. ### JavaKeyStore.VerifyKeyedDigest `Chilkat 11.7.0 · pascal · JavaKeyStore · VerifyKeyedDigest · property · read/write · since 9.5.0.44` ```pascal property VerifyKeyedDigest: Boolean read GetVerifyKeyedDigest write SetVerifyKeyedDigest; ``` 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. ## Methods ### JavaKeyStore.AddPfx `Chilkat 11.7.0 · pascal · JavaKeyStore · AddPfx · method · since 9.5.0.44` ```pascal // pfx is a TPfx object. function AddPfx(pfx: TChilkatBase;     const aliasName: string;     const password: string): Boolean; ``` 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` separately when a certificate should become an explicit trust entry. **Chain completion:** If `RequireCompleteChain` is enabled, the method fails when any imported private-key chain cannot be completed. `UseCertVault` can supply additional issuer certificates. Returns True for success, False for failure. ### JavaKeyStore.AddPrivateKey `Chilkat 11.7.0 · pascal · JavaKeyStore · AddPrivateKey · method · since 9.5.0.44` ```pascal // cert is a TCert object. function AddPrivateKey(cert: TChilkatBase;     const aliasName: string;     const password: string): Boolean; ``` 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 `RequireCompleteChain` is enabled, the method fails unless the chain can be completed. Use `UseCertVault` when additional issuer certificates are needed. Returns True for success, False for failure. ### JavaKeyStore.AddSecretKey `Chilkat 11.7.0 · pascal · JavaKeyStore · AddSecretKey · method · since 9.5.0.66` ```pascal function AddSecretKey(const encodedKeyBytes: string;     const encoding: string;     const algorithm: string;     const aliasName: string;     const password: string): Boolean; ``` 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. Returns True for success, False for failure. ### JavaKeyStore.AddTrustedCert `Chilkat 11.7.0 · pascal · JavaKeyStore · AddTrustedCert · method · since 9.5.0.44` ```pascal // cert is a TCert object. function AddTrustedCert(cert: TChilkatBase;     const aliasName: string): Boolean; ``` 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. Returns True for success, False for failure. ### JavaKeyStore.CertChainAt `Chilkat 11.7.0 · pascal · JavaKeyStore · CertChainAt · method · since 11.0.0` ```pascal // certChain is a TCertChain object. function CertChainAt(index: Integer;     certChain: TChilkatBase): Boolean; ``` Loads `certChain` with the certificate chain belonging to the private-key entry at zero-based index `index`. Valid indexes range from `0` through `NumPrivateKeys - 1`. The first certificate contains the public key corresponding to the private key; subsequent certificates are issuing certificates toward the root. Returns True for success, False for failure. ### JavaKeyStore.CertChainOf `Chilkat 11.7.0 · pascal · JavaKeyStore · CertChainOf · method · since 11.0.0` ```pascal // certChain is a TCertChain object. function CertChainOf(const aliasName: string;     caseSensitive: Boolean;     certChain: TChilkatBase): Boolean; ``` 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. Returns True for success, False for failure. ### JavaKeyStore.ChangePassword `Chilkat 11.7.0 · pascal · JavaKeyStore · ChangePassword · method · since 9.5.0.44` ```pascal function ChangePassword(index: Integer;     const oldPassword: string;     const newPassword: string): Boolean; ``` 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. Returns True for success, False for failure. ### JavaKeyStore.GetPrivateKeyAlias `Chilkat 11.7.0 · pascal · JavaKeyStore · GetPrivateKeyAlias · method · since 9.5.0.44` ```pascal function GetPrivateKeyAlias(index: Integer): string; ``` Returns the alias of the private-key entry at `index`. Indexing begins at `0`; valid indexes range from `0` through `NumPrivateKeys - 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. Returns True for success, False for failure. ### JavaKeyStore.GetSecretKey `Chilkat 11.7.0 · pascal · JavaKeyStore · GetSecretKey · method · since 9.5.0.66` ```pascal function GetSecretKey(const password: string;     index: Integer;     const encoding: string): string; ``` 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. Returns True for success, False for failure. ### JavaKeyStore.GetSecretKeyAlias `Chilkat 11.7.0 · pascal · JavaKeyStore · GetSecretKeyAlias · method · since 9.5.0.66` ```pascal function GetSecretKeyAlias(index: Integer): string; ``` Returns the alias of the secret-key entry at `index`. Indexing begins at `0`; valid indexes range from `0` through `NumSecretKeys - 1`. Returns True for success, False for failure. ### JavaKeyStore.GetTrustedCertAlias `Chilkat 11.7.0 · pascal · JavaKeyStore · GetTrustedCertAlias · method · since 9.5.0.44` ```pascal function GetTrustedCertAlias(index: Integer): string; ``` Returns the alias of the trusted-certificate entry at `index`. Indexing begins at `0`; valid indexes range from `0` through `NumTrustedCerts - 1`. Returns True for success, False for failure. ### JavaKeyStore.LoadBd `Chilkat 11.7.0 · pascal · JavaKeyStore · LoadBd · method · since 9.5.0.77` ```pascal // bd is a TBinData object. function LoadBd(const password: string;     bd: TChilkatBase): Boolean; ``` Loads a JKS or JCEKS keystore from the bytes currently contained in `bd`. `password` is the store password used for integrity verification when `VerifyKeyedDigest` is enabled. Returns True for success, False for failure. ### JavaKeyStore.LoadEncoded `Chilkat 11.7.0 · pascal · JavaKeyStore · LoadEncoded · method · since 9.5.0.44` ```pascal function LoadEncoded(const password: string;     const jksEncData: string;     const encoding: string): Boolean; ``` 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. Returns True for success, False for failure. ### JavaKeyStore.LoadFile `Chilkat 11.7.0 · pascal · JavaKeyStore · LoadFile · method · since 9.5.0.44` ```pascal function LoadFile(const password: string;     const path: string): Boolean; ``` 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 `VerifyKeyedDigest` 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. Returns True for success, False for failure. ### JavaKeyStore.LoadJwkSet `Chilkat 11.7.0 · pascal · JavaKeyStore · LoadJwkSet · method · since 9.5.0.66` ```pascal // jwkSet is a TJsonObject object. function LoadJwkSet(const password: string;     jwkSet: TChilkatBase): Boolean; ``` 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. Returns True for success, False for failure. ### JavaKeyStore.PrivateKeyAt `Chilkat 11.7.0 · pascal · JavaKeyStore · PrivateKeyAt · method · since 11.0.0` ```pascal // privKey is a TPrivateKey object. function PrivateKeyAt(const password: string;     index: Integer;     privKey: TChilkatBase): Boolean; ``` 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 `NumPrivateKeys - 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. Returns True for success, False for failure. ### JavaKeyStore.PrivateKeyOf `Chilkat 11.7.0 · pascal · JavaKeyStore · PrivateKeyOf · method · since 11.0.0` ```pascal // privKey is a TPrivateKey object. function PrivateKeyOf(const password: string;     const aliasName: string;     caseSensitive: Boolean;     privKey: TChilkatBase): Boolean; ``` 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. Returns True for success, False for failure. ### JavaKeyStore.RemoveEntry `Chilkat 11.7.0 · pascal · JavaKeyStore · RemoveEntry · method · since 9.5.0.44` ```pascal function RemoveEntry(entryType: Integer;     index: Integer): Boolean; ``` 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`, `ToBd`, or another `To*` method to persist the updated keystore. Returns True for success, False for failure. ### JavaKeyStore.SetAlias `Chilkat 11.7.0 · pascal · JavaKeyStore · SetAlias · method · since 9.5.0.44` ```pascal function SetAlias(entryType: Integer;     index: Integer;     const aliasName: string): Boolean; ``` 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. Returns True for success, False for failure. ### JavaKeyStore.ToBd `Chilkat 11.7.0 · pascal · JavaKeyStore · ToBd · method · since 11.0.0` ```pascal // bd is a TBinData object. function ToBd(const password: string;     bd: TChilkatBase): Boolean; ``` 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. Returns True for success, False for failure. ### JavaKeyStore.ToEncodedString `Chilkat 11.7.0 · pascal · JavaKeyStore · ToEncodedString · method · since 9.5.0.44` ```pascal function ToEncodedString(const password: string;     const encoding: string): string; ``` 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. Returns True for success, False for failure. ### JavaKeyStore.ToFile `Chilkat 11.7.0 · pascal · JavaKeyStore · ToFile · method · since 9.5.0.44` ```pascal function ToFile(const password: string;     const path: string): Boolean; ``` 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` for private-key entries when needed. Returns True for success, False for failure. ### JavaKeyStore.ToJwkSet `Chilkat 11.7.0 · pascal · JavaKeyStore · ToJwkSet · method · since 9.5.0.66` ```pascal // sbJwkSet is a TStringBuilder object. function ToJwkSet(const password: string;     sbJwkSet: TChilkatBase): Boolean; ``` 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. Returns True for success, False for failure. ### JavaKeyStore.ToPemObj `Chilkat 11.7.0 · pascal · JavaKeyStore · ToPemObj · method · since 11.0.0` ```pascal // pemObj is a TPem object. function ToPemObj(const password: string;     pemObj: TChilkatBase): Boolean; ``` 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. Returns True for success, False for failure. ### JavaKeyStore.ToPfxObj `Chilkat 11.7.0 · pascal · JavaKeyStore · ToPfxObj · method · since 11.0.0` ```pascal // pfxObj is a TPfx object. function ToPfxObj(const password: string;     pfxObj: TChilkatBase): Boolean; ``` 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. Returns True for success, False for failure. ### JavaKeyStore.TrustedCertAt `Chilkat 11.7.0 · pascal · JavaKeyStore · TrustedCertAt · method · since 11.0.0` ```pascal // cert is a TCert object. function TrustedCertAt(index: Integer;     cert: TChilkatBase): Boolean; ``` Loads `cert` with the trusted certificate at the zero-based index `index`. Valid indexes range from `0` through `NumTrustedCerts - 1`. The returned certificate is the single certificate stored in the trust entry and has no private key merely by virtue of being trusted. Returns True for success, False for failure. ### JavaKeyStore.TrustedCertOf `Chilkat 11.7.0 · pascal · JavaKeyStore · TrustedCertOf · method · since 11.0.0` ```pascal // cert is a TCert object. function TrustedCertOf(const aliasName: string;     caseSensitive: Boolean;     cert: TChilkatBase): Boolean; ``` 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. Returns True for success, False for failure. ### JavaKeyStore.UseCertVault `Chilkat 11.7.0 · pascal · JavaKeyStore · UseCertVault · method · since 9.5.0.44` ```pascal // vault is a TXmlCertVault object. function UseCertVault(vault: TChilkatBase): Boolean; ``` 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` or `AddPfx` 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. Returns True for success, False for failure. ## Related classes [`BinData`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/pascal/classes/BinData.md), [`Cert`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/pascal/classes/Cert.md), [`CertChain`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/pascal/classes/CertChain.md), [`JsonObject`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/pascal/classes/JsonObject.md), [`Pem`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/pascal/classes/Pem.md), [`Pfx`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/pascal/classes/Pfx.md), [`PrivateKey`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/pascal/classes/PrivateKey.md), [`StringBuilder`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/pascal/classes/StringBuilder.md), [`XmlCertVault`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/pascal/classes/XmlCertVault.md)