csp插件的安装

港控/mmm° 2022-05-21 01:53 184阅读 0赞

转载自：https://blog.csdn.net/i\_can\_do\_1098/article/details/52671791

前两周，公司的某销售经理和另一个公司某高管一起拍脑袋提出来一个需求。这不是最尴尬的，最尴尬的是这群人一直没搞懂到底要实现个什么东西。   
需求不明确不说，要点资料客户还藏着掖着不给，tnn的，我不由得怀疑，项目经理除了把问题变得更复杂外还有个jb用?最后这群爷好不容易弄清楚   
要做一个csp插件。   
==================================背景分割线===============================   
吐槽到此结束，咱们说正题，就是这个csp（crypt service provider,， 加密服务提供者）。这是微软大哥给我们留出来的一个可自定义的插件，当然接口要按照规范来写。这个东西的资料啊我就不多说了，丢给各位一个地址[csp][]。   
我做的呢是基于智能卡的一个csp，这个东西可坑苦哥了，首先你要明白csp里面的基础机制（默认大家都看过介绍了）。

咱先不研究这玩意怎么写，先研究这玩意怎么用的。   
这里面有几个比较重要的注册表键：

> HKEY\_LOCAL\_MACHINE\\SOFTWARE\\Microsoft\\Cryptography\\Defaults\\Provider

这个根键就是用来记录加密服务提供者的， CryptEnumProviders 遍历的就是它的子项，我们添加和删除一个provider就操作这个键。   
每一个provider都有以下几个基本子键：   
Image Path：插件保存的路径   
SigInFile：签名文件 （On NT5, CSP images can carry their own signatures,也就是xp以上的系统都可以自己携带签名证书了，在远古版本里面，数字证书也要写在注册表里面，现在基本都写0）；   
Type：服务类型

> HKEY\_LOCAL\_MACHINE\\SOFTWARE\\Microsoft\\Cryptography\\Calais\\SmartCards

这个根键是用来记录用于加密服务的智能卡，智能卡的名称作为子项名，我们在这个下面添加自定义服务的硬件部分。   
80000001：用于卡片与系统交流的模块   
Crypto Provider: 所属的加密服务提供者，要一致   
Smart Card Key Store Provider： key存储提供者

后两个项很好理解，这个80000001我也有些疑惑，我打开系统中自带的模块，发现里面只有一个函数。   
上函数：   
`DWORD WINAPI CardAcquireContext(  __in PCARD_DATA pCardData,  __in DWORD dwFlags  ); `  
微软大哥的解释是这样的：   
The CardAcquireContext function, defined by a smart card module, initializes communication between the smart card module and either the Microsoft Base Smart Card Cryptographic Service Provider (CSP) or smart card key storage provider (KSP).

这个模块是用来微软和卡片交流用的，微软与智能卡打交道我知道的有两种方式：   
第一种就是直接怼，通过SCardConnect建立和读卡器的链接，然后通过SCardTransmit 与智能进行数据交流；   
第二种就是通过一些标准的APi，比如说CardReadFile，CardAcquireContext之类的，那这些API由谁来实现？当然是卡片提供商;

这个80000001项存储的就是智能卡操作标准api的实现模块。   
那有人说这个东西是必须的吗？我说未必，因为你可以实现这些个接口，然后系统可以调用，csp也可以调用，这是一举两得，你要是嫌弃麻烦也可以直接在csp里面实现，这都没毛病。

目前我涉及到的就是这两个键了。

以下代码来自微软cspdk，但是这玩意太tnn古老了，所以用的时候要修改一下。

：头文件

#include "stdafx.h"
    #include "wincrypt.h""
    #include <winscard.h>
    #include <tchar.h>
    #include "cspdk.h"

*  1
 *  2
 *  3
 *  4
 *  5

：重要变量

static HMODULE
    GetInstanceHandle(
        void);
    
    #ifdef SCARD_CSP
    
    //智能卡的名字
    static const TCHAR
        l_szCardName[]
            = TEXT("?vendor? <Add your Smart Card Friendly Name Here>");
    
    //私人提供者的guid
    static const GUID   // Optional
        l_guidPrimaryProv
        //?vendor? Add your Primary Provider GUID here 
            = { /* 00000000-0000-0000-0000-000000000000 */
                0x00000000,
                0x0000,
                0x0000,
                { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }
              };
    
    //智能卡ATR
    static const BYTE
        l_rgbATR[]     = { /* ?vendor? Add your ATR here */ 0x3b, 0x00 },
        l_rgbATRMask[] = { /* ?vendor? Add your ATR Mask here */ 0xff, 0xff };
    #endif
    
    //csp服务提供者的名字
    static const TCHAR
        l_szProviderName[]
            = TEXT("?vendor? <Add your Provider Name Here>");
    
    //服务类型
    static const DWORD
        l_dwCspType
    // ?vendor? Change this to match your CSP capabilities
            = PROV_RSA_FULL;
    
    typedef DWORD
    (*LPSETCARDTYPEPROVIDERNAME)(
       IN SCARDCONTEXT hContext,
       IN LPCTSTR szCardName,
       IN DWORD dwProviderId,
       IN LPCTSTR szProvider);

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28
 *  29
 *  30
 *  31
 *  32
 *  33
 *  34
 *  35
 *  36
 *  37
 *  38
 *  39
 *  40
 *  41
 *  42
 *  43
 *  44
 *  45

：卸载服务

/*++ DllUnregisterServer: This service removes the registry entries associated with this CSP. Arguments: None Return Value: Status code as an HRESULT. Author: Doug Barlow (dbarlow) 3/11/1998 --*/
    
    STDAPI
    DllUnregisterServer(
        void)
    {
        LONG nStatus;
        DWORD dwDisp;
        HRESULT hReturnStatus = NO_ERROR;
        HKEY hProviders = NULL;
        SCARDCONTEXT hCtx = NULL;
    
        //
        // Delete the Registry key for this CSP.
        //HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Cryptography\\Defaults\\Provider
        //这是加密服务提供者的注册表根键
        //
    
        nStatus = RegCreateKeyEx(
                        HKEY_LOCAL_MACHINE,
                        TEXT("SOFTWARE\\Microsoft\\Cryptography\\Defaults\\Provider"),
                        0,
                        TEXT(""),
                        REG_OPTION_NON_VOLATILE,
                        KEY_ALL_ACCESS,
                        NULL,
                        &hProviders,
                        &dwDisp);
        if (ERROR_SUCCESS == nStatus)
        {
            RegDeleteKey(hProviders, l_szProviderName);
            RegCloseKey(hProviders);
            hProviders = NULL;
        }
    
        //注销对应的智能卡
        hCtx = NULL;
        SCardEstablishContext(SCARD_SCOPE_SYSTEM, 0, 0, &hCtx);
        SCardForgetCardType(hCtx, l_szCardName);
        if (NULL != hCtx)
        {
            SCardReleaseContext(hCtx);
            hCtx = NULL;
        }
    
        return hReturnStatus;
    }

卸载服务还是很好理解的，就是删除个注册表而已，注销个卡片而已。

：注册服务

/*++ DllRegisterServer: This function installs the proper registry entries to enable this CSP. Arguments: None Return Value: Status code as an HRESULT. Author: Doug Barlow (dbarlow) 3/11/1998 --*/
    
    STDAPI
    DllRegisterServer(
        void)
    {
        TCHAR szModulePath[MAX_PATH];
        BYTE pbSignature[136];  // Room for a 1024 bit signature, with padding.
        OSVERSIONINFO osVer;
        LPTSTR szFileName, szFileExt;
        HINSTANCE hThisDll;
        HRSRC hSigResource;
        DWORD dwStatus;
        LONG nStatus;
        BOOL fStatus;
        DWORD dwDisp;
        DWORD dwIndex;
        DWORD dwSigLength;
        HRESULT hReturnStatus = NO_ERROR;
        HKEY hProviders = NULL;
        HKEY hMyCsp = NULL;
        HKEY hCalais = NULL;
        HKEY hVendor = NULL;
        BOOL fSignatureFound = FALSE;
        HANDLE hSigFile = INVALID_HANDLE_VALUE;
    #ifdef SCARD_CSP
        BOOL fCardIntroduced = FALSE;
        SCARDCONTEXT hCtx = NULL;
    #endif
    
    #ifdef _AFXDLL
        AFX_MANAGE_STATE(AfxGetStaticModuleState());
    #endif
    
    
        //
        // Figure out the file name and path.
        //
    
        hThisDll = GetInstanceHandle();
        if (NULL == hThisDll)
        {
            hReturnStatus = HRESULT_FROM_WIN32(ERROR_INVALID_HANDLE);
            goto ErrorExit;
        }
    
        dwStatus = GetModuleFileName(
                        hThisDll,
                        szModulePath,
                        sizeof(szModulePath) / sizeof(TCHAR));
        if (0 == dwStatus)
        {
            hReturnStatus = HRESULT_FROM_WIN32(GetLastError());
            goto ErrorExit;
        }
    
        szFileName = _tcsrchr(szModulePath, TEXT('\\'));
        if (NULL == szFileName)
            szFileName = szModulePath;
        else
            szFileName += 1;
        szFileExt = _tcsrchr(szFileName, TEXT('.'));
        if (NULL == szFileExt)
        {
            hReturnStatus = HRESULT_FROM_WIN32(ERROR_INVALID_NAME);
            goto ErrorExit;
        }
        else
            szFileExt += 1;
    
    
        //
        // Create the Registry key for this CSP.
        //
    
        nStatus = RegCreateKeyEx(
                        HKEY_LOCAL_MACHINE,
                        TEXT("SOFTWARE\\Microsoft\\Cryptography\\Defaults\\Provider"),
                        0,
                        TEXT(""),
                        REG_OPTION_NON_VOLATILE,
                        KEY_ALL_ACCESS,
                        NULL,
                        &hProviders,
                        &dwDisp);
        if (ERROR_SUCCESS != nStatus)
        {
            hReturnStatus = HRESULT_FROM_WIN32(nStatus);
            goto ErrorExit;
        }
        nStatus = RegCreateKeyEx(
                        hProviders,
                        l_szProviderName,
                        0,
                        TEXT(""),
                        REG_OPTION_NON_VOLATILE,
                        KEY_ALL_ACCESS,
                        NULL,
                        &hMyCsp,
                        &dwDisp);
        if (ERROR_SUCCESS != nStatus)
        {
            hReturnStatus = HRESULT_FROM_WIN32(nStatus);
            goto ErrorExit;
        }
        nStatus = RegCloseKey(hProviders);
        hProviders = NULL;
        if (ERROR_SUCCESS != nStatus)
        {
            hReturnStatus = HRESULT_FROM_WIN32(nStatus);
            goto ErrorExit;
        }
    
    
        //
        // Install the trivial registry values.
        //
    
        nStatus = RegSetValueEx(
                        hMyCsp,
                        TEXT("Image Path"),
                        0,
                        REG_SZ,
                        (LPBYTE)szModulePath,
                        (_tcslen(szModulePath) + 1) * sizeof(TCHAR));
        if (ERROR_SUCCESS != nStatus)
        {
            hReturnStatus = HRESULT_FROM_WIN32(nStatus);
            goto ErrorExit;
        }
    
        nStatus = RegSetValueEx(
                        hMyCsp,
                        TEXT("Type"),
                        0,
                        REG_DWORD,
                        (LPBYTE)&l_dwCspType,
                        sizeof(DWORD));
        if (ERROR_SUCCESS != nStatus)
        {
            hReturnStatus = HRESULT_FROM_WIN32(nStatus);
            goto ErrorExit;
        }
    
    
        //
        // See if we're self-signed. On NT5, CSP images can carry their own
        // signatures.
        //
    
        hSigResource = FindResource(
                            hThisDll,
                            MAKEINTRESOURCE(CRYPT_SIG_RESOURCE_NUMBER),
                            RT_RCDATA);
    
    
        //
        // Install the file signature.
        //
    
        ZeroMemory(&osVer, sizeof(OSVERSIONINFO));
        osVer.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
        fStatus = GetVersionEx(&osVer);
        // ?BUGBUG? -- This works on Windows Millenium, too.
        if (fStatus
            && (VER_PLATFORM_WIN32_NT == osVer.dwPlatformId)
            && (5 <= osVer.dwMajorVersion)
            && (NULL != hSigResource))
        {
    
            //
            // Signature in file flag is sufficient.
            //
    
            dwStatus = 0;
            nStatus = RegSetValueEx(
                            hMyCsp,
                            TEXT("SigInFile"),
                            0,
                            REG_DWORD,
                            (LPBYTE)&dwStatus,
                            sizeof(DWORD));
            if (ERROR_SUCCESS != nStatus)
            {
                hReturnStatus = HRESULT_FROM_WIN32(nStatus);
                goto ErrorExit;
            }
        }
        else
        {
    
            //
            // We have to install a signature entry.
            // Try various techniques until one works.
            //
    
            for (dwIndex = 0; !fSignatureFound; dwIndex += 1)
            {
                switch (dwIndex)
                {
    
                //
                // Look for an external *.sig file and load that into the registry.
                //
    
                case 0:
                    _tcscpy(szFileExt, TEXT("sig"));
                    hSigFile = CreateFile(
                                    szModulePath,
                                    GENERIC_READ,
                                    FILE_SHARE_READ,
                                    NULL,
                                    OPEN_EXISTING,
                                    FILE_ATTRIBUTE_NORMAL,
                                    NULL);
                    if (INVALID_HANDLE_VALUE == hSigFile)
                        continue;
                    dwSigLength = GetFileSize(hSigFile, NULL);
                    if ((dwSigLength > sizeof(pbSignature))
                        || (dwSigLength < 72))      // Accept a 512-bit signature
                    {
                        hReturnStatus = NTE_BAD_SIGNATURE;
                        goto ErrorExit;
                    }
    
                    fStatus = ReadFile(
                                    hSigFile,
                                    pbSignature,
                                    sizeof(pbSignature),
                                    &dwSigLength,
                                    NULL);
                    if (!fStatus)
                    {
                        hReturnStatus = HRESULT_FROM_WIN32(GetLastError());
                        goto ErrorExit;
                    }
                    fStatus = CloseHandle(hSigFile);
                    hSigFile = NULL;
                    if (!fStatus)
                    {
                        hReturnStatus = HRESULT_FROM_WIN32(GetLastError());
                        goto ErrorExit;
                    }
                    fSignatureFound = TRUE;
                    break;
    
    
                //
                // Other cases may be added in the future.
                //
    
                default:
                    hReturnStatus = NTE_BAD_SIGNATURE;
                    goto ErrorExit;
                }
    
                if (fSignatureFound)
                {
                    for (dwIndex = 0; dwIndex < dwSigLength; dwIndex += 1)
                    {
                        if (0 != pbSignature[dwIndex])
                            break;
                    }
                    if (dwIndex >= dwSigLength)
                        fSignatureFound = FALSE;
                }
            }
    
    
            //
            // We've found a signature somewhere! Install it.
            //
    
            nStatus = RegSetValueEx(
                            hMyCsp,
                            TEXT("Signature"),
                            0,
                            REG_BINARY,
                            pbSignature,
                            dwSigLength);
            if (ERROR_SUCCESS != nStatus)
            {
                hReturnStatus = HRESULT_FROM_WIN32(nStatus);
                goto ErrorExit;
            }
        }
    
        nStatus = RegCloseKey(hMyCsp);
        hMyCsp = NULL;
        if (ERROR_SUCCESS != nStatus)
        {
            hReturnStatus = HRESULT_FROM_WIN32(nStatus);
            goto ErrorExit;
        }
    
    
    #ifdef SCARD_CSP
        //
        // Introduce the vendor card. Try various techniques until one works.
        //
    
        for (dwIndex = 0; !fCardIntroduced; dwIndex += 1)
        {
            switch (dwIndex)
            {
            case 0:
                {
                    HMODULE hWinSCard = NULL;
                    LPSETCARDTYPEPROVIDERNAME pfSetCardTypeProviderName = NULL;
    
                    hWinSCard = GetModuleHandle(TEXT("WinSCard.DLL"));
                    if (NULL == hWinSCard)
                        continue;
    #if defined(UNICODE)
                    pfSetCardTypeProviderName =
                        (LPSETCARDTYPEPROVIDERNAME)GetProcAddress(
                            hWinSCard,
                            TEXT("SCardSetCardTypeProviderNameW"));
    #else
                    pfSetCardTypeProviderName =
                        (LPSETCARDTYPEPROVIDERNAME)GetProcAddress(
                            hWinSCard,
                            TEXT("SCardSetCardTypeProviderNameA"));
    #endif
                    if (NULL == pfSetCardTypeProviderName)
                        continue;
    
                    dwStatus = SCardIntroduceCardType(
                                    NULL,
                                    l_szCardName,
                                    NULL,
                                    NULL,
                                    0,
                                    l_rgbATR,
                                    l_rgbATRMask,
                                    sizeof(l_rgbATR));
                    if ((ERROR_SUCCESS != dwStatus)
                        && (ERROR_ALREADY_EXISTS != dwStatus))
                        continue;
                    dwStatus = (*pfSetCardTypeProviderName)(
                                    NULL,
                                    l_szCardName,
                                    SCARD_PROVIDER_CSP,
                                    l_szProviderName);
                    if (ERROR_SUCCESS != dwStatus)
                    {
                        if (0 == (dwStatus & 0xffff0000))
                            hReturnStatus = HRESULT_FROM_WIN32(dwStatus);
                        else
                            hReturnStatus = (HRESULT)dwStatus;
                        goto ErrorExit;
                    }
                    fCardIntroduced = TRUE;
                    break;
                }
    
            case 1:
                dwStatus = SCardEstablishContext(SCARD_SCOPE_SYSTEM, 0, 0, &hCtx);
                if (ERROR_SUCCESS != dwStatus)
                    continue;
                dwStatus = SCardIntroduceCardType(
                                hCtx,
                                l_szCardName,
                                NULL,
                                NULL,
                                0,
                                l_rgbATR,
                                l_rgbATRMask,
                                sizeof(l_rgbATR));
                if ((ERROR_SUCCESS != dwStatus)
                    && (ERROR_ALREADY_EXISTS != dwStatus))
                {
                    if (0 == (dwStatus & 0xffff0000))
                        hReturnStatus = HRESULT_FROM_WIN32(dwStatus);
                    else
                        hReturnStatus = (HRESULT)dwStatus;
                    goto ErrorExit;
                }
                dwStatus = SCardReleaseContext(hCtx);
                hCtx = NULL;
                if (ERROR_SUCCESS != dwStatus)
                {
                    if (0 == (dwStatus & 0xffff0000))
                        hReturnStatus = HRESULT_FROM_WIN32(dwStatus);
                    else
                        hReturnStatus = (HRESULT)dwStatus;
                    goto ErrorExit;
                }
                nStatus = RegCreateKeyEx(
                                HKEY_LOCAL_MACHINE,
                                TEXT("SOFTWARE\\Microsoft\\Cryptography\\Calais\\SmartCards"),
                                0,
                                TEXT(""),
                                REG_OPTION_NON_VOLATILE,
                                KEY_ALL_ACCESS,
                                NULL,
                                &hCalais,
                                &dwDisp);
                if (ERROR_SUCCESS != nStatus)
                {
                    hReturnStatus = HRESULT_FROM_WIN32(nStatus);
                    goto ErrorExit;
                }
                nStatus = RegCreateKeyEx(
                                hCalais,
                                l_szCardName,
                                0,
                                TEXT(""),
                                REG_OPTION_NON_VOLATILE,
                                KEY_ALL_ACCESS,
                                NULL,
                                &hVendor,
                                &dwDisp);
                if (ERROR_SUCCESS != nStatus)
                {
                    hReturnStatus = HRESULT_FROM_WIN32(nStatus);
                    goto ErrorExit;
                }
                nStatus = RegCloseKey(hCalais);
                hCalais = NULL;
                if (ERROR_SUCCESS != nStatus)
                {
                    hReturnStatus = HRESULT_FROM_WIN32(nStatus);
                    goto ErrorExit;
                }
                nStatus = RegSetValueEx(
                                hVendor,
                                TEXT("Crypto Provider"),
                                0,
                                REG_SZ,
                                (LPBYTE)l_szProviderName,
                                (_tcslen(l_szProviderName) + 1) * sizeof(TCHAR));
                if (ERROR_SUCCESS != nStatus)
                {
                    hReturnStatus = HRESULT_FROM_WIN32(nStatus);
                    goto ErrorExit;
                }
    
                nStatus = RegCloseKey(hVendor);
                hVendor = NULL;
                if (ERROR_SUCCESS != nStatus)
                {
                    hReturnStatus = HRESULT_FROM_WIN32(nStatus);
                    goto ErrorExit;
                }
    
                fCardIntroduced = TRUE;
                break;
    
            case 2:
                nStatus = RegCreateKeyEx(
                                HKEY_LOCAL_MACHINE,
                                TEXT("SOFTWARE\\Microsoft\\Cryptography\\Calais\\SmartCards"),
                                0,
                                TEXT(""),
                                REG_OPTION_NON_VOLATILE,
                                KEY_ALL_ACCESS,
                                NULL,
                                &hCalais,
                                &dwDisp);
                if (ERROR_SUCCESS != nStatus)
                    continue;
                nStatus = RegCreateKeyEx(
                                hCalais,
                                l_szCardName,
                                0,
                                TEXT(""),
                                REG_OPTION_NON_VOLATILE,
                                KEY_ALL_ACCESS,
                                NULL,
                                &hVendor,
                                &dwDisp);
                if (ERROR_SUCCESS != nStatus)
                {
                    hReturnStatus = HRESULT_FROM_WIN32(nStatus);
                    goto ErrorExit;
                }
                nStatus = RegCloseKey(hCalais);
                hCalais = NULL;
                if (ERROR_SUCCESS != nStatus)
                {
                    hReturnStatus = HRESULT_FROM_WIN32(nStatus);
                    goto ErrorExit;
                }
                nStatus = RegSetValueEx(
                                hVendor,
                                TEXT("Primary Provider"),
                                0,
                                REG_BINARY,
                                (LPCBYTE)&l_guidPrimaryProv,
                                sizeof(l_guidPrimaryProv));
                if (ERROR_SUCCESS != nStatus)
                {
                    hReturnStatus = HRESULT_FROM_WIN32(nStatus);
                    goto ErrorExit;
                }
                nStatus = RegSetValueEx(
                                hVendor,
                                TEXT("ATR"),
                                0,
                                REG_BINARY,
                                l_rgbATR,
                                sizeof(l_rgbATR));
                if (ERROR_SUCCESS != nStatus)
                {
                    hReturnStatus = HRESULT_FROM_WIN32(nStatus);
                    goto ErrorExit;
                }
                nStatus = RegSetValueEx(
                                hVendor,
                                TEXT("ATRMask"),
                                0,
                                REG_BINARY,
                                l_rgbATRMask,
                                sizeof(l_rgbATRMask));
                if (ERROR_SUCCESS != nStatus)
                {
                    hReturnStatus = HRESULT_FROM_WIN32(nStatus);
                    goto ErrorExit;
                }
                nStatus = RegSetValueEx(
                                hVendor,
                                TEXT("Crypto Provider"),
                                0,
                                REG_SZ,
                                (LPBYTE)l_szProviderName,
                                (_tcslen(l_szProviderName) + 1) * sizeof(TCHAR));
                if (ERROR_SUCCESS != nStatus)
                {
                    hReturnStatus = HRESULT_FROM_WIN32(nStatus);
                    goto ErrorExit;
                }
                nStatus = RegCloseKey(hVendor);
                hVendor = NULL;
                if (ERROR_SUCCESS != nStatus)
                {
                    hReturnStatus = HRESULT_FROM_WIN32(nStatus);
                    goto ErrorExit;
                }
                fCardIntroduced = TRUE;
                break;
    
            default:
                hReturnStatus = ERROR_ACCESS_DENIED;
                goto ErrorExit;
            }
        }
    #endif
    
    
        //
        // ?vendor?
        // Add any additional initialization required here.
        //
    
    
    
        //
        // All done!
        //
    
        return hReturnStatus;
    
    
        //
        // An error was detected. Clean up any outstanding resources and
        // return the error.
        //
    
        ErrorExit:
    #ifdef SCARD_CSP
        if (NULL != hCtx)
            SCardReleaseContext(hCtx);
        if (NULL != hCalais)
            RegCloseKey(hCalais);
    #endif
        if (NULL != hVendor)
            RegCloseKey(hVendor);
        if (INVALID_HANDLE_VALUE != hSigFile)
            CloseHandle(hSigFile);
        if (NULL != hMyCsp)
            RegCloseKey(hMyCsp);
        if (NULL != hProviders)
            RegCloseKey(hProviders);
        DllUnregisterServer();
        return hReturnStatus;
    }
    
    
    /*++ GetInstanceHandle: This routine is CSP dependant. It returns the DLL instance handle. This is typically provided by the DllMain routine and stored in a global location. Arguments: None Return Value: The DLL Instance handle provided to the DLL when DllMain was called. Author: Doug Barlow (dbarlow) 3/11/1998 --*/
    
    extern "C" HINSTANCE g_hModule;
    
    static HINSTANCE
    GetInstanceHandle(
        void)
    {
    #ifdef _AFXDLL
        return AfxGetInstanceHandle();
    #else
        // ?vendor?
        // Make sure this returns your DLL instance handle.
        return g_hModule;
    #endif
    }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28
 *  29
 *  30
 *  31
 *  32
 *  33
 *  34
 *  35
 *  36
 *  37
 *  38
 *  39
 *  40
 *  41
 *  42
 *  43
 *  44
 *  45
 *  46
 *  47
 *  48
 *  49
 *  50
 *  51
 *  52
 *  53
 *  54
 *  55
 *  56
 *  57
 *  58
 *  59
 *  60
 *  61
 *  62
 *  63
 *  64
 *  65
 *  66
 *  67
 *  68
 *  69
 *  70
 *  71
 *  72
 *  73
 *  74
 *  75
 *  76
 *  77
 *  78
 *  79
 *  80
 *  81
 *  82
 *  83
 *  84
 *  85
 *  86
 *  87
 *  88
 *  89
 *  90
 *  91
 *  92
 *  93
 *  94
 *  95
 *  96
 *  97
 *  98
 *  99
 *  100
 *  101
 *  102
 *  103
 *  104
 *  105
 *  106
 *  107
 *  108
 *  109
 *  110
 *  111
 *  112
 *  113
 *  114
 *  115
 *  116
 *  117
 *  118
 *  119
 *  120
 *  121
 *  122
 *  123
 *  124
 *  125
 *  126
 *  127
 *  128
 *  129
 *  130
 *  131
 *  132
 *  133
 *  134
 *  135
 *  136
 *  137
 *  138
 *  139
 *  140
 *  141
 *  142
 *  143
 *  144
 *  145
 *  146
 *  147
 *  148
 *  149
 *  150
 *  151
 *  152
 *  153
 *  154
 *  155
 *  156
 *  157
 *  158
 *  159
 *  160
 *  161
 *  162
 *  163
 *  164
 *  165
 *  166
 *  167
 *  168
 *  169
 *  170
 *  171
 *  172
 *  173
 *  174
 *  175
 *  176
 *  177
 *  178
 *  179
 *  180
 *  181
 *  182
 *  183
 *  184
 *  185
 *  186
 *  187
 *  188
 *  189
 *  190
 *  191
 *  192
 *  193
 *  194
 *  195
 *  196
 *  197
 *  198
 *  199
 *  200
 *  201
 *  202
 *  203
 *  204
 *  205
 *  206
 *  207
 *  208
 *  209
 *  210
 *  211
 *  212
 *  213
 *  214
 *  215
 *  216
 *  217
 *  218
 *  219
 *  220
 *  221
 *  222
 *  223
 *  224
 *  225
 *  226
 *  227
 *  228
 *  229
 *  230
 *  231
 *  232
 *  233
 *  234
 *  235
 *  236
 *  237
 *  238
 *  239
 *  240
 *  241
 *  242
 *  243
 *  244
 *  245
 *  246
 *  247
 *  248
 *  249
 *  250
 *  251
 *  252
 *  253
 *  254
 *  255
 *  256
 *  257
 *  258
 *  259
 *  260
 *  261
 *  262
 *  263
 *  264
 *  265
 *  266
 *  267
 *  268
 *  269
 *  270
 *  271
 *  272
 *  273
 *  274
 *  275
 *  276
 *  277
 *  278
 *  279
 *  280
 *  281
 *  282
 *  283
 *  284
 *  285
 *  286
 *  287
 *  288
 *  289
 *  290
 *  291
 *  292
 *  293
 *  294
 *  295
 *  296
 *  297
 *  298
 *  299
 *  300
 *  301
 *  302
 *  303
 *  304
 *  305
 *  306
 *  307
 *  308
 *  309
 *  310
 *  311
 *  312
 *  313
 *  314
 *  315
 *  316
 *  317
 *  318
 *  319
 *  320
 *  321
 *  322
 *  323
 *  324
 *  325
 *  326
 *  327
 *  328
 *  329
 *  330
 *  331
 *  332
 *  333
 *  334
 *  335
 *  336
 *  337
 *  338
 *  339
 *  340
 *  341
 *  342
 *  343
 *  344
 *  345
 *  346
 *  347
 *  348
 *  349
 *  350
 *  351
 *  352
 *  353
 *  354
 *  355
 *  356
 *  357
 *  358
 *  359
 *  360
 *  361
 *  362
 *  363
 *  364
 *  365
 *  366
 *  367
 *  368
 *  369
 *  370
 *  371
 *  372
 *  373
 *  374
 *  375
 *  376
 *  377
 *  378
 *  379
 *  380
 *  381
 *  382
 *  383
 *  384
 *  385
 *  386
 *  387
 *  388
 *  389
 *  390
 *  391
 *  392
 *  393
 *  394
 *  395
 *  396
 *  397
 *  398
 *  399
 *  400
 *  401
 *  402
 *  403
 *  404
 *  405
 *  406
 *  407
 *  408
 *  409
 *  410
 *  411
 *  412
 *  413
 *  414
 *  415
 *  416
 *  417
 *  418
 *  419
 *  420
 *  421
 *  422
 *  423
 *  424
 *  425
 *  426
 *  427
 *  428
 *  429
 *  430
 *  431
 *  432
 *  433
 *  434
 *  435
 *  436
 *  437
 *  438
 *  439
 *  440
 *  441
 *  442
 *  443
 *  444
 *  445
 *  446
 *  447
 *  448
 *  449
 *  450
 *  451
 *  452
 *  453
 *  454
 *  455
 *  456
 *  457
 *  458
 *  459
 *  460
 *  461
 *  462
 *  463
 *  464
 *  465
 *  466
 *  467
 *  468
 *  469
 *  470
 *  471
 *  472
 *  473
 *  474
 *  475
 *  476
 *  477
 *  478
 *  479
 *  480
 *  481
 *  482
 *  483
 *  484
 *  485
 *  486
 *  487
 *  488
 *  489
 *  490
 *  491
 *  492
 *  493
 *  494
 *  495
 *  496
 *  497
 *  498
 *  499
 *  500
 *  501
 *  502
 *  503
 *  504
 *  505
 *  506
 *  507
 *  508
 *  509
 *  510
 *  511
 *  512
 *  513
 *  514
 *  515
 *  516
 *  517
 *  518
 *  519
 *  520
 *  521
 *  522
 *  523
 *  524
 *  525
 *  526
 *  527
 *  528
 *  529
 *  530
 *  531
 *  532
 *  533
 *  534
 *  535
 *  536
 *  537
 *  538
 *  539
 *  540
 *  541
 *  542
 *  543
 *  544
 *  545
 *  546
 *  547
 *  548
 *  549
 *  550
 *  551
 *  552
 *  553
 *  554
 *  555
 *  556
 *  557
 *  558
 *  559
 *  560
 *  561
 *  562
 *  563
 *  564
 *  565
 *  566
 *  567
 *  568
 *  569
 *  570
 *  571
 *  572
 *  573
 *  574
 *  575
 *  576
 *  577
 *  578
 *  579
 *  580
 *  581
 *  582
 *  583
 *  584
 *  585
 *  586
 *  587
 *  588
 *  589
 *  590
 *  591
 *  592
 *  593
 *  594
 *  595
 *  596
 *  597
 *  598
 *  599
 *  600
 *  601
 *  602
 *  603
 *  604
 *  605
 *  606
 *  607
 *  608
 *  609
 *  610
 *  611
 *  612
 *  613
 *  614
 *  615
 *  616
 *  617
 *  618
 *  619
 *  620
 *  621
 *  622
 *  623
 *  624
 *  625
 *  626
 *  627
 *  628
 *  629
 *  630
 *  631
 *  632
 *  633
 *  634
 *  635
 *  636
 *  637
 *  638
 *  639
 *  640
 *  641
 *  642
 *  643
 *  644
 *  645

最后再说两句，csp开发有一个很操蛋的地方，每编译一次就要重新签一次名，所以很操蛋，你不签名调用的时候会报错（签名无效）。这里我要吐槽一下微软大哥了，他给的那个cspdk是2003年的示例，调试的环境是win2000，我tm就无语了。这里只是讲了一下安装，开发后续会讲，而且很繁琐。

[csp]: http://blog.csdn.net/liuhuiyi/article/details/7778742