Inside Bitcoin

251                proxies=[self.serv3, self.serv3, self.serv3, self.serv3],
252                auth=False, test_onion=False, test_cjdns=False)
253
254        # -proxy=unauth -proxyrandomize=1 -cjdnsreachable
255        self.node_test(self.nodes[4],
256            proxies=[self.serv1, self.serv1, self.serv1, self.serv1],
257            auth=False, test_onion=True, test_cjdns=True)
258
259        if self.have_unix_sockets:
260            self.node_test(self.nodes[5],
261                proxies=[self.serv4, self.serv4, self.serv4, self.serv4],
262                auth=True, test_onion=True, test_cjdns=False)
263
264
265        def networks_dict(d):
266            r = {}
267            for x in d['networks']:
268                r[x['name']] = x
269            return r
270
271        self.log.info("Test RPC getnetworkinfo")
272        nodes_network_info = []
273
274        self.log.debug("Test that setting -proxy disables local address discovery, i.e. -discover=0")
275        for node in self.nodes:
276            network_info = node.getnetworkinfo()
277            assert_equal(network_info["localaddresses"], [])
278            nodes_network_info.append(network_info)
279
280        n0 = networks_dict(nodes_network_info[0])
281        assert_equal(NETWORKS, n0.keys())
282        for net in NETWORKS:
283            if net == NET_I2P:
284                expected_proxy = ''
285                expected_randomize = False
286            else:
287                expected_proxy = '%s:%i' % (self.conf1.addr)
288                expected_randomize = True
289            assert_equal(n0[net]['proxy'], expected_proxy)
290            assert_equal(n0[net]['proxy_randomize_credentials'], expected_randomize)
291        assert_equal(n0['onion']['reachable'], True)
292        assert_equal(n0['i2p']['reachable'], False)
293        assert_equal(n0['cjdns']['reachable'], False)
294
295        n1 = networks_dict(nodes_network_info[1])
296        assert_equal(NETWORKS, n1.keys())
297        for net in ['ipv4', 'ipv6']:
298            assert_equal(n1[net]['proxy'], f'{self.conf1.addr[0]}:{self.conf1.addr[1]}')
299            assert_equal(n1[net]['proxy_randomize_credentials'], False)
300        assert_equal(n1['onion']['proxy'], f'{self.conf2.addr[0]}:{self.conf2.addr[1]}')
301        assert_equal(n1['onion']['proxy_randomize_credentials'], False)
302        assert_equal(n1['onion']['reachable'], True)
303        assert_equal(n1['i2p']['proxy'], f'{self.i2p_sam[0]}:{self.i2p_sam[1]}')
304        assert_equal(n1['i2p']['proxy_randomize_credentials'], False)
305        assert_equal(n1['i2p']['reachable'], True)
306
307        n2 = networks_dict(nodes_network_info[2])
308        assert_equal(NETWORKS, n2.keys())
309        proxy = f'{self.conf2.addr[0]}:{self.conf2.addr[1]}'
310        for net in NETWORKS:
311            if net == NET_I2P:
312                expected_proxy = ''
313                expected_randomize = False
314            else:
315                expected_proxy = proxy
316                expected_randomize = True
317            assert_equal(n2[net]['proxy'], expected_proxy)
318            assert_equal(n2[net]['proxy_randomize_credentials'], expected_randomize)
319        assert_equal(n2['onion']['reachable'], True)
320        assert_equal(n2['i2p']['reachable'], False)
321        assert_equal(n2['cjdns']['reachable'], False)
322
323        if self.have_ipv6:
324            n3 = networks_dict(nodes_network_info[3])
325            assert_equal(NETWORKS, n3.keys())
326            proxy = f'[{self.conf3.addr[0]}]:{self.conf3.addr[1]}'
327            for net in NETWORKS:
328                expected_proxy = '' if net == NET_I2P or net == NET_ONION else proxy
329                assert_equal(n3[net]['proxy'], expected_proxy)
330                assert_equal(n3[net]['proxy_randomize_credentials'], False)
331            assert_equal(n3['onion']['reachable'], False)
332            assert_equal(n3['i2p']['reachable'], False)
333            assert_equal(n3['cjdns']['reachable'], False)
334
335        n4 = networks_dict(nodes_network_info[4])
336        assert_equal(NETWORKS, n4.keys())
337        for net in NETWORKS:
338            if net == NET_I2P:
339                expected_proxy = ''
340                expected_randomize = False
341            else:
342                expected_proxy = '%s:%i' % (self.conf1.addr)
343                expected_randomize = True
344            assert_equal(n4[net]['proxy'], expected_proxy)
345            assert_equal(n4[net]['proxy_randomize_credentials'], expected_randomize)
346        assert_equal(n4['onion']['reachable'], True)
347        assert_equal(n4['i2p']['reachable'], False)
348        assert_equal(n4['cjdns']['reachable'], True)
349
350        if self.have_unix_sockets:
351            n5 = networks_dict(nodes_network_info[5])
352            assert_equal(NETWORKS, n5.keys())
353            for net in NETWORKS:
354                if net == NET_I2P:
355                    expected_proxy = ''
356                    expected_randomize = False
357                else:
358                    expected_proxy = 'unix:' + self.conf4.addr # no port number
359                    expected_randomize = True
360                assert_equal(n5[net]['proxy'], expected_proxy)
361                assert_equal(n5[net]['proxy_randomize_credentials'], expected_randomize)
362            assert_equal(n5['onion']['reachable'], True)
363            assert_equal(n5['i2p']['reachable'], False)
364            assert_equal(n5['cjdns']['reachable'], False)
365
366            n6 = networks_dict(nodes_network_info[6])
367            assert_equal(NETWORKS, n6.keys())
368            for net in NETWORKS:
369                if net != NET_ONION:
370                    expected_proxy = ''
371                    expected_randomize = False
372                else:
373                    expected_proxy = 'unix:' + self.conf4.addr # no port number
374                    expected_randomize = True
375                assert_equal(n6[net]['proxy'], expected_proxy)
376                assert_equal(n6[net]['proxy_randomize_credentials'], expected_randomize)
377            assert_equal(n6['onion']['reachable'], True)
378            assert_equal(n6['i2p']['reachable'], False)
379            assert_equal(n6['cjdns']['reachable'], False)
380
381        self.stop_node(1)
382
383        self.log.info("Test passing invalid -proxy hostname raises expected init error")
384        self.nodes[1].extra_args = ["-proxy=abc..abc:23456"]
385        msg = "Error: Invalid -proxy address or hostname: 'abc..abc:23456'"
386        self.nodes[1].assert_start_raises_init_error(expected_msg=msg)
387
388        self.log.info("Test passing invalid -proxy port raises expected init error")
389        self.nodes[1].extra_args = ["-proxy=192.0.0.1:def"]
390        msg = "Error: Invalid port specified in -proxy: '192.0.0.1:def'"
391        self.nodes[1].assert_start_raises_init_error(expected_msg=msg)
392
393        self.log.info("Test passing invalid -onion hostname raises expected init error")
394        self.nodes[1].extra_args = ["-onion=xyz..xyz:23456"]
395        msg = "Error: Invalid -onion address or hostname: 'xyz..xyz:23456'"
396        self.nodes[1].assert_start_raises_init_error(expected_msg=msg)
397
398        self.log.info("Test passing invalid -onion port raises expected init error")
399        self.nodes[1].extra_args = ["-onion=192.0.0.1:def"]
400        msg = "Error: Invalid port specified in -onion: '192.0.0.1:def'"
401        self.nodes[1].assert_start_raises_init_error(expected_msg=msg)
402
403        self.log.info("Test passing invalid -i2psam hostname raises expected init error")
404        self.nodes[1].extra_args = ["-i2psam=def..def:23456"]
405        msg = "Error: Invalid -i2psam address or hostname: 'def..def:23456'"
406        self.nodes[1].assert_start_raises_init_error(expected_msg=msg)
407
408        self.log.info("Test passing invalid -i2psam port raises expected init error")
409        self.nodes[1].extra_args = ["-i2psam=192.0.0.1:def"]
410        msg = "Error: Invalid port specified in -i2psam: '192.0.0.1:def'"
411        self.nodes[1].assert_start_raises_init_error(expected_msg=msg)
412
413        self.log.info("Test passing invalid -onlynet=i2p without -i2psam raises expected init error")
414        self.nodes[1].extra_args = ["-onlynet=i2p"]
415        msg = "Error: Outbound connections restricted to i2p (-onlynet=i2p) but -i2psam is not provided"
416        self.nodes[1].assert_start_raises_init_error(expected_msg=msg)
417
418        self.log.info("Test passing invalid -onlynet=cjdns without -cjdnsreachable raises expected init error")
419        self.nodes[1].extra_args = ["-onlynet=cjdns"]
420        msg = "Error: Outbound connections restricted to CJDNS (-onlynet=cjdns) but -cjdnsreachable is not provided"
421        self.nodes[1].assert_start_raises_init_error(expected_msg=msg)
422
423        self.log.info("Test passing -onlynet=onion with -onion=0/-noonion raises expected init error")
424        msg = (
425            "Error: Outbound connections restricted to Tor (-onlynet=onion) but "
426            "the proxy for reaching the Tor network is explicitly forbidden: -onion=0"
427        )
428        for arg in ["-onion=0", "-noonion"]:
429            self.nodes[1].extra_args = ["-onlynet=onion", arg]
430            self.nodes[1].assert_start_raises_init_error(expected_msg=msg)
431
432        self.log.info("Test passing -onlynet=onion without -proxy, -onion or -listenonion raises expected init error")
433        self.nodes[1].extra_args = ["-onlynet=onion", "-listenonion=0"]
434        msg = (
435            "Error: Outbound connections restricted to Tor (-onlynet=onion) but the proxy for "
436            "reaching the Tor network is not provided: none of -proxy, -onion or -listenonion is given"
437        )
438        self.nodes[1].assert_start_raises_init_error(expected_msg=msg)
439
440        self.log.info("Test passing -onlynet=onion without -proxy or -onion but with -listenonion=1 is ok")
441        self.start_node(1, extra_args=["-onlynet=onion", "-listenonion=1"])
442        self.stop_node(1)
443
444        self.log.info("Test unknown and removed network names are rejected by -onlynet")
445        for network in ["abc", "tor"]:
446            self.nodes[1].extra_args = [f"-onlynet={network}"]
447            msg = f"Error: Unknown network specified in -onlynet: '{network}'"
448            self.nodes[1].assert_start_raises_init_error(expected_msg=msg)
449
450        self.log.info("Test passing trailing '=' raises expected init error")
451        self.nodes[1].extra_args = ["-proxy=127.0.0.1:9050="]
452        msg = "Error: Invalid -proxy address or hostname, ends with '=': '127.0.0.1:9050='"
453        self.nodes[1].assert_start_raises_init_error(expected_msg=msg)
454
455        self.log.info("Test unknown, removed and non-SOCKS5 network names are rejected by -proxy")
456        for network in ["Foo", "tor", "i2p"]:
457            self.nodes[1].extra_args = [f"-proxy=127.0.0.1:9050={network}"]
458            msg = f"Error: Unrecognized network in -proxy='127.0.0.1:9050={network}': '{network}'"
459            self.nodes[1].assert_start_raises_init_error(expected_msg=msg)
460
461        self.log.info("Test passing proxy only for IPv6")
462        self.start_node(1, extra_args=["-proxy=127.6.6.6:6666=ipv6"])
463        nets = networks_dict(self.nodes[1].getnetworkinfo())
464        assert_equal(nets["ipv4"]["proxy"], "")
465        assert_equal(nets["ipv6"]["proxy"], "127.6.6.6:6666")
466        self.stop_node(1)
467
468        self.log.info("Test passing separate proxy for IPv4 and IPv6")
469        self.start_node(1, extra_args=["-proxy=127.4.4.4:4444=ipv4", "-proxy=127.6.6.6:6666=ipv6"])
470        nets = networks_dict(self.nodes[1].getnetworkinfo())
471        assert_equal(nets["ipv4"]["proxy"], "127.4.4.4:4444")
472        assert_equal(nets["ipv6"]["proxy"], "127.6.6.6:6666")
473        self.stop_node(1)
474
475        self.log.info("Test overriding the Onion proxy with a mixed-case network suffix")
476        self.start_node(1, extra_args=["-proxy=127.1.1.1:1111", "-proxy=127.2.2.2:2222=OnIoN"])
477        nets = networks_dict(self.nodes[1].getnetworkinfo())
478        assert_equal(nets["ipv4"]["proxy"], "127.1.1.1:1111")
479        assert_equal(nets["ipv6"]["proxy"], "127.1.1.1:1111")
480        assert_equal(nets["onion"]["proxy"], "127.2.2.2:2222")
481        self.stop_node(1)
482
483        self.log.info("Test removing CJDNS proxy")
484        self.start_node(1, extra_args=["-proxy=127.1.1.1:1111", "-proxy=0=cjdns"])
485        nets = networks_dict(self.nodes[1].getnetworkinfo())
486        assert_equal(nets["ipv4"]["proxy"], "127.1.1.1:1111")
487        assert_equal(nets["ipv6"]["proxy"], "127.1.1.1:1111")
488        assert_equal(nets["onion"]["proxy"], "127.1.1.1:1111")
489        assert_equal(nets["cjdns"]["proxy"], "")
490        self.stop_node(1)
491
492        self.log.info("Test that clearing the IPv4 proxy also clears the name proxy")
493        self.start_node(1, extra_args=[f"-proxy={self.conf1.addr[0]}:{self.conf1.addr[1]}", "-proxy=0=ipv4", "-dns=0"])
494        with self.nodes[1].assert_debug_log(
495            expected_msgs=["trying v1 connection (manual) to example.invalid:8333"],
496            unexpected_msgs=["SOCKS5 connecting example.invalid"],
497        ):
498            self.nodes[1].addnode("example.invalid:8333", "onetry", v2transport=False)
499        self.stop_node(1)
500