There’s a shift in the world of DevOps. It is no longer enough to create applications and just launch them into the cloud. In a world where entire businesses can exist online, securing your digital assets is as important as creating them.
This is where DevSecOps comes in. It is the natural progression of DevOps — with security being a focus as much as the process of creating and launching applications. DevSecOps is a methodology that involves integrating security into the application development life cycle. The pipeline is created with security practices pre-baked into the build, test, and deployment processes.
However, there’s more to DevSecOps than just implementing security into the software and infrastructure. DevSecOps requires a pivot in the way we think about security and incorporate it into all layers of the software development process. This includes designing software with security in mind rather than a last port of thought.
Zero Trust has long become a buzzword in the security ecosystem, but it’s actually a practice that is still very relevant. The phrase was first coined by John Kindervag of Forrester in 2010, and is a strategy of never implicitly trusting anything inside or outside our digital ecosystem. Rather than trusting a source-based automatically, just because it’s inside our network, the Zero Trust model of thinking shifts to never trusting a source, and always verifying and authenticating.
The idea of Zero Trust can be applied to all the different layers required by a functioning app — from data packets to user experience implementations. When it comes to creating a secure environment, some sort of verification is needed in order to identify and decide if access should be granted. In the purest digital environment, the identification process is straightforward. The secret keys and credentials are given to the required platforms and accessibility is given if it is valid.
However, it’s important to remember that trust is human-driven. By nature, we are prone to errors. In addition to this, credentials can be misplaced and stolen, and networks can be hacked. There is no way of knowing for certain that the asserted identity is true.
DevOps is a merge of roles that requires a developer to think in a multifaceted manner. They are no longer confined to just being a ‘developer’, but a cross-functional and cross-sectional team member that understands the needs of the different layers.
DevSecOps adds the security dimension and emphasizes its importance throughout development. In this context, Zero Trust goes beyond just enforcing a different method of verification for users — it is a process of creating applications, environments, and infrastructure that consistently enforce a level of distrust on anyone and anything that tries to gain access.
Here is a rundown of the five pillars that makes up a Zero Trust application and infrastructure.
It’s one thing to verify a user and allow them access, it’s another when access is granted to foreign devices that are anomalies to the norm. For a Zero Trust environment, identifying verification by itself is not enough. Having a list of valid devices increases the layer of security through enforced distrust. This means that a user may need extra verification and confirmation before they are granted access based on the device trying to access the data.
Password-based authentication is inefficient and ineffective. Conditional access such as password-less authentication through biometrics, facial recognition and certificates, multi-factor authentication, and conditional-access policies are better alternatives to your usual username and password combination. This is because devices and client-side browsers are offering authentication management systems. This third-party involvement puts the user’s data at risk because it is out of the application’s control. We have no method of knowing who or how secure this third party is. If the client or device has a vulnerability that gets exposed, our apps become victims of a security breach that is not directly caused by us. The security risk further increases if a user repeats the same credentials across different apps and sites.
In a Zero Trust environment, a verified user should have access to the least-privilege data — and nothing else. This means that the user should only have access to the resources needed to perform the task. The best practice is to limit access to resources and grant the minimum permissions required to function. This is often implemented through micro-segmentation of accessibility.
When we assume that everyone who wants access is malicious, creating a trusted environment that consistently verifies and monitors access is a way to enforce zero trust.
Zero Trust implementation on applications requires combining device and user trust. For example, access to the business’ digital workspace can be secured with Zero Trust by ensuring that the user accessing it is doing so from a trusted device, verified MFA, and from a trusted location.
Data is one of the main reasons we need security in DevOps. To protect our applications and database from breaches, leaks, and potentially modified data, zero trust involves implementing technologies such as data loss prevention (DLP).
Security is important now more than ever. With DevSecOps, security integrates with development, putting the need for its considerations and implementation before we launch applications into the cloud with Ops. The five pillars of Zero Trust compartmentalize the different layers of building and running an application, but due to the scope of the topic, it is only a brief introduction. They should be used at a starting point towards creating awareness of what Zero Trust looks like for each of the layers. The next step is to explore the different segments of the Zero Trust pillars and implement their various identity verification processes.