//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//
//  Copyright (C) Microsoft Corporation, 1998 - 1999
//
//  File:       wiz.cpp
//
//--------------------------------------------------------------------------


#include "stdafx.h"
#include "wiz.h"
#include <rpc.h>

// sddl.h requires this value to be at least
// 0x0500.  Bump it up if necessary.  NOTE:  This
// 'bump' comes after all other H files that may
// be sensitive to this value.
#if(_WIN32_WINNT < 0x500)
#undef _WIN32_WINNT
#define _WIN32_WINNT 0x0500
#endif
#include <sddl.h>


UINT g_aidFont[] =
{
    IDS_LARGEFONTNAME,
    IDS_LARGEFONTSIZE,
    IDS_SMALLFONTNAME,
    IDS_SMALLFONTSIZE,
};

static BOOL IsDisallowedOID(LPCSTR pszOID)
{
    if ((strcmp(pszOID, szOID_SGC_NETSCAPE) == 0) ||
        (strcmp(pszOID, szOID_SERVER_GATED_CRYPTO) == 0) ||
        (strcmp(pszOID, szOID_WHQL_CRYPTO) == 0) ||
        (strcmp(pszOID, szOID_NT5_CRYPTO) == 0) ||
        (strcmp(pszOID, szOID_KP_TIME_STAMP_SIGNING) == 0))
    {
        return TRUE;
    }

    return FALSE;
}

HRESULT 
SetupFonts(
    HINSTANCE    hInstance,
    HWND         hwnd,
    CFont        *pBigBoldFont,
    CFont        *pBoldFont
    )
{
    HRESULT hr = S_OK;

    //
	// Create the fonts we need based on the dialog font
    //
	NONCLIENTMETRICS ncm = {0};
	ncm.cbSize = sizeof(ncm);
	SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, &ncm, 0);

	LOGFONT BigBoldLogFont  = ncm.lfMessageFont;
	LOGFONT BoldLogFont     = ncm.lfMessageFont;

    //
	// Create Big Bold Font and Bold Font
    //
    BigBoldLogFont.lfWeight   = FW_BOLD;
    BoldLogFont.lfWeight      = FW_BOLD;

    TCHAR FontSizeString[MAX_PATH];
    INT BigBoldFontSize;
    INT BoldFontSize;

    //
    // Load size and name from resources, since these may change
    // from locale to locale based on the size of the system font, etc.
    //
    if(!LoadString(hInstance,IDS_LARGEFONTNAME,BigBoldLogFont.lfFaceName,LF_FACESIZE)) 
    {
        lstrcpy(BigBoldLogFont.lfFaceName,TEXT("MS Shell Dlg"));
    }

    if(LoadString(hInstance,IDS_LARGEFONTSIZE,FontSizeString,sizeof(FontSizeString)/sizeof(TCHAR))) 
    {
        BigBoldFontSize = _tcstoul( FontSizeString, NULL, 10 );
    } 
    else 
    {
        BigBoldFontSize = 12;
    }

    if(LoadString(hInstance,IDS_FONTSIZE,FontSizeString,sizeof(FontSizeString)/sizeof(TCHAR))) 
    {
        BoldFontSize = _tcstoul( FontSizeString, NULL, 10 );
    } 
    else 
    {
        BoldFontSize = 10;
    }

    HDC hdc = GetDC(hwnd);
	
    if (hdc)
    {
        BigBoldLogFont.lfHeight = 0 - (GetDeviceCaps(hdc,LOGPIXELSY) * BigBoldFontSize / 72);
        BoldLogFont.lfHeight = 0 - (GetDeviceCaps(hdc,LOGPIXELSY) * BoldFontSize / 72);

        if (!pBigBoldFont->CreateFontIndirect(&BigBoldLogFont) ||
            !pBoldFont->CreateFontIndirect(&BoldLogFont))
        {
            hr = GetLastError();
            hr = HRESULT_FROM_WIN32(hr);
        }
		

        ReleaseDC(hwnd,hdc);
    }
    else
    {
	hr = GetLastError();
	hr = HRESULT_FROM_WIN32(hr);
    }

    return hr;
}


void CleanUpCertTypeInfo(PWIZARD_HELPER pwizHelp)
{
    unsigned int i;

    if (pwizHelp->pKeyUsage != NULL)
    {
        delete(pwizHelp->pKeyUsage);
        pwizHelp->pKeyUsage = NULL;
    }
    ZeroMemory(pwizHelp->KeyUsageBytes, 2);
    pwizHelp->fMarkKeyUsageCritical = FALSE;
    
    if (pwizHelp->EnhancedKeyUsage.cUsageIdentifier != 0)
    {
        for (i=0; i<pwizHelp->EnhancedKeyUsage.cUsageIdentifier; i++)
        {
            delete(pwizHelp->EnhancedKeyUsage.rgpszUsageIdentifier[i]);
        }   
        delete(pwizHelp->EnhancedKeyUsage.rgpszUsageIdentifier);
        pwizHelp->EnhancedKeyUsage.rgpszUsageIdentifier = NULL;
        pwizHelp->EnhancedKeyUsage.cUsageIdentifier = 0;
    }
    pwizHelp->fMarkEKUCritical = FALSE;

    
    pwizHelp->BasicConstraints2.fCA = FALSE; 
    pwizHelp->BasicConstraints2.fPathLenConstraint = FALSE;
    pwizHelp->BasicConstraints2.dwPathLenConstraint = 0;

    pwizHelp->fAllowCAtoFillInInfo = FALSE;
    pwizHelp->fIncludeEmail = FALSE;
    pwizHelp->fAllowAutoEnroll = FALSE;
    pwizHelp->fMachine = FALSE;

    pwizHelp->fPublishToDS = FALSE;
    pwizHelp->fAddTemplateName = FALSE;
    pwizHelp->fAddDirectoryPath = FALSE;



    if(pwizHelp->pSD)
    {
        LocalFree(pwizHelp->pSD);
        pwizHelp->pSD = NULL;
    }

    if (pwizHelp->rgszCSPList != NULL)
    {
        delete[](pwizHelp->rgszCSPList);
        pwizHelp->rgszCSPList = NULL;
        pwizHelp->cCSPs = 0;
    }
    pwizHelp->fPrivateKeyExportable = FALSE;
    pwizHelp->fDigitalSignatureContainer = TRUE;
    pwizHelp->fKeyExchangeContainer = FALSE;
}


void FillInCertTypeInfo(HCERTTYPE hCertType, PWIZARD_HELPER pwizHelp)
{
    DWORD       cNumUsages;
    CString     **aszUsages = NULL;
    unsigned int         i;
    WCHAR       **pszNameArray;
    DWORD       dwFlags, dwKeySpec;
    LPWSTR      *rgpwszSupportedCSPs;


    CleanUpCertTypeInfo(pwizHelp);

    //
    // key usage
    //
    if (MyGetKeyUsages(hCertType, &(pwizHelp->pKeyUsage), &(pwizHelp->fMarkKeyUsageCritical)))
    {
        // copy the key usage bits to the local byte array that has two bytes for sure
        ZeroMemory(pwizHelp->KeyUsageBytes, 2);
        CopyMemory(pwizHelp->KeyUsageBytes, pwizHelp->pKeyUsage->pbData, pwizHelp->pKeyUsage->cbData);
        pwizHelp->pKeyUsage->cUnusedBits = 7; // there are currently 9 key usage bits defined
        pwizHelp->pKeyUsage->pbData = pwizHelp->KeyUsageBytes;
        pwizHelp->pKeyUsage->cbData = 2;
    }

    //
    // enhanced key usage count
    //
    if(!MyGetEnhancedKeyUsages(
            hCertType, 
            NULL, 
            &cNumUsages, 
            &(pwizHelp->fMarkEKUCritical), 
            TRUE))
    {
        return;
    }

    if (cNumUsages == 0)
    {
        pwizHelp->EnhancedKeyUsage.cUsageIdentifier = 0;
        pwizHelp->EnhancedKeyUsage.rgpszUsageIdentifier = NULL;
    }
    else
    {
        aszUsages = new CString*[cNumUsages];
        if(!aszUsages)
            return;

        if(!MyGetEnhancedKeyUsages(
                hCertType, 
                aszUsages, 
                &cNumUsages, 
                &(pwizHelp->fMarkEKUCritical), 
                TRUE))
        {
            delete[] aszUsages;
            return;
        }

        pwizHelp->EnhancedKeyUsage.cUsageIdentifier = cNumUsages; 
        pwizHelp->EnhancedKeyUsage.rgpszUsageIdentifier = (LPSTR *) new (LPSTR[cNumUsages]);
        if(pwizHelp->EnhancedKeyUsage.rgpszUsageIdentifier == NULL)
        {
            delete[] aszUsages;
            return;
        }

        for (i=0; i<cNumUsages; i++)
        {
            pwizHelp->EnhancedKeyUsage.rgpszUsageIdentifier[i] = MyMkMBStr((LPCTSTR)*(aszUsages[i]));
            delete(aszUsages[i]);
        }
    }

    //
    // basic constraints
    //
    if(!MyGetBasicConstraintInfo(
            hCertType, 
            &(pwizHelp->BasicConstraints2.fCA), 
            &(pwizHelp->BasicConstraints2.fPathLenConstraint), 
            &(pwizHelp->BasicConstraints2.dwPathLenConstraint)))
    {
        delete[] aszUsages;
        return;
    }

    // if the fInEditCertTypeMode flag is set, then we need to initialize the
    // cert template name
    if (pwizHelp->fInEditCertTypeMode)
    {
        CAGetCertTypeProperty(hCertType, CERTTYPE_PROP_FRIENDLY_NAME, &pszNameArray);
        if (pszNameArray != NULL)
        {
            *(pwizHelp->pcstrFriendlyName) = pszNameArray[0];
            CAFreeCertTypeProperty(hCertType, pszNameArray);
        }
    }

    //
    // ACL info
    //
    CACertTypeGetSecurity(hCertType, &pwizHelp->pSD);


    CAGetCertTypeFlags(hCertType, &dwFlags);

    pwizHelp->fAllowCAtoFillInInfo = 
        ((dwFlags & CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT) == 0);

    pwizHelp->fAllowAutoEnroll = 
        ((dwFlags & CT_FLAG_AUTO_ENROLLMENT) == 0);
       
    pwizHelp->fMachine = 
        ((dwFlags & CT_FLAG_MACHINE_TYPE) == 0);

    pwizHelp->fPublishToDS = 
        ((dwFlags & CT_FLAG_PUBLISH_TO_DS) == 0);


    pwizHelp->fIncludeEmail = 
        ((dwFlags & CT_FLAG_ADD_EMAIL) != 0);

    pwizHelp->fAddTemplateName = 
        ((dwFlags & CT_FLAG_ADD_TEMPLATE_NAME) == 0);

    pwizHelp->fAddDirectoryPath = 
        ((dwFlags & CT_FLAG_ADD_DIRECTORY_PATH) == 0);

    //
    // CSP info
    //
    if ((CAGetCertTypeProperty(hCertType, CERTTYPE_PROP_CSP_LIST, &rgpwszSupportedCSPs) == S_OK) &&
        (rgpwszSupportedCSPs != NULL))
    {
        //
        // count number of CSPs
        //
        i = 0;
        while (rgpwszSupportedCSPs[i++] != NULL);

        pwizHelp->cCSPs = i-1;

        //
        // allocate array and copy CSP names to it
        //
        if (NULL != (pwizHelp->rgszCSPList = (CString *) new(CString[pwizHelp->cCSPs])))
        {
            i = 0;
            while (rgpwszSupportedCSPs[i] != NULL)
            {
                pwizHelp->rgszCSPList[i] = rgpwszSupportedCSPs[i];
                i++;
            }
        }

        CAFreeCertTypeProperty(hCertType, rgpwszSupportedCSPs);
    }
    pwizHelp->fPrivateKeyExportable = dwFlags & CT_FLAG_EXPORTABLE_KEY;
    CAGetCertTypeKeySpec(hCertType, &dwKeySpec);
    if (dwKeySpec == AT_KEYEXCHANGE)
    {
        pwizHelp->fDigitalSignatureContainer = FALSE;
        pwizHelp->fKeyExchangeContainer = TRUE;
    }
    else
    {
        pwizHelp->fDigitalSignatureContainer = TRUE;
        pwizHelp->fKeyExchangeContainer = FALSE;
    }

    delete[] aszUsages;
}


/////////////////////////////////////////////////////////////////////////////
// CNewCertTypeWelcome property page

CNewCertTypeWelcome::CNewCertTypeWelcome() :
    CWizard97PropertyPage(
	g_hInstance,
	CNewCertTypeWelcome::IDD,
	g_aidFont)
{
    InitWizard97 (TRUE);
}

CNewCertTypeWelcome::~CNewCertTypeWelcome()
{
}

// replacement for DoDataExchange
BOOL CNewCertTypeWelcome::UpdateData(BOOL fSuckFromDlg /*= TRUE*/)
{
    if (fSuckFromDlg)
    {
//        m_cstrModuleName.FromWindow(GetDlgItem(m_hWnd, IDC_MODULENAME));
    }
    else
    {
//        m_cstrModuleName.ToWindow(GetDlgItem(m_hWnd, IDC_MODULENAME));
    }
    return TRUE;
}


// replacement for BEGIN_MESSAGE_MAP
BOOL CNewCertTypeWelcome::OnCommand(WPARAM wParam, LPARAM lParam)
{
/*
    switch(LOWORD(wParam))
    {
    default:
        return FALSE;
        break;
    }
*/
    return TRUE;
}

/////////////////////////////////////////////////////////////////////////////
// CNewCertTypeWelcome message handlers

LRESULT CNewCertTypeWelcome::OnWizardNext() 
{
	if (m_pwizHelp->fInEditCertTypeMode)
        return (IDD_NEWCERTTYPE_INFORMATION);
    else
        return 0;
}

BOOL CNewCertTypeWelcome::OnInitDialog() 
{
	CWizard97PropertyPage::OnInitDialog();

    CString szPropSheetTitle;
    szPropSheetTitle.LoadString(IDS_CERTIFICATE_TEMPLATE_WIZARD);
    SetWindowText(m_hWnd, szPropSheetTitle);
	
    SendMessage(GetDlgItem(IDC_WELCOME_BIGBOLD_STATIC), WM_SETFONT, (WPARAM)GetBigBoldFont(), MAKELPARAM(TRUE, 0));
    SendMessage(GetDlgItem(IDC_WELCOM_BOLD_STATIC), WM_SETFONT, (WPARAM)GetBigBoldFont(), MAKELPARAM(TRUE, 0));

	return TRUE;  // return TRUE unless you set the focus to a control
	              // EXCEPTION: OCX Property Pages should return FALSE
}

BOOL CNewCertTypeWelcome::OnSetActive() 
{
    PropSheet_SetWizButtons(GetParent(), PSWIZB_NEXT);
	
	return CWizard97PropertyPage::OnSetActive();
}


/////////////////////////////////////////////////////////////////////////////
// CNewCertTypeBaseType property page

CNewCertTypeBaseType::CNewCertTypeBaseType() :
    CWizard97PropertyPage(
	g_hInstance,
	CNewCertTypeBaseType::IDD,
	g_aidFont)
{
    m_szHeaderTitle.LoadString(IDS_BASE_TYPE_TITLE);
    m_szHeaderSubTitle.LoadString(IDS_BASE_TYPE_SUB_TITLE);
    InitWizard97 (FALSE);

    m_hLastSelectedCertType = NULL;
}

CNewCertTypeBaseType::~CNewCertTypeBaseType()
{
}

// replacement for DoDataExchange
BOOL CNewCertTypeBaseType::UpdateData(BOOL fSuckFromDlg /*= TRUE*/)
{
    if (fSuckFromDlg)
    {
//        m_cstrModuleName.FromWindow(GetDlgItem(m_hWnd, IDC_MODULENAME));
    }
    else
    {
//        m_cstrModuleName.ToWindow(GetDlgItem(m_hWnd, IDC_MODULENAME));
    }
    return TRUE;
}

// replacement for BEGIN_MESSAGE_MAP
BOOL CNewCertTypeBaseType::OnCommand(WPARAM wParam, LPARAM lParam)
{
/*

    switch(LOWORD(wParam))
    {
    default:
        return FALSE;
        break;
    }
*/
    return TRUE;
}

BOOL CNewCertTypeBaseType::OnNotify(UINT idCtrl, NMHDR* pnmh)
{
    switch(idCtrl)
    {
    case IDC_BASE_CERT_TYPE_LIST:
        if (LVN_ITEMCHANGED == pnmh->code)
        {
            OnSelChange(pnmh);
            break;
        }
    default:
        return FALSE;
    }

    return TRUE;
}
/////////////////////////////////////////////////////////////////////////////
// CNewCertTypeBaseType message handlers

LRESULT CNewCertTypeBaseType::OnWizardBack() 
{
	return CWizard97PropertyPage::OnWizardBack();
}

LRESULT CNewCertTypeBaseType::OnWizardNext() 
{
	if (m_hSelectedCertType != m_hLastSelectedCertType)
    {
        if (m_hSelectedCertType == NULL)
        {
            m_pwizHelp->fBaseCertTypeUsed = FALSE;
            CleanUpCertTypeInfo(m_pwizHelp);
            m_pwizHelp->fCleanupOIDCheckBoxes = TRUE;

            // since there is no base type the key usage structure will not be initialized
            // with date, therefore we need to initialize the key usage structure with 0's
            m_pwizHelp->pKeyUsage = new(CRYPT_BIT_BLOB);
            if(m_pwizHelp->pKeyUsage == NULL)
            {
                return  CWizard97PropertyPage::OnWizardNext();
            }
            m_pwizHelp->pKeyUsage->cbData = 2;
            m_pwizHelp->pKeyUsage->pbData = m_pwizHelp->KeyUsageBytes;
            m_pwizHelp->pKeyUsage->cUnusedBits = 7;
        }
        else 
        {
            m_pwizHelp->fBaseCertTypeUsed = TRUE;
            FillInCertTypeInfo(m_hSelectedCertType, m_pwizHelp);
        }

        m_pwizHelp->fKeyUsageInitialized = FALSE;
        m_hLastSelectedCertType = m_hSelectedCertType;
    }

    
    ListView_GetItemText(m_hBaseCertTypeList, m_selectedIndex, 0, m_pwizHelp->pcstrBaseCertName->GetBuffer(MAX_PATH), MAX_PATH*sizeof(WCHAR));

    return CWizard97PropertyPage::OnWizardNext();
}

BOOL CNewCertTypeBaseType::OnSetActive() 
{
    PropSheet_SetWizButtons(GetParent(), PSWIZB_BACK | PSWIZB_NEXT);

	return CWizard97PropertyPage::OnSetActive();
}

void CNewCertTypeBaseType::OnSelChange(NMHDR * pNotifyStruct) 
{
    LPNMLISTVIEW        pListItem = (LPNMLISTVIEW) pNotifyStruct;

    if (pListItem->uNewState & LVIS_SELECTED)
    {
        m_hSelectedCertType = (HCERTTYPE) ListView_GetItemData(m_hBaseCertTypeList, pListItem->iItem);
        m_selectedIndex = pListItem->iItem;
    }
}


BOOL CNewCertTypeBaseType::OnInitDialog() 
{
	CWizard97PropertyPage::OnInitDialog();

    m_hBaseCertTypeList = GetDlgItem(m_hWnd, IDC_BASE_CERT_TYPE_LIST);
	
	HRESULT         hr;
    HCERTTYPE       hCertTypeNext;
    HCERTTYPE       hCertTypePrev;
    WCHAR **        aszCertTypeName;
    CString         szUsageString;
    int             i = 0;
    CString         szColumnHeading;
    CString         szNoBaseType;

    szColumnHeading.LoadString(IDS_COLUMN_NAME);
    ListView_NewColumn(m_hBaseCertTypeList, 0, 200, szColumnHeading, LVCFMT_LEFT);

    szColumnHeading.LoadString(IDS_COLUMN_INTENDED_PURPOSE);
    ListView_NewColumn(m_hBaseCertTypeList, 1, 200, szColumnHeading, LVCFMT_LEFT);

    // initialize the list with the <No Base Type> string selected
    szNoBaseType.LoadString(IDS_NO_BASE_TYPE);
    ListView_NewItem(m_hBaseCertTypeList, i++, szNoBaseType);
    ListView_SetItemState(m_hBaseCertTypeList, 0, LVIS_SELECTED, LVIS_SELECTED);
    m_selectedIndex = 0;

    // since there is no base type selected we need to initialize
    // the key usage structure
    m_pwizHelp->pKeyUsage = new(CRYPT_BIT_BLOB);
    if(m_pwizHelp->pKeyUsage == NULL)
    {
        return FALSE;
    }

    m_pwizHelp->pKeyUsage->cbData = 2;
    m_pwizHelp->pKeyUsage->pbData = m_pwizHelp->KeyUsageBytes;
    m_pwizHelp->pKeyUsage->cUnusedBits = 7;

    hr = CAEnumCertTypes(CT_ENUM_MACHINE_TYPES | CT_ENUM_USER_TYPES,
                         &hCertTypeNext);

    while ((hCertTypeNext != NULL) && (!FAILED(hr)))
    {
        //
        // add the cert type to the list of choices
        //
        hr = CAGetCertTypeProperty(
                hCertTypeNext,
                CERTTYPE_PROP_FRIENDLY_NAME,
                &aszCertTypeName);
    
	    ListView_NewItem(m_hBaseCertTypeList, i, aszCertTypeName[0], (LPARAM)hCertTypeNext);


        GetIntendedUsagesString(hCertTypeNext, &szUsageString);
        if (szUsageString == L"")
        {
            szUsageString.LoadString(IDS_ALL);
        }
        ListView_SetItemText(m_hBaseCertTypeList, i++, 1, (LPWSTR)(LPCTSTR)szUsageString);

        CAFreeCertTypeProperty(
                hCertTypeNext,
                aszCertTypeName);

        hCertTypePrev = hCertTypeNext;
        hCertTypeNext = NULL;
        hr = CAEnumNextCertType(hCertTypePrev, &hCertTypeNext);
    }

    ListView_SetColumnWidth(m_hBaseCertTypeList, 0, LVSCW_AUTOSIZE);
    ListView_SetColumnWidth(m_hBaseCertTypeList, 1, LVSCW_AUTOSIZE);

    
	return TRUE;  // return TRUE unless you set the focus to a control
	              // EXCEPTION: OCX Property Pages should return FALSE
}

void CNewCertTypeBaseType::OnDestroy() 
{
	CWizard97PropertyPage::OnDestroy();
    
    int         i = 0;
    HCERTTYPE   hCertType;
    
    int iCount = ListView_GetItemCount(m_hBaseCertTypeList);

    for (i=0; i<iCount; i++)
    {
        hCertType = (HCERTTYPE) ListView_GetItemData(m_hBaseCertTypeList, i);

        if (hCertType != NULL)
            CACloseCertType(hCertType);
    }
}



/////////////////////////////////////////////////////////////////////////////
// CNewCertTypeBasicInformation property page

CNewCertTypeBasicInformation::CNewCertTypeBasicInformation() :
    CWizard97PropertyPage(
	g_hInstance,
	CNewCertTypeBasicInformation::IDD,
	g_aidFont)
{
    m_szHeaderTitle.LoadString(IDS_BASIC_INFORMATION_TITLE);
    m_szHeaderSubTitle.LoadString(IDS_BASIC_INFORMATION_SUB_TITLE);
    InitWizard97 (FALSE);
}

CNewCertTypeBasicInformation::~CNewCertTypeBasicInformation()
{
}

// replacement for DoDataExchange
BOOL CNewCertTypeBasicInformation::UpdateData(BOOL fSuckFromDlg /*= TRUE*/)
{
    if (fSuckFromDlg)
    {
//        m_cstrModuleName.FromWindow(GetDlgItem(m_hWnd, IDC_MODULENAME));
    }
    else
    {
//        m_cstrModuleName.ToWindow(GetDlgItem(m_hWnd, IDC_MODULENAME));
    }
    return TRUE;
}

// replacement for BEGIN_MESSAGE_MAP
BOOL CNewCertTypeBasicInformation::OnCommand(WPARAM wParam, LPARAM lParam)
{
    switch(LOWORD(wParam))
    {
    case IDC_NEW_PURPOSE_BUTTON:
        if (HIWORD(wParam) == BN_CLICKED)
        {
            OnNewPurposeButton();
            break;
        }
    default:
        return FALSE;
        break;
    }
    return TRUE;
}


/////////////////////////////////////////////////////////////////////////////
// CNewCertTypeBasicInformation message handlers

BOOL WINAPI EnumCallback(PCCRYPT_OID_INFO pInfo, void *pvArg)
{
    CNewCertTypeBasicInformation *pDlg = (CNewCertTypeBasicInformation *) pvArg; 
    
    pDlg->AddEnumedEKU(pInfo);

    return TRUE;
}

void CNewCertTypeBasicInformation::AddEnumedEKU(PCCRYPT_OID_INFO pInfo)
{
    LPSTR pszOIDCopy;

    //
    // don't allow SGC oids
    //
    if (IsDisallowedOID(pInfo->pszOID))
    {
        return;
    }

    pszOIDCopy = (LPSTR) new(BYTE[strlen(pInfo->pszOID)+1]);

    if (pszOIDCopy != NULL)
    {
        strcpy(pszOIDCopy, pInfo->pszOID);
        
	    ListView_NewItem(m_hPurposeList, 0, pInfo->pwszName, (LPARAM)pszOIDCopy);
    }
}

void CNewCertTypeBasicInformation::UpdateWizHelp()
{
    unsigned int     i;
    int     cNumUsages;

    CString szName;
    szName.FromWindow(GetDlgItem(this->m_hWnd, IDC_CERTIFICATE_TEMPLATE_EDIT));
    *(m_pwizHelp->pcstrFriendlyName) = szName;

    m_pwizHelp->fAllowCAtoFillInInfo = (SendMessage(m_hButtonCAFillIn, BM_GETCHECK, 0, 0) == BST_CHECKED);
    m_pwizHelp->fAllowCAtoFillInInfo = (SendMessage(m_hButtonCritical, BM_GETCHECK, 0, 0) == BST_CHECKED);
    m_pwizHelp->fAllowCAtoFillInInfo = (SendMessage(m_hButtonIncludeEmail, BM_GETCHECK, 0, 0) == BST_CHECKED);
    m_pwizHelp->fAllowCAtoFillInInfo = (SendMessage(m_hButtonAllowAutoEnroll, BM_GETCHECK, 0, 0) == BST_CHECKED);
    m_pwizHelp->fAllowCAtoFillInInfo = (SendMessage(m_hButtonAdvanced, BM_GETCHECK, 0, 0) == BST_CHECKED);

    // clean up any EKU that alraedy exists
    for (i=0; i<m_pwizHelp->EnhancedKeyUsage.cUsageIdentifier; i++)
    {
        delete(m_pwizHelp->EnhancedKeyUsage.rgpszUsageIdentifier[i]);
    }
    if (m_pwizHelp->EnhancedKeyUsage.rgpszUsageIdentifier != NULL)
        delete(m_pwizHelp->EnhancedKeyUsage.rgpszUsageIdentifier);
    
    cNumUsages = ListView_GetSelectedCount(m_hPurposeList);

    // allocate memory and copy the oids
    m_pwizHelp->EnhancedKeyUsage.cUsageIdentifier = cNumUsages; 
    m_pwizHelp->EnhancedKeyUsage.rgpszUsageIdentifier = (LPSTR *) new (LPSTR[cNumUsages]);

    if(m_pwizHelp->EnhancedKeyUsage.rgpszUsageIdentifier == NULL)
    {
        return;
    }
    i = -1;
    while(-1 != (i = ListView_GetNextItem(m_hPurposeList, i, LVNI_SELECTED)) )
    {
        LPCSTR sz = (LPCSTR)ListView_GetItemData(m_hPurposeList, i);
        m_pwizHelp->EnhancedKeyUsage.rgpszUsageIdentifier[cNumUsages++] = AllocAndCopyStr(sz);
    }
}

LRESULT CNewCertTypeBasicInformation::OnWizardBack() 
{
	UpdateWizHelp();

    if (m_pwizHelp->fInEditCertTypeMode)
        return (IDD_NEWCERTTYPE_WELCOME);
    else
        return 0;
}

LRESULT CNewCertTypeBasicInformation::OnWizardNext() 
{
	CString szText0;

    szText0.FromWindow(GetDlgItem(m_hWnd, IDC_CERTIFICATE_TEMPLATE_EDIT));

    if (szText0 == L"")
    {
        CString szCaption;
        CString szText;

        szCaption.LoadString(IDS_CERTIFICATE_TEMPLATE_WIZARD);
        szText.LoadString(IDS_ENTER_CERTTYPE_NAME);
        MessageBox(m_hWnd, szText, szCaption, MB_OK | MB_ICONEXCLAMATION);
        SetFocus(GetDlgItem(m_hWnd, IDC_CERTIFICATE_TEMPLATE_EDIT));
        return -1;
    }

    UpdateWizHelp();

    return CWizard97PropertyPage::OnWizardNext();
}

BOOL CNewCertTypeBasicInformation::OnInitDialog() 
{
	CWizard97PropertyPage::OnInitDialog();

    m_hPurposeList = GetDlgItem(m_hWnd, IDC_PURPOSE_LIST);
    m_hButtonCAFillIn = GetDlgItem(m_hWnd, IDC_CA_FILL_IN_CHECK);
    m_hButtonCritical = GetDlgItem(m_hWnd, IDC_CRITICAL_CHECK);
    m_hButtonIncludeEmail = GetDlgItem(m_hWnd, IDC_INCLUDE_EMAIL_CHECK);
    m_hButtonAllowAutoEnroll = GetDlgItem(m_hWnd, IDC_ALLOW_AUTOENROLL_CHECK);
    m_hButtonAdvanced = GetDlgItem(m_hWnd, IDC_ADVANCED_OPTIONS_CHECK);

    CString szNewCertName;

    // set the name if we are in cert type edit mode
    if (m_pwizHelp->fInEditCertTypeMode)
    {
        SetDlgItemText(m_hWnd, IDC_CERTIFICATE_TEMPLATE_EDIT, *(m_pwizHelp->pcstrFriendlyName));
    }
    else
    {
        szNewCertName.LoadString(IDS_NEW_CERTIFICATE_TEMPLATE2);
        SetDlgItemText(m_hWnd, IDC_CERTIFICATE_TEMPLATE_EDIT, szNewCertName);
    }

    SendMessage(m_hButtonAdvanced, BM_SETCHECK, FALSE, 0);

    ListView_NewColumn(m_hPurposeList, 0, 0);
    ListView_SetExtendedListViewStyle(m_hPurposeList, LVS_EX_CHECKBOXES); 
    ListView_SetColumnWidth(m_hPurposeList, 0, LVSCW_AUTOSIZE);

	CryptEnumOIDInfo(CRYPT_ENHKEY_USAGE_OID_GROUP_ID, 0, (void *) this, EnumCallback);
	
	// set focus to the name edit
    SetFocus(GetDlgItem(m_hWnd, IDC_CERTIFICATE_TEMPLATE_EDIT));

	return TRUE;  // return TRUE unless you set the focus to a control
	              // EXCEPTION: OCX Property Pages should return FALSE
}

void CNewCertTypeBasicInformation::OnDestroy() 
{
	CWizard97PropertyPage::OnDestroy();

    int     i, iCount;
    
    // clean up the OID strings that were set as the LPARAM's of each item
    iCount = ListView_GetItemCount(m_hPurposeList);

    for (i=0; i<iCount; i++)
    {
        delete (LPSTR) ListView_GetItemData(m_hPurposeList, i);
    }
}

void CNewCertTypeBasicInformation::InitializeOIDList()
{
    unsigned int     i,j;
    LPSTR   pszOID;
    BOOL    bFound;
    WCHAR   szOIDName[MAX_PATH];
    LPSTR   pszNewOID;

    // this means all usages are supported
    if (m_pwizHelp->EnhancedKeyUsage.cUsageIdentifier == 0)
    {
        unsigned int iCount = ListView_GetItemCount(m_hPurposeList);

        for (i=0; i<iCount; i++)
            ListView_SetCheckState(m_hPurposeList, i, TRUE);
    }
    else
    {
        // loop for each EKU that this certificate template supports
        for (i=0; i<m_pwizHelp->EnhancedKeyUsage.cUsageIdentifier; i++)
        {
            unsigned int iCount = ListView_GetItemCount(m_hPurposeList);

            bFound = FALSE;

            // see if this EKU is in the global list
            for (j=0; j<iCount; j++)
            {
                pszOID = (LPSTR)ListView_GetItemData(m_hPurposeList, j);

                if (strcmp(pszOID, m_pwizHelp->EnhancedKeyUsage.rgpszUsageIdentifier[i]) == 0)
                {
                    // if the EKU is in the global list, then just set the check box,
                    // and set the flag that it was found
                    ListView_SetCheckState(m_hPurposeList, j, TRUE);
                    bFound = TRUE;
                }
            }
            
            // if the EKU was not in the global list then insert it into the list view,
            // and set its check box
            if (!bFound)
            {
                if (!MyGetOIDInfo(szOIDName, ARRAYSIZE(szOIDName), m_pwizHelp->EnhancedKeyUsage.rgpszUsageIdentifier[i]))
                {
                    continue;
                }

                pszNewOID = (LPSTR) new(BYTE[strlen(m_pwizHelp->EnhancedKeyUsage.rgpszUsageIdentifier[i])+1]);
                if (pszNewOID == NULL)
                {
                    continue;
                }

                strcpy(pszNewOID, m_pwizHelp->EnhancedKeyUsage.rgpszUsageIdentifier[i]);
			    ListView_NewItem(m_hPurposeList, 0, szOIDName, (LPARAM)pszNewOID);
                ListView_SetCheckState(m_hPurposeList, 0, TRUE);
            }
        }
    }
}

BOOL CNewCertTypeBasicInformation::OnSetActive() 
{
    int     i;
    LPSTR   pszOID;

    PropSheet_SetWizButtons(GetParent(), PSWIZB_BACK | PSWIZB_NEXT);

    SendMessage(m_hButtonCAFillIn, BM_SETCHECK, m_pwizHelp->fAllowCAtoFillInInfo, 0);
    SendMessage(m_hButtonCritical, BM_SETCHECK, m_pwizHelp->fMarkEKUCritical, 0);
    SendMessage(m_hButtonIncludeEmail, BM_SETCHECK, m_pwizHelp->fIncludeEmail, 0);
    SendMessage(m_hButtonAllowAutoEnroll, BM_SETCHECK, m_pwizHelp->fAllowAutoEnroll, 0);

    if (m_pwizHelp->fBaseCertTypeUsed || m_pwizHelp->fInEditCertTypeMode)
    {
        InitializeOIDList();
    }
    else
    {
        if (m_pwizHelp->fCleanupOIDCheckBoxes)
        {
            int iCount = ListView_GetItemCount(m_hPurposeList);

            for (i=0; i<iCount; i++)
            {
                ListView_SetCheckState(m_hPurposeList, i, FALSE);
            }

            m_pwizHelp->fCleanupOIDCheckBoxes = FALSE;
        }
    }
	
	return CWizard97PropertyPage::OnSetActive();
}

#include <richedit.h>

INT_PTR APIENTRY NewOIDDialogProc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
    DWORD   i;
    char    szText[256];
    WCHAR   errorString[256];
    WCHAR   errorTitle[256];
    LPSTR   pszText = NULL;
        
    switch ( msg ) {

    case WM_INITDIALOG:

        SendDlgItemMessage(hwndDlg, IDC_EDIT1, EM_EXLIMITTEXT, 0, (LPARAM) 255);
        SetDlgItemText(hwndDlg, IDC_EDIT1, L"");
        SetFocus(GetDlgItem(hwndDlg, IDC_EDIT1));
        break;
    
    case WM_COMMAND:
        switch (LOWORD(wParam)) 
        {
        
        case IDOK:
            if (GetDlgItemTextA(
                        hwndDlg,
                        IDC_EDIT1,
                        szText,
                        ARRAYSIZE(szText)))
            {
                BOOL                fError = FALSE;
                CERT_ENHKEY_USAGE   KeyUsage;
                DWORD               cbData = 0;
                LPSTR               pszCheckOID;

                // 
                // make sure there are not weird characters
                //
                for (i=0; i<strlen(szText); i++)
                {
                    if (((szText[i] < '0') || (szText[i] > '9')) && (szText[i] != '.'))
                    {
                        fError = TRUE;
                        break;
                    }
                }

                //
                // check the first and last chars, and for the empty string
                //
                if (!fError)
                {
                    if ((szText[0] == '.') || (szText[strlen(szText)-1] == '.') || (strcmp(szText, "") == 0))
                    {
                        fError = TRUE; 
                    }
                }

                //
                // finally, make sure that it encodes properly
                //
                if (!fError)
                {
                    pszCheckOID = szText;
                    KeyUsage.rgpszUsageIdentifier = &pszCheckOID;
                    KeyUsage.cUsageIdentifier = 1;

                    if (!CryptEncodeObject(
                              X509_ASN_ENCODING,
                              szOID_ENHANCED_KEY_USAGE,
                              &KeyUsage,
                              NULL,
                              &cbData))
                    {
                        fError = TRUE;
                    }
                }


                //
                // if an error has occurred then display error
                //
                if (fError)
                {
                    LoadString(g_hInstance, IDS_ERRORINOID, errorString, ARRAYSIZE(errorString));
                    LoadString(g_hInstance, IDS_CERTIFICATE_TEMPLATE_WIZARD, errorTitle, ARRAYSIZE(errorTitle));
                    MessageBox(hwndDlg, errorString, errorTitle, MB_OK | MB_ICONERROR);
                    SendDlgItemMessage(hwndDlg, IDC_EDIT1, EM_SETSEL, 0, -1);
                    SetFocus(GetDlgItem(hwndDlg, IDC_EDIT1));
                    return FALSE;
                }

                //
                // don't allow SGC oids
                //
                if (IsDisallowedOID(szText))
                {
                    LoadString(g_hInstance, IDS_NOSPECIALOID, errorString, ARRAYSIZE(errorString));
                    LoadString(g_hInstance, IDS_CERTIFICATE_TEMPLATE_WIZARD, errorTitle, ARRAYSIZE(errorTitle));
                    MessageBox(hwndDlg, errorString, errorTitle, MB_OK | MB_ICONERROR);
                    SendDlgItemMessage(hwndDlg, IDC_EDIT1, EM_SETSEL, 0, -1);
                    SetFocus(GetDlgItem(hwndDlg, IDC_EDIT1));
                    return FALSE;
                }

                //
                // allocate space for the string and pass the string back
                //
                pszText = (LPSTR) new(BYTE[strlen(szText)+1]);
                if (pszText != NULL)
                {
                    strcpy(pszText, szText);
                }
            }

            EndDialog(hwndDlg, (INT_PTR) pszText);
            break;

        case IDCANCEL:
            EndDialog(hwndDlg, NULL);
            break;
        }
            
        break;
    }

    return FALSE;
}



BOOL CNewCertTypeBasicInformation::OIDAlreadyExist(LPSTR pszNewOID)
{
    int     i;
    LPSTR   pszOID;
    
    int iCount = ListView_GetItemCount(m_hPurposeList);
    for (i=0; i<iCount; i++)
    {
        pszOID = (LPSTR) ListView_GetItemData(m_hPurposeList, i);
        if (strcmp(pszOID, pszNewOID) == 0)
        {
            ListView_SetItemState(m_hPurposeList, i, LVIS_SELECTED, LVIS_SELECTED);
            ListView_SetCheckState(m_hPurposeList, i, TRUE);
            ListView_EnsureVisible(m_hPurposeList, i, FALSE);
            return TRUE;
        }
    }

    return FALSE;
}

void CNewCertTypeBasicInformation::OnNewPurposeButton() 
{   
    LPSTR   pszNewOID;
    WCHAR   szOIDName[MAX_PATH];

    pszNewOID = (LPSTR) ::DialogBox(
                            g_hInstance, 
                            MAKEINTRESOURCE(IDD_USER_PURPOSE),
                            m_hWnd,
                            NewOIDDialogProc);

    if (pszNewOID != NULL)
    {
        DWORD       chStores = 0;
        HCERTSTORE  *phStores = NULL;

        //
        // if the OID already exists then don't add it 
        //
        if (!OIDAlreadyExist(pszNewOID))
        {
            if (!MyGetOIDInfo(szOIDName, ARRAYSIZE(szOIDName), pszNewOID))
            {
                delete[](pszNewOID);
                return;
            }

            ListView_NewItem(m_hPurposeList, 0, szOIDName, (LPARAM)pszNewOID);
            ListView_SetCheckState(m_hPurposeList, 0, TRUE);
            ListView_EnsureVisible(m_hPurposeList, 0, FALSE);
        } 
    }
}
 



/////////////////////////////////////////////////////////////////////////////
// CNewCertTypeKeyUsage property page
CNewCertTypeKeyUsage::CNewCertTypeKeyUsage() :
    CWizard97PropertyPage(
	g_hInstance,
	CNewCertTypeKeyUsage::IDD,
	g_aidFont)
{
    m_szHeaderTitle.LoadString(IDS_KEY_USAGE_TITLE);
    m_szHeaderSubTitle.LoadString(IDS_KEY_USAGE_SUB_TITLE);
    InitWizard97 (FALSE); 
}

CNewCertTypeKeyUsage::~CNewCertTypeKeyUsage()
{
}

// replacement for DoDataExchange
BOOL CNewCertTypeKeyUsage::UpdateData(BOOL fSuckFromDlg /*= TRUE*/)
{
    if (fSuckFromDlg)
    {
//        m_cstrModuleName.FromWindow(GetDlgItem(m_hWnd, IDC_MODULENAME));
    }
    else
    {
//        m_cstrModuleName.ToWindow(GetDlgItem(m_hWnd, IDC_MODULENAME));
    }
    return TRUE;
}

// replacement for BEGIN_MESSAGE_MAP
BOOL CNewCertTypeKeyUsage::OnCommand(WPARAM wParam, LPARAM lParam)
{
/*
    switch(LOWORD(wParam))
    {
    default:
        return FALSE;
        break;
    }
*/
    return TRUE;
}

/////////////////////////////////////////////////////////////////////////////
// CNewCertTypeKeyUsage message handlers

void CNewCertTypeKeyUsage::UpdateWizHelp()
{
    if (BST_CHECKED == SendMessage(m_hButtonDataEncryption, BM_GETCHECK, 0, 0))
        m_pwizHelp->KeyUsageBytes[0] |= CERT_DATA_ENCIPHERMENT_KEY_USAGE;   
    else
        m_pwizHelp->KeyUsageBytes[0] &= ~CERT_DATA_ENCIPHERMENT_KEY_USAGE;   

    if (BST_CHECKED == SendMessage(m_hButtonDigitalSignature, BM_GETCHECK, 0, 0))
        m_pwizHelp->KeyUsageBytes[0] |= CERT_DIGITAL_SIGNATURE_KEY_USAGE;   
    else
        m_pwizHelp->KeyUsageBytes[0] &= ~CERT_DIGITAL_SIGNATURE_KEY_USAGE;   

    if (BST_CHECKED == SendMessage(m_hButtonEncipherOnly, BM_GETCHECK, 0, 0))
        m_pwizHelp->KeyUsageBytes[0] |= CERT_ENCIPHER_ONLY_KEY_USAGE;   
    else
        m_pwizHelp->KeyUsageBytes[0] &= ~CERT_ENCIPHER_ONLY_KEY_USAGE;   

    if (BST_CHECKED == SendMessage(m_hButtonKeyAgreement, BM_GETCHECK, 0, 0))
        m_pwizHelp->KeyUsageBytes[0] |= CERT_KEY_AGREEMENT_KEY_USAGE;   
    else
        m_pwizHelp->KeyUsageBytes[0] &= ~CERT_KEY_AGREEMENT_KEY_USAGE;   

    if (BST_CHECKED == SendMessage(m_hButtonKeyEncryption, BM_GETCHECK, 0, 0))
        m_pwizHelp->KeyUsageBytes[0] |= CERT_KEY_ENCIPHERMENT_KEY_USAGE;   
    else
        m_pwizHelp->KeyUsageBytes[0] &= ~CERT_KEY_ENCIPHERMENT_KEY_USAGE; 
    
    if (BST_CHECKED == SendMessage(m_hButtonPrevent, BM_GETCHECK, 0, 0))
        m_pwizHelp->KeyUsageBytes[0] |= CERT_NON_REPUDIATION_KEY_USAGE;   
    else
        m_pwizHelp->KeyUsageBytes[0] &= ~CERT_NON_REPUDIATION_KEY_USAGE; 

    if (BST_CHECKED == SendMessage(m_hButtonDecipherOnly, BM_GETCHECK, 0, 0))
        m_pwizHelp->KeyUsageBytes[1] |= CERT_DECIPHER_ONLY_KEY_USAGE;   
    else
        m_pwizHelp->KeyUsageBytes[1] &= ~CERT_DECIPHER_ONLY_KEY_USAGE; 


    m_pwizHelp->fMarkKeyUsageCritical = (BST_CHECKED == SendMessage(m_hButtonKeyUsageCritical, BM_GETCHECK, 0, 0));
}

LRESULT CNewCertTypeKeyUsage::OnWizardBack() 
{
	UpdateWizHelp();
	
	return CWizard97PropertyPage::OnWizardBack();
}

LRESULT CNewCertTypeKeyUsage::OnWizardNext() 
{
	UpdateWizHelp();
    
    //if (m_pwizHelp->BasicConstraints2.fCA)
     //   return (IDD_NEWCERTTYPE_CA_CERTIFICATE);
    //else
        return 0;
}

BOOL CNewCertTypeKeyUsage::OnInitDialog() 
{
	CWizard97PropertyPage::OnInitDialog();

    m_hButtonDataEncryption = GetDlgItem(m_hWnd, IDC_DATA_ENCRYPTION_CHECK);
    m_hButtonDecipherOnly = GetDlgItem(m_hWnd, IDC_DECIPHER_ONLY_CHECK);
    m_hButtonDigitalSignature = GetDlgItem(m_hWnd, IDC_DIGITAL_SIGNATURE_CHECK);
    m_hButtonEncipherOnly = GetDlgItem(m_hWnd, IDC_ENCIPHER_ONLY_CHECK);
    m_hButtonKeyAgreement = GetDlgItem(m_hWnd, IDC_KEY_AGREEMENT_CHECK);
    m_hButtonKeyEncryption = GetDlgItem(m_hWnd, IDC_KEY_ENCRYPTION_CHECK);
    m_hButtonKeyUsageCritical = GetDlgItem(m_hWnd, IDC_KEYUSAGE_CRITICAL_CHECK);
    m_hButtonPrevent = GetDlgItem(m_hWnd, IDC_PREVENT_CHECK);

    SendMessage(m_hButtonKeyUsageCritical, BM_SETCHECK, 0, 0);
	
	return TRUE;  // return TRUE unless you set the focus to a control
	              // EXCEPTION: OCX Property Pages should return FALSE
}

void CNewCertTypeKeyUsage::OnDestroy() 
{
	CWizard97PropertyPage::OnDestroy();
}

BOOL CNewCertTypeKeyUsage::OnSetActive() 
{
    PropSheet_SetWizButtons(GetParent(), PSWIZB_BACK | PSWIZB_NEXT);

    SendMessage(m_hButtonDataEncryption, BM_SETCHECK, ((m_pwizHelp->KeyUsageBytes[0] & CERT_DATA_ENCIPHERMENT_KEY_USAGE) != 0), 0);

    if (!m_pwizHelp->fKeyUsageInitialized && m_pwizHelp->fDigitalSignatureContainer && !m_pwizHelp->fBaseCertTypeUsed)
    {
        SendMessage(m_hButtonDigitalSignature, BM_SETCHECK, TRUE, 0);
        m_pwizHelp->fKeyUsageInitialized = TRUE;
    }
    else
    {
        SendMessage(m_hButtonDigitalSignature, BM_SETCHECK, ((m_pwizHelp->KeyUsageBytes[0] & CERT_DIGITAL_SIGNATURE_KEY_USAGE) != 0), 0);
    }

    SendMessage(m_hButtonEncipherOnly, BM_SETCHECK, ((m_pwizHelp->KeyUsageBytes[0] & CERT_ENCIPHER_ONLY_KEY_USAGE) != 0), 0);
    SendMessage(m_hButtonKeyAgreement, BM_SETCHECK, ((m_pwizHelp->KeyUsageBytes[0] & CERT_KEY_AGREEMENT_KEY_USAGE) != 0), 0);
    SendMessage(m_hButtonKeyEncryption, BM_SETCHECK, ((m_pwizHelp->KeyUsageBytes[0] & CERT_KEY_ENCIPHERMENT_KEY_USAGE) != 0), 0);
    SendMessage(m_hButtonPrevent, BM_SETCHECK, ((m_pwizHelp->KeyUsageBytes[0] & CERT_NON_REPUDIATION_KEY_USAGE) != 0), 0);
    SendMessage(m_hButtonDecipherOnly, BM_SETCHECK, ((m_pwizHelp->KeyUsageBytes[1] & CERT_DECIPHER_ONLY_KEY_USAGE) != 0), 0);
    SendMessage(m_hButtonKeyUsageCritical, BM_SETCHECK, m_pwizHelp->fMarkKeyUsageCritical, 0);

    //
    // now set the enable/disable state
    //
    if (m_pwizHelp->fDigitalSignatureContainer)
    {
        EnableWindow(m_hButtonDataEncryption, FALSE);     
        EnableWindow(m_hButtonDigitalSignature, TRUE);
        EnableWindow(m_hButtonEncipherOnly, FALSE);
        EnableWindow(m_hButtonKeyAgreement, FALSE);
        EnableWindow(m_hButtonKeyEncryption, FALSE);
        EnableWindow(m_hButtonPrevent, TRUE);
        EnableWindow(m_hButtonDecipherOnly, FALSE);
    }
    else
    {
        EnableWindow(m_hButtonDataEncryption, TRUE);     
        EnableWindow(m_hButtonDigitalSignature, TRUE);     
        EnableWindow(m_hButtonEncipherOnly, TRUE);     
        EnableWindow(m_hButtonKeyAgreement, TRUE);     
        EnableWindow(m_hButtonKeyEncryption, TRUE);     
        EnableWindow(m_hButtonPrevent, TRUE);     
        EnableWindow(m_hButtonDecipherOnly, TRUE);     
    }
	
	return CWizard97PropertyPage::OnSetActive();
}


/////////////////////////////////////////////////////////////////////////////
// CNewCertTypeCACertificate property page
CNewCertTypeCACertificate::CNewCertTypeCACertificate() :
    CWizard97PropertyPage(
	g_hInstance,
	CNewCertTypeCACertificate::IDD,
	g_aidFont)
{
    m_szHeaderTitle.LoadString(IDS_CA_CERTIFICATE_TITLE);
    m_szHeaderSubTitle.LoadString(IDS_CA_CERTIFICATE_SUB_TITLE);
    InitWizard97 (FALSE);
}

CNewCertTypeCACertificate::~CNewCertTypeCACertificate()
{
}

// replacement for DoDataExchange
BOOL CNewCertTypeCACertificate::UpdateData(BOOL fSuckFromDlg /*= TRUE*/)
{
    if (fSuckFromDlg)
    {
//        m_cstrModuleName.FromWindow(GetDlgItem(m_hWnd, IDC_MODULENAME));
    }
    else
    {
//        m_cstrModuleName.ToWindow(GetDlgItem(m_hWnd, IDC_MODULENAME));
    }
    return TRUE;
}

// replacement for BEGIN_MESSAGE_MAP
BOOL CNewCertTypeCACertificate::OnCommand(WPARAM wParam, LPARAM lParam)
{
/*
    switch(LOWORD(wParam))
    {
    default:
        return FALSE;
        break;
    }
*/
    return TRUE;
}

/////////////////////////////////////////////////////////////////////////////
// CNewCertTypeCACertificate message handlers

void CNewCertTypeCACertificate::UpdateWizHelp()
{
    if (BST_CHECKED == SendMessage(m_hButtonVerifySignature, BM_GETCHECK, 0, 0))
        m_pwizHelp->KeyUsageBytes[0] |= CERT_KEY_CERT_SIGN_KEY_USAGE;
    else
        m_pwizHelp->KeyUsageBytes[0] &= ~CERT_KEY_CERT_SIGN_KEY_USAGE;

    if (BST_CHECKED == SendMessage(m_hButtonIssueCRL, BM_GETCHECK, 0, 0))
        m_pwizHelp->KeyUsageBytes[0] |= CERT_CRL_SIGN_KEY_USAGE;
    else
        m_pwizHelp->KeyUsageBytes[0] &= ~CERT_CRL_SIGN_KEY_USAGE;
}

LRESULT CNewCertTypeCACertificate::OnWizardBack() 
{
	UpdateWizHelp();
	
	return CWizard97PropertyPage::OnWizardBack();
}

LRESULT CNewCertTypeCACertificate::OnWizardNext() 
{
	UpdateWizHelp();
	
	return CWizard97PropertyPage::OnWizardNext();
}

BOOL CNewCertTypeCACertificate::OnInitDialog() 
{
	CWizard97PropertyPage::OnInitDialog();

    m_hButtonVerifySignature = GetDlgItem(m_hWnd, IDC_VERIFY_SIGNATURE_CHECK);
    m_hButtonIssueCRL = GetDlgItem(m_hWnd, IDC_ISSUE_CRL_CHECK);

	return TRUE;  // return TRUE unless you set the focus to a control
	              // EXCEPTION: OCX Property Pages should return FALSE
}

void CNewCertTypeCACertificate::OnDestroy() 
{
	CWizard97PropertyPage::OnDestroy();
}

BOOL CNewCertTypeCACertificate::OnSetActive() 
{
    PropSheet_SetWizButtons(GetParent(), PSWIZB_BACK | PSWIZB_NEXT);

    SendMessage(m_hButtonIssueCRL, BM_SETCHECK, ((m_pwizHelp->KeyUsageBytes[0] & CERT_KEY_CERT_SIGN_KEY_USAGE) != 0), 0);
    SendMessage(m_hButtonIssueCRL, BM_SETCHECK, ((m_pwizHelp->KeyUsageBytes[0] & CERT_CRL_SIGN_KEY_USAGE) != 0), 0);

	return CWizard97PropertyPage::OnSetActive();
}




/////////////////////////////////////////////////////////////////////////////
// CNewCertTypeCompletion property page
CNewCertTypeCompletion::CNewCertTypeCompletion() :
    CWizard97PropertyPage(
	g_hInstance,
	CNewCertTypeCompletion::IDD,
	g_aidFont)
{
    InitWizard97 (TRUE);
}

CNewCertTypeCompletion::~CNewCertTypeCompletion()
{
}

// replacement for DoDataExchange
BOOL CNewCertTypeCompletion::UpdateData(BOOL fSuckFromDlg /*= TRUE*/)
{
    if (fSuckFromDlg)
    {
//        m_cstrModuleName.FromWindow(GetDlgItem(m_hWnd, IDC_MODULENAME));
    }
    else
    {
//        m_cstrModuleName.ToWindow(GetDlgItem(m_hWnd, IDC_MODULENAME));
    }
    return TRUE;
}

// replacement for BEGIN_MESSAGE_MAP
BOOL CNewCertTypeCompletion::OnCommand(WPARAM wParam, LPARAM lParam)
{
/*
    switch(LOWORD(wParam))
    {
    default:
        return FALSE;
        break;
    }
*/
    return TRUE;
}



/////////////////////////////////////////////////////////////////////////////
// CNewCertTypeCompletion message handlers

BOOL CNewCertTypeCompletion::OnWizardFinish() 
{
	return CWizard97PropertyPage::OnWizardFinish();
}

LRESULT CNewCertTypeCompletion::OnWizardBack() 
{
	if (!m_pwizHelp->fShowAdvanced)
        return (IDD_NEWCERTTYPE_CONTROL);
    else if (m_pwizHelp->BasicConstraints2.fCA)
        return (IDD_NEWCERTTYPE_KEY_USAGE);
    else
        return 0;
}

void CNewCertTypeCompletion::AddResultsToSummaryList()
{
    int                 i = 0;
    unsigned int                 j;
    int                 listIndex = 0;
    CString             szItemName;
    CString             szItemText;
    PCCRYPT_OID_INFO    pOIDInfo;
    LPWSTR              pszOIDName;
    BOOL                bKeyUsageFirstItem = TRUE;
    WCHAR               szNumberString[256];

    // friendly name of cert template
    szItemName.LoadString(IDS_CERTIFICATE_TEMPLATE);

	ListView_NewItem(m_hSummaryList, i, szItemName);
    ListView_SetItemText(m_hSummaryList, i++, 1, (LPWSTR)(LPCTSTR) (*(m_pwizHelp->pcstrFriendlyName)) );
    
    // the base cert template that was used
    if (!m_pwizHelp->fInEditCertTypeMode)
    {
        szItemName.LoadString(IDS_BASE_CERTIFICATE_TEMPLATE);
		ListView_NewItem(m_hSummaryList, i, szItemName);
        ListView_SetItemText(m_hSummaryList, i++, 1, (LPWSTR)(LPCTSTR) (*(m_pwizHelp->pcstrBaseCertName)) );
    }

    // enhanced key usage list
    szItemName.LoadString(IDS_CERTIFICATE_PURPOSE_LIST);
	ListView_NewItem(m_hSummaryList, i, szItemName);

    if (m_pwizHelp->EnhancedKeyUsage.cUsageIdentifier == 0)
    {
        szItemText.LoadString(IDS_NONE);
        ListView_SetItemText(m_hSummaryList, i++, 1, (LPWSTR)(LPCTSTR)szItemText );
    }
    for (j=0; j<m_pwizHelp->EnhancedKeyUsage.cUsageIdentifier; j++)
    {
        if (j != 0)
        {
			ListView_NewItem(m_hSummaryList, i, L"");
        }
        
        pOIDInfo = CryptFindOIDInfo(
                        CRYPT_OID_INFO_OID_KEY,
                        m_pwizHelp->EnhancedKeyUsage.rgpszUsageIdentifier[j],
                        CRYPT_ENHKEY_USAGE_OID_GROUP_ID);

        if (pOIDInfo == NULL)
        {
            pszOIDName = MyMkWStr(m_pwizHelp->EnhancedKeyUsage.rgpszUsageIdentifier[j]);
            ListView_SetItemText(m_hSummaryList, i++, 1, pszOIDName);
            delete(pszOIDName);
        }
        else
        {
            ListView_SetItemText(m_hSummaryList, i++, 1, (LPWSTR)(LPCWSTR)pOIDInfo->pwszName);
        }
    }

    // enhanced key usage critical
    szItemName.LoadString(IDS_CERTIFICATE_PURPOSES_CRITICAL);
	ListView_NewItem(m_hSummaryList, i, szItemName);

    if (m_pwizHelp->fMarkEKUCritical)
        szItemText.LoadString(IDS_YES);
    else
        szItemText.LoadString(IDS_NO);
    ListView_SetItemText(m_hSummaryList, i++, 1, (LPWSTR)(LPCWSTR)szItemText);

    // include email address
    szItemName.LoadString(IDS_INCLUDE_EMAIL_ADDRESS);
	ListView_NewItem(m_hSummaryList, i, szItemName);

    if (m_pwizHelp->fIncludeEmail)
        szItemText.LoadString(IDS_YES);
    else
        szItemText.LoadString(IDS_NO);
    ListView_SetItemText(m_hSummaryList, i++, 1, (LPWSTR)(LPCWSTR)szItemText);

    // allow CA to fill in info
    szItemName.LoadString(IDS_ALLOW_CA_TO_FILL_IN);
	ListView_NewItem(m_hSummaryList, i, szItemName);

    if (m_pwizHelp->fAllowCAtoFillInInfo)
        szItemText.LoadString(IDS_YES);
    else
        szItemText.LoadString(IDS_NO);
    ListView_SetItemText(m_hSummaryList, i++, 1, (LPWSTR)(LPCWSTR)szItemText);

    // enabled for auto enroll
    szItemName.LoadString(IDS_ENABLED_FOR_AUTOENROLL);
	ListView_NewItem(m_hSummaryList, i, szItemName);

    if (m_pwizHelp->fAllowAutoEnroll)
        szItemText.LoadString(IDS_YES);
    else
        szItemText.LoadString(IDS_NO);
    ListView_SetItemText(m_hSummaryList, i++, 1, (LPWSTR)(LPCWSTR)szItemText);

    // KeyUsage
    szItemName.LoadString(IDS_PUBLIC_KEY_USAGE_LIST);
	ListView_NewItem(m_hSummaryList, i, szItemName);

    SetItemTextWrapper(
            IDS_DIGITAL_SIGNATURE_KEY_USAGE, 
            &i, 
            m_pwizHelp->KeyUsageBytes[0] & CERT_DIGITAL_SIGNATURE_KEY_USAGE, 
            &bKeyUsageFirstItem);

    SetItemTextWrapper(
            IDS_NON_REPUDIATION_KEY_USAGE, 
            &i, 
            m_pwizHelp->KeyUsageBytes[0] & CERT_NON_REPUDIATION_KEY_USAGE, 
            &bKeyUsageFirstItem);

    SetItemTextWrapper(
            IDS_DATA_ENCIPHERMENT_KEY_USAGE, 
            &i, 
            m_pwizHelp->KeyUsageBytes[0] & CERT_DATA_ENCIPHERMENT_KEY_USAGE, 
            &bKeyUsageFirstItem);
    
    SetItemTextWrapper(
            IDS_KEY_ENCIPHERMENT_KEY_USAGE, 
            &i, 
            m_pwizHelp->KeyUsageBytes[0] & CERT_KEY_ENCIPHERMENT_KEY_USAGE, 
            &bKeyUsageFirstItem);
    
    SetItemTextWrapper(
            IDS_KEY_AGREEMENT_KEY_USAGE, 
            &i, 
            m_pwizHelp->KeyUsageBytes[0] & CERT_KEY_AGREEMENT_KEY_USAGE, 
            &bKeyUsageFirstItem);

    SetItemTextWrapper(
            IDS_KEY_CERT_SIGN_KEY_USAGE, 
            &i, 
            m_pwizHelp->KeyUsageBytes[0] & CERT_KEY_CERT_SIGN_KEY_USAGE, 
            &bKeyUsageFirstItem);

    SetItemTextWrapper(
            IDS_OFFLINE_CRL_SIGN_KEY_USAGE, 
            &i, 
            m_pwizHelp->KeyUsageBytes[0] & CERT_CRL_SIGN_KEY_USAGE, 
            &bKeyUsageFirstItem);
    
    SetItemTextWrapper(
            IDS_ENCIPHER_ONLY_KEY_USAGE, 
            &i, 
            m_pwizHelp->KeyUsageBytes[0] & CERT_ENCIPHER_ONLY_KEY_USAGE, 
            &bKeyUsageFirstItem);

    SetItemTextWrapper(
            IDS_DECIPHER_ONLY_KEY_USAGE, 
            &i, 
            m_pwizHelp->KeyUsageBytes[1] & CERT_DECIPHER_ONLY_KEY_USAGE, 
            &bKeyUsageFirstItem);

    // KeyUsage critical
    szItemName.LoadString(IDS_PUBLIC_KEY_USAGE_CRITICAL);
	ListView_NewItem(m_hSummaryList, i, szItemName);

    if (m_pwizHelp->fMarkKeyUsageCritical)
        szItemText.LoadString(IDS_YES);
    else
        szItemText.LoadString(IDS_NO);
    ListView_SetItemText(m_hSummaryList, i++, 1, (LPWSTR)(LPCWSTR)szItemText);

    ListView_SetColumnWidth(m_hSummaryList, 0, LVSCW_AUTOSIZE);
    ListView_SetColumnWidth(m_hSummaryList, 1, LVSCW_AUTOSIZE);
}

BOOL CNewCertTypeCompletion::OnInitDialog() 
{
	CWizard97PropertyPage::OnInitDialog();

    m_hSummaryList = GetDlgItem(m_hWnd, IDC_SUMMARY_LIST);

    // firstlast page
    SendMessage(GetDlgItem(IDC_COMPLETION_BIGBOLD_STATIC), WM_SETFONT, (WPARAM)GetBigBoldFont(), MAKELPARAM(TRUE, 0));

    ListView_NewColumn(m_hSummaryList, 0, 50);
    ListView_NewColumn(m_hSummaryList, 1, 50);
    
    return TRUE;  // return TRUE unless you set the focus to a control
	              // EXCEPTION: OCX Property Pages should return FALSE
}

void CNewCertTypeCompletion::SetItemTextWrapper(UINT nID, int *piItem, BOOL fDoInsert, BOOL *pfFirstUsageItem)
{
    CString szOtherInfoName;
    
    if (fDoInsert)
    {
        szOtherInfoName.LoadString(nID);
        if (!(*pfFirstUsageItem))
        {
            LVITEM lvItem;
            lvItem.iItem = *piItem;
            lvItem.iSubItem = 0;
            ListView_InsertItem(m_hSummaryList, &lvItem);
        }
        else
        {
            *pfFirstUsageItem = FALSE;
        }
        ListView_SetItemText(m_hSummaryList, *piItem, 1, (LPWSTR)(LPCTSTR)szOtherInfoName);
        (*piItem)++;
    }
}

BOOL CNewCertTypeCompletion::OnSetActive() 
{
    PropSheet_SetWizButtons(GetParent(), PSWIZB_BACK | PSWIZB_FINISH);
    
    ListView_DeleteAllItems(m_hSummaryList);
    AddResultsToSummaryList();
    
    return CWizard97PropertyPage::OnSetActive();
}


HRESULT UpdateCertType(HCERTTYPE hCertType, 
                       PWIZARD_HELPER pwizHelp)
{
    HRESULT hr;
    LPWSTR  aszCertName[2];
    LPWSTR  *aszCSPList = NULL;
    DWORD   dwFlags;
    BOOL    fUseKeyUsage;
    BOOL    fUseBasicConstraints;
    unsigned int     i;

    //
    // get the flags for the cert type, then modify those, and reset the
    // flags at the end of this function
    //
    hr = CAGetCertTypeFlags(hCertType, &dwFlags);

    _JumpIfError(hr, error, "CAGetCertTypeFlags");

    //
    // key usage
    //
    fUseKeyUsage = (pwizHelp->KeyUsageBytes[0] != 0) || (pwizHelp->KeyUsageBytes[1] != 0);
    hr = CASetCertTypeExtension(
                hCertType,
                TEXT(szOID_KEY_USAGE),
                pwizHelp->fMarkKeyUsageCritical ? CA_EXT_FLAG_CRITICAL : 0,
                fUseKeyUsage ? pwizHelp->pKeyUsage : NULL);

    _JumpIfError(hr, error, "CASetCertTypeExtension");


    //
    // enhanced key usage
    //
    hr = CASetCertTypeExtension(
            hCertType,
            TEXT(szOID_ENHANCED_KEY_USAGE),
            pwizHelp->fMarkEKUCritical ? CA_EXT_FLAG_CRITICAL : 0,
            &(pwizHelp->EnhancedKeyUsage));
    _JumpIfError(hr, error, "CASetCertTypeExtension");


    //
    // basic constraints
    //
    fUseBasicConstraints = pwizHelp->BasicConstraints2.fCA;
    hr = CASetCertTypeExtension(
                hCertType,
                TEXT(szOID_BASIC_CONSTRAINTS2),
                0,
                fUseBasicConstraints ? &(pwizHelp->BasicConstraints2) : NULL);
    _JumpIfError(hr, error, "CASetCertTypeExtension");
    
    //
    // friendly name
    //
    aszCertName[0] = (LPWSTR) ((LPCTSTR) *(pwizHelp->pcstrFriendlyName));
    aszCertName[1] = NULL;
    hr = CASetCertTypeProperty(
                hCertType,
                CERTTYPE_PROP_FRIENDLY_NAME,
                aszCertName);
    _JumpIfError(hr, error, "CASetCertTypeProperty");

    //
    // digsig/exchange
    //
    if (pwizHelp->fDigitalSignatureContainer)
    {
        hr = CASetCertTypeKeySpec(hCertType, AT_SIGNATURE);
    }
    else
    {
        hr = CASetCertTypeKeySpec(hCertType, AT_KEYEXCHANGE);
    }
    _JumpIfError(hr, error, "CASetCertTypeKeySpec");

    //
    // csp list
    //
    aszCSPList = (LPWSTR *) new(LPWSTR[pwizHelp->cCSPs+1]);

    if(aszCSPList == NULL)
    {
        hr = E_OUTOFMEMORY;
        _JumpIfError(hr, error, "new");

    }

    ZeroMemory(aszCSPList, sizeof(LPWSTR)*(pwizHelp->cCSPs+1));

    //
    // copy each the array of CStrings to an array of LPWSTRs
    //
    for (i=0; i<pwizHelp->cCSPs; i++)
    {
        aszCSPList[i] = new(WCHAR[wcslen((LPCTSTR)pwizHelp->rgszCSPList[i])+1]);

        if (aszCSPList[i] == NULL)
        {
            hr = E_OUTOFMEMORY;
            _JumpIfError(hr, error, "new");
            break;
        }

        wcscpy(aszCSPList[i], (LPCTSTR)pwizHelp->rgszCSPList[i]);
    }

    //
    // NULL terminate the LPWSTR array and set the CSPlist property
    //
    if (i == pwizHelp->cCSPs)
    {
        aszCSPList[i] = NULL;
        hr = CASetCertTypeProperty(
                    hCertType,
                    CERTTYPE_PROP_CSP_LIST,
                    aszCSPList);
        _JumpIfError(hr, error, "CASetCertTypeProperty");
    }

    //
    // Acls
    //
    if(pwizHelp->pSD)
    {
        hr = CACertTypeSetSecurity(hCertType, pwizHelp->pSD);
        _JumpIfError(hr, error, "CACertTypeSetSecurity");

    }

    //
    // private key exportable, include email, allow CA to fill in name
    //
    if (pwizHelp->fPrivateKeyExportable)
    {
        dwFlags |= CT_FLAG_EXPORTABLE_KEY;
    }
    else
    {
        dwFlags &= ~CT_FLAG_EXPORTABLE_KEY;
    }

    if (pwizHelp->fIncludeEmail)
    {
        dwFlags |= CT_FLAG_ADD_EMAIL;
    }
    else
    {
        dwFlags &= ~CT_FLAG_ADD_EMAIL;
    }

    if (pwizHelp->fAllowAutoEnroll)
    {
        dwFlags |= CT_FLAG_AUTO_ENROLLMENT;
    }
    else
    {
        dwFlags &= ~CT_FLAG_AUTO_ENROLLMENT;
    }

    if (!pwizHelp->fAllowCAtoFillInInfo)
    {
        dwFlags |= CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT;
    }
    else
    {
        dwFlags &= ~CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT;
    }

    if (pwizHelp->fMachine)
    {
        dwFlags |= CT_FLAG_MACHINE_TYPE;
    }
    else
    {
        dwFlags &= ~CT_FLAG_MACHINE_TYPE;
    }

    if (pwizHelp->fPublishToDS)
    {
        dwFlags |= CT_FLAG_PUBLISH_TO_DS;
    }
    else
    {
        dwFlags &= ~CT_FLAG_PUBLISH_TO_DS;
    }

    if (pwizHelp->fAddTemplateName)
    {
        dwFlags |= CT_FLAG_ADD_TEMPLATE_NAME;
    }
    else
    {
        dwFlags &= ~CT_FLAG_ADD_TEMPLATE_NAME;
    }

    if (pwizHelp->fAddDirectoryPath)
    {
        dwFlags |= CT_FLAG_ADD_DIRECTORY_PATH;
    }
    else
    {
        dwFlags &= ~CT_FLAG_ADD_DIRECTORY_PATH;
    }

    hr = CASetCertTypeFlags(hCertType, dwFlags);

    _JumpIfError(hr, error, "CASetCertTypeFlags");
    //
    // make the call that actually writes the cached information
    //

     hr = CAUpdateCertType(hCertType);
     // So we can get logging
    _JumpIfError(hr, error, "CAUpdateCertType");

error:

    if(aszCSPList)
    {

        for (i=0; i<pwizHelp->cCSPs; i++)
        {
            if(aszCSPList[i])
            {
                delete[](aszCSPList[i]);
            }
        }
        delete[](aszCSPList);
    }

    return hr;
}

// returns the new certtype if a new one is being created, returns NULL
// if the hEditCertType parameter is non-NULL which means it is in edit mode
HCERTTYPE InvokeCertTypeWizard(HCERTTYPE hEditCertType, 
                               HWND hwndConsole)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());

    WIZARD_HELPER   wizHelp;
    ZeroMemory(&wizHelp, sizeof(wizHelp));

    int             i;
    HCERTTYPE       hNewCertType;
    HCERTTYPE       hRetCertType;
    HRESULT         hr;

    CWizard97PropertySheet PropSheet(
				g_hInstance,
				IDS_CERTIFICATE_TEMPLATE_WIZARD,
				IDB_WIZ_WATERMARK,
				IDB_WIZ_BANNER,
				TRUE);

    CString                         szPropSheetTitle;
    CNewCertTypeWelcome             WelcomePage;
    CNewCertTypeBaseType            BaseTypePage;
    CNewCertTypeBasicInformation    BasicInformationPage;
    CNewCertTypeKeyUsage            KeyUsagePage;
    CNewCertTypeCACertificate       CACertificatePage;
    CNewCertTypeCompletion          CompletionPage;

    wizHelp.pcstrFriendlyName = new(CString);
    if (wizHelp.pcstrFriendlyName == NULL)
        return NULL;

    wizHelp.pcstrBaseCertName = new(CString);
    if(wizHelp.pcstrBaseCertName == NULL)
        return NULL;

    hr = SetupFonts(g_hInstance, NULL, &wizHelp.BigBoldFont, &wizHelp.BoldFont);
    
    if (hEditCertType != NULL)
    {
        wizHelp.fInEditCertTypeMode = TRUE;
        FillInCertTypeInfo(hEditCertType, &wizHelp);
    }

    WelcomePage.m_pwizHelp = &wizHelp;
    WelcomePage.m_pWiz = &PropSheet;
    PropSheet.AddPage(&WelcomePage);
    
    BaseTypePage.m_pwizHelp = &wizHelp;
    BaseTypePage.m_pWiz = &PropSheet;
    PropSheet.AddPage(&BaseTypePage);

    BasicInformationPage.m_pwizHelp = &wizHelp;
    BasicInformationPage.m_pWiz = &PropSheet;
    PropSheet.AddPage(&BasicInformationPage);

    KeyUsagePage.m_pwizHelp = &wizHelp;
    KeyUsagePage.m_pWiz = &PropSheet;
    PropSheet.AddPage(&KeyUsagePage);

    CACertificatePage.m_pwizHelp = &wizHelp;
    CACertificatePage.m_pWiz = &PropSheet;
    PropSheet.AddPage(&CACertificatePage);

    CompletionPage.m_pwizHelp = &wizHelp;
    CompletionPage.m_pWiz = &PropSheet;
    PropSheet.AddPage(&CompletionPage);

    if (PropSheet.DoWizard(hwndConsole))
    {
        if (hEditCertType != NULL)
        {
            hr = UpdateCertType(hEditCertType, &wizHelp);
            hRetCertType = NULL;
        }
        else
        {
            GUID    guidContainerName;
            WCHAR   *sz = NULL;

            // generate a CN name for the new certtype
            RPC_STATUS rpcs = UuidCreate(&guidContainerName);
            rpcs = UuidToStringW(&guidContainerName, &sz);
            ASSERT(sz != NULL);

            hr = CACreateCertType(sz, NULL, 0, &hNewCertType);
            RpcStringFree(&sz);
            hr = UpdateCertType(hNewCertType, &wizHelp);
            hRetCertType = hNewCertType;
        }
    }
    else
    {
        hRetCertType = NULL;
    }

    CleanUpCertTypeInfo(&wizHelp);

    delete(wizHelp.pcstrFriendlyName);
    delete(wizHelp.pcstrBaseCertName);

    return hRetCertType;   
}