/// <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)); }