diff --git a/WASignalGroup/GroupProtocol.js b/WASignalGroup/GroupProtocol.js new file mode 100644 index 0000000..efa722a --- /dev/null +++ b/WASignalGroup/GroupProtocol.js @@ -0,0 +1,1697 @@ +/*eslint-disable block-scoped-var, id-length, no-control-regex, no-magic-numbers, no-prototype-builtins, no-redeclare, no-shadow, no-var, sort-vars*/ +"use strict"; + +var $protobuf = require("protobufjs/minimal"); + +// Common aliases +var $Reader = $protobuf.Reader, $Writer = $protobuf.Writer, $util = $protobuf.util; + +// Exported root namespace +var $root = $protobuf.roots["default"] || ($protobuf.roots["default"] = {}); + +$root.groupproto = (function() { + + /** + * Namespace groupproto. + * @exports groupproto + * @namespace + */ + var groupproto = {}; + + groupproto.SenderKeyMessage = (function() { + + /** + * Properties of a SenderKeyMessage. + * @memberof groupproto + * @interface ISenderKeyMessage + * @property {number|null} [id] SenderKeyMessage id + * @property {number|null} [iteration] SenderKeyMessage iteration + * @property {Uint8Array|null} [ciphertext] SenderKeyMessage ciphertext + */ + + /** + * Constructs a new SenderKeyMessage. + * @memberof groupproto + * @classdesc Represents a SenderKeyMessage. + * @implements ISenderKeyMessage + * @constructor + * @param {groupproto.ISenderKeyMessage=} [properties] Properties to set + */ + function SenderKeyMessage(properties) { + if (properties) + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + + /** + * SenderKeyMessage id. + * @member {number} id + * @memberof groupproto.SenderKeyMessage + * @instance + */ + SenderKeyMessage.prototype.id = 0; + + /** + * SenderKeyMessage iteration. + * @member {number} iteration + * @memberof groupproto.SenderKeyMessage + * @instance + */ + SenderKeyMessage.prototype.iteration = 0; + + /** + * SenderKeyMessage ciphertext. + * @member {Uint8Array} ciphertext + * @memberof groupproto.SenderKeyMessage + * @instance + */ + SenderKeyMessage.prototype.ciphertext = $util.newBuffer([]); + + /** + * Creates a new SenderKeyMessage instance using the specified properties. + * @function create + * @memberof groupproto.SenderKeyMessage + * @static + * @param {groupproto.ISenderKeyMessage=} [properties] Properties to set + * @returns {groupproto.SenderKeyMessage} SenderKeyMessage instance + */ + SenderKeyMessage.create = function create(properties) { + return new SenderKeyMessage(properties); + }; + + /** + * Encodes the specified SenderKeyMessage message. Does not implicitly {@link groupproto.SenderKeyMessage.verify|verify} messages. + * @function encode + * @memberof groupproto.SenderKeyMessage + * @static + * @param {groupproto.ISenderKeyMessage} message SenderKeyMessage message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + SenderKeyMessage.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.id != null && Object.hasOwnProperty.call(message, "id")) + writer.uint32(/* id 1, wireType 0 =*/8).uint32(message.id); + if (message.iteration != null && Object.hasOwnProperty.call(message, "iteration")) + writer.uint32(/* id 2, wireType 0 =*/16).uint32(message.iteration); + if (message.ciphertext != null && Object.hasOwnProperty.call(message, "ciphertext")) + writer.uint32(/* id 3, wireType 2 =*/26).bytes(message.ciphertext); + return writer; + }; + + /** + * Encodes the specified SenderKeyMessage message, length delimited. Does not implicitly {@link groupproto.SenderKeyMessage.verify|verify} messages. + * @function encodeDelimited + * @memberof groupproto.SenderKeyMessage + * @static + * @param {groupproto.ISenderKeyMessage} message SenderKeyMessage message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + SenderKeyMessage.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a SenderKeyMessage message from the specified reader or buffer. + * @function decode + * @memberof groupproto.SenderKeyMessage + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {groupproto.SenderKeyMessage} SenderKeyMessage + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + SenderKeyMessage.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === undefined ? reader.len : reader.pos + length, message = new $root.groupproto.SenderKeyMessage(); + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.id = reader.uint32(); + break; + case 2: + message.iteration = reader.uint32(); + break; + case 3: + message.ciphertext = reader.bytes(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + + /** + * Decodes a SenderKeyMessage message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof groupproto.SenderKeyMessage + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {groupproto.SenderKeyMessage} SenderKeyMessage + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + SenderKeyMessage.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a SenderKeyMessage message. + * @function verify + * @memberof groupproto.SenderKeyMessage + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + SenderKeyMessage.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.id != null && message.hasOwnProperty("id")) + if (!$util.isInteger(message.id)) + return "id: integer expected"; + if (message.iteration != null && message.hasOwnProperty("iteration")) + if (!$util.isInteger(message.iteration)) + return "iteration: integer expected"; + if (message.ciphertext != null && message.hasOwnProperty("ciphertext")) + if (!(message.ciphertext && typeof message.ciphertext.length === "number" || $util.isString(message.ciphertext))) + return "ciphertext: buffer expected"; + return null; + }; + + /** + * Creates a SenderKeyMessage message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof groupproto.SenderKeyMessage + * @static + * @param {Object.} object Plain object + * @returns {groupproto.SenderKeyMessage} SenderKeyMessage + */ + SenderKeyMessage.fromObject = function fromObject(object) { + if (object instanceof $root.groupproto.SenderKeyMessage) + return object; + var message = new $root.groupproto.SenderKeyMessage(); + if (object.id != null) + message.id = object.id >>> 0; + if (object.iteration != null) + message.iteration = object.iteration >>> 0; + if (object.ciphertext != null) + if (typeof object.ciphertext === "string") + $util.base64.decode(object.ciphertext, message.ciphertext = $util.newBuffer($util.base64.length(object.ciphertext)), 0); + else if (object.ciphertext.length) + message.ciphertext = object.ciphertext; + return message; + }; + + /** + * Creates a plain object from a SenderKeyMessage message. Also converts values to other types if specified. + * @function toObject + * @memberof groupproto.SenderKeyMessage + * @static + * @param {groupproto.SenderKeyMessage} message SenderKeyMessage + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + SenderKeyMessage.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.defaults) { + object.id = 0; + object.iteration = 0; + if (options.bytes === String) + object.ciphertext = ""; + else { + object.ciphertext = []; + if (options.bytes !== Array) + object.ciphertext = $util.newBuffer(object.ciphertext); + } + } + if (message.id != null && message.hasOwnProperty("id")) + object.id = message.id; + if (message.iteration != null && message.hasOwnProperty("iteration")) + object.iteration = message.iteration; + if (message.ciphertext != null && message.hasOwnProperty("ciphertext")) + object.ciphertext = options.bytes === String ? $util.base64.encode(message.ciphertext, 0, message.ciphertext.length) : options.bytes === Array ? Array.prototype.slice.call(message.ciphertext) : message.ciphertext; + return object; + }; + + /** + * Converts this SenderKeyMessage to JSON. + * @function toJSON + * @memberof groupproto.SenderKeyMessage + * @instance + * @returns {Object.} JSON object + */ + SenderKeyMessage.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return SenderKeyMessage; + })(); + + groupproto.SenderKeyDistributionMessage = (function() { + + /** + * Properties of a SenderKeyDistributionMessage. + * @memberof groupproto + * @interface ISenderKeyDistributionMessage + * @property {number|null} [id] SenderKeyDistributionMessage id + * @property {number|null} [iteration] SenderKeyDistributionMessage iteration + * @property {Uint8Array|null} [chainKey] SenderKeyDistributionMessage chainKey + * @property {Uint8Array|null} [signingKey] SenderKeyDistributionMessage signingKey + */ + + /** + * Constructs a new SenderKeyDistributionMessage. + * @memberof groupproto + * @classdesc Represents a SenderKeyDistributionMessage. + * @implements ISenderKeyDistributionMessage + * @constructor + * @param {groupproto.ISenderKeyDistributionMessage=} [properties] Properties to set + */ + function SenderKeyDistributionMessage(properties) { + if (properties) + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + + /** + * SenderKeyDistributionMessage id. + * @member {number} id + * @memberof groupproto.SenderKeyDistributionMessage + * @instance + */ + SenderKeyDistributionMessage.prototype.id = 0; + + /** + * SenderKeyDistributionMessage iteration. + * @member {number} iteration + * @memberof groupproto.SenderKeyDistributionMessage + * @instance + */ + SenderKeyDistributionMessage.prototype.iteration = 0; + + /** + * SenderKeyDistributionMessage chainKey. + * @member {Uint8Array} chainKey + * @memberof groupproto.SenderKeyDistributionMessage + * @instance + */ + SenderKeyDistributionMessage.prototype.chainKey = $util.newBuffer([]); + + /** + * SenderKeyDistributionMessage signingKey. + * @member {Uint8Array} signingKey + * @memberof groupproto.SenderKeyDistributionMessage + * @instance + */ + SenderKeyDistributionMessage.prototype.signingKey = $util.newBuffer([]); + + /** + * Creates a new SenderKeyDistributionMessage instance using the specified properties. + * @function create + * @memberof groupproto.SenderKeyDistributionMessage + * @static + * @param {groupproto.ISenderKeyDistributionMessage=} [properties] Properties to set + * @returns {groupproto.SenderKeyDistributionMessage} SenderKeyDistributionMessage instance + */ + SenderKeyDistributionMessage.create = function create(properties) { + return new SenderKeyDistributionMessage(properties); + }; + + /** + * Encodes the specified SenderKeyDistributionMessage message. Does not implicitly {@link groupproto.SenderKeyDistributionMessage.verify|verify} messages. + * @function encode + * @memberof groupproto.SenderKeyDistributionMessage + * @static + * @param {groupproto.ISenderKeyDistributionMessage} message SenderKeyDistributionMessage message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + SenderKeyDistributionMessage.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.id != null && Object.hasOwnProperty.call(message, "id")) + writer.uint32(/* id 1, wireType 0 =*/8).uint32(message.id); + if (message.iteration != null && Object.hasOwnProperty.call(message, "iteration")) + writer.uint32(/* id 2, wireType 0 =*/16).uint32(message.iteration); + if (message.chainKey != null && Object.hasOwnProperty.call(message, "chainKey")) + writer.uint32(/* id 3, wireType 2 =*/26).bytes(message.chainKey); + if (message.signingKey != null && Object.hasOwnProperty.call(message, "signingKey")) + writer.uint32(/* id 4, wireType 2 =*/34).bytes(message.signingKey); + return writer; + }; + + /** + * Encodes the specified SenderKeyDistributionMessage message, length delimited. Does not implicitly {@link groupproto.SenderKeyDistributionMessage.verify|verify} messages. + * @function encodeDelimited + * @memberof groupproto.SenderKeyDistributionMessage + * @static + * @param {groupproto.ISenderKeyDistributionMessage} message SenderKeyDistributionMessage message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + SenderKeyDistributionMessage.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a SenderKeyDistributionMessage message from the specified reader or buffer. + * @function decode + * @memberof groupproto.SenderKeyDistributionMessage + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {groupproto.SenderKeyDistributionMessage} SenderKeyDistributionMessage + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + SenderKeyDistributionMessage.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === undefined ? reader.len : reader.pos + length, message = new $root.groupproto.SenderKeyDistributionMessage(); + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.id = reader.uint32(); + break; + case 2: + message.iteration = reader.uint32(); + break; + case 3: + message.chainKey = reader.bytes(); + break; + case 4: + message.signingKey = reader.bytes(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + + /** + * Decodes a SenderKeyDistributionMessage message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof groupproto.SenderKeyDistributionMessage + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {groupproto.SenderKeyDistributionMessage} SenderKeyDistributionMessage + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + SenderKeyDistributionMessage.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a SenderKeyDistributionMessage message. + * @function verify + * @memberof groupproto.SenderKeyDistributionMessage + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + SenderKeyDistributionMessage.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.id != null && message.hasOwnProperty("id")) + if (!$util.isInteger(message.id)) + return "id: integer expected"; + if (message.iteration != null && message.hasOwnProperty("iteration")) + if (!$util.isInteger(message.iteration)) + return "iteration: integer expected"; + if (message.chainKey != null && message.hasOwnProperty("chainKey")) + if (!(message.chainKey && typeof message.chainKey.length === "number" || $util.isString(message.chainKey))) + return "chainKey: buffer expected"; + if (message.signingKey != null && message.hasOwnProperty("signingKey")) + if (!(message.signingKey && typeof message.signingKey.length === "number" || $util.isString(message.signingKey))) + return "signingKey: buffer expected"; + return null; + }; + + /** + * Creates a SenderKeyDistributionMessage message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof groupproto.SenderKeyDistributionMessage + * @static + * @param {Object.} object Plain object + * @returns {groupproto.SenderKeyDistributionMessage} SenderKeyDistributionMessage + */ + SenderKeyDistributionMessage.fromObject = function fromObject(object) { + if (object instanceof $root.groupproto.SenderKeyDistributionMessage) + return object; + var message = new $root.groupproto.SenderKeyDistributionMessage(); + if (object.id != null) + message.id = object.id >>> 0; + if (object.iteration != null) + message.iteration = object.iteration >>> 0; + if (object.chainKey != null) + if (typeof object.chainKey === "string") + $util.base64.decode(object.chainKey, message.chainKey = $util.newBuffer($util.base64.length(object.chainKey)), 0); + else if (object.chainKey.length) + message.chainKey = object.chainKey; + if (object.signingKey != null) + if (typeof object.signingKey === "string") + $util.base64.decode(object.signingKey, message.signingKey = $util.newBuffer($util.base64.length(object.signingKey)), 0); + else if (object.signingKey.length) + message.signingKey = object.signingKey; + return message; + }; + + /** + * Creates a plain object from a SenderKeyDistributionMessage message. Also converts values to other types if specified. + * @function toObject + * @memberof groupproto.SenderKeyDistributionMessage + * @static + * @param {groupproto.SenderKeyDistributionMessage} message SenderKeyDistributionMessage + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + SenderKeyDistributionMessage.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.defaults) { + object.id = 0; + object.iteration = 0; + if (options.bytes === String) + object.chainKey = ""; + else { + object.chainKey = []; + if (options.bytes !== Array) + object.chainKey = $util.newBuffer(object.chainKey); + } + if (options.bytes === String) + object.signingKey = ""; + else { + object.signingKey = []; + if (options.bytes !== Array) + object.signingKey = $util.newBuffer(object.signingKey); + } + } + if (message.id != null && message.hasOwnProperty("id")) + object.id = message.id; + if (message.iteration != null && message.hasOwnProperty("iteration")) + object.iteration = message.iteration; + if (message.chainKey != null && message.hasOwnProperty("chainKey")) + object.chainKey = options.bytes === String ? $util.base64.encode(message.chainKey, 0, message.chainKey.length) : options.bytes === Array ? Array.prototype.slice.call(message.chainKey) : message.chainKey; + if (message.signingKey != null && message.hasOwnProperty("signingKey")) + object.signingKey = options.bytes === String ? $util.base64.encode(message.signingKey, 0, message.signingKey.length) : options.bytes === Array ? Array.prototype.slice.call(message.signingKey) : message.signingKey; + return object; + }; + + /** + * Converts this SenderKeyDistributionMessage to JSON. + * @function toJSON + * @memberof groupproto.SenderKeyDistributionMessage + * @instance + * @returns {Object.} JSON object + */ + SenderKeyDistributionMessage.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return SenderKeyDistributionMessage; + })(); + + groupproto.SenderChainKey = (function() { + + /** + * Properties of a SenderChainKey. + * @memberof groupproto + * @interface ISenderChainKey + * @property {number|null} [iteration] SenderChainKey iteration + * @property {Uint8Array|null} [seed] SenderChainKey seed + */ + + /** + * Constructs a new SenderChainKey. + * @memberof groupproto + * @classdesc Represents a SenderChainKey. + * @implements ISenderChainKey + * @constructor + * @param {groupproto.ISenderChainKey=} [properties] Properties to set + */ + function SenderChainKey(properties) { + if (properties) + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + + /** + * SenderChainKey iteration. + * @member {number} iteration + * @memberof groupproto.SenderChainKey + * @instance + */ + SenderChainKey.prototype.iteration = 0; + + /** + * SenderChainKey seed. + * @member {Uint8Array} seed + * @memberof groupproto.SenderChainKey + * @instance + */ + SenderChainKey.prototype.seed = $util.newBuffer([]); + + /** + * Creates a new SenderChainKey instance using the specified properties. + * @function create + * @memberof groupproto.SenderChainKey + * @static + * @param {groupproto.ISenderChainKey=} [properties] Properties to set + * @returns {groupproto.SenderChainKey} SenderChainKey instance + */ + SenderChainKey.create = function create(properties) { + return new SenderChainKey(properties); + }; + + /** + * Encodes the specified SenderChainKey message. Does not implicitly {@link groupproto.SenderChainKey.verify|verify} messages. + * @function encode + * @memberof groupproto.SenderChainKey + * @static + * @param {groupproto.ISenderChainKey} message SenderChainKey message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + SenderChainKey.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.iteration != null && Object.hasOwnProperty.call(message, "iteration")) + writer.uint32(/* id 1, wireType 0 =*/8).uint32(message.iteration); + if (message.seed != null && Object.hasOwnProperty.call(message, "seed")) + writer.uint32(/* id 2, wireType 2 =*/18).bytes(message.seed); + return writer; + }; + + /** + * Encodes the specified SenderChainKey message, length delimited. Does not implicitly {@link groupproto.SenderChainKey.verify|verify} messages. + * @function encodeDelimited + * @memberof groupproto.SenderChainKey + * @static + * @param {groupproto.ISenderChainKey} message SenderChainKey message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + SenderChainKey.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a SenderChainKey message from the specified reader or buffer. + * @function decode + * @memberof groupproto.SenderChainKey + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {groupproto.SenderChainKey} SenderChainKey + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + SenderChainKey.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === undefined ? reader.len : reader.pos + length, message = new $root.groupproto.SenderChainKey(); + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.iteration = reader.uint32(); + break; + case 2: + message.seed = reader.bytes(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + + /** + * Decodes a SenderChainKey message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof groupproto.SenderChainKey + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {groupproto.SenderChainKey} SenderChainKey + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + SenderChainKey.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a SenderChainKey message. + * @function verify + * @memberof groupproto.SenderChainKey + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + SenderChainKey.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.iteration != null && message.hasOwnProperty("iteration")) + if (!$util.isInteger(message.iteration)) + return "iteration: integer expected"; + if (message.seed != null && message.hasOwnProperty("seed")) + if (!(message.seed && typeof message.seed.length === "number" || $util.isString(message.seed))) + return "seed: buffer expected"; + return null; + }; + + /** + * Creates a SenderChainKey message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof groupproto.SenderChainKey + * @static + * @param {Object.} object Plain object + * @returns {groupproto.SenderChainKey} SenderChainKey + */ + SenderChainKey.fromObject = function fromObject(object) { + if (object instanceof $root.groupproto.SenderChainKey) + return object; + var message = new $root.groupproto.SenderChainKey(); + if (object.iteration != null) + message.iteration = object.iteration >>> 0; + if (object.seed != null) + if (typeof object.seed === "string") + $util.base64.decode(object.seed, message.seed = $util.newBuffer($util.base64.length(object.seed)), 0); + else if (object.seed.length) + message.seed = object.seed; + return message; + }; + + /** + * Creates a plain object from a SenderChainKey message. Also converts values to other types if specified. + * @function toObject + * @memberof groupproto.SenderChainKey + * @static + * @param {groupproto.SenderChainKey} message SenderChainKey + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + SenderChainKey.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.defaults) { + object.iteration = 0; + if (options.bytes === String) + object.seed = ""; + else { + object.seed = []; + if (options.bytes !== Array) + object.seed = $util.newBuffer(object.seed); + } + } + if (message.iteration != null && message.hasOwnProperty("iteration")) + object.iteration = message.iteration; + if (message.seed != null && message.hasOwnProperty("seed")) + object.seed = options.bytes === String ? $util.base64.encode(message.seed, 0, message.seed.length) : options.bytes === Array ? Array.prototype.slice.call(message.seed) : message.seed; + return object; + }; + + /** + * Converts this SenderChainKey to JSON. + * @function toJSON + * @memberof groupproto.SenderChainKey + * @instance + * @returns {Object.} JSON object + */ + SenderChainKey.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return SenderChainKey; + })(); + + groupproto.SenderMessageKey = (function() { + + /** + * Properties of a SenderMessageKey. + * @memberof groupproto + * @interface ISenderMessageKey + * @property {number|null} [iteration] SenderMessageKey iteration + * @property {Uint8Array|null} [seed] SenderMessageKey seed + */ + + /** + * Constructs a new SenderMessageKey. + * @memberof groupproto + * @classdesc Represents a SenderMessageKey. + * @implements ISenderMessageKey + * @constructor + * @param {groupproto.ISenderMessageKey=} [properties] Properties to set + */ + function SenderMessageKey(properties) { + if (properties) + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + + /** + * SenderMessageKey iteration. + * @member {number} iteration + * @memberof groupproto.SenderMessageKey + * @instance + */ + SenderMessageKey.prototype.iteration = 0; + + /** + * SenderMessageKey seed. + * @member {Uint8Array} seed + * @memberof groupproto.SenderMessageKey + * @instance + */ + SenderMessageKey.prototype.seed = $util.newBuffer([]); + + /** + * Creates a new SenderMessageKey instance using the specified properties. + * @function create + * @memberof groupproto.SenderMessageKey + * @static + * @param {groupproto.ISenderMessageKey=} [properties] Properties to set + * @returns {groupproto.SenderMessageKey} SenderMessageKey instance + */ + SenderMessageKey.create = function create(properties) { + return new SenderMessageKey(properties); + }; + + /** + * Encodes the specified SenderMessageKey message. Does not implicitly {@link groupproto.SenderMessageKey.verify|verify} messages. + * @function encode + * @memberof groupproto.SenderMessageKey + * @static + * @param {groupproto.ISenderMessageKey} message SenderMessageKey message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + SenderMessageKey.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.iteration != null && Object.hasOwnProperty.call(message, "iteration")) + writer.uint32(/* id 1, wireType 0 =*/8).uint32(message.iteration); + if (message.seed != null && Object.hasOwnProperty.call(message, "seed")) + writer.uint32(/* id 2, wireType 2 =*/18).bytes(message.seed); + return writer; + }; + + /** + * Encodes the specified SenderMessageKey message, length delimited. Does not implicitly {@link groupproto.SenderMessageKey.verify|verify} messages. + * @function encodeDelimited + * @memberof groupproto.SenderMessageKey + * @static + * @param {groupproto.ISenderMessageKey} message SenderMessageKey message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + SenderMessageKey.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a SenderMessageKey message from the specified reader or buffer. + * @function decode + * @memberof groupproto.SenderMessageKey + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {groupproto.SenderMessageKey} SenderMessageKey + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + SenderMessageKey.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === undefined ? reader.len : reader.pos + length, message = new $root.groupproto.SenderMessageKey(); + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.iteration = reader.uint32(); + break; + case 2: + message.seed = reader.bytes(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + + /** + * Decodes a SenderMessageKey message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof groupproto.SenderMessageKey + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {groupproto.SenderMessageKey} SenderMessageKey + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + SenderMessageKey.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a SenderMessageKey message. + * @function verify + * @memberof groupproto.SenderMessageKey + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + SenderMessageKey.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.iteration != null && message.hasOwnProperty("iteration")) + if (!$util.isInteger(message.iteration)) + return "iteration: integer expected"; + if (message.seed != null && message.hasOwnProperty("seed")) + if (!(message.seed && typeof message.seed.length === "number" || $util.isString(message.seed))) + return "seed: buffer expected"; + return null; + }; + + /** + * Creates a SenderMessageKey message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof groupproto.SenderMessageKey + * @static + * @param {Object.} object Plain object + * @returns {groupproto.SenderMessageKey} SenderMessageKey + */ + SenderMessageKey.fromObject = function fromObject(object) { + if (object instanceof $root.groupproto.SenderMessageKey) + return object; + var message = new $root.groupproto.SenderMessageKey(); + if (object.iteration != null) + message.iteration = object.iteration >>> 0; + if (object.seed != null) + if (typeof object.seed === "string") + $util.base64.decode(object.seed, message.seed = $util.newBuffer($util.base64.length(object.seed)), 0); + else if (object.seed.length) + message.seed = object.seed; + return message; + }; + + /** + * Creates a plain object from a SenderMessageKey message. Also converts values to other types if specified. + * @function toObject + * @memberof groupproto.SenderMessageKey + * @static + * @param {groupproto.SenderMessageKey} message SenderMessageKey + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + SenderMessageKey.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.defaults) { + object.iteration = 0; + if (options.bytes === String) + object.seed = ""; + else { + object.seed = []; + if (options.bytes !== Array) + object.seed = $util.newBuffer(object.seed); + } + } + if (message.iteration != null && message.hasOwnProperty("iteration")) + object.iteration = message.iteration; + if (message.seed != null && message.hasOwnProperty("seed")) + object.seed = options.bytes === String ? $util.base64.encode(message.seed, 0, message.seed.length) : options.bytes === Array ? Array.prototype.slice.call(message.seed) : message.seed; + return object; + }; + + /** + * Converts this SenderMessageKey to JSON. + * @function toJSON + * @memberof groupproto.SenderMessageKey + * @instance + * @returns {Object.} JSON object + */ + SenderMessageKey.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return SenderMessageKey; + })(); + + groupproto.SenderSigningKey = (function() { + + /** + * Properties of a SenderSigningKey. + * @memberof groupproto + * @interface ISenderSigningKey + * @property {Uint8Array|null} ["public"] SenderSigningKey public + * @property {Uint8Array|null} ["private"] SenderSigningKey private + */ + + /** + * Constructs a new SenderSigningKey. + * @memberof groupproto + * @classdesc Represents a SenderSigningKey. + * @implements ISenderSigningKey + * @constructor + * @param {groupproto.ISenderSigningKey=} [properties] Properties to set + */ + function SenderSigningKey(properties) { + if (properties) + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + + /** + * SenderSigningKey public. + * @member {Uint8Array} public + * @memberof groupproto.SenderSigningKey + * @instance + */ + SenderSigningKey.prototype["public"] = $util.newBuffer([]); + + /** + * SenderSigningKey private. + * @member {Uint8Array} private + * @memberof groupproto.SenderSigningKey + * @instance + */ + SenderSigningKey.prototype["private"] = $util.newBuffer([]); + + /** + * Creates a new SenderSigningKey instance using the specified properties. + * @function create + * @memberof groupproto.SenderSigningKey + * @static + * @param {groupproto.ISenderSigningKey=} [properties] Properties to set + * @returns {groupproto.SenderSigningKey} SenderSigningKey instance + */ + SenderSigningKey.create = function create(properties) { + return new SenderSigningKey(properties); + }; + + /** + * Encodes the specified SenderSigningKey message. Does not implicitly {@link groupproto.SenderSigningKey.verify|verify} messages. + * @function encode + * @memberof groupproto.SenderSigningKey + * @static + * @param {groupproto.ISenderSigningKey} message SenderSigningKey message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + SenderSigningKey.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message["public"] != null && Object.hasOwnProperty.call(message, "public")) + writer.uint32(/* id 1, wireType 2 =*/10).bytes(message["public"]); + if (message["private"] != null && Object.hasOwnProperty.call(message, "private")) + writer.uint32(/* id 2, wireType 2 =*/18).bytes(message["private"]); + return writer; + }; + + /** + * Encodes the specified SenderSigningKey message, length delimited. Does not implicitly {@link groupproto.SenderSigningKey.verify|verify} messages. + * @function encodeDelimited + * @memberof groupproto.SenderSigningKey + * @static + * @param {groupproto.ISenderSigningKey} message SenderSigningKey message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + SenderSigningKey.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a SenderSigningKey message from the specified reader or buffer. + * @function decode + * @memberof groupproto.SenderSigningKey + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {groupproto.SenderSigningKey} SenderSigningKey + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + SenderSigningKey.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === undefined ? reader.len : reader.pos + length, message = new $root.groupproto.SenderSigningKey(); + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message["public"] = reader.bytes(); + break; + case 2: + message["private"] = reader.bytes(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + + /** + * Decodes a SenderSigningKey message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof groupproto.SenderSigningKey + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {groupproto.SenderSigningKey} SenderSigningKey + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + SenderSigningKey.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a SenderSigningKey message. + * @function verify + * @memberof groupproto.SenderSigningKey + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + SenderSigningKey.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message["public"] != null && message.hasOwnProperty("public")) + if (!(message["public"] && typeof message["public"].length === "number" || $util.isString(message["public"]))) + return "public: buffer expected"; + if (message["private"] != null && message.hasOwnProperty("private")) + if (!(message["private"] && typeof message["private"].length === "number" || $util.isString(message["private"]))) + return "private: buffer expected"; + return null; + }; + + /** + * Creates a SenderSigningKey message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof groupproto.SenderSigningKey + * @static + * @param {Object.} object Plain object + * @returns {groupproto.SenderSigningKey} SenderSigningKey + */ + SenderSigningKey.fromObject = function fromObject(object) { + if (object instanceof $root.groupproto.SenderSigningKey) + return object; + var message = new $root.groupproto.SenderSigningKey(); + if (object["public"] != null) + if (typeof object["public"] === "string") + $util.base64.decode(object["public"], message["public"] = $util.newBuffer($util.base64.length(object["public"])), 0); + else if (object["public"].length) + message["public"] = object["public"]; + if (object["private"] != null) + if (typeof object["private"] === "string") + $util.base64.decode(object["private"], message["private"] = $util.newBuffer($util.base64.length(object["private"])), 0); + else if (object["private"].length) + message["private"] = object["private"]; + return message; + }; + + /** + * Creates a plain object from a SenderSigningKey message. Also converts values to other types if specified. + * @function toObject + * @memberof groupproto.SenderSigningKey + * @static + * @param {groupproto.SenderSigningKey} message SenderSigningKey + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + SenderSigningKey.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.defaults) { + if (options.bytes === String) + object["public"] = ""; + else { + object["public"] = []; + if (options.bytes !== Array) + object["public"] = $util.newBuffer(object["public"]); + } + if (options.bytes === String) + object["private"] = ""; + else { + object["private"] = []; + if (options.bytes !== Array) + object["private"] = $util.newBuffer(object["private"]); + } + } + if (message["public"] != null && message.hasOwnProperty("public")) + object["public"] = options.bytes === String ? $util.base64.encode(message["public"], 0, message["public"].length) : options.bytes === Array ? Array.prototype.slice.call(message["public"]) : message["public"]; + if (message["private"] != null && message.hasOwnProperty("private")) + object["private"] = options.bytes === String ? $util.base64.encode(message["private"], 0, message["private"].length) : options.bytes === Array ? Array.prototype.slice.call(message["private"]) : message["private"]; + return object; + }; + + /** + * Converts this SenderSigningKey to JSON. + * @function toJSON + * @memberof groupproto.SenderSigningKey + * @instance + * @returns {Object.} JSON object + */ + SenderSigningKey.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return SenderSigningKey; + })(); + + groupproto.SenderKeyStateStructure = (function() { + + /** + * Properties of a SenderKeyStateStructure. + * @memberof groupproto + * @interface ISenderKeyStateStructure + * @property {number|null} [senderKeyId] SenderKeyStateStructure senderKeyId + * @property {groupproto.ISenderChainKey|null} [senderChainKey] SenderKeyStateStructure senderChainKey + * @property {groupproto.ISenderSigningKey|null} [senderSigningKey] SenderKeyStateStructure senderSigningKey + * @property {Array.|null} [senderMessageKeys] SenderKeyStateStructure senderMessageKeys + */ + + /** + * Constructs a new SenderKeyStateStructure. + * @memberof groupproto + * @classdesc Represents a SenderKeyStateStructure. + * @implements ISenderKeyStateStructure + * @constructor + * @param {groupproto.ISenderKeyStateStructure=} [properties] Properties to set + */ + function SenderKeyStateStructure(properties) { + this.senderMessageKeys = []; + if (properties) + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + + /** + * SenderKeyStateStructure senderKeyId. + * @member {number} senderKeyId + * @memberof groupproto.SenderKeyStateStructure + * @instance + */ + SenderKeyStateStructure.prototype.senderKeyId = 0; + + /** + * SenderKeyStateStructure senderChainKey. + * @member {groupproto.ISenderChainKey|null|undefined} senderChainKey + * @memberof groupproto.SenderKeyStateStructure + * @instance + */ + SenderKeyStateStructure.prototype.senderChainKey = null; + + /** + * SenderKeyStateStructure senderSigningKey. + * @member {groupproto.ISenderSigningKey|null|undefined} senderSigningKey + * @memberof groupproto.SenderKeyStateStructure + * @instance + */ + SenderKeyStateStructure.prototype.senderSigningKey = null; + + /** + * SenderKeyStateStructure senderMessageKeys. + * @member {Array.} senderMessageKeys + * @memberof groupproto.SenderKeyStateStructure + * @instance + */ + SenderKeyStateStructure.prototype.senderMessageKeys = $util.emptyArray; + + /** + * Creates a new SenderKeyStateStructure instance using the specified properties. + * @function create + * @memberof groupproto.SenderKeyStateStructure + * @static + * @param {groupproto.ISenderKeyStateStructure=} [properties] Properties to set + * @returns {groupproto.SenderKeyStateStructure} SenderKeyStateStructure instance + */ + SenderKeyStateStructure.create = function create(properties) { + return new SenderKeyStateStructure(properties); + }; + + /** + * Encodes the specified SenderKeyStateStructure message. Does not implicitly {@link groupproto.SenderKeyStateStructure.verify|verify} messages. + * @function encode + * @memberof groupproto.SenderKeyStateStructure + * @static + * @param {groupproto.ISenderKeyStateStructure} message SenderKeyStateStructure message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + SenderKeyStateStructure.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.senderKeyId != null && Object.hasOwnProperty.call(message, "senderKeyId")) + writer.uint32(/* id 1, wireType 0 =*/8).uint32(message.senderKeyId); + if (message.senderChainKey != null && Object.hasOwnProperty.call(message, "senderChainKey")) + $root.groupproto.SenderChainKey.encode(message.senderChainKey, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim(); + if (message.senderSigningKey != null && Object.hasOwnProperty.call(message, "senderSigningKey")) + $root.groupproto.SenderSigningKey.encode(message.senderSigningKey, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim(); + if (message.senderMessageKeys != null && message.senderMessageKeys.length) + for (var i = 0; i < message.senderMessageKeys.length; ++i) + $root.groupproto.SenderMessageKey.encode(message.senderMessageKeys[i], writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim(); + return writer; + }; + + /** + * Encodes the specified SenderKeyStateStructure message, length delimited. Does not implicitly {@link groupproto.SenderKeyStateStructure.verify|verify} messages. + * @function encodeDelimited + * @memberof groupproto.SenderKeyStateStructure + * @static + * @param {groupproto.ISenderKeyStateStructure} message SenderKeyStateStructure message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + SenderKeyStateStructure.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a SenderKeyStateStructure message from the specified reader or buffer. + * @function decode + * @memberof groupproto.SenderKeyStateStructure + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {groupproto.SenderKeyStateStructure} SenderKeyStateStructure + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + SenderKeyStateStructure.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === undefined ? reader.len : reader.pos + length, message = new $root.groupproto.SenderKeyStateStructure(); + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.senderKeyId = reader.uint32(); + break; + case 2: + message.senderChainKey = $root.groupproto.SenderChainKey.decode(reader, reader.uint32()); + break; + case 3: + message.senderSigningKey = $root.groupproto.SenderSigningKey.decode(reader, reader.uint32()); + break; + case 4: + if (!(message.senderMessageKeys && message.senderMessageKeys.length)) + message.senderMessageKeys = []; + message.senderMessageKeys.push($root.groupproto.SenderMessageKey.decode(reader, reader.uint32())); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + + /** + * Decodes a SenderKeyStateStructure message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof groupproto.SenderKeyStateStructure + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {groupproto.SenderKeyStateStructure} SenderKeyStateStructure + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + SenderKeyStateStructure.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a SenderKeyStateStructure message. + * @function verify + * @memberof groupproto.SenderKeyStateStructure + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + SenderKeyStateStructure.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.senderKeyId != null && message.hasOwnProperty("senderKeyId")) + if (!$util.isInteger(message.senderKeyId)) + return "senderKeyId: integer expected"; + if (message.senderChainKey != null && message.hasOwnProperty("senderChainKey")) { + var error = $root.groupproto.SenderChainKey.verify(message.senderChainKey); + if (error) + return "senderChainKey." + error; + } + if (message.senderSigningKey != null && message.hasOwnProperty("senderSigningKey")) { + var error = $root.groupproto.SenderSigningKey.verify(message.senderSigningKey); + if (error) + return "senderSigningKey." + error; + } + if (message.senderMessageKeys != null && message.hasOwnProperty("senderMessageKeys")) { + if (!Array.isArray(message.senderMessageKeys)) + return "senderMessageKeys: array expected"; + for (var i = 0; i < message.senderMessageKeys.length; ++i) { + var error = $root.groupproto.SenderMessageKey.verify(message.senderMessageKeys[i]); + if (error) + return "senderMessageKeys." + error; + } + } + return null; + }; + + /** + * Creates a SenderKeyStateStructure message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof groupproto.SenderKeyStateStructure + * @static + * @param {Object.} object Plain object + * @returns {groupproto.SenderKeyStateStructure} SenderKeyStateStructure + */ + SenderKeyStateStructure.fromObject = function fromObject(object) { + if (object instanceof $root.groupproto.SenderKeyStateStructure) + return object; + var message = new $root.groupproto.SenderKeyStateStructure(); + if (object.senderKeyId != null) + message.senderKeyId = object.senderKeyId >>> 0; + if (object.senderChainKey != null) { + if (typeof object.senderChainKey !== "object") + throw TypeError(".groupproto.SenderKeyStateStructure.senderChainKey: object expected"); + message.senderChainKey = $root.groupproto.SenderChainKey.fromObject(object.senderChainKey); + } + if (object.senderSigningKey != null) { + if (typeof object.senderSigningKey !== "object") + throw TypeError(".groupproto.SenderKeyStateStructure.senderSigningKey: object expected"); + message.senderSigningKey = $root.groupproto.SenderSigningKey.fromObject(object.senderSigningKey); + } + if (object.senderMessageKeys) { + if (!Array.isArray(object.senderMessageKeys)) + throw TypeError(".groupproto.SenderKeyStateStructure.senderMessageKeys: array expected"); + message.senderMessageKeys = []; + for (var i = 0; i < object.senderMessageKeys.length; ++i) { + if (typeof object.senderMessageKeys[i] !== "object") + throw TypeError(".groupproto.SenderKeyStateStructure.senderMessageKeys: object expected"); + message.senderMessageKeys[i] = $root.groupproto.SenderMessageKey.fromObject(object.senderMessageKeys[i]); + } + } + return message; + }; + + /** + * Creates a plain object from a SenderKeyStateStructure message. Also converts values to other types if specified. + * @function toObject + * @memberof groupproto.SenderKeyStateStructure + * @static + * @param {groupproto.SenderKeyStateStructure} message SenderKeyStateStructure + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + SenderKeyStateStructure.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.arrays || options.defaults) + object.senderMessageKeys = []; + if (options.defaults) { + object.senderKeyId = 0; + object.senderChainKey = null; + object.senderSigningKey = null; + } + if (message.senderKeyId != null && message.hasOwnProperty("senderKeyId")) + object.senderKeyId = message.senderKeyId; + if (message.senderChainKey != null && message.hasOwnProperty("senderChainKey")) + object.senderChainKey = $root.groupproto.SenderChainKey.toObject(message.senderChainKey, options); + if (message.senderSigningKey != null && message.hasOwnProperty("senderSigningKey")) + object.senderSigningKey = $root.groupproto.SenderSigningKey.toObject(message.senderSigningKey, options); + if (message.senderMessageKeys && message.senderMessageKeys.length) { + object.senderMessageKeys = []; + for (var j = 0; j < message.senderMessageKeys.length; ++j) + object.senderMessageKeys[j] = $root.groupproto.SenderMessageKey.toObject(message.senderMessageKeys[j], options); + } + return object; + }; + + /** + * Converts this SenderKeyStateStructure to JSON. + * @function toJSON + * @memberof groupproto.SenderKeyStateStructure + * @instance + * @returns {Object.} JSON object + */ + SenderKeyStateStructure.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return SenderKeyStateStructure; + })(); + + groupproto.SenderKeyRecordStructure = (function() { + + /** + * Properties of a SenderKeyRecordStructure. + * @memberof groupproto + * @interface ISenderKeyRecordStructure + * @property {Array.|null} [senderKeyStates] SenderKeyRecordStructure senderKeyStates + */ + + /** + * Constructs a new SenderKeyRecordStructure. + * @memberof groupproto + * @classdesc Represents a SenderKeyRecordStructure. + * @implements ISenderKeyRecordStructure + * @constructor + * @param {groupproto.ISenderKeyRecordStructure=} [properties] Properties to set + */ + function SenderKeyRecordStructure(properties) { + this.senderKeyStates = []; + if (properties) + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + + /** + * SenderKeyRecordStructure senderKeyStates. + * @member {Array.} senderKeyStates + * @memberof groupproto.SenderKeyRecordStructure + * @instance + */ + SenderKeyRecordStructure.prototype.senderKeyStates = $util.emptyArray; + + /** + * Creates a new SenderKeyRecordStructure instance using the specified properties. + * @function create + * @memberof groupproto.SenderKeyRecordStructure + * @static + * @param {groupproto.ISenderKeyRecordStructure=} [properties] Properties to set + * @returns {groupproto.SenderKeyRecordStructure} SenderKeyRecordStructure instance + */ + SenderKeyRecordStructure.create = function create(properties) { + return new SenderKeyRecordStructure(properties); + }; + + /** + * Encodes the specified SenderKeyRecordStructure message. Does not implicitly {@link groupproto.SenderKeyRecordStructure.verify|verify} messages. + * @function encode + * @memberof groupproto.SenderKeyRecordStructure + * @static + * @param {groupproto.ISenderKeyRecordStructure} message SenderKeyRecordStructure message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + SenderKeyRecordStructure.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + if (message.senderKeyStates != null && message.senderKeyStates.length) + for (var i = 0; i < message.senderKeyStates.length; ++i) + $root.groupproto.SenderKeyStateStructure.encode(message.senderKeyStates[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); + return writer; + }; + + /** + * Encodes the specified SenderKeyRecordStructure message, length delimited. Does not implicitly {@link groupproto.SenderKeyRecordStructure.verify|verify} messages. + * @function encodeDelimited + * @memberof groupproto.SenderKeyRecordStructure + * @static + * @param {groupproto.ISenderKeyRecordStructure} message SenderKeyRecordStructure message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + SenderKeyRecordStructure.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a SenderKeyRecordStructure message from the specified reader or buffer. + * @function decode + * @memberof groupproto.SenderKeyRecordStructure + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {groupproto.SenderKeyRecordStructure} SenderKeyRecordStructure + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + SenderKeyRecordStructure.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === undefined ? reader.len : reader.pos + length, message = new $root.groupproto.SenderKeyRecordStructure(); + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + if (!(message.senderKeyStates && message.senderKeyStates.length)) + message.senderKeyStates = []; + message.senderKeyStates.push($root.groupproto.SenderKeyStateStructure.decode(reader, reader.uint32())); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }; + + /** + * Decodes a SenderKeyRecordStructure message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof groupproto.SenderKeyRecordStructure + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {groupproto.SenderKeyRecordStructure} SenderKeyRecordStructure + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + SenderKeyRecordStructure.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a SenderKeyRecordStructure message. + * @function verify + * @memberof groupproto.SenderKeyRecordStructure + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + SenderKeyRecordStructure.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (message.senderKeyStates != null && message.hasOwnProperty("senderKeyStates")) { + if (!Array.isArray(message.senderKeyStates)) + return "senderKeyStates: array expected"; + for (var i = 0; i < message.senderKeyStates.length; ++i) { + var error = $root.groupproto.SenderKeyStateStructure.verify(message.senderKeyStates[i]); + if (error) + return "senderKeyStates." + error; + } + } + return null; + }; + + /** + * Creates a SenderKeyRecordStructure message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof groupproto.SenderKeyRecordStructure + * @static + * @param {Object.} object Plain object + * @returns {groupproto.SenderKeyRecordStructure} SenderKeyRecordStructure + */ + SenderKeyRecordStructure.fromObject = function fromObject(object) { + if (object instanceof $root.groupproto.SenderKeyRecordStructure) + return object; + var message = new $root.groupproto.SenderKeyRecordStructure(); + if (object.senderKeyStates) { + if (!Array.isArray(object.senderKeyStates)) + throw TypeError(".groupproto.SenderKeyRecordStructure.senderKeyStates: array expected"); + message.senderKeyStates = []; + for (var i = 0; i < object.senderKeyStates.length; ++i) { + if (typeof object.senderKeyStates[i] !== "object") + throw TypeError(".groupproto.SenderKeyRecordStructure.senderKeyStates: object expected"); + message.senderKeyStates[i] = $root.groupproto.SenderKeyStateStructure.fromObject(object.senderKeyStates[i]); + } + } + return message; + }; + + /** + * Creates a plain object from a SenderKeyRecordStructure message. Also converts values to other types if specified. + * @function toObject + * @memberof groupproto.SenderKeyRecordStructure + * @static + * @param {groupproto.SenderKeyRecordStructure} message SenderKeyRecordStructure + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + SenderKeyRecordStructure.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.arrays || options.defaults) + object.senderKeyStates = []; + if (message.senderKeyStates && message.senderKeyStates.length) { + object.senderKeyStates = []; + for (var j = 0; j < message.senderKeyStates.length; ++j) + object.senderKeyStates[j] = $root.groupproto.SenderKeyStateStructure.toObject(message.senderKeyStates[j], options); + } + return object; + }; + + /** + * Converts this SenderKeyRecordStructure to JSON. + * @function toJSON + * @memberof groupproto.SenderKeyRecordStructure + * @instance + * @returns {Object.} JSON object + */ + SenderKeyRecordStructure.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return SenderKeyRecordStructure; + })(); + + return groupproto; +})(); + +module.exports = $root; diff --git a/WASignalGroup/generate-proto.sh b/WASignalGroup/generate-proto.sh new file mode 100644 index 0000000..051876d --- /dev/null +++ b/WASignalGroup/generate-proto.sh @@ -0,0 +1 @@ +yarn pbjs -t static-module -w commonjs -o ./WASignalGroup/GroupProtocol.js ./WASignalGroup/group.proto \ No newline at end of file diff --git a/WASignalGroup/group.proto b/WASignalGroup/group.proto index a83c11e..e6f549b 100644 --- a/WASignalGroup/group.proto +++ b/WASignalGroup/group.proto @@ -13,22 +13,23 @@ message SenderKeyMessage { optional bytes signingKey = 4; } + message SenderChainKey { + optional uint32 iteration = 1; + optional bytes seed = 2; +} + +message SenderMessageKey { + optional uint32 iteration = 1; + optional bytes seed = 2; +} + +message SenderSigningKey { + optional bytes public = 1; + optional bytes private = 2; +} message SenderKeyStateStructure { - message SenderChainKey { - optional uint32 iteration = 1; - optional bytes seed = 2; - } - - message SenderMessageKey { - optional uint32 iteration = 1; - optional bytes seed = 2; - } - - message SenderSigningKey { - optional bytes public = 1; - optional bytes private = 2; - } + optional uint32 senderKeyId = 1; optional SenderChainKey senderChainKey = 2; diff --git a/WASignalGroup/protobufs.js b/WASignalGroup/protobufs.js index 797bd73..76daa5c 100644 --- a/WASignalGroup/protobufs.js +++ b/WASignalGroup/protobufs.js @@ -1,13 +1,3 @@ -const path = require('path'); -const protobuf = require('protobufjs'); +const { groupproto } = require('./GroupProtocol') -const protodir = path.resolve(__dirname); -const group = protobuf.loadSync(path.join(protodir, 'group.proto')).lookup('groupproto'); - -module.exports = { - SenderKeyDistributionMessage: group.lookup('SenderKeyDistributionMessage'), - SenderKeyMessage: group.lookup('SenderKeyMessage'), - SenderKeyStateStructure: group.lookup('SenderKeyStateStructure'), - SenderChainKey: group.lookup('SenderChainKey'), - SenderSigningKey: group.lookup('SenderSigningKey'), -}; +module.exports = groupproto \ No newline at end of file diff --git a/package.json b/package.json index 6c0a9f7..5832a0e 100644 --- a/package.json +++ b/package.json @@ -17,7 +17,7 @@ "multi-device" ], "scripts": { - "test": "mocha --timeout 240000 -r ts-node/register src/Tests/Tests.*.ts", + "test": "jest", "prepare": "tsc", "lint": "eslint '*/*.ts' --quiet --fix", "build:all": "tsc && typedoc", @@ -34,9 +34,10 @@ }, "dependencies": { "@hapi/boom": "^9.1.3", + "curve25519-js": "^0.0.4", "got": "^11.8.1", "jimp": "^0.16.1", - "libsignal": "^2.0.1", + "libsignal": "git+https://github.com/adiwajshing/libsignal-node", "music-metadata": "^7.4.1", "pino": "^6.7.0", "protobufjs": "^6.10.1", @@ -48,8 +49,8 @@ "files": [ "lib/*", "WAProto/*", - "WASignalGroup/*", - "WABinary/*" + "WASignalGroup/*.js", + "WABinary/*.js" ], "devDependencies": { "@types/got": "^9.6.11", diff --git a/src/Utils/crypto.ts b/src/Utils/crypto.ts index 02e8f08..babffd0 100644 --- a/src/Utils/crypto.ts +++ b/src/Utils/crypto.ts @@ -1,32 +1,24 @@ -import CurveCrypto from 'libsignal/src/curve25519_wrapper' +import * as curveJs from 'curve25519-js' import { createCipheriv, createDecipheriv, createHash, createHmac, randomBytes } from 'crypto' import { KeyPair } from '../Types' export const Curve = { generateKeyPair: (): KeyPair => { - const { pubKey, privKey } = CurveCrypto.keyPair(randomBytes(32)) + const { public: pubKey, private: privKey } = curveJs.generateKeyPair(randomBytes(32)) return { private: Buffer.from(privKey), public: Buffer.from(pubKey) } }, sharedKey: (privateKey: Uint8Array, publicKey: Uint8Array) => { - const shared = CurveCrypto.sharedSecret(publicKey, privateKey) + const shared = curveJs.sharedKey(privateKey, publicKey) return Buffer.from(shared) }, sign: (privateKey: Uint8Array, buf: Uint8Array) => ( - Buffer.from(CurveCrypto.sign(privateKey, buf)) + Buffer.from(curveJs.sign(privateKey, buf, null)) ), verify: (pubKey: Uint8Array, message: Uint8Array, signature: Uint8Array) => { - try { - CurveCrypto.verify(pubKey, message, signature) - return true - } catch(error) { - if(error.message.includes('Invalid')) { - return false - } - throw error - } + return curveJs.verify(pubKey, message, signature) } } diff --git a/yarn.lock b/yarn.lock index 42d1dd5..48b2201 100644 --- a/yarn.lock +++ b/yarn.lock @@ -1570,6 +1570,11 @@ cssstyle@^2.3.0: dependencies: cssom "~0.3.6" +curve25519-js@^0.0.4: + version "0.0.4" + resolved "https://registry.yarnpkg.com/curve25519-js/-/curve25519-js-0.0.4.tgz#e6ad967e8cd284590d657bbfc90d8b50e49ba060" + integrity sha512-axn2UMEnkhyDUPWOwVKBMVIzSQy2ejH2xRGy1wq81dqRwApXfIzfbE3hIX0ZRFBIihf/KDqK158DLwESu4AK1w== + data-urls@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/data-urls/-/data-urls-2.0.0.tgz#156485a72963a970f5d5821aaf642bef2bf2db9b" @@ -2698,11 +2703,11 @@ levn@~0.3.0: prelude-ls "~1.1.2" type-check "~0.3.2" -libsignal@^2.0.1: +"libsignal@git+https://github.com/adiwajshing/libsignal-node": version "2.0.1" - resolved "https://registry.yarnpkg.com/libsignal/-/libsignal-2.0.1.tgz#c276025c184ae4ebbd7d75c12c0be9f3b50cc19e" - integrity sha512-kqdl/BK5i0WCa4NxhtiBsjSzztB/FtUp3mVVLKBFicWH8rDsq95tEIqNcCaVlflLxOm6T/HRb/zv8IsCe7aopA== + resolved "git+https://github.com/adiwajshing/libsignal-node#11de21293c352a57d0c25d29c66963029873d953" dependencies: + curve25519-js "^0.0.4" protobufjs "6.8.8" load-bmfont@^1.3.1, load-bmfont@^1.4.0: