Cyber-attacks are growing more frequent and damaging. Critical sectors like healthcare and education are common targets. Threat actors are quick to exploit weak software. This leaves companies and users struggling to keep up. But there’s a better approach: build security into software from the start.

In 2023, CISA launched its Secure by Design campaign. It highlights the need for secure software development and corporate accountability. High-profile breaches like SolarWinds and Kaseya show the risks of weak defenses. They also show why software makers must take the lead on security. 

This article will explore software development security best practices. It’s based on CISA’s guidelines and Secure Software Development Lifecycle ideas. Following these practices reduces risks and builds stronger, safer systems.

Why secure software development matters

Everyone agrees security is critical in software development, yet it’s often unclear how to achieve it. Without secure processes, businesses risk deploying vulnerable applications that bad actors can exploit.

Vulnerabilities by design

Technology powers every aspect of modern life. Internet-facing systems connect critical functions like healthcare and identity management. These innovations improve convenience but also create significant risks. Cyber-attacks have disrupted hospitals, leading to canceled surgeries and delayed care. A single flaw can let attackers exploit systems, threatening lives and data.

Secure software development tackles these risks by focusing on security from the start. Manufacturers who adopt secure design principles take responsibility for reducing risks. Features like default encryption and user authentication ensure fewer vulnerabilities for users.

Historical challenges with patching

Relying on patches after deployment creates extra work for users. For example, if a security flaw is discovered, customers must apply the fix themselves. This process can take time, leaving systems exposed to cyber-attacks. A real-world example is the WannaCry attack, which exploited unpatched systems worldwide.

Secure by Design addresses these challenges by fixing vulnerabilities before product launch. For instance, testing software for common weaknesses, like injection flaws, reduces the need for patches later. This approach aligns with secure software development lifecycle practices, saving time and boosting trust in the software.

Secure by design principles

Secure by Design means building security into every product from the beginning. A good example is adding multi-factor authentication (MFA) as a standard feature. It ensures users have a second layer of protection beyond passwords. Another example is setting safe defaults, like requiring strong passwords or enabling automatic updates.

Manufacturers should also follow software development security best practices, such as performing risk assessments during development. This step identifies potential threats and includes defenses against them. For instance, a defense-in-depth strategy can add multiple layers of protection, like firewalls, secure access controls, and network monitoring tools.

Reducing customer burden

Good software should make security easier for users. For instance, automated updates prevent users from forgetting critical patches. Another example is providing built-in network monitoring tools that alert about potential issues without manual setup. These features contribute to cloud security and cybersecurity resilience.

Manufacturers can also provide clear instructions to users. For example, warning users when they change secure default settings helps maintain safety. By easing the burden on customers, manufacturers ensure better protection and fewer missteps. Conducting security awareness training for users can further enhance security.

Leading by example in secure software

Some companies set the standard for secure development by making it a priority. For example, they use features like Cloud Firewall to support network segmentation. This strengthens security in development environments by blocking unauthorized access. It helps protect users, safeguard intellectual property, and improve access controls.

A strong example is a company implementing Zero Trust Network Access (ZTNA) to limit system access. By requiring users to verify identity and devices, they reduce risks. Such practices, combined with secure coding practices, highlight the value of adopting a secure software development framework.

Common cyber-attacks for software development

1. SQL Injection

SQL injection (SQLi) is a dangerous cyber-attack targeting databases. It happens when bad actors add malicious code to input fields. This trick lets them bypass normal security checks and access data. For example, they can use a login form to steal sensitive information. SQL injection remains one of the most common web application vulnerabilities.

The impact of SQL injection is severe. It allows attackers to steal or delete sensitive data. In some cases, they can even take full control of the system. For example, an attacker might enter “OR 1 = 1” into a login field. This tricks the database into granting access without a password. According to reports, SQLi attacks accounted for 23% of major vulnerabilities in 2023.

Organizations handling sensitive data are prime targets. SQL injection attacks can expose personal records, financial data, and trade secrets. For instance, an attacker could use SQLi to steal customer payment information. In extreme cases, attackers have deleted entire databases. Such attacks often result in financial loss, lawsuits, and reputational damage.

SQL injection can also exploit error messages to learn about a system. Some attacks use “stacked queries” to execute multiple commands at once. For example, “DROP TABLE Users;” can delete critical data. In another example, attackers might extract usernames and passwords using the “UNION” SQL operator. This type of attack affects industries like retail, travel, and finance the most.

Preventing SQL injection requires strong secure coding practices. Developers should use prepared statements and validate all user input. Web application firewalls (WAFs) add an extra layer of defense. Regular security audits and vulnerability scans help catch issues early.

2. Command injection

Command injection is a critical software vulnerability. It lets attackers run harmful commands on systems. These commands can grant unauthorized access or full system control.

This issue arises when user input isn’t validated properly. Attackers craft input to manipulate how commands are executed. For example, CVE-2024-20399 involved crafted input to exploit Cisco NX-OS software. This allowed attackers to execute commands with root privileges.

The CVE-2024-20399 flaw affected many Cisco devices, including Nexus and MDS switches. A China-linked group called “Velvet Ant” used it in a cyber-espionage campaign. They targeted network devices to maintain long-term access to organizational systems.

Secure design practices, like input validation, can prevent these issues. Separating commands from input can reduce risks and stop attackers from exploiting systems.

3. Cross-site scripting (XSS)

Cross-site scripting (XSS) is a common vulnerability in web applications. It happens when an application does not validate or sanitize user inputs. This allows bad actors to inject malicious scripts into the application. These scripts can then run on the browser of another user.

Attackers use XSS to manipulate or steal user data. For example, they might inject code into a comment section on a website. When another user views the comment, the script could steal their session cookies. These cookies can give attackers access to the victim’s account. XSS can also redirect users to fake login pages or load harmful files.

XSS is a big problem because it is widespread and preventable. A report from the Open Web Application Security Project (OWASP) lists XSS as one of the most common web application security issues. Proper input validation and using secure coding practices can stop these attacks. Modern web frameworks also help by encoding data to prevent malicious code execution.

Businesses need to take XSS seriously because it can harm many users. One mistake in code can expose millions of people to risk. Regular code reviews, automated tools, and aggressive security testing can help eliminate this threat. Addressing XSS early in the secure software development process is essential to protect applications and their users.

4. Exploitation of known vulnerabilities

Bad actors often exploit known vulnerabilities in software, tracked by unique IDs called CVEs (Common Vulnerabilities and Exposures). These vulnerabilities are listed publicly to help organizations manage and fix security flaws. When actively exploited, attackers use them to spread malware, steal data, or lock systems with ransomware. For example, some types of malware, like worms, spread automatically without user interaction, underscoring the urgency of remediation.

The KEV catalog highlights vulnerabilities actively exploited in real-world attacks. Organizations should prioritize fixing these issues using automated tools to save time and reduce risks. Installing updates, removing outdated software, or applying temporary fixes are key steps to protect systems from exploitation.

5. Memory safety exploits

Memory safety exploits are a common and serious threat. These happen when software written in memory-unsafe languages, like C or C++, mishandles memory. Mistakes in managing memory can cause vulnerabilities like buffer overflows or use-after-free errors. These allow attackers to take control of software, systems, or data. For example, a buffer overflow can let attackers execute malicious code.

Most open-source software (OSS) projects rely on memory-unsafe languages. About 52% of critical OSS projects analyzed include memory-unsafe code. In total, 55% of the lines of code in these projects are written in unsafe languages. Even projects written in memory-safe languages often depend on unsafe components. This increases the risk of memory safety vulnerabilities spreading through dependencies.

The largest OSS projects are more likely to have unsafe code. Among the ten biggest projects analyzed, the median unsafe code usage is 62.5%. In four of these projects, over 94% of the code is unsafe.

These vulnerabilities are especially dangerous in performance-critical software, like operating systems or cryptography tools. Attackers target these systems to exploit weaknesses.

Using memory-safe programming languages, like Rust, can reduce these risks. These languages automatically handle memory management, which helps prevent errors. However, developers sometimes disable safety features to improve performance. This can create new vulnerabilities. Memory safety exploits remain a major challenge and require secure coding practices to minimize risks.

Software development security best practices

Implementing software development security best practices is vital for creating secure applications. These strategies help protect users from security risks while improving software reliability. When applied throughout the secure software development lifecycle, they address vulnerabilities and strengthen defenses. Below are key principles and approaches to ensure secure software and reduce evolving threats.

1. Secure by default practices

Ensuring software is secure “out of the box” minimizes user burden and proactively addresses security vulnerabilities. This approach forms a foundation for secure software development.

• Eliminate default passwords. Replace default credentials with strong, unique passwords during setup. For example, enforce minimum password lengths and block known compromised passwords to protect secure access.
• Conduct field tests. Evaluate software security features in real-world environments. Insights from red team exercises can identify gaps in firewall settings or weak points in VPN implementations.
• Discourage unsafe legacy features. Phase out insecure protocols like outdated TLS versions. Use seamless upgrade paths and in-product alerts to encourage the adoption of safer options while maintaining compatibility with cloud security standards.

2. Secure product development practices

Embedding secure coding practices into every stage of the secure software development framework ensures long-term protection against threats and enables secure development.

• Document secure SDLC framework conformance. Use frameworks like the NIST Secure Software Development Framework (SSDF) to guide development. Publish security requirements and justify alternative approaches for unique use cases in cloud computing environments.
• Mature vulnerability management. Move beyond patching to address root causes of security vulnerabilities. For example, implement quality improvement strategies to prevent recurring issues in applications involving VPN or network monitoring tools.
• Foster a workforce that understands security. Conduct security awareness training to educate developers on secure coding practices. Integrate security topics into hiring processes and collaborate with institutions to strengthen cybersecurity skills among future developers.

3. Application hardening techniques

Application hardening strengthens software against exploitation by reducing security risks and making it more resilient.

• Validate user input. Prevent common attacks like SQL injection and cross-site scripting by sanitizing inputs. For example, in cloud computing environments, validate APIs to protect data integrity.
• Adopt memory-safe programming. Use languages like Rust to eliminate memory-related security vulnerabilities. This is particularly critical in applications involving sensitive operations like network monitoring or firewall configurations.
• Implement cryptographic safeguards. Secure sensitive data with encryption and hardware-backed key management. For instance, use hardware modules to store keys securely in VPN or cloud security systems.

4. Reducing attack surfaces

Minimizing unnecessary exposure is a critical component of software development security best practices. Reducing attack surfaces enhances secure software development.

• Remove unused features. Disable or eliminate features no longer needed, such as legacy APIs. For example, retiring outdated services in cloud computing environments reduces security risks.
• Create secure configuration templates. Provide templates tailored for low, medium, and high-risk environments. This simplifies secure development while ensuring adherence to security requirements.
• Implement attention-grabbing alerts. Notify users of unsafe configurations like admin accounts without MFA. For instance, persistent alerts can improve software security by encouraging secure settings in applications.

5. Balancing security and usability

Effective security practices must balance protection with usability. A focus on user experience ensures that secure software development lifecycle measures are effectively implemented.

• Reduce hardening guide complexity. Simplify guides for end users by automating security configurations. For instance, automated firewall rules and VPN policies can be used to streamline setup.
• Provide clear nudges. Regular reminders encourage users to address potential security risks, such as enabling MFA or updating to more secure cloud security protocols.
• Innovate thoughtfully. Design intuitive security features like Single Sign-On (SSO) to reduce friction for users. For example, SSO simplifies access without compromising secure access protocols.

These strategies ensure strong cybersecurity, effective protection in cloud computing, and robust safeguards through tools like VPN, firewall, and network monitoring.

Common mistakes to avoid

Building secure software requires careful planning and attention to detail. Common mistakes are grouped into product properties, security features, and organizational processes.

Product properties

Using memory-unsafe languages

Developing software in memory-unsafe languages like C or C++ without a roadmap to reduce vulnerabilities increases security risks. These languages can introduce critical flaws like buffer overflows, leaving systems exposed.

Software manufacturers should adopt a secure software development framework with a memory safety roadmap. Prioritize fixing vulnerabilities in sensitive areas, such as network-facing code and cryptographic functions. Following secure coding practices will significantly lower the likelihood of such security vulnerabilities.

Default passwords

Shipping products with default passwords is a dangerous practice. Default credentials are often easy to guess or publicly documented, making systems vulnerable to unauthorized access.

Always require users to set unique, strong passwords during installation.

Security features

Lack of multi-factor authentication (MFA)

Failing to include MFA in products that authenticate users significantly weakens security. Passwords alone are insufficient to protect against breaches.

Ensure MFA is supported in all products, especially for admin accounts. This practice is crucial for secure development and reducing security risks in critical systems. Aligning MFA with a secure software development lifecycle further strengthens defenses.

Inadequate logging for intrusions

Products without robust logging capabilities make it difficult for customers to detect and investigate intrusions. Logs should include critical data, such as configuration changes and user activities.

Software manufacturers should provide industry-standard logging features. For SaaS and cloud computing products, include at least six months of log retention. Enhanced network monitoring and cloud security tools help organizations meet key security requirements.

Organizational processes

Releasing software with known vulnerabilities

Releasing software that includes known exploitable vulnerabilities undermines security. Attackers often exploit these flaws before patches are issued.

Manufacturers must follow secure software development lifecycle practices, including scanning for vulnerabilities before release. Maintain a software bill of materials (SBOM) to track dependencies and ensure timely updates. Cloud security solutions and firewalls can further mitigate these risks.

Failing to disclose vulnerabilities

Not publishing CVEs (Common Vulnerabilities and Exposures) for critical flaws reduces transparency and puts users at risk. Customers depend on timely information to manage vulnerabilities.

Publish CVEs for all high-impact vulnerabilities promptly. Include details like CWE (Common Weakness Enumeration) codes to guide customers in understanding and mitigating risks. Conduct security awareness training for teams to improve processes and meet secure software development security requirements.

Case study: Successful software security with NordLayer

WeTransfer needed a reliable and flexible VPN to support global operations and meet ISO 27001 standards. Their outdated, on-site VPN couldn’t handle an office move or provide secure access for teams across 130+ regions. This created risks like phishing and ransomware.

NordLayer’s cloud-native solution offered a Dedicated server with Fixed IP for secure connectivity, Shared Gateway locations for secure internet access, and adaptive Okta integration to improve access control.

Switching to NordLayer improved operations. Developers can work faster with reduced network latency and secure access via NordLayer’s Business VPN. NordLayer also supported WeTransfer’s ISO 27001 compliance efforts. NordLayer’s platform helped WeTransfer secure its network and protect millions of users worldwide.

Explore our cybersecurity solutions for software development, or contact our sales team to learn how NordLayer can secure your operations.