Vichingo455-RePacks
/
xtool
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity
xtool/contrib/DelphiEncryptionCompendium/Source/DECCiphers.pas

6613 lines
195 KiB
ObjectPascal
Raw Blame History

{*****************************************************************************
The DEC team (see file NOTICE.txt) licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License. A copy of this licence is found in the root directory
of this project in the file LICENCE.txt or alternatively at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied. See the License for the
specific language governing permissions and limitations
under the License.
*****************************************************************************}
unit DECCiphers;
interface
{$INCLUDE DECOptions.inc}
uses
DECCipherBase, DECCipherFormats, DECUtil, DECTypes;
type
// Cipher Classes
/// <summary>
/// Null cipher, doesn't encrypt, only copy
/// </summary>
TCipher_Null = class;
/// <summary>
/// A block based encryption algorithm with 32 to 448 bit key length
/// </summary>
TCipher_Blowfish = class;
/// <summary>
/// AES Round 2 Final Candidate
/// </summary>
TCipher_Twofish = class;
/// <summary>
/// International Data Encryption Algorithm, formerly patentet,
/// now patent free. The algorithm is no longer to be really recommended due
/// to some classes of weak keys and other successfull attacks.
/// </summary>
TCipher_IDEA = class;
/// <summary>
/// Carlisle Adams and Stafford Tavares, 256 bit key length
/// </summary>
TCipher_Cast256 = class;
/// <summary>
/// AES Round 2 Final Candidate
/// </summary>
TCipher_Mars = class;
/// <summary>
/// Streamcipher in as Block Cipher
/// </summary>
TCipher_RC4 = class;
/// <summary>
/// AES Round 2 Final Candidate
/// </summary>
TCipher_RC6 = class;
/// <summary>
/// AES Round 2 Final Candidate
/// </summary>
TCipher_Rijndael = class;
/// <summary>
/// AES winner = TCipher_Rijndael
/// </summary>
TCipher_AES = class;
/// <summary>
/// A block cipher invented by Joan Daemen and Vincent Rijmen. The design,
/// published in 1997, is a forerunner to Rijndael, which has been adopted
/// as the Advanced Encryption Standard. Square was introduced together with
/// a new form of cryptanalysis discovered by Lars Knudsen, called the
/// "Square attack".
/// The structure of Square is a substitution-permutation network with eight
/// rounds, operating on 128-bit blocks and using a 128-bit key.
/// </summary>
/// <remarks>
/// If possible use TCipher_AES instead
/// </remarks>
TCipher_Square = class;
/// <summary>
/// Stream Cipher in Blockmode (on UInt32), very fast
/// </summary>
TCipher_SCOP = class;
/// <summary>
/// Stream Cipher in Blockmode (on UInt32), very fast.
/// Wrong old version from DEC 5.2. Use only for backwards compatibility!
/// </summary>
TCipher_SCOP_DEC52 = class;
/// <summary>
/// Stream Cipher, eq. design from German ENIGMA Machine
/// </summary>
TCipher_Sapphire = class;
/// <summary>
/// Single DES 8 byte Blocksize, 8 byte Keysize, 56 bits relevant.
/// Considered to be too weak nowadays. Included for compatibility reasons.
/// </summary>
TCipher_1DES = class;
/// <summary>
/// Double DES 8 byte Blocksize, 16 byte Keysize, 112 bits relevant
/// </summary>
TCipher_2DES = class;
/// <summary>
/// Triple DES 8 byte Blocksize, 24 byte Keysize, 168 bits relevant
/// </summary>
TCipher_3DES = class;
/// <summary>
/// Triple DES 16 byte Blocksize, 16 byte Keysize, 112 bits relevant
/// </summary>
TCipher_2DDES = class;
/// <summary>
/// Triple DES 16 byte Blocksize, 24 byte Keysize, 168 bits relevant
/// </summary>
TCipher_3DDES = class;
/// <summary>
/// Triple DES 24 byte Blocksize, 24 byte Keysize, 168 bits relevant
/// </summary>
TCipher_3TDES = class;
/// <summary>
/// A 1994 developed block cipher using a 96 bit key. 3-Way, is vulnerable
/// to related key cryptanalysis.
/// </summary>
TCipher_3Way = class;
/// <summary>
/// Carlisle Adams and Stafford Tavares, 128 bit key length
/// </summary>
TCipher_Cast128 = class;
/// <summary>
/// Russian Cipher
/// </summary>
TCipher_Gost = class;
/// <summary>
/// Alias/new name for Gost cipher
/// </summary>
TCipher_Magma = class;
/// <summary>
/// Misty1 is a block cipher developed 1995 by Mitsubishi. It is free only for
/// academical and non-profit works in RFC 2994. it is otherwise patented.
/// In 2015 it got broken via integral cryptoanalysis.
/// </summary>
TCipher_Misty = class;
/// <summary>
/// A 1996 block cipher with a key length of 120 bit. It can be broken with
/// a relatively low number of ciphertext/plaintext queries.
/// </summary>
TCipher_NewDES = class;
/// <summary>
/// Camelia, a 128 bit block cipher.
/// Specification: https://info.isl.ntt.co.jp/crypt/eng/camellia/dl/01espec.pdf
/// </summary>
TCipher_Q128 = class;
/// <summary>
/// Rivest Cipher 2, a 1987 developed cipher with a default keysize of 64 bit
/// </summary>
TCipher_RC2 = class;
/// <summary>
/// Rivest Cipher 5, a 1994 developed cipher with emphasis on speed and low
/// size in order to make it efficient on embedded hardware as well. Key sizes
/// of up to 2048 bits are possible but 128 bits are suggested. The algorithm
/// was patented in the US up to 2015.
/// </summary>
TCipher_RC5 = class;
/// <summary>
/// SAFER = Secure And Fast Encryption Routine
/// </summary>
TCipher_SAFER = class;
/// <summary>
/// A 1996 published block cipher with a key size of 128 bits. It was
/// identified as one of the predecessors of Rijndael
/// </summary>
TCipher_Shark = class;
/// <summary>
/// A 1996 published block cipher with a key size of 128 bits. It was
/// identified as one of the predecessors of Rijndael
/// Wrong old version from DEC 5.2. Use only for backwards compatibility!
/// </summary>
TCipher_Shark_DEC52 = class;
/// <summary>
/// A NSA developed and 1998 published block cipher with a key length of
/// 80 bit. Soon after publication various weaknesses have been identified.
/// </summary>
TCipher_Skipjack = class;
/// <summary>
/// Tiny Encryption Algorithm
/// </summary>
TCipher_TEA = class;
/// <summary>
/// Tiny Encryption Algorithm, 1st extended Version
/// </summary>
TCipher_XTEA = class;
/// <summary>
/// = TCipher_XTEA (kept for backward compatibility)
/// </summary>
TCipher_TEAN = class;
/// <summary>
/// Tiny Encryption Algorithm, 1st extended Version.
/// Wrong old version from DEC 5.2. Use only for backwards compatibility!
/// </summary>
TCipher_XTEA_DEC52 = class;
// Definitions needed for Skipjack algorithm
PSkipjackTab = ^TSkipjackTab;
TSkipjackTab = array[0..255] of Byte;
/// <summary>
/// A do nothing cipher, usefull for debugging and development purposes. Do
/// not use it for actual encryption as it will not encrypt anything at all!
/// </summary>
TCipher_Null = class(TDECFormattedCipher)
protected
procedure DoInit(const Key; Size: Integer); override;
procedure DoEncode(Source, Dest: Pointer; Size: Integer); override;
procedure DoDecode(Source, Dest: Pointer; Size: Integer); override;
public
/// <summary>
/// Provides meta data about the cipher algorithm used like key size.
/// </summary>
class function Context: TCipherContext; override;
end;
TCipher_Blowfish = class(TDECFormattedCipher)
protected
/// <summary>
/// Initialize the key, based on the key passed in
/// </summary>
/// <param name="Key">
/// Encryption/Decryption key to be used
/// </param>
/// <param name="Size">
/// Size of the key passed in bytes.
/// </param>
procedure DoInit(const Key; Size: Integer); override;
procedure DoEncode(Source, Dest: Pointer; Size: Integer); override;
procedure DoDecode(Source, Dest: Pointer; Size: Integer); override;
public
class function Context: TCipherContext; override;
end;
TCipher_Twofish = class(TDECFormattedCipher)
protected
/// <summary>
/// Initialize the key, based on the key passed in
/// </summary>
/// <param name="Key">
/// Encryption/Decryption key to be used
/// </param>
/// <param name="Size">
/// Size of the key passed in bytes.
/// </param>
procedure DoInit(const Key; Size: Integer); override;
procedure DoEncode(Source, Dest: Pointer; Size: Integer); override;
procedure DoDecode(Source, Dest: Pointer; Size: Integer); override;
public
class function Context: TCipherContext; override;
end;
TCipher_IDEA = class(TDECFormattedCipher)
protected
/// <summary>
/// Initialize the key, based on the key passed in
/// </summary>
/// <param name="Key">
/// Encryption/Decryption key to be used
/// </param>
/// <param name="Size">
/// Size of the key passed in bytes.
/// </param>
procedure DoInit(const Key; Size: Integer); override;
procedure DoEncode(Source, Dest: Pointer; Size: Integer); override;
procedure DoDecode(Source, Dest: Pointer; Size: Integer); override;
public
class function Context: TCipherContext; override;
end;
TCipher_Cast256 = class(TDECFormattedCipher)
protected
/// <summary>
/// Initialize the key, based on the key passed in
/// </summary>
/// <param name="Key">
/// Encryption/Decryption key to be used
/// </param>
/// <param name="Size">
/// Size of the key passed in bytes.
/// </param>
procedure DoInit(const Key; Size: Integer); override;
procedure DoEncode(Source, Dest: Pointer; Size: Integer); override;
procedure DoDecode(Source, Dest: Pointer; Size: Integer); override;
public
class function Context: TCipherContext; override;
end;
TCipher_Mars = class(TDECFormattedCipher)
protected
/// <summary>
/// Initialize the key, based on the key passed in
/// </summary>
/// <param name="Key">
/// Encryption/Decryption key to be used
/// </param>
/// <param name="Size">
/// Size of the key passed in bytes.
/// </param>
procedure DoInit(const Key; Size: Integer); override;
procedure DoEncode(Source, Dest: Pointer; Size: Integer); override;
procedure DoDecode(Source, Dest: Pointer; Size: Integer); override;
public
class function Context: TCipherContext; override;
end;
/// <summary>
/// This is a well known stream cipher. In February 2015 its use in context
/// of TLS has been forbidden due to severe security issues.
/// </summary>
TCipher_RC4 = class(TDECFormattedCipher)
protected
/// <summary>
/// Initialize the key, based on the key passed in
/// </summary>
/// <param name="Key">
/// Encryption/Decryption key to be used
/// </param>
/// <param name="Size">
/// Size of the key passed in bytes.
/// </param>
procedure DoInit(const Key; Size: Integer); override;
procedure DoEncode(Source, Dest: Pointer; Size: Integer); override;
procedure DoDecode(Source, Dest: Pointer; Size: Integer); override;
public
class function Context: TCipherContext; override;
end;
TCipher_RC6 = class(TDECFormattedCipher)
private
FRounds: Integer;
procedure SetRounds(Value: Integer);
/// <summary>
/// Limits the number of rounds used to a minimum or maximum value,
/// depending on the current value. If FRounds is 0 it will be set to 20.
/// </summary>
procedure LimitRounds; inline;
protected
/// <summary>
/// Initialize the key, based on the key passed in
/// </summary>
/// <param name="Key">
/// Encryption/Decryption key to be used
/// </param>
/// <param name="Size">
/// Size of the key passed in bytes.
/// </param>
procedure DoInit(const Key; Size: Integer); override;
procedure DoEncode(Source, Dest: Pointer; Size: Integer); override;
procedure DoDecode(Source, Dest: Pointer; Size: Integer); override;
public
class function Context: TCipherContext; override;
/// <summary>
/// Sets the number of rounds/times the algorithm is being applied to the
/// data. Range should be 16-24 and default is 20 rounds.
/// </summary>
property Rounds: Integer read FRounds write SetRounds;
end;
TCipher_Rijndael = class(TDECFormattedCipher)
private
FRounds: Integer;
protected
/// <summary>
/// Initialize the key, based on the key passed in
/// </summary>
/// <param name="Key">
/// Encryption/Decryption key to be used
/// </param>
/// <param name="Size">
/// Size of the key passed in bytes.
/// </param>
procedure DoInit(const Key; Size: Integer); override;
procedure DoEncode(Source, Dest: Pointer; Size: Integer); override;
procedure DoDecode(Source, Dest: Pointer; Size: Integer); override;
public
class function Context: TCipherContext; override;
/// <summary>
/// Gets the number of rounds/times the algorithm is being applied to the
/// data. The number of rounds depends on the key size.
/// </summary>
property Rounds: Integer read FRounds;
end;
TCipher_AES = class(TCipher_Rijndael);
TCipher_Square = class(TDECFormattedCipher)
protected
/// <summary>
/// Initialize the key, based on the key passed in
/// </summary>
/// <param name="Key">
/// Encryption/Decryption key to be used
/// </param>
/// <param name="Size">
/// Size of the key passed in bytes.
/// </param>
procedure DoInit(const Key; Size: Integer); override;
procedure DoEncode(Source, Dest: Pointer; Size: Integer); override;
procedure DoDecode(Source, Dest: Pointer; Size: Integer); override;
public
class function Context: TCipherContext; override;
end;
TCipher_SCOP = class(TDECFormattedCipher)
protected
/// <summary>
/// Initialize the key, based on the key passed in
/// </summary>
/// <param name="Key">
/// Encryption/Decryption key to be used
/// </param>
/// <param name="Size">
/// Size of the key passed in bytes.
/// </param>
procedure DoInit(const Key; Size: Integer); override;
procedure DoEncode(Source, Dest: Pointer; Size: Integer); override;
procedure DoDecode(Source, Dest: Pointer; Size: Integer); override;
public
class function Context: TCipherContext; override;
end;
/// <remarks>
/// Do only use if backwards compatibility with old code is necessary as
/// this implementation is faulty!
/// </remarks>
TCipher_SCOP_DEC52 = class(TDECFormattedCipher)
protected
/// <summary>
/// Initialize the key, based on the key passed in
/// </summary>
/// <param name="Key">
/// Encryption/Decryption key to be used
/// </param>
/// <param name="Size">
/// Size of the key passed in bytes.
/// </param>
procedure DoInit(const Key; Size: Integer); override;
procedure DoEncode(Source, Dest: Pointer; Size: Integer); override;
procedure DoDecode(Source, Dest: Pointer; Size: Integer); override;
public
class function Context: TCipherContext; override;
end;
TCipher_Sapphire = class(TDECFormattedCipher)
protected
/// <summary>
/// Initialize the key, based on the key passed in
/// </summary>
/// <param name="Key">
/// Encryption/Decryption key to be used
/// </param>
/// <param name="Size">
/// Size of the key passed in bytes.
/// </param>
procedure DoInit(const Key; Size: Integer); override;
procedure DoEncode(Source, Dest: Pointer; Size: Integer); override;
procedure DoDecode(Source, Dest: Pointer; Size: Integer); override;
public
class function Context: TCipherContext; override;
end;
TCipher_1DES = class(TDECFormattedCipher)
protected
/// <summary>
/// Initialize the key, based on the key passed in
/// </summary>
/// <param name="Data">
/// Key for the current block to be encrypted/decrypted?
/// </param>
/// <param name="Key">
/// Encryption/Decryption key to be used
/// </param>
/// <param name="Size">
/// Size of the key passed in bytes.
/// </param>
/// <param name="Reverse">
/// Defines whether some internal calculation needs to be based from the
/// start index or the highest index (= reverse)
/// </param>
procedure DoInitKey(const Data: array of Byte; Key: PUInt32Array; Reverse: Boolean);
procedure DoInit(const Key; Size: Integer); override;
procedure DoEncode(Source, Dest: Pointer; Size: Integer); override;
procedure DoDecode(Source, Dest: Pointer; Size: Integer); override;
public
class function Context: TCipherContext; override;
end;
TCipher_2DES = class(TCipher_1DES)
protected
/// <summary>
/// Initialize the key, based on the key passed in
/// </summary>
/// <param name="Key">
/// Encryption/Decryption key to be used
/// </param>
/// <param name="Size">
/// Size of the key passed in bytes.
/// </param>
procedure DoInit(const Key; Size: Integer); override;
procedure DoEncode(Source, Dest: Pointer; Size: Integer); override;
procedure DoDecode(Source, Dest: Pointer; Size: Integer); override;
public
class function Context: TCipherContext; override;
end;
TCipher_3DES = class(TCipher_1DES)
protected
/// <summary>
/// Initialize the key, based on the key passed in
/// </summary>
/// <param name="Key">
/// Encryption/Decryption key to be used
/// </param>
/// <param name="Size">
/// Size of the key passed in bytes.
/// </param>
procedure DoInit(const Key; Size: Integer); override;
procedure DoEncode(Source, Dest: Pointer; Size: Integer); override;
procedure DoDecode(Source, Dest: Pointer; Size: Integer); override;
public
class function Context: TCipherContext; override;
end;
TCipher_2DDES = class(TCipher_2DES)
protected
procedure DoEncode(Source, Dest: Pointer; Size: Integer); override;
procedure DoDecode(Source, Dest: Pointer; Size: Integer); override;
public
class function Context: TCipherContext; override;
end;
TCipher_3DDES = class(TCipher_3DES)
protected
procedure DoEncode(Source, Dest: Pointer; Size: Integer); override;
procedure DoDecode(Source, Dest: Pointer; Size: Integer); override;
public
class function Context: TCipherContext; override;
end;
TCipher_3TDES = class(TCipher_3DES)
protected
procedure DoEncode(Source, Dest: Pointer; Size: Integer); override;
procedure DoDecode(Source, Dest: Pointer; Size: Integer); override;
public
class function Context: TCipherContext; override;
end;
TCipher_3Way = class(TDECFormattedCipher)
protected
/// <summary>
/// Initialize the key, based on the key passed in
/// </summary>
/// <param name="Key">
/// Encryption/Decryption key to be used
/// </param>
/// <param name="Size">
/// Size of the key passed in bytes.
/// </param>
procedure DoInit(const Key; Size: Integer); override;
procedure DoEncode(Source, Dest: Pointer; Size: Integer); override;
procedure DoDecode(Source, Dest: Pointer; Size: Integer); override;
public
class function Context: TCipherContext; override;
end;
TCipher_Cast128 = class(TDECFormattedCipher)
private
FRounds: Integer;
procedure SetRounds(Value: Integer);
protected
/// <summary>
/// Initialize the key, based on the key passed in
/// </summary>
/// <param name="Key">
/// Encryption/Decryption key to be used
/// </param>
/// <param name="Size">
/// Size of the key passed in bytes.
/// </param>
procedure DoInit(const Key; Size: Integer); override;
procedure DoEncode(Source, Dest: Pointer; Size: Integer); override;
procedure DoDecode(Source, Dest: Pointer; Size: Integer); override;
public
class function Context: TCipherContext; override;
/// <summary>
/// Sets the number of rounds/times the algorithm is being applied to the
/// data. Default value is 16 rounds.
/// </summary>
property Rounds: Integer read FRounds write SetRounds;
end;
TCipher_Gost = class(TDECFormattedCipher)
protected
/// <summary>
/// Initialize the key, based on the key passed in
/// </summary>
/// <param name="Key">
/// Encryption/Decryption key to be used
/// </param>
/// <param name="Size">
/// Size of the key passed in bytes.
/// </param>
procedure DoInit(const Key; Size: Integer); override;
procedure DoEncode(Source, Dest: Pointer; Size: Integer); override;
procedure DoDecode(Source, Dest: Pointer; Size: Integer); override;
public
class function Context: TCipherContext; override;
end;
/// <summary>
/// Alias for Gost
/// </summary>
TCipher_Magma = class(TCipher_Gost);
/// <summary>
/// Do no longer use this algorithm if possible, as it got broken in 2015
/// by crypto analysis.
/// </summary>
TCipher_Misty = class(TDECFormattedCipher)
protected
/// <summary>
/// Initialize the key, based on the key passed in
/// </summary>
/// <param name="Key">
/// Encryption/Decryption key to be used
/// </param>
/// <param name="Size">
/// Size of the key passed in bytes.
/// </param>
procedure DoInit(const Key; Size: Integer); override;
procedure DoEncode(Source, Dest: Pointer; Size: Integer); override;
procedure DoDecode(Source, Dest: Pointer; Size: Integer); override;
public
class function Context: TCipherContext; override;
end;
/// <summary>
/// While this algorithm resembles the Data Encryption Standard (DES),
/// it is easier to implement in software and is supposed to be more secure.
/// It is not to be confused with another algorithm - known by the same
/// name - which is simply DES without the initial and final permutations.
/// The NewDES here is a completely different algorithm.
///
/// Be aware though that recent crypto analysis shows that this algorithm is
/// less safe than DES and thus not to be recommended for use!
/// </summary>
TCipher_NewDES = class(TDECFormattedCipher)
protected
/// <summary>
/// Initialize the key, based on the key passed in
/// </summary>
/// <param name="Key">
/// Encryption/Decryption key to be used
/// </param>
/// <param name="Size">
/// Size of the key passed in bytes.
/// </param>
procedure DoInit(const Key; Size: Integer); override;
procedure DoEncode(Source, Dest: Pointer; Size: Integer); override;
procedure DoDecode(Source, Dest: Pointer; Size: Integer); override;
public
class function Context: TCipherContext; override;
end;
TCipher_Q128 = class(TDECFormattedCipher)
protected
/// <summary>
/// Initialize the key, based on the key passed in
/// </summary>
/// <param name="Key">
/// Encryption/Decryption key to be used
/// </param>
/// <param name="Size">
/// Size of the key passed in bytes.
/// </param>
procedure DoInit(const Key; Size: Integer); override;
procedure DoEncode(Source, Dest: Pointer; Size: Integer); override;
procedure DoDecode(Source, Dest: Pointer; Size: Integer); override;
public
class function Context: TCipherContext; override;
end;
TCipher_RC2 = class(TDECFormattedCipher)
protected
/// <summary>
/// Initialize the key, based on the key passed in
/// </summary>
/// <param name="Key">
/// Encryption/Decryption key to be used
/// </param>
/// <param name="Size">
/// Size of the key passed in bytes.
/// </param>
procedure DoInit(const Key; Size: Integer); override;
procedure DoEncode(Source, Dest: Pointer; Size: Integer); override;
procedure DoDecode(Source, Dest: Pointer; Size: Integer); override;
public
class function Context: TCipherContext; override;
end;
TCipher_RC5 = class(TDECFormattedCipher)
private
FRounds: Integer;
procedure SetRounds(Value: Integer);
protected
/// <summary>
/// Initialize the key, based on the key passed in
/// </summary>
/// <param name="Key">
/// Encryption/Decryption key to be used
/// </param>
/// <param name="Size">
/// Size of the key passed in bytes.
/// </param>
procedure DoInit(const Key; Size: Integer); override;
procedure DoEncode(Source, Dest: Pointer; Size: Integer); override;
procedure DoDecode(Source, Dest: Pointer; Size: Integer); override;
public
class function Context: TCipherContext; override;
/// <summary>
/// Sets the number of rounds/times the algorithm is being applied to the
/// data. Range should be 8-16 and default is 12 rounds.
/// </summary>
property Rounds: Integer read FRounds write SetRounds;
end;
/// <summary>
/// svK40 SAFER K-40 Keysize is 40bit -> 5 Byte
/// svK64 SAFER K-64 Keysize is 64bit -> 8 Byte
/// svK128 SAFER K-128 KeySize is 128bit -> 16 Byte
/// svSK40 SAFER SK-40 Stronger Version from K-40 with better Key Scheduling
/// svSK64 SAFER SK-64 Stronger Version from K-64 with better Key Scheduling
/// svSK128 SAFER SK-128 Stronger Version from K-128 with better Key Scheduling
/// </summary>
TSAFERVersion = (svSK128, svSK64, svSK40, svK128, svK64, svK40);
TCipher_SAFER = class(TDECFormattedCipher)
private
FRounds: Integer;
FVersion: TSAFERVersion;
procedure SetRounds(Value: Integer);
procedure SetVersion(Value: TSAFERVersion);
protected
/// <summary>
/// Initialize the key, based on the key passed in
/// </summary>
/// <param name="Key">
/// Encryption/Decryption key to be used
/// </param>
/// <param name="Size">
/// Size of the key passed in bytes.
/// </param>
procedure DoInit(const Key; Size: Integer); override;
procedure DoEncode(Source, Dest: Pointer; Size: Integer); override;
procedure DoDecode(Source, Dest: Pointer; Size: Integer); override;
public
class function Context: TCipherContext; override;
/// <summary>
/// Sets the number of rounds/times the algorithm is being applied to the
/// data. Range should be 4-13 and default is 5, 6, 10 or 8 rounds
/// depending on the version
/// </summary>
property Rounds: Integer read FRounds write SetRounds;
property Version: TSAFERVersion read FVersion write SetVersion;
end;
{$IFNDEF CPU64BITS}
PLong64 = ^TLong64;
TLong64 = packed record
L, R: UInt32;
end;
PLong64Array = ^TLong64Array;
TLong64Array = array[0..1023] of TLong64;
{$ENDIF}
TLogArray = array[0..255] of Byte;
/// <summary>
/// Base class for both Shark implementations
/// </summary>
TCipher_SharkBase = class(TDECFormattedCipher)
strict protected
{$IFNDEF CPU64BITS}
function Transform(A: TLong64; Log, ALog: TLogArray): TLong64;
function Shark(D: TLong64; K: PLong64): TLong64;
{$ELSE}
function Transform(A: UInt64; Log, ALog: TLogArray): UInt64;
{$ENDIF}
end;
TCipher_Shark = class(TCipher_SharkBase)
protected
/// <summary>
/// Initialize the key, based on the key passed in
/// </summary>
/// <param name="Key">
/// Encryption/Decryption key to be used
/// </param>
/// <param name="Size">
/// Size of the key passed in bytes.
/// </param>
procedure DoInit(const Key; Size: Integer); override;
procedure DoEncode(Source, Dest: Pointer; Size: Integer); override;
procedure DoDecode(Source, Dest: Pointer; Size: Integer); override;
public
class function Context: TCipherContext; override;
end;
/// <remarks>
/// Do only use if backwards compatibility with old code is necessary as
/// this implementation is faulty!
/// </remarks>
TCipher_Shark_DEC52 = class(TCipher_Shark)
protected
/// <summary>
/// Initialize the key, based on the key passed in
/// </summary>
/// <param name="Key">
/// Encryption/Decryption key to be used
/// </param>
/// <param name="Size">
/// Size of the key passed in bytes.
/// </param>
procedure DoInit(const Key; Size: Integer); override;
end;
TCipher_Skipjack = class(TDECFormattedCipher)
strict private
procedure SkipjackIncCheck(var ATab: PSkipjackTab; AMin: PSkipjackTab; AMax: PByte); inline;
procedure SkipjackDecCheck(var ATab: PSkipjackTab; AMin: PByte; AMax: PSkipjackTab); inline;
protected
/// <summary>
/// Initialize the key, based on the key passed in
/// </summary>
/// <param name="Key">
/// Encryption/Decryption key to be used
/// </param>
/// <param name="Size">
/// Size of the key passed in bytes.
/// </param>
procedure DoInit(const Key; Size: Integer); override;
procedure DoEncode(Source, Dest: Pointer; Size: Integer); override;
procedure DoDecode(Source, Dest: Pointer; Size: Integer); override;
public
class function Context: TCipherContext; override;
end;
TCipher_TEA = class(TDECFormattedCipher)
private
FRounds: Integer;
procedure SetRounds(Value: Integer);
protected
/// <summary>
/// Initialize the key, based on the key passed in
/// </summary>
/// <param name="Key">
/// Encryption/Decryption key to be used
/// </param>
/// <param name="Size">
/// Size of the key passed in bytes.
/// </param>
procedure DoInit(const Key; Size: Integer); override;
procedure DoEncode(Source, Dest: Pointer; Size: Integer); override;
procedure DoDecode(Source, Dest: Pointer; Size: Integer); override;
public
class function Context: TCipherContext; override;
/// <summary>
/// 16 - 256 Rounds, 16 (default) is sufficient, 64 is the official
/// recommendation. If a value outside the range of 16 to 256 is assigned
/// it will be limited to that range.
/// </summary>
property Rounds: Integer read FRounds write SetRounds;
end;
/// <summary>
/// XTEA is an improved version of the TEA algorithm.
/// </summary>
/// <remarks>
/// In DEC V5.2 at least and in former commits of DEC 6.0 development version
/// this algorithm was broken due to differences in brackets and thus returned
/// a different result. It is unclear why nobody reported this as bug yet
/// but be aware that if you need the old variant for compatibility reasons
/// you need a commit from before 3rd December 2020.
/// </remarks>
TCipher_XTEA = class(TCipher_TEA)
protected
procedure DoEncode(Source, Dest: Pointer; Size: Integer); override;
procedure DoDecode(Source, Dest: Pointer; Size: Integer); override;
end;
TCipher_TEAN = class(TCipher_XTEA);
/// <summary>
/// XTEA is an improved version of the TEA algorithm. This version is the
/// old faulty one from DEC 5.2. Use only if necessary for compatibility
/// reasons!
/// </summary>
/// <remarks>
/// In DEC V5.2 at least and in former commits of DEC 6.0 development version
/// this algorithm was broken due to differences in brackets and thus returned
/// a different result. It is unclear why nobody reported this as bug yet
/// but be aware that if you need the old variant for compatibility reasons
/// you need a commit from before 3rd December 2020.
/// </remarks>
TCipher_XTEA_DEC52 = class(TCipher_TEA)
protected
procedure DoEncode(Source, Dest: Pointer; Size: Integer); override;
procedure DoDecode(Source, Dest: Pointer; Size: Integer); override;
end;
implementation
{$IFOPT Q+}{$DEFINE RESTORE_OVERFLOWCHECKS}{$Q-}{$ENDIF}
{$IFOPT R+}{$DEFINE RESTORE_RANGECHECKS}{$R-}{$ENDIF}
uses
{$IFDEF FPC}
SysUtils,
{$ELSE}
System.SysUtils,
{$ENDIF}
DECData, DECDataCipher;
{ TCipher_Null }
class function TCipher_Null.Context: TCipherContext;
begin
Result.KeySize := 0;
Result.BlockSize := 1;
Result.BufferSize := 8;
Result.AdditionalBufferSize := 0;
Result.NeedsAdditionalBufferBackup := False;
Result.MinRounds := 1;
Result.MaxRounds := 1;
Result.CipherType := [ctNull, ctSymmetric];
end;
procedure TCipher_Null.DoInit(const Key; Size: Integer);
begin
// dummy
end;
procedure TCipher_Null.DoEncode(Source, Dest: Pointer; Size: Integer);
begin
if Source <> Dest then
Move(Source^, Dest^, Size);
end;
procedure TCipher_Null.DoDecode(Source, Dest: Pointer; Size: Integer);
begin
if Source <> Dest then
Move(Source^, Dest^, Size);
end;
{ TCipher_Blowfish }
type
PBlowfish = ^TBlowfish;
TBlowfish = array[0..3, 0..255] of UInt32;
class function TCipher_Blowfish.Context: TCipherContext;
begin
Result.KeySize := 56;
Result.BufferSize := 8;
Result.BlockSize := 8;
Result.AdditionalBufferSize := SizeOf(Blowfish_Data) + SizeOf(Blowfish_Key);
Result.NeedsAdditionalBufferBackup := False;
Result.MinRounds := 1;
Result.MaxRounds := 1;
Result.CipherType := [ctSymmetric, ctBlock];
end;
procedure TCipher_Blowfish.DoInit(const Key; Size: Integer);
var
I, J: Integer;
B: array[0..1] of UInt32;
K: PByteArray;
P: PUInt32Array;
S: PBlowfish;
begin
K := @Key;
S := FAdditionalBuffer;
P := Pointer(PByte(FAdditionalBuffer) + SizeOf(Blowfish_Data)); // for Pointer Math
Move(Blowfish_Data, S^, SizeOf(Blowfish_Data));
Move(Blowfish_Key, P^, Sizeof(Blowfish_Key));
J := 0;
if Size > 0 then
for I := 0 to 17 do
begin
P[I] := P[I] xor (K[(J + 0) mod Size] shl 24 +
K[(J + 1) mod Size] shl 16 +
K[(J + 2) mod Size] shl 8 +
K[(J + 3) mod Size] shl 0);
J := (J + 4) mod Size;
end;
FillChar(B, SizeOf(B), 0);
for I := 0 to 8 do
begin
DoEncode(@B, @B, SizeOf(B));
P[I * 2 + 0] := SwapUInt32(B[0]);
P[I * 2 + 1] := SwapUInt32(B[1]);
end;
for I := 0 to 3 do
for J := 0 to 127 do
begin
DoEncode(@B, @B, SizeOf(B));
S[I, J * 2 + 0] := SwapUInt32(B[0]);
S[I, J * 2 + 1] := SwapUInt32(B[1]);
end;
FillChar(B, SizeOf(B), 0);
end;
procedure TCipher_Blowfish.DoEncode(Source, Dest: Pointer; Size: Integer);
{$IFDEF X86ASM}
// Source = EDX, Dest = ECX, Size on Stack
asm
PUSH EDI
PUSH ESI
PUSH EBX
PUSH EBP
PUSH ECX
MOV ESI,[EAX].TCipher_Blowfish.FAdditionalBuffer
MOV EBX,[EDX + 0] // A
MOV EBP,[EDX + 4] // B
BSWAP EBX // CPU >= 486
BSWAP EBP
XOR EBX,[ESI + 4 * 256 * 4]
XOR EDI,EDI
@@1: MOV EAX,EBX
SHR EBX,16
MOVZX ECX,BH
AND EBX,0FFh
MOV ECX,[ESI + ECX * 4 + 1024 * 0]
MOV EBX,[ESI + EBX * 4 + 1024 * 1]
MOVZX EDX,AH
ADD EBX,ECX
MOVZX ECX,AL
MOV EDX,[ESI + EDX * 4 + 1024 * 2]
MOV ECX,[ESI + ECX * 4 + 1024 * 3]
XOR EBX,EDX
XOR EBP,[ESI + 4 * 256 * 4 + 4 + EDI * 4]
ADD EBX,ECX
INC EDI
XOR EBX,EBP
TEST EDI,010h
MOV EBP,EAX
JZ @@1
POP EAX
XOR EBP,[ESI + 4 * 256 * 4 + 17 * 4]
BSWAP EBX
BSWAP EBP
MOV [EAX + 4],EBX
MOV [EAX + 0],EBP
POP EBP
POP EBX
POP ESI
POP EDI
end;
{$ELSE !X86ASM}
var
I, A, B: UInt32;
P: PUInt32Array;
D: PBlowfish;
begin
Assert(Size = Context.BlockSize, 'Size of ' + IntToStr(Size) + ' does not equal '+
'block size of ' + IntToStr(Context.BlockSize));
D := Pointer(FAdditionalBuffer);
P := Pointer(PByte(FAdditionalBuffer) + SizeOf(Blowfish_Data)); // for Pointer Math
A := SwapUInt32(PUInt32Array(Source)[0]) xor P[0]; P := @P[1];
B := SwapUInt32(PUInt32Array(Source)[1]);
for I := 0 to 7 do
begin
B := B xor P[0] xor (D[0, A shr 24 ] +
D[1, A shr 16 and $FF] xor
D[2, A shr 8 and $FF] +
D[3, A and $FF]);
A := A xor P[1] xor (D[0, B shr 24 ] +
D[1, B shr 16 and $FF] xor
D[2, B shr 8 and $FF] +
D[3, B and $FF]);
P := @P[2];
end;
PUInt32Array(Dest)[0] := SwapUInt32(B xor P[0]);
PUInt32Array(Dest)[1] := SwapUInt32(A);
end;
{$ENDIF !X86ASM}
procedure TCipher_Blowfish.DoDecode(Source, Dest: Pointer; Size: Integer);
{$IFDEF X86ASM}
asm
PUSH EDI
PUSH ESI
PUSH EBX
PUSH EBP
PUSH ECX
MOV ESI,[EAX].TCipher_Blowfish.FAdditionalBuffer
MOV EBX,[EDX + 0] // A
MOV EBP,[EDX + 4] // B
BSWAP EBX
BSWAP EBP
XOR EBX,[ESI + 4 * 256 * 4 + 17 * 4]
MOV EDI,16
@@1: MOV EAX,EBX
SHR EBX,16
MOVZX ECX,BH
MOVZX EDX,BL
MOV EBX,[ESI + ECX * 4 + 1024 * 0]
MOV EDX,[ESI + EDX * 4 + 1024 * 1]
MOVZX ECX,AH
LEA EBX,[EBX + EDX]
MOVZX EDX,AL
MOV ECX,[ESI + ECX * 4 + 1024 * 2]
MOV EDX,[ESI + EDX * 4 + 1024 * 3]
XOR EBX,ECX
XOR EBP,[ESI + 4 * 256 * 4 + EDI * 4]
LEA EBX,[EBX + EDX]
XOR EBX,EBP
DEC EDI
MOV EBP,EAX
JNZ @@1
POP EAX
XOR EBP,[ESI + 4 * 256 * 4]
BSWAP EBX
BSWAP EBP
MOV [EAX + 0],EBP
MOV [EAX + 4],EBX
POP EBP
POP EBX
POP ESI
POP EDI
end;
{$ELSE !X86ASM}
var
I, A, B: UInt32;
P: PUInt32Array;
D: PBlowfish;
begin
Assert(Size = Context.BlockSize);
D := Pointer(FAdditionalBuffer);
P := Pointer(PByte(FAdditionalBuffer) + SizeOf(Blowfish_Data) + SizeOf(Blowfish_Key) - SizeOf(Int32));
A := SwapUInt32(PUInt32Array(Source)[0]) xor P[0];
B := SwapUInt32(PUInt32Array(Source)[1]);
for I := 0 to 7 do
begin
Dec(PUInt32(P), 2);
B := B xor P[1] xor (D[0, A shr 24 ] +
D[1, A shr 16 and $FF] xor
D[2, A shr 8 and $FF] +
D[3, A and $FF]);
A := A xor P[0] xor (D[0, B shr 24 ] +
D[1, B shr 16 and $FF] xor
D[2, B shr 8 and $FF] +
D[3, B and $FF]);
end;
Dec(PUInt32(P));
PUInt32Array(Dest)[0] := SwapUInt32(B xor P[0]);
PUInt32Array(Dest)[1] := SwapUInt32(A);
end;
{$ENDIF !X86ASM}
{ TCipher_Twofish }
type
PTwofishBox = ^TTwofishBox;
TTwofishBox = array[0..3, 0..255] of UInt32;
TLongRec = record
case Integer of
0: (L: UInt32);
1: (A, B, C, D: Byte);
end;
class function TCipher_Twofish.Context: TCipherContext;
begin
Result.KeySize := 32;
Result.BufferSize := 16;
Result.BlockSize := 16;
Result.AdditionalBufferSize := 4256;
Result.NeedsAdditionalBufferBackup := False;
Result.MinRounds := 1;
Result.MaxRounds := 1;
Result.CipherType := [ctSymmetric, ctBlock];
end;
procedure TCipher_Twofish.DoInit(const Key; Size: Integer);
var
BoxKey: array[0..3] of TLongRec;
SubKey: PUInt32Array;
Box: PTwofishBox;
procedure SetupKey;
function Encode(K0, K1: Integer): Integer;
var
R, I, J, G2, G3: Integer;
B: byte;
begin
R := 0;
for I := 0 to 1 do
begin
if I <> 0 then
R := R xor K0
else
R := R xor K1;
for J := 0 to 3 do
begin
B := R shr 24;
if B and $80 <> 0 then
G2 := (B shl 1 xor $014D) and $FF
else
G2 := B shl 1 and $FF;
if B and 1 <> 0 then
G3 := (B shr 1 and $7F) xor $014D shr 1 xor G2
else
G3 := (B shr 1 and $7F) xor G2;
R := R shl 8 xor G3 shl 24 xor G2 shl 16 xor G3 shl 8 xor B;
end;
end;
Result := R;
end;
function F32(X: Integer; K: array of Integer): Integer;
var
A, B, C, D: UInt32;
begin
A := X and $FF;
B := X shr 8 and $FF;
C := X shr 16 and $FF;
D := X shr 24;
if Size = 32 then
begin
A := Twofish_8x8[1, A] xor K[3] and $FF;
B := Twofish_8x8[0, B] xor K[3] shr 8 and $FF;
C := Twofish_8x8[0, C] xor K[3] shr 16 and $FF;
D := Twofish_8x8[1, D] xor K[3] shr 24;
end;
if Size >= 24 then
begin
A := Twofish_8x8[1, A] xor K[2] and $FF;
B := Twofish_8x8[1, B] xor K[2] shr 8 and $FF;
C := Twofish_8x8[0, C] xor K[2] shr 16 and $FF;
D := Twofish_8x8[0, D] xor K[2] shr 24;
end;
A := Twofish_8x8[0, A] xor K[1] and $FF;
B := Twofish_8x8[1, B] xor K[1] shr 8 and $FF;
C := Twofish_8x8[0, C] xor K[1] shr 16 and $FF;
D := Twofish_8x8[1, D] xor K[1] shr 24;
A := Twofish_8x8[0, A] xor K[0] and $FF;
B := Twofish_8x8[0, B] xor K[0] shr 8 and $FF;
C := Twofish_8x8[1, C] xor K[0] shr 16 and $FF;
D := Twofish_8x8[1, D] xor K[0] shr 24;
Result := Twofish_Data[0, A] xor Twofish_Data[1, B] xor
Twofish_Data[2, C] xor Twofish_Data[3, D];
end;
var
I, J, A, B: Integer;
E, O: array[0..3] of Integer;
K: array[0..7] of Integer;
begin
FillChar(K, SizeOf(K), 0);
Move(Key, K, Size);
if Size <= 16 then
Size := 16
else
if Size <= 24 then
Size := 24
else
Size := 32;
J := Size shr 3 - 1;
for I := 0 to J do
begin
E[I] := K[I shl 1];
O[I] := K[I shl 1 + 1];
BoxKey[J].L := Encode(E[I], O[I]);
Dec(J);
end;
J := 0;
for I := 0 to 19 do
begin
A := F32(J, E);
B := F32(J + $01010101, O);
B := B shl 8 or B shr 24;
SubKey[I shl 1] := A + B;
B := A + B shl 1; // here buggy instead shr 1 it's correct shl 1
SubKey[I shl 1 + 1] := B shl 9 or B shr 23;
Inc(J, $02020202);
end;
end;
procedure DoXOR(D, S: PUInt32Array; Value: UInt32);
var
I: UInt32;
begin
Value := (Value and $FF) * $01010101;
for I := 0 to 63 do
D[I] := S[I] xor Value;
end;
procedure SetupBox128;
var
L: array[0..255] of Byte;
A, I: Integer;
begin
DoXOR(@L, @Twofish_8x8[0], BoxKey[1].L);
A := BoxKey[0].A;
for I := 0 to 255 do
Box[0, I] := Twofish_Data[0, Twofish_8x8[0, L[I]] xor A];
DoXOR(@L, @Twofish_8x8[1], BoxKey[1].L shr 8);
A := BoxKey[0].B;
for I := 0 to 255 do
Box[1, I] := Twofish_Data[1, Twofish_8x8[0, L[I]] xor A];
DoXOR(@L, @Twofish_8x8[0], BoxKey[1].L shr 16);
A := BoxKey[0].C;
for I := 0 to 255 do
Box[2, I] := Twofish_Data[2, Twofish_8x8[1, L[I]] xor A];
DoXOR(@L, @Twofish_8x8[1], BoxKey[1].L shr 24);
A := BoxKey[0].D;
for I := 0 to 255 do
Box[3, I] := Twofish_Data[3, Twofish_8x8[1, L[I]] xor A];
end;
procedure SetupBox192;
var
L: array[0..255] of Byte;
A, B, I: Integer;
begin
DoXOR(@L, @Twofish_8x8[1], BoxKey[2].L);
A := BoxKey[0].A;
B := BoxKey[1].A;
for I := 0 to 255 do
Box[0, I] := Twofish_Data[0, Twofish_8x8[0, Twofish_8x8[0, L[I]] xor B] xor A];
DoXOR(@L, @Twofish_8x8[1], BoxKey[2].L shr 8);
A := BoxKey[0].B;
B := BoxKey[1].B;
for I := 0 to 255 do
Box[1, I] := Twofish_Data[1, Twofish_8x8[0, Twofish_8x8[1, L[I]] xor B] xor A];
DoXOR(@L, @Twofish_8x8[0], BoxKey[2].L shr 16);
A := BoxKey[0].C;
B := BoxKey[1].C;
for I := 0 to 255 do
Box[2, I] := Twofish_Data[2, Twofish_8x8[1, Twofish_8x8[0, L[I]] xor B] xor A];
DoXOR(@L ,@Twofish_8x8[0], BoxKey[2].L shr 24);
A := BoxKey[0].D;
B := BoxKey[1].D;
for I := 0 to 255 do
Box[3, I] := Twofish_Data[3, Twofish_8x8[1, Twofish_8x8[1, L[I]] xor B] xor A];
end;
procedure SetupBox256;
var
L: array[0..255] of Byte;
K: array[0..255] of Byte;
A, B, I: Integer;
begin
DoXOR(@K, @Twofish_8x8[1], BoxKey[3].L);
for I := 0 to 255 do
L[I] := Twofish_8x8[1, K[I]];
DoXOR(@L, @L, BoxKey[2].L);
A := BoxKey[0].A;
B := BoxKey[1].A;
for I := 0 to 255 do
Box[0, I] := Twofish_Data[0, Twofish_8x8[0, Twofish_8x8[0, L[I]] xor B] xor A];
DoXOR(@K, @Twofish_8x8[0], BoxKey[3].L shr 8);
for I := 0 to 255 do
L[I] := Twofish_8x8[1, K[I]];
DoXOR(@L, @L, BoxKey[2].L shr 8);
A := BoxKey[0].B;
B := BoxKey[1].B;
for I := 0 to 255 do
Box[1, I] := Twofish_Data[1, Twofish_8x8[0, Twofish_8x8[1, L[I]] xor B] xor A];
DoXOR(@K, @Twofish_8x8[0], BoxKey[3].L shr 16);
for I := 0 to 255 do
L[I] := Twofish_8x8[0, K[I]];
DoXOR(@L, @L, BoxKey[2].L shr 16);
A := BoxKey[0].C;
B := BoxKey[1].C;
for I := 0 to 255 do
Box[2, I] := Twofish_Data[2, Twofish_8x8[1, Twofish_8x8[0, L[I]] xor B] xor A];
DoXOR(@K, @Twofish_8x8[1], BoxKey[3].L shr 24);
for I := 0 to 255 do
L[I] := Twofish_8x8[0, K[I]];
DoXOR(@L, @L, BoxKey[2].L shr 24);
A := BoxKey[0].D;
B := BoxKey[1].D;
for I := 0 to 255 do
Box[3, I] := Twofish_Data[3, Twofish_8x8[1, Twofish_8x8[1, L[I]] xor B] xor A];
end;
begin
SubKey := FAdditionalBuffer;
Box := @SubKey[40];
SetupKey;
if Size = 16 then
SetupBox128
else
if Size = 24 then
SetupBox192
else
SetupBox256;
end;
procedure TCipher_Twofish.DoEncode(Source, Dest: Pointer; Size: Integer);
var
S: PUInt32Array;
Box: PTwofishBox;
I, X, Y: UInt32;
A, B, C, D: TLongRec;
begin
Assert(Size = Context.BlockSize);
S := FAdditionalBuffer;
A.L := PUInt32Array(Source)[0] xor S[0];
B.L := PUInt32Array(Source)[1] xor S[1];
C.L := PUInt32Array(Source)[2] xor S[2];
D.L := PUInt32Array(Source)[3] xor S[3];
Box := @S[40];
S := @S[8];
for I := 0 to 7 do
begin
X := Box[0, A.A] xor Box[1, A.B] xor Box[2, A.C] xor Box[3, A.D];
Y := Box[1, B.A] xor Box[2, B.B] xor Box[3, B.C] xor Box[0, B.D];
D.L := D.L shl 1 or D.L shr 31;
C.L := C.L xor (X + Y + S[0]);
D.L := D.L xor (X + Y shl 1 + S[1]);
C.L := C.L shr 1 or C.L shl 31;
X := Box[0, C.A] xor Box[1, C.B] xor Box[2, C.C] xor Box[3, C.D];
Y := Box[1, D.A] xor Box[2, D.B] xor Box[3, D.C] xor Box[0, D.D];
B.L := B.L shl 1 or B.L shr 31;
A.L := A.L xor (X + Y + S[2]);
B.L := B.L xor (X + Y shl 1 + S[3]);
A.L := A.L shr 1 or A.L shl 31;
S := @S[4];
end;
S := FAdditionalBuffer;
PUInt32Array(Dest)[0] := C.L xor S[4];
PUInt32Array(Dest)[1] := D.L xor S[5];
PUInt32Array(Dest)[2] := A.L xor S[6];
PUInt32Array(Dest)[3] := B.L xor S[7];
end;
procedure TCipher_Twofish.DoDecode(Source, Dest: Pointer; Size: Integer);
var
S: PUInt32Array;
Box: PTwofishBox;
I, X, Y: UInt32;
A, B, C, D: TLongRec;
begin
Assert(Size = Context.BlockSize);
S := FAdditionalBuffer;
Box := @S[40];
C.L := PUInt32Array(Source)[0] xor S[4];
D.L := PUInt32Array(Source)[1] xor S[5];
A.L := PUInt32Array(Source)[2] xor S[6];
B.L := PUInt32Array(Source)[3] xor S[7];
S := @S[36];
for I := 0 to 7 do
begin
X := Box[0, C.A] xor Box[1, C.B] xor Box[2, C.C] xor Box[3, C.D];
Y := Box[0, D.D] xor Box[1, D.A] xor Box[2, D.B] xor Box[3, D.C];
A.L := A.L shl 1 or A.L shr 31;
B.L := B.L xor (X + Y shl 1 + S[3]);
A.L := A.L xor (X + Y + S[2]);
B.L := B.L shr 1 or B.L shl 31;
X := Box[0, A.A] xor Box[1, A.B] xor Box[2, A.C] xor Box[3, A.D];
Y := Box[0, B.D] xor Box[1, B.A] xor Box[2, B.B] xor Box[3, B.C];
C.L := C.L shl 1 or C.L shr 31;
D.L := D.L xor (X + Y shl 1 + S[1]);
C.L := C.L xor (X + Y + S[0]);
D.L := D.L shr 1 or D.L shl 31;
Dec(PUInt32(S), 4);
end;
S := FAdditionalBuffer;
PUInt32Array(Dest)[0] := A.L xor S[0];
PUInt32Array(Dest)[1] := B.L xor S[1];
PUInt32Array(Dest)[2] := C.L xor S[2];
PUInt32Array(Dest)[3] := D.L xor S[3];
end;
{ TCipher_IDEA }
class function TCipher_IDEA.Context: TCipherContext;
begin
Result.KeySize := 16;
Result.BufferSize := 8;
Result.BlockSize := 8;
Result.AdditionalBufferSize := 208;
Result.NeedsAdditionalBufferBackup := False;
Result.MinRounds := 1;
Result.MaxRounds := 1;
Result.CipherType := [ctSymmetric, ctBlock];
end;
procedure TCipher_IDEA.DoInit(const Key; Size: Integer);
function IDEAInv(X: Word): Word;
var
A, B, C, D: Word;
begin
if X <= 1 then
begin
Result := X;
Exit;
end;
A := 1;
B := $10001 div X;
C := $10001 mod X;
while C <> 1 do
begin
D := X div C;
X := X mod C;
Inc(A, B * D);
if X = 1 then
begin
Result := A;
Exit;
end;
D := C div X;
C := C mod X;
Inc(B, A * D);
end;
Result := 1 - B;
end;
var
I: Integer;
E: PWordArray;
A, B, C: Word;
K, D: PWordArray;
begin
E := FAdditionalBuffer;
Move(Key, E^, Size);
for I := 0 to 7 do
E[I] := Swap(E[I]);
for I := 0 to 39 do
E[I + 8] := E[I and not 7 + (I + 1) and 7] shl 9 or
E[I and not 7 + (I + 2) and 7] shr 7;
for I := 41 to 44 do
E[I + 7] := E[I] shl 9 or E[I + 1] shr 7;
K := E;
D := @E[100];
A := IDEAInv(K[0]);
B := 0 - K[1];
C := 0 - K[2];
D[3] := IDEAInv(K[3]);
D[2] := C;
D[1] := B;
D[0] := A;
Inc(PWord(K), 4);
for I := 1 to 8 do
begin
Dec(PWord(D), 6);
A := K[0];
D[5] := K[1];
D[4] := A;
A := IDEAInv(K[2]);
B := 0 - K[3];
C := 0 - K[4];
D[3] := IDEAInv(K[5]);
D[2] := B;
D[1] := C;
D[0] := A;
Inc(PWord(K), 6);
end;
A := D[2];
D[2] := D[1];
D[1] := A;
end;
function IDEAMul(X, Y: UInt32): UInt32;
{$IF defined(X86ASM) or defined(X64ASM)}
asm
{$IFDEF X64ASM}
MOV EAX,ECX
{$ENDIF X64ASM}
AND EAX,0FFFFh
JZ @@1
AND EDX,0FFFFh
JZ @@1
MUL EDX
MOV EDX,EAX
MOV ECX,EAX
SHR EDX,16
SUB EAX,EDX
SUB CX,AX
ADC EAX,0
RET
@@1: LEA EAX,[EAX + EDX - 1]
NEG EAX
end;
{$ELSE}
begin
X := X and $FFFF;
if X <> 0 then
begin
Y := Y and $FFFF;
if Y <> 0 then
begin
X := X * Y;
Result := X - (X shr 16);
if Word(X) < Word(Result) then // carry flag check for "sub cx,ax"
Inc(Result);
Exit;
end;
end;
Result := -(X + Y - 1);
end;
{$IFEND}
procedure IDEACipher(Source, Dest: PUInt32Array; Key: PWordArray);
var
I: UInt32;
X, Y, A, B, C, D: UInt32;
begin
I := SwapUInt32(Source[0]);
A := I shr 16;
B := I and $FFFF;
I := SwapUInt32(Source[1]);
C := I shr 16;
D := I and $FFFF;
for I := 0 to 7 do
begin
A := IDEAMul(A, Key[0]);
Inc(B, Key[1]);
Inc(C, Key[2]);
D := IDEAMul(D, Key[3]);
Y := C xor A;
Y := IDEAMul(Y, Key[4]);
X := B xor D + Y;
X := IDEAMul(X, Key[5]);
Inc(Y, X);
A := A xor X;
D := D xor Y;
Y := B xor Y;
B := C xor X;
C := Y;
Key := @Key[6];
end;
Dest[0] := SwapUInt32(IDEAMul(A, Key[0]) shl 16 or (C + Key[1]) and $FFFF);
Dest[1] := SwapUInt32((B + Key[2]) shl 16 or IDEAMul(D, Key[3]) and $FFFF);
end;
procedure TCipher_IDEA.DoEncode(Source, Dest: Pointer; Size: Integer);
begin
Assert(Size = Context.BlockSize);
IDEACipher(Source, Dest, FAdditionalBuffer);
end;
procedure TCipher_IDEA.DoDecode(Source, Dest: Pointer; Size: Integer);
begin
Assert(Size = Context.BlockSize);
IDEACipher(Source, Dest, @PUInt32Array(FAdditionalBuffer)[26]);
end;
{ TCipher_Cast256 }
class function TCipher_Cast256.Context: TCipherContext;
begin
Result.KeySize := 32;
Result.BlockSize := 16;
Result.BufferSize := 16;
Result.AdditionalBufferSize := 384;
Result.NeedsAdditionalBufferBackup := False;
Result.MinRounds := 1;
Result.MaxRounds := 1;
Result.CipherType := [ctSymmetric, ctBlock];
end;
procedure TCipher_Cast256.DoInit(const Key; Size: Integer);
var
X: array[0..7] of UInt32;
M, R, I, J, T: UInt32;
K: PUInt32Array;
begin
FillChar(X, SizeOf(X), 0);
Move(Key, X, Size);
SwapUInt32Buffer(X, X, 8);
K := FAdditionalBuffer;
M := $5A827999;
R := 19;
for I := 0 to 11 do
begin
for J := 0 to 1 do
begin
T := M + X[7];
T := T shl R or T shr (32 - R);
X[6] := X[6] xor (Cast256_Data[0, T shr 24] xor
Cast256_Data[1, T shr 16 and $FF] -
Cast256_Data[2, T shr 8 and $FF] +
Cast256_Data[3, T and $FF]);
Inc(M, $6ED9EBA1);
Inc(R, 17);
T := M xor X[6];
T := T shl R or T shr (32 - R);
X[5] := X[5] xor (Cast256_Data[0, T shr 24] -
Cast256_Data[1, T shr 16 and $FF] +
Cast256_Data[2, T shr 8 and $FF] xor
Cast256_Data[3, T and $FF]);
Inc(M, $6ED9EBA1);
Inc(R, 17);
T := M - X[5];
T := T shl R or T shr (32 - R);
X[4] := X[4] xor (Cast256_Data[0, T shr 24] +
Cast256_Data[1, T shr 16 and $FF] xor
Cast256_Data[2, T shr 8 and $FF] -
Cast256_Data[3, T and $FF]);
Inc(M, $6ED9EBA1);
Inc(R, 17);
T := M + X[4];
T := T shl R or T shr (32 - R);
X[3] := X[3] xor (Cast256_Data[0, T shr 24] xor
Cast256_Data[1, T shr 16 and $FF] -
Cast256_Data[2, T shr 8 and $FF] +
Cast256_Data[3, T and $FF]);
Inc(M, $6ED9EBA1);
Inc(R, 17);
T := M xor X[3];
T := T shl R or T shr (32 - R);
X[2] := X[2] xor (Cast256_Data[0, T shr 24] -
Cast256_Data[1, T shr 16 and $FF] +
Cast256_Data[2, T shr 8 and $FF] xor
Cast256_Data[3, T and $FF]);
Inc(M, $6ED9EBA1);
Inc(R, 17);
T := M - X[2];
T := T shl R or T shr (32 - R);
X[1] := X[1] xor (Cast256_Data[0, T shr 24] +
Cast256_Data[1, T shr 16 and $FF] xor
Cast256_Data[2, T shr 8 and $FF] -
Cast256_Data[3, T and $FF]);
Inc(M, $6ED9EBA1);
Inc(R, 17);
T := M + X[1];
T := T shl R or T shr (32 - R);
X[0] := X[0] xor (Cast256_Data[0, T shr 24] xor
Cast256_Data[1, T shr 16 and $FF] -
Cast256_Data[2, T shr 8 and $FF] +
Cast256_Data[3, T and $FF]);
Inc(M, $6ED9EBA1);
Inc(R, 17);
T := M xor X[0];
T := T shl R or T shr (32 - R);
X[7] := X[7] xor (Cast256_Data[0, T shr 24] -
Cast256_Data[1, T shr 16 and $FF] +
Cast256_Data[2, T shr 8 and $FF] xor
Cast256_Data[3, T and $FF]);
Inc(M, $6ED9EBA1);
Inc(R, 17);
end;
if I < 6 then
begin
K[48] := X[0] and $1F;
K[49] := X[2] and $1F;
K[50] := X[4] and $1F;
K[51] := X[6] and $1F;
K[0] := X[7];
K[1] := X[5];
K[2] := X[3];
K[3] := X[1];
end
else
begin
K[48] := X[6] and $1F;
K[49] := X[4] and $1F;
K[50] := X[2] and $1F;
K[51] := X[0] and $1F;
K[0] := X[1];
K[1] := X[3];
K[2] := X[5];
K[3] := X[7];
end;
K := @K[4];
end;
ProtectBuffer(X, SizeOf(X));
end;
procedure TCipher_Cast256.DoEncode(Source, Dest: Pointer; Size: Integer);
var
I, T, A, B, C, D: UInt32;
K: PUInt32Array;
begin
Assert(Size = Context.BlockSize);
K := FAdditionalBuffer;
SwapUInt32Buffer(Source^, Dest^, 4);
A := PUInt32Array(Dest)[0];
B := PUInt32Array(Dest)[1];
C := PUInt32Array(Dest)[2];
D := PUInt32Array(Dest)[3];
for I := 0 to 5 do
begin
T := K[0] + D;
T := T shl K[48] or T shr (32 - K[48]);
C := C xor (Cast256_Data[0, T shr 24] xor
Cast256_Data[1, T shr 16 and $FF] -
Cast256_Data[2, T shr 8 and $FF] +
Cast256_Data[3, T and $FF]);
T := K[1] xor C;
T := T shl K[49] or T shr (32 - K[49]);
B := B xor (Cast256_Data[0, T shr 24] -
Cast256_Data[1, T shr 16 and $FF] +
Cast256_Data[2, T shr 8 and $FF] xor
Cast256_Data[3, T and $FF]);
T := K[2] - B;
T := T shl K[50] or T shr (32 - K[50]);
A := A xor (Cast256_Data[0, T shr 24] +
Cast256_Data[1, T shr 16 and $FF] xor
Cast256_Data[2, T shr 8 and $FF] -
Cast256_Data[3, T and $FF]);
T := K[3] + A;
T := T shl K[51] or T shr (32 - K[51]);
D := D xor (Cast256_Data[0, T shr 24] xor
Cast256_Data[1, T shr 16 and $FF] -
Cast256_Data[2, T shr 8 and $FF] +
Cast256_Data[3, T and $FF]);
K := @K[4];
end;
for I := 0 to 5 do
begin
T := K[0] + A;
T := T shl K[48] or T shr (32 - K[48]);
D := D xor (Cast256_Data[0, T shr 24] xor
Cast256_Data[1, T shr 16 and $FF] -
Cast256_Data[2, T shr 8 and $FF] +
Cast256_Data[3, T and $FF]);
T := K[1] - B;
T := T shl K[49] or T shr (32 - K[49]);
A := A xor (Cast256_Data[0, T shr 24] +
Cast256_Data[1, T shr 16 and $FF] xor
Cast256_Data[2, T shr 8 and $FF] -
Cast256_Data[3, T and $FF]);
T := K[2] xor C;
T := T shl K[50] or T shr (32 - K[50]);
B := B xor (Cast256_Data[0, T shr 24] -
Cast256_Data[1, T shr 16 and $FF] +
Cast256_Data[2, T shr 8 and $FF] xor
Cast256_Data[3, T and $FF]);
T := K[3] + D;
T := T shl K[51] or T shr (32 - K[51]);
C := C xor (Cast256_Data[0, T shr 24] xor
Cast256_Data[1, T shr 16 and $FF] -
Cast256_Data[2, T shr 8 and $FF] +
Cast256_Data[3, T and $FF]);
K := @K[4];
end;
PUInt32Array(Dest)[0] := A;
PUInt32Array(Dest)[1] := B;
PUInt32Array(Dest)[2] := C;
PUInt32Array(Dest)[3] := D;
SwapUInt32Buffer(Dest^, Dest^, 4);
end;
procedure TCipher_Cast256.DoDecode(Source, Dest: Pointer; Size: Integer);
var
I, T, A, B, C, D: UInt32;
K: PUInt32Array;
begin
Assert(Size = Context.BlockSize);
K := @PUInt32Array(FAdditionalBuffer)[44];
SwapUInt32Buffer(Source^, Dest^, 4);
A := PUInt32Array(Dest)[0];
B := PUInt32Array(Dest)[1];
C := PUInt32Array(Dest)[2];
D := PUInt32Array(Dest)[3];
for I := 0 to 5 do
begin
T := K[3] + D;
T := T shl K[51] or T shr (32 - K[51]);
C := C xor (Cast256_Data[0, T shr 24] xor
Cast256_Data[1, T shr 16 and $FF] -
Cast256_Data[2, T shr 8 and $FF] +
Cast256_Data[3, T and $FF]);
T := K[2] xor C;
T := T shl K[50] or T shr (32 - K[50]);
B := B xor (Cast256_Data[0, T shr 24] -
Cast256_Data[1, T shr 16 and $FF] +
Cast256_Data[2, T shr 8 and $FF] xor
Cast256_Data[3, T and $FF]);
T := K[1] - B;
T := T shl K[49] or T shr (32 - K[49]);
A := A xor (Cast256_Data[0, T shr 24] +
Cast256_Data[1, T shr 16 and $FF] xor
Cast256_Data[2, T shr 8 and $FF] -
Cast256_Data[3, T and $FF]);
T := K[0] + A;
T := T shl K[48] or T shr (32 - K[48]);
D := D xor (Cast256_Data[0, T shr 24] xor
Cast256_Data[1, T shr 16 and $FF] -
Cast256_Data[2, T shr 8 and $FF] +
Cast256_Data[3, T and $FF]);
Dec(PUInt32(K), 4);
end;
for I := 0 to 5 do
begin
T := K[3] + A;
T := T shl K[51] or T shr (32 - K[51]);
D := D xor (Cast256_Data[0, T shr 24] xor
Cast256_Data[1, T shr 16 and $FF] -
Cast256_Data[2, T shr 8 and $FF] +
Cast256_Data[3, T and $FF]);
T := K[2] - B;
T := T shl K[50] or T shr (32 - K[50]);
A := A xor (Cast256_Data[0, T shr 24] +
Cast256_Data[1, T shr 16 and $FF] xor
Cast256_Data[2, T shr 8 and $FF] -
Cast256_Data[3, T and $FF]);
T := K[1] xor C;
T := T shl K[49] or T shr (32 - K[49]);
B := B xor (Cast256_Data[0, T shr 24] -
Cast256_Data[1, T shr 16 and $FF] +
Cast256_Data[2, T shr 8 and $FF] xor
Cast256_Data[3, T and $FF]);
T := K[0] + D;
T := T shl K[48] or T shr (32 - K[48]);
C := C xor (Cast256_Data[0, T shr 24] xor
Cast256_Data[1, T shr 16 and $FF] -
Cast256_Data[2, T shr 8 and $FF] +
Cast256_Data[3, T and $FF]);
Dec(PUInt32(K), 4);
end;
PUInt32Array(Dest)[0] := A;
PUInt32Array(Dest)[1] := B;
PUInt32Array(Dest)[2] := C;
PUInt32Array(Dest)[3] := D;
SwapUInt32Buffer(Dest^, Dest^, 4);
end;
{ TCipher_Mars }
class function TCipher_Mars.Context: TCipherContext;
begin
Result.KeySize := 56;
Result.BlockSize := 16;
Result.BufferSize := 16;
Result.AdditionalBufferSize := 160;
Result.NeedsAdditionalBufferBackup := False;
Result.MinRounds := 1;
Result.MaxRounds := 1;
Result.CipherType := [ctSymmetric, ctBlock];
end;
procedure TCipher_Mars.DoInit(const Key; Size: Integer);
var
B: PUInt32Array;
function FixKey(K, R: UInt32): UInt32;
var
M1, M2: UInt32;
I: UInt32;
begin
I := K and 3;
K := K or 3;
M1 := not K xor (K shl 1);
M2 := M1 and (M1 shl 1);
M2 := M2 and (M2 shl 2);
M2 := M2 and (M2 shl 4);
M2 := M2 and (M1 shl 8);
M2 := M2 and $FFFFFE00;
if M2 = 0 then
begin
Result := K;
Exit;
end;
M1 := M2 or (M2 shr 1);
M1 := M1 or (M1 shr 2);
M1 := M1 or (M2 shr 4);
M1 := M1 or (M1 shr 5);
M1 := M1 and ((not K xor (K shl 1)) and (not K xor (K shr 1)) and $7FFFFFFC);
Result := K xor ((B[265 + I] shl R or B[265 + I] shr (32 - R)) and M1);
end;
var
T: array[0..14] of UInt32;
I, J, L: UInt32;
U: UInt32;
K: PUInt32Array;
begin
K := FAdditionalBuffer;
B := @Mars_Data;
FillChar(T, SizeOf(T), 0);
Move(Key, T, Size);
Size := Size div 4;
T[Size] := Size;
for J := 0 to 3 do
begin
for I := 0 to 14 do
begin
U := T[(I + 8) mod 15] xor T[(I + 13) mod 15];
T[I] := T[I] xor (U shl 3 or U shr 29) xor (I * 4 + J);
end;
for L := 0 to 3 do
begin
for I := 0 to 14 do
begin
Inc(T[I], B[T[(I + 14) mod 15] and $1FF]);
T[I] := T[I] shl 9 or T[I] shr 23;
end;
end;
for I := 0 to 9 do
K[(J * 10) + I] := T[(I * 4) mod 15];
end;
I := 5;
repeat
K[I] := FixKey(K[I], K[I - 1]);
Inc(I, 2);
until I >= 37;
end;
procedure TCipher_Mars.DoEncode(Source, Dest: Pointer; Size: Integer);
var
K: PUInt32Array;
I, L, R, A, B, C, D: UInt32;
begin
Assert(Size = Context.BlockSize);
K := FAdditionalBuffer;
A := PUInt32Array(Source)[0] + K[0];
B := PUInt32Array(Source)[1] + K[1];
C := PUInt32Array(Source)[2] + K[2];
D := PUInt32Array(Source)[3] + K[3];
K := @K[4];
for I := 0 to 1 do
begin
B := B xor Mars_Data[A and $FF] + Mars_Data[A shr 8 and $FF + 256];
Inc(C, Mars_Data[A shr 16 and $FF]);
D := D xor Mars_Data[A shr 24 + 256];
A := (A shr 24 or A shl 8) + D;
C := C xor Mars_Data[B and $FF] + Mars_Data[B shr 8 and $FF + 256];
Inc(D, Mars_Data[B shr 16 and $FF]);
A := A xor Mars_Data[B shr 24 + 256];
B := (B shr 24 or B shl 8) + C;
D := D xor Mars_Data[C and $FF] + Mars_Data[C shr 8 and $FF + 256];
Inc(A, Mars_Data[C shr 16 and $FF]);
B := B xor Mars_Data[C shr 24 + 256];
C := C shr 24 or C shl 8;
A := A xor Mars_Data[D and $FF] + Mars_Data[D shr 8 and $FF + 256];
Inc(B, Mars_Data[D shr 16 and $FF]);
C := C xor Mars_Data[D shr 24 + 256];
D := D shr 24 or D shl 8;
end;
for I := 0 to 3 do
begin
L := A + K[0];
A := A shl 13 or A shr 19;
R := A * K[1];
R := R shl 5 or R shr 27;
Inc(C, L shl R or L shr (32 - R));
L := Mars_Data[L and $1FF] xor R;
R := R shl 5 or R shr 27;
L := L xor R;
L := L shl R or L shr (32 - R);
if I <= 1 then
begin
Inc(B, L);
D := D xor R;
end
else
begin
Inc(D, L);
B := B xor R;
end;
L := B + K[2];
B := B shl 13 or B shr 19;
R := B * K[3];
R := R shl 5 or R shr 27;
Inc(D, L shl R or L shr (32 - R));
L := Mars_Data[L and $1FF] xor R;
R := R shl 5 or R shr 27;
L := L xor R;
L := L shl R or L shr (32 - R);
if I <= 1 then
begin
Inc(C, L);
A := A xor R;
end
else
begin
Inc(A, L);
C := C xor R;
end;
L := C + K[4];
C := C shl 13 or C shr 19;
R := C * K[5];
R := R shl 5 or R shr 27;
Inc(A, L shl R or L shr (32 - R));
L := Mars_Data[L and $1FF] xor R;
R := R shl 5 or R shr 27;
L := L xor R;
L := L shl R or L shr (32 - R);
if I <= 1 then
begin
Inc(D, L);
B := B xor R;
end
else
begin
Inc(B, L);
D := D xor R;
end;
L := D + K[6];
D := D shl 13 or D shr 19;
R := D * K[7];
R := R shl 5 or R shr 27;
Inc(B, L shl R or L shr (32 - R));
L := Mars_Data[L and $1FF] xor R;
R := R shl 5 or R shr 27;
L := L xor R;
L := L shl R or L shr (32 - R);
if I <= 1 then
begin
Inc(A, L);
C := C xor R;
end
else
begin
Inc(C, L);
A := A xor R;
end;
K := @K[8];
end;
for I := 0 to 1 do
begin
B := B xor Mars_Data[A and $FF + 256];
Dec(C, Mars_Data[A shr 24]);
D := D - Mars_Data[A shr 16 and $FF + 256] xor Mars_Data[A shr 8 and $FF];
A := A shl 24 or A shr 8;
C := C xor Mars_Data[B and $FF + 256];
Dec(D, Mars_Data[B shr 24]);
A := A - Mars_Data[B shr 16 and $FF + 256] xor Mars_Data[B shr 8 and $FF];
B := B shl 24 or B shr 8;
Dec(C, B);
D := D xor Mars_Data[C and $FF + 256];
Dec(A, Mars_Data[C shr 24]);
B := B - Mars_Data[C shr 16 and $FF + 256] xor Mars_Data[C shr 8 and $FF];
C := C shl 24 or C shr 8;
Dec(D, A);
A := A xor Mars_Data[D and $FF + 256];
Dec(B, Mars_Data[D shr 24]);
C := C - Mars_Data[D shr 16 and $FF + 256] xor Mars_Data[D shr 8 and $FF];
D := D shl 24 or D shr 8;
end;
PUInt32Array(Dest)[0] := A - K[0];
PUInt32Array(Dest)[1] := B - K[1];
PUInt32Array(Dest)[2] := C - K[2];
PUInt32Array(Dest)[3] := D - K[3];
end;
procedure TCipher_Mars.DoDecode(Source, Dest: Pointer; Size: Integer);
var
K: PUInt32Array;
I, L, R, A, B, C, D: UInt32;
begin
Assert(Size = Context.BlockSize);
K := @PUInt32Array(FAdditionalBuffer)[28];
A := PUInt32Array(Source)[0] + K[8];
B := PUInt32Array(Source)[1] + K[9];
C := PUInt32Array(Source)[2] + K[10];
D := PUInt32Array(Source)[3] + K[11];
for I := 0 to 1 do
begin
D := D shr 24 or D shl 8;
C := C xor Mars_Data[D shr 8 and $FF] + Mars_Data[D shr 16 and $FF + 256];
Inc(B, Mars_Data[D shr 24]);
A := A xor Mars_Data[D and $FF + 256];
Inc(D, A);
C := C shr 24 or C shl 8;
B := B xor Mars_Data[C shr 8 and $FF] + Mars_Data[C shr 16 and $FF + 256];
Inc(A, Mars_Data[C shr 24]);
D := D xor Mars_Data[C and $FF + 256];
Inc(C, B);
B := B shr 24 or B shl 8;
A := A xor Mars_Data[B shr 8 and $FF] + Mars_Data[B shr 16 and $FF + 256];
Inc(D, Mars_Data[B shr 24]);
C := C xor Mars_Data[B and $FF + 256];
A := A shr 24 or A shl 8;
D := D xor Mars_Data[A shr 8 and $FF] + Mars_Data[A shr 16 and $FF + 256];
Inc(C, Mars_Data[A shr 24]);
B := B xor Mars_Data[A and $FF + 256];
end;
for I := 0 to 3 do
begin
R := D * K[7];
R := R shl 5 or R shr 27;
D := D shr 13 or D shl 19;
L := D + K[6];
Dec(B, L shl R or L shr (32 - R));
L := Mars_Data[L and $1FF] xor R;
R := R shl 5 or R shr 27;
L := L xor R;
L := L shl R or L shr (32 - R);
if I <= 1 then
begin
Dec(C, L);
A := A xor R;
end
else
begin
Dec(A, L);
C := C xor R;
end;
R := C * K[5];
R := R shl 5 or R shr 27;
C := C shr 13 or C shl 19;
L := C + K[4];
Dec(A, L shl R or L shr (32 - R));
L := Mars_Data[L and $1FF] xor R;
R := R shl 5 or R shr 27;
L := L xor R;
L := L shl R or L shr (32 - R);
if I <= 1 then
begin
Dec(B, L);
D := D xor R;
end
else
begin
Dec(D, L);
B := B xor R;
end;
R := B * K[3];
R := R shl 5 or R shr 27;
B := B shr 13 or B shl 19;
L := B + K[2];
Dec(D, L shl R or L shr (32 - R));
L := Mars_Data[L and $1FF] xor R;
R := R shl 5 or R shr 27;
L := L xor R;
L := L shl R or L shr (32 - R);
if I <= 1 then
begin
Dec(A, L);
C := C xor R;
end
else
begin
Dec(C, L);
A := A xor R;
end;
R := A * K[1];
R := R shl 5 or R shr 27;
A := A shr 13 or A shl 19;
L := A + K[0];
Dec(C, L shl R or L shr (32 - R));
L := Mars_Data[L and $1FF] xor R;
R := R shl 5 or R shr 27;
L := L xor R;
L := L shl R or L shr (32 - R);
if I <= 1 then
begin
Dec(D, L);
B := B xor R;
end
else
begin
Dec(B, L);
D := D xor R;
end;
Dec(PUInt32(K), 8);
end;
for I := 0 to 1 do
begin
D := D shl 24 or D shr 8;
C := C xor Mars_Data[D shr 24 + 256];
Dec(B, Mars_Data[D shr 16 and $FF]);
A := A - Mars_Data[D shr 8 and $FF + 256] xor Mars_Data[D and $FF];
C := C shl 24 or C shr 8;
B := B xor Mars_Data[C shr 24 + 256];
Dec(A, Mars_Data[C shr 16 and $FF]);
D := D - Mars_Data[C shr 8 and $FF + 256] xor Mars_Data[C and $FF];
Dec(B, C);
B := B shl 24 or B shr 8;
A := A xor Mars_Data[B shr 24 + 256];
Dec(D, Mars_Data[B shr 16 and $FF]);
C := C - Mars_Data[B shr 8 and $FF + 256] xor Mars_Data[B and $FF];
Dec(A, D);
A := A shl 24 or A shr 8;
D := D xor Mars_Data[A shr 24 + 256];
Dec(C, Mars_Data[A shr 16 and $FF]);
B := B - Mars_Data[A shr 8 and $FF + 256] xor Mars_Data[A and $FF];
end;
PUInt32Array(Dest)[0] := A - K[4];
PUInt32Array(Dest)[1] := B - K[5];
PUInt32Array(Dest)[2] := C - K[6];
PUInt32Array(Dest)[3] := D - K[7];
end;
{ TCipher_RC4 }
class function TCipher_RC4.Context: TCipherContext;
begin
Result.KeySize := 256;
Result.BlockSize := 1;
Result.BufferSize := 16;
Result.AdditionalBufferSize := 256 + 2;
Result.NeedsAdditionalBufferBackup := true;
Result.MinRounds := 1;
Result.MaxRounds := 1;
Result.CipherType := [ctSymmetric, ctStream];
end;
procedure TCipher_RC4.DoInit(const Key; Size: Integer);
var
K: array[0..255] of Byte;
D: PByteArray;
I, J, T: Byte;
begin
D := FAdditionalBuffer;
for I := 0 to 255 do
begin
D[I] := I;
if Size > 0 then
K[I] := TByteArray(Key)[I mod Size];
end;
J := 0;
for I := 0 to 255 do
begin
J := J + D[I] + K[I];
T := D[I];
D[I] := D[J];
D[J] := T;
end;
D[256] := 0;
D[257] := 0;
ProtectBuffer(K, SizeOf(K));
end;
procedure TCipher_RC4.DoEncode(Source, Dest: Pointer; Size: Integer);
var
D: PByteArray;
S: Integer;
T, I, J: Byte;
begin
D := FAdditionalBuffer;
I := D[256];
J := D[257];
for S := 0 to Size - 1 do
begin
Inc(I);
T := D[I];
Inc(J, T);
D[I] := D[J];
D[J] := T;
PByteArray(Dest)[S] := PByteArray(Source)[S] xor D[Byte(D[I] + T)];
end;
D[256] := I;
D[257] := J;
end;
procedure TCipher_RC4.DoDecode(Source, Dest: Pointer; Size: Integer);
begin
DoEncode(Source, Dest, Size);
end;
{ TCipher_RC6 }
class function TCipher_RC6.Context: TCipherContext;
begin
Result.KeySize := 256;
Result.BlockSize := 16;
Result.BufferSize := 16;
Result.AdditionalBufferSize := 272;
Result.NeedsAdditionalBufferBackup := False;
Result.MinRounds := 16;
Result.MaxRounds := 24;
Result.CipherType := [ctSymmetric, ctBlock];
end;
procedure TCipher_RC6.SetRounds(Value: Integer);
begin
if Value < Context.MinRounds then
Value := Context.MinRounds
else
if Value > Context.MaxRounds then
Value := Context.MaxRounds;
if Value <> FRounds then
begin
if not (FState in [csNew, csInitialized, csDone]) then
Done;
FRounds := Value;
end;
end;
procedure TCipher_RC6.DoInit(const Key; Size: Integer);
var
K: array[0..63] of UInt32;
D: PUInt32Array;
I, J, L, A, B, Z, T: UInt32;
begin
LimitRounds;
D := FAdditionalBuffer;
FillChar(K, SizeOf(K), 0);
Move(Key, K, Size);
L := Size shr 2;
if Size and 3 <> 0 then
Inc(L);
if L <= 0 then
L := 1;
J := $B7E15163;
for I := 0 to (FRounds + 2) * 2 do
begin
D[I] := J;
Inc(J, $9E3779B9);
end;
if L > UInt32(FRounds + 2) * 2 then
Z := L * 3
else
Z := (FRounds + 2) * 6;
I := 0;
J := 0;
A := 0;
B := 0;
for Z := Z downto 1 do
begin
A := A + B + D[I];
A := A shl 3 or A shr 29;
D[I] := A;
T := A + B;
B := T + K[J];
B := B shl T or B shr (32 - T);
K[J] := B;
I := (I + 1) mod (UInt32(FRounds + 2) * 2);
J := (J + 1) mod L;
end;
ProtectBuffer(K, SizeOf(K));
end;
procedure TCipher_RC6.LimitRounds;
begin
if FRounds = 0 then
FRounds := 20
else
if FRounds < 16 then
FRounds := 16
else
if FRounds > 24 then
FRounds := 24;
end;
procedure TCipher_RC6.DoEncode(Source, Dest: Pointer; Size: Integer);
{$IFDEF X86ASM}
asm
PUSH EBX
PUSH ESI
PUSH EDI
PUSH EBP
PUSH ECX
MOV EBP,[EAX].TCipher_RC6.FRounds // Rounds
MOV ESI,[EAX].TCipher_RC6.FAdditionalBuffer // Key
MOV EAX,[EDX + 0] // A
MOV EBX,[EDX + 4] // B
MOV EDI,[EDX + 8] // C
MOV EDX,[EDX + 12] // D
ADD EBX,[ESI + 0] // Inc(B, K[0])
ADD EDX,[ESI + 4] // Inc(D, K[1])
ADD ESI,8 // Inc(PInteger(K), 2)
@@1: LEA ECX,[EBX * 2 + 1] // ECX := B * 2 + 1
IMUL ECX,EBX // ECX := ECX * B
ROL ECX,5 // T := ROL(B * (B * 2 + 1), 5)
PUSH ECX // save T
XOR EAX,ECX // A := A xor T
LEA ECX,[EDX * 2 + 1] // ECX := D * 2 + 1
IMUL ECX,EDX // ECX := ECX * D
ROL ECX,5 // U := ROL(D * (D * 2 + 1), 5)
XOR EDI,ECX // C := C xor U
ROL EAX,CL // A := ROL(A xor T, U)
POP ECX // restore T
ADD EAX,[ESI + 0] // Inc(A, K[0])
ROL EDI,CL // C := ROL(C xor U, T)
MOV ECX,EAX // T := A
ADD EDI,[ESI + 4] // Inc(C, K[1])
MOV EAX,EBX // A := B
MOV EBX,EDI // B := C
MOV EDI,EDX // C := D
DEC EBP
MOV EDX,ECX // D := T;
LEA ESI,[ESI + 8] // Inc(PInteger(K), 2)
JNZ @@1
ADD EAX,[ESI + 0] // Inc(A, K[0])
ADD EDI,[ESI + 4] // Inc(C, K[1])
POP ECX
MOV [ECX + 0],EAX // A
MOV [ECX + 4],EBX // B
MOV [ECX + 8],EDI // C
MOV [ECX + 12],EDX // D
POP EBP
POP EDI
POP ESI
POP EBX
end;
{$ELSE !X86ASM}
var
K: PUInt32Array;
I, T, U, A, B, C, D: UInt32;
begin
Assert(Size = Context.BlockSize);
K := Pointer(FAdditionalBuffer);
A := PUInt32Array(Source)[0];
B := PUInt32Array(Source)[1] + K[0];
C := PUInt32Array(Source)[2];
D := PUInt32Array(Source)[3] + K[1];
for I := 1 to FRounds do
begin
K := @K[2];
T := B * (B + B + 1);
T := T shl 5 or T shr 27;
U := D * (D + D + 1);
U := U shl 5 or U shr 27;
A := A xor T;
A := A shl U or A shr (32 - U) + K[0];
C := C xor U;
C := C shl T or C shr (32 - T) + K[1];
T := A; A := B; B := C; C := D; D := T;
end;
PUInt32Array(Dest)[0] := A + K[2];
PUInt32Array(Dest)[1] := B;
PUInt32Array(Dest)[2] := C + K[3];
PUInt32Array(Dest)[3] := D;
end;
{$ENDIF !X86ASM}
procedure TCipher_RC6.DoDecode(Source, Dest: Pointer; Size: Integer);
{$IFDEF X86ASM}
asm
PUSH EBX
PUSH ESI
PUSH EDI
PUSH EBP
PUSH ECX
MOV EBP,[EAX].TCipher_RC6.FRounds // Rounds
MOV ESI,[EAX].TCipher_RC6.FAdditionalBuffer // Key
LEA ESI,[ESI + EBP * 8] // Key[FRounds * 2]
MOV EAX,[EDX + 0] // A
MOV EBX,[EDX + 4] // B
MOV EDI,[EDX + 8] // C
MOV EDX,[EDX + 12] // D
SUB EDI,[ESI + 12] // Dec(C, K[3])
SUB EAX,[ESI + 8] // Dec(A, K[2])
@@1: MOV ECX,EAX // T := A
SUB EDX,[ESI + 0] // Dec(A, K[0])
MOV EAX,EDX // A := D
MOV EDX,EDI // D := C
SUB EBX,[ESI + 4] // Dec(C, K[1])
MOV EDI,EBX // C := B
MOV EBX,ECX // B := T;
LEA ECX,[EDX * 2 + 1] // ECX := D * 2 + 1
IMUL ECX,EDX // ECX := ECX * D
ROL ECX,5 // U := ROL(D * (D * 2 + 1), 5)
PUSH ECX // save U
ROR EAX,CL // A := ROR(A - K[0], U)
LEA ECX,[EBX * 2 + 1] // ECX := B * 2 + 1
IMUL ECX,EBX // ECX := ECX * B
ROL ECX,5 // T := ROL(B * (B * 2 + 1), 5)
XOR EAX,ECX // A := A xor T
ROR EDI,CL // C := ROR(C - K[1], T)
POP ECX // restore U
XOR EDI,ECX // C := C xor U
DEC EBP
LEA ESI,[ESI - 8] // Dec(PInteger(K), 2)
JNZ @@1
SUB EBX,[ESI + 0] // Dec(B, K[0])
SUB EDX,[ESI + 4] // Inc(D, K[1])
POP ECX
MOV [ECX + 0],EAX // A
MOV [ECX + 4],EBX // B
MOV [ECX + 8],EDI // C
MOV [ECX + 12],EDX // D
POP EBP
POP EDI
POP ESI
POP EBX
end;
{$ELSE !X86ASM}
var
I, U, T, A, B, C, D: UInt32;
K: PUInt32Array;
begin
Assert(Size = Context.BlockSize);
K := @PUInt32Array(FAdditionalBuffer)[FRounds * 2];
A := PUInt32Array(Source)[0] - K[2];
B := PUInt32Array(Source)[1];
C := PUInt32Array(Source)[2] - K[3];
D := PUInt32Array(Source)[3];
for I := 1 to FRounds do
begin
T := A; A := D; D := C; C := B; B := T;
U := D * (D + D + 1);
U := U shl 5 or U shr 27;
T := B * (B + B + 1);
T := T shl 5 or T shr 27;
C := C - K[1];
C := C shr T or C shl (32 - T) xor U;
A := A - K[0];
A := A shr U or A shl (32 - U) xor T;
Dec(PUInt32(K), 2);
end;
PUInt32Array(Dest)[0] := A;
PUInt32Array(Dest)[1] := B - K[0];
PUInt32Array(Dest)[2] := C;
PUInt32Array(Dest)[3] := D - K[1];
end;
{$ENDIF !X86ASM}
{ TCipher_Rijndael }
class function TCipher_Rijndael.Context: TCipherContext;
const
// don't change this!
Rijndael_Blocks = 4;
Rijndael_Rounds = 14;
begin
Result.KeySize := 32;
Result.BlockSize := Rijndael_Blocks * 4;
Result.BufferSize := Rijndael_Blocks * 4;
Result.AdditionalBufferSize := (Rijndael_Rounds + 1) * Rijndael_Blocks * SizeOf(UInt32) * 2;
Result.NeedsAdditionalBufferBackup := False;
Result.MinRounds := 1;
Result.MaxRounds := 1;
Result.CipherType := [ctSymmetric, ctBlock];
end;
procedure TCipher_Rijndael.DoInit(const Key; Size: Integer);
{$REGION OldKeyShedule}
{
// Old Rijndael Key Scheduling:
procedure BuildEncodeKey;
const
RND_Data: array[0..29] of Byte = (
$01, $02, $04, $08, $10, $20, $40, $80, $1B, $36, $6C, $D8, $AB, $4D, $9A,
$2F, $5E, $BC, $63, $C6, $97, $35, $6A, $D4, $B3, $7D, $FA, $EF, $C5, $91
);
var
T, R: Integer;
procedure NextRounds;
var
J: Integer;
begin
J := 0;
while (J < FRounds - 6) and (R <= FRounds) do
begin
while (J < FRounds - 6) and (T < Rijndael_Blocks) do
begin
PUInt32Array(FBuffer)[R * Rijndael_Blocks + T] := K[J];
Inc(J);
Inc(T);
end;
if T = Rijndael_Blocks then
begin
T := 0;
Inc(R);
end;
end;
end;
var
RND: PByte;
B: PByte;
I: Integer;
begin
R := 0;
T := 0;
RND := @RND_Data;
NextRounds;
while R <= FRounds do
begin
B := @K;
B^ := B^ xor Rijndael_S[0, K[FRounds - 7] shr 8 and $FF] xor RND^; Inc(B);
B^ := B^ xor Rijndael_S[0, K[FRounds - 7] shr 16 and $FF]; Inc(B);
B^ := B^ xor Rijndael_S[0, K[FRounds - 7] shr 24]; Inc(B);
B^ := B^ xor Rijndael_S[0, K[FRounds - 7] and $FF];
Inc(RND);
if FRounds = 14 then
begin
for I := 1 to 7 do
K[I] := K[I] xor K[I - 1];
B := @K[4];
B^ := B^ xor Rijndael_S[0, K[3] and $FF]; Inc(B);
B^ := B^ xor Rijndael_S[0, K[3] shr 8 and $FF]; Inc(B);
B^ := B^ xor Rijndael_S[0, K[3] shr 16 and $FF]; Inc(B);
B^ := B^ xor Rijndael_S[0, K[3] shr 24];
for I := 5 to 7 do
K[I] := K[I] xor K[I - 1];
end
else
for I := 1 to FRounds - 7 do
K[I] := K[I] xor K[I - 1];
NextRounds;
end;
end;
procedure BuildDecodeKey;
var
I: Integer;
D: PUInt32;
begin
D := Pointer(PAnsiChar(FBuffer) + FBufferSize shr 1); // for Pointer Math
Move(FBuffer^, D^, FBufferSize shr 1);
Inc(D, 4);
for I := 0 to FRounds * 4 - 5 do
begin
D^ := Rijndael_Key[D^ and $FF] xor
(Rijndael_Key[D^ shr 8 and $FF] shl 8 or Rijndael_Key[D^ shr 8 and $FF] shr 24) xor
(Rijndael_Key[D^ shr 16 and $FF] shl 16 or Rijndael_Key[D^ shr 16 and $FF] shr 16) xor
(Rijndael_Key[D^ shr 24] shl 24 or Rijndael_Key[D^ shr 24] shr 8);
Inc(D);
end;
end; }
{$ENDREGION}
// New AES conform Key Scheduling
procedure BuildEncodeKey;
const
RCon: array[0..9] of UInt32 = ($01, $02, $04, $08, $10, $20, $40, $80, $1b, $36);
var
I: Integer;
T: UInt32;
P: PUInt32Array;
begin
P := FAdditionalBuffer;
if Size <= 16 then
begin
for I := 0 to 9 do
begin
T := P[3];
P[4] := Rijndael_S[0, T shr 8 and $FF] xor
Rijndael_S[0, T shr 16 and $FF] shl 8 xor
Rijndael_S[0, T shr 24 ] shl 16 xor
Rijndael_S[0, T and $FF] shl 24 xor P[0] xor RCon[I];
P[5] := P[1] xor P[4];
P[6] := P[2] xor P[5];
P[7] := P[3] xor P[6];
P := @P[4];
end;
end
else
if Size <= 24 then
begin
for I := 0 to 7 do
begin
T := P[5];
P[6] := Rijndael_S[0, T shr 8 and $FF] xor
Rijndael_S[0, T shr 16 and $FF] shl 8 xor
Rijndael_S[0, T shr 24 ] shl 16 xor
Rijndael_S[0, T and $FF] shl 24 xor P[0] xor RCon[I];
P[7] := P[1] xor P[6];
P[8] := P[2] xor P[7];
P[9] := P[3] xor P[8];
if I = 7 then
Break;
P[10] := P[4] xor P[9];
P[11] := P[5] xor P[10];
P := @P[6];
end;
end
else
begin
for I :=0 to 6 do
begin
T := P[7];
P[8] := Rijndael_S[0, T shr 8 and $FF] xor
Rijndael_S[0, T shr 16 and $FF] shl 8 xor
Rijndael_S[0, T shr 24 ] shl 16 xor
Rijndael_S[0, T and $FF] shl 24 xor P[0] xor RCon[I];
P[9] := P[1] xor P[8];
P[10] := P[2] xor P[9];
P[11] := P[3] xor P[10];
if I = 6 then
Break;
T := P[11];
P[12] := Rijndael_S[0, T and $FF] xor
Rijndael_S[0, T shr 8 and $FF] shl 8 xor
Rijndael_S[0, T shr 16 and $FF] shl 16 xor
Rijndael_S[0, T shr 24 ] shl 24 xor P[4];
P[13] := P[5] xor P[12];
P[14] := P[6] xor P[13];
P[15] := P[7] xor P[14];
P := @P[8];
end;
end;
end;
procedure BuildDecodeKey;
var
P: PUInt32;
I: Integer;
begin
P := Pointer(PByte(FAdditionalBuffer) + FAdditionalBufferSize shr 1); // for Pointer Math
Move(FAdditionalBuffer^, P^, FAdditionalBufferSize shr 1);
Inc(P, 4);
for I := 0 to FRounds * 4 - 5 do
begin
P^ := Rijndael_T[4, Rijndael_S[0, P^ and $FF]] xor
Rijndael_T[5, Rijndael_S[0, P^ shr 8 and $FF]] xor
Rijndael_T[6, Rijndael_S[0, P^ shr 16 and $FF]] xor
Rijndael_T[7, Rijndael_S[0, P^ shr 24 ]];
Inc(P);
end;
end;
begin
if Size <= 16 then
FRounds := 10
else
if Size <= 24 then
FRounds := 12
else
FRounds := 14;
FillChar(FAdditionalBuffer^, 32, 0);
Move(Key, FAdditionalBuffer^, Size);
BuildEncodeKey;
BuildDecodeKey;
end;
procedure TCipher_Rijndael.DoEncode(Source, Dest: Pointer; Size: Integer);
var
P: PUInt32Array;
I: Integer;
A2, B2, C2, D2: UInt32;
A1, B1, C1, D1: UInt32;
begin
Assert(Size = Context.BlockSize);
P := FAdditionalBuffer;
A1 := PUInt32Array(Source)[0];
B1 := PUInt32Array(Source)[1];
C1 := PUInt32Array(Source)[2];
D1 := PUInt32Array(Source)[3];
for I := 2 to FRounds do
begin
A2 := A1 xor P[0];
B2 := B1 xor P[1];
C2 := C1 xor P[2];
D2 := D1 xor P[3];
A1 := Rijndael_T[0, A2 and $FF] xor
Rijndael_T[1, B2 shr 8 and $FF] xor
Rijndael_T[2, C2 shr 16 and $FF] xor
Rijndael_T[3, D2 shr 24 ];
B1 := Rijndael_T[0, B2 and $FF] xor
Rijndael_T[1, C2 shr 8 and $FF] xor
Rijndael_T[2, D2 shr 16 and $FF] xor
Rijndael_T[3, A2 shr 24 ];
C1 := Rijndael_T[0, C2 and $FF] xor
Rijndael_T[1, D2 shr 8 and $FF] xor
Rijndael_T[2, A2 shr 16 and $FF] xor
Rijndael_T[3, B2 shr 24 ];
D1 := Rijndael_T[0, D2 and $FF] xor
Rijndael_T[1, A2 shr 8 and $FF] xor
Rijndael_T[2, B2 shr 16 and $FF] xor
Rijndael_T[3, C2 shr 24 ];
P := @P[4];
end;
A2 := A1 xor P[0];
B2 := B1 xor P[1];
C2 := C1 xor P[2];
D2 := D1 xor P[3];
PUInt32Array(Dest)[0] := (Rijndael_S[0, A2 and $FF] or
Rijndael_S[0, B2 shr 8 and $FF] shl 8 or
Rijndael_S[0, C2 shr 16 and $FF] shl 16 or
Rijndael_S[0, D2 shr 24 ] shl 24) xor P[4];
PUInt32Array(Dest)[1] := (Rijndael_S[0, B2 and $FF] or
Rijndael_S[0, C2 shr 8 and $FF] shl 8 or
Rijndael_S[0, D2 shr 16 and $FF] shl 16 or
Rijndael_S[0, A2 shr 24 ] shl 24) xor P[5];
PUInt32Array(Dest)[2] := (Rijndael_S[0, C2 and $FF] or
Rijndael_S[0, D2 shr 8 and $FF] shl 8 or
Rijndael_S[0, A2 shr 16 and $FF] shl 16 or
Rijndael_S[0, B2 shr 24 ] shl 24) xor P[6];
PUInt32Array(Dest)[3] := (Rijndael_S[0, D2 and $FF] or
Rijndael_S[0, A2 shr 8 and $FF] shl 8 or
Rijndael_S[0, B2 shr 16 and $FF] shl 16 or
Rijndael_S[0, C2 shr 24 ] shl 24) xor P[7];
end;
procedure TCipher_Rijndael.DoDecode(Source, Dest: Pointer; Size: Integer);
var
P: PUInt32Array;
I: Integer;
A2, B2, C2, D2: UInt32;
A1, B1, C1, D1: UInt32;
begin
Assert(Size = Context.BlockSize);
P := Pointer(PByte(FAdditionalBuffer) + FAdditionalBufferSize shr 1 + FRounds * 16); // for Pointer Math
A1 := PUInt32Array(Source)[0];
B1 := PUInt32Array(Source)[1];
C1 := PUInt32Array(Source)[2];
D1 := PUInt32Array(Source)[3];
for I := 2 to FRounds do
begin
A2 := A1 xor P[0];
B2 := B1 xor P[1];
C2 := C1 xor P[2];
D2 := D1 xor P[3];
A1 := Rijndael_T[4, A2 and $FF] xor
Rijndael_T[5, D2 shr 8 and $FF] xor
Rijndael_T[6, C2 shr 16 and $FF] xor
Rijndael_T[7, B2 shr 24 ];
B1 := Rijndael_T[4, B2 and $FF] xor
Rijndael_T[5, A2 shr 8 and $FF] xor
Rijndael_T[6, D2 shr 16 and $FF] xor
Rijndael_T[7, C2 shr 24 ];
C1 := Rijndael_T[4, C2 and $FF] xor
Rijndael_T[5, B2 shr 8 and $FF] xor
Rijndael_T[6, A2 shr 16 and $FF] xor
Rijndael_T[7, D2 shr 24 ];
D1 := Rijndael_T[4, D2 and $FF] xor
Rijndael_T[5, C2 shr 8 and $FF] xor
Rijndael_T[6, B2 shr 16 and $FF] xor
Rijndael_T[7, A2 shr 24 ];
Dec(PUInt32(P), 4);
end;
A2 := A1 xor P[0];
B2 := B1 xor P[1];
C2 := C1 xor P[2];
D2 := D1 xor P[3];
Dec(PUInt32(P), 4);
PUInt32Array(Dest)[0] := (Rijndael_S[1, A2 and $FF] or
Rijndael_S[1, D2 shr 8 and $FF] shl 8 or
Rijndael_S[1, C2 shr 16 and $FF] shl 16 or
Rijndael_S[1, B2 shr 24] shl 24) xor P[0];
PUInt32Array(Dest)[1] := (Rijndael_S[1, B2 and $FF] or
Rijndael_S[1, A2 shr 8 and $FF] shl 8 or
Rijndael_S[1, D2 shr 16 and $FF] shl 16 or
Rijndael_S[1, C2 shr 24] shl 24) xor P[1];
PUInt32Array(Dest)[2] := (Rijndael_S[1, C2 and $FF] or
Rijndael_S[1, B2 shr 8 and $FF] shl 8 or
Rijndael_S[1, A2 shr 16 and $FF] shl 16 or
Rijndael_S[1, D2 shr 24] shl 24) xor P[2];
PUInt32Array(Dest)[3] := (Rijndael_S[1, D2 and $FF] or
Rijndael_S[1, C2 shr 8 and $FF] shl 8 or
Rijndael_S[1, B2 shr 16 and $FF] shl 16 or
Rijndael_S[1, A2 shr 24] shl 24) xor P[3];
end;
{ TCipher_Square }
class function TCipher_Square.Context: TCipherContext;
begin
Result.KeySize := 16;
Result.BlockSize := 16;
Result.BufferSize := 16;
Result.AdditionalBufferSize := 9 * 4 * 2 * SizeOf(UInt32);
Result.NeedsAdditionalBufferBackup := False;
Result.MinRounds := 1;
Result.MaxRounds := 1;
Result.CipherType := [ctSymmetric, ctBlock];
end;
procedure TCipher_Square.DoInit(const Key; Size: Integer);
type
PSquare_Key = ^TSquare_Key;
TSquare_Key = array[0..8, 0..3] of UInt32;
var
E, D: PSquare_Key;
S, T, R: UInt32;
I, J: Integer;
begin
E := FAdditionalBuffer;
D := FAdditionalBuffer; Inc(D);
Move(Key, E^, Size);
for I := 1 to 8 do
begin
T := E[I - 1, 3];
T := T shr 8 or T shl 24;
E[I, 0] := E[I - 1, 0] xor T xor 1 shl (I - 1);
E[I, 1] := E[I - 1, 1] xor E[I, 0];
E[I, 2] := E[I - 1, 2] xor E[I, 1];
E[I, 3] := E[I - 1, 3] xor E[I, 2];
D[8 - I, 0] := E[I, 0];
D[8 - I, 1] := E[I, 1];
D[8 - I, 2] := E[I, 2];
D[8 - I, 3] := E[I, 3];
for J := 0 to 3 do
begin
R := E[I - 1, J];
S := Square_PHI[R and $FF];
T := Square_PHI[R shr 8 and $FF];
T := T shl 8 or T shr 24;
S := S xor T;
T := Square_PHI[R shr 16 and $FF];
T := T shl 16 or T shr 16;
S := S xor T;
T := Square_PHI[R shr 24];
T := T shl 24 or T shr 8;
S := S xor T;
E[I - 1, J] := S;
end;
end;
D[8] := E[0];
end;
procedure TCipher_Square.DoEncode(Source, Dest: Pointer; Size: Integer);
var
Key: PUInt32Array;
A, B, C, D: UInt32;
AA, BB, CC: UInt32;
I: Integer;
begin
Key := FAdditionalBuffer;
A := PUInt32Array(Source)[0] xor Key[0];
B := PUInt32Array(Source)[1] xor Key[1];
C := PUInt32Array(Source)[2] xor Key[2];
D := PUInt32Array(Source)[3] xor Key[3];
Key := @Key[4];
for I := 0 to 6 do
begin
AA := Square_TE[0, A and $FF] xor
Square_TE[1, B and $FF] xor
Square_TE[2, C and $FF] xor
Square_TE[3, D and $FF] xor Key[0];
BB := Square_TE[0, A shr 8 and $FF] xor
Square_TE[1, B shr 8 and $FF] xor
Square_TE[2, C shr 8 and $FF] xor
Square_TE[3, D shr 8 and $FF] xor Key[1];
CC := Square_TE[0, A shr 16 and $FF] xor
Square_TE[1, B shr 16 and $FF] xor
Square_TE[2, C shr 16 and $FF] xor
Square_TE[3, D shr 16 and $FF] xor Key[2];
D := Square_TE[0, A shr 24 ] xor
Square_TE[1, B shr 24 ] xor
Square_TE[2, C shr 24 ] xor
Square_TE[3, D shr 24 ] xor Key[3];
A := AA; B := BB; C := CC;
Key := @Key[4];
end;
PUInt32Array(Dest)[0] := UInt32(Square_SE[A and $FF]) xor
UInt32(Square_SE[B and $FF]) shl 8 xor
UInt32(Square_SE[C and $FF]) shl 16 xor
UInt32(Square_SE[D and $FF]) shl 24 xor Key[0];
PUInt32Array(Dest)[1] := UInt32(Square_SE[A shr 8 and $FF]) xor
UInt32(Square_SE[B shr 8 and $FF]) shl 8 xor
UInt32(Square_SE[C shr 8 and $FF]) shl 16 xor
UInt32(Square_SE[D shr 8 and $FF]) shl 24 xor Key[1];
PUInt32Array(Dest)[2] := UInt32(Square_SE[A shr 16 and $FF]) xor
UInt32(Square_SE[B shr 16 and $FF]) shl 8 xor
UInt32(Square_SE[C shr 16 and $FF]) shl 16 xor
UInt32(Square_SE[D shr 16 and $FF]) shl 24 xor Key[2];
PUInt32Array(Dest)[3] := UInt32(Square_SE[A shr 24 ]) xor
UInt32(Square_SE[B shr 24 ]) shl 8 xor
UInt32(Square_SE[C shr 24 ]) shl 16 xor
UInt32(Square_SE[D shr 24 ]) shl 24 xor Key[3];
end;
procedure TCipher_Square.DoDecode(Source, Dest: Pointer; Size: Integer);
var
Key: PUInt32Array;
A, B, C, D: UInt32;
AA, BB, CC: UInt32;
I: Integer;
begin
Key := @PUInt32Array(FAdditionalBuffer)[9 * 4];
A := PUInt32Array(Source)[0] xor Key[0];
B := PUInt32Array(Source)[1] xor Key[1];
C := PUInt32Array(Source)[2] xor Key[2];
D := PUInt32Array(Source)[3] xor Key[3];
Key := @Key[4];
for I := 0 to 6 do
begin
AA := Square_TD[0, A and $FF] xor
Square_TD[1, B and $FF] xor
Square_TD[2, C and $FF] xor
Square_TD[3, D and $FF] xor Key[0];
BB := Square_TD[0, A shr 8 and $FF] xor
Square_TD[1, B shr 8 and $FF] xor
Square_TD[2, C shr 8 and $FF] xor
Square_TD[3, D shr 8 and $FF] xor Key[1];
CC := Square_TD[0, A shr 16 and $FF] xor
Square_TD[1, B shr 16 and $FF] xor
Square_TD[2, C shr 16 and $FF] xor
Square_TD[3, D shr 16 and $FF] xor Key[2];
D := Square_TD[0, A shr 24 ] xor
Square_TD[1, B shr 24 ] xor
Square_TD[2, C shr 24 ] xor
Square_TD[3, D shr 24 ] xor Key[3];
A := AA; B := BB; C := CC;
Key := @Key[4];
end;
PUInt32Array(Dest)[0] := UInt32(Square_SD[A and $FF]) xor
UInt32(Square_SD[B and $FF]) shl 8 xor
UInt32(Square_SD[C and $FF]) shl 16 xor
UInt32(Square_SD[D and $FF]) shl 24 xor Key[0];
PUInt32Array(Dest)[1] := UInt32(Square_SD[A shr 8 and $FF]) xor
UInt32(Square_SD[B shr 8 and $FF]) shl 8 xor
UInt32(Square_SD[C shr 8 and $FF]) shl 16 xor
UInt32(Square_SD[D shr 8 and $FF]) shl 24 xor Key[1];
PUInt32Array(Dest)[2] := UInt32(Square_SD[A shr 16 and $FF]) xor
UInt32(Square_SD[B shr 16 and $FF]) shl 8 xor
UInt32(Square_SD[C shr 16 and $FF]) shl 16 xor
UInt32(Square_SD[D shr 16 and $FF]) shl 24 xor Key[2];
PUInt32Array(Dest)[3] := UInt32(Square_SD[A shr 24 ]) xor
UInt32(Square_SD[B shr 24 ]) shl 8 xor
UInt32(Square_SD[C shr 24 ]) shl 16 xor
UInt32(Square_SD[D shr 24 ]) shl 24 xor Key[3];
end;
{ TCipher_SCOP }
class function TCipher_SCOP.Context: TCipherContext;
begin
Result.KeySize := 48;
Result.BlockSize := 4;
Result.BufferSize := 32;
Result.AdditionalBufferSize := 384 * 4 + 3 * SizeOf(UInt32);
Result.NeedsAdditionalBufferBackup := True;
Result.MinRounds := 1;
Result.MaxRounds := 1;
Result.CipherType := [ctSymmetric, ctStream];
end;
procedure TCipher_SCOP.DoInit(const Key; Size: Integer);
var
Init_State: packed record
Coef: array[0..7, 0..3] of Byte;
X: array[0..3] of UInt32;
end;
procedure ExpandKey;
var
P: PByteArray;
I, C: Integer;
begin
C := 1;
P := @Init_State;
Move(Key, P^, Size);
for I := Size to 47 do
P[I] := P[I - Size] + P[I - Size + 1];
for I := 0 to 31 do
if P[I] = 0 then
begin
P[I] := C;
Inc(C);
end;
end;
procedure GP8(Data: PUInt32Array);
var
I, I2: Integer;
NewX: array[0..3] of UInt32;
X1, X2, X3, X4: UInt32;
Y1, Y2: UInt32;
begin
I := 0;
I2 := 0;
while I < 8 do
begin
X1 := Init_State.X[I2] shr 16;
X2 := X1 * X1;
X3 := X2 * X1;
X4 := X3 * X1;
Y1 := Init_State.Coef[I][0] * X4 +
Init_State.Coef[I][1] * X3 +
Init_State.Coef[I][2] * X2 +
Init_State.Coef[I][3] * X1 + 1;
X1 := Init_State.X[I2] and $FFFF;
X2 := X1 * X1;
X3 := X2 * X1;
X4 := X3 * X1;
Y2 := Init_State.Coef[I + 1][0] * X4 +
Init_State.Coef[I + 1][1] * X3 +
Init_State.Coef[I + 1][2] * X2 +
Init_State.Coef[I + 1][3] * X1 + 1;
Data[I2] := Y1 shl 16 or Y2 and $FFFF;
NewX[I2] := Y1 and $FFFF0000 or Y2 shr 16;
Inc(I2);
Inc(I, 2);
end;
Init_State.X[0] := NewX[0] shr 16 or NewX[3] shl 16;
Init_State.X[1] := NewX[0] shl 16 or NewX[1] shr 16;
Init_State.X[2] := NewX[1] shl 16 or NewX[2] shr 16;
Init_State.X[3] := NewX[2] shl 16 or NewX[3] shr 16;
end;
var
I, J: Integer;
T: array[0..3] of UInt32;
P: PUInt32Array;
begin
FillChar(Init_State, SizeOf(Init_State), 0);
FillChar(T, SizeOf(T), 0);
P := Pointer(PByte(FAdditionalBuffer) + 12); // for Pointer Math
ExpandKey;
for I := 0 to 7 do
GP8(@T);
for I := 0 to 11 do
begin
for J := 0 to 7 do
GP8(@P[I * 32 + J * 4]);
GP8(@T);
end;
GP8(@T);
I := T[3] and $7F;
P[I] := P[I] or 1;
P := FAdditionalBuffer;
P[0] := T[3] shr 24 and $FF;
P[1] := T[3] shr 16 and $FF;
P[2] := T[3] shr 8 and $FF;
ProtectBuffer(Init_State, SizeOf(Init_State));
end;
procedure TCipher_SCOP.DoEncode(Source, Dest: Pointer; Size: Integer);
var
I, J: Byte;
T2, T3, T1: UInt32;
P: PUInt32Array;
W: Integer;
begin
P := FAdditionalBuffer;
I := P[0];
J := P[1];
T3 := P[2];
for W := 0 to Size div 4 - 1 do
begin
T1 := P[J + 3 + 128]; Inc(J, T3);
T2 := P[J + 3 + 128];
PUInt32Array(Dest)[W] := PUInt32Array(Source)[W] + T1 + T2;
T3 := T2 + P[I + 3]; Inc(I);
P[J + 3 + 128] := T3;
Inc(J, T2);
end;
P[0] := I;
P[1] := J;
P[2] := T3;
end;
procedure TCipher_SCOP.DoDecode(Source, Dest: Pointer; Size: Integer);
var
I, J: Byte;
T1, T2, T3: UInt32;
P: PUInt32Array;
W: Integer;
begin
P := FAdditionalBuffer;
I := P[0];
J := P[1];
T3 := P[2];
for W := 0 to Size div 4 - 1 do
begin
T1 := P[J + 3 + 128]; Inc(J, T3);
T2 := P[J + 3 + 128];
PUInt32Array(Dest)[W] := PUInt32Array(Source)[W] - T1 - T2;
T3 := T2 + P[I + 3];
Inc(I);
P[J + 3 + 128] := T3;
Inc(J, T2);
end;
P[0] := I;
P[1] := J;
P[2] := T3;
end;
{ TCipher_SCOP_DEC52 }
{ TODO : The old failure needs to be restored again }
class function TCipher_SCOP_DEC52.Context: TCipherContext;
begin
Result.KeySize := 48;
Result.BlockSize := 4;
Result.BufferSize := 32;
Result.AdditionalBufferSize := 384 * 4 + 3 * SizeOf(UInt32);
Result.NeedsAdditionalBufferBackup := True;
Result.MinRounds := 1;
Result.MaxRounds := 1;
Result.CipherType := [ctSymmetric, ctStream];
end;
procedure TCipher_SCOP_DEC52.DoInit(const Key; Size: Integer);
var
Init_State: packed record
Coef: array[0..7, 0..3] of Byte;
X: array[0..3] of UInt32;
end;
procedure ExpandKey;
var
P: PByteArray;
I, C: Integer;
begin
C := 1;
P := @Init_State;
Move(Key, P^, Size);
for I := Size to 47 do
P[I] := P[I - Size] + P[I - Size + 1];
for I := 0 to 31 do
if P[I] = 0 then
begin
P[I] := C;
Inc(C);
end;
end;
procedure GP8(Data: PUInt32Array);
var
I, I2: Integer;
NewX: array[0..3] of UInt32;
X1, X2, X3, X4: UInt32;
Y1, Y2: UInt32;
begin
I := 0;
I2 := 0;
while I < 8 do
begin
X1 := Init_State.X[I2] shr 16;
X2 := X1 * X1;
X3 := X2 * X1;
X4 := X3 * X1;
Y1 := Init_State.Coef[I][0] * X4 +
Init_State.Coef[I][1] * X3 +
Init_State.Coef[I][2] * X2 +
Init_State.Coef[I][3] * X1 + 1;
X1 := Init_State.X[I2] and $FFFF;
X2 := X1 * X1;
X3 := X2 * X1;
X4 := X3 * X1;
Y2 := Init_State.Coef[I + 1][0] * X4 +
Init_State.Coef[I + 2][1] * X3 +
Init_State.Coef[I + 3][2] * X2 +
Init_State.Coef[I + 4][3] * X1 + 1;
Data[I2] := Y1 shl 16 or Y2 and $FFFF;
NewX[I2] := Y1 and $FFFF0000 or Y2 shr 16;
Inc(I2);
Inc(I, 2);
end;
Init_State.X[0] := NewX[0] shr 16 or NewX[3] shl 16;
Init_State.X[1] := NewX[0] shl 16 or NewX[1] shr 16;
Init_State.X[2] := NewX[1] shl 16 or NewX[2] shr 16;
Init_State.X[3] := NewX[2] shl 16 or NewX[3] shr 16;
end;
var
I, J: Integer;
T: array[0..3] of Integer;
P: PUInt32Array;
begin
FillChar(Init_State, SizeOf(Init_State), 0);
FillChar(T, SizeOf(T), 0);
P := Pointer(PByte(FAdditionalBuffer) + 12); // for Pointer Math
ExpandKey;
for I := 0 to 7 do
GP8(@T);
for I := 0 to 11 do
begin
for J := 0 to 7 do
GP8(@P[I * 32 + J * 4]);
GP8(@T);
end;
GP8(@T);
I := T[3] and $7F;
P[I + 3] := P[I + 3] or 1;
P := FAdditionalBuffer;
P[0] := T[3] shr 24 and $FF;
P[1] := T[3] shr 16 and $FF;
P[2] := T[3] shr 8 and $FF;
ProtectBuffer(Init_State, SizeOf(Init_State));
end;
procedure TCipher_SCOP_DEC52.DoEncode(Source, Dest: Pointer; Size: Integer);
var
I, J: Byte;
T2, T3, T1: UInt32;
P: PUInt32Array;
W: Integer;
begin
P := FAdditionalBuffer;
I := P[0];
J := P[1];
T3 := P[2];
for W := 0 to Size div 4 - 1 do
begin
T1 := P[J + 3 + 128]; Inc(J, T3);
T2 := P[J + 3 + 128];
PUInt32Array(Dest)[W] := PUInt32Array(Source)[W] + T1 + T2;
T3 := T2 + P[I + 3]; Inc(I);
P[J + 3 + 128] := T3;
Inc(J, T2);
end;
P[0] := I;
P[1] := J;
P[2] := T3;
end;
procedure TCipher_SCOP_DEC52.DoDecode(Source, Dest: Pointer; Size: Integer);
var
I, J: Byte;
T1, T2, T3: UInt32;
P: PUInt32Array;
W: Integer;
begin
P := FAdditionalBuffer;
I := P[0];
J := P[1];
T3 := P[2];
for W := 0 to Size div 4 - 1 do
begin
T1 := P[J + 3 + 128]; Inc(J, T3);
T2 := P[J + 3 + 128];
PUInt32Array(Dest)[W] := PUInt32Array(Source)[W] - T1 - T2;
T3 := T2 + P[I + 3];
Inc(I);
P[J + 3 + 128] := T3;
Inc(J, T2);
end;
P[0] := I;
P[1] := J;
P[2] := T3;
end;
{ TCipher_Sapphire }
type
PSapphireKey = ^TSapphireKey;
TSapphireKey = packed record
Cards: array[0..255] of UInt32;
Rotor: UInt32;
Ratchet: UInt32;
Avalanche: UInt32;
Plain: UInt32;
Cipher: UInt32;
end;
class function TCipher_Sapphire.Context: TCipherContext;
begin
Result.KeySize := 1024;
Result.BlockSize := 1;
Result.BufferSize := 32;
Result.AdditionalBufferSize := SizeOf(TSapphireKey);
Result.NeedsAdditionalBufferBackup := True;
Result.MinRounds := 1;
Result.MaxRounds := 1;
Result.CipherType := [ctSymmetric, ctStream];
end;
procedure TCipher_Sapphire.DoInit(const Key; Size: Integer);
var
Sum: Byte;
P: Integer;
function KeyRand(Max: UInt32): Byte;
var
I, M: UInt32;
begin
Result := 0;
if Max = 0 then
Exit;
I := 0;
M := 1;
while M < Max do
Inc(M, M or 1);
repeat
Inc(Sum, TByteArray(Key)[P]);
Inc(P);
if P >= Size then
begin
P := 0;
Inc(Sum, Size);
end;
Result := M and Sum;
Inc(I);
if I > 11 then
Result := Result mod Max;
until Result <= Max;
end;
var
I, S, T: Integer;
SKey : PSapphireKey;
begin
SKey := PSapphireKey(FAdditionalBuffer);
if Size <= 0 then
begin
SKey.Rotor := 1;
SKey.Ratchet := 3;
SKey.Avalanche := 5;
SKey.Plain := 7;
SKey.Cipher := 11;
for I := 0 to 255 do
SKey.Cards[I] := 255 - I;
end
else
begin
for I := 0 to 255 do
SKey.Cards[I] := I;
P := 0;
Sum := 0;
for I := 255 downto 1 do
begin
S := KeyRand(I);
T := SKey.Cards[I];
SKey.Cards[I] := SKey.Cards[S];
SKey.Cards[S] := T;
end;
SKey.Rotor := SKey.Cards[1];
SKey.Ratchet := SKey.Cards[3];
SKey.Avalanche := SKey.Cards[5];
SKey.Plain := SKey.Cards[7];
SKey.Cipher := SKey.Cards[Sum];
end;
end;
procedure TCipher_Sapphire.DoEncode(Source, Dest: Pointer; Size: Integer);
var
T: UInt32;
I: Integer;
SKey: PSapphireKey;
begin
SKey := PSapphireKey(FAdditionalBuffer);
for I := 0 to Size - 1 do
begin
SKey.Ratchet := (SKey.Ratchet + SKey.Cards[SKey.Rotor]) and $FF;
SKey.Rotor := (SKey.Rotor + 1) and $FF;
T := SKey.Cards[SKey.Cipher];
SKey.Cards[SKey.Cipher] := SKey.Cards[SKey.Ratchet];
SKey.Cards[SKey.Ratchet] := SKey.Cards[SKey.Plain];
SKey.Cards[SKey.Plain] := SKey.Cards[SKey.Rotor];
SKey.Cards[SKey.Rotor] := T;
SKey.Avalanche := (SKey.Avalanche + SKey.Cards[T]) and $FF;
T := (SKey.Cards[SKey.Plain] + SKey.Cards[SKey.Cipher] + SKey.Cards[SKey.Avalanche]) and $FF;
SKey.Plain := PByteArray(Source)[I];
SKey.Cipher := SKey.Plain xor SKey.Cards[SKey.Cards[T]] xor
SKey.Cards[(SKey.Cards[SKey.Ratchet] +
SKey.Cards[SKey.Rotor]) and $FF];
PByteArray(Dest)[I] := SKey.Cipher;
end;
end;
procedure TCipher_Sapphire.DoDecode(Source, Dest: Pointer; Size: Integer);
var
T: UInt32;
I: Integer;
SKey: PSapphireKey;
begin
SKey := PSapphireKey(FAdditionalBuffer);
for I := 0 to Size - 1 do
begin
SKey.Ratchet := (SKey.Ratchet + SKey.Cards[SKey.Rotor]) and $FF;
SKey.Rotor := (SKey.Rotor + 1) and $FF;
T := SKey.Cards[SKey.Cipher];
SKey.Cards[SKey.Cipher] := SKey.Cards[SKey.Ratchet];
SKey.Cards[SKey.Ratchet] := SKey.Cards[SKey.Plain];
SKey.Cards[SKey.Plain] := SKey.Cards[SKey.Rotor];
SKey.Cards[SKey.Rotor] := T;
SKey.Avalanche := (SKey.Avalanche + SKey.Cards[T]) and $FF;
T := (SKey.Cards[SKey.Plain] + SKey.Cards[SKey.Cipher] + SKey.Cards[SKey.Avalanche]) and $FF;
SKey.Cipher := PByteArray(Source)[I];
SKey.Plain := SKey.Cipher xor SKey.Cards[SKey.Cards[T]] xor
SKey.Cards[(SKey.Cards[SKey.Ratchet] +
SKey.Cards[SKey.Rotor]) and $FF];
PByteArray(Dest)[I] := SKey.Plain;
end;
end;
{ TCipher_1DES }
procedure DES_Func(Source, Dest, Key: PUInt32Array);
var
L, R, X, Y, I: UInt32;
begin
L := SwapUInt32(Source[0]);
R := SwapUInt32(Source[1]);
X := (L shr 4 xor R) and $0F0F0F0F; R := R xor X; L := L xor X shl 4;
X := (L shr 16 xor R) and $0000FFFF; R := R xor X; L := L xor X shl 16;
X := (R shr 2 xor L) and $33333333; L := L xor X; R := R xor X shl 2;
X := (R shr 8 xor L) and $00FF00FF; L := L xor X; R := R xor X shl 8;
R := R shl 1 or R shr 31;
X := (L xor R) and $AAAAAAAA;
R := R xor X;
L := L xor X;
L := L shl 1 or L shr 31;
for I := 0 to 7 do
begin
X := (R shl 28 or R shr 4) xor Key[0];
Y := R xor Key[1];
L := L xor (DES_Data[0, X and $3F] or DES_Data[1, X shr 8 and $3F] or
DES_Data[2, X shr 16 and $3F] or DES_Data[3, X shr 24 and $3F] or
DES_Data[4, Y and $3F] or DES_Data[5, Y shr 8 and $3F] or
DES_Data[6, Y shr 16 and $3F] or DES_Data[7, Y shr 24 and $3F]);
X := (L shl 28 or L shr 4) xor Key[2];
Y := L xor Key[3];
R := R xor (DES_Data[0, X and $3F] or DES_Data[1, X shr 8 and $3F] or
DES_Data[2, X shr 16 and $3F] or DES_Data[3, X shr 24 and $3F] or
DES_Data[4, Y and $3F] or DES_Data[5, Y shr 8 and $3F] or
DES_Data[6, Y shr 16 and $3F] or DES_Data[7, Y shr 24 and $3F]);
Key := @Key[4];
end;
R := R shl 31 or R shr 1;
X := (L xor R) and $AAAAAAAA;
R := R xor X;
L := L xor X;
L := L shl 31 or L shr 1;
X := (L shr 8 xor R) and $00FF00FF; R := R xor X; L := L xor X shl 8;
X := (L shr 2 xor R) and $33333333; R := R xor X; L := L xor X shl 2;
X := (R shr 16 xor L) and $0000FFFF; L := L xor X; R := R xor X shl 16;
X := (R shr 4 xor L) and $0F0F0F0F; L := L xor X; R := R xor X shl 4;
Dest[0] := SwapUInt32(R);
Dest[1] := SwapUInt32(L);
end;
class function TCipher_1DES.Context: TCipherContext;
begin
Result.KeySize := 8;
Result.BlockSize := 8;
Result.BufferSize := 8;
Result.AdditionalBufferSize := 32 * 4 * 2;
Result.NeedsAdditionalBufferBackup := False;
Result.MinRounds := 1;
Result.MaxRounds := 1;
Result.CipherType := [ctSymmetric, ctBlock];
end;
procedure TCipher_1DES.DoInitKey(const Data: array of Byte; Key: PUInt32Array; Reverse: Boolean);
const
ROT: array[0..15] of Byte = (1, 2, 4, 6, 8, 10, 12, 14, 15, 17, 19, 21, 23, 25, 27, 28);
var
I, J, L, M, N: UInt32;
PC_M, PC_R: array[0..55] of Byte;
K: array[0..31] of UInt32;
begin
FillChar(K, SizeOf(K), 0);
for I := 0 to 55 do
if Data[DES_PC1[I] shr 3] and ($80 shr (DES_PC1[I] and $07)) <> 0 then
PC_M[I] := 1
else
PC_M[I] := 0;
for I := 0 to 15 do
begin
if Reverse then
M := (15 - I) shl 1
else
M := I shl 1;
N := M + 1;
for J := 0 to 27 do
begin
L := J + ROT[I];
if L < 28 then
PC_R[J] := PC_M[L]
else
PC_R[J] := PC_M[L - 28];
end;
for J := 28 to 55 do
begin
L := J + ROT[I];
if L < 56 then
PC_R[J] := PC_M[L]
else
PC_R[J] := PC_M[L - 28];
end;
L := $1000000;
for J := 0 to 23 do
begin
L := L shr 1;
if PC_R[DES_PC2[J ]] <> 0 then
K[M] := K[M] or L;
if PC_R[DES_PC2[J + 24]] <> 0 then
K[N] := K[N] or L;
end;
end;
for I := 0 to 15 do
begin
M := I shl 1;
N := M + 1;
Key[0] := K[M] and $00FC0000 shl 6 or
K[M] and $00000FC0 shl 10 or
K[N] and $00FC0000 shr 10 or
K[N] and $00000FC0 shr 6;
Key[1] := K[M] and $0003F000 shl 12 or
K[M] and $0000003F shl 16 or
K[N] and $0003F000 shr 4 or
K[N] and $0000003F;
Key := @Key[2];
end;
ProtectBuffer(K, SizeOf(K));
ProtectBuffer(PC_M, SizeOf(PC_M));
ProtectBuffer(PC_R, SizeOf(PC_R));
end;
procedure TCipher_1DES.DoInit(const Key; Size: Integer);
var
K: array[0..7] of Byte;
begin
FillChar(K, SizeOf(K), 0);
Move(Key, K, Size);
DoInitKey(K, FAdditionalBuffer, False);
DoInitKey(K, @PUInt32Array(FAdditionalBuffer)[32], True);
ProtectBuffer(K, SizeOf(K));
end;
procedure TCipher_1DES.DoEncode(Source, Dest: Pointer; Size: Integer);
begin
Assert(Size = Context.BlockSize);
DES_Func(Source, Dest, FAdditionalBuffer);
end;
procedure TCipher_1DES.DoDecode(Source, Dest: Pointer; Size: Integer);
begin
Assert(Size = Context.BlockSize);
DES_Func(Source, Dest, @PUInt32Array(FAdditionalBuffer)[32]);
end;
{ TCipher_2DES }
class function TCipher_2DES.Context: TCipherContext;
begin
Result.KeySize := 16;
Result.BlockSize := 8;
Result.BufferSize := 8;
Result.AdditionalBufferSize := 32 * 4 * 2 * 2;
Result.NeedsAdditionalBufferBackup := False;
Result.MinRounds := 1;
Result.MaxRounds := 1;
Result.CipherType := [ctSymmetric, ctBlock];
end;
procedure TCipher_2DES.DoInit(const Key; Size: Integer);
var
K: array[0..15] of Byte;
P: PUInt32Array;
begin
FillChar(K, SizeOf(K), 0);
Move(Key, K, Size);
P := FAdditionalBuffer;
DoInitKey(K[0], @P[ 0], False);
DoInitKey(K[8], @P[32], True);
DoInitKey(K[0], @P[64], True);
DoInitKey(K[8], @P[96], False);
ProtectBuffer(K, SizeOf(K));
end;
procedure TCipher_2DES.DoEncode(Source, Dest: Pointer; Size: Integer);
begin
Assert(Size = Context.BlockSize);
DES_Func(Source, Dest, FAdditionalBuffer);
DES_Func(Source, Dest, @PUInt32Array(FAdditionalBuffer)[32]);
DES_Func(Source, Dest, FAdditionalBuffer);
end;
procedure TCipher_2DES.DoDecode(Source, Dest: Pointer; Size: Integer);
begin
Assert(Size = Context.BlockSize);
DES_Func(Source, Dest, @PUInt32Array(FAdditionalBuffer)[64]);
DES_Func(Source, Dest, @PUInt32Array(FAdditionalBuffer)[96]);
DES_Func(Source, Dest, @PUInt32Array(FAdditionalBuffer)[64]);
end;
{ TCipher_3DES }
class function TCipher_3DES.Context: TCipherContext;
begin
Result.KeySize := 24;
Result.BlockSize := 8;
Result.BufferSize := 8;
Result.AdditionalBufferSize := 32 * 4 * 2 * 3;
Result.NeedsAdditionalBufferBackup := False;
Result.MinRounds := 1;
Result.MaxRounds := 1;
Result.CipherType := [ctSymmetric, ctBlock];
end;
procedure TCipher_3DES.DoInit(const Key; Size: Integer);
var
K: array[0..23] of Byte;
P: PUInt32Array;
begin
FillChar(K, SizeOf(K), 0);
Move(Key, K, Size);
P := FAdditionalBuffer;
DoInitKey(K[ 0], @P[ 0], False);
DoInitKey(K[ 8], @P[ 32], True);
DoInitKey(K[16], @P[ 64], False);
DoInitKey(K[16], @P[ 96], True);
DoInitKey(K[ 8], @P[128], False);
DoInitKey(K[ 0], @P[160], True);
ProtectBuffer(K, SizeOf(K));
end;
procedure TCipher_3DES.DoEncode(Source, Dest: Pointer; Size: Integer);
begin
Assert(Size = Context.BlockSize);
DES_Func(Source, Dest, @PUInt32Array(FAdditionalBuffer)[ 0]);
DES_Func(Source, Dest, @PUInt32Array(FAdditionalBuffer)[32]);
DES_Func(Source, Dest, @PUInt32Array(FAdditionalBuffer)[64]);
end;
procedure TCipher_3DES.DoDecode(Source, Dest: Pointer; Size: Integer);
begin
Assert(Size = Context.BlockSize);
DES_Func(Source, Dest, @PUInt32Array(FAdditionalBuffer)[96]);
DES_Func(Source, Dest, @PUInt32Array(FAdditionalBuffer)[128]);
DES_Func(Source, Dest, @PUInt32Array(FAdditionalBuffer)[160]);
end;
{ TCipher_2DDES }
class function TCipher_2DDES.Context: TCipherContext;
begin
Result := inherited Context;
Result.BlockSize := 16;
Result.BufferSize := 16;
Result.MinRounds := 1;
Result.MaxRounds := 1;
Result.CipherType := [ctSymmetric, ctBlock];
end;
procedure TCipher_2DDES.DoEncode(Source, Dest: Pointer; Size: Integer);
var
T: UInt32;
begin
Assert(Size = Context.BlockSize);
DES_Func(@PUInt32Array(Source)[0], @PUInt32Array(Dest)[0], FAdditionalBuffer);
DES_Func(@PUInt32Array(Source)[2], @PUInt32Array(Dest)[2], FAdditionalBuffer);
T := PUInt32Array(Dest)[1];
PUInt32Array(Dest)[1] := PUInt32Array(Dest)[2];
PUInt32Array(Dest)[2] := T;
DES_Func(@PUInt32Array(Dest)[0], @PUInt32Array(Dest)[0], @PUInt32Array(FAdditionalBuffer)[32]);
DES_Func(@PUInt32Array(Dest)[2], @PUInt32Array(Dest)[2], @PUInt32Array(FAdditionalBuffer)[32]);
T := PUInt32Array(Dest)[1];
PUInt32Array(Dest)[1] := PUInt32Array(Dest)[2];
PUInt32Array(Dest)[2] := T;
DES_Func(@PUInt32Array(Dest)[0], @PUInt32Array(Dest)[0], FAdditionalBuffer);
DES_Func(@PUInt32Array(Dest)[2], @PUInt32Array(Dest)[2], FAdditionalBuffer);
end;
procedure TCipher_2DDES.DoDecode(Source, Dest: Pointer; Size: Integer);
var
T: UInt32;
begin
Assert(Size = Context.BlockSize);
DES_Func(@PUInt32Array(Source)[0], @PUInt32Array(Dest)[0], @PUInt32Array(FAdditionalBuffer)[64]);
DES_Func(@PUInt32Array(Source)[2], @PUInt32Array(Dest)[2], @PUInt32Array(FAdditionalBuffer)[64]);
T := PUInt32Array(Dest)[1];
PUInt32Array(Dest)[1] := PUInt32Array(Dest)[2];
PUInt32Array(Dest)[2] := T;
DES_Func(@PUInt32Array(Dest)[0], @PUInt32Array(Dest)[0], @PUInt32Array(FAdditionalBuffer)[96]);
DES_Func(@PUInt32Array(Dest)[2], @PUInt32Array(Dest)[2], @PUInt32Array(FAdditionalBuffer)[96]);
T := PUInt32Array(Dest)[1];
PUInt32Array(Dest)[1] := PUInt32Array(Dest)[2];
PUInt32Array(Dest)[2] := T;
DES_Func(@PUInt32Array(Dest)[0], @PUInt32Array(Dest)[0], @PUInt32Array(FAdditionalBuffer)[64]);
DES_Func(@PUInt32Array(Dest)[2], @PUInt32Array(Dest)[2], @PUInt32Array(FAdditionalBuffer)[64]);
end;
{ TCipher_3DDES }
class function TCipher_3DDES.Context: TCipherContext;
begin
Result := inherited Context;
Result.BlockSize := 16;
Result.BufferSize := 16;
Result.MinRounds := 1;
Result.MaxRounds := 1;
Result.CipherType := [ctSymmetric, ctBlock];
end;
procedure TCipher_3DDES.DoEncode(Source, Dest: Pointer; Size: Integer);
var
T: UInt32;
begin
Assert(Size = Context.BlockSize);
DES_Func(@PUInt32Array(Source)[0], @PUInt32Array(Dest)[0], FAdditionalBuffer);
DES_Func(@PUInt32Array(Source)[2], @PUInt32Array(Dest)[2], FAdditionalBuffer);
T := PUInt32Array(Dest)[1];
PUInt32Array(Dest)[1] := PUInt32Array(Dest)[2];
PUInt32Array(Dest)[2] := T;
DES_Func(@PUInt32Array(Dest)[0], @PUInt32Array(Dest)[0], @PUInt32Array(FAdditionalBuffer)[32]);
DES_Func(@PUInt32Array(Dest)[2], @PUInt32Array(Dest)[2], @PUInt32Array(FAdditionalBuffer)[32]);
T := PUInt32Array(Dest)[1];
PUInt32Array(Dest)[1] := PUInt32Array(Dest)[2];
PUInt32Array(Dest)[2] := T;
DES_Func(@PUInt32Array(Dest)[0], @PUInt32Array(Dest)[0], @PUInt32Array(FAdditionalBuffer)[64]);
DES_Func(@PUInt32Array(Dest)[2], @PUInt32Array(Dest)[2], @PUInt32Array(FAdditionalBuffer)[64]);
end;
procedure TCipher_3DDES.DoDecode(Source, Dest: Pointer; Size: Integer);
var
T: UInt32;
begin
Assert(Size = Context.BlockSize);
DES_Func(@PUInt32Array(Source)[0], @PUInt32Array(Dest)[0], @PUInt32Array(FAdditionalBuffer)[96]);
DES_Func(@PUInt32Array(Source)[2], @PUInt32Array(Dest)[2], @PUInt32Array(FAdditionalBuffer)[96]);
T := PUInt32Array(Dest)[1];
PUInt32Array(Dest)[1] := PUInt32Array(Dest)[2];
PUInt32Array(Dest)[2] := T;
DES_Func(@PUInt32Array(Dest)[0], @PUInt32Array(Dest)[0], @PUInt32Array(FAdditionalBuffer)[128]);
DES_Func(@PUInt32Array(Dest)[2], @PUInt32Array(Dest)[2], @PUInt32Array(FAdditionalBuffer)[128]);
T := PUInt32Array(Dest)[1];
PUInt32Array(Dest)[1] := PUInt32Array(Dest)[2];
PUInt32Array(Dest)[2] := T;
DES_Func(@PUInt32Array(Dest)[0], @PUInt32Array(Dest)[0], @PUInt32Array(FAdditionalBuffer)[160]);
DES_Func(@PUInt32Array(Dest)[2], @PUInt32Array(Dest)[2], @PUInt32Array(FAdditionalBuffer)[160]);
end;
{ TCipher_3TDES }
class function TCipher_3TDES.Context: TCipherContext;
begin
Result := inherited Context;
Result.BlockSize := 24;
Result.BufferSize := 24;
Result.MinRounds := 1;
Result.MaxRounds := 1;
Result.CipherType := [ctSymmetric, ctBlock];
end;
procedure TCipher_3TDES.DoEncode(Source, Dest: Pointer; Size: Integer);
var
T: UInt32;
begin
Assert(Size = Context.BlockSize);
DES_Func(@PUInt32Array(Source)[0], @PUInt32Array(Dest)[0], FAdditionalBuffer);
DES_Func(@PUInt32Array(Source)[2], @PUInt32Array(Dest)[2], FAdditionalBuffer);
DES_Func(@PUInt32Array(Source)[4], @PUInt32Array(Dest)[4], FAdditionalBuffer);
T := PUInt32Array(Dest)[1];
PUInt32Array(Dest)[1] := PUInt32Array(Dest)[2];
PUInt32Array(Dest)[2] := T;
T := PUInt32Array(Dest)[3];
PUInt32Array(Dest)[3] := PUInt32Array(Dest)[4];
PUInt32Array(Dest)[4] := T;
DES_Func(@PUInt32Array(Dest)[0], @PUInt32Array(Dest)[0], @PUInt32Array(FAdditionalBuffer)[32]);
DES_Func(@PUInt32Array(Dest)[2], @PUInt32Array(Dest)[2], @PUInt32Array(FAdditionalBuffer)[32]);
DES_Func(@PUInt32Array(Dest)[4], @PUInt32Array(Dest)[4], @PUInt32Array(FAdditionalBuffer)[32]);
T := PUInt32Array(Dest)[1];
PUInt32Array(Dest)[1] := PUInt32Array(Dest)[2];
PUInt32Array(Dest)[2] := T;
T := PUInt32Array(Dest)[3];
PUInt32Array(Dest)[3] := PUInt32Array(Dest)[4];
PUInt32Array(Dest)[4] := T;
DES_Func(@PUInt32Array(Dest)[0], @PUInt32Array(Dest)[0], @PUInt32Array(FAdditionalBuffer)[64]);
DES_Func(@PUInt32Array(Dest)[2], @PUInt32Array(Dest)[2], @PUInt32Array(FAdditionalBuffer)[64]);
DES_Func(@PUInt32Array(Dest)[4], @PUInt32Array(Dest)[4], @PUInt32Array(FAdditionalBuffer)[64]);
end;
procedure TCipher_3TDES.DoDecode(Source, Dest: Pointer; Size: Integer);
var
T: UInt32;
begin
Assert(Size = Context.BlockSize);
DES_Func(@PUInt32Array(Source)[0], @PUInt32Array(Dest)[0], @PUInt32Array(FAdditionalBuffer)[96]);
DES_Func(@PUInt32Array(Source)[2], @PUInt32Array(Dest)[2], @PUInt32Array(FAdditionalBuffer)[96]);
DES_Func(@PUInt32Array(Source)[4], @PUInt32Array(Dest)[4], @PUInt32Array(FAdditionalBuffer)[96]);
T := PUInt32Array(Dest)[1];
PUInt32Array(Dest)[1] := PUInt32Array(Dest)[2];
PUInt32Array(Dest)[2] := T;
T := PUInt32Array(Dest)[3];
PUInt32Array(Dest)[3] := PUInt32Array(Dest)[4];
PUInt32Array(Dest)[4] := T;
DES_Func(@PUInt32Array(Dest)[0], @PUInt32Array(Dest)[0], @PUInt32Array(FAdditionalBuffer)[128]);
DES_Func(@PUInt32Array(Dest)[2], @PUInt32Array(Dest)[2], @PUInt32Array(FAdditionalBuffer)[128]);
DES_Func(@PUInt32Array(Dest)[4], @PUInt32Array(Dest)[4], @PUInt32Array(FAdditionalBuffer)[128]);
T := PUInt32Array(Dest)[1];
PUInt32Array(Dest)[1] := PUInt32Array(Dest)[2];
PUInt32Array(Dest)[2] := T;
T := PUInt32Array(Dest)[3];
PUInt32Array(Dest)[3] := PUInt32Array(Dest)[4];
PUInt32Array(Dest)[4] := T;
DES_Func(@PUInt32Array(Dest)[0], @PUInt32Array(Dest)[0], @PUInt32Array(FAdditionalBuffer)[160]);
DES_Func(@PUInt32Array(Dest)[2], @PUInt32Array(Dest)[2], @PUInt32Array(FAdditionalBuffer)[160]);
DES_Func(@PUInt32Array(Dest)[4], @PUInt32Array(Dest)[4], @PUInt32Array(FAdditionalBuffer)[160]);
end;
{ TCipher_3Way }
type
P3Way_Key = ^T3Way_Key;
T3Way_Key = packed record
E_Key: array[0..2] of UInt32;
E_Data: array[0..11] of UInt32;
D_Key: array[0..2] of UInt32;
D_Data: array[0..11] of UInt32;
end;
class function TCipher_3Way.Context: TCipherContext;
begin
Result.KeySize := 12;
Result.BlockSize := 12;
Result.BufferSize := 12;
Result.AdditionalBufferSize := SizeOf(T3Way_Key);
Result.NeedsAdditionalBufferBackup := False;
Result.MinRounds := 1;
Result.MaxRounds := 1;
Result.CipherType := [ctSymmetric, ctBlock];
end;
procedure TCipher_3Way.DoInit(const Key; Size: Integer);
procedure RANDGenerate(Start: UInt32; var P: array of UInt32);
var
I: Integer;
begin
for I := 0 to 11 do
begin
P[I] := Start;
Start := Start shl 1;
if Start and $10000 <> 0 then
Start := Start xor $11011;
end;
end;
var
A0, A1, A2: UInt32;
B0, B1, B2: UInt32;
P3WayKey: P3Way_Key;
begin
P3WayKey := P3Way_Key(FAdditionalBuffer);
Move(Key, P3WayKey.E_Key, Size);
Move(Key, P3WayKey.D_Key, Size);
RANDGenerate($0B0B, P3WayKey.E_Data);
RANDGenerate($B1B1, P3WayKey.D_Data);
A0 := P3WayKey.D_Key[0];
A1 := P3WayKey.D_Key[1];
A2 := P3WayKey.D_Key[2];
B0 := A0 xor A0 shr 16 xor A1 shl 16 xor A1 shr 16 xor A2 shl 16 xor
A1 shr 24 xor A2 shl 8 xor A2 shr 8 xor A0 shl 24 xor
A2 shr 16 xor A0 shl 16 xor A2 shr 24 xor A0 shl 8;
B1 := A1 xor A1 shr 16 xor A2 shl 16 xor A2 shr 16 xor A0 shl 16 xor
A2 shr 24 xor A0 shl 8 xor A0 shr 8 xor A1 shl 24 xor
A0 shr 16 xor A1 shl 16 xor A0 shr 24 xor A1 shl 8;
B2 := A2 xor A2 shr 16 xor A0 shl 16 xor A0 shr 16 xor A1 shl 16 xor
A0 shr 24 xor A1 shl 8 xor A1 shr 8 xor A2 shl 24 xor
A1 shr 16 xor A2 shl 16 xor A1 shr 24 xor A2 shl 8;
P3WayKey.D_Key[2] := ReverseBits(B0);
P3WayKey.D_Key[1] := ReverseBits(B1);
P3WayKey.D_Key[0] := ReverseBits(B2);
end;
procedure TCipher_3Way.DoEncode(Source, Dest: Pointer; Size: Integer);
var
I: Integer;
A0, A1, A2: UInt32;
B0, B1, B2: UInt32;
K0, K1, K2: UInt32;
E: PUInt32;
P3WayKey: P3Way_Key;
begin
Assert(Size = Context.BlockSize);
P3WayKey := P3Way_Key(FAdditionalBuffer);
K0 := P3WayKey.E_Key[0];
K1 := P3WayKey.E_Key[1];
K2 := P3WayKey.E_Key[2];
E := @P3WayKey.E_Data;
A0 := PUInt32Array(Source)[0];
A1 := PUInt32Array(Source)[1];
A2 := PUInt32Array(Source)[2];
for I := 0 to 10 do
begin
A0 := A0 xor K0 xor E^ shl 16;
A1 := A1 xor K1;
A2 := A2 xor K2 xor E^;
Inc(E);
B0 := A0 xor A0 shr 16 xor A1 shl 16 xor A1 shr 16 xor A2 shl 16 xor
A1 shr 24 xor A2 shl 8 xor A2 shr 8 xor A0 shl 24 xor
A2 shr 16 xor A0 shl 16 xor A2 shr 24 xor A0 shl 8;
B1 := A1 xor A1 shr 16 xor A2 shl 16 xor A2 shr 16 xor A0 shl 16 xor
A2 shr 24 xor A0 shl 8 xor A0 shr 8 xor A1 shl 24 xor
A0 shr 16 xor A1 shl 16 xor A0 shr 24 xor A1 shl 8;
B2 := A2 xor A2 shr 16 xor A0 shl 16 xor A0 shr 16 xor A1 shl 16 xor
A0 shr 24 xor A1 shl 8 xor A1 shr 8 xor A2 shl 24 xor
A1 shr 16 xor A2 shl 16 xor A1 shr 24 xor A2 shl 8;
B0 := B0 shr 10 or B0 shl 22;
B2 := B2 shl 1 or B2 shr 31;
A0 := B0 xor (B1 or not B2);
A1 := B1 xor (B2 or not B0);
A2 := B2 xor (B0 or not B1);
A0 := A0 shl 1 or A0 shr 31;
A2 := A2 shr 10 or A2 shl 22;
end;
A0 := A0 xor K0 xor E^ shl 16;
A1 := A1 xor K1;
A2 := A2 xor K2 xor E^;
PUInt32Array(Dest)[0] := A0 xor A0 shr 16 xor A1 shl 16 xor A1 shr 16 xor A2 shl 16 xor
A1 shr 24 xor A2 shl 8 xor A2 shr 8 xor A0 shl 24 xor
A2 shr 16 xor A0 shl 16 xor A2 shr 24 xor A0 shl 8;
PUInt32Array(Dest)[1] := A1 xor A1 shr 16 xor A2 shl 16 xor A2 shr 16 xor A0 shl 16 xor
A2 shr 24 xor A0 shl 8 xor A0 shr 8 xor A1 shl 24 xor
A0 shr 16 xor A1 shl 16 xor A0 shr 24 xor A1 shl 8;
PUInt32Array(Dest)[2] := A2 xor A2 shr 16 xor A0 shl 16 xor A0 shr 16 xor A1 shl 16 xor
A0 shr 24 xor A1 shl 8 xor A1 shr 8 xor A2 shl 24 xor
A1 shr 16 xor A2 shl 16 xor A1 shr 24 xor A2 shl 8;
end;
procedure TCipher_3Way.DoDecode(Source, Dest: Pointer; Size: Integer);
var
I: Integer;
A0, A1, A2: UInt32;
B0, B1, B2: UInt32;
K0, K1, K2: UInt32;
E: PUInt32;
P3WayKey: P3Way_Key;
begin
Assert(Size = Context.BlockSize);
P3WayKey := P3Way_Key(FAdditionalBuffer);
K0 := P3WayKey.D_Key[0];
K1 := P3WayKey.D_Key[1];
K2 := P3WayKey.D_Key[2];
E := @P3WayKey.D_Data;
A0 := ReverseBits(PUInt32Array(Source)[2]);
A1 := ReverseBits(PUInt32Array(Source)[1]);
A2 := ReverseBits(PUInt32Array(Source)[0]);
for I := 0 to 10 do
begin
A0 := A0 xor K0 xor E^ shl 16;
A1 := A1 xor K1;
A2 := A2 xor K2 xor E^;
Inc(E);
B0 := A0 xor A0 shr 16 xor A1 shl 16 xor A1 shr 16 xor A2 shl 16 xor
A1 shr 24 xor A2 shl 8 xor A2 shr 8 xor A0 shl 24 xor
A2 shr 16 xor A0 shl 16 xor A2 shr 24 xor A0 shl 8;
B1 := A1 xor A1 shr 16 xor A2 shl 16 xor A2 shr 16 xor A0 shl 16 xor
A2 shr 24 xor A0 shl 8 xor A0 shr 8 xor A1 shl 24 xor
A0 shr 16 xor A1 shl 16 xor A0 shr 24 xor A1 shl 8;
B2 := A2 xor A2 shr 16 xor A0 shl 16 xor A0 shr 16 xor A1 shl 16 xor
A0 shr 24 xor A1 shl 8 xor A1 shr 8 xor A2 shl 24 xor
A1 shr 16 xor A2 shl 16 xor A1 shr 24 xor A2 shl 8;
B0 := B0 shr 10 or B0 shl 22;
B2 := B2 shl 1 or B2 shr 31;
A0 := B0 xor (B1 or not B2);
A1 := B1 xor (B2 or not B0);
A2 := B2 xor (B0 or not B1);
A0 := A0 shl 1 or A0 shr 31;
A2 := A2 shr 10 or A2 shl 22;
end;
A0 := A0 xor K0 xor E^ shl 16;
A1 := A1 xor K1;
A2 := A2 xor K2 xor E^;
B0 := A0 xor A0 shr 16 xor A1 shl 16 xor A1 shr 16 xor A2 shl 16 xor
A1 shr 24 xor A2 shl 8 xor A2 shr 8 xor A0 shl 24 xor
A2 shr 16 xor A0 shl 16 xor A2 shr 24 xor A0 shl 8;
B1 := A1 xor A1 shr 16 xor A2 shl 16 xor A2 shr 16 xor A0 shl 16 xor
A2 shr 24 xor A0 shl 8 xor A0 shr 8 xor A1 shl 24 xor
A0 shr 16 xor A1 shl 16 xor A0 shr 24 xor A1 shl 8;
B2 := A2 xor A2 shr 16 xor A0 shl 16 xor A0 shr 16 xor A1 shl 16 xor
A0 shr 24 xor A1 shl 8 xor A1 shr 8 xor A2 shl 24 xor
A1 shr 16 xor A2 shl 16 xor A1 shr 24 xor A2 shl 8;
PUInt32Array(Dest)[2] := ReverseBits(B0);
PUInt32Array(Dest)[1] := ReverseBits(B1);
PUInt32Array(Dest)[0] := ReverseBits(B2);
end;
{ TCipher_Cast128 }
class function TCipher_Cast128.Context: TCipherContext;
begin
Result.KeySize := 16;
Result.BlockSize := 8;
Result.BufferSize := 8;
Result.AdditionalBufferSize := 128;
Result.NeedsAdditionalBufferBackup := false;
Result.MinRounds := 1;
Result.MaxRounds := 256;
Result.CipherType := [ctSymmetric, ctBlock];
end;
procedure TCipher_Cast128.SetRounds(Value: Integer);
begin
if Value <> FRounds then
begin
if not (FState in [csNew, csInitialized, csDone]) then
Done;
if (FState <> csNew) and (Value <= 0) then
Value := 16;
FRounds := Value;
end;
end;
procedure TCipher_Cast128.DoInit(const Key; Size: Integer);
var
Z, X, T: array[0..3] of UInt32;
K: PUInt32Array;
I: UInt32;
begin
if FRounds <= 0 then
begin
if Size <= 10 then
FRounds := 12
else
FRounds := 16;
end;
K := FAdditionalBuffer;
FillChar(X, SizeOf(X), 0);
Move(Key, X, Size);
SwapUInt32Buffer(X, X, 4);
I := 0;
while I < 32 do
begin
if I and 4 = 0 then
begin
Z[0] := X[0] xor Cast128_Key[0, X[3] shr 16 and $FF] xor
Cast128_Key[1, X[3] and $FF] xor
Cast128_Key[2, X[3] shr 24] xor
Cast128_Key[3, X[3] shr 8 and $FF] xor
Cast128_Key[2, X[2] shr 24];
T[0] := Z[0];
Z[1] := X[2] xor Cast128_Key[0, Z[0] shr 24] xor
Cast128_Key[1, Z[0] shr 8 and $FF] xor
Cast128_Key[2, Z[0] shr 16 and $FF] xor
Cast128_Key[3, Z[0] and $FF] xor
Cast128_Key[3, X[2] shr 8 and $FF];
T[1] := Z[1];
Z[2] := X[3] xor Cast128_Key[0, Z[1] and $FF] xor
Cast128_Key[1, Z[1] shr 8 and $FF] xor
Cast128_Key[2, Z[1] shr 16 and $FF] xor
Cast128_Key[3, Z[1] shr 24] xor
Cast128_Key[0, X[2] shr 16 and $FF];
T[2] := Z[2];
Z[3] := X[1] xor Cast128_Key[0, Z[2] shr 8 and $FF] xor
Cast128_Key[1, Z[2] shr 16 and $FF] xor
Cast128_Key[2, Z[2] and $FF] xor
Cast128_Key[3, Z[2] shr 24] xor
Cast128_Key[1, X[2] and $FF];
T[3] := Z[3];
end
else
begin
X[0] := Z[2] xor Cast128_Key[0, Z[1] shr 16 and $FF] xor
Cast128_Key[1, Z[1] and $FF] xor
Cast128_Key[2, Z[1] shr 24] xor
Cast128_Key[3, Z[1] shr 8 and $FF] xor
Cast128_Key[2, Z[0] shr 24];
T[0] := X[0];
X[1] := Z[0] xor Cast128_Key[0, X[0] shr 24] xor
Cast128_Key[1, X[0] shr 8 and $FF] xor
Cast128_Key[2, X[0] shr 16 and $FF] xor
Cast128_Key[3, X[0] and $FF] xor
Cast128_Key[3, Z[0] shr 8 and $FF];
T[1] := X[1];
X[2] := Z[1] xor Cast128_Key[0, X[1] and $FF] xor
Cast128_Key[1, X[1] shr 8 and $FF] xor
Cast128_Key[2, X[1] shr 16 and $FF] xor
Cast128_Key[3, X[1] shr 24] xor
Cast128_Key[0, Z[0] shr 16 and $FF];
T[2] := X[2];
X[3] := Z[3] xor Cast128_Key[0, X[2] shr 8 and $FF] xor
Cast128_Key[1, X[2] shr 16 and $FF] xor
Cast128_Key[2, X[2] and $FF] xor
Cast128_Key[3, X[2] shr 24] xor
Cast128_Key[1, Z[0] and $FF];
T[3] := X[3];
end;
case I and 12 of
0,12:
begin
K[I + 0] := Cast128_Key[0, T[2] shr 24] xor
Cast128_Key[1, T[2] shr 16 and $FF] xor
Cast128_Key[2, T[1] and $FF] xor
Cast128_Key[3, T[1] shr 8 and $FF];
K[I + 1] := Cast128_Key[0, T[2] shr 8 and $FF] xor
Cast128_Key[1, T[2] and $FF] xor
Cast128_Key[2, T[1] shr 16 and $FF] xor
Cast128_Key[3, T[1] shr 24];
K[I + 2] := Cast128_Key[0, T[3] shr 24] xor
Cast128_Key[1, T[3] shr 16 and $FF] xor
Cast128_Key[2, T[0] and $FF] xor
Cast128_Key[3, T[0] shr 8 and $FF];
K[I + 3] := Cast128_Key[0, T[3] shr 8 and $FF] xor
Cast128_Key[1, T[3] and $FF] xor
Cast128_Key[2, T[0] shr 16 and $FF] xor
Cast128_Key[3, T[0] shr 24];
end;
4,8:
begin
K[I + 0] := Cast128_Key[0, T[0] and $FF] xor
Cast128_Key[1, T[0] shr 8 and $FF] xor
Cast128_Key[2, T[3] shr 24] xor
Cast128_Key[3, T[3] shr 16 and $FF];
K[I + 1] := Cast128_Key[0, T[0] shr 16 and $FF] xor
Cast128_Key[1, T[0] shr 24] xor
Cast128_Key[2, T[3] shr 8 and $FF] xor
Cast128_Key[3, T[3] and $FF];
K[I + 2] := Cast128_Key[0, T[1] and $FF] xor
Cast128_Key[1, T[1] shr 8 and $FF] xor
Cast128_Key[2, T[2] shr 24] xor
Cast128_Key[3, T[2] shr 16 and $FF];
K[I + 3] := Cast128_Key[0, T[1] shr 16 and $FF] xor
Cast128_Key[1, T[1] shr 24] xor
Cast128_Key[2, T[2] shr 8 and $FF] xor
Cast128_Key[3, T[2] and $FF];
end;
end;
case I and 12 of
0: begin
K[I + 0] := K[I + 0] xor Cast128_Key[0, Z[0] shr 8 and $FF];
K[I + 1] := K[I + 1] xor Cast128_Key[1, Z[1] shr 8 and $FF];
K[I + 2] := K[I + 2] xor Cast128_Key[2, Z[2] shr 16 and $FF];
K[I + 3] := K[I + 3] xor Cast128_Key[3, Z[3] shr 24];
end;
4: begin
K[I + 0] := K[I + 0] xor Cast128_Key[0, X[2] shr 24];
K[I + 1] := K[I + 1] xor Cast128_Key[1, X[3] shr 16 and $FF];
K[I + 2] := K[I + 2] xor Cast128_Key[2, X[0] and $FF];
K[I + 3] := K[I + 3] xor Cast128_Key[3, X[1] and $FF];
end;
8: begin
K[I + 0] := K[I + 0] xor Cast128_Key[0, Z[2] shr 16 and $FF];
K[I + 1] := K[I + 1] xor Cast128_Key[1, Z[3] shr 24];
K[I + 2] := K[I + 2] xor Cast128_Key[2, Z[0] shr 8 and $FF];
K[I + 3] := K[I + 3] xor Cast128_Key[3, Z[1] shr 8 and $FF];
end;
12: begin
K[I + 0] := K[I + 0] xor Cast128_Key[0, X[0] and $FF];
K[I + 1] := K[I + 1] xor Cast128_Key[1, X[1] and $FF];
K[I + 2] := K[I + 2] xor Cast128_Key[2, X[2] shr 24];
K[I + 3] := K[I + 3] xor Cast128_Key[3, X[3] shr 16 and $FF];
end;
end;
if I >= 16 then
begin
K[I + 0] := K[I + 0] and $1F;
K[I + 1] := K[I + 1] and $1F;
K[I + 2] := K[I + 2] and $1F;
K[I + 3] := K[I + 3] and $1F;
end;
Inc(I, 4);
end;
ProtectBuffer(X, SizeOf(X));
ProtectBuffer(Z, SizeOf(Z));
ProtectBuffer(T, SizeOf(T));
end;
procedure TCipher_Cast128.DoEncode(Source, Dest: Pointer; Size: Integer);
var
T, I, A, B: UInt32;
K: PUInt32Array;
begin
Assert(Size = Context.BlockSize);
K := FAdditionalBuffer;
A := SwapUInt32(PUInt32Array(Source)[0]);
B := SwapUInt32(PUInt32Array(Source)[1]);
for I := 0 to 2 do
begin
T := K[0] + B;
T := T shl K[16] or T shr (32 - K[16]);
A := A xor (Cast128_Data[0, T shr 24] xor
Cast128_Data[1, T shr 16 and $FF] -
Cast128_Data[2, T shr 8 and $FF] +
Cast128_Data[3, T and $FF]);
T := K[1] xor A;
T := T shl K[17] or T shr (32 - K[17]);
B := B xor (Cast128_Data[0, T shr 24] -
Cast128_Data[1, T shr 16 and $FF] +
Cast128_Data[2, T shr 8 and $FF] xor
Cast128_Data[3, T and $FF]);
T := K[2] - B;
T := T shl K[18] or T shr (32 - K[18]);
A := A xor (Cast128_Data[0, T shr 24] +
Cast128_Data[1, T shr 16 and $FF] xor
Cast128_Data[2, T shr 8 and $FF] -
Cast128_Data[3, T and $FF]);
T := K[3] + A;
T := T shl K[19] or T shr (32 - K[19]);
B := B xor (Cast128_Data[0, T shr 24] xor
Cast128_Data[1, T shr 16 and $FF] -
Cast128_Data[2, T shr 8 and $FF] +
Cast128_Data[3, T and $FF]);
if I = 2 then
Break;
T := K[4] xor B;
T := T shl K[20] or T shr (32 - K[20]);
A := A xor (Cast128_Data[0, T shr 24] -
Cast128_Data[1, T shr 16 and $FF] +
Cast128_Data[2, T shr 8 and $FF] xor
Cast128_Data[3, T and $FF]);
T := K[5] - A;
T := T shl K[21] or T shr (32 - K[21]);
B := B xor (Cast128_Data[0, T shr 24] +
Cast128_Data[1, T shr 16 and $FF] xor
Cast128_Data[2, T shr 8 and $FF] -
Cast128_Data[3, T and $FF]);
if (I = 1) and (FRounds <= 12) then
Break;
K := @K[6];
end;
PUInt32Array(Dest)[0] := SwapUInt32(B);
PUInt32Array(Dest)[1] := SwapUInt32(A);
end;
procedure TCipher_Cast128.DoDecode(Source, Dest: Pointer; Size: Integer);
var
T, I, A, B: UInt32;
K: PUInt32Array;
JumpStart: Boolean;
begin
Assert(Size = Context.BlockSize);
JumpStart := False;
K := @PUInt32Array(FAdditionalBuffer)[12];
B := SwapUInt32(PUInt32Array(Source)[0]);
A := SwapUInt32(PUInt32Array(Source)[1]);
I := 2;
if FRounds <= 12 then
Dec(PUInt32(K), 6)
else
JumpStart := True;
while I > 0 do
begin
if not JumpStart then
begin
Dec(I);
T := K[5] - A;
T := T shl K[21] or T shr (32 - K[21]);
B := B xor (Cast128_Data[0, T shr 24] +
Cast128_Data[1, T shr 16 and $FF] xor
Cast128_Data[2, T shr 8 and $FF] -
Cast128_Data[3, T and $FF]);
T := K[4] xor B;
T := T shl K[20] or T shr (32 - K[20]);
A := A xor (Cast128_Data[0, T shr 24] -
Cast128_Data[1, T shr 16 and $FF] +
Cast128_Data[2, T shr 8 and $FF] xor
Cast128_Data[3, T and $FF]);
end
else
JumpStart := False;
T := K[3] + A;
T := T shl K[19] or T shr (32 - K[19]);
B := B xor (Cast128_Data[0, T shr 24] xor
Cast128_Data[1, T shr 16 and $FF] -
Cast128_Data[2, T shr 8 and $FF] +
Cast128_Data[3, T and $FF]);
T := K[2] - B;
T := T shl K[18] or T shr (32 - K[18]);
A := A xor (Cast128_Data[0, T shr 24] +
Cast128_Data[1, T shr 16 and $FF] xor
Cast128_Data[2, T shr 8 and $FF] -
Cast128_Data[3, T and $FF]);
T := K[1] xor A;
T := T shl K[17] or T shr (32 - K[17]);
B := B xor (Cast128_Data[0, T shr 24] -
Cast128_Data[1, T shr 16 and $FF] +
Cast128_Data[2, T shr 8 and $FF] xor
Cast128_Data[3, T and $FF]);
T := K[0] + B;
T := T shl K[16] or T shr (32 - K[16]);
A := A xor (Cast128_Data[0, T shr 24] xor
Cast128_Data[1, T shr 16 and $FF] -
Cast128_Data[2, T shr 8 and $FF] +
Cast128_Data[3, T and $FF]);
Dec(PUInt32(K), 6);
end;
PUInt32Array(Dest)[0] := SwapUInt32(A);
PUInt32Array(Dest)[1] := SwapUInt32(B);
end;
{ TCipher_Gost }
class function TCipher_Gost.Context: TCipherContext;
begin
Result.KeySize := 32;
Result.BlockSize := 8;
Result.BufferSize := 8;
Result.AdditionalBufferSize := 32;
Result.NeedsAdditionalBufferBackup := false;
Result.MinRounds := 1;
Result.MaxRounds := 1;
Result.CipherType := [ctSymmetric, ctBlock];
end;
procedure TCipher_Gost.DoInit(const Key; Size: Integer);
begin
Move(Key, FAdditionalBuffer^, Size);
end;
procedure TCipher_Gost.DoEncode(Source, Dest: Pointer; Size: Integer);
var
I, A, B, T: UInt32;
K: PUInt32Array;
begin
Assert(Size = Context.BlockSize);
K := FAdditionalBuffer;
A := PUInt32Array(Source)[0];
B := PUInt32Array(Source)[1];
for I := 0 to 11 do
begin
if I and 3 = 0 then
K := FAdditionalBuffer;
T := A + K[0];
B := B xor Gost_Data[0, T and $FF] xor
Gost_Data[1, T shr 8 and $FF] xor
Gost_Data[2, T shr 16 and $FF] xor
Gost_Data[3, T shr 24 ];
T := B + K[1];
A := A xor Gost_Data[0, T and $FF] xor
Gost_Data[1, T shr 8 and $FF] xor
Gost_Data[2, T shr 16 and $FF] xor
Gost_Data[3, T shr 24 ];
K := @K[2];
end;
K := @PUInt32Array(FAdditionalBuffer)[6];
for I := 0 to 3 do
begin
T := A + K[1];
B := B xor Gost_Data[0, T and $FF] xor
Gost_Data[1, T shr 8 and $FF] xor
Gost_Data[2, T shr 16 and $FF] xor
Gost_Data[3, T shr 24 ];
T := B + K[0];
A := A xor Gost_Data[0, T and $FF] xor
Gost_Data[1, T shr 8 and $FF] xor
Gost_Data[2, T shr 16 and $FF] xor
Gost_Data[3, T shr 24 ];
Dec(PUInt32(K), 2);
end;
PUInt32Array(Dest)[0] := B;
PUInt32Array(Dest)[1] := A;
end;
procedure TCipher_Gost.DoDecode(Source, Dest: Pointer; Size: Integer);
var
I, A, B, T: UInt32;
K: PUInt32Array;
begin
Assert(Size = Context.BlockSize);
A := PUInt32Array(Source)[0];
B := PUInt32Array(Source)[1];
K := FAdditionalBuffer;
for I := 0 to 3 do
begin
T := A + K[0];
B := B xor Gost_Data[0, T and $FF] xor
Gost_Data[1, T shr 8 and $FF] xor
Gost_Data[2, T shr 16 and $FF] xor
Gost_Data[3, T shr 24];
T := B + K[1];
A := A xor Gost_Data[0, T and $FF] xor
Gost_Data[1, T shr 8 and $FF] xor
Gost_Data[2, T shr 16 and $FF] xor
Gost_Data[3, T shr 24];
K := @K[2];
end;
for I := 0 to 11 do
begin
if I and 3 = 0 then
K := @PUInt32Array(FAdditionalBuffer)[6];
T := A + K[1];
B := B xor Gost_Data[0, T and $FF] xor
Gost_Data[1, T shr 8 and $FF] xor
Gost_Data[2, T shr 16 and $FF] xor
Gost_Data[3, T shr 24];
T := B + K[0];
A := A xor Gost_Data[0, T and $FF] xor
Gost_Data[1, T shr 8 and $FF] xor
Gost_Data[2, T shr 16 and $FF] xor
Gost_Data[3, T shr 24];
Dec(PUInt32(K), 2);
end;
PUInt32Array(Dest)[0] := B;
PUInt32Array(Dest)[1] := A;
end;
{ TCipher_Misty }
class function TCipher_Misty.Context: TCipherContext;
begin
Result.KeySize := 16;
Result.BlockSize := 8;
Result.BufferSize := 8;
Result.AdditionalBufferSize := 128;
Result.NeedsAdditionalBufferBackup := False;
Result.MinRounds := 1;
Result.MaxRounds := 1;
Result.CipherType := [ctSymmetric, ctBlock];
end;
function Misty_I(Value, Key: UInt32): UInt32;
begin
Result := Misty_Data9[Value shr 7 and $1FF] xor (Value and $7F);
Value := (Misty_Data7[Value and $7F] xor Result and $7F) xor (Key shr 9 and $7F);
Result := Misty_Data9[Result xor (Key and $1FF)] xor Value or Value shl 9;
end;
function Misty_O(Value, K: UInt32; Key: PUInt32Array): UInt32;
begin
Result := Misty_I((Value shr 16) xor Key[K], Key[(K + 5) and 7 + 8]) xor (Value and $FFFF);
Value := Misty_I((Value and $FFFF) xor Key[(K + 2) and 7], Key[(K + 1) and 7 + 8]) xor Result;
Result := Misty_I(Result xor Key[(K + 7) and 7], Key[(K + 3) and 7 + 8]) xor Value;
Result := Result or (Value xor Key[(K + 4) and 7]) shl 16;
end;
function Misty_E(Value, K: UInt32; Key: PUInt32Array): UInt32;
begin
Result := Value shr 16;
Value := Value and $FFFF;
if K and 1 <> 0 then
begin
K := K shr 1;
Value := Value xor (Result and Key[(K + 2) and 7 + 8]);
Result := Result xor (Value or Key[(K + 4) and 7]);
end
else
begin
K := K shr 1;
Value := Value xor (Result and Key[K]);
Result := Result xor (Value or Key[(K + 6) and 7 + 8]);
end;
Result:= (Result shl 16) or Value;
end;
function Misty_D(Value, K: UInt32; Key: PUInt32Array): UInt32;
begin
Result := Value shr 16;
Value := Value and $FFFF;
if K and 1 <> 0 then
begin
K := K shr 1;
Result := Result xor (Value or Key[(K + 4) and 7]);
Value := Value xor (Result and Key[(K + 2) and 7 + 8]);
end
else
begin
K := K shr 1;
Result := Result xor (Value or Key[(K + 6) and 7 + 8]);
Value := Value xor (Result and Key[K]);
end;
Result:= (Result shl 16) or Value;
end;
procedure TCipher_Misty.DoInit(const Key; Size: Integer);
var
K: array[0..15] of Byte;
D: PUInt32Array;
I: Integer;
begin
FillChar(K, SizeOf(K), 0);
Move(Key, K, Size);
D := FAdditionalBuffer;
for I := 0 to 7 do
D[I] := K[I * 2] * 256 + K[I * 2 + 1];
for I := 0 to 7 do
begin
D[I + 8] := Misty_I(D[I], D[(I + 1) and 7]);
D[I + 16] := D[I + 8] and $1FF;
D[I + 24] := D[I + 8] shr 9;
end;
ProtectBuffer(K, SizeOf(K));
end;
procedure TCipher_Misty.DoEncode(Source, Dest: Pointer; Size: Integer);
var
A, B: UInt32;
begin
Assert(Size = Context.BlockSize);
A := PUInt32Array(Source)[0];
B := PUInt32Array(Source)[1];
A := Misty_E(A, 0, FAdditionalBuffer);
B := Misty_E(B, 1, FAdditionalBuffer) xor Misty_O(A, 0, FAdditionalBuffer);
A := A xor Misty_O(B, 1, FAdditionalBuffer);
A := Misty_E(A, 2, FAdditionalBuffer);
B := Misty_E(B, 3, FAdditionalBuffer) xor Misty_O(A, 2, FAdditionalBuffer);
A := A xor Misty_O(B, 3, FAdditionalBuffer);
A := Misty_E(A, 4, FAdditionalBuffer);
B := Misty_E(B, 5, FAdditionalBuffer) xor Misty_O(A, 4, FAdditionalBuffer);
A := A xor Misty_O(B, 5, FAdditionalBuffer);
A := Misty_E(A, 6, FAdditionalBuffer);
B := Misty_E(B, 7, FAdditionalBuffer) xor Misty_O(A, 6, FAdditionalBuffer);
A := A xor Misty_O(B, 7, FAdditionalBuffer);
PUInt32Array(Dest)[0] := Misty_E(B, 9, FAdditionalBuffer);
PUInt32Array(Dest)[1] := Misty_E(A, 8, FAdditionalBuffer);
end;
procedure TCipher_Misty.DoDecode(Source, Dest: Pointer; Size: Integer);
var
A, B: UInt32;
begin
Assert(Size = Context.BlockSize);
B := Misty_D(PUInt32Array(Source)[0], 9, FAdditionalBuffer);
A := Misty_D(PUInt32Array(Source)[1], 8, FAdditionalBuffer);
A := A xor Misty_O(B, 7, FAdditionalBuffer);
B := Misty_D(B xor Misty_O(A, 6, FAdditionalBuffer), 7, FAdditionalBuffer);
A := Misty_D(A, 6, FAdditionalBuffer);
A := A xor Misty_O(B, 5, FAdditionalBuffer);
B := Misty_D(B xor Misty_O(A, 4, FAdditionalBuffer), 5, FAdditionalBuffer);
A := Misty_D(A, 4, FAdditionalBuffer);
A := A xor Misty_O(B, 3, FAdditionalBuffer);
B := Misty_D(B xor Misty_O(A, 2, FAdditionalBuffer), 3, FAdditionalBuffer);
A := Misty_D(A, 2, FAdditionalBuffer);
A := A xor Misty_O(B, 1, FAdditionalBuffer);
PUInt32Array(Dest)[0] := Misty_D(A, 0, FAdditionalBuffer);
PUInt32Array(Dest)[1] := Misty_D(B xor Misty_O(A, 0, FAdditionalBuffer), 1, FAdditionalBuffer);
end;
{ TCipher_NewDES }
procedure NewDES_Func(Source, Dest, Key: PByteArray);
var
I: Integer;
A, B, C, D, E, F, G, H: Byte;
begin
A := Source[0];
B := Source[1];
C := Source[2];
D := Source[3];
E := Source[4];
F := Source[5];
G := Source[6];
H := Source[7];
for I := 0 to 7 do
begin
E := E xor NewDES_Data[A xor Key[0]];
F := F xor NewDES_Data[B xor Key[1]];
G := G xor NewDES_Data[C xor Key[2]];
H := H xor NewDES_Data[D xor Key[3]];
B := B xor NewDES_Data[E xor Key[4]];
C := C xor NewDES_Data[F xor E];
D := D xor NewDES_Data[G xor Key[5]];
A := A xor NewDES_Data[H xor Key[6]];
Key := @Key[7];
end;
E := E xor NewDES_Data[A xor Key[0]];
F := F xor NewDES_Data[B xor Key[1]];
G := G xor NewDES_Data[C xor Key[2]];
H := H xor NewDES_Data[D xor Key[3]];
Dest[0] := A;
Dest[1] := B;
Dest[2] := C;
Dest[3] := D;
Dest[4] := E;
Dest[5] := F;
Dest[6] := G;
Dest[7] := H;
end;
class function TCipher_NewDES.Context: TCipherContext;
begin
Result.KeySize := 15;
Result.BlockSize := 8;
Result.BufferSize := 8;
Result.AdditionalBufferSize := 60 * 2;
Result.NeedsAdditionalBufferBackup := true;
Result.MinRounds := 1;
Result.MaxRounds := 1;
Result.CipherType := [ctSymmetric, ctBlock];
end;
procedure TCipher_NewDES.DoInit(const Key; Size: Integer);
var
K: array[0..14] of Byte;
E: PByteArray;
I: Integer;
begin
FillChar(K, SizeOf(K), 0);
Move(Key, K, Size);
E := FAdditionalBuffer;
Move(K, E[ 0], 15);
Move(K, E[15], 15);
Move(K, E[30], 15);
Move(K, E[45], 15);
E := @E[60];
I := 11;
repeat
E[0] := K[I]; I := (I + 1) mod 15;
E[1] := K[I]; I := (I + 1) mod 15;
E[2] := K[I]; I := (I + 1) mod 15;
E[3] := K[I]; I := (I + 9) mod 15;
if I = 12 then
Break;
E[4] := K[I]; Inc(I);
E[5] := K[I]; Inc(I);
E[6] := K[I]; I := (I + 9) mod 15;
E := @E[7];
until False;
ProtectBuffer(K, SizeOf(K));
end;
procedure TCipher_NewDES.DoEncode(Source, Dest: Pointer; Size: Integer);
begin
Assert(Size = Context.BlockSize);
NewDES_Func(Source, Dest, FAdditionalBuffer);
end;
procedure TCipher_NewDES.DoDecode(Source, Dest: Pointer; Size: Integer);
begin
Assert(Size = Context.BlockSize);
NewDES_Func(Source, Dest, @PByteArray(FAdditionalBuffer)[60]);
end;
{ TCipher_Q128 }
class function TCipher_Q128.Context: TCipherContext;
begin
Result.KeySize := 16;
Result.BlockSize := 16;
Result.BufferSize := 16;
Result.AdditionalBufferSize := 256;
Result.NeedsAdditionalBufferBackup := false;
Result.MinRounds := 1;
Result.MaxRounds := 1;
Result.CipherType := [ctSymmetric, ctBlock];
end;
procedure TCipher_Q128.DoInit(const Key; Size: Integer);
var
K: array[0..3] of UInt32;
D: PUInt32Array;
I: Integer;
begin
FillChar(K, SizeOf(K), 0);
Move(Key, K, Size);
D := FAdditionalBuffer;
for I := 19 downto 1 do
begin
K[1] := K[1] xor Q128_Data[K[0] and $03FF]; K[0] := K[0] shr 10 or K[0] shl 22;
K[2] := K[2] xor Q128_Data[K[1] and $03FF]; K[1] := K[1] shr 10 or K[1] shl 22;
K[3] := K[3] xor Q128_Data[K[2] and $03FF]; K[2] := K[2] shr 10 or K[2] shl 22;
K[0] := K[0] xor Q128_Data[K[3] and $03FF]; K[3] := K[3] shr 10 or K[3] shl 22;
if I <= 16 then
begin
D[0] := K[0];
D[1] := K[1];
D[2] := K[2];
D[3] := K[3];
D := @D[4];
end;
end;
ProtectBuffer(K, SizeOf(K));
end;
procedure TCipher_Q128.DoEncode(Source, Dest: Pointer; Size: Integer);
{$IFDEF X86ASM}
asm
PUSH ESI
PUSH EDI
PUSH EBX
PUSH EBP
PUSH ECX
MOV EDI,[EAX].TCipher_Q128.FAdditionalBuffer
MOV EAX,[EDX + 0] // B0
MOV EBX,[EDX + 4] // B1
MOV ECX,[EDX + 8] // B2
MOV EDX,[EDX + 12] // B3
MOV EBP,16
@@1: MOV ESI,EAX
ROL ESI,10
AND EAX,03FFh
MOV EAX,[EAX * 4 + OFFSET Q128_DATA]
ADD EAX,[EDI + 0]
XOR EAX,EBX
MOV EBX,EAX
ROL EBX,10
AND EAX,03FFh
MOV EAX,[EAX * 4 + OFFSET Q128_DATA]
ADD EAX,[EDI + 4]
XOR EAX,ECX
MOV ECX,EAX
ROL ECX,10
AND EAX,03FFh
MOV EAX,[EAX * 4 + OFFSET Q128_DATA]
ADD EAX,[EDI + 8]
XOR EAX,EDX
MOV EDX,EAX
ROL EDX,10
AND EAX,03FFh
MOV EAX,[EAX * 4 + OFFSET Q128_DATA]
ADD EAX,[EDI + 12]
XOR EAX,ESI
DEC EBP
LEA EDI,[EDI + 16]
JNZ @@1
POP ESI
MOV [ESI + 0],EAX // B0
MOV [ESI + 4],EBX // B1
MOV [ESI + 8],ECX // B2
MOV [ESI + 12],EDX // B3
POP EBP
POP EBX
POP EDI
POP ESI
end;
{$ELSE !X86ASM}
var
D: PUInt32Array;
B0, B1, B2, B3, I: UInt32;
begin
Assert(Size = Context.BlockSize);
D := Pointer(FAdditionalBuffer);
B0 := PUInt32Array(Source)[0];
B1 := PUInt32Array(Source)[1];
B2 := PUInt32Array(Source)[2];
B3 := PUInt32Array(Source)[3];
for I := 0 to 15 do
begin
B1 := B1 xor (Q128_Data[B0 and $03FF] + D[0]); B0 := B0 shl 10 or B0 shr 22;
B2 := B2 xor (Q128_Data[B1 and $03FF] + D[1]); B1 := B1 shl 10 or B1 shr 22;
B3 := B3 xor (Q128_Data[B2 and $03FF] + D[2]); B2 := B2 shl 10 or B2 shr 22;
B0 := B0 xor (Q128_Data[B3 and $03FF] + D[3]); B3 := B3 shl 10 or B3 shr 22;
D := @D[4];
end;
PUInt32Array(Dest)[0] := B0;
PUInt32Array(Dest)[1] := B1;
PUInt32Array(Dest)[2] := B2;
PUInt32Array(Dest)[3] := B3;
end;
{$ENDIF !X86ASM}
procedure TCipher_Q128.DoDecode(Source, Dest: Pointer; Size: Integer);
{$IFDEF X86ASM}
asm
PUSH ESI
PUSH EDI
PUSH EBX
PUSH EBP
PUSH ECX
MOV EDI,[EAX].TCipher_Q128.FAdditionalBuffer
LEA EDI,[EDI + 64 * 4]
MOV ESI,[EDX + 0] // B0
MOV EBX,[EDX + 4] // B1
MOV ECX,[EDX + 8] // B2
MOV EDX,[EDX + 12] // B3
MOV EBP,16
@@1: SUB EDI,16
ROR EDX,10
MOV EAX,EDX
AND EAX,03FFh
MOV EAX,[EAX * 4 + OFFSET Q128_DATA]
ADD EAX,[EDI + 12]
XOR ESI,EAX
ROR ECX,10
MOV EAX,ECX
AND EAX,03FFh
MOV EAX,[EAX * 4 + OFFSET Q128_DATA]
ADD EAX,[EDI + 8]
XOR EDX,EAX
ROR EBX,10
MOV EAX,EBX
AND EAX,03FFh
MOV EAX,[EAX * 4 + OFFSET Q128_DATA]
ADD EAX,[EDI + 4]
XOR ECX,EAX
ROR ESI,10
MOV EAX,ESI
AND EAX,03FFh
MOV EAX,[EAX * 4 + OFFSET Q128_DATA]
ADD EAX,[EDI]
XOR EBX,EAX
DEC EBP
JNZ @@1
POP EAX
MOV [EAX + 0],ESI // B0
MOV [EAX + 4],EBX // B1
MOV [EAX + 8],ECX // B2
MOV [EAX + 12],EDX // B3
POP EBP
POP EBX
POP EDI
POP ESI
end;
{$ELSE !X86ASM}
var
D: PUInt32Array;
B0, B1, B2, B3, I: UInt32;
begin
Assert(Size = Context.BlockSize);
D := @PUInt32Array(FAdditionalBuffer)[60];
B0 := PUInt32Array(Source)[0];
B1 := PUInt32Array(Source)[1];
B2 := PUInt32Array(Source)[2];
B3 := PUInt32Array(Source)[3];
for I := 0 to 15 do
begin
B3 := B3 shr 10 or B3 shl 22; B0 := B0 xor (Q128_Data[B3 and $03FF] + D[3]);
B2 := B2 shr 10 or B2 shl 22; B3 := B3 xor (Q128_Data[B2 and $03FF] + D[2]);
B1 := B1 shr 10 or B1 shl 22; B2 := B2 xor (Q128_Data[B1 and $03FF] + D[1]);
B0 := B0 shr 10 or B0 shl 22; B1 := B1 xor (Q128_Data[B0 and $03FF] + D[0]);
Dec(PUInt32(D), 4);
end;
PUInt32Array(Dest)[0] := B0;
PUInt32Array(Dest)[1] := B1;
PUInt32Array(Dest)[2] := B2;
PUInt32Array(Dest)[3] := B3;
end;
{$ENDIF !X86ASM}
{ TCipher_RC2 }
class function TCipher_RC2.Context: TCipherContext;
begin
Result.KeySize := 128;
Result.BlockSize := 8;
Result.BufferSize := 8;
Result.AdditionalBufferSize := 128;
Result.NeedsAdditionalBufferBackup := False;
Result.MinRounds := 1;
Result.MaxRounds := 1;
Result.CipherType := [ctSymmetric, ctBlock];
end;
procedure TCipher_RC2.DoInit(const Key; Size: Integer);
// New keyscheduling according to RFC2268 and it's testcases. The V3 keysetup
// was using an older, inferior version. Special thanks to Brendan Bosnan for
// pointing that out.
var
I, L, Mask, KeyEffectiveBits: Integer;
K: PByteArray;
begin
if Size <= 0 then
Exit;
KeyEffectiveBits := Size * 8;
L := KeyEffectiveBits and 7;
if L = 0 then
Mask := $FF
else
Mask := $FF shr (8 - L);
L := (KeyEffectiveBits + 7) shr 3;
K := FAdditionalBuffer;
Move(Key, K[0], Size);
for I := Size to 127 do
K[I] := RC2_Data[(K[I - Size] + K[I - 1]) and $FF];
K[128 - L] := RC2_Data[K[128 - L] and Mask];
for I := 127 - L downto 0 do
K[I] := RC2_Data[K[I + 1] xor K[I + L]];
end;
procedure TCipher_RC2.DoEncode(Source, Dest: Pointer; Size: Integer);
var
I: Integer;
K: PWordArray;
A, B, C, D: Word;
begin
Assert(Size = Context.BlockSize);
K := FAdditionalBuffer;
A := PWordArray(Source)[0];
B := PWordArray(Source)[1];
C := PWordArray(Source)[2];
D := PWordArray(Source)[3];
for I := 0 to 15 do
begin
Inc(A, (B and not D) + (C and D) + K[I * 4 + 0]); A := A shl 1 or A shr 15;
Inc(B, (C and not A) + (D and A) + K[I * 4 + 1]); B := B shl 2 or B shr 14;
Inc(C, (D and not B) + (A and B) + K[I * 4 + 2]); C := C shl 3 or C shr 13;
Inc(D, (A and not C) + (B and C) + K[I * 4 + 3]); D := D shl 5 or D shr 11;
if I in [4, 10] then
begin
Inc(A, K[D and $3F]);
Inc(B, K[A and $3F]);
Inc(C, K[B and $3F]);
Inc(D, K[C and $3F]);
end;
end;
PWordArray(Dest)[0] := A;
PWordArray(Dest)[1] := B;
PWordArray(Dest)[2] := C;
PWordArray(Dest)[3] := D;
end;
procedure TCipher_RC2.DoDecode(Source, Dest: Pointer; Size: Integer);
var
I: Integer;
K: PWordArray;
A, B, C, D: Word;
begin
Assert(Size = Context.BlockSize);
K := FAdditionalBuffer;
A := PWordArray(Source)[0];
B := PWordArray(Source)[1];
C := PWordArray(Source)[2];
D := PWordArray(Source)[3];
for I := 15 downto 0 do
begin
D := D shr 5 or D shl 11 - (A and not C) - (B and C) - K[I * 4 + 3];
C := C shr 3 or C shl 13 - (D and not B) - (A and B) - K[I * 4 + 2];
B := B shr 2 or B shl 14 - (C and not A) - (D and A) - K[I * 4 + 1];
A := A shr 1 or A shl 15 - (B and not D) - (C and D) - K[I * 4 + 0];
if I in [5, 11] then
begin
Dec(D, K[C and $3F]);
Dec(C, K[B and $3F]);
Dec(B, K[A and $3F]);
Dec(A, K[D and $3F]);
end;
end;
PWordArray(Dest)[0] := A;
PWordArray(Dest)[1] := B;
PWordArray(Dest)[2] := C;
PWordArray(Dest)[3] := D;
end;
{ TCipher_RC5 }
class function TCipher_RC5.Context: TCipherContext;
begin
Result.KeySize := 256;
Result.BlockSize := 8;
Result.BufferSize := 8;
Result.AdditionalBufferSize := 136;
Result.NeedsAdditionalBufferBackup := false;
Result.MinRounds := 1;
Result.MaxRounds := 256;
Result.CipherType := [ctSymmetric, ctBlock];
end;
procedure TCipher_RC5.SetRounds(Value: Integer);
begin
if Value <> FRounds then
begin
if not (FState in [csNew, csInitialized, csDone]) then
Done;
if Value <= 0 then
Value := 12;
FRounds := Value;
end;
end;
procedure TCipher_RC5.DoInit(const Key; Size: Integer);
var
K: array[0..63] of UInt32;
L, Z, I, J: Integer;
D: PUInt32Array;
A, B, T: UInt32;
begin
if FRounds <= 0 then
FRounds := 12;
FillChar(K, SizeOf(K), 0);
Move(Key, K, Size);
D := FAdditionalBuffer;
L := (Size + 3) shr 2;
if L <= 0 then
L := 1;
T := $B7E15163;
for I := 0 to (FRounds + 1) * 2 do
begin
D[I] := T;
Inc(T, $9E3779B9);
end;
if L > (FRounds + 1) * 2 then
Z := L * 3
else
Z := (FRounds + 1) * 6;
I := 0;
J := 0;
A := 0;
B := 0;
for Z := Z downto 1 do
begin
A := D[I] + A + B;
A := A shl 3 or A shr 29;
D[I] := A;
T := A + B;
B := K[J] + T;
B := B shl T or B shr (32 - T);
K[J] := B;
I := (I + 1) mod ((FRounds + 1) * 2);
J := (J + 1) mod L;
end;
ProtectBuffer(K, SizeOf(K));
end;
procedure TCipher_RC5.DoEncode(Source, Dest: Pointer; Size: Integer);
var
K: PUInt32Array;
I: Integer;
A, B: UInt32;
begin
Assert(Size = Context.BlockSize);
K := FAdditionalBuffer;
A := PUInt32Array(Source)[0] + K[0];
B := PUInt32Array(Source)[1] + K[1];
for I := 1 to FRounds do
begin
A := A xor B; A := A shl B or A shr (32 - B) + K[I * 2 + 0];
B := B xor A; B := B shl A or B shr (32 - A) + K[I * 2 + 1];
end;
PUInt32Array(Dest)[0] := A;
PUInt32Array(Dest)[1] := B;
end;
procedure TCipher_RC5.DoDecode(Source, Dest: Pointer; Size: Integer);
var
K: PUInt32Array;
I: Integer;
A, B: UInt32;
begin
Assert(Size = Context.BlockSize);
K := @PUInt32Array(FAdditionalBuffer)[0];
A := PUInt32Array(Source)[0];
B := PUInt32Array(Source)[1];
for I := FRounds downto 1 do
begin
B := B - K[I * 2 + 1]; B := B shr A or B shl (32 - A) xor A;
A := A - K[I * 2 + 0]; A := A shr B or A shl (32 - B) xor B;
end;
PUInt32Array(Dest)[0] := A - K[0];
PUInt32Array(Dest)[1] := B - K[1];
end;
{ TCipher_SAFER }
class function TCipher_SAFER.Context: TCipherContext;
begin
Result.KeySize := 16;
Result.BlockSize := 8;
Result.BufferSize := 8;
Result.AdditionalBufferSize := 768;
Result.NeedsAdditionalBufferBackup := false;
Result.MinRounds := 4;
Result.MaxRounds := 13;
Result.CipherType := [ctSymmetric, ctBlock];
end;
procedure TCipher_SAFER.SetRounds(Value: Integer);
begin
if not (FState in [csNew, csInitialized, csDone]) then
Done;
if (Value < 4) or (Value > 13) then
case FVersion of // Default Rounds
svK40, svSK40: Value := 5;
svK64, svSK64: Value := 6;
svK128, svSK128: Value := 10;
else
Value := 8;
end;
FRounds := Value;
end;
procedure TCipher_SAFER.SetVersion(Value: TSAFERVersion);
begin
if Value <> FVersion then
begin
if not (FState in [csNew, csInitialized, csDone]) then
Done;
FVersion := Value;
SetRounds(0);
end;
end;
procedure TCipher_SAFER.DoInit(const Key; Size: Integer);
procedure InitTab;
var
I, E: Integer;
Exp: PByteArray;
Log: PByteArray;
begin
Exp := FAdditionalBuffer;
Log := @Exp[256];
E := 1;
for I := 0 to 255 do
begin
Exp[I] := E and $FF;
Log[E and $FF] := I;
E := (E * 45) mod 257;
end;
end;
procedure InitKey;
var
D: PByte;
Exp: PByteArray;
Strong: Boolean;
K: array[Boolean, 0..8] of Byte;
I, J: Integer;
begin
Strong := FVersion in [svSK40, svSK64, svSK128];
Exp := FAdditionalBuffer;
D := @Exp[512];
FillChar(K, SizeOf(K), 0);
// Setup Key A
I := Size;
if I > 8 then
I := 8;
Move(Key, K[False], I);
// Setup the Key for K-40, SK-40
if FVersion in [svK40, svSK40] then
begin
K[False, 5] := K[False, 0] xor K[False, 2] xor 129;
K[False, 6] := K[False, 0] xor K[False, 3] xor K[False, 4] xor 66;
K[False, 7] := K[False, 1] xor K[False, 2] xor K[False, 4] xor 36;
K[False, 8] := K[False, 1] xor K[False, 3] xor 24;
Move(K[False], K[True], SizeOf(K[False]));
end
else
begin
if Size > 8 then
begin
I := Size - 8;
if I > 8 then
I := 8;
Move(TByteArray(Key)[8], K[True], I);
end
else
Move(K[False], K[True], 9);
for I := 0 to 7 do
begin
K[False, 8] := K[False, 8] xor K[False, I];
K[True, 8] := K[True, 8] xor K[True, I];
end;
end;
// Setup the KeyData
Move(K[True], D^, 8);
Inc(D, 8);
for I := 0 to 8 do
K[False, I] := K[False, I] shr 3 or K[False, I] shl 5;
for I := 1 to FRounds do
begin
for J := 0 to 8 do
begin
K[False, J] := K[False, J] shl 6 or K[False, J] shr 2;
K[True, J] := K[True, J] shl 6 or K[True, J] shr 2;
end;
for J := 0 to 7 do
begin
if Strong then
D^ := K[False, (J + I * 2 - 1) mod 9] + Exp[Exp[18 * I + J + 1]]
else
D^ := K[False, J] + Exp[Exp[18 * I + J + 1]];
Inc(D);
end;
for J := 0 to 7 do
begin
if Strong then
D^ := K[True, (J + I * 2) mod 9] + Exp[Exp[18 * I + J + 10]]
else
D^ := K[True, J] + Exp[Exp[18 * I + J + 10]];
Inc(D);
end;
end;
ProtectBuffer(K, SizeOf(K));
end;
begin
if (FRounds < 4) or (FRounds > 13) then
case FVersion of
svK40, svSK40: FRounds := 5;
svK64, svSK64: FRounds := 6;
svK128, svSK128: FRounds := 10;
else
FRounds := 8;
end;
InitTab;
InitKey;
end;
procedure TCipher_SAFER.DoEncode(Source, Dest: Pointer; Size: Integer);
var
Exp, Log, Key: PByteArray;
I: Integer;
A, B, C, D, E, F, G, H, T: Byte;
begin
Assert(Size = Context.BlockSize);
Exp := FAdditionalBuffer;
Log := @Exp[256];
Key := @Exp[512];
A := PByteArray(Source)[0];
B := PByteArray(Source)[1];
C := PByteArray(Source)[2];
D := PByteArray(Source)[3];
E := PByteArray(Source)[4];
F := PByteArray(Source)[5];
G := PByteArray(Source)[6];
H := PByteArray(Source)[7];
for I := 0 to FRounds - 1 do
begin
A := A xor Key[0];
B := B + Key[1];
C := C + Key[2];
D := D xor Key[3];
E := E xor Key[4];
F := F + Key[5];
G := G + Key[6];
H := H xor Key[7];
A := Exp[A] + Key[8];
B := Log[B] xor Key[9];
C := Log[C] xor Key[10];
D := Exp[D] + Key[11];
E := Exp[E] + Key[12];
F := Log[F] xor Key[13];
G := Log[G] xor Key[14];
H := Exp[H] + Key[15];
Inc(B, A); Inc(A, B);
Inc(D, C); Inc(C, D);
Inc(F, E); Inc(E, F);
Inc(H, G); Inc(G, H);
Inc(C, A); Inc(A, C);
Inc(G, E); Inc(E, G);
Inc(D, B); Inc(B, D);
Inc(H, F); Inc(F, H);
Inc(E, A); Inc(A, E);
Inc(F, B); Inc(B, F);
Inc(G, C); Inc(C, G);
Inc(H, D); Inc(D, H);
T := B; B := E; E := C; C := T;
T := D; D := F; F := G; G := T;
Key := @Key[16];
end;
PByteArray(Dest)[0] := A xor Key[0];
PByteArray(Dest)[1] := B + Key[1];
PByteArray(Dest)[2] := C + Key[2];
PByteArray(Dest)[3] := D xor Key[3];
PByteArray(Dest)[4] := E xor Key[4];
PByteArray(Dest)[5] := F + Key[5];
PByteArray(Dest)[6] := G + Key[6];
PByteArray(Dest)[7] := H xor Key[7];
end;
procedure TCipher_SAFER.DoDecode(Source, Dest: Pointer; Size: Integer);
var
Exp, Log, Key: PByteArray;
I: Integer;
A, B, C, D, E, F, G, H, T: Byte;
begin
Assert(Size = Context.BlockSize);
Exp := FAdditionalBuffer;
Log := @Exp[256];
Key := @Exp[504 + 8 * (FRounds * 2 + 1)];
A := PByteArray(Source)[0] xor Key[0];
B := PByteArray(Source)[1] - Key[1];
C := PByteArray(Source)[2] - Key[2];
D := PByteArray(Source)[3] xor Key[3];
E := PByteArray(Source)[4] xor Key[4];
F := PByteArray(Source)[5] - Key[5];
G := PByteArray(Source)[6] - Key[6];
H := PByteArray(Source)[7] xor Key[7];
for I := 0 to FRounds - 1 do
begin
Dec(PByte(Key), 16);
T := E; E := B; B := C; C := T;
T := F; F := D; D := G; G := T;
Dec(A, E); Dec(E, A);
Dec(B, F); Dec(F, B);
Dec(C, G); Dec(G, C);
Dec(D, H); Dec(H, D);
Dec(A, C); Dec(C, A);
Dec(E, G); Dec(G, E);
Dec(B, D); Dec(D, B);
Dec(F, H); Dec(H, F);
Dec(A, B); Dec(B, A);
Dec(C, D); Dec(D, C);
Dec(E, F); Dec(F, E);
Dec(G, H); Dec(H, G);
H := H - Key[15];
G := G xor Key[14];
F := F xor Key[13];
E := E - Key[12];
D := D - Key[11];
C := C xor Key[10];
B := B xor Key[9];
A := A - Key[8];
H := Log[H] xor Key[7];
G := Exp[G] - Key[6];
F := Exp[F] - Key[5];
E := Log[E] xor Key[4];
D := Log[D] xor Key[3];
C := Exp[C] - Key[2];
B := Exp[B] - Key[1];
A := Log[A] xor Key[0];
end;
PByteArray(Dest)[0] := A;
PByteArray(Dest)[1] := B;
PByteArray(Dest)[2] := C;
PByteArray(Dest)[3] := D;
PByteArray(Dest)[4] := E;
PByteArray(Dest)[5] := F;
PByteArray(Dest)[6] := G;
PByteArray(Dest)[7] := H;
end;
{ TCipher_SharkBase }
{$IFNDEF CPU64BITS}
function TCipher_SharkBase.Shark(D: TLong64; K: PLong64): TLong64;
var
R, T: Integer;
begin
for R := 0 to 4 do
begin
D.L := D.L xor K.L;
D.R := D.R xor K.R;
Inc(K);
T := Shark_CE[0, D.R shr 23 and $1FE] xor
Shark_CE[1, D.R shr 15 and $1FE] xor
Shark_CE[2, D.R shr 7 and $1FE] xor
Shark_CE[3, D.R shl 1 and $1FE] xor
Shark_CE[4, D.L shr 23 and $1FE] xor
Shark_CE[5, D.L shr 15 and $1FE] xor
Shark_CE[6, D.L shr 7 and $1FE] xor
Shark_CE[7, D.L shl 1 and $1FE];
D.R := Shark_CE[0, D.R shr 23 and $1FE or 1] xor
Shark_CE[1, D.R shr 15 and $1FE or 1] xor
Shark_CE[2, D.R shr 7 and $1FE or 1] xor
Shark_CE[3, D.R shl 1 and $1FE or 1] xor
Shark_CE[4, D.L shr 23 and $1FE or 1] xor
Shark_CE[5, D.L shr 15 and $1FE or 1] xor
Shark_CE[6, D.L shr 7 and $1FE or 1] xor
Shark_CE[7, D.L shl 1 and $1FE or 1];
D.L := T;
end;
D.L := D.L xor K.L;
D.R := D.R xor K.R;
Inc(K);
D.L := UInt32(Shark_SE[D.L shr 24 and $FF]) shl 24 xor
UInt32(Shark_SE[D.L shr 16 and $FF]) shl 16 xor
UInt32(Shark_SE[D.L shr 8 and $FF]) shl 8 xor
UInt32(Shark_SE[D.L and $FF]);
D.R := UInt32(Shark_SE[D.R shr 24 and $FF]) shl 24 xor
UInt32(Shark_SE[D.R shr 16 and $FF]) shl 16 xor
UInt32(Shark_SE[D.R shr 8 and $FF]) shl 8 xor
UInt32(Shark_SE[D.R and $FF]);
Result.L := D.L xor K.L;
Result.R := D.R xor K.R;
end;
function TCipher_SharkBase.Transform(A: TLong64; Log, ALog: TLogArray): TLong64;
function Mul(A, B: Integer): Byte;
begin
Result := ALog[(Log[A] + Log[B]) mod 255];
end;
var
I, J: Byte;
K, T: array[0..7] of Byte;
begin
Move(A.R, K[0], 4);
Move(A.L, K[4], 4);
SwapUInt32Buffer(K, K, 2);
for I := 0 to 7 do
begin
T[I] := Mul(Shark_I[I, 0], K[0]);
for J := 1 to 7 do
T[I] := T[I] xor Mul(Shark_I[I, J], K[J]);
end;
Result.L := T[0];
Result.R := 0;
for I := 1 to 7 do
begin
Result.R := Result.R shl 8 or Result.L shr 24;
Result.L := Result.L shl 8 xor T[I];
end;
end;
{$ELSE CPU64BITS}
function TCipher_SharkBase.Transform(A: UInt64; Log, ALog: TLogArray): UInt64;
var
I, J: Integer;
K, T: array[0..7] of Byte;
function Mul(A, B: Byte): Byte;
begin
// GF(256) multiplication via logarithm tables
Result := ALog[(Log[A] + Log[B]) mod 255];
end;
begin
for I := 0 to 7 do
K[I] := A shr (56 - 8 * i);
for I := 0 to 7 do
begin
T[I] := Mul(Shark_I[I, 0], K[0]);
for J := 1 to 7 do
T[I] := T[I] xor Mul(Shark_I[I, J], K[J]);
end;
Result := T[0];
for I := 1 to 7 do
Result := (Result shl 8) xor T[I];
end;
{$ENDIF}
{ TCipher_Shark }
class function TCipher_Shark.Context: TCipherContext;
begin
Result.KeySize := 16;
Result.BlockSize := 8;
Result.BufferSize := 8;
Result.AdditionalBufferSize := 112;
Result.NeedsAdditionalBufferBackup := False;
Result.MinRounds := 1;
Result.MaxRounds := 1;
Result.CipherType := [ctSymmetric, ctBlock];
end;
{$IFNDEF CPU64BITS}
procedure TCipher_Shark.DoInit(const Key; Size: Integer);
var
Log, ALog: TLogArray;
procedure InitLog;
var
I, J: Word;
begin
ALog[0] := 1;
for I := 1 to 255 do
begin
J := ALog[I - 1] shl 1;
if J and $100 <> 0 then
J := J xor $01F5;
ALog[I] := J;
end;
Log[0] := 0;
for I := 0 to 254 do
Log[ALog[I]] := I;
end;
var
T: array[0..6] of TLong64;
A: array[0..6] of TLong64;
K: array[0..15] of Byte;
I, J, R: Byte;
E, D: PLong64Array;
L: TLong64;
begin
FillChar(K, SizeOf(K), 0);
Move(Key, K, Size);
InitLog;
E := FAdditionalBuffer;
D := @E[7];
Move(Shark_CE[0], T, SizeOf(T));
T[6] := Transform(T[6], Log, ALog);
I := 0;
for R := 0 to 6 do
begin
A[R].L := K[I and $F];
A[R].R := 0;
Inc(I);
for J := 1 to 7 do
begin
A[R].R := A[R].R shl 8 or A[R].L shr 24;
A[R].L := A[R].L shl 8 or K[I and $F];
Inc(I);
end;
end;
L.L := 0;
L.R := 0;
L := Shark(L, @T);
E[0].L := A[0].L xor L.L;
E[0].R := A[0].R xor L.R;
for R := 1 to 6 do
begin
L := Shark(E[R - 1], @T);
E[R].L := A[R].L xor L.L;
E[R].R := A[R].R xor L.R;
end;
E[6] := Transform(E[6], Log, ALog);
D[0] := E[6];
D[6] := E[0];
for R := 1 to 5 do
D[R] := Transform(E[6-R], Log, ALog);
ProtectBuffer(T, SizeOf(T));
ProtectBuffer(A, SizeOf(A));
ProtectBuffer(K, SizeOf(K));
end;
procedure TCipher_Shark.DoEncode(Source, Dest: Pointer; Size: Integer);
var
I: Integer;
T, L, R: UInt32;
K: PUInt32Array;
begin
Assert(Size = Context.BlockSize);
K := FAdditionalBuffer;
L := PLong64(Source).L;
R := PLong64(Source).R;
for I := 0 to 4 do
begin
L := L xor K[I * 2 + 0];
R := R xor K[I * 2 + 1];
T := Shark_CE[0, R shr 23 and $1FE] xor
Shark_CE[1, R shr 15 and $1FE] xor
Shark_CE[2, R shr 7 and $1FE] xor
Shark_CE[3, R shl 1 and $1FE] xor
Shark_CE[4, L shr 23 and $1FE] xor
Shark_CE[5, L shr 15 and $1FE] xor
Shark_CE[6, L shr 7 and $1FE] xor
Shark_CE[7, L shl 1 and $1FE];
R := Shark_CE[0, R shr 23 and $1FE or 1] xor
Shark_CE[1, R shr 15 and $1FE or 1] xor
Shark_CE[2, R shr 7 and $1FE or 1] xor
Shark_CE[3, R shl 1 and $1FE or 1] xor
Shark_CE[4, L shr 23 and $1FE or 1] xor
Shark_CE[5, L shr 15 and $1FE or 1] xor
Shark_CE[6, L shr 7 and $1FE or 1] xor
Shark_CE[7, L shl 1 and $1FE or 1];
L := T;
end;
L := L xor K[10];
R := R xor K[11];
L := UInt32(Shark_SE[L shr 24 ]) shl 24 xor
UInt32(Shark_SE[L shr 16 and $FF]) shl 16 xor
UInt32(Shark_SE[L shr 8 and $FF]) shl 8 xor
UInt32(Shark_SE[L and $FF]);
R := UInt32(Shark_SE[R shr 24 ]) shl 24 xor
UInt32(Shark_SE[R shr 16 and $FF]) shl 16 xor
UInt32(Shark_SE[R shr 8 and $FF]) shl 8 xor
UInt32(Shark_SE[R and $FF]);
PLong64(Dest).L := L xor K[12];
PLong64(Dest).R := R xor K[13];
end;
procedure TCipher_Shark.DoDecode(Source, Dest: Pointer; Size: Integer);
var
I: Integer;
T, R, L: UInt32;
K: PUInt32Array;
begin
Assert(Size = Context.BlockSize);
K := @PUInt32Array(FAdditionalBuffer)[14];
L := PLong64(Source).L;
R := PLong64(Source).R;
for I := 0 to 4 do
begin
L := L xor K[I * 2 + 0];
R := R xor K[I * 2 + 1];
T := Shark_CD[0, R shr 23 and $1FE] xor
Shark_CD[1, R shr 15 and $1FE] xor
Shark_CD[2, R shr 7 and $1FE] xor
Shark_CD[3, R shl 1 and $1FE] xor
Shark_CD[4, L shr 23 and $1FE] xor
Shark_CD[5, L shr 15 and $1FE] xor
Shark_CD[6, L shr 7 and $1FE] xor
Shark_CD[7, L shl 1 and $1FE];
R := Shark_CD[0, R shr 23 and $1FE or 1] xor
Shark_CD[1, R shr 15 and $1FE or 1] xor
Shark_CD[2, R shr 7 and $1FE or 1] xor
Shark_CD[3, R shl 1 and $1FE or 1] xor
Shark_CD[4, L shr 23 and $1FE or 1] xor
Shark_CD[5, L shr 15 and $1FE or 1] xor
Shark_CD[6, L shr 7 and $1FE or 1] xor
Shark_CD[7, L shl 1 and $1FE or 1];
L := T;
end;
L := L xor K[10];
R := R xor K[11];
L := UInt32(Shark_SD[L shr 24 ]) shl 24 xor
UInt32(Shark_SD[L shr 16 and $FF]) shl 16 xor
UInt32(Shark_SD[L shr 8 and $FF]) shl 8 xor
UInt32(Shark_SD[L and $FF]);
R := UInt32(Shark_SD[R shr 24 ]) shl 24 xor
UInt32(Shark_SD[R shr 16 and $FF]) shl 16 xor
UInt32(Shark_SD[R shr 8 and $FF]) shl 8 xor
UInt32(Shark_SD[R and $FF]);
PLong64(Dest).L := L xor K[12];
PLong64(Dest).R := R xor K[13];
end;
{$ELSE CPU64BITS}
const
SHARK_ROUNDS = 6;
SHARK_ROUNDKEYS = SHARK_ROUNDS + 1;
SHARK_ROOT = $1F5; // GF(256) polynomial x^8 + x^7 + x^6 + x^5 + x^4 + x^2 + 1
function SharkEncode(D: UInt64; K: PUInt64): UInt64;
var
R: Integer;
begin
for R := 1 to SHARK_ROUNDS - 1 do
begin
D := D xor K^;
Inc(K);
D := Shark_CE[0, D shr 56 and $FF] xor
Shark_CE[1, D shr 48 and $FF] xor
Shark_CE[2, D shr 40 and $FF] xor
Shark_CE[3, D shr 32 and $FF] xor
Shark_CE[4, D shr 24 and $FF] xor
Shark_CE[5, D shr 16 and $FF] xor
Shark_CE[6, D shr 8 and $FF] xor
Shark_CE[7, D and $FF];
end;
D := D xor K^;
Inc(K);
D := UInt64(Shark_SE[D shr 56 and $FF]) shl 56 xor
UInt64(Shark_SE[D shr 48 and $FF]) shl 48 xor
UInt64(Shark_SE[D shr 40 and $FF]) shl 40 xor
UInt64(Shark_SE[D shr 32 and $FF]) shl 32 xor
UInt64(Shark_SE[D shr 24 and $FF]) shl 24 xor
UInt64(Shark_SE[D shr 16 and $FF]) shl 16 xor
UInt64(Shark_SE[D shr 8 and $FF]) shl 8 xor
UInt64(Shark_SE[D and $FF]);
Result := D xor K^;
end;
procedure TCipher_Shark.DoInit(const Key; Size: Integer);
var
Log, ALog: TLogArray;
procedure InitLog;
var
I, J: Word;
begin
// Generate GF(256) anti-logarithm and logarithm tables
ALog[0] := 1;
for I := 1 to 255 do
begin
J := ALog[I - 1] shl 1;
if J and $100 <> 0 then
J := J xor SHARK_ROOT;
ALog[I] := J;
end;
Log[0] := 0;
for I := 0 to 254 do
Log[ALog[I]] := I;
end;
var
T: array[0..SHARK_ROUNDS] of UInt64;
A: array[0..SHARK_ROUNDKEYS-1] of UInt64;
K: array[0..15] of Byte;
I, J, R: Integer;
E, D: PUInt64Array;
begin
FillChar(K, SizeOf(K), 0);
Move(Key, K, Size);
InitLog;
E := FAdditionalBuffer; // encryption round key
D := @E[SHARK_ROUNDS + 1]; // decryption round key
Move(Shark_CE[0], T, SizeOf(T));
T[SHARK_ROUNDS] := Transform(T[SHARK_ROUNDS], Log, ALog);
I := 0;
for R := 0 to High(A) do
begin
A[R] := K[I and $F];
Inc(I);
for J := 1 to 7 do
begin
A[R] := A[R] shl 8 or K[I and $F];
Inc(I);
end;
end;
E[0] := A[0] xor SharkEncode(0, @T);
for R := 1 to High(A) do
E[R] := A[R] xor SharkEncode(E[R - 1], @T);
E[SHARK_ROUNDS] := Transform(E[SHARK_ROUNDS], Log, ALog);
D[0] := E[SHARK_ROUNDS];
D[SHARK_ROUNDS] := E[0];
for R := 1 to SHARK_ROUNDS - 1 do
D[R] := Transform(E[SHARK_ROUNDS - R], Log, ALog);
ProtectBuffer(T, SizeOf(T));
ProtectBuffer(A, SizeOf(A));
ProtectBuffer(K, SizeOf(K));
end;
procedure TCipher_Shark.DoEncode(Source, Dest: Pointer; Size: Integer);
begin
Assert(Size = Context.BufferSize);
PUInt64(Dest)^ := SharkEncode(PUInt64(Source)^, FAdditionalBuffer);
end;
procedure TCipher_Shark.DoDecode(Source, Dest: Pointer; Size: Integer);
var
R: Integer;
D: UInt64;
K: PUInt64;
begin
Assert(Size = Context.BufferSize);
D := PUInt64(Source)^;
K := @PUInt64Array(FAdditionalBuffer)[SHARK_ROUNDS + 1]; // decryption round key
for R := 1 to SHARK_ROUNDS - 1 do
begin
D := D xor K^;
Inc(K);
D := Shark_CD[0, D shr 56 and $FF] xor
Shark_CD[1, D shr 48 and $FF] xor
Shark_CD[2, D shr 40 and $FF] xor
Shark_CD[3, D shr 32 and $FF] xor
Shark_CD[4, D shr 24 and $FF] xor
Shark_CD[5, D shr 16 and $FF] xor
Shark_CD[6, D shr 8 and $FF] xor
Shark_CD[7, D and $FF];
end;
D := D xor K^;
Inc(K);
D := UInt64(Shark_SD[D shr 56 and $FF]) shl 56 xor
UInt64(Shark_SD[D shr 48 and $FF]) shl 48 xor
UInt64(Shark_SD[D shr 40 and $FF]) shl 40 xor
UInt64(Shark_SD[D shr 32 and $FF]) shl 32 xor
UInt64(Shark_SD[D shr 24 and $FF]) shl 24 xor
UInt64(Shark_SD[D shr 16 and $FF]) shl 16 xor
UInt64(Shark_SD[D shr 8 and $FF]) shl 8 xor
UInt64(Shark_SD[D and $FF]);
PUInt64(Dest)^ := D xor K^;
end;
{$ENDIF CPU64BITS}
{ TCipher_Shark_DEC52 }
{$IFNDEF CPU64BITS}
procedure TCipher_Shark_DEC52.DoInit(const Key; Size: Integer);
var
Log, ALog: TLogArray;
procedure InitLog;
var
I, J: Word;
begin
ALog[0] := 1;
for I := 1 to 255 do
begin
J := ALog[I - 1] shl 1;
if J and $100 <> 0 then
J := J xor $01F5;
ALog[I] := J;
end;
for I := 1 to 254 do
Log[ALog[I]] := I;
end;
var
T: array[0..6] of TLong64;
A: array[0..6] of TLong64;
K: array[0..15] of Byte;
I, J, R: Byte;
E, D: PLong64Array;
L: TLong64;
begin
FillChar(K, SizeOf(K), 0);
Move(Key, K, Size);
InitLog;
E := FAdditionalBuffer;
D := @E[7];
Move(Shark_CE[0], T, SizeOf(T));
T[6] := Transform(T[6], Log, ALog);
I := 0;
for R := 0 to 6 do
begin
Inc(I);
A[R].L := K[I and $F];
A[R].R := 0;
for J := 1 to 7 do
begin
Inc(I);
A[R].R := A[R].R shl 8 or A[R].L shr 24;
A[R].L := A[R].L shl 8 or K[I and $F];
end;
end;
L.L := 0;
L.R := 0;
L := Shark(L, @T);
E[0].L := A[0].L xor L.L;
E[0].R := A[0].R xor L.R;
for R := 1 to 6 do
begin
L := Shark(E[R - 1], @T);
E[R].L := A[R].L xor L.L;
E[R].R := A[R].R xor L.R;
end;
E[6] := Transform(E[6], Log, ALog);
D[0] := E[6];
D[6] := E[0];
for R := 1 to 5 do
D[R] := Transform(E[6-R], Log, ALog);
ProtectBuffer(T, SizeOf(T));
ProtectBuffer(A, SizeOf(A));
ProtectBuffer(K, SizeOf(K));
end;
{$ELSE CPU64BITS}
procedure TCipher_Shark_DEC52.DoInit(const Key; Size: Integer);
var
Log, ALog: TLogArray;
procedure InitLog;
var
I, J: Word;
begin
// Generate GF(256) anti-logarithm and logarithm tables
ALog[0] := 1;
for I := 1 to 255 do
begin
J := ALog[I - 1] shl 1;
if J and $100 <> 0 then
J := J xor SHARK_ROOT;
ALog[I] := J;
end;
for I := 1 to 254 do
Log[ALog[I]] := I;
end;
var
T: array[0..SHARK_ROUNDS] of UInt64;
A: array[0..SHARK_ROUNDKEYS-1] of UInt64;
K: array[0..15] of Byte;
I, J, R: Integer;
E, D: PUInt64Array;
begin
FillChar(K, SizeOf(K), 0);
Move(Key, K, Size);
InitLog;
E := FAdditionalBuffer; // encryption round key
D := @E[SHARK_ROUNDS + 1]; // decryption round key
Move(Shark_CE[0], T, SizeOf(T));
T[SHARK_ROUNDS] := Transform(T[SHARK_ROUNDS], Log, ALog);
I := 0;
for R := 0 to High(A) do
begin
Inc(I);
A[R] := K[I and $F];
for J := 1 to 7 do
begin
Inc(I);
A[R] := A[R] shl 8 or K[I and $F];
end;
end;
E[0] := A[0] xor SharkEncode(0, @T);
for R := 1 to High(A) do
E[R] := A[R] xor SharkEncode(E[R - 1], @T);
E[SHARK_ROUNDS] := Transform(E[SHARK_ROUNDS], Log, ALog);
D[0] := E[SHARK_ROUNDS];
D[SHARK_ROUNDS] := E[0];
for R := 1 to SHARK_ROUNDS - 1 do
D[R] := Transform(E[SHARK_ROUNDS - R], Log, ALog);
ProtectBuffer(T, SizeOf(T));
ProtectBuffer(A, SizeOf(A));
ProtectBuffer(K, SizeOf(K));
end;
{$ENDIF}
{ TCipher_Skipjack }
class function TCipher_Skipjack.Context: TCipherContext;
begin
Result.KeySize := 10;
Result.BlockSize := 8;
Result.BufferSize := 8;
Result.AdditionalBufferSize := $A00;
Result.NeedsAdditionalBufferBackup := false;
Result.MinRounds := 1;
Result.MaxRounds := 1;
Result.CipherType := [ctSymmetric, ctBlock];
end;
procedure TCipher_Skipjack.DoInit(const Key; Size: Integer);
var
K: array[0..9] of Byte;
D: PByte;
I, J: Integer;
begin
FillChar(K, SizeOf(K), 0);
Move(Key, K, Size);
D := FAdditionalBuffer;
for I := 0 to 9 do
for J := 0 to 255 do
begin
D^ := Skipjack_Data[J xor K[I]];
Inc(D);
end;
ProtectBuffer(K, SizeOf(K));
end;
procedure TCipher_Skipjack.DoEncode(Source, Dest: Pointer; Size: Integer);
var
Tab, Min: PSkipjackTab;
Max: PByte;
K, T, A, B, C, D: UInt32;
begin
Assert(Size = Context.BlockSize);
Min := FAdditionalBuffer;
Max := PByte(Min) + 9 * 256; // for Pointer Math
Tab := Min;
A := Swap(PWordArray(Source)[0]);
B := Swap(PWordArray(Source)[1]);
C := Swap(PWordArray(Source)[2]);
D := Swap(PWordArray(Source)[3]);
K := 0;
repeat
Inc(K);
T := A;
T := T xor Tab[T and $FF] shl 8; SkipjackIncCheck(Tab, Min, Max);
T := T xor Tab[T shr 8]; SkipjackIncCheck(Tab, Min, Max);
T := T xor Tab[T and $FF] shl 8; SkipjackIncCheck(Tab, Min, Max);
T := T xor Tab[T shr 8]; SkipjackIncCheck(Tab, Min, Max);
A := T xor D xor K;
D := C;
C := B;
B := T;
until K = 8;
repeat
Inc(K);
T := A;
A := D;
D := C;
C := T xor B xor K;
T := T xor Tab[T and $FF] shl 8; SkipjackIncCheck(Tab, Min, Max);
T := T xor Tab[T shr 8]; SkipjackIncCheck(Tab, Min, Max);
T := T xor Tab[T and $FF] shl 8; SkipjackIncCheck(Tab, Min, Max);
T := T xor Tab[T shr 8]; SkipjackIncCheck(Tab, Min, Max);
B := T;
until K = 16;
repeat
Inc(K);
T := A;
T := T xor Tab[T and $FF] shl 8; SkipjackIncCheck(Tab, Min, Max);
T := T xor Tab[T shr 8]; SkipjackIncCheck(Tab, Min, Max);
T := T xor Tab[T and $FF] shl 8; SkipjackIncCheck(Tab, Min, Max);
T := T xor Tab[T shr 8]; SkipjackIncCheck(Tab, Min, Max);
A := T xor D xor K;
D := C;
C := B;
B := T;
until K = 24;
repeat
Inc(K);
T := A;
A := D;
D := C;
C := T xor B xor K;
T := T xor Tab[T and $FF] shl 8; SkipjackIncCheck(Tab, Min, Max);
T := T xor Tab[T shr 8]; SkipjackIncCheck(Tab, Min, Max);
T := T xor Tab[T and $FF] shl 8; SkipjackIncCheck(Tab, Min, Max);
T := T xor Tab[T shr 8]; SkipjackIncCheck(Tab, Min, Max);
B := T;
until K = 32;
PWordArray(Dest)[0] := Swap(A);
PWordArray(Dest)[1] := Swap(B);
PWordArray(Dest)[2] := Swap(C);
PWordArray(Dest)[3] := Swap(D);
end;
procedure TCipher_Skipjack.SkipjackIncCheck(var ATab: PSkipjackTab; AMin: PSkipjackTab; AMax: PByte);
begin
Inc(ATab);
if PByte(ATab) > AMax then
ATab := AMin;
end;
procedure TCipher_Skipjack.DoDecode(Source, Dest: Pointer; Size: Integer);
var
Tab, Max: PSkipjackTab;
Min: PByte; // for Pointer Math
K, T, A, B, C, D: UInt32;
begin
Assert(Size = Context.BlockSize);
Min := FAdditionalBuffer;
Max := Pointer(Min + 9 * 256);
Tab := Pointer(Min + 7 * 256);
A := Swap(PWordArray(Source)[0]); // holds an Integer, Compiler makes faster Code
B := Swap(PWordArray(Source)[1]);
C := Swap(PWordArray(Source)[2]);
D := Swap(PWordArray(Source)[3]);
K := 32;
repeat
T := B;
T := T xor Tab[T shr 8]; SkipjackDecCheck(Tab, Min, Max);
T := T xor Tab[T and $FF] shl 8; SkipjackDecCheck(Tab, Min, Max);
T := T xor Tab[T shr 8]; SkipjackDecCheck(Tab, Min, Max);
T := T xor Tab[T and $FF] shl 8; SkipjackDecCheck(Tab, Min, Max);
B := T xor C xor K;
C := D;
D := A;
A := T;
Dec(K);
until K = 24;
repeat
T := B;
B := C;
C := D;
D := T xor A xor K;
T := T xor Tab[T shr 8]; SkipjackDecCheck(Tab, Min, Max);
T := T xor Tab[T and $FF] shl 8; SkipjackDecCheck(Tab, Min, Max);
T := T xor Tab[T shr 8]; SkipjackDecCheck(Tab, Min, Max);
T := T xor Tab[T and $FF] shl 8; SkipjackDecCheck(Tab, Min, Max);
A := T;
Dec(K);
until K = 16;
repeat
T := B;
T := T xor Tab[T shr 8]; SkipjackDecCheck(Tab, Min, Max);
T := T xor Tab[T and $FF] shl 8; SkipjackDecCheck(Tab, Min, Max);
T := T xor Tab[T shr 8]; SkipjackDecCheck(Tab, Min, Max);
T := T xor Tab[T and $FF] shl 8; SkipjackDecCheck(Tab, Min, Max);
B := C xor T xor K;
C := D;
D := A;
A := T;
Dec(K);
until K = 8;
repeat
T := B;
B := C;
C := D;
D := T xor A xor K;
T := T xor Tab[T shr 8]; SkipjackDecCheck(Tab, Min, Max);
T := T xor Tab[T and $FF] shl 8; SkipjackDecCheck(Tab, Min, Max);
T := T xor Tab[T shr 8]; SkipjackDecCheck(Tab, Min, Max);
T := T xor Tab[T and $FF] shl 8; SkipjackDecCheck(Tab, Min, Max);
A := T;
Dec(K);
until K = 0;
PWordArray(Dest)[0] := Swap(A);
PWordArray(Dest)[1] := Swap(B);
PWordArray(Dest)[2] := Swap(C);
PWordArray(Dest)[3] := Swap(D);
end;
procedure TCipher_Skipjack.SkipjackDecCheck(var ATab: PSkipjackTab; AMin: PByte; AMax: PSkipjackTab);
begin
Dec(ATab);
// {$IFDEF DELPHIORBCB}
// if ATab < AMin then
// {$ELSE !DELPHIORBCB}
{ TODO : Pr<50>fen ob so korrekt, da ATab auf PByte umgestellt wurde, au<61>erdem sollte
diese interne procedure eher zu einer strict private methode werden}
if PByte(ATab) < AMin then
// {$ENDIF !DELPHIORBCB}
ATab := AMax;
end;
{ TCipher_TEA }
const
TEA_Delta = $9E3779B9; // magic constant, decimal 2654435769
class function TCipher_TEA.Context: TCipherContext;
begin
Result.KeySize := 16; // 128 bits
Result.BlockSize := 8; // 64 bits
Result.BufferSize := 8; // 64 bits
Result.AdditionalBufferSize := 32; // 256 bits
Result.NeedsAdditionalBufferBackup := false;
Result.MinRounds := 16;
Result.MaxRounds := 256;
Result.CipherType := [ctSymmetric, ctBlock];
end;
procedure TCipher_TEA.SetRounds(Value: Integer);
begin
if not (FState in [csNew, csInitialized, csDone]) then
Done;
if Value < 16 then
Value := 16
else
if Value > 256 then
Value := 256;
FRounds := Value;
end;
procedure TCipher_TEA.DoInit(const Key; Size: Integer);
begin
Move(Key, FAdditionalBuffer^, Size);
SetRounds(FRounds);
end;
procedure TCipher_TEA.DoEncode(Source, Dest: Pointer; Size: Integer);
var
I: Integer;
Sum,
X, Y, A, B, C, D: UInt32;
begin
Assert(Size = Context.BlockSize);
Sum := 0;
A := PUInt32Array(FAdditionalBuffer)[0];
B := PUInt32Array(FAdditionalBuffer)[1];
C := PUInt32Array(FAdditionalBuffer)[2];
D := PUInt32Array(FAdditionalBuffer)[3];
X := PUInt32Array(Source)[0];
Y := PUInt32Array(Source)[1];
for I := 0 to FRounds - 1 do
begin
Inc(Sum, TEA_Delta);
Inc(X, (((Y shl 4 + A) xor Y) + Sum) xor (Y shr 5 + B));
Inc(Y, (((X shl 4 + C) xor X) + Sum) xor (X shr 5 + D));
end;
PUInt32Array(Dest)[0] := X;
PUInt32Array(Dest)[1] := Y;
end;
procedure TCipher_TEA.DoDecode(Source, Dest: Pointer; Size: Integer);
var
I: Integer;
Sum,
X, Y, A, B, C, D: UInt32;
begin
Assert(Size = Context.BlockSize);
Sum := TEA_Delta * UInt32(FRounds);
A := PUInt32Array(FAdditionalBuffer)[0];
B := PUInt32Array(FAdditionalBuffer)[1];
C := PUInt32Array(FAdditionalBuffer)[2];
D := PUInt32Array(FAdditionalBuffer)[3];
X := PUInt32Array(Source)[0];
Y := PUInt32Array(Source)[1];
for I := 0 to FRounds - 1 do
begin
Dec(Y, (X shl 4 + C) xor X + Sum xor (X shr 5 + D));
Dec(X, (Y shl 4 + A) xor Y + Sum xor (Y shr 5 + B));
Dec(Sum, TEA_Delta);
end;
PUInt32Array(Dest)[0] := X;
PUInt32Array(Dest)[1] := Y;
end;
{ TCipher_XTEA }
procedure TCipher_XTEA.DoEncode(Source, Dest: Pointer; Size: Integer);
var
Sum,
I, X, Y: UInt32;
K: PUInt32Array;
begin
Assert(Size = Context.BlockSize);
Sum := 0;
X := PUInt32Array(Source)[0];
Y := PUInt32Array(Source)[1];
K := FAdditionalBuffer;
for I := 0 to FRounds - 1 do
begin
Inc(X, (((Y shl 4) xor (Y shr 5)) + Y) xor (Sum + K[Sum and 3]));
Inc(Sum, TEA_Delta);
Inc(Y, (((X shl 4) xor (X shr 5)) + X) xor (Sum + K[Sum shr 11 and 3]));
end;
PUInt32Array(Dest)[0] := X;
PUInt32Array(Dest)[1] := Y;
end;
procedure TCipher_XTEA.DoDecode(Source, Dest: Pointer; Size: Integer);
var
I: Integer;
Sum,
X, Y: UInt32;
K: PUInt32Array;
begin
Assert(Size = Context.BlockSize);
Sum := TEA_Delta * UInt32(FRounds);
X := PUInt32Array(Source)[0];
Y := PUInt32Array(Source)[1];
K := FAdditionalBuffer;
for I := 0 to FRounds - 1 do
begin
Dec(Y, (((X shl 4) xor (X shr 5)) + X) xor (Sum + K[Sum shr 11 and 3]));
Dec(Sum, TEA_Delta);
Dec(X, (((Y shl 4) xor (Y shr 5)) + Y) xor (Sum + K[Sum and 3]));
end;
PUInt32Array(Dest)[0] := X;
PUInt32Array(Dest)[1] := Y;
end;
{ TCipher_XTEA_DEC52 }
{ TODO : The old failure needs to be restored again }
procedure TCipher_XTEA_DEC52.DoEncode(Source, Dest: Pointer; Size: Integer);
var
Sum,
I, X, Y: UInt32;
K: PUInt32Array;
begin
Assert(Size = Context.BlockSize);
Sum := 0;
X := PUInt32Array(Source)[0];
Y := PUInt32Array(Source)[1];
K := FAdditionalBuffer;
for I := 0 to FRounds - 1 do
begin
Inc(X, (Y shl 4 xor Y shr 5) + (Y xor Sum) + K[Sum and 3]);
Inc(Sum, TEA_Delta);
Inc(Y, (X shl 4 xor X shr 5) + (X xor Sum) + K[Sum shr 11 and 3]);
end;
PUInt32Array(Dest)[0] := X;
PUInt32Array(Dest)[1] := Y;
end;
procedure TCipher_XTEA_DEC52.DoDecode(Source, Dest: Pointer; Size: Integer);
var
I: Integer;
Sum,
X, Y: UInt32;
K: PUInt32Array;
begin
Assert(Size = Context.BlockSize);
Sum := TEA_Delta * UInt32(FRounds);
X := PUInt32Array(Source)[0];
Y := PUInt32Array(Source)[1];
K := FAdditionalBuffer;
for I := 0 to FRounds - 1 do
begin
Dec(Y, (X shl 4 xor X shr 5) + (X xor Sum) + K[Sum shr 11 and 3]);
Dec(Sum, TEA_Delta);
Dec(X, (Y shl 4 xor Y shr 5) + (Y xor Sum) + K[Sum and 3]);
end;
PUInt32Array(Dest)[0] := X;
PUInt32Array(Dest)[1] := Y;
end;
{$IFDEF RESTORE_RANGECHECKS}{$R+}{$ENDIF}
{$IFDEF RESTORE_OVERFLOWCHECKS}{$Q+}{$ENDIF}
initialization
SetDefaultCipherClass(TCipher_Null);
{$IFNDEF ManualRegisterClasses}
TCipher_Null.RegisterClass(TDECCipher.ClassList);
TCipher_Blowfish.RegisterClass(TDECCipher.ClassList);
TCipher_Twofish.RegisterClass(TDECCipher.ClassList);
TCipher_IDEA.RegisterClass(TDECCipher.ClassList);
TCipher_Cast256.RegisterClass(TDECCipher.ClassList);
TCipher_Mars.RegisterClass(TDECCipher.ClassList);
TCipher_RC4.RegisterClass(TDECCipher.ClassList);
TCipher_RC6.RegisterClass(TDECCipher.ClassList);
// Explicitely not registered, as Rijndael is 1:1 the same as AES and AES is the
// more common name
// TCipher_Rijndael.RegisterClass(TDECCipher.ClassList);
TCipher_AES.RegisterClass(TDECCipher.ClassList);
TCipher_Square.RegisterClass(TDECCipher.ClassList);
TCipher_SCOP.RegisterClass(TDECCipher.ClassList);
TCipher_Sapphire.RegisterClass(TDECCipher.ClassList);
TCipher_1DES.RegisterClass(TDECCipher.ClassList);
TCipher_2DES.RegisterClass(TDECCipher.ClassList);
TCipher_3DES.RegisterClass(TDECCipher.ClassList);
TCipher_2DDES.RegisterClass(TDECCipher.ClassList);
TCipher_3DDES.RegisterClass(TDECCipher.ClassList);
TCipher_3TDES.RegisterClass(TDECCipher.ClassList);
TCipher_3Way.RegisterClass(TDECCipher.ClassList);
TCipher_Cast128.RegisterClass(TDECCipher.ClassList);
TCipher_Gost.RegisterClass(TDECCipher.ClassList);
// Explicitely not registered, as this is an alias for Gost only
// TCipher_Magma.RegisterClass(TDECCipher.ClassList);
TCipher_Misty.RegisterClass(TDECCipher.ClassList);
TCipher_NewDES.RegisterClass(TDECCipher.ClassList);
TCipher_Q128.RegisterClass(TDECCipher.ClassList);
TCipher_RC2.RegisterClass(TDECCipher.ClassList);
TCipher_RC5.RegisterClass(TDECCipher.ClassList);
TCipher_SAFER.RegisterClass(TDECCipher.ClassList);
TCipher_Shark.RegisterClass(TDECCipher.ClassList);
TCipher_Skipjack.RegisterClass(TDECCipher.ClassList);
TCipher_TEA.RegisterClass(TDECCipher.ClassList);
TCipher_XTEA.RegisterClass(TDECCipher.ClassList);
TCipher_TEAN.RegisterClass(TDECCipher.ClassList);
{$IFDEF OLD_REGISTER_FAULTY_CIPHERS}
// Those classes are only there for those who might have relied on the
// faulty implementation
TCipher_SCOP_DEC52.RegisterClass(TDECCipher.ClassList);
TCipher_Shark_DEC52.RegisterClass(TDECCipher.ClassList);
TCipher_XTEA_DEC52.RegisterClass(TDECCipher.ClassList);
{$ENDIF}
{$ENDIF}
finalization
end.
Reference in New Issue View Git Blame Copy Permalink