unit ASCryptoComp;
interface
uses
  Windows, SysUtils, Forms, Dialogs, Classes,
  ASCryptos, ASGtMath, ASUtils, ASAbout;

resourcestring
  sInvalidKey           = 'Invalid key';
  sPostInvalidKey       = 'Key considered invalid by application';
  sInvalidKeyMul        = 'Key length must be multiple of %d bytes';
  sInvalidKeySize       = 'Invalid key length: %d bytes, must be %d bytes';
  sKeyTooShort          = 'Key too short: %d bytes, must be at least %d bytes';
  sKeyTooLong           = 'Key too long: %d bytes, must not exceed %d bytes';
  sNotReadyEncrypt      = 'Not ready to encrypt, must have valid key';
  sNotReadyDecrypt      = 'Not ready to decrypt, must have valid key';
  sMustBePrime          = 'Number must be prime: %d';

  sRSANotReadySign      = 'Not ready to sign, must have valid private key';
  sRSANotReadyVerify    = 'Not ready to verify signature, must have valid public key';

  sRSAEncryptError      = 'RSA encode error';
  sRSADecryptError      = 'RSA decode error';
  sRSASignError         = 'RSA sign error';
  sRSAVerifyError       = 'RSA verify error';
  sRSANeedEncryptDigest = 'RSA must have EncryptionDigest component property assigned to operate on OAEP scheme';
  sRSANeedSignDigest    = 'RSA must have SigningDigest component property assigned to sign/verify data';
  sRSAMustHavePrimeGen  = 'RSA must have PrimeGenerator component property assigned to generate keys';
  sTrialWarning         = 'Sorry, trial version must be run from %s!';


type
  ErrorCipher = class(Exception);

  TAS_Component = class(TComponent)
  private
    FAbout: TAboutInfo;
  published
    constructor Create(AOwner: TComponent); override;
    destructor  Destroy; override;
    procedure Error(ResStringRec: PResStringRec; const Args: array of const);
    property About: TAboutInfo read FAbout write FAbout;
  end;

  // cryptography

  TCipherBlockEvent = procedure (Sender: TObject; Block: Pointer; Offset, Size: DWord) of object;

  TAS_Cryptography = class(TAS_Component)
  private
    FCipherInPlace:        Boolean;
    FDecryptedData:        TMemoryStream;
    FEncryptedData:        TMemoryStream;
    FOnBeforeEncrypt:      TNotifyEvent;
    FOnAfterEncrypt:       TNotifyEvent;
    FOnBeforeDecrypt:      TNotifyEvent;
    FOnAfterDecrypt:       TNotifyEvent;
    FOnBeforeEncryptBlock: TCipherBlockEvent;
    FOnAfterEncryptBlock:  TCipherBlockEvent;
    FOnBeforeDecryptBlock: TCipherBlockEvent;
    FOnAfterDecryptBlock:  TCipherBlockEvent;
    FOnBeforeGenKeys:      TNotifyEvent;
    FOnAfterGenKeys:       TNotifyEvent;
    FOnBeforeLoadKeys:     TNotifyEvent;
    FOnAfterLoadKeys:      TNotifyEvent;
    FOnBeforeSaveKeys:     TNotifyEvent;
    FOnAfterSaveKeys:      TNotifyEvent;
  protected
    procedure DoEncrypt(Data: Pointer; DataSize: DWord); virtual; abstract;
    procedure DoDecrypt(Data: Pointer; DataSize: DWord); virtual; abstract;
    procedure DoGenKeys(KeyByteLen: DWord);              virtual; abstract;
    procedure DoLoadKeys(const FileName: string);        virtual; abstract;
    procedure DoSaveKeys(const FileName: string);        virtual; abstract;
    function  GetKeyMinByteLen: DWord;                   virtual; abstract;
    function  GetKeyMaxByteLen: DWord;                   virtual; abstract;
    procedure SetKeyMinByteLen(Value: DWord);             // dummy
    procedure SetKeyMaxByteLen(Value: DWord);             // dummy
    function  IsReadyToEncrypt: Boolean;                 virtual; abstract;
    function  IsReadyToDecrypt: Boolean;                 virtual; abstract;
    procedure SetReadyToEncrypt(Value: Boolean);         // dummy
    procedure SetReadyToDecrypt(Value: Boolean);         // dummy
    function  GetKeyNumBits: DWord;                      virtual; abstract;
    procedure SetKeyNumBits(Value: DWord);               // dummy
    procedure SetCipherInPlace(Value: Boolean);          virtual;
  public
    constructor Create(AOwner: TComponent); override;
    destructor  Destroy; override;
    procedure Encrypt(Data: Pointer; DataSize: DWord);
    procedure Decrypt(Data: Pointer; DataSize: DWord);
    procedure EncryptFile(const FileName, DestFileName: string);
    procedure DecryptFile(const FileName, DestFileName: string);
    procedure GenerateKeys(KeyByteLen: DWord);
    procedure LoadKeysFromFile(const FileName: string);
    procedure SaveKeysToFile(const FileName: string);
    property  EncryptedData:    TMemoryStream read FEncryptedData;
    property  DecryptedData:    TMemoryStream read FDecryptedData;
  published
    property CipherInPlace:        Boolean           read FCipherInPlace        write SetCipherInPlace default False;
    property KeyMinByteLen:        DWord             read GetKeyMinByteLen      write SetKeyMinByteLen  stored False;
    property KeyMaxByteLen:        DWord             read GetKeyMaxByteLen      write SetKeyMaxByteLen  stored False;
    property KeyNumBits:           DWord             read GetKeyNumBits         write SetKeyNumBits     stored False;
    property ReadyToEncrypt:       Boolean           read IsReadyToEncrypt      write SetReadyToEncrypt stored False;
    property ReadyToDecrypt:       Boolean           read IsReadyToDecrypt      write SetReadyToDecrypt stored False;
    property OnBeforeEncrypt:      TNotifyEvent      read FOnBeforeEncrypt      write FOnBeforeEncrypt;
    property OnAfterEncrypt:       TNotifyEvent      read FOnAfterEncrypt       write FOnAfterEncrypt;
    property OnBeforeDecrypt:      TNotifyEvent      read FOnBeforeDecrypt      write FOnBeforeDecrypt;
    property OnAfterDecrypt:       TNotifyEvent      read FOnAfterDecrypt       write FOnAfterDecrypt;
    property OnBeforeEncryptBlock: TCipherBlockEvent read FOnBeforeEncryptBlock write FOnBeforeEncryptBlock;
    property OnAfterEncryptBlock:  TCipherBlockEvent read FOnAfterEncryptBlock  write FOnAfterEncryptBlock;
    property OnBeforeDecryptBlock: TCipherBlockEvent read FOnBeforeDecryptBlock write FOnBeforeDecryptBlock;
    property OnAfterDecryptBlock:  TCipherBlockEvent read FOnAfterDecryptBlock  write FOnAfterDecryptBlock;
    property OnBeforeGenKeys:      TNotifyEvent      read FOnBeforeGenKeys      write FOnBeforeGenKeys;
    property OnAfterGenKeys:       TNotifyEvent      read FOnAfterGenKeys       write FOnAfterGenKeys;
    property OnBeforeLoadKeys:     TNotifyEvent      read FOnBeforeLoadKeys     write FOnBeforeLoadKeys;
    property OnAfterLoadKeys:      TNotifyEvent      read FOnAfterLoadKeys      write FOnAfterLoadKeys;
    property OnBeforeSaveKeys:     TNotifyEvent      read FOnBeforeSaveKeys     write FOnBeforeSaveKeys;
    property OnAfterSaveKeys:      TNotifyEvent      read FOnAfterSaveKeys      write FOnAfterSaveKeys;
  end;

  // symmetric algorithms

  TValidateKeyEvent = procedure (Sender: TObject; Key: Pointer; KeyByteLen: Integer; var KeyValid: Boolean) of object;

  TAS_SymmCryptography = class(TAS_Cryptography)
  private
    FCipherMode:           TCipherMode;
    FBlockSize:            DWord;
    FUserKey:              Pointer;
    FUserKeyByteLen:       DWord;
    FExtendedKey:          Pointer;
    FExtKeyByteLen:        DWord;
    FInitVector:           Pointer;
    FInitVectorSize:       DWord;
    FOnChangeKey:          TNotifyEvent;
    FOnPostValidateKey:    TValidateKeyEvent;
    FOnChangeInitVector:   TNotifyEvent;
    function  GetUserKeyHexStr: string;
    procedure SetUserKeyHexStr(const Value: string);
    function  GetUserKeyText: string;
    procedure SetUserKeyText(const Value: string);
    function  GetInitVectorText: string;
    procedure SetInitVectorText(const Value: string);
    function  GetInitVectorHexStr: string;
    procedure SetInitVectorHexStr(const Value: string);
  protected
    procedure DoGenKeys(KeyByteLen: DWord);                   override;
    procedure DoLoadKeys(const FileName: string);             override;
    procedure DoSaveKeys(const FileName: string);             override;
    procedure DoEncrypt(Data: Pointer; DataSize: DWord);      override;
    procedure DoDecrypt(Data: Pointer; DataSize: DWord);      override;
    function  IsReadyToEncrypt: Boolean;                      override;
    function  IsReadyToDecrypt: Boolean;                      override;
    function  GetKeyNumBits: DWord;                           override;
  protected
    function  CalcExtKeyByteLen: DWord;                       virtual; abstract;
    procedure BlockEncrypt(Data: Pointer);                    virtual; abstract;
    procedure BlockDecrypt(Data: Pointer);                    virtual; abstract;
    procedure DoExpandKey;                                    virtual; abstract;
    procedure DoValidateKey(Key: Pointer; KeyByteLen: DWord); virtual;
    procedure UpdateKey;
    procedure SetCipherMode(const Value: TCipherMode);        virtual;
  public
    constructor Create(AOwner: TComponent); override;
    destructor  Destroy; override;
    procedure ValidateKey(Key: Pointer; KeyByteLen: DWord);
    procedure SetUserKey(Key: Pointer; KeyByteLen: DWord);
    procedure SetInitVector(IV: Pointer; IVSize: DWord);
    property BlockSize:            DWord             read FBlockSize default DEF_BLOCK_BYTES;
    property UserKey:              Pointer           read FUserKey;
    property UserKeyByteLen:       DWord             read FUserKeyByteLen;
    property ExtendedKey:          Pointer           read FExtendedKey;
    property ExtKeyByteLen:        DWord             read FExtKeyByteLen;
    property InitVector:           Pointer           read FInitVector;
    property InitVectorSize:       DWord             read FInitVectorSize;
  published
    property CipherMode:           TCipherMode       read FCipherMode           write SetCipherMode default cmECB;
    property KeyHexStr:            string            read GetUserKeyHexStr      write SetUserKeyHexStr stored False;
    property KeyText:              string            read GetUserKeyText        write SetUserKeyText;
    property InitVectorText:       string            read GetInitVectorText     write SetInitVectorText;
    property InitVectorHexStr:     string            read GetInitVectorHexStr   write SetInitVectorHexStr stored False;
    property OnChangeKey:          TNotifyEvent      read FOnChangeKey          write FOnChangeKey;
    property OnChangeInitVector:   TNotifyEvent      read FOnChangeInitVector   write FOnChangeInitVector;
    property OnPostValidateKey:    TValidateKeyEvent read FOnPostValidateKey    write FOnPostValidateKey;
  end;

  TAS_DESCryptography = class(TAS_SymmCryptography)
  private
    FCipherMask: DWord;
  protected
    function  CalcExtKeyByteLen: DWord;     override;
    procedure BlockEncrypt(Data: Pointer);  override;
    procedure BlockDecrypt(Data: Pointer);  override;
    procedure DoExpandKey;                  override;
    procedure DoValidateKey(Key: Pointer; KeyByteLen: DWord); override;
    function  GetKeyMinByteLen: DWord;      override;
    function  GetKeyMaxByteLen: DWord;      override;
  public
    constructor Create(AOwner: TComponent); override;
  published
    property CipherMask: DWord read FCipherMask write FCipherMask default DES_TRIPLE_CODEMASK; // triple DES = (enc, dec, enc)
  end;

  TAS_RC2Cryptography = class(TAS_SymmCryptography)
  private
    FEffBits: DWord;
    procedure SetEffBits(Value: DWord);
  protected
    function  CalcExtKeyByteLen: DWord;     override;
    procedure BlockEncrypt(Data: Pointer);  override;
    procedure BlockDecrypt(Data: Pointer);  override;
    procedure DoExpandKey;                  override;
    function  GetKeyMaxByteLen: DWord;      override;
    function  GetKeyMinByteLen: DWord;      override;
  public
    constructor Create(AOwner: TComponent); override;
  published
    property EffectiveBits: DWord read FEffBits write SetEffBits default RC2_DEF_EFFBITS;
  end;

  TAS_RC4Cryptography = class(TAS_SymmCryptography)
  private
  protected
    function  CalcExtKeyByteLen: DWord;     override;
    procedure DoEncrypt(Data: Pointer; DataSize: DWord); override;
    procedure DoDecrypt(Data: Pointer; DataSize: DWord); override;
    procedure DoExpandKey;                  override;
    function  GetKeyMaxByteLen: DWord;      override;
    function  GetKeyMinByteLen: DWord;      override;
    procedure SetCipherMode(const Value: TCipherMode);   override;
  public
    constructor Create(AOwner: TComponent); override;
  end;

  TAS_RC5Cryptography = class(TAS_SymmCryptography)
  private
    FNumRounds: Integer;
    procedure SetNumRounds(Value: Integer);
  protected
    function  CalcExtKeyByteLen: DWord;     override;
    procedure BlockEncrypt(Data: Pointer);  override;
    procedure BlockDecrypt(Data: Pointer);  override;
    procedure DoExpandKey;                  override;
    function  GetKeyMaxByteLen: DWord;      override;
    function  GetKeyMinByteLen: DWord;      override;
  public
    constructor Create(AOwner: TComponent); override;
  published
    property NumRounds: Integer read FNumRounds write SetNumRounds default RC5_DEF_ROUNDS;
  end;

  TAS_BFCryptography = class(TAS_SymmCryptography)
  protected
    function  CalcExtKeyByteLen: DWord;     override;
    procedure BlockEncrypt(Data: Pointer);  override;
    procedure BlockDecrypt(Data: Pointer);  override;
    procedure DoExpandKey;                  override;
    function  GetKeyMaxByteLen: DWord;      override;
    function  GetKeyMinByteLen: DWord;      override;
  public
    constructor Create(AOwner: TComponent); override;
  end;

  TAS_CASTCryptography = class(TAS_SymmCryptography)
  protected
    function  CalcExtKeyByteLen: DWord;     override;
    procedure BlockEncrypt(Data: Pointer);  override;
    procedure BlockDecrypt(Data: Pointer);  override;
    procedure DoExpandKey;                  override;