Пример #1
0
        public void SerializeV2()
        {
            var addr   = new NetworkAddress();
            var mem    = new MemoryStream();
            var stream = new BitcoinStream(mem, true);

            string HexStr()
            {
                var arr = mem.ToArray();

                return(Encoders.Hex.EncodeData(arr, 1, arr.Length - 3));
            }

            // Add ADDRV2_FORMAT to the version so that the CNetAddr
            // serialize method produces an address in v2 format.
            stream.ProtocolVersion = NetworkAddress.AddrV2Format;
            stream.Type            = SerializationType.Hash;

            stream.ReadWrite(addr);
            Assert.Equal("021000000000000000000000000000000000", HexStr());

            mem.Clear();
            addr = new NetworkAddress(IPAddress.Parse("1.2.3.4"));
            stream.ReadWrite(addr);
            Assert.Equal("010401020304", HexStr());

            mem.Clear();
            addr = new NetworkAddress(IPAddress.Parse("1a1b:2a2b:3a3b:4a4b:5a5b:6a6b:7a7b:8a8b"));
            stream.ReadWrite(addr);
            Assert.Equal("02101a1b2a2b3a3b4a4b5a5b6a6b7a7b8a8b", HexStr());

            mem.Clear();
            addr = new NetworkAddress();
            addr.SetSpecial("6hzph5hv6337r6p2.onion");
            stream.ReadWrite(addr);
            Assert.Equal("030af1f2f3f4f5f6f7f8f9fa", HexStr());

            mem.Clear();
            addr = new NetworkAddress();
            addr.SetSpecial("kpgvmscirrdqpekbqjsvw5teanhatztpp2gl6eee4zkowvwfxwenqaid.onion");
            stream.ReadWrite(addr);
            Assert.Equal("042053cd5648488c4707914182655b7664034e09e66f7e8cbf1084e654eb56c5bd88", HexStr());
        }
Пример #2
0
        public void SerializeV1()
        {
            var addr   = new NetworkAddress();
            var mem    = new MemoryStream();
            var stream = new BitcoinStream(mem, true);

            string AddressHex()
            {
                var arr = mem.ToArray();

                return(Encoders.Hex.EncodeData(arr, 8, 16));
            }

            // serialize method produces an address in v2 format.
            stream.Type = SerializationType.Hash;

            stream.ReadWrite(addr);
            Assert.Equal("00000000000000000000000000000000", AddressHex());

            mem.Clear();
            addr = new NetworkAddress(IPAddress.Parse("1.2.3.4"));
            stream.ReadWrite(addr);
            Assert.Equal("00000000000000000000ffff01020304", AddressHex());

            mem.Clear();
            addr = new NetworkAddress(IPAddress.Parse("1a1b:2a2b:3a3b:4a4b:5a5b:6a6b:7a7b:8a8b"));
            stream.ReadWrite(addr);
            Assert.Equal("1a1b2a2b3a3b4a4b5a5b6a6b7a7b8a8b", AddressHex());

            mem.Clear();
            addr = new NetworkAddress();
            addr.SetSpecial("6hzph5hv6337r6p2.onion");
            stream.ReadWrite(addr);
            Assert.Equal("fd87d87eeb43f1f2f3f4f5f6f7f8f9fa", AddressHex());

            mem.Clear();
            addr = new NetworkAddress();
            addr.SetSpecial("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion");
            stream.ReadWrite(addr);
            Assert.Equal("00000000000000000000000000000000", AddressHex());
        }
Пример #3
0
        public void CanParseSpecialAddresses()
        {
            var addr = new NetworkAddress();

            // TORv2
            Assert.True(addr.SetSpecial("6hzph5hv6337r6p2.onion"));
            Assert.True(addr.AddressType == NetworkAddressType.Onion);

            Assert.True(addr.IsAddrV1Compatible);
            Assert.Equal("6hzph5hv6337r6p2.onion", addr.ToAddressString());

            // TORv3
            var torv3_addr = "pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion";

            Assert.True(addr.SetSpecial(torv3_addr));
            Assert.True(addr.AddressType == NetworkAddressType.Onion);

            Assert.False(addr.IsAddrV1Compatible);
            Assert.Equal(addr.ToAddressString(), torv3_addr);

            // TORv3, broken, with wrong checksum
            Assert.False(addr.SetSpecial("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscsad.onion"));

            // TORv3, broken, with wrong version
            Assert.False(addr.SetSpecial("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscrye.onion"));

            // TORv3, malicious
            Assert.False(addr.SetSpecial("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd\0wtf.onion"));

            // TOR, bogus length
            Assert.False(addr.SetSpecial("mfrggzak.onion"));

            // TOR, invalid base32
            Assert.False(addr.SetSpecial("mf*g zak.onion"));

            // I2P
            var i2p_addr = "udhdrtrcetjm5sxzskjyr5ztpeszydbh4dpl3pl4utgqqw2v4jna.b32.i2p";

            Assert.True(addr.SetSpecial(i2p_addr));
            Assert.True(addr.AddressType == NetworkAddressType.I2P);
            Assert.False(addr.IsAddrV1Compatible);
            Assert.Equal(addr.ToAddressString(), i2p_addr);

            // I2P, malicious
            Assert.False(addr.SetSpecial("udhdrtrcetjm5sxzskjyr5ztpeszydbh4dpl3pl4utgqqw2v4jna\0wtf.b32.i2p"));

            // I2P, valid but unsupported
            Assert.False(addr.SetSpecial("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscsad.b32.i2p"));

            // I2P, invalid base32
            Assert.False(addr.SetSpecial("tp*szydbh4dp.b32.i2p"));

            // General validations
            Assert.False(addr.SetSpecial(".onion"));
            Assert.False(addr.SetSpecial(""));
        }