Should Sensitive Systems Be Open Source ?
Tags: discuss, opensource, security, softwareengineering
Published: 2024-01-22 13:16:05


![Being open source means anyone can independently review the code. If it was closed source, nobody could verify the security. I think it’s essential for a program of this nature to be open source.](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/p5tpev98h2qk7hu9ptda.jpg)

The other day, I was talking to a friend who's studying computer engineering. We were discussing my open-source project, a small online tool that helps people encrypt their data. During our conversation, my friend dropped a bombshell: **"Your app shouldn't be open source."** He argued that because my web app's source code is public, anyone can examine it, find weak points, and potentially break into the encryption system.

This led to a lively debate. I'm a big fan of open-source software and had lots to say in its defense. But my friend's comment got me thinking, and I decided to dig deeper into the topic.

In this article, I'll explore whether sharing my encryption app's code with the public is a risk. I'll also look at the bigger question of whether it's better for sensitive systems like encryption apps to be open for everyone to see or kept private. 

{%- # TOC start (generated with https://github.com/derlin/bitdowntoc) -%}

- [Closed Source for Sensitive Software ](#closed-source-for-sensitive-software)
- [Why Hiding system design Isn't a Reliable Security Strategy](#why-hiding-system-design-isnt-a-reliable-security-strategy)
- [Should Sensitive Systems Be Open Source ?](#should-sensitive-systems-be-open-source-)
- [Defense in Depth principle](#defense-in-depth-principle)
   * [So how can I apply Defense in Depth approach in open-source model ?](#so-how-can-i-apply-defense-in-depth-approach-in-opensource-model-)
- [Conclusion](#conclusion)

{%- # TOC end -%}


## Closed Source for Sensitive Software 
The term is self-explanatory, but let's look at its definition:

Closed source refers to a type of software whose source code is **not made available to the public or users**. In closed-source software, users are not allowed to copy, delete, or modify parts of the source code.

Of course, Closed-source software comes with several advantages, particularly when dealing with sensitive applications:

- **Enhanced Security:** Closed-source software provides an extra layer of security by keeping the source code confidential, making it much harder for attackers **to find weaknesses.**

- **Control:** With closed source, you get to decide who can use your software. This helps keep it away from unauthorized users and protects sensitive data.

- **Quick Issue Fixes:** If a problem is found in your software, you can fix it quickly.

- **Focused Development:** Without constant public feedback, developers can focus on building a strong and secure foundation for your software.

But, even with these advantages of closed source, it's good to question whether relying solely on the secrecy of system design is a reliable security strategy, posing the question of:

## Why Hiding system design Isn't a Reliable Security Strategy

Imagine you have a secret, like a special hiding place for your favorite toy. You don't tell anyone about it, and you hope that because it's a secret, nobody will find your toy.

Now, the problem with this approach is that if someone accidentally stumbles upon your hiding place or figures out your secret, they can easily take your toy. So, it's not a reliable way to keep things safe.

So, when a system relies on secrecy rather than the **strength of its security measures**, it hides vulnerabilities and weaknesses from detection. This lack of transparency means that issues may remain undiscovered until **a breach occurs.**

A determined attacker (like me, lol) can go to great lengths to discover hidden secrets. Just like someone might search diligently for your hidden toy, hackers can use various techniques to uncover hidden system details. Once they do, **the security crumbles.**

So, to sum it up, security through obscurity is discouraged because it relies on secrecy alone, **which can be easily breached if discovered.**

So, does this mean

## Should Sensitive Systems Be Open Source ?

![one_does_not_simply_open_source](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/t16l1vx1k28q253ou9xm.jpg)

This is a complex question, and there isn't a simple answer. However, I've done my best to provide a thoughtful response.

Let's begin by briefly compare the advantages and disadvantages of open-sourcing sensitive systems, starting with the advantages:

- **Community Auditing:** With an open-source approach, the global community of a diverse range of developers and security professionals can actively review and audit the code and that will result in a **more robust and secure system.**

- **Faster Issue Resolution:** In an open-source model, if a vulnerability is discovered, it can be addressed quickly by the community.

- **Transparency:** Open-source software allows users to see how the software works, which can build trust and confidence in its functionality.

Unfortunately, there are disadvantages, with one of the biggest being:


- **Target for Attackers:** Exposing the source code of sensitive software can make it easier for attackers to exploit vulnerabilities. and so It requires a proactive and vigilant community to stay ahead of potential threats.

- **Potential Misuse:** Open-sourcing sensitive software, like encryption apps,exposes the code to **potential misuse by attackers.**

- **Maintenance challenges:** Maintaining a large open source project can be challenging, as it requires coordinating the work of a diverse group of developers, ensuring continuous updates, responding to issues, and managing the community involvement can be resource-intensive.
This can be particularly difficult for sensitive software, where security and reliability are paramount.

So, we understand that open-sourcing software can be both an **advantage** and **disadvantage** for security. Therefore, there is **no direct answer**. 

If you have a sensitive software and are unsure whether to open source it, consider factors like **the level of community support available**, **the maturity of the software** (is the software still under development or stable?), and **the capabilities of the development team**. Think carefully before making your decision.

Wait, the article isn't finished yet! 😃

![open_source_all_the_things](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/awexip8036xb4gpfw58w.jpg)

Because, as an open-source lover and advocate, I encourage open sourcing, introducing:

## Defense in Depth principle

![defense_in_depth](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/qu777tnre9x2ylaz3c84.png)

The Defense in Depth principle is a cybersecurity strategy that involves **implementing multiple layers of security measures to protect a system**, rather than relying on a single security measure, multiple layers are implemented to create a more resilient defense against potential threats.
These layers include **technology**, **procedures**, and **people**. The goal is to **prevent**, **detect**, and **mitigate** attacks at different layers of the system.

### So how can I apply Defense in Depth approach in open-source model ?

We can define the layers of an open-source software as the Community Layer, Operational or Procedural Layer, and the Code Layer.

1- **Community Layer**
As mentioned earlier, the community can conduct **code reviews** and **security audits** to identify potential issues and improve overall security. 
So encourage your community members **to prioritize writing secure code** and actively report any vulnerabilities they discover.
2- **Operational Layer:**
Simply by conducting regular security audits and to use automated tools like static code analyzers and dependency scanners to catch common vulnerabilities early in the development process, reducing the risk of exploitation.
3- **Code Layer:**
Learn how to write **secure code** by applying Secure Coding Practices like input validation, error handling and logging, encrypting sensitive data, and much more.

Another crucial aspect: In case of an attack, develop an **Incident Response Plan** where you define the steps to take in the event of a security incident to mitigate potential damage.

By applying these measures, you can confidently open source your software and enjoy the benefits of community collaboration, security, rapid development, learning, and skill development, and much more.

## Conclusion
The article may seem simple to write, but trust me, it was a bit challenging due to the complexity of the topic. The decision to open source a project involves **careful consideration**. However, you can always embrace **the Defense in Depth strategy** for securing sensitive systems when opting for open source.

Thank you for investing your precious time in reading my article. I truly appreciate your engagement, whether through questions, critiques, or sharing your opinions and ideas in the comments. I look forward to hearing your perspectives below. Happy coding and securing! 😊