mainform.cpp

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

                }
                else
                {
                    SymKeyData = new TElXMLKeyInfoSymmetricData(true);

                    F = new TFileStream(frmEnc->KeyFile, fmOpenRead | fmShareDenyWrite);
                    try
                    {
                        SymKeyData->Key->Load(F);
                    }
                    __finally
                    {
                        delete F; F = NULL;
                    }

                    Decryptor->KeyData = SymKeyData;
                }

                i = Decryptor->Decrypt(FXMLDocument);
                if (i != SB_XML_ENC_ERROR_OK)
                {
                    if (((!Decryptor->EncryptKey) && (i == SB_XML_ENC_ERROR_INVALID_KEY)) ||
                       (Decryptor->EncryptKey && (i == SB_XML_ENC_ERROR_INVALID_KEK)))
                        MessageDlg("Decryption failed. Bad key or data is corrupted.", mtError, TMsgDlgButtons()<<mbOK, 0);
                    else
                    {
                        AnsiString s;
                        s.sprintf("Decryption failed. Error code: 0x%x", i);
                        throw(EXMLEncError(s));
                    }
                    continue;
                }

                if (Decryptor->EncryptedDataType == xedtExternal)
                {
                    F = new TFileStream(frmEnc->ExternalFile, fmCreate);
                    try
                    {
                        if (Decryptor->DecryptedData.Length > 0)
                            F->Write(&(Decryptor->DecryptedData[0]), Decryptor->DecryptedData.Length);
                    }
                    __finally
                    {
                        delete F; F = NULL;
                    }

                    MessageDlg("Data saved successfully.", mtInformation, TMsgDlgButtons()<<mbOK, 0);
                }
                else
                {
                    if (Decryptor->DecryptedNode != NULL)
                    {
                        if (AnsiString(Node->ClassName()) == "TElXMLDOMDocument")
                            FXMLDocument->ReplaceChild(Decryptor->DecryptedNode, FXMLDocument->FirstChild);
                        else
                            Node->ParentNode->ReplaceChild(Decryptor->DecryptedNode, Node);

                        Decryptor->DecryptedNode = NULL;
                    }
                    else
                    {
                        if ((Decryptor->EncryptedDataType == xedtContent) &&
                            (Decryptor->DecryptedNodeList != NULL))
                        {
                            T = Node->ParentNode;
                            for (int i = 0; i<Decryptor->DecryptedNodeList->Length;i++)
                                T->InsertBefore(Decryptor->DecryptedNodeList->Item[i]->CloneNode(true), Node);
                            T->RemoveChild(Node);
                        }
                    }

                    UpdateXML();
                }

                break;
            }
            else
              break;
        }
    }
    __finally
    {
        if (Decryptor){delete Decryptor; Decryptor = NULL;};
        if (SymKeyData){delete SymKeyData; SymKeyData = NULL;};
        if (SymKEKData){delete SymKEKData; SymKEKData = NULL;};
        if (RSAKeyData){delete RSAKeyData; RSAKeyData = NULL;};
        if (X509KeyData){delete X509KeyData; X509KeyData = NULL;};
#ifndef SBB_EXCL_XML_PGP
        if (PGPKeyData){delete PGPKeyData; PGPKeyData = NULL;};
#endif
    }
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::btnDeleteClick(TObject *Sender)
{
    TElXMLDOMNode* N;

    if ((tvXML->Selected != NULL) &&
        (tvXML->Selected->Data != NULL))
    {
        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::btnEncryptClick(TObject *Sender)
{
    TElXMLEncryptor* Encryptor;
    TElXMLKeyInfoSymmetricData* SymKeyData;
    TElXMLKeyInfoSymmetricData* SymKEKData;
    TElXMLKeyInfoRSAData* RSAKeyData;
    TElXMLKeyInfoX509Data* X509KeyData;
#ifndef SBB_EXCL_XML_PGP
    TElXMLKeyInfoPGPData* PGPKeyData;
#endif
    TFileStream* F;
    TElXMLDOMNode* Node;
    TElXMLDOMNode* EncNode;
    ByteArray Buf;

    SymKeyData = NULL;
    SymKEKData = NULL;
    RSAKeyData = NULL;
    X509KeyData = NULL;
#ifndef SBB_EXCL_XML_PGP
    PGPKeyData = NULL;
#endif
    frmEnc->LockOpt = false;
    if (frmEnc->ShowModal() == mrOk)
    {
        Encryptor = new TElXMLEncryptor(this);
        try
        {
             Encryptor->EncryptKey = frmEnc->EncryptKey;
             Encryptor->EncryptionMethod = frmEnc->EncryptionMethod;
             Encryptor->KeyName = frmEnc->KeyName;
             Encryptor->EncryptedDataType = frmEnc->EncryptedDataType;
             if (Encryptor->EncryptKey)
             {
                 Encryptor->KeyEncryptionType = frmEnc->KeyEncryptionType;
                 Encryptor->KeyTransportMethod = frmEnc->KeyTransportMethod;
                 Encryptor->KeyWrapMethod = frmEnc->KeyWrapMethod;

                 SymKeyData = new TElXMLKeyInfoSymmetricData(true);
                 // generate random Key & IV
                 switch (Encryptor->EncryptionMethod)
                 {
                     case xem3DES:
                         SymKeyData->Key->Generate(T3DESKeySize * 8);
                         SymKeyData->Key->GenerateIV(8 * 8);
                         break;
                     case xemAES:
                         SymKeyData->Key->Generate(sizeof(TAESKey256) * 8);
                         SymKeyData->Key->GenerateIV(16 * 8);
                         break;
                     case xemCamellia:
                         SymKeyData->Key->Generate(32 * 8); // 16, 24, 32
                         SymKeyData->Key->GenerateIV(16 * 8);
                         break;
                     case xemDES:
                         SymKeyData->Key->Generate(TDESKeySize * 8);
                         SymKeyData->Key->GenerateIV(8 * 8);
                         break;
                     case xemRC4:
                         SymKeyData->Key->Generate(16 * 8); // 1..32
                         break;
                 }

                 Encryptor->KeyData = SymKeyData;

                 if (Encryptor->KeyEncryptionType == xetKeyWrap)
                 {
                     SymKEKData = new TElXMLKeyInfoSymmetricData(true);
                     F = new TFileStream(frmEnc->KeyFile, fmOpenRead | fmShareDenyWrite);
                     try
                     {
                         SymKEKData->Key->Load(F);
                     }
                     __finally
                     {
                         delete F; F = NULL;
                     }
                     Encryptor->KeyEncryptionKeyData = SymKEKData;
                 }
                 else
                 { // xetKeyTransport
                     RSAKeyData = new TElXMLKeyInfoRSAData(true);
                     RSAKeyData->RSAKeyMaterial->Passphrase = frmEnc->Passphrase;
                     X509KeyData = new TElXMLKeyInfoX509Data(true);
        #ifndef SBB_EXCL_XML_PGP
                     PGPKeyData = new TElXMLKeyInfoPGPData(true);
        #endif
          /*
                     F := 蝮