Modern application development rarely happens in a single environment. Software typically moves through multiple stages, from development and testing to acceptance and production. At every stage, code can be modified, intentionally or unintentionally.
This creates a significant security challenge. Developer workstations have become a critical target for cybercriminals. Instead of purely targeting finished products, we now see an increase in the exploitation of local development environments and CI/CD pipelines (an automated set of steps and tools that lets software teams build, test, and release code changes quickly and safely). The attack surface shifts towards compromising software supply chains before applications ever reach production.
As a result, organizations must be able to verify not only who created their software. But also, that it remained unchanged throughout the entire development lifecycle.
Most organizations invest heavily in securing their infrastructure, networks, and endpoints. Yet the integrity of the code itself is often overlooked.
This is where code signing comes into play as an essential cybersecurity control.
What is code signing?
Code signing is the process of digitally signing software, scripts, executables, and other code using cryptographic certificates.
This provides two important assurances to check the code’s integrity:
We can verify the identity of the software publisher.
We can verify that the code has not been altered since it was signed.
When code is signed, a unique digital fingerprint, known as a hash, is created. Even the smallest change to the code results in a completely different hash value.
That hash is then secured using a code signing certificate, which contains the publisher’s identity and cryptographic keys. The certificate effectively links the software to a trusted source and proves that the generated hash is authentic.
When the software is executed, the operating system recalculates the hash and compares it with the signed version. If they match, the code is considered unchanged. If they don’t, the software has been modified after signing and can no longer be trusted.
In simple terms, code signing acts as a tamper-proof seal for software throughout the software development lifecycle.
Protecting the software supply chain
In most organizations, software does not move directly from a developer’s workstation to production. It passes through multiple environments, such as development, testing, acceptance, and production, often involving various teams, systems, and automated deployment pipelines along the way.
Every handoff introduces risk. Whether through a compromised developer workstation, a vulnerable build server, or unauthorized access to a deployment pipeline, attackers are constantly looking for opportunities to insert malicious code into an otherwise trusted application.
Without proper controls, those modifications may remain undetected until the software is already running in production.
In an era where software supply chain attacks continue to increase, this verification has become a critical security requirement rather than a nice-to-have capability.
Managing trust requires more than signing code
Code signing is only as strong as the protection of the certificates and private keys behind it. If attackers gain access to a signing key, they can potentially make malicious software appear legitimate.
The challenge is that managing code signing certificates manually quickly becomes complex. Organizations need to track certificate renewals, monitor expirations, control access to signing keys, and maintain auditability for compliance purposes. As development teams and application portfolios grow, these tasks become increasingly difficult to manage consistently.
This is where centralized certificate lifecycle management becomes essential. By managing code signing, Â organizations gain greater visibility and stronger governance.
Modern code signing solutions, such as ours, also support timestamping, ensuring software remains trusted even after the original signing certificate has expired.
As certificate lifecycles continue to shorten, a trend we discussed in our article 47-Day Certificates Will Challenge Every Business, centralized management is becoming a business necessity rather than an operational convenience.
One platform for certificates, code signing and SSH Keys
Many organizations already use Palo Alto Networks’ Certificate Manager to manage TLS certificates. Extending the same platform to support code signing and SSH key management is a natural next step.
Although code signing certificates and SSH keys serve different purposes, both are machine identities that establish trust between systems. Yet machine identities often receive far less governance than human identities, creating unnecessary security risks.
Unmanaged machine credentials can quickly become security blind spots. Managing certificates, code signing keys, and SSH keys through a single platform improves visibility, simplifies governance, and strengthens overall security.
For organizations already using Palo Alto Networks’ Certificate Manager, adding code signing and SSH key management is a straightforward way to increase protection against software supply chain attacks while maximizing the value of their existing investment.
The logical next step
As attackers increasingly target development environments and software supply chains, organizations need stronger controls to protect the integrity of their applications.
Code signing is a logical next step that helps ensure the software reaching production is exactly the software that was intended to be delivered. It provides that assurance. Combined with centralized certificate lifecycle management and SSH key governance, it proves an effective and low-friction way to broaden your machine identity security.
