int secureblackbox_authenticodesigner_getblockedcertcount(void* lpObj);
int secureblackbox_authenticodesigner_setblockedcertcount(void* lpObj, int iBlockedCertCount);

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

int64 secureblackbox_authenticodesigner_getblockedcerthandle(void* lpObj, int blockedcertindex);
int secureblackbox_authenticodesigner_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);

char* secureblackbox_authenticodesigner_getclaimedsigningtime(void* lpObj);
int secureblackbox_authenticodesigner_setclaimedsigningtime(void* lpObj, const char* lpszClaimedSigningTime);

QString GetClaimedSigningTime();
int SetClaimedSigningTime(QString qsClaimedSigningTime);

char* secureblackbox_authenticodesigner_getexternalcryptoasyncdocumentid(void* lpObj);
int secureblackbox_authenticodesigner_setexternalcryptoasyncdocumentid(void* lpObj, const char* lpszExternalCryptoAsyncDocumentID);

char* secureblackbox_authenticodesigner_getexternalcryptocustomparams(void* lpObj);
int secureblackbox_authenticodesigner_setexternalcryptocustomparams(void* lpObj, const char* lpszExternalCryptoCustomParams);

char* secureblackbox_authenticodesigner_getexternalcryptodata(void* lpObj);
int secureblackbox_authenticodesigner_setexternalcryptodata(void* lpObj, const char* lpszExternalCryptoData);

int secureblackbox_authenticodesigner_getexternalcryptoexternalhashcalculation(void* lpObj);
int secureblackbox_authenticodesigner_setexternalcryptoexternalhashcalculation(void* lpObj, int bExternalCryptoExternalHashCalculation);

char* secureblackbox_authenticodesigner_getexternalcryptohashalgorithm(void* lpObj);
int secureblackbox_authenticodesigner_setexternalcryptohashalgorithm(void* lpObj, const char* lpszExternalCryptoHashAlgorithm);

char* secureblackbox_authenticodesigner_getexternalcryptokeyid(void* lpObj);
int secureblackbox_authenticodesigner_setexternalcryptokeyid(void* lpObj, const char* lpszExternalCryptoKeyID);

char* secureblackbox_authenticodesigner_getexternalcryptokeysecret(void* lpObj);
int secureblackbox_authenticodesigner_setexternalcryptokeysecret(void* lpObj, const char* lpszExternalCryptoKeySecret);

int secureblackbox_authenticodesigner_getexternalcryptomethod(void* lpObj);
int secureblackbox_authenticodesigner_setexternalcryptomethod(void* lpObj, int iExternalCryptoMethod);

int secureblackbox_authenticodesigner_getexternalcryptomode(void* lpObj);
int secureblackbox_authenticodesigner_setexternalcryptomode(void* lpObj, int iExternalCryptoMode);

char* secureblackbox_authenticodesigner_getexternalcryptopublickeyalgorithm(void* lpObj);
int secureblackbox_authenticodesigner_setexternalcryptopublickeyalgorithm(void* lpObj, const char* lpszExternalCryptoPublicKeyAlgorithm);

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

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

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

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

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

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

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

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

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

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

int secureblackbox_authenticodesigner_getfipsmode(void* lpObj);
int secureblackbox_authenticodesigner_setfipsmode(void* lpObj, int bFIPSMode);

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

char* secureblackbox_authenticodesigner_gethashalgorithm(void* lpObj);
int secureblackbox_authenticodesigner_sethashalgorithm(void* lpObj, const char* lpszHashAlgorithm);

QString GetHashAlgorithm();
int SetHashAlgorithm(QString qsHashAlgorithm);

int secureblackbox_authenticodesigner_getignorechainvalidationerrors(void* lpObj);
int secureblackbox_authenticodesigner_setignorechainvalidationerrors(void* lpObj, int bIgnoreChainValidationErrors);

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

int secureblackbox_authenticodesigner_getinputbytes(void* lpObj, char** lpInputBytes, int* lenInputBytes);
int secureblackbox_authenticodesigner_setinputbytes(void* lpObj, const char* lpInputBytes, int lenInputBytes);

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

char* secureblackbox_authenticodesigner_getinputfile(void* lpObj);
int secureblackbox_authenticodesigner_setinputfile(void* lpObj, const char* lpszInputFile);

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

int secureblackbox_authenticodesigner_getknowncertcount(void* lpObj);
int secureblackbox_authenticodesigner_setknowncertcount(void* lpObj, int iKnownCertCount);

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

int64 secureblackbox_authenticodesigner_getknowncerthandle(void* lpObj, int knowncertindex);
int secureblackbox_authenticodesigner_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_authenticodesigner_getknowncrlcount(void* lpObj);
int secureblackbox_authenticodesigner_setknowncrlcount(void* lpObj, int iKnownCRLCount);

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

int64 secureblackbox_authenticodesigner_getknowncrlhandle(void* lpObj, int knowncrlindex);
int secureblackbox_authenticodesigner_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_authenticodesigner_getknownocspcount(void* lpObj);
int secureblackbox_authenticodesigner_setknownocspcount(void* lpObj, int iKnownOCSPCount);

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

int64 secureblackbox_authenticodesigner_getknownocsphandle(void* lpObj, int knownocspindex);
int secureblackbox_authenticodesigner_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_authenticodesigner_getofflinemode(void* lpObj);
int secureblackbox_authenticodesigner_setofflinemode(void* lpObj, int bOfflineMode);

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

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

QByteArray GetOutputBytes();

char* secureblackbox_authenticodesigner_getoutputfile(void* lpObj);
int secureblackbox_authenticodesigner_setoutputfile(void* lpObj, const char* lpszOutputFile);

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

char* secureblackbox_authenticodesigner_getprofile(void* lpObj);
int secureblackbox_authenticodesigner_setprofile(void* lpObj, const char* lpszProfile);

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

char* secureblackbox_authenticodesigner_getproxyaddress(void* lpObj);
int secureblackbox_authenticodesigner_setproxyaddress(void* lpObj, const char* lpszProxyAddress);

int secureblackbox_authenticodesigner_getproxyauthentication(void* lpObj);
int secureblackbox_authenticodesigner_setproxyauthentication(void* lpObj, int iProxyAuthentication);

char* secureblackbox_authenticodesigner_getproxypassword(void* lpObj);
int secureblackbox_authenticodesigner_setproxypassword(void* lpObj, const char* lpszProxyPassword);

int secureblackbox_authenticodesigner_getproxyport(void* lpObj);
int secureblackbox_authenticodesigner_setproxyport(void* lpObj, int iProxyPort);

int secureblackbox_authenticodesigner_getproxyproxytype(void* lpObj);
int secureblackbox_authenticodesigner_setproxyproxytype(void* lpObj, int iProxyProxyType);

char* secureblackbox_authenticodesigner_getproxyrequestheaders(void* lpObj);
int secureblackbox_authenticodesigner_setproxyrequestheaders(void* lpObj, const char* lpszProxyRequestHeaders);

char* secureblackbox_authenticodesigner_getproxyresponsebody(void* lpObj);
int secureblackbox_authenticodesigner_setproxyresponsebody(void* lpObj, const char* lpszProxyResponseBody);

char* secureblackbox_authenticodesigner_getproxyresponseheaders(void* lpObj);
int secureblackbox_authenticodesigner_setproxyresponseheaders(void* lpObj, const char* lpszProxyResponseHeaders);

int secureblackbox_authenticodesigner_getproxyuseipv6(void* lpObj);
int secureblackbox_authenticodesigner_setproxyuseipv6(void* lpObj, int bProxyUseIPv6);

char* secureblackbox_authenticodesigner_getproxyusername(void* lpObj);
int secureblackbox_authenticodesigner_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_authenticodesigner_getremoveexistingsignatures(void* lpObj);
int secureblackbox_authenticodesigner_setremoveexistingsignatures(void* lpObj, int bRemoveExistingSignatures);

bool GetRemoveExistingSignatures();
int SetRemoveExistingSignatures(bool bRemoveExistingSignatures);

int secureblackbox_authenticodesigner_getrevocationcheck(void* lpObj);
int secureblackbox_authenticodesigner_setrevocationcheck(void* lpObj, int iRevocationCheck);

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

char* secureblackbox_authenticodesigner_getsignaturedescription(void* lpObj);
int secureblackbox_authenticodesigner_setsignaturedescription(void* lpObj, const char* lpszSignatureDescription);

QString GetSignatureDescription();
int SetSignatureDescription(QString qsSignatureDescription);

int secureblackbox_authenticodesigner_getsignatureindex(void* lpObj);
int secureblackbox_authenticodesigner_setsignatureindex(void* lpObj, int iSignatureIndex);

int GetSignatureIndex();
int SetSignatureIndex(int iSignatureIndex);

char* secureblackbox_authenticodesigner_getsignatureurl(void* lpObj);
int secureblackbox_authenticodesigner_setsignatureurl(void* lpObj, const char* lpszSignatureURL);

QString GetSignatureURL();
int SetSignatureURL(QString qsSignatureURL);

int secureblackbox_authenticodesigner_getsignedattributecount(void* lpObj);
int secureblackbox_authenticodesigner_setsignedattributecount(void* lpObj, int iSignedAttributeCount);

char* secureblackbox_authenticodesigner_getsignedattributeoid(void* lpObj, int signedattributeindex);
int secureblackbox_authenticodesigner_setsignedattributeoid(void* lpObj, int signedattributeindex, const char* lpszSignedAttributeOID);

int secureblackbox_authenticodesigner_getsignedattributevalue(void* lpObj, int signedattributeindex, char** lpSignedAttributeValue, int* lenSignedAttributeValue);
int secureblackbox_authenticodesigner_setsignedattributevalue(void* lpObj, int signedattributeindex, const char* lpSignedAttributeValue, int lenSignedAttributeValue);

int GetSignedAttributeCount();
int SetSignedAttributeCount(int iSignedAttributeCount);

QString GetSignedAttributeOID(int iSignedAttributeIndex);
int SetSignedAttributeOID(int iSignedAttributeIndex, QString qsSignedAttributeOID);

QByteArray GetSignedAttributeValue(int iSignedAttributeIndex);
int SetSignedAttributeValue(int iSignedAttributeIndex, QByteArray qbaSignedAttributeValue);

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

int64 secureblackbox_authenticodesigner_getsigningcerthandle(void* lpObj);
int secureblackbox_authenticodesigner_setsigningcerthandle(void* lpObj, int64 lSigningCertHandle);

QByteArray GetSigningCertBytes();

qint64 GetSigningCertHandle();
int SetSigningCertHandle(qint64 lSigningCertHandle);

int secureblackbox_authenticodesigner_getsigningchaincount(void* lpObj);
int secureblackbox_authenticodesigner_setsigningchaincount(void* lpObj, int iSigningChainCount);

int secureblackbox_authenticodesigner_getsigningchainbytes(void* lpObj, int signingchainindex, char** lpSigningChainBytes, int* lenSigningChainBytes);

int64 secureblackbox_authenticodesigner_getsigningchainhandle(void* lpObj, int signingchainindex);
int secureblackbox_authenticodesigner_setsigningchainhandle(void* lpObj, int signingchainindex, int64 lSigningChainHandle);

int GetSigningChainCount();
int SetSigningChainCount(int iSigningChainCount);

QByteArray GetSigningChainBytes(int iSigningChainIndex);

qint64 GetSigningChainHandle(int iSigningChainIndex);
int SetSigningChainHandle(int iSigningChainIndex, qint64 lSigningChainHandle);

int secureblackbox_authenticodesigner_getsocketdnsmode(void* lpObj);
int secureblackbox_authenticodesigner_setsocketdnsmode(void* lpObj, int iSocketDNSMode);

int secureblackbox_authenticodesigner_getsocketdnsport(void* lpObj);
int secureblackbox_authenticodesigner_setsocketdnsport(void* lpObj, int iSocketDNSPort);

int secureblackbox_authenticodesigner_getsocketdnsquerytimeout(void* lpObj);
int secureblackbox_authenticodesigner_setsocketdnsquerytimeout(void* lpObj, int iSocketDNSQueryTimeout);

char* secureblackbox_authenticodesigner_getsocketdnsservers(void* lpObj);
int secureblackbox_authenticodesigner_setsocketdnsservers(void* lpObj, const char* lpszSocketDNSServers);

int secureblackbox_authenticodesigner_getsocketdnstotaltimeout(void* lpObj);
int secureblackbox_authenticodesigner_setsocketdnstotaltimeout(void* lpObj, int iSocketDNSTotalTimeout);

int secureblackbox_authenticodesigner_getsocketincomingspeedlimit(void* lpObj);
int secureblackbox_authenticodesigner_setsocketincomingspeedlimit(void* lpObj, int iSocketIncomingSpeedLimit);

char* secureblackbox_authenticodesigner_getsocketlocaladdress(void* lpObj);
int secureblackbox_authenticodesigner_setsocketlocaladdress(void* lpObj, const char* lpszSocketLocalAddress);

int secureblackbox_authenticodesigner_getsocketlocalport(void* lpObj);
int secureblackbox_authenticodesigner_setsocketlocalport(void* lpObj, int iSocketLocalPort);

int secureblackbox_authenticodesigner_getsocketoutgoingspeedlimit(void* lpObj);
int secureblackbox_authenticodesigner_setsocketoutgoingspeedlimit(void* lpObj, int iSocketOutgoingSpeedLimit);

int secureblackbox_authenticodesigner_getsockettimeout(void* lpObj);
int secureblackbox_authenticodesigner_setsockettimeout(void* lpObj, int iSocketTimeout);

int secureblackbox_authenticodesigner_getsocketuseipv6(void* lpObj);
int secureblackbox_authenticodesigner_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_authenticodesigner_getstatementtype(void* lpObj);
int secureblackbox_authenticodesigner_setstatementtype(void* lpObj, int iStatementType);

int GetStatementType();
int SetStatementType(int iStatementType);

char* secureblackbox_authenticodesigner_gettimestampserver(void* lpObj);
int secureblackbox_authenticodesigner_settimestampserver(void* lpObj, const char* lpszTimestampServer);

QString GetTimestampServer();
int SetTimestampServer(QString qsTimestampServer);

int secureblackbox_authenticodesigner_gettimestamptype(void* lpObj);
int secureblackbox_authenticodesigner_settimestamptype(void* lpObj, int iTimestampType);

int GetTimestampType();
int SetTimestampType(int iTimestampType);

int secureblackbox_authenticodesigner_gettlsclientcertcount(void* lpObj);
int secureblackbox_authenticodesigner_settlsclientcertcount(void* lpObj, int iTLSClientCertCount);

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

int64 secureblackbox_authenticodesigner_gettlsclientcerthandle(void* lpObj, int tlsclientcertindex);
int secureblackbox_authenticodesigner_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_authenticodesigner_gettlsservercertcount(void* lpObj);

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

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

int64 secureblackbox_authenticodesigner_gettlsservercerthandle(void* lpObj, int tlsservercertindex);

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

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

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

int secureblackbox_authenticodesigner_gettlsservercertkeybits(void* lpObj, int tlsservercertindex);

int secureblackbox_authenticodesigner_gettlsservercertkeyusage(void* lpObj, int tlsservercertindex);

int secureblackbox_authenticodesigner_gettlsservercertselfsigned(void* lpObj, int tlsservercertindex);

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

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

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

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

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

char* secureblackbox_authenticodesigner_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_authenticodesigner_gettlsautovalidatecertificates(void* lpObj);
int secureblackbox_authenticodesigner_settlsautovalidatecertificates(void* lpObj, int bTLSAutoValidateCertificates);

int secureblackbox_authenticodesigner_gettlsbaseconfiguration(void* lpObj);
int secureblackbox_authenticodesigner_settlsbaseconfiguration(void* lpObj, int iTLSBaseConfiguration);

char* secureblackbox_authenticodesigner_gettlsciphersuites(void* lpObj);
int secureblackbox_authenticodesigner_settlsciphersuites(void* lpObj, const char* lpszTLSCiphersuites);

int secureblackbox_authenticodesigner_gettlsclientauth(void* lpObj);
int secureblackbox_authenticodesigner_settlsclientauth(void* lpObj, int iTLSClientAuth);

char* secureblackbox_authenticodesigner_gettlseccurves(void* lpObj);
int secureblackbox_authenticodesigner_settlseccurves(void* lpObj, const char* lpszTLSECCurves);

char* secureblackbox_authenticodesigner_gettlsextensions(void* lpObj);
int secureblackbox_authenticodesigner_settlsextensions(void* lpObj, const char* lpszTLSExtensions);

int secureblackbox_authenticodesigner_gettlsforceresumeifdestinationchanges(void* lpObj);
int secureblackbox_authenticodesigner_settlsforceresumeifdestinationchanges(void* lpObj, int bTLSForceResumeIfDestinationChanges);

char* secureblackbox_authenticodesigner_gettlspresharedidentity(void* lpObj);
int secureblackbox_authenticodesigner_settlspresharedidentity(void* lpObj, const char* lpszTLSPreSharedIdentity);

char* secureblackbox_authenticodesigner_gettlspresharedkey(void* lpObj);
int secureblackbox_authenticodesigner_settlspresharedkey(void* lpObj, const char* lpszTLSPreSharedKey);

char* secureblackbox_authenticodesigner_gettlspresharedkeyciphersuite(void* lpObj);
int secureblackbox_authenticodesigner_settlspresharedkeyciphersuite(void* lpObj, const char* lpszTLSPreSharedKeyCiphersuite);

int secureblackbox_authenticodesigner_gettlsrenegotiationattackpreventionmode(void* lpObj);
int secureblackbox_authenticodesigner_settlsrenegotiationattackpreventionmode(void* lpObj, int iTLSRenegotiationAttackPreventionMode);

int secureblackbox_authenticodesigner_gettlsrevocationcheck(void* lpObj);
int secureblackbox_authenticodesigner_settlsrevocationcheck(void* lpObj, int iTLSRevocationCheck);

int secureblackbox_authenticodesigner_gettlsssloptions(void* lpObj);
int secureblackbox_authenticodesigner_settlsssloptions(void* lpObj, int iTLSSSLOptions);

int secureblackbox_authenticodesigner_gettlstlsmode(void* lpObj);
int secureblackbox_authenticodesigner_settlstlsmode(void* lpObj, int iTLSTLSMode);

int secureblackbox_authenticodesigner_gettlsuseextendedmastersecret(void* lpObj);
int secureblackbox_authenticodesigner_settlsuseextendedmastersecret(void* lpObj, int bTLSUseExtendedMasterSecret);

int secureblackbox_authenticodesigner_gettlsusesessionresumption(void* lpObj);
int secureblackbox_authenticodesigner_settlsusesessionresumption(void* lpObj, int bTLSUseSessionResumption);

int secureblackbox_authenticodesigner_gettlsversions(void* lpObj);
int secureblackbox_authenticodesigner_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_authenticodesigner_gettrustedcertcount(void* lpObj);
int secureblackbox_authenticodesigner_settrustedcertcount(void* lpObj, int iTrustedCertCount);

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

int64 secureblackbox_authenticodesigner_gettrustedcerthandle(void* lpObj, int trustedcertindex);
int secureblackbox_authenticodesigner_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_authenticodesigner_getunsignedattributecount(void* lpObj);
int secureblackbox_authenticodesigner_setunsignedattributecount(void* lpObj, int iUnsignedAttributeCount);

char* secureblackbox_authenticodesigner_getunsignedattributeoid(void* lpObj, int unsignedattributeindex);
int secureblackbox_authenticodesigner_setunsignedattributeoid(void* lpObj, int unsignedattributeindex, const char* lpszUnsignedAttributeOID);

int secureblackbox_authenticodesigner_getunsignedattributevalue(void* lpObj, int unsignedattributeindex, char** lpUnsignedAttributeValue, int* lenUnsignedAttributeValue);
int secureblackbox_authenticodesigner_setunsignedattributevalue(void* lpObj, int unsignedattributeindex, const char* lpUnsignedAttributeValue, int lenUnsignedAttributeValue);

int GetUnsignedAttributeCount();
int SetUnsignedAttributeCount(int iUnsignedAttributeCount);

QString GetUnsignedAttributeOID(int iUnsignedAttributeIndex);
int SetUnsignedAttributeOID(int iUnsignedAttributeIndex, QString qsUnsignedAttributeOID);

QByteArray GetUnsignedAttributeValue(int iUnsignedAttributeIndex);
int SetUnsignedAttributeValue(int iUnsignedAttributeIndex, QByteArray qbaUnsignedAttributeValue);

char* secureblackbox_authenticodesigner_getvalidationlog(void* lpObj);

QString GetValidationLog();

int secureblackbox_authenticodesigner_addattribute(void* lpObj, const char* lpszOID, const char* lpValue, int lenValue, int bSignedAttribute);

int AddAttribute(const QString& qsOID, QByteArray qbaValue, bool bSignedAttribute);

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

QString Config(const QString& qsConfigurationString);

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

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

char* secureblackbox_authenticodesigner_extractasyncdata(void* lpObj, const char* lpszAsyncReply);

QString ExtractAsyncData(const QString& qsAsyncReply);

int secureblackbox_authenticodesigner_reset(void* lpObj);

int Reset();

int secureblackbox_authenticodesigner_sign(void* lpObj);

int Sign();

char* secureblackbox_authenticodesigner_signasyncbegin(void* lpObj);

QString SignAsyncBegin();

int secureblackbox_authenticodesigner_signasyncend(void* lpObj, const char* lpszAsyncReply);

int SignAsyncEnd(const QString& qsAsyncReply);

int secureblackbox_authenticodesigner_signexternal(void* lpObj);

int SignExternal();

int secureblackbox_authenticodesigner_timestamp(void* lpObj);

int Timestamp();

int secureblackbox_authenticodesigner_update(void* lpObj);

int Update();

#define EID_AUTHENTICODESIGNER_CHAINELEMENTDOWNLOAD 1

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

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

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

#define EID_AUTHENTICODESIGNER_CHAINELEMENTNEEDED 2

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

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

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

#define EID_AUTHENTICODESIGNER_CHAINVALIDATIONPROGRESS 3

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

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

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

#define EID_AUTHENTICODESIGNER_ERROR 4

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

class AuthenticodeSignerErrorEventParams {
public:
  int ErrorCode();

  const QString &Description();

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

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

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

#define EID_AUTHENTICODESIGNER_EXTERNALSIGN 5

virtual INT SECUREBLACKBOX_CALL FireExternalSign(LPSTR &lpszOperationId, LPSTR &lpszHashAlgorithm, LPSTR &lpszPars, LPSTR &lpszData, LPSTR &lpszSignedData);

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

  const QString &HashAlgorithm();

  const QString &Pars();

  const QString &Data();

  const QString &SignedData();
  void SetSignedData(const QString &qsSignedData);

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

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

// Or, subclass AuthenticodeSigner and override this emitter function.
virtual int FireExternalSign(AuthenticodeSignerExternalSignEventParams *e) {...}

#define EID_AUTHENTICODESIGNER_NOTIFICATION 6

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

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

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

#define EID_AUTHENTICODESIGNER_START 7

virtual INT SECUREBLACKBOX_CALL FireStart(INT &iSpecifiedChecksum, INT &iActualChecksum, BOOL &bIsSigned, BOOL &bCancel);

class AuthenticodeSignerStartEventParams {
public:
  int SpecifiedChecksum();

  int ActualChecksum();

  bool IsSigned();

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

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

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

// Or, subclass AuthenticodeSigner and override this emitter function.
virtual int FireStart(AuthenticodeSignerStartEventParams *e) {...}

#define EID_AUTHENTICODESIGNER_TIMESTAMPREQUEST 8

virtual INT SECUREBLACKBOX_CALL FireTimestampRequest(LPSTR &lpszTSA, LPSTR &lpszTimestampRequest, LPSTR &lpszTimestampResponse, BOOL &bSuppressDefault);

class AuthenticodeSignerTimestampRequestEventParams {
public:
  const QString &TSA();

  const QString &TimestampRequest();

  const QString &TimestampResponse();
  void SetTimestampResponse(const QString &qsTimestampResponse);

  bool SuppressDefault();
  void SetSuppressDefault(bool bSuppressDefault);

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

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

// Or, subclass AuthenticodeSigner and override this emitter function.
virtual int FireTimestampRequest(AuthenticodeSignerTimestampRequestEventParams *e) {...}

#define EID_AUTHENTICODESIGNER_TLSCERTNEEDED 9

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

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

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

#define EID_AUTHENTICODESIGNER_TLSCERTVALIDATE 10

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

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

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

#define EID_AUTHENTICODESIGNER_TLSESTABLISHED 11

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

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

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

#define EID_AUTHENTICODESIGNER_TLSHANDSHAKE 12

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

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

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

#define EID_AUTHENTICODESIGNER_TLSSHUTDOWN 13

virtual INT SECUREBLACKBOX_CALL FireTLSShutdown(LPSTR &lpszHost);

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

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

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

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