/// <summary>
/// Synchronizes storage root path with Trinity.C.
/// Creates the directory if it does not exist.
/// </summary>
private static TrinityErrorCode CSynchronizeStorageRoot()
{
string storage_root = StorageConfig.Instance.StorageRoot;
if (!Directory.Exists(storage_root))
{
try
{
Directory.CreateDirectory(storage_root);
}
catch
{
Log.WriteLine(LogLevel.Error, "Error occurs when creating StorageRoot: " + storage_root);
return(TrinityErrorCode.E_FAILURE);
}
}
try
{
byte[] buff = BitHelper.GetBytes(storage_root);
fixed(byte *p = buff)
{
CTrinityConfig.SetStorageRoot(p, buff.Length);
}
}
catch
{
return(TrinityErrorCode.E_FAILURE);
}
return(TrinityErrorCode.E_SUCCESS);
}
public string Serialize()
{
using (var stream = new MemoryStream())
{
using (var binWriter = new BinaryWriter(stream))
{
binWriter.Write(this.Master.HasPrivateKey ? Xprv : Xpub);
binWriter.Write(this.Depth);
binWriter.Write(this.ParentFingerPrint);
binWriter.Write(BitHelper.GetBytes(this.Index, false));
binWriter.Write(this.ChainCode);
if (this.Master.HasPrivateKey)
{
binWriter.Write(byte.MinValue);
binWriter.Write(this.Master.PrivateKey.Key.GetPrivKeyBytes());
}
else
{
binWriter.Write(this.Master.PublicKey.Bytes);
}
return(Base58Encoding.EncodeWithCheckSum(stream.ToArray()));
}
}
}
public virtual ScriptBuilder EmitPush(byte[] data)
{
if (data == null)
{
throw new ArgumentNullException();
}
if (data.Length <= (int)EVMOpCode.PUSHBYTES75)
{
writer.WriteByte((byte)data.Length);
writer.Write(data, 0, data.Length);
}
else if (data.Length < 0x100)
{
Emit(EVMOpCode.PUSHDATA1);
writer.WriteByte((byte)data.Length);
writer.Write(data, 0, data.Length);
}
else if (data.Length < 0x10000)
{
Emit(EVMOpCode.PUSHDATA2);
writer.Write(BitHelper.GetBytes((ushort)data.Length), 0, 2);
writer.Write(data, 0, data.Length);
}
else// if (data.Length < 0x100000000L)
{
Emit(EVMOpCode.PUSHDATA4);
writer.Write(BitHelper.GetBytes(data.Length), 0, 4);
writer.Write(data, 0, data.Length);
}
return(this);
}
private void Button_Click(object sender, RoutedEventArgs e)
{
tmp1 = "";
tmp2 = "";
dana = inputTxt.Text;
tablicaBitowa = BitHelper.GetBytes(dana);
for (int i = 0; i < tablicaBitowa.Length; i++)
{
tmp1 += tablicaBitowa[i];
}
input = BitHelper.BytesToInts(tablicaBitowa);
encoded = hamming.GenerateCode(input);
disturbedTxt.Text = BitHelper.IntsToString(hamming.Disturbed);
DisturbedBits = GetDisturbedBits();
DisturbedBitsBox.ItemsSource = DisturbedBits;
tmp1 = BitHelper.IntsToString(encoded);
encodedTxt.Text = tmp1;
bitowa = Formatuj(tablicaBitowa);
tablicaZnakow = bitowa.ToCharArray();
binaryInputTxt.Text = FormatCharArray(tablicaZnakow);
decoded = GetString(tablicaBitowa);
recivedTxt.Text = decoded;
}
/// <summary>
/// GetHeader of message
/// </summary>
/// <param name="dataLength">Data length</param>
public byte[] GetHeader(int dataLength)
{
byte[] data = BitHelper.GetBytes(dataLength);
Array.Resize(ref data, HeaderLength);
data[HeaderLength - 1] = (byte)Type;
return(data);
}
/// <summary>
/// The standard of creating an extended key from a given seed.
/// </summary>
public static ExtendedKey Create(byte[] hashKey, byte[] seed)
{
var computedHash = CryptoUtil.ComputeHmac512(hashKey, seed);
var key = new BitcoinPrivateKey(computedHash.Take(32).ToArray());
var chain = computedHash.Skip(32).ToArray();
return(new ExtendedKey(key, chain, 0, BitHelper.GetBytes(0), 0));
}
public void Int32Test()
{
var a = BitHelper.GetBytes(123);
CollectionAssert.AreEqual(new byte[] { 123, 0, 0, 0 }, a);
var b = BitHelper.ToInt32(a, 0);
Assert.AreEqual(123, b);
}
/// <summary>
/// Flush buffer
/// </summary>
private void FlushBuffer(CancellationToken cancel)
{
var sleep = new ConditionalSleep();
var logBuffer = new byte[1 + (16 * 2) + 2];
logBuffer[0] = (byte)EFuzzerMessageType.PushLog;
while (!cancel.IsCancellationRequested)
{
cancel.ThrowIfCancellationRequested();
using (var ms = new MemoryStream())
{
while (_buffer.TryTake(out var log))
{
// Serialization
if (log.Error != null)
{
var chunk = GetMessage(EFuzzerMessageType.PushLogWithError, log);
ms.Write(chunk, 0, chunk.Length);
}
else
{
// Faster than serialize (16b InputId + 16b ConfigId + 2b Coverage)
Array.Copy(log.InputId.ToByteArray(), 0, logBuffer, 1, 16);
Array.Copy(log.ConfigId.ToByteArray(), 0, logBuffer, 16 + 1, 16);
Array.Copy(BitHelper.GetBytes((ushort)(log.Coverage * 100)), 0, logBuffer, (16 * 2) + 1, 2);
ms.Write(logBuffer, 0, logBuffer.Length);
}
}
if (ms.Length > 0)
{
var chunk = ms.ToArray();
lock (_client)
{
_client.Write(chunk, 0, chunk.Length);
_client.Flush();
}
}
sleep.Sleep();
}
}
}
private ExtendedKey GenerateKey(uint index)
{
Thrower.Condition <AddressException>((index & HardendIndex) != 0 && !this.Master.HasPrivateKey, "A public key can't derivate an hardened child");
byte[] extended;
byte[] pub = this.Master.PublicKey.Bytes;
if ((index & HardendIndex) == 0)
{
var sequenceBytes = BitHelper.GetBytes(index, false);
extended = pub.ToArray().Concat(sequenceBytes).ToArray();
}
else
{
var priv = this.Master.PrivateKey.Bytes;
var sequenceBytes = BitHelper.GetBytes(index, false);
extended = (new byte[] { 0 }).Concat(priv.ToArray()).Concat(sequenceBytes).ToArray();
}
var leftRight = CryptoUtil.ComputeHmac512(this.ChainCode, extended);
var leftKey = leftRight.Take(32).ToArray();
var rightKey = leftRight.Skip(32).ToArray();
BigInteger bigIntegerLeft = new BigInteger(1, leftKey);
Thrower.Condition <AddressException>(bigIntegerLeft.CompareTo(EcKey.EcParams.N) >= 0, "This is rather unlikely, but it did just happen");
if (this.Master.HasPrivateKey)
{
BigInteger key = bigIntegerLeft.Add(new BigInteger(1, this.Master.PrivateKey.Bytes)).Mod(EcKey.EcParams.N);
Thrower.Condition <AddressException>(key.Equals(BigInteger.Zero), "This is rather unlikely, but it did just happen");
//// fix the private key in case it needs padding
var keyBytes = new EcKey(key).GetPrivKeyBytes();
return(new ExtendedKey(new BitcoinPrivateKey(keyBytes), rightKey, (byte)(this.Depth + 1), this.GenerateFingerPrint(), index));
}
else
{
var qdecoded = EcKey.EcParams.Curve.DecodePoint(this.Master.PublicKey.Bytes);
var key = new ECPublicKeyParameters("EC", qdecoded, EcKey.EcParams);
var qkey = EcKey.EcParams.G.Multiply(bigIntegerLeft).Add(key.Q);
Thrower.Condition <AddressException>(qkey.IsInfinity, "This is rather unlikely, but it did just happen");
var point = new FpPoint(EcKey.EcParams.Curve, qkey.Normalize().XCoord, qkey.Normalize().YCoord, true);
return(new ExtendedKey(new BitcoinPublicKey(point.GetEncoded()), rightKey, (byte)(this.Depth + 1), this.GenerateFingerPrint(), index));
}
}
public byte[] GetNativeByteArray()
{
return(BitHelper.GetBytes(_objKey));
}
