private static byte[] EncryptKey(byte[] stretchedKey, byte[] buffer, int offset)
{
using var twofish = new TwofishManaged();
twofish.Mode = CipherMode.ECB;
twofish.Padding = PaddingMode.None;
twofish.KeySize = 256;
twofish.Key = stretchedKey;
using var transform = twofish.CreateEncryptor();
return(transform.TransformFinalBlock(buffer, offset, 32));
}
public void Twofish_MultiBlockFinal_ECB_256_Encrypt()
{
var key = ParseBytes("0000000000000000000000000000000000000000000000000000000000000000");
var pt = ParseBytes("000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000");
using (var algorithm = new TwofishManaged()
{
KeySize = 256, Mode = CipherMode.ECB, Padding = PaddingMode.None
}) {
algorithm.Key = key;
var ct = algorithm.CreateEncryptor().TransformFinalBlock(pt, 0, pt.Length);
Assert.AreEqual("57FF739D4DC92C1BD7FC01700CC8216F57FF739D4DC92C1BD7FC01700CC8216F57FF739D4DC92C1BD7FC01700CC8216F", BitConverter.ToString(ct).Replace("-", ""));
}
}
public void Twofish_TransformBlock_Encrypt_UseSameArray()
{
var key = ParseBytes("00000000000000000000000000000000");
var iv = ParseBytes("00000000000000000000000000000000");
var ctpt = Encoding.UTF8.GetBytes("The quick brown fox jumps over the lazy dog once");
using (var twofish = new TwofishManaged()
{
Mode = CipherMode.CBC, Padding = PaddingMode.None, KeySize = 128, Key = key, IV = iv
}) {
using (var transform = twofish.CreateEncryptor()) {
transform.TransformBlock(ctpt, 0, 48, ctpt, 0);
}
}
Assert.AreEqual("B0DD30E9AB1F1329C1BEE154DDBE88AF8C47A4FE24D56DC027ED503652C9D164CE26E0C6E32BCA8756482B99988E8C79", BitConverter.ToString(ctpt).Replace("-", ""));
}
public void Twofish_MultiBlockFinal_CBC_256_Encrypt()
{
var key = ParseBytes("0000000000000000000000000000000000000000000000000000000000000000");
var iv = ParseBytes("00000000000000000000000000000000");
var pt = ParseBytes("9F589F5CF6122C32B6BFEC2F2AE8C35A9F589F5CF6122C32B6BFEC2F2AE8C35A9F589F5CF6122C32B6BFEC2F2AE8C35A");
using (var algorithm = new TwofishManaged()
{
KeySize = 256, Mode = CipherMode.CBC, Padding = PaddingMode.None
}) {
algorithm.Key = key;
algorithm.IV = iv;
var ct = algorithm.CreateEncryptor().TransformFinalBlock(pt, 0, pt.Length);
Assert.AreEqual("61B5BC459C4E9491DD9E6ACB7478813047BE7250D34F792C17F0C23583C0B040B95C9FAE11107EE9BAC3D79BBFE019EE", BitConverter.ToString(ct).Replace("-", ""));
}
}
public static void Main(string[] args)
{
Console.Title = "Twofish.Tests";
var bIn = Encoding.UTF8.GetBytes("It works!");
byte[] key = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 }; // 128bit key
byte[] iv = { 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 }; // initialization vector
using (var algorithm = new TwofishManaged {
KeySize = key.Length * 8, Mode = CipherMode.CBC
})
{
byte[] encrypted;
using (var ms = new MemoryStream())
{
using (var transform = algorithm.CreateEncryptor(key, iv))
{
using (var cs = new CryptoStream(ms, transform, CryptoStreamMode.Write))
{
cs.Write(bIn, 0, bIn.Length);
}
}
encrypted = ms.ToArray();
Console.WriteLine($"Encrypted: {BitConverter.ToString(encrypted).Replace("-", string.Empty)}");
}
using (var ms = new MemoryStream())
{
using (var transform = algorithm.CreateDecryptor(key, iv))
{
using (var cs = new CryptoStream(ms, transform, CryptoStreamMode.Write))
{
cs.Write(encrypted, 0, encrypted.Length);
}
}
Console.WriteLine($"Decrypted: {Encoding.UTF8.GetString(ms.ToArray())}");
}
}
Console.Read();
}
public static bool TestTwofish()
{
TwofishManaged twofish = new TwofishManaged();
twofish.Padding = PaddingMode.None;
twofish.Mode = CipherMode.ECB;
byte[] key = new byte[] { 0xD4, 0x3B, 0xB7, 0x55, 0x6E, 0xA3, 0x2E, 0x46, 0xF2, 0xA2, 0x82, 0xB7, 0xD4, 0x5B, 0x4E, 0x0D, 0x57, 0xFF, 0x73, 0x9D, 0x4D, 0xC9, 0x2C, 0x1B, 0xD7, 0xFC, 0x01, 0x70, 0x0C, 0xC8, 0x21, 0x6F };
byte[] plaintext = new byte[] { 0x90, 0xAF, 0xE9, 0x1B, 0xB2, 0x88, 0x54, 0x4F, 0x2C, 0x32, 0xDC, 0x23, 0x9B, 0x26, 0x35, 0xE6 };
byte[] ciphertext = new byte[] { 0x6C, 0xB4, 0x56, 0x1C, 0x40, 0xBF, 0x0A, 0x97, 0x05, 0x93, 0x1C, 0xB6, 0xD4, 0x08, 0xE7, 0xFA };
byte[] initializationVector = new byte[16];
ICryptoTransform encryptor = twofish.CreateEncryptor(key, initializationVector);
ICryptoTransform decryptor = twofish.CreateDecryptor(key, initializationVector);
byte[] result1 = new byte[16];
byte[] result2 = new byte[16];
encryptor.TransformBlock(plaintext, 0, 16, result1, 0);
decryptor.TransformBlock(ciphertext, 0, 16, result2, 0);
return(ByteUtils.AreByteArraysEqual(result1, ciphertext) && ByteUtils.AreByteArraysEqual(result2, plaintext));
}
public void Save(Stream stream, byte[] passphraseBuffer)
{
if (stream == null)
{
throw new ArgumentNullException(nameof(stream), "Stream cannot be null.");
}
if (passphraseBuffer == null)
{
throw new ArgumentNullException(nameof(passphraseBuffer), "Passphrase cannot be null.");
}
if (!this.IsReadOnly && this.TrackModify)
{
this.Headers[HeaderType.TimestampOfLastSave].Time = DateTime.UtcNow;
var assemblyName = Assembly.GetExecutingAssembly().GetName();
this.Headers[HeaderType.WhatPerformedLastSave].Text = string.Format(CultureInfo.InvariantCulture, "{0} V{1}.{2:00}", assemblyName.Name, assemblyName.Version.Major, assemblyName.Version.Minor);
this.Headers[HeaderType.LastSavedByUser].Text = Environment.UserName;
this.Headers[HeaderType.LastSavedOnHost].Text = Environment.MachineName;
}
byte[] stretchedKey = null;
byte[] keyK = null;
byte[] keyL = null;
//byte[] data = null;
try {
stream.Write(BitConverter.GetBytes(Tag), 0, 4);
var salt = new byte[32];
Rnd.GetBytes(salt);
stream.Write(salt, 0, salt.Length);
this.Iterations = this.Iterations; //to force minimum iteration count
var iter = (uint)this.Iterations;
stream.Write(BitConverter.GetBytes(iter), 0, 4);
stretchedKey = GetStretchedKey(passphraseBuffer, salt, iter);
stream.Write(GetSha256Hash(stretchedKey), 0, 32);
keyK = new byte[32];
Rnd.GetBytes(keyK);
stream.Write(EncryptKey(stretchedKey, keyK, 0), 0, 32);
keyL = new byte[32];
Rnd.GetBytes(keyL);
stream.Write(EncryptKey(stretchedKey, keyL, 0), 0, 32);
var iv = new byte[16];
Rnd.GetBytes(iv);
stream.Write(iv, 0, iv.Length);
using (var dataHash = new HMACSHA256(keyL))
using (var twofish = new TwofishManaged()) {
twofish.Mode = CipherMode.CBC;
twofish.Padding = PaddingMode.None;
twofish.KeySize = 256;
twofish.Key = keyK;
twofish.IV = iv;
using (var dataEncryptor = twofish.CreateEncryptor()) {
foreach (var field in this.Headers)
{
WriteBlock(stream, dataHash, dataEncryptor, (byte)field.HeaderType, field.RawData);
}
WriteBlock(stream, dataHash, dataEncryptor, (byte)HeaderType.EndOfEntry, new byte[] { });
foreach (var entry in this.Entries)
{
foreach (var field in entry.Records)
{
WriteBlock(stream, dataHash, dataEncryptor, (byte)field.RecordType, field.RawData);
}
WriteBlock(stream, dataHash, dataEncryptor, (byte)RecordType.EndOfEntry, new byte[] { });
}
}
dataHash.TransformFinalBlock(new byte[] { }, 0, 0);
stream.Write(BitConverter.GetBytes(Tag), 0, 4);
stream.Write(BitConverter.GetBytes(TagEof), 0, 4);
stream.Write(BitConverter.GetBytes(Tag), 0, 4);
stream.Write(BitConverter.GetBytes(TagEof), 0, 4);
stream.Write(dataHash.Hash, 0, dataHash.Hash.Length);
this.HasChanged = false;
}
} finally {
if (stretchedKey != null)
{
Array.Clear(stretchedKey, 0, stretchedKey.Length);
}
if (keyK != null)
{
Array.Clear(keyK, 0, keyK.Length);
}
if (keyL != null)
{
Array.Clear(keyL, 0, keyL.Length);
}
//if (data != null) { Array.Clear(data, 0, data.Length); }
}
}
/// <summary>
/// Save document.
/// If key buffer is given, keys won't be randomized. This will reduce security!
/// If passphrase is null, attempt will be made to use passphrase that was used for load.
/// </summary>
/// <param name="stream">Stream.</param>
/// <param name="passphraseBuffer">Password bytes. Caller has to avoid keeping bytes unencrypted in memory.</param>
/// <param name="keyBuffer">Key bytes containing both key K and L. Must be 64 bytes. Caller has to avoid keeping bytes unencrypted in memory.</param>
internal void InternalSave(Stream stream, byte[]?passphraseBuffer, byte[]?keyBuffer)
{
if (passphraseBuffer == null)
{
passphraseBuffer = GetPassphrase();
} //first try old passphrase
if (passphraseBuffer == null)
{
throw new ArgumentNullException(nameof(passphraseBuffer), "Passphrase cannot be null.");
}
if ((keyBuffer != null) && (keyBuffer.Length != 64))
{
throw new ArgumentOutOfRangeException(nameof(keyBuffer), "Keys must be 64 bytes long.");
}
if (!IsReadOnly && TrackModify)
{
Headers[HeaderType.TimestampOfLastSave].Time = DateTime.UtcNow;
var assemblyName = Assembly.GetExecutingAssembly().GetName();
Headers[HeaderType.WhatPerformedLastSave].Text = string.Format(CultureInfo.InvariantCulture, "{0} V{1}.{2:00}", assemblyName.Name, assemblyName.Version?.Major ?? 0, assemblyName.Version?.Minor ?? 0);
Headers[HeaderType.LastSavedByUser].Text = Environment.UserName;
Headers[HeaderType.LastSavedOnHost].Text = Environment.MachineName;
}
byte[]? stretchedKey = null;
byte[]? keyK = null;
byte[]? keyL = null;
try {
stream.Write(BitConverter.GetBytes(Tag), 0, 4);
var salt = new byte[32];
Rnd.GetBytes(salt);
stream.Write(salt, 0, salt.Length);
if (Iterations < 2048)
{
Iterations = 2048;
} // to force minimum iteration count
var iter = (uint)Iterations;
stream.Write(BitConverter.GetBytes(iter), 0, 4);
stretchedKey = GetStretchedKey(passphraseBuffer, salt, iter);
stream.Write(GetSha256Hash(stretchedKey), 0, 32);
keyK = new byte[32];
keyL = new byte[32];
if (keyBuffer == null)
{
Rnd.GetBytes(keyK);
Rnd.GetBytes(keyL);
}
else
{
Buffer.BlockCopy(keyBuffer, 0, keyK, 0, keyK.Length);
Buffer.BlockCopy(keyBuffer, 32, keyL, 0, keyL.Length);
}
stream.Write(EncryptKey(stretchedKey, keyK, 0), 0, 32);
stream.Write(EncryptKey(stretchedKey, keyL, 0), 0, 32);
var iv = new byte[16];
Rnd.GetBytes(iv);
stream.Write(iv, 0, iv.Length);
using var dataHash = new HMACSHA256(keyL);
using var twofish = new TwofishManaged();
twofish.Mode = CipherMode.CBC;
twofish.Padding = PaddingMode.None;
twofish.KeySize = 256;
twofish.Key = keyK;
twofish.IV = iv;
using (var dataEncryptor = twofish.CreateEncryptor()) {
foreach (var field in Headers)
{
WriteBlock(stream, dataHash, dataEncryptor, (byte)field.HeaderType, field.RawData);
}
WriteBlock(stream, dataHash, dataEncryptor, (byte)HeaderType.EndOfEntry, Array.Empty <byte>());
foreach (var entry in Entries)
{
foreach (var field in entry.Records)
{
WriteBlock(stream, dataHash, dataEncryptor, (byte)field.RecordType, field.RawData);
}
WriteBlock(stream, dataHash, dataEncryptor, (byte)RecordType.EndOfEntry, Array.Empty <byte>());
}
}
dataHash.TransformFinalBlock(Array.Empty <byte>(), 0, 0);
stream.Write(BitConverter.GetBytes(Tag), 0, 4);
stream.Write(BitConverter.GetBytes(TagEof), 0, 4);
stream.Write(BitConverter.GetBytes(Tag), 0, 4);
stream.Write(BitConverter.GetBytes(TagEof), 0, 4);
if (dataHash.Hash == null)
{
throw new InvalidOperationException("Cannot compute hash.");
} // newer happens actually
stream.Write(dataHash.Hash, 0, dataHash.Hash.Length);
HasChanged = false;
} finally {
if (stretchedKey != null)
{
Array.Clear(stretchedKey, 0, stretchedKey.Length);
}
if (keyK != null)
{
Array.Clear(keyK, 0, keyK.Length);
}
if (keyL != null)
{
Array.Clear(keyL, 0, keyL.Length);
}
//if (data != null) { Array.Clear(data, 0, data.Length); }
}
}