An audit asks who submitted a report. The system answers with confidence: the package is signed, the signature verifies, and the certificate is trusted. The name it shows is wrong, and nothing in the system can tell, because every check it ran was designed to answer a different question.
Digital signatures protect the integrity of the bytes they cover when verified against the correct trusted key. They do not by themselves establish original authorship, preserve every earlier endorsement, or prove that a package belongs to the context in which it is being presented.[1]
That distinction becomes critical when the infrastructure holding the package is compromised. An attacker may be unable to read the data yet still able to change who appears responsible for it.
When the signature is valid and the attribution is wrong
A valid signature can authenticate the current signer without establishing the package’s original creator.
Consider a shared document service. Alice encrypts a report and signs the ciphertext. An attacker, Bob, has taken control of the storage service. He holds Alice’s encrypted package but not the key to open it. He removes Alice’s outer signature and signs the same ciphertext using his own key.
Bob does not need to decrypt the report. He can sign bytes he cannot read.
If the application accepts Bob’s signature and displays him as the report’s creator, it has confused a valid signature with proof of authorship. The encrypted contents are unchanged. The attribution is not.
A recipient that specifically requires Alice’s trusted key would reject Bob’s replacement. The weakness appears when the application accepts another signer without checking whether that signer is entitled to claim the original role.[1]

The business consequences extend beyond a misleading name on a screen. False attribution can undermine an audit, create disputes over responsibility, or make a party appear to have submitted information it never authorized. Similar failures to bind context can associate a genuine document with the wrong customer, transaction, or case. An investigation must then reconstruct facts that the system appeared to have verified already.
What the research already established
This problem has a long history. A 2001 USENIX paper by Don Davis described exactly this attack: stripping the signature from encrypted data and re-signing it to claim authorship. His analysis showed that the remedy is to bind identities across the signing and encryption layers rather than to trust either layer alone.[1]
The broader lesson keeps resurfacing. In August 2025, gnark’s maintainers disclosed that missing constraints in their signature-verification circuits let several distinct signature encodings pass the same check, so an application that used the signature as a unique event identifier could be replayed.[2] A signature should not be assigned stronger properties than the complete protocol enforces.
Sigstore’s threat model makes another boundary explicit. A valid signature does not guarantee that the signing identity was uncompromised, that it should have signed the message, or that the signed software is good.[3]
Systems must decide what a signature means before using it to make a security decision.
Assume the server is compromised
For Mimir, the starting assumption is that the server will be compromised. The architecture must account for an attacker controlling the storage service, its responses, and the metadata it supplies.
Whether that access comes through SQL injection, stolen administrative credentials, or a vulnerable service, the resulting threat includes more than disclosure. An attacker with sufficient control can substitute packages, change references, suppress newer records, or present old information as current.
Encryption can keep the contents confidential. Clients still need independent evidence that the package is the right object, from the right origin, in the right context.
This is why keeping encryption keys away from the server matters. When the compromised environment can obtain decryption keys or invoke decryption, encryption at rest alone does not preserve the confidentiality boundary. Moving decryption and processing to authorized clients removes that capability from the storage server.
How BrunnrDB and SAED close the gap
BrunnrDB follows that architectural approach: data is encrypted before upload, servers store ciphertext without the decryption keys, and decryption and processing take place locally in WebAssembly environments.[4]
This separates server access from access to plaintext. Protecting origin and history requires a corresponding separation between what the server claims and what the client can verify.
Within that architecture, Mimir’s Self-Authenticating Encrypted Data, or SAED, work does not treat the signature as a label attached to the ciphertext. SAED cryptographically links the signature to the encrypted data itself, so the body can only be decrypted under the signature it was created with. If anything about the signature changes, the encrypted body becomes impossible to decrypt.
That changes what Bob can accomplish. When he strips Alice’s signature and signs the same ciphertext with his own key, he does not produce a readable report attributed to Bob. He produces a package that no one can open. The substitution is caught by the most basic check a client performs, because decryption fails, and it is caught without trusting anything the server says about the package.
The required outcome is specific: an attacker controlling storage cannot replace the claimed origin and have the unchanged ciphertext accepted as authentic under the new origin. With SAED, the ciphertext stops being usable the moment the signature is touched.

Five questions for any encrypted-package design
For any encrypted-package design, five questions reveal whether that enforcement exists:
- Which identity is required? A valid key must also be authorized for the role and object being claimed.
- What context is protected? Relevant package identity, ownership, version relationships, and intended use must be bound to the data and checked.
- What survives an endorsement? A later approval should preserve the evidence of original authorship.
- Who can verify each property? Public signature checks and checks requiring decryption keys establish different facts.
- How is older evidence handled? A previously valid package must not silently become the current version simply because the server serves it again.
Standards provide useful examples. COSE countersignatures distinguish confirming an existing signature from independently signing the same content. RFC 9338 corrected an earlier construction that did not always include the cryptographic value it was intended to confirm.[5]
Freshness needs separate enforcement. An old package can remain correctly signed. The Update Framework therefore uses trusted version comparisons and expiration checks alongside signatures to address rollback and freeze attacks.[6]
These controls also need trust anchors outside the compromised server’s control. A client cannot independently establish origin if the same attacker can replace both the package and the authoritative key directory used to validate it. Client software and its update path are part of that boundary.
An authorized signer can still approve false information, and a compromised endpoint can misuse the data available to it. Cryptography establishes particular relationships between keys, bytes, and protected context; applications must enforce what those relationships permit.
Ask your platform provider to demonstrate what happens when a valid encrypted package is presented under a different signer, a different context, or an older version. The answer should identify which check rejects the package, which evidence that check trusts, and whether the rejection remains effective after the server is compromised.
At Mimir, that is the design standard for BrunnrDB: confidentiality without server-held keys, and package validation that does not depend on trusting the server’s description of the data.
Sources
- Don Davis, Defective Sign & Encrypt in S/MIME, PKCS#7, MOSS, PEM, PGP, and XML, USENIX, 2001.
- Consensys, Signature malleability in gnark EdDSA and ECDSA due to missing scalar checks, August 22, 2025.
- Sigstore, Threat Model.
- Mimir Security, Technology.
- IETF, RFC 9338: COSE Countersignatures, December 2022.
- The Update Framework, Specification.