azot 0.8.0 → 0.8.3

package/README.md

@@ -4,7 +4,7 @@
 ![GitHub Downloads (all assets, latest release)](https://img.shields.io/github/downloads/vitalygashkov/azot/latest/total?style=flat&color=black)
 [![npm downloads](https://img.shields.io/npm/dt/azot?style=flat&color=black)](https://www.npmjs.com/package/azot)
 
-Azot (Russian word for "nitrogen", pronounced `/azо́t/`) is a set of tools (JavaScript library, command-line utility and browser extension) for diagnosing, researching, and pentesting [Google's](https://about.google/) [Widevine](https://www.widevine.com/about) [DRM](https://www.urbandictionary.com/define.php?term=DRM).
+Azot (Russian word for "nitrogen", pronounced `/azо́t/`) is a set of tools (JavaScript library, command-line utility and browser extension) for diagnosing, researching, and pentesting [DRM](https://www.urbandictionary.com/define.php?term=DRM) systems like [Widevine](https://www.widevine.com/about).
 
 > Azot is still in the early stages of development, so until version 1.0 is released, performance may be unstable and major changes may be made
 
@@ -18,6 +18,7 @@ Azot (Russian word for "nitrogen", pronounced `/azо́t/`) is a set of tools (Ja
 - **Manifest V3** compliant browser extension
 - **Custom client support**: WVD v2, device_client_id_blob + device_private_key, client_id.bin + private_key.pem
 - **Network-independent interception**, so it doesn't matter if the request has one-time tokens or a custom request/response body format.
+- **Remote instance** to control sessions via REST API
 
 ## Installation
 

package/dist/cli/main.cjs

@@ -7202,6 +7202,7 @@ var Session = class extends EventTarget {
       deriveContext(licenseRequest.bytes)
     );
     this.dispatchEvent(new MessageEvent("license-request", message.bytes));
+    return message.bytes;
   }
   async waitForLicenseRequest() {
     return new Promise((resolve) => {
@@ -7328,6 +7329,9 @@ var Session = class extends EventTarget {
       "usable"
     );
   }
+  async getKeys() {
+    return Array.from(this.keys.values());
+  }
   close() {
     this.dispatchEvent(new Event("closed"));
     return Promise.resolve();
@@ -7476,18 +7480,34 @@ var Client = class _Client {
   vmp;
   info;
   #key;
-  static async fromPacked(data, format = "WVDv2") {
-    if (format !== "WVDv2") throw new Error("Only WVDv2 is supported");
-    const parsed = parseWvd(data);
-    const pcks1 = `-----BEGIN RSA PRIVATE KEY-----
+  static async fromPacked(data, format = "azot") {
+    const isWvd = fromBuffer(data.slice(0, 3)).toText() == "WVD";
+    if (format === "wvd" || isWvd) {
+      const parsed = parseWvd(data);
+      const pcks1 = `-----BEGIN RSA PRIVATE KEY-----
 ${fromBuffer(parsed.privateKey).toBase64()}
 -----END RSA PRIVATE KEY-----`;
-    const key = fromText(pcks1).toBuffer();
-    const type = types.get(parsed.deviceType);
-    const securityLevel = parsed.securityLevel;
-    const client2 = new _Client(parsed.clientId, type, securityLevel);
-    await client2.importKey(key);
-    return client2;
+      const key = fromText(pcks1).toBuffer();
+      const type = types.get(parsed.deviceType);
+      const securityLevel = parsed.securityLevel;
+      const client2 = new _Client(parsed.clientId, type, securityLevel);
+      await client2.importKey(key);
+      return client2;
+    } else if (format === "azot") {
+      const parsed = JSON.parse(fromBuffer(data).toText());
+      const clientId = ClientIdentification.fromObject(
+        parsed.data.clientIdentification
+      );
+      const client2 = new _Client(
+        clientId,
+        parsed.data.type,
+        parsed.data.securityLevel
+      );
+      await client2.importKey(parsed.data.privateKey);
+      return client2;
+    } else {
+      throw new Error("Unsupported format");
+    }
   }
   static async fromUnpacked(id, key, vmp) {
     const client2 = new _Client(id);
@@ -7503,7 +7523,7 @@ ${fromBuffer(parsed.privateKey).toBase64()}
     return this.#key;
   }
   constructor(id, type = CLIENT_TYPE.android, securityLevel = 3) {
-    this.id = ClientIdentification.decode(id);
+    this.id = ArrayBuffer.isView(id) ? ClientIdentification.decode(id) : id;
     this.signedDrmCertificate = SignedDrmCertificate.decode(this.id.token);
     this.drmCertificate = DrmCertificate.decode(
       this.signedDrmCertificate.drmCertificate
@@ -7520,23 +7540,39 @@ ${fromBuffer(parsed.privateKey).toBase64()}
     const key = await this.exportKey();
     return [id, key];
   }
-  async pack(format = "WVDv2") {
-    if (format !== "WVDv2") throw new Error("Only WVDv2 is supported");
-    const id = ClientIdentification.encode(this.id).finish();
-    const key = await this.exportKey();
-    const keyDer = fromBuffer(key).toText().split("\n").map((s) => s.trim()).slice(1, -1).join("\n");
-    const keyDerBinary = fromBase64(keyDer).toBuffer();
-    const [type] = types.entries().find(([, type2]) => type2 === this.type);
-    const wvd = buildWvd({
-      clientId: id,
-      deviceType: type,
-      securityLevel: this.securityLevel,
-      privateKey: keyDerBinary
-    });
-    return wvd;
+  async pack(format = "azot") {
+    if (format === "wvd") {
+      const id = ClientIdentification.encode(this.id).finish();
+      const key = await this.exportKey();
+      const keyDer = fromBuffer(key).toText().split("\n").map((s) => s.trim()).slice(1, -1).join("\n");
+      const keyDerBinary = fromBase64(keyDer).toBuffer();
+      const [type] = types.entries().find(([, type2]) => type2 === this.type);
+      const wvd = buildWvd({
+        clientId: id,
+        deviceType: type,
+        securityLevel: this.securityLevel,
+        privateKey: keyDerBinary
+      });
+      return wvd;
+    } else if (format === "azot") {
+      const clientIdentification = this.id.toJSON();
+      const privateKey = await this.exportKey();
+      const payload = {
+        version: 1,
+        type: "widevine-client",
+        data: {
+          clientIdentification,
+          privateKey: fromBuffer(privateKey).toText()
+        }
+      };
+      const data = JSON.stringify(payload, null, 2);
+      return fromText(data).toBuffer();
+    } else {
+      throw new Error("Unsupported format");
+    }
   }
   async importKey(pkcs1) {
-    const pkcs1pem = fromBuffer(pkcs1).toText();
+    const pkcs1pem = typeof pkcs1 === "string" ? pkcs1 : fromBuffer(pkcs1).toText();
     const pkcs8pem = toPKCS8(pkcs1pem);
     const pemContents = pkcs8pem.split("\n").slice(1, -2).join("\n");
     const data = fromBase64(pemContents).toBuffer();
@@ -7690,9 +7726,11 @@ var importClient = async (input) => {
     const entries = isDir ? await (0, import_promises.readdir)(input) : [];
     const idFilename = entries.find((entry) => entry.includes("client_id"));
     const keyFilename = entries.find((entry) => entry.includes("private_key"));
-    const wvdFilename = entries.find((entry) => entry.endsWith("wvd"));
+    const packedFilename = entries.find(
+      (entry) => entry.endsWith("wvd") || entry.endsWith("azot")
+    );
     const isUnpacked = !!(idFilename && keyFilename);
-    const isPacked = !!wvdFilename;
+    const isPacked = !!packedFilename;
     if (isUnpacked) {
       const idPath = (0, import_node_path.join)(input, idFilename);
       const keyPath = (0, import_node_path.join)(input, keyFilename);
@@ -7700,9 +7738,10 @@ var importClient = async (input) => {
       const key = await (0, import_promises.readFile)(keyPath);
       return Client.fromUnpacked(id, key);
     } else if (isPacked) {
-      const wvdPath = (0, import_node_path.join)(input, wvdFilename);
-      const wvd = await (0, import_promises.readFile)(wvdPath);
-      return await Client.fromPacked(wvd);
+      const packedPath = (0, import_node_path.join)(input, packedFilename);
+      const packed = await (0, import_promises.readFile)(packedPath);
+      const ext = (0, import_node_path.extname)(packedPath);
+      return await Client.fromPacked(packed, ext);
     } else {
       console.log(`Unable to find client files in ${input}`);
       process.exit(1);
@@ -7728,13 +7767,16 @@ var help = () => {
     col(`info <input>`) + "print info about client that is on <input> path (*.wvd filepath or directory with id and private key)"
   );
   console.log(
-    col(`pack <input> <output>`) + "pack client id and private key from <input> directory into single *.wvd file with <output> path"
+    col(`pack <input> <output>`) + "pack client id and private key from <input> directory into single file with <output> path"
   );
   console.log(
-    col(`unpack <input> <output>`) + "unpack *.wvd from <input> path to separate client id and private key placed in <output> directory"
+    col(`unpack <input> <output>`) + "unpack from <input> path to separate client id and private key placed in <output> directory"
   );
   console.log("");
   console.log(`Flags:`);
+  console.log(
+    col(`-f, --format`) + "Specify format for pack command (wvd/azot)"
+  );
   console.log(col(`-h, --help`) + "Display this menu and exit");
 };
 
@@ -7749,13 +7791,14 @@ var info = async (input) => {
 // src/cli/commands/client/pack.ts
 var import_promises2 = require("fs/promises");
 var import_node_path2 = require("path");
-var pack = async (input = process.cwd(), output) => {
+var pack = async (input = process.cwd(), format, output) => {
   const client2 = await importClient(input);
-  const wvd = await client2.pack();
-  const wvdName = `${client2.info.get("company_name")}_${client2.info.get("model_name")}`;
-  const wvdOutput = output || (0, import_node_path2.join)(process.cwd(), `${wvdName}.wvd`);
-  await (0, import_promises2.writeFile)(wvdOutput, wvd);
-  console.log(`Client packed: ${wvdOutput}`);
+  const ext = format || (output ? (0, import_node_path2.extname)(output) : "azot");
+  const data = await client2.pack(ext);
+  const filename = `${client2.info.get("company_name")}-${client2.info.get("model_name")}`.replaceAll(" ", "-").toLowerCase();
+  const outputPath = output || (0, import_node_path2.join)(process.cwd(), `${filename}.${ext}`);
+  await (0, import_promises2.writeFile)(outputPath, data);
+  console.log(`Client packed: ${outputPath}`);
 };
 
 // src/cli/commands/client/unpack.ts
@@ -7820,8 +7863,8 @@ license.help = help2;
 // package.json
 var package_default = {
   name: "azot",
-  version: "0.8.0",
-  description: "Swiss Army knife for pentesting DRM systems",
+  version: "0.8.3",
+  description: "The ultimate toolkit for pentesting DRM systems",
   type: "module",
   files: [
     "dist",
@@ -8200,6 +8243,7 @@ var args = (0, import_node_util.parseArgs)({
     help: { type: "boolean", short: "h" },
     version: { type: "boolean", short: "v" },
     debug: { type: "boolean", short: "d" },
+    format: { type: "boolean", short: "f" },
     host: { type: "string" },
     port: { type: "string" },
     secret: { type: "string", short: "s" },
@@ -8255,7 +8299,7 @@ var help4 = () => {
       const [input, output] = positionals;
       switch (subcommand) {
         case "pack":
-          client.pack(input, output);
+          client.pack(input, args.values.format, output);
           break;
         case "unpack":
           client.unpack(input, output);

package/dist/lib/main.cjs

@@ -7236,6 +7236,7 @@ var Session = class extends EventTarget {
       deriveContext(licenseRequest.bytes)
     );
     this.dispatchEvent(new MessageEvent("license-request", message.bytes));
+    return message.bytes;
   }
   async waitForLicenseRequest() {
     return new Promise((resolve) => {
@@ -7362,6 +7363,9 @@ var Session = class extends EventTarget {
       "usable"
     );
   }
+  async getKeys() {
+    return Array.from(this.keys.values());
+  }
   close() {
     this.dispatchEvent(new Event("closed"));
     return Promise.resolve();
@@ -7408,36 +7412,47 @@ var connect = ({ baseUrl, secret }) => {
     "content-type": "application/json"
   };
   const json = (data) => JSON.stringify(data);
-  const post = async (route, body) => {
-    const response = await fetch(`${baseUrl}${route}`, {
-      method: "POST",
-      headers,
-      body: json(body)
-    });
-    const contentLength = response.headers.get("content-length");
-    if (contentLength === "0") return;
-    return response.json();
-  };
-  const get = async (route) => {
-    const response = await fetch(`${baseUrl}${route}`, {
-      method: "GET",
-      headers
-    });
-    return response.json();
+  const http = {
+    post: async (route, body) => {
+      const response = await fetch(`${baseUrl}${route}`, {
+        method: "POST",
+        headers,
+        body: json(body)
+      });
+      const contentLength = response.headers.get("content-length");
+      if (contentLength === "0") return;
+      return response.json();
+    },
+    get: async (route) => {
+      const response = await fetch(`${baseUrl}${route}`, {
+        method: "GET",
+        headers
+      });
+      return response.json();
+    },
+    delete: async (route) => {
+      await fetch(`${baseUrl}${route}`, { method: "DELETE", headers });
+    }
   };
-  const createSession = async (client) => {
-    const data = await post(`/session`, { client });
+  const createSession = async (sessionType, client) => {
+    const data = await http.post(`/session`, { client });
     const sessionId = data.id;
-    const generateRequest = async (initData, initDataType) => {
-      const data2 = await post(`/session/${sessionId}/generate-request`, {
+    const generateRequest = async (initDataType, initData) => {
+      const data2 = await http.post(`/session/${sessionId}/generate-request`, {
         initDataType,
-        initData
+        initData: fromBuffer(initData).toBase64()
       });
-      return data2.licenseRequest;
+      return fromBase64(data2.licenseRequest).toBuffer();
     };
-    const update = async (response) => post(`/session/${sessionId}/update`, { response });
-    const keys = async () => get(`/session/${sessionId}/keys`);
-    return { sessionId, generateRequest, update, keys };
+    const update = async (response) => {
+      await http.post(`/session/${sessionId}/update`, {
+        response: fromBuffer(response).toBase64()
+      });
+    };
+    const getKeys = async () => http.get(`/session/${sessionId}/keys`);
+    const close = async () => http.delete(`/session/${sessionId}/close`);
+    const remove = async () => http.delete(`/session/${sessionId}/remove`);
+    return { sessionId, generateRequest, update, getKeys, close, remove };
   };
   return { createSession };
 };
@@ -7551,18 +7566,34 @@ var Client = class _Client {
   vmp;
   info;
   #key;
-  static async fromPacked(data, format = "WVDv2") {
-    if (format !== "WVDv2") throw new Error("Only WVDv2 is supported");
-    const parsed = parseWvd(data);
-    const pcks1 = `-----BEGIN RSA PRIVATE KEY-----
+  static async fromPacked(data, format = "azot") {
+    const isWvd = fromBuffer(data.slice(0, 3)).toText() == "WVD";
+    if (format === "wvd" || isWvd) {
+      const parsed = parseWvd(data);
+      const pcks1 = `-----BEGIN RSA PRIVATE KEY-----
 ${fromBuffer(parsed.privateKey).toBase64()}
 -----END RSA PRIVATE KEY-----`;
-    const key = fromText(pcks1).toBuffer();
-    const type = types.get(parsed.deviceType);
-    const securityLevel = parsed.securityLevel;
-    const client = new _Client(parsed.clientId, type, securityLevel);
-    await client.importKey(key);
-    return client;
+      const key = fromText(pcks1).toBuffer();
+      const type = types.get(parsed.deviceType);
+      const securityLevel = parsed.securityLevel;
+      const client = new _Client(parsed.clientId, type, securityLevel);
+      await client.importKey(key);
+      return client;
+    } else if (format === "azot") {
+      const parsed = JSON.parse(fromBuffer(data).toText());
+      const clientId = ClientIdentification.fromObject(
+        parsed.data.clientIdentification
+      );
+      const client = new _Client(
+        clientId,
+        parsed.data.type,
+        parsed.data.securityLevel
+      );
+      await client.importKey(parsed.data.privateKey);
+      return client;
+    } else {
+      throw new Error("Unsupported format");
+    }
   }
   static async fromUnpacked(id, key, vmp) {
     const client = new _Client(id);
@@ -7578,7 +7609,7 @@ ${fromBuffer(parsed.privateKey).toBase64()}
     return this.#key;
   }
   constructor(id, type = CLIENT_TYPE.android, securityLevel = 3) {
-    this.id = ClientIdentification.decode(id);
+    this.id = ArrayBuffer.isView(id) ? ClientIdentification.decode(id) : id;
     this.signedDrmCertificate = SignedDrmCertificate.decode(this.id.token);
     this.drmCertificate = DrmCertificate.decode(
       this.signedDrmCertificate.drmCertificate
@@ -7595,23 +7626,39 @@ ${fromBuffer(parsed.privateKey).toBase64()}
     const key = await this.exportKey();
     return [id, key];
   }
-  async pack(format = "WVDv2") {
-    if (format !== "WVDv2") throw new Error("Only WVDv2 is supported");
-    const id = ClientIdentification.encode(this.id).finish();
-    const key = await this.exportKey();
-    const keyDer = fromBuffer(key).toText().split("\n").map((s) => s.trim()).slice(1, -1).join("\n");
-    const keyDerBinary = fromBase64(keyDer).toBuffer();
-    const [type] = types.entries().find(([, type2]) => type2 === this.type);
-    const wvd = buildWvd({
-      clientId: id,
-      deviceType: type,
-      securityLevel: this.securityLevel,
-      privateKey: keyDerBinary
-    });
-    return wvd;
+  async pack(format = "azot") {
+    if (format === "wvd") {
+      const id = ClientIdentification.encode(this.id).finish();
+      const key = await this.exportKey();
+      const keyDer = fromBuffer(key).toText().split("\n").map((s) => s.trim()).slice(1, -1).join("\n");
+      const keyDerBinary = fromBase64(keyDer).toBuffer();
+      const [type] = types.entries().find(([, type2]) => type2 === this.type);
+      const wvd = buildWvd({
+        clientId: id,
+        deviceType: type,
+        securityLevel: this.securityLevel,
+        privateKey: keyDerBinary
+      });
+      return wvd;
+    } else if (format === "azot") {
+      const clientIdentification = this.id.toJSON();
+      const privateKey = await this.exportKey();
+      const payload = {
+        version: 1,
+        type: "widevine-client",
+        data: {
+          clientIdentification,
+          privateKey: fromBuffer(privateKey).toText()
+        }
+      };
+      const data = JSON.stringify(payload, null, 2);
+      return fromText(data).toBuffer();
+    } else {
+      throw new Error("Unsupported format");
+    }
   }
   async importKey(pkcs1) {
-    const pkcs1pem = fromBuffer(pkcs1).toText();
+    const pkcs1pem = typeof pkcs1 === "string" ? pkcs1 : fromBuffer(pkcs1).toText();
     const pkcs8pem = toPKCS8(pkcs1pem);
     const pemContents = pkcs8pem.split("\n").slice(1, -2).join("\n");
     const data = fromBase64(pemContents).toBuffer();

package/dist/lib/main.d.cts

@@ -2326,7 +2326,7 @@ type SessionType = keyof typeof SESSION_TYPES;
 /**
  * https://www.w3.org/TR/encrypted-media-2/#mediakeysession-interface
  */
-declare class Session extends EventTarget implements MediaKeySession {
+declare class Session extends EventTarget {
     #private;
     readonly sessionId: string;
     readonly keyStatuses: MediaKeyStatusMap;
@@ -2340,10 +2340,11 @@ declare class Session extends EventTarget implements MediaKeySession {
     privacyMode?: boolean;
     constructor(sessionType: SessionType | undefined, client: Client);
     setLogger(logger: Logger): void;
-    generateRequest(initDataType: string, initData: BufferSource): Promise<void>;
+    generateRequest(initDataType: string, initData: BufferSource): Promise<Uint8Array | undefined>;
     waitForLicenseRequest(): Promise<Uint8Array>;
     load(): Promise<boolean>;
     update(response: Uint8Array): Promise<void>;
+    getKeys(): Promise<Key[]>;
     close(): Promise<void>;
     remove(): Promise<void>;
 }
@@ -2364,16 +2365,16 @@ declare class Client {
     systemId: number;
     vmp: FileHashes | null;
     info: Map<string, string>;
-    static fromPacked(data: Uint8Array, format?: 'WVDv2'): Promise<Client>;
+    static fromPacked(data: Uint8Array, format?: 'wvd' | 'azot'): Promise<Client>;
     static fromUnpacked(id: Uint8Array, key: Uint8Array, vmp?: Uint8Array): Promise<Client>;
     get key(): {
         forDecrypt: CryptoKey;
         forSign: CryptoKey;
     };
-    constructor(id: Uint8Array, type?: ClientType, securityLevel?: SecurityLevel);
+    constructor(id: Uint8Array | ClientIdentification, type?: ClientType, securityLevel?: SecurityLevel);
     unpack(): Promise<[id: Uint8Array, key: Uint8Array]>;
-    pack(format?: 'WVDv2'): Promise<Uint8Array>;
-    importKey(pkcs1: Uint8Array): Promise<{
+    pack(format?: 'wvd' | 'azot'): Promise<Uint8Array>;
+    importKey(pkcs1: Uint8Array | string): Promise<{
         forDecrypt: CryptoKey;
         forSign: CryptoKey;
     }>;
@@ -2401,11 +2402,13 @@ type ConnectParams = {
     secret: string;
 };
 declare const connect: ({ baseUrl, secret }: ConnectParams) => {
-    createSession: (client: string) => Promise<{
+    createSession: (sessionType: SessionType, client: string) => Promise<{
         sessionId: any;
-        generateRequest: (initData: string, initDataType: string) => Promise<any>;
-        update: (response: string) => Promise<any>;
-        keys: () => Promise<any>;
+        generateRequest: (initDataType: string, initData: Uint8Array) => Promise<Uint8Array>;
+        update: (response: Uint8Array) => Promise<void>;
+        getKeys: () => Promise<any>;
+        close: () => Promise<void>;
+        remove: () => Promise<void>;
     }>;
 };
 

package/dist/lib/main.d.ts

@@ -2326,7 +2326,7 @@ type SessionType = keyof typeof SESSION_TYPES;
 /**
  * https://www.w3.org/TR/encrypted-media-2/#mediakeysession-interface
  */
-declare class Session extends EventTarget implements MediaKeySession {
+declare class Session extends EventTarget {
     #private;
     readonly sessionId: string;
     readonly keyStatuses: MediaKeyStatusMap;
@@ -2340,10 +2340,11 @@ declare class Session extends EventTarget implements MediaKeySession {
     privacyMode?: boolean;
     constructor(sessionType: SessionType | undefined, client: Client);
     setLogger(logger: Logger): void;
-    generateRequest(initDataType: string, initData: BufferSource): Promise<void>;
+    generateRequest(initDataType: string, initData: BufferSource): Promise<Uint8Array | undefined>;
     waitForLicenseRequest(): Promise<Uint8Array>;
     load(): Promise<boolean>;
     update(response: Uint8Array): Promise<void>;
+    getKeys(): Promise<Key[]>;
     close(): Promise<void>;
     remove(): Promise<void>;
 }
@@ -2364,16 +2365,16 @@ declare class Client {
     systemId: number;
     vmp: FileHashes | null;
     info: Map<string, string>;
-    static fromPacked(data: Uint8Array, format?: 'WVDv2'): Promise<Client>;
+    static fromPacked(data: Uint8Array, format?: 'wvd' | 'azot'): Promise<Client>;
     static fromUnpacked(id: Uint8Array, key: Uint8Array, vmp?: Uint8Array): Promise<Client>;
     get key(): {
         forDecrypt: CryptoKey;
         forSign: CryptoKey;
     };
-    constructor(id: Uint8Array, type?: ClientType, securityLevel?: SecurityLevel);
+    constructor(id: Uint8Array | ClientIdentification, type?: ClientType, securityLevel?: SecurityLevel);
     unpack(): Promise<[id: Uint8Array, key: Uint8Array]>;
-    pack(format?: 'WVDv2'): Promise<Uint8Array>;
-    importKey(pkcs1: Uint8Array): Promise<{
+    pack(format?: 'wvd' | 'azot'): Promise<Uint8Array>;
+    importKey(pkcs1: Uint8Array | string): Promise<{
         forDecrypt: CryptoKey;
         forSign: CryptoKey;
     }>;
@@ -2401,11 +2402,13 @@ type ConnectParams = {
     secret: string;
 };
 declare const connect: ({ baseUrl, secret }: ConnectParams) => {
-    createSession: (client: string) => Promise<{
+    createSession: (sessionType: SessionType, client: string) => Promise<{
         sessionId: any;
-        generateRequest: (initData: string, initDataType: string) => Promise<any>;
-        update: (response: string) => Promise<any>;
-        keys: () => Promise<any>;
+        generateRequest: (initDataType: string, initData: Uint8Array) => Promise<Uint8Array>;
+        update: (response: Uint8Array) => Promise<void>;
+        getKeys: () => Promise<any>;
+        close: () => Promise<void>;
+        remove: () => Promise<void>;
     }>;
 };
 

package/dist/lib/main.js

@@ -7190,6 +7190,7 @@ var Session = class extends EventTarget {
       deriveContext(licenseRequest.bytes)
     );
     this.dispatchEvent(new MessageEvent("license-request", message.bytes));
+    return message.bytes;
   }
   async waitForLicenseRequest() {
     return new Promise((resolve) => {
@@ -7316,6 +7317,9 @@ var Session = class extends EventTarget {
       "usable"
     );
   }
+  async getKeys() {
+    return Array.from(this.keys.values());
+  }
   close() {
     this.dispatchEvent(new Event("closed"));
     return Promise.resolve();
@@ -7362,36 +7366,47 @@ var connect = ({ baseUrl, secret }) => {
     "content-type": "application/json"
   };
   const json = (data) => JSON.stringify(data);
-  const post = async (route, body) => {
-    const response = await fetch(`${baseUrl}${route}`, {
-      method: "POST",
-      headers,
-      body: json(body)
-    });
-    const contentLength = response.headers.get("content-length");
-    if (contentLength === "0") return;
-    return response.json();
-  };
-  const get = async (route) => {
-    const response = await fetch(`${baseUrl}${route}`, {
-      method: "GET",
-      headers
-    });
-    return response.json();
+  const http = {
+    post: async (route, body) => {
+      const response = await fetch(`${baseUrl}${route}`, {
+        method: "POST",
+        headers,
+        body: json(body)
+      });
+      const contentLength = response.headers.get("content-length");
+      if (contentLength === "0") return;
+      return response.json();
+    },
+    get: async (route) => {
+      const response = await fetch(`${baseUrl}${route}`, {
+        method: "GET",
+        headers
+      });
+      return response.json();
+    },
+    delete: async (route) => {
+      await fetch(`${baseUrl}${route}`, { method: "DELETE", headers });
+    }
   };
-  const createSession = async (client) => {
-    const data = await post(`/session`, { client });
+  const createSession = async (sessionType, client) => {
+    const data = await http.post(`/session`, { client });
     const sessionId = data.id;
-    const generateRequest = async (initData, initDataType) => {
-      const data2 = await post(`/session/${sessionId}/generate-request`, {
+    const generateRequest = async (initDataType, initData) => {
+      const data2 = await http.post(`/session/${sessionId}/generate-request`, {
         initDataType,
-        initData
+        initData: fromBuffer(initData).toBase64()
       });
-      return data2.licenseRequest;
+      return fromBase64(data2.licenseRequest).toBuffer();
     };
-    const update = async (response) => post(`/session/${sessionId}/update`, { response });
-    const keys = async () => get(`/session/${sessionId}/keys`);
-    return { sessionId, generateRequest, update, keys };
+    const update = async (response) => {
+      await http.post(`/session/${sessionId}/update`, {
+        response: fromBuffer(response).toBase64()
+      });
+    };
+    const getKeys = async () => http.get(`/session/${sessionId}/keys`);
+    const close = async () => http.delete(`/session/${sessionId}/close`);
+    const remove = async () => http.delete(`/session/${sessionId}/remove`);
+    return { sessionId, generateRequest, update, getKeys, close, remove };
   };
   return { createSession };
 };
@@ -7505,18 +7520,34 @@ var Client = class _Client {
   vmp;
   info;
   #key;
-  static async fromPacked(data, format = "WVDv2") {
-    if (format !== "WVDv2") throw new Error("Only WVDv2 is supported");
-    const parsed = parseWvd(data);
-    const pcks1 = `-----BEGIN RSA PRIVATE KEY-----
+  static async fromPacked(data, format = "azot") {
+    const isWvd = fromBuffer(data.slice(0, 3)).toText() == "WVD";
+    if (format === "wvd" || isWvd) {
+      const parsed = parseWvd(data);
+      const pcks1 = `-----BEGIN RSA PRIVATE KEY-----
 ${fromBuffer(parsed.privateKey).toBase64()}
 -----END RSA PRIVATE KEY-----`;
-    const key = fromText(pcks1).toBuffer();
-    const type = types.get(parsed.deviceType);
-    const securityLevel = parsed.securityLevel;
-    const client = new _Client(parsed.clientId, type, securityLevel);
-    await client.importKey(key);
-    return client;
+      const key = fromText(pcks1).toBuffer();
+      const type = types.get(parsed.deviceType);
+      const securityLevel = parsed.securityLevel;
+      const client = new _Client(parsed.clientId, type, securityLevel);
+      await client.importKey(key);
+      return client;
+    } else if (format === "azot") {
+      const parsed = JSON.parse(fromBuffer(data).toText());
+      const clientId = ClientIdentification.fromObject(
+        parsed.data.clientIdentification
+      );
+      const client = new _Client(
+        clientId,
+        parsed.data.type,
+        parsed.data.securityLevel
+      );
+      await client.importKey(parsed.data.privateKey);
+      return client;
+    } else {
+      throw new Error("Unsupported format");
+    }
   }
   static async fromUnpacked(id, key, vmp) {
     const client = new _Client(id);
@@ -7532,7 +7563,7 @@ ${fromBuffer(parsed.privateKey).toBase64()}
     return this.#key;
   }
   constructor(id, type = CLIENT_TYPE.android, securityLevel = 3) {
-    this.id = ClientIdentification.decode(id);
+    this.id = ArrayBuffer.isView(id) ? ClientIdentification.decode(id) : id;
     this.signedDrmCertificate = SignedDrmCertificate.decode(this.id.token);
     this.drmCertificate = DrmCertificate.decode(
       this.signedDrmCertificate.drmCertificate
@@ -7549,23 +7580,39 @@ ${fromBuffer(parsed.privateKey).toBase64()}
     const key = await this.exportKey();
     return [id, key];
   }
-  async pack(format = "WVDv2") {
-    if (format !== "WVDv2") throw new Error("Only WVDv2 is supported");
-    const id = ClientIdentification.encode(this.id).finish();
-    const key = await this.exportKey();
-    const keyDer = fromBuffer(key).toText().split("\n").map((s) => s.trim()).slice(1, -1).join("\n");
-    const keyDerBinary = fromBase64(keyDer).toBuffer();
-    const [type] = types.entries().find(([, type2]) => type2 === this.type);
-    const wvd = buildWvd({
-      clientId: id,
-      deviceType: type,
-      securityLevel: this.securityLevel,
-      privateKey: keyDerBinary
-    });
-    return wvd;
+  async pack(format = "azot") {
+    if (format === "wvd") {
+      const id = ClientIdentification.encode(this.id).finish();
+      const key = await this.exportKey();
+      const keyDer = fromBuffer(key).toText().split("\n").map((s) => s.trim()).slice(1, -1).join("\n");
+      const keyDerBinary = fromBase64(keyDer).toBuffer();
+      const [type] = types.entries().find(([, type2]) => type2 === this.type);
+      const wvd = buildWvd({
+        clientId: id,
+        deviceType: type,
+        securityLevel: this.securityLevel,
+        privateKey: keyDerBinary
+      });
+      return wvd;
+    } else if (format === "azot") {
+      const clientIdentification = this.id.toJSON();
+      const privateKey = await this.exportKey();
+      const payload = {
+        version: 1,
+        type: "widevine-client",
+        data: {
+          clientIdentification,
+          privateKey: fromBuffer(privateKey).toText()
+        }
+      };
+      const data = JSON.stringify(payload, null, 2);
+      return fromText(data).toBuffer();
+    } else {
+      throw new Error("Unsupported format");
+    }
   }
   async importKey(pkcs1) {
-    const pkcs1pem = fromBuffer(pkcs1).toText();
+    const pkcs1pem = typeof pkcs1 === "string" ? pkcs1 : fromBuffer(pkcs1).toText();
     const pkcs8pem = toPKCS8(pkcs1pem);
     const pemContents = pkcs8pem.split("\n").slice(1, -2).join("\n");
     const data = fromBase64(pemContents).toBuffer();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "azot",
-  "version": "0.8.0",
-  "description": "Swiss Army knife for pentesting DRM systems",
+  "version": "0.8.3",
+  "description": "The ultimate toolkit for pentesting DRM systems",
   "type": "module",
   "files": [
     "dist",