ascryptocomp.int

CryptoKit使用简便的加密解密控件。(源代码

    function  GetKeyMaxByteLen: DWord;      override;
    function  GetKeyMinByteLen: DWord;      override;
  public
    constructor Create(AOwner: TComponent); override;
  end;

  TAS_IDEACryptography = 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;

  // asymmetric algorithms

  TAS_PrimeGenerator = class;
  TAS_Digest         = class;

  TSignEvent   = procedure (Sender: TObject; Data: Pointer; DataSize: DWord) of object;
  TVerifyEvent = procedure (Sender: TObject; Data: Pointer; DataSize: DWord; SignData: Pointer; SignSize: DWord) of object;

  TAS_RSACryptography = class(TAS_Cryptography)
  private
    FEncParam: string;
    FKeyD:           GiantInt;
    FKeyE:           GiantInt;
    FKeyN:           GiantInt;
    FPrimeGenerator: TAS_PrimeGenerator;
    FEncryptScheme:  TRSAEncryptionScheme;
    FEncryptDigest:  TAS_Digest;
    FSignDigest:     TAS_Digest;
    FSignature:      TMemoryStream;
    FOnChangeKeyN:   TNotifyEvent;
    FOnChangeKeyE:   TNotifyEvent;
    FOnChangeKeyD:   TNotifyEvent;
    FOnBeforeSign:   TSignEvent;
    FOnAfterSign:    TSignEvent;
    FOnAfterVerify:  TVerifyEvent;
    FOnBeforeVerify: TVerifyEvent;
    function  GetKeyDHexStr: string;
    function  GetKeyEHexStr: string;
    function  GetKeyNHexStr: string;
    procedure SetKeyDHexStr(const Value: string);
    procedure SetKeyEHexStr(const Value: string);
    procedure SetKeyNHexStr(const Value: string);
    function  GetSmallPubExp: DWord;
    procedure SetSmallPubExp(Value: DWord);
  private
    function  RSAEncryptOaep(Source: Pointer; SourceLen: DWord): Boolean;
    function  RSADecryptOaep(EncData: Pointer; EncLen: DWord): Boolean;
    function  RSAEncryptPkcs1(Source: Pointer; SourceLen: DWord): Boolean;
    function  RSADecryptPkcs1(EncData: Pointer; EncLen: DWord): Boolean;
    function  RSASignPkcs1(Source: Pointer; SourceLen: DWord): Boolean;
    function  RSAVerifyPkcs1(Source: Pointer; SourceLen: DWord; SignData: Pointer; SignLen: DWord): Boolean;
    function  EmeEncodeOaep(Source:  Pointer;  SourceLen: Integer; EncData: PByteArray; EncLen: Integer): Boolean;
    function  EmeDecodeOaep(EncData: PByteArray; EncLen: Integer; DecData: Pointer; var DecLen: Integer): Boolean;
    procedure GenerateAndXorMask(Z: PByteArray; ZSize: Integer; Mask: PByteArray; MaskSize: Integer);
    function  EmeEncodePkcs1(Source: Pointer;  SourceLen: Integer; EncData: PByteArray; EncLen: Integer): Boolean;
    function  EmeDecodePkcs1(EncData: PByteArray; EncLen: Integer; DecData: Pointer; var DecLen: Integer): Boolean;
    function  EmsaEncodePkcs1(Source: Pointer; SourceLen: Integer; EncData: PByteArray; EncLen: Integer): Boolean;
    function  IsReadyToSign: Boolean;
    function  IsReadyToVerify: Boolean;
    procedure SetReadyToSign(const Value: Boolean);
    procedure SetReadyToVerify(const Value: Boolean);
  protected
    procedure DoEncrypt(Data: Pointer; DataSize: DWord); override;
    procedure DoDecrypt(Data: Pointer; DataSize: DWord); override;
    procedure DoSign(Data: Pointer; DataSize: DWord);    virtual;
    procedure DoVerify(Data: Pointer; DataSize: DWord; SignData: Pointer; SignSize: DWord); virtual;
    procedure DoGenKeys(KeyByteLen: DWord);              override;
    procedure DoLoadKeys(const FileName: string);        override;
    procedure DoSaveKeys(const FileName: string);        override;
    function  GetKeyMaxByteLen: DWord;                   override;
    function  GetKeyMinByteLen: DWord;                   override;
    function  IsReadyToEncrypt: Boolean;                 override;
    function  IsReadyToDecrypt: Boolean;                 override;
    function  GetKeyNumBits: DWord;                      override;
    procedure SetCipherInPlace(Value: Boolean);          override;
  public
    constructor Create(AOwner: TComponent); override;
    destructor  Destroy; override;
    procedure SignData(Data: Pointer; DataSize: DWord);
    procedure SignFile(const FileName: string);
    procedure VerifySignature(Data: Pointer; DataSize: DWord; SignData: Pointer; SignSize: DWord);
    procedure VerifyFileSignature(const FileName: string; SignData: Pointer; SignSize: DWord);
    procedure LoadSignatureFromFile(const FileName: string);
    procedure SaveSignatureToFile(const FileName: string);
    property KeyD:             GiantInt             read FKeyD;
    property KeyE:             GiantInt             read FKeyE;
    property KeyN:             GiantInt             read FKeyN;
    property Signature:        TMemoryStream        read FSignature;
  published
    property EncryptingDigest: TAS_Digest           read FEncryptDigest  write FEncryptDigest;
    property SigningDigest:    TAS_Digest           read FSignDigest     write FSignDigest;
    property EncodingParam:    string               read FEncParam       write FEncParam;
    property EncryptionScheme: TRSAEncryptionScheme read FEncryptScheme  write FEncryptScheme   default esOaep;
    property KeyDHexStr:       string               read GetKeyDHexStr   write SetKeyDHexStr;
    property KeyEHexStr:       string               read GetKeyEHexStr   write SetKeyEHexStr;
    property KeyNHexStr:       string               read GetKeyNHexStr   write SetKeyNHexStr;
    property SmallPublicExp:   DWord                read GetSmallPubExp  write SetSmallPubExp   stored False;
    property PrimeGenerator:   TAS_PrimeGenerator   read FPrimeGenerator write FPrimeGenerator;
    property ReadyToSign:      Boolean              read IsReadyToSign   write SetReadyToSign   stored False;
    property ReadyToVerify:    Boolean              read IsReadyToVerify write SetReadyToVerify stored False;
    property OnChangeKeyE:     TNotifyEvent         read FOnChangeKeyE   write FOnChangeKeyE;
    property OnChangeKeyD:     TNotifyEvent         read FOnChangeKeyD   write FOnChangeKeyD;
    property OnChangeKeyN:     TNotifyEvent         read FOnChangeKeyN   write FOnChangeKeyN;
    property OnBeforeSign:     TSignEvent           read FOnBeforeSign   write FOnBeforeSign;
    property OnAfterSign:      TSignEvent           read FOnAfterSign    write FOnAfterSign;
    property OnBeforeVerify:   TVerifyEvent         read FOnBeforeVerify write FOnBeforeVerify;
    property OnAfterVerify:    TVerifyEvent         read FOnAfterVerify  write FOnAfterVerify;
  end;

  TGenRandomNotifyEvent = procedure (Sender: TObject; rnd: GiantInt) of object;
  TCustomGenRandomEvent = procedure (Sender: TObject; rnd: GiantInt; NumBits: Integer; top, bottom: Boolean) of object;

  TAS_RandomGenerator = class(TAS_Component)
  private
    FOnCustomGenRandom: TCustomGenRandomEvent;
    FOnBeforeGenRandom: TGenRandomNotifyEvent;
    FOnAfterGenRandom:  TGenRandomNotifyEvent;
  protected
    procedure DoGenRandom(rnd: GiantInt; NumBits: Integer; top, bottom: Boolean); virtual;
  public
    constructor Create(AOwner: TComponent); override;
    procedure GenerateRandom(rnd: GiantInt; NumBits: Integer; top, bottom: Boolean);
  published
    property OnCustomGenRandom: TCustomGenRandomEvent read FOnCustomGenRandom write FOnCustomGenRandom;
    property OnBeforeGenRandom: TGenRandomNotifyEvent read FOnBeforeGenRandom write FOnBeforeGenRandom;
    property OnAfterGenRandom:  TGenRandomNotifyEvent read FOnAfterGenRandom  write FOnAfterGenRandom;
  end;

  TGenPrimeNotifyEvent = procedure (Sender: TObject; prime: GiantInt) of object;
  TCustomGenPrimeEvent = procedure (Sender: TObject; prime: GiantInt; NumBits: Integer) of object;

  TAS_PrimeGenerator = class(TAS_Component)
  private
    FRandomGenerator:  TAS_RandomGenerator;
    FOnCustomGenPrime: TCustomGenPrimeEvent;
    FOnBeforeGenPrime: TGenPrimeNotifyEvent;
    FOnAfterGenPrime:  TGenPrimeNotifyEvent;
    FOnTryRandomPrime: TGenPrimeNotifyEvent;
  protected
    procedure DoGenPrime(prime: GiantInt; NumBits: Integer); virtual;
    function  IsPrime(n: GiantInt; checks: Integer): Boolean; virtual;
  public
    constructor Create(AOwner: TComponent); override;
    procedure GeneratePrime(prime: GiantInt; NumBits: Integer);
  published
    property RandomGenerator:  TAS_RandomGenerator  read FRandomGenerator  write FRandomGenerator;
    property OnCustomGenPrime: TCustomGenPrimeEvent read FOnCustomGenPrime write FOnCustomGenPrime;
    property OnBeforeGenPrime: TGenPrimeNotifyEvent read FOnBeforeGenPrime write FOnBeforeGenPrime;
    property OnTryRandomPrime: TGenPrimeNotifyEvent read FOnTryRandomPrime write FOnTryRandomPrime;
    property OnAfterGenPrime:  TGenPrimeNotifyEvent read FOnAfterGenPrime  write FOnAfterGenPrime;
  end;

  // digest

  TAS_Digest = class(TAS_Component)
  private
    FOnBeforeCalcDigest: TNotifyEvent;
    FOnAfterCalcDigest: TNotifyEvent;
  protected
    FDigestSize: Integer;
    procedure DoCalcDigest(Data: Pointer; DataSize: DWord); virtual; abstract;
    function  GetDigest: Pointer;                           virtual; abstract;
  public
    procedure CalcDigest(Data: Pointer; DataSize: DWord);
    procedure CalcDigestOfString(const S: string);
    procedure CalcDigestOfFile(const FileName: string);
    property Digest:     Pointer read GetDigest;
    property DigestSize: Integer read FDigestSize;
  published
    property OnBeforeCalcDigest: TNotifyEvent read FOnBeforeCalcDigest write FOnBeforeCalcDigest;
    property OnAfterCalcDigest:  TNotifyEvent read FOnAfterCalcDigest  write FOnAfterCalcDigest;
  end;

  TAS_DigestMDX = class(TAS_Digest)
  private
    FDigestMDX: TDigestMDX;
    FDigestVer: TMDXVersion;
  protected
    procedure DoCalcDigest(Data: Pointer; DataSize: DWord); override;
    function  GetDigest: Pointer;                           override;
  public
    constructor Create(AOwner: TComponent); override;
    property DigestMDX: TDigestMDX read FDigestMDX;
  published
    property Version: TMDXVersion read FDigestVer write FDigestVer default dgMD5;
  end;

  TAS_DigestSHA1 = class(TAS_Digest)
  private
    FDigestSHA1: TDigest160;
  protected
    procedure DoCalcDigest(Data: Pointer; DataSize: DWord); override;
    function  GetDigest: Pointer;                           override;
  public
    constructor Create(AOwner: TComponent); override;
    property DigestSHA1: TDigest160 read FDigestSHA1;
  end;

  TAS_DigestRIPEMD160 = class(TAS_Digest)
  private
    FDigestRIP: TDigest160;
  protected
    procedure DoCalcDigest(Data: Pointer; DataSize: DWord); override;
    function  GetDigest: Pointer;                           override;
  public
    constructor Create(AOwner: TComponent); override;
    property DigestRIPMDE160: TDigest160 read FDigestRIP;
  end;

  // coders

  TAS_Coding = class(TAS_Component)
  private
    FCodeInPlace:    Boolean;
    FDecodedData:    TMemoryStream;
    FEncodedData:    TMemoryStream;
    FOnBeforeEncode: TNotifyEvent;
    FOnAfterEncode:  TNotifyEvent;
    FOnBeforeDecode: TNotifyEvent;
    FOnAfterDecode:  TNotifyEvent;
  protected
    procedure DoEncode(Data: Pointer; DataLen: DWord; EncData: Pointer; EncDataSize: DWord; var EncDataLen: DWord); virtual; abstract;
    procedure DoDecode(Data: Pointer; DataLen: DWord; DecData: Pointer; DecDataSize: DWord; var DecDataLen: DWord); virtual; abstract;
    procedure SetCodeInPlace(Value: Boolean);                                                                        virtual; abstract;
  public
    constructor Create(AOwner: TComponent); override;
    destructor  Destroy; override;
    procedure Encode(Data: Pointer; DataSize: DWord);
    procedure Decode(Data: Pointer; DataSize: DWord);
    function  EncodeString(const S: string): string;
    function  DecodeString(const S: string): string;
    procedure EncodeFile(const FileName, DestFileName: string);
    procedure DecodeFile(const FileName, DestFileName: string);
    function  CalcEncodedSize(Data: Pointer; DataLen: DWord): DWord; virtual; abstract;
    function  CalcDecodedSize(Data: Pointer; DataLen: DWord): DWord; virtual; abstract;
    property  EncodedData:  TMemoryStream read FEncodedData;
    property  DecodedData:  TMemoryStream read FDecodedData;
  published
    property CodeInPlace:    Boolean      read FCodeInPlace    write SetCodeInPlace default False;
    property OnBeforeEncode: TNotifyEvent read FOnBeforeEncode write FOnBeforeEncode;
    property OnAfterEncode:  TNotifyEvent read FOnAfterEncode  write FOnAfterEncode;
    property OnBeforeDecode: TNotifyEvent read FOnBeforeDecode write FOnBeforeDecode;
    property OnAfterDecode:  TNotifyEvent read FOnAfterDecode  write FOnAfterDecode;
  end;

  TAS_Base64Coding = class(TAS_Coding)
  protected
    procedure DoEncode(Data: Pointer; DataLen: DWord; EncData: Pointer; EncDataSize: DWord; var EncDataLen: DWord); override;
    procedure DoDecode(Data: Pointer; DataLen: DWord; DecData: Pointer; DecDataSize: DWord; var DecDataLen: DWord); override;
    procedure SetCodeInPlace(Value: Boolean);                                                                        override;
  public
    constructor Create(AOwner: TComponent); override;
    function  CalcEncodedSize(Data: Pointer; DataLen: DWord): DWord; override;
    function  CalcDecodedSize(Data: Pointer; DataLen: DWord): DWord; override;
  end;

procedure Register;