CertificateStorage Class

Properties   Methods   Events   Config Settings   Errors  

The CertificateStorage class works with collections of certificates.

Syntax

CertificateStorage

Remarks

CertificateStorage can work with certificates residing on a variety of media. Among others, it can access certificates residing in files, Windows and macOS system stores, and PKCS#11 devices. All such kinds of media can be accessed via a simple, unified interface, which makes CertificateStorage a handy certificate access option. Most users of SecureBlackbox use this component to access certificates residing on hardware devices. CertificateStorage is also a good alternative to CertificateManager where the certificate file contains more than one certificate.

To access certificates stored on certain type of media, start with the Open method. Provide the location of your certificates via a uniform URI-like specifier. Once the storage has been opened, you can access the certificates contained in it via the Certificates property.

Iterate over certificates by using the Certificates property, or use filtering facilities such as Select and SelectChain. You can add certificates to the storage with the ImportBytes, ImportFromFile, and ImportPinned methods. In the latter case please assign the certificate object to be imported to the PinnedCert property.

Use CreateNew method to create a new storage. Note that not all storage kinds can be created.

When you have finished working with the certificate storage, close it with the Close method.

Certain types of stores must be kept open for the certificates to continue to be usable. This means that while you can copy a certificate to a different storage, or assign it to a different component, you still must keep the storage it originates from open for as long as you intend to use that certificate in your code. This is because the storage is often a bridge between a certificate and its private key, and by closing the storage early you are destroying this bridge prematurely. See the code example below: // This code, although syntactically correct, will fail because the storage is closed too early: storage.Open("pkcs11://user:12345@localhost/C:/Windows/System32/asepkcs.dll"); pdfSigner.SigningCertificate = storage.Certificates[0]; storage.Close(false); // the private key of the SigningCertificate gets lost after this call pdfSigner.Sign(); // returns an error // This code will work as expected storage.Open("pkcs11://user:12345@localhost/C:/Windows/System32/asepkcs.dll"); pdfSigner.SigningCertificate = storage.Certificates[0]; pdfSigner.Sign(); storage.Close(false);

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.

Certificates Property (CertificateStorage Class)

A collection of certificates contained in the storage.

Syntax

• C++
• C
• Qt

SecureBlackboxList<SecureBlackboxCertificate>* GetCertificates();

int secureblackbox_certificatestorage_getcertcount(void* lpObj);

int secureblackbox_certificatestorage_getcertbytes(void* lpObj, int certindex, char** lpCertBytes, int* lenCertBytes);

int secureblackbox_certificatestorage_getcertca(void* lpObj, int certindex);

int secureblackbox_certificatestorage_getcertcakeyid(void* lpObj, int certindex, char** lpCertCAKeyID, int* lenCertCAKeyID);

int secureblackbox_certificatestorage_getcertcerttype(void* lpObj, int certindex);

char* secureblackbox_certificatestorage_getcertcrldistributionpoints(void* lpObj, int certindex);

char* secureblackbox_certificatestorage_getcertcurve(void* lpObj, int certindex);

char* secureblackbox_certificatestorage_getcertfingerprint(void* lpObj, int certindex);

char* secureblackbox_certificatestorage_getcertfriendlyname(void* lpObj, int certindex);

int64 secureblackbox_certificatestorage_getcerthandle(void* lpObj, int certindex);

char* secureblackbox_certificatestorage_getcerthashalgorithm(void* lpObj, int certindex);

char* secureblackbox_certificatestorage_getcertissuer(void* lpObj, int certindex);

char* secureblackbox_certificatestorage_getcertissuerrdn(void* lpObj, int certindex);

char* secureblackbox_certificatestorage_getcertkeyalgorithm(void* lpObj, int certindex);

int secureblackbox_certificatestorage_getcertkeybits(void* lpObj, int certindex);

char* secureblackbox_certificatestorage_getcertkeyfingerprint(void* lpObj, int certindex);

int secureblackbox_certificatestorage_getcertkeyusage(void* lpObj, int certindex);

int secureblackbox_certificatestorage_getcertkeyvalid(void* lpObj, int certindex);

char* secureblackbox_certificatestorage_getcertocsplocations(void* lpObj, int certindex);

int secureblackbox_certificatestorage_getcertocspnocheck(void* lpObj, int certindex);

int secureblackbox_certificatestorage_getcertorigin(void* lpObj, int certindex);

char* secureblackbox_certificatestorage_getcertpolicyids(void* lpObj, int certindex);

int secureblackbox_certificatestorage_getcertprivatekeybytes(void* lpObj, int certindex, char** lpCertPrivateKeyBytes, int* lenCertPrivateKeyBytes);

int secureblackbox_certificatestorage_getcertprivatekeyexists(void* lpObj, int certindex);

int secureblackbox_certificatestorage_getcertprivatekeyextractable(void* lpObj, int certindex);

int secureblackbox_certificatestorage_getcertpublickeybytes(void* lpObj, int certindex, char** lpCertPublicKeyBytes, int* lenCertPublicKeyBytes);

int secureblackbox_certificatestorage_getcertqualified(void* lpObj, int certindex);

int secureblackbox_certificatestorage_getcertqualifiedstatements(void* lpObj, int certindex);

char* secureblackbox_certificatestorage_getcertqualifiers(void* lpObj, int certindex);

int secureblackbox_certificatestorage_getcertselfsigned(void* lpObj, int certindex);

int secureblackbox_certificatestorage_getcertserialnumber(void* lpObj, int certindex, char** lpCertSerialNumber, int* lenCertSerialNumber);

char* secureblackbox_certificatestorage_getcertsigalgorithm(void* lpObj, int certindex);

int secureblackbox_certificatestorage_getcertsource(void* lpObj, int certindex);

char* secureblackbox_certificatestorage_getcertsubject(void* lpObj, int certindex);

char* secureblackbox_certificatestorage_getcertsubjectalternativename(void* lpObj, int certindex);

int secureblackbox_certificatestorage_getcertsubjectkeyid(void* lpObj, int certindex, char** lpCertSubjectKeyID, int* lenCertSubjectKeyID);

char* secureblackbox_certificatestorage_getcertsubjectrdn(void* lpObj, int certindex);

int secureblackbox_certificatestorage_getcertvalid(void* lpObj, int certindex);

char* secureblackbox_certificatestorage_getcertvalidfrom(void* lpObj, int certindex);

char* secureblackbox_certificatestorage_getcertvalidto(void* lpObj, int certindex);

int GetCertCount();

QByteArray GetCertBytes(int iCertIndex);

bool GetCertCA(int iCertIndex);

QByteArray GetCertCAKeyID(int iCertIndex);

int GetCertCertType(int iCertIndex);

QString GetCertCRLDistributionPoints(int iCertIndex);

QString GetCertCurve(int iCertIndex);

QString GetCertFingerprint(int iCertIndex);

QString GetCertFriendlyName(int iCertIndex);

qint64 GetCertHandle(int iCertIndex);

QString GetCertHashAlgorithm(int iCertIndex);

QString GetCertIssuer(int iCertIndex);

QString GetCertIssuerRDN(int iCertIndex);

QString GetCertKeyAlgorithm(int iCertIndex);

int GetCertKeyBits(int iCertIndex);

QString GetCertKeyFingerprint(int iCertIndex);

int GetCertKeyUsage(int iCertIndex);

bool GetCertKeyValid(int iCertIndex);

QString GetCertOCSPLocations(int iCertIndex);

bool GetCertOCSPNoCheck(int iCertIndex);

int GetCertOrigin(int iCertIndex);

QString GetCertPolicyIDs(int iCertIndex);

QByteArray GetCertPrivateKeyBytes(int iCertIndex);

bool GetCertPrivateKeyExists(int iCertIndex);

bool GetCertPrivateKeyExtractable(int iCertIndex);

QByteArray GetCertPublicKeyBytes(int iCertIndex);

bool GetCertQualified(int iCertIndex);

int GetCertQualifiedStatements(int iCertIndex);

QString GetCertQualifiers(int iCertIndex);

bool GetCertSelfSigned(int iCertIndex);

QByteArray GetCertSerialNumber(int iCertIndex);

QString GetCertSigAlgorithm(int iCertIndex);

int GetCertSource(int iCertIndex);

QString GetCertSubject(int iCertIndex);

QString GetCertSubjectAlternativeName(int iCertIndex);

QByteArray GetCertSubjectKeyID(int iCertIndex);

QString GetCertSubjectRDN(int iCertIndex);

bool GetCertValid(int iCertIndex);

QString GetCertValidFrom(int iCertIndex);

QString GetCertValidTo(int iCertIndex);

Remarks

Use this property to access all certificates contained in the opened storage.

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

Data Type

SecureBlackboxCertificate

CRLs Property (CertificateStorage Class)

A collection of CRLs contained in the storage.

Syntax

• C++
• C
• Qt

SecureBlackboxList<SecureBlackboxCRL>* GetCRLs();

int secureblackbox_certificatestorage_getcrlcount(void* lpObj);

int secureblackbox_certificatestorage_getcrlbytes(void* lpObj, int crlindex, char** lpCRLBytes, int* lenCRLBytes);

int secureblackbox_certificatestorage_getcrlcakeyid(void* lpObj, int crlindex, char** lpCRLCAKeyID, int* lenCRLCAKeyID);

int secureblackbox_certificatestorage_getcrlentrycount(void* lpObj, int crlindex);

int64 secureblackbox_certificatestorage_getcrlhandle(void* lpObj, int crlindex);

char* secureblackbox_certificatestorage_getcrlissuer(void* lpObj, int crlindex);

char* secureblackbox_certificatestorage_getcrlissuerrdn(void* lpObj, int crlindex);

char* secureblackbox_certificatestorage_getcrllocation(void* lpObj, int crlindex);

char* secureblackbox_certificatestorage_getcrlnextupdate(void* lpObj, int crlindex);

char* secureblackbox_certificatestorage_getcrlsigalgorithm(void* lpObj, int crlindex);

int secureblackbox_certificatestorage_getcrlsource(void* lpObj, int crlindex);

int secureblackbox_certificatestorage_getcrltbs(void* lpObj, int crlindex, char** lpCRLTBS, int* lenCRLTBS);

char* secureblackbox_certificatestorage_getcrlthisupdate(void* lpObj, int crlindex);

int GetCRLCount();

QByteArray GetCRLBytes(int iCRLIndex);

QByteArray GetCRLCAKeyID(int iCRLIndex);

int GetCRLEntryCount(int iCRLIndex);

qint64 GetCRLHandle(int iCRLIndex);

QString GetCRLIssuer(int iCRLIndex);

QString GetCRLIssuerRDN(int iCRLIndex);

QString GetCRLLocation(int iCRLIndex);

QString GetCRLNextUpdate(int iCRLIndex);

QString GetCRLSigAlgorithm(int iCRLIndex);

int GetCRLSource(int iCRLIndex);

QByteArray GetCRLTBS(int iCRLIndex);

QString GetCRLThisUpdate(int iCRLIndex);

Remarks

Use this property to access all CRLs contained in the opened storage.

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

Data Type

SecureBlackboxCRL

FIPSMode Property (CertificateStorage 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_certificatestorage_getfipsmode(void* lpObj);
int secureblackbox_certificatestorage_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

OCSPs Property (CertificateStorage Class)

A collection of OCSP responses contained in the storage.

Syntax

• C++
• C
• Qt

SecureBlackboxList<SecureBlackboxOCSPResponse>* GetOCSPs();

int secureblackbox_certificatestorage_getocspcount(void* lpObj);

int secureblackbox_certificatestorage_getocspbytes(void* lpObj, int ocspindex, char** lpOCSPBytes, int* lenOCSPBytes);

int secureblackbox_certificatestorage_getocspentrycount(void* lpObj, int ocspindex);

int64 secureblackbox_certificatestorage_getocsphandle(void* lpObj, int ocspindex);

char* secureblackbox_certificatestorage_getocspissuer(void* lpObj, int ocspindex);

char* secureblackbox_certificatestorage_getocspissuerrdn(void* lpObj, int ocspindex);

char* secureblackbox_certificatestorage_getocsplocation(void* lpObj, int ocspindex);

char* secureblackbox_certificatestorage_getocspproducedat(void* lpObj, int ocspindex);

char* secureblackbox_certificatestorage_getocspsigalgorithm(void* lpObj, int ocspindex);

int secureblackbox_certificatestorage_getocspsource(void* lpObj, int ocspindex);

int GetOCSPCount();

QByteArray GetOCSPBytes(int iOCSPIndex);

int GetOCSPEntryCount(int iOCSPIndex);

qint64 GetOCSPHandle(int iOCSPIndex);

QString GetOCSPIssuer(int iOCSPIndex);

QString GetOCSPIssuerRDN(int iOCSPIndex);

QString GetOCSPLocation(int iOCSPIndex);

QString GetOCSPProducedAt(int iOCSPIndex);

QString GetOCSPSigAlgorithm(int iOCSPIndex);

int GetOCSPSource(int iOCSPIndex);

Remarks

Use this property to access all OCSP responses contained in the opened storage.

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

Data Type

SecureBlackboxOCSPResponse

Opened Property (CertificateStorage Class)

Indicates whether the storage is in the open state.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int GetOpened();

Unicode (Windows)
BOOL GetOpened();

int secureblackbox_certificatestorage_getopened(void* lpObj);

bool GetOpened();

Default Value

FALSE

Remarks

Use this property to check if the storage has been 'opened.' Different kinds of certificate storages imply different meanings for 'being opened', but generally a storage is open if it is available for operations.

Use Open method to open a storage.

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

Data Type

Boolean

PinnedCert Property (CertificateStorage Class)

A pinned certificate.

Syntax

• C++
• C
• Qt

SecureBlackboxCertificate* GetPinnedCert();
int SetPinnedCert(SecureBlackboxCertificate* val);

int secureblackbox_certificatestorage_getpinnedcertbytes(void* lpObj, char** lpPinnedCertBytes, int* lenPinnedCertBytes);

int64 secureblackbox_certificatestorage_getpinnedcerthandle(void* lpObj);
int secureblackbox_certificatestorage_setpinnedcerthandle(void* lpObj, int64 lPinnedCertHandle);

QByteArray GetPinnedCertBytes();

qint64 GetPinnedCertHandle();
int SetPinnedCertHandle(qint64 lPinnedCertHandle);

Remarks

Use this property to pin a certificate before adding it to the storage with ImportPinned method.

This property is not available at design time.

Data Type

SecureBlackboxCertificate

PinnedCRL Property (CertificateStorage Class)

A pinned CRL object.

Syntax

• C++
• C
• Qt

SecureBlackboxCRL* GetPinnedCRL();
int SetPinnedCRL(SecureBlackboxCRL* val);

int secureblackbox_certificatestorage_getpinnedcrlbytes(void* lpObj, char** lpPinnedCRLBytes, int* lenPinnedCRLBytes);

int64 secureblackbox_certificatestorage_getpinnedcrlhandle(void* lpObj);
int secureblackbox_certificatestorage_setpinnedcrlhandle(void* lpObj, int64 lPinnedCRLHandle);

QByteArray GetPinnedCRLBytes();

qint64 GetPinnedCRLHandle();
int SetPinnedCRLHandle(qint64 lPinnedCRLHandle);

Remarks

Use this property to pin a CRL before adding it to the storage with ImportPinned method.

This property is not available at design time.

Data Type

SecureBlackboxCRL

PinnedOCSP Property (CertificateStorage Class)

A pinned OCSP response object.

Syntax

• C++
• C
• Qt

SecureBlackboxOCSPResponse* GetPinnedOCSP();
int SetPinnedOCSP(SecureBlackboxOCSPResponse* val);

int secureblackbox_certificatestorage_getpinnedocspbytes(void* lpObj, char** lpPinnedOCSPBytes, int* lenPinnedOCSPBytes);

int64 secureblackbox_certificatestorage_getpinnedocsphandle(void* lpObj);
int secureblackbox_certificatestorage_setpinnedocsphandle(void* lpObj, int64 lPinnedOCSPHandle);

QByteArray GetPinnedOCSPBytes();

qint64 GetPinnedOCSPHandle();
int SetPinnedOCSPHandle(qint64 lPinnedOCSPHandle);

Remarks

Use this property to pin an OCSP response before adding it to the storage with ImportPinned method.

This property is not available at design time.

Data Type

SecureBlackboxOCSPResponse

SelectedCertificates Property (CertificateStorage Class)

A collection of selected certificates.

Syntax

• C++
• C
• Qt

SecureBlackboxList<SecureBlackboxCertificate>* GetSelectedCertificates();

int secureblackbox_certificatestorage_getselectedcertcount(void* lpObj);

int secureblackbox_certificatestorage_getselectedcertbytes(void* lpObj, int selectedcertindex, char** lpSelectedCertBytes, int* lenSelectedCertBytes);

int secureblackbox_certificatestorage_getselectedcertca(void* lpObj, int selectedcertindex);

int secureblackbox_certificatestorage_getselectedcertcakeyid(void* lpObj, int selectedcertindex, char** lpSelectedCertCAKeyID, int* lenSelectedCertCAKeyID);

int secureblackbox_certificatestorage_getselectedcertcerttype(void* lpObj, int selectedcertindex);

char* secureblackbox_certificatestorage_getselectedcertcrldistributionpoints(void* lpObj, int selectedcertindex);

char* secureblackbox_certificatestorage_getselectedcertcurve(void* lpObj, int selectedcertindex);

char* secureblackbox_certificatestorage_getselectedcertfingerprint(void* lpObj, int selectedcertindex);

char* secureblackbox_certificatestorage_getselectedcertfriendlyname(void* lpObj, int selectedcertindex);

int64 secureblackbox_certificatestorage_getselectedcerthandle(void* lpObj, int selectedcertindex);

char* secureblackbox_certificatestorage_getselectedcerthashalgorithm(void* lpObj, int selectedcertindex);

char* secureblackbox_certificatestorage_getselectedcertissuer(void* lpObj, int selectedcertindex);

char* secureblackbox_certificatestorage_getselectedcertissuerrdn(void* lpObj, int selectedcertindex);

char* secureblackbox_certificatestorage_getselectedcertkeyalgorithm(void* lpObj, int selectedcertindex);

int secureblackbox_certificatestorage_getselectedcertkeybits(void* lpObj, int selectedcertindex);

char* secureblackbox_certificatestorage_getselectedcertkeyfingerprint(void* lpObj, int selectedcertindex);

int secureblackbox_certificatestorage_getselectedcertkeyusage(void* lpObj, int selectedcertindex);

int secureblackbox_certificatestorage_getselectedcertkeyvalid(void* lpObj, int selectedcertindex);

char* secureblackbox_certificatestorage_getselectedcertocsplocations(void* lpObj, int selectedcertindex);

int secureblackbox_certificatestorage_getselectedcertocspnocheck(void* lpObj, int selectedcertindex);

int secureblackbox_certificatestorage_getselectedcertorigin(void* lpObj, int selectedcertindex);

char* secureblackbox_certificatestorage_getselectedcertpolicyids(void* lpObj, int selectedcertindex);

int secureblackbox_certificatestorage_getselectedcertprivatekeybytes(void* lpObj, int selectedcertindex, char** lpSelectedCertPrivateKeyBytes, int* lenSelectedCertPrivateKeyBytes);

int secureblackbox_certificatestorage_getselectedcertprivatekeyexists(void* lpObj, int selectedcertindex);

int secureblackbox_certificatestorage_getselectedcertprivatekeyextractable(void* lpObj, int selectedcertindex);

int secureblackbox_certificatestorage_getselectedcertpublickeybytes(void* lpObj, int selectedcertindex, char** lpSelectedCertPublicKeyBytes, int* lenSelectedCertPublicKeyBytes);

int secureblackbox_certificatestorage_getselectedcertqualified(void* lpObj, int selectedcertindex);

int secureblackbox_certificatestorage_getselectedcertqualifiedstatements(void* lpObj, int selectedcertindex);

char* secureblackbox_certificatestorage_getselectedcertqualifiers(void* lpObj, int selectedcertindex);

int secureblackbox_certificatestorage_getselectedcertselfsigned(void* lpObj, int selectedcertindex);

int secureblackbox_certificatestorage_getselectedcertserialnumber(void* lpObj, int selectedcertindex, char** lpSelectedCertSerialNumber, int* lenSelectedCertSerialNumber);

char* secureblackbox_certificatestorage_getselectedcertsigalgorithm(void* lpObj, int selectedcertindex);

int secureblackbox_certificatestorage_getselectedcertsource(void* lpObj, int selectedcertindex);

char* secureblackbox_certificatestorage_getselectedcertsubject(void* lpObj, int selectedcertindex);

char* secureblackbox_certificatestorage_getselectedcertsubjectalternativename(void* lpObj, int selectedcertindex);

int secureblackbox_certificatestorage_getselectedcertsubjectkeyid(void* lpObj, int selectedcertindex, char** lpSelectedCertSubjectKeyID, int* lenSelectedCertSubjectKeyID);

char* secureblackbox_certificatestorage_getselectedcertsubjectrdn(void* lpObj, int selectedcertindex);

int secureblackbox_certificatestorage_getselectedcertvalid(void* lpObj, int selectedcertindex);

char* secureblackbox_certificatestorage_getselectedcertvalidfrom(void* lpObj, int selectedcertindex);

char* secureblackbox_certificatestorage_getselectedcertvalidto(void* lpObj, int selectedcertindex);

int GetSelectedCertCount();

QByteArray GetSelectedCertBytes(int iSelectedCertIndex);

bool GetSelectedCertCA(int iSelectedCertIndex);

QByteArray GetSelectedCertCAKeyID(int iSelectedCertIndex);

int GetSelectedCertCertType(int iSelectedCertIndex);

QString GetSelectedCertCRLDistributionPoints(int iSelectedCertIndex);

QString GetSelectedCertCurve(int iSelectedCertIndex);

QString GetSelectedCertFingerprint(int iSelectedCertIndex);

QString GetSelectedCertFriendlyName(int iSelectedCertIndex);

qint64 GetSelectedCertHandle(int iSelectedCertIndex);

QString GetSelectedCertHashAlgorithm(int iSelectedCertIndex);

QString GetSelectedCertIssuer(int iSelectedCertIndex);

QString GetSelectedCertIssuerRDN(int iSelectedCertIndex);

QString GetSelectedCertKeyAlgorithm(int iSelectedCertIndex);

int GetSelectedCertKeyBits(int iSelectedCertIndex);

QString GetSelectedCertKeyFingerprint(int iSelectedCertIndex);

int GetSelectedCertKeyUsage(int iSelectedCertIndex);

bool GetSelectedCertKeyValid(int iSelectedCertIndex);

QString GetSelectedCertOCSPLocations(int iSelectedCertIndex);

bool GetSelectedCertOCSPNoCheck(int iSelectedCertIndex);

int GetSelectedCertOrigin(int iSelectedCertIndex);

QString GetSelectedCertPolicyIDs(int iSelectedCertIndex);

QByteArray GetSelectedCertPrivateKeyBytes(int iSelectedCertIndex);

bool GetSelectedCertPrivateKeyExists(int iSelectedCertIndex);

bool GetSelectedCertPrivateKeyExtractable(int iSelectedCertIndex);

QByteArray GetSelectedCertPublicKeyBytes(int iSelectedCertIndex);

bool GetSelectedCertQualified(int iSelectedCertIndex);

int GetSelectedCertQualifiedStatements(int iSelectedCertIndex);

QString GetSelectedCertQualifiers(int iSelectedCertIndex);

bool GetSelectedCertSelfSigned(int iSelectedCertIndex);

QByteArray GetSelectedCertSerialNumber(int iSelectedCertIndex);

QString GetSelectedCertSigAlgorithm(int iSelectedCertIndex);

int GetSelectedCertSource(int iSelectedCertIndex);

QString GetSelectedCertSubject(int iSelectedCertIndex);

QString GetSelectedCertSubjectAlternativeName(int iSelectedCertIndex);

QByteArray GetSelectedCertSubjectKeyID(int iSelectedCertIndex);

QString GetSelectedCertSubjectRDN(int iSelectedCertIndex);

bool GetSelectedCertValid(int iSelectedCertIndex);

QString GetSelectedCertValidFrom(int iSelectedCertIndex);

QString GetSelectedCertValidTo(int iSelectedCertIndex);

Remarks

This property contains a list of certificates returned by Select or SelectChain method.

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

Data Type

SecureBlackboxCertificate

StorageID Property (CertificateStorage Class)

A unique identifier of this storage.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetStorageID();

Unicode (Windows)
LPWSTR GetStorageID();

char* secureblackbox_certificatestorage_getstorageid(void* lpObj);

QString GetStorageID();

Default Value

""

Remarks

Use this property to get a unique ID of this storage. The format of ID may differ for different kinds of certificate storages, and may range from a file path for a file storage, to a URI-like ID for a PKCS#11 storage, to an empty value for an in-memory storage.

This property is read-only.

Data Type

String

StorageLocation Property (CertificateStorage Class)

Specifies the location of the currently opened storage.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetStorageLocation();

Unicode (Windows)
LPWSTR GetStorageLocation();

char* secureblackbox_certificatestorage_getstoragelocation(void* lpObj);

QString GetStorageLocation();

Default Value

""

Remarks

Use this property to get the location of the active storage. The location indicates the nature of the storage and can be assigned with one of the below values (more values may be added in future):

This property is read-only.

Data Type

String

Clear Method (CertificateStorage Class)

Removes all certificates from the storage.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int Clear();

Unicode (Windows)
INT Clear();

int secureblackbox_certificatestorage_clear(void* lpObj);

int Clear();

Remarks

Use this method to empty the storage.

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

Close Method (CertificateStorage Class)

Closes the certificate storage.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int Close(int bSave);

Unicode (Windows)
INT Close(BOOL bSave);

int secureblackbox_certificatestorage_close(void* lpObj, int bSave);

int Close(bool bSave);

Remarks

Use this method to close the storage component and clean up any resources associated with it.

This method releases all memory objects and handles associated with the certificates contained in the storage. Any certificate objects originating from the storage become invalid as soon as the storage is closed, and should not be used.

Save parameter only applies to certain types of stores, such as file stores. Set it to True to commit any changes to the underlying media. Note that PKCS#11 and Win32 storage types are of transactional nature and commit any changes immediately, so the value of the Save parameter does not make any difference with them.

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

Config Method (CertificateStorage 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_certificatestorage_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.

CreateNew Method (CertificateStorage Class)

Creates a new storage.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int CreateNew(const char* lpszStorageLocation, const char* lpszStorageID);

Unicode (Windows)
INT CreateNew(LPCWSTR lpszStorageLocation, LPCWSTR lpszStorageID);

int secureblackbox_certificatestorage_createnew(void* lpObj, const char* lpszStorageLocation, const char* lpszStorageID);

int CreateNew(const QString& qsStorageLocation, const QString& qsStorageID);

Remarks

Use this method to create new certificate storage.

StorageLocation specifies where the new storage should be created, and StorageID contains a unique storage identifier.

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 (CertificateStorage 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_certificatestorage_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.

ExportBytes Method (CertificateStorage Class)

Exports the certificates in the chosen format.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* ExportBytes(int iWhat, int iFormat, const char* lpszPassword, int *lpSize = NULL);

Unicode (Windows)
LPSTR ExportBytes(INT iWhat, INT iFormat, LPCWSTR lpszPassword, LPINT lpSize = NULL);

char* secureblackbox_certificatestorage_exportbytes(void* lpObj, int iWhat, int iFormat, const char* lpszPassword, int *lpSize);

QByteArray ExportBytes(int iWhat, int iFormat, const QString& qsPassword);

Remarks

Use this method to save the certificates in one of the formats defined below.

Pass the encryption password via the Password parameter if needed.

Note that not all formats support encryption, and some (like PEM) only support partial encryption (key only). Keep this in mind when considering which format to choose for storing your certificates.

Error Handling (C++)

This method returns a Byte Array value (with length lpSize); 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.

ExportToFile Method (CertificateStorage Class)

Exports the certificates to a file.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int ExportToFile(int iWhat, const char* lpszFileName, int iFormat, const char* lpszPassword);

Unicode (Windows)
INT ExportToFile(INT iWhat, LPCWSTR lpszFileName, INT iFormat, LPCWSTR lpszPassword);

int secureblackbox_certificatestorage_exporttofile(void* lpObj, int iWhat, const char* lpszFileName, int iFormat, const char* lpszPassword);

int ExportToFile(int iWhat, const QString& qsFileName, int iFormat, const QString& qsPassword);

Remarks

Use this method to save the certificates to a file in one of the formats given below. Pass the encryption password via the Password parameter.

Note that not all formats support encryption, and some (like PEM) only support partial encryption (key only). Keep this in mind when considering which format to choose for storing your certificates.

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

ExportToStream Method (CertificateStorage Class)

Exports the certificate to a stream.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int ExportToStream(int iWhat, SecureBlackboxStream* sCertStream, int iFormat, const char* lpszPassword);

Unicode (Windows)
INT ExportToStream(INT iWhat, SecureBlackboxStream* sCertStream, INT iFormat, LPCWSTR lpszPassword);

int secureblackbox_certificatestorage_exporttostream(void* lpObj, int iWhat, SecureBlackboxStream* sCertStream, int iFormat, const char* lpszPassword);

int ExportToStream(int iWhat, SecureBlackboxStream* sCertStream, int iFormat, const QString& qsPassword);

Remarks

Use this method to save the certificate to a stream in one of the formats given below. Pass the encryption password via the Password parameter.

Note that not all formats support encryption, and some (like PEM) only support partial encryption (key only). Keep this in mind when considering which format to choose for storing your certificates.

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

GetStorageProperty Method (CertificateStorage Class)

Returns the value of a custom certificate storage property.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetStorageProperty(const char* lpszName);

Unicode (Windows)
LPWSTR GetStorageProperty(LPCWSTR lpszName);

char* secureblackbox_certificatestorage_getstorageproperty(void* lpObj, const char* lpszName);

QString GetStorageProperty(const QString& qsName);

Remarks

This method, together with SetStorageProperty, provides an extensible way of managing the certificate storage's settings that are not available through the primary properties of the component. The list of settings may be extended in future, in response to emergence of new storage variants and recognition of non-obvious storage usage scenarios.

The following certificate storage properties can be read using this method:

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.

ImportBytes Method (CertificateStorage Class)

Imports a certificate.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int ImportBytes(const char* lpCertBytes, int lenCertBytes, const char* lpszPassword, int bClear);

Unicode (Windows)
INT ImportBytes(LPCSTR lpCertBytes, INT lenCertBytes, LPCWSTR lpszPassword, BOOL bClear);

int secureblackbox_certificatestorage_importbytes(void* lpObj, const char* lpCertBytes, int lenCertBytes, const char* lpszPassword, int bClear);

int ImportBytes(QByteArray qbaCertBytes, const QString& qsPassword, bool bClear);

Remarks

Use this method to load a certificate or certificates from a byte array. Provide the password via the Password parameter. The Password parameter is optional. If it is omitted and it is later discovered that the certificate is password-encrypted, the PasswordNeeded event will be fired to request it.

This method supports certificates in DER, PEM, PFX, and SPC formats. Multi-certificate blobs certificate files are supported.

Use the Clear parameter to tell the component whether it should empty the storage before importing the new certificates.

Hint: use this method with Clear set to false to mimic the behavior of the previous version's Add() method.

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

ImportFromFile Method (CertificateStorage Class)

Loads a certificate from a file.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int ImportFromFile(const char* lpszPath, const char* lpszPassword, int bClear);

Unicode (Windows)
INT ImportFromFile(LPCWSTR lpszPath, LPCWSTR lpszPassword, BOOL bClear);

int secureblackbox_certificatestorage_importfromfile(void* lpObj, const char* lpszPath, const char* lpszPassword, int bClear);

int ImportFromFile(const QString& qsPath, const QString& qsPassword, bool bClear);

Remarks

This method can load certificates saved in a file in one of the following formats: DER, PEM, PFX, SPC.

Use the Path parameter to provide a path to the certificate file, and Password to specify the password.

The Password parameter is optional. If it is omitted and it is later discovered that the certificate is password-encrypted, the PasswordNeeded event will be fired to request it.

This method supports certificates in DER, PEM, PFX, and SPC formats. Multi-certificate blobs certificate files are supported.

Use the Clear parameter to tell the component whether it should empty the storage before importing the new certificates.

Hint: use this method with Clear set to false to mimic the behavior of the previous version's AddFromFile() method.

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

ImportFromStream Method (CertificateStorage Class)

Loads a certificate from a stream.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int ImportFromStream(SecureBlackboxStream* sCertStream, const char* lpszPassword, int bClear);

Unicode (Windows)
INT ImportFromStream(SecureBlackboxStream* sCertStream, LPCWSTR lpszPassword, BOOL bClear);

int secureblackbox_certificatestorage_importfromstream(void* lpObj, SecureBlackboxStream* sCertStream, const char* lpszPassword, int bClear);

int ImportFromStream(SecureBlackboxStream* sCertStream, const QString& qsPassword, bool bClear);

Remarks

This method can load certificates saved in one of the following formats: DER, PEM, PFX, SPC.

Use the CertStream parameter to provide a stream containing the certificate data, and Password to specify the password. The Password parameter is optional. If it is omitted and it is later discovered that the certificate is password-encrypted, the PasswordNeeded event will be fired to request it.

This method supports certificates in DER, PEM, PFX, and SPC formats. Multi-certificate blobs certificate files are supported.

Use the Clear parameter to tell the component whether it should empty the storage before importing the new certificates.

Hint: use this method with Clear set to false to mimic the behavior of the previous version's AddFromStream() method.

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

ImportPinned Method (CertificateStorage Class)

Adds the pinned certificate to the storage.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int ImportPinned(int bClear);

Unicode (Windows)
INT ImportPinned(BOOL bClear);

int secureblackbox_certificatestorage_importpinned(void* lpObj, int bClear);

int ImportPinned(bool bClear);

Remarks

This method adds a certificate attached to the PinnedCert property into the storage. This method is a handy way of adding certificates generated/returned by other components.

Use the Clear parameter to tell the component whether it should empty the storage before importing the new certificate.

Hint: use this method with Clear set to false to mimic the behavior of the previous version's AddPinned() method.

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

ListStores Method (CertificateStorage Class)

Returns a list of individual stores available within the storage.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* ListStores();

Unicode (Windows)
LPWSTR ListStores();

char* secureblackbox_certificatestorage_liststores(void* lpObj);

QString ListStores();

Remarks

Use this method to query a list of individual stores available in the opened storage.

The contents of the list depends on the type of the store used and the parameters it is opened with. For system (CryptoAPI) stores the method returns a list of available system stores for the chosen access type, as returned by Windows (e.g. MY, ADDRESSBOOK, CA). For PKCS#11 stores the method returns a list of slot descriptions for all slots published by the driver.

The store names are separated from each other with a CRLF sequence.

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.

Login Method (CertificateStorage Class)

Signs in to a session or elevates the session rights.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int Login(int iSessionType, const char* lpszPin, int bReadOnly);

Unicode (Windows)
INT Login(INT iSessionType, LPCWSTR lpszPin, BOOL bReadOnly);

int secureblackbox_certificatestorage_login(void* lpObj, int iSessionType, const char* lpszPin, int bReadOnly);

int Login(int iSessionType, const QString& qsPin, bool bReadOnly);

Remarks

Use this method to sign in to a session with a required access type. Note that in some cases you may call this method more than one time for a specific session to elevate your access rights, for example: // open an unauthenticated session storage.Login(stUnauthenticated, "", false); // elevate the access rights for the session storage.Login(stUser, "password", false); Sessions are currently supported for PKCS#11 storage types only.

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

Logout Method (CertificateStorage Class)

Signs out of an opened session.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int Logout(int bCloseSesion);

Unicode (Windows)
INT Logout(BOOL bCloseSesion);

int secureblackbox_certificatestorage_logout(void* lpObj, int bCloseSesion);

int Logout(bool bCloseSesion);

Remarks

Use this method to sign out of a session. Pass true to CloseSession to shut the session down altogether.

This method is currently support for PKCS#11 storage type only.

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

Open Method (CertificateStorage Class)

Opens existing storage or creates one in memory.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int Open(const char* lpszStorageID);

Unicode (Windows)
INT Open(LPCWSTR lpszStorageID);

int secureblackbox_certificatestorage_open(void* lpObj, const char* lpszStorageID);

int Open(const QString& qsStorageID);

Remarks

Use this method to open the storage with the given StorageID. Certificate storages can come from several different locations, detailed below.

Memory

A storage can be created in memory by passing an empty string ("").

File

A storage can be opened from a file using one of two syntaxes:

• C:\Certs\certs.pem
• file://C:/Certs/certs.pem

Windows System

A storage can be opened from the Windows System using this syntax: system://{user}@{host}/?{params}

user is one of these values:

• currentuser
• localmachine
• currentservice

params are chosen from this list:

• store (required), is the name of the Windows store to access (e.g. "MY")
• readonly, whether to access the store with only read permissions. Use 0 for false, and 1 for true.

PKCS#11 Device

A storage can be opened from a PKCS#11 device using this syntax: pkcs11://{user}:{pin}@/{driverpath}?{params}

user is the username used to access the device; typically it's either "user" or "admin".

pin is the pin code used to access the device.

driverpath is the path to the driver used to access the device.

params are chosen from this list:

• slot, the token slot to access on the device. If not provided, one will be chosen automatically. If set to -1, no session will be opened.
• readonly, whether to access the device with only read permissions. Use 0 for false, and 1 for true.
• login, whether to sign in to the device with a PIN. Use 0 or no to avoid signing in, or 1 or yes to enforce it. When not specified, the yes mode is used.

macOS

A keychain can be opened on macOS using this syntax: macos://:{password}@/{keychain}?{params}

This is the right way to perform cryptographic operations using private keys, including non-exportable private keys. By now, only certificates with RSA keys are supported, other certificates are not listed and are not used.

keychain is the path to a keychain file. If no keychain specified, the default keychain is opened.

password is the keychain access password. If no password is provided, it will be asked by macOS UI if necessary. To access a keychain in readonly mode, no password is needed usually.

params are chosen from this list:

• readonly, whether to access the keychain with only read permissions. Use 0 for false, and 1 for true.

iOS

A keychain can be opened on iOS using this syntax: ios:///?{params}

iOS doesn't support keychains located in files. By now, only certificates with RSA keys are supported, other certificates are not listed and are not used.

params are chosen from this list:

• readonly, whether to access the keychain with only read permissions. Use 0 for false, and 1 for true.

KMIP Server

A storage can be opened from a KMIP server using this syntax: mailto:{password}@{remotehost}:{remoteport}/?{params}

password is the password use to authenticate to the server.

remotehost is the FQDN to the server.

remoteport is the server port to connect to.

params are chosen from this list:

• encoder, the message encoding used to communicate with the server. Possible values are:
  • 1 (XML)
  • 2 (JSON)
  • 3 (TTLV)

Apple

A storage can be opened on macOS using this syntax: apple:///{path}/?{params}

This is a legacy way to work with keychains on macOS and iOS.

path is the path for storage file.

params are chosen from this list:

• keychainindex, key chain index. If not provided, one will be set to 0.
• readonly, whether to access the storage with only read permissions. Use 0 for false, and 1 for true.

params are chosen from this list:

• readonly, whether to access the storage with only read permissions. Use 0 for false, and 1 for true.

In Xamarin projects for iOS keychain support should be enabled manually. To do this: 1. Double click on Entitlements.plist file, go to "Entitlements" tab and turn "Enable Keychain" option on. 2. Go to project options, select "iOS Bundle Signing", choose correct configuration and platform and set "Custom Entitlements" to "Entitlements.plist" value.

Azure Key Vault

A storage can be opened from the Azure Key Vault service using this syntax: vault://{clientid}:{clientsecret}@{vaultname}.{vaulthost}/

clientid is the client id obtained from Azure Portal when registering an app.

clientsecret is the client secret obtained from Azure Portal when registering an app.

vaultname is the name of the vault to connect to.

vaulthost is the Cloud environment where the vault is located; supported environments are:

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

Refresh Method (CertificateStorage Class)

Refreshes all storage keychains.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int Refresh();

Unicode (Windows)
INT Refresh();

int secureblackbox_certificatestorage_refresh(void* lpObj);

int Refresh();

Remarks

Call this method to refresh the storage.

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

Remove Method (CertificateStorage Class)

Removes a certificate from the storage.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int Remove(int iIndex);

Unicode (Windows)
INT Remove(INT iIndex);

int secureblackbox_certificatestorage_remove(void* lpObj, int iIndex);

int Remove(int iIndex);

Remarks

Use this method to remove the certificate from the storage given its index.

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

RemoveCRL Method (CertificateStorage Class)

Removes a CRL from the storage.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int RemoveCRL(int iIndex);

Unicode (Windows)
INT RemoveCRL(INT iIndex);

int secureblackbox_certificatestorage_removecrl(void* lpObj, int iIndex);

int RemoveCRL(int iIndex);

Remarks

Use this method to remove a CRL from the storage given its index.

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

RemoveOCSP Method (CertificateStorage Class)

Removes an OCSP response from the storage.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int RemoveOCSP(int iIndex);

Unicode (Windows)
INT RemoveOCSP(INT iIndex);

int secureblackbox_certificatestorage_removeocsp(void* lpObj, int iIndex);

int RemoveOCSP(int iIndex);

Remarks

Use this method to remove an OCSP response from the storage given its index.

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

Reset Method (CertificateStorage Class)

Resets the class settings.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int Reset();

Unicode (Windows)
INT Reset();

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

Select Method (CertificateStorage Class)

Allows the selection of certificates from the system store.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int Select(const char* lpszFilter, int bPrivateKeyNeeded, int iMaxCount);

Unicode (Windows)
INT Select(LPCWSTR lpszFilter, BOOL bPrivateKeyNeeded, INT iMaxCount);

int secureblackbox_certificatestorage_select(void* lpObj, const char* lpszFilter, int bPrivateKeyNeeded, int iMaxCount);

int Select(const QString& qsFilter, bool bPrivateKeyNeeded, int iMaxCount);

Remarks

This function allows the user to select certificates from the system store by Filter and save them to SelectedCertificates. PrivateKeyNeeded specifies whether the method only should consider certificates having associated private keys. MaxCount limits the number of certificates selected.

The supported filters are listed below. Split the name and value of a specific filter with colon (:). Use | separator to pass more than one filter. During the search, the filters are joined using OR logic.

• subjectkeyid: the subject key identifier, in hexadecimal format.
• cakeyid: the key identifier of the issuing certificate, in hexadecimal format.
• serialnumber: the serial number of the certificate, in hexadecimal format.
• keyusage: certificate key usage flags. Use bitwise OR to specify several key usage flags using the values shown below.
• fingerprint: certificate fingerprint in hexadecimal format. MD5, SHA1, SHA256, and SHA512 fingerprints are supported.
• email: the e-mail parameter of the certificate subject.
• subject: the subject of the certificate, either as an RDN, or as its common name parameter.
• issuer: the issuer of the certificate, either as an RDN or a common name.
• ui (Windows system stores only): whether to use UI dialog to select a certificate. Supported values: true, false, 1, 0. All other filters are ignored if this filter is specified.
• * (asterisk): selects all certificates. This filter should always be used as a single character, not as a name:value pair.

Examples of filters

ui:1 - use Windows certificate selection dialog to let the user select a certificate visually.

* - select all certificates.

email:user@server.com - select all certificates with subject RDNs containing this e-mail address.

fingerprint:0a1b3c4d5e6f708192a3b4c5d6e7f8091a2b3c4d - select all certificates with this SHA1 fingerprint.

subject:/C=US/O=Big Company Inc/CN=Signing Certificate - select all certificates with the specified subject RDN.

keyusage:3|email:user@server.com - select all certificates with key usages of Digital Signature or Non-Repudiation, or those having this e-mail address in their subject.

Key usage flags

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

SelectChain Method (CertificateStorage Class)

Selects a chain of certificates given its index.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int SelectChain(int iIndex);

Unicode (Windows)
INT SelectChain(INT iIndex);

int secureblackbox_certificatestorage_selectchain(void* lpObj, int iIndex);

int SelectChain(int iIndex);

Remarks

Use this method to select a certificate chain given its index.

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

SetStorageProperty Method (CertificateStorage Class)

Sets the value of a custom certificate storage property.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int SetStorageProperty(const char* lpszName, const char* lpszValue);

Unicode (Windows)
INT SetStorageProperty(LPCWSTR lpszName, LPCWSTR lpszValue);

int secureblackbox_certificatestorage_setstorageproperty(void* lpObj, const char* lpszName, const char* lpszValue);

int SetStorageProperty(const QString& qsName, const QString& qsValue);

Remarks

This method, together with GetStorageProperty, provides an extensible way of managing the certificate storage's settings that are not available through the primary properties of the component. The list of settings may be extended in future, in response to emergence of new storage variants and recognition of non-obvious storage usage scenarios.

The following certificate storage properties can be read using this method:

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

Error Event (CertificateStorage Class)

Information about errors during certificate loading or saving.

Syntax

• C++
• C
• Qt

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

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


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

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

#define EID_CERTIFICATESTORAGE_ERROR 1

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

class CertificateStorageErrorEventParams {
public:
  int ErrorCode();

  const QString &Description();

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

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

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

Remarks

Reports exceptional conditions during certificate loading or exporting.

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

Notification Event (CertificateStorage Class)

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

Syntax

• C++
• C
• Qt

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

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


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

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

#define EID_CERTIFICATESTORAGE_NOTIFICATION 2

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

class CertificateStorageNotificationEventParams {
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(CertificateStorageNotificationEventParams *e);

// Or, subclass CertificateStorage and override this emitter function.
virtual int FireNotification(CertificateStorageNotificationEventParams *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.

This class can fire this event with the following EventID values:

PasswordNeeded Event (CertificateStorage Class)

This event is fired when a decryption password is needed.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FirePasswordNeeded(CertificateStoragePasswordNeededEventParams *e);

typedef struct {
  const char *NeededFor;
  char *Password;
  int Cancel;
  int reserved;
} CertificateStoragePasswordNeededEventParams;


Unicode (Windows)
virtual INT FirePasswordNeeded(CertificateStoragePasswordNeededEventParams *e);

typedef struct {
  LPCWSTR NeededFor;
  LPWSTR Password;
  BOOL Cancel;
  INT reserved;
} CertificateStoragePasswordNeededEventParams;

#define EID_CERTIFICATESTORAGE_PASSWORDNEEDED 3

virtual INT SECUREBLACKBOX_CALL FirePasswordNeeded(LPSTR &lpszNeededFor, LPSTR &lpszPassword, BOOL &bCancel);

class CertificateStoragePasswordNeededEventParams {
public:
  const QString &NeededFor();

  const QString &Password();
  void SetPassword(const QString &qsPassword);

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

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

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

// Or, subclass CertificateStorage and override this emitter function.
virtual int FirePasswordNeeded(CertificateStoragePasswordNeededEventParams *e) {...}

Remarks

The class fires this event when a password is needed to decrypt a certificate or a private key.

In the handler of this event, assign the password to the Password parameter, or set Cancel to true to abort the operation.

The NeededFor parameter identifies the certificate for which the password is requested.

Certificate Type

Encapsulates an individual X.509 certificate.

Syntax

SecureBlackboxCertificate (declared in secureblackbox.h)

Remarks

This type keeps and provides access to X.509 certificate details.

Fields

Constructors

Certificate()

CRL Type

Represents a Certificate Revocation List.

Syntax

SecureBlackboxCRL (declared in secureblackbox.h)

Remarks

CRLs store information about revoked certificates, i.e., certificates that have been identified as invalid by their issuing certificate authority (CA) for any number of reasons.

Each CRL object lists certificates from a single CA and identifies them by their serial numbers. A CA may or may not publish a CRL, may publish several CRLs, or may publish the same CRL in multiple locations.

Unlike OCSP responses, CRLs only list certificates that have been revoked. They do not list certificates that are still valid.

Fields

Constructors

CRL()

OCSPResponse Type

Represents a single OCSP response originating from an OCSP responder.

Syntax

SecureBlackboxOCSPResponse (declared in secureblackbox.h)

Remarks

OCSP is a protocol that allows verification of certificate status in real-time, and is an alternative to Certificate Revocation Lists (CRLs).

An OCSP response is a snapshot of the certificate status at a given time.

Fields

Constructors

OCSPResponse()

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 CertificateStorage class.

int GetCount() {}

int SetCount(int count) {}

T* Get(int index) {}

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

SecureBlackboxStream Type

Syntax

SecureBlackboxStream (declared in secureblackbox.h)

Remarks

The CertificateStorage class includes one or more API members that take a stream object as a parameter. To use such API members, create a concrete class that implements the SecureBlackboxStream interface and pass the CertificateStorage class an instance of that concrete class.

When implementing the SecureBlackboxStream interface's properties and methods, they must behave as described below. If the concrete class's implementation does not behave as expected, undefined behavior may occur.

bool CanRead() { return true; }

bool CanSeek() { return true; }

bool CanWrite() { return true; }

int64 GetLength() = 0;

void Close() {}

int Flush() { return 0; }

int Read(void* buffer, int count) = 0;

int64 Seek(int64 offset, int seekOrigin) = 0;

int Write(const void* buffer, int count) = 0;

Config Settings (CertificateStorage Class)

CertificateStorage Config Settings

Base Config Settings

Trappable Errors (CertificateStorage 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.

CertificateStorage Errors