mainform.cpp

著名的SecureBlackBox控件完整源码

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

#include <vcl.h>
#pragma hdrstop

#include "MainForm.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma link "SBPGP"
#pragma link "SBPGPKeys"
#pragma resource "*.dfm"
TfrmForm *frmForm;
//---------------------------------------------------------------------------
__fastcall TfrmForm::TfrmForm(TComponent* Owner)
        : TForm(Owner)
{
  SetLicenseKey((AnsiString)
  "ADDCD14AD06709806817E0B3D7BFD0A2222D536FE156466C5D5FE65DB5DEAE76" + 
  "FFDEBC07E915A5751C12C01C783958872A38E4A5EDA140E7247E0F2E56442A3C" + 
  "F3E9347AD8FDE52083A0DFC86BC00ECB0FD0CF1B51159A2BCB84F6EA6349EF47" + 
  "5C15A59AFCC55F7C3AAD26C279628B5D91B1DC94BD2385354A70CCA3B76101D9" + 
  "F41C84A639FC3CCE4BA8F0CC4A66DCD150114A3F58C1AD46B7B94643741BC20A" + 
  "8DCA83AB921480951B423CAA19EF1863A47CA2C3422E7E5634BED98939A5AE43" + 
  "DE1E4BAD79E66D8A5C973B3455656C8C9B6FF024FADD6CDA02D0F506D98493C8" + 
  "BD1ED7B237DB75FA31F2C82654490CDDDEE24E19939137B9E1DB05508733B22F");
    pgpReader->OnSignatures = pgpReaderSignatures; 

}
//---------------------------------------------------------------------------
void __fastcall TfrmForm::FormCreate(TObject *Sender)
{

    ChangeState(STATE_SELECT_OPERATION);
    cbEncryptClick(NULL);
    cbSignClick(NULL);
}
//---------------------------------------------------------------------------
void __fastcall TfrmForm::btnCancelClick(TObject *Sender)
{
    Close();
}
//---------------------------------------------------------------------------
void __fastcall TfrmForm::btnNextClick(TObject *Sender)
{
    Next();
}
//---------------------------------------------------------------------------
void __fastcall TfrmForm::btnBackClick(TObject *Sender)
{
    Back();
}
//---------------------------------------------------------------------------
void TfrmForm::Back()
{
    ChangeState(GetPrevState(State));
}
//---------------------------------------------------------------------------
void TfrmForm::Next()
{
    switch (State)
    {
        case STATE_SELECT_OPERATION:
            if (rbProtect->Checked)
                ChangeState(STATE_PROTECT_SELECT_KEYRING);
            else
                ChangeState(STATE_DECRYPT_SELECT_KEYRING);
            break;
        case STATE_PROTECT_SELECT_KEYRING:
        case STATE_DECRYPT_SELECT_KEYRING:
            if (!FileExists(edPubKeyring->Text))
                MessageDlg((AnsiString)"Keyring file \"" + edPubKeyring->Text + "\" not found", mtError, TMsgDlgButtons()<<mbOK, 0);
            else if (!FileExists(edSecKeyring->Text))
                MessageDlg((AnsiString)"Keyring file \"" + edSecKeyring->Text + "\" not found", mtError, TMsgDlgButtons()<<mbOK, 0);
            else
            {
                try
                {
                    pgpKeyring->Load(edPubKeyring->Text, edSecKeyring->Text, true);
                }
                catch(Exception& e)
                {
                    MessageDlg((AnsiString)"Failed to load keyring: " + e.Message, mtError, TMsgDlgButtons()<<mbOK, 0);
                    return;
                }

                if (State == STATE_PROTECT_SELECT_KEYRING)
                    ChangeState(STATE_PROTECT_SELECT_SOURCE);
                else
                    ChangeState(STATE_DECRYPT_SELECT_SOURCE);
            }
            break;
        case STATE_PROTECT_SELECT_SOURCE:
            if (!FileExists(edFile->Text))
                MessageDlg((AnsiString)"Source file \"" + edFile->Text + "\" not found", mtError, TMsgDlgButtons()<<mbOK, 0);
            else
            {
                Source = edFile->Text;
                ChangeState(STATE_PROTECT_SELECT_OPERATION);
            }
            break;
        case STATE_PROTECT_SELECT_OPERATION:
            if (!(cbEncrypt->Checked || cbSign->Checked))
                MessageDlg("Please select protection operation", mtError, TMsgDlgButtons()<<mbOK, 0);
            else
            {
                if (cbEncrypt->Checked)
                    ChangeState(STATE_PROTECT_SELECT_RECIPIENTS);
                else
                    ChangeState(STATE_PROTECT_SELECT_SIGNERS);
            }
            break;
        case STATE_PROTECT_SELECT_RECIPIENTS:
            {
              pgpPubKeyring->Clear();
              for (int i = 0; i<lvKeys->Items->Count; i++)
                  if (lvKeys->Items->Item[i]->Checked)
                      pgpPubKeyring->AddPublicKey(((TElPGPPublicKey*)(lvKeys->Items->Item[i]->Data)));

              if ((pgpPubKeyring->PublicCount == 0) && (!cbUseConvEnc->Checked))
                  MessageDlg("At least one recipient key must be selected", mtError, TMsgDlgButtons()<<mbOK, 0);
              else
              {
                  if (cbSign->Checked)
                      ChangeState(STATE_PROTECT_SELECT_SIGNERS);
                  else
                      ChangeState(STATE_PROTECT_SELECT_DESTINATION);
              }
            }
            break;
        case STATE_PROTECT_SELECT_SIGNERS:
            {
              pgpSecKeyring->Clear();
              for (int i = 0; i<lvKeys->Items->Count; i++)
                if (lvKeys->Items->Item[i]->Checked)
                    pgpSecKeyring->AddSecretKey(((TElPGPSecretKey*)(lvKeys->Items->Item[i]->Data)));

              if (pgpSecKeyring->PublicCount == 0)
                  MessageDlg("At least one signer's key must be selected", mtError, TMsgDlgButtons()<<mbOK, 0);
              else
                  ChangeState(STATE_PROTECT_SELECT_DESTINATION);
            }
            break;
        case STATE_PROTECT_SELECT_DESTINATION:
            ChangeState(STATE_PROTECT_PROGRESS);
            break;
        case STATE_DECRYPT_SELECT_SOURCE:
            if (!FileExists(edFile->Text))
                MessageDlg("Source file \"" + edFile->Text + "\" not found", mtError, TMsgDlgButtons()<<mbOK, 0);
            else
            {
                Source = edFile->Text;
                ChangeState(STATE_DECRYPT_PROGRESS);
            }
            break;
    }
}
//---------------------------------------------------------------------------
AnsiString TfrmForm::RequestKeyPassphrase(TElPGPCustomSecretKey* Key, bool &Cancel)
{
    AnsiString UserName;

    Cancel = False;
    AnsiString Result = "";
    
    TfrmPassphraseRequest* pForm = new TfrmPassphraseRequest(this);
//    with TfrmPassphraseRequest.Create(Self) do

    try
    {
        if (Key != NULL)
        {
            if (AnsiString(Key->ClassName()) == AnsiString("TElPGPSecretKey"))
            {
                if (((TElPGPSecretKey*)(Key))->PublicKey->UserIDCount > 0)
                    UserName = ((TElPGPSecretKey*)(Key))->PublicKey->UserIDs[0]->Name;
                else
                    UserName = "<no name>";
            }
            else
                UserName = "Subkey";

            pForm->lbPrompt->Caption = "Passphrase is needed for secret key:";
			pForm->lbKeyID->Caption = UserName;// + " (ID=0x" + KeyID2Str(AnsiString(Key->KeyID( ()).c_str(), true) + ")";
        }
        else
        {
            pForm->lbPrompt->Caption = "Passphrase is needed to decrypt the message";
            pForm->lbKeyID->Caption = "";
        }

        if (pForm->ShowModal() == mrOk)
            Result = pForm->edPassphrase->Text;
        else
            Cancel = true;
    }
    __finally
    {
        delete pForm;
    }
    return Result;
}
//---------------------------------------------------------------------------
void TfrmForm::EnableButtons(bool Back, bool Next)
{
    btnBack->Enabled = Back;
    btnNext->Enabled = Next;
}
//---------------------------------------------------------------------------
void TfrmForm::SetCaption(const AnsiString Stage, AnsiString Comment)
{
    lbStage->Caption = Stage;
    lbStageComment->Caption = Comment;
}
//---------------------------------------------------------------------------
int TfrmForm::GetPrevState(int State)
{
    switch(State)
    {
        case STATE_SELECT_OPERATION:
            return STATE_INVALID;
        case STATE_PROTECT_SELECT_KEYRING:
            return STATE_SELECT_OPERATION;
        case STATE_PROTECT_SELECT_SOURCE:
            return STATE_PROTECT_SELECT_KEYRING;
        case STATE_PROTECT_SELECT_OPERATION:
            return STATE_PROTECT_SELECT_SOURCE;
        case STATE_PROTECT_SELECT_DESTINATION:
            if (cbSign->Checked)
                return STATE_PROTECT_SELECT_SIGNERS;
            else
                return STATE_PROTECT_SELECT_RECIPIENTS;
        case STATE_PROTECT_SELECT_RECIPIENTS:
            return STATE_PROTECT_SELECT_OPERATION;
        case STATE_PROTECT_SELECT_SIGNERS:
            if (cbEncrypt->Checked)
                return STATE_PROTECT_SELECT_RECIPIENTS;
            else
                return STATE_PROTECT_SELECT_OPERATION;
        case STATE_DECRYPT_SELECT_KEYRING:
            return STATE_SELECT_OPERATION;
        case STATE_DECRYPT_SELECT_SOURCE:
            return STATE_DECRYPT_SELECT_KEYRING;
        default:
            return STATE_INVALID;
    }
}
//---------------------------------------------------------------------------
void TfrmForm::ChangeState(int nextState)
{
    switch(nextState)
    {
        case STATE_SELECT_OPERATION:
            {
                SetCaption("Preparatory stage", "Choose desired operation");
                EnableButtons(false, true);
                PageControl->ActivePage = tsOperationSelect;
            }
            break;
        case STATE_PROTECT_SELECT_KEYRING:
            {
                SetCaption("Step 1 of 6", "Select keyring files");
                EnableButtons(true, true);
                PageControl->ActivePage = tsKeyringSelect;
            }
            break;
        case STATE_PROTECT_SELECT_SOURCE:
            {
                SetCaption("Step 2 of 6", "Select file to protect");
                lbFileSelectComment->Caption = "";
                EnableButtons(true, true);
                PageControl->ActivePage = tsFileSelect;
             }
             break;
        case STATE_PROTECT_SELECT_OPERATION:
            {
                SetCaption("Step 3 of 6", "Select protection options");
                EnableButtons(true, true);
                cbEncryptionAlg->Text = "CAST5";
                cbProtLevel->Text = "Low";

                if (pgpKeyring->SecretCount == 0)
                {
                    cbSign->Checked = false;
                    cbSign->Enabled = false;
                }
                else
                  cbSign->Enabled = true;

                if (pgpKeyring->PublicCount == 0)
                {
                    cbEncrypt->Checked = false;
                    cbEncrypt->Enabled = false;
                }
                else
                  cbEncrypt->Enabled = true;

                PageControl->ActivePage = tsEncOps;
             }
             break;

         case STATE_PROTECT_SELECT_RECIPIENTS:
             {
                 SetCaption("Step 4 of 6", "Select recipients");
                 EnableButtons(true, true);
                 KeysToList(true);
                 edPassphrase->Visible = cbUseConvEnc->Checked;
                 edPassphraseConf->Visible = cbUseConvEnc->Checked;
                 lbPassphrase->Visible = cbUseConvEnc->Checked;
                 lbPassphraseConfirmation->Visible = cbUseConvEnc->Checked;
                 PageControl->ActivePage = tsUserSelect;
             }
             break;

         case STATE_PROTECT_SELECT_SIGNERS:
             {
                 SetCaption("Step 4 of 6", "Select signers");
                 EnableButtons(true, true);
                 KeysToList(false);
                 edPassphrase->Visible = false;
                 edPassphraseConf->Visible = false;
                 lbPassphrase->Visible = false;
                 lbPassphraseConfirmation->Visible = false;
                 PageControl->ActivePage = tsUserSelect;
             }
             break;

         case STATE_PROTECT_SELECT_DESTINATION:
             {
                 SetCaption("Step 5 of 6", "Select destination file");
                 lbFileSelectComment->Caption = "";
                 edFile->Text = Source + ".pgp";
                 EnableButtons(true, true);
                 PageControl->ActivePage = tsFileSelect;
             }
             break;

         case STATE_PROTECT_PROGRESS:
             {
                 SetCaption("Step 6 of 6", "Protecting file");
                 EnableButtons(false, false);
                 pbProgress->Position = 0;
                 lbProcessingFile->Visible = true;
                 pbProgress->Visible = true;
                 lbErrorComment->Caption = "";
                 lbFinished->Caption = "Operation successfully finished";
                 PageControl->ActivePage = tsProgress;
                 try
                 {
                     ProtectFile(Source, edFile->Text);
                 }
                 catch(Exception &e)
                 {
                     lbErrorComment->Caption = e.Message;
                     lbFinished->Caption = "ERROR";
                 }

                 pbProgress->Visible = false;
                 lbProcessingFile->Visible = false;
                 ChangeState(STATE_PROTECT_FINISH);
             }
             break;