# PGPReader Class

The PGPReader class unprotects, verifies, and extracts data from protected PGP files.

## Syntax

```text
secureblackbox.PGPReader
```

## Remarks

PGPReader lets you process PGP messages, and validate and extract the protected data.

PGPReader supports all modern PGP keys and formats, from last-century PGP 2.6.x to the state-of-the art PGP 6. Single- and multi-file, as well as for-your-eyes-only PGP containers are supported.

The use of PGPReader is quite straightforward: you only need to provide the protected data and the keyring files, and the component will do the rest. PGPReader detects the protection parameters, matches them to the keys, and unwraps the protected data automatically.

### Preparing keys

Encryption and signing in PGP is done with asymmetric keys (and sometimes with passwords, but that is a far less common scenario). Keys are normally stored in files called keyrings. More often that not they consist of a pair of files: a public keyring (e.g pubring.pkr) and a secret keyring (secring.skr), although there are exceptions. Sometimes, parties provide each other with standalone public keys that they want them to encrypt or verify data with.

Whichever form your keyring takes, use [PGPKeyring](PGPKeyring.md#PGPKeyring) to load it. It is recommended to load all the keyring files that you have to make sure that you have all the keys loaded. [PGPKeyring](PGPKeyring.md#PGPKeyring) can detect duplicate keys, so don't worry about loading the same key twice - any duplicates will be neatly merged together into one key object.

```text
  PGPKeyring keyring = new PGPKeyring();
  keyring.ImportFromFile("pubring.pkr");
  keyring.ImportFromFile("secring.skr");
```

You keyring will typically contain two types of keys: public and private. Private keys (i.e. your keys) are used for signing and decryption. Public keys (someone else's keys) are used for encryption and signature verification. This means that if you are looking to decrypt a file, you need to get your private keys ready. If you are looking to verify someone's signature over the data, you need to get the public keys.

When processing protected files PGPReader can look for the required keys in the keyring and select the appropriate ones automatically. This means that you do not need to comb through your key collection manually, cherry-picking public and private keys. Simply assign the entire collection of keys to PGPReader's [DecryptingKeys](#decryptingkeys-property-pgpreader-class) and [VerifyingKeys](#verifyingkeys-property-pgpreader-class) properties, and PGPReader will find and use the right one:

```text
  reader.DecryptingKeys = keyring.Keys;
  reader.VerifyingKeys = keyring.Keys;
```

When it comes to using your private keys - i.e. when decrypting the data - there is one important catch that you need to keep in mind. Private PGP keys are typically protected with passwords. To be able to use them, you need to provide the valid password to the component when the key needs to be used. You can do that in one of the following three ways:

- By assigning the password to [Passphrase](#PGPKey_f_Passphrase) property. You can check whether the provided password is valid using the [PassphraseValid](#PGPKey_f_PassphraseValid) property.
- By assigning the password to [KeyPassphrase](#keypassphrase-property-pgpreader-class) property. This and the previous method assumes that you anticipate which key you will likely need to use.
- By subscribing to [KeyPassphraseNeeded](#keypassphraseneeded-event-pgpreader-class) event and providing the password from within the event handler. This event will be fired in the middle of the decryption process for each eligible private key for which no valid password was provided using the first two methods. This method lets you provide the password on-the-fly, and is handy when you don't know which key you are going to use in advance.

### Configuring the component

Unprotection configuration if quite straightforward and encompasses adjustment of the following settings:

- Provide the input data via the [InputFile](#inputfile-property-pgpreader-class) (or [InputBytes](#inputbytes-property-pgpreader-class)) property.
- Provide the destination in [OutputFile](#outputfile-property-pgpreader-class). If no output destination is provided, the output will be generated in [OutputBytes](#outputbytes-property-pgpreader-class).
- When processing multi-files PGP archives, consider subscribing to [MultipleFilesFound](#multiplefilesfound-event-pgpreader-class), [FileExtractionStart](#fileextractionstart-event-pgpreader-class) and [FileExtractionFinish](#fileextractionfinish-event-pgpreader-class) events. These come handy in tracking progress and adjusting output locations for individual files.
- Depending on your circumstances, you may want to subscribe to [Signed](#signed-event-pgpreader-class) and [EncryptionInfo](#encryptioninfo-event-pgpreader-class) events to be notified about various protection parameters.

### Unprotecting the file

You are all set now. Call the appropriate unprotection method to proceed with operation:

- [DecryptAndVerify](#decryptandverify-method-pgpreader-class): process the input data by decrypting any protected data, extracting individual files, and verifying signatures. This is the method that you would likely need to use in most cases.
- [VerifyDetached](#verifydetached-method-pgpreader-class): verify a detached signature. Remember that you need to provide the original data separately via the [DataFile](#datafile-property-pgpreader-class) or [DataBytes](#databytes-property-pgpreader-class) properties.

```text
  reader.InputFile = "C:\files\input.pgp";
  reader.OutputFile = "C:\files\output.txt";
  reader.DecryptingKeys = keyring.Keys;
  reader.VerifyingKeys = keyring.Keys;
  reader.KeyPassphrase = "password";
  reader.DecryptAndVerify();
```

## Property List

*The following is the full list of the properties of the class with short descriptions. Click on the links for further details.*

|  |  |
| --- | --- |
| [Armored](#armored-property-pgpreader-class) | Indicates if the processed message had been base64-armored. |
| [Compressed](#compressed-property-pgpreader-class) | Indicates if the processed message had been compressed. |
| [DataBytes](#databytes-property-pgpreader-class) | Use this property to pass the original signed data to class in the byte array form. |
| [DataFile](#datafile-property-pgpreader-class) | The name of the file containing the original signed data. |
| [DataStream](#datastream-property-pgpreader-class) | A stream containing the originally signed data. |
| [DecryptingKeys](#decryptingkeys-property-pgpreader-class) | A collection of keys to be used for decryption. |
| [ExternalCrypto](#externalcrypto-property-pgpreader-class) | Provides access to external signing and DC parameters. |
| [FIPSMode](#fipsmode-property-pgpreader-class) | Reserved. |
| [InputBytes](#inputbytes-property-pgpreader-class) | Use this property to pass the input to class in byte array form. |
| [InputFile](#inputfile-property-pgpreader-class) | Provides a filename of a file to process. |
| [InputStream](#inputstream-property-pgpreader-class) | A stream containing the input to process. |
| [KeyPassphrase](#keypassphrase-property-pgpreader-class) | Specifies a passphrase for the decryption key. |
| [OutputBytes](#outputbytes-property-pgpreader-class) | Use this property to read the output the class object has produced. |
| [OutputFile](#outputfile-property-pgpreader-class) | The file where the encrypted and/or signed data will be saved. |
| [OutputStream](#outputstream-property-pgpreader-class) | The stream where the encrypted and/or signed data will be saved. |
| [Passphrase](#passphrase-property-pgpreader-class) | Specifies a message decryption password. |
| [ProcessedLength](#processedlength-property-pgpreader-class) | Reports the number of bytes processed. |
| [Profile](#profile-property-pgpreader-class) | Specifies a pre-defined profile to apply when creating the signature. |
| [Signatures](#signatures-property-pgpreader-class) | Contains signatures that were included in the protected message. |
| [VerifyingKeys](#verifyingkeys-property-pgpreader-class) | A collection of keys to be used for signature verification. |

## Method List

*The following is the full list of the methods of the class with short descriptions. Click on the links for further details.*

|  |  |
| --- | --- |
| [Config](#config-method-pgpreader-class) | Sets or retrieves a configuration setting. |
| [DecryptAndVerify](#decryptandverify-method-pgpreader-class) | Decrypts and verifies a protected message. |
| [DoAction](#doaction-method-pgpreader-class) | Performs an additional action. |
| [Reset](#reset-method-pgpreader-class) | Resets the class settings. |
| [VerifyDetached](#verifydetached-method-pgpreader-class) | Verifies a detached signature. |

## Event List

*The following is the full list of the events fired by the class with short descriptions. Click on the links for further details.*

|  |  |
| --- | --- |
| [EncryptionInfo](#encryptioninfo-event-pgpreader-class) | Reports early information on encryption parameters. |
| [Error](#error-event-pgpreader-class) | Information about errors during PGP decryption/verification. |
| [ExternalDecrypt](#externaldecrypt-event-pgpreader-class) | Handles remote or external decryption. |
| [FileExtractionFinish](#fileextractionfinish-event-pgpreader-class) | Reports the ending of file extraction process. |
| [FileExtractionStart](#fileextractionstart-event-pgpreader-class) | Reports the beginning of file extraction process. |
| [KeyPassphraseNeeded](#keypassphraseneeded-event-pgpreader-class) | Requests a key protection password from the application. |
| [MultipleFilesFound](#multiplefilesfound-event-pgpreader-class) | Fires if the PGP message is recognized to contain multiple files. |
| [Notification](#notification-event-pgpreader-class) | This event notifies the application about an underlying control flow event. |
| [PassphraseNeeded](#passphraseneeded-event-pgpreader-class) | Requests a data protection password from the application. |
| [Progress](#progress-event-pgpreader-class) | Reports the progress of the decryption operation. |
| [Signed](#signed-event-pgpreader-class) | Notifies the application about a signed message. |

## Config Settings

*The following is a list of config settings for the class with short descriptions. Click on the links for further details.*

|  |  |
| --- | --- |
| [IgnoreDataPacketLengths](#IgnoreDataPacketLengths) | Whether to check the length of input data packets. |
| [PasswordAttempts](#PasswordAttempts) | The number of attempts allowed for entering password. |
| [TempPath](#TempPath) | Path for storing temporary files. |
| [UndefInputLength](#UndefInputLength) | Set this property if you are working with non-seekable streams. |
| [UseGreedyMemoryConsumption](#UseGreedyMemoryConsumption) | Whether to limit memory consumption for the cost of speed. |
| [ASN1UseGlobalTagCache](#ASN1UseGlobalTagCache) | Controls whether ASN.1 module should use a global object cache. |
| [AssignSystemSmartCardPins](#AssignSystemSmartCardPins) | Specifies whether CSP-level PINs should be assigned to CNG keys. |
| [CheckKeyIntegrityBeforeUse](#CheckKeyIntegrityBeforeUse) | Enables or disable private key integrity check before use. |
| [CookieCaching](#CookieCaching) | Specifies whether a cookie cache should be used for HTTP(S) transports. |
| [Cookies](#Cookies) | Gets or sets local cookies for the class. |
| [DefDeriveKeyIterations](#DefDeriveKeyIterations) | Specifies the default key derivation algorithm iteration count. |
| [DNSLocalSuffix](#DNSLocalSuffix) | The suffix to assign for TLD names. |
| [EnableClientSideSSLFFDHE](#EnableClientSideSSLFFDHE) | Enables or disables finite field DHE key exchange support in TLS clients. |
| [EnableSSHMLKEM](#EnableSSHMLKEM) | Enables support for ML-KEM/hybrid key exchange algorithms in SSH client and server classes. |
| [EnableTLSMLKEM](#EnableTLSMLKEM) | Enables support for ML-KEM and hybrid groups in TLS client and server classes. |
| [GlobalCookies](#GlobalCookies) | Gets or sets global cookies for all the HTTP transports. |
| [HardwareCryptoUsePolicy](#HardwareCryptoUsePolicy) | The hardware crypto usage policy. |
| [HttpUserAgent](#HttpUserAgent) | Specifies the user agent name to be used by all HTTP clients. |
| [HttpVersion](#HttpVersion) | The HTTP version to use in any inner HTTP client classes created. |
| [IgnoreExpiredMSCTLSigningCert](#IgnoreExpiredMSCTLSigningCert) | Whether to tolerate the expired Windows Update signing certificate. |
| [ListDelimiter](#ListDelimiter) | The delimiter character for multi-element lists. |
| [LogDestination](#LogDestination) | Specifies the debug log destination. |
| [LogDetails](#LogDetails) | Specifies the debug log details to dump. |
| [LogFile](#LogFile) | Specifies the debug log filename. |
| [LogFilters](#LogFilters) | Specifies the debug log filters. |
| [LogFlushMode](#LogFlushMode) | Specifies the log flush mode. |
| [LogLevel](#LogLevel) | Specifies the debug log level. |
| [LogMaxEventCount](#LogMaxEventCount) | Specifies the maximum number of events to cache before further action is taken. |
| [LogRotationMode](#LogRotationMode) | Specifies the log rotation mode. |
| [MaxASN1BufferLength](#MaxASN1BufferLength) | Specifies the maximal allowed length for ASN.1 primitive tag data. |
| [MaxASN1TreeDepth](#MaxASN1TreeDepth) | Specifies the maximal depth for processed ASN.1 trees. |
| [OCSPHashAlgorithm](#OCSPHashAlgorithm) | Specifies the hash algorithm to be used to identify certificates in OCSP requests. |
| [OldClientSideRSAFallback](#OldClientSideRSAFallback) | Specifies whether the SSH client should use a SHA1 fallback. |
| [PKICache](#PKICache) | Specifies which PKI elements (certificates, CRLs, OCSP responses) should be cached. |
| [PKICachePath](#PKICachePath) | Specifies the file system path where cached PKI data is stored. |
| [ProductVersion](#ProductVersion) | Returns the version of the SecureBlackbox library. |
| [ServerSSLDHKeyLength](#ServerSSLDHKeyLength) | Sets the size of the TLS DHE key exchange group. |
| [StaticDNS](#StaticDNS) | Specifies whether static DNS rules should be used. |
| [StaticIPAddress\[domain\]](#StaticIPAddress[domain]) | Gets or sets an IP address for the specified domain name. |
| [StaticIPAddresses](#StaticIPAddresses) | Gets or sets all the static DNS rules. |
| [Tag](#Tag) | Allows to store any custom data. |
| [TLSSessionGroup](#TLSSessionGroup) | Specifies the group name of TLS sessions to be used for session resumption. |
| [TLSSessionLifetime](#TLSSessionLifetime) | Specifies lifetime in seconds of the cached TLS session. |
| [TLSSessionPurgeInterval](#TLSSessionPurgeInterval) | Specifies how often the session cache should remove the expired TLS sessions. |
| [UseCRLObjectCaching](#UseCRLObjectCaching) | Specifies whether reuse of loaded CRL objects is enabled. |
| [UseInternalRandom](#UseInternalRandom) | Switches between SecureBlackbox-own and platform PRNGs. |
| [UseLegacyAdESValidation](#UseLegacyAdESValidation) | Enables legacy AdES validation mode. |
| [UseOCSPResponseObjectCaching](#UseOCSPResponseObjectCaching) | Specifies whether reuse of loaded OCSP response objects is enabled. |
| [UseOwnDNSResolver](#UseOwnDNSResolver) | Specifies whether the client classes should use own DNS resolver. |
| [UseSharedSystemStorages](#UseSharedSystemStorages) | Specifies whether the validation engine should use a global per-process copy of the system certificate stores. |
| [UseSystemNativeSizeCalculation](#UseSystemNativeSizeCalculation) | An internal CryptoAPI access tweak. |
| [UseSystemOAEPAndPSS](#UseSystemOAEPAndPSS) | Enforces or disables the use of system-driven RSA OAEP and PSS computations. |
| [UseSystemRandom](#UseSystemRandom) | Enables or disables the use of the OS PRNG. |
| [XMLRDNDescriptorName\[OID\]](#XMLRDNDescriptorName[OID]) | Defines an OID mapping to descriptor names for the certificate's IssuerRDN or SubjectRDN. |
| [XMLRDNDescriptorPriority\[OID\]](#XMLRDNDescriptorPriority[OID]) | Specifies the priority of descriptor names associated with a specific OID. |
| [XMLRDNDescriptorReverseOrder](#XMLRDNDescriptorReverseOrder) | Specifies whether to reverse the order of descriptors in RDN. |
| [XMLRDNDescriptorSeparator](#XMLRDNDescriptorSeparator) | Specifies the separator used between descriptors in RDN. |

# Armored Property ([PGPReader](#pgpreader-class) Class)

Indicates if the processed message had been base64-armored.

## Syntax

```text
public boolean isArmored();
```

## Default Value

False

## Remarks

This property is set to true if the supplied message was armored by encoding it into base64 and adding BEGIN and END brackets.

This property is read-only and not available at design time.

# Compressed Property ([PGPReader](#pgpreader-class) Class)

Indicates if the processed message had been compressed.

## Syntax

```text
public boolean isCompressed();
```

## Default Value

False

## Remarks

This property is set to true if the supplied message was compressed by its creator.

This property is read-only and not available at design time.

# DataBytes Property ([PGPReader](#pgpreader-class) Class)

Use this property to pass the original signed data to class in the byte array form.

## Syntax

```text
public byte[] getDataBytes();
public void setDataBytes(byte[] dataBytes);
```

## Remarks

When validating detached signatures, assign a byte array containing the signed data to this property.

This property is not available at design time.

# DataFile Property ([PGPReader](#pgpreader-class) Class)

The name of the file containing the original signed data.

## Syntax

```text
public String getDataFile();
public void setDataFile(String dataFile);
```

## Default Value

""

## Remarks

Use this property to provide the original data when validating detached signatures with [VerifyDetached](#verifydetached-method-pgpreader-class).

# DataStream Property ([PGPReader](#pgpreader-class) Class)

A stream containing the originally signed data.

## Syntax

```text
public java.io.InputStream getDataStream();
public void setDataStream(java.io.InputStream dataStream);
```

## Default Value

null

## Remarks

Use this property to provide the original data when validating detached signatures with [VerifyDetached](#verifydetached-method-pgpreader-class).

This property is not available at design time.

# DecryptingKeys Property ([PGPReader](#pgpreader-class) Class)

A collection of keys to be used for decryption.

## Syntax

```text
public PGPKeyList getDecryptingKeys();
```

## Remarks

Use this property to provide decryption keys. Note that only secret keys can decrypt.

In most cases you will also need to supply a passphrase for the chosen decryption key. Use this by subscribing to [KeyPassphraseNeeded](#keypassphraseneeded-event-pgpreader-class) event, setting the control's [KeyPassphrase](#keypassphrase-property-pgpreader-class) property, or setting the *Passphrase* property of the relevant key object.

This property is not available at design time.

 Please refer to the [PGPKey](#pgpkey-type) type for a complete list of fields.

# ExternalCrypto Property ([PGPReader](#pgpreader-class) Class)

Provides access to external signing and DC parameters.

## Syntax

```text
public ExternalCrypto getExternalCrypto();
```

## Remarks

Use this property to tune-up remote cryptography settings. SecureBlackbox supports two independent types of external cryptography: synchronous (based on the ExternalSign event) and asynchronous (based on the DC protocol and the DCAuth signing component).

This property is read-only.

 Please refer to the [ExternalCrypto](#externalcrypto-type) type for a complete list of fields.

# FIPSMode Property ([PGPReader](#pgpreader-class) Class)

Reserved.

## Syntax

```text
public boolean isFIPSMode();
public void setFIPSMode(boolean FIPSMode);
```

## Default Value

False

## Remarks

This property is reserved for future use.

# InputBytes Property ([PGPReader](#pgpreader-class) Class)

Use this property to pass the input to class in byte array form.

## Syntax

```text
public byte[] getInputBytes();
public void setInputBytes(byte[] inputBytes);
```

## Remarks

Assign a byte array containing the data to be processed to this property.

This property is not available at design time.

# InputFile Property ([PGPReader](#pgpreader-class) Class)

Provides a filename of a file to process.

## Syntax

```text
public String getInputFile();
public void setInputFile(String inputFile);
```

## Default Value

""

## Remarks

Use this property to provide a path to the file to be encrypted and/or signed.

# InputStream Property ([PGPReader](#pgpreader-class) Class)

A stream containing the input to process.

## Syntax

```text
public java.io.InputStream getInputStream();
public void setInputStream(java.io.InputStream inputStream);
```

## Default Value

null

## Remarks

Use this property to feed the input data to the component from a stream object.

This property is not available at design time.

# KeyPassphrase Property ([PGPReader](#pgpreader-class) Class)

Specifies a passphrase for the decryption key.

## Syntax

```text
public String getKeyPassphrase();
public void setKeyPassphrase(String keyPassphrase);
```

## Default Value

""

## Remarks

Use this property to provide a passphrase for the decryption secret key.

If this property is left empty or a wrong passphrase is provided, the [KeyPassphraseNeeded](#keypassphraseneeded-event-pgpreader-class) event will be fired to request the correct passphrase.

# OutputBytes Property ([PGPReader](#pgpreader-class) Class)

Use this property to read the output the class object has produced.

## Syntax

```text
public byte[] getOutputBytes();
```

## Remarks

Read the contents of this property after the operation has completed to read the produced output. This property will only be set if the [OutputFile](#outputfile-property-pgpreader-class) and [OutputStream](#outputstream-property-pgpreader-class) properties had not been assigned.

This property is read-only and not available at design time.

# OutputFile Property ([PGPReader](#pgpreader-class) Class)

The file where the encrypted and/or signed data will be saved.

## Syntax

```text
public String getOutputFile();
public void setOutputFile(String outputFile);
```

## Default Value

""

## Remarks

Use this property to provide a path to the file where the class should store the encrypted and/or signed data.

# OutputStream Property ([PGPReader](#pgpreader-class) Class)

The stream where the encrypted and/or signed data will be saved.

## Syntax

```text
public java.io.OutputStream getOutputStream();
public void setOutputStream(java.io.OutputStream outputStream);
```

## Default Value

null

## Remarks

Use this property to specify the stream to take the resulting encrypted and/or signed data.

This property is not available at design time.

# Passphrase Property ([PGPReader](#pgpreader-class) Class)

Specifies a message decryption password.

## Syntax

```text
public String getPassphrase();
public void setPassphrase(String passphrase);
```

## Default Value

""

## Remarks

Use this property to provide a password to decrypt the data. Whether the message can be decrypted with a password is indicated by *PassphraseUsed* parameter of [EncryptionInfo](#encryptioninfo-event-pgpreader-class) event.

Note that this is not the same as a secret key passphrase, which should be provided via [KeyPassphrase](#keypassphrase-property-pgpreader-class) property.

If this property is left empty or the assigned passphrase is incorrect, the [PassphraseNeeded](#passphraseneeded-event-pgpreader-class) event will be fired to request the correct one.

# ProcessedLength Property ([PGPReader](#pgpreader-class) Class)

Reports the number of bytes processed.

## Syntax

```text
public long getProcessedLength();
```

## Default Value

0

## Remarks

Use this property to check the number of bytes that the component has read when processing the protected message.

This property is read-only and not available at design time.

# Profile Property ([PGPReader](#pgpreader-class) Class)

Specifies a pre-defined profile to apply when creating the signature.

## Syntax

```text
public String getProfile();
public void setProfile(String profile);
```

## Default Value

""

## Remarks

Advanced signatures come in many variants, which are often defined by parties that needs to process them or by local standards. SecureBlackbox profiles are sets of pre-defined configurations which correspond to particular signature variants. By specifying a profile, you are pre-configuring the component to make it produce the signature that matches the configuration corresponding to that profile.

# Signatures Property ([PGPReader](#pgpreader-class) Class)

Contains signatures that were included in the protected message.

## Syntax

```text
public PGPSignatureList getSignatures();
```

## Remarks

Use this property to access the details of the signatures included in the processed message.

This property is read-only and not available at design time.

 Please refer to the [PGPSignature](#pgpsignature-type) type for a complete list of fields.

# VerifyingKeys Property ([PGPReader](#pgpreader-class) Class)

A collection of keys to be used for signature verification.

## Syntax

```text
public PGPKeyList getVerifyingKeys();
```

## Remarks

Use this property to provide verifying keys.

You will need an appropriate key to verify every signature included in the message. Use [Signed](#signed-event-pgpreader-class) event to get informed about the keys that were used for signing.

This property is not available at design time.

 Please refer to the [PGPKey](#pgpkey-type) type for a complete list of fields.

# Config Method ([PGPReader](#pgpreader-class) Class)

Sets or retrieves a configuration setting.

## Syntax

```text
public String config(String configurationString);
```

## Remarks

Config is a generic method available in every class. It is used to set and retrieve [configuration settings](#config-settings-pgpreader-class) for the class.

These settings are similar in functionality to properties, but they are rarely used. In order to avoid "polluting" the property namespace of the class, access to these *internal properties* is provided through the Config method.

To set a configuration setting named *PROPERTY*, you must call *Config("PROPERTY=VALUE")*, where *VALUE* is the value of the setting expressed as a string. For boolean values, use the strings "True", "False", "0", "1", "Yes", or "No" (case does not matter).

To read (query) the value of a [configuration setting](#config-settings-pgpreader-class), you must call *Config("PROPERTY")*. The value will be returned as a string.

# DecryptAndVerify Method ([PGPReader](#pgpreader-class) Class)

Decrypts and verifies a protected message.

## Syntax

```text
public void decryptAndVerify();
```

## Remarks

Use this method to unprotect a PGP message contained in a byte array ([InputBytes](#inputbytes-property-pgpreader-class)), in a file ([InputFile](#inputfile-property-pgpreader-class)) or in a stream ([InputStream](#inputstream-property-pgpreader-class)). The method writes the decrypted message to a byte array ([OutputBytes](#outputbytes-property-pgpreader-class)), to a file ([OutputFile](#outputfile-property-pgpreader-class)) or to a stream ([OutputStream](#outputstream-property-pgpreader-class)).

# DoAction Method ([PGPReader](#pgpreader-class) Class)

Performs an additional action.

## Syntax

```text
public String doAction(String actionID, String actionParams);
```

## Remarks

DoAction is a generic method available in every class. It is used to perform an additional action introduced after the product major release. The list of actions is not fixed, and may be flexibly extended over time.

The unique identifier (case insensitive) of the action is provided in the *ActionID* parameter.

*ActionParams* contains the value of a single parameter, or a list of multiple parameters for the action in the form of *PARAM1=VALUE1;PARAM2=VALUE2;...*.

Common ActionIDs:

|  |  |  |  |
| --- | --- | --- | --- |
| Action | Parameters | Returned value | Description |
| ResetTrustedListCache | none | none | Clears the cached list of trusted lists. |
| ResetCertificateCache | none | none | Clears the cached certificates. |
| ResetCRLCache | none | none | Clears the cached CRLs. |
| ResetOCSPResponseCache | none | none | Clears the cached OCSP responses. |

# Reset Method ([PGPReader](#pgpreader-class) Class)

Resets the class settings.

## Syntax

```text
public void reset();
```

## Remarks

Reset is a generic method available in every class.

# VerifyDetached Method ([PGPReader](#pgpreader-class) Class)

Verifies a detached signature.

## Syntax

```text
public void verifyDetached();
```

## Remarks

Use this method to verify a detached signature contained in a byte array ([DataBytes](#databytes-property-pgpreader-class)), in a file ([DataFile](#datafile-property-pgpreader-class)) or in a stream ([DataStream](#datastream-property-pgpreader-class)) over a message contained in a byte array ([InputBytes](#inputbytes-property-pgpreader-class)), in a file ([InputFile](#inputfile-property-pgpreader-class)) or in a stream ([InputStream](#inputstream-property-pgpreader-class)).

# EncryptionInfo Event ([PGPReader](#pgpreader-class) Class)

Reports early information on encryption parameters.

## Syntax

```text
public class DefaultPGPReaderEventListener implements PGPReaderEventListener {
  ...
  public void encryptionInfo(PGPReaderEncryptionInfoEvent e) {}
  ...
}

public class PGPReaderEncryptionInfoEvent {
  public String keyIDs;
  public int encryptedProtection;
  public boolean passphraseUsed;
}
```

## Remarks

The class fires this event to report early encryption information. Use this event to find out what encryption type is used, and to provide appropriate decryption material (the secret keys or the password) via [DecryptingKeys](#decryptingkeys-property-pgpreader-class) or [Passphrase](#passphrase-property-pgpreader-class) properties.

*KeyIDs* contains the IDs of the keys that can be used to decrypt the data. *PassphraseUsed* shows if the message can also be decrypted with a passphrase. Both can be set at the same time, indicating that each of the decryption routes can be taken.

*EncryptedProtection* parameter specifies whether the message includes a modification detection record.

# Error Event ([PGPReader](#pgpreader-class) Class)

Information about errors during PGP decryption/verification.

## Syntax

```text
public class DefaultPGPReaderEventListener implements PGPReaderEventListener {
  ...
  public void error(PGPReaderErrorEvent e) {}
  ...
}

public class PGPReaderErrorEvent {
  public int errorCode;
  public String description;
}
```

## Remarks

The event is fired in case of exceptional conditions during decryption/verification of protected data.

*ErrorCode* contains an error code and *Description* contains a textual description of the error.

# ExternalDecrypt Event ([PGPReader](#pgpreader-class) Class)

Handles remote or external decryption.

## Syntax

```text
public class DefaultPGPReaderEventListener implements PGPReaderEventListener {
  ...
  public void externalDecrypt(PGPReaderExternalDecryptEvent e) {}
  ...
}

public class PGPReaderExternalDecryptEvent {
  public String operationId;
  public String algorithm;
  public String pars;
  public String encryptedData;
  public String data; //read-write
}
```

## Remarks

Assign a handler to this event if you need to delegate a low-level decryption operation to an external, remote, or custom decryption engine. The handler receives an encrypted value in the *EncryptedData* parameter, and is expected to decrypt it and place the decrypted value into the *Data* parameter.

*OperationId* provides a comment about the operation and its origin. It depends on the exact class being used, and may be empty. *Algorithm* specifies the encryption algorithm being used, and *Pars* contains algorithm-dependent parameters.

The class uses base16 (hex) encoding for the *EncryptedData*, *Data*, and *Pars* parameters. If your decryption engine uses a different input and output encoding, you may need to decode and/or encode the data before and/or after the decryption.

Sample data encoded in base16: a0dee2a0382afbb09120ffa7ccd8a152 - lower case base16 A0DEE2A0382AFBB09120FFA7CCD8A152 - upper case base16

# FileExtractionFinish Event ([PGPReader](#pgpreader-class) Class)

Reports the ending of file extraction process.

## Syntax

```text
public class DefaultPGPReaderEventListener implements PGPReaderEventListener {
  ...
  public void fileExtractionFinish(PGPReaderFileExtractionFinishEvent e) {}
  ...
}

public class PGPReaderFileExtractionFinishEvent {
  public String fileName;
  public String timestamp;
}
```

## Remarks

This event informs about the ending of extraction of the next available file. *FileName* parameter indicates the original file name, and the Timestamp its last modification time.

In the handler, the user can take away the output stream or store the file data from [OutputBytes](#outputbytes-property-pgpreader-class).

# FileExtractionStart Event ([PGPReader](#pgpreader-class) Class)

Reports the beginning of file extraction process.

## Syntax

```text
public class DefaultPGPReaderEventListener implements PGPReaderEventListener {
  ...
  public void fileExtractionStart(PGPReaderFileExtractionStartEvent e) {}
  ...
}

public class PGPReaderFileExtractionStartEvent {
  public String fileName;
  public String timestamp;
  public boolean skip; //read-write
}
```

## Remarks

This event informs about the beginning of extraction of the next available file. A PGP message may contain more than one file. *FileName* parameter indicates the original file name, and the Timestamp its last modification time.

The user should provide an output filename in [OutputFile](#outputfile-property-pgpreader-class) or a stream in [OutputStream](#outputstream-property-pgpreader-class). If none of them is provided, the extracted file will be placed to [OutputBytes](#outputbytes-property-pgpreader-class). After the file is extracted, [FileExtractionFinish](#fileextractionfinish-event-pgpreader-class) event is fired.

# KeyPassphraseNeeded Event ([PGPReader](#pgpreader-class) Class)

Requests a key protection password from the application.

## Syntax

```text
public class DefaultPGPReaderEventListener implements PGPReaderEventListener {
  ...
  public void keyPassphraseNeeded(PGPReaderKeyPassphraseNeededEvent e) {}
  ...
}

public class PGPReaderKeyPassphraseNeededEvent {
  public String keyID;
  public String userID;
  public boolean mainKey;
  public String passphrase; //read-write
  public boolean skip; //read-write
}
```

## Remarks

The class fires this event to request a secret key passphrase from the application. Note that this event asks for a key protection passphrase rather than a message protection passphrase (which is requested via [PassphraseNeeded](#passphraseneeded-event-pgpreader-class)). The class fires it when it has found a suitable decryption secret key in the keyring, and attempts to use it to decrypt the data.

If the data is encrypted with multiple keys, this event is called for each key in a loop until the password for at least one key is provided correctly. *KeyID* specifies the key for which the password is requested, and *UserID* identifies its user. *MainKey* tells whether the key is a master key or a subkey.

The handler should provide password via the *Passphrase* parameter, or set *Skip* to True to skip this key.

For each key *KeyPassphraseNeeded* is called in a loop until the correct password is provided or the maximum number of password attempts reached.

# MultipleFilesFound Event ([PGPReader](#pgpreader-class) Class)

Fires if the PGP message is recognized to contain multiple files.

## Syntax

```text
public class DefaultPGPReaderEventListener implements PGPReaderEventListener {
  ...
  public void multipleFilesFound(PGPReaderMultipleFilesFoundEvent e) {}
  ...
}

public class PGPReaderMultipleFilesFoundEvent {
  public String tarFileName;
  public boolean proceed; //read-write
}
```

## Remarks

The class fires this event to report that there is more than one file in the PGP message.

The *TarFileName* specifies the name of the TAR file containing the files. Tune up *Proceed* to go ahead or stop the processing.

# Notification Event ([PGPReader](#pgpreader-class) Class)

This event notifies the application about an underlying control flow event.

## Syntax

```text
public class DefaultPGPReaderEventListener implements PGPReaderEventListener {
  ...
  public void notification(PGPReaderNotificationEvent e) {}
  ...
}

public class PGPReaderNotificationEvent {
  public String eventID;
  public String eventParam;
}
```

## Remarks

The class fires this event to let the application know about some event, occurrence, or milestone in the class. For example, it may fire to report completion of the document processing. The list of events being reported is not fixed, and may be flexibly extended over time.

The unique identifier of the event is provided in the *EventID* parameter. *EventParam* contains any parameters accompanying the occurrence. Depending on the type of the class, the exact action it is performing, or the document being processed, one or both may be omitted.

# PassphraseNeeded Event ([PGPReader](#pgpreader-class) Class)

Requests a data protection password from the application.

## Syntax

```text
public class DefaultPGPReaderEventListener implements PGPReaderEventListener {
  ...
  public void passphraseNeeded(PGPReaderPassphraseNeededEvent e) {}
  ...
}

public class PGPReaderPassphraseNeededEvent {
  public String passphrase; //read-write
  public boolean skip; //read-write
}
```

## Remarks

The class fires this event to request a decryption password. It is only fired if the data can be decrypted without a key.

The event is fired in a loop until the correct password is passed or the number of password attempts is exceeded.

# Progress Event ([PGPReader](#pgpreader-class) Class)

Reports the progress of the decryption operation.

## Syntax

```text
public class DefaultPGPReaderEventListener implements PGPReaderEventListener {
  ...
  public void progress(PGPReaderProgressEvent e) {}
  ...
}

public class PGPReaderProgressEvent {
  public long current;
  public long total;
  public boolean cancel; //read-write
}
```

## Remarks

The class fires this event repeatedly to report the progress of the file extraction operation.

*Current* indicates the amount of processed data in bytes, and *Total* is the total number of bytes to be processed. Use *Cancel* to terminate the extraction process.

# Signed Event ([PGPReader](#pgpreader-class) Class)

Notifies the application about a signed message.

## Syntax

```text
public class DefaultPGPReaderEventListener implements PGPReaderEventListener {
  ...
  public void signed(PGPReaderSignedEvent e) {}
  ...
}

public class PGPReaderSignedEvent {
  public String keyIDs;
  public int signatureType;
}
```

## Remarks

The class fires this event when it identifies a signed message to allow the application to prepare the component for verification.

Use the *KeyIDs* parameter to identify keys used that were used to sign the message, and make sure they are available in the [VerifyingKeys](#verifyingkeys-property-pgpreader-class) list.

*SignatureType* indicates the signature type:

|  |  |  |
| --- | --- | --- |
| pstNormal | 0 | A traditional signature, compatible (algorithm permitting) with PGP 2.6.x |
| pstOnePass | 1 | A newer one-pass signature |
| pstDetached | 2 | A detached signature, i.e., a signature contained in a separate file from the data it covers |
| pstCleartext | 3 | A signature made over textual data and appended to it |

# ExternalCrypto Type

Specifies the parameters of external cryptographic calls.

## Remarks

External cryptocalls are used in a Distributed Cryptography (DC) subsystem, which allows the delegation of security operations to the remote agent. For instance, it can be used to compute the signature value on the server, while retaining the client's private key locally.

The following fields are available:

- [AsyncDocumentID](#ExternalCrypto_f_AsyncDocumentID)

- [CustomParams](#ExternalCrypto_f_CustomParams)

- [Data](#ExternalCrypto_f_Data)

- [ExternalHashCalculation](#ExternalCrypto_f_ExternalHashCalculation)

- [HashAlgorithm](#ExternalCrypto_f_HashAlgorithm)

- [KeyID](#ExternalCrypto_f_KeyID)

- [KeySecret](#ExternalCrypto_f_KeySecret)

- [Method](#ExternalCrypto_f_Method)

- [Mode](#ExternalCrypto_f_Mode)

- [PublicKeyAlgorithm](#ExternalCrypto_f_PublicKeyAlgorithm)

## Fields

 **AsyncDocumentID** *String*
*Default Value: ""*

Specifies an optional document ID for SignAsyncBegin() and SignAsyncEnd() calls.

Use this property when working with multi-signature DCAuth requests and responses to uniquely identify documents signed within a larger batch. On the completion stage, this value helps the signing component identify the correct signature in the returned batch of responses.

If using batched requests, make sure to set this property to the same value on both the pre-signing (SignAsyncBegin) and completion (SignAsyncEnd) stages.

 **CustomParams** *String*
*Default Value: ""*

Custom parameters to be passed to the signing service (uninterpreted).

 **Data** *String*
*Default Value: ""*

Additional data to be included in the async state and mirrored back by the requestor.

 **ExternalHashCalculation** *boolean*
*Default Value: False*

Specifies whether the message hash is to be calculated at the external endpoint. Please note that this mode is not supported by the DCAuth class.

If set to true, the class will pass a few kilobytes of to-be-signed data from the document to the OnExternalSign event. This only applies when SignExternal() is called.

 **HashAlgorithm** *String*
*Default Value: "SHA256"*

Specifies the request's signature hash algorithm.

|  |  |  |
| --- | --- | --- |
| SB_HASH_ALGORITHM_SHA1 | SHA1 |  |
| SB_HASH_ALGORITHM_SHA224 | SHA224 |  |
| SB_HASH_ALGORITHM_SHA256 | SHA256 |  |
| SB_HASH_ALGORITHM_SHA384 | SHA384 |  |
| SB_HASH_ALGORITHM_SHA512 | SHA512 |  |
| SB_HASH_ALGORITHM_MD2 | MD2 |  |
| SB_HASH_ALGORITHM_MD4 | MD4 |  |
| SB_HASH_ALGORITHM_MD5 | MD5 |  |
| SB_HASH_ALGORITHM_RIPEMD160 | RIPEMD160 |  |
| SB_HASH_ALGORITHM_CRC32 | CRC32 |  |
| SB_HASH_ALGORITHM_SSL3 | SSL3 |  |
| SB_HASH_ALGORITHM_GOST_R3411_1994 | GOST1994 |  |
| SB_HASH_ALGORITHM_WHIRLPOOL | WHIRLPOOL |  |
| SB_HASH_ALGORITHM_POLY1305 | POLY1305 |  |
| SB_HASH_ALGORITHM_SHA3_224 | SHA3_224 |  |
| SB_HASH_ALGORITHM_SHA3_256 | SHA3_256 |  |
| SB_HASH_ALGORITHM_SHA3_384 | SHA3_384 |  |
| SB_HASH_ALGORITHM_SHA3_512 | SHA3_512 |  |
| SB_HASH_ALGORITHM_BLAKE2S_128 | BLAKE2S_128 |  |
| SB_HASH_ALGORITHM_BLAKE2S_160 | BLAKE2S_160 |  |
| SB_HASH_ALGORITHM_BLAKE2S_224 | BLAKE2S_224 |  |
| SB_HASH_ALGORITHM_BLAKE2S_256 | BLAKE2S_256 |  |
| SB_HASH_ALGORITHM_BLAKE2B_160 | BLAKE2B_160 |  |
| SB_HASH_ALGORITHM_BLAKE2B_256 | BLAKE2B_256 |  |
| SB_HASH_ALGORITHM_BLAKE2B_384 | BLAKE2B_384 |  |
| SB_HASH_ALGORITHM_BLAKE2B_512 | BLAKE2B_512 |  |
| SB_HASH_ALGORITHM_SHAKE_128 | SHAKE_128 |  |
| SB_HASH_ALGORITHM_SHAKE_256 | SHAKE_256 |  |
| SB_HASH_ALGORITHM_SHAKE_128_LEN | SHAKE_128_LEN |  |
| SB_HASH_ALGORITHM_SHAKE_256_LEN | SHAKE_256_LEN |  |

 **KeyID** *String*
*Default Value: ""*

The ID of the pre-shared key used for DC request authentication.

Asynchronous DCAuth-driven communication requires that parties authenticate each other with a secret pre-shared cryptographic key. This provides an extra protection layer for the protocol and diminishes the risk of the private key becoming abused by foreign parties. Use this property to provide the pre-shared key identifier, and use [KeySecret](#ExternalCrypto_f_KeySecret) to pass the key itself.

The same KeyID/KeySecret pair should be used on the DCAuth side for the signing requests to be accepted.

Note: The KeyID/KeySecret scheme is very similar to the AuthKey scheme used in various Cloud service providers to authenticate users.

Example:

```text
  signer.ExternalCrypto.KeyID = "MainSigningKey";
  signer.ExternalCrypto.KeySecret = "abcdef0123456789";
```

 **KeySecret** *String*
*Default Value: ""*

The pre-shared key used for DC request authentication. This key must be set and match the key used by the DCAuth counterpart for the scheme to work.

Read more about configuring authentication in the [KeyID](#ExternalCrypto_f_KeyID) topic.

 **Method** *int*
*Default Value: 0*

Specifies the asynchronous signing method. This is typically defined by the DC server capabilities and setup.

Available options:

|  |  |
| --- | --- |
| asmdPKCS1 | 0 |
| asmdPKCS7 | 1 |

 **Mode** *int*
*Default Value: 0*

Specifies the external cryptography mode.

Available options:

|  |  |
| --- | --- |
| ecmDefault | The default value (0) |
| ecmDisabled | Do not use DC or external signing (1) |
| ecmGeneric | Generic external signing with the OnExternalSign event (2) |
| ecmDCAuth | DCAuth signing (3) |
| ecmDCAuthJSON | DCAuth signing in JSON format (4) |

 **PublicKeyAlgorithm** *String*
*Default Value: ""*

Provide the public key algorithm here if the certificate is not available on the pre-signing stage.

|  |  |  |
| --- | --- | --- |
| SB_CERT_ALGORITHM_ID_RSA_ENCRYPTION | rsaEncryption |  |
| SB_CERT_ALGORITHM_MD2_RSA_ENCRYPTION | md2withRSAEncryption |  |
| SB_CERT_ALGORITHM_MD5_RSA_ENCRYPTION | md5withRSAEncryption |  |
| SB_CERT_ALGORITHM_SHA1_RSA_ENCRYPTION | sha1withRSAEncryption |  |
| SB_CERT_ALGORITHM_ID_DSA | id-dsa |  |
| SB_CERT_ALGORITHM_ID_DSA_SHA1 | id-dsa-with-sha1 |  |
| SB_CERT_ALGORITHM_DH_PUBLIC | dhpublicnumber |  |
| SB_CERT_ALGORITHM_SHA224_RSA_ENCRYPTION | sha224WithRSAEncryption |  |
| SB_CERT_ALGORITHM_SHA256_RSA_ENCRYPTION | sha256WithRSAEncryption |  |
| SB_CERT_ALGORITHM_SHA384_RSA_ENCRYPTION | sha384WithRSAEncryption |  |
| SB_CERT_ALGORITHM_SHA512_RSA_ENCRYPTION | sha512WithRSAEncryption |  |
| SB_CERT_ALGORITHM_ID_RSAPSS | id-RSASSA-PSS |  |
| SB_CERT_ALGORITHM_ID_RSAOAEP | id-RSAES-OAEP |  |
| SB_CERT_ALGORITHM_RSASIGNATURE_RIPEMD160 | ripemd160withRSA |  |
| SB_CERT_ALGORITHM_ID_ELGAMAL | elGamal |  |
| SB_CERT_ALGORITHM_SHA1_ECDSA | ecdsa-with-SHA1 |  |
| SB_CERT_ALGORITHM_RECOMMENDED_ECDSA | ecdsa-recommended |  |
| SB_CERT_ALGORITHM_SHA224_ECDSA | ecdsa-with-SHA224 |  |
| SB_CERT_ALGORITHM_SHA256_ECDSA | ecdsa-with-SHA256 |  |
| SB_CERT_ALGORITHM_SHA384_ECDSA | ecdsa-with-SHA384 |  |
| SB_CERT_ALGORITHM_SHA512_ECDSA | ecdsa-with-SHA512 |  |
| SB_CERT_ALGORITHM_EC | id-ecPublicKey |  |
| SB_CERT_ALGORITHM_SPECIFIED_ECDSA | ecdsa-specified |  |
| SB_CERT_ALGORITHM_GOST_R3410_1994 | id-GostR3410-94 |  |
| SB_CERT_ALGORITHM_GOST_R3410_2001 | id-GostR3410-2001 |  |
| SB_CERT_ALGORITHM_GOST_R3411_WITH_R3410_1994 | id-GostR3411-94-with-GostR3410-94 |  |
| SB_CERT_ALGORITHM_GOST_R3411_WITH_R3410_2001 | id-GostR3411-94-with-GostR3410-2001 |  |
| SB_CERT_ALGORITHM_SHA1_ECDSA_PLAIN | ecdsa-plain-SHA1 |  |
| SB_CERT_ALGORITHM_SHA224_ECDSA_PLAIN | ecdsa-plain-SHA224 |  |
| SB_CERT_ALGORITHM_SHA256_ECDSA_PLAIN | ecdsa-plain-SHA256 |  |
| SB_CERT_ALGORITHM_SHA384_ECDSA_PLAIN | ecdsa-plain-SHA384 |  |
| SB_CERT_ALGORITHM_SHA512_ECDSA_PLAIN | ecdsa-plain-SHA512 |  |
| SB_CERT_ALGORITHM_RIPEMD160_ECDSA_PLAIN | ecdsa-plain-RIPEMD160 |  |
| SB_CERT_ALGORITHM_WHIRLPOOL_RSA_ENCRYPTION | whirlpoolWithRSAEncryption |  |
| SB_CERT_ALGORITHM_ID_DSA_SHA224 | id-dsa-with-sha224 |  |
| SB_CERT_ALGORITHM_ID_DSA_SHA256 | id-dsa-with-sha256 |  |
| SB_CERT_ALGORITHM_SHA3_224_RSA_ENCRYPTION | id-rsassa-pkcs1-v1_5-with-sha3-224 |  |
| SB_CERT_ALGORITHM_SHA3_256_RSA_ENCRYPTION | id-rsassa-pkcs1-v1_5-with-sha3-256 |  |
| SB_CERT_ALGORITHM_SHA3_384_RSA_ENCRYPTION | id-rsassa-pkcs1-v1_5-with-sha3-384 |  |
| SB_CERT_ALGORITHM_SHA3_512_RSA_ENCRYPTION | id-rsassa-pkcs1-v1_5-with-sha3-512 |  |
| SB_CERT_ALGORITHM_SHA3_224_ECDSA | id-ecdsa-with-sha3-224 |  |
| SB_CERT_ALGORITHM_SHA3_256_ECDSA | id-ecdsa-with-sha3-256 |  |
| SB_CERT_ALGORITHM_SHA3_384_ECDSA | id-ecdsa-with-sha3-384 |  |
| SB_CERT_ALGORITHM_SHA3_512_ECDSA | id-ecdsa-with-sha3-512 |  |
| SB_CERT_ALGORITHM_SHA3_224_ECDSA_PLAIN | id-ecdsa-plain-with-sha3-224 |  |
| SB_CERT_ALGORITHM_SHA3_256_ECDSA_PLAIN | id-ecdsa-plain-with-sha3-256 |  |
| SB_CERT_ALGORITHM_SHA3_384_ECDSA_PLAIN | id-ecdsa-plain-with-sha3-384 |  |
| SB_CERT_ALGORITHM_SHA3_512_ECDSA_PLAIN | id-ecdsa-plain-with-sha3-512 |  |
| SB_CERT_ALGORITHM_ID_DSA_SHA3_224 | id-dsa-with-sha3-224 |  |
| SB_CERT_ALGORITHM_ID_DSA_SHA3_256 | id-dsa-with-sha3-256 |  |
| SB_CERT_ALGORITHM_BLAKE2S_128_RSA_ENCRYPTION | id-rsassa-pkcs1-v1_5-with-blake2s128 |  |
| SB_CERT_ALGORITHM_BLAKE2S_160_RSA_ENCRYPTION | id-rsassa-pkcs1-v1_5-with-blake2s160 |  |
| SB_CERT_ALGORITHM_BLAKE2S_224_RSA_ENCRYPTION | id-rsassa-pkcs1-v1_5-with-blake2s224 |  |
| SB_CERT_ALGORITHM_BLAKE2S_256_RSA_ENCRYPTION | id-rsassa-pkcs1-v1_5-with-blake2s256 |  |
| SB_CERT_ALGORITHM_BLAKE2B_160_RSA_ENCRYPTION | id-rsassa-pkcs1-v1_5-with-blake2b160 |  |
| SB_CERT_ALGORITHM_BLAKE2B_256_RSA_ENCRYPTION | id-rsassa-pkcs1-v1_5-with-blake2b256 |  |
| SB_CERT_ALGORITHM_BLAKE2B_384_RSA_ENCRYPTION | id-rsassa-pkcs1-v1_5-with-blake2b384 |  |
| SB_CERT_ALGORITHM_BLAKE2B_512_RSA_ENCRYPTION | id-rsassa-pkcs1-v1_5-with-blake2b512 |  |
| SB_CERT_ALGORITHM_BLAKE2S_128_ECDSA | id-ecdsa-with-blake2s128 |  |
| SB_CERT_ALGORITHM_BLAKE2S_160_ECDSA | id-ecdsa-with-blake2s160 |  |
| SB_CERT_ALGORITHM_BLAKE2S_224_ECDSA | id-ecdsa-with-blake2s224 |  |
| SB_CERT_ALGORITHM_BLAKE2S_256_ECDSA | id-ecdsa-with-blake2s256 |  |
| SB_CERT_ALGORITHM_BLAKE2B_160_ECDSA | id-ecdsa-with-blake2b160 |  |
| SB_CERT_ALGORITHM_BLAKE2B_256_ECDSA | id-ecdsa-with-blake2b256 |  |
| SB_CERT_ALGORITHM_BLAKE2B_384_ECDSA | id-ecdsa-with-blake2b384 |  |
| SB_CERT_ALGORITHM_BLAKE2B_512_ECDSA | id-ecdsa-with-blake2b512 |  |
| SB_CERT_ALGORITHM_BLAKE2S_128_ECDSA_PLAIN | id-ecdsa-plain-with-blake2s128 |  |
| SB_CERT_ALGORITHM_BLAKE2S_160_ECDSA_PLAIN | id-ecdsa-plain-with-blake2s160 |  |
| SB_CERT_ALGORITHM_BLAKE2S_224_ECDSA_PLAIN | id-ecdsa-plain-with-blake2s224 |  |
| SB_CERT_ALGORITHM_BLAKE2S_256_ECDSA_PLAIN | id-ecdsa-plain-with-blake2s256 |  |
| SB_CERT_ALGORITHM_BLAKE2B_160_ECDSA_PLAIN | id-ecdsa-plain-with-blake2b160 |  |
| SB_CERT_ALGORITHM_BLAKE2B_256_ECDSA_PLAIN | id-ecdsa-plain-with-blake2b256 |  |
| SB_CERT_ALGORITHM_BLAKE2B_384_ECDSA_PLAIN | id-ecdsa-plain-with-blake2b384 |  |
| SB_CERT_ALGORITHM_BLAKE2B_512_ECDSA_PLAIN | id-ecdsa-plain-with-blake2b512 |  |
| SB_CERT_ALGORITHM_ID_DSA_BLAKE2S_224 | id-dsa-with-blake2s224 |  |
| SB_CERT_ALGORITHM_ID_DSA_BLAKE2S_256 | id-dsa-with-blake2s256 |  |
| SB_CERT_ALGORITHM_EDDSA_ED25519 | id-Ed25519 |  |
| SB_CERT_ALGORITHM_EDDSA_ED448 | id-Ed448 |  |
| SB_CERT_ALGORITHM_EDDSA_ED25519_PH | id-Ed25519ph |  |
| SB_CERT_ALGORITHM_EDDSA_ED448_PH | id-Ed448ph |  |
| SB_CERT_ALGORITHM_EDDSA | id-EdDSA |  |
| SB_CERT_ALGORITHM_EDDSA_SIGNATURE | id-EdDSA-sig |  |
| SB_CERT_ALGORITHM_MLDSA_44 | id-ml-dsa-44 |  |
| SB_CERT_ALGORITHM_MLDSA_65 | id-ml-dsa-65 |  |
| SB_CERT_ALGORITHM_MLDSA_87 | id-ml-dsa-87 |  |
| SB_CERT_ALGORITHM_HASH_MLDSA_44_SHA512 | id-hash-ml-dsa-44-with-sha512 |  |
| SB_CERT_ALGORITHM_HASH_MLDSA_65_SHA512 | id-hash-ml-dsa-65-with-sha512 |  |
| SB_CERT_ALGORITHM_HASH_MLDSA_87_SHA512 | id-hash-ml-dsa-87-with-sha512 |  |
| SB_CERT_ALGORITHM_MLKEM_512 | id-ml-kem-512 |  |
| SB_CERT_ALGORITHM_MLKEM_768 | id-ml-kem-768 |  |
| SB_CERT_ALGORITHM_MLKEM_1024 | id-ml-kem-1024 |  |

## Constructors

```text
public ExternalCrypto();
```

 Creates a new ExternalCrypto object with default field values.

# PGPKey Type

This container represents a PGP key.

## Remarks

OpenPGP standard supports several types of keys. In our days, a typical OpenPGP keypair actually consists of two cryptographic keys: a primary key and a subkey. The primary key is normally used for signing, while the subkey is used for encryption.

While it is typical for PGP environments to use a primary key/subkey bundle, this is not a must. Sometimes you may come across standalone keys (mainly when dealing with older implementations), as well as whole key trees, each of those carrying a bunch of differently-purposed subkeys bound to the same primary key.

Algorithm-wise, OpenPGP keys also differ. Generally speaking, OpenPGP supports the following public key algorithms: RSA, Elgamal (often incorrectly referred to as DH), DSA, ECDH and ECDSA. When it comes to primary key/subkey bundles, DSA/Elgamal, RSA/RSA and ECDSA/ECDH pairs are typically used. Although there's no restriction on algorithm bundles, and, e.g. a ECDSA/Elgamal key bundle is perfectly possible, such combination is rarely used in practice.

A typical OpenPGP key is associated with some kind of user ID (Username). It is normally represented with a user's e-mail address, while in theory can be any piece of text. The secret part of the OpenPGP keypair is protected with a password (Passphrase).

The following fields are available:

- [BitsInKey](#PGPKey_f_BitsInKey)

- [CanEncrypt](#PGPKey_f_CanEncrypt)

- [CanSign](#PGPKey_f_CanSign)

- [Curve](#PGPKey_f_Curve)

- [Enabled](#PGPKey_f_Enabled)

- [EncryptionAlgorithm](#PGPKey_f_EncryptionAlgorithm)

- [IsPublic](#PGPKey_f_IsPublic)

- [IsSecret](#PGPKey_f_IsSecret)

- [IsSubkey](#PGPKey_f_IsSubkey)

- [KeyFP](#PGPKey_f_KeyFP)

- [KeyID](#PGPKey_f_KeyID)

- [Passphrase](#PGPKey_f_Passphrase)

- [PassphraseValid](#PGPKey_f_PassphraseValid)

- [PrimaryKeyID](#PGPKey_f_PrimaryKeyID)

- [Protection](#PGPKey_f_Protection)

- [PublicKeyAlgorithm](#PGPKey_f_PublicKeyAlgorithm)

- [QBits](#PGPKey_f_QBits)

- [Timestamp](#PGPKey_f_Timestamp)

- [Username](#PGPKey_f_Username)

- [ValidTo](#PGPKey_f_ValidTo)

- [Version](#PGPKey_f_Version)

## Fields

 **BitsInKey** *int (read-only)*
*Default Value: 2048*

Indicates the key length in bits.

 **CanEncrypt** *boolean (read-only)*
*Default Value: False*

Returns True if this key can be used for encryption.

 **CanSign** *boolean (read-only)*
*Default Value: False*

Returns True if this key can be used for signing.

 **Curve** *String (read-only)*
*Default Value: ""*

Indicates the elliptic curve associated with a EC key.

Supported values:

|  |  |  |
| --- | --- | --- |
| SB_PGP_CURVE_P256 | P256 |  |
| SB_PGP_CURVE_P384 | P384 |  |
| SB_PGP_CURVE_P521 | P521 |  |
| SB_PGP_CURVE_ED25519 | ED25519 |  |
| SB_PGP_CURVE_CURVE25519 | CURVE25519 |  |
| SB_PGP_CURVE_BRAINPOOLP256R1 | BRAINPOOLP256 |  |
| SB_PGP_CURVE_BRAINPOOLP512R1 | BRAINPOOLP512 |  |

 **Enabled** *boolean*
*Default Value: False*

Enables or disables this key for use in encryption or signing operation.

 **EncryptionAlgorithm** *String (read-only)*
*Default Value: "AES128"*

Indicates the symmetric algorithm used to encrypt the secret key.

 **IsPublic** *boolean (read-only)*
*Default Value: False*

Returns True if this key is a public key, and False otherwise.

 **IsSecret** *boolean (read-only)*
*Default Value: False*

Returns True if this key is a secret key, and False otherwise.

 **IsSubkey** *boolean (read-only)*
*Default Value: False*

Returns True if this key is a subkey of another key, and False otherwise.

 **KeyFP** *String (read-only)*
*Default Value: ""*

The 20-byte fingerprint (hash value) of this key.

KeyFP could be used to distinguish two keys with the same KeyID.

 **KeyID** *String (read-only)*
*Default Value: ""*

Contains a 8-byte key identifier.

It is quite rare that IDs of two keys collide. If that happens, their fingerprints (KeyFP) can be used for distinguish between the keys. Please note that many PGP implementations show only 4 lowest bytes of the KeyID to the user.

 **Passphrase** *String*
*Default Value: ""*

The key protection password.

 **PassphraseValid** *boolean (read-only)*
*Default Value: False*

Use this property to check whether the specified [Passphrase](#PGPKey_f_Passphrase) is valid and can be used to unlock the secret key.

 **PrimaryKeyID** *String (read-only)*
*Default Value: ""*

If this key is a subkey ([IsSubkey](#PGPKey_f_IsSubkey) returns True), this field contains the identifier of the subkey's primary key.

 **Protection** *int (read-only)*
*Default Value: 0*

Specifies the level of protection applied to the secret key.

Allowed values:

|  |  |  |
| --- | --- | --- |
| pptNone | 0 | Key is not encrypted |
| pptLow | 1 | Only the password hash is used to derive the secret key |
| pptNormal | 2 | Password hash with salt is used to derive the secret key |
| pptHigh | 3 | Hash from multiple passwords and salt are used for key derivation |

 **PublicKeyAlgorithm** *String (read-only)*
*Default Value: ""*

Specifies the asymmetric algorithm of the key.

 **QBits** *int (read-only)*
*Default Value: 0*

The length of the DSA Q (legitimate range: 160-512).

This parameter corresponds to the hash algorithm used with the key. For example, if the value of Q is 256, SHA-256 will be used.

 **Timestamp** *String (read-only)*
*Default Value: ""*

Use this property to check the time the key was generated. The date and time are stored and retrieved in Universal Coordinate Time (UTC).

 **Username** *String (read-only)*
*Default Value: ""*

Specifies the name of the user bound to this key.

The PGP username is typically represented with a full name and an email address, but generally can be any non-empty string.

 **ValidTo** *String (read-only)*
*Default Value: "0"*

Provide accurate expiration moment indication. This is different to expires property which only contains expiration time in days in old keys.

 **Version** *int (read-only)*
*Default Value: 0*

Indicates the key version.

The key version refers to the version of the public-key packet format as defined in RFC 4880.

Only four versions are currently allowed here: 3, 4, 5 and 6. It is recommended that all new keys are created with version of 6.

## Constructors

```text
public PGPKey();
```

 Creates an empty PGP key object.

```text
public PGPKey(String fileName);
```

 Create a PGP key object from a key file.

# PGPSignature Type

A container for PGP signature properties.

## Remarks

PGPSignature contains details and validation information for a PGP signature.

The following fields are available:

- [CertificationType](#PGPSignature_f_CertificationType)

- [CreationTime](#PGPSignature_f_CreationTime)

- [ExpirationTime](#PGPSignature_f_ExpirationTime)

- [Exportable](#PGPSignature_f_Exportable)

- [HashAlgorithm](#PGPSignature_f_HashAlgorithm)

- [HashMark](#PGPSignature_f_HashMark)

- [KeyExpirationTime](#PGPSignature_f_KeyExpirationTime)

- [KeyFlags](#PGPSignature_f_KeyFlags)

- [LegacyFormat](#PGPSignature_f_LegacyFormat)

- [PolicyURL](#PGPSignature_f_PolicyURL)

- [PreferredAlgorithms](#PGPSignature_f_PreferredAlgorithms)

- [PrimaryUserID](#PGPSignature_f_PrimaryUserID)

- [ReasonForRevocation](#PGPSignature_f_ReasonForRevocation)

- [Revocable](#PGPSignature_f_Revocable)

- [Revocation](#PGPSignature_f_Revocation)

- [SignatureClass](#PGPSignature_f_SignatureClass)

- [SignerKeyID](#PGPSignature_f_SignerKeyID)

- [SignerUserID](#PGPSignature_f_SignerUserID)

- [StrictlyValid](#PGPSignature_f_StrictlyValid)

- [Target](#PGPSignature_f_Target)

- [TextSignature](#PGPSignature_f_TextSignature)

- [TrustAmount](#PGPSignature_f_TrustAmount)

- [TrustLevel](#PGPSignature_f_TrustLevel)

- [Validated](#PGPSignature_f_Validated)

- [Validity](#PGPSignature_f_Validity)

- [Version](#PGPSignature_f_Version)

## Fields

 **CertificationType** *int (read-only)*
*Default Value: 0*

Specifies the type of a UserID signature.

|  |  |  |
| --- | --- | --- |
| pctGeneric | 0 | Generic certification of a User ID and Public Key packet. The issuer of this certification does not make any particular assertion as to how well the certifier has checked that the owner of the key is in fact the person described by the User ID. By default user certifications use Generic type. |
| pctPersona | 1 | Persona certification of a User ID and Public Key packet. The issuer of this certification has not done any verification of the claim that the owner of this key corresponds to the specified User ID. |
| pctCasual | 2 | Casual certification of a User ID and a Public Key packet. The issuer of this certification has done some casual verification of the claim of identity. |
| pctPositive | 3 | Positive certification of a User ID and a Public Key packet. The issuer of this certification has done substantial verification of the claim of identity. |

 **CreationTime** *String (read-only)*
*Default Value: ""*

The time when the signature was created, in Universal Coordinated Time (UTC).

 **ExpirationTime** *int (read-only)*
*Default Value: 0*

Specifies signature expiration time, in seconds since its creation time (CreationTime).

This property set to 0 indicates that the signature never expires.

 **Exportable** *boolean (read-only)*
*Default Value: False*

Specifies whether a certification signature is "exportable", meaning it can be used by entities other than the signature's issuer.

 **HashAlgorithm** *String (read-only)*
*Default Value: ""*

Specifies the hash algorithm used in the signature.

 **HashMark** *int (read-only)*
*Default Value: 0*

Returns the hash mark attribute of a signature.

Check this property to get a hash mark of a signature.

 **KeyExpirationTime** *int (read-only)*
*Default Value: 0*

The number of seconds after which the signed key will expire.

 **KeyFlags** *int (read-only)*
*Default Value: 0*

Returns the key flags included in the signature.

Use this property to retrieve the key flags stored in the key signature.

 **LegacyFormat** *boolean (read-only)*
*Default Value: False*

Indicates whether signature uses PGP 2.6.x-compatible packet format.

The signature is fully compatible with the 'old' format only if it has version 3, uses MD5 hash algorithm, RSA public key algorithm, and its key length is not greater than 1024 bits.

 **PolicyURL** *String (read-only)*
*Default Value: ""*

Contains the URL of the signature policy.

 **PreferredAlgorithms** *String (read-only)*
*Default Value: ""*

Contains a list of algorithms preferred by the signed key holder.

 **PrimaryUserID** *boolean (read-only)*
*Default Value: False*

Indicates whether the UserID covered by the signature is the main user id for this key.

 **ReasonForRevocation** *String (read-only)*
*Default Value: ""*

Describes the reason why the key or the certificate was revoked.

 **Revocable** *boolean (read-only)*
*Default Value: False*

Specifies whether the signature can be revoked.

 **Revocation** *boolean (read-only)*
*Default Value: False*

Indicates whether or not the signature is a revocation signature.

 **SignatureClass** *int (read-only)*
*Default Value: 0*

Indicates the signature class.

|  |  |  |
| --- | --- | --- |
| pscDocument | 0 | Signature over binary file |
| pscTextDocument | 1 | Signature over text |
| pscStandalone | 2 | A standalone signature |
| pscUIDGeneric | 3 | User certification signature |
| pscUIDPersona | 4 | User certification signature (persona) |
| pscUIDCasual | 5 | User certification signature (casual) |
| pscUIDPositive | 6 | User certification signature (positive) |
| pscSubkeyBinding | 7 | Subkey binding signature |
| pscPrimaryKeyBinding | 8 | Primary key binding signature |
| pscDirectKey | 9 | Direct signature over a public key |
| pscKeyRevocation | 10 | Key revocation |
| pscSubkeyRevocation | 11 | Subkey revocation |
| pscCertRevocation | 12 | User revocation |
| pscTimestamp | 13 | Timestamp signature |
| pscThirdParty | 14 | Third-party signature |
| pscNotSpecified | 15 | Signature type not provided |

 **SignerKeyID** *String (read-only)*
*Default Value: ""*

Indicates the KeyID of the signing key.

 **SignerUserID** *String (read-only)*
*Default Value: ""*

Indicates the UserID associated with the signing key.

 **StrictlyValid** *boolean (read-only)*
*Default Value: False*

Returns True if this signature is valid in a strict way (no compatibility relaxations).

 **Target** *String (read-only)*
*Default Value: ""*

Indicates the KeyID or Username of the target key or user.

 **TextSignature** *boolean (read-only)*
*Default Value: False*

Indicates whether or not the signature is made over a text document.

 **TrustAmount** *int (read-only)*
*Default Value: 0*

Specifies the amount of trust assigned by this signature.

Specifies the amount of trust, in range 0-255, interpreted such that values less than 120 indicate partial trust and values of 120 or greater indicate complete trust.

 **TrustLevel** *int (read-only)*
*Default Value: 0*

The trust level assigned by this signature.

Level 1 means that the signed key is asserted to be a valid trusted introducer, with the 2nd octet of the body specifying the degree of trust. Level n means that the signed key is asserted to be trusted to issue level (n-1)-trust signatures.

 **Validated** *boolean (read-only)*
*Default Value: False*

Whether the signature has been validated.

 **Validity** *int (read-only)*
*Default Value: 0*

Provides the validity status of the signature if the signature has been validated.

|  |  |  |
| --- | --- | --- |
| svtValid | 0 | The signature is valid |
| svtUnknown | 1 | Signature validity is unknown |
| svtCorrupted | 2 | The signature is corrupted |
| svtSignerNotFound | 3 | Failed to acquire the signing certificate. The signature cannot be validated. |
| svtFailure | 4 | General failure |
| svtReferenceCorrupted | 5 | Reference corrupted (XML-based signatures only) |

 **Version** *int (read-only)*
*Default Value: 0*

Indicates the signature version.

RFC 4880 defines two versions for PGP signatures: 3 and 4.

## Constructors

```text
public PGPSignature();
```

 Creates an empty PGPSignature object.

# Config Settings ([PGPReader](#pgpreader-class) Class)

 The class accepts one or more of the following *configuration settings*. Configuration settings are similar in functionality to properties, but they are rarely used. In order to avoid "polluting" the property namespace of the class, access to these *internal properties* is provided through the [Config](#config-method-pgpreader-class) method.

### PGPReader Config Settings

**IgnoreDataPacketLengths**: Whether to check the length of input data packets.Set this property to True to prevent the class from checking input packet lengths.

**PasswordAttempts**: The number of attempts allowed for entering password.Use this property to specify how many times a wrong password may be entered.

**TempPath**: Path for storing temporary files.This setting specifies an absolute path to the location on disk where temporary files are stored. This setting is supported only in the Java edition for all applicable signing components except [PDFSigner](PDFSigner.md#PDFSigner), where this limitation does not apply.

**UndefInputLength**: Set this property if you are working with non-seekable streams.Use this property to turn on support for streams with unknown length and position parameters, such as network or database streams. It prevents the class from checking input stream length or position.

**UseGreedyMemoryConsumption**: Whether to limit memory consumption for the cost of speed.When this property is True, the class uses more memory, but decrypts data faster. Otherwise, less memory is consumed, but the decryption is slower.

### Base Config Settings

**ASN1UseGlobalTagCache**: Controls whether ASN.1 module should use a global object cache.This is a performance setting. It is unlikely that you will ever need to adjust it.

**AssignSystemSmartCardPins**: Specifies whether CSP-level PINs should be assigned to CNG keys.This is a low-level tweak for certain cryptographic providers. It is unlikely that you will ever need to adjust it.

**CheckKeyIntegrityBeforeUse**: Enables or disable private key integrity check before use.This global property enables or disables private key material check before each signing operation. This slows down performance a bit, but prevents a selection of attacks on RSA keys where keys with unknown origins are used.

You can switch this property off to improve performance if your project only uses known, good private keys.

**CookieCaching**: Specifies whether a cookie cache should be used for HTTP(S) transports.Set this property to enable or disable cookies caching for the class.

Supported values are:

|  |  |  |
| --- | --- | --- |
| off |  | No caching (default) |
| local |  | Local caching |
| global |  | Global caching |

**Cookies**: Gets or sets local cookies for the class.Use this property to get cookies from the internal cookie storage of the class and/or restore them back between application sessions.

**DefDeriveKeyIterations**: Specifies the default key derivation algorithm iteration count.This global property sets the default number of iterations for all supported key derivation algorithms. Note that you can provide the required number of iterations by using properties of the relevant key generation component; this global setting is used in scenarios where specific iteration count is not or cannot be provided.

**DNSLocalSuffix**: The suffix to assign for TLD names.Use this global setting to adjust the default suffix to assign to top-level domain names. The default is *.local*.

**EnableClientSideSSLFFDHE**: Enables or disables finite field DHE key exchange support in TLS clients.This global property enables or disables support for finite field DHE key exchange methods in TLS clients. FF DHE is a slower algorithm if compared to EC DHE; enabling it may result in slower connections.

This setting only applies to sessions negotiated with TLS version 1.3.

**EnableSSHMLKEM**: Enables support for ML-KEM/hybrid key exchange algorithms in SSH client and server components.Use this setting to enable hybrid key exchange algorithms in client and server SSH and SFTP components. This is a global setting that enables ML-KEM blanketly in all SSH-dependent components.

**EnableTLSMLKEM**: Enables support for ML-KEM and hybrid groups in TLS client and server components.Use this setting to enable ML-KEM and hybrid key exchange groups in client and server TLS components. This is a global setting that enables ML-KEM blanketly in all TLS-dependent components.

**GlobalCookies**: Gets or sets global cookies for all the HTTP transports.Use this property to get cookies from the GLOBAL cookie storage or restore them back between application sessions. These cookies will be used by all the classes that have its *CookieCaching* property set to "global".

**HardwareCryptoUsePolicy**: The hardware crypto usage policy.This global setting controls the hardware cryptography usage policy.

Supported Values:

|  |  |
| --- | --- |
| auto | Use hardware cryptography if available; otherwise, fall back to software-based cryptography (default). |
| enable | Always attempt to use hardware cryptography. If unavailable, exception will be thrown. |
| disable | Do not use hardware cryptography. |

**HttpUserAgent**: Specifies the user agent name to be used by all HTTP clients.This global setting defines the User-Agent field of the HTTP request provides information about the software that initiates the request. This value will be used by all the HTTP clients including the ones used internally in other classes.

**HttpVersion**: The HTTP version to use in any inner HTTP client components created.Set this property to 1.0 or 1.1 to indicate the HTTP version that any internal HTTP clients should use.

**IgnoreExpiredMSCTLSigningCert**: Whether to tolerate the expired Windows Update signing certificate.It is not uncommon for Microsoft Windows Update Certificate Trust List to be signed with an expired Microsoft certificate. Setting this global property to true makes SBB ignore the expired factor and take the Trust List into account.

**ListDelimiter**: The delimiter character for multi-element lists.Allows to set the delimiter for any multi-entry values returned by the component as a string object, such as file lists. For most of the components, this property is set to a newline sequence.

**LogDestination**: Specifies the debug log destination.Contains a comma-separated list of values that specifies where debug log should be dumped.

Supported values are:

|  |  |  |
| --- | --- | --- |
| file |  | File |
| console |  | Console |
| systemlog |  | System Log (supported for Android only) |
| debugger |  | Debugger (supported for VCL for Windows and .Net) |

**LogDetails**: Specifies the debug log details to dump.Contains a comma-separated list of values that specifies which debug log details to dump.

Supported values are:

|  |  |  |
| --- | --- | --- |
| time |  | Current time |
| level |  | Level |
| package |  | Package name |
| module |  | Module name |
| class |  | Class name |
| method |  | Method name |
| threadid |  | Thread Id |
| contenttype |  | Content type |
| content |  | Content |
| all |  | All details |

**LogFile**: Specifies the debug log filename.Use this property to provide a path to the log file.

**LogFilters**: Specifies the debug log filters.Contains a comma-separated list of value pairs ("name:value") that describe filters.

Supported filter names are:

|  |  |  |
| --- | --- | --- |
| exclude-package |  | Exclude a package specified in the value |
| exclude-module |  | Exclude a module specified in the value |
| exclude-class |  | Exclude a class specified in the value |
| exclude-method |  | Exclude a method specified in the value |
| include-package |  | Include a package specified in the value |
| include-module |  | Include a module specified in the value |
| include-class |  | Include a class specified in the value |
| include-method |  | Include a method specified in the value |

**LogFlushMode**: Specifies the log flush mode.Use this property to set the log flush mode. The following values are defined:

|  |  |  |
| --- | --- | --- |
| none |  | No flush (caching only) |
| immediate |  | Immediate flush (real-time logging) |
| maxcount |  | Flush cached entries upon reaching LogMaxEventCount entries in the cache. |

**LogLevel**: Specifies the debug log level.Use this property to provide the desired debug log level.

Supported values are:

|  |  |  |
| --- | --- | --- |
| none |  | None (by default) |
| fatal |  | Severe errors that cause premature termination. |
| error |  | Other runtime errors or unexpected conditions. |
| warning |  | Use of deprecated APIs, poor use of API, 'almost' errors, other runtime situations that are undesirable or unexpected, but not necessarily "wrong". |
| info |  | Interesting runtime events (startup/shutdown). |
| debug |  | Detailed information on flow of through the system. |
| trace |  | More detailed information. |

**LogMaxEventCount**: Specifies the maximum number of events to cache before further action is taken.Use this property to specify the log event number threshold. This threshold may have different effects, depending on the rotation setting and/or the flush mode.

The default value of this setting is 100.

**LogRotationMode**: Specifies the log rotation mode.Use this property to set the log rotation mode. The following values are defined:

|  |  |  |
| --- | --- | --- |
| none |  | No rotation |
| deleteolder |  | Delete older entries from the cache upon reaching LogMaxEventCount |
| keepolder |  | Keep older entries in the cache upon reaching LogMaxEventCount (newer entries are discarded) |

**MaxASN1BufferLength**: Specifies the maximal allowed length for ASN.1 primitive tag data.This global property limits the maximal allowed length for ASN.1 tag data for non-content-carrying structures, such as certificates, CRLs, or timestamps. It does not affect structures that can carry content, such as CMS/CAdES messages. This is a security property aiming at preventing DoS attacks.

**MaxASN1TreeDepth**: Specifies the maximal depth for processed ASN.1 trees.This global property limits the maximal depth of ASN.1 trees that the component can handle without throwing an error. This is a security property aiming at preventing DoS attacks.

**OCSPHashAlgorithm**: Specifies the hash algorithm to be used to identify certificates in OCSP requests.This global setting defines the hash algorithm to use in OCSP requests during chain validation. Some OCSP responders can only use older algorithms, in which case setting this property to SHA1 may be helpful.

**OldClientSideRSAFallback**: Specifies whether the SSH client should use a SHA1 fallback.Tells the SSH client to use a legacy ssh-rsa authentication even if the server indicates support for newer algorithms, such as rsa-sha-256. This is a backward-compatibility tweak.

**PKICache**: Specifies which PKI elements (certificates, CRLs, OCSP responses) should be cached.The PKICache setting specifies which Public Key Infrastructure (PKI) elements should be cached to optimize performance and reduce retrieval times. It supports comma-separated values to indicate the specific types of PKI data that should be cached.

Supported Values:

|  |  |
| --- | --- |
| certificate | Enables caching of certificates. |
| crl | Enables caching of Certificate Revocation Lists (CRLs). |
| ocsp | Enables caching of OCSP (Online Certificate Status Protocol) responses. |

Example (default value):

```text
PKICache=certificate,crl,ocsp
```

 In this example, the component caches certificates, CRLs, and OCSP responses.

**PKICachePath**: Specifies the file system path where cached PKI data is stored.The PKICachePath setting defines the file system path where cached PKI data (e.g., certificates, CRLs, OCSP responses and Trusted Lists) will be stored. This allows the system to persistently save and retrieve PKI cache data, even across application restarts.

The default value is an empty string - no cached PKI data is stored on disk.

Example:

```text
PKICachePath=C:\Temp\cache
```

 In this example, the cached PKI data is stored in the C:\Temp\cache directory.

**ProductVersion**: Returns the version of the SecureBlackbox library.This property returns the long version string of the SecureBlackbox library being used (major.minor.build.revision).

**ServerSSLDHKeyLength**: Sets the size of the TLS DHE key exchange group.Use this property to adjust the length, in bits, of the DHE prime to be used by the TLS server.

**StaticDNS**: Specifies whether static DNS rules should be used.Set this property to enable or disable static DNS rules for the class. Works only if *UseOwnDNSResolver* is set to *true*.

Supported values are:

|  |  |  |
| --- | --- | --- |
| none |  | No static DNS rules (default) |
| local |  | Local static DNS rules |
| global |  | Global static DNS rules |

**StaticIPAddress[domain]**: Gets or sets an IP address for the specified domain name.Use this property to get or set an IP address for the specified domain name in the internal (of the class) or global DNS rules storage depending on the *StaticDNS* value. The type of the IP address (IPv4 or IPv6) is determined automatically. If both addresses are available, they are divided by the | (pipe) character.

**StaticIPAddresses**: Gets or sets all the static DNS rules.Use this property to get static DNS rules from the current rules storage or restore them back between application sessions. If *StaticDNS* of the class is set to "*local*", the property returns/restores the rules from/to the internal storage of the class. If *StaticDNS* of the class is set to "*global*", the property returns/restores the rules from/to the GLOBAL storage. The rules list is returned and accepted in JSON format.

**Tag**: Allows to store any custom data.Use this config property to store any custom data.

**TLSSessionGroup**: Specifies the group name of TLS sessions to be used for session resumption.Use this property to limit the search of cached TLS sessions to the specified group. Sessions from other groups will be ignored. By default, all sessions are cached with an empty group name and available to all the classes.

**TLSSessionLifetime**: Specifies lifetime in seconds of the cached TLS session.Use this property to specify how much time the TLS session should be kept in the session cache. After this time, the session expires and will be automatically removed from the cache. Default value is 300 seconds (5 minutes).

**TLSSessionPurgeInterval**: Specifies how often the session cache should remove the expired TLS sessions.Use this property to specify the time interval of purging the expired TLS sessions from the session cache. Default value is 60 seconds (1 minute).

**UseCRLObjectCaching**: Specifies whether reuse of loaded CRL objects is enabled.This setting enables or disables the caching of CRL objects. When set to true (the default value), the system checks if a CRL object is already loaded in memory before attempting to load a new instance. If the object is found, the existing instance is reused, and its reference count is incremented to track its usage. When the reference count reaches zero, indicating that no references to the object remain, the system will free the object from memory. This setting enhances performance by minimizing unnecessary object instantiation and promotes efficient memory management, particularly in scenarios where CRL objects are frequently used.

**UseInternalRandom**: Switches between SecureBlackbox-own and platform PRNGs.Allows to switch between internal/native PRNG implementation and the one provided by the platform.

**UseLegacyAdESValidation**: Enables legacy AdES validation mode.Use this setting to switch the AdES component to the validation approach that was used in SBB 2020/SBB 2022 (less attention to temporal details).

**UseOCSPResponseObjectCaching**: Specifies whether reuse of loaded OCSP response objects is enabled.This setting enables or disables the caching of OCSP response objects. When set to true (the default value), the system checks if a OCSP response object is already loaded in memory before attempting to load a new instance. If the object is found, the existing instance is reused, and its reference count is incremented to track its usage. When the reference count reaches zero, indicating that no references to the object remain, the system will free the object from memory. This setting enhances performance by minimizing unnecessary object instantiation and promotes efficient memory management, particularly in scenarios where OCSP response objects are frequently used.

**UseOwnDNSResolver**: Specifies whether the client components should use own DNS resolver.Set this global property to false to force all the client components to use the DNS resolver provided by the target OS instead of using own one.

**UseSharedSystemStorages**: Specifies whether the validation engine should use a global per-process copy of the system certificate stores.Set this global property to false to make each validation run use its own copy of system certificate stores.

**UseSystemNativeSizeCalculation**: An internal CryptoAPI access tweak.This is an internal setting. Please do not use it unless instructed by the support team.

**UseSystemOAEPAndPSS**: Enforces or disables the use of system-driven RSA OAEP and PSS computations.This global setting defines who is responsible for performing RSA-OAEP and RSA-PSS computations where the private key is stored in a Windows system store and is exportable. If set to true, SBB will delegate the computations to Windows via a CryptoAPI call. Otherwise, it will export the key material and perform the computations using its own OAEP/PSS implementation.

This setting only applies to certificates originating from a Windows system store.

**UseSystemRandom**: Enables or disables the use of the OS PRNG.Use this global property to enable or disable the use of operating system-driven pseudorandom number generation.

**XMLRDNDescriptorName[OID]**: Defines an OID mapping to descriptor names for the certificate's IssuerRDN or SubjectRDN.This property defines custom mappings between Object Identifiers (OIDs) and descriptor names. This mapping specifies how the certificate's issuer and subject information (ds:IssuerRDN and ds:SubjectRDN elements respectively) are represented in XML signatures.

The property accepts comma-separated values where the first descriptor name is used when the OID is mapped, and subsequent values act as aliases for parsing.

Syntax:

```text
Config("XMLRDNDescriptorName[OID]=PrimaryName,Alias1,Alias2");
```

Where:

OID: The Object Identifier from the certificate's IssuerRDN or SubjectRDN that you want to map.

PrimaryName: The main descriptor name used in the XML signature when the OID is encountered.

Alias1, Alias2, ...: Optional alternative names recognized during parsing.

Usage Examples:

Map OID 2.5.4.5 to SERIALNUMBER:

```text
Config("XMLRDNDescriptorName[2.5.4.5]=SERIALNUMBER");
```

Map OID 1.2.840.113549.1.9.1 to E, with aliases EMAIL and EMAILADDRESS:

```text
Config("XMLRDNDescriptorName[1.2.840.113549.1.9.1]=E,EMAIL,EMAILADDRESS");
```

**XMLRDNDescriptorPriority[OID]**: Specifies the priority of descriptor names associated with a specific OID.This property specifies the priority of descriptor names associated with a specific OID that allows to reorder descriptors in the ds:IssuerRDN and ds:SubjectRDN elements during signing.

**XMLRDNDescriptorReverseOrder**: Specifies whether to reverse the order of descriptors in RDN.Specifies whether to reverse the order of descriptors in the ds:IssuerRDN and ds:SubjectRDN elements during XML signing. By default, this property is set to true (as specified in RFC 2253, 2.1).

**XMLRDNDescriptorSeparator**: Specifies the separator used between descriptors in RDN.Specifies the separator used between descriptors in the ds:IssuerRDN and ds:SubjectRDN elements during XML signing. By default, this property is set to ", " value.

# Trappable Errors ([PGPReader](#pgpreader-class) Class)

### PGPReader Errors

|  |  |
| --- | --- |
| 1048577 | Invalid parameter ([SB_ERROR_INVALID_PARAMETER](constants.md#const_SBERRORINVALIDPARAMETER)) |
| 1048578 | Invalid configuration ([SB_ERROR_INVALID_SETUP](constants.md#const_SBERRORINVALIDSETUP)) |
| 1048579 | Invalid state ([SB_ERROR_INVALID_STATE](constants.md#const_SBERRORINVALIDSTATE)) |
| 1048580 | Invalid value ([SB_ERROR_INVALID_VALUE](constants.md#const_SBERRORINVALIDVALUE)) |
| 1048581 | Private key not found ([SB_ERROR_NO_PRIVATE_KEY](constants.md#const_SBERRORNOPRIVATEKEY)) |
| 1048582 | Cancelled by the user ([SB_ERROR_CANCELLED_BY_USER](constants.md#const_SBERRORCANCELLEDBYUSER)) |
| 1048583 | The file was not found ([SB_ERROR_NO_SUCH_FILE](constants.md#const_SBERRORNOSUCHFILE)) |
| 1048584 | Unsupported feature or operation ([SB_ERROR_UNSUPPORTED_FEATURE](constants.md#const_SBERRORUNSUPPORTEDFEATURE)) |
| 1048585 | General error ([SB_ERROR_GENERAL_ERROR](constants.md#const_SBERRORGENERALERROR)) |
| 27262977 | The file was not found ([SB_ERROR_PGP_FILE_NOT_EXISTS](constants.md#const_SBERRORPGPFILENOTEXISTS)) |
| 27262978 | Invalid signing key ([SB_ERROR_PGP_INVALID_KEY](constants.md#const_SBERRORPGPINVALIDKEY)) |
| 27262980 | No secret key is available ([SB_ERROR_PGP_NO_SECRET_KEY](constants.md#const_SBERRORPGPNOSECRETKEY)) |
| 27262982 | The operation is not supported on a subkey ([SB_ERROR_PGP_OPERATION_ON_SUBKEY](constants.md#const_SBERRORPGPOPERATIONONSUBKEY)) |