Backup encryption prevents data leaking from the repository or from transported media; when the key is lost, however, it turns the backup itself into rubbish. In a ransomware scenario things get harsher: the attacker doesn’t just try to delete backups, but also to change encryption settings in their own favor. This guide explains encryption points, key management models, key storage and escrow rules, and key recovery testing from the point of view of teams that run backup infrastructure.
The purpose and risks of backup encryption
A backup file is a copy of almost all the organization’s data gathered in one place. A domain controller’s ntds.dit file can be extracted from a virtual machine backup, personal data from a file server backup, customer records from a SQL backup. For an attacker, a backup is a target both to exfiltrate and to delete. Immutable storage protects against deletion, not against reading. Encryption closes this gap.
The risks encryption brings fall under three headings:
- Key loss: If the password is kept only on the backup server or in a domain-joined password vault, these sources can’t be used after an attack and the backups can’t be opened.
- The key being compromised together with the backup: If the key sits in the backup console’s database, on the same server or somewhere the same administrator account can reach, encryption doesn’t provide meaningful protection against leaks.
- The attacker weaponizing encryption: An attacker who takes over the console can change jobs’ encryption password to one they choose. This topic is covered separately below.
Encryption points: source, transit, repository
Backup data can be encrypted at three points, and each answers a different threat. Saying “our backups are encrypted” without knowing which layer protects what is misleading. It’s the sentence we hear most often in audits.
| Point | How it’s applied | What it protects against | What it doesn’t protect against |
|---|---|---|---|
| At the source (job level) | The backup software encrypts data before writing it to the repository | Reading of the repository, tape and cloud copy | A restore by an administrator who has taken over the console |
| In transit | TLS between components or network traffic encryption | Eavesdropping on the network | Access to data sitting in the repository |
| In the repository (data at rest) | Disk/array encryption, server-side encryption in object storage | Loss of a physical disk or device | Data read with authorized access to the repository |
Repository-level encryption (for example, server-side encryption in S3-compatible storage) is usually transparent: every process with authorized access to the repository reads the data as plain text. That’s why for copies going to cloud or third-party repositories, job-level encryption is added on top of repository encryption, not instead of it. If you use tape, write down explicitly whether LTO drive encryption or software encryption is used and who manages the key. Otherwise, the key for a cartridge that needs to be read years later can’t be found. The tape stays on the shelf, and the key gets lost.
Password-based and KMS-based key management
Most backup products offer two models. In the password-based model, the administrator sets a password for each job or repository; the software derives the key from this password. In the KMS-based model, keys are generated in an external key management system (an on-premises KMIP server, an HSM or a cloud KMS), and the backup software requests the key from there. Products such as Veeam Backup & Replication offer both models; because the scope of KMS support varies by version, verify it in the documentation for your version.
| Criterion | Password-based | KMS-based |
|---|---|---|
| Setup | Simple, no additional infrastructure | Requires a KMS, certificates and an access policy |
| Human error | Weak passwords, sharing, forgetting to record them | Less; the key doesn’t pass through human hands |
| Dependency after an attack | On the out-of-band record of the password | On the KMS being up and reachable |
| Attacker’s impact | Can change the password from the console | Can disable the key if they have KMS rights |
| Where it fits | Small and mid-sized, few jobs | Many jobs, compliance requirements, central auditing |
If a KMS has been chosen, the real question is how the KMS itself will be recovered. If the KMS virtual machine is in the same hypervisor cluster, joined to the same domain and backed up by the same backup job, a circular dependency arises: opening the backups requires the KMS, and restoring the KMS requires the backup. The key ends up locked inside its own box. Also keep the KMS’s key material as an offline copy independent of the backup infrastructure.
In the password-based model, the password should be long and random; key derivation doesn’t strengthen a weak password. Using random passwords of at least 20 characters generated in the password vault, and recording who can access each password, is a practical start. A mistake we often run into in the field is the same single, memorized password being used for all jobs for years.
Storing keys separately and escrow
From an enterprise cybersecurity standpoint, the basic rule of key management is this: the key doesn’t sit in the same trust zone as the data it protects. NIST SP 800-57 defines separate controls for the whole lifecycle of a key (generation, distribution, storage, archiving, destruction). In the backup scenario, the most neglected stage is archiving. If the old password is deleted after a planned change, old restore points within the retention period can’t be opened.
A working escrow arrangement includes these elements:
- Two separate copies: One in the corporate password vault for day-to-day operation, the other in an environment independent of the domain and the corporate network (a safe with a sealed envelope, an offline password vault managed with separate credentials, or an encrypted file protected with a hardware key).
- Split knowledge: A two-person rule can be applied for critical keys; for example, two halves of the password are held by two different administrators, or two approvals are needed to open the vault.
- Version record: For each password or key, the validity start, which jobs it’s used for and until what date it needs to be kept are written down.
- Central recovery feature: Some products offer password loss protection (in Veeam, through Enterprise Manager). If this feature is used, the key material of the relevant server is subject to the same separation rules.
A simple but complete template for the key record:
Key ID : BKK-2026-03
Scope : Cloud copy jobs (BCJ-*), tape pool TP-MONTHLY
Validity start : 2026-03-01
Replaces : BKK-2025-09
Retention end : Retention of the last point written with this key + 30 days
Primary location : Corporate password vault / Backup-Keys folder
Secondary location : Offline safe, envelope no. 14
Access : Backup lead + information security lead (two approvals)
Last recovery test : 2026-06-12, successful
The risk of an attacker changing encryption settings
An attacker who gets into the backup console with administrator rights doesn’t always try to delete backups. On an immutable repository, deletion fails and may raise an alarm. A quieter route is turning on encryption in job settings, or changing the password to one the attacker knows. From that moment on, every backup is written with the attacker’s key; as old restore points expire and are deleted, the organization is left with no backup it can open. Immutability doesn’t prevent this, because the backup isn’t being deleted; it’s being written in an unreadable form. The backup exists, but it isn’t yours.
In architectures using a cloud KMS, a similar route is disabling the key or scheduling it for deletion. In AWS KMS, key deletion is scheduled with a waiting period of 7 to 30 days; it can be canceled within this period, but if it goes unnoticed, all data encrypted with the key becomes permanently unreadable. Below is an example organization policy (SCP) that removes the right to delete and disable keys from everyone except a separate role for recovery purposes. SCPs aren’t applied to the AWS Organizations management account; that’s why you should keep keys in member accounts:
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "DenyBackupKeyDestruction",
"Effect": "Deny",
"Action": ["kms:ScheduleKeyDeletion", "kms:DisableKey"],
"Resource": "*",
"Condition": {
"ArnNotLike": {
"aws:PrincipalArn": "arn:aws:iam::*:role/BreakGlass-KeyAdmin"
}
}
}
]
}
Controls against this risk:
- Give the right to change encryption settings in the backup console only to a separate role; the everyday operator role shouldn’t see this setting. The full picture of identity separation is covered in the identity isolation in backup infrastructure guide.
- If the product supports it, turn on four-eyes approval for critical setting changes.
- Send the event log of job encryption settings and password changes to the SIEM; raise a high-priority alarm on an unexpected change. Other events to monitor are listed in the signs of attacks on backup infrastructure article.
- For a cloud KMS, monitor
ScheduleKeyDeletionandDisableKeycalls through CloudTrail.
It’s also useful to periodically compare the current state of encryption settings against a reference. An example that lists per-job encryption status with the Veeam Backup & Replication PowerShell module (property names may vary by version; verify in your own environment):
Get-VBRJob | Select-Object Name,
@{n='Encryption';e={$_.GetOptions().BackupStorageOptions.StorageEncryptionEnabled}} |
Sort-Object Name | Export-Csv C:\Reports\backup-encryption.csv -NoTypeInformation -Encoding UTF8
Compare this output each week with the previous week; a job whose encryption has unexpectedly been turned on or off stands out immediately. A simple diff is enough.
Key recovery testing
Routine restore tests are mostly done while the backup server is running; the software already knows the key, so the password is never asked for. This test doesn’t prove the key is really recoverable. In a key recovery test, you act as if the backup server and corporate identity infrastructure don’t exist; you try to open the data with only the backup files and the key in escrow.
- On an isolated network, install the backup software on a clean server not joined to the domain.
- Import a backup chain from the immutable repository or offline copy.
- Take the password or key only from the offline escrow copy; don’t connect to the corporate password vault.
- Restore a virtual machine or set of files and verify that the content can be read.
- If a KMS is used, run the same test together with bringing the KMS up from backup or a secondary copy.
- Record the key ID used, the time taken and the obstacles encountered in the key record.
The problems that come up most often in this test: the password in escrow isn’t current, old keys haven’t been archived, it’s unclear who can access the offline safe, and the certificates needed to restore the KMS exist only in the production environment. The test can also be run as part of a full cyber recovery exercise scenario; the exercise’s identity loss variation already tests key access.
Implementation checklist
- Is every backup copy that goes outside the organization or to a separate environment encrypted at the job level?
- Is at least one copy of each key in a place independent of the domain, corporate email and the backup server?
- Are replaced old keys kept in the archive until the relevant retention period ends?
- Are the accounts that can change encryption settings limited and logged?
- Do changes to encryption settings and KMS key state raise alarms?
- When was the last key recovery test done, and was the result recorded?
When encryption, immutability and an offline copy are designed together, the backup is protected against both leaks and deletion; for the general readiness framework, see the ransomware recovery readiness article. If you’d like the key management of your current architecture assessed with an independent eye, take a look at the scope of our backup security and ransomware readiness service.
The primary source on the key lifecycle: NIST SP 800-57 Part 1 Rev. 5.
Frequently asked questions
If the backup encryption password is forgotten, can the backups be recovered?
If encryption is implemented correctly, nobody, including the software vendor, can open the data without the password. Some products offer password loss protection through a central management server; if this feature isn’t enabled and the password isn’t recorded, all restore points encrypted with that password are considered lost.
Does a backup written to an immutable repository need to be encrypted as well?
Yes. Immutability protects against deletion and modification, not against reading. Someone with access to the repository or copy media can extract databases, mailboxes and password hashes from an unencrypted backup. The two controls answer different threats; use them together.
How often should the backup encryption key be changed?
Event-driven change matters more than a fixed schedule: the departure of someone with access to the key, a suspected leak, or a security incident in the backup infrastructure. With a planned change, keep old keys in an archive until the last restore point encrypted with them leaves the retention period.
Is using a KMS always safer than password-based management?
No. A KMS reduces human error and password sharing, but it makes opening the backup dependent on the KMS being available. If the KMS is tied to the domain or the production cloud account, an attacker can render the backups unusable by disabling the key. The right choice depends on the KMS being managed with identities separate from the backup infrastructure.