KMIPServer Class

Properties   Methods   Events   Config Settings   Errors  

The KMIPServer class provides server-side functionality for Key Management Interoperability Protocol (KMIP).

Syntax

KMIPServer

Remarks

The Key Management Interoperability Protocol (KMIP) is an OASIS standard for communication between key management servers and clients. KMIP servers are typically responsible for managing cryptographic keys and providing access to them to remote client applications.

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.

Active Property (KMIPServer Class)

Indicates if the KMIP server is active and listening to incoming connections.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int GetActive();

Unicode (Windows)
BOOL GetActive();

int secureblackbox_kmipserver_getactive(void* lpObj);

bool GetActive();

Default Value

FALSE

Remarks

Check this property to find out if the KMIP server is in an active state. Use Start and Stop methods to launch and stop the server.

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

Data Type

Boolean

AllowKeepAlive Property (KMIPServer Class)

Enables or disables keep-alive mode.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int GetAllowKeepAlive();
int SetAllowKeepAlive(int bAllowKeepAlive);

Unicode (Windows)
BOOL GetAllowKeepAlive();
INT SetAllowKeepAlive(BOOL bAllowKeepAlive);

int secureblackbox_kmipserver_getallowkeepalive(void* lpObj);
int secureblackbox_kmipserver_setallowkeepalive(void* lpObj, int bAllowKeepAlive);

bool GetAllowKeepAlive();
int SetAllowKeepAlive(bool bAllowKeepAlive);

Default Value

TRUE

Remarks

Use this property to enable or disable the keep-alive connection mode. If keep-alive is enabled, clients that choose to use it may stay connected for a while.

Data Type

Boolean

AuthRealm Property (KMIPServer Class)

Specifies authentication realm for digest and NTLM authentication.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetAuthRealm();
int SetAuthRealm(const char* lpszAuthRealm);

Unicode (Windows)
LPWSTR GetAuthRealm();
INT SetAuthRealm(LPCWSTR lpszAuthRealm);

char* secureblackbox_kmipserver_getauthrealm(void* lpObj);
int secureblackbox_kmipserver_setauthrealm(void* lpObj, const char* lpszAuthRealm);

QString GetAuthRealm();
int SetAuthRealm(QString qsAuthRealm);

Default Value

"SecureBlackbox"

Remarks

Specifies authentication realm for digest and NTLM authentication types.

Data Type

String

AuthTypes Property (KMIPServer Class)

Defines allowed HTTP authentication types.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int GetAuthTypes();
int SetAuthTypes(int iAuthTypes);

Unicode (Windows)
INT GetAuthTypes();
INT SetAuthTypes(INT iAuthTypes);

int secureblackbox_kmipserver_getauthtypes(void* lpObj);
int secureblackbox_kmipserver_setauthtypes(void* lpObj, int iAuthTypes);

int GetAuthTypes();
int SetAuthTypes(int iAuthTypes);

Default Value

0

Remarks

Use this property to define which authentication types the component should support or attempt to use by enabling the relevant bitmask flags:

Data Type

Integer

BoundPort Property (KMIPServer Class)

Indicates the bound listening port.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int GetBoundPort();

Unicode (Windows)
INT GetBoundPort();

int secureblackbox_kmipserver_getboundport(void* lpObj);

int GetBoundPort();

Default Value

0

Remarks

Check this property to find out the port that has been allocated to the server by the system. The bound port always equals Port if it is provided, or is allocated dynamically if configured to fall in the range between PortRangeFrom and PortRangeTo constraints.

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

Data Type

Integer

CACertificate Property (KMIPServer Class)

The default CA certificate.

Syntax

• C++
• C
• Qt

SecureBlackboxCertificate* GetCACertificate();
int SetCACertificate(SecureBlackboxCertificate* val);

int secureblackbox_kmipserver_getcacertbytes(void* lpObj, char** lpCACertBytes, int* lenCACertBytes);

int64 secureblackbox_kmipserver_getcacerthandle(void* lpObj);
int secureblackbox_kmipserver_setcacerthandle(void* lpObj, int64 lCACertHandle);

QByteArray GetCACertBytes();

qint64 GetCACertHandle();
int SetCACertHandle(qint64 lCACertHandle);

Remarks

KMIP server uses this certificate to sign incoming certificate requests. All certificates generated by the KMIP server will be signed by this CA.

This property is not available at design time.

Data Type

SecureBlackboxCertificate

Certificate Property (KMIPServer Class)

Contains the certificate that has just been generated or added.

Syntax

• C++
• C
• Qt

SecureBlackboxCertificate* GetCertificate();
int SetCertificate(SecureBlackboxCertificate* val);

int secureblackbox_kmipserver_getcertificatebytes(void* lpObj, char** lpCertificateBytes, int* lenCertificateBytes);

int64 secureblackbox_kmipserver_getcertificatehandle(void* lpObj);
int secureblackbox_kmipserver_setcertificatehandle(void* lpObj, int64 lCertificateHandle);

QByteArray GetCertificateBytes();

qint64 GetCertificateHandle();
int SetCertificateHandle(qint64 lCertificateHandle);

Remarks

Use this property to access the certificate that has just been generated or added.

This property is not available at design time.

Data Type

SecureBlackboxCertificate

CompressionLevel Property (KMIPServer Class)

The default compression level to use.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int GetCompressionLevel();
int SetCompressionLevel(int iCompressionLevel);

Unicode (Windows)
INT GetCompressionLevel();
INT SetCompressionLevel(INT iCompressionLevel);

int secureblackbox_kmipserver_getcompressionlevel(void* lpObj);
int secureblackbox_kmipserver_setcompressionlevel(void* lpObj, int iCompressionLevel);

int GetCompressionLevel();
int SetCompressionLevel(int iCompressionLevel);

Default Value

6

Remarks

Assign this property with the compression level (1 to 9) to apply for gzipped responses. 1 stands for the lightest but fastest compression, and 9 for the best but the slowest.

Data Type

Integer

ExternalCrypto Property (KMIPServer Class)

Provides access to external signing and DC parameters.

Syntax

• C++
• C
• Qt

SecureBlackboxExternalCrypto* GetExternalCrypto();

char* secureblackbox_kmipserver_getexternalcryptoasyncdocumentid(void* lpObj);
int secureblackbox_kmipserver_setexternalcryptoasyncdocumentid(void* lpObj, const char* lpszExternalCryptoAsyncDocumentID);

char* secureblackbox_kmipserver_getexternalcryptocustomparams(void* lpObj);
int secureblackbox_kmipserver_setexternalcryptocustomparams(void* lpObj, const char* lpszExternalCryptoCustomParams);

char* secureblackbox_kmipserver_getexternalcryptodata(void* lpObj);
int secureblackbox_kmipserver_setexternalcryptodata(void* lpObj, const char* lpszExternalCryptoData);

int secureblackbox_kmipserver_getexternalcryptoexternalhashcalculation(void* lpObj);
int secureblackbox_kmipserver_setexternalcryptoexternalhashcalculation(void* lpObj, int bExternalCryptoExternalHashCalculation);

char* secureblackbox_kmipserver_getexternalcryptohashalgorithm(void* lpObj);
int secureblackbox_kmipserver_setexternalcryptohashalgorithm(void* lpObj, const char* lpszExternalCryptoHashAlgorithm);

char* secureblackbox_kmipserver_getexternalcryptokeyid(void* lpObj);
int secureblackbox_kmipserver_setexternalcryptokeyid(void* lpObj, const char* lpszExternalCryptoKeyID);

char* secureblackbox_kmipserver_getexternalcryptokeysecret(void* lpObj);
int secureblackbox_kmipserver_setexternalcryptokeysecret(void* lpObj, const char* lpszExternalCryptoKeySecret);

int secureblackbox_kmipserver_getexternalcryptomethod(void* lpObj);
int secureblackbox_kmipserver_setexternalcryptomethod(void* lpObj, int iExternalCryptoMethod);

int secureblackbox_kmipserver_getexternalcryptomode(void* lpObj);
int secureblackbox_kmipserver_setexternalcryptomode(void* lpObj, int iExternalCryptoMode);

char* secureblackbox_kmipserver_getexternalcryptopublickeyalgorithm(void* lpObj);
int secureblackbox_kmipserver_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 (KMIPServer 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_kmipserver_getfipsmode(void* lpObj);
int secureblackbox_kmipserver_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

HandshakeTimeout Property (KMIPServer Class)

Specifies the handshake timeout in milliseconds.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int GetHandshakeTimeout();
int SetHandshakeTimeout(int iHandshakeTimeout);

Unicode (Windows)
INT GetHandshakeTimeout();
INT SetHandshakeTimeout(INT iHandshakeTimeout);

int secureblackbox_kmipserver_gethandshaketimeout(void* lpObj);
int secureblackbox_kmipserver_sethandshaketimeout(void* lpObj, int iHandshakeTimeout);

int GetHandshakeTimeout();
int SetHandshakeTimeout(int iHandshakeTimeout);

Default Value

20000

Remarks

Use this property to set the TLS handshake timeout.

Data Type

Integer

Host Property (KMIPServer Class)

Specifies the host name of the KMIP server.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetHost();
int SetHost(const char* lpszHost);

Unicode (Windows)
LPWSTR GetHost();
INT SetHost(LPCWSTR lpszHost);

char* secureblackbox_kmipserver_gethost(void* lpObj);
int secureblackbox_kmipserver_sethost(void* lpObj, const char* lpszHost);

QString GetHost();
int SetHost(QString qsHost);

Default Value

""

Remarks

Use this property to specify the address of the KMIP server.

Data Type

String

Key Property (KMIPServer Class)

Contains the key that has just been generated or added.

Syntax

• C++
• C
• Qt

SecureBlackboxCryptoKey* GetKey();
int SetKey(SecureBlackboxCryptoKey* val);

char* secureblackbox_kmipserver_getkeyalgorithm(void* lpObj);
int secureblackbox_kmipserver_setkeyalgorithm(void* lpObj, const char* lpszKeyAlgorithm);

int secureblackbox_kmipserver_getkeybits(void* lpObj);

char* secureblackbox_kmipserver_getkeycurve(void* lpObj);
int secureblackbox_kmipserver_setkeycurve(void* lpObj, const char* lpszKeyCurve);

int secureblackbox_kmipserver_getkeyexportable(void* lpObj);

char* secureblackbox_kmipserver_getkeyfingerprint(void* lpObj);

int64 secureblackbox_kmipserver_getkeyhandle(void* lpObj);
int secureblackbox_kmipserver_setkeyhandle(void* lpObj, int64 lKeyHandle);

int secureblackbox_kmipserver_getkeyid(void* lpObj, char** lpKeyID, int* lenKeyID);
int secureblackbox_kmipserver_setkeyid(void* lpObj, const char* lpKeyID, int lenKeyID);

int secureblackbox_kmipserver_getkeyiv(void* lpObj, char** lpKeyIV, int* lenKeyIV);
int secureblackbox_kmipserver_setkeyiv(void* lpObj, const char* lpKeyIV, int lenKeyIV);

int secureblackbox_kmipserver_getkeykey(void* lpObj, char** lpKeyKey, int* lenKeyKey);

int secureblackbox_kmipserver_getkeynonce(void* lpObj, char** lpKeyNonce, int* lenKeyNonce);
int secureblackbox_kmipserver_setkeynonce(void* lpObj, const char* lpKeyNonce, int lenKeyNonce);

int secureblackbox_kmipserver_getkeyprivate(void* lpObj);

int secureblackbox_kmipserver_getkeypublic(void* lpObj);

int secureblackbox_kmipserver_getkeysubject(void* lpObj, char** lpKeySubject, int* lenKeySubject);
int secureblackbox_kmipserver_setkeysubject(void* lpObj, const char* lpKeySubject, int lenKeySubject);

int secureblackbox_kmipserver_getkeysymmetric(void* lpObj);

int secureblackbox_kmipserver_getkeyvalid(void* lpObj);

QString GetKeyAlgorithm();
int SetKeyAlgorithm(QString qsKeyAlgorithm);

int GetKeyBits();

QString GetKeyCurve();
int SetKeyCurve(QString qsKeyCurve);

bool GetKeyExportable();

QString GetKeyFingerprint();

qint64 GetKeyHandle();
int SetKeyHandle(qint64 lKeyHandle);

QByteArray GetKeyID();
int SetKeyID(QByteArray qbaKeyID);

QByteArray GetKeyIV();
int SetKeyIV(QByteArray qbaKeyIV);

QByteArray GetKeyKey();

QByteArray GetKeyNonce();
int SetKeyNonce(QByteArray qbaKeyNonce);

bool GetKeyPrivate();

bool GetKeyPublic();

QByteArray GetKeySubject();
int SetKeySubject(QByteArray qbaKeySubject);

bool GetKeySymmetric();

bool GetKeyValid();

Remarks

Use this property to access the key that has just been generated or added.

This property is not available at design time.

Data Type

SecureBlackboxCryptoKey

PinnedClient Property (KMIPServer Class)

Populates the pinned client details.

Syntax

• C++
• C
• Qt

SecureBlackboxTLSConnectionInfo* GetPinnedClient();

int secureblackbox_kmipserver_getpinnedclientaeadcipher(void* lpObj);

int secureblackbox_kmipserver_getpinnedclientchainvalidationdetails(void* lpObj);

int secureblackbox_kmipserver_getpinnedclientchainvalidationresult(void* lpObj);

char* secureblackbox_kmipserver_getpinnedclientciphersuite(void* lpObj);

int secureblackbox_kmipserver_getpinnedclientclientauthenticated(void* lpObj);

int secureblackbox_kmipserver_getpinnedclientclientauthrequested(void* lpObj);

int secureblackbox_kmipserver_getpinnedclientconnectionestablished(void* lpObj);

int secureblackbox_kmipserver_getpinnedclientconnectionid(void* lpObj, char** lpPinnedClientConnectionID, int* lenPinnedClientConnectionID);

char* secureblackbox_kmipserver_getpinnedclientdigestalgorithm(void* lpObj);

char* secureblackbox_kmipserver_getpinnedclientencryptionalgorithm(void* lpObj);

int secureblackbox_kmipserver_getpinnedclientexportable(void* lpObj);

int64 secureblackbox_kmipserver_getpinnedclientid(void* lpObj);

char* secureblackbox_kmipserver_getpinnedclientkeyexchangealgorithm(void* lpObj);

int secureblackbox_kmipserver_getpinnedclientkeyexchangekeybits(void* lpObj);

char* secureblackbox_kmipserver_getpinnedclientnamedeccurve(void* lpObj);

int secureblackbox_kmipserver_getpinnedclientpfscipher(void* lpObj);

char* secureblackbox_kmipserver_getpinnedclientpresharedidentity(void* lpObj);

char* secureblackbox_kmipserver_getpinnedclientpresharedidentityhint(void* lpObj);

int secureblackbox_kmipserver_getpinnedclientpublickeybits(void* lpObj);

char* secureblackbox_kmipserver_getpinnedclientremoteaddress(void* lpObj);

int secureblackbox_kmipserver_getpinnedclientremoteport(void* lpObj);

int secureblackbox_kmipserver_getpinnedclientresumedsession(void* lpObj);

int secureblackbox_kmipserver_getpinnedclientsecureconnection(void* lpObj);

int secureblackbox_kmipserver_getpinnedclientserverauthenticated(void* lpObj);

char* secureblackbox_kmipserver_getpinnedclientsignaturealgorithm(void* lpObj);

int secureblackbox_kmipserver_getpinnedclientsymmetricblocksize(void* lpObj);

int secureblackbox_kmipserver_getpinnedclientsymmetrickeybits(void* lpObj);

int64 secureblackbox_kmipserver_getpinnedclienttotalbytesreceived(void* lpObj);

int64 secureblackbox_kmipserver_getpinnedclienttotalbytessent(void* lpObj);

char* secureblackbox_kmipserver_getpinnedclientvalidationlog(void* lpObj);

char* secureblackbox_kmipserver_getpinnedclientversion(void* lpObj);

bool GetPinnedClientAEADCipher();

int GetPinnedClientChainValidationDetails();

int GetPinnedClientChainValidationResult();

QString GetPinnedClientCiphersuite();

bool GetPinnedClientClientAuthenticated();

bool GetPinnedClientClientAuthRequested();

bool GetPinnedClientConnectionEstablished();

QByteArray GetPinnedClientConnectionID();

QString GetPinnedClientDigestAlgorithm();

QString GetPinnedClientEncryptionAlgorithm();

bool GetPinnedClientExportable();

qint64 GetPinnedClientID();

QString GetPinnedClientKeyExchangeAlgorithm();

int GetPinnedClientKeyExchangeKeyBits();

QString GetPinnedClientNamedECCurve();

bool GetPinnedClientPFSCipher();

QString GetPinnedClientPreSharedIdentity();

QString GetPinnedClientPreSharedIdentityHint();

int GetPinnedClientPublicKeyBits();

QString GetPinnedClientRemoteAddress();

int GetPinnedClientRemotePort();

bool GetPinnedClientResumedSession();

bool GetPinnedClientSecureConnection();

bool GetPinnedClientServerAuthenticated();

QString GetPinnedClientSignatureAlgorithm();

int GetPinnedClientSymmetricBlockSize();

int GetPinnedClientSymmetricKeyBits();

qint64 GetPinnedClientTotalBytesReceived();

qint64 GetPinnedClientTotalBytesSent();

QString GetPinnedClientValidationLog();

QString GetPinnedClientVersion();

Remarks

Use this property to access the details of the client connection previously pinned with PinClient method.

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

Data Type

SecureBlackboxTLSConnectionInfo

PinnedClientChain Property (KMIPServer Class)

Contains the certificate chain of the pinned client.

Syntax

• C++
• C
• Qt

SecureBlackboxList<SecureBlackboxCertificate>* GetPinnedClientChain();

int secureblackbox_kmipserver_getpinnedclientcertcount(void* lpObj);

int secureblackbox_kmipserver_getpinnedclientcertbytes(void* lpObj, int pinnedclientcertindex, char** lpPinnedClientCertBytes, int* lenPinnedClientCertBytes);

int secureblackbox_kmipserver_getpinnedclientcertcakeyid(void* lpObj, int pinnedclientcertindex, char** lpPinnedClientCertCAKeyID, int* lenPinnedClientCertCAKeyID);

char* secureblackbox_kmipserver_getpinnedclientcertfingerprint(void* lpObj, int pinnedclientcertindex);

int64 secureblackbox_kmipserver_getpinnedclientcerthandle(void* lpObj, int pinnedclientcertindex);

char* secureblackbox_kmipserver_getpinnedclientcertissuer(void* lpObj, int pinnedclientcertindex);

char* secureblackbox_kmipserver_getpinnedclientcertissuerrdn(void* lpObj, int pinnedclientcertindex);

char* secureblackbox_kmipserver_getpinnedclientcertkeyalgorithm(void* lpObj, int pinnedclientcertindex);

int secureblackbox_kmipserver_getpinnedclientcertkeybits(void* lpObj, int pinnedclientcertindex);

char* secureblackbox_kmipserver_getpinnedclientcertkeyfingerprint(void* lpObj, int pinnedclientcertindex);

int secureblackbox_kmipserver_getpinnedclientcertkeyusage(void* lpObj, int pinnedclientcertindex);

int secureblackbox_kmipserver_getpinnedclientcertpublickeybytes(void* lpObj, int pinnedclientcertindex, char** lpPinnedClientCertPublicKeyBytes, int* lenPinnedClientCertPublicKeyBytes);

int secureblackbox_kmipserver_getpinnedclientcertselfsigned(void* lpObj, int pinnedclientcertindex);

int secureblackbox_kmipserver_getpinnedclientcertserialnumber(void* lpObj, int pinnedclientcertindex, char** lpPinnedClientCertSerialNumber, int* lenPinnedClientCertSerialNumber);

char* secureblackbox_kmipserver_getpinnedclientcertsigalgorithm(void* lpObj, int pinnedclientcertindex);

char* secureblackbox_kmipserver_getpinnedclientcertsubject(void* lpObj, int pinnedclientcertindex);

int secureblackbox_kmipserver_getpinnedclientcertsubjectkeyid(void* lpObj, int pinnedclientcertindex, char** lpPinnedClientCertSubjectKeyID, int* lenPinnedClientCertSubjectKeyID);

char* secureblackbox_kmipserver_getpinnedclientcertsubjectrdn(void* lpObj, int pinnedclientcertindex);

char* secureblackbox_kmipserver_getpinnedclientcertvalidfrom(void* lpObj, int pinnedclientcertindex);

char* secureblackbox_kmipserver_getpinnedclientcertvalidto(void* lpObj, int pinnedclientcertindex);

int GetPinnedClientCertCount();

QByteArray GetPinnedClientCertBytes(int iPinnedClientCertIndex);

QByteArray GetPinnedClientCertCAKeyID(int iPinnedClientCertIndex);

QString GetPinnedClientCertFingerprint(int iPinnedClientCertIndex);

qint64 GetPinnedClientCertHandle(int iPinnedClientCertIndex);

QString GetPinnedClientCertIssuer(int iPinnedClientCertIndex);

QString GetPinnedClientCertIssuerRDN(int iPinnedClientCertIndex);

QString GetPinnedClientCertKeyAlgorithm(int iPinnedClientCertIndex);

int GetPinnedClientCertKeyBits(int iPinnedClientCertIndex);

QString GetPinnedClientCertKeyFingerprint(int iPinnedClientCertIndex);

int GetPinnedClientCertKeyUsage(int iPinnedClientCertIndex);

QByteArray GetPinnedClientCertPublicKeyBytes(int iPinnedClientCertIndex);

bool GetPinnedClientCertSelfSigned(int iPinnedClientCertIndex);

QByteArray GetPinnedClientCertSerialNumber(int iPinnedClientCertIndex);

QString GetPinnedClientCertSigAlgorithm(int iPinnedClientCertIndex);

QString GetPinnedClientCertSubject(int iPinnedClientCertIndex);

QByteArray GetPinnedClientCertSubjectKeyID(int iPinnedClientCertIndex);

QString GetPinnedClientCertSubjectRDN(int iPinnedClientCertIndex);

QString GetPinnedClientCertValidFrom(int iPinnedClientCertIndex);

QString GetPinnedClientCertValidTo(int iPinnedClientCertIndex);

Remarks

Use this property to access the certificate chain of the client connection pinned previously with a PinClient call.

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

Data Type

SecureBlackboxCertificate

Port Property (KMIPServer Class)

A port to listen for connections on.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int GetPort();
int SetPort(int iPort);

Unicode (Windows)
INT GetPort();
INT SetPort(INT iPort);

int secureblackbox_kmipserver_getport(void* lpObj);
int secureblackbox_kmipserver_setport(void* lpObj, int iPort);

int GetPort();
int SetPort(int iPort);

Default Value

5696

Remarks

Use this property to specify the listening port.

Data Type

Integer

ReadOnly Property (KMIPServer Class)

Controls whether the server works in read-only mode.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int GetReadOnly();
int SetReadOnly(int bReadOnly);

Unicode (Windows)
BOOL GetReadOnly();
INT SetReadOnly(BOOL bReadOnly);

int secureblackbox_kmipserver_getreadonly(void* lpObj);
int secureblackbox_kmipserver_setreadonly(void* lpObj, int bReadOnly);

bool GetReadOnly();
int SetReadOnly(bool bReadOnly);

Default Value

FALSE

Remarks

Use this property to enable or disable read-only mode on the server. It is an easy way to prevent connecting users from adding or removing objects managed by the server.

This property is not available at design time.

Data Type

Boolean

SessionTimeout Property (KMIPServer Class)

Specifies the default session timeout value in milliseconds.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int GetSessionTimeout();
int SetSessionTimeout(int iSessionTimeout);

Unicode (Windows)
INT GetSessionTimeout();
INT SetSessionTimeout(INT iSessionTimeout);

int secureblackbox_kmipserver_getsessiontimeout(void* lpObj);
int secureblackbox_kmipserver_setsessiontimeout(void* lpObj, int iSessionTimeout);

int GetSessionTimeout();
int SetSessionTimeout(int iSessionTimeout);

Default Value

360000

Remarks

Specifies the period of inactivity (in milliseconds) after which the connection will be terminated by the server.

Data Type

Integer

SocketSettings Property (KMIPServer Class)

Manages network connection settings.

Syntax

• C++
• C
• Qt

SecureBlackboxSocketSettings* GetSocketSettings();

int secureblackbox_kmipserver_getsocketincomingspeedlimit(void* lpObj);
int secureblackbox_kmipserver_setsocketincomingspeedlimit(void* lpObj, int iSocketIncomingSpeedLimit);

char* secureblackbox_kmipserver_getsocketlocaladdress(void* lpObj);
int secureblackbox_kmipserver_setsocketlocaladdress(void* lpObj, const char* lpszSocketLocalAddress);

int secureblackbox_kmipserver_getsocketlocalport(void* lpObj);
int secureblackbox_kmipserver_setsocketlocalport(void* lpObj, int iSocketLocalPort);

int secureblackbox_kmipserver_getsocketoutgoingspeedlimit(void* lpObj);
int secureblackbox_kmipserver_setsocketoutgoingspeedlimit(void* lpObj, int iSocketOutgoingSpeedLimit);

int secureblackbox_kmipserver_getsockettimeout(void* lpObj);
int secureblackbox_kmipserver_setsockettimeout(void* lpObj, int iSocketTimeout);

int secureblackbox_kmipserver_getsocketuseipv6(void* lpObj);
int secureblackbox_kmipserver_setsocketuseipv6(void* lpObj, int bSocketUseIPv6);

int GetSocketIncomingSpeedLimit();
int SetSocketIncomingSpeedLimit(int iSocketIncomingSpeedLimit);

QString GetSocketLocalAddress();
int SetSocketLocalAddress(QString qsSocketLocalAddress);

int GetSocketLocalPort();
int SetSocketLocalPort(int iSocketLocalPort);

int GetSocketOutgoingSpeedLimit();
int SetSocketOutgoingSpeedLimit(int iSocketOutgoingSpeedLimit);

int GetSocketTimeout();
int SetSocketTimeout(int iSocketTimeout);

bool GetSocketUseIPv6();
int SetSocketUseIPv6(bool bSocketUseIPv6);

Remarks

Use this property to tune up network connection parameters.

This property is read-only.

Data Type

SecureBlackboxSocketSettings

StorageFileName Property (KMIPServer Class)

A path to the KMIP object database.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetStorageFileName();
int SetStorageFileName(const char* lpszStorageFileName);

Unicode (Windows)
LPWSTR GetStorageFileName();
INT SetStorageFileName(LPCWSTR lpszStorageFileName);

char* secureblackbox_kmipserver_getstoragefilename(void* lpObj);
int secureblackbox_kmipserver_setstoragefilename(void* lpObj, const char* lpszStorageFileName);

QString GetStorageFileName();
int SetStorageFileName(QString qsStorageFileName);

Default Value

""

Remarks

Assign the path to the database of objects managed by the KMIP server to this property.

Data Type

String

TLSServerChain Property (KMIPServer Class)

The server's TLS certificates.

Syntax

• C++
• C
• Qt

SecureBlackboxList<SecureBlackboxCertificate>* GetTLSServerChain();
int SetTLSServerChain(SecureBlackboxList<SecureBlackboxCertificate>* val);

int secureblackbox_kmipserver_gettlsservercertcount(void* lpObj);
int secureblackbox_kmipserver_settlsservercertcount(void* lpObj, int iTLSServerCertCount);

int secureblackbox_kmipserver_gettlsservercertbytes(void* lpObj, int tlsservercertindex, char** lpTLSServerCertBytes, int* lenTLSServerCertBytes);

int64 secureblackbox_kmipserver_gettlsservercerthandle(void* lpObj, int tlsservercertindex);
int secureblackbox_kmipserver_settlsservercerthandle(void* lpObj, int tlsservercertindex, int64 lTLSServerCertHandle);

int GetTLSServerCertCount();
int SetTLSServerCertCount(int iTLSServerCertCount);

QByteArray GetTLSServerCertBytes(int iTLSServerCertIndex);

qint64 GetTLSServerCertHandle(int iTLSServerCertIndex);
int SetTLSServerCertHandle(int iTLSServerCertIndex, qint64 lTLSServerCertHandle);

Remarks

Use this property to provide a list of TLS certificates for the server endpoint.

A TLS endpoint needs a certificate to be able to accept TLS connections. At least one of the certificates in the collection - the endpoint certificate - must have a private key associated with it.

The collection may include more than one endpoint certificate, and more than one chain. A typical usage scenario is to include two chains (ECDSA and RSA), to cater for clients with different cipher suite preferences.

This property is not available at design time.

Data Type

SecureBlackboxCertificate

TLSSettings Property (KMIPServer Class)

Manages TLS layer settings.

Syntax

• C++
• C
• Qt

SecureBlackboxTLSSettings* GetTLSSettings();

int secureblackbox_kmipserver_gettlsautovalidatecertificates(void* lpObj);
int secureblackbox_kmipserver_settlsautovalidatecertificates(void* lpObj, int bTLSAutoValidateCertificates);

int secureblackbox_kmipserver_gettlsbaseconfiguration(void* lpObj);
int secureblackbox_kmipserver_settlsbaseconfiguration(void* lpObj, int iTLSBaseConfiguration);

char* secureblackbox_kmipserver_gettlsciphersuites(void* lpObj);
int secureblackbox_kmipserver_settlsciphersuites(void* lpObj, const char* lpszTLSCiphersuites);

int secureblackbox_kmipserver_gettlsclientauth(void* lpObj);
int secureblackbox_kmipserver_settlsclientauth(void* lpObj, int iTLSClientAuth);

char* secureblackbox_kmipserver_gettlseccurves(void* lpObj);
int secureblackbox_kmipserver_settlseccurves(void* lpObj, const char* lpszTLSECCurves);

char* secureblackbox_kmipserver_gettlsextensions(void* lpObj);
int secureblackbox_kmipserver_settlsextensions(void* lpObj, const char* lpszTLSExtensions);

int secureblackbox_kmipserver_gettlsforceresumeifdestinationchanges(void* lpObj);
int secureblackbox_kmipserver_settlsforceresumeifdestinationchanges(void* lpObj, int bTLSForceResumeIfDestinationChanges);

char* secureblackbox_kmipserver_gettlspresharedidentity(void* lpObj);
int secureblackbox_kmipserver_settlspresharedidentity(void* lpObj, const char* lpszTLSPreSharedIdentity);

char* secureblackbox_kmipserver_gettlspresharedkey(void* lpObj);
int secureblackbox_kmipserver_settlspresharedkey(void* lpObj, const char* lpszTLSPreSharedKey);

char* secureblackbox_kmipserver_gettlspresharedkeyciphersuite(void* lpObj);
int secureblackbox_kmipserver_settlspresharedkeyciphersuite(void* lpObj, const char* lpszTLSPreSharedKeyCiphersuite);

int secureblackbox_kmipserver_gettlsrenegotiationattackpreventionmode(void* lpObj);
int secureblackbox_kmipserver_settlsrenegotiationattackpreventionmode(void* lpObj, int iTLSRenegotiationAttackPreventionMode);

int secureblackbox_kmipserver_gettlsrevocationcheck(void* lpObj);
int secureblackbox_kmipserver_settlsrevocationcheck(void* lpObj, int iTLSRevocationCheck);

int secureblackbox_kmipserver_gettlsssloptions(void* lpObj);
int secureblackbox_kmipserver_settlsssloptions(void* lpObj, int iTLSSSLOptions);

int secureblackbox_kmipserver_gettlstlsmode(void* lpObj);
int secureblackbox_kmipserver_settlstlsmode(void* lpObj, int iTLSTLSMode);

int secureblackbox_kmipserver_gettlsuseextendedmastersecret(void* lpObj);
int secureblackbox_kmipserver_settlsuseextendedmastersecret(void* lpObj, int bTLSUseExtendedMasterSecret);

int secureblackbox_kmipserver_gettlsusesessionresumption(void* lpObj);
int secureblackbox_kmipserver_settlsusesessionresumption(void* lpObj, int bTLSUseSessionResumption);

int secureblackbox_kmipserver_gettlsversions(void* lpObj);
int secureblackbox_kmipserver_settlsversions(void* lpObj, int iTLSVersions);

bool GetTLSAutoValidateCertificates();
int SetTLSAutoValidateCertificates(bool bTLSAutoValidateCertificates);

int GetTLSBaseConfiguration();
int SetTLSBaseConfiguration(int iTLSBaseConfiguration);

QString GetTLSCiphersuites();
int SetTLSCiphersuites(QString qsTLSCiphersuites);

int GetTLSClientAuth();
int SetTLSClientAuth(int iTLSClientAuth);

QString GetTLSECCurves();
int SetTLSECCurves(QString qsTLSECCurves);

QString GetTLSExtensions();
int SetTLSExtensions(QString qsTLSExtensions);

bool GetTLSForceResumeIfDestinationChanges();
int SetTLSForceResumeIfDestinationChanges(bool bTLSForceResumeIfDestinationChanges);

QString GetTLSPreSharedIdentity();
int SetTLSPreSharedIdentity(QString qsTLSPreSharedIdentity);

QString GetTLSPreSharedKey();
int SetTLSPreSharedKey(QString qsTLSPreSharedKey);

QString GetTLSPreSharedKeyCiphersuite();
int SetTLSPreSharedKeyCiphersuite(QString qsTLSPreSharedKeyCiphersuite);

int GetTLSRenegotiationAttackPreventionMode();
int SetTLSRenegotiationAttackPreventionMode(int iTLSRenegotiationAttackPreventionMode);

int GetTLSRevocationCheck();
int SetTLSRevocationCheck(int iTLSRevocationCheck);

int GetTLSSSLOptions();
int SetTLSSSLOptions(int iTLSSSLOptions);

int GetTLSTLSMode();
int SetTLSTLSMode(int iTLSTLSMode);

bool GetTLSUseExtendedMasterSecret();
int SetTLSUseExtendedMasterSecret(bool bTLSUseExtendedMasterSecret);

bool GetTLSUseSessionResumption();
int SetTLSUseSessionResumption(bool bTLSUseSessionResumption);

int GetTLSVersions();
int SetTLSVersions(int iTLSVersions);

Remarks

Use this property to tune up the TLS layer parameters.

This property is read-only.

Data Type

SecureBlackboxTLSSettings

UseChunkedTransfer Property (KMIPServer Class)

Enables chunked transfer.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int GetUseChunkedTransfer();
int SetUseChunkedTransfer(int bUseChunkedTransfer);

Unicode (Windows)
BOOL GetUseChunkedTransfer();
INT SetUseChunkedTransfer(BOOL bUseChunkedTransfer);

int secureblackbox_kmipserver_getusechunkedtransfer(void* lpObj);
int secureblackbox_kmipserver_setusechunkedtransfer(void* lpObj, int bUseChunkedTransfer);

bool GetUseChunkedTransfer();
int SetUseChunkedTransfer(bool bUseChunkedTransfer);

Default Value

FALSE

Remarks

Use this property to enable chunked content encoding.

Data Type

Boolean

UseCompression Property (KMIPServer Class)

Enables or disables server-side compression.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int GetUseCompression();
int SetUseCompression(int bUseCompression);

Unicode (Windows)
BOOL GetUseCompression();
INT SetUseCompression(BOOL bUseCompression);

int secureblackbox_kmipserver_getusecompression(void* lpObj);
int secureblackbox_kmipserver_setusecompression(void* lpObj, int bUseCompression);

bool GetUseCompression();
int SetUseCompression(bool bUseCompression);

Default Value

FALSE

Remarks

Use this property to enable or disable server-side content compression.

Data Type

Boolean

UseHTTP Property (KMIPServer Class)

Specifies whether the server should use HTTP instead of KMIP-over-TCP/TLS.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int GetUseHTTP();
int SetUseHTTP(int bUseHTTP);

Unicode (Windows)
BOOL GetUseHTTP();
INT SetUseHTTP(BOOL bUseHTTP);

int secureblackbox_kmipserver_getusehttp(void* lpObj);
int secureblackbox_kmipserver_setusehttp(void* lpObj, int bUseHTTP);

bool GetUseHTTP();
int SetUseHTTP(bool bUseHTTP);

Default Value

FALSE

Remarks

Set this property to true to tell the server to expect HTTP(S) connections instead of TCP-based KMIP requests.

This property is not available at design time.

Data Type

Boolean

Users Property (KMIPServer Class)

A database of registered users.

Syntax

• C++
• C
• Qt

SecureBlackboxList<SecureBlackboxUserAccount>* GetUsers();
int SetUsers(SecureBlackboxList<SecureBlackboxUserAccount>* val);

int secureblackbox_kmipserver_getusercount(void* lpObj);
int secureblackbox_kmipserver_setusercount(void* lpObj, int iUserCount);

int secureblackbox_kmipserver_getuserassociateddata(void* lpObj, int userindex, char** lpUserAssociatedData, int* lenUserAssociatedData);
int secureblackbox_kmipserver_setuserassociateddata(void* lpObj, int userindex, const char* lpUserAssociatedData, int lenUserAssociatedData);

char* secureblackbox_kmipserver_getuserbasepath(void* lpObj, int userindex);
int secureblackbox_kmipserver_setuserbasepath(void* lpObj, int userindex, const char* lpszUserBasePath);

int secureblackbox_kmipserver_getusercertificate(void* lpObj, int userindex, char** lpUserCertificate, int* lenUserCertificate);
int secureblackbox_kmipserver_setusercertificate(void* lpObj, int userindex, const char* lpUserCertificate, int lenUserCertificate);

char* secureblackbox_kmipserver_getuserdata(void* lpObj, int userindex);
int secureblackbox_kmipserver_setuserdata(void* lpObj, int userindex, const char* lpszUserData);

char* secureblackbox_kmipserver_getuseremail(void* lpObj, int userindex);
int secureblackbox_kmipserver_setuseremail(void* lpObj, int userindex, const char* lpszUserEmail);

int64 secureblackbox_kmipserver_getuserhandle(void* lpObj, int userindex);
int secureblackbox_kmipserver_setuserhandle(void* lpObj, int userindex, int64 lUserHandle);

char* secureblackbox_kmipserver_getuserhashalgorithm(void* lpObj, int userindex);
int secureblackbox_kmipserver_setuserhashalgorithm(void* lpObj, int userindex, const char* lpszUserHashAlgorithm);

int secureblackbox_kmipserver_getuserincomingspeedlimit(void* lpObj, int userindex);
int secureblackbox_kmipserver_setuserincomingspeedlimit(void* lpObj, int userindex, int iUserIncomingSpeedLimit);

int secureblackbox_kmipserver_getuserotpalgorithm(void* lpObj, int userindex);
int secureblackbox_kmipserver_setuserotpalgorithm(void* lpObj, int userindex, int iUserOtpAlgorithm);

int secureblackbox_kmipserver_getuserotplen(void* lpObj, int userindex);
int secureblackbox_kmipserver_setuserotplen(void* lpObj, int userindex, int iUserOTPLen);

int secureblackbox_kmipserver_getuserotpvalue(void* lpObj, int userindex);
int secureblackbox_kmipserver_setuserotpvalue(void* lpObj, int userindex, int iUserOtpValue);

int secureblackbox_kmipserver_getuseroutgoingspeedlimit(void* lpObj, int userindex);
int secureblackbox_kmipserver_setuseroutgoingspeedlimit(void* lpObj, int userindex, int iUserOutgoingSpeedLimit);

char* secureblackbox_kmipserver_getuserpassword(void* lpObj, int userindex);
int secureblackbox_kmipserver_setuserpassword(void* lpObj, int userindex, const char* lpszUserPassword);

int secureblackbox_kmipserver_getusersharedsecret(void* lpObj, int userindex, char** lpUserSharedSecret, int* lenUserSharedSecret);
int secureblackbox_kmipserver_setusersharedsecret(void* lpObj, int userindex, const char* lpUserSharedSecret, int lenUserSharedSecret);

int secureblackbox_kmipserver_getusersshkey(void* lpObj, int userindex, char** lpUserSSHKey, int* lenUserSSHKey);
int secureblackbox_kmipserver_setusersshkey(void* lpObj, int userindex, const char* lpUserSSHKey, int lenUserSSHKey);

char* secureblackbox_kmipserver_getuserusername(void* lpObj, int userindex);
int secureblackbox_kmipserver_setuserusername(void* lpObj, int userindex, const char* lpszUserUsername);

int GetUserCount();
int SetUserCount(int iUserCount);

QByteArray GetUserAssociatedData(int iUserIndex);
int SetUserAssociatedData(int iUserIndex, QByteArray qbaUserAssociatedData);

QString GetUserBasePath(int iUserIndex);
int SetUserBasePath(int iUserIndex, QString qsUserBasePath);

QByteArray GetUserCertificate(int iUserIndex);
int SetUserCertificate(int iUserIndex, QByteArray qbaUserCertificate);

QString GetUserData(int iUserIndex);
int SetUserData(int iUserIndex, QString qsUserData);

QString GetUserEmail(int iUserIndex);
int SetUserEmail(int iUserIndex, QString qsUserEmail);

qint64 GetUserHandle(int iUserIndex);
int SetUserHandle(int iUserIndex, qint64 lUserHandle);

QString GetUserHashAlgorithm(int iUserIndex);
int SetUserHashAlgorithm(int iUserIndex, QString qsUserHashAlgorithm);

int GetUserIncomingSpeedLimit(int iUserIndex);
int SetUserIncomingSpeedLimit(int iUserIndex, int iUserIncomingSpeedLimit);

int GetUserOtpAlgorithm(int iUserIndex);
int SetUserOtpAlgorithm(int iUserIndex, int iUserOtpAlgorithm);

int GetUserOTPLen(int iUserIndex);
int SetUserOTPLen(int iUserIndex, int iUserOTPLen);

int GetUserOtpValue(int iUserIndex);
int SetUserOtpValue(int iUserIndex, int iUserOtpValue);

int GetUserOutgoingSpeedLimit(int iUserIndex);
int SetUserOutgoingSpeedLimit(int iUserIndex, int iUserOutgoingSpeedLimit);

QString GetUserPassword(int iUserIndex);
int SetUserPassword(int iUserIndex, QString qsUserPassword);

QByteArray GetUserSharedSecret(int iUserIndex);
int SetUserSharedSecret(int iUserIndex, QByteArray qbaUserSharedSecret);

QByteArray GetUserSSHKey(int iUserIndex);
int SetUserSSHKey(int iUserIndex, QByteArray qbaUserSSHKey);

QString GetUserUsername(int iUserIndex);
int SetUserUsername(int iUserIndex, QString qsUserUsername);

Remarks

Use this property to configure user authentication on the KMIP server.

This property is not available at design time.

Data Type

SecureBlackboxUserAccount

Cleanup Method (KMIPServer Class)

Cleans up the server environment by purging expired sessions and cleaning caches.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int Cleanup();

Unicode (Windows)
INT Cleanup();

int secureblackbox_kmipserver_cleanup(void* lpObj);

int Cleanup();

Remarks

Call this method while the server is active to clean up the environment allocated for the server by releasing unused resources and cleaning caches.

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 (KMIPServer 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_kmipserver_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.

DoAction Method (KMIPServer 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_kmipserver_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.

DropClient Method (KMIPServer Class)

Terminates a client connection.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int DropClient(int64 lConnectionId, int bForced);

Unicode (Windows)
INT DropClient(LONG64 lConnectionId, BOOL bForced);

int secureblackbox_kmipserver_dropclient(void* lpObj, int64 lConnectionId, int bForced);

int DropClient(qint64 lConnectionId, bool bForced);

Remarks

Call this method to shut down a connected client. Forced indicates whether the connection should be closed in a graceful manner.

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

GetClientCert Method (KMIPServer Class)

Populates the per-connection certificate object.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int GetClientCert(int64 lConnectionID);

Unicode (Windows)
INT GetClientCert(LONG64 lConnectionID);

int secureblackbox_kmipserver_getclientcert(void* lpObj, int64 lConnectionID);

int GetClientCert(qint64 lConnectionID);

Remarks

This method populates the certificate template/object received with the certificate generation request in Certificate property.

Call this method from your BeforeGenerate event handler to populate the certificate template, as received in the request. It is still not late to alter the details of the certificate on this stage.

Call it from your AfterGenerate event handler to populate the certificate that has been generated.

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

GetClientKey Method (KMIPServer Class)

Populates the per-connection key object.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int GetClientKey(int64 lConnectionID);

Unicode (Windows)
INT GetClientKey(LONG64 lConnectionID);

int secureblackbox_kmipserver_getclientkey(void* lpObj, int64 lConnectionID);

int GetClientKey(qint64 lConnectionID);

Remarks

This method populates the key template/object received with the key generation request in Key property.

Call this method from your BeforeGenerateKey event handler to populate the key template, as received in the request. It is still not late to alter the details of the key on this stage.

Call it from your AfterGenerateKey event handler to populate the key that has been generated.

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

GetRequestHeader Method (KMIPServer Class)

Returns a request header value.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetRequestHeader(int64 lConnectionId, const char* lpszHeaderName);

Unicode (Windows)
LPWSTR GetRequestHeader(LONG64 lConnectionId, LPCWSTR lpszHeaderName);

char* secureblackbox_kmipserver_getrequestheader(void* lpObj, int64 lConnectionId, const char* lpszHeaderName);

QString GetRequestHeader(qint64 lConnectionId, const QString& qsHeaderName);

Remarks

Use this method to get the value of a request header. A good place to call this method is a request-marking event, such as GetRequest or PostRequest.

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.

GetResponseHeader Method (KMIPServer Class)

Returns a response header value.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetResponseHeader(int64 lConnectionId, const char* lpszHeaderName);

Unicode (Windows)
LPWSTR GetResponseHeader(LONG64 lConnectionId, LPCWSTR lpszHeaderName);

char* secureblackbox_kmipserver_getresponseheader(void* lpObj, int64 lConnectionId, const char* lpszHeaderName);

QString GetResponseHeader(qint64 lConnectionId, const QString& qsHeaderName);

Remarks

Use this method to get the value of a response header. A good place to call this method is HeadersPrepared event. Call the method with empty HeaderName to get the whole response header.

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.

ListClients Method (KMIPServer Class)

Enumerates the connected clients.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* ListClients();

Unicode (Windows)
LPWSTR ListClients();

char* secureblackbox_kmipserver_listclients(void* lpObj);

QString ListClients();

Remarks

This method enumerates the connected clients. It returns a list of strings, with each string being of 'ConnectionID|Address|Port' format, and representing a single connection.

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.

PinClient Method (KMIPServer Class)

Takes a snapshot of the connection's properties.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int PinClient(int64 lConnectionId);

Unicode (Windows)
INT PinClient(LONG64 lConnectionId);

int secureblackbox_kmipserver_pinclient(void* lpObj, int64 lConnectionId);

int PinClient(qint64 lConnectionId);

Remarks

Use this method to take a snapshot of a connected client. The captured properties are populated in PinnedClient and PinnedClientChain properties.

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

ProcessGenericRequest Method (KMIPServer Class)

Processes a generic HTTP request.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* ProcessGenericRequest(int64 lConnectionId, const char* lpRequestBytes, int lenRequestBytes, int *lpSize = NULL);

Unicode (Windows)
LPSTR ProcessGenericRequest(LONG64 lConnectionId, LPCSTR lpRequestBytes, INT lenRequestBytes, LPINT lpSize = NULL);

char* secureblackbox_kmipserver_processgenericrequest(void* lpObj, int64 lConnectionId, const char* lpRequestBytes, int lenRequestBytes, int *lpSize);

QByteArray ProcessGenericRequest(qint64 lConnectionId, QByteArray qbaRequestBytes);

Remarks

This method processes a generic HTTP request and produces a response. Use it to generate HTTP responses for requests obtained externally, out of the default HTTP channel.

This method respects all current settings of the server object, and invokes the corresponding events to consult about the request and response details with the application. ConnectionId allows to identify the request in the events.

The method returns the complete HTTP response including HTTP headers.

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.

Reset Method (KMIPServer Class)

Resets the class settings.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int Reset();

Unicode (Windows)
INT Reset();

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

SetClientBytes Method (KMIPServer Class)

Commits a data buffer to the connection.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int SetClientBytes(int64 lConnectionID, const char* lpValue, int lenValue);

Unicode (Windows)
INT SetClientBytes(LONG64 lConnectionID, LPCSTR lpValue, INT lenValue);

int secureblackbox_kmipserver_setclientbytes(void* lpObj, int64 lConnectionID, const char* lpValue, int lenValue);

int SetClientBytes(qint64 lConnectionID, QByteArray qbaValue);

Remarks

Use this method from your Response Encrypt AfterEncrypt Decrypt AfterDecrypt Sign AfterSign events handler to commit a new data to the server component.

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

SetClientCert Method (KMIPServer Class)

Commits the per-connection certificate object to the connection context.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int SetClientCert(int64 lConnectionID);

Unicode (Windows)
INT SetClientCert(LONG64 lConnectionID);

int secureblackbox_kmipserver_setclientcert(void* lpObj, int64 lConnectionID);

int SetClientCert(qint64 lConnectionID);

Remarks

This method commits the certificate object stored in Certificate to the connection context.

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

SetClientKey Method (KMIPServer Class)

Commits the per-connection key object to the connection context.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int SetClientKey(int64 lConnectionID);

Unicode (Windows)
INT SetClientKey(LONG64 lConnectionID);

int secureblackbox_kmipserver_setclientkey(void* lpObj, int64 lConnectionID);

int SetClientKey(qint64 lConnectionID);

Remarks

This method commits the key object stored in Key to the connection context.

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

SetResponseHeader Method (KMIPServer Class)

Sets a response header.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int SetResponseHeader(int64 lConnectionId, const char* lpszHeaderName, const char* lpszValue);

Unicode (Windows)
INT SetResponseHeader(LONG64 lConnectionId, LPCWSTR lpszHeaderName, LPCWSTR lpszValue);

int secureblackbox_kmipserver_setresponseheader(void* lpObj, int64 lConnectionId, const char* lpszHeaderName, const char* lpszValue);

int SetResponseHeader(qint64 lConnectionId, const QString& qsHeaderName, const QString& qsValue);

Remarks

Use this method to set a response header. A good place to call this method is a request-marking event, such as GetRequest or PostRequest.

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

Start Method (KMIPServer Class)

Start the KMIP server.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int Start();

Unicode (Windows)
INT Start();

int secureblackbox_kmipserver_start(void* lpObj);

int Start();

Remarks

Call this method to activate the KMIP server and start listening to incoming connections.

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

Stop Method (KMIPServer Class)

Stops the KMIP server.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int Stop();

Unicode (Windows)
INT Stop();

int secureblackbox_kmipserver_stop(void* lpObj);

int Stop();

Remarks

Call this method to stop the KMIP server.

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

Accept Event (KMIPServer Class)

Reports an incoming connection.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireAccept(KMIPServerAcceptEventParams *e);

typedef struct {
  const char *RemoteAddress;
  int RemotePort;
  int Accept;
  int reserved;
} KMIPServerAcceptEventParams;


Unicode (Windows)
virtual INT FireAccept(KMIPServerAcceptEventParams *e);

typedef struct {
  LPCWSTR RemoteAddress;
  INT RemotePort;
  BOOL Accept;
  INT reserved;
} KMIPServerAcceptEventParams;

#define EID_KMIPSERVER_ACCEPT 1

virtual INT SECUREBLACKBOX_CALL FireAccept(LPSTR &lpszRemoteAddress, INT &iRemotePort, BOOL &bAccept);

class KMIPServerAcceptEventParams {
public:
  const QString &RemoteAddress();

  int RemotePort();

  bool Accept();
  void SetAccept(bool bAccept);

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

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

// Or, subclass KMIPServer and override this emitter function.
virtual int FireAccept(KMIPServerAcceptEventParams *e) {...}

Remarks

This event is fired when a new connection from RemoteAddress:RemotePort is ready to be accepted. Use the Accept parameter to accept or decline it.

Subscribe to Connect event to be notified of every connection that has been set up.

ActivateObject Event (KMIPServer Class)

Notifies the application about the object activation request.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireActivateObject(KMIPServerActivateObjectEventParams *e);

typedef struct {
  int64 ConnectionId;
  const char *ObjectId;
  int OperationStatus;
  int reserved;
} KMIPServerActivateObjectEventParams;


Unicode (Windows)
virtual INT FireActivateObject(KMIPServerActivateObjectEventParams *e);

typedef struct {
  LONG64 ConnectionId;
  LPCWSTR ObjectId;
  INT OperationStatus;
  INT reserved;
} KMIPServerActivateObjectEventParams;

#define EID_KMIPSERVER_ACTIVATEOBJECT 2

virtual INT SECUREBLACKBOX_CALL FireActivateObject(LONG64 &lConnectionId, LPSTR &lpszObjectId, INT &iOperationStatus);

class KMIPServerActivateObjectEventParams {
public:
  qint64 ConnectionId();

  const QString &ObjectId();

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass KMIPServer and override this emitter function.
virtual int FireActivateObject(KMIPServerActivateObjectEventParams *e) {...}

Remarks

Subscribe to this event to get notified about object activation requests. The ObjectId parameter contain the unique identifier of the object being activated.

Object activation requests are handled in a simplified way, without using the three-step virtualization approach.

Add Event (KMIPServer Class)

Passes the certificate import request to the application.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireAdd(KMIPServerAddEventParams *e);

typedef struct {
  int64 ConnectionId;
  char *Group;
  char *CertId;
  int OperationStatus;
  int reserved;
} KMIPServerAddEventParams;


Unicode (Windows)
virtual INT FireAdd(KMIPServerAddEventParams *e);

typedef struct {
  LONG64 ConnectionId;
  LPWSTR Group;
  LPWSTR CertId;
  INT OperationStatus;
  INT reserved;
} KMIPServerAddEventParams;

#define EID_KMIPSERVER_ADD 3

virtual INT SECUREBLACKBOX_CALL FireAdd(LONG64 &lConnectionId, LPSTR &lpszGroup, LPSTR &lpszCertId, INT &iOperationStatus);

class KMIPServerAddEventParams {
public:
  qint64 ConnectionId();

  const QString &Group();
  void SetGroup(const QString &qsGroup);

  const QString &CertId();
  void SetCertId(const QString &qsCertId);

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass KMIPServer and override this emitter function.
virtual int FireAdd(KMIPServerAddEventParams *e) {...}

Remarks

The server uses this event to allow the application to customize a certificate import request. This request fires after BeforeAdd if the Action parameter passed back to it was set to fraCustom.

The Group parameter indicates the shared name for the certificate elements (public key, private key, certificate). The CertId provides a unique identifier for the certificate object. Both can be adjusted by the application as required. Use the Certificate object to access the certificate parameters.

Upon completion of the processing, set the value of OperationStatus to match the result of the operation.

AddKey Event (KMIPServer Class)

Expects the application to handle the key import request.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireAddKey(KMIPServerAddKeyEventParams *e);

typedef struct {
  int64 ConnectionId;
  char *Group;
  char *KeyId;
  int OperationStatus;
  int reserved;
} KMIPServerAddKeyEventParams;


Unicode (Windows)
virtual INT FireAddKey(KMIPServerAddKeyEventParams *e);

typedef struct {
  LONG64 ConnectionId;
  LPWSTR Group;
  LPWSTR KeyId;
  INT OperationStatus;
  INT reserved;
} KMIPServerAddKeyEventParams;

#define EID_KMIPSERVER_ADDKEY 4

virtual INT SECUREBLACKBOX_CALL FireAddKey(LONG64 &lConnectionId, LPSTR &lpszGroup, LPSTR &lpszKeyId, INT &iOperationStatus);

class KMIPServerAddKeyEventParams {
public:
  qint64 ConnectionId();

  const QString &Group();
  void SetGroup(const QString &qsGroup);

  const QString &KeyId();
  void SetKeyId(const QString &qsKeyId);

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass KMIPServer and override this emitter function.
virtual int FireAddKey(KMIPServerAddKeyEventParams *e) {...}

Remarks

Application uses this event to wiretap into the key import procedure. For this event to be invoked, the fraCustom action needs to be previously returned from the BeforeAddKey event.

The handler of this event should process the key data provided via the Key property, typically by storing the key object in a local database. The handler also should set the KeyId and, optionally, Group parameters to match the properties of the new key object. The result of the operation should be returned via the OperationStatus parameter.

See the

Handling and overriding server operations using the Three-Step Virtualization

Most of the server components shipped with SecureBlackbox are highly customizable, allowing the user to override or alter the way the clients' requests are handled by default. The customization feature paves the way for creation of bespoke or virtualized server solutions that work over standardized protocols.

The possibility of customization is typically offered through a three-step virtualization model. Every customizable operation or request that can be handled by the server - say, RenameFile - is represented with a triple of events:

• BeforeRenameFile
• RenameFile
• AfterRenameFile

The first event fires right after the respective request has been received from a client. It provides the details of the operation, such as the original and target file names, and, importantly, a by-reference (writable) Action parameter. The event handler can set the Action parameter to one of the three settings given below. The setting chosen defines the further operation flow:

• fraAuto: the operation shall be handled automatically by the server: in this case, a file will be searched in the provided local directory and renamed.
• fraCustom: indicates that the user wants to take care of the operation by themselves. If this setting is chosen, the server takes no action, and instead fires the RenameFile event shortly after BeforeRenameFile completes. The user is expected to handle RenameFile and perform the requested action - that is, rename the file - manually.
• fraAbort: the operation should be aborted as not supported/allowed. Neither the server nor the user are expected to perform it.

The second event (RenameFile) only fires if Action was set to fraCustom in the earlier call to BeforeRenameFile. It lets the user handle the requested operation in the way they want. The user code must fulfil the operation (for example, rename a database entry, if building a virtualized server), and return the operation result as the event's OperationResult parameter.

If the Action parameter was set to fraAuto, RenameFile is not called. The server performs the operation automatically.

The third event, AfterRenameFile, fires upon completion of the operation, either in automatic or custom mode. The user code can check and/or adjust the result to be returned to the client.

To summarize:

• If Action is set to fraAuto, the next call about this operation will be to AfterRenameFile.
• If Action is set to fraCustom, the next call about the operation will be to RenameFile, and after that to AfterRenameFile.
• If Action is set to fraAbort, the operation is rejected and no further calls about it are performed.

AfterAdd Event (KMIPServer Class)

Notifies the application about completion of the certificate import operation.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireAfterAdd(KMIPServerAfterAddEventParams *e);

typedef struct {
  int64 ConnectionId;
  char *Group;
  char *CertId;
  int OperationStatus;
  int reserved;
} KMIPServerAfterAddEventParams;


Unicode (Windows)
virtual INT FireAfterAdd(KMIPServerAfterAddEventParams *e);

typedef struct {
  LONG64 ConnectionId;
  LPWSTR Group;
  LPWSTR CertId;
  INT OperationStatus;
  INT reserved;
} KMIPServerAfterAddEventParams;

#define EID_KMIPSERVER_AFTERADD 5

virtual INT SECUREBLACKBOX_CALL FireAfterAdd(LONG64 &lConnectionId, LPSTR &lpszGroup, LPSTR &lpszCertId, INT &iOperationStatus);

class KMIPServerAfterAddEventParams {
public:
  qint64 ConnectionId();

  const QString &Group();
  void SetGroup(const QString &qsGroup);

  const QString &CertId();
  void SetCertId(const QString &qsCertId);

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass KMIPServer and override this emitter function.
virtual int FireAfterAdd(KMIPServerAfterAddEventParams *e) {...}

Remarks

The class fires this event upon completion of certificate import routine. The certificate object that has been generated can be read from the Certificate property.

The Group and CertId parameters contain the name of the group and the unique identifier assigned to the new certificate. The OperationStatus parameter contains the result of the operation. The application can adjust them as required.

AfterAddKey Event (KMIPServer Class)

Reports the completion of the key import procedure.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireAfterAddKey(KMIPServerAfterAddKeyEventParams *e);

typedef struct {
  int64 ConnectionId;
  char *Group;
  char *KeyId;
  int OperationStatus;
  int reserved;
} KMIPServerAfterAddKeyEventParams;


Unicode (Windows)
virtual INT FireAfterAddKey(KMIPServerAfterAddKeyEventParams *e);

typedef struct {
  LONG64 ConnectionId;
  LPWSTR Group;
  LPWSTR KeyId;
  INT OperationStatus;
  INT reserved;
} KMIPServerAfterAddKeyEventParams;

#define EID_KMIPSERVER_AFTERADDKEY 6

virtual INT SECUREBLACKBOX_CALL FireAfterAddKey(LONG64 &lConnectionId, LPSTR &lpszGroup, LPSTR &lpszKeyId, INT &iOperationStatus);

class KMIPServerAfterAddKeyEventParams {
public:
  qint64 ConnectionId();

  const QString &Group();
  void SetGroup(const QString &qsGroup);

  const QString &KeyId();
  void SetKeyId(const QString &qsKeyId);

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass KMIPServer and override this emitter function.
virtual int FireAfterAddKey(KMIPServerAfterAddKeyEventParams *e) {...}

Remarks

The component uses the AfterAddKey event to notify the application about completion of the key import processing. The OperationStatus parameter returns the operation result. The KeyId and Group parameters are set to match the properties of the newly created key. The application can change them if required.

This event fires both for "normal" and "virtualized" requests, independently of the value of the Action parameter returned from the BeforeAddKey event. See the

Handling and overriding server operations using the Three-Step Virtualization

Most of the server components shipped with SecureBlackbox are highly customizable, allowing the user to override or alter the way the clients' requests are handled by default. The customization feature paves the way for creation of bespoke or virtualized server solutions that work over standardized protocols.

The possibility of customization is typically offered through a three-step virtualization model. Every customizable operation or request that can be handled by the server - say, RenameFile - is represented with a triple of events:

• BeforeRenameFile
• RenameFile
• AfterRenameFile

The first event fires right after the respective request has been received from a client. It provides the details of the operation, such as the original and target file names, and, importantly, a by-reference (writable) Action parameter. The event handler can set the Action parameter to one of the three settings given below. The setting chosen defines the further operation flow:

• fraAuto: the operation shall be handled automatically by the server: in this case, a file will be searched in the provided local directory and renamed.
• fraCustom: indicates that the user wants to take care of the operation by themselves. If this setting is chosen, the server takes no action, and instead fires the RenameFile event shortly after BeforeRenameFile completes. The user is expected to handle RenameFile and perform the requested action - that is, rename the file - manually.
• fraAbort: the operation should be aborted as not supported/allowed. Neither the server nor the user are expected to perform it.

The second event (RenameFile) only fires if Action was set to fraCustom in the earlier call to BeforeRenameFile. It lets the user handle the requested operation in the way they want. The user code must fulfil the operation (for example, rename a database entry, if building a virtualized server), and return the operation result as the event's OperationResult parameter.

If the Action parameter was set to fraAuto, RenameFile is not called. The server performs the operation automatically.

The third event, AfterRenameFile, fires upon completion of the operation, either in automatic or custom mode. The user code can check and/or adjust the result to be returned to the client.

To summarize:

• If Action is set to fraAuto, the next call about this operation will be to AfterRenameFile.
• If Action is set to fraCustom, the next call about the operation will be to RenameFile, and after that to AfterRenameFile.
• If Action is set to fraAbort, the operation is rejected and no further calls about it are performed.

AfterBrowse Event (KMIPServer Class)

KMIP server uses this event to notify the application about the completion of the browsing (attribute request) operation.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireAfterBrowse(KMIPServerAfterBrowseEventParams *e);

typedef struct {
  int64 ConnectionID;
  const char *ObjectId;
  int OperationStatus;
  int reserved;
} KMIPServerAfterBrowseEventParams;


Unicode (Windows)
virtual INT FireAfterBrowse(KMIPServerAfterBrowseEventParams *e);

typedef struct {
  LONG64 ConnectionID;
  LPCWSTR ObjectId;
  INT OperationStatus;
  INT reserved;
} KMIPServerAfterBrowseEventParams;

#define EID_KMIPSERVER_AFTERBROWSE 7

virtual INT SECUREBLACKBOX_CALL FireAfterBrowse(LONG64 &lConnectionID, LPSTR &lpszObjectId, INT &iOperationStatus);

class KMIPServerAfterBrowseEventParams {
public:
  qint64 ConnectionID();

  const QString &ObjectId();

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass KMIPServer and override this emitter function.
virtual int FireAfterBrowse(KMIPServerAfterBrowseEventParams *e) {...}

Remarks

The ConnectionID parameter identifies the client connection, and the ObjectId parameter specifies the unique ID of the object the attributes of which are being requested.

This event follows the three-step virtualization approach, and fires after the preceding BeforeBrowse and ReadAttribute events.

Check the operation status, and alter it, if needed, through the OperationStatus parameter:

See the

Handling and overriding server operations using the Three-Step Virtualization

Most of the server components shipped with SecureBlackbox are highly customizable, allowing the user to override or alter the way the clients' requests are handled by default. The customization feature paves the way for creation of bespoke or virtualized server solutions that work over standardized protocols.

The possibility of customization is typically offered through a three-step virtualization model. Every customizable operation or request that can be handled by the server - say, RenameFile - is represented with a triple of events:

• BeforeRenameFile
• RenameFile
• AfterRenameFile

The first event fires right after the respective request has been received from a client. It provides the details of the operation, such as the original and target file names, and, importantly, a by-reference (writable) Action parameter. The event handler can set the Action parameter to one of the three settings given below. The setting chosen defines the further operation flow:

• fraAuto: the operation shall be handled automatically by the server: in this case, a file will be searched in the provided local directory and renamed.
• fraCustom: indicates that the user wants to take care of the operation by themselves. If this setting is chosen, the server takes no action, and instead fires the RenameFile event shortly after BeforeRenameFile completes. The user is expected to handle RenameFile and perform the requested action - that is, rename the file - manually.
• fraAbort: the operation should be aborted as not supported/allowed. Neither the server nor the user are expected to perform it.

The second event (RenameFile) only fires if Action was set to fraCustom in the earlier call to BeforeRenameFile. It lets the user handle the requested operation in the way they want. The user code must fulfil the operation (for example, rename a database entry, if building a virtualized server), and return the operation result as the event's OperationResult parameter.

If the Action parameter was set to fraAuto, RenameFile is not called. The server performs the operation automatically.

The third event, AfterRenameFile, fires upon completion of the operation, either in automatic or custom mode. The user code can check and/or adjust the result to be returned to the client.

To summarize:

• If Action is set to fraAuto, the next call about this operation will be to AfterRenameFile.
• If Action is set to fraCustom, the next call about the operation will be to RenameFile, and after that to AfterRenameFile.
• If Action is set to fraAbort, the operation is rejected and no further calls about it are performed.

AfterDecrypt Event (KMIPServer Class)

Notifies the application about completion of the decryption call.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireAfterDecrypt(KMIPServerAfterDecryptEventParams *e);

typedef struct {
  int64 ConnectionId;
  const char *ObjectId;
  const char *DecryptedData;
  int lenDecryptedData;
  char *CorrelationValue;
  int OperationStatus;
  int reserved;
} KMIPServerAfterDecryptEventParams;


Unicode (Windows)
virtual INT FireAfterDecrypt(KMIPServerAfterDecryptEventParams *e);

typedef struct {
  LONG64 ConnectionId;
  LPCWSTR ObjectId;
  LPCSTR DecryptedData;
  INT lenDecryptedData;
  LPWSTR CorrelationValue;
  INT OperationStatus;
  INT reserved;
} KMIPServerAfterDecryptEventParams;

#define EID_KMIPSERVER_AFTERDECRYPT 8

virtual INT SECUREBLACKBOX_CALL FireAfterDecrypt(LONG64 &lConnectionId, LPSTR &lpszObjectId, LPSTR &lpDecryptedData, INT &lenDecryptedData, LPSTR &lpszCorrelationValue, INT &iOperationStatus);

class KMIPServerAfterDecryptEventParams {
public:
  qint64 ConnectionId();

  const QString &ObjectId();

  const QByteArray &DecryptedData();

  const QString &CorrelationValue();
  void SetCorrelationValue(const QString &qsCorrelationValue);

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass KMIPServer and override this emitter function.
virtual int FireAfterDecrypt(KMIPServerAfterDecryptEventParams *e) {...}

Remarks

The component uses this event to notify the application about completion of the decrypt request. The event parameters provide the details of the decryption operation. This event fires independently of whether the build-in or virtualized decryption is used.

The ObjectId parameter contains the unique identifier of the decryption key. DecryptedData contains the decryption result. The CorrelationValue string is a linking token that allows to associate several pieces of a multi-step decryption operation together. The OperationStatus contains the result of the operation.

See the

Handling and overriding server operations using the Three-Step Virtualization

Most of the server components shipped with SecureBlackbox are highly customizable, allowing the user to override or alter the way the clients' requests are handled by default. The customization feature paves the way for creation of bespoke or virtualized server solutions that work over standardized protocols.

The possibility of customization is typically offered through a three-step virtualization model. Every customizable operation or request that can be handled by the server - say, RenameFile - is represented with a triple of events:

• BeforeRenameFile
• RenameFile
• AfterRenameFile

The first event fires right after the respective request has been received from a client. It provides the details of the operation, such as the original and target file names, and, importantly, a by-reference (writable) Action parameter. The event handler can set the Action parameter to one of the three settings given below. The setting chosen defines the further operation flow:

• fraAuto: the operation shall be handled automatically by the server: in this case, a file will be searched in the provided local directory and renamed.
• fraCustom: indicates that the user wants to take care of the operation by themselves. If this setting is chosen, the server takes no action, and instead fires the RenameFile event shortly after BeforeRenameFile completes. The user is expected to handle RenameFile and perform the requested action - that is, rename the file - manually.
• fraAbort: the operation should be aborted as not supported/allowed. Neither the server nor the user are expected to perform it.

The second event (RenameFile) only fires if Action was set to fraCustom in the earlier call to BeforeRenameFile. It lets the user handle the requested operation in the way they want. The user code must fulfil the operation (for example, rename a database entry, if building a virtualized server), and return the operation result as the event's OperationResult parameter.

If the Action parameter was set to fraAuto, RenameFile is not called. The server performs the operation automatically.

The third event, AfterRenameFile, fires upon completion of the operation, either in automatic or custom mode. The user code can check and/or adjust the result to be returned to the client.

To summarize:

• If Action is set to fraAuto, the next call about this operation will be to AfterRenameFile.
• If Action is set to fraCustom, the next call about the operation will be to RenameFile, and after that to AfterRenameFile.
• If Action is set to fraAbort, the operation is rejected and no further calls about it are performed.

AfterDeriveKey Event (KMIPServer Class)

Notifies the application about completion of the key derivation request.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireAfterDeriveKey(KMIPServerAfterDeriveKeyEventParams *e);

typedef struct {
  int64 ConnectionId;
  char *NewKeyId;
  int OperationStatus;
  int reserved;
} KMIPServerAfterDeriveKeyEventParams;


Unicode (Windows)
virtual INT FireAfterDeriveKey(KMIPServerAfterDeriveKeyEventParams *e);

typedef struct {
  LONG64 ConnectionId;
  LPWSTR NewKeyId;
  INT OperationStatus;
  INT reserved;
} KMIPServerAfterDeriveKeyEventParams;

#define EID_KMIPSERVER_AFTERDERIVEKEY 9

virtual INT SECUREBLACKBOX_CALL FireAfterDeriveKey(LONG64 &lConnectionId, LPSTR &lpszNewKeyId, INT &iOperationStatus);

class KMIPServerAfterDeriveKeyEventParams {
public:
  qint64 ConnectionId();

  const QString &NewKeyId();
  void SetNewKeyId(const QString &qsNewKeyId);

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass KMIPServer and override this emitter function.
virtual int FireAfterDeriveKey(KMIPServerAfterDeriveKeyEventParams *e) {...}

Remarks

Use this event to get notified about completion of key derivation requests. The OperationStatus parameter specifies the result of the key derivation operation. The NewKeyId contains the unique identifier of the new key. You can change both parameters if required.

See the

Handling and overriding server operations using the Three-Step Virtualization

Most of the server components shipped with SecureBlackbox are highly customizable, allowing the user to override or alter the way the clients' requests are handled by default. The customization feature paves the way for creation of bespoke or virtualized server solutions that work over standardized protocols.

The possibility of customization is typically offered through a three-step virtualization model. Every customizable operation or request that can be handled by the server - say, RenameFile - is represented with a triple of events:

• BeforeRenameFile
• RenameFile
• AfterRenameFile

The first event fires right after the respective request has been received from a client. It provides the details of the operation, such as the original and target file names, and, importantly, a by-reference (writable) Action parameter. The event handler can set the Action parameter to one of the three settings given below. The setting chosen defines the further operation flow:

• fraAuto: the operation shall be handled automatically by the server: in this case, a file will be searched in the provided local directory and renamed.
• fraCustom: indicates that the user wants to take care of the operation by themselves. If this setting is chosen, the server takes no action, and instead fires the RenameFile event shortly after BeforeRenameFile completes. The user is expected to handle RenameFile and perform the requested action - that is, rename the file - manually.
• fraAbort: the operation should be aborted as not supported/allowed. Neither the server nor the user are expected to perform it.

The second event (RenameFile) only fires if Action was set to fraCustom in the earlier call to BeforeRenameFile. It lets the user handle the requested operation in the way they want. The user code must fulfil the operation (for example, rename a database entry, if building a virtualized server), and return the operation result as the event's OperationResult parameter.

If the Action parameter was set to fraAuto, RenameFile is not called. The server performs the operation automatically.

The third event, AfterRenameFile, fires upon completion of the operation, either in automatic or custom mode. The user code can check and/or adjust the result to be returned to the client.

To summarize:

• If Action is set to fraAuto, the next call about this operation will be to AfterRenameFile.
• If Action is set to fraCustom, the next call about the operation will be to RenameFile, and after that to AfterRenameFile.
• If Action is set to fraAbort, the operation is rejected and no further calls about it are performed.

AfterEdit Event (KMIPServer Class)

Notifies the application of completion of the object editing operation.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireAfterEdit(KMIPServerAfterEditEventParams *e);

typedef struct {
  int64 ConnectionID;
  const char *ObjectId;
  int OperationStatus;
  int reserved;
} KMIPServerAfterEditEventParams;


Unicode (Windows)
virtual INT FireAfterEdit(KMIPServerAfterEditEventParams *e);

typedef struct {
  LONG64 ConnectionID;
  LPCWSTR ObjectId;
  INT OperationStatus;
  INT reserved;
} KMIPServerAfterEditEventParams;

#define EID_KMIPSERVER_AFTEREDIT 10

virtual INT SECUREBLACKBOX_CALL FireAfterEdit(LONG64 &lConnectionID, LPSTR &lpszObjectId, INT &iOperationStatus);

class KMIPServerAfterEditEventParams {
public:
  qint64 ConnectionID();

  const QString &ObjectId();

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass KMIPServer and override this emitter function.
virtual int FireAfterEdit(KMIPServerAfterEditEventParams *e) {...}

Remarks

The component fires this event to notify the application about completion of an edit operation. An edit operation consists of a number of individual attribute update requests.

The ObjectId parameter contains the unique identifier of the object that was edited. Use the OperationStatus parameter to check or update the result of the operation.

AfterEncrypt Event (KMIPServer Class)

Notifies the application about the completion of the encryption call.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireAfterEncrypt(KMIPServerAfterEncryptEventParams *e);

typedef struct {
  int64 ConnectionId;
  const char *ObjectId;
  const char *EncryptedData;
  int lenEncryptedData;
  char *CorrelationValue;
  int OperationStatus;
  int reserved;
} KMIPServerAfterEncryptEventParams;


Unicode (Windows)
virtual INT FireAfterEncrypt(KMIPServerAfterEncryptEventParams *e);

typedef struct {
  LONG64 ConnectionId;
  LPCWSTR ObjectId;
  LPCSTR EncryptedData;
  INT lenEncryptedData;
  LPWSTR CorrelationValue;
  INT OperationStatus;
  INT reserved;
} KMIPServerAfterEncryptEventParams;

#define EID_KMIPSERVER_AFTERENCRYPT 11

virtual INT SECUREBLACKBOX_CALL FireAfterEncrypt(LONG64 &lConnectionId, LPSTR &lpszObjectId, LPSTR &lpEncryptedData, INT &lenEncryptedData, LPSTR &lpszCorrelationValue, INT &iOperationStatus);

class KMIPServerAfterEncryptEventParams {
public:
  qint64 ConnectionId();

  const QString &ObjectId();

  const QByteArray &EncryptedData();

  const QString &CorrelationValue();
  void SetCorrelationValue(const QString &qsCorrelationValue);

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass KMIPServer and override this emitter function.
virtual int FireAfterEncrypt(KMIPServerAfterEncryptEventParams *e) {...}

Remarks

The component uses this event to notify the application about completion of the encrypt request. The event parameters provide the details of the encryption operation. This event fires independently of whether the build-in or virtualized decryption is used.

The ObjectId parameter contains the unique identifier of the encryption key. EncryptedData contains the encryption result. The CorrelationValue string is a linking token that allows to associate several pieces of a multi-step encryption operation together. The OperationStatus contains the result of the operation.

See the

Handling and overriding server operations using the Three-Step Virtualization

Most of the server components shipped with SecureBlackbox are highly customizable, allowing the user to override or alter the way the clients' requests are handled by default. The customization feature paves the way for creation of bespoke or virtualized server solutions that work over standardized protocols.

The possibility of customization is typically offered through a three-step virtualization model. Every customizable operation or request that can be handled by the server - say, RenameFile - is represented with a triple of events:

• BeforeRenameFile
• RenameFile
• AfterRenameFile

The first event fires right after the respective request has been received from a client. It provides the details of the operation, such as the original and target file names, and, importantly, a by-reference (writable) Action parameter. The event handler can set the Action parameter to one of the three settings given below. The setting chosen defines the further operation flow:

• fraAuto: the operation shall be handled automatically by the server: in this case, a file will be searched in the provided local directory and renamed.
• fraCustom: indicates that the user wants to take care of the operation by themselves. If this setting is chosen, the server takes no action, and instead fires the RenameFile event shortly after BeforeRenameFile completes. The user is expected to handle RenameFile and perform the requested action - that is, rename the file - manually.
• fraAbort: the operation should be aborted as not supported/allowed. Neither the server nor the user are expected to perform it.

The second event (RenameFile) only fires if Action was set to fraCustom in the earlier call to BeforeRenameFile. It lets the user handle the requested operation in the way they want. The user code must fulfil the operation (for example, rename a database entry, if building a virtualized server), and return the operation result as the event's OperationResult parameter.

If the Action parameter was set to fraAuto, RenameFile is not called. The server performs the operation automatically.

The third event, AfterRenameFile, fires upon completion of the operation, either in automatic or custom mode. The user code can check and/or adjust the result to be returned to the client.

To summarize:

• If Action is set to fraAuto, the next call about this operation will be to AfterRenameFile.
• If Action is set to fraCustom, the next call about the operation will be to RenameFile, and after that to AfterRenameFile.
• If Action is set to fraAbort, the operation is rejected and no further calls about it are performed.

AfterGenerate Event (KMIPServer Class)

Signifies completion of certificate generation.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireAfterGenerate(KMIPServerAfterGenerateEventParams *e);

typedef struct {
  int64 ConnectionId;
  char *CertId;
  int OperationStatus;
  int reserved;
} KMIPServerAfterGenerateEventParams;


Unicode (Windows)
virtual INT FireAfterGenerate(KMIPServerAfterGenerateEventParams *e);

typedef struct {
  LONG64 ConnectionId;
  LPWSTR CertId;
  INT OperationStatus;
  INT reserved;
} KMIPServerAfterGenerateEventParams;

#define EID_KMIPSERVER_AFTERGENERATE 12

virtual INT SECUREBLACKBOX_CALL FireAfterGenerate(LONG64 &lConnectionId, LPSTR &lpszCertId, INT &iOperationStatus);

class KMIPServerAfterGenerateEventParams {
public:
  qint64 ConnectionId();

  const QString &CertId();
  void SetCertId(const QString &qsCertId);

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass KMIPServer and override this emitter function.
virtual int FireAfterGenerate(KMIPServerAfterGenerateEventParams *e) {...}

Remarks

The class fires this event upon completion of certificate generation routine. The generated certificate can be read from Certificate.

AfterGenerateKey Event (KMIPServer Class)

Notifies the application of the completion of key generation procedure.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireAfterGenerateKey(KMIPServerAfterGenerateKeyEventParams *e);

typedef struct {
  int64 ConnectionId;
  char *KeyId;
  int OperationStatus;
  int reserved;
} KMIPServerAfterGenerateKeyEventParams;


Unicode (Windows)
virtual INT FireAfterGenerateKey(KMIPServerAfterGenerateKeyEventParams *e);

typedef struct {
  LONG64 ConnectionId;
  LPWSTR KeyId;
  INT OperationStatus;
  INT reserved;
} KMIPServerAfterGenerateKeyEventParams;

#define EID_KMIPSERVER_AFTERGENERATEKEY 13

virtual INT SECUREBLACKBOX_CALL FireAfterGenerateKey(LONG64 &lConnectionId, LPSTR &lpszKeyId, INT &iOperationStatus);

class KMIPServerAfterGenerateKeyEventParams {
public:
  qint64 ConnectionId();

  const QString &KeyId();
  void SetKeyId(const QString &qsKeyId);

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass KMIPServer and override this emitter function.
virtual int FireAfterGenerateKey(KMIPServerAfterGenerateKeyEventParams *e) {...}

Remarks

The component uses this event to notify the application about the completion of the key generation procedure. The KeyId parameter contains the ID of the new key object (and can be changed by the user code if required). The OperationStatus parameter reports the result of the operation.

This event is the third and conclusive in the sequence of BeforeGenerateKey, GenerateKey, and the AfterGenerateKey events. See the

Handling and overriding server operations using the Three-Step Virtualization

Most of the server components shipped with SecureBlackbox are highly customizable, allowing the user to override or alter the way the clients' requests are handled by default. The customization feature paves the way for creation of bespoke or virtualized server solutions that work over standardized protocols.

The possibility of customization is typically offered through a three-step virtualization model. Every customizable operation or request that can be handled by the server - say, RenameFile - is represented with a triple of events:

• BeforeRenameFile
• RenameFile
• AfterRenameFile

The first event fires right after the respective request has been received from a client. It provides the details of the operation, such as the original and target file names, and, importantly, a by-reference (writable) Action parameter. The event handler can set the Action parameter to one of the three settings given below. The setting chosen defines the further operation flow:

• fraAuto: the operation shall be handled automatically by the server: in this case, a file will be searched in the provided local directory and renamed.
• fraCustom: indicates that the user wants to take care of the operation by themselves. If this setting is chosen, the server takes no action, and instead fires the RenameFile event shortly after BeforeRenameFile completes. The user is expected to handle RenameFile and perform the requested action - that is, rename the file - manually.
• fraAbort: the operation should be aborted as not supported/allowed. Neither the server nor the user are expected to perform it.

The second event (RenameFile) only fires if Action was set to fraCustom in the earlier call to BeforeRenameFile. It lets the user handle the requested operation in the way they want. The user code must fulfil the operation (for example, rename a database entry, if building a virtualized server), and return the operation result as the event's OperationResult parameter.

If the Action parameter was set to fraAuto, RenameFile is not called. The server performs the operation automatically.

The third event, AfterRenameFile, fires upon completion of the operation, either in automatic or custom mode. The user code can check and/or adjust the result to be returned to the client.

To summarize:

• If Action is set to fraAuto, the next call about this operation will be to AfterRenameFile.
• If Action is set to fraCustom, the next call about the operation will be to RenameFile, and after that to AfterRenameFile.
• If Action is set to fraAbort, the operation is rejected and no further calls about it are performed.

AfterGenerateKeyPair Event (KMIPServer Class)

Notifies the application of the completion of keypair generation.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireAfterGenerateKeyPair(KMIPServerAfterGenerateKeyPairEventParams *e);

typedef struct {
  int64 ConnectionId;
  char *PrivateKeyId;
  char *PublicKeyId;
  int OperationStatus;
  int reserved;
} KMIPServerAfterGenerateKeyPairEventParams;


Unicode (Windows)
virtual INT FireAfterGenerateKeyPair(KMIPServerAfterGenerateKeyPairEventParams *e);

typedef struct {
  LONG64 ConnectionId;
  LPWSTR PrivateKeyId;
  LPWSTR PublicKeyId;
  INT OperationStatus;
  INT reserved;
} KMIPServerAfterGenerateKeyPairEventParams;

#define EID_KMIPSERVER_AFTERGENERATEKEYPAIR 14

virtual INT SECUREBLACKBOX_CALL FireAfterGenerateKeyPair(LONG64 &lConnectionId, LPSTR &lpszPrivateKeyId, LPSTR &lpszPublicKeyId, INT &iOperationStatus);

class KMIPServerAfterGenerateKeyPairEventParams {
public:
  qint64 ConnectionId();

  const QString &PrivateKeyId();
  void SetPrivateKeyId(const QString &qsPrivateKeyId);

  const QString &PublicKeyId();
  void SetPublicKeyId(const QString &qsPublicKeyId);

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass KMIPServer and override this emitter function.
virtual int FireAfterGenerateKeyPair(KMIPServerAfterGenerateKeyPairEventParams *e) {...}

Remarks

The component uses this event to notify the application about the completion of the keypair generation operation. The PrivateKeyId and PublicKeyId parameters contain the IDs of the new private and public keys respectively. The OperationStatus parameter returns the result of the operation.

See the

Handling and overriding server operations using the Three-Step Virtualization

Most of the server components shipped with SecureBlackbox are highly customizable, allowing the user to override or alter the way the clients' requests are handled by default. The customization feature paves the way for creation of bespoke or virtualized server solutions that work over standardized protocols.

The possibility of customization is typically offered through a three-step virtualization model. Every customizable operation or request that can be handled by the server - say, RenameFile - is represented with a triple of events:

• BeforeRenameFile
• RenameFile
• AfterRenameFile

The first event fires right after the respective request has been received from a client. It provides the details of the operation, such as the original and target file names, and, importantly, a by-reference (writable) Action parameter. The event handler can set the Action parameter to one of the three settings given below. The setting chosen defines the further operation flow:

• fraAuto: the operation shall be handled automatically by the server: in this case, a file will be searched in the provided local directory and renamed.
• fraCustom: indicates that the user wants to take care of the operation by themselves. If this setting is chosen, the server takes no action, and instead fires the RenameFile event shortly after BeforeRenameFile completes. The user is expected to handle RenameFile and perform the requested action - that is, rename the file - manually.
• fraAbort: the operation should be aborted as not supported/allowed. Neither the server nor the user are expected to perform it.

The second event (RenameFile) only fires if Action was set to fraCustom in the earlier call to BeforeRenameFile. It lets the user handle the requested operation in the way they want. The user code must fulfil the operation (for example, rename a database entry, if building a virtualized server), and return the operation result as the event's OperationResult parameter.

If the Action parameter was set to fraAuto, RenameFile is not called. The server performs the operation automatically.

The third event, AfterRenameFile, fires upon completion of the operation, either in automatic or custom mode. The user code can check and/or adjust the result to be returned to the client.

To summarize:

• If Action is set to fraAuto, the next call about this operation will be to AfterRenameFile.
• If Action is set to fraCustom, the next call about the operation will be to RenameFile, and after that to AfterRenameFile.
• If Action is set to fraAbort, the operation is rejected and no further calls about it are performed.

AfterHash Event (KMIPServer Class)

Notifies the application about completion of the hashing call.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireAfterHash(KMIPServerAfterHashEventParams *e);

typedef struct {
  int64 ConnectionId;
  const char *ObjectId;
  const char *HashData;
  int lenHashData;
  char *CorrelationValue;
  int OperationStatus;
  int reserved;
} KMIPServerAfterHashEventParams;


Unicode (Windows)
virtual INT FireAfterHash(KMIPServerAfterHashEventParams *e);

typedef struct {
  LONG64 ConnectionId;
  LPCWSTR ObjectId;
  LPCSTR HashData;
  INT lenHashData;
  LPWSTR CorrelationValue;
  INT OperationStatus;
  INT reserved;
} KMIPServerAfterHashEventParams;

#define EID_KMIPSERVER_AFTERHASH 15

virtual INT SECUREBLACKBOX_CALL FireAfterHash(LONG64 &lConnectionId, LPSTR &lpszObjectId, LPSTR &lpHashData, INT &lenHashData, LPSTR &lpszCorrelationValue, INT &iOperationStatus);

class KMIPServerAfterHashEventParams {
public:
  qint64 ConnectionId();

  const QString &ObjectId();

  const QByteArray &HashData();

  const QString &CorrelationValue();
  void SetCorrelationValue(const QString &qsCorrelationValue);

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass KMIPServer and override this emitter function.
virtual int FireAfterHash(KMIPServerAfterHashEventParams *e) {...}

Remarks

Subscribe to this event to be notified about completion of the hashing request processing. The DataHash parameter contains the hash that has been calculated. The OperationStatus parameter contains the operation result. If the hashing operation was a MAC (keyed) operation, the ID of the key is passed to the ObjectId parameter.

See the

Handling and overriding server operations using the Three-Step Virtualization

Most of the server components shipped with SecureBlackbox are highly customizable, allowing the user to override or alter the way the clients' requests are handled by default. The customization feature paves the way for creation of bespoke or virtualized server solutions that work over standardized protocols.

The possibility of customization is typically offered through a three-step virtualization model. Every customizable operation or request that can be handled by the server - say, RenameFile - is represented with a triple of events:

• BeforeRenameFile
• RenameFile
• AfterRenameFile

The first event fires right after the respective request has been received from a client. It provides the details of the operation, such as the original and target file names, and, importantly, a by-reference (writable) Action parameter. The event handler can set the Action parameter to one of the three settings given below. The setting chosen defines the further operation flow:

• fraAuto: the operation shall be handled automatically by the server: in this case, a file will be searched in the provided local directory and renamed.
• fraCustom: indicates that the user wants to take care of the operation by themselves. If this setting is chosen, the server takes no action, and instead fires the RenameFile event shortly after BeforeRenameFile completes. The user is expected to handle RenameFile and perform the requested action - that is, rename the file - manually.
• fraAbort: the operation should be aborted as not supported/allowed. Neither the server nor the user are expected to perform it.

The second event (RenameFile) only fires if Action was set to fraCustom in the earlier call to BeforeRenameFile. It lets the user handle the requested operation in the way they want. The user code must fulfil the operation (for example, rename a database entry, if building a virtualized server), and return the operation result as the event's OperationResult parameter.

If the Action parameter was set to fraAuto, RenameFile is not called. The server performs the operation automatically.

The third event, AfterRenameFile, fires upon completion of the operation, either in automatic or custom mode. The user code can check and/or adjust the result to be returned to the client.

To summarize:

• If Action is set to fraAuto, the next call about this operation will be to AfterRenameFile.
• If Action is set to fraCustom, the next call about the operation will be to RenameFile, and after that to AfterRenameFile.
• If Action is set to fraAbort, the operation is rejected and no further calls about it are performed.

AfterList Event (KMIPServer Class)

Notifies the application about completion of the list command.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireAfterList(KMIPServerAfterListEventParams *e);

typedef struct {
  int64 ConnectionId;
  int ObjectType;
  int ObjectStatus;
  int OnlyFreshObjects;
  char *ObjectIds;
  int OperationStatus;
  int reserved;
} KMIPServerAfterListEventParams;


Unicode (Windows)
virtual INT FireAfterList(KMIPServerAfterListEventParams *e);

typedef struct {
  LONG64 ConnectionId;
  INT ObjectType;
  INT ObjectStatus;
  BOOL OnlyFreshObjects;
  LPWSTR ObjectIds;
  INT OperationStatus;
  INT reserved;
} KMIPServerAfterListEventParams;

#define EID_KMIPSERVER_AFTERLIST 16

virtual INT SECUREBLACKBOX_CALL FireAfterList(LONG64 &lConnectionId, INT &iObjectType, INT &iObjectStatus, BOOL &bOnlyFreshObjects, LPSTR &lpszObjectIds, INT &iOperationStatus);

class KMIPServerAfterListEventParams {
public:
  qint64 ConnectionId();

  int ObjectType();

  int ObjectStatus();

  bool OnlyFreshObjects();

  const QString &ObjectIds();
  void SetObjectIds(const QString &qsObjectIds);

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass KMIPServer and override this emitter function.
virtual int FireAfterList(KMIPServerAfterListEventParams *e) {...}

Remarks

The component uses this event to notify the application about the completion of the list command. The ObjectType, ObjectStatus, and OnlyFreshObjects contain the listing criteria. The ObjectIds contains a list of object unique identifiers, separated by newlines.

See the

Handling and overriding server operations using the Three-Step Virtualization

Most of the server components shipped with SecureBlackbox are highly customizable, allowing the user to override or alter the way the clients' requests are handled by default. The customization feature paves the way for creation of bespoke or virtualized server solutions that work over standardized protocols.

The possibility of customization is typically offered through a three-step virtualization model. Every customizable operation or request that can be handled by the server - say, RenameFile - is represented with a triple of events:

• BeforeRenameFile
• RenameFile
• AfterRenameFile

The first event fires right after the respective request has been received from a client. It provides the details of the operation, such as the original and target file names, and, importantly, a by-reference (writable) Action parameter. The event handler can set the Action parameter to one of the three settings given below. The setting chosen defines the further operation flow:

• fraAuto: the operation shall be handled automatically by the server: in this case, a file will be searched in the provided local directory and renamed.
• fraCustom: indicates that the user wants to take care of the operation by themselves. If this setting is chosen, the server takes no action, and instead fires the RenameFile event shortly after BeforeRenameFile completes. The user is expected to handle RenameFile and perform the requested action - that is, rename the file - manually.
• fraAbort: the operation should be aborted as not supported/allowed. Neither the server nor the user are expected to perform it.

The second event (RenameFile) only fires if Action was set to fraCustom in the earlier call to BeforeRenameFile. It lets the user handle the requested operation in the way they want. The user code must fulfil the operation (for example, rename a database entry, if building a virtualized server), and return the operation result as the event's OperationResult parameter.

If the Action parameter was set to fraAuto, RenameFile is not called. The server performs the operation automatically.

The third event, AfterRenameFile, fires upon completion of the operation, either in automatic or custom mode. The user code can check and/or adjust the result to be returned to the client.

To summarize:

• If Action is set to fraAuto, the next call about this operation will be to AfterRenameFile.
• If Action is set to fraCustom, the next call about the operation will be to RenameFile, and after that to AfterRenameFile.
• If Action is set to fraAbort, the operation is rejected and no further calls about it are performed.

AfterObtainLease Event (KMIPServer Class)

Reports the completion of lease allocation operation.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireAfterObtainLease(KMIPServerAfterObtainLeaseEventParams *e);

typedef struct {
  int64 ConnectionId;
  const char *ObjectId;
  int LeaseTime;
  char *LastChangeDate;
  int OperationStatus;
  int reserved;
} KMIPServerAfterObtainLeaseEventParams;


Unicode (Windows)
virtual INT FireAfterObtainLease(KMIPServerAfterObtainLeaseEventParams *e);

typedef struct {
  LONG64 ConnectionId;
  LPCWSTR ObjectId;
  INT LeaseTime;
  LPWSTR LastChangeDate;
  INT OperationStatus;
  INT reserved;
} KMIPServerAfterObtainLeaseEventParams;

#define EID_KMIPSERVER_AFTEROBTAINLEASE 17

virtual INT SECUREBLACKBOX_CALL FireAfterObtainLease(LONG64 &lConnectionId, LPSTR &lpszObjectId, INT &iLeaseTime, LPSTR &lpszLastChangeDate, INT &iOperationStatus);

class KMIPServerAfterObtainLeaseEventParams {
public:
  qint64 ConnectionId();

  const QString &ObjectId();

  int LeaseTime();
  void SetLeaseTime(int iLeaseTime);

  const QString &LastChangeDate();
  void SetLastChangeDate(const QString &qsLastChangeDate);

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass KMIPServer and override this emitter function.
virtual int FireAfterObtainLease(KMIPServerAfterObtainLeaseEventParams *e) {...}

Remarks

The component uses this event to notify the application about the completion of lease allocation operation. The ObjectId parameter specifies the identifier of the object a lease for each is allocated. The LeaseTime and LastChangeDate parameters specify parameters of the lease.

See the

Handling and overriding server operations using the Three-Step Virtualization

Most of the server components shipped with SecureBlackbox are highly customizable, allowing the user to override or alter the way the clients' requests are handled by default. The customization feature paves the way for creation of bespoke or virtualized server solutions that work over standardized protocols.

The possibility of customization is typically offered through a three-step virtualization model. Every customizable operation or request that can be handled by the server - say, RenameFile - is represented with a triple of events:

• BeforeRenameFile
• RenameFile
• AfterRenameFile

The first event fires right after the respective request has been received from a client. It provides the details of the operation, such as the original and target file names, and, importantly, a by-reference (writable) Action parameter. The event handler can set the Action parameter to one of the three settings given below. The setting chosen defines the further operation flow:

• fraAuto: the operation shall be handled automatically by the server: in this case, a file will be searched in the provided local directory and renamed.
• fraCustom: indicates that the user wants to take care of the operation by themselves. If this setting is chosen, the server takes no action, and instead fires the RenameFile event shortly after BeforeRenameFile completes. The user is expected to handle RenameFile and perform the requested action - that is, rename the file - manually.
• fraAbort: the operation should be aborted as not supported/allowed. Neither the server nor the user are expected to perform it.

The second event (RenameFile) only fires if Action was set to fraCustom in the earlier call to BeforeRenameFile. It lets the user handle the requested operation in the way they want. The user code must fulfil the operation (for example, rename a database entry, if building a virtualized server), and return the operation result as the event's OperationResult parameter.

If the Action parameter was set to fraAuto, RenameFile is not called. The server performs the operation automatically.

The third event, AfterRenameFile, fires upon completion of the operation, either in automatic or custom mode. The user code can check and/or adjust the result to be returned to the client.

To summarize:

• If Action is set to fraAuto, the next call about this operation will be to AfterRenameFile.
• If Action is set to fraCustom, the next call about the operation will be to RenameFile, and after that to AfterRenameFile.
• If Action is set to fraAbort, the operation is rejected and no further calls about it are performed.

AfterReadObject Event (KMIPServer Class)

Notifies the application of the completion of the read operation on the object.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireAfterReadObject(KMIPServerAfterReadObjectEventParams *e);

typedef struct {
  int64 ConnectionId;
  const char *ObjectId;
  int ObjectType;
  int OperationStatus;
  int reserved;
} KMIPServerAfterReadObjectEventParams;


Unicode (Windows)
virtual INT FireAfterReadObject(KMIPServerAfterReadObjectEventParams *e);

typedef struct {
  LONG64 ConnectionId;
  LPCWSTR ObjectId;
  INT ObjectType;
  INT OperationStatus;
  INT reserved;
} KMIPServerAfterReadObjectEventParams;

#define EID_KMIPSERVER_AFTERREADOBJECT 18

virtual INT SECUREBLACKBOX_CALL FireAfterReadObject(LONG64 &lConnectionId, LPSTR &lpszObjectId, INT &iObjectType, INT &iOperationStatus);

class KMIPServerAfterReadObjectEventParams {
public:
  qint64 ConnectionId();

  const QString &ObjectId();

  int ObjectType();

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass KMIPServer and override this emitter function.
virtual int FireAfterReadObject(KMIPServerAfterReadObjectEventParams *e) {...}

Remarks

Use this event to be notified about completion of the read operation.

See the

Handling and overriding server operations using the Three-Step Virtualization

Most of the server components shipped with SecureBlackbox are highly customizable, allowing the user to override or alter the way the clients' requests are handled by default. The customization feature paves the way for creation of bespoke or virtualized server solutions that work over standardized protocols.

The possibility of customization is typically offered through a three-step virtualization model. Every customizable operation or request that can be handled by the server - say, RenameFile - is represented with a triple of events:

• BeforeRenameFile
• RenameFile
• AfterRenameFile

The first event fires right after the respective request has been received from a client. It provides the details of the operation, such as the original and target file names, and, importantly, a by-reference (writable) Action parameter. The event handler can set the Action parameter to one of the three settings given below. The setting chosen defines the further operation flow:

• fraAuto: the operation shall be handled automatically by the server: in this case, a file will be searched in the provided local directory and renamed.
• fraCustom: indicates that the user wants to take care of the operation by themselves. If this setting is chosen, the server takes no action, and instead fires the RenameFile event shortly after BeforeRenameFile completes. The user is expected to handle RenameFile and perform the requested action - that is, rename the file - manually.
• fraAbort: the operation should be aborted as not supported/allowed. Neither the server nor the user are expected to perform it.

The second event (RenameFile) only fires if Action was set to fraCustom in the earlier call to BeforeRenameFile. It lets the user handle the requested operation in the way they want. The user code must fulfil the operation (for example, rename a database entry, if building a virtualized server), and return the operation result as the event's OperationResult parameter.

If the Action parameter was set to fraAuto, RenameFile is not called. The server performs the operation automatically.

The third event, AfterRenameFile, fires upon completion of the operation, either in automatic or custom mode. The user code can check and/or adjust the result to be returned to the client.

To summarize:

• If Action is set to fraAuto, the next call about this operation will be to AfterRenameFile.
• If Action is set to fraCustom, the next call about the operation will be to RenameFile, and after that to AfterRenameFile.
• If Action is set to fraAbort, the operation is rejected and no further calls about it are performed.

AfterReCertify Event (KMIPServer Class)

Notifies the application about the completion of the re-certify operation.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireAfterReCertify(KMIPServerAfterReCertifyEventParams *e);

typedef struct {
  int64 ConnectionId;
  char *NewCertId;
  int OperationStatus;
  int reserved;
} KMIPServerAfterReCertifyEventParams;


Unicode (Windows)
virtual INT FireAfterReCertify(KMIPServerAfterReCertifyEventParams *e);

typedef struct {
  LONG64 ConnectionId;
  LPWSTR NewCertId;
  INT OperationStatus;
  INT reserved;
} KMIPServerAfterReCertifyEventParams;

#define EID_KMIPSERVER_AFTERRECERTIFY 19

virtual INT SECUREBLACKBOX_CALL FireAfterReCertify(LONG64 &lConnectionId, LPSTR &lpszNewCertId, INT &iOperationStatus);

class KMIPServerAfterReCertifyEventParams {
public:
  qint64 ConnectionId();

  const QString &NewCertId();
  void SetNewCertId(const QString &qsNewCertId);

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass KMIPServer and override this emitter function.
virtual int FireAfterReCertify(KMIPServerAfterReCertifyEventParams *e) {...}

Remarks

The server component uses this event to notify the application about the completion of the re-certification (certificate renewal) operation. The NewCertId contains the unique ID of the new certificate object. You can adjust it if required.

AfterReKey Event (KMIPServer Class)

Notifies the application about the completion of the re-key operation.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireAfterReKey(KMIPServerAfterReKeyEventParams *e);

typedef struct {
  int64 ConnectionId;
  char *NewKeyId;
  int OperationStatus;
  int reserved;
} KMIPServerAfterReKeyEventParams;


Unicode (Windows)
virtual INT FireAfterReKey(KMIPServerAfterReKeyEventParams *e);

typedef struct {
  LONG64 ConnectionId;
  LPWSTR NewKeyId;
  INT OperationStatus;
  INT reserved;
} KMIPServerAfterReKeyEventParams;

#define EID_KMIPSERVER_AFTERREKEY 20

virtual INT SECUREBLACKBOX_CALL FireAfterReKey(LONG64 &lConnectionId, LPSTR &lpszNewKeyId, INT &iOperationStatus);

class KMIPServerAfterReKeyEventParams {
public:
  qint64 ConnectionId();

  const QString &NewKeyId();
  void SetNewKeyId(const QString &qsNewKeyId);

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass KMIPServer and override this emitter function.
virtual int FireAfterReKey(KMIPServerAfterReKeyEventParams *e) {...}

Remarks

The server component uses this event to notify the application about the completion of the re-key (key renewal) operation. The NewKeyId contains the unique ID of the new key object. You can adjust it if required.

AfterRekeyKeyPair Event (KMIPServer Class)

Notifies the application about the completion of the re-key keypair operation.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireAfterRekeyKeyPair(KMIPServerAfterRekeyKeyPairEventParams *e);

typedef struct {
  int64 ConnectionId;
  char *NewPrivateKeyId;
  char *NewPublicKeyId;
  int OperationStatus;
  int reserved;
} KMIPServerAfterRekeyKeyPairEventParams;


Unicode (Windows)
virtual INT FireAfterRekeyKeyPair(KMIPServerAfterRekeyKeyPairEventParams *e);

typedef struct {
  LONG64 ConnectionId;
  LPWSTR NewPrivateKeyId;
  LPWSTR NewPublicKeyId;
  INT OperationStatus;
  INT reserved;
} KMIPServerAfterRekeyKeyPairEventParams;

#define EID_KMIPSERVER_AFTERREKEYKEYPAIR 21

virtual INT SECUREBLACKBOX_CALL FireAfterRekeyKeyPair(LONG64 &lConnectionId, LPSTR &lpszNewPrivateKeyId, LPSTR &lpszNewPublicKeyId, INT &iOperationStatus);

class KMIPServerAfterRekeyKeyPairEventParams {
public:
  qint64 ConnectionId();

  const QString &NewPrivateKeyId();
  void SetNewPrivateKeyId(const QString &qsNewPrivateKeyId);

  const QString &NewPublicKeyId();
  void SetNewPublicKeyId(const QString &qsNewPublicKeyId);

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass KMIPServer and override this emitter function.
virtual int FireAfterRekeyKeyPair(KMIPServerAfterRekeyKeyPairEventParams *e) {...}

Remarks

The server component uses this event to notify the application about the completion of the re-key (asymmetric key renewal) operation. The NewPrivateKeyId and NewPublicKeyId parameters contains the unique ID of the new key objects. You can adjust them if required.

AfterRemoveObject Event (KMIPServer Class)

Notifies the application about completion of the object removal request.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireAfterRemoveObject(KMIPServerAfterRemoveObjectEventParams *e);

typedef struct {
  int64 ConnectionId;
  const char *ObjectId;
  int OperationStatus;
  int reserved;
} KMIPServerAfterRemoveObjectEventParams;


Unicode (Windows)
virtual INT FireAfterRemoveObject(KMIPServerAfterRemoveObjectEventParams *e);

typedef struct {
  LONG64 ConnectionId;
  LPCWSTR ObjectId;
  INT OperationStatus;
  INT reserved;
} KMIPServerAfterRemoveObjectEventParams;

#define EID_KMIPSERVER_AFTERREMOVEOBJECT 22

virtual INT SECUREBLACKBOX_CALL FireAfterRemoveObject(LONG64 &lConnectionId, LPSTR &lpszObjectId, INT &iOperationStatus);

class KMIPServerAfterRemoveObjectEventParams {
public:
  qint64 ConnectionId();

  const QString &ObjectId();

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass KMIPServer and override this emitter function.
virtual int FireAfterRemoveObject(KMIPServerAfterRemoveObjectEventParams *e) {...}

Remarks

Subscribe to this event to be notified about completion of an object removal request. The OperationStatus parameter contains the result of the operation.

See the

Handling and overriding server operations using the Three-Step Virtualization

Most of the server components shipped with SecureBlackbox are highly customizable, allowing the user to override or alter the way the clients' requests are handled by default. The customization feature paves the way for creation of bespoke or virtualized server solutions that work over standardized protocols.

The possibility of customization is typically offered through a three-step virtualization model. Every customizable operation or request that can be handled by the server - say, RenameFile - is represented with a triple of events:

• BeforeRenameFile
• RenameFile
• AfterRenameFile

The first event fires right after the respective request has been received from a client. It provides the details of the operation, such as the original and target file names, and, importantly, a by-reference (writable) Action parameter. The event handler can set the Action parameter to one of the three settings given below. The setting chosen defines the further operation flow:

• fraAuto: the operation shall be handled automatically by the server: in this case, a file will be searched in the provided local directory and renamed.
• fraCustom: indicates that the user wants to take care of the operation by themselves. If this setting is chosen, the server takes no action, and instead fires the RenameFile event shortly after BeforeRenameFile completes. The user is expected to handle RenameFile and perform the requested action - that is, rename the file - manually.
• fraAbort: the operation should be aborted as not supported/allowed. Neither the server nor the user are expected to perform it.

The second event (RenameFile) only fires if Action was set to fraCustom in the earlier call to BeforeRenameFile. It lets the user handle the requested operation in the way they want. The user code must fulfil the operation (for example, rename a database entry, if building a virtualized server), and return the operation result as the event's OperationResult parameter.

If the Action parameter was set to fraAuto, RenameFile is not called. The server performs the operation automatically.

The third event, AfterRenameFile, fires upon completion of the operation, either in automatic or custom mode. The user code can check and/or adjust the result to be returned to the client.

To summarize:

• If Action is set to fraAuto, the next call about this operation will be to AfterRenameFile.
• If Action is set to fraCustom, the next call about the operation will be to RenameFile, and after that to AfterRenameFile.
• If Action is set to fraAbort, the operation is rejected and no further calls about it are performed.

AfterSign Event (KMIPServer Class)

Notifies the application of completion of a signing operation.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireAfterSign(KMIPServerAfterSignEventParams *e);

typedef struct {
  int64 ConnectionId;
  const char *ObjectId;
  int InputIsHash;
  const char *SignatureData;
  int lenSignatureData;
  char *CorrelationValue;
  int OperationStatus;
  int reserved;
} KMIPServerAfterSignEventParams;


Unicode (Windows)
virtual INT FireAfterSign(KMIPServerAfterSignEventParams *e);

typedef struct {
  LONG64 ConnectionId;
  LPCWSTR ObjectId;
  BOOL InputIsHash;
  LPCSTR SignatureData;
  INT lenSignatureData;
  LPWSTR CorrelationValue;
  INT OperationStatus;
  INT reserved;
} KMIPServerAfterSignEventParams;

#define EID_KMIPSERVER_AFTERSIGN 23

virtual INT SECUREBLACKBOX_CALL FireAfterSign(LONG64 &lConnectionId, LPSTR &lpszObjectId, BOOL &bInputIsHash, LPSTR &lpSignatureData, INT &lenSignatureData, LPSTR &lpszCorrelationValue, INT &iOperationStatus);

class KMIPServerAfterSignEventParams {
public:
  qint64 ConnectionId();

  const QString &ObjectId();

  bool InputIsHash();

  const QByteArray &SignatureData();

  const QString &CorrelationValue();
  void SetCorrelationValue(const QString &qsCorrelationValue);

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass KMIPServer and override this emitter function.
virtual int FireAfterSign(KMIPServerAfterSignEventParams *e) {...}

Remarks

The component uses this event to notify the application about the completion of a signing operation.

The ObjectId parameter contains the unique identifier of the signing key. SignatureData contains the signing result. The CorrelationValue string is a linking token that allows to associate several pieces of a multi-step signing operation together. The OperationStatus contains the result of the operation.

See the

Handling and overriding server operations using the Three-Step Virtualization

Most of the server components shipped with SecureBlackbox are highly customizable, allowing the user to override or alter the way the clients' requests are handled by default. The customization feature paves the way for creation of bespoke or virtualized server solutions that work over standardized protocols.

The possibility of customization is typically offered through a three-step virtualization model. Every customizable operation or request that can be handled by the server - say, RenameFile - is represented with a triple of events:

• BeforeRenameFile
• RenameFile
• AfterRenameFile

The first event fires right after the respective request has been received from a client. It provides the details of the operation, such as the original and target file names, and, importantly, a by-reference (writable) Action parameter. The event handler can set the Action parameter to one of the three settings given below. The setting chosen defines the further operation flow:

• fraAuto: the operation shall be handled automatically by the server: in this case, a file will be searched in the provided local directory and renamed.
• fraCustom: indicates that the user wants to take care of the operation by themselves. If this setting is chosen, the server takes no action, and instead fires the RenameFile event shortly after BeforeRenameFile completes. The user is expected to handle RenameFile and perform the requested action - that is, rename the file - manually.
• fraAbort: the operation should be aborted as not supported/allowed. Neither the server nor the user are expected to perform it.

The second event (RenameFile) only fires if Action was set to fraCustom in the earlier call to BeforeRenameFile. It lets the user handle the requested operation in the way they want. The user code must fulfil the operation (for example, rename a database entry, if building a virtualized server), and return the operation result as the event's OperationResult parameter.

If the Action parameter was set to fraAuto, RenameFile is not called. The server performs the operation automatically.

The third event, AfterRenameFile, fires upon completion of the operation, either in automatic or custom mode. The user code can check and/or adjust the result to be returned to the client.

To summarize:

• If Action is set to fraAuto, the next call about this operation will be to AfterRenameFile.
• If Action is set to fraCustom, the next call about the operation will be to RenameFile, and after that to AfterRenameFile.
• If Action is set to fraAbort, the operation is rejected and no further calls about it are performed.

AfterVerify Event (KMIPServer Class)

Notifies the application about completion of the Verify operation.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireAfterVerify(KMIPServerAfterVerifyEventParams *e);

typedef struct {
  int64 ConnectionId;
  const char *ObjectId;
  int InputIsHash;
  int ValidationResult;
  char *CorrelationValue;
  int OperationStatus;
  int reserved;
} KMIPServerAfterVerifyEventParams;


Unicode (Windows)
virtual INT FireAfterVerify(KMIPServerAfterVerifyEventParams *e);

typedef struct {
  LONG64 ConnectionId;
  LPCWSTR ObjectId;
  BOOL InputIsHash;
  INT ValidationResult;
  LPWSTR CorrelationValue;
  INT OperationStatus;
  INT reserved;
} KMIPServerAfterVerifyEventParams;

#define EID_KMIPSERVER_AFTERVERIFY 24

virtual INT SECUREBLACKBOX_CALL FireAfterVerify(LONG64 &lConnectionId, LPSTR &lpszObjectId, BOOL &bInputIsHash, INT &iValidationResult, LPSTR &lpszCorrelationValue, INT &iOperationStatus);

class KMIPServerAfterVerifyEventParams {
public:
  qint64 ConnectionId();

  const QString &ObjectId();

  bool InputIsHash();

  int ValidationResult();
  void SetValidationResult(int iValidationResult);

  const QString &CorrelationValue();
  void SetCorrelationValue(const QString &qsCorrelationValue);

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass KMIPServer and override this emitter function.
virtual int FireAfterVerify(KMIPServerAfterVerifyEventParams *e) {...}

Remarks

The component fires this event to notify the application of a completion of a verification operation. The ValidationResult parameter contains the validity status of the signature.

The ObjectId parameter contains the unique identifier of the verifying key. The OperationStatus parameter contains the result of the operation.

See the

Handling and overriding server operations using the Three-Step Virtualization

Most of the server components shipped with SecureBlackbox are highly customizable, allowing the user to override or alter the way the clients' requests are handled by default. The customization feature paves the way for creation of bespoke or virtualized server solutions that work over standardized protocols.

The possibility of customization is typically offered through a three-step virtualization model. Every customizable operation or request that can be handled by the server - say, RenameFile - is represented with a triple of events:

• BeforeRenameFile
• RenameFile
• AfterRenameFile

The first event fires right after the respective request has been received from a client. It provides the details of the operation, such as the original and target file names, and, importantly, a by-reference (writable) Action parameter. The event handler can set the Action parameter to one of the three settings given below. The setting chosen defines the further operation flow:

• fraAuto: the operation shall be handled automatically by the server: in this case, a file will be searched in the provided local directory and renamed.
• fraCustom: indicates that the user wants to take care of the operation by themselves. If this setting is chosen, the server takes no action, and instead fires the RenameFile event shortly after BeforeRenameFile completes. The user is expected to handle RenameFile and perform the requested action - that is, rename the file - manually.
• fraAbort: the operation should be aborted as not supported/allowed. Neither the server nor the user are expected to perform it.

The second event (RenameFile) only fires if Action was set to fraCustom in the earlier call to BeforeRenameFile. It lets the user handle the requested operation in the way they want. The user code must fulfil the operation (for example, rename a database entry, if building a virtualized server), and return the operation result as the event's OperationResult parameter.

If the Action parameter was set to fraAuto, RenameFile is not called. The server performs the operation automatically.

The third event, AfterRenameFile, fires upon completion of the operation, either in automatic or custom mode. The user code can check and/or adjust the result to be returned to the client.

To summarize:

• If Action is set to fraAuto, the next call about this operation will be to AfterRenameFile.
• If Action is set to fraCustom, the next call about the operation will be to RenameFile, and after that to AfterRenameFile.
• If Action is set to fraAbort, the operation is rejected and no further calls about it are performed.

AfterVerifyHash Event (KMIPServer Class)

Notifies the application about completion of the hash verification.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireAfterVerifyHash(KMIPServerAfterVerifyHashEventParams *e);

typedef struct {
  int64 ConnectionId;
  const char *ObjectId;
  int IsValid;
  char *CorrelationValue;
  int OperationStatus;
  int reserved;
} KMIPServerAfterVerifyHashEventParams;


Unicode (Windows)
virtual INT FireAfterVerifyHash(KMIPServerAfterVerifyHashEventParams *e);

typedef struct {
  LONG64 ConnectionId;
  LPCWSTR ObjectId;
  BOOL IsValid;
  LPWSTR CorrelationValue;
  INT OperationStatus;
  INT reserved;
} KMIPServerAfterVerifyHashEventParams;

#define EID_KMIPSERVER_AFTERVERIFYHASH 25

virtual INT SECUREBLACKBOX_CALL FireAfterVerifyHash(LONG64 &lConnectionId, LPSTR &lpszObjectId, BOOL &bIsValid, LPSTR &lpszCorrelationValue, INT &iOperationStatus);

class KMIPServerAfterVerifyHashEventParams {
public:
  qint64 ConnectionId();

  const QString &ObjectId();

  bool IsValid();
  void SetIsValid(bool bIsValid);

  const QString &CorrelationValue();
  void SetCorrelationValue(const QString &qsCorrelationValue);

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass KMIPServer and override this emitter function.
virtual int FireAfterVerifyHash(KMIPServerAfterVerifyHashEventParams *e) {...}

Remarks

The component uses this event to notify the application about hash verification result. The optional ObjectId parameter contains the unique identifier of the key object if HMAC algorithm is used.

The IsValid parameter contains the validity factor of the hash.

See the

Handling and overriding server operations using the Three-Step Virtualization

Most of the server components shipped with SecureBlackbox are highly customizable, allowing the user to override or alter the way the clients' requests are handled by default. The customization feature paves the way for creation of bespoke or virtualized server solutions that work over standardized protocols.

The possibility of customization is typically offered through a three-step virtualization model. Every customizable operation or request that can be handled by the server - say, RenameFile - is represented with a triple of events:

• BeforeRenameFile
• RenameFile
• AfterRenameFile

The first event fires right after the respective request has been received from a client. It provides the details of the operation, such as the original and target file names, and, importantly, a by-reference (writable) Action parameter. The event handler can set the Action parameter to one of the three settings given below. The setting chosen defines the further operation flow:

• fraAuto: the operation shall be handled automatically by the server: in this case, a file will be searched in the provided local directory and renamed.
• fraCustom: indicates that the user wants to take care of the operation by themselves. If this setting is chosen, the server takes no action, and instead fires the RenameFile event shortly after BeforeRenameFile completes. The user is expected to handle RenameFile and perform the requested action - that is, rename the file - manually.
• fraAbort: the operation should be aborted as not supported/allowed. Neither the server nor the user are expected to perform it.

The second event (RenameFile) only fires if Action was set to fraCustom in the earlier call to BeforeRenameFile. It lets the user handle the requested operation in the way they want. The user code must fulfil the operation (for example, rename a database entry, if building a virtualized server), and return the operation result as the event's OperationResult parameter.

If the Action parameter was set to fraAuto, RenameFile is not called. The server performs the operation automatically.

The third event, AfterRenameFile, fires upon completion of the operation, either in automatic or custom mode. The user code can check and/or adjust the result to be returned to the client.

To summarize:

• If Action is set to fraAuto, the next call about this operation will be to AfterRenameFile.
• If Action is set to fraCustom, the next call about the operation will be to RenameFile, and after that to AfterRenameFile.
• If Action is set to fraAbort, the operation is rejected and no further calls about it are performed.

ArchiveObject Event (KMIPServer Class)

Notifies the application about the received object archival request.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireArchiveObject(KMIPServerArchiveObjectEventParams *e);

typedef struct {
  int64 ConnectionId;
  const char *ObjectId;
  int OperationStatus;
  int reserved;
} KMIPServerArchiveObjectEventParams;


Unicode (Windows)
virtual INT FireArchiveObject(KMIPServerArchiveObjectEventParams *e);

typedef struct {
  LONG64 ConnectionId;
  LPCWSTR ObjectId;
  INT OperationStatus;
  INT reserved;
} KMIPServerArchiveObjectEventParams;

#define EID_KMIPSERVER_ARCHIVEOBJECT 26

virtual INT SECUREBLACKBOX_CALL FireArchiveObject(LONG64 &lConnectionId, LPSTR &lpszObjectId, INT &iOperationStatus);

class KMIPServerArchiveObjectEventParams {
public:
  qint64 ConnectionId();

  const QString &ObjectId();

  int OperationStatus();
  void SetOperationStatus(int iOperationStatus);

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

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

// Or, subclass KMIPServer and override this emitter function.
virtual int FireArchiveObject(KMIPServerArchiveObjectEventParams *e) {...}

Remarks

The component fires this event when it receives an object archival request from a connected client. The archival procedure go through a simplified handling route, without the three-step flow.

AuthAttempt Event (KMIPServer Class)

Fires when a connected client makes an authentication attempt.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireAuthAttempt(KMIPServerAuthAttemptEventParams *e);

typedef struct {
  int64 ConnectionID;
  const char *HTTPMethod;
  const char *URI;
  const char *AuthMethod;
  const char *Username;
  const char *Password;
  int Allow;
  int reserved;
} KMIPServerAuthAttemptEventParams;


Unicode (Windows)
virtual INT FireAuthAttempt(KMIPServerAuthAttemptEventParams *e);

typedef struct {
  LONG64 ConnectionID;
  LPCWSTR HTTPMethod;
  LPCWSTR URI;
  LPCWSTR AuthMethod;
  LPCWSTR Username;
  LPCWSTR Password;
  BOOL Allow;
  INT reserved;
} KMIPServerAuthAttemptEventParams;

#define EID_KMIPSERVER_AUTHATTEMPT 27

virtual INT SECUREBLACKBOX_CALL FireAuthAttempt(LONG64 &lConnectionID, LPSTR &lpszHTTPMethod, LPSTR &lpszURI, LPSTR &lpszAuthMethod, LPSTR &lpszUsername, LPSTR &lpszPassword, BOOL &bAllow);

class KMIPServerAuthAttemptEventParams {
public:
  qint64 ConnectionID();

  const QString &HTTPMethod();

  const QString &URI();

  const QString &AuthMethod();

  const QString &Username();

  const QString &Password();

  bool Allow();
  void SetAllow(bool bAllow);

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

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

// Or, subclass KMIPServer and override this emitter function.
virtual int FireAuthAttempt(KMIPServerAuthAttemptEventParams *e) {...}

Remarks

The class fires this event whenever a client attempts to authenticate itself. Use the Allow parameter to let the client through.

ConnectionID contains the unique session identifier for that client, HTTPMethod specifies the HTTP method (GET, POST, etc.) used to access the URI resource, AuthMethod specifies the authentication method, and Username and Password contain the professed credentials.

BeforeAdd Event (KMIPServer Class)

Fires when a certificate import request is received from a client.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireBeforeAdd(KMIPServerBeforeAddEventParams *e);

typedef struct {
  int64 ConnectionId;
  char *Group;
  int Action;
  int reserved;
} KMIPServerBeforeAddEventParams;


Unicode (Windows)
virtual INT FireBeforeAdd(KMIPServerBeforeAddEventParams *e);

typedef struct {
  LONG64 ConnectionId;
  LPWSTR Group;
  INT Action;
  INT reserved;
} KMIPServerBeforeAddEventParams;

#define EID_KMIPSERVER_BEFOREADD 28

virtual INT SECUREBLACKBOX_CALL FireBeforeAdd(LONG64 &lConnectionId, LPSTR &lpszGroup, INT &iAction);

class KMIPServerBeforeAddEventParams {
public:
  qint64 ConnectionId();

  const QString &Group();
  void SetGroup(const QString &qsGroup);

  int Action();
  void SetAction(int iAction);

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

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

// Or, subclass KMIPServer and override this emitter function.
virtual int FireBeforeAdd(KMIPServerBeforeAddEventParams *e) {...}

Remarks

The class fires this event when it receives a request from the client to import a certificate on to the server. The supplied certificate is available in Certificate object.

The Group parameter specifies a common identifier for objects related to the certificate being imported: the certificate, its public key, and its private key.

BeforeAddKey Event (KMIPServer Class)

Fires when a key import request is received from the client.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireBeforeAddKey(KMIPServerBeforeAddKeyEventParams *e);

typedef struct {
  int64 ConnectionId;
  char *Group;
  int Action;
  int reserved;
} KMIPServerBeforeAddKeyEventParams;


Unicode (Windows)
virtual INT FireBeforeAddKey(KMIPServerBeforeAddKeyEventParams *e);

typedef struct {
  LONG64 ConnectionId;
  LPWSTR Group;
  INT Action;
  INT reserved;
} KMIPServerBeforeAddKeyEventParams;

#define EID_KMIPSERVER_BEFOREADDKEY 29

virtual INT SECUREBLACKBOX_CALL FireBeforeAddKey(LONG64 &lConnectionId, LPSTR &lpszGroup, INT &iAction);

class KMIPServerBeforeAddKeyEventParams {
public:
  qint64 ConnectionId();

  const QString &Group();
  void SetGroup(const QString &qsGroup);

  int Action();
  void SetAction(int iAction);

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

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

// Or, subclass KMIPServer and override this emitter function.
virtual int FireBeforeAddKey(KMIPServerBeforeAddKeyEventParams *e) {...}

Remarks

The class fires this event when it receives a request from the client to import a key on to the server. The supplied key is available in the Key parameter.

For keypairs, the Group parameter contains a common label that will be applied to both parts of that keypair (the public key object and the private key object).

BeforeBrowse Event (KMIPServer Class)

Notifies the application about the browse request being received.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireBeforeBrowse(KMIPServerBeforeBrowseEventParams *e);

typedef struct {
  int64 ConnectionID;
  const char *ObjectId;
  int Action;
  int reserved;
} KMIPServerBeforeBrowseEventParams;


Unicode (Windows)
virtual INT FireBeforeBrowse(KMIPServerBeforeBrowseEventParams *e);

typedef struct {
  LONG64 ConnectionID;
  LPCWSTR ObjectId;
  INT Action;
  INT reserved;
} KMIPServerBeforeBrowseEventParams;

#define EID_KMIPSERVER_BEFOREBROWSE 30

virtual INT SECUREBLACKBOX_CALL FireBeforeBrowse(LONG64 &lConnectionID, LPSTR &lpszObjectId, INT &iAction);

class KMIPServerBeforeBrowseEventParams {
public:
  qint64 ConnectionID();

  const QString &ObjectId();

  int Action();
  void SetAction(int iAction);

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

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

// Or, subclass KMIPServer and override this emitter function.
virtual int FireBeforeBrowse(KMIPServerBeforeBrowseEventParams *e) {...}