ScvpResponderEntryDlg.cpp

Go to the documentation of this file.

#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) && defined(PKIFRESOURCES_ALLOW_GCC_PRAGMA)
    #pragma implementation "ScvpResponderEntryDlg.cpp"
#endif

//Pick up PKIF windows SDK configuration macros instead of WX's 
#include "PKIFdll.h"
// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#include "ScvpResponderEntryDlg.h"
#ifdef __INCLUDE_SCVP_SUPPORT__
#include "PKIFSCVP.h"
#endif
#include "ExtractInfoFromCertDlg.h"
#include "CredentialSelectorDlg.h"
#include "EvidenceRecordVerifierDlg.h"
#include "ResourceUtils.h"
#include "PkiEnvironmentDefinitionNotebook.h"
#include "PathSettingsNotebook.h"
#include "PKIFCMS.h"

#include <sstream>
#include <iomanip>

using namespace boost;
using namespace std;

//implemented in OcspResponderEntryDlg.cpp
void DisplayCertificateDetails(const CPKIFCertificatePtr& cert, wxTextCtrl* tcSubjectName, wxTextCtrl* tcSkid);

//Using the global OIDs from PKIFSCVP won't work with delayed loading, so we'll keep our own copies
CPKIFOIDPtr g_id_swb_pkc_best_cert_path2
    (new CPKIFOID(CPKIFStringPtr(new std::string("1.3.6.1.5.5.7.18.1"))));//id_swb_pkc_best_cert_path
CPKIFOIDPtr g_id_swb_pkc_revocation_info2
    (new CPKIFOID(CPKIFStringPtr(new std::string("1.3.6.1.5.5.7.18.2"))));//id_swb_pkc_revocation_info
CPKIFOIDPtr g_id_swb_pkc_cert2
    (new CPKIFOID(CPKIFStringPtr(new std::string("1.3.6.1.5.5.7.18.10"))));//id_swb_pkc_cert
CPKIFOIDPtr g_idSwbPartialCertPath2
    (new CPKIFOID(CPKIFStringPtr(new std::string("1.3.6.1.5.5.7.18.15"))));

CPKIFOIDPtr g_idSwbErsPkcCert2
    (new CPKIFOID(CPKIFStringPtr(new std::string("1.3.6.1.5.5.7.18.16"))));
CPKIFOIDPtr g_idSwbErsPartialCertPath2
    (new CPKIFOID(CPKIFStringPtr(new std::string("1.3.6.1.5.5.7.18.18"))));
CPKIFOIDPtr g_idSwbErsRevocationInfo2
    (new CPKIFOID(CPKIFStringPtr(new std::string("1.3.6.1.5.5.7.18.19"))));

CPKIFOIDPtr g_id_ct_scvp_valPolResponse2
    (new CPKIFOID(CPKIFStringPtr(new std::string("1.2.840.113549.1.9.16.1.13"))));//id-ct-scvp-valPolResponse

// WDR: class implementations

//----------------------------------------------------------------------------
// CScvpResponderEntryDlg
//----------------------------------------------------------------------------

// WDR: event table for CScvpResponderEntryDlg

BEGIN_EVENT_TABLE(CScvpResponderEntryDlg,wxDialog)
    //General events
    EVT_INIT_DIALOG( CScvpResponderEntryDlg::OnInitDialog )

    //Want backs group box events
    //NONE

    //Validation policy group box events
    EVT_BUTTON( ID_BUTTON_GET_VAL_POL, CScvpResponderEntryDlg::OnLoadNow )

    //SCVP request signing credential group box events
    EVT_BUTTON( ID_BUTTON_CLEAR_CRED_SCVP, CScvpResponderEntryDlg::OnClearCredential )
    EVT_BUTTON( ID_BUTTON_SELECT_CRED_SCVP, CScvpResponderEntryDlg::OnSelectCredential )
    
    //Acceptable namespaces group box events
    EVT_BUTTON( ID_BUTTON_ADD_NAMESPACE_SCVP, CScvpResponderEntryDlg::OnAddNamespace )
    EVT_BUTTON( ID_BUTTON_REMOVE_NAMESPACE_SCVP, CScvpResponderEntryDlg::OnRemoveNamespace )

    //Settings for SCVP response verification group box events
    EVT_BUTTON( ID_BUTTON_SCVP_RESPONSE_PATH, CScvpResponderEntryDlg::OnScvpResponsePath )
    EVT_BUTTON( ID_BUTTON_SCVP_RESPONSE_MEDS, CScvpResponderEntryDlg::OnScvpResponseMeds )
    EVT_CHECKBOX( ID_CHECKBOX_SCVP_RESPONSE_MEDS, CScvpResponderEntryDlg::OnCheckScvpResponseMeds )
    EVT_CHECKBOX( ID_CHECKBOX_SCVP_RESPONSE_PATH, CScvpResponderEntryDlg::OnCheckScvpResponsePath )

    //Custom validation policy group box events
    EVT_CHECKBOX( ID_CHECKBOX_VAL_POL_PATH, CScvpResponderEntryDlg::OnCheckValPolPath )
    EVT_BUTTON( ID_BUTTON_VAL_POL_PATH, CScvpResponderEntryDlg::OnValPolPath )

    //OK and CANCEL button events
    EVT_BUTTON( wxID_OK, CScvpResponderEntryDlg::OnOk )
    EVT_BUTTON( wxID_CANCEL, CScvpResponderEntryDlg::OnCancel )
    EVT_BUTTON( ID_BUTTON_CONFIGURE_ER_VERIFIER, CScvpResponderEntryDlg::OnClickConfigureErVerifier )

    
    //SCVP SCVP DPD only event
    EVT_CHECKBOX( ID_CHECK_SCVP_DPD_ONLY, CScvpResponderEntryDlg::OnClickSCVPDPDOnly )
END_EVENT_TABLE()
CScvpResponderEntryDlg::CScvpResponderEntryDlg( wxWindow *parent, wxWindowID id, const wxString &title,
    const wxPoint &position, const wxSize& size, long style ) :
    wxDialog( parent, id, title, position, size, style )
{
    m_bDpdOnly = false;
    m_bGenerateNonce = false;
    m_bRequireNonceMatch = false;
    m_bRequireSignedDPD = false;
    m_bFetchValPol = false;

    // WDR: dialog function ScvpResponderEntryDlg for CScvpResponderEntryDlg
    ScvpResponderEntryDlg( this, TRUE ); 
}
CScvpResponderEntryDlg::~CScvpResponderEntryDlg()
{
}
const char* MakeTimePurty(
    CPKIFTimePtr& t,
    std::string& s)
{
    std::ostringstream oss;
    switch(t->month())
    {
    case 1:
        oss << "January";
        break;
    case 2:
        oss << "February";
        break;
    case 3:
        oss << "March";
        break;
    case 4:
        oss << "April";
        break;
    case 5:
        oss << "May";
        break;
    case 6:
        oss << "June";
        break;
    case 7:
        oss << "July";
        break;
    case 8:
        oss << "August";
        break;
    case 9:
        oss << "September";
        break;
    case 10:
        oss << "October";
        break;
    case 11:
        oss << "November";
        break;
    case 12:
        oss << "December";
        break;
    }

    oss << " " << t->dayOfMonth() << ", " << t->year() << " " <<
        std::setw(2) << std::setfill('0') << t->hours() << ":" <<
        std::setw(2) << std::setfill('0') << t->minutes() << ":" <<
        std::setw(2) << std::setfill('0')<< t->seconds() << ends;
    s = oss.str();
    return s.c_str();
}
void CScvpResponderEntryDlg::DisplayValPolTime()
{
#ifdef __INCLUDE_SCVP_SUPPORT__
    if(!m_valPol)
        return;

    try
    {
        CPKIFOIDPtr contentType = m_valPol->GetContentType();
        if(!contentType || (*g_signedData != *contentType))
            throw CPKIFException(TOOLKIT_SCVP_SUBCOMPONENT, COMMON_INVALID_INPUT, "Unexpected ValPol contents.  SignedData not present.");

        CPKIFBufferPtr content = m_valPol->GetContent();

        CPKIFSignedData sd;
        sd.Decode(content);

        CPKIFEncapsulatedContentInfoPtr ecip = sd.GetEncapsulatedContent();
        CPKIFOIDPtr ecipOid = ecip->GetOID();
        if(!ecipOid || (*g_id_ct_scvp_valPolResponse2 != *ecipOid))
            throw CPKIFException(TOOLKIT_SCVP_SUBCOMPONENT, COMMON_INVALID_INPUT, "Unexpected ValPol contents.  ValPolRepsonse not present.");

        CPKIFBufferPtr ecipBuf = ecip->GetContent();
        CPKIFValPolResponsePtr vp(new CPKIFValPolResponse);
        vp->Decode(ecipBuf);

        CPKIFTimePtr thisUpdate = vp->GetThisUpdate();
        CPKIFTimePtr nextUpdate = vp->GetNextUpdate();

        ostringstream oss;
        std::string strref;
        if(!nextUpdate)
            oss << "Current policy valid since " << MakeTimePurty(thisUpdate, strref) << ends;
        else
            oss << "Current policy valid until " << MakeTimePurty(nextUpdate, strref) << ends;

        wxStaticText* text = GetTextValpolStatus();
        wxString label(oss.str().c_str(),wxConvUTF8);
        text->SetLabel(label);

        wxComboBox* cbValPols = GetComboBoxValpol();
        cbValPols->Clear();
        CPKIFOIDListPtr valPols;
        vp->GetValidationPolicies(valPols);
        if(valPols)
        {
            CPKIFOIDList::iterator pos = valPols->begin();
            CPKIFOIDList::iterator end = valPols->end();
            for(; pos != end; ++pos)
            {
                cbValPols->Append((*pos)->ToString());
            }
        }
    }
    catch(...)
    {
    }   
#endif
}
void CScvpResponderEntryDlg::ClearMembers()
{
    m_url = wxEmptyString;
    m_bDpdOnly = false;
    m_bGenerateNonce = false;
    m_bRequireNonceMatch = false;
    m_bRequireSignedDPD = false;

    //Want backs group box
    CPKIFOIDListPtr emptyWBs;
    m_wantBacks = emptyWBs;

    //Validation policy group box
    CPKIFContentInfoPtr emptyVP;
    m_valPol = emptyVP;
    m_bFetchValPol = false;

    //SCVP request signing credential group box
    CPKIFCredentialPtr emptyCred;
    m_cred = emptyCred;

    IPKIFMediatorPtr emptyMeds;
    m_medsForCreds = emptyMeds;

    //Acceptable namespaces group box
    CPKIFGeneralSubtreeList emptyNames;
    m_rndList = emptyNames;

    //Settings for SCVP response verification group box
    m_scvpResponseMeds = emptyMeds;

    CPKIFPathSettingsPtr emptyPath;
    m_scvpResponsePath = emptyPath;

    //Custom validation policy group box
    m_valPolPath = emptyPath;
}

// WDR: handler implementations for CScvpResponderEntryDlg

//**********************************************************************************************
//  Dialog events
//**********************************************************************************************
bool CScvpResponderEntryDlg::Validate()
{
    return TRUE;
}
bool CScvpResponderEntryDlg::TransferDataToWindow()
{
    return TRUE;
}
bool CScvpResponderEntryDlg::TransferDataFromWindow()
{
    return TRUE;
}

//**********************************************************************************************
//  Button-related events
//**********************************************************************************************
void CScvpResponderEntryDlg::OnOk(wxCommandEvent &event)
{
    wxTextCtrl* tc = GetTextUrlScvp();
    wxASSERT(tc);
    wxString url = tc->GetValue();
    if(url.IsEmpty())
    {
        wxMessageBox(wxT("You must specify at least a URI or click Cancel to dismiss this dialog."));
        return;
    }

    m_url = url;

    event.Skip();
}
void CScvpResponderEntryDlg::OnCancel(wxCommandEvent &event)
{
    event.Skip();
}
void CScvpResponderEntryDlg::OnLoadNow( wxCommandEvent &event )
{
#ifdef __INCLUDE_SCVP_SUPPORT__
    CPKIFValPolRequestPtr vr(new CPKIFValPolRequest);
    vr->SetGenerateNonce(true);

    CPKIFBufferPtr encVR = vr->Encode();

    CPKIFOIDPtr id_ct_scvp_valPolRequest
        (new CPKIFOID(CPKIFStringPtr(new std::string("1.2.840.113549.1.9.16.1.12"))));//id-ct-scvp-valPolRequest

    CPKIFContentInfo ci;
    ci.SetContent(encVR);
    ci.SetContentType(id_ct_scvp_valPolRequest);

    CPKIFBufferPtr resp;
    CPKIFBufferPtr encReq = ci.Encode();
    if(PostRequestURL(encReq, resp, GetTextUrlScvp()->GetValue().mb_str(), PKIF_SCVP_VAL_POL)) 
    {
        try
        {
            const unsigned char* xxx = resp->GetBuffer();
            int xxxlen = resp->GetLength();

            CPKIFContentInfoPtr ci(new CPKIFContentInfo);
            ci->Decode(xxx, xxxlen);
            m_valPol = ci;
            DisplayValPolTime();
        }
        catch(...)
        {
        }
    }
#endif
}
void CScvpResponderEntryDlg::OnScvpResponseMeds( wxCommandEvent &event )
{
    CPKIFPkiEnvironmentDefinitionNotebook pedn(NULL,-1,wxT("PKI Environment Definition for SCVP Response Processing"),
        wxDefaultPosition,wxDefaultSize, wxDEFAULT_DIALOG_STYLE, false);
    pedn.SetInitialMediator(m_scvpResponseMeds);
    pedn.Center();
    wxButton * okButton = (wxButton *)pedn.FindWindow(wxID_OK);
    if(okButton) okButton->SetLabel(wxT("Save"));
    if(wxID_OK == pedn.ShowModal())
    {
        m_scvpResponseMeds = pedn.GetMediator();
    }
}
void CScvpResponderEntryDlg::OnScvpResponsePath( wxCommandEvent &event )
{
    CPKIFPathSettingsNotebook psn(NULL,-1,wxT("Path Validation Settings for SCVP Response Processing"),wxDefaultPosition,wxDefaultSize,
        wxDEFAULT_DIALOG_STYLE);
    psn.SetInitialPathSettings(m_scvpResponsePath);
    psn.Center();
    wxButton * okButton = (wxButton *)psn.FindWindow(wxID_OK);
    if(okButton) okButton->SetLabel(wxT("Save"));
    if(wxID_OK == psn.ShowModal())
    {
        m_scvpResponsePath = psn.GetPathSettings();
    }
}
void CScvpResponderEntryDlg::OnValPolPath( wxCommandEvent &event )
{
    CPKIFPathSettingsNotebook psn(NULL,-1,wxT("Path Validation Settings for Custom Validation Policy"),wxDefaultPosition,wxDefaultSize,
        wxDEFAULT_DIALOG_STYLE);
    psn.SetInitialPathSettings(m_valPolPath);
    psn.Center();
    wxButton * okButton = (wxButton *)psn.FindWindow(wxID_OK);
    if(okButton) okButton->SetLabel(wxT("Save"));
    if(wxID_OK == psn.ShowModal())
    {
        m_valPolPath = psn.GetPathSettings();
    }
}
void CScvpResponderEntryDlg::OnCheckValPolPath( wxCommandEvent &event )
{
    if(GetCheckboxValPolMeds()->GetValue())
    {
        GetValPolMeds()->Enable();
    }
    else
    {
        GetValPolMeds()->Enable(false);
    }
}
void CScvpResponderEntryDlg::OnCheckScvpResponsePath( wxCommandEvent &event )
{
    if(GetCheckboxScvpResponsePath()->GetValue())
    {
        GetScvpResponsePath()->Enable();
    }
    else
    {
        GetScvpResponsePath()->Enable(false);
    }
}
void CScvpResponderEntryDlg::OnCheckScvpResponseMeds( wxCommandEvent &event )
{
    if(GetCheckboxScvpResponseMeds()->GetValue())
    {
        GetScvpResponseMeds()->Enable();
    }
    else
    {
        GetScvpResponseMeds()->Enable(false);
    }
}
void CScvpResponderEntryDlg::OnRemoveNamespace( wxCommandEvent &event )
{
    wxListBox* lb = GetListboxNamespacesScvp();
    wxASSERT(lb);
    int sel = lb->GetSelection();
    string selection;
    if(wxNOT_FOUND != sel)
    {
        selection = lb->GetStringSelection().mb_str();
        lb->Delete(sel);
    }

    CPKIFGeneralSubtreeList::iterator pos;
    CPKIFGeneralSubtreeList::iterator end = m_rndList.end();
    for(pos = m_rndList.begin(); pos != end; ++pos)
    {
        string str1 = (*pos)->GetBase()->directoryName()->ToString();
        if(strcmp(str1.c_str(), selection.c_str()) == 0 )
        {
            m_rndList.erase(pos);
            break;
        }
    }
}
void CScvpResponderEntryDlg::OnAddNamespace( wxCommandEvent &event )
{
    static wxString filter = wxT("Certificate files (*.cer, *.der, *.crt)|*.cer;*.der;*.crt|All files (*.*)|*.*");
    wxString certLocation = wxFileSelector(wxT("Select Certificate File"), 0, 0, 0, filter);//wxT("CRT files (*.crt)|*.crt|DER files (*.der)|*.der|CER files (*.cer)|*.cer"));
    if(certLocation != wxT(""))
    {
        try {
            CExtractInfoFromCertDialog dlg((wxWindow *) this, -1 , wxT("Extract Info From Certificate"), wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE, certLocation);
            dlg.Centre();
            if(wxID_OK == dlg.ShowModal())
            {   
                CPKIFGeneralSubtreePtr ns = dlg.GetNamespace();

                m_rndList.push_back(ns);
                wxString wxNS(ns->GetBase()->directoryName()->ToString(),wxConvUTF8);
                GetListboxNamespacesScvp()->InsertItems(1, &wxNS, 0);
            }
        }catch(CPKIFException &){
            wxMessageBox(wxT("Unable to decode certificate."),wxT("Error"),wxICON_ERROR|wxOK);
        }
    }
}
void CScvpResponderEntryDlg::OnClearCredential( wxCommandEvent &event )
{
    CPKIFCredentialPtr emptyCred;
    m_cred = emptyCred;

    GetTextSignersNameScvp()->Clear();
    GetTextSignersSkidScvp()->Clear();
}
void CScvpResponderEntryDlg::OnSelectCredential( wxCommandEvent &event )
{
    CPKIFCredentialSelectorDlg dlg(this, -1, wxT("Select a credential"));
    dlg.SetMediator(m_medsForCreds);
    if(wxID_OK == dlg.ShowModal())
    {
        m_cred = dlg.GetSelectedCredential();
        DisplayCertificateDetails(m_cred->GetCertificate(), GetTextSignersNameScvp(), GetTextSignersSkidScvp());
    }
}

void CScvpResponderEntryDlg::SetInitialScvpClient(IPKIFScvpClientPtr& scvp)
{
#ifdef __INCLUDE_SCVP_SUPPORT__
    if(scvp)
    {
        //*********************************************************************************************
        //SCVP responder location information group box
        //*********************************************************************************************
        const char* url = scvp->GetResponderUrl();
        if(url)
        {
            wxString wxURLString(url,wxConvUTF8);
            m_url = wxURLString;
        }
        else
        {
            m_url = wxEmptyString;
        }

        CPKIFScvpPathBuildPtr dpd = dynamic_pointer_cast<CPKIFScvpPathBuild, IPKIFScvpClient>(scvp);
        if(dpd)
        {
            m_bDpdOnly = true;
            if(dpd->GetUseValidPkcPathCertCheck())
            {
                GetResponderValidatedDpd()->SetValue(true);
            }
            else
            {
                GetClientValidatedDpd()->SetValue(true);
            }

        }
        else
            m_bDpdOnly = false;

        //we do not distinguish between including a nonce and requiring a nonce.
        m_bGenerateNonce = scvp->GetRequireNonceMatch();
        m_bRequireNonceMatch = m_bGenerateNonce;

        m_bRequireSignedDPD = scvp->GetRequireSignedDPD();

        //*********************************************************************************************
        //Want backs group box
        //*********************************************************************************************
        m_wantBacks = scvp->GetWantBacks();

        //*********************************************************************************************
        //Evidence record verifier group box
        //*********************************************************************************************
        m_erv = scvp->GetEvidenceRecordVerifier();

        //*********************************************************************************************
        //Validation policy group box
        //*********************************************************************************************
        m_valPol = scvp->GetValPol();
        m_bFetchValPol = scvp->GetFetchValPolWhenLoading();

        //*********************************************************************************************
        //SCVP request signing credential group box
        //*********************************************************************************************
        m_cred = scvp->GetSigningCredential();

        //*********************************************************************************************
        //Acceptable namespaces group box
        //*********************************************************************************************
        m_rndList = scvp->GetNamespaces();

        //*********************************************************************************************
        //Settings for SCVP response verification group box
        //*********************************************************************************************
        m_scvpResponseMeds = scvp->GetMediator();
        m_scvpResponsePath = scvp->GetPathSettings();

        //*********************************************************************************************
        //Custom validation policy group box
        //*********************************************************************************************
        m_valPolPath = scvp->GetPathSettingsForValPol();
    }
    else
#endif
    {
        ClearMembers();
    }
}
void CScvpResponderEntryDlg::OnClickConfigureErVerifier( wxCommandEvent &event )
{
    #ifdef __INCLUDE_SCVP_SUPPORT__
    CEvidenceRecordVerifierDlg dlg(this, -1, wxT("Configure your evidence record verifier"));
    dlg.SetInitialEvidenceRecordVerifier(m_erv);
    if(dlg.ShowModal())
    {
        m_erv = dlg.GetEvidenceRecordVerifier();
    }
    #endif
}
void CScvpResponderEntryDlg::OnClickSCVPDPDOnly( wxCommandEvent &event )
{
    if(GetCheckScvpDpdOnly()->GetValue())
    {
        GetClientValidatedDpd()->Enable();
        GetResponderValidatedDpd()->Enable();
    }
    else
    {
        GetClientValidatedDpd()->Enable(false);
        GetResponderValidatedDpd()->Enable(false);
    }
}
//**********************************************************************************************
//  Sow and reap
//**********************************************************************************************

void CScvpResponderEntryDlg::OnInitDialog(wxInitDialogEvent& event)
{
    //*********************************************************************************************
    //SCVP responder location information group box
    //*********************************************************************************************
    if(!m_url.IsEmpty())
        GetTextUrlScvp()->SetValue(m_url);

    GetCheckScvpDpdOnly()->SetValue(m_bDpdOnly);
    if(m_bDpdOnly)
    {
        GetClientValidatedDpd()->Enable();
        GetResponderValidatedDpd()->Enable();
    }
    GetCheckRequireSignedDpd()->SetValue(m_bRequireSignedDPD);
    GetCheckRequireNonce()->SetValue(m_bRequireNonceMatch);

    //*********************************************************************************************
    //Want backs group box
    //*********************************************************************************************
    if(m_wantBacks)
    {
        CPKIFOIDList::iterator wbPos;
        CPKIFOIDList::iterator wbEnd = m_wantBacks->end();
        for(wbPos = m_wantBacks->begin(); wbPos != wbEnd; ++wbPos)
        {
            if(*g_id_swb_pkc_best_cert_path2 == *(*wbPos))
                GetCertPathWB()->SetValue(true);
            else if(*g_id_swb_pkc_revocation_info2 == *(*wbPos))
                GetRevInfoWB()->SetValue(true);
            else if(*g_id_swb_pkc_cert2 == *(*wbPos))
                GetTargetCertWB()->SetValue(true);
            else if(*g_idSwbPartialCertPath2 == *(*wbPos))
                GetPartialPathWB()->SetValue(true);
            else if(*g_idSwbErsPkcCert2 == *(*wbPos))
                GetErsTargetCertWB()->SetValue(true);
            else if(*g_idSwbErsPartialCertPath2 == *(*wbPos))
                GetErsPartialPathWB()->SetValue(true);
            else if(*g_idSwbErsRevocationInfo2 == *(*wbPos))
                GetErsRevInfoWB()->SetValue(true);
        }
    }

    //*********************************************************************************************
    //Validation policy group box
    //*********************************************************************************************
    GetCheckboxFetchValpol()->SetValue(m_bFetchValPol);
    if(m_valPol)
    {
        DisplayValPolTime();
    }

    //*********************************************************************************************
    //SCVP request signing credential group box
    //*********************************************************************************************
    if(m_cred != (CPKIFCredential*)NULL)
        DisplayCertificateDetails(m_cred->GetCertificate(), GetTextSignersNameScvp(), GetTextSignersSkidScvp());

    //*********************************************************************************************
    //Acceptable namespaces group box
    //*********************************************************************************************
    CPKIFGeneralSubtreeList::iterator pos;
    CPKIFGeneralSubtreeList::iterator end = m_rndList.end();
    for(pos = m_rndList.begin(); pos != end; ++pos)
    {
        string str1 = (*pos)->GetBase()->directoryName()->ToString();
        wxString wxNS(str1.c_str(),wxConvUTF8);
        GetListboxNamespacesScvp()->InsertItems(1, &wxNS, 0);
    }

    //*********************************************************************************************
    //Settings for SCVP response verification group box
    //*********************************************************************************************
    if(m_scvpResponseMeds)
    {
        GetCheckboxScvpResponseMeds()->SetValue(true);
        GetScvpResponseMeds()->Enable();
    }
    else
    {
        GetCheckboxScvpResponseMeds()->SetValue(false);
        GetScvpResponseMeds()->Enable(false);
    }

    if(m_scvpResponsePath)
    {
        GetCheckboxScvpResponsePath()->SetValue(true);
        GetScvpResponsePath()->Enable();
    }
    else
    {
        GetCheckboxScvpResponsePath()->SetValue(false);
        GetScvpResponsePath()->Enable(false);
    }

    //*********************************************************************************************
    //Custom validation policy group box
    //*********************************************************************************************
    if(m_valPolPath)
    {
        GetCheckboxValPolMeds()->SetValue(true);
        GetValPolMeds()->Enable();
    }
    else
    {
        GetCheckboxValPolMeds()->SetValue(false);
        GetValPolMeds()->Enable(false);
    }
}
IPKIFScvpClientPtr CScvpResponderEntryDlg::GetScvpClient()
{
#ifdef __INCLUDE_SCVP_SUPPORT__

    IPKIFScvpClientPtr empty;

    //*********************************************************************************************
    //SCVP responder location information group box
    //*********************************************************************************************
    //if we don't have at least the URL, return empty
    if(m_url.IsEmpty())
        return empty;

    IPKIFScvpClientPtr scvp;
    if(GetCheckScvpDpdOnly()->GetValue())
    {
        CPKIFScvpPathBuildPtr pb(new CPKIFScvpPathBuild);
        scvp = dynamic_pointer_cast<IPKIFScvpClient, CPKIFScvpPathBuild>(pb);

        if(GetResponderValidatedDpd()->GetValue())
            pb->SetUseValidPkcPathCertCheck(true);
    }
    else
    {
        CPKIFScvpPathBuildAndValidatePtr pbav(new CPKIFScvpPathBuildAndValidate);
        scvp = dynamic_pointer_cast<IPKIFScvpClient, CPKIFScvpPathBuildAndValidate>(pbav);
    }

    scvp->SetResponderUrl(m_url.mb_str());
    scvp->SetRequireNonceMatch(GetCheckRequireNonce()->GetValue());
    scvp->SetGenerateNonce(GetCheckRequireNonce()->GetValue());
    scvp->SetRequireSignedDPD(GetCheckRequireSignedDpd()->GetValue());

    wxString oidVal = GetComboBoxValpol()->GetValue();
    if(!oidVal.IsEmpty())
    {
        CPKIFOIDPtr id_svp_defaultValPolicy(new CPKIFOID("1.3.6.1.5.5.7.19.1"));

        CPKIFOIDPtr tmpOidVal(new CPKIFOID(oidVal.mb_str()));
        if(!(*tmpOidVal == *id_svp_defaultValPolicy))
        {
            scvp->SetValidationPolicy(tmpOidVal);
        }
    }

    //*********************************************************************************************
    //Want backs group box
    //*********************************************************************************************
    CPKIFOIDListPtr wantBacks(new CPKIFOIDList);
    if(GetCertPathWB()->GetValue())
        wantBacks->push_back(g_id_swb_pkc_best_cert_path2);
    if(GetRevInfoWB()->GetValue())
        wantBacks->push_back(g_id_swb_pkc_revocation_info2);
    if(GetTargetCertWB()->GetValue())
        wantBacks->push_back(g_id_swb_pkc_cert2);
    if(GetPartialPathWB()->GetValue())
        wantBacks->push_back(g_idSwbPartialCertPath2);
    if(GetErsTargetCertWB()->GetValue())
        wantBacks->push_back(g_idSwbErsPkcCert2);
    if(GetErsPartialPathWB()->GetValue())
        wantBacks->push_back(g_idSwbErsPartialCertPath2);
    if(GetErsRevInfoWB()->GetValue())
        wantBacks->push_back(g_idSwbErsRevocationInfo2);        

    if(!wantBacks->empty())
        scvp->SetWantBacks(wantBacks);

    //*********************************************************************************************
    //Evidence record verifier group box
    //*********************************************************************************************
    if(m_erv)
        scvp->SetEvidenceRecordVerifier(m_erv);

    //*********************************************************************************************
    //Validation policy group box
    //*********************************************************************************************
    scvp->SetFetchValPolWhenLoading(GetCheckboxFetchValpol()->GetValue());
    scvp->SetValPol(m_valPol);

    //*********************************************************************************************
    //SCVP request signing credential group box
    //*********************************************************************************************
    scvp->SetSigningCredential(m_cred);

    //*********************************************************************************************
    //Acceptable namespaces group box
    //*********************************************************************************************
    CPKIFGeneralSubtreeList::iterator namePos;
    CPKIFGeneralSubtreeList::iterator nameEnd = m_rndList.end();
    for(namePos = m_rndList.begin(); namePos != nameEnd; ++namePos)
        scvp->AddNamespace(*namePos);

    //*********************************************************************************************
    //Settings for SCVP response verification group box
    //*********************************************************************************************
    scvp->SetPathSettings(m_scvpResponsePath);
    scvp->SetMediator(m_scvpResponseMeds);

    //*********************************************************************************************
    //Custom validation policy group box
    //*********************************************************************************************
    scvp->SetPathSettingsForValPol(m_valPolPath);

    return scvp;
#else
    IPKIFScvpClientPtr empty;
    return empty;
#endif
}