Mend.io may modify this page retroactively from time to time.
Version 26.10.2 (16-November-2026)
New Features and Updates
-
Introduced a new guided onboarding wizard that enables users to easily activate SAST scanning for their repositories directly from the Mend Platform. This streamlined flow enables quick repository selection and pilot scan execution without manual configuration, providing immediate visibility into scan results and security findings. Additionally, users can now delegate the onboarding process to colleagues via email invitations, facilitating team-wide adoption.
-
Enhanced the Global Scan Configuration by implementing language filtering based on engine generation. This update ensures that only languages supported by the current engine generation are displayed, streamlining the configuration process and improving selection accuracy for scan setups.
Resolved Issues
-
Fixed an issue where it failed to detect vulnerabilities in Express route handlers wrapped in `asyncHandler` or similar wrapper functions. The JavaScript engine now correctly identifies these wrapped functions as entry points, ensuring comprehensive analysis and reporting of security findings, such as SSRF (CWE-918) and Log Forging (CWE-117), within these handlers.
-
Enhanced the JavaScript Gen 2 engine to improve detection of DOM XSS vulnerabilities. The analysis now identifies tainted data in additional jQuery AJAX callback shapes.
-
Improved the accuracy of the Swift Gen 2 engine by reducing false positives for CWE-117 (Log Injection) and CWE-295 (Insecure TLS Configuration). Swift `print` and `debugPrint` findings are now categorized as low-probability, hiding them by default to focus on persistent logging sinks. Additionally, the engine now correctly recognizes certificate and public-key pinning in `URLSession` challenge handlers, preventing incorrect reports of insecure configurations when proper validation is present.
Version 26.10.1 (02-November-2026)
New Features and Updates
-
(Open Beta) Introducing Mend Intelligent Agent, an AI-powered assistant embedded within the Mend Platform. Users can now interact using natural language to explore platform capabilities, receive guidance to relevant views, and obtain executive-level risk summaries. This feature provides a centralized organizational perspective, enabling security teams to identify and prioritize critical findings across all applications and projects efficiently. Mend Assist streamlines security oversight by delivering instant, actionable insights and automated navigation, all within the existing platform workflow.
-
The feature is enabled by default for organizations with signed AI consent via an addendum in your Mend.io contract. For organizations without consent, the feature remains disabled. Please contact your Customer Success Manager for more details.
-
-
Introduced granular control for low-probability scan categories within the Scan Profile. Users can now selectively include or exclude specific categories, such as File Read or Database Read, to refine detection and reduce noise. This update replaces the previous binary toggle with a configurable selection tree, allowing for self-service tuning tailored to specific codebase requirements. Changes are applied to the next scan and include a count indicator for selected categories.
-
Added support for custom Node.js routing frameworks where entry points are defined in `routes.json` files. This update enables the engine to parse these manifests and correctly identify handler functions as entry points for taint analysis, ensuring comprehensive vulnerability detection for non-standard routing configurations.
Resolved Issues
-
Fixed an issue in the CLI where Go scans experienced significant performance degradation and timeouts when analyzing generated protobuf (.pb.go) files. The analysis process is now optimized, resulting in substantially faster scan completion times for projects containing these files.
-
Fixed an issue where some Swagger YAML entry points were not correctly detected during scans. The engine now correctly parses Swagger YAML files to identify all API endpoints, ensuring comprehensive vulnerability coverage and accurate reporting for applications using Swagger-generated code.
-
Fixed an issue where Code report downloads failed in Chromium-based browsers, such as Chrome and Edge, when the organization name contained a comma.
Version 26.9.3 (19-October-2026)
New Features and Updates
-
Introducing the Gen 2 detection engine for Swift and PHP, with improved CWE and framework coverage for accurate, scalable scans.
-
The Gen 2 engine is the default for new organizations.
-
-
Project Risk Factors is now available in all environments. It helps you decide which security issues to fix first by showing which of your applications and projects handle sensitive or critical functionality.
You can see a project's risk factors in a new column in the Applications and Projects lists, where you can filter by group or by individual risk factor. They also appear in a widget on the project summary page. To see why a project was classified a certain way, open the evidence page, which lists the code signals behind each classification, grouped by risk factor and file.
Classification runs automatically on your existing scans once an organization administrator enables AI-based project risk factors in organization administration. The setting requires AI consent and is off by default. When it's on, snippets of your source code and project details are shared with Mend's AI model to produce the classifications.
Resolved Issues
-
Fixed an issue where `HttpServletResponse` and `ServletResponse` parameters were incorrectly treated as taint sources in Java, leading to false-positive Cross-Site Scripting (XSS) findings. The analysis engine now correctly identifies that these objects are container-managed and do not inherently contain attacker-controlled data upon entry.
-
Fixed an issue where false-positive findings were reported for JavaScript and TypeScript applications. The engine incorrectly flagged Server-Side Request Forgery (SSRF) on relative in-app paths using React Router's navigate function and NoSQL Injection on Sequelize models even when configured with a PostgreSQL dialect. These detection gaps have been resolved to improve scan accuracy.
-
Fixed an issue where some Swagger YAML entry points were not correctly detected during scans, ensuring more comprehensive coverage and accurate vulnerability reporting for API definitions.
Version 26.9.2 (05-October-2026)
New Features and Updates
-
Mend SAST now supports additional configuration files, such as YAML and JSON, to improve entry point detection. The engine automatically identifies API endpoints and maps them to their corresponding implementation classes. This enhancement ensures comprehensive security coverage for contract-first applications by automatically marking all generated entry point parameters as tainted, eliminating the need for manual configuration of custom frameworks.
-
Improved the accuracy of the Python engine across the following CWEs:
-
CWE-022 Path Traversal
-
CWE-078 OS Command Injection
-
CWE-079 XSS
-
CWE-089 SQL Injection
-
CWE-094 Code Injection
-
CWE-209 Error Message Info Exposure
-
CWE-295 Improper Cert Validation
-
CWE-532 Sensitive Info in Log
-
CWE-601 Open Redirect
-
CWE-918 SSRF
-
CWE-943 NoSQL Injection
-
Resolved Issues
-
Fixed an issue where the entry resolver failed when scanning certain AWS Lambda handler files in TypeScript.
Version 26.9.1 (28-September-2026)
New Features and Updates
-
The Mend CLI SAST scan (mend code) now supports a --print-to-console flag that prints the CLI logs directly to the console (stdout) as the scan runs, in addition to writing them to the log file.
-
Improved the AI-generated remediation suggestions for CWE-117 (Log Forging) in Python code. The remediation now correctly neutralizes carriage return (CR) and line feed (LF) characters instead of applying HTML escaping. Additionally, the suggestion ensures all client-controlled values within the log statement are sanitized, providing a more comprehensive and effective fix for log forging vulnerabilities.
-
Default exclusions in
mend codeCLI scans now ignore/_MACOSX/..*metadata files across all SAST scan engines. This update prevents macOS-specific system files from interfering with the TreeSitter parser during scans on Windows environments, ensuring more stable and accurate analysis. These exclusions are applied automatically via centralized settings, even when default exclusions are otherwise disabled.
Resolved Issues
-
Fixed an issue where Mend CLI SAST scans failed to return exit code 9 and did not break the pipeline, even when workflow violations were detected and the "Fail Pipeline on Violation" setting was enabled. The CLI now correctly enforces workflow policies by returning the appropriate exit code to ensure pipeline failures occur as expected when security violations are identified.
-
Fixed an issue in the Mend CLI where users with non-English characters in their profile names were denied access due to incorrect JWT decoding. The authentication process now correctly handles special characters to ensure seamless access for all users.
Version 26.8.2 (07-September-2026)
New Features and Updates
-
Improved detection accuracy of JavaScript /TypeScript analysis engine across 11 CWEs. Key refinements include tuning detection for React controlled components to prevent false positives where query parameters flowing into escaped JSX attributes were incorrectly flagged as DOM-based XSS. In detail, the following CWEs were updated:
-
-
CWE-22 — Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal')
-
CWE-78 — Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection')
-
CWE-79 — Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
-
CWE-89 — Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection')
-
CWE-90 — Improper Neutralization of Special Elements used in an LDAP Query ('LDAP Injection')
-
CWE-94 — Improper Control of Generation of Code ('Code Injection')
-
CWE-117 — Improper Output Neutralization for Logs
-
CWE-295 — Improper Certificate Validation
-
CWE-601 — URL Redirection to Untrusted Site ('Open Redirect')
-
CWE-918 — Server-Side Request Forgery (SSRF)
-
CWE-943 — Improper Neutralization of Special Elements in Data Query Logic (NoSQL / query-language injection)
-
Resolved Issues
-
Fixed an issue where false-positive XSS and SQL injection findings were reported in ColdFusion projects. Mend SAST now accurately handles local variables assigned to hardcoded integer literals and correctly identifies parameterized queries using `<cfqueryparam>` or numeric validation guards. Additionally, scan performance and reliability were significantly improved.
-
Fixed an issue that caused the IDE plugins to crash in certain scenarios when fetching the existing results.
-
Fixed an issue in the IDE plugins causing some of the Bitbucket Data Center repositories to be matched incorrectly with the Mend Platform projects.
Version 26.8.1 (24-August-2026)
New Features and Updates
-
When viewing finding details in the Mend Platform, you can now see the probability risk factor next to each data flow, providing more granular information.
-
Mend SAST now includes detection for CWE-99: Improper Control of Resource Identifiers / Client Resource Injection in JavaScript/TypeScript. This update expands security coverage by identifying vulnerabilities where untrusted input can influence the selection of resources, such as files or network connections, helping to prevent client-side resource injection attacks.
-
Mend SAST now supports CWE-319: Cleartext Transmission of Sensitive Information and CWE-321: Use of Hard-coded Cryptographic Key for Rust.
Resolved Issues
-
Fixed an issue where Java SAST scans performed on a non-system drive, such as a D: drive, failed to report findings. The engine now correctly handles cross-drive paths, ensuring consistent detection results regardless of the scan's location.
-
Fixed an issue where the iOS Objective-C engine incorrectly flagged standard Apple APIs—including `removeItemAtPath` and `NSUserDefaults`—as security vulnerabilities based on their presence alone. The engine now requires evidence of external control or sensitive data usage before reporting File Manipulation (CWE-73) or Insecure Data Storage findings. These improvements significantly reduce false positives in mobile application scans by ensuring that standard in-memory and lifecycle operations are not misidentified as risks.
-
Fixed an issue where VB.net scans would experience severe performance degradation or fail to complete when processing large files during the deep analysis phase. The engine has been optimized to significantly improve scan speeds, ensuring that complex files complete analysis instead of being skipped or timing out.
-
Fixed an issue where the Mend Agentic MCP Integration's SAST tool failed to provide remediation suggestions due to an internal server error. The LLM remediation service has been stabilized to ensure consistent performance and successful tool calls within the integration.
-
Fixed an issue where Mend CLI SAST scans failed to upload results after long-running engine analysis. This occurred when network firewalls closed idle TCP connections during extended analysis phases, leading to EOF errors. The system now gracefully handles these network conditions to ensure scan results are successfully submitted even after periods of inactivity.
Version 26.7.2 (10-August-2026)
New Features and Updates
-
Introducing the Gen 2 Ruby detection engine, with improved CWE and framework coverage for accurate, scalable scans.
-
The Scala detection engine is now generally available, delivering increased coverage and accuracy for Scala code analysis.
-
The compliance standards section in the Mend Platform now shows, for each standard, how many findings violate it. That count is clickable, and selecting it takes you directly to the list of findings that violate that specific standard, so you can move from a compliance overview straight to the exact findings you need to review.
Resolved Issues
-
Fixed an issue where Mend SAST incorrectly flagged `getIntent()` calls in non-exported Android Activities as potential vulnerabilities.
-
Fixed an issue where Mend SAST incorrectly flagged log messages in Android Java applications when the message consisted solely of fixed string literals or compile-time constants.
-
Fixed an issue where the iOS Objective-C engine incorrectly identified `NSMutableDictionary` as a vulnerability, resulting in false-positive Insecure Data Storage findings.
-
Fixed an issue where the iOS Objective-C engine could experience memory inefficiency and stalls when processing dense C preprocessor macro blocks.
-
Fixed an issue where the JavaScript engine incorrectly flagged false-positive Open Redirect (CWE-601) findings when processing server-rendered attributes.
-
Fixed an issue where JavaScript / TypeScript detection engine reported false-positive findings for DOM-based XSS.
Version 26.7.1 (27-July-2026)
New Features and Updates
-
Introduced a new toggle in the Custom Code Configuration settings that allows you to automatically include newly supported CWE types in their scan coverage. When enabled, new vulnerability types are added by default, ensuring up-to-date detection and reducing manual maintenance. This setting is disabled by default and does not override any CWE types previously excluded by administrators.
-
Mend SAST now supports Python for CWE-614 (Sensitive Cookie Without 'Secure' Attribute).
-
Mend SAST now includes detection for CWE-642 (External Control of Critical State Data) in Java.
-
Mend SAST now includes detection for CWE-284 (Improper Access Control / Unsafe Permission Check) in Java.
-
Improved the detection accuracy in Java and JavaScript (Gen2) engines across several CWE categories, including SQL Injection (CWE-89), Path Traversal (CWE-22), and Cross-Site Scripting (CWE-79).
-
Updated the Mend SAST detection engine for Scala to include support for CWE-94: Improper Control of Generation of Code ('Code Injection').
-
Improved the accuracy of Scala security scans by refining the sanitization logic for Server-Side Request Forgery (SSRF) detection.
-
Mend SAST now supports CWE-319 (Cleartext Transmission of Sensitive Information) for the Go programming language.
Resolved Issues
-
Fixed an issue where Mend SAST incorrectly flagged FIPS-approved cryptographic algorithms, such as Elliptic Curve (EC) and PBKDF2WithHmacSHA256, as insecure under CWE-327.
-
Fixed an issue where false-positive XSS vulnerabilities were incorrectly flagged in Python environments.
-
Fixed an issue where the secrets detection engine incorrectly flagged Mend SAST cache files as false positives when the cache directory was located within the scanned target directory. The engine now automatically excludes Mend's internal cache, binary, and log directories from secrets detection.
Version 26.6.2 (13-July-2026)
New Features and Updates
-
Minor improvements in the AI-based Triage capability in the Developer Platform.
-
(Open Beta) Scala support is now in open beta, supporting a wider breadth of CWEs compared to the closed beta phase. Customers can now analyze Scala projects to further reduce security risk.
-
Scala detection is disabled by default. Please reach out to your CSM at Mend.io to enable it.
-
-
Improved the accuracy of the JavaScript hardcoded-password rule by refining the detection logic for identifiers, ensuring more reliable security findings.
-
The Suppression Requests CSV export now includes a direct link to each finding in the platform. This new column allows for immediate navigation from the exported file to specific findings, eliminating the need for manual searches and significantly streamlining the bulk review and triage process.
Resolved Issues
-
Improved performance when loading secrets detection findings in minified JavaScript files.
-
Fixed a bug where clicking the Compliance Standards drill-down on the project Summary page would open the Code Findings view with zero findings displayed. The drill-down now correctly navigates to the findings view with the appropriate filters.
-
Fixed an issue where the SAST engine incorrectly flagged the use of `NSURL` in Swift as a CWE-676 (External URL Access) vulnerability.
-
Fixed an issue where C/C++ vulnerabilities were not properly detected when using low-probability (LP) sources. The analysis engine now correctly identifies these findings by treating file open and read operations as valid taint sources, ensuring comprehensive security coverage for complex C/C++ codebases.
Version 26.6.1 (29-June-2026)
New Features and Updates
-
Introduced a production-grade AI-based triage capability for SAST findings in the Developer Platform, enabling developers and security managers to quickly identify and prioritize real vulnerabilities in their SCM. This feature automates false positive detection, provides AI-generated explanations and exploitation paths, and significantly reduces manual review time.
This feature will be rolled out gradually in the next four weeks.
For more information, refer to the AI Triage section of the relevant SCM: -
Increased the detection accuracy for Python, especially for the following CWEs:
-
CWE-22: Path Traversal
-
CWE-78: Command Injection
-
CWE-79: Cross-site Scripting
-
CWE-117: Log Forging
-
-
Enhanced JavaScript analysis by adding the local storage as a low-probability source. This update improves the detection of potential client-side vulnerabilities, such as stored DOM XSS, by identifying data retrieved from local storage as a possible point of origin for tainted input.
-
Increased the detection accuracy for Java, especially for CWE-117: Log Forging.
Resolved Issues
-
Fixed an issue where the "fromDate" and "toDate" fields were incorrectly included in standard JSON reports with zeroed values. These fields, intended only for resolved findings reports, have been removed from standard reports to ensure data clarity and accuracy.
-
Fixed an issue where code snippets were missing from SAST reports if a previous scan in the same project had the snippet size set to zero. Subsequent scans with code upload enabled now correctly include the expected code snippets in the generated reports.
-
Fixed an issue where "Weak Hash Strength" findings were incorrectly grouped by vulnerability name alone, leading to inconsistent CWE mapping in reports. The grouping logic now utilizes both the vulnerability name and the specific CWE ID (such as CWE-328 or CWE-916) to ensure accurate reporting across different programming languages.
-
Fixed an issue where multiline suppression justification comments submitted from GitHub were truncated to the first line in the Mend Platform. The full multi-line text is now correctly preserved and displayed.
-
Fixed an issue where a single line of code snippet remained visible in the Mend Platform UI and reports even when the snippet size was set to zero in the latest scan.
-
Fixed an issue where the VB.NET engine failed to scan files when the Windows system locale was set to Traditional Chinese (cp950).
Version 26.5.2 (15-June-2026)
New Features and Updates
-
Extended the support for JWT callbacks and anonymous classes in Java.
-
Improved detection of CWE-79: Cross-site Scripting (XSS) in JavaScript/TypeScript.
-
Improved detection of hard-coded credentials for JavaScript/TypeScript, PL/SQL, and VB.Net.
-
The SAST findings API now includes natural language descriptions for each step in a vulnerability's data flow trace. When retrieving a finding, each step in the data flow — from the tainted input to the vulnerable sink — now comes with a plain-English explanation of what's happening at that point in the code.
Resolved Issues
-
Fixed an issue where Chinese characters wouldn’t be displayed correctly in the PDF version of the Code Compliance Report.
-
Finding details in Mend for JetBrains now display correctly on narrow panels. Labels now stack vertically, keeping the information clear and legible regardless of how wide the panel is.
Version 26.5.1 (01-June-2026)
New Features and Updates
-
(Closed Beta) Mend SAST now supports a new programming language! First as a closed beta program, customers can now analyze Scala projects to even further reduce security risk.
-
Secret scanning now detects hardcoded private keys (
*.pem,*.key) and committed certificate files (*.pfx,*.p12). PowerShell scripts (.ps1) are also included in the set of file types scanned by default. Additionally, the engine now detects a broad set of new credential patterns related to Azure Dev Ops products. -
Added a new "Information Requested" state to suppression requests, enabling reviewers to request additional context from developers and filter these requests from their pending review queue. This update streamlines the review process and improves workflow efficiency.
-
Security managers can now configure which suppression reasons are available to developers when requesting a SAST suppression through GitHub Classic integrations. By adding a suppressionReasons array to scanSettingsSAST in the .whitesource file, organizations can restrict the available options to any combination of false-positive, acceptable-risk, temporarily-ignore, etc. — ensuring developers can only submit justifications aligned with the organizational policy.
Resolved Issues
-
Improved accuracy of Dangerous Method detection in Swift.
Version 26.4.3 (18-May-2026)
New Features and Updates
-
Mend now offers a SAST plugin for JetBrains IDEs (IntelliJ and others), allowing developers to find and fix security vulnerabilities without leaving their editor. The plugin allows developers to run a scan, highlights vulnerable lines of code directly in the editor, and separates the new issues introduced by the developer's own changes from the existing issues — keeping the noise low. For each finding, developers can see remediation suggestions, code flow traces, CWE descriptions, and training materials. Applying a fix is a single click: the plugin shows a code diff and patches the file automatically. IDE scans are kept isolated from the Mend AppSec Platform, meaning local scans don't affect project-level statistics.
-
The Gen 2 Go detection engine is now generally available, delivering increased coverage and accuracy for Go code analysis.
-
Secrets scanning now detects hardcoded Stripe credentials more robustly.
-
Improved secret detection by addressing cases where certain secrets were previously missed during scanning.
Resolved Issues
-
Fixed an issue where SSRF (Server-Side Request Forgery) vulnerabilities were incorrectly flagged as false positives in C# (Gen2) scans.
Version 26.4.2 (04-May-2026)
New Features and Updates
-
Added taint analysis support for Python smbclient to enhance detection of path traversal vulnerabilities.
-
Added support to ensure that SSRF vulnerabilities in JavaScript are reported only when detected on the server side, improving the accuracy of security findings.
-
Secret scanning is now available in Mend for Visual Studio Code.
Version 26.4.1 (20-April-2026)
New Features and Updates
-
(Closed Beta) Introducing the Gen 2 Go detection engine, with improved CWE and framework coverage for accurate, scalable scans.
-
Automated remediation suggestions for Code findings are now also supported for Rust. The following CWEs are covered:
-
CWE-22 - Path Traversal
-
CWE-78 - Command Injection
-
CWE-89 - SQL Injection
-
CWE-90 - LDAP Injection
-
CWE-643 - XPath Injection
This feature will be rolled out gradually during the next 14 days.
-
-
Added support for additional low-probability security protocols in Rust, expanding coverage for several CWEs and enhancing detection capabilities.
-
Several accuracy improvements for C#, mainly for the following CWEs:
-
CWE-89: SQL Injection
-
CWE-502: Deserialization of Untrusted Data
-
CWE-643: XPath Injection
-
-
Improved the accuracy of CWE-79: Cross-site Scripting for Angular.
-
Incremental scanning is now available for secrets detection. When running a scan, only files that have changed since the last scan are analyzed, reducing scan times.
-
CSV exports and generated reports now include a Deep Link column with a direct URL to each finding in the Mend AppSec Platform UI, making it faster to navigate from a report to the relevant finding for triage or remediation.
Resolved Issues
-
Fixed an issue where temporary folders were not cleaned up properly after a CLI scan, which could lead to scan failures in certain cases.
Version 26.3.2 (13-April-2026)
New Features and Updates
-
Improved the formatting of suppression request comments. Comments are now displayed more concisely, with clearer attribution and support for bold and italic text, making it easier to communicate during the review and approval process.
-
Minor accuracy improvements of the remediation suggestions across all supported languages and CWEs.
-
Improved accuracy for CWE-79: Cross-site Scripting detection in React code.
Resolved Issues
-
Fixed an issue where the OWASP Top 10 bar chart was missing from the PDF version of the code compliance report.
-
Fixed an issue where the C++ engine reported malformed data flows, causing sink lines to appear in temporary files and preventing snippet reading or signature computation.
-
Fixed an issue related to the MEND_SAST_STORAGE_LIMIT environment variable.
-
Fixed an issue where JavaScript scans failed on Alpine Linux due to Node.js compatibility. The CLI now downloads the correct Node.js flavor for Alpine, ensuring successful scans on supported versions.
Version 26.3.1 (23-March-2026)
New Features and Updates
-
Organization admin users can now see all suppression requests across the organization in a single view, with filtering by application, project, status, and reason. Results can be exported to CSV for compliance and audit purposes. The view is accessible via Findings --> Suppression Requests.
-
This feature will be gradually rolled out to all environments until April 6th, 2026.
-
-
Reduced memory consumption and improved performance of Go analysis.
-
Optimized a potentially time consuming post-processing step for log records.
Resolved Issues
-
Fixed an issue where suppressing findings via the API did not update the findings count in the Code Findings JSON report, causing the count to remain non-zero even though findings were suppressed. Now, the count correctly reflects zero after suppression through the API, ensuring consistency with the UI behavior.
-
Fixed an issue where certain DOM-based cross-site scripting (CWE-79) vulnerabilities were not being identified by the JavaScript analysis engine.
-
Fixed an issue where NoSQL Injection vulnerabilities in JavaScript applications using MongoDBClient were not properly detected.
-
Injecting objects into Angular components is now handled correctly during JavaScript/TypeScript analysis.
Version 26.2.2 (09-March-2026)
New Features and Updates
-
Added support for CWE-457: Use of Uninitialized Variable and CWE-824: Access of Uninitialized Pointer to C/C++ analysis in low probability mode.
-
The custom sources and sinks configuration pages now include links to the relevant documentation, making it easier to learn how to define custom taint sources and sinks.
-
When a finding is suppressed and its corresponding GitHub issue is closed, Mend now adds a comment to the issue with the suppression reason, any additional comments, and the user who performed the suppression. This provides a clear audit trail directly within GitHub, regardless of whether the suppression was initiated from a repository-level request or directly on the Mend platform.
-
Suppression request tables now show who approved or rejected each request in a new “Reviewed By” column, giving security managers a complete audit trail of suppression decisions.
-
The finding details page now includes a refresh button in the Comments tab, allowing you to quickly check for new comments.
Resolved Issues
-
Fixed an issue where adding a custom source in JavaScript did not result in automatically adding the surrounding method as an entry point, potentially preventing the taint source from being reached.
-
Fixed a false positive where Hardcoded Password was incorrectly reported for masked passwords in Python files.
-
Fixed an issue where the Hardcoded Credentials (CWE-798) finding was incorrectly reported as an SQL injection, ensuring accurate vulnerability identification in scan results.
-
Fixed an issue where the Code Compliance report displayed vulnerability counts even after all findings were suppressed, ensuring accurate statistics are shown in compliance and severity reports.
Version 26.2.1 (23-February-2026)
New Features and Updates
-
Increased the accuracy of CWE-502: Deserialization of Untrusted Data and CWE-798: Hard-Coded Credentials detection for C#.
Version 26.1.2 (09-February-2026)
New Features and Updates
-
Added the ability to generate SAST reports that include resolved (historical) findings for a selected time frame. Users can now export these reports in CSV, XML, and JSON formats via both API and Platform UI, enabling better tracking of risk trends and remediation effectiveness for security and compliance needs.
-
Increased the accuracy of CWE-79: Cross-site Scripting detection for JavaScript.
-
Multiple minor improvements to increase the accuracy of Rust detection.
-
Improved secret scanning to better detect hardcoded database connection strings.
-
Changes in configuration files now trigger secret scanning even when no actual code is present in the repository.
-
Repository integration users can now request to disable Secure Code Warrior training materials by contacting Mend Support.
Version 26.1.1 (26-January-2026)
New Features and Updates
-
The Mend Developer Platform now supports suppression approval workflows for GitHub repositories. Developers can request suppressions directly from their workflows, while security managers retain control by approving or rejecting them. This ensures governance over security exceptions without slowing down development.
-
Automated remediation suggestions for Code findings are now also supported for C and C++. The following CWEs are covered:
· CWE-22 - Path Traversal
· CWE-79 - XSS (Cross-site Scripting)
· CWE-89 - SQL Injection
· CWE-117 - Log Injection
· CWE-601 - Open Redirect -
Mend SAST Rust detection is now generally available, offering enhanced security scanning for Rust projects. This update incorporates feedback from beta users and increases coverage of Common Weakness Enumerations (CWEs), enabling developers and security teams to identify vulnerabilities in Rust code with greater accuracy and confidence. Click here to learn about the Rust coverage.
-
Added support for
.pbxprojfiles in secret scanning, helping users detect and prevent exposure of sensitive information in Xcode configuration files. -
SAST detection for Android, Objective-C and Cold Fusion now supports multi-threading to reduce the scan time.
-
Updated Taint Sanitizer support in both Project and Global Scan contexts. The updates include expanded support for parameter values, clearer CWE type selection, and improved accessibility for configuration modals.
Version 25.12.2 (12-January-2026)
New Features and Updates
-
The Mend Developer Platform now supports suppression approval workflows for Azure DevOps repositories. Developers can request suppressions directly from their workflows, while security managers retain control by approving or rejecting them. This ensures governance over security exceptions without slowing down development.
-
Added additional entry points for Express framework.
Version 25.12.1 (05-January-2026)
Resolved Issues
-
The Mend Developer Platform now supports suppression approval workflows for Bitbucket repositories. Developers can request suppressions directly from their workflows, while security managers retain control by approving or rejecting them. This ensures governance over security exceptions without slowing down development.
-
Improved handling of double unwrapping in Rust analysis.
-
Updated Mend CLI code scan dependencies for improved security.
Version 25.11.2 (15-December-2025)
New Features and Updates
-
Improved accuracy of Java, JavaScript/TypeScript and Python analysis, especially for the following CWEs:
-
CWE-78: Command Injection
-
CWE-79: Cross-site Scripting
-
CWE-89: SQL Injection
-
-
Added support for two compliance standards, PCI DSS 4.0 and MISRA, now visible in the code findings table and code reports.
-
Dead code analysis for Java now excludes generated files and skips scanning those exceeding the maximum file size limit, improving performance and focusing results on relevant code only.
-
Enhanced support for Rust macros, ensuring they are properly parsed to detect tainted data.
-
When reviewing suppression requests, users can now filter by predefined reasons—false positive or acceptable risk—to make the review process more efficient.
-
Newly created organizations will now have C++ gen 2 engine enabled by default, ensuring all users benefit from the latest version automatically.
-
Scans are now automatically stopped if the CLI cannot retrieve required engine configuration, preventing inconsistent results when some components are unreachable.
-
Added the ability to filter, sort, and group findings by project in the applications view, making it easier to manage and analyze security findings.
Resolved Issues
-
Fixed an issue where the PHP engine could become unresponsive on Windows due to improper timeout handling. The timeout mechanism has been adjusted to restore previous logic on Windows, ensuring stable scanning and preventing unexpected engine hangs.
-
Fixed an issue where importing results from an external SARIF file would fail if the tool name in the imported file contained spaces.
-
Fixed an issue that caused reports to show negative numbers of detected findings.
Version 25.11.1 (01-December-2025)
New Features and Updates
-
The Agentic SAST detection now reports all detected findings in the generated code at once instead of just one finding per invocation.
-
Added low probability taint sources for file, database, console, and environment variable reads in Rust, improving analysis accuracy.
-
Reclassified CWE-242: Use of Inherently Dangerous Function and CWE-676: Use of Potentially Dangerous Function to low probability category for C/C++, enhancing scan accuracy when scanning with the default configuration.
-
Further improved detection accuracy for C/C++ gen 2, most notably for the following CWEs:
-
CWE-121: Buffer Overflow
-
CWE-369: Divide by Zero
-
CWE-606: Loop Denial of Service
-
CWE-611: XML External Entity (XXE) Injection
-
CWE-789: Uncontrolled Memory Allocation
Additionally, reading from local files has been added as a low probability taint source.
-
-
Organizations are now sorted alphabetically in the Mend CLI’s organization selection step, making it easier and faster to navigate large lists.
Resolved Issues
-
Fixed an issue in the Classic Repository Integrations where SAST scans on pull requests targeting an empty main branch produced misleading results and incorrectly reported a successful scan status.