@codacy/tools-flawfinder-2 0.1.0

package/dist/index.js

@@ -0,0 +1,2166 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+var import_tooling2 = require("@codacy/tooling");
+
+// src/adapter.ts
+var import_tooling = require("@codacy/tooling");
+var import_path = __toESM(require("path"));
+var import_promises = __toESM(require("fs/promises"));
+
+// src/patterns.json
+var patterns_default = [
+  {
+    id: "flawfinder_access",
+    category: "Security",
+    severityLevel: "High",
+    title: "Detect Potential Security Flaws in access() Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_AddAccessAllowedAce",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid AddAccessAllowedAce calls without setting inheritance bits",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_atoi",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid unsafe usage of atoi",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_atol",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid unchecked use of atol",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_bcopy",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid unsafe use of bcopy",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_char",
+    category: "Security",
+    severityLevel: "High",
+    title: "Detect Potential Security Problems in char Array Usage",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_chgrp",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Race Condition in chgrp Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_chmod",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid insecure use of chmod with filename arguments",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_chown",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid insecure use of chown calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_chroot",
+    category: "Security",
+    severityLevel: "High",
+    title: "Detect Potential Security Issues in chroot Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_CoImpersonateClient",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid failing CoImpersonateClient calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_CopyMemory",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid Unsafe CopyMemory Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_CreateProcess",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Unsafe Use of CreateProcess Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_CreateProcessAsUser",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Unsafe Use of CreateProcessAsUser",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_CreateProcessWithLogon",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid Unsafe Use of CreateProcessWithLogon",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_crypt",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Using Weak crypt() Function",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_crypt_r",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Using crypt_r with Weak Hashing Algorithm",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_curl_getenv",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Using curl_getenv with Untrusted Environment Variables",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_cuserid",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid use of cuserid() function",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_drand48",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Using drand48 for Security-Sensitive Randomness",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_equal",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid unsafe use of equal calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_erand48",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Using erand48 for Security-Critical Randomness",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_EVP_des_cbc",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Use of EVP_des_cbc (DES with CBC mode)",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_EVP_des_cfb",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid Using EVP_des_cfb Due to Weak DES Encryption",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_EVP_des_ecb",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Using EVP_des_ecb for Encryption",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_EVP_des_ofb",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Using EVP_des_ofb with DES",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_EVP_desx_cbc",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid Using EVP_desx_cbc with DES Encryption",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_EVP_rc2_40_cbc",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Using EVP_rc2_40_cbc with Small Key Sizes",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_EVP_rc2_64_cbc",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Using EVP_rc2_64_cbc with Small Key Sizes",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_EVP_rc4_40",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Using EVP_rc4_40 with Small Key Sizes",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_execl",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid unsafe use of execl calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_execle",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid insecure use of execle calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_execlp",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Unsafe Use of execlp Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_execv",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Unsafe execv Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_execvp",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Unsafe Use of execvp",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_fgetc",
+    category: "Security",
+    severityLevel: "High",
+    title: "Check Buffer Boundaries in fgetc Calls",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "flawfinder_fopen",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Unsafe fopen Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_fprintf",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid Unsafe fprintf Usage",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_fread",
+    category: "Security",
+    severityLevel: "High",
+    title: "Detect Potential Security Issues in fread Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_fscanf",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid unsafe fscanf %s usage",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder__ftcscat",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid unsafe use of _ftcscat",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder__ftcscpy",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid unsafe _ftcscpy usage",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder__ftprintf",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid Unsafe _ftprintf Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder__ftscanf",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid unsafe _ftscanf %s usage",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_fvwprintf",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid insecure use of fvwprintf",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_fwprintf",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid insecure usage of fwprintf with attacker-controlled format strings",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_fwscanf",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid unsafe usage of fwscanf with %s specifier",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_getc",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Unsafe Use of getc",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "flawfinder_getchar",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Unsafe Use of getchar()",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "flawfinder_getenv",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Unsafe Use of getenv",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_getlogin",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Using getlogin() for Security-Related Purposes",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_getopt",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Unsafe getopt Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_getopt_long",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Unsafe getopt_long Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_getpass",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Using Obsolete getpass Function",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_getpw",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Using getpw Function",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_gets",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid using gets function",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder__gettc",
+    category: "Security",
+    severityLevel: "High",
+    title: "Check buffer boundaries in _gettc calls",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "flawfinder_GetTempFileName",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid insecure use of GetTempFileName",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder__getts",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid _getts Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_getwd",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Using getwd Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_g_get_home_dir",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Using g_get_home_dir Due to Untrusted Input",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_g_get_tmp_dir",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Using g_get_tmp_dir for Temporary Directory Retrieval",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_g_rand_boolean",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Using g_rand_boolean for Security-Sensitive Randomness",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_g_rand_double",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid using g_rand_double for security-related randomness",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_g_rand_double_range",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid use of g_rand_double_range for security-sensitive randomness",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_g_rand_int",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid Using g_rand_int for Security-Critical Randomness",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_g_rand_int_range",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid Using g_rand_int_range for Security-Critical Randomness",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_g_random_boolean",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Using g_random_boolean for Security-Sensitive Randomness",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_g_random_double",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Using g_random_double for Security-Critical Randomness",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_g_random_double_range",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Using g_random_double_range for Security-Critical Randomness",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_g_random_int",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Using g_random_int for Security-Sensitive Randomness",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_g_random_int_range",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Using g_random_int_range for Security-Critical Randomness",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_gsignal",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid use of obsolete gsignal functions",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_ImpersonateDdeClientWindow",
+    category: "Security",
+    severityLevel: "High",
+    title: "Detect Potential Security Issues in ImpersonateDdeClientWindow Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_ImpersonateLoggedOnUser",
+    category: "Security",
+    severityLevel: "High",
+    title: "Detect potential security problems in ImpersonateLoggedOnUser calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_ImpersonateNamedPipeClient",
+    category: "Security",
+    severityLevel: "High",
+    title: "Detect Potential Security Issues in ImpersonateNamedPipeClient Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_ImpersonateSecurityContext",
+    category: "Security",
+    severityLevel: "High",
+    title: "Detect Potential Security Issues in ImpersonateSecurityContext Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_InitializeCriticalSection",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Exceptions in InitializeCriticalSection Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_is_permutation",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid unsafe use of is_permutation that may cause iterator over-read",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_jrand48",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Using jrand48 for Security-Related Randomness",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_lcong48",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Using lcong48 for Security-Critical Randomness",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_LoadLibrary",
+    category: "Security",
+    severityLevel: "High",
+    title: "Ensure Full Path in LoadLibrary Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_LoadLibraryEx",
+    category: "Security",
+    severityLevel: "High",
+    title: "Ensure Full Path in LoadLibraryEx Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_lrand48",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid using lrand48 for security-sensitive randomness",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_lstrcat",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid Unsafe Use of lstrcat",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_lstrcatA",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid Unsafe Use of lstrcatA",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_lstrcatn",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Incorrect Usage of lstrcatn",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "flawfinder_lstrcatnA",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid Unsafe Use of lstrcatnA",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_lstrcatnW",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid unsafe use of lstrcatnW",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_lstrcatW",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid unsafe usage of lstrcatW",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_lstrcpy",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid unsafe use of lstrcpy",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_lstrcpyA",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid unsafe use of lstrcpyA",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_lstrcpyn",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Incorrect Use of lstrcpyn",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "flawfinder_lstrcpynA",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid insecure use of lstrcpynA calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_lstrcpynW",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid unsafe use of lstrcpynW",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_lstrcpyW",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid Unsafe Use of lstrcpyW",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_lstrncat",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid unsafe use of lstrncat",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder__mbccat",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid unsafe use of _mbccat function",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder__mbccpy",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid _mbccpy Calls Without Buffer Overflow Checks",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder__mbscat",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Unsafe _mbscat Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder__mbscpy",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid _mbscpy Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder__mbslen",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Unsafe _mbslen Calls",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "flawfinder__mbsnbcat",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Unsafe Use of _mbsnbcat",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "flawfinder__mbsnbcpy",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Incorrect Use of _mbsnbcpy",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "flawfinder__mbsncpy",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid unsafe use of _mbsncpy",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_memalign",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Unsafe memalign Usage",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "flawfinder_memcpy",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid Unsafe memcpy Usage",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_mismatch",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Unsafe Usage of std::mismatch",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_mkstemp",
+    category: "Security",
+    severityLevel: "High",
+    title: "Detect Potential Security Vulnerabilities in mkstemp Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_mktemp",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid insecure mktemp usage",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_mrand48",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid using mrand48 for security-related randomness",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_MultiByteToWideChar",
+    category: "Security",
+    severityLevel: "High",
+    title: "Ensure MultiByteToWideChar Maximum Length Is in Characters",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_nrand48",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Using nrand48 for Security-Critical Randomness",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_open",
+    category: "Security",
+    severityLevel: "High",
+    title: "Detect Potential Security Issues in open() Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_popen",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid Unsafe Use of popen",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_printf",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid Unsafe Use of printf with Untrusted Format Strings",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_random",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Using Insufficiently Random Functions for Security",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_read",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Check Buffer Boundaries in read Calls",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "flawfinder_readlink",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid insecure use of readlink",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_readv",
+    category: "Security",
+    severityLevel: "High",
+    title: "Detect Potential Security Issues in readv Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_realpath",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid unsafe realpath usage",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_recv",
+    category: "Security",
+    severityLevel: "High",
+    title: "Detect Potential Security Issues in recv Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_recvfrom",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid unsafe usage of recvfrom calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_recvmsg",
+    category: "Security",
+    severityLevel: "High",
+    title: "Detect Potential Security Issues in recvmsg Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_RpcImpersonateClient",
+    category: "Security",
+    severityLevel: "High",
+    title: "Check RpcImpersonateClient Call Success",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_scanf",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid Unsafe scanf %s Usage",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_seed48",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Using seed48 for Security-Critical Randomness",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_SetSecurityDescriptorDacl",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid Creating NULL ACLs with SetSecurityDescriptorDacl",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_setstate",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid using setstate for security-related randomness",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_SetThreadToken",
+    category: "Security",
+    severityLevel: "High",
+    title: "Detect Potential Security Issues in SetThreadToken Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_ShellExecute",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Unsafe ShellExecute Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_snprintf",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid insecure usage of snprintf",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder__snprintf",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Detect Potential Security Issues in _snprintf Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder__sntprintf",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid Unsafe Use of _sntprintf",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_sprintf",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid Unsafe Use of sprintf",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_srand",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Using srand for Security-Sensitive Randomness",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_srandom",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Using srandom for Security-Sensitive Randomness",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_sscanf",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid unsafe usage of sscanf with %s specifier",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_ssignal",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid usage of ssignal function",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder__stprintf",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid unsafe use of _stprintf",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_strcadd",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid unsafe use of strcadd",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "flawfinder_strcat",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid unsafe use of strcat",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_StrCat",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid Unsafe Use of strcat",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_StrCatA",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid unsafe use of StrCatA",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_strCatBuff",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid Unsafe Use of strCatBuff",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_StrCatBuffA",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid unsafe use of StrCatBuffA",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_StrCatBuffW",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid unsafe usage of StrCatBuffW",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_StrCatChainW",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Unsafe Use of StrCatChainW",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_StrCatN",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid unsafe use of StrCatN",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_StrCatNA",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid unsafe use of StrCatNA",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_StrCatNW",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid unsafe use of StrCatNW",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_StrcatW",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid unsafe use of StrcatW",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_strccpy",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid unsafe use of strccpy",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "flawfinder_strcpy",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid unsafe use of strcpy",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_StrCpy",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid Using strcpy to Prevent Buffer Overflows",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_strcpyA",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid unsafe strcpyA calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_StrCpyA",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid unsafe use of StrCpyA calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_StrCpyN",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid unsafe StrCpyN calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_strcpynA",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid unsafe usage of strcpynA",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_StrCpyNA",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Unsafe Use of StrCpyNA",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_StrCpyNW",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Unsafe Use of StrCpyNW",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_strcpyW",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid unsafe strcpyW usage",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_streadd",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Using streadd Function",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_strecpy",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Using strecpy Function",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_strfry",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid using strfry for security-related randomness",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_strlen",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid unsafe usage of strlen on non-null-terminated strings",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "flawfinder_strncat",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Incorrect Use of strncat",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "flawfinder_StrNCat",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid unsafe strncat usage",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_StrNCatA",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid Unsafe Use of StrNCatA",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_StrNCatW",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid unsafe StrNCatW calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_strncpy",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid Incorrect Use of strncpy",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "flawfinder_StrNCpy",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid unsafe usage of strncpy",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_StrNCpyA",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid unsafe use of StrNCpyA calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_StrNCpyW",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid Unsafe Use of StrNCpyW",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_strtrns",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Unsafe strtrns Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_swprintf",
+    category: "Security",
+    severityLevel: "High",
+    title: "Detect Potential Buffer Overflow in swprintf Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_syslog",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid Untrusted Input in syslog Format Strings",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_system",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Using system() Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder__tccat",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid unsafe use of _tccat calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder__tccpy",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid using _tccpy to prevent buffer overflows",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_TCHAR",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Potential Security Problems in TCHAR Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder__tcscat",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid unsafe use of _tcscat",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder__tcscpy",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Unsafe _tcscpy Usage",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder__tcslen",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Unsafe Use of _tcslen",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "flawfinder__tcsncat",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Incorrect Usage of _tcsncat",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "flawfinder__tcsncpy",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Incorrect Use of _tcsncpy",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "flawfinder_tempnam",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Using tempnam for Temporary File Creation",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_tmpfile",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Using tmpfile() Function",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_tmpnam",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid Using tmpnam Function",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder__tscanf",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid unsafe usage of _tscanf with %s specifier",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_ulimit",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Using Obsolete ulimit C Routine",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "flawfinder_umask",
+    category: "Security",
+    severityLevel: "High",
+    title: "Enforce Restrictive umask Settings",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "flawfinder_usleep",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid using usleep function",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "flawfinder_vfork",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Unsafe Use of vfork",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_vfprintf",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid Unsafe vfprintf Usage",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_vfscanf",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid unsafe vfscanf %s usage without length limit",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder__vftprintf",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid unsafe _vftprintf calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_vfwprintf",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid unsafe vfwprintf usage",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_vfwscanf",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid unsafe usage of vfwscanf with %s specifier",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_vprintf",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid insecure use of vprintf format strings",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_vscanf",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid Unsafe vscanf Usage",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_vsnprintf",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid insecure usage of vsnprintf",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder__vsntprintf",
+    category: "Security",
+    severityLevel: "High",
+    title: "Detect Potential Security Issues in _vsntprintf Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_vsprintf",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid using vsprintf",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_vsscanf",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Unsafe vsscanf Usage",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder__vstprintf",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid Unsafe _vstprintf Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_vswprintf",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Unsafe vswprintf Usage",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_vswscanf",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid unsafe use of vswscanf with %s specifier",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder__vtprintf",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid Unsafe Use of _vtprintf Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_vwprintf",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Unsafe vwprintf Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_vwscanf",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid unsafe vwscanf calls without length limit",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_wchar_t",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Unsafe Usage of wchar_t Arrays",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_wcscat",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid Unsafe Use of wcscat",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_wcscpy",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid unsafe use of wcscpy",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_wcslen",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid unsafe wcslen calls",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "flawfinder_wcsncat",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid Incorrect Use of wcsncat",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "flawfinder_wcsncpy",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Incorrect Usage of wcsncpy",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "flawfinder_WinExec",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid Unsafe Use of WinExec",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_wprintf",
+    category: "Security",
+    severityLevel: "Error",
+    title: "Avoid unsafe wprintf usage",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder_wscanf",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid unsafe usage of wscanf with %s specifier",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder__wtoi",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid unchecked use of _wtoi",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "flawfinder__wtoi64",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid unchecked use of _wtoi64",
+    enabled: false,
+    parameters: []
+  }
+];
+
+// src/adapter.ts
+var TOOL_ID = "flawfinder";
+var PIP_PACKAGE = "flawfinder==2.0.19";
+var BINARY = "flawfinder";
+var PATTERN_META = new Map(
+  patterns_default.map((p) => [
+    p.id,
+    {
+      category: p.category,
+      severity: p.severityLevel ?? "Info"
+    }
+  ])
+);
+function ruleMetadata(ruleId) {
+  const patternId = (0, import_tooling.buildPatternId)(TOOL_ID, ruleId);
+  return PATTERN_META.get(patternId) ?? { category: "Security", severity: "Info" };
+}
+function extractFunctionName(ruleName) {
+  const slashIdx = ruleName.lastIndexOf("/");
+  return slashIdx >= 0 ? ruleName.slice(slashIdx + 1) : ruleName;
+}
+function getLineContent(lines, lineNumber) {
+  return lines[lineNumber - 1] ?? "";
+}
+async function readFileLines(filePath) {
+  try {
+    const content = await import_promises.default.readFile(filePath, "utf-8");
+    return content.split("\n");
+  } catch {
+    return [];
+  }
+}
+function buildResult(startedAt, completedAt, issues, errors, filesAnalyzed) {
+  const durationMs = completedAt.getTime() - startedAt.getTime();
+  return {
+    metadata: {
+      startedAt: startedAt.toISOString(),
+      completedAt: completedAt.toISOString(),
+      durationMs
+    },
+    issues,
+    errors,
+    summary: {
+      toolId: TOOL_ID,
+      status: errors.some((e) => e.level === "error") ? "partial" : "success",
+      issueCount: issues.length,
+      errorCount: errors.length,
+      durationMs,
+      filesAnalyzed
+    }
+  };
+}
+async function getVersionFromBinary(binaryPath) {
+  try {
+    const { stdout, stderr, exitCode } = await (0, import_tooling.spawnTool)(binaryPath, ["--version"], {
+      cwd: process.cwd()
+    });
+    if (exitCode !== 0) return null;
+    const output = (stdout || stderr || "").trim();
+    const match = output.match(/(\d+\.\d+\.\d+)/);
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+async function resolveBinaryPath(ctx) {
+  const venvDir = (0, import_tooling.getVenvDir)(ctx.globalDir, adapter.id);
+  const venvBin = import_path.default.join(venvDir, "bin", BINARY);
+  const venvVersion = await getVersionFromBinary(venvBin);
+  if (venvVersion) return venvBin;
+  return BINARY;
+}
+var adapter = {
+  id: TOOL_ID,
+  displayName: "Flawfinder",
+  preferredVersion: "2.0.19",
+  compatibleVersions: ">=2.0.0",
+  website: "https://dwheeler.com/flawfinder/",
+  languages: ["C", "CPP"],
+  filePatterns: ["**/*.c", "**/*.h", "**/*.cpp", "**/*.cc", "**/*.cxx", "**/*.hpp"],
+  supportedOS: ["linux", "darwin"],
+  supportedArch: ["x64", "arm64"],
+  supportedRunners: ["local", "container"],
+  prerequisites: [
+    {
+      name: "Python",
+      versionRange: ">=3.8.0",
+      preferredVersion: "3.12.0",
+      checkCommand: "python3 --version"
+    }
+  ],
+  /**
+   * Checks whether the `flawfinder` binary is present and runnable.
+   *
+   * Checks in order:
+   * 1. Codacy-managed venv at `~/.codacy/runtimes/flawfinder/venv/bin/flawfinder`
+   * 2. Global PATH (`flawfinder`)
+   *
+   * Parses the version from `Flawfinder version X.Y.Z`. Returns `available: false`
+   * (rather than throwing) if the binary is not found or returns a non-zero exit code.
+   */
+  async checkAvailability(ctx) {
+    ctx.logger.debug("Checking availability", { toolId: TOOL_ID });
+    const pythonInfo = await (0, import_tooling.findPython)(void 0, ctx.logger).catch(() => null);
+    const dependencies = pythonInfo ? [{ name: "Python", available: true, version: pythonInfo.version, installation: "global" }] : [{ name: "Python", available: false, reason: "Python 3 not found" }];
+    const venvDir = (0, import_tooling.getVenvDir)(ctx.globalDir, adapter.id);
+    const venvBinPath = import_path.default.join(venvDir, "bin", BINARY);
+    const venvVersion = await getVersionFromBinary(venvBinPath);
+    if (venvVersion) {
+      ctx.logger.debug("Found flawfinder in codacy venv", { toolId: TOOL_ID, version: venvVersion });
+      return {
+        available: true,
+        version: venvVersion,
+        path: venvBinPath,
+        installation: "codacy",
+        dependencies
+      };
+    }
+    const globalVersion = await getVersionFromBinary(BINARY);
+    if (globalVersion) {
+      ctx.logger.debug("Found flawfinder on global PATH", { toolId: TOOL_ID, version: globalVersion });
+      return {
+        available: true,
+        version: globalVersion,
+        installation: "global",
+        dependencies
+      };
+    }
+    ctx.logger.debug("flawfinder not found", { toolId: TOOL_ID });
+    return {
+      available: false,
+      reason: "flawfinder not found in PATH or Codacy venv",
+      installHint: "pip install flawfinder  # or\ncodacy-analysis analyze . --install-dependencies  # auto-install",
+      dependencies
+    };
+  },
+  /**
+   * Installs flawfinder into an isolated Python virtual environment.
+   *
+   * Steps:
+   * 1. Find a Python 3 interpreter on the system.
+   * 2. Create (or reuse) a venv at `~/.codacy/runtimes/flawfinder/venv/`.
+   * 3. Run `pip install flawfinder==2.0.19` inside the venv.
+   * 4. Verify the installed binary runs and return its path and version.
+   */
+  async install(ctx) {
+    ctx.logger.info("Starting install", { toolId: TOOL_ID });
+    const python = await (0, import_tooling.ensurePython)(ctx.globalDir, void 0, ctx.logger);
+    if (!python) {
+      return {
+        success: false,
+        error: {
+          toolId: TOOL_ID,
+          phase: "requirementCheck",
+          kind: "MissingPrerequisite",
+          message: "Python 3 could not be found or downloaded. Install Python 3.8+ or enable auto-install.",
+          level: "error"
+        }
+      };
+    }
+    try {
+      const venvDir = (0, import_tooling.getVenvDir)(ctx.globalDir, adapter.id);
+      ctx.logger.info(`Ensuring venv at ${venvDir} (python: ${python.path})`);
+      const venv = await (0, import_tooling.ensureVenv)(python.path, venvDir, ctx.logger);
+      ctx.logger.info(`Installing ${PIP_PACKAGE} into venv...`);
+      await (0, import_tooling.pipInstall)(venv, [PIP_PACKAGE], ctx.logger);
+      const installedVersion = await (0, import_tooling.checkVenvTool)(
+        venv,
+        BINARY,
+        "--version",
+        /(\d+\.\d+\.\d+)/,
+        ctx.logger
+      );
+      if (!installedVersion) {
+        return {
+          success: false,
+          error: {
+            toolId: TOOL_ID,
+            phase: "toolInstall",
+            kind: "VerificationFailed",
+            message: "flawfinder was installed but the version could not be verified",
+            level: "error"
+          }
+        };
+      }
+      const installedPath = (0, import_tooling.resolveVenvBinary)(venv, BINARY);
+      ctx.logger.info(`Installed flawfinder v${installedVersion} at ${installedPath}`);
+      return { success: true, installedPath, installedVersion };
+    } catch (err) {
+      return {
+        success: false,
+        error: {
+          toolId: TOOL_ID,
+          phase: "toolInstall",
+          kind: "InstallError",
+          message: `Failed to install flawfinder: ${err instanceof Error ? err.message : String(err)}`,
+          level: "error"
+        }
+      };
+    }
+  },
+  /**
+   * Flawfinder has no configuration file — all options are passed via CLI flags.
+   * Always returns `{ found: false }`.
+   */
+  async checkLocalConfigurationFile(_ctx) {
+    _ctx.logger.debug("Checking for local config", { toolId: TOOL_ID });
+    return { found: false };
+  },
+  /**
+   * Runs `flawfinder --sarif --falsepositive <files...>` against the target files
+   * and converts the SARIF JSON output into Codacy Issue objects.
+   *
+   * Key details:
+   * - `--sarif` produces SARIF v2.1.0 JSON on stdout.
+   * - `--falsepositive` / `-F` excludes likely false positives (matches legacy wrapper).
+   * - Exit code is always 0 on successful analysis.
+   * - Exit code 15 = encoding error, 16 = CLI option error.
+   * - Pattern filtering is done post-hoc since flawfinder has no rule selection flag.
+   *
+   * SARIF parsing extracts `runs[0].results[]` — each result has a `ruleId`
+   * (the function name), location, and message.
+   *
+   * Never throws — all errors are captured in the returned `errors` array.
+   */
+  async analyze(ctx, codacyConfig) {
+    const startMs = Date.now();
+    ctx.logger.info("Starting analysis", { toolId: TOOL_ID, fileCount: ctx.targetFiles.length });
+    const startedAt = /* @__PURE__ */ new Date();
+    const issues = [];
+    const errors = [];
+    if (ctx.targetFiles.length === 0) {
+      return buildResult(startedAt, /* @__PURE__ */ new Date(), issues, errors, 0);
+    }
+    const binary = await resolveBinaryPath(ctx);
+    const absoluteFiles = ctx.targetFiles.map((f) => import_path.default.resolve(ctx.repositoryRoot, f));
+    const args = ["--sarif", "--falsepositive", ...absoluteFiles];
+    try {
+      const { stdout, stderr, exitCode } = await (0, import_tooling.spawnTool)(binary, args, {
+        cwd: ctx.repositoryRoot,
+        logger: ctx.logger
+      });
+      if (exitCode !== 0) {
+        errors.push({
+          toolId: TOOL_ID,
+          phase: "toolInvoke",
+          kind: "NonZeroExit",
+          message: `flawfinder exited with code ${exitCode}${stderr ? `: ${stderr.trim()}` : ""}`,
+          level: "error"
+        });
+        return buildResult(startedAt, /* @__PURE__ */ new Date(), issues, errors, ctx.targetFiles.length);
+      }
+      if (!stdout.trim()) {
+        return buildResult(startedAt, /* @__PURE__ */ new Date(), issues, errors, ctx.targetFiles.length);
+      }
+      let sarif;
+      try {
+        sarif = JSON.parse(stdout);
+      } catch (err) {
+        errors.push({
+          toolId: TOOL_ID,
+          phase: "outputParse",
+          kind: "MalformedOutput",
+          message: `Failed to parse flawfinder SARIF output: ${err instanceof Error ? err.message : String(err)}`,
+          level: "error"
+        });
+        return buildResult(startedAt, /* @__PURE__ */ new Date(), issues, errors, ctx.targetFiles.length);
+      }
+      const run = sarif.runs?.[0];
+      const results = run?.results ?? [];
+      const ruleIdToFunctionName = /* @__PURE__ */ new Map();
+      for (const rule of run?.tool?.driver?.rules ?? []) {
+        if (rule.id && rule.name) {
+          ruleIdToFunctionName.set(rule.id, extractFunctionName(rule.name));
+        }
+      }
+      const enabledPatterns = new Set(codacyConfig.patterns.map((p) => p.patternId));
+      const resultsByFile = /* @__PURE__ */ new Map();
+      for (const result2 of results) {
+        const loc = result2.locations?.[0]?.physicalLocation;
+        if (!loc) continue;
+        const uri = loc.artifactLocation?.uri;
+        if (!uri) continue;
+        const functionName = ruleIdToFunctionName.get(result2.ruleId) ?? result2.ruleId;
+        const line = loc.region?.startLine ?? 1;
+        const column = loc.region?.startColumn ?? 1;
+        const absoluteFilePath = import_path.default.isAbsolute(uri) ? uri : import_path.default.resolve(ctx.repositoryRoot, uri);
+        const list = resultsByFile.get(absoluteFilePath) ?? [];
+        list.push({ result: result2, functionName, filePath: absoluteFilePath, line, column });
+        resultsByFile.set(absoluteFilePath, list);
+      }
+      for (const [absoluteFilePath, fileResults] of resultsByFile) {
+        const lines = await readFileLines(absoluteFilePath);
+        const relPath = import_path.default.relative(ctx.repositoryRoot, absoluteFilePath);
+        for (const { result: result2, functionName, line, column } of fileResults) {
+          const patternId = (0, import_tooling.buildPatternId)(TOOL_ID, functionName);
+          if (enabledPatterns.size > 0 && !enabledPatterns.has(patternId)) {
+            continue;
+          }
+          const meta = ruleMetadata(functionName);
+          issues.push({
+            filePath: relPath,
+            patternId,
+            toolId: TOOL_ID,
+            line,
+            column,
+            message: result2.message.text,
+            lineContent: getLineContent(lines, line),
+            category: meta.category,
+            severity: meta.severity
+          });
+        }
+      }
+      if (stderr.trim()) {
+        errors.push({
+          toolId: TOOL_ID,
+          phase: "outputParse",
+          kind: "ParseWarning",
+          message: `flawfinder stderr: ${stderr.trim()}`,
+          level: "warning"
+        });
+      }
+    } catch (err) {
+      errors.push({
+        toolId: TOOL_ID,
+        phase: "toolInvoke",
+        kind: "InvocationError",
+        message: `Failed to run flawfinder: ${err instanceof Error ? err.message : String(err)}`,
+        level: "error"
+      });
+    }
+    const result = buildResult(startedAt, /* @__PURE__ */ new Date(), issues, errors, ctx.targetFiles.length);
+    ctx.logger.info("Analysis complete", {
+      toolId: TOOL_ID,
+      issueCount: result.summary.issueCount,
+      errorCount: result.summary.errorCount,
+      durationMs: Date.now() - startMs
+    });
+    return result;
+  }
+};
+
+// src/index.ts
+var index_default = (0, import_tooling2.defineToolAdapter)(adapter);