Secure SDLC (Part 1): issues, approach, tech metrics, team’s KPI
Tags: devsecops, sdlc, appsec, asoc
Published: 2024-04-16 08:16:30

_Dive dive into Secure SDLC by SecChamp, senior DevSecOps engineer and AppSec manager_


## Intro
Building a **secure software development cycle (Secure SDLC)** is one of the priority tasks for companies which are developing software, making digital products and providing own services. Many specialists unfamiliar with cybersecurity incorrectly interpret **application security(AppSec)** only as the introduction of **static (SAST)** and **dynamic( DAST)** analyzers into the development pipeline.

Today we will look in detail at what a secure software development cycle consists of, how the effectiveness of practices is measured, such measurement approaches exist, and how to evaluate the work of a security champion (the entire AppSec team)

## How to measure SSDLC progress?
As companies increasingly adopt agile development methods, many are looking for ways to improve their application security program. One of the first questions which they must address - is how to measure progress?

For every application-security program, there are two tracks of the problem that companies need to pursue: **(1) how to measure risk in a way that informs action**, and **(2) how to use metrics to train the development staff ** in ways that prevent the creation of new vulnerabilities.



**Metrics** — or perhaps more accurately, the right metrics — are crucial for understanding what’s really happening in your AppSec program. So, the metrics serve a dual purpose: they demonstrate where your organization is at but also show what progress it’s making in achieving its objectives.

The key to a truly effective AppSec program is to identify the right metrics and present them in a way that your executives and key business decision-makers can understand and use. An overly cumbersome approach, or one that presents information in an obtuse and burdensome way, isn’t likely to succeed.

### Why Is metrics important? — management vs dev

Executives need to understand the story behind the metrics. It’s a basic truth: No enterprise initiative succeeds without executive buy-in. However, enterprises cybersecurity and AppSec are particularly challenging tasks. For them to succeed, thought leadership and messaging are crucial; funding for the right tools, systems, and technologies is critical. Organizations achieve best-practice results when they deliver the right level of information in the right format to executives — while providing your executives and development teams with more detailed metrics, as appropriate.

**The executive team** needs to understand the metrics being used and how they’re related to success and reduced risk.

**The developers (and operation also) team** must understand why metrics matter. It’s logical to think that your developers should understand the need for metrics and key performance indicators. But, historically, cybersecurity and application security haven’t been the primary focus for developers. Writing code and producing applications is at the center of their world.

## The Main Software Security Metrics
Understanding a few of the most common Secure SDLC metrics

**1. Mean-time to Remediate (MTTR)**
This metric tracks the average time it takes to resolve or mitigate a discovered security vulnerability, from the time it is identified to the time it is fixed. Faster remediation reduces the window of opportunity for attackers.

**2. Threat Risk Index (TRI)**
TRI assesses the overall risk of a software application based on the number and severity of identified threats and vulnerabilities. Lower TRI values represent more secure software.

**3. Vulnerability Density**
This metric measures the number of discovered security vulnerabilities per thousand lines of code (KLOC). Lower vulnerability density means better security.

**4. Code Review Coverage**
This metric tracks the percentage of source code covered by formal code reviews, including manual and automated tools. Higher code review coverage improves the likelihood of identifying and resolving vulnerabilities.

**5. Patch Management Efficiency**
This metric measures the % of security patches applied within a specified time frame. Higher patch management efficiency ensures a more secure software environment.

**6. Static Analysis Defect Density**
This measures the number of security vulnerabilities discovered through static analysis tools per KLOC. Lower defect density indicates better code quality and fewer potential security issues.

**7. Security Training Effectiveness**
This metric measures the % of the organization’s developers who have undergone security training and their level of proficiency. Higher training effectiveness indicates a more security-aware development team.

**8. Application Security Compliance(e.g. OWASP Top10)**
This metric tracks the adherence of a software application to OWASP’s Top Ten security risks. Higher compliance with OWASP’s guidelines results in better security posture.

**9. False-Positive Rate**
This metric measures the proportion of reported security vulnerabilities that turn out to be false positives. Lower false-positive rates indicate more accurate vulnerability detection tools and processes.

**10. Security Debt Ratio**
This metric compares the number of unresolved security vulnerabilities to the total number of open issues in a software project. A lower security debt ratio indicates that security vulnerabilities are being more effectively managed.

**11. Security Testing Coverage**
This metric measures the extent to which security testing (e.g., penetration testing, fuzz testing, etc.) covers different parts of the application. Higher testing coverage ensures a more secure application.

**12. Incident Response Time**
This measures the average duration between the detection of a security incident and the initiation of an appropriate response. Faster response times minimize the potential impact of an attack.

**13. Runtime Security Event Rate**
This metric tracks the number of security-related events (e.g., attack attempts, policy violations) detected by monitoring tools while the software is running. Lower event rates indicate a more secure runtime environment.

**Efficiency indicators may already be available in your bug tracking system. These may include:**

**Time to Remediate (TTR)** — how long between when a specific vulnerability is first identified and when it’s fully remediated
**Average TTR — TTR per time period**
**Current/Average Remediation Queue Size** — how much technical security debt exists
**Velocity** — bug fixes completed per time period
**Pipeline Stress** — how many requests for things like manual testing or code review were expedited

Other indicators can be designed to track efficiency in security operations, like time to assign an AppSec resource for internal assurance services, time to complete and so on.

**Coverage** — the number of applications per assurance activity (code scan, dynamic analysis) per time period; applications can be ranked according to risk or mission criticality
**Top Vulnerability Types** — per time period
**Rate of Recurrence** — how often known defects come back
**Churn** — how many times a specific vulnerability was incorrectly remediated
**Composite Risk Rating** — often shown graphically, this is a somewhat arbitrary visualization of business risk, defined by something similar to: vulnerability severity x defect count x application risk rating
**Security Defect Ratio** — number of security defects divided by the total number of defects

## Software Security Metrics Explained
Software Security Metrics are crucial in maintaining a secure software environment, as they provide insights into vulnerabilities, remediation efforts, and overall risk management. Vulnerability Density, for instance, helps identify the number of security vulnerabilities in a given amount of code, with a lower density indicating better security. Meanwhile, metrics like **Mean-time to Remediate (MTTR)** and **Patch Management Efficiency** focus on the speed and effectiveness of addressing security vulnerabilities, as a faster response minimizes the opportunity for attackers to exploit any weaknesses.

Tools like **Static Analysis Defect Density** and **Code Review Coverage** help ensure code quality and security, while the **Threat Risk Index (TRI)** provides a comprehensive assessment of overall risk. In addition, **Security Training Effectiveness** highlights the importance of cultivating security-aware development teams, and **OWASP Compliance** (or another) measures adherence to established security standards.

Metrics such as **Security Testing Coverage**, **Incident Response Time**, and **False-Positive Rate** provide insights into the effectiveness and accuracy of security testing processes, helping teams prioritize vulnerabilities efficiently. Lastly, the **Security Debt Ratio** and **Runtime Security Event Rate** offer valuable information about the management of vulnerabilities, potential attack indicators, and the runtime security of the software.

Together, these metrics allow organizations to maintain and improve their software security posture.



## Which security KPIs should you measure?
Teams should measure the effectiveness of their AppSec program from a few different angles. Well, by following a variety of KPIs, they can ensure that their application security program aligns with their organization’s unique needs and structure.

**These five metrics are a great place to start:**

**Exploitable vulnerabilities.** How many of your assets have exploitable and reachable vulnerabilities? And how many are in the high-critical CVSS score range?

**Alignment with compliance frameworks.** How does your program measure up to compliance frameworks such as NIST 800, SOC2, PCI DSS, and ISO? Are you meeting standards for your specific industry and location, such as HIPAA or GDPR?

**Organizational policy compliance.** What percentage of your applications align with the internal security policies? These company-specific policies often focus on mission-critical applications and other business priorities.

**Time-to-fix.** How long does it take the security and development teams to fix major vulnerabilities after a tool uncovers them?

**Tool coverage.** Are there gaps in your overall coverage that your team needs to resolve? These metrics are especially crucial for recently acquired or merged businesses, as they will likely bring in new critical assets that existing security tooling isn’t covering.

---

Next reading **Secure SDLC (Part 2): ASOC, ASPM, DevSecOps and the AppSec future** will be soon..