Our expertise
Our services
Who we serve
Insights
About us
Insights Resource library Careers Let's talk

Beyond patching: How do we stay protected between updates?

PHP2Shell has reminded us that patching is essential, but reactive. Until a fix is deployed, you’re exposed. Here’s how access control and segregation keeps you protected between updates.

Barry Sadler, Head of Penetration Testing's photo
Barry Sadler, Head of Penetration Testing
Bridge

The recent critical PHP vulnerabilities (PHP2Shell) disclosed in October 2026 have reignited conversations around the importance of patching and dependency management.  

While the PHP vulnerability itself led to a lot of discussions around patching it and the severity of it, the discussions themselves are what intrigued me more than the vulnerability itself.  

When vulnerabilities like these are released, many teams are sent into firefighting mode where they focus on fixing the problem, fast, and without breaking other things. 

Due to the speed of response needed, these conversations typically lack discussions on proactive, strategic measures. Patching is reactionary by nature, but until that patch is released, the vulnerabilities that exist (disclosed or not) still exist. 

So, what can we do about it?

Accept the limitations in patching

Patching is a reactive measure to an existing vulnerability; it doesn’t protect against unknown vulnerabilities. When patching is your main control, every new CVE turns into a scramble and, over time, that scramble starts to feel like normal security work. The real exposure is the gap between disclosure and deployment. If attackers exploit a flaw before you’ve patched it, and nothing else stands in their way, you’re exposed.

Patching should continue to be an essential, regular step in mitigating vulnerabilities, but wherever possible, it should not be used as your only line of defence.

Beyond patching, where do we begin?

Understand what you control

From a top-down view, we control the conditions within our perimeter. But that doesn’t mean everything is within our control. If we narrow the scope of this conversation to software, this becomes clearer.

Where third-party commercial software is used, the code itself is rarely accessible to us, so finding and fixing vulnerabilities within the code is beyond our control. The only related thing we can normally control here is the version of the software installed.

Beyond that, there are still surrounding elements that we can manage. These areas help us protect our business from unnecessary unpatched software vulnerabilities.  

Some questions you should know the answer to:

  • What third-party software do we use?
  • How can it be accessed?
  • What does the software/system have access to?
  • What functionality can be used?
Understand the software we use

Some software is built better than others. This can be in what it does, how it does it, ease of use and so on. But from a security perspective, we also need to think about areas such as:

  • Least privilege: Does the software request more privileges than is necessary for it to work?
  • Security tools: Do the security tool(s) we use cover the ground needed? Do they work with our policies and help enforce the relevant controls?
  • Future changes: If this software becomes unfit for use in the future, how disruptive would changing software be?
  • Redundant software: Is there software we have but no longer use and can remove?
  • Security testing: Does the third-party software undergo regular security testing? Do they use that information to prevent reoccurrences of similar vulnerabilities?  
How can it be accessed?

One key requirement for exploitation to be possible is for the attacker to have access. If we can prevent access, then new CVEs require less of an emergency response.

We also have the challenge of making sure that we have appropriate policies, with controls that work as expected and are enforced appropriately. If enforcement of controls is too stringent, it can become a new source of disruption to the business; however, if they are too lax, it could allow threat actors to harm the business.

Where access can be restricted, the questions that need be answered are:

  • Who actually needs access the software? How do we determine this?
  • How is that access controlled?
  • How long do people need access for?

For example, let's say you use an Employee HR portal—there would need to be access limitations for some employees. You could consider firewall rules or making it accessible to an internal network where access to that network is controlled.

By implementing these controls, it adds an additional layer of security. Attackers would first need to find a way to bypass the access control before then being able to identify, target and exploit vulnerable software in use.

Segregation

Preventing access to software is not always a viable solution, especially when remote, public access is the purpose. In practice, this could mean services (such as web applications) are hosted in separate environments to prevent disruption to the wider business if it was compromised.

For example, say you run a website designed to attract customers. The server behind it has no reason to reach your payment systems, finance platforms or internal databases, so it shouldn’t be able to. Where it does need to connect to something, such as passing enquiries to your CRM, that link should be narrow and tightly controlled.

So, if the website was disrupted due to an exploited vulnerability, segregation limits what attackers can do from that point of entry. It will still be disruptive to lead generation but creates a barrier that protects other areas of the business from disruption.

Limiting what is possible

A less common but useful area to be aware of is around controlling what is possible with the software itself. This can be in the form of:

  • Limiting what plugins or extra features are in use.
  • Restricting what users are able to do.
  • Turning off unnecessary features or functionality
  • Server-side hardening of the application's deployment.

An example of this would be a web application built using a Content Management System (CMS). These often allow users to install plugins, sometimes from third-party sources, but often the plugin hasn’t been security tested. There are valid use cases for plugins like this, but they also open up the risk of vulnerabilities being introduced into the environment.  

Many years ago, I was working on a penetration test for a popular CMS and a plugin related to file storage was in use, but was explicitly not in scope for testing. Not too long after the report was released, it turned out that the plugin would have allowed for attackers to get access to the underlying system itself by uploading malicious files to the server.

The plugin renamed a file to contain the ‘.php’ extension and attackers were able to upload a file to exploit that by running PHP code on the web application.

Getting started

With time being a valuable asset to us, how we use it to improve our security posture is important. The following are steps you can take to help reshape how you maintain control over your environment:

  • Understand your security perimeter, what you control and what you don’t.
  • Develop and review policies that clarify expected behaviours around security.
  • Implement and assess existing controls that enforce those policies. This could start with locally hosting the software then implementing network segmentation to protect areas with the highest potential for disruption in the business.  
  • Test your security controls actually work in practice.

If you need help with any of this, reach out to us today.