@angular/core
Version:
Angular - the core framework
261 lines • 27.7 kB
JavaScript
/**
* @fileoverview added by tsickle
* Generated from: packages/core/src/sanitization/sanitization.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
*/
import { getDocument } from '../render3/interfaces/document';
import { SANITIZER } from '../render3/interfaces/view';
import { getLView } from '../render3/state';
import { renderStringify } from '../render3/util/misc_utils';
import { allowSanitizationBypassAndThrow, unwrapSafeValue } from './bypass';
import { _sanitizeHtml as _sanitizeHtml } from './html_sanitizer';
import { SecurityContext } from './security';
import { _sanitizeStyle } from './style_sanitizer';
import { _sanitizeUrl as _sanitizeUrl } from './url_sanitizer';
/**
* An `html` sanitizer which converts untrusted `html` **string** into trusted string by removing
* dangerous content.
*
* This method parses the `html` and locates potentially dangerous content (such as urls and
* javascript) and removes it.
*
* It is possible to mark a string as trusted by calling {\@link bypassSanitizationTrustHtml}.
*
* \@publicApi
* @param {?} unsafeHtml untrusted `html`, typically from the user.
* @return {?} `html` string which is safe to display to user, because all of the dangerous javascript
* and urls have been removed.
*
*/
export function ɵɵsanitizeHtml(unsafeHtml) {
/** @type {?} */
const sanitizer = getSanitizer();
if (sanitizer) {
return sanitizer.sanitize(SecurityContext.HTML, unsafeHtml) || '';
}
if (allowSanitizationBypassAndThrow(unsafeHtml, "HTML" /* Html */)) {
return unwrapSafeValue(unsafeHtml);
}
return _sanitizeHtml(getDocument(), renderStringify(unsafeHtml));
}
/**
* A `style` sanitizer which converts untrusted `style` **string** into trusted string by removing
* dangerous content.
*
* This method parses the `style` and locates potentially dangerous content (such as urls and
* javascript) and removes it.
*
* It is possible to mark a string as trusted by calling {\@link bypassSanitizationTrustStyle}.
*
* \@publicApi
* @param {?} unsafeStyle untrusted `style`, typically from the user.
* @return {?} `style` string which is safe to bind to the `style` properties, because all of the
* dangerous javascript and urls have been removed.
*
*/
export function ɵɵsanitizeStyle(unsafeStyle) {
/** @type {?} */
const sanitizer = getSanitizer();
if (sanitizer) {
return sanitizer.sanitize(SecurityContext.STYLE, unsafeStyle) || '';
}
if (allowSanitizationBypassAndThrow(unsafeStyle, "Style" /* Style */)) {
return unwrapSafeValue(unsafeStyle);
}
return _sanitizeStyle(renderStringify(unsafeStyle));
}
/**
* A `url` sanitizer which converts untrusted `url` **string** into trusted string by removing
* dangerous
* content.
*
* This method parses the `url` and locates potentially dangerous content (such as javascript) and
* removes it.
*
* It is possible to mark a string as trusted by calling {\@link bypassSanitizationTrustUrl}.
*
* \@publicApi
* @param {?} unsafeUrl untrusted `url`, typically from the user.
* @return {?} `url` string which is safe to bind to the `src` properties such as `<img src>`, because
* all of the dangerous javascript has been removed.
*
*/
export function ɵɵsanitizeUrl(unsafeUrl) {
/** @type {?} */
const sanitizer = getSanitizer();
if (sanitizer) {
return sanitizer.sanitize(SecurityContext.URL, unsafeUrl) || '';
}
if (allowSanitizationBypassAndThrow(unsafeUrl, "URL" /* Url */)) {
return unwrapSafeValue(unsafeUrl);
}
return _sanitizeUrl(renderStringify(unsafeUrl));
}
/**
* A `url` sanitizer which only lets trusted `url`s through.
*
* This passes only `url`s marked trusted by calling {\@link bypassSanitizationTrustResourceUrl}.
*
* \@publicApi
* @param {?} unsafeResourceUrl untrusted `url`, typically from the user.
* @return {?} `url` string which is safe to bind to the `src` properties such as `<img src>`, because
* only trusted `url`s have been allowed to pass.
*
*/
export function ɵɵsanitizeResourceUrl(unsafeResourceUrl) {
/** @type {?} */
const sanitizer = getSanitizer();
if (sanitizer) {
return sanitizer.sanitize(SecurityContext.RESOURCE_URL, unsafeResourceUrl) || '';
}
if (allowSanitizationBypassAndThrow(unsafeResourceUrl, "ResourceURL" /* ResourceUrl */)) {
return unwrapSafeValue(unsafeResourceUrl);
}
throw new Error('unsafe value used in a resource URL context (see http://g.co/ng/security#xss)');
}
/**
* A `script` sanitizer which only lets trusted javascript through.
*
* This passes only `script`s marked trusted by calling {\@link
* bypassSanitizationTrustScript}.
*
* \@publicApi
* @param {?} unsafeScript untrusted `script`, typically from the user.
* @return {?} `url` string which is safe to bind to the `<script>` element such as `<img src>`,
* because only trusted `scripts` have been allowed to pass.
*
*/
export function ɵɵsanitizeScript(unsafeScript) {
/** @type {?} */
const sanitizer = getSanitizer();
if (sanitizer) {
return sanitizer.sanitize(SecurityContext.SCRIPT, unsafeScript) || '';
}
if (allowSanitizationBypassAndThrow(unsafeScript, "Script" /* Script */)) {
return unwrapSafeValue(unsafeScript);
}
throw new Error('unsafe value used in a script context');
}
/**
* Detects which sanitizer to use for URL property, based on tag name and prop name.
*
* The rules are based on the RESOURCE_URL context config from
* `packages/compiler/src/schema/dom_security_schema.ts`.
* If tag and prop names don't match Resource URL schema, use URL sanitizer.
* @param {?} tag
* @param {?} prop
* @return {?}
*/
export function getUrlSanitizer(tag, prop) {
if ((prop === 'src' &&
(tag === 'embed' || tag === 'frame' || tag === 'iframe' || tag === 'media' ||
tag === 'script')) ||
(prop === 'href' && (tag === 'base' || tag === 'link'))) {
return ɵɵsanitizeResourceUrl;
}
return ɵɵsanitizeUrl;
}
/**
* Sanitizes URL, selecting sanitizer function based on tag and property names.
*
* This function is used in case we can't define security context at compile time, when only prop
* name is available. This happens when we generate host bindings for Directives/Components. The
* host element is unknown at compile time, so we defer calculation of specific sanitizer to
* runtime.
*
* \@publicApi
* @param {?} unsafeUrl untrusted `url`, typically from the user.
* @param {?} tag target element tag name.
* @param {?} prop name of the property that contains the value.
* @return {?} `url` string which is safe to bind.
*
*/
export function ɵɵsanitizeUrlOrResourceUrl(unsafeUrl, tag, prop) {
return getUrlSanitizer(tag, prop)(unsafeUrl);
}
/**
* The default style sanitizer will handle sanitization for style properties by
* sanitizing any CSS property that can include a `url` value (usually image-based properties)
*
* \@publicApi
* @type {?}
*/
export const ɵɵdefaultStyleSanitizer = ((/** @type {?} */ ((/**
* @param {?} prop
* @param {?} value
* @param {?=} mode
* @return {?}
*/
function (prop, value, mode) {
if (value === undefined && mode === undefined) {
// This is a workaround for the fact that `StyleSanitizeFn` should not exist once PR#34480
// lands. For now the `StyleSanitizeFn` and should act like `(value: any) => string` as a
// work around.
return ɵɵsanitizeStyle(prop);
}
mode = mode || 3 /* ValidateAndSanitize */;
/** @type {?} */
let doSanitizeValue = true;
if (mode & 1 /* ValidateProperty */) {
doSanitizeValue = stylePropNeedsSanitization(prop);
}
if (mode & 2 /* SanitizeOnly */) {
return doSanitizeValue ? ɵɵsanitizeStyle(value) : unwrapSafeValue(value);
}
else {
return doSanitizeValue;
}
}))));
/**
* @param {?} prop
* @return {?}
*/
export function stylePropNeedsSanitization(prop) {
return prop === 'background-image' || prop === 'backgroundImage' || prop === 'background' ||
prop === 'border-image' || prop === 'borderImage' || prop === 'border-image-source' ||
prop === 'borderImageSource' || prop === 'filter' || prop === 'list-style' ||
prop === 'listStyle' || prop === 'list-style-image' || prop === 'listStyleImage' ||
prop === 'clip-path' || prop === 'clipPath';
}
/**
* @param {?} name
* @return {?}
*/
export function validateAgainstEventProperties(name) {
if (name.toLowerCase().startsWith('on')) {
/** @type {?} */
const msg = `Binding to event property '${name}' is disallowed for security reasons, ` +
`please use (${name.slice(2)})=...` +
`\nIf '${name}' is a directive input, make sure the directive is imported by the` +
` current module.`;
throw new Error(msg);
}
}
/**
* @param {?} name
* @return {?}
*/
export function validateAgainstEventAttributes(name) {
if (name.toLowerCase().startsWith('on')) {
/** @type {?} */
const msg = `Binding to event attribute '${name}' is disallowed for security reasons, ` +
`please use (${name.slice(2)})=...`;
throw new Error(msg);
}
}
/**
* @return {?}
*/
function getSanitizer() {
/** @type {?} */
const lView = getLView();
return lView && lView[SANITIZER];
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sanitization.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/sanitization/sanitization.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\nimport {getDocument} from '../render3/interfaces/document';\nimport {SANITIZER} from '../render3/interfaces/view';\nimport {getLView} from '../render3/state';\nimport {renderStringify} from '../render3/util/misc_utils';\n\nimport {allowSanitizationBypassAndThrow, BypassType, unwrapSafeValue} from './bypass';\nimport {_sanitizeHtml as _sanitizeHtml} from './html_sanitizer';\nimport {Sanitizer} from './sanitizer';\nimport {SecurityContext} from './security';\nimport {_sanitizeStyle, StyleSanitizeFn, StyleSanitizeMode} from './style_sanitizer';\nimport {_sanitizeUrl as _sanitizeUrl} from './url_sanitizer';\n\n\n\n/**\n * An `html` sanitizer which converts untrusted `html` **string** into trusted string by removing\n * dangerous content.\n *\n * This method parses the `html` and locates potentially dangerous content (such as urls and\n * javascript) and removes it.\n *\n * It is possible to mark a string as trusted by calling {@link bypassSanitizationTrustHtml}.\n *\n * @param unsafeHtml untrusted `html`, typically from the user.\n * @returns `html` string which is safe to display to user, because all of the dangerous javascript\n * and urls have been removed.\n *\n * @publicApi\n */\nexport function ɵɵsanitizeHtml(unsafeHtml: any): string {\n  const sanitizer = getSanitizer();\n  if (sanitizer) {\n    return sanitizer.sanitize(SecurityContext.HTML, unsafeHtml) || '';\n  }\n  if (allowSanitizationBypassAndThrow(unsafeHtml, BypassType.Html)) {\n    return unwrapSafeValue(unsafeHtml);\n  }\n  return _sanitizeHtml(getDocument(), renderStringify(unsafeHtml));\n}\n\n/**\n * A `style` sanitizer which converts untrusted `style` **string** into trusted string by removing\n * dangerous content.\n *\n * This method parses the `style` and locates potentially dangerous content (such as urls and\n * javascript) and removes it.\n *\n * It is possible to mark a string as trusted by calling {@link bypassSanitizationTrustStyle}.\n *\n * @param unsafeStyle untrusted `style`, typically from the user.\n * @returns `style` string which is safe to bind to the `style` properties, because all of the\n * dangerous javascript and urls have been removed.\n *\n * @publicApi\n */\nexport function ɵɵsanitizeStyle(unsafeStyle: any): string {\n  const sanitizer = getSanitizer();\n  if (sanitizer) {\n    return sanitizer.sanitize(SecurityContext.STYLE, unsafeStyle) || '';\n  }\n  if (allowSanitizationBypassAndThrow(unsafeStyle, BypassType.Style)) {\n    return unwrapSafeValue(unsafeStyle);\n  }\n  return _sanitizeStyle(renderStringify(unsafeStyle));\n}\n\n/**\n * A `url` sanitizer which converts untrusted `url` **string** into trusted string by removing\n * dangerous\n * content.\n *\n * This method parses the `url` and locates potentially dangerous content (such as javascript) and\n * removes it.\n *\n * It is possible to mark a string as trusted by calling {@link bypassSanitizationTrustUrl}.\n *\n * @param unsafeUrl untrusted `url`, typically from the user.\n * @returns `url` string which is safe to bind to the `src` properties such as `<img src>`, because\n * all of the dangerous javascript has been removed.\n *\n * @publicApi\n */\nexport function ɵɵsanitizeUrl(unsafeUrl: any): string {\n  const sanitizer = getSanitizer();\n  if (sanitizer) {\n    return sanitizer.sanitize(SecurityContext.URL, unsafeUrl) || '';\n  }\n  if (allowSanitizationBypassAndThrow(unsafeUrl, BypassType.Url)) {\n    return unwrapSafeValue(unsafeUrl);\n  }\n  return _sanitizeUrl(renderStringify(unsafeUrl));\n}\n\n/**\n * A `url` sanitizer which only lets trusted `url`s through.\n *\n * This passes only `url`s marked trusted by calling {@link bypassSanitizationTrustResourceUrl}.\n *\n * @param unsafeResourceUrl untrusted `url`, typically from the user.\n * @returns `url` string which is safe to bind to the `src` properties such as `<img src>`, because\n * only trusted `url`s have been allowed to pass.\n *\n * @publicApi\n */\nexport function ɵɵsanitizeResourceUrl(unsafeResourceUrl: any): string {\n  const sanitizer = getSanitizer();\n  if (sanitizer) {\n    return sanitizer.sanitize(SecurityContext.RESOURCE_URL, unsafeResourceUrl) || '';\n  }\n  if (allowSanitizationBypassAndThrow(unsafeResourceUrl, BypassType.ResourceUrl)) {\n    return unwrapSafeValue(unsafeResourceUrl);\n  }\n  throw new Error('unsafe value used in a resource URL context (see http://g.co/ng/security#xss)');\n}\n\n/**\n * A `script` sanitizer which only lets trusted javascript through.\n *\n * This passes only `script`s marked trusted by calling {@link\n * bypassSanitizationTrustScript}.\n *\n * @param unsafeScript untrusted `script`, typically from the user.\n * @returns `url` string which is safe to bind to the `<script>` element such as `<img src>`,\n * because only trusted `scripts` have been allowed to pass.\n *\n * @publicApi\n */\nexport function ɵɵsanitizeScript(unsafeScript: any): string {\n  const sanitizer = getSanitizer();\n  if (sanitizer) {\n    return sanitizer.sanitize(SecurityContext.SCRIPT, unsafeScript) || '';\n  }\n  if (allowSanitizationBypassAndThrow(unsafeScript, BypassType.Script)) {\n    return unwrapSafeValue(unsafeScript);\n  }\n  throw new Error('unsafe value used in a script context');\n}\n\n/**\n * Detects which sanitizer to use for URL property, based on tag name and prop name.\n *\n * The rules are based on the RESOURCE_URL context config from\n * `packages/compiler/src/schema/dom_security_schema.ts`.\n * If tag and prop names don't match Resource URL schema, use URL sanitizer.\n */\nexport function getUrlSanitizer(tag: string, prop: string) {\n  if ((prop === 'src' &&\n       (tag === 'embed' || tag === 'frame' || tag === 'iframe' || tag === 'media' ||\n        tag === 'script')) ||\n      (prop === 'href' && (tag === 'base' || tag === 'link'))) {\n    return ɵɵsanitizeResourceUrl;\n  }\n  return ɵɵsanitizeUrl;\n}\n\n/**\n * Sanitizes URL, selecting sanitizer function based on tag and property names.\n *\n * This function is used in case we can't define security context at compile time, when only prop\n * name is available. This happens when we generate host bindings for Directives/Components. The\n * host element is unknown at compile time, so we defer calculation of specific sanitizer to\n * runtime.\n *\n * @param unsafeUrl untrusted `url`, typically from the user.\n * @param tag target element tag name.\n * @param prop name of the property that contains the value.\n * @returns `url` string which is safe to bind.\n *\n * @publicApi\n */\nexport function ɵɵsanitizeUrlOrResourceUrl(unsafeUrl: any, tag: string, prop: string): any {\n  return getUrlSanitizer(tag, prop)(unsafeUrl);\n}\n\n/**\n * The default style sanitizer will handle sanitization for style properties by\n * sanitizing any CSS property that can include a `url` value (usually image-based properties)\n *\n * @publicApi\n */\nexport const ɵɵdefaultStyleSanitizer =\n    (function(prop: string, value: string|null, mode?: StyleSanitizeMode): string|boolean|null {\n      if (value === undefined && mode === undefined) {\n        // This is a workaround for the fact that `StyleSanitizeFn` should not exist once PR#34480\n        // lands. For now the `StyleSanitizeFn` and should act like `(value: any) => string` as a\n        // work around.\n        return ɵɵsanitizeStyle(prop);\n      }\n      mode = mode || StyleSanitizeMode.ValidateAndSanitize;\n      let doSanitizeValue = true;\n      if (mode & StyleSanitizeMode.ValidateProperty) {\n        doSanitizeValue = stylePropNeedsSanitization(prop);\n      }\n\n      if (mode & StyleSanitizeMode.SanitizeOnly) {\n        return doSanitizeValue ? ɵɵsanitizeStyle(value) : unwrapSafeValue(value);\n      } else {\n        return doSanitizeValue;\n      }\n    } as StyleSanitizeFn);\n\nexport function stylePropNeedsSanitization(prop: string): boolean {\n  return prop === 'background-image' || prop === 'backgroundImage' || prop === 'background' ||\n      prop === 'border-image' || prop === 'borderImage' || prop === 'border-image-source' ||\n      prop === 'borderImageSource' || prop === 'filter' || prop === 'list-style' ||\n      prop === 'listStyle' || prop === 'list-style-image' || prop === 'listStyleImage' ||\n      prop === 'clip-path' || prop === 'clipPath';\n}\n\nexport function validateAgainstEventProperties(name: string) {\n  if (name.toLowerCase().startsWith('on')) {\n    const msg = `Binding to event property '${name}' is disallowed for security reasons, ` +\n        `please use (${name.slice(2)})=...` +\n        `\\nIf '${name}' is a directive input, make sure the directive is imported by the` +\n        ` current module.`;\n    throw new Error(msg);\n  }\n}\n\nexport function validateAgainstEventAttributes(name: string) {\n  if (name.toLowerCase().startsWith('on')) {\n    const msg = `Binding to event attribute '${name}' is disallowed for security reasons, ` +\n        `please use (${name.slice(2)})=...`;\n    throw new Error(msg);\n  }\n}\n\nfunction getSanitizer(): Sanitizer|null {\n  const lView = getLView();\n  return lView && lView[SANITIZER];\n}\n"]}