Source: structs.js

  1. /**
  2.  * Implements common structures.
  3.  * @see {@link
  4.  * https://bitmessage.org/wiki/Protocol_specification#Common_structures}
  5.  * @module bitmessage/structs
  6.  * @example
  7.  * var structs = require("bitmessage").structs;
  8.  *
  9.  * var encoded = Buffer.concat([
  10.  *   structs.var_int.encode(4),
  11.  *   Buffer("test"),
  12.  *   structs.var_str.encode("test2"),
  13.  *   structs.var_int_list.encode([1, 2, 3]),
  14.  * ]);
  15.  *
  16.  * var decoded1 = structs.var_str.decode(encoded);
  17.  * console.log(decoded1.str);  // test
  18.  * var decoded2 = structs.var_str.decode(decoded1.rest);
  19.  * console.log(decoded2.str);  // test2
  20.  * var decoded3 = structs.var_int.decode(decoded2.rest);
  21.  * console.log(decoded3.value);  // 3
  22.  * var decoded4 = structs.var_int_list.decode(decoded2.rest);
  23.  * console.log(decoded4.list);  // [1, 2, 3]
  24.  */
  26. "use strict";
  28. var objectAssign = Object.assign || require("object-assign");
  29. var bufferEqual = require("buffer-equal");
  30. var bmcrypto = require("./crypto");
  31. var POW = require("./pow");
  32. var util = require("./_util");
  34. var assert = util.assert;
  35. var IPv4_MAPPING = util.IPv4_MAPPING;
  36. var inet_pton = util.inet_pton;
  38. function isAscii(str) {
  39.   for (var i = 0; i < str.length; i++) {
  40.     if (str.charCodeAt(i) > 127) {
  41.       return false;
  42.     }
  43.   }
  44.   return true;
  45. }
  47. // Compute the message checksum for the given data.
  48. function getmsgchecksum(data) {
  49.   return bmcrypto.sha512(data).slice(0, 4);
  50. }
  52. // \ :3 /
  53. function findMagic(buf) {
  54.   var i;
  55.   var len = buf.length;
  56.   var firstb = false;
  57.   var secondb = false;
  58.   var thirdb = false;
  59.   for (i = 0; i < len; ++i) {
  60.     switch (buf[i]) {
  61.       case 0xE9:
  62.         firstb = true;
  63.         break;
  64.       case 0xBE:
  65.         if (firstb) { secondb = true; }
  66.         break;
  67.       case 0xB4:
  68.         if (firstb && secondb) { thirdb = true; }
  69.         break;
  70.       case 0xD9:
  71.         if (firstb && secondb && thirdb) { return i - 3; }
  72.         break;
  73.       default:
  74.         firstb = false;
  75.         secondb = false;
  76.         thirdb = false;
  77.     }
  78.   }
  79.   // If we reached the end of the buffer but part of the magic matches
  80.   // we'll still return index of the magic's start position.
  81.   if (firstb) {
  82.     if (secondb) {
  83.       --i;
  84.     }
  85.     if (thirdb) {
  86.       --i;
  87.     }
  88.     return i - 1;  // Compensate for last i's increment
  89.   } else {
  90.     return -1;
  91.   }
  92. }
  94. /**
  95.  * Message structure.
  96.  * @see {@link https://bitmessage.org/wiki/Protocol_specification#Message_structure}
  97.  * @namespace
  98.  * @static
  99.  */
  100. var message = exports.message = {
  101.   /**
  102.    * Bitmessage magic value.
  103.    * @constant {number}
  104.    */
  105.   MAGIC: 0xE9BEB4D9,
  107.   /**
  108.    * @typedef {Object} TryDecodeResult
  109.    * @property {Object} message - Decoded message
  110.    * @property {string} message.command - Message command
  111.    * @property {Buffer} message.payload - Message payload
  112.    * @property {number} message.length - Full message length
  113.    * @property {Error} error - ...or decoding error
  114.    * @property {Buffer} rest - The rest of the input buffer after
  115.    * processing message
  116.    * @memberof module:bitmessage/structs.message
  117.    */
  119.   /**
  120.    * Decode message in "stream" mode.  
  121.    * NOTE: message payload and `rest` are copied (so the runtime can GC
  122.    * processed buffer data).
  123.    * @param {Buffer} buf - Data buffer
  124.    * @return {?TryDecodeResult}
  125.    * [Decoded result.]{@link module:bitmessage/structs.message.TryDecodeResult}
  126.    */
  127.   tryDecode: function(buf) {
  128.     if (buf.length < 24) {
  129.       // Message is not yet fully received, just skip to next process
  130.       // cycle.
  131.       return;
  132.     }
  133.     var res = {};
  135.     // Magic.
  136.     var mindex = findMagic(buf);
  137.     if (mindex !== 0) {
  138.       if (mindex === -1) {
  139.         res.error = new Error("Magic not found, skipping buffer data");
  140.         res.rest = new Buffer(0);
  141.       } else {
  142.         res.error = new Error(
  143.           "Magic in the middle of buffer, skipping some data at start"
  144.         );
  145.         res.rest = new Buffer(buf.length - mindex);
  146.         buf.copy(res.rest, 0, mindex);
  147.       }
  148.       return res;
  149.     }
  151.     // Payload length.
  152.     var payloadLength = buf.readUInt32BE(16, true);
  153.     var msgLength = 24 + payloadLength;
  154.     // See: <https://github.com/Bitmessage/PyBitmessage/issues/767>.
  155.     if (payloadLength > 1600003) {
  156.       res.error = new Error("Message is too large, skipping it");
  157.       if (buf.length > msgLength) {
  158.         res.rest = new Buffer(buf.length - msgLength);
  159.         buf.copy(res.rest, 0, msgLength);
  160.       } else {
  161.         res.rest = new Buffer(0);
  162.       }
  163.       return res;
  164.     }
  165.     if (buf.length < msgLength) {
  166.       // Message is not yet fully received, just skip to next process
  167.       // cycle.
  168.       return;
  169.     }
  171.     // Now we can set `rest` value.
  172.     res.rest = new Buffer(buf.length - msgLength);
  173.     buf.copy(res.rest, 0, msgLength);
  175.     // Command.
  176.     var command = buf.slice(4, 16);
  177.     var firstNonNull = 0;
  178.     var i;
  179.     for (i = 11; i >=0; i--) {
  180.       if (command[i] > 127) {
  181.         res.error = new Error(
  182.           "Non-ASCII characters in command, skipping message"
  183.         );
  184.         return res;
  185.       }
  186.       if (!firstNonNull && command[i] !== 0) {
  187.         firstNonNull = i + 1;
  188.       }
  189.     }
  190.     command = command.slice(0, firstNonNull).toString("ascii");
  192.     // Payload.
  193.     var payload = new Buffer(payloadLength);
  194.     buf.copy(payload, 0, 24, msgLength);
  195.     var checksum = buf.slice(20, 24);
  196.     if (!bufferEqual(checksum, getmsgchecksum(payload))) {
  197.       res.error = new Error("Bad checksum, skipping message");
  198.       return res;
  199.     }
  201.     res.message = {command: command, payload: payload, length: msgLength};
  202.     return res;
  203.   },
  205.   /**
  206.    * @typedef {Object} DecodeResult
  207.    * @property {string} command - Message command
  208.    * @property {Buffer} payload - Message payload
  209.    * @property {number} length - Full message length
  210.    * @property {Buffer} rest - The rest of the input buffer
  211.    * @memberof module:bitmessage/structs.message
  212.    */
  214.   /**
  215.    * Decode message.  
  216.    * NOTE: `payload` is copied, `rest` references input buffer.
  217.    * @param {Buffer} buf - Buffer that starts with encoded message
  218.    * @return {DecodeResult}
  219.    * [Decoded message structure.]{@link module:bitmessage/structs.message.DecodeResult}
  220.    */
  221.   decode: function(buf) {
  222.     assert(buf.length >= 24, "Buffer is too small");
  223.     assert(buf.readUInt32BE(0, true) === message.MAGIC, "Wrong magic");
  224.     var command = buf.slice(4, 16);
  225.     var firstNonNull = 0;
  226.     for (var i = 11; i >=0; i--) {
  227.       assert(command[i] <= 127, "Non-ASCII characters in command");
  228.       if (!firstNonNull && command[i] !== 0) {
  229.         firstNonNull = i + 1;
  230.       }
  231.     }
  232.     // NOTE(Kagami): Command can be empty.
  233.     // NOTE(Kagami): "ascii" encoding is not necessary here since we
  234.     // already validated the command but that should be quite faster
  235.     // than default "utf-8" encoding.
  236.     command = command.slice(0, firstNonNull).toString("ascii");
  237.     var payloadLength = buf.readUInt32BE(16, true);
  238.     assert(payloadLength <= 1600003, "Message payload is too big");
  239.     var length = 24 + payloadLength;
  240.     assert(buf.length >= length, "Truncated payload");
  241.     var checksum = buf.slice(20, 24);
  242.     // NOTE(Kagami): We do copy instead of slice to protect against
  243.     // possible source buffer modification by user.
  244.     var payload = new Buffer(payloadLength);
  245.     buf.copy(payload, 0, 24, length);
  246.     assert(bufferEqual(checksum, getmsgchecksum(payload)), "Bad checksum");
  247.     var rest = buf.slice(length);
  248.     return {command: command, payload: payload, length: length, rest: rest};
  249.   },
  251.   /**
  252.    * Encode message.
  253.    * @param {string} command - Message command
  254.    * @param {Bufer} payload - Message payload
  255.    * @return {Buffer} Encoded message structure.
  256.    */
  257.   encode: function(command, payload) {
  258.     assert(command.length <= 12, "Command is too long");
  259.     assert(isAscii(command), "Non-ASCII characters in command");
  260.     payload = payload || new Buffer(0);
  261.     assert(payload.length <= 1600003, "Message payload is too big");
  262.     var buf = new Buffer(24 + payload.length);
  263.     buf.fill(0);
  264.     buf.writeUInt32BE(message.MAGIC, 0, true);
  265.     buf.write(command, 4);
  266.     buf.writeUInt32BE(payload.length, 16, true);
  267.     getmsgchecksum(payload).copy(buf, 20);
  268.     payload.copy(buf, 24);
  269.     return buf;
  270.   },
  271. };
  273. /**
  274.  * An `object` is a message which is shared throughout a stream. It is
  275.  * the only message which propagates; all others are only between two
  276.  * nodes.
  277.  * @see {@link https://bitmessage.org/wiki/Protocol_specification#object}
  278.  * @namespace
  279.  * @static
  280.  */
  281. var object = exports.object = {
  282.   /**
  283.    * [getpubkey]{@link module:bitmessage/objects.getpubkey} object type.
  284.    * @constant {number}
  285.    */
  286.   GETPUBKEY: 0,
  287.   /**
  288.    * [pubkey]{@link module:bitmessage/objects.pubkey} object type.
  289.    * @constant {number}
  290.    */
  291.   PUBKEY: 1,
  292.   /**
  293.    * [msg]{@link module:bitmessage/objects.msg} object type.
  294.    * @constant {number}
  295.    */
  296.   MSG: 2,
  297.   /**
  298.    * [broadcast]{@link module:bitmessage/objects.broadcast} object type.
  299.    * @constant {number}
  300.    */
  301.   BROADCAST: 3,
  303.   /**
  304.    * @typedef {Object} DecodeResult
  305.    * @property {Buffer} nonce - A 8-byte object nonce
  306.    * @property {number} ttl - Time to live in seconds
  307.    * @property {Date} expires - Object expiration date
  308.    * @property {number} type - Object type
  309.    * @property {number} version - Object version
  310.    * @property {number} stream - Object stream
  311.    * @property {number} headerLength - Length of the object header
  312.    * @property {Buffer} objectPayload - Object payload
  313.    * @memberof module:bitmessage/structs.object
  314.    */
  316.   /**
  317.    * Decode `object` message.  
  318.    * NOTE: `nonce` and `objectPayload` are copied.
  319.    * @param {Buffer} buf - Message
  320.    * @param {Object=} opts - Decoding options
  321.    * @param {boolean} opts.allowExpired - Allow expired objects
  322.    * @param {boolean} opts.skipPow - Do not validate object POW
  323.    * @return {DecodeResult} [Decoded `object` structure.]{@link
  324.    * module:bitmessage/structs.object.DecodeResult}
  325.    * @throws {Error} Invalid object
  326.    */
  327.   decode: function(buf, opts) {
  328.     var decoded = message.decode(buf);
  329.     assert(decoded.command === "object", "Given message is not an object");
  330.     return object.decodePayload(decoded.payload, opts);
  331.   },
  333.   /**
  334.    * Decode `object` message payload.
  335.    * The same as [decode]{@link module:bitmessage/structs.object.decode}.
  336.    */
  337.   decodePayload: function(buf, opts) {
  338.     opts = opts || {};
  340.     // 8 + 8 + 4 + (1+) + (1+)
  341.     assert(buf.length >= 22, "object message payload is too small");
  342.     assert(buf.length <= 262144, "object message payload is too big");
  343.     var nonce;
  344.     if (!opts._validate) {
  345.       nonce = new Buffer(8);
  346.       buf.copy(nonce, 0, 0, 8);
  347.     }
  349.     // TTL.
  350.     var expiresTime = util.readTimestamp64BE(buf.slice(8, 16));
  351.     var expires = new Date(expiresTime * 1000);
  352.     var ttl = expiresTime - util.tnow();
  353.     assert(ttl <= 2430000, "expiresTime is too far in the future");
  354.     if (!opts.allowExpired) {
  355.       assert(ttl >= -3600, "Object expired more than a hour ago");
  356.     }
  358.     // POW.
  359.     if (!opts.skipPow) {
  360.       // User may specify trials/payload extra options and we will
  361.       // account in here.
  362.       var targetOpts = objectAssign({}, opts, {ttl: ttl, payload: buf});
  363.       var target = POW.getTarget(targetOpts);
  364.       assert(POW.check({target: target, payload: buf}), "Insufficient POW");
  365.     }
  367.     var type = buf.readUInt32BE(16, true);
  368.     var decodedVersion = var_int.decode(buf.slice(20));
  369.     var decodedStream = var_int.decode(decodedVersion.rest);
  370.     var headerLength = 20 + decodedVersion.length + decodedStream.length;
  372.     if (opts._validate) { return {stream: decodedStream.value}; }
  374.     var objectPayload = new Buffer(decodedStream.rest.length);
  375.     decodedStream.rest.copy(objectPayload);
  377.     return {
  378.       nonce: nonce,
  379.       ttl: ttl,
  380.       expires: expires,
  381.       type: type,
  382.       version: decodedVersion.value,
  383.       stream: decodedStream.value,
  384.       headerLength: headerLength,
  385.       objectPayload: objectPayload,
  386.     };
  387.   },
  389.   /**
  390.    * Check whether given `object` message is valid.
  391.    * @param {Buffer} buf - Message
  392.    * @param {Object=} opts - Any of [object.decode]{@link
  393.    * module:bitmessage/structs.object.decode} options and:
  394.    * @param {number} opts.stream - Expected object's stream
  395.    * @return {?Error} Return an error with description if object is
  396.    * invalid.
  397.    */
  398.   validate: function(buf, opts) {
  399.     var decoded;
  400.     try {
  401.       decoded = message.decode(buf);
  402.     } catch(e) {
  403.       return e;
  404.     }
  405.     if (decoded.command !== "object") {
  406.       return new Error("Given message is not an object");
  407.     }
  408.     return object.validatePayload(decoded.payload, opts);
  409.   },
  411.   /**
  412.    * Check whether `object` message payload is valid.
  413.    * The same as [validate]{@link
  414.    * module:bitmessage/structs.object.validate}.
  415.    */
  416.   validatePayload: function(buf, opts) {
  417.     opts = objectAssign({}, opts, {_validate: true});
  418.     var decoded;
  419.     try {
  420.       decoded = object.decodePayload(buf, opts);
  421.     } catch(e) {
  422.       return e;
  423.     }
  424.     if (opts.stream && decoded.stream !== opts.stream) {
  425.       return new Error(
  426.         "The stream number " + opts.stream +
  427.         " is not the one we are interested in"
  428.       );
  429.     }
  430.   },
  432.   /**
  433.    * Encode `object` message.
  434.    * @param {Object} opts - Object options
  435.    * @param {Object} opts.nonce - A 8-byte object nonce
  436.    * @param {number} opts.ttl - Time to live in seconds
  437.    * @param {number} opts.type - Object type
  438.    * @param {number} opts.version - Object version
  439.    * @param {number=} opts.stream - Object stream (1 by default)
  440.    * @param {Buffer} opts.objectPayload - Object payload
  441.    * @return {Buffer} Encoded message.
  442.    */
  443.   encode: function(opts) {
  444.     var payload = object.encodePayload(opts);
  445.     return message.encode("object", payload);
  446.   },
  448.   /**
  449.    * Encode `object` message payload.
  450.    * The same as [encode]{@link module:bitmessage/structs.object.encode}.
  451.    */
  452.   encodePayload: function(opts) {
  453.     // NOTE(Kagami): We do not try to calculate nonce here if it is not
  454.     // provided because:
  455.     // 1) It's async operation but in `structs` module all operations
  456.     // are synchronous.
  457.     // 2) It shouldn't be useful because almost all objects signatures
  458.     // include object header and POW is computed for entire object so at
  459.     // first the object header should be assembled and only then we can
  460.     // do a POW.
  461.     assert(opts.nonce.length === 8, "Bad nonce");
  462.     // NOTE(Kagami): This may be a bit inefficient since we allocate
  463.     // twice.
  464.     return Buffer.concat([
  465.       opts.nonce,
  466.       object.encodePayloadWithoutNonce(opts),
  467.     ]);
  468.   },
  470.   /**
  471.    * Encode `object` message payload without leading nonce field (may be
  472.    * useful if you are going to calculate it later).
  473.    * @param {Object} opts - Object options
  474.    * @param {number} opts.ttl - Time to live in seconds
  475.    * @param {number} opts.type - Object type
  476.    * @param {number} opts.version - Object version
  477.    * @param {number=} opts.stream - Object stream (1 by default)
  478.    * @param {Buffer} opts.objectPayload - Object payload
  479.    * @return {Buffer} Encoded payload.
  480.    */
  481.   encodePayloadWithoutNonce: function(opts) {
  482.     assert(opts.ttl > 0, "Bad TTL");
  483.     assert(opts.ttl <= 2430000, "TTL may not be larger than 28 days + 3 hours");
  484.     var expiresTime = util.tnow() + opts.ttl;
  485.     var type = new Buffer(4);
  486.     type.writeUInt32BE(opts.type, 0);
  487.     var stream = opts.stream || 1;
  488.     var obj = Buffer.concat([
  489.       util.writeUInt64BE(null, expiresTime),
  490.       type,
  491.       var_int.encode(opts.version),
  492.       var_int.encode(stream),
  493.       opts.objectPayload,
  494.     ]);
  495.     assert(obj.length <= 262136, "object message payload is too big");
  496.     return obj;
  497.   },
  498. };
  500. /**
  501.  * Variable length integer.
  502.  * @see {@link https://bitmessage.org/wiki/Protocol_specification#Variable_length_integer}
  503.  * @namespace
  504.  * @static
  505.  */
  506. var var_int = exports.var_int = {
  507.   /**
  508.    * @typedef {Object} DecodeResult
  509.    * @property {number} value - Stored value
  510.    * @property {number} length - `var_int` full length
  511.    * @property {Buffer} rest - The rest of the input buffer
  512.    * @memberof module:bitmessage/structs.var_int
  513.    */
  515.   /**
  516.    * Decode `var_int`.  
  517.    * NOTE: `rest` references input buffer.
  518.    * @param {Buffer} buf - A buffer that starts with encoded `var_int`
  519.    * @return {DecodeResult}
  520.    * [Decoded `var_int` structure.]{@link module:bitmessage/structs.var_int.DecodeResult}
  521.    */
  522.   decode: function(buf) {
  523.     var value, length;
  524.     assert(buf.length > 0, "Empty buffer");
  525.     switch (buf[0]) {
  526.       case 253:
  527.         value = buf.readUInt16BE(1);
  528.         assert(value >= 253, "Impractical var_int");
  529.         length = 3;
  530.         break;
  531.       case 254:
  532.         value = buf.readUInt32BE(1);
  533.         assert(value >= 65536, "Impractical var_int");
  534.         length = 5;
  535.         break;
  536.       case 255:
  537.         var hi = buf.readUInt32BE(1);
  538.         assert(hi !== 0, "Impractical var_int");
  539.         // Max safe number = 2^53 - 1 =
  540.         // 0b0000000000011111111111111111111111111111111111111111111111111111
  541.         // = 2097151*(2^32) + (2^32 - 1).
  542.         // So it's safe until hi <= 2097151. See
  543.         // <http://mdn.io/issafeinteger>,
  544.         // <https://stackoverflow.com/q/307179> for details.
  545.         // TODO(Kagami): We may want to return raw Buffer for
  546.         // 2^53 <= value <= 2^64 - 1 range. Probably using the optional
  547.         // argument because most of the code expect to get a number when
  548.         // calling `var_int.decode`.
  549.         assert(hi <= 2097151, "Unsafe integer");
  550.         var lo = buf.readUInt32BE(5);
  551.         value = hi * 4294967296 + lo;
  552.         length = 9;
  553.         break;
  554.       default:
  555.         value = buf[0];
  556.         length = 1;
  557.     }
  558.     var rest = buf.slice(length);
  559.     return {value: value, length: length, rest: rest};
  560.   },
  562.   /**
  563.    * Encode number into `var_int`.
  564.    * @param {(number|Buffer)} value - Input number
  565.    * @return {Buffer} Encoded `var_int`.
  566.    */
  567.   encode: function(value) {
  568.     var buf, targetStart;
  569.     if (typeof value === "number") {
  570.       assert(value >= 0, "Value cannot be less than zero");
  571.       if (value < 253) {
  572.         buf = new Buffer([value]);
  573.       } else if (value < 65536) {
  574.         buf = new Buffer(3);
  575.         buf[0] = 253;
  576.         buf.writeUInt16BE(value, 1, true);
  577.       } else if (value < 4294967296) {
  578.         buf = new Buffer(5);
  579.         buf[0] = 254;
  580.         buf.writeUInt32BE(value, 1, true);
  581.       } else {
  582.         assert(value <= 9007199254740991, "Unsafe integer");
  583.         buf = new Buffer(9);
  584.         buf[0] = 255;
  585.         buf.writeUInt32BE(Math.floor(value / 4294967296), 1, true);  // high32
  586.         buf.writeUInt32BE(value % 4294967296, 5, true);  // low32
  587.       }
  588.     } else if (Buffer.isBuffer(value)) {
  589.       assert(value.length <= 8, "Buffer is too big");
  590.       buf = new Buffer(9);
  591.       buf.fill(0);
  592.       buf[0] = 255;
  593.       targetStart = 1 + (8 - value.length);
  594.       value.copy(buf, targetStart);
  595.     } else {
  596.       throw new Error("Unknown value type");
  597.     }
  598.     return buf;
  599.   },
  600. };
  602. /**
  603.  * Variable length string.
  604.  * @see {@link https://bitmessage.org/wiki/Protocol_specification#Variable_length_string}
  605.  * @namespace
  606.  */
  607. exports.var_str = {
  608.   /**
  609.    * @typedef {Object} DecodeResult
  610.    * @property {number} str - The string itself
  611.    * @property {number} length - `var_str` full length
  612.    * @property {Buffer} rest - The rest of the input buffer
  613.    * @memberof module:bitmessage/structs.var_str
  614.    */
  616.   /**
  617.    * Decode `var_str`.  
  618.    * NOTE: `rest` references input buffer.
  619.    * @param {Buffer} buf - A buffer that starts with encoded `var_str`
  620.    * @return {DecodeResult}
  621.    * [Decoded `var_str` structure.]{@link module:bitmessage/structs.var_str.DecodeResult}
  622.    */
  623.   decode: function(buf) {
  624.     var decoded = var_int.decode(buf);
  625.     var strLength = decoded.value;
  626.     var length = decoded.length + strLength;
  627.     assert(buf.length >= length, "Buffer is too small");
  628.     // XXX(Kagami): Spec doesn't mention encoding, using UTF-8.
  629.     var str = decoded.rest.slice(0, strLength).toString("utf8");
  630.     var rest = decoded.rest.slice(strLength);
  631.     return {str: str, length: length, rest: rest};
  632.   },
  634.   /**
  635.    * Encode string into `var_str`.
  636.    * @param {string} str - A string
  637.    * @return {Buffer} Encoded `var_str`.
  638.    */
  639.   encode: function(str) {
  640.     // XXX(Kagami): Spec doesn't mention encoding, using UTF-8.
  641.     var strBuf = new Buffer(str, "utf8");
  642.     return Buffer.concat([var_int.encode(strBuf.length), strBuf]);
  643.   },
  644. };
  646. /**
  647.  * Variable length list of integers.
  648.  * @see {@link https://bitmessage.org/wiki/Protocol_specification#Variable_length_list_of_integers}
  649.  * @namespace
  650.  */
  651. exports.var_int_list = {
  652.   /**
  653.    * @typedef {Object} DecodeResult
  654.    * @property {number} list - Stored numbers
  655.    * @property {number} length - `var_int_list` full length
  656.    * @property {Buffer} rest - The rest of the input buffer
  657.    * @memberof module:bitmessage/structs.var_int_list
  658.    */
  660.   /**
  661.    * Decode `var_int_list`.  
  662.    * NOTE: `rest` references input buffer.
  663.    * @param {Buffer} buf - A buffer that starts with encoded
  664.    * `var_int_list`
  665.    * @return {DecodeResult}
  666.    * [Decoded `var_int_list` structure.]{@link module:bitmessage/structs.var_int_list.DecodeResult}
  667.    */
  668.   decode: function(buf) {
  669.     var decoded = var_int.decode(buf);
  670.     var listLength = decoded.value;
  671.     var list = new Array(listLength);
  672.     var rest = decoded.rest;
  673.     var sumLength = decoded.length;
  674.     for (var i = 0; i < listLength; i++) {
  675.       decoded = var_int.decode(rest);
  676.       list[i] = decoded.value;
  677.       rest = decoded.rest;
  678.       sumLength += decoded.length;
  679.     }
  680.     return {list: list, length: sumLength, rest: rest};
  681.   },
  683.   /**
  684.    * Encode list of numbers into `var_int_list`.
  685.    * @param {number[]} list - A number list
  686.    * @return {Buffer} Encoded `var_int_list`.
  687.    */
  688.   encode: function(list) {
  689.     var var_ints = list.map(var_int.encode);
  690.     var bufs = [var_int.encode(list.length)].concat(var_ints);
  691.     return Buffer.concat(bufs);
  692.   },
  693. };
  695. // Very simple inet_ntop(3) equivalent.
  696. function inet_ntop(buf) {
  697.   assert(buf.length === 16, "Bad buffer size");
  698.   // IPv4 mapped to IPv6.
  699.   if (bufferEqual(buf.slice(0, 12), IPv4_MAPPING)) {
  700.     return Array.prototype.join.call(buf.slice(12), ".");
  701.   // IPv6.
  702.   } else {
  703.     // TODO(Kagami): Join empty groups to make address looks nicer.
  704.     var groups = [];
  705.     for (var i = 0; i < 8; i++) {
  706.       groups.push(buf.readUInt16BE(i * 2, true).toString(16));
  707.     }
  708.     return groups.join(":");
  709.   }
  710. }
  712. /**
  713.  * Network address.
  714.  * @see {@link https://bitmessage.org/wiki/Protocol_specification#Network_address}
  715.  * @namespace
  716.  */
  717. exports.net_addr = {
  718.   /**
  719.    * @typedef {Object} DecodeResult
  720.    * @property {Date} time - Time the node was last active, not included
  721.    * in short mode
  722.    * @property {number} stream - Stream number of the node, not included
  723.    * in short mode
  724.    * @property {Object} services -
  725.    * [Services]{@link module:bitmessage/structs.ServicesBitfield}
  726.    * provided by the node
  727.    * @property {string} host - IPv4/IPv6 address of the node
  728.    * @property {number} port - Incoming port of the node
  729.    * @memberof module:bitmessage/structs.net_addr
  730.    */
  732.   /**
  733.    * Decode `net_addr`.
  734.    * @param {Buffer} buf - A buffer that contains encoded `net_addr`
  735.    * @param {Object=} opts - Decoding options; use `short` option to
  736.    * decode `net_addr` from
  737.    * [version message]{@link module:bitmessage/messages.version}
  738.    * @return {DecodeResult}
  739.    * [Decoded `net_addr` structure.]{@link module:bitmessage/structs.net_addr.DecodeResult}
  740.    */
  741.   decode: function(buf, opts) {
  742.     var short = !!(opts || {}).short;
  743.     var res = {};
  744.     if (short) {
  745.       assert(buf.length === 26, "Bad buffer size");
  746.     } else {
  747.       assert(buf.length === 38, "Bad buffer size");
  748.       var timeHi = buf.readUInt32BE(0, true);
  749.       var timeLo = buf.readUInt32BE(4, true);
  750.       // JavaScript's Date object can't work with timestamps higher than
  751.       // 8640000000000 (~2^43, ~275760 year). Hope JavaScript will
  752.       // support 64-bit numbers up to this date.
  753.       assert(timeHi <= 2011, "Time is too high");
  754.       assert(timeHi !== 2011 || timeLo <= 2820767744, "Time is too high");
  755.       res.time = new Date((timeHi * 4294967296 + timeLo) * 1000);
  756.       res.stream = buf.readUInt32BE(8, true);
  757.       buf = buf.slice(12);
  758.     }
  759.     res.services = ServicesBitfield(buf.slice(0, 8), {copy: true});
  760.     res.host = inet_ntop(buf.slice(8, 24));
  761.     res.port = buf.readUInt16BE(24, true);
  762.     return res;
  763.   },
  765.   /**
  766.    * Encode `net_addr`.
  767.    * @param {Object} opts - Encoding options
  768.    * @param {boolean=} opts.short - Encode `net_addr` for
  769.    * [version message]{@link module:bitmessage/messages.version}
  770.    * (false by default)
  771.    * @param {Date=} opts.time - Time the node was last active, not
  772.    * included in short mode (current time by default)
  773.    * @param {number=} opts.stream - Stream number of the node, not
  774.    * included in short mode (1 by default)
  775.    * @param {(Object|Buffer)=} opts.services -
  776.    * [Services]{@link module:bitmessage/structs.ServicesBitfield}
  777.    * provided by the node (`NODE_NETWORK` by default)
  778.    * @param {string} opts.host - IPv4/IPv6 address of the node
  779.    * @param {number} opts.port - Incoming port of the node
  780.    * @return {Buffer} Encoded `net_addr`.
  781.    */
  782.   encode: function(opts) {
  783.     // Be aware of `Buffer.slice` quirk in browserify:
  784.     // <http://git.io/lNZF1A> (does not modify parent buffer's memory in
  785.     // old browsers). So we use offset instead of `buf = buf.slice`.
  786.     var buf, shift;
  787.     if (opts.short) {
  788.       buf = new Buffer(26);
  789.       shift = 0;
  790.     } else {
  791.       buf = new Buffer(38);
  792.       var time = opts.time || new Date();
  793.       time = Math.floor(time.getTime() / 1000);
  794.       buf.writeUInt32BE(Math.floor(time / 4294967296), 0, true);  // high32
  795.       buf.writeUInt32BE(time % 4294967296, 4, true);  // low32
  796.       var stream = opts.stream || 1;
  797.       buf.writeUInt32BE(stream, 8);
  798.       shift = 12;
  799.     }
  800.     var services = opts.services ||
  801.                    ServicesBitfield().set(ServicesBitfield.NODE_NETWORK);
  802.     if (Buffer.isBuffer(services)) {
  803.       assert(services.length === 8, "Bad services buffer length");
  804.     } else {
  805.       services = services.buffer;
  806.     }
  807.     services.copy(buf, shift);
  808.     inet_pton(opts.host).copy(buf, shift + 8);
  809.     buf.writeUInt16BE(opts.port, shift + 24);
  810.     return buf;
  811.   },
  812. };
  814. /**
  815.  * Inventory vector.
  816.  * @see {@link https://bitmessage.org/wiki/Protocol_specification#Inventory_Vectors}
  817.  * @namespace
  818.  */
  819. exports.inv_vect = {
  820.   // NOTE(Kagami): Only encode operation is defined because decoding of
  821.   // the encoded vector is impossible.
  823.   /**
  824.    * Encode inventory vector.
  825.    * @param {Buffer} buf - Payload to calculate the inventory vector for
  826.    * @return {Buffer} A 32-byte encoded `inv_vect`.
  827.    */
  828.   encode: function(buf) {
  829.     return bmcrypto.sha512(bmcrypto.sha512(buf)).slice(0, 32);
  830.   },
  831. };
  833. /**
  834.  * Encrypted payload.
  835.  * @see {@link https://bitmessage.org/wiki/Protocol_specification#Encrypted_payload}
  836.  * @namespace encrypted
  837.  * @static
  838.  */
  839. /**
  840.  * @typedef {Object} DecodeResult
  841.  * @property {Buffer} iv - Initialization vector (16 bytes)
  842.  * @property {Buffer} ephemPrivateKey - Ephemeral private key (32 bytes)
  843.  * @property {Buffer} ciphertext - The result of encryption (variable
  844.  * size)
  845.  * @property {Buffer} mac - Message authentication code (32 bytes)
  846.  * @memberof module:bitmessage/structs.encrypted
  847.  */
  848. /**
  849.  * Decode encrypted payload.  
  850.  * NOTE: all structure members are copied.
  851.  * @param {Buffer} buf - A buffer that contains encrypted payload
  852.  * @return {DecodeResult}
  853.  * [Decoded `encrypted` structure.]{@link module:bitmessage/structs.encrypted.DecodeResult}
  854.  * @function decode
  855.  * @memberof module:bitmessage/structs.encrypted
  856.  */
  857. /**
  858.  * Encode `encrypted`.
  859.  * @param {Object} opts - Encoding options
  860.  * @param {Buffer} opts.iv - Initialization vector (16 bytes)
  861.  * @param {Buffer} opts.ephemPrivateKey - Ephemeral private key (32
  862.  * bytes)
  863.  * @param {Buffer} opts.ciphertext - The result of encryption (variable
  864.  * size)
  865.  * @param {Buffer} opts.mac - Message authentication code (32 bytes)
  866.  * @return {Buffer} Encoded `encrypted` payload.
  867.  * @function encode
  868.  * @memberof module:bitmessage/structs.encrypted
  869.  */
  870. // Reexport struct.
  871. exports.encrypted = bmcrypto.encrypted;
  873. // Creates bitfield (MSB 0) class of the specified size.
  874. var Bitfield = function(size) {
  875.   var bytesize = size / 8;
  877.   // Inspired by <https://github.com/fb55/bitfield>.
  878.   function BitfieldInner(buf, opts) {
  879.     if (!(this instanceof BitfieldInner)) {
  880.       return new BitfieldInner(buf);
  881.     }
  882.     opts = opts || {};
  883.     if (buf) {
  884.       assert(buf.length === bytesize, "Bad buffer size");
  885.       if (opts.copy) {
  886.         var dup = new Buffer(bytesize);
  887.         dup.fill(0);
  888.         buf.copy(dup);
  889.         buf = dup;
  890.       }
  891.     } else {
  892.       buf = new Buffer(bytesize);
  893.       buf.fill(0);
  894.     }
  895.     this.buffer = buf;
  896.   }
  898.   BitfieldInner.prototype.get = function(bits) {
  899.     if (!Array.isArray(bits)) {
  900.       bits = [bits];
  901.     }
  902.     var buf = this.buffer;
  903.     return bits.every(function(bit) {
  904.       assert(bit >= 0, "Bit number is too low");
  905.       assert(bit < size, "Bit number is too high");
  906.       var index = Math.floor(bit / 8);
  907.       var shift = 7 - (bit % 8);
  908.       return (buf[index] & (1 << shift)) !== 0;  // jshint ignore:line
  909.     });
  910.   };
  912.   BitfieldInner.prototype.set = function(bits) {
  913.     if (!Array.isArray(bits)) {
  914.       bits = [bits];
  915.     }
  916.     var buf = this.buffer;
  917.     bits.forEach(function(bit) {
  918.       assert(bit >= 0, "Bit number is too low");
  919.       assert(bit < size, "Bit number is too high");
  920.       var index = Math.floor(bit / 8);
  921.       var shift = 7 - (bit % 8);
  922.       buf[index] |= 1 << shift;  // jshint ignore:line
  923.     });
  924.     return this;
  925.   };
  927.   BitfieldInner.prototype.toString = function() {
  928.     var i;
  929.     var str = "";
  930.     for (i = 0; i < this.buffer.length; i++) {
  931.       // Should be faster than pushing to array and joining on v8.
  932.       str += ("0000000" + this.buffer[i].toString(2)).slice(-8);
  933.     }
  934.     return "<Bitfield:" + str + ">";
  935.   };
  937.   return BitfieldInner;
  938. };
  940. /**
  941.  * Service features bitfield (MSB 0).
  942.  * @see {@link https://bitmessage.org/wiki/Protocol_specification#version}
  943.  * @param {Buffer=} buf - A 8-byte bitfield buffer (will be created if
  944.  * not provided or will be copied if `opts.copy` is `true`)
  945.  * @param {Object=} opts - Options
  946.  * @constructor
  947.  * @static
  948.  * @example
  949.  * var ServicesBitfield = require("bitmessage").structs.ServicesBitfield;
  950.  * var services = ServicesBitfield().set(ServicesBitfield.NODE_NETWORK);
  951.  * console.log(services.get(ServicesBitfield.NODE_NETWORK));  // true
  952.  * console.log(services.get(15));  // false
  953.  */
  954. // NOTE(Kagami): Since pubkey bitfield uses MSB 0, we use it here too.
  955. // See <https://github.com/Bitmessage/PyBitmessage/issues/769> for
  956. // details.
  957. var ServicesBitfield = exports.ServicesBitfield = objectAssign(Bitfield(64), {
  958.   /**
  959.    * Returns a boolean indicating whether the bit is set.
  960.    * @param {number} index - Bit index (MSB 0)
  961.    * @function get
  962.    * @instance
  963.    * @return {boolean}
  964.    * @memberof module:bitmessage/structs.ServicesBitfield
  965.    */
  966.   /**
  967.    * Set the given bit(s) to `1`.
  968.    * @param {(number|number[])} index - Bit(s) index (MSB 0)
  969.    * @function set
  970.    * @instance
  971.    * @return {Object} Returns self so methods can be chained.
  972.    * @memberof module:bitmessage/structs.ServicesBitfield
  973.    */
  974.   /**
  975.    * The contents of the bitfield.
  976.    * @type {Buffer}
  977.    * @var buffer
  978.    * @instance
  979.    * @memberof module:bitmessage/structs.ServicesBitfield
  980.    */
  982.   /**
  983.    * Bit index indicating normal network node.
  984.    * @memberof module:bitmessage/structs.ServicesBitfield
  985.    * @constant {number}
  986.    */
  987.   NODE_NETWORK: 63,
  988.   /**
  989.    * Bit index indicating web/mobile client with limited network
  990.    * capabilities (proposal feature).
  991.    * @memberof module:bitmessage/structs.ServicesBitfield
  992.    * @see {@link https://bitmessage.org/wiki/Mobile_Protocol_specification}
  993.    * @constant {number}
  994.    */
  995.   NODE_MOBILE: 62,
  996.   /**
  997.    * Bit index indicating node which can work as a WebSocket gateway for
  998.    * web/mobile clients (proposal feature).
  999.    * @memberof module:bitmessage/structs.ServicesBitfield
  1000.    * @see {@link https://bitmessage.org/wiki/Mobile_Protocol_specification}
  1001.    * @constant {number}
  1002.    */
  1003.   NODE_GATEWAY: 61,
  1004. });
  1006. /**
  1007.  * Pubkey features bitfield (MSB 0).
  1008.  * @see {@link https://bitmessage.org/wiki/Protocol_specification#Pubkey_bitfield_features}
  1009.  * @param {Buffer=} buf - A 4-byte bitfield buffer (will be created if
  1010.  * not provided or will be copied if `opts.copy` is `true`)
  1011.  * @param {Object=} opts - Options
  1012.  * @constructor
  1013.  * @example
  1014.  * var PubkeyBitfield = require("bitmessage").structs.PubkeyBitfield;
  1015.  * var behavior = PubkeyBitfield().set([
  1016.  *   PubkeyBitfield.INCLUDE_DESTINATION,
  1017.  *   PubkeyBitfield.DOES_ACK,
  1018.  * ]).set(1);
  1019.  * console.log(behavior.get(PubkeyBitfield.DOES_ACK));  // true
  1020.  * console.log(behavior.get(15));  // false
  1021.  */
  1022. exports.PubkeyBitfield = objectAssign(Bitfield(32), {
  1023.   /**
  1024.    * Returns a boolean indicating whether the bit is set.
  1025.    * @param {number} index - Bit index (MSB 0)
  1026.    * @function get
  1027.    * @instance
  1028.    * @return {boolean}
  1029.    * @memberof module:bitmessage/structs.PubkeyBitfield
  1030.    */
  1031.   /**
  1032.    * Set the given bit(s) to `1`.
  1033.    * @param {(number|number[])} index - Bit(s) index (MSB 0)
  1034.    * @function set
  1035.    * @instance
  1036.    * @return {Object} Returns self so methods can be chained.
  1037.    * @memberof module:bitmessage/structs.PubkeyBitfield
  1038.    */
  1039.   /**
  1040.    * The contents of the bitfield.
  1041.    * @type {Buffer}
  1042.    * @var buffer
  1043.    * @instance
  1044.    * @memberof module:bitmessage/structs.PubkeyBitfield
  1045.    */
  1047.   /**
  1048.    * Bit index.
  1049.    * If set, the receiving node does send acknowledgements (rather than
  1050.    * dropping them).
  1051.    * @memberof module:bitmessage/structs.PubkeyBitfield
  1052.    * @constant {number}
  1053.    */
  1054.   DOES_ACK: 31,
  1055.   /**
  1056.    * Bit index.
  1057.    * If set, the receiving node expects that the RIPEMD hash encoded in
  1058.    * their address preceedes the encrypted message data of msg messages
  1059.    * bound for them.
  1060.    * @memberof module:bitmessage/structs.PubkeyBitfield
  1061.    * @constant {number}
  1062.    */
  1063.   INCLUDE_DESTINATION: 30,
  1064. });