referenceform.cpp

来自「著名的SecureBlackBox控件完整源码」· C++ 代码 · 共 453 行

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "ReferenceForm.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TfrmReference *frmReference;
//---------------------------------------------------------------------------
__fastcall TfrmReference::TfrmReference(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TfrmReference::btnAddTransformClick(TObject *Sender)
{
    TElXMLC14NTransform* C14N;
    TElXMLXPathTransform* XPathTransform;
    XMLString s;
    XMLString t;
    int i;

    if (cmbTransform->Text == "Base64 transform")
        FReference->TransformChain->Add(new TElXMLBase64Transform);
    else if (cmbTransform->Text == "Enveloped signature transform")
        FReference->TransformChain->Add(new TElXMLEnvelopedSignatureTransform);
    else if (cmbTransform->Text == "XPath transform")
    {
        XPathTransform = new TElXMLXPathTransform;
        XPathTransform->XPath = edXPath->Text;

        s = Trim(edXPathNSMap->Text);
        while(s != XMLString(""))
        {
            i = s.Pos(",");
            if (i > 0)
            {
                t = Trim(s.SubString(1, i - 1));
                s = Trim(s.SubString(i + 1, MaxInt));
            }
            else
            {
                t = s;
                s = "";
            }

            i = t.Pos("=");
            if (i > 0)
                XPathTransform->NamespaceMap->AddNamespace(Trim(t.SubString(1, i - 1)), Trim(t.SubString(i + 1, MaxInt)));
        }

        FReference->TransformChain->Add(XPathTransform);
    }
    else
    {
        C14N = new TElXMLC14NTransform;
        if (cmbTransform->Text == "Canonical transform")
        {
            C14N->CanonicalizationMethod = xcmCanon;
            FReference->TransformChain->Add(C14N);
        }
        else if (cmbTransform->Text == "Canonical with comments transform")
        {
            C14N->CanonicalizationMethod = xcmCanonComment;
            FReference->TransformChain->Add(C14N);
        }
        else if (cmbTransform->Text == "Minimal canonical transform")
        {
            C14N->CanonicalizationMethod = xcmMinCanon;
            FReference->TransformChain->Add(C14N);
        }
        else
            delete C14N;
    }

    UpdateDigestValue();
    UpdateTransformChain();
}
//---------------------------------------------------------------------------
void __fastcall TfrmReference::btnDeleteTransformClick(TObject *Sender)
{
    for (int i = 0; i<lbTransforms->Items->Count; i++)
    {
        if (lbTransforms->Selected[i])
        {
            FReference->TransformChain->Delete(i);
            break;;
        }
    }
    UpdateDigestValue();
    UpdateTransformChain();
}
//---------------------------------------------------------------------------
void __fastcall TfrmReference::btnVerifyClick(TObject *Sender)
{
    ByteArray dv;

    dv = FReference->DigestValue;
    FReference->UpdateDigestValue();
    if (Sbutils::CompareMem(FReference->DigestValue, dv))
        MessageDlg("Verified OK", mtInformation, TMsgDlgButtons()<<mbOK, 0);
    else
        MessageDlg("BAD digest or data", mtError, TMsgDlgButtons()<<mbOK, 0);

    FReference->DigestValue = dv;
}
//---------------------------------------------------------------------------
void __fastcall TfrmReference::cmbDigestMethodChange(TObject *Sender)
{
    switch(cmbDigestMethod->ItemIndex)
    {
        case 0:
            FReference->DigestMethod = xdmMD5;
            break;
        case 1:
            FReference->DigestMethod = xdmSHA1;
            break;
        case 2:
            FReference->DigestMethod = xdmSHA224;
            break;
        case 3:
            FReference->DigestMethod = xdmSHA256;
            break;
        case 4:
            FReference->DigestMethod = xdmSHA384;
            break;
        case 5:
            FReference->DigestMethod = xdmSHA512;
            break;
        case 6:
            FReference->DigestMethod = xdmRIPEMD160;
            break;
        default:
            FReference->DigestMethod = xdmSHA1;
    }
    UpdateDigestValue();
}
//---------------------------------------------------------------------------
void __fastcall TfrmReference::cmbTransformChange(TObject *Sender)
{
    edXPath->Enabled = (cmbTransform->Text == "XPath transform");
    lbXPath->Enabled = edXPath->Enabled;
    lbXPathNS->Enabled = edXPath->Enabled;
    edXPathNSMap->Enabled = edXPath->Enabled;
}
//---------------------------------------------------------------------------
void __fastcall TfrmReference::edURINodeExit(TObject *Sender)
{
    ExtractURINode();
    if (rbURINode->Checked)
    {
        FReference->URINode = FURINode;
        UpdateDigestValue();
    }
}
//---------------------------------------------------------------------------
void TfrmReference::ExtractURINode(void)
{
    TElXMLNodeSet* NodeSet;
    TElXMLNamespaceMap* NSMap;
    XMLString s;
    XMLString t;
    int i;

    if (edNSMap->Text == "")
        NodeSet = FDocument->SelectNodes(edURINode->Text);
    else
    {
        NSMap = new TElXMLNamespaceMap;
        try
        {
            s = Trim(edNSMap->Text);
            while (s != XMLString(""))
            {
                i = s.Pos(",");
                if (i > 0)
                {
                    t = Trim(s.SubString(1, i - 1));
                    s = Trim(s.SubString(i + 1, MaxInt));
                }
                else
                {
                    t = s;
                    s = "";
                }

                i = t.Pos("=");
                if (i > 0)
                    NSMap->AddNamespace(Trim(t.SubString(1, i - 1)), Trim(t.SubString(i + 1, MaxInt)));
            }

            NodeSet = FDocument->SelectNodes(edURINode->Text, NSMap);
        }
        __finally
        {
            delete NSMap;
        }
    }

    try
    {
        if (NodeSet->Count > 0)
            FURINode = NodeSet->Node[0];
        else
          FURINode = NULL;
    }
    __finally
    {
        delete NodeSet;
    }
}
//---------------------------------------------------------------------------
TElXMLReference* TfrmReference::GetReference(void)
{
    FReference->ID = edID->Text;
    FReference->URI = edURI->Text;

    return FReference;
}
//---------------------------------------------------------------------------
void __fastcall TfrmReference::mmDataExit(TObject *Sender)
{
    FReference->URIData = BytesOfString(mmData->Text);
    UpdateDigestValue();
}
//---------------------------------------------------------------------------
void __fastcall TfrmReference::rbURIDataClick(TObject *Sender)
{
    rbURINode->Checked = !rbURIData->Checked;
    if (rbURINode->Checked)
        FReference->URINode = FURINode;
    else
        FReference->URINode = NULL;
    UpdateDigestValue();
}
//---------------------------------------------------------------------------
void __fastcall TfrmReference::rbURINodeClick(TObject *Sender)
{
    rbURIData->Checked = !rbURINode->Checked;
    if (rbURINode->Checked)
        FReference->URINode = FURINode;
    else
        FReference->URINode = NULL;
    UpdateDigestValue();
}
//---------------------------------------------------------------------------
void TfrmReference::SetReference(const TElXMLReference* Value)
{
    FReference = (TElXMLReference*)Value;
    edID->Text = FReference->ID;
    edURI->Text = FReference->URI;

    switch(FReference->DigestMethod)
    {
        case xdmMD5:
            cmbDigestMethod->ItemIndex = 0;
            break;
        case xdmSHA1:
            cmbDigestMethod->ItemIndex = 1;
            break;
        case xdmSHA224:
            cmbDigestMethod->ItemIndex = 2;
            break;
        case xdmSHA256:
            cmbDigestMethod->ItemIndex = 3;
            break;
        case xdmSHA384:
            cmbDigestMethod->ItemIndex = 4;
            break;
        case xdmSHA512:
            cmbDigestMethod->ItemIndex = 5;
            break;
        case xdmRIPEMD160:
            cmbDigestMethod->ItemIndex = 6;
            break;
    }

    FURINode = FReference->URINode;
    UpdateURINode(FURINode);
    mmData->Text = StringOfBytes(FReference->URIData);

    rbURINode->Checked = (FURINode!=NULL);

    if (Verify)
    {
        if (FReference->DigestValue.Length > 0)
            edDigestValue->Text = BinaryToString(&(FReference->DigestValue[0]), FReference->DigestValue.Length);
        else
            edDigestValue->Text = "";
    }
    else
        UpdateDigestValue();
    UpdateTransformChain();
}
//---------------------------------------------------------------------------
void TfrmReference::SetVerify(const bool Value)
{
    FVerify = Value;
    btnAddTransform->Enabled = !FVerify;
    btnDeleteTransform->Enabled = !FVerify;
    edID->ReadOnly = FVerify;
    edURI->ReadOnly = FVerify;
    btnVerify->Visible = FVerify;
}
//---------------------------------------------------------------------------
AnsiString TfrmReference::TransformToStr(TElXMLTransform* Transform)
{
    AnsiString Result = "Unknown transform";
    if (AnsiString(Transform->ClassName()) == "TElXMLBase64Transform")
        Result = "Base64 transform";
    else if (AnsiString(Transform->ClassName()) == "TElXMLC14NTransform")
    {
      if (((TElXMLC14NTransform*)Transform)->CanonicalizationMethod == xcmCanon)
          Result = "Canonical transform";
      else if (((TElXMLC14NTransform*)Transform)->CanonicalizationMethod == xcmCanonComment)
          Result = "Canonical with comments transform";
      else if (((TElXMLC14NTransform*)Transform)->CanonicalizationMethod == xcmMinCanon)
          Result = "Minimal canonical transform";
    }
    else if (AnsiString(Transform->ClassName()) == "TElXMLEnvelopedSignatureTransform")
        Result = "Enveloped signature transform";
    else if (AnsiString(Transform->ClassName()) == "TElXMLXPathTransform")
        Result = "XPath transform";
    return Result;
}
//---------------------------------------------------------------------------
void TfrmReference::UpdateDigestValue(void)
{
    if (Verify)
        return;

    try
    {
      FReference->UpdateDigestValue();
      if (FReference->DigestValue.Length > 0)
          edDigestValue->Text = BinaryToString(&(FReference->DigestValue[0]), FReference->DigestValue.Length);
      else
          edDigestValue->Text = "";
    }
    catch(Exception &e)
    {
        edDigestValue->Text = "";
    }
}
//---------------------------------------------------------------------------
void TfrmReference::UpdateTransformChain(void)
{
    lbTransforms->Clear();
    for (int i = 0;i<FReference->TransformChain->Count; i++)
        lbTransforms->Items->AddObject(TransformToStr(FReference->TransformChain->Transforms[i]), FReference->TransformChain->Transforms[i]);

    edXPath->Enabled = (cmbTransform->Text == "XPath transform");
    lbXPath->Enabled = edXPath->Enabled;
    lbXPathNS->Enabled = edXPath->Enabled;
    edXPathNSMap->Enabled = edXPath->Enabled;
}
//---------------------------------------------------------------------------
void TfrmReference::UpdateURINode(TElXMLDOMNode* Node)
{
    TElXMLDOMNode* PrevNode;
    TElXMLNamespaceMap* NSMap;
    XMLString s;
    XMLString p;
    XMLString Path;
    int i, k;

    if (Node == NULL)
    {
        edURINode->Text = "";
        edNSMap->Text = "";
        return;
    }

    NSMap = new TElXMLNamespaceMap;
    Path = "";
    while (AnsiString(Node->ClassName()) != "TElXMLDOMDocument")
    {
        i = 0;
        PrevNode = Node->PreviousSibling;
        while (PrevNode != NULL)
        {
            if ((PrevNode->NodeName == Node->NodeName) &&
                (PrevNode->NamespaceURI == Node->NamespaceURI))
                i++;
            PrevNode = PrevNode->PreviousSibling;
        }

        s = Node->NodeName;
        if (Node->NamespaceURI != XMLString(""))
        {
            p = "";
            if (Node->Prefix != XMLString(""))
                p = Node->Prefix;
            else
            {
                for (k = 0; k< NSMap->Count;k++)
                {
                    if (NSMap->URI[k] == Node->NamespaceURI)
                    {
                        p = NSMap->Prefix[k];
                        break;
                    }
                }

                if (p == XMLString(""))
                {
                    p = "x";
                    k = 1;
                    while (NSMap->FindNamespace(p) != XMLString(""))
                    {
                        k++;
                        p = XMLString("x") + IntToStr(k);
                    }
                }

                NSMap->AddNamespace(p, Node->NamespaceURI);
            }

            s = p + ":" + s;
        }

        if (i > 0)
            Path = "/" + s + "[" + IntToStr(i + 1) + "]" + Path;
        else
            Path = "/" + s + Path;

        Node = Node->ParentNode;
    }

    if (Path == XMLString(""))
        Path = "/";

    s = "";
    for (i = 0;i<NSMap->Count;i++)
    {
        if ((NSMap->Prefix[i] != XMLString("")) && (NSMap->Prefix[i] != XMLString("xml")))
        {
            if (s != XMLString(""))
                s = s + ", ";
            s = s + NSMap->Prefix[i] + "=" + NSMap->URI[i];
        }
    }

    delete NSMap;

    edURINode->Text = Path;
    edNSMap->Text = s;
}
//---------------------------------------------------------------------------