Exemple #1
0
        protected override void OnReceived(byte[] buffer, long offset, long size)
        {
            byte[] remaining = new byte[size];
            Array.Copy(buffer, remaining, size);
            Log.Debug("[{SessionId}] RECV: {Bytes}", Id, remaining.GetPrintableBytes());

            // Legacy packet
            if (remaining[0] == 0xfe)
            {
                Disconnect();
                return;
            }

            while (true)
            {
                int    packetLength = VarInt.Decode(remaining, out remaining);
                byte[] packet       = new byte[packetLength];
                Array.Copy(remaining, packet, packetLength);
                PacketBuffer.Enqueue(packet);

                remaining = remaining.Skip(packetLength).ToArray();
                if (remaining.Length == 0)
                {
                    break;
                }
            }
        }
Exemple #2
0
        public void ReadStream(BinaryReader br)
        {
            magicId = br.ReadUInt32();
            size    = br.ReadUInt32();
            version = br.ReadUInt32();

            byte[] hexPrevBlockHash = br.ReadBytes(32);
            prevBlockHash = new Hash(hexPrevBlockHash);

            byte[] hexMerkleRootHash = br.ReadBytes(32);
            merkleRootHash = new Hash(hexMerkleRootHash);

            timestamp    = br.ReadUInt32();
            creationTime = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc).
                           AddSeconds(timestamp).ToLocalTime();

            targetDifficulty = br.ReadUInt32();
            nonce            = br.ReadUInt32();

            blockHash = GetBlockHash();

            VarInt.Decode(br, out firstVarIntByteNTxns, out nTxns);
            txns = Util.InstantiateArrayOf <Transaction>(nTxns);

            for (UInt64 i = 0; i < nTxns; ++i)
            {
                txns[i].ReadStream(br);
            }
        }
Exemple #3
0
        public void ReadStream(BinaryReader br) {

            VarInt.Decode(br, out firstVarIntByteNItems, out nStackItems);
            stackItems = Util.InstantiateArrayOf<StackItem>(nStackItems);

            for (int i = 0; i < stackItems.Length; ++i) {
                stackItems[i].ReadStream(br);
            }
        }
Exemple #4
0
        public void ReadStream(BinaryReader br)
        {
            VarInt.Decode(br, out firstVarIntByteLength, out itemLength);
            item = Util.InstantiateArrayOf <byte>(itemLength);

            for (int i = 0; i < item.Length; ++i)
            {
                item[i] = br.ReadByte();
            }
        }
        private void NetworkLoop()
        {
            _server.Start();
            while (!TridentMc.Instance.State.IsShuttingDown)
            {
                Thread.Sleep(1);
                foreach (var session in Sessions)
                {
                    while (session.PacketBuffer.Count > 0)
                    {
                        var packet = session.PacketBuffer.Dequeue();

                        if (session.UsesCompression)
                        {
                            throw new NotYetImplemented("Compression isn't implemented yet");
                        }
                        else
                        {
                            var packetId = VarInt.Decode(packet, out packet);
                            Log.Debug("[{SessionId}] Packet {PacketId} with state being {State}", session.Id, packetId, session.ConnectionState);

                            var serverPacket = _packetManager.CreateServerPacket(session.ConnectionState, packetId, packet);
                            if (serverPacket == null)
                            {
                                Log.Debug("[{SessionId}] -> Unknown packet", session.Id);
                                session.Disconnect();
                                break;
                            }

                            Type     packetReceivedType = typeof(PacketReceived <>).MakeGenericType(serverPacket.GetType());
                            object[] args = { serverPacket, session };
                            TridentMc.Instance.EventManager.FireEvent((IEvent)Activator.CreateInstance(packetReceivedType, args));

                            if (serverPacket is IChangesState stateChangePacket)
                            {
                                Log.Debug("[{SessionId}] Changing state to {NewState}", session.Id, stateChangePacket.NextState);
                                session.ConnectionState = stateChangePacket.NextState;
                            }

                            serverPacket.Handle(session);
                        }
                    }
                }
            }
        }
Exemple #6
0
        private static void Main(string[] args)
        {
            //Key Generation
            const string privKeyHex = "E9873D79C6D87DC0FB6A5778633389F4453213303DA61F20BD67FC233AA33262";
            BigInteger   privateKey = Hex.HexToBigInteger(privKeyHex);
            ECPoint      publicKey  = Secp256k1.G.Multiply(privateKey);
            string       bitcoinAddressUncompressed = publicKey.GetBitcoinAddress(false);
            string       bitcoinAddressCompressed   = publicKey.GetBitcoinAddress(compressed: true);

            Console.WriteLine("PrivateKey (Hex): {0}", privateKey.ToHex());
            Console.WriteLine("Address (Uncompressed): {0}", bitcoinAddressUncompressed);
            Console.WriteLine("Address (Compressed): {0}", bitcoinAddressCompressed);

            uint value = 268435263;

            var varInt = new VarInt(value);  //create VarInt from Integer

            Console.WriteLine("VarInt Internal Value: {0}", varInt.Value);
            Console.WriteLine("VarInt (hex): 0x{0:X}", varInt.Value);

            value = value ^ 2;

            byte[] varIntBytes = VarInt.Encode(value);
            Console.WriteLine("VarInt Static Encode & Decode test for value: {0}", value);
            Console.WriteLine("VarInt Encoded (hex): {0}", varIntBytes.ToHex());
            Console.WriteLine("Value Decoded: {0}", VarInt.Decode(varIntBytes));

            // encryption
            ECEncryption encryption = new ECEncryption();
            const string message    = "This is my encrypted message";

            byte[] encrypted        = encryption.Encrypt(publicKey, message);
            byte[] decrypted        = encryption.Decrypt(privateKey, encrypted);
            string decryptedMessage = Encoding.UTF8.GetString(decrypted);

            // signing
            MessageSignerVerifier messageSigner = new MessageSignerVerifier();
            SignedMessage         signedMessage = messageSigner.Sign(privateKey, "Test Message to sign, you can verify this on http://brainwallet.org/#verify");
            bool verified = messageSigner.Verify(signedMessage);

            Console.WriteLine("Press Any Key ...");
            Console.ReadKey();
        }
Exemple #7
0
        public void ReadStream(BinaryReader br)
        {
            versionNum = br.ReadUInt32();

            isSegwit = CheckForSegwitFlag(br);

            VarInt.Decode(br, out firstVarIntByteNInputs, out nInputs);
            inputs = Util.InstantiateArrayOf <InputTxn>(nInputs);

            for (int i = 0; i < inputs.Length; ++i)
            {
                inputs[i].ReadStream(br);
            }

            VarInt.Decode(br, out firstVarIntByteNOutputs, out nOutputs);
            outputs = Util.InstantiateArrayOf <OutputTxn>(nOutputs);

            for (int i = 0; i < outputs.Length; ++i)
            {
                outputs[i].ReadStream(br);
            }

            if (isSegwit)
            {
                witnesses = Util.InstantiateArrayOf <Witness>(nInputs);

                for (int i = 0; i < witnesses.Length; ++i)
                {
                    witnesses[i].ReadStream(br);
                }
            }

            lockTime = br.ReadUInt32();

            foreach (var output in outputs)
            {
                output.destinationAddress = Script.ExtractDestination(output);
            }

            txId = GetTxId();
        }
Exemple #8
0
        public void ReadStream(BinaryReader br)
        {
            byte[] hexTxnHash = new byte[32];
            hexTxnHash = br.ReadBytes(32);
            txnHash    = new Hash(hexTxnHash);

            vout = br.ReadUInt32();

            if (vout == 0xFFFFFFFF)
            {
                vout = 0x11111111;
            }

            VarInt.Decode(br, out firstVarIntByteScriptLength, out inputScriptLength);

            inputScript = Util.InstantiateArrayOf <byte>(inputScriptLength);

            for (int i = 0; i < inputScript.Length; ++i)
            {
                inputScript[i] = br.ReadByte();
            }

            sequenceNum = br.ReadUInt32();
        }
Exemple #9
0
 public int ReadVarint()
 {
     return(VarInt.Decode(_buffer, out _buffer));
 }
Exemple #10
0
 public void ReadStream(BinaryReader br)
 {
     value = br.ReadUInt64();
     VarInt.Decode(br, out firstVarIntByteScriptLength, out outputScriptLength);
     scriptPubKey = new ScriptPubKey(br, outputScriptLength);
 }