Secure software delivery is a continuous operational process—not a one-time certification.

Your development team completes an application. The unit tests pass. Quality Assurance approves the release. SonarQube reports no blocking issues. Dependency scanning identifies no unacceptable vulnerabilities.
The application successfully passes its security reviews and goes into production.
Congratulations. You’ve delivered what appears to be a secure enterprise application.
But here’s a question.
Is that application still secure tomorrow? Next week? Six months from now?
Nothing needs to change in your source code for your security posture to change.
A new vulnerability may be discovered in your application framework. A trusted software dependency may be compromised. An attacker may acquire credentials used by your build pipeline. A previously unknown weakness may become practical to exploit.
The application that passed every security check yesterday may require urgent attention today.
Recent cybersecurity incidents involving PHP and LiteLLM demonstrate two different ways this can happen.
For CIOs, CTOs, engineering directors, and development managers, the lesson is important:
Application security does not end when software is deployed.
It must remain an active part of the software engineering and operational lifecycle.
1. Security Approval Is a Point-in-Time Assessment
Traditional enterprise application development has made substantial progress in software security.
Modern development organizations use automated testing, static code analysis, software composition analysis, dependency scanning, secret detection, and controlled deployment pipelines.
Platforms such as GitHub Actions and Azure DevOps integrate many of these capabilities into established development workflows.
These controls are valuable.
They identify weaknesses before software reaches production and allow teams to enforce consistent security requirements without manually reviewing every change.
But there’s an important distinction between passing a security assessment and remaining secure.
A successful scan means the application satisfied the checks performed using the tools, configurations, and vulnerability intelligence available at that time.
It does not establish that every vulnerability has been discovered.
Nor does it guarantee that the software dependencies, runtime environment, credentials, and supporting infrastructure will remain trustworthy.
Security is not a permanent property established by an approval certificate.
It’s a condition that must be continuously reassessed as the application and its operating environment change.
Two incidents from October 2026 illustrate why.
2. The PHP Vulnerabilities: Your Code Didn’t Change, but Your Risk Did
On October 21, 2026, the PHP development team released emergency security updates addressing two critical vulnerabilities:
- CVE-2026-109618: Remote-code-execution risk involving out-of-memory handling and corrupted internal request state.
- CVE-2026-109619: Remote-code-execution risk involving stale internal state and previously freed memory.
Both vulnerabilities received CVSS 4.0 severity scores of 9.2.
The PHP team released corrected versions 8.2.35, 8.3.36, 8.4.27, and 8.5.12, warning that there were no complete mitigations and that upgrading was necessary.
Source: PHP Security Advisory, October 21, 2026
These vulnerabilities affected the PHP runtime itself.
That distinction matters.
An enterprise application might have perfectly valid business logic, properly implemented authentication, comprehensive automated tests, and no previously identified application-level vulnerabilities.
Yet a critical defect in the underlying runtime could expose the application to attack.
The application’s source code hasn’t changed.
Its security exposure has.
The vulnerability did not mean every PHP deployment was compromised or equally exploitable. Actual exposure depended on the environment, and the PHP team identified Apache mod_php as particularly concerning.
But organizations still needed to identify affected systems, apply the appropriate updates, and verify that the patched runtime was actually deployed.
This is why application inventories must include more than application names.
Enterprises need visibility into the runtimes, frameworks, dependencies, containers, and infrastructure supporting their production applications.
Otherwise, a newly announced vulnerability creates an immediate operational question:
Which of our applications are affected, and how quickly can we secure them?
If answering that question requires several days of investigation, the organization has a serious vulnerability-management problem.
AI Is Changing Vulnerability Discovery
The PHP incident also illustrates another important development.
OpenAI reported that researchers using GPT-5.6 Sol helped identify one of the flaws, while Wiz independently discovered and reported both vulnerabilities.
Researchers, PHP maintainers, infrastructure providers, and government partners coordinated remediation before public disclosure.
Source: OpenAI — Patch the Planet
This was a defensive use of AI.
But similar capabilities can potentially help attackers discover vulnerabilities and develop exploits.
That doesn’t mean every vulnerability will immediately become exploitable.
It means organizations should reconsider whether traditional vulnerability assessment and remediation schedules are sufficiently responsive.
When vulnerability discovery accelerates, the engineering organization must be prepared to accelerate its response.
3. The LiteLLM Compromise: When Trusted Software Becomes the Threat
The second incident demonstrates a different problem.
On October 21, 2026, LiteLLM published a compromised release, version 1.107.0, through official software distribution channels.
LiteLLM is commonly used as an AI gateway, providing applications with a common interface to multiple AI model providers.
Depending on its deployment, an AI gateway may possess model-provider credentials, database connections, workload identities, and other sensitive configuration information.
That makes it an attractive target.
The compromised LiteLLM release contained malicious components designed to collect credentials and other sensitive information.
According to Microsoft’s analysis, the malware used Python startup mechanisms that could execute without an application explicitly importing LiteLLM.
Simply starting Python inside an affected environment could trigger the malicious code.
Source: Microsoft Security — LiteLLM Supply-Chain Compromise
The compromised PyPI release was available for approximately two hours. Affected container images were also distributed.
LiteLLM reported that its separate private enterprise registry was not affected. The full extent of downstream compromise was not established by the initial investigation.
Nevertheless, the architectural implications are significant.
Organizations might have downloaded software from an official repository, used an approved package-management process, and deployed an artifact from a trusted distribution channel.
Yet the software itself contained malware.
How Did the Attackers Compromise the Release?
LiteLLM’s published root-cause analysis describes a chain of security failures.
A master key associated with an experimental agent platform had accidentally been committed to a public repository months earlier.
The exposure was recognized, but the key was not revoked.
The attacker subsequently used that credential to access the agent platform and obtain an overprivileged GitHub authentication token associated with an organization owner.
That access enabled further credential theft and manipulation of release infrastructure.
The attacker redirected the release process toward a malicious repository, then used compromised credentials to trigger and approve publication.
The normal release process produced and distributed the compromised artifacts.
Source: LiteLLM — October 21 Release Compromise: Root-Cause Analysis
This wasn’t simply a malicious developer submitting a suspicious code change.
It involved failures across credential management, privileged identity, source control, approval controls, and build infrastructure.
The investigation does not establish that an autonomous AI agent carried out the attack. Rather, an inadequately secured agent platform formed part of the credential-compromise chain.
The application development and release infrastructure became part of the attack surface.
4. The Software Was Signed. It Was Still Malware.
One particularly important detail deserves attention.
The compromised LiteLLM artifacts were produced through the project’s legitimate release infrastructure.
That demonstrates a limitation of relying exclusively on code signing.
A digital signature can help establish the identity associated with an artifact and verify that the artifact hasn’t been modified since signing.
It does not necessarily establish that the artifact contains the intended source code.
If attackers compromise the build pipeline, redirect its source inputs, or obtain signing authority, the resulting malicious artifact may still be legitimately signed.
The signature isn’t necessarily defective.
The trust placed in the build process is.
This is why software supply-chain security must extend beyond signing release packages.
Organizations should establish verifiable build provenance, connecting each deployed artifact to its expected repository, source revision, build workflow, and trusted builder.
Frameworks such as SLSA provide guidance for strengthening build integrity and provenance.
GitHub also supports artifact attestations to help establish where and how software was built.
But provenance verification must compare the evidence against trusted expectations.
A perfectly valid attestation documenting an attacker-controlled source repository is not proof that the artifact is safe.
The question isn’t merely whether software was signed. It’s whether the correct software was built through an authorized, trustworthy process.
5. DevSecOps Tools Are Essential, but They Have Different Responsibilities
This is where mature DevSecOps practices become increasingly important.
Tools such as Snyk, SonarQube, GitHub security features, and Microsoft Defender can contribute different capabilities to an enterprise application security program.
But they are not interchangeable, and no single tool provides comprehensive protection.
Consider several categories of controls.
Static Application Security Testing (SAST) examines source code or related program representations for potentially insecure coding patterns.
Software Composition Analysis (SCA) identifies third-party components and known vulnerabilities associated with them.
Secret scanning helps detect exposed credentials, tokens, and other sensitive values.
Infrastructure as Code scanning examines cloud and deployment definitions for insecure configurations.
Dynamic Application Security Testing (DAST) evaluates running applications for certain observable vulnerabilities.
Artifact provenance verification helps establish whether software was produced through an expected build process.
Runtime monitoring and threat detection help identify suspicious behavior after deployment.
Each addresses a different portion of the problem.
For example, a source-code scanner may detect an unsafe SQL query in a C# application.
A dependency scanner may identify a vulnerable NuGet package.
A provenance check may identify an artifact built from an unexpected repository.
Runtime monitoring may detect suspicious credential access or unexpected outbound connections.
These controls complement one another.
The OWASP DevSecOps Guideline explicitly recognizes multiple security-testing and supply-chain controls as parts of a broader engineering process.
Passing one category of security testing does not imply that the others are unnecessary.
And passing all available automated checks still doesn’t guarantee the absence of vulnerabilities.
6. Continuous Vulnerability Management Must Continue After Deployment
A mature security pipeline should evaluate software before release.
But enterprises also need systems that continuously reassess software already running in production.
One useful mechanism is a Software Bill of Materials, or SBOM.
An SBOM identifies software components and dependencies associated with an application or artifact.
When a new vulnerability is disclosed, organizations can compare the affected component against their application inventory.
But an SBOM is only useful when it is accurate, maintained, and connected to deployed assets.
A bill of materials created during development doesn’t necessarily describe what is currently running in production.
Organizations need to connect component inventories to application owners, deployed versions, runtime environments, and business criticality.
A practical continuous assessment process should:
- Maintain inventories of production applications and their dependencies.
- Monitor authoritative vulnerability intelligence and vendor advisories.
- Reassess deployed software when new vulnerabilities are disclosed.
- Determine actual exposure and potential business impact.
- Assign remediation work to accountable engineering teams.
- Verify that updates or compensating controls have been deployed.
- Continue monitoring for exploitation or recurrence.
Tools such as OWASP Dependency-Track illustrate how SBOM inventories can be continuously reanalyzed against changing vulnerability intelligence.
The important distinction is between scanning software during a build and maintaining awareness of the security posture of software already in production.
Enterprises need both.
7. Not Every Vulnerability Deserves an Emergency Deployment
Continuous vulnerability management doesn’t mean stopping development every time a scanner reports a finding.
Security teams need to prioritize.
A critical vulnerability actively exploited against an internet-facing production system may require immediate intervention.
A lower-severity vulnerability in an unreachable development-only dependency may be addressed through normal maintenance.
The difference depends on several factors:
- Whether exploitation is occurring or considered likely.
- Whether the vulnerable component is reachable in the deployed environment.
- What privileges or data an attacker could obtain.
- The business importance of the affected system.
- Whether effective compensating controls exist.
CISA’s Known Exploited Vulnerabilities catalog provides evidence of vulnerabilities exploited in the wild.
The Exploit Prediction Scoring System provides additional probability estimates, although those estimates do not replace environment-specific risk assessment.
The objective is to make defensible remediation decisions based on evidence.
Prioritize vulnerabilities according to actual risk, not simply the number of findings in a scanner report.
And when a serious exposure threatens the enterprise, cybersecurity leadership should have the authority to require remediation ahead of discretionary feature development.
8. Secure the CI/CD Pipeline Itself
The LiteLLM incident also demonstrates why development infrastructure deserves careful security engineering.
CI/CD pipelines frequently possess powerful credentials.
They may access source repositories, package registries, cloud environments, deployment systems, and production configuration.
In some environments, compromising the release pipeline can be more damaging than compromising an individual application server.
I would recommend several controls for enterprise development organizations.
Use dedicated, narrowly scoped identities
Avoid using personal administrator credentials for routine build and deployment automation.
Prefer short-lived, workload-specific credentials and federation where supported.
Protect source-control administration
Restrict who can change repository protections, deployment workflows, release branches, and security policies.
Require independently enforced approvals for high-impact changes.
Isolate build environments
Use appropriately hardened and isolated build workers. Avoid allowing untrusted build activity to inherit credentials or persistent access from unrelated workloads.
Verify software artifacts
Tie releases to expected source revisions and verified build provenance.
Pin dependency versions and container images to reviewed versions or immutable digests where practical.
Restrict release authority
Separate the ability to modify software from the authority to approve and publish production releases.
Protect emergency override mechanisms against unauthorized use.
Monitor privileged activity
Alert on unexpected changes to release workflows, repository permissions, deployment credentials, artifact destinations, and signing infrastructure.
These measures do not make compromise impossible.
They reduce the opportunities for attackers to convert one compromised credential into control of the entire software delivery process.
9. Emergency Remediation Must Be Part of the Engineering Lifecycle
One weakness in many enterprise development processes is that routine releases are well defined, while emergency security remediation is improvised.
Normal release management may include planning cycles, approval meetings, regression testing, deployment windows, and documentation.
Those processes serve important purposes.
But a serious production vulnerability may require action before the next scheduled release.
Organizations need an established emergency remediation process.
That process should identify who can declare an emergency, which teams respond, how changes are authorized, what minimum validation is required, and how successful remediation is verified.
It should also address rollback, recovery, communications, and subsequent investigation.
A compromised dependency requires particular care.
Simply installing a clean package may not remove malware that already executed.
In the LiteLLM incident, Microsoft advised investigating affected environments from trusted systems, rebuilding from verified artifacts, and rotating credentials that the malicious software could have accessed.
That is fundamentally different from updating a normal vulnerable library.
The organization must determine not just whether the software is now patched, but whether the environment can still be trusted.
Emergency remediation is an operational capability that should be designed and rehearsed before an incident occurs.
10. What CTOs and Engineering Directors Should Measure
Enterprise security programs frequently report the number of vulnerabilities discovered.
That’s useful, but incomplete.
I’d be more interested in whether the engineering organization can identify, prioritize, and remediate meaningful security risks quickly.
Consider measuring:
- Time from vulnerability disclosure to identification of affected production systems.
- Time from confirmed exposure to effective remediation.
- Percentage of production applications with current dependency inventories.
- Percentage of release artifacts with verified provenance.
- Number of privileged build and deployment identities using long-lived credentials.
- Percentage of critical security findings resolved within defined risk-based deadlines.
- Success rates for emergency deployment, rollback, and credential-revocation exercises.
These measurements evaluate operational capabilities rather than simply counting scanner findings.
They also help CIOs and CTOs identify where additional automation, engineering investment, or security support is necessary.
A development organization that discovers fewer issues isn’t automatically more secure.
It might simply be looking less effectively.
What matters is the organization’s ability to detect and manage real exposure.
11. Security Is Part of Software Engineering, Not an External Approval Process
The larger lesson extends beyond PHP and LiteLLM.
Secure software development depends on architecture, implementation, verification, deployment, operations, and continuous improvement.
Security teams cannot accomplish this alone.
Developers must implement secure capabilities. Architects must establish appropriate trust boundaries. Platform teams must protect build and deployment infrastructure. Operations teams must maintain visibility into running systems.
And business leadership must provide the priorities, resources, and authority necessary to address serious risks.
The NIST Secure Software Development Framework reflects this lifecycle approach, including practices for protecting software, producing secure releases, and responding to vulnerabilities after release.
For organizations adopting AI, the stakes increase further.
AI gateways, model integrations, coding agents, and autonomous applications introduce additional dependencies and privileged execution paths.
They require the same engineering discipline as conventional enterprise applications, plus controls appropriate to their particular authority and behavior.
The answer isn’t to stop software development.
It’s to establish secure delivery and continuous security reassessment as normal engineering operations.
Conclusion: Secure Yesterday Doesn’t Mean Secure Tomorrow
The PHP vulnerabilities and LiteLLM compromise illustrate two different but related enterprise security problems.
In one case, serious vulnerabilities were discovered in software already deployed throughout the industry.
In the other, attackers compromised trusted development infrastructure and distributed malicious software through official release channels.
Neither incident means modern DevSecOps practices are ineffective.
Quite the opposite.
They demonstrate why mature security engineering, automated assessment, software supply-chain controls, and emergency remediation capabilities are essential.
Enterprises should continue delivering valuable software through established, well-governed CI/CD pipelines.
But security assessments must not stop when an application reaches production.
A successful deployment isn’t the end of the security lifecycle. It’s the beginning of the operational security lifecycle.
For CIOs, CTOs, and engineering leaders, the question shouldn’t simply be whether an application passed its last security review.
It should be whether the organization can recognize when that application’s security posture changes—and respond before the exposure becomes a business incident.
Because your application may have been secure yesterday.
That doesn’t guarantee it’s secure today.
Continue Exploring Enterprise AI Engineering and Security
This article is part of AInDotNet’s Enterprise AI Security Special Series, examining how enterprise organizations can strengthen cybersecurity while continuing to develop and deploy valuable business applications.
Explore these related AInDotNet frameworks:
- AI Engineering Discipline and Delivery Lifecycle — Production readiness, validation, release controls, continuous evaluation, and operational engineering.
- Enterprise AI Governance, Risk and Security — Security authority, accountability, identity, enterprise risk, and enforceable governance.
- Enterprise AI Architecture — Building enterprise AI systems around bounded capabilities, explicit interfaces, and controlled execution.
AInDotNet — Practical Enterprise AI Architecture, Engineering, and Governance.
Frequently Asked Questions
Can an application become vulnerable without any code changes?
Yes. New vulnerabilities may be discovered in existing frameworks, runtimes, and dependencies. Changes in external exposure, configurations, or attacker capabilities can also alter an application’s security risk even when its source code remains unchanged.
What is the difference between DevSecOps and a security review?
A security review evaluates specified risks or controls at a particular point in time. DevSecOps integrates security activities throughout development, deployment, and operations, including automated testing, continuous vulnerability assessment, and remediation.
Does code signing guarantee that software is safe?
No. Code signing helps establish artifact integrity and signing identity. It does not guarantee that the source code, build pipeline, or signing credentials were uncompromised. Verified provenance and trusted build infrastructure provide additional assurance.
Should critical security vulnerabilities delay feature development?
When a serious, exploitable vulnerability creates unacceptable business risk, remediation should take priority over discretionary features. Lower-risk findings can generally follow established remediation schedules. Decisions should reflect exposure, exploitation evidence, potential impact, and enterprise risk policy.
