nints.pas

cipher 5.1。一个几乎包含了所有常见的加密算法的控件

{Copyright:      Hagen Reddmann  HaReddmann at T-Online dot de
 Author:         Hagen Reddmann
 Remarks:        this Copyright must be included
 known Problems: none
 Version:        5.1,  Part II from Delphi Encryption Compendium
                 Delphi 5

 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ''AS IS'' AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

}
unit NInts;

{$I VER.INC}

interface

uses TypInfo, Classes, SysUtils, CRC, DECUtil, DECHash, DECFmt, NMath;

type
  TBase = type Word;// 0= Default or Parse, 2..64= valid StringFormats, 256= Byte copying

  TIntegerFormat = (ifASN1, ifDEC, ifCRC, ifPGP, ifPlain, ifFast);

  TNAFArray = array of Integer;

  TPiece = (piBit, piByte, piWord, piLong);

  Long96 = array[0..2] of Cardinal;

  IInteger = interface
    ['{126BE010-061D-4067-9E0A-E2A490AF5CEA}']
    function Count: Integer;
    function GetDigit(Index: Integer): Cardinal;

    property Digit[Index: Integer]: Cardinal read GetDigit; default;
  end;

  I2Point = packed record
    X,Y: IInteger;
  end;

  I3Point = packed record
    X,Y,Z: IInteger;
  end;

  IIntegerArray = array of IInteger;

  EInteger = class(EMath);

  TIIntegerPrimeCallback = function(const P: IInteger): Boolean; register;
  TIIntegerSortCompare = function(const A, B: IInteger): Integer; register;
  TIIntegerForEachCallback = function(var A: IInteger): Boolean; register;

  TIIntegerSplitData = packed record
    P,Q,A,B: IInteger;
  end;

  TIIntegerBinarySplittingCallback = procedure(N: Cardinal; var P: TIIntegerSplitData); register;

  TStrFormat = packed record           // String-Convertion structure
    Base: TBase;                       // Numberbase
    Plus: array[0..15] of Char;        // String for positive IInteger (+)
    Minus: array[0..15] of Char;       // String for negative IInteger (-)
    Zero: array[0..15] of Char;        // String for zero              (0)
    Comma: Char;
    DigitsPerBlock: Word;              // Digits on one Block
    BlockSep: array[0..15] of Char;    // separator between two blocks (Space)
    BlockPadding: Char;                // left padding char of first block
    DigitsPerLine: Word;               // count of digits in one line
    LineSep: array[0..15] of Char;     // separator after one line (CR+LF)
    LinePadding: Char;                 // left padding char of first line
    DigitsChars: array[0..63] of Char; // possible Digits of a valid Numberstring
    FormatChars: array[0..63] of Char; // Numberstrings can contain these chars, but should be ignored
    LeftAlign: Boolean;
    Offset: Integer;                   // Offset to first char that contains digits, NSet(string)
    Precision: Integer;
  end;

  TTrialDivision = (IsPrime, NotDivisible, Divisible);

  IPowModPrecomputation = interface
    ['{126BE018-061D-4067-9E0A-E2A490AF5CEA}']
    procedure Precompute(const B,M: IInteger; EMaxBitSize: Integer; EIsNeg: Boolean);
    function  PowMod(var A: IInteger; const B,E,M: IInteger; var Res: Boolean): Boolean;
    function  PowMod2k(var A: IInteger; const B,E: IInteger; K: Cardinal; var Res: Boolean): Boolean;
    procedure Save(Stream: TStream);
    procedure Load(Stream: TStream);
  end;

procedure NSet(var A: IInteger; B: Integer); overload;
procedure NSet(var A: IInteger; B: Int64); overload;
procedure NSet(var A: IInteger; B: Extended); overload;
procedure NSet(var A: IInteger; const B: IInteger = nil; Abs: Boolean = False); overload;
function  NSet(var A: IInteger; const B: String; const Format: TStrFormat): Integer; overload;
procedure NSet(var A: IInteger; const B: String; Base: TBase = 0); overload;
procedure NSet(var A: IInteger; const B; Size: Integer; Bits: Integer = 0); overload;
procedure NSet(var A: IInteger; Stream: TStream; Format: TIntegerFormat = ifASN1); overload;
procedure NSet(var A: IInteger; const B: TVarRec); overload;
procedure NSet(var A: IIntegerArray; const B: array of const); overload;
procedure NSet(var A: IIntegerArray; const B: IIntegerArray); overload;
procedure NRnd(var A: IInteger; Bits: Integer = 0; Sign: Boolean = False); overload;
function  NInt(A: Integer = 0): IInteger; overload;
function  NInt(A: Int64): IInteger; overload;
function  NInt(A: Extended): IInteger; overload;
function  NInt(const A: IInteger; Abs: Boolean = False): IInteger; overload;
function  NInt(const A; Size: Integer; Bits: Integer = 0): IInteger; overload;
function  NInt(const A: String; Base: TBase = 0): IInteger; overload;
function  NInt(Stream: TStream; Format: TIntegerFormat = ifASN1): IInteger; overload;
function  NInt(const A: array of const): IIntegerArray; overload;
function  NSgn(const A: IInteger; Extended: Boolean = False): Integer; overload;
procedure NSgn(var A: IInteger; Sign: Integer); overload;
function  NOdd(const A: IInteger): Boolean; overload;
function  NOdd(var A: IInteger; Odd: Boolean): Boolean; overload;
function  NNeg(var A: IInteger): Boolean; overload;
function  NNeg(var A: IInteger; Negative: Boolean): Boolean; overload;//??
function  NAbs(var A: IInteger): Boolean; overload;
function  NBit(const A: IInteger; Index: Integer): Boolean; overload;
procedure NBit(var A: IInteger; Index: Integer; Value: Boolean); overload;
function  NLow(const A: IInteger; Piece: TPiece = piBit): Integer; overload;
function  NHigh(const A: IInteger; Piece: TPiece = piBit): Integer; overload;
function  NSize(const A: IInteger; Piece: TPiece = piBit): Integer; overload;
function  NCmp(const A,B: IInteger; Abs: Boolean = False): Integer; overload;
function  NCmp(const A: IInteger; B: Integer; Abs: Boolean = False): Integer; overload;
function  NCmp(const A,B: IInteger; Bits: Integer; Abs: Boolean = False): Integer; overload;
function  NCRC(const A: IInteger; CRC: TCRCType = CRC_32CCITT): Cardinal; overload;
function  NCRC(const A: IIntegerArray; CRC: TCRCType = CRC_32CCITT): Cardinal; overload;
function  NParity(const A: IInteger): Boolean; overload;
function  NWeight(const A: IInteger): Integer; overload;
function  NBitPos(const A: IInteger; Bit: Integer): Integer; overload;
//procedure NBitAdd(var A: IInteger; const B: IInteger; Bits: Integer); overload;
procedure NSplit(var A: IInteger; const B: IInteger; Bits: Byte); overload;
procedure NSwp(var A,B: IInteger); overload;
procedure NSwp(var A: IInteger; Piece: TPiece; Normalize: Boolean = True); overload;
procedure NSwp(var A: IInteger; const B: IInteger; Piece: TPiece; Normalize: Boolean = True); overload;
procedure NCpy(var A: IInteger; Count: Integer; Start: Integer = 0); overload;
procedure NCpy(var A: IInteger; const B: IInteger; Count: Integer; Start: Integer = 0); overload;
procedure NShl(var A: IInteger; Shift: Integer); overload;
procedure NShl(var A: IInteger; const B: IInteger; Shift: Integer); overload;
procedure NShr(var A: IInteger; Shift: Integer); overload;
procedure NShr(var A: IInteger; const B: IInteger; Shift: Integer); overload;
function  NShr(var A: IInteger): Integer; overload;
function  NShr(var A: IInteger; const B: IInteger): Integer; overload;
procedure NCut(var A: IInteger; Bits: Integer); overload;
procedure NCut(var A: IInteger; const B: IInteger; Bits: Integer); overload;
procedure NCat(var A: IInteger; const B: IIntegerArray; Bits: Integer = 0);
procedure NNot(var A: IInteger; Bits: Integer = 0; Sign: Boolean = False); overload;
procedure NNot(var A: IInteger; const B: IInteger; Bits: Integer = 0; Sign: Boolean = False); overload;
procedure NXor(var A: IInteger; const B: IInteger; Bits: Integer = 0; Sign: Boolean = False); overload;
procedure NXor(var A: IInteger; const B,C: IInteger; Bits: Integer = 0; Sign: Boolean = False); overload;
procedure NAnd(var A: IInteger; const B: IInteger; Bits: Integer = 0; Sign: Boolean = False); overload;
procedure NAnd(var A: IInteger; const B,C: IInteger; Bits: Integer = 0; Sign: Boolean = False); overload;
procedure NOr (var A: IInteger; const B: IInteger; Bits: Integer = 0; Sign: Boolean = False); overload;
procedure NOr (var A: IInteger; const B,C: IInteger; Bits: Integer = 0; Sign: Boolean = False); overload;
procedure NCpl(var A: IInteger; Bits: Integer = 0; Sign: Boolean = False); overload;
procedure NCpl(var A: IInteger; const B: IInteger; Bits: Integer = 0; Sign: Boolean = False); overload;
procedure NInc(var A: IInteger; B: Cardinal = 1); overload;
procedure NDec(var A: IInteger; B: Cardinal = 1); overload;
procedure NAdd(var A: IInteger; B: Integer); overload;
procedure NAdd(var A: IInteger; const B: IInteger); overload;
procedure NAdd(var A: IInteger; const B,C: IInteger); overload;
procedure NSub(var A: IInteger; B: Integer); overload;
procedure NSub(var A: IInteger; const B: IInteger); overload;
procedure NSub(var A: IInteger; const B,C: IInteger); overload;
procedure NMul(var A: IInteger; B: Integer); overload;
procedure NMul(var A: IInteger; B: Int64); overload;
procedure NMul(var A: IInteger; const B: IInteger; C: Int64); overload;
procedure NMul(var A: IInteger; const B: IInteger; C: Integer); overload;
procedure NMul(var A: IInteger; const B: IInteger); overload;
procedure NMul(var A: IInteger; const B,C: IInteger); overload;
procedure NSqr(var A: IInteger); overload;
procedure NSqr(var A: IInteger; const B: IInteger); overload;
function  NMod(const A: IInteger; M: Integer): Integer; overload;
function  NModU(const A: IInteger; M: Cardinal): Cardinal; overload;
procedure NMod(var A: IInteger; const M: IInteger); overload;
procedure NMod(var A: IInteger; const B,M: IInteger); overload;
function  NRem(const A: IInteger; B: Integer): Integer; overload;
procedure NRem(var A: IInteger; const B: IInteger); overload;
procedure NRem(var A: IInteger; const B,C: IInteger); overload;
function  NDiv(var Q: IInteger; A: Integer): Integer; overload;
function  NDivU(var Q: IInteger; A: Cardinal): Cardinal; overload;
procedure NDiv(var Q: IInteger; const A: IInteger); overload;
function  NDiv(var Q: IInteger; const A: IInteger; B: Integer): Integer; overload;