packages/compiler-core/src/codegen.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 456: let id = assets[i] -------------------------------------------------------------------------------- 493: const exp = hoists[i] -------------------------------------------------------------------------------- 556: const node = nodes[i] -------------------------------------------------------------------------------- 696: const child = node.children![i] -------------------------------------------------------------------------------- 808: const { key, value } = properties[i] -------------------------------------------------------------------------------- 936: const e = node.elements[i] packages/compiler-core/src/compat/compatConfig.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via key Details: https://sg.run/XBkj 158: const { message, link } = deprecationData[key] packages/compiler-core/src/compat/transformFilter.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 49: const child = node.children[i] packages/compiler-core/src/parse.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 259: const node = nodes[i] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i - 1 Details: https://sg.run/XBkj 262: const prev = nodes[i - 1] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i + 1 Details: https://sg.run/XBkj 263: const next = nodes[i + 1] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 589: const p = props[i] -------------------------------------------------------------------------------- 660: const p = props[i] packages/compiler-core/src/runtimeHelpers.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via s Details: https://sg.run/XBkj 90: helperNameMap[s] = helpers[s] packages/compiler-core/src/transform.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via PatchFlags.STABLE_FRAGMENT Details: https://sg.run/XBkj 363: let patchFlagText = PatchFlagNames[PatchFlags.STABLE_FRAGMENT] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 489: const prop = props[i] packages/compiler-core/src/transforms/hoistStatic.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 70: const child = children[i] -------------------------------------------------------------------------------- 226: const p = node.props[i] -------------------------------------------------------------------------------- 273: const child = node.children[i] -------------------------------------------------------------------------------- 330: const { key, value } = properties[i] packages/compiler-core/src/transforms/transformElement.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 463: const prop = props[i] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via name Details: https://sg.run/XBkj 621: const directiveTransform = context.directiveTransforms[name] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 801: const prop = properties[i] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via raw Details: https://sg.run/XBkj 903: const type = bindingMetadata[raw] packages/compiler-core/src/transforms/transformExpression.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 51: const dir = node.props[i] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i - 1 Details: https://sg.run/XBkj 306: const last = ids[i - 1] packages/compiler-core/src/transforms/transformSlotOutlet.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 67: const p = node.props[i] packages/compiler-core/src/transforms/transformText.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 32: const child = children[i] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via j Details: https://sg.run/XBkj 36: const next = children[j] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 88: const child = children[i] packages/compiler-core/src/transforms/vIf.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via PatchFlags.STABLE_FRAGMENT Details: https://sg.run/XBkj 272: let patchFlagText = PatchFlagNames[PatchFlags.STABLE_FRAGMENT] packages/compiler-core/src/transforms/vSlot.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 165: const slotElement = children[i] -------------------------------------------------------------------------------- 382: const child = children[i] packages/compiler-core/src/utils.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 258: const p = node.props[i] -------------------------------------------------------------------------------- 276: const p = node.props[i] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via callPath.length - 1 Details: https://sg.run/XBkj 388: parentCall = callPath[callPath.length - 1] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via callPath.length - 2 Details: https://sg.run/XBkj 437: parentCall = callPath[callPath.length - 2] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 476: const p = node.props[i] packages/compiler-core/src/validateExpression.ts rule:javascript.lang.security.audit.detect-non-literal-regexp.detect-non-literal-regexp: RegExp() called with a variable, this might allow an attacker to DOS your application with a long-running regular expression. Details: https://sg.run/gr65 8:const prohibitedKeywordRE = new RegExp( 9: '\\b' + 10: ( 11: 'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' + 12: 'super,throw,while,yield,delete,export,import,return,switch,default,' + 13: 'extends,finally,continue,debugger,function,arguments,typeof,void' 14: ) 15: .split(',') 16: .join('\\b|\\b') + 17: '\\b' -------- [hid 1 additional lines, adjust with --max-lines-per-finding] --------- rule:javascript.lang.security.detect-eval-with-expression.detect-eval-with-expression: Detected eval(variable), which could allow a malicious actor to run arbitrary code. Details: https://sg.run/6nwK 44: new Function( 45: asRawStatements 46: ? ` ${exp} ` 47: : `return ${asParams ? `(${exp}) => {}` : `(${exp})`}` 48: ) packages/compiler-dom/src/transforms/stringifyStatic.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 196: const p = node.props[i] -------------------------------------------------------------------------------- 217: const child = node.children[i] -------------------------------------------------------------------------------- 269: const p = node.props[i] -------------------------------------------------------------------------------- rule:javascript.lang.security.detect-eval-with-expression.detect-eval-with-expression: Detected eval(variable), which could allow a malicious actor to run arbitrary code. Details: https://sg.run/6nwK 313: return new Function(`return ${exp.content}`)() packages/compiler-dom/src/transforms/vOn.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 47: const modifier = modifiers[i] packages/compiler-sfc/src/compileScript.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via key Details: https://sg.run/XBkj 689: const { type, required } = props[key] -------------------------------------------------------------------------------- 713: const destructured = propsDestructuredBindings[key] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via node.trailingComments.length - 1 Details: https://sg.run/XBkj 878: const lastCommentNode = 879: node.trailingComments[node.trailingComments.length - 1] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 913: const current = node.specifiers[i] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i + 1 Details: https://sg.run/XBkj 914: const next = node.specifiers[i + 1] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 926: const specifier = node.specifiers[i] -------------------------------------------------------------------------------- 989: const decl = node.declarations[i] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via key Details: https://sg.run/XBkj 1156: const { local } = propsDestructuredBindings[key] -------------------------------------------------------------------------------- 1174: bindingMetadata[key] = scriptBindings[key] -------------------------------------------------------------------------------- 1177: bindingMetadata[key] = setupBindings[key] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 1978: const prop = node.props[i] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-non-literal-regexp.detect-non-literal-regexp: RegExp() called with a variable, this might allow an attacker to DOS your application with a long-running regular expression. Details: https://sg.run/gr65 338: isUsedInTemplate = new RegExp( 339: // #4274 escape $ since it's a special char in regex 340: // (and is the only regex special char that is valid in identifiers) 341: `[^\\w$_]${local.replace(/\$/g, '\\$')}[^\\w$_]` 342: ).test(resolveTemplateUsageCheckString(sfc)) -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.prototype-pollution.prototype-pollution-function.prototype-pollution-function: Possibility of prototype polluting function detected. By adding or modifying attributes of an object prototype, it is possible to create attributes that exist on every object, or replace critical attributes with malicious ones. This can be problematic if the software depends on existence or non-existence of certain attributes, or uses pre-defined attributes of object prototype (such as hasOwnProperty, toString or valueOf). Possible mitigations might be: freezing the object prototype, using an object without prototypes (via Object.create(null) ), blocking modifications of attributes that resolve to object prototype, using Map instead of object. Details: https://sg.run/kkZe 1600: declaredTypes[node.id.name] = [`Object`] -------------------------------------------------------------------------------- 1602: declaredTypes[node.id.name] = inferRuntimeType( 1603: node.typeAnnotation, 1604: declaredTypes 1605: ) packages/compiler-sfc/src/parse.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via p.name Details: https://sg.run/XBkj 328: ;(block as SFCStyleBlock).module = attrs[p.name] packages/compiler-sfc/src/templateTransformAssetUrl.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via node.tag Details: https://sg.run/XBkj 96: const attrs = tags[node.tag] packages/compiler-sfc/src/templateTransformSrcset.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 63: const { url } = imageCandidates[i] packages/compiler-ssr/src/ssrCodegenTransform.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via bufferedElements.length - 1 Details: https://sg.run/XBkj 100: const lastItem = bufferedElements[bufferedElements.length - 1] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 138: const child = children[i] packages/compiler-ssr/src/transforms/ssrTransformComponent.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 191: const { fn, children, vnodeBranch } = wipEntries[i] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.prototype-pollution.prototype-pollution-function.prototype-pollution-function: Possibility of prototype polluting function detected. By adding or modifying attributes of an object prototype, it is possible to create attributes that exist on every object, or replace critical attributes with malicious ones. This can be problematic if the software depends on existence or non-existence of certain attributes, or uses pre-defined attributes of object prototype (such as hasOwnProperty, toString or valueOf). Possible mitigations might be: freezing the object prototype, using an object without prototypes (via Object.create(null) ), blocking modifications of attributes that resolve to object prototype, using Map instead of object. Details: https://sg.run/kkZe 327: res[key] = clone(v[key]) packages/compiler-ssr/src/transforms/ssrTransformElement.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 163: const prop = node.props[i] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via prop.name Details: https://sg.run/XBkj 184: const directiveTransform = context.directiveTransforms[prop.name] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via j Details: https://sg.run/XBkj 203: const { key, value } = props[j] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-non-literal-regexp.detect-non-literal-regexp: RegExp() called with a variable, this might allow an attacker to DOS your application with a long-running regular expression. Details: https://sg.run/gr65 355: const regExp = new RegExp(`^ ${binding}=".+"$`) packages/compiler-ssr/src/transforms/ssrTransformSuspense.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 69: const { fn, children } = wipSlots[i] packages/compiler-ssr/src/transforms/ssrVIf.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 39: const branch = node.branches[i] packages/reactivity/__tests__/effect.spec.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via key Details: https://sg.run/XBkj 596: dummy = obj[key] packages/reactivity/src/baseHandlers.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via key Details: https://sg.run/XBkj 148: let oldValue = (target as any)[key] -------------------------------------------------------------------------------- 179: const oldValue = (target as any)[key] packages/reactivity/src/collectionHandlers.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via ReactiveFlags.RAW Details: https://sg.run/XBkj 26: target = (target as any)[ReactiveFlags.RAW] -------------------------------------------------------------------------------- 47: const target = (this as any)[ReactiveFlags.RAW] -------------------------------------------------------------------------------- 60: target = (target as any)[ReactiveFlags.RAW] -------------------------------------------------------------------------------- 143: const target = observed[ReactiveFlags.RAW] -------------------------------------------------------------------------------- 178: const target = (this as any)[ReactiveFlags.RAW] packages/reactivity/src/dep.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 45: const dep = deps[i] packages/reactivity/src/effectScope.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via effectScopeStack.length - 1 Details: https://sg.run/XBkj 53: activeEffectScope = effectScopeStack[effectScopeStack.length - 1] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.prototype-pollution.prototype-pollution-function.prototype-pollution-function: Possibility of prototype polluting function detected. By adding or modifying attributes of an object prototype, it is possible to create attributes that exist on every object, or replace critical attributes with malicious ones. This can be problematic if the software depends on existence or non-existence of certain attributes, or uses pre-defined attributes of object prototype (such as hasOwnProperty, toString or valueOf). Possible mitigations might be: freezing the object prototype, using an object without prototypes (via Object.create(null) ), blocking modifications of attributes that resolve to object prototype, using Map instead of object. Details: https://sg.run/kkZe 69: this.parent.scopes![this.index!] = last packages/reactivity/src/ref.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via key Details: https://sg.run/XBkj 136: const oldValue = target[key] -------------------------------------------------------------------------------- 228: const val = object[key] packages/ref-transform/src/refTransform.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via key Details: https://sg.run/XBkj 135: const { local } = knownProps[key] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via id.name Details: https://sg.run/XBkj 344: const bindingType = scope[id.name] packages/runtime-core/__tests__/hmr.spec.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via components.length - 1 Details: https://sg.run/XBkj 330: const last = components[components.length - 1] -------------------------------------------------------------------------------- rule:javascript.lang.security.detect-eval-with-expression.detect-eval-with-expression: Detected eval(variable), which could allow a malicious actor to run arbitrary code. Details: https://sg.run/6nwK 24: const render = new Function('Vue', code)( packages/runtime-core/src/apiSetupHelpers.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via key Details: https://sg.run/XBkj 205: const opt = props[key] -------------------------------------------------------------------------------- 210: opt.default = defaults[key] packages/runtime-core/src/apiWatch.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via segments[i] Details: https://sg.run/XBkj 425: cur = cur[segments[i]] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.prototype-pollution.prototype-pollution-loop.prototype-pollution-loop: Possibility of prototype polluting function detected. By adding or modifying attributes of an object prototype, it is possible to create attributes that exist on every object, or replace critical attributes with malicious ones. This can be problematic if the software depends on existence or non-existence of certain attributes, or uses pre-defined attributes of object prototype (such as hasOwnProperty, toString or valueOf). Possible mitigations might be: freezing the object prototype, using an object without prototypes (via Object.create(null) ), blocking modifications of attributes that resolve to object prototype, using Map instead of object. Details: https://sg.run/w1DB 425: cur = cur[segments[i]] packages/runtime-core/src/compat/compatConfig.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via key Details: https://sg.run/XBkj 489: const { message, link } = deprecationData[key] packages/runtime-core/src/compat/componentFunctional.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via key Details: https://sg.run/XBkj 18: const slot = target[key] packages/runtime-core/src/compat/customDirective.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via name Details: https://sg.run/XBkj 31: const mappedName = legacyDirectiveHookMap[name] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via mapped Details: https://sg.run/XBkj 36: const mappedHook = dir[mapped] packages/runtime-core/src/compat/data.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via key Details: https://sg.run/XBkj 6: const toVal = to[key] -------------------------------------------------------------------------------- 7: const fromVal = from[key] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.prototype-pollution.prototype-pollution-function.prototype-pollution-function: Possibility of prototype polluting function detected. By adding or modifying attributes of an object prototype, it is possible to create attributes that exist on every object, or replace critical attributes with malicious ones. This can be problematic if the software depends on existence or non-existence of certain attributes, or uses pre-defined attributes of object prototype (such as hasOwnProperty, toString or valueOf). Possible mitigations might be: freezing the object prototype, using an object without prototypes (via Object.create(null) ), blocking modifications of attributes that resolve to object prototype, using Map instead of object. Details: https://sg.run/kkZe 12: to[key] = fromVal packages/runtime-core/src/compat/global.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via key Details: https://sg.run/XBkj 250: const superValue = Super.options[key] -------------------------------------------------------------------------------- 386: app._context[key] = singletonApp._context[key] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via key as keyof AppConfig Details: https://sg.run/XBkj 399: const val = singletonApp.config[key as keyof AppConfig] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 524: const attr = container.attributes[i] packages/runtime-core/src/compat/globalConfig.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via key Details: https://sg.run/XBkj 49: let val = (config as any)[key] packages/runtime-core/src/compat/instanceEventEmitter.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via event! Details: https://sg.run/XBkj 81: const cbs = events[event!] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via event Details: https://sg.run/XBkj 98: const cbs = getRegistry(instance)[event] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.prototype-pollution.prototype-pollution-function.prototype-pollution-function: Possibility of prototype polluting function detected. By adding or modifying attributes of an object prototype, it is possible to create attributes that exist on every object, or replace critical attributes with malicious ones. This can be problematic if the software depends on existence or non-existence of certain attributes, or uses pre-defined attributes of object prototype (such as hasOwnProperty, toString or valueOf). Possible mitigations might be: freezing the object prototype, using an object without prototypes (via Object.create(null) ), blocking modifications of attributes that resolve to object prototype, using Map instead of object. Details: https://sg.run/kkZe 43: ;(events[event] || (events[event] = [])).push(fn) -------------------------------------------------------------------------------- 86: events[event!] = undefined -------------------------------------------------------------------------------- 89: events[event!] = cbs.filter(cb => !(cb === fn || (cb as any).fn === fn)) packages/runtime-core/src/compat/instanceListeners.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via key Details: https://sg.run/XBkj 15: listeners[key[2].toLowerCase() + key.slice(3)] = rawProps[key] packages/runtime-core/src/compat/ref.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via key Details: https://sg.run/XBkj 28: const existing = refs[key] packages/runtime-core/src/compat/renderFn.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via key Details: https://sg.run/XBkj 191: const listeners = legacyProps[key] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via event Details: https://sg.run/XBkj 196: const incoming = listeners[event] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via key as keyof LegacyVNodeProps Details: https://sg.run/XBkj 206: converted[key] = legacyProps[key as keyof LegacyVNodeProps] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 270: const child = children[i] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via key Details: https://sg.run/XBkj 282: const slotChildren = slots[key] packages/runtime-core/src/compat/renderHelpers.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via key Details: https://sg.run/XBkj 40: data[key] = value[key] -------------------------------------------------------------------------------- 50: attrs[key] = value[key] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 105: const fn = slots[i] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via index Details: https://sg.run/XBkj 133: const fn = (instance.type as any).staticRenderFns[index] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 172: const key = values[i] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i + 1 Details: https://sg.run/XBkj 174: props[values[i]] = values[i + 1] packages/runtime-core/src/componentEmits.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via event Details: https://sg.run/XBkj 99: const validator = emitsOptions[event] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via handlerName = toHandlerKey(hyphenate(event)) Details: https://sg.run/XBkj 157: handler = props[(handlerName = toHandlerKey(hyphenate(event)))] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via handlerName + `Once Details: https://sg.run/XBkj 169: const onceHandler = props[handlerName + `Once`] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.prototype-pollution.prototype-pollution-function.prototype-pollution-function: Possibility of prototype polluting function detected. By adding or modifying attributes of an object prototype, it is possible to create attributes that exist on every object, or replace critical attributes with malicious ones. This can be problematic if the software depends on existence or non-existence of certain attributes, or uses pre-defined attributes of object prototype (such as hasOwnProperty, toString or valueOf). Possible mitigations might be: freezing the object prototype, using an object without prototypes (via Object.create(null) ), blocking modifications of attributes that resolve to object prototype, using Map instead of object. Details: https://sg.run/kkZe 176: instance.emitted[handlerName] = true -------------------------------------------------------------------------------- 232: raw.forEach(key => (normalized[key] = null)) packages/runtime-core/src/componentOptions.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via key Details: https://sg.run/XBkj 620: const methodHandler = (methods as MethodOptions)[key] -------------------------------------------------------------------------------- 688: const opt = (computedOptions as ComputedOptions)[key] -------------------------------------------------------------------------------- 826: const opt = (injectOptions as ObjectInjectOptions)[key] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via raw Details: https://sg.run/XBkj 895: const handler = ctx[raw] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 1071: res[raw[i]] = raw[i] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.prototype-pollution.prototype-pollution-function.prototype-pollution-function: Possibility of prototype polluting function detected. By adding or modifying attributes of an object prototype, it is possible to create attributes that exist on every object, or replace critical attributes with malicious ones. This can be problematic if the software depends on existence or non-existence of certain attributes, or uses pre-defined attributes of object prototype (such as hasOwnProperty, toString or valueOf). Possible mitigations might be: freezing the object prototype, using an object without prototypes (via Object.create(null) ), blocking modifications of attributes that resolve to object prototype, using Map instead of object. Details: https://sg.run/kkZe 997: to[key] = strat ? strat(to[key], from[key]) : from[key] packages/runtime-core/src/componentProps.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 223: let key = propsToUpdate[i] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via key Details: https://sg.run/XBkj 350: const value = rawProps[key] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 383: const key = needCastKeys[i] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via key Details: https://sg.run/XBkj 406: const opt = options[key] -------------------------------------------------------------------------------- 415: value = propsDefaults[key] -------------------------------------------------------------------------------- 506: const opt = raw[key] -------------------------------------------------------------------------------- 572: let opt = options[key] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.prototype-pollution.prototype-pollution-function.prototype-pollution-function: Possibility of prototype polluting function detected. By adding or modifying attributes of an object prototype, it is possible to create attributes that exist on every object, or replace critical attributes with malicious ones. This can be problematic if the software depends on existence or non-existence of certain attributes, or uses pre-defined attributes of object prototype (such as hasOwnProperty, toString or valueOf). Possible mitigations might be: freezing the object prototype, using an object without prototypes (via Object.create(null) ), blocking modifications of attributes that resolve to object prototype, using Map instead of object. Details: https://sg.run/kkZe 496: normalized[normalizedKey] = EMPTY_OBJ -------------------------------------------------------------------------------- 507: const prop: NormalizedProp = (normalized[normalizedKey] = 508: isArray(opt) || isFunction(opt) ? { type: opt } : opt) -------------------------------------------------------------------------------- 512: prop[BooleanFlags.shouldCast] = booleanIndex > -1 -------------------------------------------------------------------------------- 513: prop[BooleanFlags.shouldCastTrue] = 514: stringIndex < 0 || booleanIndex < stringIndex packages/runtime-core/src/componentPublicInstance.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via key Details: https://sg.run/XBkj 294: const n = accessCache![key] -------------------------------------------------------------------------------- 329: const publicGetter = publicPropertiesMap[key] -------------------------------------------------------------------------------- 358: const val = globalProperties[key] packages/runtime-core/src/componentRenderUtils.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 154: const key = allAttrs[i] -------------------------------------------------------------------------------- 276: const child = children[i] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via key Details: https://sg.run/XBkj 298: ;(res || (res = {}))[key] = attrs[key] -------------------------------------------------------------------------------- 308: res[key] = attrs[key] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 357: const key = dynamicProps[i] -------------------------------------------------------------------------------- 399: const key = nextKeys[i] packages/runtime-core/src/componentSlots.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via key Details: https://sg.run/XBkj 89: const value = rawSlots[key] packages/runtime-core/src/components/BaseTransition.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 464: const child = children[i] packages/runtime-core/src/components/Teleport.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 246: const child = (children as VNode[])[i] packages/runtime-core/src/customFormatter.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via key Details: https://sg.run/XBkj 161: extracted[key] = instance.ctx[key] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via type Details: https://sg.run/XBkj 168: const opts = Comp[type] packages/runtime-core/src/directives.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 99: let [dir, value, arg, modifiers = EMPTY_OBJ] = directives[i] -------------------------------------------------------------------------------- 130: const binding = bindings[i] packages/runtime-core/src/errorHandling.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via type Details: https://sg.run/XBkj 148: const info = ErrorTypeStrings[type] packages/runtime-core/src/helpers/createSlots.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 22: const slot = dynamicSlots[i] packages/runtime-core/src/helpers/renderList.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 85: const key = keys[i] packages/runtime-core/src/helpers/renderSlot.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via name Details: https://sg.run/XBkj 40: let slot = slots[name] packages/runtime-core/src/helpers/toHandlers.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via key Details: https://sg.run/XBkj 15: ret[toHandlerKey(key)] = obj[key] packages/runtime-core/src/renderer.ts rule:javascript.lang.correctness.useless-eqeq.eqeq-is-bad: Detected a useless comparison operation `dynamicChildren == dynamicChildren` or `dynamicChildren != dynamicChildren`. This operation is always true. If testing for floating point NaN, use `math.isnan`, or `cmath.isnan` if the number is complex. Details: https://sg.run/Kl6n 941: } else if (!optimized && dynamicChildren == null) { -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 913: const key = propsToUpdate[i] -------------------------------------------------------------------------------- 973: const oldVNode = oldChildren[i] -------------------------------------------------------------------------------- 974: const newVNode = newChildren[i] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via key Details: https://sg.run/XBkj 1019: const next = newProps[key] -------------------------------------------------------------------------------- 1020: const prev = oldProps[key] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 2501: const arrI = arr[i] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via result.length - 1 Details: https://sg.run/XBkj 2503: j = result[result.length - 1] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via u - 1 Details: https://sg.run/XBkj 2521: p[i] = result[u - 1] -------------------------------------------------------------------------------- 2528: v = result[u - 1] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.prototype-pollution.prototype-pollution-function.prototype-pollution-function: Possibility of prototype polluting function detected. By adding or modifying attributes of an object prototype, it is possible to create attributes that exist on every object, or replace critical attributes with malicious ones. This can be problematic if the software depends on existence or non-existence of certain attributes, or uses pre-defined attributes of object prototype (such as hasOwnProperty, toString or valueOf). Possible mitigations might be: freezing the object prototype, using an object without prototypes (via Object.create(null) ), blocking modifications of attributes that resolve to object prototype, using Map instead of object. Details: https://sg.run/kkZe 2400: refs[oldRef] = null -------------------------------------------------------------------------------- 2402: setupState[oldRef] = null -------------------------------------------------------------------------------- 2414: refs[ref] = value -------------------------------------------------------------------------------- 2417: setupState[ref] = value -------------------------------------------------------------------------------- 2480: c2 = ch2[i] = cloneIfMounted(ch2[i] as VNode) packages/runtime-core/src/vnode.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 783: const toMerge = args[i] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via key Details: https://sg.run/XBkj 792: const existing = ret[key] -------------------------------------------------------------------------------- 793: const incoming = toMerge[key] -------------------------------------------------------------------------------- 800: ret[key] = toMerge[key] packages/runtime-core/src/warning.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via stack.length - 1 Details: https://sg.run/XBkj 75: let currentVNode: VNode | null = stack[stack.length - 1] packages/runtime-dom/__tests__/directives/vOn.spec.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via button Details: https://sg.run/XBkj 120: triggerEvent(el, 'mousedown', e => (e.button = buttonCodes[button])) -------------------------------------------------------------------------------- 123: triggerEvent(el, 'mousedown', e => (e.button = buttonCodes[button])) packages/runtime-dom/src/apiCustomElement.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via key Details: https://sg.run/XBkj 226: const opt = props[key] packages/runtime-dom/src/components/Transition.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via key Details: https://sg.run/XBkj 114: ;(baseProps as any)[key] = (rawProps as any)[key] packages/runtime-dom/src/components/TransitionGroup.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 122: const child = children[i] -------------------------------------------------------------------------------- 135: const child = prevChildren[i] packages/runtime-dom/src/directives/vModel.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 224: const option = el.options[i] packages/runtime-dom/src/directives/vOn.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via modifiers[i] Details: https://sg.run/XBkj 38: const guard = modifierGuards[modifiers[i]] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via mod Details: https://sg.run/XBkj 103: const codes = globalKeyCodes[mod] packages/runtime-dom/src/helpers/useCssModule.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via name Details: https://sg.run/XBkj 17: const mod = modules[name] packages/runtime-dom/src/index.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 89: const attr = container.attributes[i] packages/runtime-dom/src/modules/events.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via rawName Details: https://sg.run/XBkj 73: const existingInvoker = invokers[rawName] packages/runtime-dom/src/modules/style.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via rawName Details: https://sg.run/XBkj 71: const cached = prefixCache[rawName] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.prototype-pollution.prototype-pollution-function.prototype-pollution-function: Possibility of prototype polluting function detected. By adding or modifying attributes of an object prototype, it is possible to create attributes that exist on every object, or replace critical attributes with malicious ones. This can be problematic if the software depends on existence or non-existence of certain attributes, or uses pre-defined attributes of object prototype (such as hasOwnProperty, toString or valueOf). Possible mitigations might be: freezing the object prototype, using an object without prototypes (via Object.create(null) ), blocking modifications of attributes that resolve to object prototype, using Map instead of object. Details: https://sg.run/kkZe 61: style[prefixed as any] = val packages/runtime-test/src/serialize.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via key Details: https://sg.run/XBkj 42: const value = node.props[key] packages/runtime-test/src/triggerEvent.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via event Details: https://sg.run/XBkj 11: const listener = eventListeners[event] packages/server-renderer/src/helpers/ssrCompile.ts rule:javascript.lang.security.detect-eval-with-expression.detect-eval-with-expression: Detected eval(variable), which could allow a malicious actor to run arbitrary code. Details: https://sg.run/6nwK 79: return (compileCache[cacheKey] = Function('require', code)(require)) packages/server-renderer/src/helpers/ssrRenderAttrs.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via key Details: https://sg.run/XBkj 30: const value = props[key] packages/server-renderer/src/helpers/ssrRenderList.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 29: const key = keys[i] packages/server-renderer/src/helpers/ssrRenderSlot.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via slotName Details: https://sg.run/XBkj 24: const slotFn = slots[slotName] packages/server-renderer/src/render.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 332: const binding = dirs[i] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.prototype-pollution.prototype-pollution-function.prototype-pollution-function: Possibility of prototype polluting function detected. By adding or modifying attributes of an object prototype, it is possible to create attributes that exist on every object, or replace critical attributes with malicious ones. This can be problematic if the software depends on existence or non-existence of certain attributes, or uses pre-defined attributes of object prototype (such as hasOwnProperty, toString or valueOf). Possible mitigations might be: freezing the object prototype, using an object without prototypes (via Object.create(null) ), blocking modifications of attributes that resolve to object prototype, using Map instead of object. Details: https://sg.run/kkZe 67: buffer[buffer.length - 1] += item as string packages/server-renderer/src/renderToStream.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 26: let item = buffer[i] -------------------------------------------------------------------------------- 45: let item = buffer[i] packages/server-renderer/src/renderToString.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 18: let item = buffer[i] -------------------------------------------------------------------------------- 39: let item = buffer[i] packages/shared/src/index.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via str Details: https://sg.run/XBkj 95: const hit = cache[str] packages/shared/src/normalizeProp.ts rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via i Details: https://sg.run/XBkj 12: const item = value[i] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via key Details: https://sg.run/XBkj 18: res[key] = normalized[key] -------------------------------------------------------------------------------- 52: const value = styles[key] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.prototype-pollution.prototype-pollution-function.prototype-pollution-function: Possibility of prototype polluting function detected. By adding or modifying attributes of an object prototype, it is possible to create attributes that exist on every object, or replace critical attributes with malicious ones. This can be problematic if the software depends on existence or non-existence of certain attributes, or uses pre-defined attributes of object prototype (such as hasOwnProperty, toString or valueOf). Possible mitigations might be: freezing the object prototype, using an object without prototypes (via Object.create(null) ), blocking modifications of attributes that resolve to object prototype, using Map instead of object. Details: https://sg.run/kkZe 18: res[key] = normalized[key] packages/vue/src/index.ts rule:javascript.lang.security.detect-eval-with-expression.detect-eval-with-expression: Detected eval(variable), which could allow a malicious actor to run arbitrary code. Details: https://sg.run/6nwK 78: __GLOBAL__ ? new Function(code)() : new Function('Vue', code)(runtimeDom) -------------------------------------------------------------------------------- 78: __GLOBAL__ ? new Function(code)() : new Function('Vue', code)(runtimeDom) packages/vue-compat/src/index.ts rule:javascript.lang.security.detect-eval-with-expression.detect-eval-with-expression: Detected eval(variable), which could allow a malicious actor to run arbitrary code. Details: https://sg.run/6nwK 83: __GLOBAL__ ? new Function(code)() : new Function('Vue', code)(runtimeDom) -------------------------------------------------------------------------------- 83: __GLOBAL__ ? new Function(code)() : new Function('Vue', code)(runtimeDom) rollup.config.js rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via key Details: https://sg.run/XBkj 279: replacements[key] = process.env[key] scripts/release.js rule:javascript.lang.security.audit.detect-bracket-object-injection.detect-bracket-object-injection: Object injection via bracket notation via depType Details: https://sg.run/XBkj 160: const deps = pkg[depType] -------------------------------------------------------------------------------- rule:javascript.lang.security.audit.prototype-pollution.prototype-pollution-assignment.prototype-pollution-assignment: Possibility of prototype polluting assignment detected. By adding or modifying attributes of an object prototype, it is possible to create attributes that exist on every object, or replace critical attributes with malicious ones. This can be problematic if the software depends on existence or non-existence of certain attributes, or uses pre-defined attributes of object prototype (such as hasOwnProperty, toString or valueOf). Possible mitigations might be: freezing the object prototype, using an object without prototypes (via Object.create(null) ), blocking modifications of attributes that resolve to object prototype, using Map instead of object. Details: https://sg.run/N8AA 170: deps[dep] = version