public void WhenDelimiterIsHexValue_ThenThrowException()
{
foreach (var ch in HexCharacterSet.HexChars)
{
Assert.Throws <ArgumentException>(() => _ = new HexEncoder(ch));
}
}
/// <summary>
/// Gets a bitcoin block from the file system.
/// </summary>
/// <param name="hash">The block's hash that identifies the requested block.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The requested bitcoin block.</returns>
public async Task <Block?> TryGetAsync(uint256 hash, CancellationToken cancellationToken)
{
// Try get the block.
Block?block = null;
using (await BlockFolderLock.LockAsync(cancellationToken).ConfigureAwait(false))
{
var encoder = new HexEncoder();
var filePath = Path.Combine(BlocksFolderPath, hash.ToString());
if (File.Exists(filePath))
{
try
{
byte[] blockBytes = await File.ReadAllBytesAsync(filePath, cancellationToken).ConfigureAwait(false);
block = Block.Load(blockBytes, Network);
_ = new FileInfo(filePath)
{
LastAccessTimeUtc = DateTime.UtcNow
};
}
catch
{
// In case the block file is corrupted and we get an EndOfStreamException exception
// Ignore any error and continue to re-downloading the block.
Logger.LogDebug($"Block {hash} file corrupted, deleting file and block will be re-downloaded.");
File.Delete(filePath);
}
}
}
return(block);
}
public static byte[] EncryptBytes2(byte[] byteText)
{
var aes = Aes.Create();
aes.KeySize = 256;
aes.BlockSize = 128;
aes.Mode = CipherMode.CBC;
string sIV = "1d2c793dedc237897269859b34d31d93";
string sKey = "3d6b59e8c5623ce4ff7c165995b209e7f03461ec057ca33a5cd1559d01e5682b";
aes.Key = Encoders.Hex.DecodeData(sKey);
aes.IV = Encoders.Hex.DecodeData(sIV);
byte[] encrypted;
HexEncoder he = new HexEncoder();
using (MemoryStream ms = new MemoryStream())
{
using (var cs = new CryptoStream(ms, aes.CreateEncryptor(), CryptoStreamMode.Write))
{
cs.Write(byteText, 0, byteText.Length);
cs.FlushFinalBlock();
}
encrypted = ms.ToArray();
}
return(encrypted);
}
public override string ToString()
{
var branch = Branch == Branch.Left ? "left" : "right";
var encodedHash = HexEncoder.Encode(Hash);
return($"{branch}:{encodedHash}");
}
public object ToJson()
{
var branch = Branch == Branch.Left ? "left" : "right";
var encodedHash = HexEncoder.Encode(Hash);
return($"{{ \"{branch}\":\"{encodedHash}\"}}");
}
public void BigSizeDecodingDataTest()
{
string rawData = File.ReadAllText("Data/BigSizeDecodingData.json");
TlvData[] data = JsonSerializer.Deserialize <TlvData[]>(rawData);
foreach (TlvData tlvData in data)
{
byte[] dataBytes = HexEncoder.ToHexBytes(tlvData.bytes);
if (tlvData.exp_error != null)
{
Assert.Throws <MessageSerializationException>(() =>
{
var reader = new SequenceReader <byte>(new ReadOnlySequence <byte>(dataBytes));
return(SequenceReaderExtensions.ReadBigSize(ref reader));
});
}
else
{
var reader = new SequenceReader <byte>(new ReadOnlySequence <byte>(dataBytes));
ulong res = SequenceReaderExtensions.ReadBigSize(ref reader);
Assert.Equal(tlvData.value, res);
}
}
}
public static PSBT Parse(string hexOrBase64, Network network)
{
if (network == null)
{
throw new ArgumentNullException(nameof(network));
}
if (hexOrBase64 == null)
{
throw new ArgumentNullException(nameof(hexOrBase64));
}
if (network == null)
{
throw new ArgumentNullException(nameof(network));
}
byte[] raw;
if (HexEncoder.IsWellFormed(hexOrBase64))
{
raw = Encoders.Hex.DecodeData(hexOrBase64);
}
else
{
raw = Encoders.Base64.DecodeData(hexOrBase64);
}
return(Load(raw, network));
}
public void Proof()
{
var mt = new MerkleTree();
foreach (var i in Enumerable.Range(0, 10))
{
mt.AddLeaf(sha256($"test{i}"));
}
Assert.Equal(5, mt.Levels);
foreach (var i in Enumerable.Range(0, 10))
{
var proof = mt.GetProof(i);
var receipt = proof.ToReceipt();
receipt.AddAnchor("BTCOpReturn", "ae125");
var jo = (JObject)JsonConvert.DeserializeObject(receipt.ToJson());
Assert.Equal(receipt.Context, jo["@context"]);
Assert.Equal(HexEncoder.Encode(receipt.TargetHash), (string)(jo["targetHash"]));
Assert.Equal(HexEncoder.Encode(receipt.MerkleRoot), (string)(jo["merkleRoot"]));
Assert.Equal(receipt.Type, jo["type"]);
Assert.Equal("ChainpointSHA256v2", receipt.Type);
var rproof = (JArray)jo["proof"];
var j = 0;
foreach (var p in proof)
{
var branch = (p.Branch == Branch.Left) ? "left" : "right";
var rp = rproof[j++];
Assert.Equal(HexEncoder.Encode(p.Hash), (string)(rp[branch]));
}
Assert.True((bool)mt.ValidateProof(proof, sha256($"test{i}")));
}
}
public static Script ParseScript(string s)
{
MemoryStream result = new MemoryStream();
if (mapOpNames.Count == 0)
{
mapOpNames = new Dictionary <string, OpcodeType>(Op._OpcodeByName);
foreach (var kv in mapOpNames.ToArray())
{
if (kv.Key.StartsWith("OP_", StringComparison.Ordinal))
{
var name = kv.Key.Substring(3, kv.Key.Length - 3);
mapOpNames.AddOrReplace(name, kv.Value);
}
}
}
var words = s.Split(' ', '\t', '\n');
foreach (string w in words)
{
if (w == "")
{
continue;
}
if (w.All(l => l.IsDigit()) ||
(w.StartsWith("-") && w.Substring(1).All(l => l.IsDigit())))
{
// Number
long n = long.Parse(w);
Op.GetPushOp(new BigInteger(n)).WriteTo(result);
}
else if (w.StartsWith("0x") && HexEncoder.IsWellFormed(w.Substring(2)))
{
// Raw hex data, inserted NOT pushed onto stack:
var raw = Encoders.Hex.DecodeData(w.Substring(2));
result.Write(raw, 0, raw.Length);
}
else if (w.Length >= 2 && w.StartsWith("'") && w.EndsWith("'"))
{
// Single-quoted string, pushed as data. NOTE: this is poor-man's
// parsing, spaces/tabs/newlines in single-quoted strings won't work.
var b = TestUtils.ToBytes(w.Substring(1, w.Length - 2));
Op.GetPushOp(b).WriteTo(result);
}
else if (mapOpNames.ContainsKey(w))
{
// opcode, e.g. OP_ADD or ADD:
result.WriteByte((byte)mapOpNames[w]);
}
else
{
Assert.True(false, "Invalid test");
return(null);
}
}
return(new Script(result.ToArray()));
}
static Encoders()
{
ASCII = new ASCIIEncoder();
Hex = new HexEncoder();
Base58 = new Base58Encoder();
Base58Check = new Base58CheckEncoder();
Base64 = new Base64Encoder();
}
static Encoders()
{
Base64 = new Base64Encoder();
Base58Check = new Base58CheckEncoder();
Base58 = new Base58Encoder();
Hex = new HexEncoder();
ASCII = new ASCIIEncoder();
}
public void WhenDelimiterSet_ThenReturnEncodedWithDelimiter(char delimiter, string expected)
{
var sut = new HexEncoder(delimiter);
var result = sut.Encode("John");
Assert.That(result, Is.EqualTo(expected));
}
/// <inheritdoc />
public string GetFilePath(IMediaFileSystem fileSystem, Guid itemGuid, Guid propertyGuid, string filename, string previous = null)
{
// assumes that cuid and puid keys can be trusted - and that a single property type
// for a single content cannot store two different files with the same name
var directory = HexEncoder.Encode(GuidUtils.Combine(itemGuid, propertyGuid).ToByteArray() /*'/', 2, 4*/); // could use ext to fragment path eg 12/e4/f2/...
return(Path.Combine(directory, filename).Replace('\\', '/'));
}
public void WhenDelimiterSet_ThenReturnDecoded(string hex, string expected)
{
var sut = new HexEncoder('=');
var result = sut.Decode(hex);
Assert.That(result, Is.EqualTo(expected));
}
public static Slip21Node FromSeed(string seed)
{
if (HexEncoder.IsWellFormed(seed))
{
return(FromSeed(Encoders.Hex.DecodeData(seed)));
}
return(FromSeed(Encoding.ASCII.GetBytes(seed)));
}
public static Sign ParseFromTLV(string hexOrBase64, Network network)
{
var bytes = HexEncoder.IsWellFormed(hexOrBase64) ? Encoders.Hex.DecodeData(hexOrBase64) : Encoders.Base64.DecodeData(hexOrBase64);
var reader = new TLVReader(new MemoryStream(bytes));
var sign = new Sign();
sign.ReadTLV(reader, network);
return(sign);
}
public static Offer ParseFromTLV(string hexOrBase64, Network network)
{
var bytes = HexEncoder.IsWellFormed(hexOrBase64) ? Encoders.Hex.DecodeData(hexOrBase64) : Encoders.Base64.DecodeData(hexOrBase64);
var reader = new TLVReader(new MemoryStream(bytes));
var offer = new Offer();
offer.ReadTLV(reader, network);
return(offer);
}
public static Accept ParseFromTLV(string hexOrBase64, Network network)
{
var bytes = HexEncoder.IsWellFormed(hexOrBase64) ? Encoders.Hex.DecodeData(hexOrBase64) : Encoders.Base64.DecodeData(hexOrBase64);
var reader = new TLVReader(new MemoryStream(bytes));
var accept = new Accept();
accept.ReadTLV(reader, network);
return(accept);
}
private static RSAParameters?ParsePemKey(string pem, string password = null)
{
var reader = new PemReader(new System.IO.StringReader(pem));
var pemObj = reader.ReadPemObject();
if (pemObj == null)
{
return(null);
}
if (pemObj.Type == "PUBLIC KEY")
{
return(ParsePublicKey(pemObj.Content));
}
else if (pemObj.Type == "RSA PRIVATE KEY")
{
byte[] keyBytes = pemObj.Content;
var headers = new Dictionary <string, string>();
foreach (PemHeader header in pemObj.Headers)
{
headers[header.Name] = header.Value;
}
headers.TryGetValue("Proc-Type", out string procType);
if (procType == "4,ENCRYPTED")
{
if (string.IsNullOrWhiteSpace(password))
{
throw new ArgumentNullException(nameof(password));
}
var dekItems = headers["DEK-Info"].Split(',');
var algItems = dekItems[0].Trim().Split('-');
byte[] iv = new HexEncoder().Decode(Encoding.ASCII.GetBytes(dekItems[1]));
keyBytes = DecryptRsaPrivateKeyData(keyBytes, algItems, iv, password);
}
return(ParseRsaPrivateKey(keyBytes));
}
else if (pemObj.Type == "PRIVATE KEY") // nocrypt pkcs8
{
return(ParsePrivateKey(pemObj.Content));
}
else if (pemObj.Type == "ENCRYPTED PRIVATE KEY") // encrypted pkcs8
{
// 测试存在bug
throw new NotSupportedException("Not yet supported.");
//return ParseEncryptedPrivateKey(pemObj.Content, password);
}
else
{
return(null);
}
}
public static byte[] EncryptBytes(byte[] byteText)
{
var aes = Aes.Create();
aes.KeySize = 256;
aes.BlockSize = 128;
aes.Mode = CipherMode.CBC;
// This Salt & IV was ported in from Biblepay-QT
string sSalt = "eb5a781ea9da2ef36";
string sKey = "biblepay";
byte[] bytesSalt = System.Text.Encoding.ASCII.GetBytes(sSalt);
byte[] bytesKey = System.Text.Encoding.ASCII.GetBytes(sKey);
// These static bytes were ported in from Biblepay-QT, because OpenSSL uses a proprietary method to create the 256 bit AES-CBC key: EVP_BytesToKey(EVP_aes_256_cbc(), EVP_sha512()
string sAdvancedKey = "98,-5,23,119,-28,-99,-5,90,62,-63,82,39,63,-67,-85,37,-29,-65,97,80,57,-24,71,67,119,14,-67,12,-96,99,-84,-97";
string sIV = "29,44,121,61,-19,-62,55,-119,114,105,-123,-101,52,-45,29,-109";
var vKey = sAdvancedKey.Split(new string[] { "," }, StringSplitOptions.None);
var vIV = sIV.Split(new string[] { "," }, StringSplitOptions.None);
byte[] myBytedKey = new byte[32];
byte[] myBytedIV = new byte[16];
for (int i = 0; i < vKey.Length; i++)
{
int iMyKey = (int)BibleHash.cdbl(vKey[i], 0);
myBytedKey[i] = (byte)(iMyKey + 0);
}
for (int i = 0; i < vIV.Length; i++)
{
int iMyIV = (int)BibleHash.cdbl(vIV[i], 0);
myBytedIV[i] = (byte)(iMyIV + 0);
}
aes.Key = myBytedKey;
aes.IV = myBytedIV;
byte[] encrypted;
HexEncoder he = new HexEncoder();
string keyHex = he.EncodeData(myBytedKey);
string keyIV = he.EncodeData(myBytedIV);
string sBytedKeyHex = BibleHash.ByteArrayToHexString(myBytedKey);
string sBytedIVHex = BibleHash.ByteArrayToHexString(myBytedIV);
using (MemoryStream ms = new MemoryStream())
{
using (var cs = new CryptoStream(ms, aes.CreateEncryptor(), CryptoStreamMode.Write))
{
cs.Write(byteText, 0, byteText.Length);
cs.FlushFinalBlock();
}
encrypted = ms.ToArray();
}
return(encrypted);
}
public void ToHexStringWithSeparatorCreatesCorrectValue()
{
var buffer = new byte[255];
var random = new Random();
random.NextBytes(buffer);
var expected = ToHexString(buffer, '/', 2, 4);
var actual = HexEncoder.Encode(buffer, '/', 2, 4);
Assert.AreEqual(expected, actual);
}
public Slip21Node DeriveChild(string label)
{
if (string.IsNullOrEmpty(label))
{
throw new ArgumentException("label must not be null or empty", nameof(label));
}
if (HexEncoder.IsWellFormed(label))
{
return(DeriveChild(Encoders.Hex.DecodeData(label)));
}
return(DeriveChild(Encoding.ASCII.GetBytes(label)));
}
public static bool TryParse(string str, out SSHFingerprint fingerPrint)
{
if (str == null)
{
throw new ArgumentNullException(nameof(str));
}
fingerPrint = null;
str = str.Trim();
try
{
var shortFingerprint = str.Replace(":", "", StringComparison.OrdinalIgnoreCase);
if (HexEncoder.IsWellFormed(shortFingerprint))
{
var hash = Encoders.Hex.DecodeData(shortFingerprint);
if (hash.Length == 16)
{
fingerPrint = new SSHFingerprint(hash);
return(true);
}
return(false);
}
}
catch
{
}
if (str.StartsWith("SHA256:", StringComparison.OrdinalIgnoreCase))
{
str = str.Substring("SHA256:".Length).Trim();
}
if (str.Contains(':', StringComparison.OrdinalIgnoreCase))
{
return(false);
}
if (!str.EndsWith('='))
{
str = str + "=";
}
try
{
var hash = Encoders.Base64.DecodeData(str);
if (hash.Length == 32)
{
fingerPrint = new SSHFingerprint(hash);
return(true);
}
}
catch
{
}
return(false);
}
private ushort GetTLVType(string hexOrBase64)
{
try
{
var data = HexEncoder.IsWellFormed(hexOrBase64) ? Encoders.Hex.DecodeData(hexOrBase64) : Encoders.Base64.DecodeData(hexOrBase64);
var r = new TLVReader(new MemoryStream(data));
return(r.ReadU16());
}
catch
{
}
return(0);
}
public void util_IsHex()
{
Assert.True(HexEncoder.IsWellFormed("00"));
Assert.True(HexEncoder.IsWellFormed("00112233445566778899aabbccddeeffAABBCCDDEEFF"));
Assert.True(HexEncoder.IsWellFormed("ff"));
Assert.True(HexEncoder.IsWellFormed("FF"));
Assert.True(HexEncoder.IsWellFormed(""));
Assert.True(!HexEncoder.IsWellFormed("0"));
Assert.True(!HexEncoder.IsWellFormed("a"));
Assert.True(!HexEncoder.IsWellFormed("eleven"));
Assert.True(!HexEncoder.IsWellFormed("00xx00"));
Assert.True(!HexEncoder.IsWellFormed("0x0000"));
}
public static bool TryParse(string str, out HDFingerprint result)
{
if (str == null)
{
throw new ArgumentNullException(nameof(str));
}
result = default;
if (!HexEncoder.IsWellFormed(str) || str.Length != 4 * 2)
{
return(false);
}
result = new HDFingerprint(Encoders.Hex.DecodeData(str));
return(true);
}
public void BigSizeEncodingDataTest()
{
string rawData = File.ReadAllText("Data/BigSizeEncodingData.json");
TlvData[] data = JsonSerializer.Deserialize <TlvData[]>(rawData);
foreach (TlvData tlvData in data)
{
byte[] dataBytes = HexEncoder.ToHexBytes(tlvData.bytes);
var writer = new ArrayBufferWriter <byte>();
writer.WriteBigSize(tlvData.value);
Assert.Equal(dataBytes, writer.WrittenSpan.ToArray());
}
}
public void HexEncoderOutputIsCorrect()
{
byte[] hash = Hash();
var sb = new StringBuilder(hash.Length * 2);
for (int i = 0; i < hash.Length; i++)
{
sb.Append(hash[i].ToString("x2"));
}
string expected = sb.ToString();
string actual = HexEncoder.Encode(hash);
Assert.Equal(expected, actual);
}
public static bool TryParse(string str, [MaybeNullWhen(false)] out OracleId id)
{
id = null;
if (!HexEncoder.IsWellFormed(str))
{
return(false);
}
var bytes = Encoders.Hex.DecodeData(str);
if (!ECXOnlyPubKey.TryCreate(bytes, Context.Instance, out var k) || k is null)
{
return(false);
}
id = new OracleId(k);
return(true);
}
private void OnDetected(IFeliCaReader reader)
{
Idm.Value = string.Empty;
Access.Value = null;
Logs.Clear();
var idm = reader.ExecutePolling(0x0003);
if (idm.Length == 0)
{
return;
}
var block = new ReadBlock {
BlockNo = 0
};
if (!reader.ExecuteReadWoe(idm, 0x008B, block))
{
return;
}
var blocks1 = Enumerable.Range(0, 8).Select(x => new ReadBlock {
BlockNo = (byte)x
}).ToArray();
var blocks2 = Enumerable.Range(8, 8).Select(x => new ReadBlock {
BlockNo = (byte)x
}).ToArray();
var blocks3 = Enumerable.Range(16, 4).Select(x => new ReadBlock {
BlockNo = (byte)x
}).ToArray();
if (!reader.ExecuteReadWoe(idm, 0x090F, blocks1) ||
!reader.ExecuteReadWoe(idm, 0x090F, blocks2) ||
!reader.ExecuteReadWoe(idm, 0x090F, blocks3))
{
return;
}
Idm.Value = HexEncoder.ToHex(idm);
Access.Value = Suica.ConvertToAccessData(block.BlockData);
Logs.AddRange(blocks1.Concat(blocks2).Concat(blocks3)
.Select(x => Suica.ConvertToLogData(x.BlockData))
.Where(x => x != null)
.ToArray());
}
public void ToHexStringCreatesCorrectValue()
{
var buffer = new byte[255];
var random = new Random();
random.NextBytes(buffer);
var sb = new StringBuilder(buffer.Length * 2);
for (var i = 0; i < buffer.Length; i++)
{
sb.Append(buffer[i].ToString("X2"));
}
var expected = sb.ToString();
var actual = HexEncoder.Encode(buffer);
Assert.AreEqual(expected, actual);
}
public void ShouldHandleUpperAndLowerCaseEncoded()
{
var encoder = new HexEncoder();
Assert.AreEqual(new byte[] {0x33, 0xa4}, encoder.Decode("33a4"));
Assert.AreEqual(new byte[] {0x33, 0xa4}, encoder.Decode("33A4"));
}
public void ShouldEncodeToUppercase()
{
var encoder = new HexEncoder();
var encoded = encoder.Encode(new byte[] {0x66, 0xff, 0x00, 0x44});
Assert.AreEqual("66FF0044", encoded);
}
public void ShouldThrowOnBadInputWhenDecoding()
{
var encoder = new HexEncoder();
Assert.Throws(typeof (ArgumentException), () => encoder.Decode("odd"));
Assert.Throws(typeof (ArgumentException), () => encoder.Decode("even"));
}
