int secureblackbox_authenticodeverifier_getactualchecksum(void* lpObj);

int GetActualChecksum();

int secureblackbox_authenticodeverifier_getallsignaturesvalid(void* lpObj);

bool GetAllSignaturesValid();

int secureblackbox_authenticodeverifier_getblockedcertcount(void* lpObj);
int secureblackbox_authenticodeverifier_setblockedcertcount(void* lpObj, int iBlockedCertCount);

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

int64 secureblackbox_authenticodeverifier_getblockedcerthandle(void* lpObj, int blockedcertindex);
int secureblackbox_authenticodeverifier_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_authenticodeverifier_getcertcount(void* lpObj);

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

int secureblackbox_authenticodeverifier_getcertca(void* lpObj, int certindex);

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

int secureblackbox_authenticodeverifier_getcertcerttype(void* lpObj, int certindex);

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

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

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

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

int64 secureblackbox_authenticodeverifier_getcerthandle(void* lpObj, int certindex);

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

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

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

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

int secureblackbox_authenticodeverifier_getcertkeybits(void* lpObj, int certindex);

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

int secureblackbox_authenticodeverifier_getcertkeyusage(void* lpObj, int certindex);

int secureblackbox_authenticodeverifier_getcertkeyvalid(void* lpObj, int certindex);

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

int secureblackbox_authenticodeverifier_getcertocspnocheck(void* lpObj, int certindex);

int secureblackbox_authenticodeverifier_getcertorigin(void* lpObj, int certindex);

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

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

int secureblackbox_authenticodeverifier_getcertprivatekeyexists(void* lpObj, int certindex);

int secureblackbox_authenticodeverifier_getcertprivatekeyextractable(void* lpObj, int certindex);

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

int secureblackbox_authenticodeverifier_getcertqualified(void* lpObj, int certindex);

int secureblackbox_authenticodeverifier_getcertqualifiedstatements(void* lpObj, int certindex);

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

int secureblackbox_authenticodeverifier_getcertselfsigned(void* lpObj, int certindex);

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

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

int secureblackbox_authenticodeverifier_getcertsource(void* lpObj, int certindex);

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

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

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

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

int secureblackbox_authenticodeverifier_getcertvalid(void* lpObj, int certindex);

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

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

int GetCertCount();

QByteArray GetCertBytes(int iCertIndex);

bool GetCertCA(int iCertIndex);

QByteArray GetCertCAKeyID(int iCertIndex);

int GetCertCertType(int iCertIndex);

QString GetCertCRLDistributionPoints(int iCertIndex);

QString GetCertCurve(int iCertIndex);

QString GetCertFingerprint(int iCertIndex);

QString GetCertFriendlyName(int iCertIndex);

qint64 GetCertHandle(int iCertIndex);

QString GetCertHashAlgorithm(int iCertIndex);

QString GetCertIssuer(int iCertIndex);

QString GetCertIssuerRDN(int iCertIndex);

QString GetCertKeyAlgorithm(int iCertIndex);

int GetCertKeyBits(int iCertIndex);

QString GetCertKeyFingerprint(int iCertIndex);

int GetCertKeyUsage(int iCertIndex);

bool GetCertKeyValid(int iCertIndex);

QString GetCertOCSPLocations(int iCertIndex);

bool GetCertOCSPNoCheck(int iCertIndex);

int GetCertOrigin(int iCertIndex);

QString GetCertPolicyIDs(int iCertIndex);

QByteArray GetCertPrivateKeyBytes(int iCertIndex);

bool GetCertPrivateKeyExists(int iCertIndex);

bool GetCertPrivateKeyExtractable(int iCertIndex);

QByteArray GetCertPublicKeyBytes(int iCertIndex);

bool GetCertQualified(int iCertIndex);

int GetCertQualifiedStatements(int iCertIndex);

QString GetCertQualifiers(int iCertIndex);

bool GetCertSelfSigned(int iCertIndex);

QByteArray GetCertSerialNumber(int iCertIndex);

QString GetCertSigAlgorithm(int iCertIndex);

int GetCertSource(int iCertIndex);

QString GetCertSubject(int iCertIndex);

QString GetCertSubjectAlternativeName(int iCertIndex);

QByteArray GetCertSubjectKeyID(int iCertIndex);

QString GetCertSubjectRDN(int iCertIndex);

bool GetCertValid(int iCertIndex);

QString GetCertValidFrom(int iCertIndex);

QString GetCertValidTo(int iCertIndex);

int secureblackbox_authenticodeverifier_getcrlcount(void* lpObj);

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

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

int secureblackbox_authenticodeverifier_getcrlentrycount(void* lpObj, int crlindex);

int64 secureblackbox_authenticodeverifier_getcrlhandle(void* lpObj, int crlindex);

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

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

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

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

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

int secureblackbox_authenticodeverifier_getcrlsource(void* lpObj, int crlindex);

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

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

int GetCRLCount();

QByteArray GetCRLBytes(int iCRLIndex);

QByteArray GetCRLCAKeyID(int iCRLIndex);

int GetCRLEntryCount(int iCRLIndex);

qint64 GetCRLHandle(int iCRLIndex);

QString GetCRLIssuer(int iCRLIndex);

QString GetCRLIssuerRDN(int iCRLIndex);

QString GetCRLLocation(int iCRLIndex);

QString GetCRLNextUpdate(int iCRLIndex);

QString GetCRLSigAlgorithm(int iCRLIndex);

int GetCRLSource(int iCRLIndex);

QByteArray GetCRLTBS(int iCRLIndex);

QString GetCRLThisUpdate(int iCRLIndex);

int secureblackbox_authenticodeverifier_getfipsmode(void* lpObj);
int secureblackbox_authenticodeverifier_setfipsmode(void* lpObj, int bFIPSMode);

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

int secureblackbox_authenticodeverifier_getignorechainvalidationerrors(void* lpObj);
int secureblackbox_authenticodeverifier_setignorechainvalidationerrors(void* lpObj, int bIgnoreChainValidationErrors);

bool GetIgnoreChainValidationErrors();
int SetIgnoreChainValidationErrors(bool bIgnoreChainValidationErrors);

int secureblackbox_authenticodeverifier_getinputbytes(void* lpObj, char** lpInputBytes, int* lenInputBytes);
int secureblackbox_authenticodeverifier_setinputbytes(void* lpObj, const char* lpInputBytes, int lenInputBytes);

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

char* secureblackbox_authenticodeverifier_getinputfile(void* lpObj);
int secureblackbox_authenticodeverifier_setinputfile(void* lpObj, const char* lpszInputFile);

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

int secureblackbox_authenticodeverifier_getknowncertcount(void* lpObj);
int secureblackbox_authenticodeverifier_setknowncertcount(void* lpObj, int iKnownCertCount);

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

int64 secureblackbox_authenticodeverifier_getknowncerthandle(void* lpObj, int knowncertindex);
int secureblackbox_authenticodeverifier_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_authenticodeverifier_getknowncrlcount(void* lpObj);
int secureblackbox_authenticodeverifier_setknowncrlcount(void* lpObj, int iKnownCRLCount);

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

int64 secureblackbox_authenticodeverifier_getknowncrlhandle(void* lpObj, int knowncrlindex);
int secureblackbox_authenticodeverifier_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_authenticodeverifier_getknownocspcount(void* lpObj);
int secureblackbox_authenticodeverifier_setknownocspcount(void* lpObj, int iKnownOCSPCount);

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

int64 secureblackbox_authenticodeverifier_getknownocsphandle(void* lpObj, int knownocspindex);
int secureblackbox_authenticodeverifier_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_authenticodeverifier_getocspcount(void* lpObj);

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

int secureblackbox_authenticodeverifier_getocspentrycount(void* lpObj, int ocspindex);

int64 secureblackbox_authenticodeverifier_getocsphandle(void* lpObj, int ocspindex);

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

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

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

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

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

int secureblackbox_authenticodeverifier_getocspsource(void* lpObj, int ocspindex);

int GetOCSPCount();

QByteArray GetOCSPBytes(int iOCSPIndex);

int GetOCSPEntryCount(int iOCSPIndex);

qint64 GetOCSPHandle(int iOCSPIndex);

QString GetOCSPIssuer(int iOCSPIndex);

QString GetOCSPIssuerRDN(int iOCSPIndex);

QString GetOCSPLocation(int iOCSPIndex);

QString GetOCSPProducedAt(int iOCSPIndex);

QString GetOCSPSigAlgorithm(int iOCSPIndex);

int GetOCSPSource(int iOCSPIndex);

int secureblackbox_authenticodeverifier_getofflinemode(void* lpObj);
int secureblackbox_authenticodeverifier_setofflinemode(void* lpObj, int bOfflineMode);

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

char* secureblackbox_authenticodeverifier_getprofile(void* lpObj);
int secureblackbox_authenticodeverifier_setprofile(void* lpObj, const char* lpszProfile);

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

char* secureblackbox_authenticodeverifier_getproxyaddress(void* lpObj);
int secureblackbox_authenticodeverifier_setproxyaddress(void* lpObj, const char* lpszProxyAddress);

int secureblackbox_authenticodeverifier_getproxyauthentication(void* lpObj);
int secureblackbox_authenticodeverifier_setproxyauthentication(void* lpObj, int iProxyAuthentication);

char* secureblackbox_authenticodeverifier_getproxypassword(void* lpObj);
int secureblackbox_authenticodeverifier_setproxypassword(void* lpObj, const char* lpszProxyPassword);

int secureblackbox_authenticodeverifier_getproxyport(void* lpObj);
int secureblackbox_authenticodeverifier_setproxyport(void* lpObj, int iProxyPort);

int secureblackbox_authenticodeverifier_getproxyproxytype(void* lpObj);
int secureblackbox_authenticodeverifier_setproxyproxytype(void* lpObj, int iProxyProxyType);

char* secureblackbox_authenticodeverifier_getproxyrequestheaders(void* lpObj);
int secureblackbox_authenticodeverifier_setproxyrequestheaders(void* lpObj, const char* lpszProxyRequestHeaders);

char* secureblackbox_authenticodeverifier_getproxyresponsebody(void* lpObj);
int secureblackbox_authenticodeverifier_setproxyresponsebody(void* lpObj, const char* lpszProxyResponseBody);

char* secureblackbox_authenticodeverifier_getproxyresponseheaders(void* lpObj);
int secureblackbox_authenticodeverifier_setproxyresponseheaders(void* lpObj, const char* lpszProxyResponseHeaders);

int secureblackbox_authenticodeverifier_getproxyuseipv6(void* lpObj);
int secureblackbox_authenticodeverifier_setproxyuseipv6(void* lpObj, int bProxyUseIPv6);

char* secureblackbox_authenticodeverifier_getproxyusername(void* lpObj);
int secureblackbox_authenticodeverifier_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);

int secureblackbox_authenticodeverifier_getrevocationcheck(void* lpObj);
int secureblackbox_authenticodeverifier_setrevocationcheck(void* lpObj, int iRevocationCheck);

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

int secureblackbox_authenticodeverifier_getsigchainvalidationdetails(void* lpObj);

int secureblackbox_authenticodeverifier_getsigchainvalidationresult(void* lpObj);

char* secureblackbox_authenticodeverifier_getsigclaimedsigningtime(void* lpObj);

char* secureblackbox_authenticodeverifier_getsigdescription(void* lpObj);

int secureblackbox_authenticodeverifier_getsigerrorcode(void* lpObj);

char* secureblackbox_authenticodeverifier_getsigerrormessage(void* lpObj);

char* secureblackbox_authenticodeverifier_getsigfilehashalgorithm(void* lpObj);

int64 secureblackbox_authenticodeverifier_getsighandle(void* lpObj);

char* secureblackbox_authenticodeverifier_getsighashalgorithm(void* lpObj);

int secureblackbox_authenticodeverifier_getsigsignaturebytes(void* lpObj, char** lpSigSignatureBytes, int* lenSigSignatureBytes);

int secureblackbox_authenticodeverifier_getsigsignaturevalidationresult(void* lpObj);

int secureblackbox_authenticodeverifier_getsigstatementtype(void* lpObj);

char* secureblackbox_authenticodeverifier_getsigurl(void* lpObj);

char* secureblackbox_authenticodeverifier_getsigvalidatedsigningtime(void* lpObj);

char* secureblackbox_authenticodeverifier_getsigvalidationlog(void* lpObj);

int GetSigChainValidationDetails();

int GetSigChainValidationResult();

QString GetSigClaimedSigningTime();

QString GetSigDescription();

int GetSigErrorCode();

QString GetSigErrorMessage();

QString GetSigFileHashAlgorithm();

qint64 GetSigHandle();

QString GetSigHashAlgorithm();

QByteArray GetSigSignatureBytes();

int GetSigSignatureValidationResult();

int GetSigStatementType();

QString GetSigURL();

QString GetSigValidatedSigningTime();

QString GetSigValidationLog();

int secureblackbox_authenticodeverifier_getsigned(void* lpObj);

bool GetSigned();

int secureblackbox_authenticodeverifier_getsignedattributecount(void* lpObj);

char* secureblackbox_authenticodeverifier_getsignedattributeoid(void* lpObj, int signedattributeindex);

int secureblackbox_authenticodeverifier_getsignedattributevalue(void* lpObj, int signedattributeindex, char** lpSignedAttributeValue, int* lenSignedAttributeValue);

int GetSignedAttributeCount();

QString GetSignedAttributeOID(int iSignedAttributeIndex);

QByteArray GetSignedAttributeValue(int iSignedAttributeIndex);

int secureblackbox_authenticodeverifier_getsigningcertbytes(void* lpObj, char** lpSigningCertBytes, int* lenSigningCertBytes);

int secureblackbox_authenticodeverifier_getsigningcertca(void* lpObj);

int secureblackbox_authenticodeverifier_getsigningcertcakeyid(void* lpObj, char** lpSigningCertCAKeyID, int* lenSigningCertCAKeyID);

char* secureblackbox_authenticodeverifier_getsigningcertcrldistributionpoints(void* lpObj);

char* secureblackbox_authenticodeverifier_getsigningcertcurve(void* lpObj);

char* secureblackbox_authenticodeverifier_getsigningcertfingerprint(void* lpObj);

char* secureblackbox_authenticodeverifier_getsigningcertfriendlyname(void* lpObj);

int64 secureblackbox_authenticodeverifier_getsigningcerthandle(void* lpObj);

char* secureblackbox_authenticodeverifier_getsigningcerthashalgorithm(void* lpObj);

char* secureblackbox_authenticodeverifier_getsigningcertissuer(void* lpObj);

char* secureblackbox_authenticodeverifier_getsigningcertissuerrdn(void* lpObj);

char* secureblackbox_authenticodeverifier_getsigningcertkeyalgorithm(void* lpObj);

int secureblackbox_authenticodeverifier_getsigningcertkeybits(void* lpObj);

char* secureblackbox_authenticodeverifier_getsigningcertkeyfingerprint(void* lpObj);

int secureblackbox_authenticodeverifier_getsigningcertkeyusage(void* lpObj);

int secureblackbox_authenticodeverifier_getsigningcertkeyvalid(void* lpObj);

char* secureblackbox_authenticodeverifier_getsigningcertocsplocations(void* lpObj);

char* secureblackbox_authenticodeverifier_getsigningcertpolicyids(void* lpObj);

int secureblackbox_authenticodeverifier_getsigningcertpublickeybytes(void* lpObj, char** lpSigningCertPublicKeyBytes, int* lenSigningCertPublicKeyBytes);

int secureblackbox_authenticodeverifier_getsigningcertselfsigned(void* lpObj);

int secureblackbox_authenticodeverifier_getsigningcertserialnumber(void* lpObj, char** lpSigningCertSerialNumber, int* lenSigningCertSerialNumber);

char* secureblackbox_authenticodeverifier_getsigningcertsigalgorithm(void* lpObj);

char* secureblackbox_authenticodeverifier_getsigningcertsubject(void* lpObj);

int secureblackbox_authenticodeverifier_getsigningcertsubjectkeyid(void* lpObj, char** lpSigningCertSubjectKeyID, int* lenSigningCertSubjectKeyID);

char* secureblackbox_authenticodeverifier_getsigningcertsubjectrdn(void* lpObj);

char* secureblackbox_authenticodeverifier_getsigningcertvalidfrom(void* lpObj);

char* secureblackbox_authenticodeverifier_getsigningcertvalidto(void* lpObj);

QByteArray GetSigningCertBytes();

bool GetSigningCertCA();

QByteArray GetSigningCertCAKeyID();

QString GetSigningCertCRLDistributionPoints();

QString GetSigningCertCurve();

QString GetSigningCertFingerprint();

QString GetSigningCertFriendlyName();

qint64 GetSigningCertHandle();

QString GetSigningCertHashAlgorithm();

QString GetSigningCertIssuer();

QString GetSigningCertIssuerRDN();

QString GetSigningCertKeyAlgorithm();

int GetSigningCertKeyBits();

QString GetSigningCertKeyFingerprint();

int GetSigningCertKeyUsage();

bool GetSigningCertKeyValid();

QString GetSigningCertOCSPLocations();

QString GetSigningCertPolicyIDs();

QByteArray GetSigningCertPublicKeyBytes();

bool GetSigningCertSelfSigned();

QByteArray GetSigningCertSerialNumber();

QString GetSigningCertSigAlgorithm();

QString GetSigningCertSubject();

QByteArray GetSigningCertSubjectKeyID();

QString GetSigningCertSubjectRDN();

QString GetSigningCertValidFrom();

QString GetSigningCertValidTo();

int secureblackbox_authenticodeverifier_getsocketdnsmode(void* lpObj);
int secureblackbox_authenticodeverifier_setsocketdnsmode(void* lpObj, int iSocketDNSMode);

int secureblackbox_authenticodeverifier_getsocketdnsport(void* lpObj);
int secureblackbox_authenticodeverifier_setsocketdnsport(void* lpObj, int iSocketDNSPort);

int secureblackbox_authenticodeverifier_getsocketdnsquerytimeout(void* lpObj);
int secureblackbox_authenticodeverifier_setsocketdnsquerytimeout(void* lpObj, int iSocketDNSQueryTimeout);

char* secureblackbox_authenticodeverifier_getsocketdnsservers(void* lpObj);
int secureblackbox_authenticodeverifier_setsocketdnsservers(void* lpObj, const char* lpszSocketDNSServers);

int secureblackbox_authenticodeverifier_getsocketdnstotaltimeout(void* lpObj);
int secureblackbox_authenticodeverifier_setsocketdnstotaltimeout(void* lpObj, int iSocketDNSTotalTimeout);

int secureblackbox_authenticodeverifier_getsocketincomingspeedlimit(void* lpObj);
int secureblackbox_authenticodeverifier_setsocketincomingspeedlimit(void* lpObj, int iSocketIncomingSpeedLimit);

char* secureblackbox_authenticodeverifier_getsocketlocaladdress(void* lpObj);
int secureblackbox_authenticodeverifier_setsocketlocaladdress(void* lpObj, const char* lpszSocketLocalAddress);

int secureblackbox_authenticodeverifier_getsocketlocalport(void* lpObj);
int secureblackbox_authenticodeverifier_setsocketlocalport(void* lpObj, int iSocketLocalPort);

int secureblackbox_authenticodeverifier_getsocketoutgoingspeedlimit(void* lpObj);
int secureblackbox_authenticodeverifier_setsocketoutgoingspeedlimit(void* lpObj, int iSocketOutgoingSpeedLimit);

int secureblackbox_authenticodeverifier_getsockettimeout(void* lpObj);
int secureblackbox_authenticodeverifier_setsockettimeout(void* lpObj, int iSocketTimeout);

int secureblackbox_authenticodeverifier_getsocketuseipv6(void* lpObj);
int secureblackbox_authenticodeverifier_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_authenticodeverifier_getspecifiedchecksum(void* lpObj);

int GetSpecifiedChecksum();

int64 secureblackbox_authenticodeverifier_gettimestampaccuracy(void* lpObj);

int secureblackbox_authenticodeverifier_gettimestampbytes(void* lpObj, char** lpTimestampBytes, int* lenTimestampBytes);

int secureblackbox_authenticodeverifier_gettimestampcertificateindex(void* lpObj);

int secureblackbox_authenticodeverifier_gettimestampchainvalidationdetails(void* lpObj);

int secureblackbox_authenticodeverifier_gettimestampchainvalidationresult(void* lpObj);

int secureblackbox_authenticodeverifier_gettimestampcontainslongterminfo(void* lpObj);

char* secureblackbox_authenticodeverifier_gettimestampentitylabel(void* lpObj);

char* secureblackbox_authenticodeverifier_gettimestamphashalgorithm(void* lpObj);

char* secureblackbox_authenticodeverifier_gettimestampparententity(void* lpObj);

int secureblackbox_authenticodeverifier_gettimestampserialnumber(void* lpObj, char** lpTimestampSerialNumber, int* lenTimestampSerialNumber);

char* secureblackbox_authenticodeverifier_gettimestamptime(void* lpObj);

int secureblackbox_authenticodeverifier_gettimestamptimestamptype(void* lpObj);

char* secureblackbox_authenticodeverifier_gettimestamptsaname(void* lpObj);

char* secureblackbox_authenticodeverifier_gettimestampvalidationlog(void* lpObj);

int secureblackbox_authenticodeverifier_gettimestampvalidationresult(void* lpObj);

qint64 GetTimestampAccuracy();

QByteArray GetTimestampBytes();

int GetTimestampCertificateIndex();

int GetTimestampChainValidationDetails();

int GetTimestampChainValidationResult();

bool GetTimestampContainsLongTermInfo();

QString GetTimestampEntityLabel();

QString GetTimestampHashAlgorithm();

QString GetTimestampParentEntity();

QByteArray GetTimestampSerialNumber();

QString GetTimestampTime();

int GetTimestampTimestampType();

QString GetTimestampTSAName();

QString GetTimestampValidationLog();

int GetTimestampValidationResult();

int secureblackbox_authenticodeverifier_gettimestamped(void* lpObj);

bool GetTimestamped();

int secureblackbox_authenticodeverifier_gettlsclientcertcount(void* lpObj);
int secureblackbox_authenticodeverifier_settlsclientcertcount(void* lpObj, int iTLSClientCertCount);

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

int64 secureblackbox_authenticodeverifier_gettlsclientcerthandle(void* lpObj, int tlsclientcertindex);
int secureblackbox_authenticodeverifier_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_authenticodeverifier_gettlsservercertcount(void* lpObj);

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

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

int64 secureblackbox_authenticodeverifier_gettlsservercerthandle(void* lpObj, int tlsservercertindex);

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

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

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

int secureblackbox_authenticodeverifier_gettlsservercertkeybits(void* lpObj, int tlsservercertindex);

int secureblackbox_authenticodeverifier_gettlsservercertkeyusage(void* lpObj, int tlsservercertindex);

int secureblackbox_authenticodeverifier_gettlsservercertselfsigned(void* lpObj, int tlsservercertindex);

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

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

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

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

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

char* secureblackbox_authenticodeverifier_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_authenticodeverifier_gettlsautovalidatecertificates(void* lpObj);
int secureblackbox_authenticodeverifier_settlsautovalidatecertificates(void* lpObj, int bTLSAutoValidateCertificates);

int secureblackbox_authenticodeverifier_gettlsbaseconfiguration(void* lpObj);
int secureblackbox_authenticodeverifier_settlsbaseconfiguration(void* lpObj, int iTLSBaseConfiguration);

char* secureblackbox_authenticodeverifier_gettlsciphersuites(void* lpObj);
int secureblackbox_authenticodeverifier_settlsciphersuites(void* lpObj, const char* lpszTLSCiphersuites);

int secureblackbox_authenticodeverifier_gettlsclientauth(void* lpObj);
int secureblackbox_authenticodeverifier_settlsclientauth(void* lpObj, int iTLSClientAuth);

char* secureblackbox_authenticodeverifier_gettlseccurves(void* lpObj);
int secureblackbox_authenticodeverifier_settlseccurves(void* lpObj, const char* lpszTLSECCurves);

char* secureblackbox_authenticodeverifier_gettlsextensions(void* lpObj);
int secureblackbox_authenticodeverifier_settlsextensions(void* lpObj, const char* lpszTLSExtensions);

int secureblackbox_authenticodeverifier_gettlsforceresumeifdestinationchanges(void* lpObj);
int secureblackbox_authenticodeverifier_settlsforceresumeifdestinationchanges(void* lpObj, int bTLSForceResumeIfDestinationChanges);

char* secureblackbox_authenticodeverifier_gettlspresharedidentity(void* lpObj);
int secureblackbox_authenticodeverifier_settlspresharedidentity(void* lpObj, const char* lpszTLSPreSharedIdentity);

char* secureblackbox_authenticodeverifier_gettlspresharedkey(void* lpObj);
int secureblackbox_authenticodeverifier_settlspresharedkey(void* lpObj, const char* lpszTLSPreSharedKey);

char* secureblackbox_authenticodeverifier_gettlspresharedkeyciphersuite(void* lpObj);
int secureblackbox_authenticodeverifier_settlspresharedkeyciphersuite(void* lpObj, const char* lpszTLSPreSharedKeyCiphersuite);

int secureblackbox_authenticodeverifier_gettlsrenegotiationattackpreventionmode(void* lpObj);
int secureblackbox_authenticodeverifier_settlsrenegotiationattackpreventionmode(void* lpObj, int iTLSRenegotiationAttackPreventionMode);

int secureblackbox_authenticodeverifier_gettlsrevocationcheck(void* lpObj);
int secureblackbox_authenticodeverifier_settlsrevocationcheck(void* lpObj, int iTLSRevocationCheck);

int secureblackbox_authenticodeverifier_gettlsssloptions(void* lpObj);
int secureblackbox_authenticodeverifier_settlsssloptions(void* lpObj, int iTLSSSLOptions);

int secureblackbox_authenticodeverifier_gettlstlsmode(void* lpObj);
int secureblackbox_authenticodeverifier_settlstlsmode(void* lpObj, int iTLSTLSMode);

int secureblackbox_authenticodeverifier_gettlsuseextendedmastersecret(void* lpObj);
int secureblackbox_authenticodeverifier_settlsuseextendedmastersecret(void* lpObj, int bTLSUseExtendedMasterSecret);

int secureblackbox_authenticodeverifier_gettlsusesessionresumption(void* lpObj);
int secureblackbox_authenticodeverifier_settlsusesessionresumption(void* lpObj, int bTLSUseSessionResumption);

int secureblackbox_authenticodeverifier_gettlsversions(void* lpObj);
int secureblackbox_authenticodeverifier_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_authenticodeverifier_gettrustedcertcount(void* lpObj);
int secureblackbox_authenticodeverifier_settrustedcertcount(void* lpObj, int iTrustedCertCount);

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

int64 secureblackbox_authenticodeverifier_gettrustedcerthandle(void* lpObj, int trustedcertindex);
int secureblackbox_authenticodeverifier_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_authenticodeverifier_gettsacertbytes(void* lpObj, char** lpTSACertBytes, int* lenTSACertBytes);

int secureblackbox_authenticodeverifier_gettsacertca(void* lpObj);

int secureblackbox_authenticodeverifier_gettsacertcakeyid(void* lpObj, char** lpTSACertCAKeyID, int* lenTSACertCAKeyID);

char* secureblackbox_authenticodeverifier_gettsacertcrldistributionpoints(void* lpObj);

char* secureblackbox_authenticodeverifier_gettsacertcurve(void* lpObj);

char* secureblackbox_authenticodeverifier_gettsacertfingerprint(void* lpObj);

char* secureblackbox_authenticodeverifier_gettsacertfriendlyname(void* lpObj);

int64 secureblackbox_authenticodeverifier_gettsacerthandle(void* lpObj);

char* secureblackbox_authenticodeverifier_gettsacerthashalgorithm(void* lpObj);

char* secureblackbox_authenticodeverifier_gettsacertissuer(void* lpObj);

char* secureblackbox_authenticodeverifier_gettsacertissuerrdn(void* lpObj);

char* secureblackbox_authenticodeverifier_gettsacertkeyalgorithm(void* lpObj);

int secureblackbox_authenticodeverifier_gettsacertkeybits(void* lpObj);

char* secureblackbox_authenticodeverifier_gettsacertkeyfingerprint(void* lpObj);

int secureblackbox_authenticodeverifier_gettsacertkeyusage(void* lpObj);

int secureblackbox_authenticodeverifier_gettsacertkeyvalid(void* lpObj);

char* secureblackbox_authenticodeverifier_gettsacertocsplocations(void* lpObj);

char* secureblackbox_authenticodeverifier_gettsacertpolicyids(void* lpObj);

int secureblackbox_authenticodeverifier_gettsacertpublickeybytes(void* lpObj, char** lpTSACertPublicKeyBytes, int* lenTSACertPublicKeyBytes);

int secureblackbox_authenticodeverifier_gettsacertselfsigned(void* lpObj);

int secureblackbox_authenticodeverifier_gettsacertserialnumber(void* lpObj, char** lpTSACertSerialNumber, int* lenTSACertSerialNumber);

char* secureblackbox_authenticodeverifier_gettsacertsigalgorithm(void* lpObj);

char* secureblackbox_authenticodeverifier_gettsacertsubject(void* lpObj);

int secureblackbox_authenticodeverifier_gettsacertsubjectkeyid(void* lpObj, char** lpTSACertSubjectKeyID, int* lenTSACertSubjectKeyID);

char* secureblackbox_authenticodeverifier_gettsacertsubjectrdn(void* lpObj);

char* secureblackbox_authenticodeverifier_gettsacertvalidfrom(void* lpObj);

char* secureblackbox_authenticodeverifier_gettsacertvalidto(void* lpObj);

QByteArray GetTSACertBytes();

bool GetTSACertCA();

QByteArray GetTSACertCAKeyID();

QString GetTSACertCRLDistributionPoints();

QString GetTSACertCurve();

QString GetTSACertFingerprint();

QString GetTSACertFriendlyName();

qint64 GetTSACertHandle();

QString GetTSACertHashAlgorithm();

QString GetTSACertIssuer();

QString GetTSACertIssuerRDN();

QString GetTSACertKeyAlgorithm();

int GetTSACertKeyBits();

QString GetTSACertKeyFingerprint();

int GetTSACertKeyUsage();

bool GetTSACertKeyValid();

QString GetTSACertOCSPLocations();

QString GetTSACertPolicyIDs();

QByteArray GetTSACertPublicKeyBytes();

bool GetTSACertSelfSigned();

QByteArray GetTSACertSerialNumber();

QString GetTSACertSigAlgorithm();

QString GetTSACertSubject();

QByteArray GetTSACertSubjectKeyID();

QString GetTSACertSubjectRDN();

QString GetTSACertValidFrom();

QString GetTSACertValidTo();

int secureblackbox_authenticodeverifier_getunsignedattributecount(void* lpObj);

char* secureblackbox_authenticodeverifier_getunsignedattributeoid(void* lpObj, int unsignedattributeindex);

int secureblackbox_authenticodeverifier_getunsignedattributevalue(void* lpObj, int unsignedattributeindex, char** lpUnsignedAttributeValue, int* lenUnsignedAttributeValue);

int GetUnsignedAttributeCount();

QString GetUnsignedAttributeOID(int iUnsignedAttributeIndex);

QByteArray GetUnsignedAttributeValue(int iUnsignedAttributeIndex);

char* secureblackbox_authenticodeverifier_getvalidationmoment(void* lpObj);
int secureblackbox_authenticodeverifier_setvalidationmoment(void* lpObj, const char* lpszValidationMoment);

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

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

QString Config(const QString& qsConfigurationString);

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

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

int secureblackbox_authenticodeverifier_reset(void* lpObj);

int Reset();

int secureblackbox_authenticodeverifier_verify(void* lpObj);

int Verify();

#define EID_AUTHENTICODEVERIFIER_CHAINELEMENTDOWNLOAD 1

virtual INT SECUREBLACKBOX_CALL FireChainElementDownload(INT &iKind, LPSTR &lpszCertRDN, LPSTR &lpszCACertRDN, LPSTR &lpszLocation, INT &iAction);

class AuthenticodeVerifierChainElementDownloadEventParams {
public:
  int Kind();

  const QString &CertRDN();

  const QString &CACertRDN();

  const QString &Location();

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

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

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

// Or, subclass AuthenticodeVerifier and override this emitter function.
virtual int FireChainElementDownload(AuthenticodeVerifierChainElementDownloadEventParams *e) {...}

#define EID_AUTHENTICODEVERIFIER_CHAINELEMENTNEEDED 2

virtual INT SECUREBLACKBOX_CALL FireChainElementNeeded(INT &iKind, LPSTR &lpszCertRDN, LPSTR &lpszCACertRDN);

class AuthenticodeVerifierChainElementNeededEventParams {
public:
  int Kind();

  const QString &CertRDN();

  const QString &CACertRDN();

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

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

// Or, subclass AuthenticodeVerifier and override this emitter function.
virtual int FireChainElementNeeded(AuthenticodeVerifierChainElementNeededEventParams *e) {...}

#define EID_AUTHENTICODEVERIFIER_CHAINVALIDATED 3

virtual INT SECUREBLACKBOX_CALL FireChainValidated(LPSTR &lpszSubjectRDN, INT &iValidationResult, INT &iValidationDetails);

class AuthenticodeVerifierChainValidatedEventParams {
public:
  const QString &SubjectRDN();

  int ValidationResult();

  int ValidationDetails();

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

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

// Or, subclass AuthenticodeVerifier and override this emitter function.
virtual int FireChainValidated(AuthenticodeVerifierChainValidatedEventParams *e) {...}

#define EID_AUTHENTICODEVERIFIER_CHAINVALIDATIONPROGRESS 4

virtual INT SECUREBLACKBOX_CALL FireChainValidationProgress(LPSTR &lpszEventKind, LPSTR &lpszCertRDN, LPSTR &lpszCACertRDN, INT &iAction);

class AuthenticodeVerifierChainValidationProgressEventParams {
public:
  const QString &EventKind();

  const QString &CertRDN();

  const QString &CACertRDN();

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

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

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

// Or, subclass AuthenticodeVerifier and override this emitter function.
virtual int FireChainValidationProgress(AuthenticodeVerifierChainValidationProgressEventParams *e) {...}

#define EID_AUTHENTICODEVERIFIER_ERROR 5

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

class AuthenticodeVerifierErrorEventParams {
public:
  int ErrorCode();

  const QString &Description();

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

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

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

#define EID_AUTHENTICODEVERIFIER_NOTIFICATION 6

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

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

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

#define EID_AUTHENTICODEVERIFIER_SIGNATUREFOUND 7

virtual INT SECUREBLACKBOX_CALL FireSignatureFound(LPSTR &lpszIssuerRDN, LPSTR &lpSerialNumber, INT &lenSerialNumber, LPSTR &lpSubjectKeyID, INT &lenSubjectKeyID, BOOL &bCertFound, BOOL &bValidateSignature, BOOL &bValidateChain);

class AuthenticodeVerifierSignatureFoundEventParams {
public:
  const QString &IssuerRDN();

  const QByteArray &SerialNumber();

  const QByteArray &SubjectKeyID();

  bool CertFound();

  bool ValidateSignature();
  void SetValidateSignature(bool bValidateSignature);

  bool ValidateChain();
  void SetValidateChain(bool bValidateChain);

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

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

// Or, subclass AuthenticodeVerifier and override this emitter function.
virtual int FireSignatureFound(AuthenticodeVerifierSignatureFoundEventParams *e) {...}

#define EID_AUTHENTICODEVERIFIER_SIGNATUREVALIDATED 8

virtual INT SECUREBLACKBOX_CALL FireSignatureValidated(LPSTR &lpszIssuerRDN, LPSTR &lpSerialNumber, INT &lenSerialNumber, LPSTR &lpSubjectKeyID, INT &lenSubjectKeyID, INT &iValidationResult);

class AuthenticodeVerifierSignatureValidatedEventParams {
public:
  const QString &IssuerRDN();

  const QByteArray &SerialNumber();

  const QByteArray &SubjectKeyID();

  int ValidationResult();

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

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

// Or, subclass AuthenticodeVerifier and override this emitter function.
virtual int FireSignatureValidated(AuthenticodeVerifierSignatureValidatedEventParams *e) {...}

#define EID_AUTHENTICODEVERIFIER_TIMESTAMPFOUND 9

virtual INT SECUREBLACKBOX_CALL FireTimestampFound(LPSTR &lpszIssuerRDN, LPSTR &lpSerialNumber, INT &lenSerialNumber, LPSTR &lpSubjectKeyID, INT &lenSubjectKeyID, BOOL &bCertFound, BOOL &bValidateTimestamp, BOOL &bValidateChain);

class AuthenticodeVerifierTimestampFoundEventParams {
public:
  const QString &IssuerRDN();

  const QByteArray &SerialNumber();

  const QByteArray &SubjectKeyID();

  bool CertFound();

  bool ValidateTimestamp();
  void SetValidateTimestamp(bool bValidateTimestamp);

  bool ValidateChain();
  void SetValidateChain(bool bValidateChain);

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

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

// Or, subclass AuthenticodeVerifier and override this emitter function.
virtual int FireTimestampFound(AuthenticodeVerifierTimestampFoundEventParams *e) {...}

#define EID_AUTHENTICODEVERIFIER_TIMESTAMPVALIDATED 10

virtual INT SECUREBLACKBOX_CALL FireTimestampValidated(LPSTR &lpszIssuerRDN, LPSTR &lpSerialNumber, INT &lenSerialNumber, LPSTR &lpSubjectKeyID, INT &lenSubjectKeyID, LPSTR &lpszTime, INT &iValidationResult, INT &iChainValidationResult, INT &iChainValidationDetails);

class AuthenticodeVerifierTimestampValidatedEventParams {
public:
  const QString &IssuerRDN();

  const QByteArray &SerialNumber();

  const QByteArray &SubjectKeyID();

  const QString &Time();

  int ValidationResult();

  int ChainValidationResult();

  int ChainValidationDetails();

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

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

// Or, subclass AuthenticodeVerifier and override this emitter function.
virtual int FireTimestampValidated(AuthenticodeVerifierTimestampValidatedEventParams *e) {...}

#define EID_AUTHENTICODEVERIFIER_TLSCERTNEEDED 11

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

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

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

#define EID_AUTHENTICODEVERIFIER_TLSCERTVALIDATE 12

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

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

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

#define EID_AUTHENTICODEVERIFIER_TLSESTABLISHED 13

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

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

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

#define EID_AUTHENTICODEVERIFIER_TLSHANDSHAKE 14

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

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

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

#define EID_AUTHENTICODEVERIFIER_TLSSHUTDOWN 15

virtual INT SECUREBLACKBOX_CALL FireTLSShutdown(LPSTR &lpszHost);

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

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

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

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