trunk/OpenPGPminidriverTest/main.cpp

/*      OpenPGP Smart Card Mini Driver
    Copyright (C) 2009 Vincent Le Toux

    This library is Free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License version 2.1 as published by the Free Software Foundation.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include <windows.h>
#include <tchar.h>
#include <cardmod.h>
#include <commctrl.h>
#include <Cryptuiapi.h>
#include "dialog.h"
#include "global.h"

#pragma comment(lib,"comctl32")

#ifdef UNICODE
#if defined _M_IX86
#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='x86' publicKeyToken='6595b64144ccf1df' language='*'\"")
#elif defined _M_IA64
#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='ia64' publicKeyToken='6595b64144ccf1df' language='*'\"")
#elif defined _M_X64
#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='amd64' publicKeyToken='6595b64144ccf1df' language='*'\"")
#else
#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"")
#endif
#endif

// Variables globales :
HINSTANCE g_hinst;                                                              // instance actuelle

INT_PTR CALLBACK        WndProcConnect(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK        WndProcPin(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK        WndProcFile(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK        WndProcCrypto(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK        WndProcCryptoApi(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK        WndProcEnroll(HWND, UINT, WPARAM, LPARAM);

int APIENTRY _tWinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPTSTR    lpCmdLine,
                     int       nCmdShow)
{
        UNREFERENCED_PARAMETER(hPrevInstance);
        UNREFERENCED_PARAMETER(lpCmdLine);
        g_hinst = hInstance;
    PROPSHEETPAGE psp[6];
    PROPSHEETHEADER psh;
    psp[0].dwSize = sizeof(PROPSHEETPAGE);
    psp[0].dwFlags = PSP_USETITLE;
    psp[0].hInstance = g_hinst;
    psp[0].pszTemplate = MAKEINTRESOURCE(IDD_CONNECT);
    psp[0].pszIcon = NULL;
    psp[0].pfnDlgProc = WndProcConnect;
    psp[0].pszTitle = TEXT("Connect");
    psp[0].lParam = 0;
    psp[0].pfnCallback = NULL;
    psp[1].dwSize = sizeof(PROPSHEETPAGE);
    psp[1].dwFlags = PSP_USETITLE;
    psp[1].hInstance = g_hinst;
    psp[1].pszTemplate = MAKEINTRESOURCE(IDD_PIN);
    psp[1].pszIcon = NULL;
    psp[1].pfnDlgProc = WndProcPin;
    psp[1].pszTitle = TEXT("Pin");
    psp[1].lParam = 0;
    psp[2].pfnCallback = NULL;
        psp[2].dwSize = sizeof(PROPSHEETPAGE);
    psp[2].dwFlags = PSP_USETITLE;
    psp[2].hInstance = g_hinst;
    psp[2].pszTemplate = MAKEINTRESOURCE(IDD_FILE);
    psp[2].pszIcon = NULL;
    psp[2].pfnDlgProc = WndProcFile;
    psp[2].pszTitle = TEXT("File");
    psp[2].lParam = 0;
    psp[2].pfnCallback = NULL;
        psp[3].dwSize = sizeof(PROPSHEETPAGE);
    psp[3].dwFlags = PSP_USETITLE;
    psp[3].hInstance = g_hinst;
    psp[3].pszTemplate = MAKEINTRESOURCE(IDD_CRYPTO);
    psp[3].pszIcon = NULL;
    psp[3].pfnDlgProc = WndProcCrypto;
    psp[3].pszTitle = TEXT("Crypto");
    psp[3].lParam = 0;
    psp[3].pfnCallback = NULL;
        psp[4].dwSize = sizeof(PROPSHEETPAGE);
    psp[4].dwFlags = PSP_USETITLE;
    psp[4].hInstance = g_hinst;
    psp[4].pszTemplate = MAKEINTRESOURCE(IDD_CRYPTOAPI);
    psp[4].pszIcon = NULL;
    psp[4].pfnDlgProc = WndProcCryptoApi;
    psp[4].pszTitle = TEXT("CryptoApi");
    psp[4].lParam = 0;
    psp[4].pfnCallback = NULL;
        psp[5].dwSize = sizeof(PROPSHEETPAGE);
    psp[5].dwFlags = PSP_USETITLE;
    psp[5].hInstance = g_hinst;
    psp[5].pszTemplate = MAKEINTRESOURCE(IDD_ENROLL);
    psp[5].pszIcon = NULL;
    psp[5].pfnDlgProc = WndProcEnroll;
    psp[5].pszTitle = TEXT("Enroll");
    psp[5].lParam = 0;
    psp[5].pfnCallback = NULL;
    psh.dwSize = sizeof(PROPSHEETHEADER);
    psh.dwFlags = PSH_USEICONID | PSH_PROPSHEETPAGE;
    psh.hwndParent = NULL;
    psh.hInstance = g_hinst;
    psh.pszIcon =NULL;
    psh.pszCaption = TEXT("Test");
    psh.nPages = ARRAYSIZE(psp);
    psh.nStartPage = 0;
    psh.ppsp = (LPCPROPSHEETPAGE) &psp;
    psh.pfnCallback = NULL;
    PropertySheet(&psh);
    return 0;

}

void MessageBoxWin32(DWORD status) {
        LPVOID Error;
        FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
                NULL,status,0,(LPTSTR)&Error,0,NULL);
        MessageBox(NULL,(LPCTSTR)Error,NULL,MB_ICONASTERISK);
        LocalFree(Error);
}


void ViewCertificate(HWND hWnd, PCCERT_CONTEXT pCertContext)
{
        CRYPTUI_VIEWCERTIFICATE_STRUCT certViewInfo;
        BOOL fPropertiesChanged = FALSE;
        certViewInfo.dwSize = sizeof(CRYPTUI_VIEWCERTIFICATE_STRUCT);
        certViewInfo.hwndParent = hWnd;
        certViewInfo.dwFlags = CRYPTUI_DISABLE_EDITPROPERTIES | CRYPTUI_DISABLE_ADDTOSTORE | CRYPTUI_DISABLE_EXPORT | CRYPTUI_DISABLE_HTMLLINK;
        certViewInfo.szTitle = TEXT("Info");
        certViewInfo.pCertContext = pCertContext;
        certViewInfo.cPurposes = 0;
        certViewInfo.rgszPurposes = 0;
        certViewInfo.pCryptProviderData = NULL;
        certViewInfo.hWVTStateData = NULL;
        certViewInfo.fpCryptProviderDataTrustedUsage = FALSE;
        certViewInfo.idxSigner = 0;
        certViewInfo.idxCert = 0;
        certViewInfo.fCounterSigner = FALSE;
        certViewInfo.idxCounterSigner = 0;
        certViewInfo.cStores = 0;
        certViewInfo.rghStores = NULL;
        certViewInfo.cPropSheetPages = 0;
        certViewInfo.rgPropSheetPages = NULL;
        certViewInfo.nStartPage = 0;
        
        CryptUIDlgViewCertificate(&certViewInfo,&fPropertiesChanged);
}

#define C_PAGES 5
 
typedef struct tag_dlghdr { 
    HWND hwndTab;       // tab control 
    HWND hwndDisplay;   // current child dialog box 
    RECT rcDisplay;     // display rectangle for the tab control 
    DLGTEMPLATE *apRes[C_PAGES]; 
        DLGPROC pDialogFunc[C_PAGES];
} DLGHDR; 


BOOL GetContainerName(HWND hWnd, PWSTR szContainer, PDWORD pdwKeySpec)
{
        DWORD iItem = (DWORD)SendMessage(GetDlgItem(hWnd, IDC_LSTCONTAINER),LB_GETCURSEL,0,0);
        if (iItem == LB_ERR) return FALSE;
        SendMessage( GetDlgItem(hWnd,IDC_LSTCONTAINER), LB_GETTEXT,iItem,(LPARAM)szContainer);
        *pdwKeySpec = _tstoi(szContainer + _tcslen(szContainer) - 1);
        szContainer[ _tcslen(szContainer) - 2] = 0;
        return TRUE;
}

 
INT_PTR CALLBACK WndProcConnect(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
        int wmId, wmEvent;
        DWORD dwReturn;
        switch (message)
        {
        case WM_INITDIALOG:
                CheckDlgButton(hWnd,IDC_CurrentDll,BST_CHECKED);
                break;
        case WM_COMMAND:
                wmId    = LOWORD(wParam);
                wmEvent = HIWORD(wParam);
                
                switch (wmId)
                {
                        case IDC_CONNECT:
                        if (IsDlgButtonChecked(hWnd,IDC_SystemDll))
                        {
                                dwReturn = Connect(TRUE);
                        }
                        else
                        {
                                dwReturn = Connect(FALSE);
                        }
                        if (dwReturn)
                        {
                                MessageBoxWin32(dwReturn);
                        }
                        break;
                        case IDC_DISCONNECT:
                                dwReturn = Disconnect();
                                if (dwReturn)
                                {
                                        MessageBoxWin32(dwReturn);
                                }
                                break;
                }
                break;
        }
        return FALSE;
}

INT_PTR CALLBACK WndProcPin(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
        int wmId, wmEvent;
        DWORD dwReturn;
        CHAR szPin[256];
        CHAR szPin2[256];
        DWORD dwRemaining;
        switch (message)
        {
        case WM_INITDIALOG:
                CheckDlgButton(hWnd,IDC_PINUSER,BST_CHECKED);
                SendMessage( GetDlgItem(hWnd, IDC_TXTPIN), WM_SETTEXT,0,(LPARAM) TEXT("123456"));
                break;
        case WM_COMMAND:
                wmId    = LOWORD(wParam);
                wmEvent = HIWORD(wParam);
                
                switch (wmId)
                {
                        case IDC_PINUSER:
                                SendMessage( GetDlgItem(hWnd, IDC_TXTPIN), WM_SETTEXT,0,(LPARAM) TEXT("123456"));
                        break;
                        case IDC_PINADMIN:
                                SendMessage( GetDlgItem(hWnd, IDC_TXTPIN), WM_SETTEXT,0,(LPARAM) TEXT("12345678"));
                        break;
                        case IDC_PUK:
                                SendMessage( GetDlgItem(hWnd, IDC_TXTPIN), WM_SETTEXT,0,(LPARAM) TEXT("000000"));
                        break;
                        case IDC_CHECKPIN:
                                GetDlgItemTextA(hWnd,IDC_TXTPIN,szPin,ARRAYSIZE(szPin));

                                if (IsDlgButtonChecked(hWnd,IDC_PINADMIN))
                                {
                                        dwReturn = Authenticate(szPin, wszCARD_USER_ADMIN, &dwRemaining);
                                }
                                else
                                {
                                        dwReturn = Authenticate(szPin, wszCARD_USER_USER, &dwRemaining);
                                }
                                MessageBoxWin32(dwReturn);
                                break;
                        case IDC_UNBLOCKPIN:
                                GetDlgItemTextA(hWnd,IDC_TXTPIN,szPin,ARRAYSIZE(szPin));
                                GetDlgItemTextA(hWnd,IDC_TXTPIN2,szPin2,ARRAYSIZE(szPin2));
                                if (IsDlgButtonChecked(hWnd,IDC_PINADMIN))
                                {
                                        dwReturn = ResetPin(szPin, szPin2, FALSE, &dwRemaining);
                                }
                                else if (IsDlgButtonChecked(hWnd,IDC_PUK))
                                {
                                        dwReturn = ResetPin(szPin, szPin2, TRUE, &dwRemaining);
                                }
                                else
                                {
                                        dwReturn = E_INVALIDARG;
                                }
                                MessageBoxWin32(dwReturn);
                                break;
                        case IDC_CHANGEPIN:
                                GetDlgItemTextA(hWnd,IDC_TXTPIN,szPin,ARRAYSIZE(szPin));
                                GetDlgItemTextA(hWnd,IDC_TXTPIN2,szPin2,ARRAYSIZE(szPin2));
                                if (IsDlgButtonChecked(hWnd,IDC_PINADMIN))
                                {
                                        dwReturn = ChangePin(szPin, szPin2, wszCARD_USER_ADMIN, &dwRemaining);
                                }
                                else if (IsDlgButtonChecked(hWnd,IDC_PINUSER))
                                {
                                        dwReturn = ChangePin(szPin, szPin2, wszCARD_USER_USER, &dwRemaining);
                                }
                                else
                                {
                                        dwReturn = E_INVALIDARG;
                                }
                                MessageBoxWin32(dwReturn);
                                break;
                        case IDC_SETPUK:
                                GetDlgItemTextA(hWnd,IDC_TXTPIN,szPin,ARRAYSIZE(szPin));
                                GetDlgItemTextA(hWnd,IDC_TXTPIN2,szPin2,ARRAYSIZE(szPin2));
                                dwReturn = SetPuk(szPin, szPin2, &dwRemaining);
                                MessageBoxWin32(dwReturn);
                                break;
                        case IDC_SETSM:
                                GetDlgItemTextA(hWnd,IDC_TXTPIN,szPin,ARRAYSIZE(szPin));
                                GetDlgItemTextA(hWnd,IDC_TXTPIN2,szPin2,ARRAYSIZE(szPin2));
                                dwReturn = SetSM(szPin, szPin2, &dwRemaining);
                                MessageBoxWin32(dwReturn);
                                break;
                        case IDC_PERSONNALIZE:
                                dwReturn = Personnalize();
                                MessageBoxWin32(dwReturn);
                                break;
                }
                break;
        }
        return FALSE;
}

INT_PTR CALLBACK WndProcFile(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
        int wmId, wmEvent;
        DWORD dwReturn;
        switch (message)
        {
        case WM_INITDIALOG:
                break;
        case WM_COMMAND:
                wmId    = LOWORD(wParam);
                wmEvent = HIWORD(wParam);
                
                switch (wmId)
                {
                        case IDC_LISTFILES:
                                dwReturn = ListFiles(hWnd);
                                if (dwReturn)
                                {
                                        MessageBoxWin32(dwReturn);
                                }
                                break;
                        case IDC_FILES:
                                switch(wmEvent)
                                {
                                        case LBN_SELCHANGE:
                                                dwReturn = ViewFile(hWnd);
                                                if (dwReturn)
                                                {
                                                        MessageBoxWin32(dwReturn);
                                                }
                                                break;
                                }
                                break;
                }
                break;
        }
        return FALSE;
}

INT_PTR CALLBACK WndProcCrypto(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
        int wmId, wmEvent;
        DWORD dwReturn;
        switch (message)
        {
        case WM_INITDIALOG:
                SendDlgItemMessage(hWnd,IDC_CONTAINERINDEX,CB_ADDSTRING,0,(LPARAM)TEXT("Signature"));
                SendDlgItemMessage(hWnd,IDC_CONTAINERINDEX,CB_ADDSTRING,0,(LPARAM)TEXT("Confidentiality"));
                SendDlgItemMessage(hWnd,IDC_CONTAINERINDEX,CB_ADDSTRING,0,(LPARAM)TEXT("Authentication"));
                SendDlgItemMessage(hWnd,IDC_CONTAINERINDEX, CB_SETCURSEL, 0, 0);
                break;
        case WM_COMMAND:
                wmId    = LOWORD(wParam);
                wmEvent = HIWORD(wParam);
                
                switch (wmId)
                {
                        case IDC_NEWKEY:
                                dwReturn = GenerateNewKey((DWORD)SendDlgItemMessage(hWnd,IDC_CONTAINERINDEX, CB_GETCURSEL, 0, 0));
                                MessageBoxWin32(dwReturn);
                                break;
                        case IDC_IMPORTKEY:
                                dwReturn = ImportKey((DWORD)SendDlgItemMessage(hWnd,IDC_CONTAINERINDEX, CB_GETCURSEL, 0, 0));
                                MessageBoxWin32(dwReturn);
                                break;
                        case IDC_SAMEKEY:
                                dwReturn = SetTheSameKeyForAllContainers();
                                MessageBoxWin32(dwReturn);
                                break;
                        case IDC_SETREADONLY:
                                dwReturn = SetReadOnly(TRUE);
                                MessageBoxWin32(dwReturn);
                                break;
                        case IDC_UNSETREADONLY:
                                dwReturn = SetReadOnly(FALSE);
                                MessageBoxWin32(dwReturn);
                                break;
                }
                break;
        }
        return FALSE;
}

INT_PTR CALLBACK WndProcCryptoApi(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
        int wmId, wmEvent;
        DWORD dwReturn;
        TCHAR szContainer[256];
        DWORD dwKeySpec;
        switch (message)
        {
        case WM_INITDIALOG:
                break;
        case WM_COMMAND:
                wmId    = LOWORD(wParam);
                wmEvent = HIWORD(wParam);
                
                switch (wmId)
                {
                        case IDC_CONTAINER:
                                dwReturn = ListContainer(hWnd);
                                if (dwReturn)
                                {
                                        MessageBoxWin32(dwReturn);
                                }
                                break;
                        case IDC_SIGN:
                                if (GetContainerName(hWnd, szContainer, &dwKeySpec))
                                {
                                        dwReturn = Sign(szContainer, dwKeySpec);
                                        MessageBoxWin32(dwReturn);
                                }
                                break;
                        case IDC_DECRYPT:
                                if (GetContainerName(hWnd, szContainer, &dwKeySpec))
                                {
                                        dwReturn = Decrypt(szContainer, dwKeySpec);
                                        MessageBoxWin32(dwReturn);
                                }
                                break;
                        case IDC_LSTCONTAINER:
                                switch(wmEvent)
                                {
                                        case LBN_DBLCLK:
                                                if (GetContainerName(hWnd, szContainer, &dwKeySpec))
                                                {
                                                        dwReturn = ViewCertificate(hWnd, szContainer, dwKeySpec);
                                                        if (dwReturn)
                                                        {
                                                                MessageBoxWin32(dwReturn);
                                                        }
                                                }
                                                break;
                                }
                                break;
                }
                break;
        }
        return FALSE;
}

INT_PTR CALLBACK WndProcEnroll(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
        int wmId, wmEvent;
        DWORD dwReturn;
        switch (message)
        {
        case WM_INITDIALOG:
                break;
        case WM_COMMAND:
                wmId    = LOWORD(wParam);
                wmEvent = HIWORD(wParam);
                
                switch (wmId)
                {
                        case IDC_ENROLL:
                                dwReturn = Enroll();
                                MessageBoxWin32(dwReturn);
                                break;
                }
        }
        return FALSE;
}
1	vletoux	1	/* OpenPGP Smart Card Mini Driver
2			Copyright (C) 2009 Vincent Le Toux
3
4			This library is Free software; you can redistribute it and/or
5			modify it under the terms of the GNU Lesser General Public
6			License version 2.1 as published by the Free Software Foundation.
7
8			This library is distributed in the hope that it will be useful,
9			but WITHOUT ANY WARRANTY; without even the implied warranty of
10			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11			Lesser General Public License for more details.
12
13			You should have received a copy of the GNU Lesser General Public
14			License along with this library; if not, write to the Free Software
15			Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16			*/
17
18			#include <windows.h>
19			#include <tchar.h>
20			#include <cardmod.h>
21			#include <commctrl.h>
22	vletoux	11	#include <Cryptuiapi.h>
23	vletoux	1	#include "dialog.h"
24			#include "global.h"
25
26	vletoux	8	#pragma comment(lib,"comctl32")
27
28	vletoux	1	#ifdef UNICODE
29			#if defined _M_IX86
30			#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='x86' publicKeyToken='6595b64144ccf1df' language='*'\"")
31			#elif defined _M_IA64
32			#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='ia64' publicKeyToken='6595b64144ccf1df' language='*'\"")
33			#elif defined _M_X64
34			#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='amd64' publicKeyToken='6595b64144ccf1df' language='*'\"")
35			#else
36			#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='' publicKeyToken='6595b64144ccf1df' language=''\"")
37			#endif
38			#endif
39
40			// Variables globales :
41	vletoux	8	HINSTANCE g_hinst; // instance actuelle
42	vletoux	1
43	vletoux	8	INT_PTR CALLBACK WndProcConnect(HWND, UINT, WPARAM, LPARAM);
44			INT_PTR CALLBACK WndProcPin(HWND, UINT, WPARAM, LPARAM);
45			INT_PTR CALLBACK WndProcFile(HWND, UINT, WPARAM, LPARAM);
46			INT_PTR CALLBACK WndProcCrypto(HWND, UINT, WPARAM, LPARAM);
47			INT_PTR CALLBACK WndProcCryptoApi(HWND, UINT, WPARAM, LPARAM);
48	vletoux	12	INT_PTR CALLBACK WndProcEnroll(HWND, UINT, WPARAM, LPARAM);
49	vletoux	1
50			int APIENTRY _tWinMain(HINSTANCE hInstance,
51			HINSTANCE hPrevInstance,
52			LPTSTR lpCmdLine,
53			int nCmdShow)
54			{
55			UNREFERENCED_PARAMETER(hPrevInstance);
56			UNREFERENCED_PARAMETER(lpCmdLine);
57	vletoux	8	g_hinst = hInstance;
58	vletoux	12	PROPSHEETPAGE psp[6];
59	vletoux	8	PROPSHEETHEADER psh;
60			psp[0].dwSize = sizeof(PROPSHEETPAGE);
61			psp[0].dwFlags = PSP_USETITLE;
62			psp[0].hInstance = g_hinst;
63			psp[0].pszTemplate = MAKEINTRESOURCE(IDD_CONNECT);
64			psp[0].pszIcon = NULL;
65			psp[0].pfnDlgProc = WndProcConnect;
66			psp[0].pszTitle = TEXT("Connect");
67			psp[0].lParam = 0;
68			psp[0].pfnCallback = NULL;
69			psp[1].dwSize = sizeof(PROPSHEETPAGE);
70			psp[1].dwFlags = PSP_USETITLE;
71			psp[1].hInstance = g_hinst;
72			psp[1].pszTemplate = MAKEINTRESOURCE(IDD_PIN);
73			psp[1].pszIcon = NULL;
74			psp[1].pfnDlgProc = WndProcPin;
75			psp[1].pszTitle = TEXT("Pin");
76			psp[1].lParam = 0;
77			psp[2].pfnCallback = NULL;
78			psp[2].dwSize = sizeof(PROPSHEETPAGE);
79			psp[2].dwFlags = PSP_USETITLE;
80			psp[2].hInstance = g_hinst;
81			psp[2].pszTemplate = MAKEINTRESOURCE(IDD_FILE);
82			psp[2].pszIcon = NULL;
83			psp[2].pfnDlgProc = WndProcFile;
84			psp[2].pszTitle = TEXT("File");
85			psp[2].lParam = 0;
86			psp[2].pfnCallback = NULL;
87			psp[3].dwSize = sizeof(PROPSHEETPAGE);
88			psp[3].dwFlags = PSP_USETITLE;
89			psp[3].hInstance = g_hinst;
90			psp[3].pszTemplate = MAKEINTRESOURCE(IDD_CRYPTO);
91			psp[3].pszIcon = NULL;
92			psp[3].pfnDlgProc = WndProcCrypto;
93			psp[3].pszTitle = TEXT("Crypto");
94			psp[3].lParam = 0;
95			psp[3].pfnCallback = NULL;
96			psp[4].dwSize = sizeof(PROPSHEETPAGE);
97			psp[4].dwFlags = PSP_USETITLE;
98			psp[4].hInstance = g_hinst;
99			psp[4].pszTemplate = MAKEINTRESOURCE(IDD_CRYPTOAPI);
100			psp[4].pszIcon = NULL;
101			psp[4].pfnDlgProc = WndProcCryptoApi;
102			psp[4].pszTitle = TEXT("CryptoApi");
103			psp[4].lParam = 0;
104			psp[4].pfnCallback = NULL;
105	vletoux	12	psp[5].dwSize = sizeof(PROPSHEETPAGE);
106			psp[5].dwFlags = PSP_USETITLE;
107			psp[5].hInstance = g_hinst;
108			psp[5].pszTemplate = MAKEINTRESOURCE(IDD_ENROLL);
109			psp[5].pszIcon = NULL;
110			psp[5].pfnDlgProc = WndProcEnroll;
111			psp[5].pszTitle = TEXT("Enroll");
112			psp[5].lParam = 0;
113			psp[5].pfnCallback = NULL;
114	vletoux	8	psh.dwSize = sizeof(PROPSHEETHEADER);
115			psh.dwFlags = PSH_USEICONID \| PSH_PROPSHEETPAGE;
116			psh.hwndParent = NULL;
117			psh.hInstance = g_hinst;
118			psh.pszIcon =NULL;
119			psh.pszCaption = TEXT("Test");
120			psh.nPages = ARRAYSIZE(psp);
121			psh.nStartPage = 0;
122			psh.ppsp = (LPCPROPSHEETPAGE) &psp;
123			psh.pfnCallback = NULL;
124			PropertySheet(&psh);
125	vletoux	1	return 0;
126
127			}
128
129			void MessageBoxWin32(DWORD status) {
130			LPVOID Error;
131			FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER\|FORMAT_MESSAGE_FROM_SYSTEM,
132			NULL,status,0,(LPTSTR)&Error,0,NULL);
133			MessageBox(NULL,(LPCTSTR)Error,NULL,MB_ICONASTERISK);
134			LocalFree(Error);
135			}
136
137	vletoux	11
138			void ViewCertificate(HWND hWnd, PCCERT_CONTEXT pCertContext)
139			{
140			CRYPTUI_VIEWCERTIFICATE_STRUCT certViewInfo;
141			BOOL fPropertiesChanged = FALSE;
142			certViewInfo.dwSize = sizeof(CRYPTUI_VIEWCERTIFICATE_STRUCT);
143			certViewInfo.hwndParent = hWnd;
144			certViewInfo.dwFlags = CRYPTUI_DISABLE_EDITPROPERTIES \| CRYPTUI_DISABLE_ADDTOSTORE \| CRYPTUI_DISABLE_EXPORT \| CRYPTUI_DISABLE_HTMLLINK;
145			certViewInfo.szTitle = TEXT("Info");
146			certViewInfo.pCertContext = pCertContext;
147			certViewInfo.cPurposes = 0;
148			certViewInfo.rgszPurposes = 0;
149			certViewInfo.pCryptProviderData = NULL;
150			certViewInfo.hWVTStateData = NULL;
151			certViewInfo.fpCryptProviderDataTrustedUsage = FALSE;
152			certViewInfo.idxSigner = 0;
153			certViewInfo.idxCert = 0;
154			certViewInfo.fCounterSigner = FALSE;
155			certViewInfo.idxCounterSigner = 0;
156			certViewInfo.cStores = 0;
157			certViewInfo.rghStores = NULL;
158			certViewInfo.cPropSheetPages = 0;
159			certViewInfo.rgPropSheetPages = NULL;
160			certViewInfo.nStartPage = 0;
161
162			CryptUIDlgViewCertificate(&certViewInfo,&fPropertiesChanged);
163			}
164
165	vletoux	8	#define C_PAGES 5
166
167			typedef struct tag_dlghdr {
168			HWND hwndTab; // tab control
169			HWND hwndDisplay; // current child dialog box
170			RECT rcDisplay; // display rectangle for the tab control
171			DLGTEMPLATE *apRes[C_PAGES];
172			DLGPROC pDialogFunc[C_PAGES];
173			} DLGHDR;
174
175
176			BOOL GetContainerName(HWND hWnd, PWSTR szContainer, PDWORD pdwKeySpec)
177	vletoux	1	{
178	vletoux	8	DWORD iItem = (DWORD)SendMessage(GetDlgItem(hWnd, IDC_LSTCONTAINER),LB_GETCURSEL,0,0);
179	vletoux	1	if (iItem == LB_ERR) return FALSE;
180	vletoux	8	SendMessage( GetDlgItem(hWnd,IDC_LSTCONTAINER), LB_GETTEXT,iItem,(LPARAM)szContainer);
181	vletoux	1	*pdwKeySpec = _tstoi(szContainer + _tcslen(szContainer) - 1);
182			szContainer[ _tcslen(szContainer) - 2] = 0;
183			return TRUE;
184			}
185
186	vletoux	8
187			INT_PTR CALLBACK WndProcConnect(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
188	vletoux	1	{
189			int wmId, wmEvent;
190			DWORD dwReturn;
191			switch (message)
192			{
193			case WM_INITDIALOG:
194			CheckDlgButton(hWnd,IDC_CurrentDll,BST_CHECKED);
195			break;
196			case WM_COMMAND:
197			wmId = LOWORD(wParam);
198			wmEvent = HIWORD(wParam);
199
200			switch (wmId)
201			{
202			case IDC_CONNECT:
203			if (IsDlgButtonChecked(hWnd,IDC_SystemDll))
204			{
205			dwReturn = Connect(TRUE);
206			}
207			else
208			{
209			dwReturn = Connect(FALSE);
210			}
211			if (dwReturn)
212			{
213			MessageBoxWin32(dwReturn);
214			}
215			break;
216			case IDC_DISCONNECT:
217			dwReturn = Disconnect();
218			if (dwReturn)
219			{
220			MessageBoxWin32(dwReturn);
221			}
222			break;
223	vletoux	8	}
224			break;
225			}
226			return FALSE;
227			}
228
229			INT_PTR CALLBACK WndProcPin(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
230			{
231			int wmId, wmEvent;
232			DWORD dwReturn;
233			CHAR szPin[256];
234			CHAR szPin2[256];
235			DWORD dwRemaining;
236			switch (message)
237			{
238			case WM_INITDIALOG:
239			CheckDlgButton(hWnd,IDC_PINUSER,BST_CHECKED);
240			SendMessage( GetDlgItem(hWnd, IDC_TXTPIN), WM_SETTEXT,0,(LPARAM) TEXT("123456"));
241			break;
242			case WM_COMMAND:
243			wmId = LOWORD(wParam);
244			wmEvent = HIWORD(wParam);
245
246			switch (wmId)
247			{
248			case IDC_PINUSER:
249			SendMessage( GetDlgItem(hWnd, IDC_TXTPIN), WM_SETTEXT,0,(LPARAM) TEXT("123456"));
250			break;
251			case IDC_PINADMIN:
252			SendMessage( GetDlgItem(hWnd, IDC_TXTPIN), WM_SETTEXT,0,(LPARAM) TEXT("12345678"));
253			break;
254			case IDC_PUK:
255			SendMessage( GetDlgItem(hWnd, IDC_TXTPIN), WM_SETTEXT,0,(LPARAM) TEXT("000000"));
256			break;
257			case IDC_CHECKPIN:
258			GetDlgItemTextA(hWnd,IDC_TXTPIN,szPin,ARRAYSIZE(szPin));
259
260	vletoux	1	if (IsDlgButtonChecked(hWnd,IDC_PINADMIN))
261			{
262			dwReturn = Authenticate(szPin, wszCARD_USER_ADMIN, &dwRemaining);
263			}
264			else
265			{
266			dwReturn = Authenticate(szPin, wszCARD_USER_USER, &dwRemaining);
267			}
268			MessageBoxWin32(dwReturn);
269			break;
270	vletoux	8	case IDC_UNBLOCKPIN:
271			GetDlgItemTextA(hWnd,IDC_TXTPIN,szPin,ARRAYSIZE(szPin));
272			GetDlgItemTextA(hWnd,IDC_TXTPIN2,szPin2,ARRAYSIZE(szPin2));
273			if (IsDlgButtonChecked(hWnd,IDC_PINADMIN))
274			{
275			dwReturn = ResetPin(szPin, szPin2, FALSE, &dwRemaining);
276			}
277			else if (IsDlgButtonChecked(hWnd,IDC_PUK))
278			{
279			dwReturn = ResetPin(szPin, szPin2, TRUE, &dwRemaining);
280			}
281			else
282			{
283			dwReturn = E_INVALIDARG;
284			}
285			MessageBoxWin32(dwReturn);
286			break;
287			case IDC_CHANGEPIN:
288			GetDlgItemTextA(hWnd,IDC_TXTPIN,szPin,ARRAYSIZE(szPin));
289			GetDlgItemTextA(hWnd,IDC_TXTPIN2,szPin2,ARRAYSIZE(szPin2));
290			if (IsDlgButtonChecked(hWnd,IDC_PINADMIN))
291			{
292			dwReturn = ChangePin(szPin, szPin2, wszCARD_USER_ADMIN, &dwRemaining);
293			}
294			else if (IsDlgButtonChecked(hWnd,IDC_PINUSER))
295			{
296			dwReturn = ChangePin(szPin, szPin2, wszCARD_USER_USER, &dwRemaining);
297			}
298			else
299			{
300			dwReturn = E_INVALIDARG;
301			}
302			MessageBoxWin32(dwReturn);
303			break;
304	vletoux	11	case IDC_SETPUK:
305			GetDlgItemTextA(hWnd,IDC_TXTPIN,szPin,ARRAYSIZE(szPin));
306			GetDlgItemTextA(hWnd,IDC_TXTPIN2,szPin2,ARRAYSIZE(szPin2));
307			dwReturn = SetPuk(szPin, szPin2, &dwRemaining);
308			MessageBoxWin32(dwReturn);
309			break;
310	vletoux	12	case IDC_SETSM:
311			GetDlgItemTextA(hWnd,IDC_TXTPIN,szPin,ARRAYSIZE(szPin));
312			GetDlgItemTextA(hWnd,IDC_TXTPIN2,szPin2,ARRAYSIZE(szPin2));
313			dwReturn = SetSM(szPin, szPin2, &dwRemaining);
314			MessageBoxWin32(dwReturn);
315			break;
316	vletoux	11	case IDC_PERSONNALIZE:
317			dwReturn = Personnalize();
318			MessageBoxWin32(dwReturn);
319			break;
320	vletoux	8	}
321			break;
322			}
323			return FALSE;
324			}
325
326			INT_PTR CALLBACK WndProcFile(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
327			{
328			int wmId, wmEvent;
329			DWORD dwReturn;
330			switch (message)
331			{
332			case WM_INITDIALOG:
333			break;
334			case WM_COMMAND:
335			wmId = LOWORD(wParam);
336			wmEvent = HIWORD(wParam);
337
338			switch (wmId)
339			{
340	vletoux	1	case IDC_LISTFILES:
341	vletoux	8	dwReturn = ListFiles(hWnd);
342	vletoux	1	if (dwReturn)
343			{
344			MessageBoxWin32(dwReturn);
345			}
346			break;
347	vletoux	8	case IDC_FILES:
348			switch(wmEvent)
349			{
350			case LBN_SELCHANGE:
351			dwReturn = ViewFile(hWnd);
352			if (dwReturn)
353			{
354			MessageBoxWin32(dwReturn);
355			}
356			break;
357			}
358			break;
359			}
360			break;
361			}
362			return FALSE;
363			}
364
365			INT_PTR CALLBACK WndProcCrypto(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
366			{
367			int wmId, wmEvent;
368			DWORD dwReturn;
369			switch (message)
370			{
371			case WM_INITDIALOG:
372			SendDlgItemMessage(hWnd,IDC_CONTAINERINDEX,CB_ADDSTRING,0,(LPARAM)TEXT("Signature"));
373	vletoux	10	SendDlgItemMessage(hWnd,IDC_CONTAINERINDEX,CB_ADDSTRING,0,(LPARAM)TEXT("Confidentiality"));
374	vletoux	8	SendDlgItemMessage(hWnd,IDC_CONTAINERINDEX,CB_ADDSTRING,0,(LPARAM)TEXT("Authentication"));
375			SendDlgItemMessage(hWnd,IDC_CONTAINERINDEX, CB_SETCURSEL, 0, 0);
376			break;
377			case WM_COMMAND:
378			wmId = LOWORD(wParam);
379			wmEvent = HIWORD(wParam);
380
381			switch (wmId)
382			{
383	vletoux	1	case IDC_NEWKEY:
384	vletoux	8	dwReturn = GenerateNewKey((DWORD)SendDlgItemMessage(hWnd,IDC_CONTAINERINDEX, CB_GETCURSEL, 0, 0));
385	vletoux	1	MessageBoxWin32(dwReturn);
386			break;
387			case IDC_IMPORTKEY:
388	vletoux	8	dwReturn = ImportKey((DWORD)SendDlgItemMessage(hWnd,IDC_CONTAINERINDEX, CB_GETCURSEL, 0, 0));
389	vletoux	1	MessageBoxWin32(dwReturn);
390			break;
391	vletoux	5	case IDC_SAMEKEY:
392			dwReturn = SetTheSameKeyForAllContainers();
393			MessageBoxWin32(dwReturn);
394			break;
395	vletoux	10	case IDC_SETREADONLY:
396			dwReturn = SetReadOnly(TRUE);
397			MessageBoxWin32(dwReturn);
398			break;
399			case IDC_UNSETREADONLY:
400			dwReturn = SetReadOnly(FALSE);
401			MessageBoxWin32(dwReturn);
402			break;
403	vletoux	8	}
404			break;
405			}
406			return FALSE;
407			}
408
409			INT_PTR CALLBACK WndProcCryptoApi(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
410			{
411			int wmId, wmEvent;
412			DWORD dwReturn;
413			TCHAR szContainer[256];
414			DWORD dwKeySpec;
415			switch (message)
416			{
417			case WM_INITDIALOG:
418			break;
419			case WM_COMMAND:
420			wmId = LOWORD(wParam);
421			wmEvent = HIWORD(wParam);
422
423			switch (wmId)
424			{
425	vletoux	1	case IDC_CONTAINER:
426	vletoux	8	dwReturn = ListContainer(hWnd);
427	vletoux	1	if (dwReturn)
428			{
429			MessageBoxWin32(dwReturn);
430			}
431			break;
432			case IDC_SIGN:
433	vletoux	8	if (GetContainerName(hWnd, szContainer, &dwKeySpec))
434	vletoux	1	{
435			dwReturn = Sign(szContainer, dwKeySpec);
436			MessageBoxWin32(dwReturn);
437			}
438			break;
439			case IDC_DECRYPT:
440	vletoux	8	if (GetContainerName(hWnd, szContainer, &dwKeySpec))
441	vletoux	1	{
442			dwReturn = Decrypt(szContainer, dwKeySpec);
443			MessageBoxWin32(dwReturn);
444			}
445			break;
446			case IDC_LSTCONTAINER:
447			switch(wmEvent)
448			{
449			case LBN_DBLCLK:
450	vletoux	8	if (GetContainerName(hWnd, szContainer, &dwKeySpec))
451	vletoux	1	{
452	vletoux	8	dwReturn = ViewCertificate(hWnd, szContainer, dwKeySpec);
453	vletoux	1	if (dwReturn)
454			{
455			MessageBoxWin32(dwReturn);
456			}
457			}
458			break;
459			}
460			break;
461			}
462			break;
463			}
464			return FALSE;
465			}
466
467	vletoux	12	INT_PTR CALLBACK WndProcEnroll(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
468			{
469			int wmId, wmEvent;
470			DWORD dwReturn;
471			switch (message)
472			{
473			case WM_INITDIALOG:
474			break;
475			case WM_COMMAND:
476			wmId = LOWORD(wParam);
477			wmEvent = HIWORD(wParam);
478
479			switch (wmId)
480			{
481			case IDC_ENROLL:
482			dwReturn = Enroll();
483			MessageBoxWin32(dwReturn);
484			break;
485			}
486			}
487			return FALSE;
488			}