int secureblackbox_certificatevalidator_getblockedcertcount(void* lpObj);
int secureblackbox_certificatevalidator_setblockedcertcount(void* lpObj, int iBlockedCertCount);

int secureblackbox_certificatevalidator_getblockedcertbytes(void* lpObj, int blockedcertindex, char** lpBlockedCertBytes, int* lenBlockedCertBytes);

int64 secureblackbox_certificatevalidator_getblockedcerthandle(void* lpObj, int blockedcertindex);
int secureblackbox_certificatevalidator_setblockedcerthandle(void* lpObj, int blockedcertindex, int64 lBlockedCertHandle);

int GetBlockedCertCount();
int SetBlockedCertCount(int iBlockedCertCount);

QByteArray GetBlockedCertBytes(int iBlockedCertIndex);

qint64 GetBlockedCertHandle(int iBlockedCertIndex);
int SetBlockedCertHandle(int iBlockedCertIndex, qint64 lBlockedCertHandle);

int secureblackbox_certificatevalidator_getcachevalidationresults(void* lpObj);
int secureblackbox_certificatevalidator_setcachevalidationresults(void* lpObj, int bCacheValidationResults);

bool GetCacheValidationResults();
int SetCacheValidationResults(bool bCacheValidationResults);

int secureblackbox_certificatevalidator_getcertbytes(void* lpObj, char** lpCertBytes, int* lenCertBytes);

int64 secureblackbox_certificatevalidator_getcerthandle(void* lpObj);
int secureblackbox_certificatevalidator_setcerthandle(void* lpObj, int64 lCertHandle);

QByteArray GetCertBytes();

qint64 GetCertHandle();
int SetCertHandle(qint64 lCertHandle);

int secureblackbox_certificatevalidator_getchainvalidationdetails(void* lpObj);

int GetChainValidationDetails();

int secureblackbox_certificatevalidator_getchainvalidationresult(void* lpObj);

int GetChainValidationResult();

int secureblackbox_certificatevalidator_getchecktrustedlists(void* lpObj);
int secureblackbox_certificatevalidator_setchecktrustedlists(void* lpObj, int bCheckTrustedLists);

bool GetCheckTrustedLists();
int SetCheckTrustedLists(bool bCheckTrustedLists);

int secureblackbox_certificatevalidator_getcurrentcacertbytes(void* lpObj, char** lpCurrentCACertBytes, int* lenCurrentCACertBytes);

int secureblackbox_certificatevalidator_getcurrentcacertca(void* lpObj);

int secureblackbox_certificatevalidator_getcurrentcacertcakeyid(void* lpObj, char** lpCurrentCACertCAKeyID, int* lenCurrentCACertCAKeyID);

int secureblackbox_certificatevalidator_getcurrentcacertcerttype(void* lpObj);

char* secureblackbox_certificatevalidator_getcurrentcacertcrldistributionpoints(void* lpObj);

char* secureblackbox_certificatevalidator_getcurrentcacertcurve(void* lpObj);

char* secureblackbox_certificatevalidator_getcurrentcacertfingerprint(void* lpObj);

char* secureblackbox_certificatevalidator_getcurrentcacertfriendlyname(void* lpObj);

int64 secureblackbox_certificatevalidator_getcurrentcacerthandle(void* lpObj);

char* secureblackbox_certificatevalidator_getcurrentcacerthashalgorithm(void* lpObj);

char* secureblackbox_certificatevalidator_getcurrentcacertissuer(void* lpObj);

char* secureblackbox_certificatevalidator_getcurrentcacertissuerrdn(void* lpObj);

char* secureblackbox_certificatevalidator_getcurrentcacertkeyalgorithm(void* lpObj);

int secureblackbox_certificatevalidator_getcurrentcacertkeybits(void* lpObj);

char* secureblackbox_certificatevalidator_getcurrentcacertkeyfingerprint(void* lpObj);

int secureblackbox_certificatevalidator_getcurrentcacertkeyusage(void* lpObj);

int secureblackbox_certificatevalidator_getcurrentcacertkeyvalid(void* lpObj);

char* secureblackbox_certificatevalidator_getcurrentcacertocsplocations(void* lpObj);

int secureblackbox_certificatevalidator_getcurrentcacertocspnocheck(void* lpObj);

int secureblackbox_certificatevalidator_getcurrentcacertorigin(void* lpObj);

char* secureblackbox_certificatevalidator_getcurrentcacertpolicyids(void* lpObj);

int secureblackbox_certificatevalidator_getcurrentcacertprivatekeybytes(void* lpObj, char** lpCurrentCACertPrivateKeyBytes, int* lenCurrentCACertPrivateKeyBytes);

int secureblackbox_certificatevalidator_getcurrentcacertprivatekeyexists(void* lpObj);

int secureblackbox_certificatevalidator_getcurrentcacertprivatekeyextractable(void* lpObj);

int secureblackbox_certificatevalidator_getcurrentcacertpublickeybytes(void* lpObj, char** lpCurrentCACertPublicKeyBytes, int* lenCurrentCACertPublicKeyBytes);

int secureblackbox_certificatevalidator_getcurrentcacertqualified(void* lpObj);

int secureblackbox_certificatevalidator_getcurrentcacertqualifiedstatements(void* lpObj);

char* secureblackbox_certificatevalidator_getcurrentcacertqualifiers(void* lpObj);

int secureblackbox_certificatevalidator_getcurrentcacertselfsigned(void* lpObj);

int secureblackbox_certificatevalidator_getcurrentcacertserialnumber(void* lpObj, char** lpCurrentCACertSerialNumber, int* lenCurrentCACertSerialNumber);

char* secureblackbox_certificatevalidator_getcurrentcacertsigalgorithm(void* lpObj);

int secureblackbox_certificatevalidator_getcurrentcacertsource(void* lpObj);

char* secureblackbox_certificatevalidator_getcurrentcacertsubject(void* lpObj);

char* secureblackbox_certificatevalidator_getcurrentcacertsubjectalternativename(void* lpObj);

int secureblackbox_certificatevalidator_getcurrentcacertsubjectkeyid(void* lpObj, char** lpCurrentCACertSubjectKeyID, int* lenCurrentCACertSubjectKeyID);

char* secureblackbox_certificatevalidator_getcurrentcacertsubjectrdn(void* lpObj);

int secureblackbox_certificatevalidator_getcurrentcacertvalid(void* lpObj);

char* secureblackbox_certificatevalidator_getcurrentcacertvalidfrom(void* lpObj);

char* secureblackbox_certificatevalidator_getcurrentcacertvalidto(void* lpObj);

QByteArray GetCurrentCACertBytes();

bool GetCurrentCACertCA();

QByteArray GetCurrentCACertCAKeyID();

int GetCurrentCACertCertType();

QString GetCurrentCACertCRLDistributionPoints();

QString GetCurrentCACertCurve();

QString GetCurrentCACertFingerprint();

QString GetCurrentCACertFriendlyName();

qint64 GetCurrentCACertHandle();

QString GetCurrentCACertHashAlgorithm();

QString GetCurrentCACertIssuer();

QString GetCurrentCACertIssuerRDN();

QString GetCurrentCACertKeyAlgorithm();

int GetCurrentCACertKeyBits();

QString GetCurrentCACertKeyFingerprint();

int GetCurrentCACertKeyUsage();

bool GetCurrentCACertKeyValid();

QString GetCurrentCACertOCSPLocations();

bool GetCurrentCACertOCSPNoCheck();

int GetCurrentCACertOrigin();

QString GetCurrentCACertPolicyIDs();

QByteArray GetCurrentCACertPrivateKeyBytes();

bool GetCurrentCACertPrivateKeyExists();

bool GetCurrentCACertPrivateKeyExtractable();

QByteArray GetCurrentCACertPublicKeyBytes();

bool GetCurrentCACertQualified();

int GetCurrentCACertQualifiedStatements();

QString GetCurrentCACertQualifiers();

bool GetCurrentCACertSelfSigned();

QByteArray GetCurrentCACertSerialNumber();

QString GetCurrentCACertSigAlgorithm();

int GetCurrentCACertSource();

QString GetCurrentCACertSubject();

QString GetCurrentCACertSubjectAlternativeName();

QByteArray GetCurrentCACertSubjectKeyID();

QString GetCurrentCACertSubjectRDN();

bool GetCurrentCACertValid();

QString GetCurrentCACertValidFrom();

QString GetCurrentCACertValidTo();

int secureblackbox_certificatevalidator_getcurrentcertbytes(void* lpObj, char** lpCurrentCertBytes, int* lenCurrentCertBytes);

int secureblackbox_certificatevalidator_getcurrentcertca(void* lpObj);

int secureblackbox_certificatevalidator_getcurrentcertcakeyid(void* lpObj, char** lpCurrentCertCAKeyID, int* lenCurrentCertCAKeyID);

int secureblackbox_certificatevalidator_getcurrentcertcerttype(void* lpObj);

char* secureblackbox_certificatevalidator_getcurrentcertcrldistributionpoints(void* lpObj);

char* secureblackbox_certificatevalidator_getcurrentcertcurve(void* lpObj);

char* secureblackbox_certificatevalidator_getcurrentcertfingerprint(void* lpObj);

char* secureblackbox_certificatevalidator_getcurrentcertfriendlyname(void* lpObj);

int64 secureblackbox_certificatevalidator_getcurrentcerthandle(void* lpObj);

char* secureblackbox_certificatevalidator_getcurrentcerthashalgorithm(void* lpObj);

char* secureblackbox_certificatevalidator_getcurrentcertissuer(void* lpObj);

char* secureblackbox_certificatevalidator_getcurrentcertissuerrdn(void* lpObj);

char* secureblackbox_certificatevalidator_getcurrentcertkeyalgorithm(void* lpObj);

int secureblackbox_certificatevalidator_getcurrentcertkeybits(void* lpObj);

char* secureblackbox_certificatevalidator_getcurrentcertkeyfingerprint(void* lpObj);

int secureblackbox_certificatevalidator_getcurrentcertkeyusage(void* lpObj);

int secureblackbox_certificatevalidator_getcurrentcertkeyvalid(void* lpObj);

char* secureblackbox_certificatevalidator_getcurrentcertocsplocations(void* lpObj);

int secureblackbox_certificatevalidator_getcurrentcertocspnocheck(void* lpObj);

int secureblackbox_certificatevalidator_getcurrentcertorigin(void* lpObj);

char* secureblackbox_certificatevalidator_getcurrentcertpolicyids(void* lpObj);

int secureblackbox_certificatevalidator_getcurrentcertprivatekeybytes(void* lpObj, char** lpCurrentCertPrivateKeyBytes, int* lenCurrentCertPrivateKeyBytes);

int secureblackbox_certificatevalidator_getcurrentcertprivatekeyexists(void* lpObj);

int secureblackbox_certificatevalidator_getcurrentcertprivatekeyextractable(void* lpObj);

int secureblackbox_certificatevalidator_getcurrentcertpublickeybytes(void* lpObj, char** lpCurrentCertPublicKeyBytes, int* lenCurrentCertPublicKeyBytes);

int secureblackbox_certificatevalidator_getcurrentcertqualified(void* lpObj);

int secureblackbox_certificatevalidator_getcurrentcertqualifiedstatements(void* lpObj);

char* secureblackbox_certificatevalidator_getcurrentcertqualifiers(void* lpObj);

int secureblackbox_certificatevalidator_getcurrentcertselfsigned(void* lpObj);

int secureblackbox_certificatevalidator_getcurrentcertserialnumber(void* lpObj, char** lpCurrentCertSerialNumber, int* lenCurrentCertSerialNumber);

char* secureblackbox_certificatevalidator_getcurrentcertsigalgorithm(void* lpObj);

int secureblackbox_certificatevalidator_getcurrentcertsource(void* lpObj);

char* secureblackbox_certificatevalidator_getcurrentcertsubject(void* lpObj);

char* secureblackbox_certificatevalidator_getcurrentcertsubjectalternativename(void* lpObj);

int secureblackbox_certificatevalidator_getcurrentcertsubjectkeyid(void* lpObj, char** lpCurrentCertSubjectKeyID, int* lenCurrentCertSubjectKeyID);

char* secureblackbox_certificatevalidator_getcurrentcertsubjectrdn(void* lpObj);

int secureblackbox_certificatevalidator_getcurrentcertvalid(void* lpObj);

char* secureblackbox_certificatevalidator_getcurrentcertvalidfrom(void* lpObj);

char* secureblackbox_certificatevalidator_getcurrentcertvalidto(void* lpObj);

QByteArray GetCurrentCertBytes();

bool GetCurrentCertCA();

QByteArray GetCurrentCertCAKeyID();

int GetCurrentCertCertType();

QString GetCurrentCertCRLDistributionPoints();

QString GetCurrentCertCurve();

QString GetCurrentCertFingerprint();

QString GetCurrentCertFriendlyName();

qint64 GetCurrentCertHandle();

QString GetCurrentCertHashAlgorithm();

QString GetCurrentCertIssuer();

QString GetCurrentCertIssuerRDN();

QString GetCurrentCertKeyAlgorithm();

int GetCurrentCertKeyBits();

QString GetCurrentCertKeyFingerprint();

int GetCurrentCertKeyUsage();

bool GetCurrentCertKeyValid();

QString GetCurrentCertOCSPLocations();

bool GetCurrentCertOCSPNoCheck();

int GetCurrentCertOrigin();

QString GetCurrentCertPolicyIDs();

QByteArray GetCurrentCertPrivateKeyBytes();

bool GetCurrentCertPrivateKeyExists();

bool GetCurrentCertPrivateKeyExtractable();

QByteArray GetCurrentCertPublicKeyBytes();

bool GetCurrentCertQualified();

int GetCurrentCertQualifiedStatements();

QString GetCurrentCertQualifiers();

bool GetCurrentCertSelfSigned();

QByteArray GetCurrentCertSerialNumber();

QString GetCurrentCertSigAlgorithm();

int GetCurrentCertSource();

QString GetCurrentCertSubject();

QString GetCurrentCertSubjectAlternativeName();

QByteArray GetCurrentCertSubjectKeyID();

QString GetCurrentCertSubjectRDN();

bool GetCurrentCertValid();

QString GetCurrentCertValidFrom();

QString GetCurrentCertValidTo();

int secureblackbox_certificatevalidator_getfipsmode(void* lpObj);
int secureblackbox_certificatevalidator_setfipsmode(void* lpObj, int bFIPSMode);

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

int secureblackbox_certificatevalidator_getgraceperiod(void* lpObj);
int secureblackbox_certificatevalidator_setgraceperiod(void* lpObj, int iGracePeriod);

int GetGracePeriod();
int SetGracePeriod(int iGracePeriod);

int secureblackbox_certificatevalidator_getinterimvalidationdetails(void* lpObj);
int secureblackbox_certificatevalidator_setinterimvalidationdetails(void* lpObj, int iInterimValidationDetails);

int GetInterimValidationDetails();
int SetInterimValidationDetails(int iInterimValidationDetails);

int secureblackbox_certificatevalidator_getinterimvalidationresult(void* lpObj);
int secureblackbox_certificatevalidator_setinterimvalidationresult(void* lpObj, int iInterimValidationResult);

int GetInterimValidationResult();
int SetInterimValidationResult(int iInterimValidationResult);

int secureblackbox_certificatevalidator_getknowncertcount(void* lpObj);
int secureblackbox_certificatevalidator_setknowncertcount(void* lpObj, int iKnownCertCount);

int secureblackbox_certificatevalidator_getknowncertbytes(void* lpObj, int knowncertindex, char** lpKnownCertBytes, int* lenKnownCertBytes);

int64 secureblackbox_certificatevalidator_getknowncerthandle(void* lpObj, int knowncertindex);
int secureblackbox_certificatevalidator_setknowncerthandle(void* lpObj, int knowncertindex, int64 lKnownCertHandle);

int GetKnownCertCount();
int SetKnownCertCount(int iKnownCertCount);

QByteArray GetKnownCertBytes(int iKnownCertIndex);

qint64 GetKnownCertHandle(int iKnownCertIndex);
int SetKnownCertHandle(int iKnownCertIndex, qint64 lKnownCertHandle);

int secureblackbox_certificatevalidator_getknowncrlcount(void* lpObj);
int secureblackbox_certificatevalidator_setknowncrlcount(void* lpObj, int iKnownCRLCount);

int secureblackbox_certificatevalidator_getknowncrlbytes(void* lpObj, int knowncrlindex, char** lpKnownCRLBytes, int* lenKnownCRLBytes);

int64 secureblackbox_certificatevalidator_getknowncrlhandle(void* lpObj, int knowncrlindex);
int secureblackbox_certificatevalidator_setknowncrlhandle(void* lpObj, int knowncrlindex, int64 lKnownCRLHandle);

int GetKnownCRLCount();
int SetKnownCRLCount(int iKnownCRLCount);

QByteArray GetKnownCRLBytes(int iKnownCRLIndex);

qint64 GetKnownCRLHandle(int iKnownCRLIndex);
int SetKnownCRLHandle(int iKnownCRLIndex, qint64 lKnownCRLHandle);

int secureblackbox_certificatevalidator_getknownocspcount(void* lpObj);
int secureblackbox_certificatevalidator_setknownocspcount(void* lpObj, int iKnownOCSPCount);

int secureblackbox_certificatevalidator_getknownocspbytes(void* lpObj, int knownocspindex, char** lpKnownOCSPBytes, int* lenKnownOCSPBytes);

int64 secureblackbox_certificatevalidator_getknownocsphandle(void* lpObj, int knownocspindex);
int secureblackbox_certificatevalidator_setknownocsphandle(void* lpObj, int knownocspindex, int64 lKnownOCSPHandle);

int GetKnownOCSPCount();
int SetKnownOCSPCount(int iKnownOCSPCount);

QByteArray GetKnownOCSPBytes(int iKnownOCSPIndex);

qint64 GetKnownOCSPHandle(int iKnownOCSPIndex);
int SetKnownOCSPHandle(int iKnownOCSPIndex, qint64 lKnownOCSPHandle);

int secureblackbox_certificatevalidator_getmaxvalidationtime(void* lpObj);
int secureblackbox_certificatevalidator_setmaxvalidationtime(void* lpObj, int iMaxValidationTime);

int GetMaxValidationTime();
int SetMaxValidationTime(int iMaxValidationTime);

int secureblackbox_certificatevalidator_getofflinemode(void* lpObj);
int secureblackbox_certificatevalidator_setofflinemode(void* lpObj, int bOfflineMode);

bool GetOfflineMode();
int SetOfflineMode(bool bOfflineMode);

char* secureblackbox_certificatevalidator_getproxyaddress(void* lpObj);
int secureblackbox_certificatevalidator_setproxyaddress(void* lpObj, const char* lpszProxyAddress);

int secureblackbox_certificatevalidator_getproxyauthentication(void* lpObj);
int secureblackbox_certificatevalidator_setproxyauthentication(void* lpObj, int iProxyAuthentication);

char* secureblackbox_certificatevalidator_getproxypassword(void* lpObj);
int secureblackbox_certificatevalidator_setproxypassword(void* lpObj, const char* lpszProxyPassword);

int secureblackbox_certificatevalidator_getproxyport(void* lpObj);
int secureblackbox_certificatevalidator_setproxyport(void* lpObj, int iProxyPort);

int secureblackbox_certificatevalidator_getproxyproxytype(void* lpObj);
int secureblackbox_certificatevalidator_setproxyproxytype(void* lpObj, int iProxyProxyType);

char* secureblackbox_certificatevalidator_getproxyrequestheaders(void* lpObj);
int secureblackbox_certificatevalidator_setproxyrequestheaders(void* lpObj, const char* lpszProxyRequestHeaders);

char* secureblackbox_certificatevalidator_getproxyresponsebody(void* lpObj);
int secureblackbox_certificatevalidator_setproxyresponsebody(void* lpObj, const char* lpszProxyResponseBody);

char* secureblackbox_certificatevalidator_getproxyresponseheaders(void* lpObj);
int secureblackbox_certificatevalidator_setproxyresponseheaders(void* lpObj, const char* lpszProxyResponseHeaders);

int secureblackbox_certificatevalidator_getproxyuseipv6(void* lpObj);
int secureblackbox_certificatevalidator_setproxyuseipv6(void* lpObj, int bProxyUseIPv6);

char* secureblackbox_certificatevalidator_getproxyusername(void* lpObj);
int secureblackbox_certificatevalidator_setproxyusername(void* lpObj, const char* lpszProxyUsername);

QString GetProxyAddress();
int SetProxyAddress(QString qsProxyAddress);

int GetProxyAuthentication();
int SetProxyAuthentication(int iProxyAuthentication);

QString GetProxyPassword();
int SetProxyPassword(QString qsProxyPassword);

int GetProxyPort();
int SetProxyPort(int iProxyPort);

int GetProxyProxyType();
int SetProxyProxyType(int iProxyProxyType);

QString GetProxyRequestHeaders();
int SetProxyRequestHeaders(QString qsProxyRequestHeaders);

QString GetProxyResponseBody();
int SetProxyResponseBody(QString qsProxyResponseBody);

QString GetProxyResponseHeaders();
int SetProxyResponseHeaders(QString qsProxyResponseHeaders);

bool GetProxyUseIPv6();
int SetProxyUseIPv6(bool bProxyUseIPv6);

QString GetProxyUsername();
int SetProxyUsername(QString qsProxyUsername);

char* secureblackbox_certificatevalidator_getqualifiedinfoaddress(void* lpObj);

char* secureblackbox_certificatevalidator_getqualifiedinfocustomtrustedlists(void* lpObj);
int secureblackbox_certificatevalidator_setqualifiedinfocustomtrustedlists(void* lpObj, const char* lpszQualifiedInfoCustomTrustedLists);

char* secureblackbox_certificatevalidator_getqualifiedinfodownloadlog(void* lpObj);

char* secureblackbox_certificatevalidator_getqualifiedinfoinformationuri(void* lpObj);

char* secureblackbox_certificatevalidator_getqualifiedinfolanguages(void* lpObj);
int secureblackbox_certificatevalidator_setqualifiedinfolanguages(void* lpObj, const char* lpszQualifiedInfoLanguages);

char* secureblackbox_certificatevalidator_getqualifiedinfonextupdate(void* lpObj);

char* secureblackbox_certificatevalidator_getqualifiedinfoprovider(void* lpObj);

int secureblackbox_certificatevalidator_getqualifiedinfoqualified(void* lpObj);

char* secureblackbox_certificatevalidator_getqualifiedinfoqualifiers(void* lpObj);

char* secureblackbox_certificatevalidator_getqualifiedinfoservicename(void* lpObj);

char* secureblackbox_certificatevalidator_getqualifiedinfoservicetypeid(void* lpObj);

int secureblackbox_certificatevalidator_getqualifiedinfosource(void* lpObj);

int secureblackbox_certificatevalidator_getqualifiedinfostatus(void* lpObj);

char* secureblackbox_certificatevalidator_getqualifiedinfotradename(void* lpObj);

int secureblackbox_certificatevalidator_getqualifiedinfotrusted(void* lpObj);

int secureblackbox_certificatevalidator_getqualifiedinfousedefaulttrustedlists(void* lpObj);
int secureblackbox_certificatevalidator_setqualifiedinfousedefaulttrustedlists(void* lpObj, int bQualifiedInfoUseDefaultTrustedLists);

char* secureblackbox_certificatevalidator_getqualifiedinfovalidationlog(void* lpObj);

char* secureblackbox_certificatevalidator_getqualifiedinfoxml(void* lpObj);

QString GetQualifiedInfoAddress();

QString GetQualifiedInfoCustomTrustedLists();
int SetQualifiedInfoCustomTrustedLists(QString qsQualifiedInfoCustomTrustedLists);

QString GetQualifiedInfoDownloadLog();

QString GetQualifiedInfoInformationURI();

QString GetQualifiedInfoLanguages();
int SetQualifiedInfoLanguages(QString qsQualifiedInfoLanguages);

QString GetQualifiedInfoNextUpdate();

QString GetQualifiedInfoProvider();

bool GetQualifiedInfoQualified();

QString GetQualifiedInfoQualifiers();

QString GetQualifiedInfoServiceName();

QString GetQualifiedInfoServiceTypeId();

int GetQualifiedInfoSource();

int GetQualifiedInfoStatus();

QString GetQualifiedInfoTradeName();

bool GetQualifiedInfoTrusted();

bool GetQualifiedInfoUseDefaultTrustedLists();
int SetQualifiedInfoUseDefaultTrustedLists(bool bQualifiedInfoUseDefaultTrustedLists);

QString GetQualifiedInfoValidationLog();

QString GetQualifiedInfoXML();

int secureblackbox_certificatevalidator_getrevocationcheck(void* lpObj);
int secureblackbox_certificatevalidator_setrevocationcheck(void* lpObj, int iRevocationCheck);

int GetRevocationCheck();
int SetRevocationCheck(int iRevocationCheck);

int secureblackbox_certificatevalidator_getsocketdnsmode(void* lpObj);
int secureblackbox_certificatevalidator_setsocketdnsmode(void* lpObj, int iSocketDNSMode);

int secureblackbox_certificatevalidator_getsocketdnsport(void* lpObj);
int secureblackbox_certificatevalidator_setsocketdnsport(void* lpObj, int iSocketDNSPort);

int secureblackbox_certificatevalidator_getsocketdnsquerytimeout(void* lpObj);
int secureblackbox_certificatevalidator_setsocketdnsquerytimeout(void* lpObj, int iSocketDNSQueryTimeout);

char* secureblackbox_certificatevalidator_getsocketdnsservers(void* lpObj);
int secureblackbox_certificatevalidator_setsocketdnsservers(void* lpObj, const char* lpszSocketDNSServers);

int secureblackbox_certificatevalidator_getsocketdnstotaltimeout(void* lpObj);
int secureblackbox_certificatevalidator_setsocketdnstotaltimeout(void* lpObj, int iSocketDNSTotalTimeout);

int secureblackbox_certificatevalidator_getsocketincomingspeedlimit(void* lpObj);
int secureblackbox_certificatevalidator_setsocketincomingspeedlimit(void* lpObj, int iSocketIncomingSpeedLimit);

char* secureblackbox_certificatevalidator_getsocketlocaladdress(void* lpObj);
int secureblackbox_certificatevalidator_setsocketlocaladdress(void* lpObj, const char* lpszSocketLocalAddress);

int secureblackbox_certificatevalidator_getsocketlocalport(void* lpObj);
int secureblackbox_certificatevalidator_setsocketlocalport(void* lpObj, int iSocketLocalPort);

int secureblackbox_certificatevalidator_getsocketoutgoingspeedlimit(void* lpObj);
int secureblackbox_certificatevalidator_setsocketoutgoingspeedlimit(void* lpObj, int iSocketOutgoingSpeedLimit);

int secureblackbox_certificatevalidator_getsockettimeout(void* lpObj);
int secureblackbox_certificatevalidator_setsockettimeout(void* lpObj, int iSocketTimeout);

int secureblackbox_certificatevalidator_getsocketuseipv6(void* lpObj);
int secureblackbox_certificatevalidator_setsocketuseipv6(void* lpObj, int bSocketUseIPv6);

int GetSocketDNSMode();
int SetSocketDNSMode(int iSocketDNSMode);

int GetSocketDNSPort();
int SetSocketDNSPort(int iSocketDNSPort);

int GetSocketDNSQueryTimeout();
int SetSocketDNSQueryTimeout(int iSocketDNSQueryTimeout);

QString GetSocketDNSServers();
int SetSocketDNSServers(QString qsSocketDNSServers);

int GetSocketDNSTotalTimeout();
int SetSocketDNSTotalTimeout(int iSocketDNSTotalTimeout);

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

int secureblackbox_certificatevalidator_gettlsclientcertcount(void* lpObj);
int secureblackbox_certificatevalidator_settlsclientcertcount(void* lpObj, int iTLSClientCertCount);

int secureblackbox_certificatevalidator_gettlsclientcertbytes(void* lpObj, int tlsclientcertindex, char** lpTLSClientCertBytes, int* lenTLSClientCertBytes);

int64 secureblackbox_certificatevalidator_gettlsclientcerthandle(void* lpObj, int tlsclientcertindex);
int secureblackbox_certificatevalidator_settlsclientcerthandle(void* lpObj, int tlsclientcertindex, int64 lTLSClientCertHandle);

int GetTLSClientCertCount();
int SetTLSClientCertCount(int iTLSClientCertCount);

QByteArray GetTLSClientCertBytes(int iTLSClientCertIndex);

qint64 GetTLSClientCertHandle(int iTLSClientCertIndex);
int SetTLSClientCertHandle(int iTLSClientCertIndex, qint64 lTLSClientCertHandle);

int secureblackbox_certificatevalidator_gettlsservercertcount(void* lpObj);

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

char* secureblackbox_certificatevalidator_gettlsservercertfingerprint(void* lpObj, int tlsservercertindex);

int64 secureblackbox_certificatevalidator_gettlsservercerthandle(void* lpObj, int tlsservercertindex);

char* secureblackbox_certificatevalidator_gettlsservercertissuer(void* lpObj, int tlsservercertindex);

char* secureblackbox_certificatevalidator_gettlsservercertissuerrdn(void* lpObj, int tlsservercertindex);

char* secureblackbox_certificatevalidator_gettlsservercertkeyalgorithm(void* lpObj, int tlsservercertindex);

int secureblackbox_certificatevalidator_gettlsservercertkeybits(void* lpObj, int tlsservercertindex);

int secureblackbox_certificatevalidator_gettlsservercertkeyusage(void* lpObj, int tlsservercertindex);

int secureblackbox_certificatevalidator_gettlsservercertselfsigned(void* lpObj, int tlsservercertindex);

int secureblackbox_certificatevalidator_gettlsservercertserialnumber(void* lpObj, int tlsservercertindex, char** lpTLSServerCertSerialNumber, int* lenTLSServerCertSerialNumber);

char* secureblackbox_certificatevalidator_gettlsservercertsigalgorithm(void* lpObj, int tlsservercertindex);

char* secureblackbox_certificatevalidator_gettlsservercertsubject(void* lpObj, int tlsservercertindex);

char* secureblackbox_certificatevalidator_gettlsservercertsubjectrdn(void* lpObj, int tlsservercertindex);

char* secureblackbox_certificatevalidator_gettlsservercertvalidfrom(void* lpObj, int tlsservercertindex);

char* secureblackbox_certificatevalidator_gettlsservercertvalidto(void* lpObj, int tlsservercertindex);

int GetTLSServerCertCount();

QByteArray GetTLSServerCertBytes(int iTLSServerCertIndex);

QString GetTLSServerCertFingerprint(int iTLSServerCertIndex);

qint64 GetTLSServerCertHandle(int iTLSServerCertIndex);

QString GetTLSServerCertIssuer(int iTLSServerCertIndex);

QString GetTLSServerCertIssuerRDN(int iTLSServerCertIndex);

QString GetTLSServerCertKeyAlgorithm(int iTLSServerCertIndex);

int GetTLSServerCertKeyBits(int iTLSServerCertIndex);

int GetTLSServerCertKeyUsage(int iTLSServerCertIndex);

bool GetTLSServerCertSelfSigned(int iTLSServerCertIndex);

QByteArray GetTLSServerCertSerialNumber(int iTLSServerCertIndex);

QString GetTLSServerCertSigAlgorithm(int iTLSServerCertIndex);

QString GetTLSServerCertSubject(int iTLSServerCertIndex);

QString GetTLSServerCertSubjectRDN(int iTLSServerCertIndex);

QString GetTLSServerCertValidFrom(int iTLSServerCertIndex);

QString GetTLSServerCertValidTo(int iTLSServerCertIndex);

int secureblackbox_certificatevalidator_gettlsautovalidatecertificates(void* lpObj);
int secureblackbox_certificatevalidator_settlsautovalidatecertificates(void* lpObj, int bTLSAutoValidateCertificates);

int secureblackbox_certificatevalidator_gettlsbaseconfiguration(void* lpObj);
int secureblackbox_certificatevalidator_settlsbaseconfiguration(void* lpObj, int iTLSBaseConfiguration);

char* secureblackbox_certificatevalidator_gettlsciphersuites(void* lpObj);
int secureblackbox_certificatevalidator_settlsciphersuites(void* lpObj, const char* lpszTLSCiphersuites);

int secureblackbox_certificatevalidator_gettlsclientauth(void* lpObj);
int secureblackbox_certificatevalidator_settlsclientauth(void* lpObj, int iTLSClientAuth);

char* secureblackbox_certificatevalidator_gettlseccurves(void* lpObj);
int secureblackbox_certificatevalidator_settlseccurves(void* lpObj, const char* lpszTLSECCurves);

char* secureblackbox_certificatevalidator_gettlsextensions(void* lpObj);
int secureblackbox_certificatevalidator_settlsextensions(void* lpObj, const char* lpszTLSExtensions);

int secureblackbox_certificatevalidator_gettlsforceresumeifdestinationchanges(void* lpObj);
int secureblackbox_certificatevalidator_settlsforceresumeifdestinationchanges(void* lpObj, int bTLSForceResumeIfDestinationChanges);

char* secureblackbox_certificatevalidator_gettlspresharedidentity(void* lpObj);
int secureblackbox_certificatevalidator_settlspresharedidentity(void* lpObj, const char* lpszTLSPreSharedIdentity);

char* secureblackbox_certificatevalidator_gettlspresharedkey(void* lpObj);
int secureblackbox_certificatevalidator_settlspresharedkey(void* lpObj, const char* lpszTLSPreSharedKey);

char* secureblackbox_certificatevalidator_gettlspresharedkeyciphersuite(void* lpObj);
int secureblackbox_certificatevalidator_settlspresharedkeyciphersuite(void* lpObj, const char* lpszTLSPreSharedKeyCiphersuite);

int secureblackbox_certificatevalidator_gettlsrenegotiationattackpreventionmode(void* lpObj);
int secureblackbox_certificatevalidator_settlsrenegotiationattackpreventionmode(void* lpObj, int iTLSRenegotiationAttackPreventionMode);

int secureblackbox_certificatevalidator_gettlsrevocationcheck(void* lpObj);
int secureblackbox_certificatevalidator_settlsrevocationcheck(void* lpObj, int iTLSRevocationCheck);

int secureblackbox_certificatevalidator_gettlsssloptions(void* lpObj);
int secureblackbox_certificatevalidator_settlsssloptions(void* lpObj, int iTLSSSLOptions);

int secureblackbox_certificatevalidator_gettlstlsmode(void* lpObj);
int secureblackbox_certificatevalidator_settlstlsmode(void* lpObj, int iTLSTLSMode);

int secureblackbox_certificatevalidator_gettlsuseextendedmastersecret(void* lpObj);
int secureblackbox_certificatevalidator_settlsuseextendedmastersecret(void* lpObj, int bTLSUseExtendedMasterSecret);

int secureblackbox_certificatevalidator_gettlsusesessionresumption(void* lpObj);
int secureblackbox_certificatevalidator_settlsusesessionresumption(void* lpObj, int bTLSUseSessionResumption);

int secureblackbox_certificatevalidator_gettlsversions(void* lpObj);
int secureblackbox_certificatevalidator_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);

int secureblackbox_certificatevalidator_gettrustedcertcount(void* lpObj);
int secureblackbox_certificatevalidator_settrustedcertcount(void* lpObj, int iTrustedCertCount);

int secureblackbox_certificatevalidator_gettrustedcertbytes(void* lpObj, int trustedcertindex, char** lpTrustedCertBytes, int* lenTrustedCertBytes);

int64 secureblackbox_certificatevalidator_gettrustedcerthandle(void* lpObj, int trustedcertindex);
int secureblackbox_certificatevalidator_settrustedcerthandle(void* lpObj, int trustedcertindex, int64 lTrustedCertHandle);

int GetTrustedCertCount();
int SetTrustedCertCount(int iTrustedCertCount);

QByteArray GetTrustedCertBytes(int iTrustedCertIndex);

qint64 GetTrustedCertHandle(int iTrustedCertIndex);
int SetTrustedCertHandle(int iTrustedCertIndex, qint64 lTrustedCertHandle);

int secureblackbox_certificatevalidator_getusedcertcount(void* lpObj);

int secureblackbox_certificatevalidator_getusedcertbytes(void* lpObj, int usedcertindex, char** lpUsedCertBytes, int* lenUsedCertBytes);

int secureblackbox_certificatevalidator_getusedcertca(void* lpObj, int usedcertindex);

int secureblackbox_certificatevalidator_getusedcertcakeyid(void* lpObj, int usedcertindex, char** lpUsedCertCAKeyID, int* lenUsedCertCAKeyID);

int secureblackbox_certificatevalidator_getusedcertcerttype(void* lpObj, int usedcertindex);

char* secureblackbox_certificatevalidator_getusedcertcrldistributionpoints(void* lpObj, int usedcertindex);

char* secureblackbox_certificatevalidator_getusedcertcurve(void* lpObj, int usedcertindex);

char* secureblackbox_certificatevalidator_getusedcertfingerprint(void* lpObj, int usedcertindex);

char* secureblackbox_certificatevalidator_getusedcertfriendlyname(void* lpObj, int usedcertindex);

int64 secureblackbox_certificatevalidator_getusedcerthandle(void* lpObj, int usedcertindex);

char* secureblackbox_certificatevalidator_getusedcerthashalgorithm(void* lpObj, int usedcertindex);

char* secureblackbox_certificatevalidator_getusedcertissuer(void* lpObj, int usedcertindex);

char* secureblackbox_certificatevalidator_getusedcertissuerrdn(void* lpObj, int usedcertindex);

char* secureblackbox_certificatevalidator_getusedcertkeyalgorithm(void* lpObj, int usedcertindex);

int secureblackbox_certificatevalidator_getusedcertkeybits(void* lpObj, int usedcertindex);

char* secureblackbox_certificatevalidator_getusedcertkeyfingerprint(void* lpObj, int usedcertindex);

int secureblackbox_certificatevalidator_getusedcertkeyusage(void* lpObj, int usedcertindex);

int secureblackbox_certificatevalidator_getusedcertkeyvalid(void* lpObj, int usedcertindex);

char* secureblackbox_certificatevalidator_getusedcertocsplocations(void* lpObj, int usedcertindex);

int secureblackbox_certificatevalidator_getusedcertocspnocheck(void* lpObj, int usedcertindex);

int secureblackbox_certificatevalidator_getusedcertorigin(void* lpObj, int usedcertindex);

char* secureblackbox_certificatevalidator_getusedcertpolicyids(void* lpObj, int usedcertindex);

int secureblackbox_certificatevalidator_getusedcertprivatekeybytes(void* lpObj, int usedcertindex, char** lpUsedCertPrivateKeyBytes, int* lenUsedCertPrivateKeyBytes);

int secureblackbox_certificatevalidator_getusedcertprivatekeyexists(void* lpObj, int usedcertindex);

int secureblackbox_certificatevalidator_getusedcertprivatekeyextractable(void* lpObj, int usedcertindex);

int secureblackbox_certificatevalidator_getusedcertpublickeybytes(void* lpObj, int usedcertindex, char** lpUsedCertPublicKeyBytes, int* lenUsedCertPublicKeyBytes);

int secureblackbox_certificatevalidator_getusedcertqualified(void* lpObj, int usedcertindex);

int secureblackbox_certificatevalidator_getusedcertqualifiedstatements(void* lpObj, int usedcertindex);

char* secureblackbox_certificatevalidator_getusedcertqualifiers(void* lpObj, int usedcertindex);

int secureblackbox_certificatevalidator_getusedcertselfsigned(void* lpObj, int usedcertindex);

int secureblackbox_certificatevalidator_getusedcertserialnumber(void* lpObj, int usedcertindex, char** lpUsedCertSerialNumber, int* lenUsedCertSerialNumber);

char* secureblackbox_certificatevalidator_getusedcertsigalgorithm(void* lpObj, int usedcertindex);

int secureblackbox_certificatevalidator_getusedcertsource(void* lpObj, int usedcertindex);

char* secureblackbox_certificatevalidator_getusedcertsubject(void* lpObj, int usedcertindex);

char* secureblackbox_certificatevalidator_getusedcertsubjectalternativename(void* lpObj, int usedcertindex);

int secureblackbox_certificatevalidator_getusedcertsubjectkeyid(void* lpObj, int usedcertindex, char** lpUsedCertSubjectKeyID, int* lenUsedCertSubjectKeyID);

char* secureblackbox_certificatevalidator_getusedcertsubjectrdn(void* lpObj, int usedcertindex);

int secureblackbox_certificatevalidator_getusedcertvalid(void* lpObj, int usedcertindex);

char* secureblackbox_certificatevalidator_getusedcertvalidfrom(void* lpObj, int usedcertindex);

char* secureblackbox_certificatevalidator_getusedcertvalidto(void* lpObj, int usedcertindex);

int GetUsedCertCount();

QByteArray GetUsedCertBytes(int iUsedCertIndex);

bool GetUsedCertCA(int iUsedCertIndex);

QByteArray GetUsedCertCAKeyID(int iUsedCertIndex);

int GetUsedCertCertType(int iUsedCertIndex);

QString GetUsedCertCRLDistributionPoints(int iUsedCertIndex);

QString GetUsedCertCurve(int iUsedCertIndex);

QString GetUsedCertFingerprint(int iUsedCertIndex);

QString GetUsedCertFriendlyName(int iUsedCertIndex);

qint64 GetUsedCertHandle(int iUsedCertIndex);

QString GetUsedCertHashAlgorithm(int iUsedCertIndex);

QString GetUsedCertIssuer(int iUsedCertIndex);

QString GetUsedCertIssuerRDN(int iUsedCertIndex);

QString GetUsedCertKeyAlgorithm(int iUsedCertIndex);

int GetUsedCertKeyBits(int iUsedCertIndex);

QString GetUsedCertKeyFingerprint(int iUsedCertIndex);

int GetUsedCertKeyUsage(int iUsedCertIndex);

bool GetUsedCertKeyValid(int iUsedCertIndex);

QString GetUsedCertOCSPLocations(int iUsedCertIndex);

bool GetUsedCertOCSPNoCheck(int iUsedCertIndex);

int GetUsedCertOrigin(int iUsedCertIndex);

QString GetUsedCertPolicyIDs(int iUsedCertIndex);

QByteArray GetUsedCertPrivateKeyBytes(int iUsedCertIndex);

bool GetUsedCertPrivateKeyExists(int iUsedCertIndex);

bool GetUsedCertPrivateKeyExtractable(int iUsedCertIndex);

QByteArray GetUsedCertPublicKeyBytes(int iUsedCertIndex);

bool GetUsedCertQualified(int iUsedCertIndex);

int GetUsedCertQualifiedStatements(int iUsedCertIndex);

QString GetUsedCertQualifiers(int iUsedCertIndex);

bool GetUsedCertSelfSigned(int iUsedCertIndex);

QByteArray GetUsedCertSerialNumber(int iUsedCertIndex);

QString GetUsedCertSigAlgorithm(int iUsedCertIndex);

int GetUsedCertSource(int iUsedCertIndex);

QString GetUsedCertSubject(int iUsedCertIndex);

QString GetUsedCertSubjectAlternativeName(int iUsedCertIndex);

QByteArray GetUsedCertSubjectKeyID(int iUsedCertIndex);

QString GetUsedCertSubjectRDN(int iUsedCertIndex);

bool GetUsedCertValid(int iUsedCertIndex);

QString GetUsedCertValidFrom(int iUsedCertIndex);

QString GetUsedCertValidTo(int iUsedCertIndex);

int secureblackbox_certificatevalidator_getusedcrlcount(void* lpObj);

int secureblackbox_certificatevalidator_getusedcrlbytes(void* lpObj, int usedcrlindex, char** lpUsedCRLBytes, int* lenUsedCRLBytes);

int64 secureblackbox_certificatevalidator_getusedcrlhandle(void* lpObj, int usedcrlindex);

char* secureblackbox_certificatevalidator_getusedcrlissuer(void* lpObj, int usedcrlindex);

char* secureblackbox_certificatevalidator_getusedcrlissuerrdn(void* lpObj, int usedcrlindex);

char* secureblackbox_certificatevalidator_getusedcrllocation(void* lpObj, int usedcrlindex);

char* secureblackbox_certificatevalidator_getusedcrlnextupdate(void* lpObj, int usedcrlindex);

int secureblackbox_certificatevalidator_getusedcrlsource(void* lpObj, int usedcrlindex);

char* secureblackbox_certificatevalidator_getusedcrlthisupdate(void* lpObj, int usedcrlindex);

int GetUsedCRLCount();

QByteArray GetUsedCRLBytes(int iUsedCRLIndex);

qint64 GetUsedCRLHandle(int iUsedCRLIndex);

QString GetUsedCRLIssuer(int iUsedCRLIndex);

QString GetUsedCRLIssuerRDN(int iUsedCRLIndex);

QString GetUsedCRLLocation(int iUsedCRLIndex);

QString GetUsedCRLNextUpdate(int iUsedCRLIndex);

int GetUsedCRLSource(int iUsedCRLIndex);

QString GetUsedCRLThisUpdate(int iUsedCRLIndex);

int secureblackbox_certificatevalidator_getusedocspcount(void* lpObj);

int secureblackbox_certificatevalidator_getusedocspbytes(void* lpObj, int usedocspindex, char** lpUsedOCSPBytes, int* lenUsedOCSPBytes);

int64 secureblackbox_certificatevalidator_getusedocsphandle(void* lpObj, int usedocspindex);

char* secureblackbox_certificatevalidator_getusedocspissuer(void* lpObj, int usedocspindex);

char* secureblackbox_certificatevalidator_getusedocspissuerrdn(void* lpObj, int usedocspindex);

char* secureblackbox_certificatevalidator_getusedocsplocation(void* lpObj, int usedocspindex);

char* secureblackbox_certificatevalidator_getusedocspproducedat(void* lpObj, int usedocspindex);

int secureblackbox_certificatevalidator_getusedocspsource(void* lpObj, int usedocspindex);

int GetUsedOCSPCount();

QByteArray GetUsedOCSPBytes(int iUsedOCSPIndex);

qint64 GetUsedOCSPHandle(int iUsedOCSPIndex);

QString GetUsedOCSPIssuer(int iUsedOCSPIndex);

QString GetUsedOCSPIssuerRDN(int iUsedOCSPIndex);

QString GetUsedOCSPLocation(int iUsedOCSPIndex);

QString GetUsedOCSPProducedAt(int iUsedOCSPIndex);

int GetUsedOCSPSource(int iUsedOCSPIndex);

int secureblackbox_certificatevalidator_getusesystemcertificates(void* lpObj);
int secureblackbox_certificatevalidator_setusesystemcertificates(void* lpObj, int bUseSystemCertificates);

bool GetUseSystemCertificates();
int SetUseSystemCertificates(bool bUseSystemCertificates);

char* secureblackbox_certificatevalidator_getvalidationlog(void* lpObj);

QString GetValidationLog();

char* secureblackbox_certificatevalidator_getvalidationmoment(void* lpObj);
int secureblackbox_certificatevalidator_setvalidationmoment(void* lpObj, const char* lpszValidationMoment);

QString GetValidationMoment();
int SetValidationMoment(QString qsValidationMoment);

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

QString Config(const QString& qsConfigurationString);

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

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

int secureblackbox_certificatevalidator_getqualifiedstatus(void* lpObj);

int GetQualifiedStatus();

char* secureblackbox_certificatevalidator_gettrustedlistproperty(void* lpObj, const char* lpszPropName, const char* lpszLanguage);

QString GetTrustedListProperty(const QString& qsPropName, const QString& qsLanguage);

int secureblackbox_certificatevalidator_refreshcache(void* lpObj);

int RefreshCache();

int secureblackbox_certificatevalidator_reset(void* lpObj);

int Reset();

int secureblackbox_certificatevalidator_resetcache(void* lpObj);

int ResetCache();

int secureblackbox_certificatevalidator_terminate(void* lpObj);

int Terminate();

int secureblackbox_certificatevalidator_validate(void* lpObj);

int Validate();

int secureblackbox_certificatevalidator_validateforsmime(void* lpObj, const char* lpszEmailAddress);

int ValidateForSMIME(const QString& qsEmailAddress);

int secureblackbox_certificatevalidator_validateforssl(void* lpObj, const char* lpszURL, const char* lpszIPAddress);

int ValidateForSSL(const QString& qsURL, const QString& qsIPAddress);

#define EID_CERTIFICATEVALIDATOR_AFTERCERTIFICATEPROCESSING 1

virtual INT SECUREBLACKBOX_CALL FireAfterCertificateProcessing(LPSTR &lpszCert, INT &iValidity, INT &iValidationDetails);

class CertificateValidatorAfterCertificateProcessingEventParams {
public:
  const QString &Cert();

  int Validity();

  int ValidationDetails();

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

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

// Or, subclass CertificateValidator and override this emitter function.
virtual int FireAfterCertificateProcessing(CertificateValidatorAfterCertificateProcessingEventParams *e) {...}

#define EID_CERTIFICATEVALIDATOR_AFTERCERTIFICATEVALIDATION 2

virtual INT SECUREBLACKBOX_CALL FireAfterCertificateValidation(LPSTR &lpszCert, LPSTR &lpszCACert, INT &iValidity, INT &iValidationDetails);

class CertificateValidatorAfterCertificateValidationEventParams {
public:
  const QString &Cert();

  const QString &CACert();

  int Validity();

  int ValidationDetails();

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

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

// Or, subclass CertificateValidator and override this emitter function.
virtual int FireAfterCertificateValidation(CertificateValidatorAfterCertificateValidationEventParams *e) {...}

#define EID_CERTIFICATEVALIDATOR_BEFORECACERTIFICATEDOWNLOAD 3

virtual INT SECUREBLACKBOX_CALL FireBeforeCACertificateDownload(LPSTR &lpszCert, LPSTR &lpszLocation);

class CertificateValidatorBeforeCACertificateDownloadEventParams {
public:
  const QString &Cert();

  const QString &Location();

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

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

// Or, subclass CertificateValidator and override this emitter function.
virtual int FireBeforeCACertificateDownload(CertificateValidatorBeforeCACertificateDownloadEventParams *e) {...}

#define EID_CERTIFICATEVALIDATOR_BEFORECERTIFICATEPROCESSING 4

virtual INT SECUREBLACKBOX_CALL FireBeforeCertificateProcessing(LPSTR &lpszCert, INT &iValidity, INT &iValidationDetails);

class CertificateValidatorBeforeCertificateProcessingEventParams {
public:
  const QString &Cert();

  int Validity();

  int ValidationDetails();

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

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

// Or, subclass CertificateValidator and override this emitter function.
virtual int FireBeforeCertificateProcessing(CertificateValidatorBeforeCertificateProcessingEventParams *e) {...}

#define EID_CERTIFICATEVALIDATOR_BEFORECERTIFICATEVALIDATION 5

virtual INT SECUREBLACKBOX_CALL FireBeforeCertificateValidation(LPSTR &lpszCert, LPSTR &lpszCACert);

class CertificateValidatorBeforeCertificateValidationEventParams {
public:
  const QString &Cert();

  const QString &CACert();

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

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

// Or, subclass CertificateValidator and override this emitter function.
virtual int FireBeforeCertificateValidation(CertificateValidatorBeforeCertificateValidationEventParams *e) {...}

#define EID_CERTIFICATEVALIDATOR_BEFORECRLDOWNLOAD 6

virtual INT SECUREBLACKBOX_CALL FireBeforeCRLDownload(LPSTR &lpszCert, LPSTR &lpszCACert, LPSTR &lpszLocation);

class CertificateValidatorBeforeCRLDownloadEventParams {
public:
  const QString &Cert();

  const QString &CACert();

  const QString &Location();

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

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

// Or, subclass CertificateValidator and override this emitter function.
virtual int FireBeforeCRLDownload(CertificateValidatorBeforeCRLDownloadEventParams *e) {...}

#define EID_CERTIFICATEVALIDATOR_BEFOREOCSPDOWNLOAD 7

virtual INT SECUREBLACKBOX_CALL FireBeforeOCSPDownload(LPSTR &lpszCert, LPSTR &lpszCACert, LPSTR &lpszLocation);

class CertificateValidatorBeforeOCSPDownloadEventParams {
public:
  const QString &Cert();

  const QString &CACert();

  const QString &Location();

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

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

// Or, subclass CertificateValidator and override this emitter function.
virtual int FireBeforeOCSPDownload(CertificateValidatorBeforeOCSPDownloadEventParams *e) {...}

#define EID_CERTIFICATEVALIDATOR_CACERTIFICATEDOWNLOADED 8

virtual INT SECUREBLACKBOX_CALL FireCACertificateDownloaded(LPSTR &lpszCert, LPSTR &lpszLocation);

class CertificateValidatorCACertificateDownloadedEventParams {
public:
  const QString &Cert();

  const QString &Location();

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

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

// Or, subclass CertificateValidator and override this emitter function.
virtual int FireCACertificateDownloaded(CertificateValidatorCACertificateDownloadedEventParams *e) {...}

#define EID_CERTIFICATEVALIDATOR_CACERTIFICATENEEDED 9

virtual INT SECUREBLACKBOX_CALL FireCACertificateNeeded(LPSTR &lpszCert);

class CertificateValidatorCACertificateNeededEventParams {
public:
  const QString &Cert();

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

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

// Or, subclass CertificateValidator and override this emitter function.
virtual int FireCACertificateNeeded(CertificateValidatorCACertificateNeededEventParams *e) {...}

#define EID_CERTIFICATEVALIDATOR_CRLDOWNLOADED 10

virtual INT SECUREBLACKBOX_CALL FireCRLDownloaded(LPSTR &lpszCert, LPSTR &lpszCACert, LPSTR &lpszLocation);

class CertificateValidatorCRLDownloadedEventParams {
public:
  const QString &Cert();

  const QString &CACert();

  const QString &Location();

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

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

// Or, subclass CertificateValidator and override this emitter function.
virtual int FireCRLDownloaded(CertificateValidatorCRLDownloadedEventParams *e) {...}

#define EID_CERTIFICATEVALIDATOR_CRLNEEDED 11

virtual INT SECUREBLACKBOX_CALL FireCRLNeeded(LPSTR &lpszCert, LPSTR &lpszCACert);

class CertificateValidatorCRLNeededEventParams {
public:
  const QString &Cert();

  const QString &CACert();

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

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

// Or, subclass CertificateValidator and override this emitter function.
virtual int FireCRLNeeded(CertificateValidatorCRLNeededEventParams *e) {...}

#define EID_CERTIFICATEVALIDATOR_ERROR 12

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

class CertificateValidatorErrorEventParams {
public:
  int ErrorCode();

  const QString &Description();

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

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

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

#define EID_CERTIFICATEVALIDATOR_NOTIFICATION 13

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

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

  const QString &EventParam();

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

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

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

#define EID_CERTIFICATEVALIDATOR_OCSPDOWNLOADED 14

virtual INT SECUREBLACKBOX_CALL FireOCSPDownloaded(LPSTR &lpszCert, LPSTR &lpszCACert, LPSTR &lpszLocation);

class CertificateValidatorOCSPDownloadedEventParams {
public:
  const QString &Cert();

  const QString &CACert();

  const QString &Location();

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

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

// Or, subclass CertificateValidator and override this emitter function.
virtual int FireOCSPDownloaded(CertificateValidatorOCSPDownloadedEventParams *e) {...}

#define EID_CERTIFICATEVALIDATOR_TLSCERTNEEDED 15

virtual INT SECUREBLACKBOX_CALL FireTLSCertNeeded(LPSTR &lpszHost, LPSTR &lpszCANames);

class CertificateValidatorTLSCertNeededEventParams {
public:
  const QString &Host();

  const QString &CANames();

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

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

// Or, subclass CertificateValidator and override this emitter function.
virtual int FireTLSCertNeeded(CertificateValidatorTLSCertNeededEventParams *e) {...}

#define EID_CERTIFICATEVALIDATOR_TLSCERTVALIDATE 16

virtual INT SECUREBLACKBOX_CALL FireTLSCertValidate(LPSTR &lpszServerHost, LPSTR &lpszServerIP, BOOL &bAccept);

class CertificateValidatorTLSCertValidateEventParams {
public:
  const QString &ServerHost();

  const QString &ServerIP();

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

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

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

// Or, subclass CertificateValidator and override this emitter function.
virtual int FireTLSCertValidate(CertificateValidatorTLSCertValidateEventParams *e) {...}

#define EID_CERTIFICATEVALIDATOR_TLSESTABLISHED 17

virtual INT SECUREBLACKBOX_CALL FireTLSEstablished(LPSTR &lpszHost, LPSTR &lpszVersion, LPSTR &lpszCiphersuite, LPSTR &lpConnectionId, INT &lenConnectionId, BOOL &bAbort);

class CertificateValidatorTLSEstablishedEventParams {
public:
  const QString &Host();

  const QString &Version();

  const QString &Ciphersuite();

  const QByteArray &ConnectionId();

  bool Abort();
  void SetAbort(bool bAbort);

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

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

// Or, subclass CertificateValidator and override this emitter function.
virtual int FireTLSEstablished(CertificateValidatorTLSEstablishedEventParams *e) {...}

#define EID_CERTIFICATEVALIDATOR_TLSHANDSHAKE 18

virtual INT SECUREBLACKBOX_CALL FireTLSHandshake(LPSTR &lpszHost, BOOL &bAbort);

class CertificateValidatorTLSHandshakeEventParams {
public:
  const QString &Host();

  bool Abort();
  void SetAbort(bool bAbort);

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

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

// Or, subclass CertificateValidator and override this emitter function.
virtual int FireTLSHandshake(CertificateValidatorTLSHandshakeEventParams *e) {...}

#define EID_CERTIFICATEVALIDATOR_TLSSHUTDOWN 19

virtual INT SECUREBLACKBOX_CALL FireTLSShutdown(LPSTR &lpszHost);

class CertificateValidatorTLSShutdownEventParams {
public:
  const QString &Host();

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

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

// Or, subclass CertificateValidator and override this emitter function.
virtual int FireTLSShutdown(CertificateValidatorTLSShutdownEventParams *e) {...}