public void EncodeBlock()
{
BlockEncoder instance = new BlockEncoder(new KeyScheduler {
Key = Key, IV = IV
});
byte[] block = hasher.ComputeHash(Key);
byte[] encoded = instance.Encode(block, iterations: 1);
CollectionAssert.AreNotEqual(encoded, block);
}
public void EncodeDecodeBlock()
{
BlockEncoder encoder = new BlockEncoder();
Hash hash = new Hash();
Block block = new Block(1, hash);
var result = encoder.Decode(encoder.Encode(block));
Assert.IsNotNull(result);
Assert.AreEqual(1, result.Number);
Assert.AreEqual(hash, result.ParentHash);
}
public void DecodeBlock()
{
BlockEncoder encoder = new BlockEncoder(new KeyScheduler {
Key = Key, IV = IV
});
BlockEncoder decoder = new BlockEncoder(new KeyScheduler {
Key = Key, IV = IV
});
byte[] block = hasher.ComputeHash(Key);
byte[] encoded = encoder.Encode(block, iterations: 1);
byte[] decoded = decoder.Decode(block, iterations: 1);
}
void Encode_zero_blocks()
{
string errorMessage;
errorMessage = BlockEncoder.Encode(16, new InstructionBlock[0], BlockEncoderOptions.None);
Assert.Null(errorMessage);
errorMessage = BlockEncoder.Encode(32, new InstructionBlock[0], BlockEncoderOptions.None);
Assert.Null(errorMessage);
errorMessage = BlockEncoder.Encode(64, new InstructionBlock[0], BlockEncoderOptions.None);
Assert.Null(errorMessage);
}
public void EncodeDecodeBlockWithTransaction()
{
BlockEncoder encoder = new BlockEncoder();
Address from = new Address();
Address to = new Address();
Transaction transaction = new Transaction(from, to, new BigInteger(2));
Block original = new Block(0, null, new Transaction[] { transaction });
Block block = encoder.Decode(encoder.Encode(original));
Assert.IsNotNull(block.Transactions);
Assert.AreEqual(1, block.Transactions.Count);
Transaction result = block.Transactions.First();
Assert.AreEqual(new BigInteger(2), result.Value);
}
void Encode_zero_instructions()
{
string errorMessage;
var codeWriter = new CodeWriterImpl();
errorMessage = BlockEncoder.Encode(16, new InstructionBlock(codeWriter, Array.Empty <Instruction>(), 0, Array.Empty <RelocInfo>(), Array.Empty <uint>(), Array.Empty <ConstantOffsets>()), BlockEncoderOptions.None);
Assert.Null(errorMessage);
Assert.Empty(codeWriter.ToArray());
errorMessage = BlockEncoder.Encode(32, new InstructionBlock(codeWriter, Array.Empty <Instruction>(), 0, Array.Empty <RelocInfo>(), Array.Empty <uint>(), Array.Empty <ConstantOffsets>()), BlockEncoderOptions.None);
Assert.Null(errorMessage);
Assert.Empty(codeWriter.ToArray());
errorMessage = BlockEncoder.Encode(64, new InstructionBlock(codeWriter, Array.Empty <Instruction>(), 0, Array.Empty <RelocInfo>(), Array.Empty <uint>(), Array.Empty <ConstantOffsets>()), BlockEncoderOptions.None);
Assert.Null(errorMessage);
Assert.Empty(codeWriter.ToArray());
}
public void Encode()
{
List <string> results = new List <string>()
{
};
for (int i = CryptoTransform.MinRounds; i < CryptoTransform.MinRounds + CryptoTransform.MaxAdditionalRounds; i++)
{
BlockEncoder instance = new BlockEncoder(new KeyScheduler {
Key = Key, IV = IV
});
byte[] block = hasher.ComputeHash(Key);
byte[] encoded = instance.Encode(block, iterations: i);
Assert.IsTrue(block.Length == encoded.Length);
results.Add(Encoding.ASCII.GetString(encoded));
}
CollectionAssert.AllItemsAreUnique(results);
}
public void Decode()
{
for (int i = CryptoTransform.MinRounds; i < CryptoTransform.MinRounds + CryptoTransform.MaxAdditionalRounds; i++)
{
BlockEncoder encoder = new BlockEncoder(new KeyScheduler {
Key = Key, IV = IV
});
BlockEncoder decoder = new BlockEncoder(new KeyScheduler {
Key = Key, IV = IV
});
byte[] block = hasher.ComputeHash(Key);
byte[] copy = (byte[])block.Clone();
byte[] encoded = encoder.Encode(block, i);
//check to see whether it's being altered by accident
CollectionAssert.AreEqual(copy, block);
byte[] decoded = decoder.Decode(encoded, i);
Assert.IsTrue(block.Length == decoded.Length);
CollectionAssert.AreEqual(decoded, block);
}
}
void DefaultArgs()
{
const int bitness = 64;
const ulong origRip = 0x123456789ABCDE00;
const ulong newRip = 0x8000000000000000;
var originalData = new byte[] {
/*0000*/ 0xB0, 0x00, // mov al,0
/*0002*/ 0xEB, 0x09, // jmp short 123456789ABCDE0Dh
/*0004*/ 0xB0, 0x01, // mov al,1
/*0006*/ 0xE9, 0x03, 0x00, 0x00, 0x00, // jmp near ptr 123456789ABCDE0Eh
/*000B*/ 0xB0, 0x02, // mov al,2
};
var instructions = BlockEncoderTest.Decode(bitness, origRip, originalData, DecoderOptions.None);
var codeWriter = new CodeWriterImpl();
var errorMessage = BlockEncoder.Encode(bitness, new InstructionBlock(codeWriter, instructions, newRip));
Assert.Null(errorMessage);
Assert.Equal(0x28, codeWriter.ToArray().Length);
}
void Invalid_ConstantOffsets_Throws()
{
Assert.Throws <ArgumentException>(() => BlockEncoder.Encode(64, new InstructionBlock(new CodeWriterImpl(), new Instruction[0], 0, Array.Empty <RelocInfo>(), null, new ConstantOffsets[1]), BlockEncoderOptions.None));
Assert.Throws <ArgumentException>(() => BlockEncoder.Encode(64, new InstructionBlock(new CodeWriterImpl(), new Instruction[1], 0, Array.Empty <RelocInfo>(), null, new ConstantOffsets[0]), BlockEncoderOptions.None));
}
