OcspResponderEntryDlg.cpp

Go to the documentation of this file.

#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) && defined(PKIFRESOURCES_ALLOW_GCC_PRAGMA)
    #pragma implementation "OcspResponderEntryDlg.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 "OcspResponderEntryDlg.h"
#include "CredentialSelectorDlg.h"
#include "ResourceUtils.h"
#include "ExtractInfoFromCertDlg.h"

using namespace std;
void DisplayCertificateDetails(const CPKIFCertificatePtr& cert, wxTextCtrl* tcSubjectName, wxTextCtrl* tcSkid)
{
    wxASSERT(tcSubjectName);
    wxASSERT(tcSkid);

    if(NULL == tcSubjectName || NULL == tcSkid || cert == (CPKIFCertificate*)NULL)
        return;

    tcSubjectName->Clear();
    tcSkid->Clear();

    CPKIFSubjectKeyIdentifierPtr skidExt = cert->GetExtension<CPKIFSubjectKeyIdentifier>();
    if(skidExt != (CPKIFSubjectKeyIdentifier*)NULL)
    {
        CPKIFBufferPtr skid = skidExt->KeyIdentifier();
        if(skid != (CPKIFBuffer*)NULL)
        {
            int skidLen = skid->GetLength();
            char* asciiSkid = new char[(skidLen*2)+1];
            btoa((const char*)skid->GetBuffer(), asciiSkid, skidLen);
            wxString wxSkid(asciiSkid,wxConvUTF8);
            delete[] asciiSkid;
            tcSkid->SetValue(wxSkid);
        }
    }

    CPKIFNamePtr subjectName = cert->Subject();
    if(subjectName != (CPKIFName*)NULL)
    {
        wxString wxName(subjectName->ToString(),wxConvUTF8);
        tcSubjectName->SetValue(wxName);
    }
    else
    {
        //should add code to display info from subject alt name
    }
}

// WDR: class implementations

//----------------------------------------------------------------------------
// CPKIFOcspResponderEntryDlg
//----------------------------------------------------------------------------

// WDR: event table for CPKIFOcspResponderEntryDlg

BEGIN_EVENT_TABLE(CPKIFOcspResponderEntryDlg,wxDialog)
    EVT_INIT_DIALOG( CPKIFOcspResponderEntryDlg::OnInitDialog )
    EVT_BUTTON( ID_BUTTON_SELECT_OCSP_CRED, CPKIFOcspResponderEntryDlg::OnSelectOcspCredential )
    EVT_BUTTON( ID_BUTTON_CLEAR_OCSP_CRED, CPKIFOcspResponderEntryDlg::OnClearOcspCredential )
    EVT_BUTTON( wxID_OK, CPKIFOcspResponderEntryDlg::OnOK )
    EVT_BUTTON( wxID_CANCEL, CPKIFOcspResponderEntryDlg::OnCancel )
    EVT_BUTTON( ID_BUTTON_CLEAR_OCSP_CERT, CPKIFOcspResponderEntryDlg::OnClearResponderCertificate )
    EVT_BUTTON( ID_BUTTON_BROWSE_TO_RESPONDER_CERT, CPKIFOcspResponderEntryDlg::OnSelectResponderCertificate )
    EVT_BUTTON( ID_BUTTON_ADD_OCSP_NAMESPACE, CPKIFOcspResponderEntryDlg::AddNamespace )
    EVT_BUTTON( ID_BUTTON_REMOVE_OCSP_NAMESPACE, CPKIFOcspResponderEntryDlg::RemoveNamespace )
    EVT_BUTTON( ID_BUTTON_ADD_OCSP_NAMESPACE_ISSUER, CPKIFOcspResponderEntryDlg::AddNamespaceIssuer )
    EVT_BUTTON( ID_BUTTON_REMOVE_OCSP_NAMESPACE_ISSUER, CPKIFOcspResponderEntryDlg::RemoveNamespaceIssuer )
END_EVENT_TABLE()
CPKIFOcspResponderEntryDlg::CPKIFOcspResponderEntryDlg( wxWindow *parent, wxWindowID id, const wxString &title,
    const wxPoint &position, const wxSize& size, long style ) :
    wxDialog( parent, id, title, position, size, style )
{
    // WDR: dialog function OcspResponderEntryDlg for CPKIFOcspResponderEntryDlg
    OcspResponderEntryDlg( this, TRUE ); 

    m_mCert = false;
    m_bCacheResponders = false;
    m_bRequireNonceMatch = false;
    m_bGenerateNonce = false;
}

// WDR: handler implementations for CPKIFOcspResponderEntryDlg
void CPKIFOcspResponderEntryDlg::OnSelectResponderCertificate( wxCommandEvent &event )
{
    static wxString filter = wxT("Certificate files (*.cer, *.der, *.crt)|*.cer;*.der;*.crt|All files (*.*)|*.*");
    wxString filename = wxFileSelector(wxT("Select the responder's certificate"), NULL, NULL, NULL, filter);
    if(!filename.IsEmpty()) 
    {
        m_responderCert = GetCert(filename);
        DisplayCertificateDetails(m_responderCert, GetTextName(), GetTextSkid());
    }
}
void CPKIFOcspResponderEntryDlg::OnClearResponderCertificate( wxCommandEvent &event )
{
    CPKIFCertificatePtr emptyCert;
    m_responderCert = emptyCert;

    GetTextName()->Clear();
    GetTextSkid()->Clear();
}
void CPKIFOcspResponderEntryDlg::OnCancel( wxCommandEvent &event )
{
    event.Skip();
}
void CPKIFOcspResponderEntryDlg::OnOK( wxCommandEvent &event )
{
    wxTextCtrl* tc = GetTextUrl();
    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;

    m_mCert = GetMultipleCertWx()->GetValue();
    m_bCacheResponders = GetCacheRespondersWx()->GetValue();
    m_bRequireNonceMatch = GetRequireNonceMatchWx()->GetValue();
    m_bGenerateNonce = GetGenerateNonceWx()->GetValue();

    event.Skip();
}
void CPKIFOcspResponderEntryDlg::OnClearOcspCredential( wxCommandEvent &event )
{
    CPKIFCredentialPtr emptyCred;
    m_cred = emptyCred;

    GetTextSignersName()->Clear();
    GetTextSignersSkid()->Clear();
}
void CPKIFOcspResponderEntryDlg::OnSelectOcspCredential( wxCommandEvent &event )
{
    CPKIFCredentialSelectorDlg dlg(this, -1, wxT("Select a credential"));
    dlg.SetMediator(m_mediator);
    if(wxID_OK == dlg.ShowModal())
    {
        m_cred = dlg.GetSelectedCredential();
        DisplayCertificateDetails(m_cred->GetCertificate(), GetTextSignersName(), GetTextSignersSkid());
    }
}
void CPKIFOcspResponderEntryDlg::GetUrl(
    wxString& url) const
{
    url = m_url;
}
void CPKIFOcspResponderEntryDlg::SetUrl(
    wxString& url)
{
    m_url = url;
}
void CPKIFOcspResponderEntryDlg::OnInitDialog(wxInitDialogEvent& event)
{
    if(!m_url.IsEmpty())
        GetTextUrl()->SetValue(m_url);

    if(m_responderCert != (CPKIFCertificate*)NULL)
        DisplayCertificateDetails(m_responderCert, GetTextName(), GetTextSkid());

    if(m_cred != (CPKIFCredential*)NULL)
        DisplayCertificateDetails(m_cred->GetCertificate(), GetTextSignersName(), GetTextSignersSkid());

    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);
        GetNamespaceList()->InsertItems(1, &wxNS, 0);
    }


    end = m_issuerNamespaceList.end();
    for(pos = m_issuerNamespaceList.begin(); pos != end; ++pos)
    {
        string str1 = (*pos)->GetBase()->directoryName()->ToString();
        wxString wxNS(str1.c_str(),wxConvUTF8);
        GetIssuerNamespaceList()->InsertItems(1, &wxNS, 0);
    }

    GetMultipleCertWx()->SetValue(m_mCert);
    GetCacheRespondersWx()->SetValue(m_bCacheResponders);
    GetGenerateNonceWx()->SetValue(m_bGenerateNonce);
    GetRequireNonceMatchWx()->SetValue(m_bRequireNonceMatch);
}
CPKIFOCSPCheckerPtr CPKIFOcspResponderEntryDlg::GetOCSPChecker()
{
    CPKIFOCSPCheckerPtr empty;
    if(m_url.IsEmpty())
        return empty;

    CPKIFOCSPCheckerPtr ocsp(new CPKIFOCSPChecker);
    ocsp->SetURL(m_url.mb_str());

    if(m_cred != (CPKIFCredential*)NULL)
        ocsp->SetSigningCredential(m_cred);

    if(m_responderCert != (CPKIFCertificate*)NULL)
        ocsp->SetResponderPublicKey(m_responderCert, false);

    CPKIFGeneralSubtreeList::iterator pos;
    CPKIFGeneralSubtreeList::iterator end = m_rndList.end();
    for(pos = m_rndList.begin(); pos != end; ++pos)
    {
        ocsp->AddNamespace((*pos));
    }

    CPKIFGeneralSubtreeList::iterator pos2;
    CPKIFGeneralSubtreeList::iterator end2 = m_issuerNamespaceList.end();
    for(pos2 = m_issuerNamespaceList.begin(); pos2 != end2; ++pos2)
    {
        ocsp->AddIssuerNamespace((*pos2));
    }

    ocsp->SetMultiCertRequest(m_mCert);
    ocsp->SetCacheValidatedResponders(m_bCacheResponders);
    ocsp->SetGenerateNonce(m_bGenerateNonce);
    ocsp->SetRequireNonceMatch(m_bRequireNonceMatch);

    return ocsp;
}
void CPKIFOcspResponderEntryDlg::SetInitialOCSPChecker(
    CPKIFOCSPCheckerPtr& ocsp)
{
    if(ocsp)
    {
        CPKIFStringPtr url = ocsp->GetURL();
        if(url != (std::string*)NULL)
        {
            wxString wxURLString(url->c_str(),wxConvUTF8);
            m_url = wxURLString;
        }

        m_responderCert = ocsp->GetResponderPublicKey();
        m_cred = ocsp->GetSigningCredential();

        m_rndList = ocsp->GetNamespaces();
        m_issuerNamespaceList = ocsp->GetIssuerNamespaces();

        m_mCert = ocsp->GetMultiCertRequest();
        m_bCacheResponders = ocsp->GetCacheValidatedResponders();
        m_bRequireNonceMatch = ocsp->GetRequireNonceMatch();
        m_bGenerateNonce = ocsp->GetGenerateNonce();
    }
    else
    {
        m_url = wxEmptyString;

        CPKIFCertificatePtr emptyCert;
        m_responderCert = emptyCert;

        CPKIFCredentialPtr emptyCred;
        m_cred = emptyCred;

        m_mCert = false;
        m_bCacheResponders = false;
        m_bRequireNonceMatch = false;
        m_bGenerateNonce = false;
    }
}

bool CPKIFOcspResponderEntryDlg::SetMediator(
    IPKIFMediatorPtr& m)
{
    if(NULL != m)
    {
        IPKIFCryptoKeyIDOperations* iCKIO = m->GetMediator<IPKIFCryptoKeyIDOperations>();
        if(NULL == iCKIO)
            return false;
    }
    m_mediator = m;
    return true;
}
void CPKIFOcspResponderEntryDlg::AddNamespace(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();

                if(ns != (CPKIFGeneralSubtree*)NULL)
                {
                    m_rndList.push_back(ns);
                    wxString wxNS(ns->GetBase()->directoryName()->ToString(),wxConvUTF8);
                    GetNamespaceList()->InsertItems(1, &wxNS, 0);
                }
            }
        }catch(CPKIFException &){
            wxMessageBox(wxT("Unable to decode certificate."),wxT("Error"),wxICON_ERROR|wxOK);
        }
    }
}
void CPKIFOcspResponderEntryDlg::RemoveNamespace(wxCommandEvent &event)
{
    wxListBox* lb = GetNamespaceList();
    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 CPKIFOcspResponderEntryDlg::AddNamespaceIssuer(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, false);
            dlg.Centre();
            if(wxID_OK == dlg.ShowModal())
            {   
                CPKIFGeneralSubtreePtr ns = dlg.GetNamespace();

                if(ns != (CPKIFGeneralSubtree*)NULL)
                {
                    m_issuerNamespaceList.push_back(ns);
                    wxString wxNS(ns->GetBase()->directoryName()->ToString(),wxConvUTF8);
                    GetIssuerNamespaceList()->InsertItems(1, &wxNS, 0);
                }
            }
        }catch(CPKIFException &){
            wxMessageBox(wxT("Unable to decode certificate."),wxT("Error"),wxICON_ERROR|wxOK);
        }
    }
}
void CPKIFOcspResponderEntryDlg::RemoveNamespaceIssuer(wxCommandEvent &event)
{
    wxListBox* lb = GetIssuerNamespaceList();
    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_issuerNamespaceList.end();
    for(pos = m_issuerNamespaceList.begin(); pos != end; ++pos)
    {
        string str1 = (*pos)->GetBase()->directoryName()->ToString();
        if(strcmp(str1.c_str(), selection.c_str()) == 0 )
        {
            m_issuerNamespaceList.erase(pos);
            break;
        }
    }
}
CPKIFGeneralSubtreeList CPKIFOcspResponderEntryDlg::GetNamespaces() const
{
    return m_rndList;
}
void CPKIFOcspResponderEntryDlg::SetNamespaces(CPKIFGeneralSubtreeList &rdnList)
{
    m_rndList = rdnList;
}

CPKIFGeneralSubtreeList CPKIFOcspResponderEntryDlg::GetIssuerNamespaces() const
{
    return m_issuerNamespaceList;
}
void CPKIFOcspResponderEntryDlg::SetIssuerNamespaces(CPKIFGeneralSubtreeList &issuerNamespaceList)
{
    m_issuerNamespaceList = issuerNamespaceList;
}
void CPKIFOcspResponderEntryDlg::SetMultipleCert(
    bool b)
{
    m_mCert = b;
}
bool CPKIFOcspResponderEntryDlg::GetMultipleCert()
{
    return m_mCert;
}
void CPKIFOcspResponderEntryDlg::SetCacheResponders(
    bool b)
{
    m_bCacheResponders = b;
}
bool CPKIFOcspResponderEntryDlg::GetCacheResponders()
{
    return m_bCacheResponders;
}

void CPKIFOcspResponderEntryDlg::SetGenerateNonce(bool b)
{
    m_bGenerateNonce = b;
}
bool CPKIFOcspResponderEntryDlg::GetGenerateNonce()
{
    return m_bGenerateNonce;
}

void CPKIFOcspResponderEntryDlg::SetRequireNonceMatch(bool b)
{
    m_bRequireNonceMatch = b;
}
bool CPKIFOcspResponderEntryDlg::GetRequireNonceMatch()
{
    return m_bRequireNonceMatch;
}