msl_client.js

function arrayBufferToBase64(buffer) {
  var binary = "";
  var bytes = new Uint8Array(buffer);
  var len = bytes.byteLength;
  for (var i = 0; i < len; i++) {
    binary += String.fromCharCode(bytes[i]);
  }

  return btoa(binary);
}

function base64ToArrayBuffer(b64) {
  var byteString = atob(b64);
  var byteArray = new Uint8Array(byteString.length);
  for (var i = 0; i < byteString.length; i++) {
    byteArray[i] = byteString.charCodeAt(i);
  }

  return byteArray;
}

function arrayBufferToString(buffer) {
  var arr = new Uint8Array(buffer);
  var str = String.fromCharCode.apply(String, arr);
  if (/[\u0080-\uffff]/.test(str)) {
    throw new Error("this string seems to contain (still encoded) multibytes");
  }

  return str;
}

function padBase64(b64) {
  var l = b64.length % 4;
  if (l == 2) {
    b64 += "==";
  } else if (l == 3) {
    b64 += "=";
  }

  return b64.replace(/-/g, "+").replace(/_/g, "/");
}

function generateEsn() {
  var text = "";
  var possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

  for (var i = 0; i < 30; i++)
    text += possible.charAt(Math.floor(Math.random() * possible.length));

  return text;
}

var manifestUrl =
  "https://www.netflix.com/nq/msl_v1/cadmium/pbo_manifests/^1.0.0/router";
var licenseUrl =
  "https://www.netflix.com/nq/msl_v1/cadmium/pbo_licenses/^1.0.0/router";
var shaktiMetadataUrl = (movieId) =>
  `https://www.netflix.com/nq/website/memberapi/v726683ab/metadata?webp=true&drmSystem=widevine&isVolatileBillboardsEnabled=true&routeAPIRequestsThroughFTL=false&isTop10Supported=true&isTop10KidsSupported=false&hasVideoMerchInBob=true&hasVideoMerchInJaw=true&persoInfoDensity=false&infoDensityToggle=false&contextAwareImages=true&enableMultiLanguageCatalog=false&usePreviewModal=true&movieid=${movieId}&imageFormat=webp&&withSize=true&materialize=true`;
//var defaultEsn = "NFCDFF-02-" + generateEsn();
var defaultEsn = "NFCDFF-02-GTP5ED21NYP055242EU63FDQKYQ2FM";
var profiles = [
  "heaac-2-dash",
  "heaac-2hq-dash",
  "playready-h264mpl30-dash",
  "playready-h264mpl31-dash",
  "playready-h264hpl30-dash",
  "playready-h264hpl31-dash",
  "playready-h264mpl40-dash",
  "playready-h264hpl40-dash",
  "vp9-profile0-L30-dash-cenc",
  "vp9-profile0-L31-dash-cenc",
  "vp9-profile0-L40-dash-cenc",
  "ddplus-2.0-dash",
  "ddplus-5.1-dash",
  "dfxp-ls-sdh",
  "simplesdh",
  "nflx-cmisc",
  "BIF240",
  "BIF320",
];

var messageid = Math.floor(Math.random() * 2 ** 52);
var metadata = null;
var header = {
  sender: defaultEsn,
  renewable: true,
  capabilities: {
    languages: ["en-US"],
    compressionalgos: [""],
  },
  messageid: messageid,
};

async function getViewableId(viewableIdPath) {
  console.log("Getting video metadata for ID " + viewableIdPath);

  var apiResp = await fetch(shaktiMetadataUrl(viewableIdPath), {
    credentials: "same-origin",
    method: "GET",
  });

  var apiJson = await apiResp.json();
  console.log("viewable id response:");
  console.log(apiJson);

  var viewableId = apiJson.video.currentEpisode;
  if (!viewableId) {
    viewableId = parseInt(viewableIdPath);
  }

  return viewableId;
}

async function getMetadata() {
  const viewableIdPath = window.location.pathname.substring(7, 15);
  console.log("Getting video metadata for ID " + viewableIdPath);

  var apiResp = await fetch(shaktiMetadataUrl(viewableIdPath), {
    credentials: "same-origin",
    method: "GET",
  });

  var apiJson = await apiResp.json();
  console.log("metadata response:");
  console.log(apiJson);

  return apiJson;
}

async function performKeyExchange() {
  delete header.userauthdata;
  var keyPair = await window.crypto.subtle.generateKey(
    {
      name: "RSA-OAEP",
      modulusLength: 2048,
      publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
      hash: {
        name: "SHA-1",
      },
    },
    false,
    ["encrypt", "decrypt"]
  );

  var publicKey = await window.crypto.subtle.exportKey(
    "spki",
    keyPair.publicKey
  );

  header.keyrequestdata = [
    {
      scheme: "ASYMMETRIC_WRAPPED",
      keydata: {
        publickey: arrayBufferToBase64(publicKey),
        mechanism: "JWK_RSA",
        keypairid: "rsaKeypairId",
      },
    },
  ];

  var headerenvelope = {
    entityauthdata: {
      scheme: "NONE",
      authdata: {
        identity: defaultEsn,
      },
    },
    signature: "",
  };

  headerenvelope.headerdata = btoa(JSON.stringify(header));

  var payload = {
    signature: "",
  };

  payload.payload = btoa(
    JSON.stringify({
      sequencenumber: 1,
      messageid: messageid,
      endofmsg: true,
      data: "",
    })
  );

  var request = JSON.stringify(headerenvelope) + JSON.stringify(payload);

  var handshakeResp = await fetch(manifestUrl, {
    body: request,
    method: "POST",
  });

  var handshakeJson = await handshakeResp.json();
  if (!handshakeJson.headerdata) {
    console.error(JSON.parse(atob(handshakeJson.errordata)));
    throw "Error parsing key exchange response";
  }

  var headerdata = JSON.parse(atob(handshakeJson.headerdata));
  var encryptionKeyData = await window.crypto.subtle.decrypt(
    {
      name: "RSA-OAEP",
    },
    keyPair.privateKey,
    base64ToArrayBuffer(headerdata.keyresponsedata.keydata.encryptionkey)
  );

  encryptionKeyData = JSON.parse(arrayBufferToString(encryptionKeyData));

  var signKeyData = await window.crypto.subtle.decrypt(
    {
      name: "RSA-OAEP",
    },
    keyPair.privateKey,
    base64ToArrayBuffer(headerdata.keyresponsedata.keydata.hmackey)
  );

  signKeyData = JSON.parse(arrayBufferToString(signKeyData));

  return {
    headerdata: headerdata,
    encryptionKeyData: encryptionKeyData,
    signKeyData: signKeyData,
  };
}

async function generateMslRequestData(data) {
  var iv = window.crypto.getRandomValues(new Uint8Array(16));
  var aesCbc = new aesjs.ModeOfOperation.cbc(
    base64ToArrayBuffer(padBase64(encryptionKeyData.k)),
    iv
  );

  var textBytes = aesjs.utils.utf8.toBytes(JSON.stringify(header));
  var encrypted = aesCbc.encrypt(aesjs.padding.pkcs7.pad(textBytes));
  var encryptionEnvelope = {
    keyid: defaultEsn + "_" + sequenceNumber,
    sha256: "AA==",
    iv: arrayBufferToBase64(iv),
    ciphertext: arrayBufferToBase64(encrypted),
  };

  var shaObj = new jsSHA("SHA-256", "TEXT");
  shaObj.setHMACKey(padBase64(signKeyData.k), "B64");
  shaObj.update(JSON.stringify(encryptionEnvelope));
  var signature = shaObj.getHMAC("B64");
  var encryptedHeader = {
    signature: signature,
    mastertoken: mastertoken,
  };

  encryptedHeader.headerdata = btoa(JSON.stringify(encryptionEnvelope));

  var firstPayload = {
    messageid: messageid,
    data: btoa(JSON.stringify(data)),
    sequencenumber: 1,
    endofmsg: true,
  };

  iv = window.crypto.getRandomValues(new Uint8Array(16));
  aesCbc = new aesjs.ModeOfOperation.cbc(
    base64ToArrayBuffer(padBase64(encryptionKeyData.k)),
    iv
  );

  textBytes = aesjs.utils.utf8.toBytes(JSON.stringify(firstPayload));
  encrypted = aesCbc.encrypt(aesjs.padding.pkcs7.pad(textBytes));

  encryptionEnvelope = {
    keyid: defaultEsn + "_" + sequenceNumber,
    sha256: "AA==",
    iv: arrayBufferToBase64(iv),
    ciphertext: arrayBufferToBase64(encrypted),
  };

  shaObj = new jsSHA("SHA-256", "TEXT");
  shaObj.setHMACKey(padBase64(signKeyData.k), "B64");
  shaObj.update(JSON.stringify(encryptionEnvelope));
  signature = shaObj.getHMAC("B64");

  var firstPayloadChunk = {
    signature: signature,
    payload: btoa(JSON.stringify(encryptionEnvelope)),
  };

  return JSON.stringify(encryptedHeader) + JSON.stringify(firstPayloadChunk);
}

async function decryptMslResponse(data) {
  try {
    JSON.parse(data);
    console.error(JSON.parse(atob(JSON.parse(data).errordata)));
    throw "Error parsing data";
  } catch (e) {}

  var pattern = /,"signature":"[0-9A-Za-z/+=]+"}/;
  var payloadsSplit = data.split("}}")[1].split(pattern);
  payloadsSplit.pop();
  var payloadChunks = [];
  for (var i = 0; i < payloadsSplit.length; i++) {
    payloadChunks.push(payloadsSplit[i] + "}");
  }

  var chunks = "";
  for (i = 0; i < payloadChunks.length; i++) {
    var payloadchunk = JSON.parse(payloadChunks[i]);
    encryptionEnvelope = atob(payloadchunk.payload);
    aesCbc = new aesjs.ModeOfOperation.cbc(
      base64ToArrayBuffer(padBase64(encryptionKeyData.k)),
      base64ToArrayBuffer(JSON.parse(encryptionEnvelope).iv)
    );

    var ciphertext = base64ToArrayBuffer(
      JSON.parse(encryptionEnvelope).ciphertext
    );

    var plaintext = JSON.parse(
      arrayBufferToString(aesjs.padding.pkcs7.strip(aesCbc.decrypt(ciphertext)))
    );

    chunks += atob(plaintext.data);
  }

  var decrypted = JSON.parse(chunks);

  if (!decrypted.result) {
    console.error(decrypted);
    throw "Error parsing decrypted data";
  }

  return decrypted.result;
}

async function getManifest(esn = defaultEsn, id) {
  defaultEsn = esn;
  console.log("Performing key exchange");
  keyExchangeData = await performKeyExchange();
  console.log("Key exchange data:");
  console.log(keyExchangeData);

  headerdata = keyExchangeData.headerdata;
  encryptionKeyData = keyExchangeData.encryptionKeyData;
  signKeyData = keyExchangeData.signKeyData;
  mastertoken = headerdata.keyresponsedata.mastertoken;
  sequenceNumber = JSON.parse(atob(mastertoken.tokendata)).sequencenumber;
  viewableIdPath = window.location.pathname.substring(7, 15);
  viewableId = id ? id : await getViewableId(viewableIdPath);

  localeId = "en-US";

  var manifestRequestData = {
    version: 2,
    url: "/manifest",
    id: Date.now(),
    esn: defaultEsn,
    languages: [localeId],
    uiVersion: "shakti-v6a5172d2",
    clientVersion: "6.0026.529.051",
    params: {
      type: "standard",
      viewableId: viewableId,
      profiles: [
        "heaac-2-dash",
        "heaac-2hq-dash",
        "playready-h264mpl30-dash",
        "playready-h264mpl31-dash",
        "playready-h264mpl40-dash",
        "playready-h264hpl30-dash",
        "playready-h264hpl31-dash",
        "playready-h264hpl40-dash",
        "ddplus-2.0-dash",
        "ddplus-5.1-dash",
        "heaac-5.1-dash",
        "dfxp-ls-sdh",
        "simplesdh",
        "nflx-cmisc",
        "BIF240",
        "BIF320",
      ],
      flavor: "STANDARD",
      drmType: "widevine",
      drmVersion: 25,
      usePsshBox: true,
      isBranching: false,
      useHttpsStreams: true,
      supportsUnequalizedDownloadables: true,
      imageSubtitleHeight: 720,
      uiVersion: "shakti-v6a5172d2",
      uiPlatform: "SHAKTI",
      clientVersion: "6.0026.529.051",
      supportsPreReleasePin: true,
      supportsWatermark: true,
      showAllSubDubTracks: false,
      videoOutputInfo: [
        {
          type: "DigitalVideoOutputDescriptor",
          outputType: "unknown",
          supportedHdcpVersions: ["1.4"],
          isHdcpEngaged: true,
        },
      ],
      titleSpecificData: {
        80070182: {
          unletterboxed: false,
        },
      },
      preferAssistiveAudio: false,
      isUIAutoPlay: false,
      isNonMember: false,
      desiredVmaf: "plus_lts",
    },
  };

  header.userauthdata = {
    scheme: "NETFLIXID",
    authdata: {},
  };

  var encryptedManifestRequest = await generateMslRequestData(
    manifestRequestData
  );

  var manifestResp = await fetch(manifestUrl, {
    body: encryptedManifestRequest,
    credentials: "same-origin",
    method: "POST",
    headers: {
      "Content-Type": "application/json",
    },
  });

  manifestResp = await manifestResp.text();
  var manifest = await decryptMslResponse(manifestResp);

  console.log("Manifest:");
  console.log(manifest);

  licensePath = manifest.links.license.href;

  if (manifest.video_tracks.length > 1) {
    console.warn(`There are ${manifest.video_tracks.length} video tracks!`);
  }

  const videoStream =
    manifest.video_tracks[0].streams[
      manifest.video_tracks[0].streams.length - 1
    ];
  console.log(
    `Highest stream resolution is ${videoStream.res_w}x${videoStream.res_h}`
  );

  return manifest;
}

window.getManifest = getManifest;

async function getLicense(challenge, sessionId) {
  licenseRequestData = {
    version: 2,
    url: licensePath,
    id: Date.now(),
    esn: defaultEsn,
    languages: [localeId],
    uiVersion: "v6a5172d2",
    clientVersion: "6.0015.328.011",
    params: [
      {
        sessionId: sessionId,
        clientTime: Math.floor(Date.now() / 1000),
        challengeBase64: challenge,
        xid: Math.floor((Math.floor(Date.now() / 1000) + 0.1612) * 1000),
      },
    ],
    echo: "sessionId",
  };

  var encryptedLicenseRequest = await generateMslRequestData(
    licenseRequestData
  );
  var licenseResp = await fetch(licenseUrl, {
    body: encryptedLicenseRequest,
    credentials: "same-origin",
    method: "POST",
    headers: {
      "Content-Type": "application/json",
    },
  });

  licenseResp = await licenseResp.text();
  var license = await decryptMslResponse(licenseResp);

  console.log("License:");
  console.log(license);

  return license;
}