{"schema_version":"2","scorer_version":"0.1.0","scoring_version":"prov-5+qual-2+sec-2","generated_at":"2026-11-14T14:52:04.374012Z","repo":{"ref":{"host":"github.com","owner":"farbrausch","name":"fr_public"},"default_branch":"master","clone_url":"https://github.com/farbrausch/fr_public.git","html_url":"https://github.com/farbrausch/fr_public","description":"Farbrausch demo tools 2001-2011","stars":3839,"forks":407,"is_fork":false,"is_archived":false,"is_private":false,"size_kb":47174,"primary_language":"C++","license_spdx":null,"created_at":"2012-04-11T05:28:30Z","pushed_at":"2019-07-28T21:02:28Z","security_policy_url":null,"distribution":{"owner_created_at":"2012-04-14T20:54:12Z","owner_type":"Organization","release_assets":[]}},"commit_sha":"8c8f82c2ae01133370e649bbc05916e7aceecadd","profile":{"lines_by_language":{"C++":877180,"C":97733},"files_by_category":{"source":1503,"other":472,"docs":256,"binary":183,"oversized":30,"config":19},"source_lines":974913,"test_lines":0},"pillars":{"ai_provenance":{"score":0.0,"confidence":0.65,"coverage":1.0,"label":"none-detected","breakdown":{"attributed_share":0.0,"suspected_share":0.0,"estimated_share":0.0,"ai_artifacts":0.0,"flagged_work_units":0.0,"flagged_releases":null,"style_index":0.097},"summary":"No AI attribution or AI-consistent velocity signals detected."},"quality":{"score":31.7,"confidence":0.9,"coverage":1.0,"label":"poor","breakdown":{"complexity":36.5,"duplication":4.5,"lint":99.9,"testing":0.0,"docs":40.0,"type_safety":null,"process":null},"summary":"Code quality is poor: test-to-source ratio 0.00, no CI test run detected; 34% of function code in complex or long functions; 52% duplicated lines. Weakest area: testing."},"security":{"score":80.1,"confidence":0.85,"coverage":1.0,"label":"adequate","breakdown":{"secrets":96.7,"sast":99.3,"dependencies":null,"ci_actions":null,"posture":0.0,"scorecard":null},"summary":"Security posture is adequate: no high-impact findings. Weakest area: posture."}},"analyzer_results":[{"analyzer":"sec-scorecard","pillar":"security","status":"skipped","tool_version":null,"metrics":{},"findings":[],"evidence":[],"data":{},"error":"no published OpenSSF Scorecard result for this repo"},{"analyzer":"sec-registry","pillar":"security","status":"skipped","tool_version":null,"metrics":{},"findings":[],"evidence":[],"data":{},"error":"no registry dependencies declared"},{"analyzer":"ai-attribution","pillar":"ai_provenance","status":"ok","tool_version":"signatures-v1","metrics":{"commits":309.0,"attributed_commits":0.0,"attributed_commit_share":0.0,"effective_loc":1027946.0,"attributed_loc":0.0,"attributed_loc_share":0.0,"tools_detected":0.0},"findings":[],"evidence":[],"data":{"attributed_loc_by_commit":{},"tools":{},"monthly":{"2012-04":{"loc":825330,"attributed_loc":0},"2012-05":{"loc":457,"attributed_loc":0},"2012-06":{"loc":296,"attributed_loc":0},"2012-07":{"loc":6690,"attributed_loc":0},"2012-08":{"loc":30428,"attributed_loc":0},"2012-09":{"loc":9118,"attributed_loc":0},"2012-10":{"loc":404,"attributed_loc":0},"2012-11":{"loc":51,"attributed_loc":0},"2012-12":{"loc":6233,"attributed_loc":0},"2013-01":{"loc":26,"attributed_loc":0},"2013-03":{"loc":7522,"attributed_loc":0},"2013-06":{"loc":1147,"attributed_loc":0},"2013-08":{"loc":0,"attributed_loc":0},"2014-04":{"loc":278,"attributed_loc":0},"2014-09":{"loc":139011,"attributed_loc":0},"2015-03":{"loc":510,"attributed_loc":0},"2016-03":{"loc":130,"attributed_loc":0},"2017-04":{"loc":315,"attributed_loc":0}}},"error":null},{"analyzer":"ai-artifacts","pillar":"ai_provenance","status":"ok","tool_version":"signatures-v1","metrics":{"artifacts":0.0,"workflow_agents":0.0,"tools_configured":0.0},"findings":[],"evidence":[],"data":{"artifacts":[],"workflows":[],"tools":[]},"error":null},{"analyzer":"ai-velocity","pillar":"ai_provenance","status":"ok","tool_version":"prov-4","metrics":{"work_units":146.0,"flagged_units":0.0,"pre_ai_era_bursts":10.0,"pre_ai_era_measured_loc":100002.0,"pre_ai_era_burst_loc":83819.0,"measured_loc":100002.0,"flagged_loc":0.0,"flagged_loc_share":0.0,"max_loc_per_hour":6694.54520377905,"median_loc_per_hour":112.63751489868892,"pr_timed_units":0.0,"excluded_import_loc":927944.0},"findings":[],"evidence":[],"data":{"flagged_loc_by_commit":{},"excluded_import_commits":["0a3d41c160eea3eb1ecd28faad3fee859059a6b8","1829c804028057204910bc62b6499ea963a2408c","2707a07c0af0ba6b4213df247b6c456efe16de66","80bbe3ce39a8bd5497902972b720eb38072f4182","ac7742d9480ae4123173a571fd46cc7bf62dcaeb","c46c5bb548e7427b5fa10467e2df1dbad97b405a","d19b62252ac1bd9c793f70fede5b2d5c98e790e2","da8e5cb032f18b2968ec5417574fcb965e7c626f","ebd813b96ad0ca8a5c919ddd8ea3eadcb216bcaa"]},"error":null},{"analyzer":"ai-release-velocity","pillar":"ai_provenance","status":"skipped","tool_version":null,"metrics":{},"findings":[],"evidence":[],"data":{},"error":null},{"analyzer":"ai-stylometry","pillar":"ai_provenance","status":"ok","tool_version":null,"metrics":{"lines_scanned":940900.0,"index":0.097,"count:narrated_steps":79.0,"per_kloc:narrated_steps":0.084,"files:narrated_steps":48.0,"count:placeholder":0.0,"per_kloc:placeholder":0.0,"files:placeholder":0.0,"count:emoji_in_code":0.0,"per_kloc:emoji_in_code":0.0,"files:emoji_in_code":0.0,"count:assistant_voice":6.0,"per_kloc:assistant_voice":0.006,"files:assistant_voice":6.0},"findings":[],"evidence":[{"kind":"stylometry:narrated_steps","description":"step-by-step narration comment: // Finally, given a filename (or an open file or memory block--see header","ref":"Altona2/Altona2/Libs/Util/StbImage.c:173","url":"https://github.com/farbrausch/fr_public/blob/8c8f82c2ae01133370e649bbc05916e7aceecadd/Altona2/Altona2/Libs/Util/StbImage.c#L173","weight":0.0},{"kind":"stylometry:narrated_steps","description":"step-by-step narration comment: // Finally, the image data.","ref":"Altona2/Altona2/Libs/Util/StbImage.c:3552","url":"https://github.com/farbrausch/fr_public/blob/8c8f82c2ae01133370e649bbc05916e7aceecadd/Altona2/Altona2/Libs/Util/StbImage.c#L3552","weight":0.0},{"kind":"stylometry:narrated_steps","description":"step-by-step narration comment: // now we need to indicate how they correspond; we could either","ref":"Altona2/Altona2/Libs/Util/StbVorbis.c:1111","url":"https://github.com/farbrausch/fr_public/blob/8c8f82c2ae01133370e649bbc05916e7aceecadd/Altona2/Altona2/Libs/Util/StbVorbis.c#L1111","weight":0.0},{"kind":"stylometry:narrated_steps","description":"step-by-step narration comment: // now we use symbolic names for these, so that we can","ref":"Altona2/Altona2/Libs/Util/StbVorbis.c:2707","url":"https://github.com/farbrausch/fr_public/blob/8c8f82c2ae01133370e649bbc05916e7aceecadd/Altona2/Altona2/Libs/Util/StbVorbis.c#L2707","weight":0.0},{"kind":"stylometry:narrated_steps","description":"step-by-step narration comment: // now, we can start decoding frames... we'll only FAKE decode them,","ref":"Altona2/Altona2/Libs/Util/StbVorbis.c:4663","url":"https://github.com/farbrausch/fr_public/blob/8c8f82c2ae01133370e649bbc05916e7aceecadd/Altona2/Altona2/Libs/Util/StbVorbis.c#L4663","weight":0.0},{"kind":"stylometry:narrated_steps","description":"step-by-step narration comment: // now we want to lerp between these for the target samples...","ref":"Altona2/Altona2/Libs/Util/StbVorbis.c:4789","url":"https://github.com/farbrausch/fr_public/blob/8c8f82c2ae01133370e649bbc05916e7aceecadd/Altona2/Altona2/Libs/Util/StbVorbis.c#L4789","weight":0.0},{"kind":"stylometry:narrated_steps","description":"step-by-step narration comment: // step 1: we need to bias towards the page start...","ref":"Altona2/Altona2/Libs/Util/StbVorbis.c:4791","url":"https://github.com/farbrausch/fr_public/blob/8c8f82c2ae01133370e649bbc05916e7aceecadd/Altona2/Altona2/Libs/Util/StbVorbis.c#L4791","weight":0.0},{"kind":"stylometry:narrated_steps","description":"step-by-step narration comment: // first, store the current decode position so we can restore it","ref":"Altona2/Altona2/Libs/Util/StbVorbis.c:4867","url":"https://github.com/farbrausch/fr_public/blob/8c8f82c2ae01133370e649bbc05916e7aceecadd/Altona2/Altona2/Libs/Util/StbVorbis.c#L4867","weight":0.0}],"data":{},"error":null},{"analyzer":"sec-secrets","pillar":"security","status":"ok","tool_version":"gitleaks 8.30.1","metrics":{"secrets_current":0.0,"secrets_history":0.0,"secrets_nonprod":0.0,"secrets_low_confidence":1.0},"findings":[{"rule_id":"gitleaks/generic-api-key","severity":"low","message":"Possible generic-api-key secret in the current tree","path":"altona_wz4/altona/main/base/system.hpp","line":756,"fingerprint":"altona_wz4/altona/main/base/system.hpp:generic-api-key:756"}],"evidence":[],"data":{},"error":null},{"analyzer":"sec-sast","pillar":"security","status":"ok","tool_version":"opengrep 1.33.1; rules f1d2b562b414","metrics":{"findings":82.0,"findings_high":0.0,"findings_medium":82.0,"findings_low":0.0,"weighted_findings":20.5,"scanned_lines":974913.0,"parse_errors":68.0},"findings":[{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"Altona2/Altona2/Libs/Util/StbDxt.h","line":152,"fingerprint":"c.lang.security.insecure-use-memset:Altona2/Altona2/Libs/Util/StbDxt.h:152"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"Altona2/Altona2/Libs/Util/StbImage.c","line":1036,"fingerprint":"c.lang.security.insecure-use-memset:Altona2/Altona2/Libs/Util/StbImage.c:1036"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"Altona2/Altona2/Libs/Util/StbImage.c","line":1172,"fingerprint":"c.lang.security.insecure-use-memset:Altona2/Altona2/Libs/Util/StbImage.c:1172"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"Altona2/Altona2/Libs/Util/StbImage.c","line":1996,"fingerprint":"c.lang.security.insecure-use-memset:Altona2/Altona2/Libs/Util/StbImage.c:1996"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"Altona2/Altona2/Libs/Util/StbImage.c","line":1997,"fingerprint":"c.lang.security.insecure-use-memset:Altona2/Altona2/Libs/Util/StbImage.c:1997"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"Altona2/Altona2/Libs/Util/StbImage.c","line":2178,"fingerprint":"c.lang.security.insecure-use-memset:Altona2/Altona2/Libs/Util/StbImage.c:2178"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"Altona2/Altona2/Libs/Util/StbImage.c","line":2193,"fingerprint":"c.lang.security.insecure-use-memset:Altona2/Altona2/Libs/Util/StbImage.c:2193"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"Altona2/Altona2/Libs/Util/StbImage.c","line":2197,"fingerprint":"c.lang.security.insecure-use-memset:Altona2/Altona2/Libs/Util/StbImage.c:2197"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"Altona2/Altona2/Libs/Util/StbImage.c","line":2202,"fingerprint":"c.lang.security.insecure-use-memset:Altona2/Altona2/Libs/Util/StbImage.c:2202"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"Altona2/Altona2/Libs/Util/StbImage.c","line":3836,"fingerprint":"c.lang.security.insecure-use-memset:Altona2/Altona2/Libs/Util/StbImage.c:3836"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"Altona2/Altona2/Libs/Util/StbVorbis.c","line":1009,"fingerprint":"c.lang.security.insecure-use-memset:Altona2/Altona2/Libs/Util/StbVorbis.c:1009"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"Altona2/Altona2/Libs/Util/StbVorbis.c","line":2102,"fingerprint":"c.lang.security.insecure-use-memset:Altona2/Altona2/Libs/Util/StbVorbis.c:2102"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"Altona2/Altona2/Libs/Util/StbVorbis.c","line":3361,"fingerprint":"c.lang.security.insecure-use-memset:Altona2/Altona2/Libs/Util/StbVorbis.c:3361"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"Altona2/Altona2/Libs/Util/StbVorbis.c","line":3369,"fingerprint":"c.lang.security.insecure-use-memset:Altona2/Altona2/Libs/Util/StbVorbis.c:3369"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"Altona2/Altona2/Libs/Util/StbVorbis.c","line":3656,"fingerprint":"c.lang.security.insecure-use-memset:Altona2/Altona2/Libs/Util/StbVorbis.c:3656"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"Altona2/Altona2/Libs/Util/StbVorbis.c","line":3688,"fingerprint":"c.lang.security.insecure-use-memset:Altona2/Altona2/Libs/Util/StbVorbis.c:3688"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"Altona2/Altona2/Libs/Util/StbVorbis.c","line":3966,"fingerprint":"c.lang.security.insecure-use-memset:Altona2/Altona2/Libs/Util/StbVorbis.c:3966"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"Altona2/Altona2/Libs/Util/StbVorbis.c","line":4159,"fingerprint":"c.lang.security.insecure-use-memset:Altona2/Altona2/Libs/Util/StbVorbis.c:4159"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"Altona2/Altona2/Libs/Util/StbVorbis.c","line":5087,"fingerprint":"c.lang.security.insecure-use-memset:Altona2/Altona2/Libs/Util/StbVorbis.c:5087"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"Altona2/Altona2/Libs/Util/StbVorbis.c","line":5115,"fingerprint":"c.lang.security.insecure-use-memset:Altona2/Altona2/Libs/Util/StbVorbis.c:5115"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"Altona2/Altona2/Libs/Util/StbVorbis.c","line":5156,"fingerprint":"c.lang.security.insecure-use-memset:Altona2/Altona2/Libs/Util/StbVorbis.c:5156"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"Altona2/Altona2/Libs/Util/StbVorbis.c","line":5363,"fingerprint":"c.lang.security.insecure-use-memset:Altona2/Altona2/Libs/Util/StbVorbis.c:5363"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"RG2/Viewer/math3d_2.h","line":185,"fingerprint":"c.lang.security.insecure-use-memset:RG2/Viewer/math3d_2.h:185"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"RG2/math3d_2.h","line":276,"fingerprint":"c.lang.security.insecure-use-memset:RG2/math3d_2.h:276"},{"rule_id":"opengrep/c.lang.security.insecure-use-string-copy-fn","severity":"medium","message":"Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker [confidence low]","path":"RG2/pool.h","line":58,"fingerprint":"c.lang.security.insecure-use-string-copy-fn:RG2/pool.h:58"},{"rule_id":"opengrep/c.lang.security.insecure-use-string-copy-fn","severity":"medium","message":"Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker [confidence low]","path":"RG2/pool.h","line":141,"fingerprint":"c.lang.security.insecure-use-string-copy-fn:RG2/pool.h:141"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"altona_wz4/altona/main/ogg/stb_vorbis.h","line":1022,"fingerprint":"c.lang.security.insecure-use-memset:altona_wz4/altona/main/ogg/stb_vorbis.h:1022"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"altona_wz4/altona/main/ogg/stb_vorbis.h","line":2111,"fingerprint":"c.lang.security.insecure-use-memset:altona_wz4/altona/main/ogg/stb_vorbis.h:2111"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"altona_wz4/altona/main/ogg/stb_vorbis.h","line":3373,"fingerprint":"c.lang.security.insecure-use-memset:altona_wz4/altona/main/ogg/stb_vorbis.h:3373"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"altona_wz4/altona/main/ogg/stb_vorbis.h","line":3381,"fingerprint":"c.lang.security.insecure-use-memset:altona_wz4/altona/main/ogg/stb_vorbis.h:3381"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"altona_wz4/altona/main/ogg/stb_vorbis.h","line":3668,"fingerprint":"c.lang.security.insecure-use-memset:altona_wz4/altona/main/ogg/stb_vorbis.h:3668"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"altona_wz4/altona/main/ogg/stb_vorbis.h","line":3700,"fingerprint":"c.lang.security.insecure-use-memset:altona_wz4/altona/main/ogg/stb_vorbis.h:3700"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"altona_wz4/altona/main/ogg/stb_vorbis.h","line":3978,"fingerprint":"c.lang.security.insecure-use-memset:altona_wz4/altona/main/ogg/stb_vorbis.h:3978"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"altona_wz4/altona/main/ogg/stb_vorbis.h","line":4171,"fingerprint":"c.lang.security.insecure-use-memset:altona_wz4/altona/main/ogg/stb_vorbis.h:4171"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"altona_wz4/altona/main/ogg/stb_vorbis.h","line":5097,"fingerprint":"c.lang.security.insecure-use-memset:altona_wz4/altona/main/ogg/stb_vorbis.h:5097"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"altona_wz4/altona/main/ogg/stb_vorbis.h","line":5126,"fingerprint":"c.lang.security.insecure-use-memset:altona_wz4/altona/main/ogg/stb_vorbis.h:5126"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"altona_wz4/altona/main/ogg/stb_vorbis.h","line":5167,"fingerprint":"c.lang.security.insecure-use-memset:altona_wz4/altona/main/ogg/stb_vorbis.h:5167"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"altona_wz4/altona/main/ogg/stb_vorbis.h","line":5374,"fingerprint":"c.lang.security.insecure-use-memset:altona_wz4/altona/main/ogg/stb_vorbis.h:5374"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"altona_wz4/altona/main/util/stb_image.c","line":991,"fingerprint":"c.lang.security.insecure-use-memset:altona_wz4/altona/main/util/stb_image.c:991"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"altona_wz4/altona/main/util/stb_image.c","line":1118,"fingerprint":"c.lang.security.insecure-use-memset:altona_wz4/altona/main/util/stb_image.c:1118"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"altona_wz4/altona/main/util/stb_image.c","line":1970,"fingerprint":"c.lang.security.insecure-use-memset:altona_wz4/altona/main/util/stb_image.c:1970"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"altona_wz4/altona/main/util/stb_image.c","line":1971,"fingerprint":"c.lang.security.insecure-use-memset:altona_wz4/altona/main/util/stb_image.c:1971"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"altona_wz4/altona/main/util/stb_image.c","line":2154,"fingerprint":"c.lang.security.insecure-use-memset:altona_wz4/altona/main/util/stb_image.c:2154"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"altona_wz4/altona/main/util/stb_image.c","line":2169,"fingerprint":"c.lang.security.insecure-use-memset:altona_wz4/altona/main/util/stb_image.c:2169"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"altona_wz4/altona/main/util/stb_image.c","line":2173,"fingerprint":"c.lang.security.insecure-use-memset:altona_wz4/altona/main/util/stb_image.c:2173"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"altona_wz4/altona/main/util/stb_image.c","line":2178,"fingerprint":"c.lang.security.insecure-use-memset:altona_wz4/altona/main/util/stb_image.c:2178"},{"rule_id":"opengrep/c.lang.security.insecure-use-string-copy-fn","severity":"medium","message":"Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker [confidence low]","path":"v2/standalone/multibutton.h","line":80,"fingerprint":"c.lang.security.insecure-use-string-copy-fn:v2/standalone/multibutton.h:80"},{"rule_id":"opengrep/c.lang.security.insecure-use-string-copy-fn","severity":"medium","message":"Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker [confidence low]","path":"v2/standalone/multibutton.h","line":84,"fingerprint":"c.lang.security.insecure-use-string-copy-fn:v2/standalone/multibutton.h:84"},{"rule_id":"opengrep/c.lang.security.insecure-use-string-copy-fn","severity":"medium","message":"Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker [confidence low]","path":"v2/standalone/wtlblaview.h","line":246,"fingerprint":"c.lang.security.insecure-use-string-copy-fn:v2/standalone/wtlblaview.h:246"},{"rule_id":"opengrep/c.lang.security.insecure-use-string-copy-fn","severity":"medium","message":"Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker [confidence low]","path":"v2/standalone/wtlblaview.h","line":1060,"fingerprint":"c.lang.security.insecure-use-string-copy-fn:v2/standalone/wtlblaview.h:1060"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"v2/vsti/MachineInterfaceTL.h","line":688,"fingerprint":"c.lang.security.insecure-use-memset:v2/vsti/MachineInterfaceTL.h:688"},{"rule_id":"opengrep/c.lang.security.insecure-use-string-copy-fn","severity":"medium","message":"Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker [confidence low]","path":"v2/vsti/multibutton.h","line":80,"fingerprint":"c.lang.security.insecure-use-string-copy-fn:v2/vsti/multibutton.h:80"},{"rule_id":"opengrep/c.lang.security.insecure-use-string-copy-fn","severity":"medium","message":"Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker [confidence low]","path":"v2/vsti/multibutton.h","line":84,"fingerprint":"c.lang.security.insecure-use-string-copy-fn:v2/vsti/multibutton.h:84"},{"rule_id":"opengrep/c.lang.security.insecure-use-string-copy-fn","severity":"medium","message":"Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker [confidence low]","path":"v2/vsti/v2appearance.h","line":750,"fingerprint":"c.lang.security.insecure-use-string-copy-fn:v2/vsti/v2appearance.h:750"},{"rule_id":"opengrep/c.lang.security.insecure-use-string-copy-fn","severity":"medium","message":"Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker [confidence low]","path":"v2/vsti/v2buzz.h","line":668,"fingerprint":"c.lang.security.insecure-use-string-copy-fn:v2/vsti/v2buzz.h:668"},{"rule_id":"opengrep/c.lang.security.insecure-use-string-copy-fn","severity":"medium","message":"Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker [confidence low]","path":"v2/vsti/v2buzz.h","line":672,"fingerprint":"c.lang.security.insecure-use-string-copy-fn:v2/vsti/v2buzz.h:672"},{"rule_id":"opengrep/c.lang.security.insecure-use-string-copy-fn","severity":"medium","message":"Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker [confidence low]","path":"v2/vsti/v2buzz.h","line":688,"fingerprint":"c.lang.security.insecure-use-string-copy-fn:v2/vsti/v2buzz.h:688"},{"rule_id":"opengrep/c.lang.security.insecure-use-string-copy-fn","severity":"medium","message":"Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker [confidence low]","path":"v2/vsti/v2buzz.h","line":699,"fingerprint":"c.lang.security.insecure-use-string-copy-fn:v2/vsti/v2buzz.h:699"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"v2/vsti/v2buzz.h","line":722,"fingerprint":"c.lang.security.insecure-use-memset:v2/vsti/v2buzz.h:722"},{"rule_id":"opengrep/c.lang.security.insecure-use-string-copy-fn","severity":"medium","message":"Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker [confidence low]","path":"v2/vsti/v2buzz.h","line":922,"fingerprint":"c.lang.security.insecure-use-string-copy-fn:v2/vsti/v2buzz.h:922"},{"rule_id":"opengrep/c.lang.security.insecure-use-strcat-fn","severity":"medium","message":"Finding triggers whenever there is a strcat or strncat used. This is an issue because strcat or strncat can lead to buffer overflow vulns. Fix this by using strcat_s instead. [confidence low]","path":"v2/vsti/v2buzz.h","line":924,"fingerprint":"c.lang.security.insecure-use-strcat-fn:v2/vsti/v2buzz.h:924"},{"rule_id":"opengrep/c.lang.security.insecure-use-strcat-fn","severity":"medium","message":"Finding triggers whenever there is a strcat or strncat used. This is an issue because strcat or strncat can lead to buffer overflow vulns. Fix this by using strcat_s instead. [confidence low]","path":"v2/vsti/v2buzz.h","line":926,"fingerprint":"c.lang.security.insecure-use-strcat-fn:v2/vsti/v2buzz.h:926"},{"rule_id":"opengrep/c.lang.security.insecure-use-string-copy-fn","severity":"medium","message":"Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker [confidence low]","path":"v2/vsti/v2view.h","line":4203,"fingerprint":"c.lang.security.insecure-use-string-copy-fn:v2/vsti/v2view.h:4203"},{"rule_id":"opengrep/c.lang.security.insecure-use-string-copy-fn","severity":"medium","message":"Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker [confidence low]","path":"v2/vsti/v2view.h","line":4204,"fingerprint":"c.lang.security.insecure-use-string-copy-fn:v2/vsti/v2view.h:4204"},{"rule_id":"opengrep/c.lang.security.insecure-use-string-copy-fn","severity":"medium","message":"Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker [confidence low]","path":"v2/vsti/v2view.h","line":4205,"fingerprint":"c.lang.security.insecure-use-string-copy-fn:v2/vsti/v2view.h:4205"},{"rule_id":"opengrep/c.lang.security.insecure-use-string-copy-fn","severity":"medium","message":"Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker [confidence low]","path":"v2/vsti/v2view.h","line":4206,"fingerprint":"c.lang.security.insecure-use-string-copy-fn:v2/vsti/v2view.h:4206"},{"rule_id":"opengrep/c.lang.security.insecure-use-string-copy-fn","severity":"medium","message":"Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker [confidence low]","path":"v2/vsti/wtlblaview.h","line":261,"fingerprint":"c.lang.security.insecure-use-string-copy-fn:v2/vsti/wtlblaview.h:261"},{"rule_id":"opengrep/c.lang.security.insecure-use-string-copy-fn","severity":"medium","message":"Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker [confidence low]","path":"v2/vsti/wtlblaview.h","line":1214,"fingerprint":"c.lang.security.insecure-use-string-copy-fn:v2/vsti/wtlblaview.h:1214"},{"rule_id":"opengrep/c.lang.security.insecure-use-string-copy-fn","severity":"medium","message":"Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker [confidence low]","path":"v2/vsti/wtlblaview.h","line":1326,"fingerprint":"c.lang.security.insecure-use-string-copy-fn:v2/vsti/wtlblaview.h:1326"},{"rule_id":"opengrep/c.lang.security.insecure-use-string-copy-fn","severity":"medium","message":"Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker [confidence low]","path":"v2/vsti/wtlblaview.h","line":1327,"fingerprint":"c.lang.security.insecure-use-string-copy-fn:v2/vsti/wtlblaview.h:1327"},{"rule_id":"opengrep/c.lang.security.insecure-use-string-copy-fn","severity":"medium","message":"Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker [confidence low]","path":"v2/vsti/wtlblaview.h","line":1328,"fingerprint":"c.lang.security.insecure-use-string-copy-fn:v2/vsti/wtlblaview.h:1328"},{"rule_id":"opengrep/c.lang.security.insecure-use-string-copy-fn","severity":"medium","message":"Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker [confidence low]","path":"v2/vsti/wtlblaview.h","line":1329,"fingerprint":"c.lang.security.insecure-use-string-copy-fn:v2/vsti/wtlblaview.h:1329"},{"rule_id":"opengrep/c.lang.security.insecure-use-string-copy-fn","severity":"medium","message":"Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker [confidence low]","path":"v2/vsti/wtlblaview.h","line":1381,"fingerprint":"c.lang.security.insecure-use-string-copy-fn:v2/vsti/wtlblaview.h:1381"},{"rule_id":"opengrep/c.lang.security.insecure-use-strcat-fn","severity":"medium","message":"Finding triggers whenever there is a strcat or strncat used. This is an issue because strcat or strncat can lead to buffer overflow vulns. Fix this by using strcat_s instead. [confidence low]","path":"v2/vsti/wtlblaview.h","line":1382,"fingerprint":"c.lang.security.insecure-use-strcat-fn:v2/vsti/wtlblaview.h:1382"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"werkkzeug3/w3texlib/stb_image.c","line":941,"fingerprint":"c.lang.security.insecure-use-memset:werkkzeug3/w3texlib/stb_image.c:941"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"werkkzeug3/w3texlib/stb_image.c","line":1068,"fingerprint":"c.lang.security.insecure-use-memset:werkkzeug3/w3texlib/stb_image.c:1068"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"werkkzeug3/w3texlib/stb_image.c","line":1920,"fingerprint":"c.lang.security.insecure-use-memset:werkkzeug3/w3texlib/stb_image.c:1920"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"werkkzeug3/w3texlib/stb_image.c","line":1921,"fingerprint":"c.lang.security.insecure-use-memset:werkkzeug3/w3texlib/stb_image.c:1921"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"werkkzeug3/w3texlib/stb_image.c","line":2102,"fingerprint":"c.lang.security.insecure-use-memset:werkkzeug3/w3texlib/stb_image.c:2102"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"werkkzeug3/w3texlib/stb_image.c","line":2117,"fingerprint":"c.lang.security.insecure-use-memset:werkkzeug3/w3texlib/stb_image.c:2117"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"werkkzeug3/w3texlib/stb_image.c","line":2121,"fingerprint":"c.lang.security.insecure-use-memset:werkkzeug3/w3texlib/stb_image.c:2121"},{"rule_id":"opengrep/c.lang.security.insecure-use-memset","severity":"medium","message":"When handling sensitive information in a buffer, it's important to ensure  that the data is securely erased before the buffer is deleted or reused.  While `memset()` is commonly used for this purpose, it can leave sensitive  information behind due to compiler optimizations or other factors.  To avoi [confidence low]","path":"werkkzeug3/w3texlib/stb_image.c","line":2126,"fingerprint":"c.lang.security.insecure-use-memset:werkkzeug3/w3texlib/stb_image.c:2126"}],"evidence":[],"data":{"rulesets":["c"]},"error":null},{"analyzer":"sec-deps","pillar":"security","status":"skipped","tool_version":null,"metrics":{},"findings":[],"evidence":[],"data":{},"error":null},{"analyzer":"sec-actions","pillar":"security","status":"skipped","tool_version":null,"metrics":{},"findings":[],"evidence":[],"data":{},"error":null},{"analyzer":"sec-posture","pillar":"security","status":"ok","tool_version":null,"metrics":{"check:security_policy":0.0,"check:dependency_updates":0.0,"check:signed_commits":0.0,"check:lockfiles":1.0,"signed_commit_share":0.0,"unpinned_manifests":0.0},"findings":[],"evidence":[],"data":{},"error":null},{"analyzer":"sec-distribution","pillar":"security","status":"ok","tool_version":null,"metrics":{"signals":0.0,"binary_assets":0.0,"suspicious":0.0},"findings":[],"evidence":[],"data":{"signals":[],"suspicious":false,"unusual_traction":false,"metadata":true},"error":null},{"analyzer":"qual-complexity","pillar":"quality","status":"ok","tool_version":"lizard 1.25.1","metrics":{"functions":34019.0,"function_nloc":573503.0,"mean_ccn":3.89,"p90_ccn":8.0,"complex_functions":1446.0,"long_functions":771.0,"many_param_functions":349.0,"risky_nloc_share":0.3356},"findings":[],"evidence":[{"kind":"complex-function","description":"glewContextInit in Altona2/Altona2/Libs/Base/GraphicsGlew.cpp: complexity 869, 651 lines","ref":"Altona2/Altona2/Libs/Base/GraphicsGlew.cpp","url":"https://github.com/farbrausch/fr_public/blob/8c8f82c2ae01133370e649bbc05916e7aceecadd/Altona2/Altona2/Libs/Base/GraphicsGlew.cpp#L8102","weight":1.0},{"kind":"complex-function","description":"glewIsSupported in Altona2/Altona2/Libs/Base/GraphicsGlew.cpp: complexity 867, 2186 lines","ref":"Altona2/Altona2/Libs/Base/GraphicsGlew.cpp","url":"https://github.com/farbrausch/fr_public/blob/8c8f82c2ae01133370e649bbc05916e7aceecadd/Altona2/Altona2/Libs/Base/GraphicsGlew.cpp#L11641","weight":1.0},{"kind":"complex-function","description":"_glewInit_GL_EXT_direct_state_access in Altona2/Altona2/Libs/Base/GraphicsGlew.cpp: complexity 214, 218 lines","ref":"Altona2/Altona2/Libs/Base/GraphicsGlew.cpp","url":"https://github.com/farbrausch/fr_public/blob/8c8f82c2ae01133370e649bbc05916e7aceecadd/Altona2/Altona2/Libs/Base/GraphicsGlew.cpp#L5351","weight":1.0},{"kind":"complex-function","description":"Altona2::sScanner::Scan in Altona2/Altona2/Libs/Util/Scanner.cpp: complexity 186, 456 lines","ref":"Altona2/Altona2/Libs/Util/Scanner.cpp","url":"https://github.com/farbrausch/fr_public/blob/8c8f82c2ae01133370e649bbc05916e7aceecadd/Altona2/Altona2/Libs/Util/Scanner.cpp#L301","weight":1.0},{"kind":"complex-function","description":"sScanner::Scan in altona_wz4/altona/main/util/scanner.cpp: complexity 168, 408 lines","ref":"altona_wz4/altona/main/util/scanner.cpp","url":"https://github.com/farbrausch/fr_public/blob/8c8f82c2ae01133370e649bbc05916e7aceecadd/altona_wz4/altona/main/util/scanner.cpp#L430","weight":1.0},{"kind":"complex-function","description":"WinView::OnCommand in werkkzeug3/winview.cpp: complexity 147, 436 lines","ref":"werkkzeug3/winview.cpp","url":"https://github.com/farbrausch/fr_public/blob/8c8f82c2ae01133370e649bbc05916e7aceecadd/werkkzeug3/winview.cpp#L1379","weight":1.0},{"kind":"complex-function","description":"start_decoder in Altona2/Altona2/Libs/Util/StbVorbis.c: complexity 146, 419 lines","ref":"Altona2/Altona2/Libs/Util/StbVorbis.c","url":"https://github.com/farbrausch/fr_public/blob/8c8f82c2ae01133370e649bbc05916e7aceecadd/Altona2/Altona2/Libs/Util/StbVorbis.c#L3577","weight":1.0},{"kind":"complex-function","description":"start_decoder in altona_wz4/altona/main/ogg/stb_vorbis.h: complexity 146, 419 lines","ref":"altona_wz4/altona/main/ogg/stb_vorbis.h","url":"https://github.com/farbrausch/fr_public/blob/8c8f82c2ae01133370e649bbc05916e7aceecadd/altona_wz4/altona/main/ogg/stb_vorbis.h#L3589","weight":1.0},{"kind":"complex-function","description":"MsgProc in altona_wz4/altona/main/base/system_win.cpp: complexity 143, 398 lines","ref":"altona_wz4/altona/main/base/system_win.cpp","url":"https://github.com/farbrausch/fr_public/blob/8c8f82c2ae01133370e649bbc05916e7aceecadd/altona_wz4/altona/main/base/system_win.cpp#L1857","weight":1.0},{"kind":"complex-function","description":"wglewContextInit in Altona2/Altona2/Libs/Base/GraphicsGlew.cpp: complexity 141, 95 lines","ref":"Altona2/Altona2/Libs/Base/GraphicsGlew.cpp","url":"https://github.com/farbrausch/fr_public/blob/8c8f82c2ae01133370e649bbc05916e7aceecadd/Altona2/Altona2/Libs/Base/GraphicsGlew.cpp#L10368","weight":1.0}],"data":{},"error":null},{"analyzer":"qual-duplication","pillar":"quality","status":"ok","tool_version":"repotrust-dup-w6","metrics":{"compared_lines":658039.0,"duplicated_lines":340079.0,"duplicated_share":0.5168,"files":1503.0},"findings":[],"evidence":[{"kind":"duplicate-code","description":"6+ duplicated lines: Altona2/Altona2/Examples/base/Audio/main.cpp:1 and Altona2/Altona2/Examples/base/Audio/main.hpp:1","ref":"Altona2/Altona2/Examples/base/Audio/main.cpp","url":"https://github.com/farbrausch/fr_public/blob/8c8f82c2ae01133370e649bbc05916e7aceecadd/Altona2/Altona2/Examples/base/Audio/main.cpp#L1","weight":0.3},{"kind":"duplicate-code","description":"6+ duplicated lines: Altona2/Altona2/Examples/base/Audio/main.cpp:3 and Altona2/Altona2/Examples/base/cpp11/main.cpp:3","ref":"Altona2/Altona2/Examples/base/Audio/main.cpp","url":"https://github.com/farbrausch/fr_public/blob/8c8f82c2ae01133370e649bbc05916e7aceecadd/Altona2/Altona2/Examples/base/Audio/main.cpp#L3","weight":0.3},{"kind":"duplicate-code","description":"6+ duplicated lines: Altona2/Altona2/Examples/base/Audio/main.cpp:14 and Altona2/Altona2/Examples/graphics/DynamicTextureMap/main.cpp:14","ref":"Altona2/Altona2/Examples/base/Audio/main.cpp","url":"https://github.com/farbrausch/fr_public/blob/8c8f82c2ae01133370e649bbc05916e7aceecadd/Altona2/Altona2/Examples/base/Audio/main.cpp#L14","weight":0.3},{"kind":"duplicate-code","description":"6+ duplicated lines: Altona2/Altona2/Examples/base/Audio/main.cpp:26 and Altona2/Altona2/Examples/graphics_dx11/ComputeMesh/Main.cpp:24","ref":"Altona2/Altona2/Examples/base/Audio/main.cpp","url":"https://github.com/farbrausch/fr_public/blob/8c8f82c2ae01133370e649bbc05916e7aceecadd/Altona2/Altona2/Examples/base/Audio/main.cpp#L26","weight":0.3},{"kind":"duplicate-code","description":"6+ duplicated lines: Altona2/Altona2/Examples/base/Audio/main.cpp:33 and Altona2/Altona2/Examples/graphics/DynamicVertexMap/main.cpp:37","ref":"Altona2/Altona2/Examples/base/Audio/main.cpp","url":"https://github.com/farbrausch/fr_public/blob/8c8f82c2ae01133370e649bbc05916e7aceecadd/Altona2/Altona2/Examples/base/Audio/main.cpp#L33","weight":0.3},{"kind":"duplicate-code","description":"6+ duplicated lines: Altona2/Altona2/Examples/base/Audio/main.cpp:36 and Altona2/Altona2/Examples/graphics/DynamicVertexArray/main.cpp:43","ref":"Altona2/Altona2/Examples/base/Audio/main.cpp","url":"https://github.com/farbrausch/fr_public/blob/8c8f82c2ae01133370e649bbc05916e7aceecadd/Altona2/Altona2/Examples/base/Audio/main.cpp#L36","weight":0.3},{"kind":"duplicate-code","description":"6+ duplicated lines: Altona2/Altona2/Examples/base/Audio/main.cpp:95 and Altona2/Altona2/Examples/emptyprojects/gui3d/main.hpp:14","ref":"Altona2/Altona2/Examples/base/Audio/main.cpp","url":"https://github.com/farbrausch/fr_public/blob/8c8f82c2ae01133370e649bbc05916e7aceecadd/Altona2/Altona2/Examples/base/Audio/main.cpp#L95","weight":0.3},{"kind":"duplicate-code","description":"6+ duplicated lines: Altona2/Altona2/Examples/base/Audio/main.hpp:3 and Altona2/Altona2/Examples/graphics/DynamicTextureMap/main.hpp:3","ref":"Altona2/Altona2/Examples/base/Audio/main.hpp","url":"https://github.com/farbrausch/fr_public/blob/8c8f82c2ae01133370e649bbc05916e7aceecadd/Altona2/Altona2/Examples/base/Audio/main.hpp#L3","weight":0.3},{"kind":"duplicate-code","description":"6+ duplicated lines: Altona2/Altona2/Examples/base/Volumes/Main.cpp:3 and Altona2/Altona2/Examples/base/helloworld/main.cpp:3","ref":"Altona2/Altona2/Examples/base/Volumes/Main.cpp","url":"https://github.com/farbrausch/fr_public/blob/8c8f82c2ae01133370e649bbc05916e7aceecadd/Altona2/Altona2/Examples/base/Volumes/Main.cpp#L3","weight":0.3},{"kind":"duplicate-code","description":"6+ duplicated lines: Altona2/Altona2/Examples/emptyprojects/gui3d/doc.cpp:7 and Altona2/Altona2/Tools/Asc/Doc.cpp:14","ref":"Altona2/Altona2/Examples/emptyprojects/gui3d/doc.cpp","url":"https://github.com/farbrausch/fr_public/blob/8c8f82c2ae01133370e649bbc05916e7aceecadd/Altona2/Altona2/Examples/emptyprojects/gui3d/doc.cpp#L7","weight":0.3}],"data":{},"error":null},{"analyzer":"qual-lint","pillar":"quality","status":"ok","tool_version":"opengrep 1.33.1; rules f1d2b562b414","metrics":{"findings":2.0,"weighted_findings":2.0,"scanned_lines":974913.0,"category:correctness":2.0},"findings":[{"rule_id":"opengrep/c.lang.correctness.incorrect-use-ato-fn","severity":"medium","message":"Avoid the 'ato*()' family of functions. Their use can lead to undefined behavior, integer overflows, and lack of appropriate error handling. Instead prefer the 'strtol*()' family of functions.","path":"RG2/VideoDlg.h","line":56,"fingerprint":"c.lang.correctness.incorrect-use-ato-fn:RG2/VideoDlg.h:56"},{"rule_id":"opengrep/c.lang.correctness.incorrect-use-ato-fn","severity":"medium","message":"Avoid the 'ato*()' family of functions. Their use can lead to undefined behavior, integer overflows, and lack of appropriate error handling. Instead prefer the 'strtol*()' family of functions.","path":"RG2/VideoDlg.h","line":58,"fingerprint":"c.lang.correctness.incorrect-use-ato-fn:RG2/VideoDlg.h:58"}],"evidence":[],"data":{},"error":null},{"analyzer":"qual-testing","pillar":"quality","status":"ok","tool_version":null,"metrics":{"check:has_tests":0.0,"check:test_ratio":0.0,"check:ci_present":0.0,"check:ci_runs_tests":0.0,"check:ci_runs_lint":0.0,"check:tests_cochange":0.0,"test_lines":0.0,"source_lines":974913.0,"test_ratio":0.0,"ci_files":0.0,"cochange_share":0.0,"cochange_commits":219.0},"findings":[],"evidence":[],"data":{"test_commands":[],"lint_commands":[]},"error":null},{"analyzer":"qual-docs","pillar":"quality","status":"ok","tool_version":null,"metrics":{"check:readme":1.0,"check:license":0.0,"check:contributing":0.0,"check:changelog":0.0,"readme_lines":93.0},"findings":[],"evidence":[{"kind":"docs","description":"README.md","ref":"README.md","url":null,"weight":0.0}],"data":{},"error":null},{"analyzer":"qual-type-safety","pillar":"quality","status":"skipped","tool_version":null,"metrics":{},"findings":[],"evidence":[],"data":{},"error":null}],"flags":[]}