public static byte[] XTS(byte[] Key1, byte[] Key2, int SectorSize, byte[] Data, ulong Sector, bool Encrypt) { byte[] TransformedBytes, BlockData; Xts XTS128 = XtsAes128.Create(Key1, Key2); int Blocks; var MemStrm = new MemoryStream(); var Writer = new BinaryWriter(MemStrm); XtsCryptoTransform CryptoTransform; if (Encrypt) { CryptoTransform = XTS128.CreateEncryptor(); } else { CryptoTransform = XTS128.CreateDecryptor(); } BlockData = new byte[SectorSize]; Blocks = Data.Length / SectorSize; for (int i = 0; i < Blocks; i++) { CryptoTransform.TransformBlock(Data, i * SectorSize, SectorSize, BlockData, 0, Sector++); Writer.Write(BlockData); } TransformedBytes = MemStrm.ToArray(); return(TransformedBytes); }
private void Decrypt_Click(object sender, RoutedEventArgs e) { var inputString = EncryptInputTextBox.Text; CryptoTransform cryptoTransform = new CryptoTransform(Helper.PASSPHRASE, Helper.INITVECTOR); var outputString = cryptoTransform.Decrypt(inputString); DecryptOutputTextBox.Text = outputString; }
public unsafe override void Transform(byte[] input) { byte[] buffer = new byte[BlockSize]; for (int i = 0; i < input.Length; i += BlockSize) { CryptoTransform.TransformBlock(x, 0, BlockSize, buffer, 0); input.Xor(i, buffer, 0, BlockSize); x.Increment(); } }
protected CryptoTransform GetTransform(string peerId) { CryptoTransform transform; lock (_transforms) { if (!_transforms.TryGetValue(peerId, out transform)) { // we prepend RijndaelV1 to peerId to make possible future changes to RijndaelEncryptionProvider logic (for example increasing key or IV size). // if we use unchanged peerId (user id) then it will be impossilbe to store ecnryption keys of different sizes and encryption provider versioning will be broken. var key =_encryptionEncryptionKeyProvider.GetEncryptionKey("RijndaelV1." + peerId, CryptoProvider.KeySize / 8, CryptoProvider.BlockSize / 8); transform = new CryptoTransform(CryptoProvider.CreateEncryptor(key.Key, key.IV), CryptoProvider.CreateDecryptor(key.Key, key.IV)); _transforms.Add(peerId, transform); } } return transform; }
public void Transform(byte[] data, int offset, int length, byte[] output, int outputOffset) { for (var i = 0; i < length; i++) { if (Number == 0) { CryptoTransform.TransformBlock(Iv, 0, Iv.Length, Xor, 0); for (var j = 15; j >= 0; j--) { Iv[j]++; if (Iv[j] != 0) { break; } } } output[i + outputOffset] = (byte)(data[i + offset] ^ Xor[Number]); Number = (Number + 1) & 0xF; } }
/// <summary> /// Calls <see cref="Finish"/> and closes the underlying /// stream when <see cref="IsStreamOwner"></see> is true. /// </summary> /// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param> protected override void Dispose(bool disposing) { if (!isClosed) { isClosed = true; try { Finish(); if (CryptoTransform != null) { CryptoTransform.Dispose(); CryptoTransform = null; } } finally { if (IsStreamOwner) { BaseOutputStream.Dispose(); } } } }
private void InputToOutput(Encoding encode) { otp = OneTimePadAlgorithm.Create(); otp.setInputLength(txtInput.Text.Length); if (rbEncrypt.Checked) { bool isNumeric = int.TryParse(txtSeed.Text, out _); if (isNumeric) { otp.setStringSeed(int.Parse(txtSeed.Text)); } else { otp.setStringSeed(txtSeed.Text); } otp.GenerateKey(); CryptoTransform ict = (CryptoTransform)otp.CreateEncryptor(otp.Key, null); byte[] inputText = encode.GetBytes(txtInput.Text); txtOTP.Text = encode.GetString(otp.Key); txtOutput.Text = encode.GetString(ict.TransformFinalBlock(inputText, 0, txtInput.Text.Length)); } else { otp.Key = encode.GetBytes(txtOTP.Text); CryptoTransform ict = (CryptoTransform)otp.CreateDecryptor(otp.Key, null); byte[] inputText = encode.GetBytes(txtInput.Text); txtOutput.Text = encode.GetString(ict.TransformFinalBlock(inputText, 0, txtInput.Text.Length)); } }
/// <summary> /// Encrypt a block of data. /// </summary> /// <param name="buffer"> /// Data to encrypt. NOTE the original contents of the buffer are lost. /// </param> /// <param name="offset"> /// Offset of first byte in buffer to encrypt. /// </param> /// <param name="length"> /// Number of bytes in buffer to encrypt. /// </param> protected void EncryptBlock(byte[] buffer, int offset, int length) { CryptoTransform.TransformBlock(buffer, offset, length, buffer, 0); }
public override byte[] TransformFinal(byte[] input) { return(CryptoTransform.TransformFinalBlock(input, 0, input.Length)); }
public override void Transform(byte[] input) { CryptoTransform.TransformBlock(input, 0, input.Length, input, 0); }
public void Dispose() { CryptoTransform.Dispose(); }
/// <summary> /// 创建签名秘钥 /// </summary> /// <param name="lenght">签名秘钥字节长度</param> /// <returns>签名Key Base64字符串</returns> public String CreatedSignKey(int lenght = 64) { return(CryptoTransform.CreateKey(lenght)); }