1037 lines
32 KiB
JavaScript
1037 lines
32 KiB
JavaScript
/**
|
|
* Implements common structures.
|
|
* @see {@link https://bitmessage.org/wiki/Protocol_specification#Common_structures}
|
|
* @module bitmessage/structs
|
|
*/
|
|
|
|
"use strict";
|
|
|
|
var objectAssign = Object.assign || require("object-assign");
|
|
var bufferEqual = require("buffer-equal");
|
|
var assert = require("./_util").assert;
|
|
var bmcrypto = require("./crypto");
|
|
var POW = require("./pow");
|
|
var util = require("./_util");
|
|
|
|
function isAscii(str) {
|
|
for (var i = 0; i < str.length; i++) {
|
|
if (str.charCodeAt(i) > 127) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Compute the message checksum for the given data.
|
|
function getmsgchecksum(data) {
|
|
return bmcrypto.sha512(data).slice(0, 4);
|
|
}
|
|
|
|
// \ :3 /
|
|
function findMagic(buf) {
|
|
var i;
|
|
var len = buf.length;
|
|
var firstb = false;
|
|
var secondb = false;
|
|
var thirdb = false;
|
|
for (i = 0; i < len; ++i) {
|
|
switch (buf[i]) {
|
|
case 0xE9:
|
|
firstb = true;
|
|
break;
|
|
case 0xBE:
|
|
if (firstb) { secondb = true; }
|
|
break;
|
|
case 0xB4:
|
|
if (firstb && secondb) { thirdb = true; }
|
|
break;
|
|
case 0xD9:
|
|
if (firstb && secondb && thirdb) { return i - 3; }
|
|
break;
|
|
default:
|
|
firstb = false;
|
|
secondb = false;
|
|
thirdb = false;
|
|
}
|
|
}
|
|
// If we reached the end of the buffer but part of the magic matches
|
|
// we'll still return index of the magic's start position.
|
|
if (firstb) {
|
|
if (secondb) {
|
|
--i;
|
|
}
|
|
if (thirdb) {
|
|
--i;
|
|
}
|
|
return i - 1; // Compensate for last i's increment
|
|
} else {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Message structure.
|
|
* @see {@link https://bitmessage.org/wiki/Protocol_specification#Message_structure}
|
|
* @namespace
|
|
* @static
|
|
*/
|
|
var message = exports.message = {
|
|
/**
|
|
* Bitmessage magic value.
|
|
* @constant {number}
|
|
*/
|
|
MAGIC: 0xE9BEB4D9,
|
|
|
|
/**
|
|
* @typedef {Object} TryDecodeResult
|
|
* @property {Object} message - Decoded message
|
|
* @property {string} message.command - Message command
|
|
* @property {Buffer} message.payload - Message payload
|
|
* @property {number} message.length - Full message length
|
|
* @property {Error} error - ...or decoding error
|
|
* @property {Buffer} rest - The rest of the input buffer after
|
|
* processing message
|
|
* @memberof module:bitmessage/structs.message
|
|
*/
|
|
|
|
/**
|
|
* Decode message in "stream" mode.
|
|
* NOTE: message payload and `rest` are copied (so the runtime can GC
|
|
* processed buffer data).
|
|
* @param {Buffer} buf - Data buffer
|
|
* @return {?TryDecodeResult}
|
|
* [Decoded result.]{@link module:bitmessage/structs.message.TryDecodeResult}
|
|
*/
|
|
tryDecode: function(buf) {
|
|
if (buf.length < 24) {
|
|
// Message is not yet fully received, just skip to next process
|
|
// cycle.
|
|
return;
|
|
}
|
|
var res = {};
|
|
|
|
// Magic.
|
|
var mindex = findMagic(buf);
|
|
if (mindex !== 0) {
|
|
if (mindex === -1) {
|
|
res.error = new Error("Magic not found, skipping buffer data");
|
|
res.rest = new Buffer(0);
|
|
} else {
|
|
res.error = new Error(
|
|
"Magic in the middle of buffer, skipping some data at start"
|
|
);
|
|
res.rest = new Buffer(buf.length - mindex);
|
|
buf.copy(res.rest, 0, mindex);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
// Payload length.
|
|
var payloadLength = buf.readUInt32BE(16, true);
|
|
var msgLength = 24 + payloadLength;
|
|
// See: <https://github.com/Bitmessage/PyBitmessage/issues/767>.
|
|
if (payloadLength > 1600003) {
|
|
res.error = new Error("Message is too large, skipping it");
|
|
if (buf.length > msgLength) {
|
|
res.rest = new Buffer(buf.length - msgLength);
|
|
buf.copy(res.rest, 0, msgLength);
|
|
} else {
|
|
res.rest = new Buffer(0);
|
|
}
|
|
return res;
|
|
}
|
|
if (buf.length < msgLength) {
|
|
// Message is not yet fully received, just skip to next process
|
|
// cycle.
|
|
return;
|
|
}
|
|
|
|
// Now we can set `rest` value.
|
|
res.rest = new Buffer(buf.length - msgLength);
|
|
buf.copy(res.rest, 0, msgLength);
|
|
|
|
// Command.
|
|
var command = buf.slice(4, 16);
|
|
var firstNonNull = 0;
|
|
var i;
|
|
for (i = 11; i >=0; i--) {
|
|
if (command[i] > 127) {
|
|
res.error = new Error(
|
|
"Non-ASCII characters in command, skipping message"
|
|
);
|
|
return res;
|
|
}
|
|
if (!firstNonNull && command[i] !== 0) {
|
|
firstNonNull = i + 1;
|
|
}
|
|
}
|
|
command = command.slice(0, firstNonNull).toString("ascii");
|
|
|
|
// Payload.
|
|
var payload = new Buffer(payloadLength);
|
|
buf.copy(payload, 0, 24, msgLength);
|
|
var checksum = buf.slice(20, 24);
|
|
if (!bufferEqual(checksum, getmsgchecksum(payload))) {
|
|
res.error = new Error("Bad checksum, skipping message");
|
|
return res;
|
|
}
|
|
|
|
res.message = {command: command, payload: payload, length: msgLength};
|
|
return res;
|
|
},
|
|
|
|
/**
|
|
* @typedef {Object} DecodeResult
|
|
* @property {string} command - Message command
|
|
* @property {Buffer} payload - Message payload
|
|
* @property {number} length - Full message length
|
|
* @property {Buffer} rest - The rest of the input buffer
|
|
* @memberof module:bitmessage/structs.message
|
|
*/
|
|
|
|
/**
|
|
* Decode message.
|
|
* NOTE: `payload` is copied, `rest` references input buffer.
|
|
* @param {Buffer} buf - Buffer that starts with encoded message
|
|
* @return {DecodeResult}
|
|
* [Decoded message structure.]{@link module:bitmessage/structs.message.DecodeResult}
|
|
*/
|
|
decode: function(buf) {
|
|
assert(buf.length >= 24, "Buffer is too small");
|
|
assert(buf.readUInt32BE(0, true) === message.MAGIC, "Wrong magic");
|
|
var command = buf.slice(4, 16);
|
|
var firstNonNull = 0;
|
|
for (var i = 11; i >=0; i--) {
|
|
assert(command[i] <= 127, "Non-ASCII characters in command");
|
|
if (!firstNonNull && command[i] !== 0) {
|
|
firstNonNull = i + 1;
|
|
}
|
|
}
|
|
// NOTE(Kagami): Command can be empty.
|
|
// NOTE(Kagami): "ascii" encoding is not necessary here since we
|
|
// already validated the command but that should be quite faster
|
|
// than default "utf-8" encoding.
|
|
command = command.slice(0, firstNonNull).toString("ascii");
|
|
var payloadLength = buf.readUInt32BE(16, true);
|
|
assert(payloadLength <= 1600003, "Message payload is too big");
|
|
var length = 24 + payloadLength;
|
|
assert(buf.length >= length, "Truncated payload");
|
|
var checksum = buf.slice(20, 24);
|
|
// NOTE(Kagami): We do copy instead of slice to protect against
|
|
// possible source buffer modification by user.
|
|
var payload = new Buffer(payloadLength);
|
|
buf.copy(payload, 0, 24, length);
|
|
assert(bufferEqual(checksum, getmsgchecksum(payload)), "Bad checksum");
|
|
var rest = buf.slice(length);
|
|
return {command: command, payload: payload, length: length, rest: rest};
|
|
},
|
|
|
|
/**
|
|
* Encode message.
|
|
* @param {string} command - Message command
|
|
* @param {Bufer} payload - Message payload
|
|
* @return {Buffer} Encoded message structure.
|
|
*/
|
|
encode: function(command, payload) {
|
|
assert(command.length <= 12, "Command is too long");
|
|
assert(isAscii(command), "Non-ASCII characters in command");
|
|
payload = payload || new Buffer(0);
|
|
assert(payload.length <= 1600003, "Message payload is too big");
|
|
var buf = new Buffer(24 + payload.length);
|
|
buf.fill(0);
|
|
buf.writeUInt32BE(message.MAGIC, 0, true);
|
|
buf.write(command, 4);
|
|
buf.writeUInt32BE(payload.length, 16, true);
|
|
getmsgchecksum(payload).copy(buf, 20);
|
|
payload.copy(buf, 24);
|
|
return buf;
|
|
},
|
|
};
|
|
|
|
/**
|
|
* An `object` is a message which is shared throughout a stream. It is
|
|
* the only message which propagates; all others are only between two
|
|
* nodes.
|
|
* @see {@link https://bitmessage.org/wiki/Protocol_specification#object}
|
|
* @namespace
|
|
* @static
|
|
*/
|
|
var object = exports.object = {
|
|
/**
|
|
* [getpubkey]{@link module:bitmessage/objects.getpubkey} object type.
|
|
* @constant {number}
|
|
*/
|
|
GETPUBKEY: 0,
|
|
/**
|
|
* [pubkey]{@link module:bitmessage/objects.pubkey} object type.
|
|
* @constant {number}
|
|
*/
|
|
PUBKEY: 1,
|
|
/**
|
|
* [msg]{@link module:bitmessage/objects.msg} object type.
|
|
* @constant {number}
|
|
*/
|
|
MSG: 2,
|
|
/**
|
|
* [broadcast]{@link module:bitmessage/objects.broadcast} object type.
|
|
* @constant {number}
|
|
*/
|
|
BROADCAST: 3,
|
|
|
|
/**
|
|
* @typedef {Object} DecodeResult
|
|
* @property {Buffer} nonce - A 8-byte object nonce
|
|
* @property {number} ttl - Time to live in seconds
|
|
* @property {number} type - Object type
|
|
* @property {number} version - Object version
|
|
* @property {number} stream - Object stream
|
|
* @property {number} headerLength - Length of the object header
|
|
* @property {Buffer} objectPayload - Object payload
|
|
* @memberof module:bitmessage/structs.object
|
|
*/
|
|
|
|
/**
|
|
* Decode `object` message.
|
|
* NOTE: `nonce` and `objectPayload` are copied.
|
|
* @param {Buffer} buf - Message
|
|
* @param {Object=} opts - Decoding options
|
|
* @param {boolean} opts.allowExpired - Allow expired objects
|
|
* @param {boolean} opts.skipPow - Do not validate object POW
|
|
* @return {DecodeResult}
|
|
* [Decoded `object` structure.]{@link module:bitmessage/structs.object.DecodeResult}
|
|
*/
|
|
decode: function(buf, opts) {
|
|
var decoded = message.decode(buf);
|
|
assert(decoded.command === "object", "Bad command");
|
|
return object.decodePayload(decoded.payload, opts);
|
|
},
|
|
|
|
/**
|
|
* Decode `object` message payload.
|
|
* The same as [decode]{@link module:bitmessage/structs.object.decode}.
|
|
*/
|
|
decodePayload: function(buf, opts) {
|
|
opts = opts || {};
|
|
// 8 + 8 + 4 + (1+) + (1+)
|
|
assert(buf.length >= 22, "object message payload is too small");
|
|
assert(buf.length <= 262144, "object message payload is too big");
|
|
var nonce = new Buffer(8);
|
|
buf.copy(nonce, 0, 0, 8);
|
|
|
|
// TTL.
|
|
var expiresTime = util.readTimestamp64BE(buf.slice(8, 16));
|
|
var ttl = expiresTime - util.tnow();
|
|
assert(ttl <= 2430000, "expiresTime is too far in the future");
|
|
if (!opts.allowExpired) {
|
|
assert(ttl >= -3600, "Object expired more than a hour ago");
|
|
}
|
|
|
|
// POW.
|
|
if (!opts.skipPow) {
|
|
// User may specify trials/payload extra options and we will
|
|
// account in here.
|
|
var targetOpts = objectAssign({}, opts, {ttl: ttl, payload: buf});
|
|
var target = POW.getTarget(targetOpts);
|
|
assert(POW.check({target: target, payload: buf}), "Insufficient POW");
|
|
}
|
|
|
|
var type = buf.readUInt32BE(16, true);
|
|
var decodedVersion = var_int.decode(buf.slice(20));
|
|
var decodedStream = var_int.decode(decodedVersion.rest);
|
|
var headerLength = 20 + decodedVersion.length + decodedStream.length;
|
|
var objectPayload = new Buffer(decodedStream.rest.length);
|
|
decodedStream.rest.copy(objectPayload);
|
|
|
|
return {
|
|
nonce: nonce,
|
|
ttl: ttl,
|
|
type: type,
|
|
version: decodedVersion.value,
|
|
stream: decodedStream.value,
|
|
headerLength: headerLength,
|
|
objectPayload: objectPayload,
|
|
};
|
|
},
|
|
|
|
/**
|
|
* Encode `object` message.
|
|
* @param {Object} opts - Object options
|
|
* @param {Object} opts.nonce - A 8-byte object nonce
|
|
* @param {number} opts.ttl - Time to live in seconds
|
|
* @param {number} opts.type - Object type
|
|
* @param {number} opts.version - Object version
|
|
* @param {number=} opts.stream - Object stream (1 by default)
|
|
* @param {Buffer} opts.objectPayload - Object payload
|
|
* @return {Buffer} Encoded message.
|
|
*/
|
|
encode: function(opts) {
|
|
var payload = object.encodePayload(opts);
|
|
return message.encode("object", payload);
|
|
},
|
|
|
|
/**
|
|
* Encode `object` message payload.
|
|
* The same as [encode]{@link module:bitmessage/structs.object.encode}.
|
|
*/
|
|
encodePayload: function(opts) {
|
|
// NOTE(Kagami): We do not try to calculate nonce here if it is not
|
|
// provided because:
|
|
// 1) It's async operation but in `structs` module all operations
|
|
// are synchronous.
|
|
// 2) It shouldn't be useful because almost all objects signatures
|
|
// include object header and POW is computed for entire object so at
|
|
// first the object header should be assembled and only then we can
|
|
// do a POW.
|
|
assert(opts.nonce.length === 8, "Bad nonce");
|
|
// NOTE(Kagami): This may be a bit inefficient since we allocate
|
|
// twice.
|
|
return Buffer.concat([
|
|
opts.nonce,
|
|
object.encodePayloadWithoutNonce(opts),
|
|
]);
|
|
},
|
|
|
|
/**
|
|
* Encode `object` message payload without leading nonce field (may be
|
|
* useful if you are going to calculate it later).
|
|
* @param {Object} opts - Object options
|
|
* @param {number} opts.ttl - Time to live in seconds
|
|
* @param {number} opts.type - Object type
|
|
* @param {number} opts.version - Object version
|
|
* @param {number=} opts.stream - Object stream (1 by default)
|
|
* @param {Buffer} opts.objectPayload - Object payload
|
|
* @return {Buffer} Encoded payload.
|
|
*/
|
|
encodePayloadWithoutNonce: function(opts) {
|
|
assert(opts.ttl > 0, "Bad TTL");
|
|
assert(opts.ttl <= 2430000, "TTL may not be larger than 28 days + 3 hours");
|
|
var expiresTime = util.tnow() + opts.ttl;
|
|
var type = new Buffer(4);
|
|
type.writeUInt32BE(opts.type, 0);
|
|
var stream = opts.stream || 1;
|
|
var obj = Buffer.concat([
|
|
util.writeUInt64BE(null, expiresTime),
|
|
type,
|
|
var_int.encode(opts.version),
|
|
var_int.encode(stream),
|
|
opts.objectPayload,
|
|
]);
|
|
assert(obj.length <= 262136, "object message payload is too big");
|
|
return obj;
|
|
},
|
|
};
|
|
|
|
/**
|
|
* Variable length integer.
|
|
* @see {@link https://bitmessage.org/wiki/Protocol_specification#Variable_length_integer}
|
|
* @namespace
|
|
* @static
|
|
*/
|
|
var var_int = exports.var_int = {
|
|
/**
|
|
* @typedef {Object} DecodeResult
|
|
* @property {number} value - Stored value
|
|
* @property {number} length - `var_int` full length
|
|
* @property {Buffer} rest - The rest of the input buffer
|
|
* @memberof module:bitmessage/structs.var_int
|
|
*/
|
|
|
|
/**
|
|
* Decode `var_int`.
|
|
* NOTE: `rest` references input buffer.
|
|
* @param {Buffer} buf - A buffer that starts with encoded `var_int`
|
|
* @return {DecodeResult}
|
|
* [Decoded `var_int` structure.]{@link module:bitmessage/structs.var_int.DecodeResult}
|
|
*/
|
|
decode: function(buf) {
|
|
var value, length;
|
|
assert(buf.length > 0, "Empty buffer");
|
|
switch (buf[0]) {
|
|
case 253:
|
|
value = buf.readUInt16BE(1);
|
|
assert(value >= 253, "Impractical var_int");
|
|
length = 3;
|
|
break;
|
|
case 254:
|
|
value = buf.readUInt32BE(1);
|
|
assert(value >= 65536, "Impractical var_int");
|
|
length = 5;
|
|
break;
|
|
case 255:
|
|
var hi = buf.readUInt32BE(1);
|
|
assert(hi !== 0, "Impractical var_int");
|
|
// Max safe number = 2^53 - 1 =
|
|
// 0b0000000000011111111111111111111111111111111111111111111111111111
|
|
// = 2097151*(2^32) + (2^32 - 1).
|
|
// So it's safe until hi <= 2097151. See
|
|
// <http://mdn.io/issafeinteger>,
|
|
// <https://stackoverflow.com/q/307179> for details.
|
|
// TODO(Kagami): We may want to return raw Buffer for
|
|
// 2^53 <= value <= 2^64 - 1 range. Probably using the optional
|
|
// argument because most of the code expect to get a number when
|
|
// calling `var_int.decode`.
|
|
assert(hi <= 2097151, "Unsafe integer");
|
|
var lo = buf.readUInt32BE(5);
|
|
value = hi * 4294967296 + lo;
|
|
length = 9;
|
|
break;
|
|
default:
|
|
value = buf[0];
|
|
length = 1;
|
|
}
|
|
var rest = buf.slice(length);
|
|
return {value: value, length: length, rest: rest};
|
|
},
|
|
|
|
/**
|
|
* Encode number into `var_int`.
|
|
* @param {(number|Buffer)} value - Input number
|
|
* @return {Buffer} Encoded `var_int`.
|
|
*/
|
|
encode: function(value) {
|
|
var buf, targetStart;
|
|
if (typeof value === "number") {
|
|
assert(value >= 0, "Value cannot be less than zero");
|
|
if (value < 253) {
|
|
buf = new Buffer([value]);
|
|
} else if (value < 65536) {
|
|
buf = new Buffer(3);
|
|
buf[0] = 253;
|
|
buf.writeUInt16BE(value, 1, true);
|
|
} else if (value < 4294967296) {
|
|
buf = new Buffer(5);
|
|
buf[0] = 254;
|
|
buf.writeUInt32BE(value, 1, true);
|
|
} else {
|
|
assert(value <= 9007199254740991, "Unsafe integer");
|
|
buf = new Buffer(9);
|
|
buf[0] = 255;
|
|
buf.writeUInt32BE(Math.floor(value / 4294967296), 1, true); // high32
|
|
buf.writeUInt32BE(value % 4294967296, 5, true); // low32
|
|
}
|
|
} else if (Buffer.isBuffer(value)) {
|
|
assert(value.length <= 8, "Buffer is too big");
|
|
buf = new Buffer(9);
|
|
buf.fill(0);
|
|
buf[0] = 255;
|
|
targetStart = 1 + (8 - value.length);
|
|
value.copy(buf, targetStart);
|
|
} else {
|
|
throw new Error("Unknown value type");
|
|
}
|
|
return buf;
|
|
},
|
|
};
|
|
|
|
/**
|
|
* Variable length string.
|
|
* @see {@link https://bitmessage.org/wiki/Protocol_specification#Variable_length_string}
|
|
* @namespace
|
|
*/
|
|
exports.var_str = {
|
|
/**
|
|
* @typedef {Object} DecodeResult
|
|
* @property {number} str - The string itself
|
|
* @property {number} length - `var_str` full length
|
|
* @property {Buffer} rest - The rest of the input buffer
|
|
* @memberof module:bitmessage/structs.var_str
|
|
*/
|
|
|
|
/**
|
|
* Decode `var_str`.
|
|
* NOTE: `rest` references input buffer.
|
|
* @param {Buffer} buf - A buffer that starts with encoded `var_str`
|
|
* @return {DecodeResult}
|
|
* [Decoded `var_str` structure.]{@link module:bitmessage/structs.var_str.DecodeResult}
|
|
*/
|
|
decode: function(buf) {
|
|
var decoded = var_int.decode(buf);
|
|
var strLength = decoded.value;
|
|
var length = decoded.length + strLength;
|
|
assert(buf.length >= length, "Buffer is too small");
|
|
// XXX(Kagami): Spec doesn't mention encoding, using UTF-8.
|
|
var str = decoded.rest.slice(0, strLength).toString("utf8");
|
|
var rest = decoded.rest.slice(strLength);
|
|
return {str: str, length: length, rest: rest};
|
|
},
|
|
|
|
/**
|
|
* Encode string into `var_str`.
|
|
* @param {string} str - A string
|
|
* @return {Buffer} Encoded `var_str`.
|
|
*/
|
|
encode: function(str) {
|
|
// XXX(Kagami): Spec doesn't mention encoding, using UTF-8.
|
|
var strBuf = new Buffer(str, "utf8");
|
|
return Buffer.concat([var_int.encode(strBuf.length), strBuf]);
|
|
},
|
|
};
|
|
|
|
/**
|
|
* Variable length list of integers.
|
|
* @see {@link https://bitmessage.org/wiki/Protocol_specification#Variable_length_list_of_integers}
|
|
* @namespace
|
|
*/
|
|
exports.var_int_list = {
|
|
/**
|
|
* @typedef {Object} DecodeResult
|
|
* @property {number} list - Stored numbers
|
|
* @property {number} length - `var_int_list` full length
|
|
* @property {Buffer} rest - The rest of the input buffer
|
|
* @memberof module:bitmessage/structs.var_int_list
|
|
*/
|
|
|
|
/**
|
|
* Decode `var_int_list`.
|
|
* NOTE: `rest` references input buffer.
|
|
* @param {Buffer} buf - A buffer that starts with encoded
|
|
* `var_int_list`
|
|
* @return {DecodeResult}
|
|
* [Decoded `var_int_list` structure.]{@link module:bitmessage/structs.var_int_list.DecodeResult}
|
|
*/
|
|
decode: function(buf) {
|
|
var decoded = var_int.decode(buf);
|
|
var listLength = decoded.value;
|
|
var list = new Array(listLength);
|
|
var rest = decoded.rest;
|
|
var sumLength = decoded.length;
|
|
for (var i = 0; i < listLength; i++) {
|
|
decoded = var_int.decode(rest);
|
|
list[i] = decoded.value;
|
|
rest = decoded.rest;
|
|
sumLength += decoded.length;
|
|
}
|
|
return {list: list, length: sumLength, rest: rest};
|
|
},
|
|
|
|
/**
|
|
* Encode list of numbers into `var_int_list`.
|
|
* @param {number[]} list - A number list
|
|
* @return {Buffer} Encoded `var_int_list`.
|
|
*/
|
|
encode: function(list) {
|
|
var var_ints = list.map(var_int.encode);
|
|
var bufs = [var_int.encode(list.length)].concat(var_ints);
|
|
return Buffer.concat(bufs);
|
|
},
|
|
};
|
|
|
|
// See https://en.wikipedia.org/wiki/IPv6#IPv4-mapped_IPv6_addresses
|
|
var IPv4_MAPPING = new Buffer([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255]);
|
|
|
|
// Very simple inet_ntop(3) equivalent.
|
|
function inet_ntop(buf) {
|
|
assert(buf.length === 16, "Bad buffer size");
|
|
// IPv4 mapped to IPv6.
|
|
if (bufferEqual(buf.slice(0, 12), IPv4_MAPPING)) {
|
|
return Array.prototype.join.call(buf.slice(12), ".");
|
|
// IPv6.
|
|
} else {
|
|
var groups = [];
|
|
for (var i = 0; i < 8; i++) {
|
|
groups.push(buf.readUInt16BE(i * 2, true).toString(16));
|
|
}
|
|
return groups.join(":");
|
|
}
|
|
}
|
|
|
|
// Very simple inet_pton(3) equivalent.
|
|
function inet_pton(str) {
|
|
var buf = new Buffer(16);
|
|
buf.fill(0);
|
|
// IPv4-mapped IPv6.
|
|
if (str.slice(0, 7) === "::ffff:") {
|
|
str = str.slice(7);
|
|
}
|
|
// IPv4.
|
|
if (str.indexOf(":") === -1) {
|
|
IPv4_MAPPING.copy(buf);
|
|
var octets = str.split(/\./g).map(function(o) {
|
|
assert(/^\d+$/.test(o), "Bad octet");
|
|
return parseInt(o, 10);
|
|
});
|
|
// Support short form from inet_aton(3) man page.
|
|
if (octets.length === 1) {
|
|
buf.writeUInt32BE(octets[0], 12);
|
|
} else {
|
|
// Check against 1000.bad.addr
|
|
octets.forEach(function(octet) {
|
|
assert(octet >= 0, "Bad IPv4 address");
|
|
assert(octet <= 255, "Bad IPv4 address");
|
|
});
|
|
if (octets.length === 2) {
|
|
buf[12] = octets[0];
|
|
buf[15] = octets[1];
|
|
} else if (octets.length === 3) {
|
|
buf[12] = octets[0];
|
|
buf[13] = octets[1];
|
|
buf[15] = octets[2];
|
|
} else if (octets.length === 4) {
|
|
buf[12] = octets[0];
|
|
buf[13] = octets[1];
|
|
buf[14] = octets[2];
|
|
buf[15] = octets[3];
|
|
} else {
|
|
throw new Error("Bad IPv4 address");
|
|
}
|
|
}
|
|
// IPv6.
|
|
} else {
|
|
var dgroups = str.split(/::/g);
|
|
// Check against 1::1::1
|
|
assert(dgroups.length <= 2, "Bad IPv6 address");
|
|
var groups = [];
|
|
var i;
|
|
if (dgroups[0]) {
|
|
groups.push.apply(groups, dgroups[0].split(/:/g));
|
|
}
|
|
if (dgroups.length === 2) {
|
|
if (dgroups[1]) {
|
|
var splitted = dgroups[1].split(/:/g);
|
|
var fill = 8 - (groups.length + splitted.length);
|
|
// Check against 1:1:1:1::1:1:1:1
|
|
assert(fill > 0, "Bad IPv6 address");
|
|
for (i = 0; i < fill; i++) {
|
|
groups.push(0);
|
|
}
|
|
groups.push.apply(groups, splitted);
|
|
} else {
|
|
// Check against 1:1:1:1:1:1:1:1::
|
|
assert(groups.length <= 7, "Bad IPv6 address");
|
|
}
|
|
} else {
|
|
// Check against 1:1:1
|
|
assert(groups.length === 8, "Bad IPv6 address");
|
|
}
|
|
for (i = 0; i < Math.min(groups.length, 8); i++) {
|
|
// Check against parseInt("127.0.0.1", 16) -> 295
|
|
assert(/^[0-9a-f]+$/.test(groups[i]), "Bad group");
|
|
buf.writeUInt16BE(parseInt(groups[i], 16), i * 2);
|
|
}
|
|
}
|
|
return buf;
|
|
}
|
|
|
|
/**
|
|
* Network address.
|
|
* @see {@link https://bitmessage.org/wiki/Protocol_specification#Network_address}
|
|
* @namespace
|
|
*/
|
|
exports.net_addr = {
|
|
/**
|
|
* @typedef {Object} DecodeResult
|
|
* @property {Date} time - Time the node was last active, not included
|
|
* in short mode
|
|
* @property {number} stream - Stream number of the node, not included
|
|
* in short mode
|
|
* @property {Object} services -
|
|
* [Services]{@link module:bitmessage/structs.ServicesBitfield}
|
|
* provided by the node
|
|
* @property {string} host - IPv4/IPv6 address of the node
|
|
* @property {number} port - Incoming port of the node
|
|
* @memberof module:bitmessage/structs.net_addr
|
|
*/
|
|
|
|
/**
|
|
* Decode `net_addr`.
|
|
* @param {Buffer} buf - A buffer that contains encoded `net_addr`
|
|
* @param {Object=} opts - Decoding options; use `short` option to
|
|
* decode `net_addr` from
|
|
* [version message]{@link module:bitmessage/messages.version}
|
|
* @return {DecodeResult}
|
|
* [Decoded `net_addr` structure.]{@link module:bitmessage/structs.net_addr.DecodeResult}
|
|
*/
|
|
decode: function(buf, opts) {
|
|
var short = !!(opts || {}).short;
|
|
var res = {};
|
|
if (short) {
|
|
assert(buf.length === 26, "Bad buffer size");
|
|
} else {
|
|
assert(buf.length === 38, "Bad buffer size");
|
|
var timeHi = buf.readUInt32BE(0, true);
|
|
var timeLo = buf.readUInt32BE(4, true);
|
|
// JavaScript's Date object can't work with timestamps higher than
|
|
// 8640000000000 (~2^43, ~275760 year). Hope JavaScript will
|
|
// support 64-bit numbers up to this date.
|
|
assert(timeHi <= 2011, "Time is too high");
|
|
assert(timeHi !== 2011 || timeLo <= 2820767744, "Time is too high");
|
|
res.time = new Date((timeHi * 4294967296 + timeLo) * 1000);
|
|
res.stream = buf.readUInt32BE(8, true);
|
|
buf = buf.slice(12);
|
|
}
|
|
res.services = ServicesBitfield(buf.slice(0, 8), {copy: true});
|
|
res.host = inet_ntop(buf.slice(8, 24));
|
|
res.port = buf.readUInt16BE(24, true);
|
|
return res;
|
|
},
|
|
|
|
/**
|
|
* Encode `net_addr`.
|
|
* @param {Object} opts - Encoding options
|
|
* @param {boolean=} opts.short - Encode `net_addr` for
|
|
* [version message]{@link module:bitmessage/messages.version}
|
|
* (false by default)
|
|
* @param {Date=} opts.time - Time the node was last active, not
|
|
* included in short mode (current time by default)
|
|
* @param {number=} opts.stream - Stream number of the node, not
|
|
* included in short mode (1 by default)
|
|
* @param {Object=} opts.services -
|
|
* [Services]{@link module:bitmessage/structs.ServicesBitfield}
|
|
* provided by the node (`NODE_NETWORK` by default)
|
|
* @param {string} opts.host - IPv4/IPv6 address of the node
|
|
* @param {number} opts.port - Incoming port of the node
|
|
* @return {Buffer} Encoded `net_addr`.
|
|
*/
|
|
encode: function(opts) {
|
|
// Be aware of `Buffer.slice` quirk in browserify:
|
|
// <http://git.io/lNZF1A> (does not modify parent buffer's memory in
|
|
// old browsers). So we use offset instead of `buf = buf.slice`.
|
|
var buf, shift;
|
|
if (opts.short) {
|
|
buf = new Buffer(26);
|
|
shift = 0;
|
|
} else {
|
|
buf = new Buffer(38);
|
|
var time = opts.time || new Date();
|
|
time = Math.floor(time.getTime() / 1000);
|
|
buf.writeUInt32BE(Math.floor(time / 4294967296), 0, true); // high32
|
|
buf.writeUInt32BE(time % 4294967296, 4, true); // low32
|
|
var stream = opts.stream || 1;
|
|
buf.writeUInt32BE(stream, 8);
|
|
shift = 12;
|
|
}
|
|
var services = opts.services ||
|
|
ServicesBitfield().set(ServicesBitfield.NODE_NETWORK);
|
|
services.buffer.copy(buf, shift);
|
|
inet_pton(opts.host).copy(buf, shift + 8);
|
|
buf.writeUInt16BE(opts.port, shift + 24);
|
|
return buf;
|
|
},
|
|
};
|
|
|
|
/**
|
|
* Inventory vector.
|
|
* @see {@link https://bitmessage.org/wiki/Protocol_specification#Inventory_Vectors}
|
|
* @namespace
|
|
*/
|
|
exports.inv_vect = {
|
|
// NOTE(Kagami): Only encode operation is defined because decoding of
|
|
// the encoded vector is impossible.
|
|
|
|
/**
|
|
* Encode inventory vector.
|
|
* @param {Buffer} buf - Payload to calculate the inventory vector for
|
|
* @return {Buffer} A 32-byte encoded `inv_vect`.
|
|
*/
|
|
encode: function(buf) {
|
|
return bmcrypto.sha512(bmcrypto.sha512(buf)).slice(0, 32);
|
|
},
|
|
};
|
|
|
|
/**
|
|
* Encrypted payload.
|
|
* @see {@link https://bitmessage.org/wiki/Protocol_specification#Encrypted_payload}
|
|
* @namespace encrypted
|
|
* @static
|
|
*/
|
|
/**
|
|
* @typedef {Object} DecodeResult
|
|
* @property {Buffer} iv - Initialization vector (16 bytes)
|
|
* @property {Buffer} ephemPrivateKey - Ephemeral private key (32 bytes)
|
|
* @property {Buffer} ciphertext - The result of encryption (variable
|
|
* size)
|
|
* @property {Buffer} mac - Message authentication code (32 bytes)
|
|
* @memberof module:bitmessage/structs.encrypted
|
|
*/
|
|
/**
|
|
* Decode encrypted payload.
|
|
* NOTE: all structure members are copied.
|
|
* @param {Buffer} buf - A buffer that contains encrypted payload
|
|
* @return {DecodeResult}
|
|
* [Decoded `encrypted` structure.]{@link module:bitmessage/structs.encrypted.DecodeResult}
|
|
* @function decode
|
|
* @memberof module:bitmessage/structs.encrypted
|
|
*/
|
|
/**
|
|
* Encode `encrypted`.
|
|
* @param {Object} opts - Encoding options
|
|
* @param {Buffer} opts.iv - Initialization vector (16 bytes)
|
|
* @param {Buffer} opts.ephemPrivateKey - Ephemeral private key (32
|
|
* bytes)
|
|
* @param {Buffer} opts.ciphertext - The result of encryption (variable
|
|
* size)
|
|
* @param {Buffer} opts.mac - Message authentication code (32 bytes)
|
|
* @return {Buffer} Encoded `encrypted` payload.
|
|
* @function encode
|
|
* @memberof module:bitmessage/structs.encrypted
|
|
*/
|
|
// Reexport struct.
|
|
exports.encrypted = bmcrypto.encrypted;
|
|
|
|
// Creates bitfield (MSB 0) class of the specified size.
|
|
var Bitfield = function(size) {
|
|
var bytesize = size / 8;
|
|
|
|
// Inspired by <https://github.com/fb55/bitfield>.
|
|
function BitfieldInner(buf, opts) {
|
|
if (!(this instanceof BitfieldInner)) {
|
|
return new BitfieldInner(buf);
|
|
}
|
|
opts = opts || {};
|
|
if (buf) {
|
|
assert(buf.length === bytesize, "Bad buffer size");
|
|
if (opts.copy) {
|
|
var dup = new Buffer(bytesize);
|
|
dup.fill(0);
|
|
buf.copy(dup);
|
|
buf = dup;
|
|
}
|
|
} else {
|
|
buf = new Buffer(bytesize);
|
|
buf.fill(0);
|
|
}
|
|
this.buffer = buf;
|
|
}
|
|
|
|
BitfieldInner.prototype.get = function(bits) {
|
|
if (!Array.isArray(bits)) {
|
|
bits = [bits];
|
|
}
|
|
var buf = this.buffer;
|
|
return bits.every(function(bit) {
|
|
assert(bit >= 0, "Bit number is too low");
|
|
assert(bit < size, "Bit number is too high");
|
|
var index = Math.floor(bit / 8);
|
|
var shift = 7 - (bit % 8);
|
|
return (buf[index] & (1 << shift)) !== 0; // jshint ignore:line
|
|
});
|
|
};
|
|
|
|
BitfieldInner.prototype.set = function(bits) {
|
|
if (!Array.isArray(bits)) {
|
|
bits = [bits];
|
|
}
|
|
var buf = this.buffer;
|
|
bits.forEach(function(bit) {
|
|
assert(bit >= 0, "Bit number is too low");
|
|
assert(bit < size, "Bit number is too high");
|
|
var index = Math.floor(bit / 8);
|
|
var shift = 7 - (bit % 8);
|
|
buf[index] |= 1 << shift; // jshint ignore:line
|
|
});
|
|
return this;
|
|
};
|
|
|
|
return BitfieldInner;
|
|
};
|
|
|
|
/**
|
|
* Service features bitfield (MSB 0).
|
|
* @see {@link https://bitmessage.org/wiki/Protocol_specification#version}
|
|
* @param {Buffer=} buf - A 8-byte bitfield buffer (will be created if
|
|
* not provided or will be copied if `opts.copy` is `true`)
|
|
* @param {Object=} opts - Options
|
|
* @constructor
|
|
* @static
|
|
* @example
|
|
* var ServicesBitfield = require("bitmessage").structs.ServicesBitfield;
|
|
* var services = ServicesBitfield().set(ServicesBitfield.NODE_NETWORK);
|
|
* console.log(services.get(ServicesBitfield.NODE_NETWORK)); // true
|
|
* console.log(services.get(15)); // false
|
|
*/
|
|
// NOTE(Kagami): Since pubkey bitfield uses MSB 0, we use it here too.
|
|
// See <https://github.com/Bitmessage/PyBitmessage/issues/769> for
|
|
// details.
|
|
var ServicesBitfield = exports.ServicesBitfield = objectAssign(Bitfield(64), {
|
|
/**
|
|
* Returns a boolean indicating whether the bit is set.
|
|
* @param {number} index - Bit index (MSB 0)
|
|
* @function get
|
|
* @instance
|
|
* @return {boolean}
|
|
* @memberof module:bitmessage/structs.ServicesBitfield
|
|
*/
|
|
/**
|
|
* Set the given bit(s) to `1`.
|
|
* @param {(number|number[])} index - Bit(s) index (MSB 0)
|
|
* @function set
|
|
* @instance
|
|
* @return {Object} Returns self so methods can be chained.
|
|
* @memberof module:bitmessage/structs.ServicesBitfield
|
|
*/
|
|
/**
|
|
* The contents of the bitfield.
|
|
* @type {Buffer}
|
|
* @var buffer
|
|
* @instance
|
|
* @memberof module:bitmessage/structs.ServicesBitfield
|
|
*/
|
|
|
|
/**
|
|
* Bit index indicating normal network node.
|
|
* @memberof module:bitmessage/structs.ServicesBitfield
|
|
* @constant {number}
|
|
*/
|
|
NODE_NETWORK: 63,
|
|
});
|
|
|
|
/**
|
|
* Pubkey features bitfield (MSB 0).
|
|
* @see {@link https://bitmessage.org/wiki/Protocol_specification#Pubkey_bitfield_features}
|
|
* @param {Buffer=} buf - A 4-byte bitfield buffer (will be created if
|
|
* not provided or will be copied if `opts.copy` is `true`)
|
|
* @param {Object=} opts - Options
|
|
* @constructor
|
|
* @example
|
|
* var PubkeyBitfield = require("bitmessage").structs.PubkeyBitfield;
|
|
* var behavior = PubkeyBitfield().set([
|
|
* PubkeyBitfield.INCLUDE_DESTINATION,
|
|
* PubkeyBitfield.DOES_ACK,
|
|
* ]).set(1);
|
|
* console.log(behavior.get(PubkeyBitfield.DOES_ACK)); // true
|
|
* console.log(behavior.get(15)); // false
|
|
*/
|
|
exports.PubkeyBitfield = objectAssign(Bitfield(32), {
|
|
/**
|
|
* Returns a boolean indicating whether the bit is set.
|
|
* @param {number} index - Bit index (MSB 0)
|
|
* @function get
|
|
* @instance
|
|
* @return {boolean}
|
|
* @memberof module:bitmessage/structs.PubkeyBitfield
|
|
*/
|
|
/**
|
|
* Set the given bit(s) to `1`.
|
|
* @param {(number|number[])} index - Bit(s) index (MSB 0)
|
|
* @function set
|
|
* @instance
|
|
* @return {Object} Returns self so methods can be chained.
|
|
* @memberof module:bitmessage/structs.PubkeyBitfield
|
|
*/
|
|
/**
|
|
* The contents of the bitfield.
|
|
* @type {Buffer}
|
|
* @var buffer
|
|
* @instance
|
|
* @memberof module:bitmessage/structs.PubkeyBitfield
|
|
*/
|
|
|
|
/**
|
|
* Bit index.
|
|
* If set, the receiving node expects that the RIPEMD hash encoded in
|
|
* their address preceedes the encrypted message data of msg messages
|
|
* bound for them.
|
|
* @memberof module:bitmessage/structs.PubkeyBitfield
|
|
* @constant {number}
|
|
*/
|
|
INCLUDE_DESTINATION: 30,
|
|
/**
|
|
* Bit index.
|
|
* If set, the receiving node does send acknowledgements (rather than
|
|
* dropping them).
|
|
* @memberof module:bitmessage/structs.PubkeyBitfield
|
|
* @constant {number}
|
|
*/
|
|
DOES_ACK: 31,
|
|
});
|