PGPReader Class

Properties   Methods   Events   Config Settings   Errors  

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

Syntax

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 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 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. 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 and VerifyingKeys properties, and PGPReader will find and use the right one: 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 property. You can check whether the provided password is valid using the PassphraseValid property.
• By assigning the password to KeyPassphrase property. This and the previous method assumes that you anticipate which key you will likely need to use.
• By subscribing to KeyPassphraseNeeded 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 (or InputBytes) property.
• Provide the destination in OutputFile. If no output destination is provided, the output will be generated in OutputBytes.
• When processing multi-files PGP archives, consider subscribing to MultipleFilesFound, FileExtractionStart and FileExtractionFinish 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 and EncryptionInfo 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: 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: verify a detached signature. Remember that you need to provide the original data separately via the DataFile or DataBytes properties.

Property List

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

Method List

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

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.

Config Settings

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

Armored Property (PGPReader Class)

Indicates if the processed message had been base64-armored.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int GetArmored();

Unicode (Windows)
BOOL GetArmored();

int secureblackbox_pgpreader_getarmored(void* lpObj);

bool GetArmored();

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.

Data Type

Boolean

Compressed Property (PGPReader Class)

Indicates if the processed message had been compressed.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int GetCompressed();

Unicode (Windows)
BOOL GetCompressed();

int secureblackbox_pgpreader_getcompressed(void* lpObj);

bool GetCompressed();

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.

Data Type

Boolean

DataBytes Property (PGPReader Class)

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

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int GetDataBytes(char* &lpDataBytes, int &lenDataBytes);
int SetDataBytes(const char* lpDataBytes, int lenDataBytes);

Unicode (Windows)
INT GetDataBytes(LPSTR &lpDataBytes, INT &lenDataBytes);
INT SetDataBytes(LPCSTR lpDataBytes, INT lenDataBytes);

int secureblackbox_pgpreader_getdatabytes(void* lpObj, char** lpDataBytes, int* lenDataBytes);
int secureblackbox_pgpreader_setdatabytes(void* lpObj, const char* lpDataBytes, int lenDataBytes);

QByteArray GetDataBytes();
int SetDataBytes(QByteArray qbaDataBytes);

Remarks

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

This property is not available at design time.

Data Type

Byte Array

DataFile Property (PGPReader Class)

The name of the file containing the original signed data.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetDataFile();
int SetDataFile(const char* lpszDataFile);

Unicode (Windows)
LPWSTR GetDataFile();
INT SetDataFile(LPCWSTR lpszDataFile);

char* secureblackbox_pgpreader_getdatafile(void* lpObj);
int secureblackbox_pgpreader_setdatafile(void* lpObj, const char* lpszDataFile);

QString GetDataFile();
int SetDataFile(QString qsDataFile);

Default Value

""

Remarks

Use this property to provide the original data when validating detached signatures with VerifyDetached.

Data Type

String

DecryptingKeys Property (PGPReader Class)

A collection of keys to be used for decryption.

Syntax

• C++
• C
• Qt

SecureBlackboxList<SecureBlackboxPGPKey>* GetDecryptingKeys();
int SetDecryptingKeys(SecureBlackboxList<SecureBlackboxPGPKey>* val);

int secureblackbox_pgpreader_getdecryptingkeycount(void* lpObj);
int secureblackbox_pgpreader_setdecryptingkeycount(void* lpObj, int iDecryptingKeyCount);

int64 secureblackbox_pgpreader_getdecryptingkeyhandle(void* lpObj, int decryptingkeyindex);
int secureblackbox_pgpreader_setdecryptingkeyhandle(void* lpObj, int decryptingkeyindex, int64 lDecryptingKeyHandle);

char* secureblackbox_pgpreader_getdecryptingkeykeyfp(void* lpObj, int decryptingkeyindex);

char* secureblackbox_pgpreader_getdecryptingkeykeyid(void* lpObj, int decryptingkeyindex);

char* secureblackbox_pgpreader_getdecryptingkeypassphrase(void* lpObj, int decryptingkeyindex);
int secureblackbox_pgpreader_setdecryptingkeypassphrase(void* lpObj, int decryptingkeyindex, const char* lpszDecryptingKeyPassphrase);

int secureblackbox_pgpreader_getdecryptingkeypassphrasevalid(void* lpObj, int decryptingkeyindex);

char* secureblackbox_pgpreader_getdecryptingkeyusername(void* lpObj, int decryptingkeyindex);

int GetDecryptingKeyCount();
int SetDecryptingKeyCount(int iDecryptingKeyCount);

qint64 GetDecryptingKeyHandle(int iDecryptingKeyIndex);
int SetDecryptingKeyHandle(int iDecryptingKeyIndex, qint64 lDecryptingKeyHandle);

QString GetDecryptingKeyKeyFP(int iDecryptingKeyIndex);

QString GetDecryptingKeyKeyID(int iDecryptingKeyIndex);

QString GetDecryptingKeyPassphrase(int iDecryptingKeyIndex);
int SetDecryptingKeyPassphrase(int iDecryptingKeyIndex, QString qsDecryptingKeyPassphrase);

bool GetDecryptingKeyPassphraseValid(int iDecryptingKeyIndex);

QString GetDecryptingKeyUsername(int iDecryptingKeyIndex);

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 event, setting the control's KeyPassphrase property, or setting the Passphrase property of the relevant key object.

This property is not available at design time.

Data Type

SecureBlackboxPGPKey

ExternalCrypto Property (PGPReader Class)

Provides access to external signing and DC parameters.

Syntax

• C++
• C
• Qt

SecureBlackboxExternalCrypto* GetExternalCrypto();

char* secureblackbox_pgpreader_getexternalcryptoasyncdocumentid(void* lpObj);
int secureblackbox_pgpreader_setexternalcryptoasyncdocumentid(void* lpObj, const char* lpszExternalCryptoAsyncDocumentID);

char* secureblackbox_pgpreader_getexternalcryptocustomparams(void* lpObj);
int secureblackbox_pgpreader_setexternalcryptocustomparams(void* lpObj, const char* lpszExternalCryptoCustomParams);

char* secureblackbox_pgpreader_getexternalcryptodata(void* lpObj);
int secureblackbox_pgpreader_setexternalcryptodata(void* lpObj, const char* lpszExternalCryptoData);

int secureblackbox_pgpreader_getexternalcryptoexternalhashcalculation(void* lpObj);
int secureblackbox_pgpreader_setexternalcryptoexternalhashcalculation(void* lpObj, int bExternalCryptoExternalHashCalculation);

char* secureblackbox_pgpreader_getexternalcryptohashalgorithm(void* lpObj);
int secureblackbox_pgpreader_setexternalcryptohashalgorithm(void* lpObj, const char* lpszExternalCryptoHashAlgorithm);

char* secureblackbox_pgpreader_getexternalcryptokeyid(void* lpObj);
int secureblackbox_pgpreader_setexternalcryptokeyid(void* lpObj, const char* lpszExternalCryptoKeyID);

char* secureblackbox_pgpreader_getexternalcryptokeysecret(void* lpObj);
int secureblackbox_pgpreader_setexternalcryptokeysecret(void* lpObj, const char* lpszExternalCryptoKeySecret);

int secureblackbox_pgpreader_getexternalcryptomethod(void* lpObj);
int secureblackbox_pgpreader_setexternalcryptomethod(void* lpObj, int iExternalCryptoMethod);

int secureblackbox_pgpreader_getexternalcryptomode(void* lpObj);
int secureblackbox_pgpreader_setexternalcryptomode(void* lpObj, int iExternalCryptoMode);

char* secureblackbox_pgpreader_getexternalcryptopublickeyalgorithm(void* lpObj);
int secureblackbox_pgpreader_setexternalcryptopublickeyalgorithm(void* lpObj, const char* lpszExternalCryptoPublicKeyAlgorithm);

QString GetExternalCryptoAsyncDocumentID();
int SetExternalCryptoAsyncDocumentID(QString qsExternalCryptoAsyncDocumentID);

QString GetExternalCryptoCustomParams();
int SetExternalCryptoCustomParams(QString qsExternalCryptoCustomParams);

QString GetExternalCryptoData();
int SetExternalCryptoData(QString qsExternalCryptoData);

bool GetExternalCryptoExternalHashCalculation();
int SetExternalCryptoExternalHashCalculation(bool bExternalCryptoExternalHashCalculation);

QString GetExternalCryptoHashAlgorithm();
int SetExternalCryptoHashAlgorithm(QString qsExternalCryptoHashAlgorithm);

QString GetExternalCryptoKeyID();
int SetExternalCryptoKeyID(QString qsExternalCryptoKeyID);

QString GetExternalCryptoKeySecret();
int SetExternalCryptoKeySecret(QString qsExternalCryptoKeySecret);

int GetExternalCryptoMethod();
int SetExternalCryptoMethod(int iExternalCryptoMethod);

int GetExternalCryptoMode();
int SetExternalCryptoMode(int iExternalCryptoMode);

QString GetExternalCryptoPublicKeyAlgorithm();
int SetExternalCryptoPublicKeyAlgorithm(QString qsExternalCryptoPublicKeyAlgorithm);

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.

Data Type

SecureBlackboxExternalCrypto

FIPSMode Property (PGPReader Class)

Reserved.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int GetFIPSMode();
int SetFIPSMode(int bFIPSMode);

Unicode (Windows)
BOOL GetFIPSMode();
INT SetFIPSMode(BOOL bFIPSMode);

int secureblackbox_pgpreader_getfipsmode(void* lpObj);
int secureblackbox_pgpreader_setfipsmode(void* lpObj, int bFIPSMode);

bool GetFIPSMode();
int SetFIPSMode(bool bFIPSMode);

Default Value

FALSE

Remarks

This property is reserved for future use.

Data Type

Boolean

InputBytes Property (PGPReader Class)

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

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int GetInputBytes(char* &lpInputBytes, int &lenInputBytes);
int SetInputBytes(const char* lpInputBytes, int lenInputBytes);

Unicode (Windows)
INT GetInputBytes(LPSTR &lpInputBytes, INT &lenInputBytes);
INT SetInputBytes(LPCSTR lpInputBytes, INT lenInputBytes);

int secureblackbox_pgpreader_getinputbytes(void* lpObj, char** lpInputBytes, int* lenInputBytes);
int secureblackbox_pgpreader_setinputbytes(void* lpObj, const char* lpInputBytes, int lenInputBytes);

QByteArray GetInputBytes();
int SetInputBytes(QByteArray qbaInputBytes);

Remarks

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

This property is not available at design time.

Data Type

Byte Array

InputFile Property (PGPReader Class)

Provides a filename of a file to process.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetInputFile();
int SetInputFile(const char* lpszInputFile);

Unicode (Windows)
LPWSTR GetInputFile();
INT SetInputFile(LPCWSTR lpszInputFile);

char* secureblackbox_pgpreader_getinputfile(void* lpObj);
int secureblackbox_pgpreader_setinputfile(void* lpObj, const char* lpszInputFile);

QString GetInputFile();
int SetInputFile(QString qsInputFile);

Default Value

""

Remarks

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

Data Type

String

KeyPassphrase Property (PGPReader Class)

Specifies a passphrase for the decryption key.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetKeyPassphrase();
int SetKeyPassphrase(const char* lpszKeyPassphrase);

Unicode (Windows)
LPWSTR GetKeyPassphrase();
INT SetKeyPassphrase(LPCWSTR lpszKeyPassphrase);

char* secureblackbox_pgpreader_getkeypassphrase(void* lpObj);
int secureblackbox_pgpreader_setkeypassphrase(void* lpObj, const char* lpszKeyPassphrase);

QString GetKeyPassphrase();
int SetKeyPassphrase(QString qsKeyPassphrase);

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 event will be fired to request the correct passphrase.

Data Type

String

OutputBytes Property (PGPReader Class)

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

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int GetOutputBytes(char* &lpOutputBytes, int &lenOutputBytes);

Unicode (Windows)
INT GetOutputBytes(LPSTR &lpOutputBytes, INT &lenOutputBytes);

int secureblackbox_pgpreader_getoutputbytes(void* lpObj, char** lpOutputBytes, int* lenOutputBytes);

QByteArray 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 and OutputStream properties had not been assigned.

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

Data Type

Byte Array

OutputFile Property (PGPReader Class)

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

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetOutputFile();
int SetOutputFile(const char* lpszOutputFile);

Unicode (Windows)
LPWSTR GetOutputFile();
INT SetOutputFile(LPCWSTR lpszOutputFile);

char* secureblackbox_pgpreader_getoutputfile(void* lpObj);
int secureblackbox_pgpreader_setoutputfile(void* lpObj, const char* lpszOutputFile);

QString GetOutputFile();
int SetOutputFile(QString qsOutputFile);

Default Value

""

Remarks

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

Data Type

String

Passphrase Property (PGPReader Class)

Specifies a message decryption password.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetPassphrase();
int SetPassphrase(const char* lpszPassphrase);

Unicode (Windows)
LPWSTR GetPassphrase();
INT SetPassphrase(LPCWSTR lpszPassphrase);

char* secureblackbox_pgpreader_getpassphrase(void* lpObj);
int secureblackbox_pgpreader_setpassphrase(void* lpObj, const char* lpszPassphrase);

QString GetPassphrase();
int SetPassphrase(QString qsPassphrase);

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 event.

Note that this is not the same as a secret key passphrase, which should be provided via KeyPassphrase property.

If this property is left empty or the assigned passphrase is incorrect, the PassphraseNeeded event will be fired to request the correct one.

Data Type

String

ProcessedLength Property (PGPReader Class)

Reports the number of bytes processed.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int64 GetProcessedLength();

Unicode (Windows)
LONG64 GetProcessedLength();

int64 secureblackbox_pgpreader_getprocessedlength(void* lpObj);

qint64 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.

Data Type

Long64

Profile Property (PGPReader Class)

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

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetProfile();
int SetProfile(const char* lpszProfile);

Unicode (Windows)
LPWSTR GetProfile();
INT SetProfile(LPCWSTR lpszProfile);

char* secureblackbox_pgpreader_getprofile(void* lpObj);
int secureblackbox_pgpreader_setprofile(void* lpObj, const char* lpszProfile);

QString GetProfile();
int SetProfile(QString qsProfile);

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.

Data Type

String

Signatures Property (PGPReader Class)

Contains signatures that were included in the protected message.

Syntax

• C++
• C
• Qt

SecureBlackboxList<SecureBlackboxPGPSignature>* GetSignatures();

int secureblackbox_pgpreader_getsignaturecount(void* lpObj);

int secureblackbox_pgpreader_getsignaturecertificationtype(void* lpObj, int signatureindex);

char* secureblackbox_pgpreader_getsignaturecreationtime(void* lpObj, int signatureindex);

int secureblackbox_pgpreader_getsignatureexpirationtime(void* lpObj, int signatureindex);

int secureblackbox_pgpreader_getsignatureexportable(void* lpObj, int signatureindex);

int64 secureblackbox_pgpreader_getsignaturehandle(void* lpObj, int signatureindex);

char* secureblackbox_pgpreader_getsignaturehashalgorithm(void* lpObj, int signatureindex);

int secureblackbox_pgpreader_getsignaturehashmark(void* lpObj, int signatureindex);

int secureblackbox_pgpreader_getsignaturekeyexpirationtime(void* lpObj, int signatureindex);

int secureblackbox_pgpreader_getsignaturekeyflags(void* lpObj, int signatureindex);

int secureblackbox_pgpreader_getsignaturelegacyformat(void* lpObj, int signatureindex);

char* secureblackbox_pgpreader_getsignaturepolicyurl(void* lpObj, int signatureindex);

char* secureblackbox_pgpreader_getsignaturepreferredalgorithms(void* lpObj, int signatureindex);

int secureblackbox_pgpreader_getsignatureprimaryuserid(void* lpObj, int signatureindex);

char* secureblackbox_pgpreader_getsignaturereasonforrevocation(void* lpObj, int signatureindex);

int secureblackbox_pgpreader_getsignaturerevocable(void* lpObj, int signatureindex);

int secureblackbox_pgpreader_getsignaturerevocation(void* lpObj, int signatureindex);

int secureblackbox_pgpreader_getsignaturesignatureclass(void* lpObj, int signatureindex);

char* secureblackbox_pgpreader_getsignaturesignerkeyid(void* lpObj, int signatureindex);

char* secureblackbox_pgpreader_getsignaturesigneruserid(void* lpObj, int signatureindex);

int secureblackbox_pgpreader_getsignaturestrictlyvalid(void* lpObj, int signatureindex);

char* secureblackbox_pgpreader_getsignaturetarget(void* lpObj, int signatureindex);

int secureblackbox_pgpreader_getsignaturetextsignature(void* lpObj, int signatureindex);

int secureblackbox_pgpreader_getsignaturetrustamount(void* lpObj, int signatureindex);

int secureblackbox_pgpreader_getsignaturetrustlevel(void* lpObj, int signatureindex);

int secureblackbox_pgpreader_getsignaturevalidated(void* lpObj, int signatureindex);

int secureblackbox_pgpreader_getsignaturevalidity(void* lpObj, int signatureindex);

int secureblackbox_pgpreader_getsignatureversion(void* lpObj, int signatureindex);

int GetSignatureCount();

int GetSignatureCertificationType(int iSignatureIndex);

QString GetSignatureCreationTime(int iSignatureIndex);

int GetSignatureExpirationTime(int iSignatureIndex);

bool GetSignatureExportable(int iSignatureIndex);

qint64 GetSignatureHandle(int iSignatureIndex);

QString GetSignatureHashAlgorithm(int iSignatureIndex);

int GetSignatureHashMark(int iSignatureIndex);

int GetSignatureKeyExpirationTime(int iSignatureIndex);

int GetSignatureKeyFlags(int iSignatureIndex);

bool GetSignatureLegacyFormat(int iSignatureIndex);

QString GetSignaturePolicyURL(int iSignatureIndex);

QString GetSignaturePreferredAlgorithms(int iSignatureIndex);

bool GetSignaturePrimaryUserID(int iSignatureIndex);

QString GetSignatureReasonForRevocation(int iSignatureIndex);

bool GetSignatureRevocable(int iSignatureIndex);

bool GetSignatureRevocation(int iSignatureIndex);

int GetSignatureSignatureClass(int iSignatureIndex);

QString GetSignatureSignerKeyID(int iSignatureIndex);

QString GetSignatureSignerUserID(int iSignatureIndex);

bool GetSignatureStrictlyValid(int iSignatureIndex);

QString GetSignatureTarget(int iSignatureIndex);

bool GetSignatureTextSignature(int iSignatureIndex);

int GetSignatureTrustAmount(int iSignatureIndex);

int GetSignatureTrustLevel(int iSignatureIndex);

bool GetSignatureValidated(int iSignatureIndex);

int GetSignatureValidity(int iSignatureIndex);

int GetSignatureVersion(int iSignatureIndex);

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.

Data Type

SecureBlackboxPGPSignature

VerifyingKeys Property (PGPReader Class)

A collection of keys to be used for signature verification.

Syntax

• C++
• C
• Qt

SecureBlackboxList<SecureBlackboxPGPKey>* GetVerifyingKeys();
int SetVerifyingKeys(SecureBlackboxList<SecureBlackboxPGPKey>* val);

int secureblackbox_pgpreader_getverifyingkeycount(void* lpObj);
int secureblackbox_pgpreader_setverifyingkeycount(void* lpObj, int iVerifyingKeyCount);

int64 secureblackbox_pgpreader_getverifyingkeyhandle(void* lpObj, int verifyingkeyindex);
int secureblackbox_pgpreader_setverifyingkeyhandle(void* lpObj, int verifyingkeyindex, int64 lVerifyingKeyHandle);

char* secureblackbox_pgpreader_getverifyingkeykeyfp(void* lpObj, int verifyingkeyindex);

char* secureblackbox_pgpreader_getverifyingkeykeyid(void* lpObj, int verifyingkeyindex);

char* secureblackbox_pgpreader_getverifyingkeyusername(void* lpObj, int verifyingkeyindex);

int GetVerifyingKeyCount();
int SetVerifyingKeyCount(int iVerifyingKeyCount);

qint64 GetVerifyingKeyHandle(int iVerifyingKeyIndex);
int SetVerifyingKeyHandle(int iVerifyingKeyIndex, qint64 lVerifyingKeyHandle);

QString GetVerifyingKeyKeyFP(int iVerifyingKeyIndex);

QString GetVerifyingKeyKeyID(int iVerifyingKeyIndex);

QString GetVerifyingKeyUsername(int iVerifyingKeyIndex);

Remarks

Use this property to provide verifying keys.

You will need an appropriate key to verify every signature included in the message. Use Signed event to get informed about the keys that were used for signing.

This property is not available at design time.

Data Type

SecureBlackboxPGPKey

Config Method (PGPReader Class)

Sets or retrieves a configuration setting.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* Config(const char* lpszConfigurationString);

Unicode (Windows)
LPWSTR Config(LPCWSTR lpszConfigurationString);

char* secureblackbox_pgpreader_config(void* lpObj, const char* lpszConfigurationString);

QString Config(const QString& qsConfigurationString);

Remarks

Config is a generic method available in every class. It is used to set and retrieve configuration settings 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, you must call Config("PROPERTY"). The value will be returned as a string.

Error Handling (C++)

This method returns a String value; after it returns, call the GetLastErrorCode() method to obtain its result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message.

DecryptAndVerify Method (PGPReader Class)

Decrypts and verifies a protected message.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int DecryptAndVerify();

Unicode (Windows)
INT DecryptAndVerify();

int secureblackbox_pgpreader_decryptandverify(void* lpObj);

int DecryptAndVerify();

Remarks

Use this method to unprotect a PGP message contained in a byte array (InputBytes), in a file (InputFile) or in a stream (InputStream). The method writes the decrypted message to a byte array (OutputBytes), to a file (OutputFile) or to a stream (OutputStream).

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

DoAction Method (PGPReader Class)

Performs an additional action.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* DoAction(const char* lpszActionID, const char* lpszActionParams);

Unicode (Windows)
LPWSTR DoAction(LPCWSTR lpszActionID, LPCWSTR lpszActionParams);

char* secureblackbox_pgpreader_doaction(void* lpObj, const char* lpszActionID, const char* lpszActionParams);

QString DoAction(const QString& qsActionID, const QString& qsActionParams);

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:

Error Handling (C++)

This method returns a String value; after it returns, call the GetLastErrorCode() method to obtain its result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message.

Reset Method (PGPReader Class)

Resets the class settings.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int Reset();

Unicode (Windows)
INT Reset();

int secureblackbox_pgpreader_reset(void* lpObj);

int Reset();

Remarks

Reset is a generic method available in every class.

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

VerifyDetached Method (PGPReader Class)

Verifies a detached signature.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int VerifyDetached();

Unicode (Windows)
INT VerifyDetached();

int secureblackbox_pgpreader_verifydetached(void* lpObj);

int VerifyDetached();

Remarks

Use this method to verify a detached signature contained in a byte array (DataBytes), in a file (DataFile) or in a stream (DataStream) over a message contained in a byte array (InputBytes), in a file (InputFile) or in a stream (InputStream).

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

EncryptionInfo Event (PGPReader Class)

Reports early information on encryption parameters.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireEncryptionInfo(PGPReaderEncryptionInfoEventParams *e);

typedef struct {
  const char *KeyIDs;
  int EncryptedProtection;
  int PassphraseUsed;
  int reserved;
} PGPReaderEncryptionInfoEventParams;


Unicode (Windows)
virtual INT FireEncryptionInfo(PGPReaderEncryptionInfoEventParams *e);

typedef struct {
  LPCWSTR KeyIDs;
  INT EncryptedProtection;
  BOOL PassphraseUsed;
  INT reserved;
} PGPReaderEncryptionInfoEventParams;

#define EID_PGPREADER_ENCRYPTIONINFO 1

virtual INT SECUREBLACKBOX_CALL FireEncryptionInfo(LPSTR &lpszKeyIDs, INT &iEncryptedProtection, BOOL &bPassphraseUsed);

class PGPReaderEncryptionInfoEventParams {
public:
  const QString &KeyIDs();

  int EncryptedProtection();

  bool PassphraseUsed();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void EncryptionInfo(PGPReaderEncryptionInfoEventParams *e);

// Or, subclass PGPReader and override this emitter function.
virtual int FireEncryptionInfo(PGPReaderEncryptionInfoEventParams *e) {...}

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 or Passphrase 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 Class)

Information about errors during PGP decryption/verification.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireError(PGPReaderErrorEventParams *e);

typedef struct {
  int ErrorCode;
  const char *Description;
  int reserved;
} PGPReaderErrorEventParams;


Unicode (Windows)
virtual INT FireError(PGPReaderErrorEventParams *e);

typedef struct {
  INT ErrorCode;
  LPCWSTR Description;
  INT reserved;
} PGPReaderErrorEventParams;

#define EID_PGPREADER_ERROR 2

virtual INT SECUREBLACKBOX_CALL FireError(INT &iErrorCode, LPSTR &lpszDescription);

class PGPReaderErrorEventParams {
public:
  int ErrorCode();

  const QString &Description();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void Error(PGPReaderErrorEventParams *e);

// Or, subclass PGPReader and override this emitter function.
virtual int FireError(PGPReaderErrorEventParams *e) {...}

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 Class)

Handles remote or external decryption.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireExternalDecrypt(PGPReaderExternalDecryptEventParams *e);

typedef struct {
  const char *OperationId;
  const char *Algorithm;
  const char *Pars;
  const char *EncryptedData;
  char *Data;
  int reserved;
} PGPReaderExternalDecryptEventParams;


Unicode (Windows)
virtual INT FireExternalDecrypt(PGPReaderExternalDecryptEventParams *e);

typedef struct {
  LPCWSTR OperationId;
  LPCWSTR Algorithm;
  LPCWSTR Pars;
  LPCWSTR EncryptedData;
  LPWSTR Data;
  INT reserved;
} PGPReaderExternalDecryptEventParams;

#define EID_PGPREADER_EXTERNALDECRYPT 3

virtual INT SECUREBLACKBOX_CALL FireExternalDecrypt(LPSTR &lpszOperationId, LPSTR &lpszAlgorithm, LPSTR &lpszPars, LPSTR &lpszEncryptedData, LPSTR &lpszData);

class PGPReaderExternalDecryptEventParams {
public:
  const QString &OperationId();

  const QString &Algorithm();

  const QString &Pars();

  const QString &EncryptedData();

  const QString &Data();
  void SetData(const QString &qsData);

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void ExternalDecrypt(PGPReaderExternalDecryptEventParams *e);

// Or, subclass PGPReader and override this emitter function.
virtual int FireExternalDecrypt(PGPReaderExternalDecryptEventParams *e) {...}

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 Class)

Reports the ending of file extraction process.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireFileExtractionFinish(PGPReaderFileExtractionFinishEventParams *e);

typedef struct {
  const char *FileName;
  const char *Timestamp;
  int reserved;
} PGPReaderFileExtractionFinishEventParams;


Unicode (Windows)
virtual INT FireFileExtractionFinish(PGPReaderFileExtractionFinishEventParams *e);

typedef struct {
  LPCWSTR FileName;
  LPCWSTR Timestamp;
  INT reserved;
} PGPReaderFileExtractionFinishEventParams;

#define EID_PGPREADER_FILEEXTRACTIONFINISH 4

virtual INT SECUREBLACKBOX_CALL FireFileExtractionFinish(LPSTR &lpszFileName, LPSTR &lpszTimestamp);

class PGPReaderFileExtractionFinishEventParams {
public:
  const QString &FileName();

  const QString &Timestamp();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void FileExtractionFinish(PGPReaderFileExtractionFinishEventParams *e);

// Or, subclass PGPReader and override this emitter function.
virtual int FireFileExtractionFinish(PGPReaderFileExtractionFinishEventParams *e) {...}

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.

FileExtractionStart Event (PGPReader Class)

Reports the beginning of file extraction process.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireFileExtractionStart(PGPReaderFileExtractionStartEventParams *e);

typedef struct {
  const char *FileName;
  const char *Timestamp;
  int Skip;
  int reserved;
} PGPReaderFileExtractionStartEventParams;


Unicode (Windows)
virtual INT FireFileExtractionStart(PGPReaderFileExtractionStartEventParams *e);

typedef struct {
  LPCWSTR FileName;
  LPCWSTR Timestamp;
  BOOL Skip;
  INT reserved;
} PGPReaderFileExtractionStartEventParams;

#define EID_PGPREADER_FILEEXTRACTIONSTART 5

virtual INT SECUREBLACKBOX_CALL FireFileExtractionStart(LPSTR &lpszFileName, LPSTR &lpszTimestamp, BOOL &bSkip);

class PGPReaderFileExtractionStartEventParams {
public:
  const QString &FileName();

  const QString &Timestamp();

  bool Skip();
  void SetSkip(bool bSkip);

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void FileExtractionStart(PGPReaderFileExtractionStartEventParams *e);

// Or, subclass PGPReader and override this emitter function.
virtual int FireFileExtractionStart(PGPReaderFileExtractionStartEventParams *e) {...}

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 or a stream in OutputStream. If none of them is provided, the extracted file will be placed to OutputBytes. After the file is extracted, FileExtractionFinish event is fired.

KeyPassphraseNeeded Event (PGPReader Class)

Requests a key protection password from the application.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireKeyPassphraseNeeded(PGPReaderKeyPassphraseNeededEventParams *e);

typedef struct {
  const char *KeyID;
  const char *UserID;
  int MainKey;
  char *Passphrase;
  int Skip;
  int reserved;
} PGPReaderKeyPassphraseNeededEventParams;


Unicode (Windows)
virtual INT FireKeyPassphraseNeeded(PGPReaderKeyPassphraseNeededEventParams *e);

typedef struct {
  LPCWSTR KeyID;
  LPCWSTR UserID;
  BOOL MainKey;
  LPWSTR Passphrase;
  BOOL Skip;
  INT reserved;
} PGPReaderKeyPassphraseNeededEventParams;

#define EID_PGPREADER_KEYPASSPHRASENEEDED 6

virtual INT SECUREBLACKBOX_CALL FireKeyPassphraseNeeded(LPSTR &lpszKeyID, LPSTR &lpszUserID, BOOL &bMainKey, LPSTR &lpszPassphrase, BOOL &bSkip);

class PGPReaderKeyPassphraseNeededEventParams {
public:
  const QString &KeyID();

  const QString &UserID();

  bool MainKey();

  const QString &Passphrase();
  void SetPassphrase(const QString &qsPassphrase);

  bool Skip();
  void SetSkip(bool bSkip);

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void KeyPassphraseNeeded(PGPReaderKeyPassphraseNeededEventParams *e);

// Or, subclass PGPReader and override this emitter function.
virtual int FireKeyPassphraseNeeded(PGPReaderKeyPassphraseNeededEventParams *e) {...}

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). 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 Class)

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

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireMultipleFilesFound(PGPReaderMultipleFilesFoundEventParams *e);

typedef struct {
  const char *TarFileName;
  int Proceed;
  int reserved;
} PGPReaderMultipleFilesFoundEventParams;


Unicode (Windows)
virtual INT FireMultipleFilesFound(PGPReaderMultipleFilesFoundEventParams *e);

typedef struct {
  LPCWSTR TarFileName;
  BOOL Proceed;
  INT reserved;
} PGPReaderMultipleFilesFoundEventParams;

#define EID_PGPREADER_MULTIPLEFILESFOUND 7

virtual INT SECUREBLACKBOX_CALL FireMultipleFilesFound(LPSTR &lpszTarFileName, BOOL &bProceed);

class PGPReaderMultipleFilesFoundEventParams {
public:
  const QString &TarFileName();

  bool Proceed();
  void SetProceed(bool bProceed);

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void MultipleFilesFound(PGPReaderMultipleFilesFoundEventParams *e);

// Or, subclass PGPReader and override this emitter function.
virtual int FireMultipleFilesFound(PGPReaderMultipleFilesFoundEventParams *e) {...}

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 Class)

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

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireNotification(PGPReaderNotificationEventParams *e);

typedef struct {
  const char *EventID;
  const char *EventParam;
  int reserved;
} PGPReaderNotificationEventParams;


Unicode (Windows)
virtual INT FireNotification(PGPReaderNotificationEventParams *e);

typedef struct {
  LPCWSTR EventID;
  LPCWSTR EventParam;
  INT reserved;
} PGPReaderNotificationEventParams;

#define EID_PGPREADER_NOTIFICATION 8

virtual INT SECUREBLACKBOX_CALL FireNotification(LPSTR &lpszEventID, LPSTR &lpszEventParam);

class PGPReaderNotificationEventParams {
public:
  const QString &EventID();

  const QString &EventParam();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void Notification(PGPReaderNotificationEventParams *e);

// Or, subclass PGPReader and override this emitter function.
virtual int FireNotification(PGPReaderNotificationEventParams *e) {...}

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 Class)

Requests a data protection password from the application.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FirePassphraseNeeded(PGPReaderPassphraseNeededEventParams *e);

typedef struct {
  char *Passphrase;
  int Skip;
  int reserved;
} PGPReaderPassphraseNeededEventParams;


Unicode (Windows)
virtual INT FirePassphraseNeeded(PGPReaderPassphraseNeededEventParams *e);

typedef struct {
  LPWSTR Passphrase;
  BOOL Skip;
  INT reserved;
} PGPReaderPassphraseNeededEventParams;

#define EID_PGPREADER_PASSPHRASENEEDED 9

virtual INT SECUREBLACKBOX_CALL FirePassphraseNeeded(LPSTR &lpszPassphrase, BOOL &bSkip);

class PGPReaderPassphraseNeededEventParams {
public:
  const QString &Passphrase();
  void SetPassphrase(const QString &qsPassphrase);

  bool Skip();
  void SetSkip(bool bSkip);

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void PassphraseNeeded(PGPReaderPassphraseNeededEventParams *e);

// Or, subclass PGPReader and override this emitter function.
virtual int FirePassphraseNeeded(PGPReaderPassphraseNeededEventParams *e) {...}

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 Class)

Reports the progress of the decryption operation.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireProgress(PGPReaderProgressEventParams *e);

typedef struct {
  int64 Current;
  int64 Total;
  int Cancel;
  int reserved;
} PGPReaderProgressEventParams;


Unicode (Windows)
virtual INT FireProgress(PGPReaderProgressEventParams *e);

typedef struct {
  LONG64 Current;
  LONG64 Total;
  BOOL Cancel;
  INT reserved;
} PGPReaderProgressEventParams;

#define EID_PGPREADER_PROGRESS 10

virtual INT SECUREBLACKBOX_CALL FireProgress(LONG64 &lCurrent, LONG64 &lTotal, BOOL &bCancel);

class PGPReaderProgressEventParams {
public:
  qint64 Current();

  qint64 Total();

  bool Cancel();
  void SetCancel(bool bCancel);

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void Progress(PGPReaderProgressEventParams *e);

// Or, subclass PGPReader and override this emitter function.
virtual int FireProgress(PGPReaderProgressEventParams *e) {...}

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 Class)

Notifies the application about a signed message.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireSigned(PGPReaderSignedEventParams *e);

typedef struct {
  const char *KeyIDs;
  int SignatureType;
  int reserved;
} PGPReaderSignedEventParams;


Unicode (Windows)
virtual INT FireSigned(PGPReaderSignedEventParams *e);

typedef struct {
  LPCWSTR KeyIDs;
  INT SignatureType;
  INT reserved;
} PGPReaderSignedEventParams;

#define EID_PGPREADER_SIGNED 11

virtual INT SECUREBLACKBOX_CALL FireSigned(LPSTR &lpszKeyIDs, INT &iSignatureType);

class PGPReaderSignedEventParams {
public:
  const QString &KeyIDs();

  int SignatureType();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void Signed(PGPReaderSignedEventParams *e);

// Or, subclass PGPReader and override this emitter function.
virtual int FireSigned(PGPReaderSignedEventParams *e) {...}

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 list.

SignatureType indicates the signature type:

ExternalCrypto Type

Specifies the parameters of external cryptographic calls.

Syntax

SecureBlackboxExternalCrypto (declared in secureblackbox.h)

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.

Fields

Constructors

ExternalCrypto()

PGPKey Type

This container represents a PGP key.

Syntax

SecureBlackboxPGPKey (declared in secureblackbox.h)

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).

Fields

Constructors

PGPKey()

PGPSignature Type

A container for PGP signature properties.

Syntax

SecureBlackboxPGPSignature (declared in secureblackbox.h)

Remarks

PGPSignature contains details and validation information for a PGP signature.

Fields

Constructors

PGPSignature()

SecureBlackboxList Type

Syntax

SecureBlackboxList<T> (declared in secureblackbox.h)

Remarks

SecureBlackboxList is a generic class that is used to hold a collection of objects of type T, where T is one of the custom types supported by the PGPReader class.

int GetCount() {}

int SetCount(int count) {}

T* Get(int index) {}

T* Set(int index, T* value) {}

Config Settings (PGPReader Class)

PGPReader Config Settings

Base Config Settings

Trappable Errors (PGPReader Class)

Error Handling (C++)

Call the GetLastErrorCode() method to obtain the last called method's result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. Known error codes are listed below. If an error occurs, the GetLastError() method can be called to retrieve the associated error message.

PGPReader Errors