Secure Coding Practices Every Dev Should Pick Up

Dec 11, 2021

4 Min Read

Focus on Input Validation

Whether you’re creating a website or a phone app, your data can have many sources. Unfortunately, you can never know what data source a hacker is going to use. So make sure to validate data from all possible data sources.

Possible data sources include network interfaces, files controlled by the user, command-line arguments, and any other source from which your data may be coming from. This will protect you from all untrusted data sources that may try to do any harm.

Pay Attention to Compiler Warnings

When it comes to securing code, compiler warnings are your best friend. Use the compiler with the highest warning and sensitivity level available. The compiler will inform you of all kinds of bugs and vulnerabilities in your code.

You can’t fix what you don’t know is broken. The compiler highlights the broken parts of your code so that you can see your mistakes and rectify them. You can also use static and dynamic analysis tools to fortify your code from future security issues further.

Design with Security Policies in Mind

Before you even move into the coding stage, you should give some ample to your software’s design.

The architecture of your software should include all the necessary security policies you plan on implementing. This will help give your software a better structure and make it simpler to implement security.

For example, if you create a system that provides different access levels to other people, maybe you should design a system divided into separate parts depending on the level of access allowed.

Keep Things Simple

While we’re on the topic of design, you should remember one very important thing that makes a design good. Your design should be as simple as possible.

Complex systems are harder to implement and secure because of residual bugs and errors caused by incorrect or incomplete implementation.

Deny First, Judge Second

When you’re designing software, deny all access requests by default. That means that no one should have direct access to the software. So first, they’re kept outside the barrier. And then, the security protocol determines whether access is allowed or not.

Follow the Principle of Least Privilege

The principle of least privilege says that each process of your system should only get the smallest number of privileges required to complete a task. Higher privileges should only be allowed to a process with a task that is essential to be completed in a short time.

Since your processes will rarely have elevated privileges, attackers will have way fewer chances to try and run some malicious code with increased privileges. Checkmate.

Check and Refine the Data Sent to Subsystems

Data isn’t idle. It is passed from one component to another in a system. When a component is passing data to a complex subsystem such as a database, command shell, or COTS (Commercial Off-the-Shelf) components, it is the responsibility of the sending system to clean the data being passed forward.

Most subsystems don’t have a clue what context they’ll be used in. So, it becomes the responsibility of the sending system to make sure data is clean of malicious code, commands, or anything that can invoke an injection attack. This is a separate scenario from input validation, as the receiving system has no context clues to work with.

Reinforce Defense at Every Level

Don’t rely on just one level of security to keep all attacks at bay. Instead, implement security at every layer so that if one point of defense fails, another can prevent exploiting a vulnerability or security flaw in your system.

For instance, you can combine practices for secure programming with secure runtime environments. This will fortify your system and reduce the chances of a flaw being exploited for malicious purposes.

Use Quality Assurance Techniques for Maximum Benefit

Whether you like it or not, quality assurance is an important part of your SDLC. Utilize the available QA techniques for maximum refinement of your system.

Techniques like source code audits, penetration testing, and fuzz testing can point out technical flaws that might have been missed before. External security reviews can also identify problem areas based on incorrect assumptions and improve system security.

Employ a Coding Standard

When creating a system, it is best to use a customized or existing secure coding standard. You can implement one that best suits your development language or platform. But employ one nonetheless because it will create consistent and secure code.

Identify Security Requirements Beforehand

The first part of the development of any software system should be requirement elicitation and documentation. A developed system and its security cannot be evaluated if there is no base set for requirements.

So, save yourself the headache. Figure out the requirements and base all of your subsequent designs on these requirements.

Use Threat Modelling

Threat modeling is nothing but anticipation of all possible threats that your system might face. You identify the most important components, find ways to break them, categorize and rate the potential vulnerabilities in it. Afterward, you figure out ways to protect your system from these vulnerabilities and implement your solution in your system design, code, and test cases.


Stay Connected with the Latest