feat: implement bloop version 4 protocol

BREAKING CHANGE: This will require a client implementing version 4 of the bloop
protocol.

Author: DASPRiD

.eslintrc.json

@@ -1,6 +1,6 @@
 {
     "extends": "eslint-config-dasprid",
     "parserOptions": {
-        "project": "tsconfig.eslint.json"
+        "project": "tsconfig.json"
     }
 }

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2022, Bloop Box
+Copyright (c) 2023, Bloop Box
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

package-lock.json

@@ -26,20 +26,21 @@
     "Typescript"
   ],
   "devDependencies": {
-    "@commitlint/cli": "^17.3.0",
-    "@commitlint/config-conventional": "^17.3.0",
-    "@rollup/plugin-typescript": "^10.0.1",
-    "@tsconfig/node16": "^1.0.3",
+    "@commitlint/cli": "^18.0.0",
+    "@commitlint/config-conventional": "^18.0.0",
+    "@rollup/plugin-typescript": "^11.1.5",
+    "@tsconfig/node18": "^18.2.2",
     "@types/jest": "^29.2.4",
-    "@types/node": "^16.18.4",
+    "@types/node": "^20.8.8",
     "eslint": "^8.29.0",
-    "eslint-config-dasprid": "^0.1.13",
+    "eslint-config-dasprid": "^0.3.1",
     "husky": "^8.0.2",
     "jest": "^29.3.1",
-    "lint-staged": "^13.1.0",
-    "rollup": "^3.6.0",
+    "lint-staged": "^15.0.2",
+    "rollup": "^4.1.4",
     "ts-jest": "^29.0.3",
-    "typescript": "^4.9.3",
+    "tslib": "^2.6.2",
+    "typescript": "^5.2.2",
     "winston": "^3.8.2"
   },
   "lint-staged": {

package.json

@@ -8,7 +8,7 @@ export default {
         {file: pkg.module, format: 'es', sourcemap: true},
     ],
     plugins: [
-        typescript({tsconfig: './tsconfig.json'}),
+        typescript({tsconfig: './tsconfig.build.json'}),
     ],
     external: ['tls'],
 };

rollup.config.mjs

@@ -100,7 +100,7 @@ class BufferedStream<T extends Socket> implements Stream {
                 this.queue.shift();
             } else {
                 this.queue[0].copy(result, offset, 0, length);
-                this.queue[0] = this.queue[0].slice(length);
+                this.queue[0] = this.queue[0].subarray(length);
             }
 
             length -= bufferLength;

src/BufferedStream.ts

@@ -1,3 +1,5 @@
+import type {IpAddr} from './ip-addr';
+
 export class UnknownUidResult {}
 export class ThrottledUidResult {}
 export class ValidUidResult {
@@ -25,7 +27,7 @@ export class AudioFoundResult {
 export type GetAudioResult = AudioNotFoundResult | AudioFoundResult;
 
 type Processor = {
-    authenticate : (clientId : string, secret : string) => Promise<boolean> | boolean;
+    authenticate : (clientId : string, secret : string, localIp : IpAddr) => Promise<boolean> | boolean;
     checkUid : (clientId : string, uid : Buffer) => Promise<CheckUidResult>;
     getAudio : (id : Buffer) => Promise<GetAudioResult>;
 };

src/Processor.ts

@@ -1,4 +1,6 @@
 import type {Logger} from 'winston';
+import {IpV4Addr, IpV6Addr} from './ip-addr';
+import type {IpAddr} from './ip-addr';
 import type Processor from './Processor';
 import {AudioNotFoundResult, ThrottledUidResult, UnknownUidResult} from './Processor';
 import type Stream from './Stream';
@@ -7,16 +9,26 @@ export enum Command {
     checkUid = 0,
     getAudio = 1,
     ping = 2,
+    quit = 3,
 }
 
-export enum Response {
+export enum AuthResponse {
     invalidAuth = 0,
     validAuth = 1,
+}
+
+export enum CheckUidResponse {
     unknownUid = 0,
     throttledUid = 2,
     validUid = 1,
+}
+
+export enum GetAudioResponse {
     audioNotFound = 0,
     audioFound = 1,
+}
+
+export enum PingResponse {
     pong = 0,
 }
 
@@ -39,25 +51,39 @@ const handleClient = async (
             }, authTimeout);
         }),
         (async () => {
-            const credentialsLength = await stream.readUint8();
-            const credentials = (await stream.readExact(credentialsLength)).toString('ascii');
+            const clientIdLength = await stream.readUint8();
+            const clientId = (await stream.readExact(clientIdLength)).toString('utf-8');
 
-            if (!credentials.includes(':')) {
-                logger?.info('Malformed credentials');
-                stream.writeUint8(Response.invalidAuth);
-                return null;
+            const secretLength = await stream.readUint8();
+            const secret = (await stream.readExact(secretLength)).toString('utf-8');
+
+            const inetVersion = await stream.readUint8();
+            let localIp : IpAddr;
+
+            switch (inetVersion) {
+                case 4:
+                    localIp = new IpV4Addr(await stream.readExact(4));
+                    break;
+
+                case 6:
+                    localIp = new IpV6Addr(await stream.readExact(16));
+                    break;
+
+                default:
+                    logger?.info(`Invalid INET version "${inetVersion}"`);
+                    stream.writeUint8(AuthResponse.invalidAuth);
+                    return null;
             }
 
-            const [clientId, secret] = credentials.split(':', 2);
-            const authResult = await processor.authenticate(clientId, secret);
+            const authResult = await processor.authenticate(clientId, secret, localIp);
 
             if (!authResult) {
                 logger?.info(`Unknown client ID "${clientId}" or invalid secret`);
-                stream.writeUint8(Response.invalidAuth);
+                stream.writeUint8(AuthResponse.invalidAuth);
                 return null;
             }
 
-            stream.writeUint8(Response.validAuth);
+            stream.writeUint8(AuthResponse.validAuth);
             return clientId;
         })(),
     ]);
@@ -83,16 +109,16 @@ const handleClient = async (
                 const response = await processor.checkUid(clientId, uid);
 
                 if (response instanceof UnknownUidResult) {
-                    stream.writeUint8(Response.unknownUid);
+                    stream.writeUint8(CheckUidResponse.unknownUid);
                     break;
                 }
 
                 if (response instanceof ThrottledUidResult) {
-                    stream.writeUint8(Response.throttledUid);
+                    stream.writeUint8(CheckUidResponse.throttledUid);
                     break;
                 }
 
-                stream.writeUint8(Response.validUid);
+                stream.writeUint8(CheckUidResponse.validUid);
                 stream.writeUint8(response.achievementIds.length);
 
                 for (const achievementId of response.achievementIds) {
@@ -107,20 +133,23 @@ const handleClient = async (
                 const result = await processor.getAudio(id);
 
                 if (result instanceof AudioNotFoundResult) {
-                    stream.writeUint8(Response.audioNotFound);
+                    stream.writeUint8(GetAudioResponse.audioNotFound);
                     break;
                 }
 
-                stream.writeUint8(Response.audioFound);
+                stream.writeUint8(GetAudioResponse.audioFound);
                 stream.writeUInt32LE(result.data.length);
                 stream.writeAll(result.data);
                 break;
             }
 
             case Command.ping:
-                stream.writeUint8(Response.pong);
+                stream.writeUint8(PingResponse.pong);
                 break;
 
+            case Command.quit:
+                return;
+
             default:
                 logger?.info(`Unknown command: ${commandCode}`);
                 return;

src/client.ts

@@ -3,3 +3,6 @@ export {startServer} from './server';
 
 export type {default as Processor, CheckUidResult, GetAudioResult} from './Processor';
 export {AudioFoundResult, AudioNotFoundResult, ThrottledUidResult, ValidUidResult, UnknownUidResult} from './Processor';
+
+export type {IpAddr} from './ip-addr';
+export {IpV4Addr, IpV6Addr} from './ip-addr';

src/index.ts

@@ -0,0 +1,43 @@
+export type IpAddr = {
+    toString : () => string;
+};
+
+export class IpV4Addr implements IpAddr {
+    private readonly bytes : Buffer;
+
+    public constructor(bytes : Buffer) {
+        if (bytes.length !== 4) {
+            throw new Error('Bytes must be exactly 4 in length');
+        }
+
+        this.bytes = bytes;
+    }
+
+    public toString() : string {
+        return [...this.bytes].join('.');
+    }
+}
+
+export class IpV6Addr implements IpAddr {
+    private readonly bytes : Buffer;
+
+    public constructor(bytes : Buffer) {
+        if (bytes.length !== 16) {
+            throw new Error('Bytes must be exactly 16 in length');
+        }
+
+        this.bytes = bytes;
+    }
+
+    public toString() : string {
+        return (
+            this.bytes
+                .toString('hex')
+                .match(/.{4}/g) as string[]
+        )
+            .map(value => value.replace(/^0+/, ''))
+            .join(':')
+            .replace(/0000:/g, ':')
+            .replace(/:{2,}/g, '::');
+    }
+}