public static string EncodeWithCheck(byte[] plaintext) { ContractsCommon.NotNull(plaintext, "plaintext"); ContractsCommon.ResultIsNonNull <string>(); return(EncodeWithCheck(new byte[0], plaintext)); }
public static string Encode(byte[] plaintext) { ContractsCommon.NotNull(plaintext, "plaintext"); ContractsCommon.ResultIsNonNull <string>(); var plaintextArr = new byte[plaintext.Length + 1]; Array.Copy(plaintext, 0, plaintextArr, 1, plaintext.Length); Array.Reverse(plaintextArr); var workingValue = new BigInteger(plaintextArr); StringBuilder sb = new StringBuilder(plaintext.Length * 138 / 100 + 1); while (workingValue.CompareTo(BigInteger.Zero) > 0) { BigInteger remainder; workingValue = BigInteger.DivRem(workingValue, Base, out remainder); sb.Append(Alphabet[(int)remainder]); } Contract.Assert(workingValue.Sign >= 0); //sb.Insert(0, Alphabet[(int)workingValue]); for (int i = 0; i < plaintext.Length && plaintext[i] == 0; ++i) { sb.Append(Alphabet[0]); } var retVal = new char[sb.Length]; sb.CopyTo(0, retVal, 0, sb.Length); Array.Reverse(retVal); return(new string(retVal)); }
public static byte[] DecodeWithCheck(string enc) { ContractsCommon.NotNull(enc, "enc"); Contract.Requires <FormatException>(Contract.ForAll(0, enc.Length, i => Alphabet.IndexOf(enc[i]) != -1)); byte[] plaintext; return(DecodeWithCheck(enc, out plaintext) ? plaintext : null); }
public static void WriteBytesBE(this ushort val, byte[] buffer, int offset) { ContractsCommon.NotNull(buffer, "buffer"); ContractsCommon.ValidOffsetLength(0, buffer.Length, offset, UINT16_SIZE, "offset", "offset"); buffer[offset] = (byte)(val >> 8); buffer[offset + 1] = (byte)val; }
public static bool DecodeWithCheck(string enc, out byte[] plaintext) { ContractsCommon.NotNull(enc, "enc"); Contract.Requires <FormatException>(Contract.ForAll(0, enc.Length, i => Alphabet.IndexOf(enc[i]) != -1)); Contract.Ensures(Contract.Result <bool>() == false || Contract.ValueAtReturn(out plaintext) != null); byte[] prefix; return(DecodeWithCheck(enc, 0, out prefix, out plaintext)); }
public static void WriteBytes(this uint val, byte[] buffer, int offset) { ContractsCommon.NotNull(buffer, "buffer"); ContractsCommon.ValidOffsetLength(0, buffer.Length, offset, UINT32_SIZE, "offset", "offset"); buffer[offset] = (byte)val; buffer[offset + 1] = (byte)(val >> 8); buffer[offset + 2] = (byte)(val >> 16); buffer[offset + 3] = (byte)(val >> 24); }
public static byte[] ToBytesArrayBE(this BigInteger bi) { ContractsCommon.ResultIsNonNull <byte[]>(); Contract.Ensures(Contract.Result <byte[]>().Length == bi.ToByteArray().Length); var resultArray = bi.ToByteArray(); Array.Reverse(resultArray); return(resultArray); }
public static ushort ReadUInt16BE(this byte[] buffer, int offset) { ContractsCommon.NotNull(buffer, "buffer"); ContractsCommon.ValidOffsetLength(0, buffer.Length, offset, UINT16_SIZE, "offset", "offset"); ushort val = (ushort)(((uint)buffer[offset]) << 8); val |= buffer[offset + 1]; return(val); }
public static uint ReadUInt32(this byte[] buffer, int offset) { ContractsCommon.NotNull(buffer, "buffer"); ContractsCommon.ValidOffsetLength(0, buffer.Length, offset, UINT32_SIZE, "offset", "offset"); uint val = buffer[offset]; val |= ((uint)buffer[offset + 1]) << 8; val |= ((uint)buffer[offset + 2]) << 16; val |= ((uint)buffer[offset + 3]) << 24; return(val); }
public static void WriteBytesBE(this ulong val, byte[] buffer, int offset) { ContractsCommon.NotNull(buffer, "buffer"); ContractsCommon.ValidOffsetLength(0, buffer.Length, offset, UINT64_SIZE, "offset", "offset"); buffer[offset] = (byte)(val >> 56); buffer[offset + 1] = (byte)(val >> 48); buffer[offset + 2] = (byte)(val >> 40); buffer[offset + 3] = (byte)(val >> 32); buffer[offset + 4] = (byte)(val >> 24); buffer[offset + 5] = (byte)(val >> 16); buffer[offset + 6] = (byte)(val >> 8); buffer[offset + 7] = (byte)val; }
public static string EncodeWithCheck(byte[] prefix, byte[] plaintext) { ContractsCommon.NotNull(prefix, "prefix"); ContractsCommon.NotNull(plaintext, "plaintext"); ContractsCommon.ResultIsNonNull <string>(); var plaintextArr = (byte[])plaintext.Clone(); var hash = Cryptography.CryptoFunctionProviderFactory.Default.Hash256(plaintextArr, prefix); var plaintextExtended = new byte[plaintext.Length + prefix.Length + 4]; Array.Copy(plaintext, 0, plaintextExtended, 0, plaintext.Length); Array.Copy(prefix, 0, plaintextExtended, plaintext.Length, prefix.Length); Array.Copy(hash.Bytes, 0, plaintextExtended, prefix.Length + plaintext.Length, 4); return(Encode(plaintextExtended)); }
public static ulong ReadUInt64BE(this byte[] buffer, int offset) { ContractsCommon.NotNull(buffer, "buffer"); ContractsCommon.ValidOffsetLength(0, buffer.Length, offset, UINT64_SIZE, "offset", "offset"); ulong val = ((ulong)buffer[offset]) << 56; val |= ((ulong)buffer[offset + 1]) << 48; val |= ((ulong)buffer[offset + 2]) << 40; val |= ((ulong)buffer[offset + 3]) << 32; val |= ((ulong)buffer[offset + 4]) << 24; val |= ((ulong)buffer[offset + 5]) << 16; val |= ((ulong)buffer[offset + 6]) << 8; val |= buffer[offset + 7]; return(val); }
public static byte[] Decode(string enc) { ContractsCommon.NotNull(enc, "enc"); Contract.Requires <FormatException>(Contract.ForAll(0, enc.Length, i => Alphabet.IndexOf(enc[i]) != -1)); ContractsCommon.ResultIsNonNull <byte[]>(); if (enc.Length == 0) { return(new byte[0]); } var workingValue = BigInteger.Zero; for (int i = 0; i < enc.Length; ++i) { var index = new BigInteger(Alphabet.IndexOf(enc[i])); workingValue = workingValue + index * BigInteger.Pow(Base, enc.Length - 1 - i); } var retVal = workingValue.ToByteArray(); Array.Reverse(retVal); if (retVal[0] == 0 && workingValue > 0) { var newBytes = new byte[retVal.Length - 1]; Array.Copy(retVal, 1, newBytes, 0, newBytes.Length); retVal = newBytes; } var count = 0; while (enc[count] == Alphabet[0]) { ++count; } if (count > 0) { var newBytes = new byte[retVal.Length + count]; Array.Copy(retVal, 0, newBytes, count, retVal.Length); retVal = newBytes; } return(retVal); }
public static bool DecodeWithCheck(string enc, int prefixLength, out byte[] prefix, out byte[] plaintext) { ContractsCommon.NotNull(enc, "enc"); // Approximate decoded byte size = enc.Length * 100 / 138 + 1 // Plaintext may be all prefix (-0) // Prefix may not include bytes reserved for hash (-4) ContractsCommon.ValidLength(0, (enc.Length) * 100 / 138 - 3, prefixLength, "prefixLength"); Contract.Requires <FormatException>(Contract.ForAll(0, enc.Length, i => Alphabet.IndexOf(enc[i]) != -1)); Contract.Ensures(Contract.Result <bool>() == false || Contract.ValueAtReturn(out prefix) != null && Contract.ValueAtReturn(out prefix).Length == prefixLength); Contract.Ensures(Contract.Result <bool>() == false || Contract.ValueAtReturn(out plaintext) != null); var plaintextExtended = Decode(enc); if (plaintextExtended.Length < 4 + prefixLength) { prefix = new byte[0]; plaintext = plaintextExtended; return(false); } var hash = Cryptography.CryptoFunctionProviderFactory.Default.Hash256(plaintextExtended, 0, plaintextExtended.Length - 4).Bytes; var pre = new byte[prefixLength]; Array.Copy(plaintextExtended, pre, prefixLength); prefix = pre; var pt = new byte[plaintextExtended.Length - prefixLength - 4]; Array.Copy(plaintextExtended, prefixLength, pt, 0, pt.Length); plaintext = pt; return(hash[0] == plaintextExtended[plaintextExtended.Length - 4] && hash[1] == plaintextExtended[plaintextExtended.Length - 3] && hash[2] == plaintextExtended[plaintextExtended.Length - 2] && hash[3] == plaintextExtended[plaintextExtended.Length - 1]); }
public static void CanWriteToStream(System.IO.Stream stream, string streamParamName, int expectedWriteLength) { ContractsCommon.NotNull(stream, streamParamName); Contract.Requires <ArgumentException>(stream.CanWrite, "Stream does not support writing: '" + streamParamName + "'."); }
public static void CanWriteToStream(System.IO.Stream stream, int expectedWriteLength) { ContractsCommon.CanWriteToStream(stream, "stream", expectedWriteLength); }