networkwm-js 0.1.0

package/dist/devices.d.ts

@@ -0,0 +1,6 @@
+export declare const DeviceIds: {
+    vendorId: number;
+    productId: number;
+    name: string;
+}[];
+//# sourceMappingURL=devices.d.ts.map

package/dist/devices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"devices.d.ts","sourceRoot":"","sources":["../src/devices.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,EAK3E,CAAC"}

package/dist/devices.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceIds = void 0;
+exports.DeviceIds = [
+    { vendorId: 0x054c, productId: 0x01ad, name: 'Sony NW-HD1 / NW-HD2' },
+    { vendorId: 0x054c, productId: 0x0210, name: 'Sony NW-HD3' },
+    { vendorId: 0x054c, productId: 0x0233, name: 'Sony NW-HD5' },
+    { vendorId: 0x054c, productId: 0x0269, name: 'Sony NW-A3000' },
+];

package/dist/encryption.d.ts

@@ -0,0 +1,16 @@
+import Crypto from '@originjs/crypto-js-wasm';
+export declare function initCrypto(): Promise<void>;
+export declare const EKBROOTS: {
+    [key: number]: Uint8Array;
+};
+export declare function importKeys(rawKeysContents: Uint8Array): void;
+export declare function getMP3EncryptionKey(discId: Uint8Array, trackNumber: number): Uint8Array;
+export declare function createTrackKeyForKeyring(ekbNum: number, verificationKey: Uint8Array, trackKey: Uint8Array): Uint8Array;
+export declare function createMaclistValue(ekbNum: number, verificationKey: Uint8Array, contents: Uint8Array): Uint8Array;
+export declare function retailMac(message: Uint8Array, key: Uint8Array): Uint8Array;
+export declare function createIcvMac(icvAndHeader: Uint8Array, sessionKey: Uint8Array): Uint8Array;
+export declare function encryptTrackKey(trackKey: Uint8Array): Uint8Array;
+export declare function createTrackMac2(trackKeyWa: Crypto.lib.WordArray, trackEntry: Uint8Array): Uint8Array;
+export declare function createTrackMac(trackKey: Uint8Array, trackEntry: Uint8Array): Uint8Array;
+export declare function desDecrypt(data: Uint8Array, key: Uint8Array): Uint8Array;
+//# sourceMappingURL=encryption.d.ts.map

package/dist/encryption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encryption.d.ts","sourceRoot":"","sources":["../src/encryption.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,0BAA0B,CAAC;AAK9C,wBAAsB,UAAU,kBAG/B;AAGD,eAAO,MAAM,QAAQ,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAA;CAExC,CAAC;AAEX,wBAAgB,UAAU,CAAC,eAAe,EAAE,UAAU,QAQrD;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,cAG1E;AAED,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,EAAE,eAAe,EAAE,UAAU,EAAE,QAAQ,EAAE,UAAU,cAsBzG;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,eAAe,EAAE,UAAU,EAAE,QAAQ,EAAE,UAAU,cAenG;AAID,wBAAgB,SAAS,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,cAgB7D;AAED,wBAAgB,YAAY,CAAC,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,cAM5E;AAED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,UAAU,cAKnD;AAED,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,CAAC,GAAG,CAAC,SAAS,EAAE,UAAU,EAAE,UAAU,cAQvF;AAED,wBAAgB,cAAc,CAAC,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,cAG1E;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,cAE3D"}

package/dist/encryption.js

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.desDecrypt = exports.createTrackMac = exports.createTrackMac2 = exports.encryptTrackKey = exports.createIcvMac = exports.retailMac = exports.createMaclistValue = exports.createTrackKeyForKeyring = exports.getMP3EncryptionKey = exports.importKeys = exports.EKBROOTS = exports.initCrypto = void 0;
+const crypto_js_wasm_1 = __importDefault(require("@originjs/crypto-js-wasm"));
+const bytemanip_1 = require("./bytemanip");
+const errors_1 = require("./errors");
+const utils_1 = require("./utils");
+async function initCrypto() {
+    await crypto_js_wasm_1.default.TripleDES.loadWasm();
+    await crypto_js_wasm_1.default.DES.loadWasm();
+}
+exports.initCrypto = initCrypto;
+// prettier-ignore
+exports.EKBROOTS = {
+// <Redacted>
+};
+function importKeys(rawKeysContents) {
+    let offset = 0;
+    const dataView = new DataView(rawKeysContents.buffer);
+    while (offset < rawKeysContents.length) {
+        let ekbid;
+        [ekbid, offset] = (0, bytemanip_1.readUint32)(dataView, offset);
+        exports.EKBROOTS[ekbid] = rawKeysContents.slice(offset, offset += 3 * 8);
+    }
+}
+exports.importKeys = importKeys;
+function getMP3EncryptionKey(discId, trackNumber) {
+    const key = (trackNumber * 0x6953b2ed + 0x6baab1) ^ (0, bytemanip_1.getUint32)(discId, 12);
+    return (0, bytemanip_1.writeUint32)(key);
+}
+exports.getMP3EncryptionKey = getMP3EncryptionKey;
+function createTrackKeyForKeyring(ekbNum, verificationKey, trackKey) {
+    if (!(ekbNum in exports.EKBROOTS)) {
+        throw new errors_1.NWJSError('Requested decription with an unknown EKB');
+    }
+    const rootKeyC = crypto_js_wasm_1.default.lib.WordArray.create(exports.EKBROOTS[ekbNum]);
+    const verificationKeyC = crypto_js_wasm_1.default.lib.CipherParams.create({
+        ciphertext: crypto_js_wasm_1.default.lib.WordArray.create(verificationKey),
+    });
+    const trackKeyC = crypto_js_wasm_1.default.lib.CipherParams.create({
+        ciphertext: crypto_js_wasm_1.default.lib.WordArray.create(trackKey),
+    });
+    // Step 1: get real verification key
+    const decryptedVerificationKey = crypto_js_wasm_1.default.TripleDES.decrypt(verificationKeyC, rootKeyC, {
+        mode: crypto_js_wasm_1.default.mode.ECB,
+    });
+    // Step 2: get "encrypted" track key - so decrypt it
+    const decryptedTrackKey = crypto_js_wasm_1.default.TripleDES.decrypt(trackKeyC, decryptedVerificationKey, {
+        mode: crypto_js_wasm_1.default.mode.ECB,
+    });
+    return (0, utils_1.wordArrayToByteArray)(decryptedTrackKey, 8);
+}
+exports.createTrackKeyForKeyring = createTrackKeyForKeyring;
+function createMaclistValue(ekbNum, verificationKey, contents) {
+    if (!(ekbNum in exports.EKBROOTS)) {
+        throw new errors_1.NWJSError('Requested decription with an unknown EKB');
+    }
+    const rootKeyC = crypto_js_wasm_1.default.lib.WordArray.create(exports.EKBROOTS[ekbNum]);
+    const verificationKeyC = crypto_js_wasm_1.default.lib.CipherParams.create({
+        ciphertext: crypto_js_wasm_1.default.lib.WordArray.create(verificationKey),
+    });
+    // Step 1: get real verification key
+    const decryptedVerificationKey = crypto_js_wasm_1.default.TripleDES.decrypt(verificationKeyC, rootKeyC, {
+        mode: crypto_js_wasm_1.default.mode.ECB,
+    });
+    return createTrackMac2(decryptedVerificationKey, contents);
+}
+exports.createMaclistValue = createMaclistValue;
+const NO_PADDING = { pad: (a) => a, unpad: (a) => a };
+function retailMac(message, key) {
+    const keyA = key.subarray(0, 8);
+    const keyB = key.subarray(8, 16);
+    const messageWa = crypto_js_wasm_1.default.lib.WordArray.create(message);
+    const keyAWa = crypto_js_wasm_1.default.lib.WordArray.create(keyA);
+    const keyBWa = crypto_js_wasm_1.default.lib.WordArray.create(keyB);
+    const zeroWa = crypto_js_wasm_1.default.lib.WordArray.create(new Uint8Array(8).fill(0));
+    const encA = crypto_js_wasm_1.default.DES.encrypt(messageWa, keyAWa, { padding: NO_PADDING, mode: crypto_js_wasm_1.default.mode.CBC, iv: zeroWa }).ciphertext;
+    const messageBFull = (0, utils_1.wordArrayToByteArray)(encA);
+    const messageB = messageBFull.subarray(messageBFull.length - 8);
+    const messageBWa = crypto_js_wasm_1.default.lib.CipherParams.create({
+        ciphertext: crypto_js_wasm_1.default.lib.WordArray.create(messageB),
+    });
+    const encB = crypto_js_wasm_1.default.DES.decrypt(messageBWa, keyBWa, { padding: NO_PADDING, mode: crypto_js_wasm_1.default.mode.ECB });
+    const final = crypto_js_wasm_1.default.DES.encrypt(encB, keyAWa, { padding: NO_PADDING, mode: crypto_js_wasm_1.default.mode.ECB }).ciphertext;
+    return (0, utils_1.wordArrayToByteArray)(final);
+}
+exports.retailMac = retailMac;
+function createIcvMac(icvAndHeader, sessionKey) {
+    const icvWa = crypto_js_wasm_1.default.lib.WordArray.create(icvAndHeader);
+    const sessionKeyWa = crypto_js_wasm_1.default.lib.WordArray.create(sessionKey);
+    const zeroWa = crypto_js_wasm_1.default.lib.WordArray.create(new Uint8Array(8).fill(0));
+    const result = crypto_js_wasm_1.default.DES.encrypt(icvWa, sessionKeyWa, { mode: crypto_js_wasm_1.default.mode.CBC, iv: zeroWa, padding: NO_PADDING });
+    return (0, utils_1.wordArrayToByteArray)(result.ciphertext).subarray(-8);
+}
+exports.createIcvMac = createIcvMac;
+function encryptTrackKey(trackKey) {
+    const trackKeyWa = crypto_js_wasm_1.default.lib.WordArray.create(trackKey);
+    const keyWa = crypto_js_wasm_1.default.lib.WordArray.create(exports.EKBROOTS[0x00010012]);
+    const encrypted = crypto_js_wasm_1.default.TripleDES.encrypt(trackKeyWa, keyWa, { mode: crypto_js_wasm_1.default.mode.ECB, padding: NO_PADDING });
+    return (0, utils_1.wordArrayToByteArray)(encrypted.ciphertext);
+}
+exports.encryptTrackKey = encryptTrackKey;
+function createTrackMac2(trackKeyWa, trackEntry) {
+    const trackEntryWa = crypto_js_wasm_1.default.lib.WordArray.create(trackEntry);
+    const macKeySourceWa = crypto_js_wasm_1.default.lib.WordArray.create(new Uint8Array(8).fill(0));
+    const macKey = crypto_js_wasm_1.default.DES.encrypt(macKeySourceWa, trackKeyWa, { mode: crypto_js_wasm_1.default.mode.ECB, padding: NO_PADDING }).ciphertext;
+    const zeroWa = crypto_js_wasm_1.default.lib.WordArray.create(new Uint8Array(8).fill(0));
+    const mac = crypto_js_wasm_1.default.DES.encrypt(trackEntryWa, macKey, { mode: crypto_js_wasm_1.default.mode.CBC, iv: zeroWa, padding: NO_PADDING });
+    return (0, utils_1.wordArrayToByteArray)(mac.ciphertext).subarray(-8);
+}
+exports.createTrackMac2 = createTrackMac2;
+function createTrackMac(trackKey, trackEntry) {
+    const trackKeyWa = crypto_js_wasm_1.default.lib.WordArray.create(trackKey);
+    return createTrackMac2(trackKeyWa, trackEntry);
+}
+exports.createTrackMac = createTrackMac;
+function desDecrypt(data, key) {
+    return (0, utils_1.wordArrayToByteArray)(crypto_js_wasm_1.default.TripleDES.decrypt(crypto_js_wasm_1.default.lib.CipherParams.create({ ciphertext: crypto_js_wasm_1.default.lib.WordArray.create(data) }), crypto_js_wasm_1.default.lib.WordArray.create(key), { mode: crypto_js_wasm_1.default.mode.ECB, iv: crypto_js_wasm_1.default.lib.WordArray.create(new Uint8Array(8).fill(0)) }), data.length);
+}
+exports.desDecrypt = desDecrypt;

package/dist/errors.d.ts

@@ -0,0 +1,4 @@
+export declare class NWJSError extends Error {
+    constructor(m: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,SAAU,SAAQ,KAAK;gBACpB,CAAC,EAAE,MAAM;CAIxB"}

package/dist/errors.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NWJSError = void 0;
+class NWJSError extends Error {
+    constructor(m) {
+        super(m);
+        Object.setPrototypeOf(this, NWJSError.prototype);
+    }
+}
+exports.NWJSError = NWJSError;

package/dist/filesystem/index.d.ts

@@ -0,0 +1,2 @@
+export * from './usb-mass-storage-webusb-filesystem';
+//# sourceMappingURL=index.d.ts.map

package/dist/filesystem/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/filesystem/index.ts"],"names":[],"mappings":"AAAA,cAAc,sCAAsC,CAAC"}

package/dist/filesystem/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./usb-mass-storage-webusb-filesystem"), exports);

package/dist/filesystem/usb-mass-storage-webusb-filesystem.d.ts

@@ -0,0 +1,44 @@
+import { HiMDFile, HiMDFilesystem, SonyVendorUSMCDriver, UMSCHiMDFilesystem } from 'himd-js';
+import { WebUSBDevice } from 'usb';
+export declare class SonyVendorNWJSUSMCDriver extends SonyVendorUSMCDriver {
+    protected drmRead(param: number, length: number): Promise<Uint8Array>;
+    protected drmWrite(param: number, data: Uint8Array): Promise<void>;
+    writeHostLeafID(leafID: Uint8Array, hostNonce: Uint8Array): Promise<void>;
+    getAuthenticationStage2Info(): Promise<{
+        discId: Uint8Array;
+        mac: Uint8Array;
+        deviceLeafId: Uint8Array;
+        deviceNonce: Uint8Array;
+    }>;
+    writeAuthenticationStage3Info(hostMac: Uint8Array): Promise<void>;
+    readMasterKey(): Promise<{
+        header: Uint8Array;
+        masterKey: Uint8Array;
+    }>;
+    writeMasterKeyAndMac(generation: number, masterKey: Uint8Array, mac: Uint8Array, sessionKey: Uint8Array): Promise<void>;
+}
+export declare class UMSCNWJSSession {
+    protected driver: SonyVendorNWJSUSMCDriver;
+    protected fs: HiMDFilesystem;
+    hostNonce: Uint8Array;
+    hostLeafId: Uint8Array;
+    deviceNonce?: Uint8Array;
+    discId?: Uint8Array;
+    deviceLeafId?: Uint8Array;
+    currentIcv?: Uint8Array;
+    currentIcvHeader?: Uint8Array;
+    sessionKey?: Uint8Array;
+    mclistHandle?: HiMDFile;
+    currentGeneration?: number;
+    allMacs?: Uint8Array;
+    constructor(driver: SonyVendorNWJSUSMCDriver, fs: HiMDFilesystem);
+    performAuthorization(): Promise<void>;
+    finalizeSession(): Promise<void>;
+    writeTrackMac(trackNumber: number, mac: Uint8Array): void;
+}
+export declare class UMSCNWJSFilesystem extends UMSCHiMDFilesystem {
+    driver: SonyVendorNWJSUSMCDriver;
+    constructor(webUSB: WebUSBDevice);
+    protected initFS(bypassCoherencyChecks?: boolean | undefined): Promise<void>;
+}
+//# sourceMappingURL=usb-mass-storage-webusb-filesystem.d.ts.map

package/dist/filesystem/usb-mass-storage-webusb-filesystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usb-mass-storage-webusb-filesystem.d.ts","sourceRoot":"","sources":["../../src/filesystem/usb-mass-storage-webusb-filesystem.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAI7F,OAAO,EAAE,YAAY,EAAE,MAAM,KAAK,CAAC;AAGnC,qBAAa,wBAAyB,SAAQ,oBAAoB;cAC9C,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;cAuBrC,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU;IA2BlD,eAAe,CAAC,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU;IASzD,2BAA2B;;;;;;IAoB3B,6BAA6B,CAAC,OAAO,EAAE,UAAU;IAyBjD,aAAa;;;;IAWb,oBAAoB,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU;CAuBhH;AAED,qBAAa,eAAe;IAgBZ,SAAS,CAAC,MAAM,EAAE,wBAAwB;IAAE,SAAS,CAAC,EAAE,EAAE,cAAc;IAfpF,SAAS,aAAuB;IAChC,UAAU,aAAoE;IAE9E,WAAW,CAAC,EAAE,UAAU,CAAC;IACzB,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB,YAAY,CAAC,EAAE,UAAU,CAAC;IAC1B,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,gBAAgB,CAAC,EAAE,UAAU,CAAC;IAC9B,UAAU,CAAC,EAAE,UAAU,CAAC;IAExB,YAAY,CAAC,EAAE,QAAQ,CAAC;IACxB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAE3B,OAAO,CAAC,EAAE,UAAU,CAAC;gBAEC,MAAM,EAAE,wBAAwB,EAAY,EAAE,EAAE,cAAc;IAEvE,oBAAoB;IAkBpB,eAAe;IAYrB,aAAa,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,EAAE,UAAU;CAG5D;AAED,qBAAa,kBAAmB,SAAQ,kBAAkB;IACtD,MAAM,EAAE,wBAAwB,CAAC;gBACrB,MAAM,EAAE,YAAY;cAKhB,MAAM,CAAC,qBAAqB,CAAC,EAAE,OAAO,GAAG,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;CAYrF"}

package/dist/filesystem/usb-mass-storage-webusb-filesystem.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UMSCNWJSFilesystem = exports.UMSCNWJSSession = exports.SonyVendorNWJSUSMCDriver = void 0;
+const himd_js_1 = require("himd-js");
+const utils_1 = require("../utils");
+const bytemanip_1 = require("../bytemanip");
+const encryption_1 = require("../encryption");
+const nufatfs_1 = require("nufatfs");
+class SonyVendorNWJSUSMCDriver extends himd_js_1.SonyVendorUSMCDriver {
+    async drmRead(param, length) {
+        const command = new Uint8Array([
+            0xa4,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0xbc,
+            (length >> 8) & 0xff,
+            length & 0xff,
+            param,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+        ]);
+        const result = await this.sendCommandInGetResult(command, length, false, command.length);
+        return result.result.subarray(2);
+    }
+    async drmWrite(param, data) {
+        const newData = new Uint8Array(data.length + 2);
+        newData.set((0, bytemanip_1.writeUint16)(data.length), 0);
+        newData.set(data, 2);
+        const length = newData.length;
+        const command = new Uint8Array([
+            0xa3,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0xbc,
+            (length >> 8) & 0xff,
+            length & 0xff,
+            param,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+        ]);
+        await this.sendCommandOutGetResult(command, newData, command.length);
+    }
+    async writeHostLeafID(leafID, hostNonce) {
+        (0, utils_1.assert)(leafID.length === 8, 'Wrong length of leaf id');
+        const finalBuffer = new Uint8Array(2 + 8 + 8);
+        finalBuffer.fill(0);
+        finalBuffer.set(leafID, 2);
+        finalBuffer.set(hostNonce, 10);
+        await this.drmWrite(0x30, finalBuffer);
+    }
+    async getAuthenticationStage2Info() {
+        const data = await this.drmRead(0x31, 0x43c);
+        let _current = 2;
+        const read = (len) => data.subarray(_current, (_current += len));
+        const discId = read(16);
+        const mac = read(8);
+        const deviceLeafId = read(8);
+        const deviceNonce = read(8);
+        // // EKB info begin
+        // const keyType = read(4);
+        // const keyLevel = read(4);
+        // const ekbid = read(4);
+        // const zero = read(4);
+        // const key = read(16);
+        return { discId, mac, deviceLeafId, deviceNonce };
+    }
+    async writeAuthenticationStage3Info(hostMac) {
+        const finalBuffer = new Uint8Array(0x41a);
+        finalBuffer.fill(0);
+        finalBuffer.set(hostMac, 2);
+        // Send own configuration
+        // Key type 1
+        // Key level 8
+        // EKB 00010021
+        // Encrypted Node Key: 0xf0, 0x5c, 0xb7, 0xfe, 0xde, 0x3c, 0x94, 0x01, 0x78, 0x4a, 0x71, 0x8d, 0x9f, 0xf7, 0xf4, 0xb1
+        finalBuffer.set([
+            0x00, 0x00, 0x00, 0x01,
+            0x00, 0x00, 0x00, 0x08,
+            0x00, 0x01, 0x00, 0x21,
+            0x00, 0x00, 0x00, 0x00,
+            0xf0, 0x5c, 0xb7, 0xfe, 0xde, 0x3c, 0x94, 0x01,
+            0x78, 0x4a, 0x71, 0x8d, 0x9f, 0xf7, 0xf4, 0xb1,
+        ], 10);
+        await this.drmWrite(0x32, finalBuffer);
+    }
+    async readMasterKey() {
+        const data = await this.drmRead(0x33, 0x404);
+        let _current = 2;
+        const read = (len) => data.subarray(_current, (_current += len));
+        const header = read(8);
+        // Zeros
+        _current += 4;
+        const masterKey = read(16);
+        return { header, masterKey };
+    }
+    async writeMasterKeyAndMac(generation, masterKey, mac, sessionKey) {
+        // masterKey = 0xe0, 0xaa, 0x0b, 0x24, 0xd5, 0x1f, 0x97, 0x1d, 0x57, 0xaa, 0x7a, 0x3f, 0x8f, 0x93, 0xe7, 0xb3
+        // mac = 0x9e, 0x29, 0xe4, 0xa3, 0x4f, 0x8d, 0x43, 0xc7
+        const generationBytes = (0, bytemanip_1.writeUint32)(generation);
+        const theSonySoup = new Uint8Array([
+            0x00, 0x20, 0x00, 0x98,
+            ...generationBytes,
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x01, 0x00, 0x21,
+            ...masterKey,
+            ...mac,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+        ]);
+        theSonySoup.set((0, bytemanip_1.writeUint32)(generation), 4);
+        const newMac = (0, encryption_1.createIcvMac)(theSonySoup, sessionKey);
+        const finalBuffer = new Uint8Array(0x402).fill(0);
+        finalBuffer.set(newMac, 2 + theSonySoup.length);
+        finalBuffer.set(theSonySoup, 2);
+        await this.drmWrite(0x34, finalBuffer);
+    }
+}
+exports.SonyVendorNWJSUSMCDriver = SonyVendorNWJSUSMCDriver;
+class UMSCNWJSSession {
+    constructor(driver, fs) {
+        this.driver = driver;
+        this.fs = fs;
+        this.hostNonce = (0, utils_1.createRandomBytes)();
+        this.hostLeafId = new Uint8Array([0x03, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
+    }
+    async performAuthorization() {
+        await this.driver.writeHostLeafID(this.hostLeafId, this.hostNonce);
+        const resultsStage2 = await this.driver.getAuthenticationStage2Info();
+        this.discId = resultsStage2.discId;
+        this.deviceLeafId = resultsStage2.deviceLeafId;
+        this.deviceNonce = resultsStage2.deviceNonce;
+        // Disregard device mac
+        const ekb10021Root = encryption_1.EKBROOTS[0x00010021];
+        const hostMac = (0, encryption_1.retailMac)((0, utils_1.concatUint8Arrays)([resultsStage2.discId, resultsStage2.deviceNonce, this.hostNonce]), ekb10021Root);
+        await this.driver.writeAuthenticationStage3Info(hostMac);
+        const { header, masterKey: anyKey } = await this.driver.readMasterKey();
+        this.sessionKey = (0, encryption_1.retailMac)((0, utils_1.concatUint8Arrays)([resultsStage2.discId, resultsStage2.mac, hostMac]), ekb10021Root);
+        this.currentGeneration = (0, bytemanip_1.getUint32)(header, 4);
+        this.mclistHandle = await this.fs.open("/OMGAUDIO/MACLIST0.DAT", "rw");
+        this.allMacs = await this.mclistHandle.read();
+    }
+    async finalizeSession() {
+        const ekb10021Root = encryption_1.EKBROOTS[0x00010021];
+        this.currentGeneration += 1;
+        const masterKey = new TextEncoder().encode('.DRMisBadForYou.');
+        const mac = (0, encryption_1.retailMac)((0, utils_1.concatUint8Arrays)([this.discId, this.allMacs]), (0, encryption_1.desDecrypt)(masterKey, ekb10021Root));
+        await this.driver.writeMasterKeyAndMac(this.currentGeneration, masterKey, mac, this.sessionKey);
+        await this.mclistHandle.seek(0);
+        await this.mclistHandle.write(this.allMacs);
+        await this.mclistHandle.close();
+    }
+    // trackNumber starts from 0
+    writeTrackMac(trackNumber, mac) {
+        this.allMacs.set(mac, trackNumber * 8);
+    }
+}
+exports.UMSCNWJSSession = UMSCNWJSSession;
+class UMSCNWJSFilesystem extends himd_js_1.UMSCHiMDFilesystem {
+    constructor(webUSB) {
+        super(webUSB);
+        this.driver = new SonyVendorNWJSUSMCDriver(webUSB, 0x06);
+    }
+    async initFS(bypassCoherencyChecks) {
+        await this.driver.inquiry();
+        await this.driver.testUnitReady();
+        const partInfo = await this.driver.getCapacity();
+        console.log(partInfo);
+        const baseDriver = await this.driver.createNUFatFSVolumeDriverFromMBRPart(0, true);
+        this.fsUncachedDriver = this.fsDriver = (0, nufatfs_1.createChunkingDriver)(baseDriver, 240, partInfo.blockSize);
+        this.fatfs = await nufatfs_1.FatFilesystem.create(this.fsDriver, bypassCoherencyChecks);
+        this.volumeSize = partInfo.deviceSize;
+    }
+}
+exports.UMSCNWJSFilesystem = UMSCNWJSFilesystem;

package/dist/functions.d.ts

@@ -0,0 +1,12 @@
+import { CodecInfo } from "himd-js";
+import { WebUSBDevice } from "usb";
+import { TrackMetadata } from "./databases";
+import { UMSCNWJSFilesystem, UMSCNWJSSession } from "./filesystem";
+import { DatabaseAbstraction } from "./database-abstraction";
+export declare function uploadTrack(database: DatabaseAbstraction, session: UMSCNWJSSession, trackInfo: TrackMetadata, codec: CodecInfo, rawData: Uint8Array, callback?: (done: number, outOf: number) => void): Promise<void>;
+export declare function createNWJSFS(webUsbDevice: WebUSBDevice, bypassCoherencyChecks: boolean): Promise<UMSCNWJSFilesystem>;
+export declare function openNewDeviceNode(): Promise<{
+    dev: WebUSBDevice;
+    name: string;
+} | null>;
+//# sourceMappingURL=functions.d.ts.map

package/dist/functions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"functions.d.ts","sourceRoot":"","sources":["../src/functions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACpC,OAAO,EAAE,YAAY,EAAa,MAAM,KAAK,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAInE,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAO7D,wBAAsB,WAAW,CAC7B,QAAQ,EAAE,mBAAmB,EAC7B,OAAO,EAAE,eAAe,EACxB,SAAS,EAAE,aAAa,EACxB,KAAK,EAAE,SAAS,EAChB,OAAO,EAAE,UAAU,EACnB,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,iBA2BnD;AAED,wBAAsB,YAAY,CAAC,YAAY,EAAE,YAAY,EAAE,qBAAqB,EAAE,OAAO,+BAO5F;AAED,wBAAsB,iBAAiB,IAAI,OAAO,CAAC;IAAE,GAAG,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC,CA2B7F"}

package/dist/functions.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openNewDeviceNode = exports.createNWJSFS = exports.uploadTrack = void 0;
+const usb_1 = require("usb");
+const filesystem_1 = require("./filesystem");
+const tagged_oma_1 = require("./tagged-oma");
+const utils_1 = require("./utils");
+const devices_1 = require("./devices");
+const initialization_1 = require("./initialization");
+function resolvePathFromGlobalIndex(globalTrackIndex) {
+    return (0, utils_1.join)('OMGAUDIO', '10F00', '1000' + globalTrackIndex.toString(16).padStart(4, '0').toUpperCase() + '.OMA');
+}
+async function uploadTrack(database, session, trackInfo, codec, rawData, callback) {
+    // Step 1 - Create the encrypted OMA which will later be written to the device's storage
+    const encryptedOMA = (0, tagged_oma_1.createTaggedEncryptedOMA)(rawData, trackInfo, codec);
+    // Step 2 - write track to the database
+    const globalTrackIndex = database.addNewTrack({
+        ...trackInfo,
+        trackDuration: encryptedOMA.duration,
+    }, codec);
+    // Step 3 - write track to the filesystem
+    const fh = await database.database.filesystem.open(resolvePathFromGlobalIndex(globalTrackIndex), 'rw');
+    const data = encryptedOMA.data;
+    let remaining = data.length;
+    let i = 0;
+    callback === null || callback === void 0 ? void 0 : callback(i, data.length);
+    while (remaining) {
+        const toWrite = Math.min(2048, remaining);
+        await fh.write(data.slice(i, i + toWrite));
+        i += toWrite;
+        remaining -= toWrite;
+        callback === null || callback === void 0 ? void 0 : callback(i, data.length);
+    }
+    await fh.close();
+    // Step 4 - write MAC
+    session.writeTrackMac(globalTrackIndex - 1, encryptedOMA.maclistValue);
+}
+exports.uploadTrack = uploadTrack;
+async function createNWJSFS(webUsbDevice, bypassCoherencyChecks) {
+    // Connect into the HiMD codebase
+    const fs = new filesystem_1.UMSCNWJSFilesystem(webUsbDevice);
+    await fs.init();
+    await (0, initialization_1.initializeIfNeeded)(fs);
+    return fs;
+}
+exports.createNWJSFS = createNWJSFS;
+async function openNewDeviceNode() {
+    let legacyDevice, devName = null;
+    for (let dev of devices_1.DeviceIds) {
+        legacyDevice = (0, usb_1.findByIds)(dev.vendorId, dev.productId);
+        if (legacyDevice) {
+            devName = dev.name;
+            break;
+        }
+    }
+    if (!legacyDevice) {
+        return null;
+    }
+    legacyDevice.open();
+    await new Promise(res => legacyDevice.reset(res));
+    const iface = legacyDevice.interface(0);
+    try {
+        if (iface.isKernelDriverActive())
+            iface.detachKernelDriver();
+    }
+    catch (ex) {
+        // console.log("Couldn't detach the kernel driver. Expected on Windows.");
+    }
+    const webUsbDevice = (await usb_1.WebUSBDevice.createInstance(legacyDevice));
+    await webUsbDevice.open();
+    return { dev: webUsbDevice, name: devName };
+}
+exports.openNewDeviceNode = openNewDeviceNode;

package/dist/helpers.d.ts

@@ -0,0 +1,9 @@
+import { WebUSBDevice } from "usb";
+import { UMSCNWJSFilesystem } from "./filesystem";
+export declare function resolvePathFromGlobalIndex(globalTrackIndex: number): string;
+export declare function createNWJSFS(webUsbDevice: WebUSBDevice, bypassCoherencyChecks: boolean): Promise<UMSCNWJSFilesystem>;
+export declare function openNewDeviceNode(): Promise<{
+    dev: WebUSBDevice;
+    name: string;
+} | null>;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../src/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAkB,MAAM,KAAK,CAAC;AACnD,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAKlD,wBAAgB,0BAA0B,CAAC,gBAAgB,EAAE,MAAM,UAElE;AAED,wBAAsB,YAAY,CAAC,YAAY,EAAE,YAAY,EAAE,qBAAqB,EAAE,OAAO,+BAO5F;AAED,wBAAsB,iBAAiB,IAAI,OAAO,CAAC;IAAE,GAAG,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC,CA2B7F"}

package/dist/helpers.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openNewDeviceNode = exports.createNWJSFS = exports.resolvePathFromGlobalIndex = void 0;
+const usb_1 = require("usb");
+const filesystem_1 = require("./filesystem");
+const utils_1 = require("./utils");
+const devices_1 = require("./devices");
+const initialization_1 = require("./initialization");
+function resolvePathFromGlobalIndex(globalTrackIndex) {
+    return (0, utils_1.join)('OMGAUDIO', '10F00', '1000' + globalTrackIndex.toString(16).padStart(4, '0').toUpperCase() + '.OMA');
+}
+exports.resolvePathFromGlobalIndex = resolvePathFromGlobalIndex;
+async function createNWJSFS(webUsbDevice, bypassCoherencyChecks) {
+    // Connect into the HiMD codebase
+    const fs = new filesystem_1.UMSCNWJSFilesystem(webUsbDevice);
+    await fs.init();
+    await (0, initialization_1.initializeIfNeeded)(fs);
+    return fs;
+}
+exports.createNWJSFS = createNWJSFS;
+async function openNewDeviceNode() {
+    let legacyDevice = undefined, devName = null;
+    for (let dev of devices_1.DeviceIds) {
+        legacyDevice = (0, usb_1.findByIds)(dev.vendorId, dev.productId);
+        if (legacyDevice) {
+            devName = dev.name;
+            break;
+        }
+    }
+    if (!legacyDevice) {
+        return null;
+    }
+    legacyDevice.open();
+    await new Promise(res => legacyDevice.reset(res));
+    const iface = legacyDevice.interface(0);
+    try {
+        if (iface.isKernelDriverActive())
+            iface.detachKernelDriver();
+    }
+    catch (ex) {
+        // console.log("Couldn't detach the kernel driver. Expected on Windows.");
+    }
+    const webUsbDevice = (await usb_1.WebUSBDevice.createInstance(legacyDevice));
+    await webUsbDevice.open();
+    return { dev: webUsbDevice, name: devName };
+}
+exports.openNewDeviceNode = openNewDeviceNode;

package/dist/id3.d.ts

@@ -0,0 +1,18 @@
+export interface ID3Tag {
+    id: string;
+    flags: number;
+    contents: Uint8Array;
+}
+export interface ID3Tags {
+    version: {
+        minor: number;
+        major: number;
+    };
+    tags: ID3Tag[];
+    flags: number;
+}
+export declare function readSynchsafeInt32(data: DataView, offset: number): [number, number];
+export declare function parse(buffer: Uint8Array): ID3Tags;
+export declare function serialize(tags: ID3Tags): Uint8Array;
+export declare function encodeUTF16BEStringEA3(source: string, includeType?: boolean): Uint8Array;
+//# sourceMappingURL=id3.d.ts.map

package/dist/id3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"id3.d.ts","sourceRoot":"","sources":["../src/id3.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,MAAM;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,UAAU,CAAC;CACxB;AAED,MAAM,WAAW,OAAO;IACpB,OAAO,EAAE;QACL,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACjB;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAYnF;AAKD,wBAAgB,KAAK,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CA+CjD;AAWD,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,GAAG,UAAU,CAuCnD;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,UAAO,cAgCxE"}