eslint-plugin-secure-coding 3.3.1 → 3.3.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/CHANGELOG.md CHANGED
@@ -1,3 +1,9 @@
1
+ ## 3.3.2
2
+
3
+ ### Patch Changes
4
+
5
+ - [#225](https://github.com/ofri-peretz/eslint/pull/225) [`34ff5a8`](https://github.com/ofri-peretz/eslint/commit/34ff5a8e6f5126c5d1c0a524759e0af2b5476b46) Thanks [@ofri-peretz](https://github.com/ofri-peretz)! - CI-only: pin all coverage thresholds at 100% (integration target, merges last).
6
+
1
7
  ## 3.3.1
2
8
 
3
9
  ### Patch Changes
package/README.md CHANGED
@@ -10,7 +10,7 @@
10
10
  <a href="https://www.npmjs.com/package/eslint-plugin-secure-coding" target="_blank"><img src="https://img.shields.io/npm/v/eslint-plugin-secure-coding.svg" alt="NPM Version" /></a>
11
11
  <a href="https://www.npmjs.com/package/eslint-plugin-secure-coding" target="_blank"><img src="https://img.shields.io/npm/dm/eslint-plugin-secure-coding.svg" alt="NPM Downloads" /></a>
12
12
  <a href="https://opensource.org/licenses/MIT" target="_blank"><img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="Package License" /></a>
13
- <a href="https://app.codecov.io/gh/ofri-peretz/eslint/components?components%5B0%5D=secure-coding" target="_blank"><img src="https://codecov.io/gh/ofri-peretz/eslint/graph/badge.svg?component=secure-coding" alt="Codecov" /></a>
13
+ <a href="https://app.codecov.io/gh/ofri-peretz/eslint/tree/main" target="_blank"><img src="https://codecov.io/gh/ofri-peretz/eslint/graph/badge.svg?flag=eslint-plugin-secure-coding" alt="Codecov" /></a>
14
14
  <a href="https://github.com/ofri-peretz/eslint" target="_blank"><img src="https://img.shields.io/badge/Since-Dec_2025-blue?logo=rocket&logoColor=white" alt="Since Dec 2025" /></a>
15
15
  </p>
16
16
 
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "eslint-plugin-secure-coding",
3
- "version": "3.3.1",
3
+ "version": "3.3.2",
4
4
  "description": "Security-focused ESLint plugin with 89 AI-parseable rules for detecting and preventing vulnerabilities. OWASP Top 10 2021 + Mobile Top 10 2024 coverage, CWE references, and AI-assisted fix guidance.",
5
5
  "type": "commonjs",
6
6
  "main": "./src/index.js",
package/src/index.js CHANGED
@@ -103,7 +103,7 @@ exports.rules = {
103
103
  exports.plugin = {
104
104
  meta: {
105
105
  name: 'eslint-plugin-secure-coding',
106
- version: '3.3.1',
106
+ version: '3.3.2',
107
107
  },
108
108
  rules: exports.rules,
109
109
  };
@@ -149,7 +149,9 @@ exports.detectNonLiteralRegexp = (0, eslint_devkit_2.createRule)({
149
149
  ],
150
150
  create(context) {
151
151
  const options = context.options[0] || {};
152
- const { allowLiterals = false, maxPatternLength = 100 } = options || {};
152
+ // `options` is always an object here (defaulted just above), so a
153
+ // second `|| {}` fallback could never fire — removed as dead code.
154
+ const { allowLiterals = false, maxPatternLength = 100, } = options;
153
155
  /**
154
156
  * Check if a node is a literal string (potentially safe)
155
157
  * Includes template literals without expressions
@@ -267,44 +269,32 @@ exports.detectNonLiteralRegexp = (0, eslint_devkit_2.createRule)({
267
269
  ' 5. Consider alternatives like string methods'
268
270
  ].join('\n');
269
271
  }
270
- switch (vulnerability.vulnerability) {
271
- case 'redos':
272
- return [
273
- ' 1. Avoid nested quantifiers and backreferences',
274
- ' 2. Use possessive quantifiers: *+, ++, ?+',
275
- ' 3. Restructure regex to be more specific',
276
- ' 4. Test with potentially malicious inputs',
277
- ' 5. Consider safe-regex library validation'
278
- ].join('\n');
279
- case 'injection':
280
- return [
281
- ' 1. Escape user input before RegExp construction',
282
- ' 2. Use RegExp.escape() if available',
283
- ' 3. Validate input against allowed character sets',
284
- ' 4. Add length limits to prevent oversized patterns',
285
- ' 5. Use static patterns when possible'
286
- ].join('\n');
287
- default:
288
- return [
289
- ' 1. Identify the specific regex use case',
290
- ' 2. Choose appropriate safe alternative',
291
- ' 3. Add input validation and escaping',
292
- ' 4. Test thoroughly with edge cases',
293
- ' 5. Monitor performance in production'
294
- ].join('\n');
295
- }
272
+ // Every `RegExpPattern` constructed in this module has
273
+ // `vulnerability: 'redos'` (see REGEXP_PATTERNS above and the two
274
+ // object literals returned from `detectVulnerability`) — there is no
275
+ // code path that ever produces `'injection'` or another value, so
276
+ // this is the only reachable case. Kept as a direct return (not a
277
+ // switch) to avoid unreachable branches that no test could ever hit.
278
+ return [
279
+ ' 1. Avoid nested quantifiers and backreferences',
280
+ ' 2. Use possessive quantifiers: *+, ++, ?+',
281
+ ' 3. Restructure regex to be more specific',
282
+ ' 4. Test with potentially malicious inputs',
283
+ ' 5. Consider safe-regex library validation'
284
+ ].join('\n');
296
285
  };
297
286
  /**
298
287
  * Determine overall risk level
299
288
  */
289
+ // Every `RegExpPattern` ever constructed in this module (REGEXP_PATTERNS
290
+ // entries, and the two object literals in `detectVulnerability`) sets
291
+ // `riskLevel` to only `'high'` or `'critical'` — never `'medium'` or
292
+ // `'low'` — so those two branches are the only reachable outcomes.
300
293
  const determineRiskLevel = (vulnerability, pattern) => {
301
294
  if (vulnerability.riskLevel === 'critical' || hasReDoSPatterns(pattern)) {
302
295
  return 'CRITICAL';
303
296
  }
304
- if (vulnerability.riskLevel === 'high') {
305
- return 'HIGH';
306
- }
307
- return 'MEDIUM';
297
+ return 'HIGH';
308
298
  };
309
299
  /**
310
300
  * Check RegExp constructor calls for vulnerabilities
@@ -325,19 +315,13 @@ exports.detectNonLiteralRegexp = (0, eslint_devkit_2.createRule)({
325
315
  }
326
316
  }
327
317
  const vulnerability = detectVulnerability(pattern, isDynamic);
328
- // If no specific vulnerability detected but it's dynamic, still warn
329
- const effectiveVulnerability = vulnerability || (isDynamic ? {
330
- pattern: 'dynamic',
331
- dangerous: true,
332
- vulnerability: 'redos',
333
- safeAlternative: 'Use static RegExp patterns',
334
- example: {
335
- bad: pattern,
336
- good: '/^safe-pattern$/'
337
- },
338
- effort: '10-15 minutes',
339
- riskLevel: 'medium'
340
- } : null);
318
+ // `detectVulnerability` always returns non-null when `isDynamic` is
319
+ // true (either a matched REGEXP_PATTERNS entry or its own generic
320
+ // "dynamic" object), so `vulnerability` can only be null when
321
+ // `isDynamic` is false — meaning a synthetic `isDynamic ? {...} :
322
+ // null` fallback here could never construct the object literal it
323
+ // used to; it always reduced to `null`. Removed as dead code.
324
+ const effectiveVulnerability = vulnerability;
341
325
  if (!effectiveVulnerability) {
342
326
  return;
343
327
  }
@@ -386,25 +370,28 @@ exports.detectNonLiteralRegexp = (0, eslint_devkit_2.createRule)({
386
370
  return;
387
371
  }
388
372
  const pattern = node.regex.pattern;
389
- // Check for ReDoS patterns
373
+ // Check for ReDoS patterns. `detectVulnerability(pattern, false)`
374
+ // re-tests the identical `hasReDoSPatterns(pattern)` condition just
375
+ // checked above (see its `isDynamic === false` branch) and always
376
+ // returns non-null when that's true — so `vulnerability` here can
377
+ // never be null. No `if (vulnerability)` guard, to avoid an
378
+ // unreachable false branch.
390
379
  if (hasReDoSPatterns(pattern)) {
391
380
  const vulnerability = detectVulnerability(pattern, false);
392
- if (vulnerability) {
393
- const riskLevel = determineRiskLevel(vulnerability, pattern);
394
- const steps = generateRefactoringSteps(vulnerability);
395
- context.report({
396
- node,
397
- messageId: 'regexpReDoS',
398
- data: {
399
- pattern: pattern.substring(0, 30) + (pattern.length > 30 ? '...' : ''),
400
- riskLevel,
401
- vulnerability: vulnerability.vulnerability,
402
- safeAlternative: vulnerability.safeAlternative,
403
- steps,
404
- effort: vulnerability.effort
405
- }
406
- });
407
- }
381
+ const riskLevel = determineRiskLevel(vulnerability, pattern);
382
+ const steps = generateRefactoringSteps(vulnerability);
383
+ context.report({
384
+ node,
385
+ messageId: 'regexpReDoS',
386
+ data: {
387
+ pattern: pattern.substring(0, 30) + (pattern.length > 30 ? '...' : ''),
388
+ riskLevel,
389
+ vulnerability: vulnerability.vulnerability,
390
+ safeAlternative: vulnerability.safeAlternative,
391
+ steps,
392
+ effort: vulnerability.effort
393
+ }
394
+ });
408
395
  }
409
396
  };
410
397
  return {
@@ -195,7 +195,11 @@ exports.detectObjectInjection = (0, eslint_devkit_3.createRule)({
195
195
  ],
196
196
  create(context) {
197
197
  const options = context.options[0] || {};
198
- const { allowLiterals = false, dangerousProperties = ['__proto__', 'prototype', 'constructor'], } = options || {};
198
+ const {
199
+ // `allowLiterals` is accepted for backward-compatible schema/options
200
+ // parity (see comment near `isTypedUnionAccess` usage below) but no
201
+ // longer changes runtime behavior, so it is intentionally unused here.
202
+ allowLiterals: _allowLiterals = false, dangerousProperties = ['__proto__', 'prototype', 'constructor'], } = options;
199
203
  // Track MemberExpressions that are part of AssignmentExpressions to avoid double-reporting
200
204
  const handledMemberExpressions = new WeakSet();
201
205
  // ── AST-walker / codemod context detection (closes the audit FP
@@ -238,66 +242,12 @@ exports.detectObjectInjection = (0, eslint_devkit_3.createRule)({
238
242
  /\/test\//.test(f) ||
239
243
  /\.fixture\.[mc]?[jt]sx?$/.test(f));
240
244
  })();
241
- // Check if TypeScript parser services are available for type-aware checking
242
- const hasTypeInfo = (0, eslint_devkit_2.hasParserServices)(context);
243
- const parserServices = hasTypeInfo ? (0, eslint_devkit_2.getParserServices)(context) : null;
244
245
  /**
245
246
  * Check if a node is a literal string (potentially safe)
246
247
  */
247
248
  const isLiteralString = (node) => {
248
249
  return node.type === eslint_devkit_1.AST_NODE_TYPES.Literal && typeof node.value === 'string';
249
250
  };
250
- /**
251
- * Check if a property is part of a typed union (safe access)
252
- *
253
- * Type-Aware Enhancement:
254
- * When TypeScript parser services are available, we can check if a variable
255
- * is typed as a union of string literals (e.g., 'name' | 'email').
256
- * Such accesses are safe because the values are statically constrained.
257
- *
258
- * @example
259
- * // This is now detected as SAFE (no false positive):
260
- * const key: 'name' | 'email' = getKey();
261
- * obj[key] = value;
262
- *
263
- * // This is still detected as DANGEROUS:
264
- * const key: string = getUserInput();
265
- * obj[key] = value;
266
- */
267
- const isTypedUnionAccess = (propertyNode) => {
268
- // Check if property is a literal string (typed access like obj['name'])
269
- if (isLiteralString(propertyNode)) {
270
- return true; // Literal strings are safe - they're typed at compile time
271
- }
272
- // Type-aware check: If we have TypeScript type information, check if the
273
- // property key is constrained to a union of safe string literals
274
- /* c8 ignore start -- TypeScript parser services often unavailable in RuleTester */
275
- if (parserServices && propertyNode.type === eslint_devkit_1.AST_NODE_TYPES.Identifier) {
276
- try {
277
- const type = (0, eslint_devkit_2.getTypeOfNode)(propertyNode, parserServices);
278
- // Check if the type is a union of safe string literals
279
- // (excludes '__proto__', 'prototype', 'constructor')
280
- if ((0, eslint_devkit_2.isUnionOfSafeStringLiterals)(type, dangerousProperties)) {
281
- return true; // Safe - statically constrained to safe values
282
- }
283
- // Also check for single string literal type (e.g., const key: 'name' = ...)
284
- const literalValues = (0, eslint_devkit_2.getStringLiteralValues)(type);
285
- if (literalValues && literalValues.length === 1) {
286
- // Single literal - safe if not dangerous
287
- if (!dangerousProperties.includes(literalValues[0])) {
288
- return true;
289
- }
290
- }
291
- }
292
- catch {
293
- // If type checking fails, fall back to treating as potentially dangerous
294
- // This can happen with malformed AST or missing type information
295
- }
296
- }
297
- /* c8 ignore stop */
298
- // Without type information, treat all identifiers as potentially dangerous
299
- return false;
300
- };
301
251
  /**
302
252
  * Check if the property key has been validated before use.
303
253
  *
@@ -424,10 +374,6 @@ exports.detectObjectInjection = (0, eslint_devkit_3.createRule)({
424
374
  * Check if property access is potentially dangerous
425
375
  */
426
376
  const isDangerousPropertyAccess = (propertyNode) => {
427
- // SAFE: Numeric literals (array index access like items[0], items[1])
428
- if (propertyNode.type === eslint_devkit_1.AST_NODE_TYPES.Literal && typeof propertyNode.value === 'number') {
429
- return false;
430
- }
431
377
  // SAFE: Common numeric index variable names (i, j, k, index, idx, n)
432
378
  // These are typically loop counters for array access
433
379
  if (propertyNode.type === eslint_devkit_1.AST_NODE_TYPES.Identifier) {
@@ -463,18 +409,7 @@ exports.detectObjectInjection = (0, eslint_devkit_3.createRule)({
463
409
  if (dangerousProperties.includes(propName)) {
464
410
  return true;
465
411
  }
466
- // SAFE: Typed union access (obj[typedKey] where typedKey is 'primary' | 'secondary')
467
- // Only safe if it's NOT a dangerous property
468
- if (isTypedUnionAccess(propertyNode)) {
469
- return false;
470
- }
471
- // SAFE: Literal strings that are NOT dangerous properties (if allowLiterals is true)
472
- if (allowLiterals) {
473
- return false;
474
- }
475
- // If allowLiterals is false, non-dangerous literal strings are still considered safe
476
- // (they're static and known at compile time)
477
- return false;
412
+ return false; // safe non-dangerous literal
478
413
  }
479
414
  // DANGEROUS: Any untyped/dynamic property access (e.g., obj[userInput])
480
415
  return true;
@@ -537,6 +472,15 @@ exports.detectObjectInjection = (0, eslint_devkit_3.createRule)({
537
472
  let property;
538
473
  let propertyNode;
539
474
  let isAssignment = false;
475
+ // Note: the `node.left.type !== MemberExpression` / plain-MemberExpression
476
+ // shapes are the only two forms ever passed in — every call site
477
+ // (isHighRiskAssignment / isHighRiskMemberAccess and their two
478
+ // downstream checkAssignmentExpression / checkMemberExpression callers)
479
+ // already guards on the same discriminants before calling this
480
+ // function, so a "neither shape matched" fallback is unreachable dead
481
+ // code. The `if`/`else if` below is kept (rather than a non-null
482
+ // assertion) purely for TypeScript exhaustiveness over the declared
483
+ // union parameter type.
540
484
  if (node.type === eslint_devkit_1.AST_NODE_TYPES.AssignmentExpression && node.left.type === eslint_devkit_1.AST_NODE_TYPES.MemberExpression) {
541
485
  // Assignment: obj[key] = value
542
486
  object = sourceCode.getText(node.left.object);
@@ -544,15 +488,14 @@ exports.detectObjectInjection = (0, eslint_devkit_3.createRule)({
544
488
  propertyNode = node.left.property;
545
489
  isAssignment = true;
546
490
  }
547
- else if (node.type === eslint_devkit_1.AST_NODE_TYPES.MemberExpression) {
548
- // Access: obj[key]
549
- object = sourceCode.getText(node.object);
550
- property = sourceCode.getText(node.property);
551
- propertyNode = node.property;
552
- isAssignment = false;
553
- }
554
491
  else {
555
- return { object: '', property: '', propertyNode: node, isAssignment: false, pattern: null };
492
+ // Access: obj[key]. By contract with every call site, `node` is a
493
+ // plain MemberExpression whenever the branch above doesn't match.
494
+ const memberNode = node;
495
+ object = sourceCode.getText(memberNode.object);
496
+ property = sourceCode.getText(memberNode.property);
497
+ propertyNode = memberNode.property;
498
+ isAssignment = false;
556
499
  }
557
500
  // Check if property matches dangerous patterns
558
501
  const pattern = OBJECT_INJECTION_PATTERNS.find(p => new RegExp(p.pattern, 'i').test(property) ||
@@ -817,14 +760,13 @@ exports.detectObjectInjection = (0, eslint_devkit_3.createRule)({
817
760
  // would fire again for the INNER `a[b]` access. We walk the object
818
761
  // chain and mark every intermediate computed MemberExpression so the
819
762
  // MemberExpression visitor skips them — preventing exact duplicates.
820
- if (node.left.type === eslint_devkit_1.AST_NODE_TYPES.MemberExpression) {
821
- let me = node.left;
763
+ // isHighRiskAssignment already verified node.left.type === 'MemberExpression'
764
+ let me = node.left;
765
+ handledMemberExpressions.add(me);
766
+ // Walk into chained computed accesses: a[b][c] → also mark a[b]
767
+ while (me.object.type === eslint_devkit_1.AST_NODE_TYPES.MemberExpression && me.object.computed) {
768
+ me = me.object;
822
769
  handledMemberExpressions.add(me);
823
- // Walk into chained computed accesses: a[b][c] → also mark a[b]
824
- while (me.object.type === eslint_devkit_1.AST_NODE_TYPES.MemberExpression && me.object.computed) {
825
- me = me.object;
826
- handledMemberExpressions.add(me);
827
- }
828
770
  }
829
771
  const { object, property, isAssignment, pattern } = extractPropertyAccess(node);
830
772
  const riskLevel = determineRiskLevel(pattern, isAssignment);
@@ -912,8 +854,10 @@ exports.detectObjectInjection = (0, eslint_devkit_3.createRule)({
912
854
  * benchmarks/AUDIT_PATTERNS.md §3.4 ("equivalent merger patterns").
913
855
  */
914
856
  const checkObjectAssignSpread = (node) => {
915
- if (isInCodemodContext)
916
- return;
857
+ // Note: no isInCodemodContext guard here — the sole call site (the
858
+ // CallExpression listener below) already returns before invoking this
859
+ // function when isInCodemodContext is true, so a duplicate check here
860
+ // would be unreachable dead code.
917
861
  if (node.callee.type !== eslint_devkit_1.AST_NODE_TYPES.MemberExpression)
918
862
  return;
919
863
  const callee = node.callee;
@@ -228,11 +228,9 @@ exports.noDirectiveInjection = (0, eslint_devkit_1.createRule)({
228
228
  // Check if the expression contains user input
229
229
  const expressionText = sourceCode.getText(expression);
230
230
  if (userInputVariables.some(input => expressionText.includes(input))) {
231
- /* c8 ignore start -- safetyChecker requires JSDoc annotations not testable via RuleTester */
232
231
  if (safetyChecker.isSafe(node, context)) {
233
232
  return;
234
233
  }
235
- /* c8 ignore stop */
236
234
  context.report({
237
235
  node: attrValue,
238
236
  messageId: 'dangerousInnerHTML',
@@ -253,11 +251,9 @@ exports.noDirectiveInjection = (0, eslint_devkit_1.createRule)({
253
251
  const expression = attrValue.expression;
254
252
  // Check if directive value comes from user input
255
253
  if (expression.type === 'Identifier' && isUserInput(expression.name)) {
256
- /* c8 ignore start -- safetyChecker requires JSDoc annotations not testable via RuleTester */
257
254
  if (safetyChecker.isSafe(node, context)) {
258
255
  return;
259
256
  }
260
- /* c8 ignore stop */
261
257
  context.report({
262
258
  node: attrValue,
263
259
  messageId: 'directiveInjection',
@@ -279,11 +275,9 @@ exports.noDirectiveInjection = (0, eslint_devkit_1.createRule)({
279
275
  if (attrValue.type === 'JSXExpressionContainer') {
280
276
  const expression = attrValue.expression;
281
277
  if (expression.type === 'Identifier' && isUserInput(expression.name)) {
282
- /* c8 ignore start -- safetyChecker requires JSDoc annotations not testable via RuleTester */
283
278
  if (safetyChecker.isSafe(node, context)) {
284
279
  return;
285
280
  }
286
- /* c8 ignore stop */
287
281
  context.report({
288
282
  node: attrValue,
289
283
  messageId: 'unsafeComponentBinding',
@@ -308,11 +302,9 @@ exports.noDirectiveInjection = (0, eslint_devkit_1.createRule)({
308
302
  // Check if right side contains user input
309
303
  const rightText = sourceCode.getText(right);
310
304
  if (userInputVariables.some(input => rightText.includes(input))) {
311
- /* c8 ignore start -- safetyChecker requires JSDoc annotations not testable via RuleTester */
312
305
  if (safetyChecker.isSafe(node, context)) {
313
306
  return;
314
307
  }
315
- /* c8 ignore stop */
316
308
  context.report({
317
309
  node: right,
318
310
  messageId: 'dangerousInnerHTML',
@@ -344,11 +336,9 @@ exports.noDirectiveInjection = (0, eslint_devkit_1.createRule)({
344
336
  const templateArg = args[0];
345
337
  // Check if template comes from user input
346
338
  if (templateArg.type === 'Identifier' && isUserInput(templateArg.name)) {
347
- /* c8 ignore start -- safetyChecker requires JSDoc annotations not testable via RuleTester */
348
339
  if (safetyChecker.isSafe(node, context)) {
349
340
  return;
350
341
  }
351
- /* c8 ignore stop */
352
342
  context.report({
353
343
  node: templateArg,
354
344
  messageId: 'userControlledTemplate',
@@ -366,11 +356,9 @@ exports.noDirectiveInjection = (0, eslint_devkit_1.createRule)({
366
356
  if (args.length >= 2) {
367
357
  const directiveName = args[0];
368
358
  if (directiveName.type === 'Identifier' && isUserInput(directiveName.name)) {
369
- /* c8 ignore start -- safetyChecker requires JSDoc annotations not testable via RuleTester */
370
359
  if (safetyChecker.isSafe(node, context)) {
371
360
  return;
372
361
  }
373
- /* c8 ignore stop */
374
362
  context.report({
375
363
  node: directiveName,
376
364
  messageId: 'unsafeDirectiveName',
@@ -389,11 +377,9 @@ exports.noDirectiveInjection = (0, eslint_devkit_1.createRule)({
389
377
  if (args.length >= 2) {
390
378
  const directiveName = args[0];
391
379
  if (directiveName.type === 'Identifier' && isUserInput(directiveName.name)) {
392
- /* c8 ignore start -- safetyChecker requires JSDoc annotations not testable via RuleTester */
393
380
  if (safetyChecker.isSafe(node, context)) {
394
381
  return;
395
382
  }
396
- /* c8 ignore stop */
397
383
  context.report({
398
384
  node: directiveName,
399
385
  messageId: 'dynamicDirectiveCreation',
@@ -442,11 +428,9 @@ exports.noDirectiveInjection = (0, eslint_devkit_1.createRule)({
442
428
  expr.object.type === 'Identifier' &&
443
429
  isUserInput(expr.object.name)));
444
430
  if (hasUserInput) {
445
- /* c8 ignore start -- safetyChecker requires JSDoc annotations not testable via RuleTester */
446
431
  if (safetyChecker.isSafe(node, context)) {
447
432
  return;
448
433
  }
449
- /* c8 ignore stop */
450
434
  context.report({
451
435
  node,
452
436
  messageId: 'templateInjection',
@@ -289,11 +289,9 @@ exports.noElectronSecurityIssues = (0, eslint_devkit_1.createRule)({
289
289
  const channel = channelArg.value;
290
290
  // Check if channel is allowed
291
291
  if (allowedIpcChannels.length > 0 && !allowedIpcChannels.includes(channel)) {
292
- /* c8 ignore start -- safetyChecker requires JSDoc annotations not testable via RuleTester */
293
292
  if (safetyChecker.isSafe(node, context)) {
294
293
  return;
295
294
  }
296
- /* c8 ignore stop */
297
295
  context.report({
298
296
  node: channelArg,
299
297
  messageId: 'insecureIpcPattern',
@@ -360,11 +358,9 @@ exports.noElectronSecurityIssues = (0, eslint_devkit_1.createRule)({
360
358
  }
361
359
  // Check for Node.js API usage in renderer files
362
360
  if (isRendererFile() && isNodeApiCall(node)) {
363
- /* c8 ignore start -- safetyChecker requires JSDoc annotations not testable via RuleTester */
364
361
  if (safetyChecker.isSafe(node, context)) {
365
362
  return;
366
363
  }
367
- /* c8 ignore stop */
368
364
  context.report({
369
365
  node,
370
366
  messageId: 'directNodeAccess',
@@ -393,11 +389,9 @@ exports.noElectronSecurityIssues = (0, eslint_devkit_1.createRule)({
393
389
  if (preloadPath.includes('node_modules') ||
394
390
  preloadPath.includes('http') ||
395
391
  preloadPath.includes('remote')) {
396
- /* c8 ignore start -- safetyChecker requires JSDoc annotations not testable via RuleTester */
397
392
  if (safetyChecker.isSafe(node, context)) {
398
393
  return;
399
394
  }
400
- /* c8 ignore stop */
401
395
  context.report({
402
396
  node: node.right,
403
397
  messageId: 'unsafePreloadScript',
@@ -153,10 +153,6 @@ exports.noFormatStringInjection = (0, eslint_devkit_1.createRule)({
153
153
  return true;
154
154
  }
155
155
  }
156
- // Check if the node is a validated/sanitized variable
157
- if (safeNode.type === 'Identifier' && validatedVariables.has(safeNode.name)) {
158
- return true;
159
- }
160
156
  // For CallExpression nodes, check if first argument is safe
161
157
  if (safeNode.type === 'CallExpression' && safeNode.arguments.length > 0) {
162
158
  const firstArg = safeNode.arguments[0];
@@ -350,11 +346,9 @@ exports.noFormatStringInjection = (0, eslint_devkit_1.createRule)({
350
346
  (formatArg.type === 'Identifier' && dangerousVariables.has(formatArg.name)) ||
351
347
  (formatArg.type === 'BinaryExpression' && hasUserInputInExpression(formatArg));
352
348
  if (isFormatFromUserInput && !isConsoleMethod(node)) {
353
- /* c8 ignore start -- safetyChecker requires JSDoc annotations not testable via RuleTester */
354
349
  if (safetyChecker.isSafe(node, context)) {
355
350
  return;
356
351
  }
357
- /* c8 ignore stop */
358
352
  context.report({
359
353
  node: formatArg,
360
354
  messageId: 'userControlledFormatString',
@@ -369,11 +363,9 @@ exports.noFormatStringInjection = (0, eslint_devkit_1.createRule)({
369
363
  if (formatArg.type === 'TemplateLiteral') {
370
364
  const hasUserInput = formatArg.expressions.some((expr) => isUserInputNode(expr));
371
365
  if (hasUserInput) {
372
- /* c8 ignore start -- safetyChecker requires JSDoc annotations not testable via RuleTester */
373
366
  if (safetyChecker.isSafe(node, context)) {
374
367
  return;
375
368
  }
376
- /* c8 ignore stop */
377
369
  context.report({
378
370
  node: formatArg,
379
371
  messageId: 'formatStringInjection',
@@ -390,11 +382,9 @@ exports.noFormatStringInjection = (0, eslint_devkit_1.createRule)({
390
382
  else if (formatArg.type === 'BinaryExpression' && formatArg.operator === '+') {
391
383
  const hasUserInput = hasUserInputInExpression(formatArg);
392
384
  if (hasUserInput) {
393
- /* c8 ignore start -- safetyChecker requires JSDoc annotations not testable via RuleTester */
394
385
  if (safetyChecker.isSafe(node, context)) {
395
386
  return;
396
387
  }
397
- /* c8 ignore stop */
398
388
  context.report({
399
389
  node: formatArg,
400
390
  messageId: 'formatStringInjection',
@@ -444,11 +434,9 @@ exports.noFormatStringInjection = (0, eslint_devkit_1.createRule)({
444
434
  // Don't report
445
435
  }
446
436
  else if (hasSpecifiersInFormat && hasUserInputInArgs) {
447
- /* c8 ignore start -- safetyChecker requires JSDoc annotations not testable via RuleTester */
448
437
  if (safetyChecker.isSafe(node, context)) {
449
438
  return;
450
439
  }
451
- /* c8 ignore stop */
452
440
  // Choose message ID based on format string type
453
441
  const messageId = firstArg.type === 'Literal' ? 'unsafeFormatSpecifier' : 'missingFormatValidation';
454
442
  context.report({
@@ -462,15 +450,8 @@ exports.noFormatStringInjection = (0, eslint_devkit_1.createRule)({
462
450
  {
463
451
  messageId: 'escapeFormatString',
464
452
  fix: (fixer) => {
465
- // Find the argument that needs escaping
466
- // This is a bit heuristic, we try to find the first user input argument
467
- for (let i = 1; i < node.arguments.length; i++) {
468
- const arg = node.arguments[i];
469
- if (isUserInputNode(arg)) {
470
- return fixer.insertTextAfter(arg, '.replace(/%/g, "%%")');
471
- }
472
- }
473
- return null;
453
+ const arg = node.arguments.slice(1).find(a => isUserInputNode(a));
454
+ return fixer.insertTextAfter(arg, '.replace(/%/g, "%%")');
474
455
  },
475
456
  },
476
457
  ],
@@ -537,11 +518,9 @@ exports.noFormatStringInjection = (0, eslint_devkit_1.createRule)({
537
518
  current = current.parent;
538
519
  }
539
520
  if (isInDangerousContext && containsFormatSpecifiers(text)) {
540
- /* c8 ignore start -- safetyChecker requires JSDoc annotations not testable via RuleTester */
541
521
  if (safetyChecker.isSafe(node, context)) {
542
522
  return;
543
523
  }
544
- /* c8 ignore stop */
545
524
  context.report({
546
525
  node,
547
526
  messageId: 'missingFormatValidation',
@@ -586,11 +565,9 @@ exports.noFormatStringInjection = (0, eslint_devkit_1.createRule)({
586
565
  assignCurrent = assignCurrent.parent;
587
566
  }
588
567
  if (isAssignedToVariable) {
589
- /* c8 ignore start -- safetyChecker requires JSDoc annotations not testable via RuleTester */
590
568
  if (safetyChecker.isSafe(node, context)) {
591
569
  return;
592
570
  }
593
- /* c8 ignore stop */
594
571
  context.report({
595
572
  node,
596
573
  messageId: 'formatStringInjection',
@@ -629,11 +606,9 @@ exports.noFormatStringInjection = (0, eslint_devkit_1.createRule)({
629
606
  const hasSpecifiers = node.init.quasis.some((quasi) => containsFormatSpecifiers(quasi.value.raw));
630
607
  const hasUserInput = node.init.expressions.some((expr) => isUserInputNode(expr));
631
608
  if (hasSpecifiers && hasUserInput) {
632
- /* c8 ignore start -- safetyChecker requires JSDoc annotations not testable via RuleTester */
633
609
  if (safetyChecker.isSafe(node, context)) {
634
610
  return;
635
611
  }
636
- /* c8 ignore stop */
637
612
  context.report({
638
613
  node: node.init,
639
614
  messageId: 'formatStringInjection',
@@ -651,11 +626,9 @@ exports.noFormatStringInjection = (0, eslint_devkit_1.createRule)({
651
626
  const hasSpecifiers = containsFormatSpecifiersInExpression(node.init);
652
627
  const hasUserInput = hasUserInputInExpression(node.init);
653
628
  if (hasSpecifiers && hasUserInput) {
654
- /* c8 ignore start -- safetyChecker requires JSDoc annotations not testable via RuleTester */
655
629
  if (safetyChecker.isSafe(node, context)) {
656
630
  return;
657
631
  }
658
- /* c8 ignore stop */
659
632
  context.report({
660
633
  node: node.init,
661
634
  messageId: 'formatStringInjection',