pairnet 0.2.0 → 0.2.2

package/index.js

@@ -33,6 +33,7 @@ const requireEither = require("@validatem/require-either");
 const either = require("@validatem/either");
 const arrayOf = require("@validatem/array-of");
 const allowExtraProperties = require("@validatem/allow-extra-properties");
+const isPlainObject = require("@validatem/is-plain-object");
 const isFunction = require("@validatem/is-function");
 const isBuffer = require("@validatem/is-buffer");
 const isBoolean = require("@validatem/is-boolean");
@@ -143,12 +144,11 @@ module.exports = {
 			};
 		}
 
-		async function makeRawPairingToken() {
+		async function makeRawPairingToken(data) {
 			let token = generatePairingToken();
 			// TODO: Expiry
-			// TODO: Allow data to be associated with the token?
-			await store.setValidPairingToken(token);
-			debug(`[generatePairingToken] Generated pairing token ${token}`);
+			await store.setValidPairingToken(token, data ?? {});
+			debug(`[generatePairingToken] Generated pairing token ${token}`); // TODO: log associated data?
 			return token;
 		}
 
@@ -246,11 +246,21 @@ module.exports = {
 	
 		return {
 			fingerprint: identity.fingerprint,
+			getPeerData: async function (fingerprint) {
+				let storedData = await store.getPeerData(fingerprint);
+				
+				if (storedData === NotSet) {
+					throw new Error(`Specified fingerprint is not known, cannot retrieve peer data`);
+				} else {
+					return storedData;
+				}
+			},
 			generatePairingToken: async function (_port, _options) {
-				let [ port, { compact }] = validateArguments(arguments, {
+				let [ port, { compact, data }] = validateArguments(arguments, {
 					port: [ required, isPortNumber ],
 					options: [ defaultTo({}), {
-						compact: [ defaultTo(false), isBoolean ]
+						compact: [ defaultTo(false), isBoolean ],
+						data: [ defaultTo({}), isPlainObject ],
 					}]
 				});
 
@@ -261,7 +271,7 @@ module.exports = {
 						? reduceAddresses(ips.all)
 						: ips.all,
 					port: port,
-					rawToken: await makeRawPairingToken(),
+					rawToken: await makeRawPairingToken(data),
 					fingerprint: identity.fingerprint,
 				});
 			},
@@ -314,12 +324,13 @@ module.exports = {
 				});
 			},
 			createServer: async function (_option) {
-				let { hostname, port, onConnect, onDisconnect, onQuery } = validateOptions(arguments, {
+				let { hostname, port, onConnect, onDisconnect, onQuery, onPaired } = validateOptions(arguments, {
 					hostname: [ isNonEmptyString ], /* undefined == listen on all public interfaces */
 					port: [ required, isPortNumber ],
 					onConnect: [ required, isFunction ],
 					onDisconnect: [ isFunction ],
-					onQuery: [ required, isFunction ]
+					onQuery: [ required, isFunction ],
+					onPaired: [ isFunction ]
 				});
 
 				if (protocolConfiguration.isServer) {
@@ -358,8 +369,10 @@ module.exports = {
 											let { token } = query;
 			
 											if (await store.isValidPairingToken(token) === true) {
-												await store.trustPeer(clientFingerprint, { /* FIXME */ });
-												await store.removeValidPairingToken(token);
+												// TODO: What happens if a client chooses to remain connected after pairing? Can this possibility result in any security issues?
+												let data = await store.removeValidPairingToken(token);
+												await store.trustPeer(clientFingerprint, { data });
+												await onPaired?.(clientFingerprint);
 												return true;
 											} else {
 												// TODO: Force disconnect?

package/lib/storages/file.js

@@ -29,7 +29,7 @@ module.exports = async function createFileStorage(folder) {
 		},
 		get: async function (key) {
 			try {
-				return fs.readFile(path.join(folder, safeName(key)));
+				return await fs.readFile(path.join(folder, safeName(key)));
 			} catch (error) {
 				if (error.code === "ENOENT") {
 					return NotSet;

package/lib/store.js

@@ -1,5 +1,6 @@
 "use strict";
 
+const assert = require("node:assert");
 const { NotSet } = require("./storages/symbols");
 
 module.exports = function (storage) {
@@ -12,13 +13,17 @@ module.exports = function (storage) {
 			return storage.set("pairnet_identity", identity);
 		},
 		isValidPairingToken: async function (token) {
-			return (await storage.get(`pairnet_token_${token.toString("hex")}`) === true);
+			return (await storage.get(`pairnet_token_${token.toString("hex")}`) !== NotSet);
 		},
-		setValidPairingToken: async function (token) {
-			return storage.set(`pairnet_token_${token.toString("hex")}`, true);
+		setValidPairingToken: async function (token, data) {
+			assert(data != null);
+			return storage.set(`pairnet_token_${token.toString("hex")}`, data);
 		},
 		removeValidPairingToken: async function (token) {
-			return storage.delete(`pairnet_token_${token.toString("hex")}`);
+			let key = `pairnet_token_${token.toString("hex")}`;
+			let data = storage.get(key);
+			await storage.delete(key);
+			return data;
 		},
 		trustPeer: async function (fingerprint, data) {
 			return storage.set(`pairnet_peer_${fingerprint}`, data ?? {});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pairnet",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "",
   "main": "index.js",
   "keywords": [],
@@ -27,6 +27,7 @@
     "@validatem/is-buffer": "^0.1.1",
     "@validatem/is-function": "^0.1.0",
     "@validatem/is-non-empty-string": "^0.1.1",
+    "@validatem/is-plain-object": "^0.1.1",
     "@validatem/is-port-number": "^1.0.0",
     "@validatem/require-either": "^0.1.0",
     "@validatem/required": "^0.1.1",

package/test/index.js

@@ -51,17 +51,21 @@ async function makePeer(overrides) {
 test("full procedure", async (t) => {
 	let peer1 = await makePeer();
 	let peer2 = await makePeer();
+	let pairedFingerprint;
 
 	let server = await peer1.createServer({
 		hostname: "localhost", port: 4005,
 		onQuery: (fingerprint, query) => ({ number: query.number * 2, hasFingerprint: (fingerprint != null) }),
 		onConnect: async (peer) => {
 			yeetStream(peer.eventStream);
+		},
+		onPaired: async (fingerprint) => {
+			pairedFingerprint = fingerprint;
 		}
 	});
 
 	// let token = await peer1.generatePairingToken(4005);
-	let rawToken = await peer1.generateRawPairingToken();
+	let rawToken = await peer1.generateRawPairingToken({ foo: "bar" });
 
 	await t.test("fails on wrong fingerprint", { timeout: 500 }, async () => {
 		await assert.rejects(async () => {
@@ -85,6 +89,9 @@ test("full procedure", async (t) => {
 			await peer.disconnect();
 			// FIXME: Test query error reply
 		});
+
+		assert.strictEqual(pairedFingerprint, peer2.fingerprint);
+		assert.deepStrictEqual(await peer1.getPeerData(peer2.fingerprint), { data: { foo: "bar" }});
 	});
 
 	await server.stop();
@@ -105,8 +112,9 @@ test("full procedure with wrapped token", async (t) => {
 	let fingerprint;
 
 	await t.test("pair", { timeout: 500 }, async () => {
-		let token = await peer1.generatePairingToken(4005);
+		let token = await peer1.generatePairingToken(4005, { data: { foo: "bar" }});
 		fingerprint = await peer2.pair(token);
+		assert.deepStrictEqual(await peer1.getPeerData(peer2.fingerprint), { data: { foo: "bar" }});
 	});
 
 	await t.test("connect", { timeout: 500 }, async () => {