public void StreamedEncoding()
{
using (var source = new MemoryStream()) {
source.Write(_sampleBytes, 0, BUFFER_SIZE);
source.Seek(0, SeekOrigin.Begin);
using (var target = new MemoryStream()) {
using (var encodingStream = new Base32EncodingStream(target)) {
var buffer = new byte[1000]; // also must be multiple of 5
StreamHelper.PumpAll(source, encodingStream, buffer);
}
target.Seek(0, SeekOrigin.Begin);
var targetLength = Convert.ToInt32(target.Length);
var targetData = target.GetBuffer().Take(targetLength).ToArray();
var encoded = Encoding.UTF8.GetString(targetData);
var checkData = Base32Core.FromBase32String(encoded);
Assert.AreEqual(encoded, _sampleString);
Assert.IsTrue(checkData.SequenceEqual(_sampleBytes));
}
}
}
public void EncodeSmallestNative()
{
var data = SampleData[5];
var encoded = Base32Core.ToBase32String(data);
Assert.AreEqual(8, encoded.Length);
Assert.IsFalse(HasCutoff(encoded));
}
public void MarkupErrorTest()
{
var block = new Block();
var accumulator = new List <Block>();
Base32Core.MarkupBlocks(ref block, accumulator, "a", false);
Base32Core.MarkupBlocks(ref block, accumulator, "a", true);
}
public void Cutoff1Bytes()
{
var data = SampleData[1];
var encoded = Base32Core.ToBase32String(data);
Assert.AreEqual(3, encoded.Length);
Assert.IsTrue(HasCutoff(encoded));
Assert.IsTrue(Common.IsCutoffCharacter(encoded[1]));
}
public void CreateSampleData()
{
_sampleBytes = new byte[BUFFER_SIZE];
for (int i = 0; i < BUFFER_SIZE; i++)
{
_sampleBytes[i] = (byte)i;
}
_sampleString = Base32Core.ToBase32String(_sampleBytes);
}
public void SingleByteDecode()
{
for (int i = 0; i < 256; i++)
{
var x = new[] { (byte)i };
var encoded = Base32Core.ToBase32String(x);
var decoded = Base32Core.FromBase32String(encoded);
Assert.IsTrue(x.SequenceEqual(decoded));
}
}
private static void SplitStringDecodeTest()
{
const int DATA_SIZE = 13;
const int FRAGMENT_SIZE = 10;
byte[] data1 = new byte[DATA_SIZE];
for (int i = 0; i < DATA_SIZE; i++)
{
data1[i] = (byte)i;
}
string base32 = Base32Core.ToBase32String(data1) + "a";
var length32 = base32.Length;
var accumulator = new List <byte>();
Action <byte[]> handler = (i) => { foreach (var x in i)
{
accumulator.Add(x);
}
};
using (var pipe = new Base32DecodePipe(handler)) {
var offset = 0;
while (offset < base32.Length)
{
var length = Math.Min(FRAGMENT_SIZE, base32.Length - offset);
var progress = length + offset;
var final = progress == base32.Length;
var fragment = base32.Substring(offset, length);
pipe.FeedFragment(fragment, final);
offset += FRAGMENT_SIZE;
}
}
var data2 = accumulator.ToArray();
var isok = data2.SequenceEqual(data1);
}
public void SingleByteEncode()
{
for (int i = 0; i < 256; i++)
{
var x = (byte)i;
var low = x & 0x1f;
var high = x >> 5;
var clow = Base32Core.EncodeTable[low];
var chigh = Base32Core.EncodeTable[high];
var encoded = Base32Core.ToBase32String(new[] { x });
Assert.AreEqual(3, encoded.Length);
Assert.AreEqual(clow, encoded[0]);
Assert.AreEqual(chigh, encoded[2]);
var c = encoded[1];
Assert.IsTrue((c >= '7' && c <= '9') || c == '0');
}
}
/// <summary>
/// Illustrates data transformation steps.
/// </summary>
/// <remarks>
/// PREPARE DATA TO TRANSFER
/// 1. Pack input bytes by Zip.
/// 2. Encrypt packed bytes with password.
/// 3. Convert encrypted bytes to confidential string.
/// TRANSFER CONFIDENTIAL STRING OVER INTERNET.
/// TRANSFORM TRANSFERRED STRING TO ORIGINAL DATA.
/// 4. Convert confidential string to encrypted bytes.
/// 5. Decrypt converted bytes with password.
/// 6. Unpack decrypted bytes to original data.
/// </remarks>
internal static void TransformationModel()
{
//TestData.Cleanup();
const string PASSWORD = "******";
var my_input =
File.ReadAllBytes("C:\\1.input");
//new byte[] { 0x08, 0x00, 0x52 };
//new byte[] { 0x08, 0x00 };
//new byte[] { 0x08 };
//new byte[0];
var input_size = my_input.Length;
Console.WriteLine($"Input is {input_size} bytes");
////
//// Step 1: Pack input bytes by Zip.
////
//var my_packed = my_input.Pack();
//File.WriteAllBytes("C:\\1.packed", my_packed);
////
//// Step 2: Encrypt packed bytes with password.
////
var my_secret = RijndaelEncryptorDecryptor.Encrypt(my_input, PASSWORD);
File.WriteAllBytes("C:\\1.secret", my_secret);
string my_confidential = null;
////
//// Step 3: Convert encrypted bytes to confidential string to be transferred.
////
my_confidential = Base32Core.ToBase32String(my_secret);
File.WriteAllText("C:\\1.confidential", my_confidential);
////
//// TRANSFER CONFIDENTIAL STRING OVER INTERNET.
//// TRANSFORM TRANSFERRED STRING TO ORIGINAL DATA.
////
var my_transferred = my_confidential; // emulate transfer
// ReSharper disable once AssignNullToNotNullAttribute
var transfer_size = Encoding.UTF8.GetBytes(my_transferred).Length;
Console.WriteLine($"Transfer is {transfer_size} bytes");
Console.WriteLine($"Sample transfer ratio is {transfer_size / (1.0 * input_size)}");
////
//// Step 4: Convert confidential string to encrypted bytes.
////
var my_secret2 = Base32Core.FromBase32String(my_transferred);
File.WriteAllBytes("C:\\1.secret2", my_secret2);
Console.WriteLine($"Confidential conversion OK: {my_secret.SequenceEqual(my_secret2)}");
////
//// Step 5: Decrypt converted bytes with password.
////
var my_output = RijndaelEncryptorDecryptor.Decrypt(my_secret2, PASSWORD);
////
//// Step 6: Unpack decrypted bytes to original data.
////
File.WriteAllBytes("C:\\1.output", my_output);
Console.WriteLine($"Encrypting/decrypting OK: {my_input.SequenceEqual(my_output)}");
}
public void DecodeEmpty()
{
var decoded = Base32Core.FromBase32String(string.Empty);
Assert.IsTrue(decoded.SequenceEqual(new byte[0]));
}
public void DecodeNull()
{
var decoded = Base32Core.FromBase32String(null);
}
public void EncodeEmpty()
{
var encoded = Base32Core.ToBase32String(new byte[0]);
Assert.AreEqual(String.Empty, encoded);
}
public void EncodeNull()
{
var encoded = Base32Core.ToBase32String(null);
}
