public IBlockTransformer CreateDecryptor(BlockCipherMode mode, byte[] key, byte[] iv) { switch (PlatformDetector.GetCurrentPlatform()) { case OperatingPlatform.Windows: return(new BCryptAesTransformer(mode, key, iv, false)); default: throw new PlatformNotSupportedException("The current system platform is not supported."); } }
public static void SetBlockChainingMode(IntPtr hAlgorithmProvider, BlockCipherMode mode) { string chainingModeValue; switch (mode) { case BlockCipherMode.CBC: chainingModeValue = BCryptConstants.BCRYPT_CHAIN_MODE_CBC; break; case BlockCipherMode.CCM: chainingModeValue = BCryptConstants.BCRYPT_CHAIN_MODE_CCM; break; case BlockCipherMode.CFB: chainingModeValue = BCryptConstants.BCRYPT_CHAIN_MODE_CFB; break; case BlockCipherMode.ECB: chainingModeValue = BCryptConstants.BCRYPT_CHAIN_MODE_ECB; break; case BlockCipherMode.GCM: chainingModeValue = BCryptConstants.BCRYPT_CHAIN_MODE_GCM; break; case BlockCipherMode.Unspecified: chainingModeValue = BCryptConstants.BCRYPT_CHAIN_MODE_NA; break; default: throw new ArgumentException("The specified block cipher chaining mode is not recognized.", nameof(mode)); } GCHandle gcChainingModeValue = GCHandle.Alloc(chainingModeValue, GCHandleType.Pinned); uint result; try { result = BCryptCore.BCryptSetProperty(hAlgorithmProvider, BCryptConstants.BCRYPT_CHAINING_MODE, gcChainingModeValue.AddrOfPinnedObject(), (ulong)chainingModeValue.Length, 0); } finally { gcChainingModeValue.Free(); } if (result != 0) { throw new SystemException("An error was encountered while setting the cipher chaining mode."); } }
/// <summary> /// Create a configuration for a block cipher. /// </summary> /// <param name="cipher">Block cipher to use.</param> /// <param name="mode">Mode of operation for the cipher.</param> /// <param name="padding">Padding scheme to use with the mode, where necessary (e.g. CBC).</param> /// <param name="keySize">Key size to use, in bits.</param> /// <param name="blockSize">Cipher block size to use, in bits.</param> /// <returns>Block cipher configuration DTO.</returns> public static CipherConfiguration CreateBlockCipherConfiguration(BlockCipher cipher, BlockCipherMode mode, BlockCipherPadding padding, int?keySize = null, int?blockSize = null) { var config = new CipherConfiguration { Type = CipherType.Block }; // Set the key size int keySizeNonNull = keySize ?? Athena.Cryptography.BlockCiphers[cipher].DefaultKeySizeBits; if (keySize == null || Athena.Cryptography.BlockCiphers[cipher].AllowableKeySizesBits.Contains(keySizeNonNull)) { config.KeySizeBits = keySizeNonNull; } else { throw new CipherKeySizeException(cipher, keySizeNonNull); } // Set the block size int blockSizeNonNull = blockSize ?? Athena.Cryptography.BlockCiphers[cipher].DefaultBlockSizeBits; if (blockSize == null || Athena.Cryptography.BlockCiphers[cipher].AllowableBlockSizesBits.Contains(blockSizeNonNull)) { config.BlockSizeBits = blockSizeNonNull; } else { throw new BlockSizeException(cipher, blockSizeNonNull); } // Set the mode if (Athena.Cryptography.BlockCipherModes[mode].PaddingRequirement == PaddingRequirement.Always && padding == BlockCipherPadding.None) { throw new ArgumentException(mode + " mode must be used with padding or errors will occur when plaintext length is not equal to or a multiple of the block size."); } config.ModeName = mode.ToString(); config.PaddingName = padding.ToString(); config.CipherName = cipher.ToString(); config.InitialisationVector = new byte[config.BlockSizeBits.Value / 8]; StratCom.EntropySupplier.NextBytes(config.InitialisationVector); return(config); }
private static void SendKeysToNodes(BlockCipherMode mode) { switch (mode) { case BlockCipherMode.ECB: _socketA.WriteBytes(Secrets.KeyEcb.Encrypt(Secrets.Key3).GetB()); break; case BlockCipherMode.CFB: _socketB.WriteBytes(Secrets.KeyCfb.Encrypt(Secrets.Key3).GetB()); _socketB.WriteBytes(Secrets.Iv.Encrypt(Secrets.Key3).GetB()); break; default: throw new ArgumentOutOfRangeException(nameof(mode), mode, null); } }
public ClientBehavior(BlockCipherMode modeChoice) { this.modeChoice = modeChoice; _sender = GetClientSocket(); this.modeFinal = GetFinalMode(); Debug("Final mode chosen"); alg = getSecurityAlgorithm(); return; var inputList = "heyy looka this 1234g5g5asd789a9sd3".SplitInBlocks(); var encryptedList = alg.EncryptList(inputList); var decryptedlist = alg.DecryptList(encryptedList); Debug(inputList.ToString()); Debug(encryptedList.ToString()); Debug(decryptedlist.ToString()); }
public BCryptAesTransformer(BlockCipherMode mode, byte[] key, byte[] iv, bool isEncrypting) { this.mode = mode; uint result = BCryptCore.BCryptOpenAlgorithmProvider(out this.hAlgorithmProvider, "AES", null, 0); if (result != 0) { throw new SystemException("An error was encountered while opening the algorithm provider."); } BCryptHelper.SetBlockChainingMode(this.hAlgorithmProvider, mode); result = BCryptCore.BCryptGenerateSymmetricKey(this.hAlgorithmProvider, out this.hKey, null, 0, key, (ulong)key.Length, 0); if (result != 0) { throw new SystemException("An error was encountered while generating a symmetric key."); } this.iv = iv; this.isEncrypting = isEncrypting; }
protected BlockCipher(BlockCipherMode mode) => Mode = mode;
public SecurityAlgorithm(Block key, Block iv, BlockCipherMode mode) { _key = key ?? throw new ArgumentNullException(nameof(key)); _iv = iv != null || mode != BlockCipherMode.CFB ? iv : throw new ArgumentNullException(nameof(iv)); _mode = mode; }
/// <summary> /// Implements a mode of operation on top of an existing block cipher. /// </summary> /// <param name="cipher">The block cipher to implement this mode of operation on top of.</param> /// <param name="modeEnum">The mode of operation to implement.</param> /// <returns> /// A <see cref="BlockCipherBase" /> object implementing the relevant mode of operation, /// overlaying the supplied symmetric block cipher. /// </returns> public static BlockCipherModeBase OverlayBlockCipherWithMode(BlockCipherBase cipher, BlockCipherMode modeEnum) { Contract.Requires <ArgumentNullException>(cipher != null); Contract.Requires(modeEnum != BlockCipherMode.None, "Cannot instantiate null mode of operation."); BlockCipherModeBase cipherMode = ModeInstantiatorsBlock[modeEnum](cipher); return(cipherMode); }
/// <summary> /// Instantiate the block cipher mode of operation. /// </summary> /// <param name="modeIdentity">Type of the mode of operation. Used to provide and verify configuration.</param> /// <param name="cipher">Block cipher to wrap with operation mode.</param> /// <param name="blockSize"></param> protected BlockCipherModeBase(BlockCipherMode modeIdentity, BlockCipherBase cipher, int?blockSize = null) { CipherModeIdentity = modeIdentity; BlockCipher = cipher; CipherBlockSize = blockSize ?? cipher.BlockSize; }