/** * initialise a DESede cipher. * * @param forEncryption whether or not we are for encryption. * @param parameters the parameters required to set up the cipher. * @exception ArgumentException if the parameters argument is * inappropriate. */ public override void Init( bool forEncryption, ICipherParameters parameters) { if (!(parameters is KeyParameter)) throw new ArgumentException("invalid parameter passed to DESede init - " + parameters.GetType().ToString()); byte[] keyMaster = ((KeyParameter)parameters).GetKey(); if (keyMaster.Length != 24 && keyMaster.Length != 16) throw new ArgumentException("key size must be 16 or 24 bytes."); this.forEncryption = forEncryption; byte[] key1 = new byte[8]; Array.Copy(keyMaster, 0, key1, 0, key1.Length); workingKey1 = GenerateWorkingKey(forEncryption, key1); byte[] key2 = new byte[8]; Array.Copy(keyMaster, 8, key2, 0, key2.Length); workingKey2 = GenerateWorkingKey(!forEncryption, key2); if (keyMaster.Length == 24) { byte[] key3 = new byte[8]; Array.Copy(keyMaster, 16, key3, 0, key3.Length); workingKey3 = GenerateWorkingKey(forEncryption, key3); } else // 16 byte key { workingKey3 = workingKey1; } }
public void Init(bool encrypting, ICipherParameters parameters) { if (!(parameters is KeyParameter)) { throw new ArgumentException("Invalid parameter passed to "+ "DesSsh1Engine init - " + parameters.GetType()); } this.encrypting = encrypting; byte[] passphraseKey = (parameters as KeyParameter).GetKey(); if (passphraseKey.Length !=16) { throw new ArgumentException("key size different than 16 bytes"); } byte[] keyPart1 = new byte[8]; byte[] keyPart2 = new byte[8]; Array.Copy(passphraseKey, keyPart1, 8); Array.Copy(passphraseKey, 8, keyPart2, 0, 8); desEngine1 = new CbcBlockCipher(new DesEngine()); desEngine2 = new CbcBlockCipher(new DesEngine()); desEngine3 = new CbcBlockCipher(new DesEngine()); desEngine1.Init(encrypting, new KeyParameter(keyPart1)); desEngine2.Init(!encrypting, new KeyParameter(keyPart2)); desEngine3.Init(encrypting, new KeyParameter(keyPart1)); }
/** * initialise a SKIPJACK cipher. * * @param forEncryption whether or not we are for encryption. * @param parameters the parameters required to set up the cipher. * @exception ArgumentException if the parameters argument is * inappropriate. */ public virtual void Init( bool forEncryption, ICipherParameters parameters) { if (!(parameters is KeyParameter)) throw new ArgumentException("invalid parameter passed to SKIPJACK init - " + parameters.GetType().ToString()); byte[] keyBytes = ((KeyParameter)parameters).GetKey(); this.encrypting = forEncryption; this.key0 = new int[32]; this.key1 = new int[32]; this.key2 = new int[32]; this.key3 = new int[32]; // // expand the key to 128 bytes in 4 parts (saving us a modulo, multiply // and an addition). // for (int i = 0; i < 32; i ++) { key0[i] = keyBytes[(i * 4) % 10] & 0xff; key1[i] = keyBytes[(i * 4 + 1) % 10] & 0xff; key2[i] = keyBytes[(i * 4 + 2) % 10] & 0xff; key3[i] = keyBytes[(i * 4 + 3) % 10] & 0xff; } }
public void Init( ICipherParameters parameters) { Reset(); buf = new byte[blockSize]; if (parameters is ParametersWithSBox) { ParametersWithSBox param = (ParametersWithSBox)parameters; // // Set the S-Box // param.GetSBox().CopyTo(this.S, 0); // // set key if there is one // if (param.Parameters != null) { workingKey = generateWorkingKey(((KeyParameter)param.Parameters).GetKey()); } } else if (parameters is KeyParameter) { workingKey = generateWorkingKey(((KeyParameter)parameters).GetKey()); } else { throw new ArgumentException("invalid parameter passed to Gost28147 init - " + parameters.GetType().Name); } }
/** * Initialise a HC-256 cipher. * * @param forEncryption whether or not we are for encryption. Irrelevant, as * encryption and decryption are the same. * @param params the parameters required to set up the cipher. * @throws ArgumentException if the params argument is * inappropriate (ie. the key is not 256 bit long). */ public void Init( bool forEncryption, ICipherParameters parameters) { ICipherParameters keyParam = parameters; if (parameters is ParametersWithIV) { iv = ((ParametersWithIV)parameters).GetIV(); keyParam = ((ParametersWithIV)parameters).Parameters; } else { iv = new byte[0]; } if (keyParam is KeyParameter) { key = ((KeyParameter)keyParam).GetKey(); Init(); } else { throw new ArgumentException( "Invalid parameter passed to HC256 init - " + parameters.GetType().Name, "parameters"); } initialised = true; }
/** * initialise a DES cipher. * * @param forEncryption whether or not we are for encryption. * @param parameters the parameters required to set up the cipher. * @exception ArgumentException if the parameters argument is * inappropriate. */ public virtual void Init( bool forEncryption, ICipherParameters parameters) { if (!(parameters is KeyParameter)) throw new ArgumentException("invalid parameter passed to DES init - " + parameters.GetType().ToString()); workingKey = GenerateWorkingKey(forEncryption, ((KeyParameter)parameters).GetKey()); }
private int X0, X1, X2, X3; // registers /** * initialise a Serpent cipher. * * @param forEncryption whether or not we are for encryption. * @param parameters the parameters required to set up the cipher. * @exception ArgumentException if the parameters argument is * inappropriate. */ public virtual void Init( bool forEncryption, ICipherParameters parameters) { if (!(parameters is KeyParameter)) throw new ArgumentException("invalid parameter passed to Serpent init - " + parameters.GetType().ToString()); this.encrypting = forEncryption; this.wKey = MakeWorkingKey(((KeyParameter)parameters).GetKey()); }
/** * initialise a RC5-32 cipher. * * @param forEncryption whether or not we are for encryption. * @param parameters the parameters required to set up the cipher. * @exception ArgumentException if the parameters argument is * inappropriate. */ public void Init( bool forEncryption, ICipherParameters parameters) { if (!(parameters is KeyParameter)) throw new ArgumentException("invalid parameter passed to RC6 init - " + parameters.GetType().ToString()); this.forEncryption = forEncryption; KeyParameter p = (KeyParameter)parameters; SetKey(p.GetKey()); }
/** * initialise * * @param forEncryption whether or not we are for encryption. * @param params the parameters required to set up the cipher. * @exception ArgumentException if the params argument is * inappropriate. */ public virtual void Init( bool forEncryption, ICipherParameters parameters) { if (!(parameters is KeyParameter)) throw new ArgumentException("Invalid parameters passed to Noekeon init - " + parameters.GetType().Name, "parameters"); _forEncryption = forEncryption; _initialised = true; KeyParameter p = (KeyParameter) parameters; setKey(p.GetKey()); }
/** * initialise a RC5-64 cipher. * * @param forEncryption whether or not we are for encryption. * @param parameters the parameters required to set up the cipher. * @exception ArgumentException if the parameters argument is * inappropriate. */ public void Init( bool forEncryption, ICipherParameters parameters) { if (!(parameters is RC5Parameters)) { throw new ArgumentException("invalid parameter passed to RC564 init - " + parameters.GetType().ToString()); } RC5Parameters p = (RC5Parameters)parameters; this.forEncryption = forEncryption; _noRounds = p.Rounds; SetKey(p.GetKey()); }
/** * initialise an ISAAC cipher. * * @param forEncryption whether or not we are for encryption. * @param params the parameters required to set up the cipher. * @exception ArgumentException if the params argument is * inappropriate. */ public void Init( bool forEncryption, ICipherParameters parameters) { if (!(parameters is KeyParameter)) throw new ArgumentException( "invalid parameter passed to ISAAC Init - " + parameters.GetType().Name, "parameters"); /* * ISAAC encryption and decryption is completely * symmetrical, so the 'forEncryption' is * irrelevant. */ KeyParameter p = (KeyParameter) parameters; setKey(p.GetKey()); }
/** * initialise * * @param forEncryption whether or not we are for encryption. * @param params the parameters required to set up the cipher. * @exception ArgumentException if the params argument is * inappropriate. */ public void Init( bool forEncryption, ICipherParameters parameters) { if (!(parameters is KeyParameter)) { throw new ArgumentException("invalid parameter passed to TEA init - " + parameters.GetType().FullName); } _forEncryption = forEncryption; _initialised = true; KeyParameter p = (KeyParameter) parameters; setKey(p.GetKey()); }
/** * initialise a RC4 cipher. * * @param forEncryption whether or not we are for encryption. * @param parameters the parameters required to set up the cipher. * @exception ArgumentException if the parameters argument is * inappropriate. */ public void Init( bool forEncryption, ICipherParameters parameters) { if (parameters is KeyParameter) { /* * RC4 encryption and decryption is completely * symmetrical, so the 'forEncryption' is * irrelevant. */ workingKey = ((KeyParameter)parameters).GetKey(); SetKey(workingKey); return; } throw new ArgumentException("invalid parameter passed to RC4 init - " + parameters.GetType().ToString()); }
/// <summary> /// Optionally initialises the Skein digest with the provided parameters. /// </summary> /// See <see cref="NBitcoin.BouncyCastle.Crypto.Parameters.SkeinParameters"></see> for details on the parameterisation of the Skein hash function. /// <param name="parameters">the parameters to apply to this engine, or <code>null</code> to use no parameters.</param> public void Init(ICipherParameters parameters) { SkeinParameters skeinParameters; if (parameters is SkeinParameters) { skeinParameters = (SkeinParameters)parameters; } else if (parameters is KeyParameter) { skeinParameters = new SkeinParameters.Builder().SetKey(((KeyParameter)parameters).GetKey()).Build(); } else { throw new ArgumentException("Invalid parameter passed to Skein MAC init - " + parameters.GetType().Name); } if (skeinParameters.GetKey() == null) { throw new ArgumentException("Skein MAC requires a key parameter."); } engine.Init(skeinParameters); }
/// <summary> /// Initialise the engine. /// </summary> /// <param name="forEncryption">Initialise for encryption if true, for decryption if false.</param> /// <param name="parameters">an instance of <see cref="TweakableBlockCipherParameters"/> or <see cref="KeyParameter"/> (to /// use a 0 tweak)</param> public void Init(bool forEncryption, ICipherParameters parameters) { byte[] keyBytes; byte[] tweakBytes; if (parameters is TweakableBlockCipherParameters) { TweakableBlockCipherParameters tParams = (TweakableBlockCipherParameters)parameters; keyBytes = tParams.Key.GetKey(); tweakBytes = tParams.Tweak; } else if (parameters is KeyParameter) { keyBytes = ((KeyParameter)parameters).GetKey(); tweakBytes = null; } else { throw new ArgumentException("Invalid parameter passed to Threefish init - " + parameters.GetType().Name); } ulong[] keyWords = null; ulong[] tweakWords = null; if (keyBytes != null) { if (keyBytes.Length != this.blocksizeBytes) { throw new ArgumentException("Threefish key must be same size as block (" + blocksizeBytes + " bytes)"); } keyWords = new ulong[blocksizeWords]; for (int i = 0; i < keyWords.Length; i++) { keyWords[i] = BytesToWord(keyBytes, i * 8); } } if (tweakBytes != null) { if (tweakBytes.Length != TWEAK_SIZE_BYTES) { throw new ArgumentException("Threefish tweak must be " + TWEAK_SIZE_BYTES + " bytes"); } tweakWords = new ulong[]{BytesToWord(tweakBytes, 0), BytesToWord(tweakBytes, 8)}; } Init(forEncryption, keyWords, tweakWords); }
/** * initialise a RC5-32 cipher. * * @param forEncryption whether or not we are for encryption. * @param parameters the parameters required to set up the cipher. * @exception ArgumentException if the parameters argument is * inappropriate. */ public void Init( bool forEncryption, ICipherParameters parameters) { if (parameters is RC5Parameters) { RC5Parameters p = (RC5Parameters)parameters; _noRounds = p.Rounds; SetKey (p.GetKey ()); } else if (parameters is KeyParameter) { KeyParameter p = (KeyParameter)parameters; SetKey (p.GetKey ()); } else { throw new ArgumentException ("invalid parameter passed to RC532 init - " + parameters.GetType ().ToString ()); } this.forEncryption = forEncryption; }
public virtual void Init(bool forEncryption, ICipherParameters parameters) { if (!(parameters is KeyParameter)) { throw new ArgumentException("invalid parameter passed to ISAAC Init - " + parameters.GetType().Name, "parameters"); } KeyParameter keyParameter = (KeyParameter)parameters; this.setKey(keyParameter.GetKey()); }
/** * initialise an Gost28147 cipher. * * @param forEncryption whether or not we are for encryption. * @param parameters the parameters required to set up the cipher. * @exception ArgumentException if the parameters argument is inappropriate. */ public virtual void Init( bool forEncryption, ICipherParameters parameters) { if (parameters is ParametersWithSBox) { ParametersWithSBox param = (ParametersWithSBox)parameters; // // Set the S-Box // byte[] sBox = param.GetSBox(); if (sBox.Length != Sbox_Default.Length) { throw new ArgumentException("invalid S-box passed to GOST28147 init"); } this.S = Arrays.Clone(sBox); // // set key if there is one // if (param.Parameters != null) { workingKey = generateWorkingKey(forEncryption, ((KeyParameter)param.Parameters).GetKey()); } } else if (parameters is KeyParameter) { workingKey = generateWorkingKey(forEncryption, ((KeyParameter)parameters).GetKey()); } else if (parameters != null) { throw new ArgumentException("invalid parameter passed to Gost28147 init - " + parameters.GetType().Name); } }
/** * initialise an AES cipher. * * @param forEncryption whether or not we are for encryption. * @param parameters the parameters required to set up the cipher. * @exception ArgumentException if the parameters argument is * inappropriate. */ public void Init( bool forEncryption, ICipherParameters parameters) { if (!(parameters is KeyParameter)) { throw new ArgumentException("invalid parameter passed to AES init - " + parameters.GetType().ToString()); } WorkingKey = GenerateWorkingKey(((KeyParameter)parameters).GetKey(), forEncryption); this.forEncryption = forEncryption; }
/** * initialise a RC5-32 cipher. * * @param forEncryption whether or not we are for encryption. * @param parameters the parameters required to set up the cipher. * @exception ArgumentException if the parameters argument is * inappropriate. */ public void Init(bool forEncryption, ICipherParameters parameters) { if (parameters is RC5Parameters) { var p = (RC5Parameters)parameters; _noRounds = p.Rounds; SetKey(p.GetKey()); } else if (parameters is KeyParameter) { var p = (KeyParameter)parameters; SetKey(p.GetKey()); } else { throw new ArgumentException("invalid parameter passed to RC532 init - " + parameters.GetType()); } this.forEncryption = forEncryption; }
/** * initialise a RC2 cipher. * * @param forEncryption whether or not we are for encryption. * @param parameters the parameters required to set up the cipher. * @exception ArgumentException if the parameters argument is * inappropriate. */ public void Init( bool forEncryption, ICipherParameters parameters) { this.encrypting = forEncryption; if (parameters is RC2Parameters) { RC2Parameters param = (RC2Parameters) parameters; workingKey = GenerateWorkingKey(param.GetKey(), param.EffectiveKeyBits); } else if (parameters is KeyParameter) { KeyParameter param = (KeyParameter) parameters; byte[] key = param.GetKey(); workingKey = GenerateWorkingKey(key, key.Length * 8); } else { throw new ArgumentException("invalid parameter passed to RC2 init - " + parameters.GetType().Name); } }
/** * initialise an Gost28147 cipher. * * @param forEncryption whether or not we are for encryption. * @param parameters the parameters required to set up the cipher. * @exception ArgumentException if the parameters argument is inappropriate. */ public void Init( bool forEncryption, ICipherParameters parameters) { if (parameters is ParametersWithSBox) { ParametersWithSBox param = (ParametersWithSBox)parameters; // // Set the S-Box // Array.Copy(param.GetSBox(), 0, this.S, 0, param.GetSBox().Length); // // set key if there is one // if (param.Parameters != null) { workingKey = generateWorkingKey(forEncryption, ((KeyParameter)param.Parameters).GetKey()); } } else if (parameters is KeyParameter) { workingKey = generateWorkingKey(forEncryption, ((KeyParameter)parameters).GetKey()); } else { throw new ArgumentException("invalid parameter passed to Gost28147 init - " + parameters.GetType().Name); } }
public virtual void Init(bool forEncryption, ICipherParameters parameters) { if (!(parameters is KeyParameter)) { throw new ArgumentException("invalid parameter passed to TEA init - " + parameters.GetType().FullName); } this._forEncryption = forEncryption; this._initialised = true; KeyParameter keyParameter = (KeyParameter)parameters; this.setKey(keyParameter.GetKey()); }
/** * initialise an AES cipher. * * @param forEncryption whether or not we are for encryption. * @param parameters the parameters required to set up the cipher. * @exception ArgumentException if the parameters argument is * inappropriate. */ public void Init( bool forEncryption, ICipherParameters parameters) { if (!(parameters is KeyParameter)) throw new ArgumentException("invalid parameter passed to AES init - " + parameters.GetType().ToString()); WorkingKey = GenerateWorkingKey(((KeyParameter)parameters).GetKey(), forEncryption); this.forEncryption = forEncryption; }
private int X0, X1, X2, X3; // registers /** * initialise a Serpent cipher. * * @param forEncryption whether or not we are for encryption. * @param parameters the parameters required to set up the cipher. * @exception ArgumentException if the parameters argument is * inappropriate. */ public virtual void Init( bool forEncryption, ICipherParameters parameters) { if (!(parameters is KeyParameter)) { throw new ArgumentException("invalid parameter passed to Serpent init - " + parameters.GetType().ToString()); } this.encrypting = forEncryption; this.wKey = MakeWorkingKey(((KeyParameter)parameters).GetKey()); }
/** * initialise * * @param forEncryption whether or not we are for encryption. * @param params the parameters required to set up the cipher. * @exception ArgumentException if the params argument is * inappropriate. */ public virtual void Init( bool forEncryption, ICipherParameters parameters) { if (!(parameters is KeyParameter)) { throw new ArgumentException("Invalid parameters passed to Noekeon init - " + parameters.GetType().Name, "parameters"); } _forEncryption = forEncryption; _initialised = true; KeyParameter p = (KeyParameter)parameters; setKey(p.GetKey()); }
/** * initialise a RC5-32 cipher. * * @param forEncryption whether or not we are for encryption. * @param parameters the parameters required to set up the cipher. * @exception ArgumentException if the parameters argument is * inappropriate. */ public virtual void Init( bool forEncryption, ICipherParameters parameters) { if (typeof(RC5Parameters).IsInstanceOfType(parameters)) { RC5Parameters p = (RC5Parameters)parameters; _noRounds = p.Rounds; SetKey(p.GetKey()); } else if (typeof(KeyParameter).IsInstanceOfType(parameters)) { KeyParameter p = (KeyParameter)parameters; SetKey(p.GetKey()); } else { throw new ArgumentException("invalid parameter passed to RC532 init - " + parameters.GetType().ToString()); } this.forEncryption = forEncryption; }
/** * initialise a RC5-32 cipher. * * @param forEncryption whether or not we are for encryption. * @param parameters the parameters required to set up the cipher. * @exception ArgumentException if the parameters argument is * inappropriate. */ public void Init( bool forEncryption, ICipherParameters parameters) { //TODO: SUSTITUIDO. CAMBIAMOS EL IsInstanceOfType POR UN BLOQUE try - catch //if (typeof(RC5Parameters).IsInstanceOfType(parameters)) //{ // RC5Parameters p = (RC5Parameters)parameters; // _noRounds = p.Rounds; // SetKey(p.GetKey()); //} //else if (typeof(KeyParameter).GetType().IsInstanceOfType(parameters)) //{ // KeyParameter p = (KeyParameter)parameters; // SetKey(p.GetKey()); //} //else //{ // throw new ArgumentException("invalid parameter passed to RC532 init - " + parameters.GetType().ToString()); //} //this.forEncryption = forEncryption; try{ RC5Parameters p = (RC5Parameters)parameters; _noRounds = p.Rounds; SetKey(p.GetKey()); } catch (Exception e) { try { KeyParameter p = (KeyParameter)parameters; SetKey(p.GetKey()); } catch (Exception e2) { throw new ArgumentException("invalid parameter passed to RC532 init - " + parameters.GetType().ToString() + " e:" + e + " : " + e2); } } this.forEncryption = forEncryption; }
/** * initialise a Twofish cipher. * * @param forEncryption whether or not we are for encryption. * @param parameters the parameters required to set up the cipher. * @exception ArgumentException if the parameters argument is * inappropriate. */ public void Init( bool forEncryption, ICipherParameters parameters) { if (!(parameters is KeyParameter)) throw new ArgumentException("invalid parameter passed to Twofish init - " + parameters.GetType().ToString()); this.encrypting = forEncryption; this.workingKey = ((KeyParameter)parameters).GetKey(); this.k64Cnt = (this.workingKey.Length / 8); // pre-padded ? SetKey(this.workingKey); }
public void Init(ICipherParameters parameters) { SkeinParameters skeinParameters; if (parameters is SkeinParameters) { skeinParameters = (SkeinParameters)parameters; } else { if (!(parameters is KeyParameter)) { throw new ArgumentException("Invalid parameter passed to Skein MAC init - " + parameters.GetType().Name); } skeinParameters = new SkeinParameters.Builder().SetKey(((KeyParameter)parameters).GetKey()).Build(); } if (skeinParameters.GetKey() == null) { throw new ArgumentException("Skein MAC requires a key parameter."); } this.engine.Init(skeinParameters); }
/** * initialise a CAST cipher. * * @param forEncryption whether or not we are for encryption. * @param parameters the parameters required to set up the cipher. * @exception ArgumentException if the parameters argument is * inappropriate. */ public void Init( bool forEncryption, ICipherParameters parameters) { if (!(parameters is KeyParameter)) throw new ArgumentException("Invalid parameter passed to "+ AlgorithmName +" init - " + parameters.GetType().ToString()); _encrypting = forEncryption; _workingKey = ((KeyParameter)parameters).GetKey(); SetKey(_workingKey); }
public virtual void Init(bool forEncryption, ICipherParameters parameters) { ICipherParameters cipherParameters = parameters; if (parameters is ParametersWithIV) { this.iv = ((ParametersWithIV)parameters).GetIV(); cipherParameters = ((ParametersWithIV)parameters).Parameters; } else { this.iv = new byte[0]; } if (cipherParameters is KeyParameter) { this.key = ((KeyParameter)cipherParameters).GetKey(); this.Init(); this.initialised = true; return; } throw new ArgumentException("Invalid parameter passed to HC128 init - " + parameters.GetType().Name, "parameters"); }
/** * initialise a DESede cipher. * * @param forEncryption whether or not we are for encryption. * @param parameters the parameters required to set up the cipher. * @exception ArgumentException if the parameters argument is * inappropriate. */ public override void Init( bool forEncryption, ICipherParameters parameters) { if (parameters == null) { return; // already initialised } if (!(parameters is KeyParameter)) { throw new ArgumentException("invalid parameter passed to DESede init - " + parameters.GetType().ToString()); } byte[] keyMaster = ((KeyParameter)parameters).GetKey(); if (keyMaster.Length != 24 && keyMaster.Length != 16) { throw new ArgumentException("key size must be 16 or 24 bytes."); } this.forEncryption = forEncryption; byte[] key1 = new byte[8]; Array.Copy(keyMaster, 0, key1, 0, key1.Length); workingKey1 = GenerateWorkingKey(forEncryption, key1); byte[] key2 = new byte[8]; Array.Copy(keyMaster, 8, key2, 0, key2.Length); workingKey2 = GenerateWorkingKey(!forEncryption, key2); if (keyMaster.Length == 24) { byte[] key3 = new byte[8]; Array.Copy(keyMaster, 16, key3, 0, key3.Length); workingKey3 = GenerateWorkingKey(forEncryption, key3); } else // 16 byte key { workingKey3 = workingKey1; } // note: blockCount can only go to zero on cipher initialization. blockCount = 0; }
public void Init(bool forEncryption, ICipherParameters parameters) { if (!(parameters is KeyParameter)) { throw new ArgumentException("invalid parameter passed to Twofish init - " + parameters.GetType().ToString()); } this.encrypting = forEncryption; this.workingKey = ((KeyParameter)parameters).GetKey(); this.k64Cnt = this.workingKey.Length / 8; this.SetKey(this.workingKey); }
/** * initialise a RC5-64 cipher. * * @param forEncryption whether or not we are for encryption. * @param parameters the parameters required to set up the cipher. * @exception ArgumentException if the parameters argument is * inappropriate. */ public void Init( bool forEncryption, ICipherParameters parameters) { if (!(typeof(RC5Parameters).IsInstanceOfType(parameters))) { throw new ArgumentException("invalid parameter passed to RC564 init - " + parameters.GetType().ToString()); } RC5Parameters p = (RC5Parameters)parameters; this.forEncryption = forEncryption; _noRounds = p.Rounds; SetKey(p.GetKey()); }
/** * initialise a RC5-32 cipher. * * @param forEncryption whether or not we are for encryption. * @param parameters the parameters required to set up the cipher. * @exception ArgumentException if the parameters argument is * inappropriate. */ public void Init( bool forEncryption, ICipherParameters parameters) { if (!(parameters is KeyParameter)) { throw new ArgumentException("invalid parameter passed to RC6 init - " + parameters.GetType().ToString()); } this.forEncryption = forEncryption; KeyParameter p = (KeyParameter)parameters; SetKey(p.GetKey()); }
/** * initialise a RC2 cipher. * * @param forEncryption whether or not we are for encryption. * @param parameters the parameters required to set up the cipher. * @exception ArgumentException if the parameters argument is * inappropriate. */ public virtual void Init( bool forEncryption, ICipherParameters parameters) { this.encrypting = forEncryption; if (parameters is RC2Parameters) { RC2Parameters param = (RC2Parameters)parameters; workingKey = GenerateWorkingKey(param.GetKey(), param.EffectiveKeyBits); } else if (parameters is KeyParameter) { KeyParameter param = (KeyParameter)parameters; byte[] key = param.GetKey(); workingKey = GenerateWorkingKey(key, key.Length * 8); } else { throw new ArgumentException("invalid parameter passed to RC2 init - " + parameters.GetType().Name); } }
public override void Init(bool forEncryption, ICipherParameters parameters) { if (!(parameters is KeyParameter)) { throw new ArgumentException("invalid parameter passed to DESede init - " + parameters.GetType().ToString()); } byte[] key = ((KeyParameter)parameters).GetKey(); if (key.Length != 24 && key.Length != 16) { throw new ArgumentException("key size must be 16 or 24 bytes."); } this.forEncryption = forEncryption; byte[] array = new byte[8]; Array.Copy(key, 0, array, 0, array.Length); workingKey1 = DesEngine.GenerateWorkingKey(forEncryption, array); byte[] array2 = new byte[8]; Array.Copy(key, 8, array2, 0, array2.Length); workingKey2 = DesEngine.GenerateWorkingKey(!forEncryption, array2); if (key.Length == 24) { byte[] array3 = new byte[8]; Array.Copy(key, 16, array3, 0, array3.Length); workingKey3 = DesEngine.GenerateWorkingKey(forEncryption, array3); } else { workingKey3 = workingKey1; } }
/** * initialise a Rijndael cipher. * * @param forEncryption whether or not we are for encryption. * @param parameters the parameters required to set up the cipher. * @exception ArgumentException if the parameters argument is * inappropriate. */ public void Init( bool forEncryption, ICipherParameters parameters) { var parameter = parameters as KeyParameter; if (parameter != null) { workingKey = GenerateWorkingKey(parameter.GetKey()); this.forEncryption = forEncryption; return; } throw new ArgumentException("invalid parameter passed to Rijndael init - " + parameters.GetType()); }
/** * initialise an Gost28147 cipher. * * @param forEncryption whether or not we are for encryption. * @param parameters the parameters required to set up the cipher. * @exception ArgumentException if the parameters argument is inappropriate. */ public void Init( bool forEncryption, ICipherParameters parameters) { if (parameters is ParametersWithSBox) { ParametersWithSBox param = (ParametersWithSBox)parameters; // // Set the S-Box // byte[] sBox = param.GetSBox(); if (sBox.Length != Sbox_Default.Length) throw new ArgumentException("invalid S-box passed to GOST28147 init"); this.S = Arrays.Clone(sBox); // // set key if there is one // if (param.Parameters != null) { workingKey = generateWorkingKey(forEncryption, ((KeyParameter)param.Parameters).GetKey()); } } else if (parameters is KeyParameter) { workingKey = generateWorkingKey(forEncryption, ((KeyParameter)parameters).GetKey()); } else if (parameters != null) { throw new ArgumentException("invalid parameter passed to Gost28147 init - " + parameters.GetType().Name); } }
/** * initialise a DESede cipher. * * @param forEncryption whether or not we are for encryption. * @param parameters the parameters required to set up the cipher. * @exception ArgumentException if the parameters argument is * inappropriate. */ public override void Init( bool forEncryption, ICipherParameters parameters) { if (!(parameters is KeyParameter)) { throw new ArgumentException("invalid parameter passed to DESede init - " + parameters.GetType().ToString()); } byte[] keyMaster = ((KeyParameter)parameters).GetKey(); this.forEncryption = forEncryption; byte[] key1 = new byte[8]; Array.Copy(keyMaster, 0, key1, 0, key1.Length); workingKey1 = GenerateWorkingKey(forEncryption, key1); byte[] key2 = new byte[8]; Array.Copy(keyMaster, 8, key2, 0, key2.Length); workingKey2 = GenerateWorkingKey(!forEncryption, key2); if (keyMaster.Length == 24) { byte[] key3 = new byte[8]; Array.Copy(keyMaster, 16, key3, 0, key3.Length); workingKey3 = GenerateWorkingKey(forEncryption, key3); } else // 16 byte key { workingKey3 = workingKey1; } }
/** * initialise a RC5-32 cipher. * * @param forEncryption whether or not we are for encryption. * @param parameters the parameters required to set up the cipher. * @exception ArgumentException if the parameters argument is * inappropriate. */ public void Init( bool forEncryption, ICipherParameters parameters) { //TODO: SUSTITUIDO. CAMBIAMOS EL IsInstanceOfType POR UN BLOQUE try - catch //if (typeof(RC5Parameters).IsInstanceOfType(parameters)) //{ // RC5Parameters p = (RC5Parameters)parameters; // _noRounds = p.Rounds; // SetKey(p.GetKey()); //} //else if (typeof(KeyParameter).GetType().IsInstanceOfType(parameters)) //{ // KeyParameter p = (KeyParameter)parameters; // SetKey(p.GetKey()); //} //else //{ // throw new ArgumentException("invalid parameter passed to RC532 init - " + parameters.GetType().ToString()); //} //this.forEncryption = forEncryption; try{ RC5Parameters p = (RC5Parameters)parameters; _noRounds = p.Rounds; SetKey(p.GetKey()); } catch (Exception e){ try { KeyParameter p = (KeyParameter)parameters; SetKey(p.GetKey()); } catch (Exception e2) { throw new ArgumentException("invalid parameter passed to RC532 init - " + parameters.GetType().ToString()+" e:"+e+" : "+e2); } } this.forEncryption = forEncryption; }
/** * initialise a Blowfish cipher. * * @param forEncryption whether or not we are for encryption. * @param parameters the parameters required to set up the cipher. * @exception ArgumentException if the parameters argument is * inappropriate. */ public void Init( bool forEncryption, ICipherParameters parameters) { if (!(parameters is KeyParameter)) throw new ArgumentException("invalid parameter passed to Blowfish init - " + parameters.GetType().ToString()); this.encrypting = forEncryption; this.workingKey = ((KeyParameter)parameters).GetKey(); SetKey(this.workingKey); }
/** * initialise a RC5-64 cipher. * * @param forEncryption whether or not we are for encryption. * @param parameters the parameters required to set up the cipher. * @exception ArgumentException if the parameters argument is * inappropriate. */ public void Init( bool forEncryption, ICipherParameters parameters) { if (parameters == null || !typeof(RC5Parameters).GetTypeInfo().IsAssignableFrom(parameters.GetType().GetTypeInfo())) { throw new ArgumentException("invalid parameter passed to RC564 init - " + parameters.GetType().ToString()); } RC5Parameters p = (RC5Parameters)parameters; this.forEncryption = forEncryption; _noRounds = p.Rounds; SetKey(p.GetKey()); }
public virtual void Init(bool forEncryption, ICipherParameters parameters) { if (parameters is ParametersWithSBox) { ParametersWithSBox parametersWithSBox = (ParametersWithSBox)parameters; byte[] sBox = parametersWithSBox.GetSBox(); if (sBox.Length != Gost28147Engine.Sbox_Default.Length) { throw new ArgumentException("invalid S-box passed to GOST28147 init"); } this.S = Arrays.Clone(sBox); if (parametersWithSBox.Parameters != null) { this.workingKey = this.generateWorkingKey(forEncryption, ((KeyParameter)parametersWithSBox.Parameters).GetKey()); return; } } else { if (parameters is KeyParameter) { this.workingKey = this.generateWorkingKey(forEncryption, ((KeyParameter)parameters).GetKey()); return; } if (parameters != null) { throw new ArgumentException("invalid parameter passed to Gost28147 init - " + parameters.GetType().Name); } } }
/** * initialise a Rijndael cipher. * * @param forEncryption whether or not we are for encryption. * @param parameters the parameters required to set up the cipher. * @exception ArgumentException if the parameters argument is * inappropriate. */ public void Init( bool forEncryption, ICipherParameters parameters) { var parameter = parameters as KeyParameter; if (parameter != null) { workingKey = GenerateWorkingKey(parameter.GetKey()); this.forEncryption = forEncryption; return; } throw new ArgumentException("invalid parameter passed to Rijndael init - " + parameters.GetType().ToString()); }
public virtual void Init(bool forEncryption, ICipherParameters parameters) { if (!(parameters is KeyParameter)) { throw new ArgumentException("invalid parameter passed to DES init - " + parameters.GetType().ToString()); } workingKey = GenerateWorkingKey(forEncryption, ((KeyParameter)parameters).GetKey()); }
/** * initialise a Rijndael cipher. * * @param forEncryption whether or not we are for encryption. * @param parameters the parameters required to set up the cipher. * @exception ArgumentException if the parameters argument is * inappropriate. */ //TODO: COMENTADO. NO EXISTE EL TIPO "IsInstanceOfType". VAMOS A SUSTITUIRLO POR UN TRY CATCH //public void Init( // bool forEncryption, // ICipherParameters parameters) //{ // if (typeof(KeyParameter).IsInstanceOfType(parameters)) // { // workingKey = GenerateWorkingKey(((KeyParameter)parameters).GetKey()); // this.forEncryption = forEncryption; // return; // } // throw new ArgumentException("invalid parameter passed to Rijndael init - " + parameters.GetType().ToString()); //} public void Init( bool forEncryption, ICipherParameters parameters) { try { workingKey = GenerateWorkingKey(((KeyParameter)parameters).GetKey()); this.forEncryption = forEncryption; return; } catch (Exception e) { throw new ArgumentException("invalid parameter passed to Rijndael init - " + parameters.GetType().ToString()+" e:"+e); } }
/** * initialise an AES cipher. * * @param forEncryption whether or not we are for encryption. * @param parameters the parameters required to set up the cipher. * @exception ArgumentException if the parameters argument is * inappropriate. */ public virtual void Init( bool forEncryption, ICipherParameters parameters) { KeyParameter keyParameter = parameters as KeyParameter; if (keyParameter == null) { throw new ArgumentException("invalid parameter passed to AES init - " + parameters.GetType().Name); } WorkingKey = GenerateWorkingKey(keyParameter.GetKey(), forEncryption); this.forEncryption = forEncryption; }
public virtual void Init(bool forEncryption, ICipherParameters parameters) { if (!(parameters is KeyParameter)) { throw new ArgumentException("invalid parameter passed to SKIPJACK init - " + parameters.GetType().ToString()); } byte[] key = ((KeyParameter)parameters).GetKey(); this.encrypting = forEncryption; this.key0 = new int[32]; this.key1 = new int[32]; this.key2 = new int[32]; this.key3 = new int[32]; for (int i = 0; i < 32; i++) { this.key0[i] = (int)(key[i * 4 % 10] & 255); this.key1[i] = (int)(key[(i * 4 + 1) % 10] & 255); this.key2[i] = (int)(key[(i * 4 + 2) % 10] & 255); this.key3[i] = (int)(key[(i * 4 + 3) % 10] & 255); } }
public virtual void Init(bool forEncryption, ICipherParameters parameters) { if (typeof(KeyParameter).IsInstanceOfType(parameters)) { workingKey = GenerateWorkingKey(((KeyParameter)parameters).GetKey()); this.forEncryption = forEncryption; return; } throw new ArgumentException("invalid parameter passed to Rijndael init - " + parameters.GetType().ToString()); }
/** * initialise a Rijndael cipher. * * @param forEncryption whether or not we are for encryption. * @param parameters the parameters required to set up the cipher. * @exception ArgumentException if the parameters argument is * inappropriate. */ public void Init( bool forEncryption, ICipherParameters parameters) { if (typeof(KeyParameter).IsInstanceOfType(parameters)) { workingKey = GenerateWorkingKey(((KeyParameter)parameters).GetKey()); this.forEncryption = forEncryption; return; } throw new ArgumentException("invalid parameter passed to Rijndael init - " + parameters.GetType().ToString()); }
/** * initialise a CAST cipher. * * @param forEncryption whether or not we are for encryption. * @param parameters the parameters required to set up the cipher. * @exception ArgumentException if the parameters argument is * inappropriate. */ public void Init( bool forEncryption, ICipherParameters parameters) { if (!(parameters is KeyParameter)) { throw new ArgumentException("Invalid parameter passed to " + AlgorithmName + " init - " + parameters.GetType().ToString()); } _encrypting = forEncryption; _workingKey = ((KeyParameter)parameters).GetKey(); SetKey(_workingKey); }
/** * initialise an AES cipher. * * @param forEncryption whether or not we are for encryption. * @param parameters the parameters required to set up the cipher. * @exception ArgumentException if the parameters argument is * inappropriate. */ public void Init( bool forEncryption, ICipherParameters parameters) { KeyParameter keyParameter = parameters as KeyParameter; if (keyParameter == null) throw new ArgumentException("invalid parameter passed to AES init - " + parameters.GetType().Name); WorkingKey = GenerateWorkingKey(keyParameter.GetKey(), forEncryption); this.forEncryption = forEncryption; }
/** * initialise a SKIPJACK cipher. * * @param forEncryption whether or not we are for encryption. * @param parameters the parameters required to set up the cipher. * @exception ArgumentException if the parameters argument is * inappropriate. */ public void Init( bool forEncryption, ICipherParameters parameters) { if (!(parameters is KeyParameter)) { throw new ArgumentException("invalid parameter passed to SKIPJACK init - " + parameters.GetType().ToString()); } byte[] keyBytes = ((KeyParameter)parameters).GetKey(); this.encrypting = forEncryption; this.key0 = new int[32]; this.key1 = new int[32]; this.key2 = new int[32]; this.key3 = new int[32]; // // expand the key to 128 bytes in 4 parts (saving us a modulo, multiply // and an addition). // for (int i = 0; i < 32; i++) { key0[i] = keyBytes[(i * 4) % 10] & 0xff; key1[i] = keyBytes[(i * 4 + 1) % 10] & 0xff; key2[i] = keyBytes[(i * 4 + 2) % 10] & 0xff; key3[i] = keyBytes[(i * 4 + 3) % 10] & 0xff; } }
/** * initialise a RC5-32 cipher. * * @param forEncryption whether or not we are for encryption. * @param parameters the parameters required to set up the cipher. * @exception ArgumentException if the parameters argument is * inappropriate. */ public void Init( bool forEncryption, ICipherParameters parameters) { if (parameters != null && typeof(RC5Parameters).GetTypeInfo().IsAssignableFrom(parameters.GetType().GetTypeInfo())) { RC5Parameters p = (RC5Parameters)parameters; _noRounds = p.Rounds; SetKey(p.GetKey()); } else if (parameters != null && typeof(KeyParameter).GetTypeInfo().IsAssignableFrom(parameters.GetType().GetTypeInfo())) { KeyParameter p = (KeyParameter)parameters; SetKey(p.GetKey()); } else { throw new ArgumentException("invalid parameter passed to RC532 init - " + parameters.GetType().ToString()); } this.forEncryption = forEncryption; }
/** * initialise a Rijndael cipher. * * @param forEncryption whether or not we are for encryption. * @param parameters the parameters required to set up the cipher. * @exception ArgumentException if the parameters argument is * inappropriate. */ public void Init( bool forEncryption, ICipherParameters parameters) { if (parameters != null && typeof(KeyParameter).GetTypeInfo().IsAssignableFrom(parameters.GetType().GetTypeInfo())) { workingKey = GenerateWorkingKey(((KeyParameter)parameters).GetKey()); this.forEncryption = forEncryption; return; } throw new ArgumentException("invalid parameter passed to Rijndael init - " + parameters.GetType().ToString()); }