Source: lib/util/xml_utils.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.util.XmlUtils');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.log');
  11. goog.require('shaka.util.Lazy');
  12. goog.require('shaka.util.StringUtils');
  15. /**
  16.  * @summary A set of XML utility functions.
  17.  */
  18. shaka.util.XmlUtils = class {
  19.   /**
  20.    * Parse a string and return the resulting root element if it was valid XML.
  21.    *
  22.    * @param {string} xmlString
  23.    * @param {string} expectedRootElemName
  24.    * @return {Element}
  25.    */
  26.   static parseXmlString(xmlString, expectedRootElemName) {
  27.     const parser = new DOMParser();
  28.     const unsafeXmlString =
  29.         shaka.util.XmlUtils.trustedHTMLFromString_.value()(xmlString);
  30.     let unsafeXml = null;
  31.     try {
  32.       unsafeXml = parser.parseFromString(unsafeXmlString, 'text/xml');
  33.     } catch (exception) {
  34.       shaka.log.error('XML parsing exception:', exception);
  35.       return null;
  36.     }
  38.     // According to MDN, parseFromString never returns null.
  39.     goog.asserts.assert(unsafeXml, 'Parsed XML document cannot be null!');
  41.     // Check for empty documents.
  42.     const rootElem = unsafeXml.documentElement;
  43.     if (!rootElem) {
  44.       shaka.log.error('XML document was empty!');
  45.       return null;
  46.     }
  48.     // Check for parser errors.
  49.     const parserErrorElements = rootElem.getElementsByTagName('parsererror');
  50.     if (parserErrorElements.length) {
  51.       shaka.log.error('XML parser error found:', parserErrorElements[0]);
  52.       return null;
  53.     }
  55.     // The top-level element in the loaded XML should have the name we expect.
  56.     if (rootElem.tagName != expectedRootElemName) {
  57.       shaka.log.error(
  58.           `XML tag name does not match expected "${expectedRootElemName}":`,
  59.           rootElem.tagName);
  60.       return null;
  61.     }
  63.     // Cobalt browser doesn't support document.createNodeIterator.
  64.     if (!('createNodeIterator' in document)) {
  65.       return rootElem;
  66.     }
  68.     // SECURITY: Verify that the document does not contain elements from the
  69.     // HTML or SVG namespaces, which could trigger script execution and XSS.
  70.     const iterator = document.createNodeIterator(
  71.         unsafeXml,
  72.         NodeFilter.SHOW_ALL,
  73.     );
  74.     let currentNode;
  75.     while (currentNode = iterator.nextNode()) {
  76.       if (currentNode instanceof HTMLElement ||
  77.           currentNode instanceof SVGElement) {
  78.         shaka.log.error('XML document embeds unsafe content!');
  79.         return null;
  80.       }
  81.     }
  83.     return rootElem;
  84.   }
  87.   /**
  88.    * Parse some data (auto-detecting the encoding) and return the resulting
  89.    * root element if it was valid XML.
  90.    * @param {BufferSource} data
  91.    * @param {string} expectedRootElemName
  92.    * @return {Element}
  93.    */
  94.   static parseXml(data, expectedRootElemName) {
  95.     try {
  96.       const string = shaka.util.StringUtils.fromBytesAutoDetect(data);
  97.       return shaka.util.XmlUtils.parseXmlString(string, expectedRootElemName);
  98.     } catch (exception) {
  99.       shaka.log.error('parseXmlString threw!', exception);
  100.       return null;
  101.     }
  102.   }
  105.   /**
  106.    * Converts a Element to BufferSource.
  107.    * @param {!Element} elem
  108.    * @return {!ArrayBuffer}
  109.    */
  110.   static toArrayBuffer(elem) {
  111.     return shaka.util.StringUtils.toUTF8(elem.outerHTML);
  112.   }
  113. };
  115. /**
  116.  * Promote a string to TrustedHTML. This function is security-sensitive and
  117.  * should only be used with security approval where the string is guaranteed not
  118.  * to cause an XSS vulnerability.
  119.  *
  120.  * @private {!shaka.util.Lazy.<function(!string): (!TrustedHTML|!string)>}
  121.  */
  122. shaka.util.XmlUtils.trustedHTMLFromString_ = new shaka.util.Lazy(() => {
  123.   if (typeof trustedTypes !== 'undefined') {
  124.     // Create a Trusted Types policy for promoting the string to TrustedHTML.
  125.     // The Lazy wrapper ensures this policy is only created once.
  126.     const policy = trustedTypes.createPolicy('shaka-player#xml', {
  127.       createHTML: (s) => s,
  128.     });
  129.     return (s) => policy.createHTML(s);
  130.   }
  131.   // Fall back to strings in environments that don't support Trusted Types.
  132.   return (s) => s;
  133. });