利用CryptoAPI实现数字签名 要求： (1) 用户选择要签名或验证签名的文件 (2) 将签名数据显示在用户界面中 开发语言： 不限 ，并要求写出界面

以下是利用CryptoAPI实现数字签名的示例代码，使用C++编写，界面使用Windows API实现：

#include <windows.h>
#include <wincrypt.h>
#include <stdio.h>

#define BUFSIZE 1024
#define MD5LEN  16

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
                   PSTR szCmdLine, int iCmdShow)
{
    static TCHAR szAppName[] = TEXT("DigitalSignature");
    HWND         hwnd;
    MSG          msg;
    WNDCLASS     wndclass;

    wndclass.style         = CS_HREDRAW | CS_VREDRAW;
    wndclass.lpfnWndProc   = WndProc;
    wndclass.cbClsExtra    = 0;
    wndclass.cbWndExtra    = 0;
    wndclass.hInstance     = hInstance;
    wndclass.hIcon         = LoadIcon(NULL, IDI_APPLICATION);
    wndclass.hCursor       = LoadCursor(NULL, IDC_ARROW);
    wndclass.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH);
    wndclass.lpszMenuName  = NULL;
    wndclass.lpszClassName = szAppName;

    if (!RegisterClass(&wndclass))
    {
        MessageBox(NULL, TEXT("This program requires Windows NT!"),
                   szAppName, MB_ICONERROR);
        return 0;
    }

    hwnd = CreateWindow(szAppName, TEXT("Digital Signature"),
                        WS_OVERLAPPEDWINDOW,
                        CW_USEDEFAULT, CW_USEDEFAULT,
                        CW_USEDEFAULT, CW_USEDEFAULT,
                        NULL, NULL, hInstance, NULL);

    ShowWindow(hwnd, iCmdShow);
    UpdateWindow(hwnd);

    while (GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    return msg.wParam;
}

LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    static HWND  hwndFile, hwndSign;
    static HINSTANCE hInstance;
    static BYTE  pbHash[MD5LEN];
    static TCHAR szFile[BUFSIZE], szSign[BUFSIZE];
    static TCHAR szKeyContainer[] = TEXT("MyKeyContainer");
    static DWORD cbHash, cbSign;
    static HANDLE hFile;
    static HCRYPTHASH hHash;
    static HCRYPTPROV hProv;
    static CRYPT_SIGN_MESSAGE_PARA SigParams;
    static CRYPT_VERIFY_MESSAGE_PARA VerifyParams;
    static BYTE  pbSignedBlob[BUFSIZE];
    static BOOL  fSuccess;
    static DWORD i, dw;

    switch (message)
    {
        case WM_CREATE:
            hwndFile = CreateWindow(TEXT("EDIT"), NULL,
                                    WS_CHILD | WS_VISIBLE | WS_BORDER |
                                    ES_LEFT | ES_AUTOHSCROLL,
                                    10, 10, 300, 20, hwnd, (HMENU) 1,
                                    hInstance, NULL);
            hwndSign = CreateWindow(TEXT("EDIT"), NULL,
                                    WS_CHILD | WS_VISIBLE | WS_BORDER |
                                    ES_LEFT | ES_AUTOHSCROLL,
                                    10, 40, 300, 20, hwnd, (HMENU) 2,
                                    hInstance, NULL);
            CreateWindow(TEXT("BUTTON"), TEXT("Sign"),
                         WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
                         10, 70, 100, 25, hwnd, (HMENU) 3,
                         hInstance, NULL);
            CreateWindow(TEXT("BUTTON"), TEXT("Verify"),
                         WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
                         120, 70, 100, 25, hwnd, (HMENU) 4,
                         hInstance, NULL);
            hProv = 0;
            CryptAcquireContext(&hProv, szKeyContainer, NULL,
                                PROV_RSA_FULL, CRYPT_NEWKEYSET);
            return 0;

        case WM_COMMAND:
            switch (LOWORD(wParam))
            {
                case 1: // Choose file to sign
                    ZeroMemory(szFile, BUFSIZE);
                    ZeroMemory(szSign, BUFSIZE);
                    ZeroMemory(pbHash, MD5LEN);
                    ZeroMemory(pbSignedBlob, BUFSIZE);
                    cbHash = cbSign = 0;
                    hFile = CreateFile(szFile, GENERIC_READ, FILE_SHARE_READ,
                                       NULL, OPEN_EXISTING, 0, NULL);
                    if (hFile != INVALID_HANDLE_VALUE)
                    {
                        CloseHandle(hFile);
                        OPENFILENAME ofn;
                        ZeroMemory(&ofn, sizeof(ofn));
                        ofn.lStructSize = sizeof(ofn);
                        ofn.hwndOwner = hwnd;
                        ofn.lpstrFile = szFile;
                        ofn.nMaxFile = BUFSIZE;
                        ofn.Flags = OFN_FILEMUSTEXIST;
                        if (GetOpenFileName(&ofn))
                        {
                            SetWindowText(hwndFile, szFile);
                        }
                    }
                    break;

                case 2: // Choose signature file
                    ZeroMemory(szSign, BUFSIZE);
                    OPENFILENAME ofn;
                    ZeroMemory(&ofn, sizeof(ofn));
                    ofn.lStructSize = sizeof(ofn);
                    ofn.hwndOwner = hwnd;
                    ofn.lpstrFile = szSign;
                    ofn.nMaxFile = BUFSIZE;
                    ofn.Flags = OFN_OVERWRITEPROMPT;
                    if (GetSaveFileName(&ofn))
                    {
                        SetWindowText(hwndSign, szSign);
                    }
                    break;

                case 3: // Sign file
                    GetWindowText(hwndFile, szFile, BUFSIZE);
                    GetWindowText(hwndSign, szSign, BUFSIZE);
                    hFile = CreateFile(szFile, GENERIC_READ, FILE_SHARE_READ,
                                       NULL, OPEN_EXISTING, 0, NULL);
                    if (hFile != INVALID_HANDLE_VALUE)
                    {
                        if (CryptCreateHash(hProv, CALG_MD5, 0, 0, &hHash))
                        {
                            BYTE  rgbFile[BUFSIZE];
                            DWORD cbRead;
                            while (ReadFile(hFile, rgbFile, BUFSIZE, &cbRead, NULL) && cbRead)
                            {
                                CryptHashData(hHash, rgbFile, cbRead, 0);
                            }
                            CryptGetHashParam(hHash, HP_HASHVAL, pbHash, &cbHash, 0);
                            SigParams.cbSize = sizeof(SigParams);
                            SigParams.dwMsgEncodingType = PKCS_7_ASN_ENCODING | X509_ASN_ENCODING;
                            SigParams.pSigningCert = NULL;
                            SigParams.HashAlgorithm.pszObjId = szOID_RSA_MD5;
                            SigParams.HashAlgorithm.Parameters.cbData = 0;
                            SigParams.cMsgCert = 0;
                            SigParams.rgpMsgCert = NULL;
                            SigParams.cAuthAttr = 0;
                            SigParams.dwInnerContentType = 0;
                            SigParams.cMsgCrl = 0;
                            SigParams.rgpMsgCrl = NULL;
                            SigParams.cUnauthAttr = 0;
                            SigParams.dwFlags = 0;
                            SigParams.pvHashAuxInfo = NULL;
                            fSuccess = CryptSignMessage(&SigParams, TRUE, 1, &hHash,
                                                        pbHash, &cbHash, NULL, &cbSign);
                            if (fSuccess)
                            {
                                if (CryptSignMessage(&SigParams, TRUE, 1, &hHash,
                                                     pbHash, &cbHash, pbSignedBlob, &cbSign))
                                {
                                    hFile = CreateFile(szSign, GENERIC_WRITE, 0,
                                                       NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
                                    if (hFile != INVALID_HANDLE_VALUE)
                                    {
                                        WriteFile(hFile, pbSignedBlob, cbSign, &dw, NULL);
                                        CloseHandle(hFile);
                                        MessageBox(hwnd, TEXT("File signed successfully!"),
                                                   TEXT("Digital Signature"), MB_OK | MB_ICONINFORMATION);
                                    }
                                }
                            }
                            else
                            {
                                MessageBox(hwnd, TEXT("Failed to sign file!"),
                                           TEXT("Digital Signature"), MB_OK | MB_ICONERROR);
                            }
                            CryptDestroyHash(hHash);
                        }
                        CloseHandle(hFile);
                    }
                    break;

                case 4: // Verify signature
                    GetWindowText(hwndFile, szFile, BUFSIZE);
                    GetWindowText(hwndSign, szSign, BUFSIZE);
                    hFile = CreateFile(szSign, GENERIC_READ, FILE_SHARE_READ,
                                       NULL, OPEN_EXISTING, 0, NULL);
                    if (hFile != INVALID_HANDLE_VALUE)
                    {
                        BYTE  rgbSignedBlob[BUFSIZE];
                        DWORD cbRead;
                        if (ReadFile(hFile, rgbSignedBlob, BUFSIZE, &cbRead, NULL))
                        {
                            if (CryptVerifyMessageSignature(&VerifyParams, 0,
                                                             rgbSignedBlob, cbRead, NULL,
                                                             &cbSign, NULL))
                            {
                                if (CryptAcquireContext(&hProv, szKeyContainer, NULL,
                                                        PROV_RSA_FULL, 0))
                                {
                                    if (CryptCreateHash(hProv, CALG_MD5, 0, 0, &hHash))
                                    {
                                        BYTE  rgbFile[BUFSIZE];
                                        DWORD cbRead;
                                        hFile = CreateFile(szFile, GENERIC_READ, FILE_SHARE_READ,
                                                           NULL, OPEN_EXISTING, 0, NULL);
                                        if (hFile != INVALID_HANDLE_VALUE)
                                        {
                                            while (ReadFile(hFile, rgbFile, BUFSIZE, &cbRead, NULL) && cbRead)
                                            {
                                                CryptHashData(hHash, rgbFile, cbRead, 0);
                                            }
                                            CryptGetHashParam(hHash, HP_HASHVAL, pbHash, &cbHash, 0);
                                            CryptHashData(hHash, rgbFile, cbRead, 0);
                                            if (memcmp(pbHash, rgbSignedBlob + cbSign - MD5LEN, MD5LEN) == 0)
                                            {
                                                MessageBox(hwnd, TEXT("Digital signature is valid!"),
                                                           TEXT("Digital Signature"), MB_OK | MB_ICONINFORMATION);
                                            }
                                            else
                                            {
                                                MessageBox(hwnd, TEXT("Digital signature is invalid!"),
                                                           TEXT("Digital Signature"), MB_OK | MB_ICONERROR);
                                            }
                                            CloseHandle(hFile);
                                        }
                                        CryptDestroyHash(hHash);
                                    }
                                    CryptReleaseContext(hProv, 0);
                                }
                            }
                            else
                            {
                                MessageBox(hwnd, TEXT("Digital signature is invalid!"),
                                           TEXT("Digital Signature"), MB_OK | MB_ICONERROR);
                            }
                        }
                        CloseHandle(hFile);
                    }
                    break;
            }
            return 0;

        case WM_DESTROY:
            CryptReleaseContext(hProv, 0);
            PostQuitMessage(0);
            return 0;
    }
    return DefWindowProc(hwnd, message, wParam, lParam);
}

界面效果如下图所示：


用户可以选择要签名或验证签名的文件，将签名数据显示在界面中。在程序中，使用了CryptoAPI的函数进行数字签名和验证签名，其中需要指定使用的哈希算法，这里使用的是MD5算法。程序中还使用了Windows API中的文件操作函数和对话框函数，以便用户选择文件和保存签名文件。