mainform.cpp

来自「著名的SecureBlackBox控件完整源码」· C++ 代码 · 共 749 行 · 第 1/2 页

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

#include <vcl.h>
#pragma hdrstop

#include "MainForm.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TfrmMain *frmMain;
//---------------------------------------------------------------------------
__fastcall TfrmMain::TfrmMain(TComponent* Owner)
        : TForm(Owner)
{
    SetLicenseKey(
      (AnsiString)"ADDCD14AD06709806817E0B3D7BFD0A2222D536FE156466C5D5FE65DB5DEAE76" +
                  "FFDEBC07E915A5751C12C01C783958872A38E4A5EDA140E7247E0F2E56442A3C" +
                  "F3E9347AD8FDE52083A0DFC86BC00ECB0FD0CF1B51159A2BCB84F6EA6349EF47" +
                  "5C15A59AFCC55F7C3AAD26C279628B5D91B1DC94BD2385354A70CCA3B76101D9" +
                  "F41C84A639FC3CCE4BA8F0CC4A66DCD150114A3F58C1AD46B7B94643741BC20A" +
                  "8DCA83AB921480951B423CAA19EF1863A47CA2C3422E7E5634BED98939A5AE43" +
                  "DE1E4BAD79E66D8A5C973B3455656C8C9B6FF024FADD6CDA02D0F506D98493C8" +
                  "BD1ED7B237DB75FA31F2C82654490CDDDEE24E19939137B9E1DB05508733B22F");
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::btnClearClick(TObject *Sender)
{
    if(FXMLDocument){delete FXMLDocument; FXMLDocument = NULL;};
    FXMLDocument = new TElXMLDOMDocument;
    UpdateXML();
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::btnDeleteClick(TObject *Sender)
{
    TElXMLDOMNode* N;

    if ((tvXML->Selected) &&
        (tvXML->Selected->Data))
    {
        N = (TElXMLDOMNode*)(tvXML->Selected->Data);
        if ((AnsiString(N->ClassName()) == "TElXMLDOMElement") ||
            (AnsiString(N->ClassName()) == "TElXMLDOMText"))
        {
            if (N->ParentNode != NULL)
                N->ParentNode->RemoveChild(N);
            else
                FXMLDocument->RemoveChild(N);
        }
        else if ((AnsiString(N->ClassName()) == "TElXMLDOMAttr") &&
                 (tvXML->Selected->Parent != NULL) &&
                 (tvXML->Selected->Parent->Data != NULL) &&
                 (AnsiString(((TElXMLDOMNode*)(tvXML->Selected->Parent->Data))->ClassName()) == "TElXMLDOMElement"))
          ((TElXMLDOMElement*)(tvXML->Selected->Parent->Data))->RemoveAttributeNode((TElXMLDOMAttr*)N);
    }

    UpdateXML();
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::btnLoadXMLClick(TObject *Sender)
{
    TFileStream* F = new TFileStream(edXMLFile->Text, fmOpenRead | fmShareDenyWrite);
    try
    {
        FXMLDocument->LoadFromStream(F);
    }
    catch(Exception &e)
    {
        MessageDlg("Error: " + e.Message, mtError, TMsgDlgButtons()>>mbOK, 0);
    }

    delete F;
    UpdateXML();
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::btnRemoveSignatureClick(TObject *Sender)
{
    TElXMLVerifier* Verifier;
    TElXMLDOMNode* Node;
    TElXMLDOMNode* T;

    if ((tvXML->Selected != NULL) &&
        (tvXML->Selected->Data))
        Node = (TElXMLDOMNode*)(tvXML->Selected->Data);
    else
        Node = (TElXMLDOMNode*)(FXMLDocument);

    while ((AnsiString(Node->ClassName()) == "TElXMLDOMElement") &&
           (((TElXMLDOMElement*)Node)->LocalName != XMLString("Signature")) &&
           (Node->ParentNode != NULL))
        Node = Node->ParentNode;

    if ((AnsiString(Node->ClassName()) == "TElXMLDOMElement") &&
        (((TElXMLDOMElement*)Node)->LocalName == XMLString("Signature")) &&
        (Node->ParentNode != NULL) &&
        (AnsiString(Node->ParentNode->ClassName()) == "TElXMLDOMDocument"))
        Node = Node->ParentNode;

    if (AnsiString(Node->ClassName()) == "TElXMLDOMDocument")
        T = Node->FirstChild;
    else
        T = Node;

    if ((AnsiString(T->ClassName()) != "TElXMLDOMElement") ||
        ((((TElXMLDOMElement*)T)->LocalName != XMLString("Signature")) &&
         (FindChildElementSig((TElXMLDOMElement*)T, "Signature") == NULL)))
    {
        MessageDlg("Please, select Signature element for verifying.", mtInformation, TMsgDlgButtons()<<mbOK, 0);
        return;
    }

    Verifier = new TElXMLVerifier(NULL);
    try
    {
        try
        {
            Verifier->Load((TElXMLDOMElement*)T);
        }
        catch(Exception &e)
        {
            AnsiString s;
            s.sprintf("Signature data loading failed. (%s)", e.Message);
            throw(EXMLError(s));
        }

        Verifier->SignatureType = xstEnveloped;
        T->ParentNode->ReplaceChild(Verifier->RemoveSignature(), T);
    }
    __finally
    {
      delete Verifier;
    }

    UpdateXML();
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::btnSaveXMLClick(TObject *Sender)
{
    TFileStream* F = new TFileStream(edXMLFile->Text, fmCreate | fmOpenWrite);
    try
    {
        FXMLDocument->SaveToStream(F);
    }
    catch(Exception &e)
    {
        MessageDlg("Error: " + e.Message, mtError, TMsgDlgButtons()<<mbOK, 0);
    }
    delete F;
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::btnSignClick(TObject *Sender)
{
    TElXMLSigner* Signer;
    TElXMLKeyInfoHMACData* HMACKeyData;
    TElXMLKeyInfoRSAData* RSAKeyData;
    TElXMLKeyInfoX509Data* X509KeyData;
    TElXMLKeyInfoPGPData* PGPKeyData;
    TElX509Certificate* Cert;
    TFileStream* F;
    TElXMLDOMNode* Node;
    TElXMLDOMNode* SigNode;
    TElXMLDOMNode* ParentNode;
    ByteArray Buf;
    TElXMLReference* Ref;
    TElXMLReferenceList* Refs;
    int i;

    HMACKeyData = NULL;
    RSAKeyData = NULL;
    X509KeyData = NULL;
    PGPKeyData = NULL;
    Refs = new TElXMLReferenceList;
    try
    {
        if ((tvXML->Selected!=NULL) &&
            (tvXML->Selected->Data))
        {
            Ref = new TElXMLReference;
            Ref->DigestMethod = xdmSHA1;
            if (AnsiString(((TElXMLDOMNode*)(tvXML->Selected->Data))->ClassName()) == "TElXMLDOMDocument")
            {
                Node = ((TElXMLDOMDocument*)(tvXML->Selected->Data))->FirstChild;
                while ((Node!=NULL) && (AnsiString(Node->ClassName())!= "TElXMLDOMElement"))
                    Node = Node->NextSibling;

                Ref->URINode = Node;
                Ref->URI = "";
            }
            else if (AnsiString(((TElXMLDOMNode*)(tvXML->Selected->Data))->ClassName()) == "TElXMLDOMElement")
            {
                Ref->URINode = ((TElXMLDOMNode*)(tvXML->Selected->Data));
                if (((TElXMLDOMElement*)(tvXML->Selected->Data))->AttribStrings["Id"] != XMLString(""))
                    Ref->URI = XMLString("#") + ((TElXMLDOMElement*)(tvXML->Selected->Data))->AttribStrings["Id"];
                else if (AnsiString(((TElXMLDOMElement*)(tvXML->Selected->Data))->ParentNode->ClassName()) == "TElXMLDOMDocument")
                    Ref->URI = "";
                else
                    Ref->URI = ((TElXMLDOMElement*)(tvXML->Selected->Data))->LocalName;
            }
            else
            {
                Ref->URINode = ((TElXMLDOMNode*)(tvXML->Selected->Data));
                Ref->URI = ((TElXMLDOMNode*)(tvXML->Selected->Data))->LocalName;
            }

            Ref->TransformChain->Add(new TElXMLEnvelopedSignatureTransform);
            Refs->Add(Ref);
        }

        frmReference->Document = FXMLDocument;
        frmReferences->References = Refs;
        frmReferences->Verify = false;

        if (frmSign->ShowModal() == mrOk)
        {
            Signer = new TElXMLSigner(this);
            try
            {
                Signer->SignatureType = frmSign->SignatureType;
                Signer->CanonicalizationMethod = frmSign->CanonicalizationMethod;
                Signer->SignatureMethodType = frmSign->SignatureMethodType;
                Signer->SignatureMethod = frmSign->SigMethod;
                Signer->MACMethod = frmSign->HMACMethod;
                Signer->References = Refs;
                Signer->KeyName = frmSign->KeyName;

                Cert = frmSelWinCert->Certificate;

                if (Signer->SignatureMethodType == xmtMAC)
                {
                    HMACKeyData = new TElXMLKeyInfoHMACData(true);

                    F = new TFileStream(frmSign->KeyFile, fmOpenRead | fmShareDenyWrite);

                    Buf.set_length(F->Size);
                    if (F->Size > 0)
                        F->Read(&(Buf[0]), F->Size);

                    delete F;
                    HMACKeyData->Key->Key = Buf;
                    Signer->KeyData = HMACKeyData;
                }
                else
                {
                    if ((Cert != NULL) && Cert->PrivateKeyExists)
                    {
                        X509KeyData = new TElXMLKeyInfoX509Data(false);
                        X509KeyData->Certificate = Cert;
                        Signer->KeyData = X509KeyData;
                    }
                    else
                    {
                        RSAKeyData = new TElXMLKeyInfoRSAData(true);
                        RSAKeyData->RSAKeyMaterial->Passphrase = frmSign->Passphrase;
                        X509KeyData = new TElXMLKeyInfoX509Data(true);
                        PGPKeyData = new TElXMLKeyInfoPGPData(true);

                        F = new TFileStream(frmSign->KeyFile, fmOpenRead | fmShareDenyWrite);

                        try
                        {
                            RSAKeyData->RSAKeyMaterial->LoadSecret(F);
                        }
                        catch(Exception &){}

                        if (RSAKeyData->RSAKeyMaterial->SecretKey)
                        {
                            F->Position = 0;
                            LoadCertificate(F, frmSign->Passphrase, X509KeyData);
                        }

                        if ((!RSAKeyData->RSAKeyMaterial->PublicKey) &&
                            (X509KeyData->Certificate != NULL))
                        {
                            F->Position = 0;
                            PGPKeyData->SecretKey = new TElPGPSecretKey;
                            PGPKeyData->SecretKey->Passphrase = frmSign->Passphrase;
                            try
                            {
                                PGPKeyData->SecretKey->LoadFromStream(F);
                            }
                            catch(Exception &e)
                            {
                                PGPKeyData->SecretKey->Free();
                                PGPKeyData->SecretKey = NULL;
                            }
                        }

                        delete F;

                        if (RSAKeyData->RSAKeyMaterial->SecretKey)
                            Signer->KeyData = RSAKeyData;
                        else if (X509KeyData->Certificate != NULL)
                            Signer->KeyData = X509KeyData;
                        else if (PGPKeyData->SecretKey != NULL)
                            Signer->KeyData = PGPKeyData;
                        else
                            throw(EXMLError("Key not loaded."));
                    }
                }

                Signer->UpdateReferencesDigest();

                if (Signer->SignatureType == xstDetached)
                {
                    Signer->Sign();

                    if (FXMLDocument){delete FXMLDocument; FXMLDocument = NULL;}
                    try
                    {
                        SigNode = NULL;
                        Signer->Save(SigNode);
                        FXMLDocument = SigNode->OwnerDocument;
                    }
                    catch(Exception &e)
                    {
                        FXMLDocument = new TElXMLDOMDocument;
                        AnsiString s;
                        s.sprintf("Signed data saving failed. (%s)", e.Message);
                        throw (EXMLError(s));
                    }
                }
                else
                {
                    if ((tvXML->Selected == NULL) ||
                        (tvXML->Selected->Data == NULL))
                    {
                        MessageDlg("Please, select node for signing.", mtInformation, TMsgDlgButtons()<<mbOK, 0);
                        return;
                    }

                    Signer->Sign();

                    SigNode = ((TElXMLDOMNode*)(tvXML->Selected->Data));
                    if (AnsiString(SigNode->ClassName()) == "TElXMLDOMDocument")
                    {
                        SigNode = SigNode->FirstChild;
                        while ((SigNode != NULL) && (AnsiString(SigNode->ClassName()) != "TElXMLDOMElement"))
                            SigNode = SigNode->NextSibling;
                    }

                    try
                    {
                        Signer->Save(SigNode);
                    }
                    catch(Exception &e)
                    {
                        AnsiString s;
                        s.sprintf("Signed data saving failed. (%s)", e.Message);
                        throw EXMLError(s);
                    }
                }
                UpdateXML();
            }
            __finally
            {
                delete Signer;
                delete HMACKeyData;
                delete RSAKeyData;
                delete X509KeyData;
                delete PGPKeyData;
            }
        }
    }
    __finally
    {
        delete Refs;
    }
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::btnVerifyClick(TObject *Sender)
{
    TElXMLVerifier* Verifier;
    TElXMLKeyInfoHMACData* HMACKeyData;
    TElXMLKeyInfoRSAData* RSAKeyData;
    TElXMLKeyInfoX509Data* X509KeyData;
    TElXMLKeyInfoPGPData* PGPKeyData;