You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1437 lines
32 KiB
1437 lines
32 KiB
// xenroll.idl : IDL source for xenroll.dll
|
|
//
|
|
|
|
// This file will be processed by the MIDL tool to
|
|
// produce the type library (xenroll.tlb) and marshalling code.
|
|
|
|
|
|
import "oaidl.idl";
|
|
import "ocidl.idl";
|
|
|
|
import "wincrypt.idl";
|
|
|
|
//+--------------------------------------------------------------------------
|
|
// interface ICEnroll
|
|
|
|
[
|
|
object,
|
|
uuid(43F8F288-7A20-11D0-8F06-00C04FC295E1),
|
|
dual,
|
|
helpstring("ICEnroll Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface ICEnroll : IDispatch
|
|
{
|
|
//
|
|
// Walk the end user through the process of generating a key
|
|
// pair, which either will or will not be required to use some form
|
|
// of hardware private key management, per the fRequireHardware
|
|
// parameter. Return to the caller a PKCS#10 of the resulting
|
|
// generated key, where in the subject name
|
|
//
|
|
HRESULT createFilePKCS10(
|
|
[in] BSTR DNName,
|
|
[in] BSTR Usage,
|
|
[in] BSTR wszPKCS10FileName
|
|
);
|
|
|
|
//
|
|
// Accept delivery of the credentials that correspond to a previous
|
|
// call to GenerateKeyPair. This method puts the credentials
|
|
// whereever they are supposed to go for easy subsequent access
|
|
// by the user.
|
|
//
|
|
HRESULT acceptFilePKCS7(
|
|
[in] BSTR wszPKCS7FileName
|
|
);
|
|
|
|
HRESULT createPKCS10(
|
|
|
|
// This is the DN name for the certificate in X500 name syntax.
|
|
// For example CN=KeithV
|
|
[in] BSTR DNName,
|
|
|
|
|
|
// This is the usage string, it will end up in the certificate
|
|
// enumerating what the certificate is used for. For example
|
|
// ClientAuth, Or CodeSigning. It can be any string.
|
|
[in] BSTR Usage,
|
|
|
|
// The return value is a Base64 encoded
|
|
// PKCS10 Cert Request
|
|
[out, retval] BSTR* pPKCS10
|
|
|
|
);
|
|
|
|
//
|
|
// Accept delivery of the credentials that correspond to a previous
|
|
// call to GenerateKeyPair. This method puts the credentials
|
|
// whereever they are supposed to go for easy subsequent access
|
|
// by the user.
|
|
//
|
|
HRESULT acceptPKCS7(
|
|
//
|
|
// The credentials that are to be stored. Credentials
|
|
// are a PKCS#7 SignedData that is used simply as a bucket
|
|
// to convey a bunch of certificates. There must be precisely
|
|
// one certificate with no child in the bucket.
|
|
//
|
|
[in] BSTR PKCS7
|
|
);
|
|
|
|
HRESULT getCertFromPKCS7(
|
|
[in] BSTR wszPKCS7,
|
|
[out, retval] BSTR* pbstrCert
|
|
);
|
|
|
|
HRESULT enumProviders(
|
|
[in] LONG dwIndex,
|
|
[in] LONG dwFlags,
|
|
[out, retval] BSTR* pbstrProvName
|
|
);
|
|
|
|
HRESULT enumContainers(
|
|
[in] LONG dwIndex,
|
|
[out, retval] BSTR* pbstr
|
|
);
|
|
|
|
//
|
|
// Session Id's must be appropriately clean up
|
|
//
|
|
HRESULT freeRequestInfo(
|
|
//
|
|
// The session Id that represents the data
|
|
//
|
|
[in] BSTR PKCS7OrPKCS10
|
|
);
|
|
|
|
[propget]
|
|
HRESULT MyStoreName(
|
|
[out, retval] BSTR * pbstrName
|
|
);
|
|
|
|
[propput]
|
|
HRESULT MyStoreName(
|
|
[in] BSTR bstrName
|
|
);
|
|
|
|
[propget]
|
|
HRESULT MyStoreType(
|
|
[out, retval] BSTR * pbstrType
|
|
);
|
|
|
|
[propput]
|
|
HRESULT MyStoreType(
|
|
[in] BSTR bstrType
|
|
);
|
|
|
|
[propget]
|
|
HRESULT MyStoreFlags(
|
|
[out, retval] LONG * pdwFlags
|
|
);
|
|
|
|
[propput]
|
|
HRESULT MyStoreFlags(
|
|
[in] LONG dwFlags
|
|
);
|
|
|
|
[propget]
|
|
HRESULT CAStoreName(
|
|
[out, retval] BSTR * pbstrName
|
|
);
|
|
|
|
[propput]
|
|
HRESULT CAStoreName(
|
|
[in] BSTR bstrName
|
|
);
|
|
|
|
[propget]
|
|
HRESULT CAStoreType(
|
|
[out, retval] BSTR * pbstrType
|
|
);
|
|
|
|
[propput]
|
|
HRESULT CAStoreType(
|
|
[in] BSTR bstrType
|
|
);
|
|
|
|
[propget]
|
|
HRESULT CAStoreFlags(
|
|
[out, retval] LONG * pdwFlags
|
|
);
|
|
|
|
[propput]
|
|
HRESULT CAStoreFlags(
|
|
[in] LONG dwFlags
|
|
);
|
|
|
|
[propget]
|
|
HRESULT RootStoreName(
|
|
[out, retval] BSTR * pbstrName
|
|
);
|
|
|
|
[propput]
|
|
HRESULT RootStoreName(
|
|
[in] BSTR bstrName
|
|
);
|
|
|
|
[propget]
|
|
HRESULT RootStoreType(
|
|
[out, retval] BSTR * pbstrType
|
|
);
|
|
|
|
[propput]
|
|
HRESULT RootStoreType(
|
|
[in] BSTR bstrType
|
|
);
|
|
|
|
[propget]
|
|
HRESULT RootStoreFlags(
|
|
[out, retval] LONG * pdwFlags
|
|
);
|
|
|
|
[propput]
|
|
HRESULT RootStoreFlags(
|
|
[in] LONG dwFlags
|
|
);
|
|
|
|
[propget]
|
|
HRESULT RequestStoreName(
|
|
[out, retval] BSTR * pbstrName
|
|
);
|
|
|
|
[propput]
|
|
HRESULT RequestStoreName(
|
|
[in] BSTR bstrName
|
|
);
|
|
|
|
[propget]
|
|
HRESULT RequestStoreType(
|
|
[out, retval] BSTR * pbstrType
|
|
);
|
|
|
|
[propput]
|
|
HRESULT RequestStoreType(
|
|
[in] BSTR bstrType
|
|
);
|
|
|
|
[propget]
|
|
HRESULT RequestStoreFlags(
|
|
[out, retval] LONG * pdwFlags
|
|
);
|
|
|
|
[propput]
|
|
HRESULT RequestStoreFlags(
|
|
[in] LONG dwFlags
|
|
);
|
|
|
|
[propget]
|
|
HRESULT ContainerName(
|
|
[out, retval] BSTR * pbstrContainer
|
|
);
|
|
|
|
[propput]
|
|
HRESULT ContainerName(
|
|
[in] BSTR bstrContainer
|
|
);
|
|
|
|
[propget]
|
|
HRESULT ProviderName(
|
|
[out, retval] BSTR * pbstrProvider
|
|
);
|
|
|
|
[propput]
|
|
HRESULT ProviderName(
|
|
[in] BSTR bstrProvider
|
|
);
|
|
|
|
[propget]
|
|
HRESULT ProviderType(
|
|
[out, retval] LONG * pdwType
|
|
);
|
|
|
|
[propput]
|
|
HRESULT ProviderType(
|
|
[in] LONG dwType
|
|
);
|
|
|
|
[propget]
|
|
HRESULT KeySpec(
|
|
[out, retval] LONG * pdw
|
|
);
|
|
|
|
[propput]
|
|
HRESULT KeySpec(
|
|
[in] LONG dw
|
|
);
|
|
|
|
[propget]
|
|
HRESULT ProviderFlags(
|
|
[out, retval] LONG * pdwFlags
|
|
);
|
|
|
|
[propput]
|
|
HRESULT ProviderFlags(
|
|
[in] LONG dwFlags
|
|
);
|
|
|
|
[propget]
|
|
HRESULT UseExistingKeySet(
|
|
[out, retval] BOOL * fUseExistingKeys
|
|
);
|
|
|
|
[propput]
|
|
HRESULT UseExistingKeySet(
|
|
[in] BOOL fUseExistingKeys
|
|
);
|
|
|
|
[propget]
|
|
HRESULT GenKeyFlags(
|
|
[out, retval] LONG * pdwFlags
|
|
);
|
|
|
|
[propput]
|
|
HRESULT GenKeyFlags(
|
|
[in] LONG dwFlags
|
|
);
|
|
|
|
[propget]
|
|
HRESULT DeleteRequestCert(
|
|
[out, retval] BOOL * fDelete
|
|
);
|
|
|
|
[propput]
|
|
HRESULT DeleteRequestCert(
|
|
[in] BOOL fDelete
|
|
);
|
|
|
|
[propget]
|
|
HRESULT WriteCertToCSP(
|
|
[out, retval] BOOL * fBool
|
|
);
|
|
|
|
[propput]
|
|
HRESULT WriteCertToCSP(
|
|
[in] BOOL fBool
|
|
);
|
|
|
|
[propget]
|
|
HRESULT SPCFileName(
|
|
[out, retval] BSTR * pbstr
|
|
);
|
|
|
|
[propput]
|
|
HRESULT SPCFileName(
|
|
[in] BSTR bstr
|
|
);
|
|
|
|
[propget]
|
|
HRESULT PVKFileName(
|
|
[out, retval] BSTR * pbstr
|
|
);
|
|
|
|
[propput]
|
|
HRESULT PVKFileName(
|
|
[in] BSTR bstr
|
|
);
|
|
|
|
[propget]
|
|
HRESULT HashAlgorithm(
|
|
[out, retval] BSTR * pbstr
|
|
);
|
|
|
|
[propput]
|
|
HRESULT HashAlgorithm(
|
|
[in] BSTR bstr
|
|
);
|
|
};
|
|
|
|
|
|
//+--------------------------------------------------------------------------
|
|
// interface ICEnroll2
|
|
|
|
[
|
|
object,
|
|
uuid(704ca730-c90b-11d1-9bec-00c04fc295e1),
|
|
dual,
|
|
helpstring("ICEnroll2 Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface ICEnroll2 : ICEnroll
|
|
{
|
|
HRESULT addCertTypeToRequest(
|
|
[in] BSTR CertType
|
|
);
|
|
|
|
HRESULT addNameValuePairToSignature(
|
|
[in] BSTR Name,
|
|
[in] BSTR Value
|
|
);
|
|
|
|
[propget]
|
|
HRESULT WriteCertToUserDS(
|
|
[out, retval] BOOL * fBool
|
|
);
|
|
|
|
[propput]
|
|
HRESULT WriteCertToUserDS(
|
|
[in] BOOL fBool
|
|
);
|
|
|
|
[propget]
|
|
HRESULT EnableT61DNEncoding(
|
|
[out, retval] BOOL * fBool
|
|
);
|
|
|
|
[propput]
|
|
HRESULT EnableT61DNEncoding(
|
|
[in] BOOL fBool
|
|
);
|
|
};
|
|
|
|
|
|
//+--------------------------------------------------------------------------
|
|
// interface ICEnroll3
|
|
|
|
[
|
|
object,
|
|
uuid(c28c2d95-b7de-11d2-a421-00c04f79fe8e),
|
|
dual,
|
|
helpstring("ICEnroll3 Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface ICEnroll3 : ICEnroll2
|
|
{
|
|
HRESULT InstallPKCS7(
|
|
[in] BSTR PKCS7
|
|
);
|
|
|
|
HRESULT Reset(
|
|
void
|
|
);
|
|
|
|
HRESULT GetSupportedKeySpec(
|
|
[out, retval] LONG * pdwKeySpec
|
|
);
|
|
|
|
HRESULT GetKeyLen(
|
|
[in] BOOL fMin,
|
|
[in] BOOL fExchange,
|
|
[out, retval] LONG * pdwKeySize
|
|
);
|
|
|
|
HRESULT EnumAlgs(
|
|
[in] LONG dwIndex,
|
|
[in] LONG algClass,
|
|
[out, retval] LONG * pdwAlgID
|
|
);
|
|
|
|
HRESULT GetAlgName(
|
|
[in] LONG algID,
|
|
[out, retval] BSTR * pbstr
|
|
);
|
|
|
|
[propput]
|
|
HRESULT ReuseHardwareKeyIfUnableToGenNew(
|
|
[in] BOOL fReuseHardwareKeyIfUnableToGenNew
|
|
);
|
|
|
|
[propget]
|
|
HRESULT ReuseHardwareKeyIfUnableToGenNew(
|
|
[out, retval] BOOL * fReuseHardwareKeyIfUnableToGenNew
|
|
);
|
|
|
|
[propput]
|
|
HRESULT HashAlgID(
|
|
[in] LONG hashAlgID
|
|
);
|
|
|
|
[propget]
|
|
HRESULT HashAlgID(
|
|
[out, retval] LONG * hashAlgID
|
|
);
|
|
|
|
[propput]
|
|
HRESULT LimitExchangeKeyToEncipherment(
|
|
[in] BOOL fLimitExchangeKeyToEncipherment
|
|
);
|
|
|
|
[propget]
|
|
HRESULT LimitExchangeKeyToEncipherment(
|
|
[out, retval] BOOL * fLimitExchangeKeyToEncipherment
|
|
);
|
|
|
|
[propput]
|
|
HRESULT EnableSMIMECapabilities(
|
|
[in] BOOL fEnableSMIMECapabilities
|
|
);
|
|
|
|
[propget]
|
|
HRESULT EnableSMIMECapabilities(
|
|
[out, retval] BOOL * fEnableSMIMECapabilities
|
|
);
|
|
};
|
|
|
|
|
|
//+--------------------------------------------------------------------------
|
|
// interface ICEnroll4
|
|
|
|
[
|
|
object,
|
|
uuid(c1f1188a-2eb5-4a80-841b-7e729a356d90),
|
|
dual,
|
|
helpstring("ICEnroll4 Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface ICEnroll4 : ICEnroll3
|
|
{
|
|
|
|
[propput]
|
|
HRESULT PrivateKeyArchiveCertificate(
|
|
[in] BSTR bstrCert
|
|
);
|
|
|
|
[propget]
|
|
HRESULT PrivateKeyArchiveCertificate(
|
|
[out, retval] BSTR *pbstrCert
|
|
);
|
|
|
|
[propput]
|
|
HRESULT ThumbPrint(
|
|
[in] BSTR bstrThumbPrint
|
|
);
|
|
|
|
[propget]
|
|
HRESULT ThumbPrint(
|
|
[out, retval] BSTR *pbstrThumbPrint
|
|
);
|
|
|
|
HRESULT binaryToString(
|
|
[in] LONG Flags,
|
|
[in] BSTR strBinary,
|
|
[out, retval] BSTR *pstrEncoded
|
|
);
|
|
|
|
HRESULT stringToBinary(
|
|
[in] LONG Flags,
|
|
[in] BSTR strEncoded,
|
|
[out, retval] BSTR *pstrBinary
|
|
);
|
|
|
|
HRESULT addExtensionToRequest(
|
|
[in] LONG Flags,
|
|
[in] BSTR strName,
|
|
[in] BSTR strValue
|
|
);
|
|
|
|
HRESULT addAttributeToRequest(
|
|
[in] LONG Flags,
|
|
[in] BSTR strName,
|
|
[in] BSTR strValue
|
|
);
|
|
|
|
HRESULT addNameValuePairToRequest(
|
|
[in] LONG Flags,
|
|
[in] BSTR strName,
|
|
[in] BSTR strValue
|
|
);
|
|
|
|
HRESULT resetExtensions(
|
|
void
|
|
);
|
|
|
|
HRESULT resetAttributes(
|
|
void
|
|
);
|
|
|
|
HRESULT createRequest(
|
|
[in] LONG Flags,
|
|
[in] BSTR strDNName,
|
|
[in] BSTR Usage,
|
|
[out, retval] BSTR *pstrRequest
|
|
);
|
|
|
|
HRESULT createFileRequest(
|
|
[in] LONG Flags ,
|
|
[in] BSTR strDNName,
|
|
[in] BSTR strUsage,
|
|
[in] BSTR strRequestFileName
|
|
);
|
|
|
|
HRESULT acceptResponse(
|
|
[in] BSTR strResponse
|
|
);
|
|
|
|
HRESULT acceptFileResponse(
|
|
[in] BSTR strResponseFileName
|
|
);
|
|
|
|
HRESULT getCertFromResponse(
|
|
[in] BSTR strResponse,
|
|
[out, retval] BSTR *pstrCert
|
|
);
|
|
|
|
HRESULT getCertFromFileResponse(
|
|
[in] BSTR strResponseFileName,
|
|
[out, retval] BSTR *pstrCert
|
|
);
|
|
|
|
HRESULT createPFX(
|
|
[in] BSTR strPassword,
|
|
[out, retval] BSTR *pstrPFX
|
|
);
|
|
|
|
HRESULT createFilePFX(
|
|
[in] BSTR strPassword,
|
|
[in] BSTR strPFXFileName
|
|
);
|
|
|
|
HRESULT setPendingRequestInfo(
|
|
[in] LONG lRequestID,
|
|
[in] BSTR strCADNS,
|
|
[in] BSTR strCAName,
|
|
[in] BSTR strFriendlyName
|
|
);
|
|
|
|
HRESULT enumPendingRequest(
|
|
[in] LONG lIndex,
|
|
[in] LONG lDesiredProperty,
|
|
[out, retval] VARIANT *pvarProperty
|
|
);
|
|
|
|
HRESULT removePendingRequest(
|
|
[in] BSTR strThumbprint
|
|
);
|
|
|
|
HRESULT GetKeyLenEx(
|
|
[in] LONG lSizeSpec,
|
|
[in] LONG lKeySpec,
|
|
[out, retval] LONG * pdwKeySize
|
|
);
|
|
|
|
HRESULT InstallPKCS7Ex(
|
|
[in] BSTR PKCS7,
|
|
[out, retval] LONG * plCertInstalled
|
|
);
|
|
|
|
HRESULT addCertTypeToRequestEx(
|
|
[in] LONG lType,
|
|
[in] BSTR bstrOIDOrName,
|
|
[in] LONG lMajorVersion,
|
|
[in] BOOL fMinorVersion,
|
|
[in] LONG lMinorVersion
|
|
);
|
|
|
|
HRESULT getProviderType(
|
|
[in] BSTR strProvName,
|
|
[out, retval] LONG *plProvType
|
|
);
|
|
|
|
[propput]
|
|
HRESULT SignerCertificate(
|
|
[in] BSTR bstrCert
|
|
);
|
|
|
|
[propput]
|
|
HRESULT ClientId(
|
|
[in] LONG lClientId
|
|
);
|
|
|
|
[propget]
|
|
HRESULT ClientId(
|
|
[out, retval] LONG *plClientId
|
|
);
|
|
|
|
HRESULT addBlobPropertyToCertificate(
|
|
[in] LONG lPropertyId,
|
|
[in] LONG lReserved,
|
|
[in] BSTR bstrProperty
|
|
);
|
|
|
|
HRESULT resetBlobProperties(
|
|
void
|
|
);
|
|
|
|
[propput]
|
|
HRESULT IncludeSubjectKeyID(
|
|
[in] BOOL fInclude
|
|
);
|
|
|
|
[propget]
|
|
HRESULT IncludeSubjectKeyID(
|
|
[out, retval] BOOL *pfInclude
|
|
);
|
|
|
|
};
|
|
|
|
|
|
//+--------------------------------------------------------------------------
|
|
// interface IEnroll
|
|
|
|
[
|
|
object,
|
|
uuid(acaa7838-4585-11d1-ab57-00c04fc295e1),
|
|
local,
|
|
helpstring("IEnroll Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IEnroll : IUnknown
|
|
{
|
|
//
|
|
// Walk the end user through the process of generating a key
|
|
// pair, which either will or will not be required to use some form
|
|
// of hardware private key management, per the fRequireHardware
|
|
// parameter. Return to the caller a PKCS#10 of the resulting
|
|
// generated key, where in the subject name
|
|
//
|
|
HRESULT createFilePKCS10WStr(
|
|
[in] LPCWSTR DNName,
|
|
[in] LPCWSTR Usage,
|
|
[in] LPCWSTR wszPKCS10FileName
|
|
);
|
|
|
|
//
|
|
// Accept delivery of the credentials that correspond to a previous
|
|
// call to GenerateKeyPair. This method puts the credentials
|
|
// whereever they are supposed to go for easy subsequent access
|
|
// by the user.
|
|
//
|
|
HRESULT acceptFilePKCS7WStr(
|
|
[in] LPCWSTR wszPKCS7FileName
|
|
);
|
|
|
|
HRESULT createPKCS10WStr(
|
|
|
|
// This is the DN name for the certificate in X500 name syntax.
|
|
// For example CN=KeithV
|
|
[in] LPCWSTR DNName,
|
|
|
|
|
|
// This is the usage string, it will end up in the certificate
|
|
// enumerating what the certificate is used for. For example
|
|
// ClientAuth, Or CodeSigning. It can be any string.
|
|
[in] LPCWSTR Usage,
|
|
|
|
// The return value is a Base64 encoded
|
|
// PKCS10 Cert Request
|
|
[out] PCRYPT_DATA_BLOB pPkcs10Blob
|
|
|
|
);
|
|
|
|
//
|
|
// Accept delivery of the credentials that correspond to a previous
|
|
// call to GenerateKeyPair. This method puts the credentials
|
|
// whereever they are supposed to go for easy subsequent access
|
|
// by the user.
|
|
//
|
|
HRESULT acceptPKCS7Blob(
|
|
//
|
|
// The credentials that are to be stored. Credentials
|
|
// are a PKCS#7 SignedData that is used simply as a bucket
|
|
// to convey a bunch of certificates. There must be precisely
|
|
// one certificate with no child in the bucket.
|
|
//
|
|
[in] PCRYPT_DATA_BLOB pBlobPKCS7
|
|
);
|
|
|
|
PCCERT_CONTEXT getCertContextFromPKCS7(
|
|
[in] PCRYPT_DATA_BLOB pBlobPKCS7
|
|
);
|
|
|
|
HCERTSTORE getMyStore(
|
|
void
|
|
);
|
|
|
|
HCERTSTORE getCAStore(
|
|
void
|
|
);
|
|
|
|
HCERTSTORE getROOTHStore(
|
|
void
|
|
);
|
|
|
|
HRESULT enumProvidersWStr(
|
|
[in] LONG dwIndex,
|
|
[in] LONG dwFlags,
|
|
[out] LPWSTR * pbstrProvName
|
|
);
|
|
|
|
HRESULT enumContainersWStr(
|
|
[in] LONG dwIndex,
|
|
[out] LPWSTR * pbstr
|
|
);
|
|
|
|
//
|
|
// Session Id's must be appropriately clean up
|
|
//
|
|
HRESULT freeRequestInfoBlob(
|
|
|
|
//
|
|
// The session Id that represents the data
|
|
//
|
|
[in] CRYPT_DATA_BLOB pkcs7OrPkcs10
|
|
|
|
);
|
|
|
|
[propget]
|
|
HRESULT MyStoreNameWStr(
|
|
[out] LPWSTR * szwName
|
|
);
|
|
|
|
[propput]
|
|
HRESULT MyStoreNameWStr(
|
|
[in] LPWSTR szwName
|
|
);
|
|
|
|
[propget]
|
|
HRESULT MyStoreTypeWStr(
|
|
[out] LPWSTR * szwType
|
|
);
|
|
|
|
[propput]
|
|
HRESULT MyStoreTypeWStr(
|
|
[in] LPWSTR szwType
|
|
);
|
|
|
|
[propget]
|
|
HRESULT MyStoreFlags(
|
|
[out] LONG * pdwFlags
|
|
);
|
|
|
|
[propput]
|
|
HRESULT MyStoreFlags(
|
|
[in] LONG dwFlags
|
|
);
|
|
|
|
[propget]
|
|
HRESULT CAStoreNameWStr(
|
|
[out] LPWSTR * szwName
|
|
);
|
|
|
|
[propput]
|
|
HRESULT CAStoreNameWStr(
|
|
[in] LPWSTR szwName
|
|
);
|
|
|
|
[propget]
|
|
HRESULT CAStoreTypeWStr(
|
|
[out] LPWSTR * szwType
|
|
);
|
|
|
|
[propput]
|
|
HRESULT CAStoreTypeWStr(
|
|
[in] LPWSTR szwType
|
|
);
|
|
|
|
[propget]
|
|
HRESULT CAStoreFlags(
|
|
[out] LONG * pdwFlags
|
|
);
|
|
|
|
[propput]
|
|
HRESULT CAStoreFlags(
|
|
[in] LONG dwFlags
|
|
);
|
|
|
|
[propget]
|
|
HRESULT RootStoreNameWStr(
|
|
[out] LPWSTR * szwName
|
|
);
|
|
|
|
[propput]
|
|
HRESULT RootStoreNameWStr(
|
|
[in] LPWSTR szwName
|
|
);
|
|
|
|
[propget]
|
|
HRESULT RootStoreTypeWStr(
|
|
[out] LPWSTR * szwType
|
|
);
|
|
|
|
[propput]
|
|
HRESULT RootStoreTypeWStr(
|
|
[in] LPWSTR szwType
|
|
);
|
|
|
|
[propget]
|
|
HRESULT RootStoreFlags(
|
|
[out] LONG * pdwFlags
|
|
);
|
|
|
|
[propput]
|
|
HRESULT RootStoreFlags(
|
|
[in] LONG dwFlags
|
|
);
|
|
|
|
[propget]
|
|
HRESULT RequestStoreNameWStr(
|
|
[out] LPWSTR * szwName
|
|
);
|
|
|
|
[propput]
|
|
HRESULT RequestStoreNameWStr(
|
|
[in] LPWSTR szwName
|
|
);
|
|
|
|
[propget]
|
|
HRESULT RequestStoreTypeWStr(
|
|
[out] LPWSTR * szwType
|
|
);
|
|
|
|
[propput]
|
|
HRESULT RequestStoreTypeWStr(
|
|
[in] LPWSTR szwType
|
|
);
|
|
|
|
[propget]
|
|
HRESULT RequestStoreFlags(
|
|
[out] LONG * pdwFlags
|
|
);
|
|
|
|
[propput]
|
|
HRESULT RequestStoreFlags(
|
|
[in] LONG dwFlags
|
|
);
|
|
|
|
[propget]
|
|
HRESULT ContainerNameWStr(
|
|
[out] LPWSTR * szwContainer
|
|
);
|
|
|
|
[propput]
|
|
HRESULT ContainerNameWStr(
|
|
[in] LPWSTR szwContainer
|
|
);
|
|
|
|
[propget]
|
|
HRESULT ProviderNameWStr(
|
|
[out] LPWSTR * szwProvider
|
|
);
|
|
|
|
[propput]
|
|
HRESULT ProviderNameWStr(
|
|
[in] LPWSTR szwProvider
|
|
);
|
|
|
|
[propget]
|
|
HRESULT ProviderType(
|
|
[out] LONG * pdwType
|
|
);
|
|
|
|
[propput]
|
|
HRESULT ProviderType(
|
|
[in] LONG dwType
|
|
);
|
|
|
|
[propget]
|
|
HRESULT KeySpec(
|
|
[out] LONG * pdw
|
|
);
|
|
|
|
[propput]
|
|
HRESULT KeySpec(
|
|
[in] LONG dw
|
|
);
|
|
|
|
[propget]
|
|
HRESULT ProviderFlags(
|
|
[out] LONG * pdwFlags
|
|
);
|
|
|
|
[propput]
|
|
HRESULT ProviderFlags(
|
|
[in] LONG dwFlags
|
|
);
|
|
|
|
[propget]
|
|
HRESULT UseExistingKeySet(
|
|
[out] BOOL * fUseExistingKeys
|
|
);
|
|
|
|
[propput]
|
|
HRESULT UseExistingKeySet(
|
|
[in] BOOL fUseExistingKeys
|
|
);
|
|
|
|
[propget]
|
|
HRESULT GenKeyFlags(
|
|
[out] LONG * pdwFlags
|
|
);
|
|
|
|
[propput]
|
|
HRESULT GenKeyFlags(
|
|
[in] LONG dwFlags
|
|
);
|
|
|
|
[propget]
|
|
HRESULT DeleteRequestCert(
|
|
[out] BOOL * fDelete
|
|
);
|
|
|
|
[propput]
|
|
HRESULT DeleteRequestCert(
|
|
[in] BOOL fDelete
|
|
);
|
|
|
|
[propget]
|
|
HRESULT WriteCertToUserDS(
|
|
[out] BOOL * fBool
|
|
);
|
|
|
|
[propput]
|
|
HRESULT WriteCertToUserDS(
|
|
[in] BOOL fBool
|
|
);
|
|
|
|
[propget]
|
|
HRESULT EnableT61DNEncoding(
|
|
[out] BOOL * fBool
|
|
);
|
|
|
|
[propput]
|
|
HRESULT EnableT61DNEncoding(
|
|
[in] BOOL fBool
|
|
);
|
|
|
|
[propget]
|
|
HRESULT WriteCertToCSP(
|
|
[out] BOOL * fBool
|
|
);
|
|
|
|
[propput]
|
|
HRESULT WriteCertToCSP(
|
|
[in] BOOL fBool
|
|
);
|
|
|
|
[propget]
|
|
HRESULT SPCFileNameWStr(
|
|
[out] LPWSTR * szw
|
|
);
|
|
|
|
[propput]
|
|
HRESULT SPCFileNameWStr(
|
|
[in] LPWSTR szw
|
|
);
|
|
|
|
[propget]
|
|
HRESULT PVKFileNameWStr(
|
|
[out] LPWSTR * szw
|
|
);
|
|
|
|
[propput]
|
|
HRESULT PVKFileNameWStr(
|
|
[in] LPWSTR szw
|
|
);
|
|
|
|
[propget]
|
|
HRESULT HashAlgorithmWStr(
|
|
[out] LPWSTR * szw
|
|
);
|
|
|
|
[propput]
|
|
HRESULT HashAlgorithmWStr(
|
|
[in] LPWSTR szw
|
|
);
|
|
|
|
[propget]
|
|
HRESULT RenewalCertificate(
|
|
[out] PCCERT_CONTEXT * ppCertContext
|
|
);
|
|
|
|
[propput]
|
|
HRESULT RenewalCertificate(
|
|
[in] PCCERT_CONTEXT pCertContext
|
|
);
|
|
|
|
HRESULT AddCertTypeToRequestWStr(
|
|
[in] LPWSTR szw
|
|
);
|
|
|
|
HRESULT AddNameValuePairToSignatureWStr(
|
|
[in] LPWSTR Name,
|
|
[in] LPWSTR Value
|
|
);
|
|
|
|
HRESULT AddExtensionsToRequest(
|
|
[in] PCERT_EXTENSIONS pCertExtensions
|
|
);
|
|
|
|
HRESULT AddAuthenticatedAttributesToPKCS7Request(
|
|
[in] PCRYPT_ATTRIBUTES pAttributes
|
|
);
|
|
|
|
HRESULT CreatePKCS7RequestFromRequest(
|
|
[in] PCRYPT_DATA_BLOB pRequest,
|
|
[in] PCCERT_CONTEXT pSigningCertContext,
|
|
[out] PCRYPT_DATA_BLOB pPkcs7Blob
|
|
);
|
|
|
|
|
|
};
|
|
|
|
|
|
//+--------------------------------------------------------------------------
|
|
// interface IEnroll2
|
|
|
|
[
|
|
object,
|
|
uuid(c080e199-b7df-11d2-a421-00c04f79fe8e),
|
|
local,
|
|
helpstring("IEnroll2 Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IEnroll2 : IEnroll
|
|
{
|
|
|
|
HRESULT InstallPKCS7Blob(
|
|
[in] PCRYPT_DATA_BLOB pBlobPKCS7
|
|
);
|
|
|
|
HRESULT Reset(
|
|
void
|
|
);
|
|
|
|
HRESULT GetSupportedKeySpec(
|
|
[out] LONG * pdwKeySpec
|
|
);
|
|
|
|
HRESULT GetKeyLen(
|
|
[in] BOOL fMin,
|
|
[in] BOOL fExchange,
|
|
[out] LONG * pdwKeySize
|
|
);
|
|
|
|
HRESULT EnumAlgs(
|
|
[in] LONG dwIndex,
|
|
[in] LONG algClass,
|
|
[out] LONG * pdwAlgID
|
|
);
|
|
|
|
HRESULT GetAlgNameWStr(
|
|
[in] LONG algID,
|
|
[out] LPWSTR * ppwsz
|
|
);
|
|
|
|
[propput]
|
|
HRESULT ReuseHardwareKeyIfUnableToGenNew(
|
|
[in] BOOL fReuseHardwareKeyIfUnableToGenNew
|
|
);
|
|
|
|
[propget]
|
|
HRESULT ReuseHardwareKeyIfUnableToGenNew(
|
|
[out] BOOL * fReuseHardwareKeyIfUnableToGenNew
|
|
);
|
|
|
|
[propput]
|
|
HRESULT HashAlgID(
|
|
[in] LONG hashAlgID
|
|
);
|
|
|
|
[propget]
|
|
HRESULT HashAlgID(
|
|
[out, retval] LONG * hashAlgID
|
|
);
|
|
|
|
HRESULT SetHStoreMy(
|
|
[in] HCERTSTORE hStore
|
|
);
|
|
|
|
HRESULT SetHStoreCA(
|
|
[in] HCERTSTORE hStore
|
|
);
|
|
|
|
HRESULT SetHStoreROOT(
|
|
[in] HCERTSTORE hStore
|
|
);
|
|
|
|
HRESULT SetHStoreRequest(
|
|
[in] HCERTSTORE hStore
|
|
);
|
|
|
|
[propput]
|
|
HRESULT LimitExchangeKeyToEncipherment(
|
|
[in] BOOL fLimitExchangeKeyToEncipherment
|
|
);
|
|
|
|
[propget]
|
|
HRESULT LimitExchangeKeyToEncipherment(
|
|
[out, retval] BOOL * fLimitExchangeKeyToEncipherment
|
|
);
|
|
|
|
[propput]
|
|
HRESULT EnableSMIMECapabilities(
|
|
[in] BOOL fEnableSMIMECapabilities
|
|
);
|
|
|
|
[propget]
|
|
HRESULT EnableSMIMECapabilities(
|
|
[out, retval] BOOL * fEnableSMIMECapabilities
|
|
);
|
|
};
|
|
|
|
|
|
//+--------------------------------------------------------------------------
|
|
// interface IEnroll4
|
|
|
|
[
|
|
object,
|
|
uuid(f8053fe5-78f4-448f-a0db-41d61b73446b),
|
|
local,
|
|
helpstring("IEnroll4 Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IEnroll4 : IEnroll2
|
|
{
|
|
[propput]
|
|
HRESULT ThumbPrintWStr(
|
|
[in] CRYPT_DATA_BLOB thumbPrintBlob
|
|
);
|
|
|
|
[propget]
|
|
HRESULT ThumbPrintWStr(
|
|
[out, retval] PCRYPT_DATA_BLOB thumbPrintBlob
|
|
);
|
|
|
|
HRESULT SetPrivateKeyArchiveCertificate(
|
|
[in] PCCERT_CONTEXT pPrivateKeyArchiveCert
|
|
);
|
|
|
|
PCCERT_CONTEXT GetPrivateKeyArchiveCertificate(
|
|
void
|
|
);
|
|
|
|
HRESULT binaryBlobToString(
|
|
[in] LONG Flags,
|
|
[in] PCRYPT_DATA_BLOB pblobBinary,
|
|
[out] LPWSTR *ppwszString
|
|
);
|
|
|
|
HRESULT stringToBinaryBlob(
|
|
[in] LONG Flags,
|
|
[in] LPCWSTR pwszString,
|
|
[out] PCRYPT_DATA_BLOB pblobBinary,
|
|
[out] LONG *pdwSkip,
|
|
[out] LONG *pdwFlags
|
|
);
|
|
|
|
HRESULT addExtensionToRequestWStr(
|
|
[in] LONG Flags,
|
|
[in] LPCWSTR pwszName,
|
|
[in] PCRYPT_DATA_BLOB pblobValue
|
|
);
|
|
|
|
HRESULT addAttributeToRequestWStr(
|
|
[in] LONG Flags,
|
|
[in] LPCWSTR pwszName,
|
|
[in] PCRYPT_DATA_BLOB pblobValue
|
|
);
|
|
|
|
HRESULT addNameValuePairToRequestWStr(
|
|
[in] LONG Flags,
|
|
[in] LPCWSTR pwszName,
|
|
[in] LPCWSTR pwszValue
|
|
);
|
|
|
|
HRESULT resetExtensions(
|
|
void
|
|
);
|
|
|
|
HRESULT resetAttributes(
|
|
void
|
|
);
|
|
|
|
HRESULT createRequestWStr(
|
|
[in] LONG Flags,
|
|
[in] LPCWSTR pwszDNName,
|
|
[in] LPCWSTR pwszUsage,
|
|
[out] PCRYPT_DATA_BLOB pblobRequest
|
|
);
|
|
|
|
HRESULT createFileRequestWStr(
|
|
[in] LONG Flags,
|
|
[in] LPCWSTR pwszDNName,
|
|
[in] LPCWSTR pwszUsage,
|
|
[in] LPCWSTR pwszRequestFileName
|
|
);
|
|
|
|
HRESULT acceptResponseBlob(
|
|
[in] PCRYPT_DATA_BLOB pblobResponse
|
|
);
|
|
|
|
HRESULT acceptFileResponseWStr(
|
|
[in] LPCWSTR pwszResponseFileName
|
|
);
|
|
|
|
HRESULT getCertContextFromResponseBlob(
|
|
[in] PCRYPT_DATA_BLOB pblobResponse,
|
|
[out] PCCERT_CONTEXT *ppCertContext
|
|
);
|
|
|
|
HRESULT getCertContextFromFileResponseWStr(
|
|
[in] LPCWSTR pwszResponseFileName,
|
|
[out] PCCERT_CONTEXT *ppCertContext
|
|
);
|
|
|
|
HRESULT createPFXWStr(
|
|
[in] LPCWSTR pwszPassword,
|
|
[out] PCRYPT_DATA_BLOB pblobPFX
|
|
);
|
|
|
|
HRESULT createFilePFXWStr(
|
|
[in] LPCWSTR pwszPassword,
|
|
[in] LPCWSTR pwszPFXFileName
|
|
);
|
|
|
|
HRESULT setPendingRequestInfoWStr(
|
|
[in] LONG lRequestID,
|
|
[in] LPCWSTR pwszCADNS,
|
|
[in] LPCWSTR pwszCAName,
|
|
[in] LPCWSTR pwszFriendlyName
|
|
);
|
|
|
|
HRESULT enumPendingRequestWStr(
|
|
[in] LONG lIndex,
|
|
[in] LONG lDesiredProperty,
|
|
[out] LPVOID ppProperty
|
|
);
|
|
|
|
HRESULT removePendingRequestWStr(
|
|
[in] CRYPT_DATA_BLOB thumbPrintBlob
|
|
);
|
|
|
|
HRESULT GetKeyLenEx(
|
|
[in] LONG lSizeSpec,
|
|
[in] LONG lKeySpec,
|
|
[out, retval] LONG * pdwKeySize
|
|
);
|
|
|
|
HRESULT InstallPKCS7BlobEx(
|
|
[in] PCRYPT_DATA_BLOB pBlobPKCS7,
|
|
[out, retval] LONG * plCertInstalled
|
|
);
|
|
|
|
HRESULT AddCertTypeToRequestWStrEx(
|
|
[in] LONG lType,
|
|
[in] LPCWSTR pwszOIDOrName,
|
|
[in] LONG lMajorVersion,
|
|
[in] BOOL fMinorVersion,
|
|
[in] LONG lMinorVersion
|
|
);
|
|
|
|
HRESULT getProviderTypeWStr(
|
|
[in] LPCWSTR pwszProvName,
|
|
[out, retval] LONG * plProvType
|
|
);
|
|
|
|
HRESULT addBlobPropertyToCertificateWStr(
|
|
[in] LONG lPropertyId,
|
|
[in] LONG lReserved,
|
|
[in] PCRYPT_DATA_BLOB pBlobProperty
|
|
);
|
|
|
|
HRESULT SetSignerCertificate(
|
|
[in] PCCERT_CONTEXT pSignerCert
|
|
);
|
|
|
|
[propput]
|
|
HRESULT ClientId(
|
|
[in] LONG lClientId
|
|
);
|
|
|
|
[propget]
|
|
HRESULT ClientId(
|
|
[out, retval] LONG *plClientId
|
|
);
|
|
|
|
[propput]
|
|
HRESULT IncludeSubjectKeyID(
|
|
[in] BOOL fInclude
|
|
);
|
|
|
|
[propget]
|
|
HRESULT IncludeSubjectKeyID(
|
|
[out, retval] BOOL *pfInclude
|
|
);
|
|
|
|
};
|
|
|
|
//+--------------------------------------------------------------------------
|
|
// library XENROLLLib
|
|
|
|
[
|
|
uuid(5b9169c0-db65-42aa-a38a-0726846aaeb3),
|
|
version(1.0),
|
|
helpstring("xenroll 1.0 Type Library")
|
|
]
|
|
library XENROLLLib
|
|
{
|
|
importlib("stdole32.tlb");
|
|
importlib("stdole2.tlb");
|
|
|
|
[
|
|
uuid(127698e4-e730-4e5c-a2b1-21490a70c8a1),
|
|
helpstring("CEnroll Class")
|
|
]
|
|
coclass CEnroll2
|
|
{
|
|
[default] interface ICEnroll4;
|
|
};
|
|
|
|
[
|
|
uuid(43F8F289-7A20-11D0-8F06-00C04FC295E1),
|
|
helpstring("CEnroll Class")
|
|
]
|
|
coclass CEnroll
|
|
{
|
|
[default] interface ICEnroll4;
|
|
};
|
|
};
|
|
|
|
cpp_quote("extern \"C\" IEnroll * WINAPI PIEnrollGetNoCOM(void);")
|
|
cpp_quote("extern \"C\" IEnroll2 * WINAPI PIEnroll2GetNoCOM(void);")
|
|
cpp_quote("extern \"C\" IEnroll4 * WINAPI PIEnroll4GetNoCOM(void);")
|
|
|
|
cpp_quote("#define CRYPT_ENUM_ALL_PROVIDERS 0x1")
|
|
|
|
//enumPendingRequestInfo types
|
|
cpp_quote("#define XEPR_ENUM_FIRST -1")
|
|
cpp_quote("#define XEPR_CADNS 0x01")
|
|
cpp_quote("#define XEPR_CANAME 0x02")
|
|
cpp_quote("#define XEPR_CAFRIENDLYNAME 0x03")
|
|
cpp_quote("#define XEPR_REQUESTID 0x04")
|
|
cpp_quote("#define XEPR_DATE 0x05")
|
|
cpp_quote("#define XEPR_TEMPLATENAME 0x06")
|
|
cpp_quote("#define XEPR_VERSION 0x07")
|
|
cpp_quote("#define XEPR_HASH 0x08")
|
|
cpp_quote("#define XEPR_V1TEMPLATENAME 0x09")
|
|
cpp_quote("#define XEPR_V2TEMPLATEOID 0x10")
|
|
|
|
//createRequest types
|
|
cpp_quote("#define XECR_PKCS10_V2_0 0x1")
|
|
cpp_quote("#define XECR_PKCS7 0x2")
|
|
cpp_quote("#define XECR_CMC 0x3")
|
|
cpp_quote("#define XECR_PKCS10_V1_5 0x4")
|
|
|
|
//GetKeyLenEx lSizeSpec types
|
|
cpp_quote("#define XEKL_KEYSIZE_MIN 0x1")
|
|
cpp_quote("#define XEKL_KEYSIZE_MAX 0x2")
|
|
cpp_quote("#define XEKL_KEYSIZE_INC 0x3")
|
|
cpp_quote("#define XEKL_KEYSIZE_DEFAULT 0x4")
|
|
|
|
//GetKeyLenEx lKeySpec types
|
|
cpp_quote("#define XEKL_KEYSPEC_KEYX 0x1")
|
|
cpp_quote("#define XEKL_KEYSPEC_SIG 0x2")
|
|
|
|
//addCertTypeToRequestEx types
|
|
cpp_quote("#define XECT_EXTENSION_V1 0x1")
|
|
cpp_quote("#define XECT_EXTENSION_V2 0x2")
|
|
|
|
//addBlobPropertyToCertificate flags
|
|
cpp_quote("#define XECP_STRING_PROPERTY 0x1")
|
|
|
|
//ClientId property
|
|
cpp_quote("#define XECI_DISABLE 0x0")
|
|
cpp_quote("#define XECI_XENROLL 0x1")
|
|
cpp_quote("#define XECI_AUTOENROLL 0x2")
|
|
cpp_quote("#define XECI_REQWIZARD 0x3")
|
|
cpp_quote("#define XECI_CERTREQ 0x4")
|