mainform.cpp

著名的SecureBlackBox控件完整源码

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

#include <vcl.h>
#pragma hdrstop

#include "MainForm.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma link "SBPGPKeys"
#pragma resource "*.dfm"
TfrmKeys *frmKeys;
//---------------------------------------------------------------------------
__fastcall TfrmKeys::TfrmKeys(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------
AnsiString KeyIDToString(const TSBKeyID* KeyID)
{
    AnsiString s;
    s.sprintf("0x%.2X%.2X%.2X%.2X", KeyID[4], KeyID[5], KeyID[6], KeyID[7]);
    return s;
}
//---------------------------------------------------------------------------
AnsiString PubKeyAlgToString(int Alg)
{
    switch(Alg)
    {
        case SB_PGP_ALGORITHM_PK_RSA:
            return "RSA";
        case SB_PGP_ALGORITHM_PK_RSA_ENCRYPT:
            return "RSA";
        case SB_PGP_ALGORITHM_PK_RSA_SIGN:
            return "RSA";
        case SB_PGP_ALGORITHM_PK_ELGAMAL_ENCRYPT:
            return "ElGamal";
        case SB_PGP_ALGORITHM_PK_DSA:
            return "DSS";
        case SB_PGP_ALGORITHM_PK_ELGAMAL:
            return "ElGamal";
        default:
            return "Unknown";
    }
}
//---------------------------------------------------------------------------
AnsiString GetDefaultUserID(TElPGPPublicKey* Key)
{
    if (Key->UserIDCount > 0)
        return Key->UserIDs[0]->Name;
    else
        return "No name";
}
//---------------------------------------------------------------------------
void RedrawKeyring(TTreeView* tv, TElPGPKeyring* Keyring)
{
//    int i, j, k;
    TTreeNode* KeyNode;
    TTreeNode* UserNode;
    TTreeNode* SubKeyNode;
    TTreeNode* SigNode;

    tv->Items->BeginUpdate();

    try
    {
        tv->Items->Clear();
        for (int i = 0; i< Keyring->PublicCount; i++)
        {
            // Creating key node
            KeyNode = tv->Items->Add(NULL, GetDefaultUserID(Keyring->PublicKeys[i]));
            KeyNode->Data = Keyring->PublicKeys[i];
            if ((Keyring->PublicKeys[i]->PublicKeyAlgorithm == SB_PGP_ALGORITHM_PK_RSA) ||
                (Keyring->PublicKeys[i]->PublicKeyAlgorithm == SB_PGP_ALGORITHM_PK_RSA_ENCRYPT) ||
                (Keyring->PublicKeys[i]->PublicKeyAlgorithm == SB_PGP_ALGORITHM_PK_RSA_SIGN))
                KeyNode->ImageIndex = 1;
            else
                KeyNode->ImageIndex = 0;

            KeyNode->SelectedIndex = KeyNode->ImageIndex;
            if (Keyring->PublicKeys[i]->SecretKey != NULL)
            {
                // KeyNode.NodeFont = new Font(this.Font, FontStyle.Bold);
            }

            if (Keyring->PublicKeys[i]->Revoked)
            {
                // KeyNode.NodeFont = new Font(tv.Font, FontStyle.Italic);
            }

            // Creating user nodes
            for (int j = 0; j < Keyring->PublicKeys[i]->UserIDCount; j++)
            {
                UserNode = tv->Items->AddChild(KeyNode, Keyring->PublicKeys[i]->UserIDs[j]->Name);
                UserNode->Data = Keyring->PublicKeys[i]->UserIDs[j];
                UserNode->ImageIndex = 2;
                UserNode->SelectedIndex = 2;

                // Creating signature nodes
                for (int k = 0; k < Keyring->PublicKeys[i]->UserIDs[j]->SignatureCount; k++)
                {
                    if (Keyring->PublicKeys[i]->UserIDs[j]->Signatures[k]->IsUserRevocation())
                    {
                        SigNode = tv->Items->AddChild(UserNode, "Revocation");
              //          UserNode->NodeFont = new Font(tv->Font, FontStyle->Italic);
                    }
                    else
                    {
                        SigNode = tv->Items->AddChild(UserNode, "Signature");
                        SigNode->ImageIndex = 3;
                        SigNode->SelectedIndex = 3;
                    }

                    SigNode->Data = Keyring->PublicKeys[i]->UserIDs[j]->Signatures[k];
                }
            }

            for (int j = 0; j < Keyring->PublicKeys[i]->UserAttrCount; j++)
            {
                UserNode = tv->Items->AddChild(KeyNode, "Photo");
                UserNode->Data = Keyring->PublicKeys[i]->UserAttrs[j];

                // Creating signature nodes
                for (int k = 0; k < Keyring->PublicKeys[i]->UserAttrs[j]->SignatureCount; k++)
                {
                    if (Keyring->PublicKeys[i]->UserAttrs[j]->Signatures[k]->IsUserRevocation())
                    {
                        SigNode = tv->Items->AddChild(UserNode, "Revocation");
              //          UserNode->NodeFont = new Font(tv->Font, FontStyle->Italic);
                    }
                    else
                    {
                        SigNode = tv->Items->AddChild(UserNode, "Signature");
                        SigNode->ImageIndex = 3;
                        SigNode->SelectedIndex = 3;
                    }

                    SigNode->Data = Keyring->PublicKeys[i]->UserAttrs[j]->Signatures[k];
                }
            }

            // Subkeys
            for (int j = 0; j < Keyring->PublicKeys[i]->SubkeyCount; j++)
            {
                SubKeyNode = tv->Items->AddChild(KeyNode, (AnsiString)PKAlg2Str(Keyring->PublicKeys[i]->Subkeys[j]->PublicKeyAlgorithm) + " subkey");
                SubKeyNode->Data = Keyring->PublicKeys[i]->Subkeys[j];

                // Creating signature nodes
                for (int k = 0; k < Keyring->PublicKeys[i]->Subkeys[j]->SignatureCount; k++)
                {
                    if (Keyring->PublicKeys[i]->Subkeys[j]->Signatures[k]->IsSubkeyRevocation())
                    {
                        SigNode = tv->Items->AddChild(SubKeyNode, "Revocation");
              //          SubKeyNode->NodeFont = new Font(tv->Font, FontStyle->Italic);
                    }
                    else
                    {
                        SigNode = tv->Items->AddChild(SubKeyNode, "Signature");
                        SigNode->ImageIndex = 3;
                        SigNode->SelectedIndex = 3;
                    }

                    SigNode->Data = Keyring->PublicKeys[i]->Subkeys[j]->Signatures[k];
                }
            }
        }
    }
    __finally
    {
        tv->Items->EndUpdate();
    }
}
//---------------------------------------------------------------------------
void __fastcall TfrmKeys::actNewKeyringExecute(TObject *Sender)
{
    if (MessageDlg("Are you sure you want to create a new keyring?\nAll unsaved information will be LOST!",
          mtConfirmation, TMsgDlgButtons()<<mbYes<<mbNo, 0) == mrYes)
    {
        PubKeyringFileName = "";
        SecKeyringFileName = "";
        tvKeyring->Items->Clear();
        pgpKeyring->Clear();
        HideAllInfoPanels();
        RedrawKeyring(tvKeyring, pgpKeyring);
        SetStatus("New keyring created");
    }
}
//---------------------------------------------------------------------------
void __fastcall TfrmKeys::actOpenKeyringExecute(TObject *Sender)
{
    TElPGPKeyring* tempKeyring = new TElPGPKeyring(NULL);
    TfrmSelectKeyring* pForm = new TfrmSelectKeyring(this);
    try
    {
        pForm->OpenKeyring = True;
        pForm->Caption = "Load keyring";
        if (pForm->ShowModal() == mrOk)
        {
            try
            {
                tempKeyring->Load(pForm->edtPub->Text, pForm->edtSec->Text, true);
            }
            catch(Exception &e)
            {
                MessageDlg(e.Message, mtError, TMsgDlgButtons()<<mbOK, 0);
                SetStatus("Failed to load keyring");
                return;
            }

            HideAllInfoPanels();
            FPubKeyringFileName = pForm->edtPub->Text;
            FSecKeyringFileName = pForm->edtSec->Text;
            pgpKeyring->Clear();
            tempKeyring->ExportTo(pgpKeyring);
            RedrawKeyring(tvKeyring, pgpKeyring);
            SetStatus("Keyring loaded");
        }
    }
    __finally
    {
        delete tempKeyring;
        delete pForm;
    }
}
//---------------------------------------------------------------------------
void __fastcall TfrmKeys::actSaveKeyringExecute(TObject *Sender)
{
    TfrmSelectKeyring* pForm = new TfrmSelectKeyring(this);
    try
    {
        pForm->OpenKeyring = false;
        pForm->Caption = "Save keyring";
        pForm->edtPub->Text = PubKeyringFileName;
        pForm->edtSec->Text = SecKeyringFileName;
        if (pForm->ShowModal() == mrOk)
        {
            try
            {
                pgpKeyring->Save(pForm->edtPub->Text, pForm->edtSec->Text, false);
                SetStatus("Keyring saved");
            }
            catch(Exception &e)
            {
                MessageDlg(e.Message, mtError, TMsgDlgButtons()<<mbOK, 0);
                SetStatus("Failed to save keyring");
            }
        }
    }
    __finally
    {
        delete pForm;
    }
}
//---------------------------------------------------------------------------
void __fastcall TfrmKeys::actExitExecute(TObject *Sender)
{
    Close();
}
//---------------------------------------------------------------------------
void __fastcall TfrmKeys::actGenerateKeyExecute(TObject *Sender)
{
    TfrmWizard* pForm = new TfrmWizard(this);
    try
    {
        if (pForm->ShowModal() == mrOk)
        {
            pgpKeyring->AddSecretKey(pForm->FSecKey);
    //        pgpKeyring.AddPublicKey(FSecKey.PublicKey);
            RedrawKeyring(tvKeyring, pgpKeyring);
            SetStatus("New key was added to keyring");
        }
    }
    __finally
    {
        delete pForm;
    }
}
//---------------------------------------------------------------------------
void __fastcall TfrmKeys::actAddKeyExecute(TObject *Sender)
{
    TElPGPKeyring* tempKeyring = new TElPGPKeyring(NULL);
    if (OpenDlg->Execute())
    {
        try
        {
            tempKeyring->Load(OpenDlg->FileName, "", true);
        }
        catch(Exception &e)
        {
            MessageDlg(e.Message, mtError, TMsgDlgButtons()<<mbOK, 0);
            SetStatus("Failed to import key");
            delete tempKeyring;
        }

        TfrmImportKey* pForm = new TfrmImportKey(this);
        try
        {
            pForm->tvKeys->Images = imgTreeView;
            RedrawKeyring(pForm->tvKeys, tempKeyring);
            if (pForm->ShowModal() == mrOk)
            {
                tempKeyring->ExportTo(pgpKeyring);
                RedrawKeyring(tvKeyring, pgpKeyring);
            }
        }
        __finally
        {
            delete pForm;
        }
    }

    SetStatus((AnsiString)IntToStr(tempKeyring->PublicCount) + " key(s) successfully imported");
    delete tempKeyring;
}
//---------------------------------------------------------------------------
void __fastcall TfrmKeys::actRemoveKeyUpdate(TObject *Sender)
{
    ((TAction*)(Sender))->Enabled = (tvKeyring->Selected != NULL) &&
      (tvKeyring->Selected->Level == 0);
}
//---------------------------------------------------------------------------
void __fastcall TfrmKeys::actRemoveKeyExecute(TObject *Sender)
{
    if ((tvKeyring->Selected != NULL) && ((AnsiString(((TObject*)(tvKeyring->Selected->Data))->ClassName())) == "TElPGPPublicKey"))
    {
        TElPGPPublicKey* Key = ((TElPGPPublicKey*)(tvKeyring->Selected->Data));
        if (MessageDlg((AnsiString)"Are you sure you want to remove the key (" + GetDefaultUserID(Key) + ")?",
                      mtConfirmation, TMsgDlgButtons()<<mbYes<<mbNo, 0) == mrYes)
        {
            if (Key->SecretKey != NULL)
            {
                if (MessageDlg("The key you want to remove is SECRET! Are you still sure?",
                          mtConfirmation, TMsgDlgButtons()<<mbYes<<mbNo, 0) != mrYes)
                    return;
            }

            pgpKeyring->RemovePublicKey(Key, True);
            RedrawKeyring(tvKeyring, pgpKeyring);
            SetStatus("Key was successfully removed");
        }
    }
}
//---------------------------------------------------------------------------
void __fastcall TfrmKeys::actExportKeyExecute(TObject *Sender)
{
    if ((tvKeyring->Selected != NULL) && ((AnsiString(((TObject*)(tvKeyring->Selected->Data))->ClassName())) == "TElPGPPublicKey"))
    {
        TElPGPPublicKey* Key = ((TElPGPPublicKey*)(tvKeyring->Selected->Data));
        if (SaveDlg->Execute())
        {
            Key->SaveToFile(SaveDlg->FileName, true);
            SetStatus("Key saved");
        }
    }
}
//---------------------------------------------------------------------------
void __fastcall TfrmKeys::actSignUpdate(TObject *Sender)
{
    ((TAction*)Sender)->Enabled = (tvKeyring->Selected != NULL) &&
      (tvKeyring->Selected->Level < 2);
}
//---------------------------------------------------------------------------
TElPGPSignature* TfrmKeys::SignUser(TElPGPCustomUser* user, TElPGPCustomPublicKey* userKey, TElPGPSecretKey* signingKey)
{
    TElPGPSignature* Sig = new TElPGPSignature();
    Sig->CreationTime = TDateTime::CurrentDateTime();
    try
    {
        signingKey->Sign(((TElPGPPublicKey*)(userKey)), user, Sig, ctGeneric);
    }
    catch(Exception &e)