@angular/core
Version:
Angular - the core framework
213 lines • 22.9 kB
JavaScript
/**
* @fileoverview added by tsickle
* Generated from: packages/core/src/sanitization/inert_body.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
/**
* This helper class is used to get hold of an inert tree of DOM elements containing dirty HTML
* that needs sanitizing.
* Depending upon browser support we must use one of three strategies for doing this.
* Support: Safari 10.x -> XHR strategy
* Support: Firefox -> DomParser strategy
* Default: InertDocument strategy
*/
export class InertBodyHelper {
/**
* @param {?} defaultDoc
*/
constructor(defaultDoc) {
this.defaultDoc = defaultDoc;
this.inertDocument = this.defaultDoc.implementation.createHTMLDocument('sanitization-inert');
/** @type {?} */
let inertBodyElement = this.inertDocument.body;
if (inertBodyElement == null) {
// usually there should be only one body element in the document, but IE doesn't have any, so
// we need to create one.
/** @type {?} */
const inertHtml = this.inertDocument.createElement('html');
this.inertDocument.appendChild(inertHtml);
inertBodyElement = this.inertDocument.createElement('body');
inertHtml.appendChild(inertBodyElement);
}
inertBodyElement.innerHTML = '<svg><g onload="this.parentNode.remove()"></g></svg>';
if (inertBodyElement.querySelector && !inertBodyElement.querySelector('svg')) {
// We just hit the Safari 10.1 bug - which allows JS to run inside the SVG G element
// so use the XHR strategy.
this.getInertBodyElement = this.getInertBodyElement_XHR;
return;
}
inertBodyElement.innerHTML = '<svg><p><style><img src="</style><img src=x onerror=alert(1)//">';
if (inertBodyElement.querySelector && inertBodyElement.querySelector('svg img')) {
// We just hit the Firefox bug - which prevents the inner img JS from being sanitized
// so use the DOMParser strategy, if it is available.
// If the DOMParser is not available then we are not in Firefox (Server/WebWorker?) so we
// fall through to the default strategy below.
if (isDOMParserAvailable()) {
this.getInertBodyElement = this.getInertBodyElement_DOMParser;
return;
}
}
// None of the bugs were hit so it is safe for us to use the default InertDocument strategy
this.getInertBodyElement = this.getInertBodyElement_InertDocument;
}
/**
* Use XHR to create and fill an inert body element (on Safari 10.1)
* See
* https://github.com/cure53/DOMPurify/blob/a992d3a75031cb8bb032e5ea8399ba972bdf9a65/src/purify.js#L439-L449
* @private
* @param {?} html
* @return {?}
*/
getInertBodyElement_XHR(html) {
// We add these extra elements to ensure that the rest of the content is parsed as expected
// e.g. leading whitespace is maintained and tags like `<meta>` do not get hoisted to the
// `<head>` tag.
html = '<body><remove></remove>' + html + '</body>';
try {
html = encodeURI(html);
}
catch (_a) {
return null;
}
/** @type {?} */
const xhr = new XMLHttpRequest();
xhr.responseType = 'document';
xhr.open('GET', 'data:text/html;charset=utf-8,' + html, false);
xhr.send(undefined);
/** @type {?} */
const body = xhr.response.body;
body.removeChild((/** @type {?} */ (body.firstChild)));
return body;
}
/**
* Use DOMParser to create and fill an inert body element (on Firefox)
* See https://github.com/cure53/DOMPurify/releases/tag/0.6.7
*
* @private
* @param {?} html
* @return {?}
*/
getInertBodyElement_DOMParser(html) {
// We add these extra elements to ensure that the rest of the content is parsed as expected
// e.g. leading whitespace is maintained and tags like `<meta>` do not get hoisted to the
// `<head>` tag.
html = '<body><remove></remove>' + html + '</body>';
try {
/** @type {?} */
const body = (/** @type {?} */ (new ((/** @type {?} */ (window))).DOMParser().parseFromString(html, 'text/html').body));
body.removeChild((/** @type {?} */ (body.firstChild)));
return body;
}
catch (_a) {
return null;
}
}
/**
* Use an HTML5 `template` element, if supported, or an inert body element created via
* `createHtmlDocument` to create and fill an inert DOM element.
* This is the default sane strategy to use if the browser does not require one of the specialised
* strategies above.
* @private
* @param {?} html
* @return {?}
*/
getInertBodyElement_InertDocument(html) {
// Prefer using <template> element if supported.
/** @type {?} */
const templateEl = this.inertDocument.createElement('template');
if ('content' in templateEl) {
templateEl.innerHTML = html;
return templateEl;
}
// Note that previously we used to do something like `this.inertDocument.body.innerHTML = html`
// and we returned the inert `body` node. This was changed, because IE seems to treat setting
// `innerHTML` on an inserted element differently, compared to one that hasn't been inserted
// yet. In particular, IE appears to split some of the text into multiple text nodes rather
// than keeping them in a single one which ends up messing with Ivy's i18n parsing further
// down the line. This has been worked around by creating a new inert `body` and using it as
// the root node in which we insert the HTML.
/** @type {?} */
const inertBody = this.inertDocument.createElement('body');
inertBody.innerHTML = html;
// Support: IE 9-11 only
// strip custom-namespaced attributes on IE<=11
if (((/** @type {?} */ (this.defaultDoc))).documentMode) {
this.stripCustomNsAttrs(inertBody);
}
return inertBody;
}
/**
* When IE9-11 comes across an unknown namespaced attribute e.g. 'xlink:foo' it adds 'xmlns:ns1'
* attribute to declare ns1 namespace and prefixes the attribute with 'ns1' (e.g.
* 'ns1:xlink:foo').
*
* This is undesirable since we don't want to allow any of these custom attributes. This method
* strips them all.
* @private
* @param {?} el
* @return {?}
*/
stripCustomNsAttrs(el) {
/** @type {?} */
const elAttrs = el.attributes;
// loop backwards so that we can support removals.
for (let i = elAttrs.length - 1; 0 < i; i--) {
/** @type {?} */
const attrib = elAttrs.item(i);
/** @type {?} */
const attrName = (/** @type {?} */ (attrib)).name;
if (attrName === 'xmlns:ns1' || attrName.indexOf('ns1:') === 0) {
el.removeAttribute(attrName);
}
}
/** @type {?} */
let childNode = (/** @type {?} */ (el.firstChild));
while (childNode) {
if (childNode.nodeType === Node.ELEMENT_NODE)
this.stripCustomNsAttrs((/** @type {?} */ (childNode)));
childNode = childNode.nextSibling;
}
}
}
if (false) {
/**
* @type {?}
* @private
*/
InertBodyHelper.prototype.inertDocument;
/**
* Get an inert DOM element containing DOM created from the dirty HTML string provided.
* The implementation of this is determined in the constructor, when the class is instantiated.
* @type {?}
*/
InertBodyHelper.prototype.getInertBodyElement;
/**
* @type {?}
* @private
*/
InertBodyHelper.prototype.defaultDoc;
}
/**
* We need to determine whether the DOMParser exists in the global context.
* The try-catch is because, on some browsers, trying to access this property
* on window can actually throw an error.
*
* @suppress {uselessCode}
* @return {?}
*/
function isDOMParserAvailable() {
try {
return !!((/** @type {?} */ (window))).DOMParser;
}
catch (_a) {
return false;
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"inert_body.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/sanitization/inert_body.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * This helper class is used to get hold of an inert tree of DOM elements containing dirty HTML\n * that needs sanitizing.\n * Depending upon browser support we must use one of three strategies for doing this.\n * Support: Safari 10.x -> XHR strategy\n * Support: Firefox -> DomParser strategy\n * Default: InertDocument strategy\n */\nexport class InertBodyHelper {\n  private inertDocument: Document;\n\n  constructor(private defaultDoc: Document) {\n    this.inertDocument = this.defaultDoc.implementation.createHTMLDocument('sanitization-inert');\n    let inertBodyElement = this.inertDocument.body;\n\n    if (inertBodyElement == null) {\n      // usually there should be only one body element in the document, but IE doesn't have any, so\n      // we need to create one.\n      const inertHtml = this.inertDocument.createElement('html');\n      this.inertDocument.appendChild(inertHtml);\n      inertBodyElement = this.inertDocument.createElement('body');\n      inertHtml.appendChild(inertBodyElement);\n    }\n\n    inertBodyElement.innerHTML = '<svg><g onload=\"this.parentNode.remove()\"></g></svg>';\n    if (inertBodyElement.querySelector && !inertBodyElement.querySelector('svg')) {\n      // We just hit the Safari 10.1 bug - which allows JS to run inside the SVG G element\n      // so use the XHR strategy.\n      this.getInertBodyElement = this.getInertBodyElement_XHR;\n      return;\n    }\n\n    inertBodyElement.innerHTML = '<svg><p><style><img src=\"</style><img src=x onerror=alert(1)//\">';\n    if (inertBodyElement.querySelector && inertBodyElement.querySelector('svg img')) {\n      // We just hit the Firefox bug - which prevents the inner img JS from being sanitized\n      // so use the DOMParser strategy, if it is available.\n      // If the DOMParser is not available then we are not in Firefox (Server/WebWorker?) so we\n      // fall through to the default strategy below.\n      if (isDOMParserAvailable()) {\n        this.getInertBodyElement = this.getInertBodyElement_DOMParser;\n        return;\n      }\n    }\n\n    // None of the bugs were hit so it is safe for us to use the default InertDocument strategy\n    this.getInertBodyElement = this.getInertBodyElement_InertDocument;\n  }\n\n  /**\n   * Get an inert DOM element containing DOM created from the dirty HTML string provided.\n   * The implementation of this is determined in the constructor, when the class is instantiated.\n   */\n  getInertBodyElement: (html: string) => HTMLElement | null;\n\n  /**\n   * Use XHR to create and fill an inert body element (on Safari 10.1)\n   * See\n   * https://github.com/cure53/DOMPurify/blob/a992d3a75031cb8bb032e5ea8399ba972bdf9a65/src/purify.js#L439-L449\n   */\n  private getInertBodyElement_XHR(html: string) {\n    // We add these extra elements to ensure that the rest of the content is parsed as expected\n    // e.g. leading whitespace is maintained and tags like `<meta>` do not get hoisted to the\n    // `<head>` tag.\n    html = '<body><remove></remove>' + html + '</body>';\n    try {\n      html = encodeURI(html);\n    } catch {\n      return null;\n    }\n    const xhr = new XMLHttpRequest();\n    xhr.responseType = 'document';\n    xhr.open('GET', 'data:text/html;charset=utf-8,' + html, false);\n    xhr.send(undefined);\n    const body: HTMLBodyElement = xhr.response.body;\n    body.removeChild(body.firstChild!);\n    return body;\n  }\n\n  /**\n   * Use DOMParser to create and fill an inert body element (on Firefox)\n   * See https://github.com/cure53/DOMPurify/releases/tag/0.6.7\n   *\n   */\n  private getInertBodyElement_DOMParser(html: string) {\n    // We add these extra elements to ensure that the rest of the content is parsed as expected\n    // e.g. leading whitespace is maintained and tags like `<meta>` do not get hoisted to the\n    // `<head>` tag.\n    html = '<body><remove></remove>' + html + '</body>';\n    try {\n      const body = new (window as any).DOMParser().parseFromString(html, 'text/html').body as\n          HTMLBodyElement;\n      body.removeChild(body.firstChild!);\n      return body;\n    } catch {\n      return null;\n    }\n  }\n\n  /**\n   * Use an HTML5 `template` element, if supported, or an inert body element created via\n   * `createHtmlDocument` to create and fill an inert DOM element.\n   * This is the default sane strategy to use if the browser does not require one of the specialised\n   * strategies above.\n   */\n  private getInertBodyElement_InertDocument(html: string) {\n    // Prefer using <template> element if supported.\n    const templateEl = this.inertDocument.createElement('template');\n    if ('content' in templateEl) {\n      templateEl.innerHTML = html;\n      return templateEl;\n    }\n\n    // Note that previously we used to do something like `this.inertDocument.body.innerHTML = html`\n    // and we returned the inert `body` node. This was changed, because IE seems to treat setting\n    // `innerHTML` on an inserted element differently, compared to one that hasn't been inserted\n    // yet. In particular, IE appears to split some of the text into multiple text nodes rather\n    // than keeping them in a single one which ends up messing with Ivy's i18n parsing further\n    // down the line. This has been worked around by creating a new inert `body` and using it as\n    // the root node in which we insert the HTML.\n    const inertBody = this.inertDocument.createElement('body');\n    inertBody.innerHTML = html;\n\n    // Support: IE 9-11 only\n    // strip custom-namespaced attributes on IE<=11\n    if ((this.defaultDoc as any).documentMode) {\n      this.stripCustomNsAttrs(inertBody);\n    }\n\n    return inertBody;\n  }\n\n  /**\n   * When IE9-11 comes across an unknown namespaced attribute e.g. 'xlink:foo' it adds 'xmlns:ns1'\n   * attribute to declare ns1 namespace and prefixes the attribute with 'ns1' (e.g.\n   * 'ns1:xlink:foo').\n   *\n   * This is undesirable since we don't want to allow any of these custom attributes. This method\n   * strips them all.\n   */\n  private stripCustomNsAttrs(el: Element) {\n    const elAttrs = el.attributes;\n    // loop backwards so that we can support removals.\n    for (let i = elAttrs.length - 1; 0 < i; i--) {\n      const attrib = elAttrs.item(i);\n      const attrName = attrib!.name;\n      if (attrName === 'xmlns:ns1' || attrName.indexOf('ns1:') === 0) {\n        el.removeAttribute(attrName);\n      }\n    }\n    let childNode = el.firstChild as Node | null;\n    while (childNode) {\n      if (childNode.nodeType === Node.ELEMENT_NODE) this.stripCustomNsAttrs(childNode as Element);\n      childNode = childNode.nextSibling;\n    }\n  }\n}\n\n/**\n * We need to determine whether the DOMParser exists in the global context.\n * The try-catch is because, on some browsers, trying to access this property\n * on window can actually throw an error.\n *\n * @suppress {uselessCode}\n */\nfunction isDOMParserAvailable() {\n  try {\n    return !!(window as any).DOMParser;\n  } catch {\n    return false;\n  }\n}\n"]}