Source: net/netaddress.js

  1. /*!
  2.  * netaddress.js - network address object for hsd
  3.  * Copyright (c) 2017-2018, Christopher Jeffrey (MIT License).
  4.  * https://github.com/handshake-org/hsd
  5.  */
  7. 'use strict';
  9. const assert = require('bsert');
  10. const bio = require('bufio');
  11. const IP = require('binet');
  12. const base32 = require('bcrypto/lib/encoding/base32');
  13. const Network = require('../protocol/network');
  14. const util = require('../utils/util');
  15. const common = require('./common');
  17. /** @typedef {import('net').Socket} NetSocket */
  18. /** @typedef {import('../types').NetworkType} NetworkType */
  19. /** @typedef {import('../types').BufioWriter} BufioWriter */
  21. /*
  22.  * Constants
  23.  */
  25. const ZERO_KEY = Buffer.alloc(33, 0x00);
  27. /**
  28.  * Net Address
  29.  * Represents a network address.
  30.  * @alias module:net.NetAddress
  31.  * @property {Host} host
  32.  * @property {Number} port
  33.  * @property {Number} services
  34.  * @property {Number} time
  35.  */
  37. class NetAddress extends bio.Struct {
  38.   /**
  39.    * Create a network address.
  40.    * @constructor
  41.    * @param {Object} [options]
  42.    * @param {Number?} options.time - Timestamp.
  43.    * @param {Number?} options.services - Service bits.
  44.    * @param {String?} options.host - IP address (IPv6 or IPv4).
  45.    * @param {Number?} options.port - Port.
  46.    */
  48.   constructor(options) {
  49.     super();
  51.     this.host = '0.0.0.0';
  52.     this.port = 0;
  53.     this.services = 0;
  54.     this.time = 0;
  55.     this.hostname = '0.0.0.0:0';
  56.     this.raw = IP.ZERO_IPV4;
  57.     this.key = ZERO_KEY;
  59.     if (options)
  60.       this.fromOptions(options);
  61.   }
  63.   /**
  64.    * Inject properties from options object.
  65.    * @param {Object} options
  66.    */
  68.   fromOptions(options) {
  69.     assert(typeof options.host === 'string',
  70.       'NetAddress requires host string.');
  71.     assert(typeof options.port === 'number',
  72.       'NetAddress requires port number.');
  73.     assert(options.port >= 0 && options.port <= 0xffff,
  74.       'port number is incorrect.');
  76.     this.raw = IP.toBuffer(options.host);
  77.     this.host = IP.toString(this.raw);
  78.     this.port = options.port;
  80.     if (options.services) {
  81.       assert(typeof options.services === 'number',
  82.         'services must be a number.');
  83.       this.services = options.services;
  84.     }
  86.     if (options.time) {
  87.       assert(typeof options.time === 'number',
  88.         'time must be a number.');
  89.       this.time = options.time;
  90.     }
  92.     if (options.key) {
  93.       assert(Buffer.isBuffer(options.key), 'key must be a buffer.');
  94.       assert(options.key.length === 33, 'key length must be 33.');
  95.       this.key = options.key;
  96.     }
  98.     this.hostname = IP.toHostname(this.host, this.port, this.key);
  100.     return this;
  101.   }
  103.   /**
  104.    * Test whether required services are available.
  105.    * @param {Number} services
  106.    * @returns {Boolean}
  107.    */
  109.   hasServices(services) {
  110.     return (this.services & services) === services;
  111.   }
  113.   /**
  114.    * Test whether the address is IPv4.
  115.    * @returns {Boolean}
  116.    */
  118.   isIPv4() {
  119.     return IP.isIPv4(this.raw);
  120.   }
  122.   /**
  123.    * Test whether the address is IPv6.
  124.    * @returns {Boolean}
  125.    */
  127.   isIPv6() {
  128.     return IP.isIPv6(this.raw);
  129.   }
  131.   /**
  132.    * Test whether the address is RFC3964.
  133.    * @returns {Boolean}
  134.    */
  136.   isRFC3964() {
  137.     return IP.isRFC3964(this.raw);
  138.   }
  140.   /**
  141.    * Test whether the address is RFC4380.
  142.    * @returns {Boolean}
  143.    */
  145.   isRFC4380() {
  146.     return IP.isRFC4380(this.raw);
  147.   }
  149.   /**
  150.    * Test whether the address is RFC6052.
  151.    * @returns {Boolean}
  152.    */
  154.   isRFC6052() {
  155.     return IP.isRFC6052(this.raw);
  156.   }
  158.   /**
  159.    * Test whether the address is RFC6145.
  160.    * @returns {Boolean}
  161.    */
  163.   isRFC6145() {
  164.     return IP.isRFC6145(this.raw);
  165.   }
  167.   /**
  168.    * Test whether the host is null.
  169.    * @returns {Boolean}
  170.    */
  172.   isNull() {
  173.     return IP.isNull(this.raw);
  174.   }
  176.   /**
  177.    * Test whether the host is a local address.
  178.    * @returns {Boolean}
  179.    */
  181.   isLocal() {
  182.     return IP.isLocal(this.raw);
  183.   }
  185.   /**
  186.    * Test whether the host is valid.
  187.    * @returns {Boolean}
  188.    */
  190.   isValid() {
  191.     return IP.isValid(this.raw);
  192.   }
  194.   /**
  195.    * Test whether the host is routable.
  196.    * @returns {Boolean}
  197.    */
  199.   isRoutable() {
  200.     return IP.isRoutable(this.raw);
  201.   }
  203.   /**
  204.    * Test whether the host is an onion address.
  205.    * @returns {Boolean}
  206.    */
  208.   isOnion() {
  209.     return IP.isOnion(this.raw);
  210.   }
  212.   /**
  213.    * Test whether the peer has a key.
  214.    * @returns {Boolean}
  215.    */
  217.   hasKey() {
  218.     return !this.key.equals(ZERO_KEY);
  219.   }
  221.   /**
  222.    * Compare against another network address.
  223.    * @param {NetAddress} addr
  224.    * @returns {Boolean}
  225.    */
  227.   equal(addr) {
  228.     return this.compare(addr) === 0;
  229.   }
  231.   /**
  232.    * Compare against another network address.
  233.    * @param {NetAddress} addr
  234.    * @returns {Number}
  235.    */
  237.   compare(addr) {
  238.     const cmp = this.raw.compare(addr.raw);
  240.     if (cmp !== 0)
  241.       return cmp;
  243.     return this.port - addr.port;
  244.   }
  246.   /**
  247.    * Get reachable score to destination.
  248.    * @param {NetAddress} dest
  249.    * @returns {Number}
  250.    */
  252.   getReachability(dest) {
  253.     return IP.getReachability(this.raw, dest.raw);
  254.   }
  256.   /**
  257.    * Get the canonical identifier of our network group
  258.    * @returns {Buffer}
  259.    */
  261.   getGroup() {
  262.     return groupKey(this);
  263.   }
  265.   /**
  266.    * Set null host.
  267.    */
  269.   setNull() {
  270.     this.raw = IP.ZERO_IPV4;
  271.     this.host = '0.0.0.0';
  272.     this.key = ZERO_KEY;
  273.     this.hostname = IP.toHostname(this.host, this.port, this.key);
  274.   }
  276.   /**
  277.    * Set host.
  278.    * @param {String} host
  279.    */
  281.   setHost(host) {
  282.     this.raw = IP.toBuffer(host);
  283.     this.host = IP.toString(this.raw);
  284.     this.hostname = IP.toHostname(this.host, this.port, this.key);
  285.   }
  287.   /**
  288.    * Set port.
  289.    * @param {Number} port
  290.    */
  292.   setPort(port) {
  293.     assert(port >= 0 && port <= 0xffff);
  294.     this.port = port;
  295.     this.hostname = IP.toHostname(this.host, this.port, this.key);
  296.   }
  298.   /**
  299.    * Set key.
  300.    * @param {Buffer} key
  301.    */
  303.   setKey(key) {
  304.     if (key == null)
  305.       key = ZERO_KEY;
  307.     assert(Buffer.isBuffer(key) && key.length === 33);
  309.     this.key = key;
  310.     this.hostname = IP.toHostname(this.host, this.port, this.key);
  311.   }
  313.   /**
  314.    * Get key.
  315.    * @param {String} enc
  316.    * @returns {String|Buffer}
  317.    */
  319.   getKey(enc) {
  320.     if (!this.hasKey())
  321.       return null;
  323.     if (enc === 'base32')
  324.       return base32.encode(this.key);
  326.     if (enc === 'hex')
  327.       return this.key.toString('hex');
  329.     return this.key;
  330.   }
  332.   /**
  333.    * Inject properties from host, port, and network.
  334.    * @param {String} host
  335.    * @param {Number} port
  336.    * @param {Buffer} [key]
  337.    * @param {(Network|NetworkType)?} [network]
  338.    */
  340.   fromHost(host, port, key, network) {
  341.     network = Network.get(network);
  343.     assert(port >= 0 && port <= 0xffff);
  344.     assert(!key || Buffer.isBuffer(key));
  345.     assert(!key || key.length === 33);
  347.     this.raw = IP.toBuffer(host);
  348.     this.host = IP.toString(this.raw);
  349.     this.port = port;
  350.     this.services = NetAddress.DEFAULT_SERVICES;
  351.     this.time = network.now();
  352.     this.key = key || ZERO_KEY;
  353.     this.hostname = IP.toHostname(this.host, this.port, this.key);
  355.     return this;
  356.   }
  358.   /**
  359.    * Instantiate a network address
  360.    * from a host and port.
  361.    * @param {String} host
  362.    * @param {Number} port
  363.    * @param {Buffer} [key]
  364.    * @param {(Network|NetworkType)?} [network]
  365.    * @returns {NetAddress}
  366.    */
  368.   static fromHost(host, port, key, network) {
  369.     return new this().fromHost(host, port, key, network);
  370.   }
  372.   /**
  373.    * Inject properties from hostname and network.
  374.    * @param {String} hostname
  375.    * @param {(Network|NetworkType)?} [network]
  376.    */
  378.   fromHostname(hostname, network) {
  379.     network = Network.get(network);
  381.     const addr = IP.fromHostname(hostname);
  383.     if (addr.port === 0)
  384.       addr.port = addr.key ? network.brontidePort : network.port;
  386.     return this.fromHost(addr.host, addr.port, addr.key, network);
  387.   }
  389.   /**
  390.    * Instantiate a network address
  391.    * from a hostname (i.e. 127.0.0.1:8333).
  392.    * @param {String} hostname
  393.    * @param {(Network|NetworkType)?} [network]
  394.    * @returns {NetAddress}
  395.    */
  397.   static fromHostname(hostname, network) {
  398.     return new this().fromHostname(hostname, network);
  399.   }
  401.   /**
  402.    * Inject properties from socket.
  403.    * @param {NetSocket} socket
  404.    * @param {(Network|NetworkType)?} [network]
  405.    */
  407.   fromSocket(socket, network) {
  408.     const host = socket.remoteAddress;
  409.     const port = socket.remotePort;
  410.     assert(typeof host === 'string');
  411.     assert(typeof port === 'number');
  412.     return this.fromHost(IP.normalize(host), port, null, network);
  413.   }
  415.   /**
  416.    * Instantiate a network address
  417.    * from a socket.
  418.    * @param {NetSocket} socket
  419.    * @param {(Network|NetworkType)?} [network]
  420.    * @returns {NetAddress}
  421.    */
  423.   static fromSocket(socket, network) {
  424.     return new this().fromSocket(socket, network);
  425.   }
  427.   /**
  428.    * Calculate serialization size of address.
  429.    * @returns {Number}
  430.    */
  432.   getSize() {
  433.     return 88;
  434.   }
  436.   /**
  437.    * Write network address to a buffer writer.
  438.    * @param {BufioWriter} bw
  439.    * @returns {BufioWriter}
  440.    */
  442.   write(bw) {
  443.     bw.writeU64(this.time);
  444.     bw.writeU32(this.services);
  445.     bw.writeU32(0);
  446.     bw.writeU8(0);
  447.     bw.writeBytes(this.raw);
  448.     bw.fill(0, 20); // reserved
  449.     bw.writeU16(this.port);
  450.     bw.writeBytes(this.key);
  451.     return bw;
  452.   }
  454.   /**
  455.    * Inject properties from buffer reader.
  456.    * @param {bio.BufferReader} br
  457.    */
  459.   read(br) {
  460.     this.time = br.readU64();
  461.     this.services = br.readU32();
  463.     // Note: hi service bits
  464.     // are currently unused.
  465.     br.readU32();
  467.     if (br.readU8() === 0) {
  468.       this.raw = br.readBytes(16);
  469.       br.seek(20);
  470.     } else {
  471.       this.raw = Buffer.alloc(16, 0x00);
  472.       br.seek(36);
  473.     }
  475.     this.port = br.readU16();
  476.     this.key = br.readBytes(33);
  478.     this.host = IP.toString(this.raw);
  479.     this.hostname = IP.toHostname(this.host, this.port, this.key);
  481.     return this;
  482.   }
  484.   /**
  485.    * Convert net address to json-friendly object.
  486.    * @returns {Object}
  487.    */
  489.   getJSON() {
  490.     return {
  491.       host: this.host,
  492.       port: this.port,
  493.       services: this.services,
  494.       time: this.time,
  495.       key: this.key.toString('hex')
  496.     };
  497.   }
  499.   /**
  500.    * Inject properties from json object.
  501.    * @param {Object} json
  502.    * @returns {this}
  503.    */
  505.   fromJSON(json) {
  506.     assert((json.port & 0xffff) === json.port);
  507.     assert((json.services >>> 0) === json.services);
  508.     assert((json.time >>> 0) === json.time);
  509.     assert(typeof json.key === 'string');
  510.     this.raw = IP.toBuffer(json.host);
  511.     this.host = json.host;
  512.     this.port = json.port;
  513.     this.services = json.services;
  514.     this.time = json.time;
  515.     this.key = Buffer.from(json.key, 'hex');
  516.     this.hostname = IP.toHostname(this.host, this.port, this.key);
  517.     return this;
  518.   }
  520.   /**
  521.    * Inspect the network address.
  522.    * @returns {Object}
  523.    */
  525.   format() {
  526.     return '<NetAddress:'
  527.       + ` hostname=${this.hostname}`
  528.       + ` services=${this.services.toString(2)}`
  529.       + ` date=${util.date(this.time)}`
  530.       + '>';
  531.   }
  532. }
  534. /**
  535.  * Default services for
  536.  * unknown outbound peers.
  537.  * @const {Number}
  538.  * @default
  539.  */
  541. NetAddress.DEFAULT_SERVICES = 0
  542.   | common.services.NETWORK
  543.   | common.services.BLOOM;
  545. /*
  546.  * Helpers
  547.  */
  549. /**
  550.  * @param {NetAddress} addr
  551.  * @returns {Buffer}
  552.  */
  554. function groupKey(addr) {
  555.   const raw = addr.raw;
  557.   // See: https://github.com/bitcoin/bitcoin/blob/e258ce7/src/netaddress.cpp#L413
  558.   // Todo: Use IP->ASN mapping, see:
  559.   // https://github.com/bitcoin/bitcoin/blob/adea5e1/src/addrman.h#L274
  560.   let type = IP.networks.INET6; // NET_IPV6
  561.   let start = 0;
  562.   let bits = 16;
  563.   let i = 0;
  565.   if (addr.isLocal()) {
  566.     type = 255; // NET_LOCAL
  567.     bits = 0;
  568.   } else if (!addr.isRoutable()) {
  569.     type = IP.networks.NONE; // NET_UNROUTABLE
  570.     bits = 0;
  571.   } else if (addr.isIPv4() || addr.isRFC6145() || addr.isRFC6052()) {
  572.     type = IP.networks.INET4; // NET_IPV4
  573.     start = 12;
  574.   } else if (addr.isRFC3964()) {
  575.     type = IP.networks.INET4; // NET_IPV4
  576.     start = 2;
  577.   } else if (addr.isRFC4380()) {
  578.     const buf = Buffer.alloc(3);
  579.     buf[0] = IP.networks.INET4; // NET_IPV4
  580.     buf[1] = raw[12] ^ 0xff;
  581.     buf[2] = raw[13] ^ 0xff;
  582.     return buf;
  583.   } else if (addr.isOnion()) {
  584.     type = IP.networks.ONION; // NET_ONION
  585.     start = 6;
  586.     bits = 4;
  587.   } else if (raw[0] === 0x20
  588.           && raw[1] === 0x01
  589.           && raw[2] === 0x04
  590.           && raw[3] === 0x70) {
  591.     bits = 36;
  592.   } else {
  593.     bits = 32;
  594.   }
  596.   const out = Buffer.alloc(1 + ((bits + 7) >>> 3));
  598.   out[i++] = type;
  600.   while (bits >= 8) {
  601.     out[i++] = raw[start++];
  602.     bits -= 8;
  603.   }
  605.   if (bits > 0)
  606.     out[i++] = raw[start] | ((1 << (8 - bits)) - 1);
  608.   assert(i === out.length);
  610.   return out;
  611. }
  613. /*
  614.  * Expose
  615.  */
  617. module.exports = NetAddress;