mainform.cpp

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

    TElX509Certificate* Cert;
    TFileStream* F;
    ByteArray Buf;
    TElXMLDOMNode* Node;
    TElXMLDOMNode* T;

    if ((tvXML->Selected != NULL) &&
        (tvXML->Selected->Data != NULL))
        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;
    }

    HMACKeyData = NULL;
    RSAKeyData = NULL;
    X509KeyData = NULL;
    PGPKeyData = NULL;
    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);
        }

        frmReference->Document = FXMLDocument;
        frmReferences->References = Verifier->References;
        frmReferences->Verify = true;

        if (!Verifier->ValidateSignature())
        {
            // KeyInfo doesn't contain correct public key for the signature
            // or data corrupted

            frmSign->CanonicalizationMethod = Verifier->CanonicalizationMethod;
            frmSign->SignatureType = Verifier->SignatureType;
            frmSign->SignatureMethodType = Verifier->SignatureMethodType;
            frmSign->SigMethod = Verifier->SignatureMethod;
            frmSign->HMACMethod = Verifier->MACMethod;
            frmSign->KeyName = Verifier->KeyName;

            Cert = frmSelWinCert->Certificate;

            if (frmSign->ShowModal() == mrOk)
            {
                frmSign->SignatureType = Verifier->SignatureType;

                if (Verifier->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;
                    Verifier->HMACKey = HMACKeyData;
                }
                else
                {
                    if (Cert != NULL)
                    {
                        X509KeyData = new TElXMLKeyInfoX509Data(false);
                        X509KeyData->Certificate = Cert;
                        Verifier->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->LoadPublic(F);
                        }
                        catch(Exception &e){}

                        if (!RSAKeyData->RSAKeyMaterial->PublicKey)
                        {
                            F->Position = 0;
                            try
                            {
                                RSAKeyData->RSAKeyMaterial->LoadSecret(F);
                            }
                            catch (Exception &e){}
                        }

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

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

                            if (PGPKeyData->PublicKey == 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->PublicKey)
                            Verifier->KeyData = RSAKeyData;
                        else if (X509KeyData->Certificate != NULL)
                            Verifier->KeyData = X509KeyData;
                        else if ((PGPKeyData->PublicKey != NULL) ||
                                 (PGPKeyData->SecretKey != NULL))
                            Verifier->KeyData = PGPKeyData;
                        else
                            throw(EXMLError("Key not loaded."));
                    }
                }

                if (Verifier->ValidateSignature())
                    MessageDlg("Signature validated successfully.", mtInformation, TMsgDlgButtons()<<mbOK, 0);
                else
                    MessageDlg("Signature is invalid", mtError, TMsgDlgButtons()<<mbOK, 0);
            }
        }
        else
        {
            if (MessageDlg("Signature validated successfully.\x13\x10 Do you want to validate references?", mtInformation, TMsgDlgButtons()<<mbYes<<mbNo, 0) == mrYes)
                frmReferences->ShowModal();
        }
    }
    __finally
    {
        delete Verifier;
        delete HMACKeyData;
        delete RSAKeyData;
        delete X509KeyData;
        delete PGPKeyData;
    }
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::FormCreate(TObject *Sender)
{
    FXMLDocument = new TElXMLDOMDocument;
    UpdateXML();
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::FormDestroy(TObject *Sender)
{
    delete FXMLDocument;
}
//---------------------------------------------------------------------------
void TfrmMain::LoadCertificate(TFileStream* F, const AnsiString Password, TElXMLKeyInfoX509Data* X509KeyData)
{
    TSBCertFileFormat CertFormat;

    X509KeyData->Certificate = new TElX509Certificate(NULL);
    try
    {
        CertFormat = X509KeyData->Certificate->DetectCertFileFormat(X509KeyData->Certificate->ClassType(), F);
        F->Position = 0;

        switch(CertFormat)
        {
            case cfDER:
                X509KeyData->Certificate->LoadFromStream(F);
                break;
            case cfPEM:
                X509KeyData->Certificate->LoadFromStreamPEM(F, Password);
                break;
            case cfPFX:
                X509KeyData->Certificate->LoadFromStreamPFX(F, Password);
                break;
            default:
                X509KeyData->Certificate->Free();
                X509KeyData->Certificate = NULL;
        }
    }
    catch(Exception &e)
    {
        X509KeyData->Certificate->Free();
        X509KeyData->Certificate = NULL;
    }
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::sbBrowseXMLFileClick(TObject *Sender)
{
    dlgOpenXML->InitialDir = Sbutils::ExtractFilePath(Application->ExeName) + "Samples";
    dlgOpenXML->FileName = edXMLFile->Text;
    if (dlgOpenXML->Execute())
        edXMLFile->Text = dlgOpenXML->FileName;
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::tvXMLChange(TObject *Sender, TTreeNode *Node)
{
    TElXMLDOMNode* N;
    AnsiString s, nt;

    if ((tvXML->Selected != NULL) &&
        (tvXML->Selected->Data))
    {
        N = (TElXMLDOMNode*)(tvXML->Selected->Data);
        if (AnsiString(N->ClassName()) == "TElXMLDOMAttr")
            s = ((TElXMLDOMAttr*)N)->NodeValue;
        else
            s = N->OuterXML;

        dlbNamespaceURI->Caption = N->NamespaceURI;
        mmXML->Text = AdjustLineBreaks(s);
        if (AnsiString(N->ClassName()) == "TElXMLDOMAttr")
            nt = "Attribute";
        else if (AnsiString(N->ClassName()) == "TElXMLDOMElement")
        {
            if ((N->ParentNode != NULL) &&
                (AnsiString(N->ParentNode->ClassName()) != "TElXMLDOMDocument"))
                nt = "Element";
            else
                nt = "Root element";
        }
        else if (AnsiString(N->ClassName()) == "TElXMLDOMText")
            nt = "Text";
        else if (AnsiString(N->ClassName()) == "TElXMLDOMComment")
            nt = "Comment";
        else if (AnsiString(N->ClassName()) == "TElXMLDOMCharacterData")
            nt = "CDATA";
        else if (AnsiString(N->ClassName()) == "TElXMLDOMDocument")
            nt = "Document";
        else
            nt = "Unknown";

        dlbNodeType->Caption = nt;
    }
    else
    {
        mmXML->Clear();
        dlbNodeType->Caption = "None";
        dlbNamespaceURI->Caption = "";
    }
}
//---------------------------------------------------------------------------
TTreeNode* TfrmMain::AddNode(TTreeNode* Sibling, TElXMLDOMNode* Node)
{
    TTreeNode* Result = NULL;
    TElXMLDOMNode* T;
    TTreeNode* AttrNode;
    TElXMLDOMNamedNodeMap* Attributes;
    int i;
    AnsiString s;

    if (AnsiString(Node->ClassName()) == "TElXMLDOMDocument")
        s = ((TElXMLDOMDocument*)Node)->LocalName;
    else if (AnsiString(Node->ClassName()) == "TElXMLDOMElement")
        s = ((TElXMLDOMElement*)Node)->NodeName;
    else if (AnsiString(Node->ClassName()) == "TElXMLDOMAttr")
        s = ((TElXMLDOMAttr*)Node)->NodeName;
    else
        s = Node->NodeName;

    Result = tvXML->Items->AddChild(Sibling, s);
    Result->Data = Node;
    if (AnsiString(Node->ClassName()) == "TElXMLDOMElement")
    {
        Attributes = ((TElXMLDOMElement*)Node)->Attributes;
        if ((Attributes != NULL) && (Attributes->Length > 0))
        {
            AttrNode = Result;
    //        AttrNode = tvXML->Items->AddChild(Result, "Attributes");
            for (int i = 0; i<Attributes->Length; i++)
                AddNode(AttrNode, Attributes->Item[i]);
        }
    }

    if (AnsiString(Node->ClassName()) == "TElXMLDOMAttr")
        return Result;

    T = Node->FirstChild;
    while (T != NULL)
    {
        if ((AnsiString(T->ClassName()) == "TElXMLDOMElement") ||
            (AnsiString(T->ClassName()) == "TElXMLDOMAttr") ||
            ( (AnsiString(T->ClassName()) == "TElXMLDOMCharacterData") &&
              ( (Trim(((TElXMLDOMCharacterData*)T)->Data) != XMLString("")) ||
                ((!T->Loaded) && (T->RawDataLength > 0)) )))
            AddNode(Result, T);

        T = T->NextSibling;
    }
    return Result;
}
//---------------------------------------------------------------------------
void TfrmMain::UpdateXML(void)
{
    mmXML->Clear();
    tvXML->Items->BeginUpdate();
    try
    {
        tvXML->Items->Clear();
        AddNode(NULL, FXMLDocument);
        tvXML->Items->GetFirstNode()->Expand(false);
    }
    __finally
    {
        tvXML->Items->EndUpdate();
    }
}
//---------------------------------------------------------------------------