Skip to content

Privacy and preparation

Dataset encryption key separation: a release procedure both sides verify

By SourceX Editorial · Reviewed by Noah Loul ·

10 sections

Short answer

Exchange an encrypted dataset and its key separately in three ways: by channel, by person and by time. Verify the recipient's key or account against the signed agreement through a second channel, send the ciphertext, have the recipient confirm its hashes, and only then release the key or grant to that verified person. Then confirm the decrypted manifest hash and close access.

Document stack

Dataset encryption key

This page covers dataset encryption key separation: a release procedure both sides verify.Illustrative

Key takeaways

  • Key separation is about channel, custody and timing, not only sending the password in a different email.
  • The safest model sends no secret at all: encrypt to a verified public key or grant use of a managed key.
  • Verify the recipient against the signed agreement by a channel you did not get from the request.
  • Release the key only after the recipient confirms matching ciphertext hashes, then confirm the plaintext manifest.
  • If the key and data travel together, treat it as exposure: revoke, re-encrypt and record.

What does dataset encryption key separation mean in practice?

Dataset encryption key separation means the encrypted files and whatever unlocks them never travel together, are never controlled by the same single person, and the unlock step happens only after the recipient has been verified and has confirmed it holds the exact package. It is three separations at once: channel, custody and time.

Channel separation is the familiar part: the key does not ride in the same email, bucket, drive box or link as the data. Custody separation means the person who packs and sends the dataset is not the person who holds and releases the key, so one compromised mailbox or one mistake cannot expose both. Time separation means the key is released last, after the files have arrived and their hashes match, so an intercepted package is useless and a misdelivered one can be abandoned without exposure.

OWASP's Cryptographic Storage Cheat Sheet states the underlying principle for stored data: where possible, keys should be kept in a separate location from encrypted data, so an attacker who reaches one does not get both. A dataset delivery applies the same principle to data in motion and to the people handling it.

Which separation model fits your delivery?

Pick the model that leaves the least secret to send. The best case is that no secret key travels at all, because the data is encrypted to the recipient's public key or the recipient is granted use of a managed key. A shared passphrase sent by a second channel is the fallback, not the default.

With public-key file encryption, such as age or OpenPGP, you encrypt to the recipient's public key and only their private key decrypts; the risk moves from sending a secret to confirming that the public key really belongs to the recipient. The age documentation shows files can be encrypted to an age public key or an SSH public key, and to several recipients at once, each of whom can decrypt. With a cloud key service, nothing is sent: AWS KMS, for example, requires both a key policy in the key owner's account and an IAM policy in the caller's account before a principal in another account can use the key.

Which separation model fits your delivery?
ModelWhat travels separatelyMain riskFits when
Encrypt to recipient public key (age, OpenPGP)Nothing secret; only the recipient's public key comes in, verifiedEncrypting to a substituted or wrong public keyRecipient can manage a key pair; files move by any channel
Cloud key service grant (for example AWS KMS cross-account)No key; a permission scoped to named principalsOver-broad grant or a grant never revokedBoth parties work in the same cloud and the data stays there
Shared symmetric key or passphraseThe secret itself, by a second channelKey and data reaching the same inbox or personRecipient cannot handle key pairs; one-off small delivery
Hardware-encrypted drive with PINThe PIN or unlock credential, by a second channelPIN written on or shipped with the driveLarge volumes moved physically
Provider device service (for example Azure Data Box)Unlock password held in the provider portalPortal access too broad on either sideMoving data into a provider's cloud at volume

The key separation and recipient verification procedure

Use the procedure below as written, adjusting only the channel names. Each step has a named role, a piece of evidence and a stop condition. If a stop condition is hit, do not skip ahead: the whole value of separation is lost the moment the key is released early or to the wrong person.

Steps 1 and 2 happen before anything is encrypted, because the recipient key decides how the package is built. Steps 6 and 8 are the recipient's half of the procedure; tell the recipient in advance what they will be asked to report and in what form, for example a hash list as a plain text file, so the exchange does not stall on the day. Every evidence item goes into the transaction's audit log with the time and the person who recorded it.

The key separation and recipient verification procedure
StepRoleActionEvidence recordedStop if
1 Name the recipientData ownerTake recipient name, role and a verification contact from the signed agreement, not from the request emailAgreement reference and named contactNo named person in the agreement
2 Get and check the recipient keyKey custodianReceive the public key or account ID, then confirm its full fingerprint or ID with the named contact by phone or videoFingerprint or account ID, who confirmed it, when, howFingerprint cannot be confirmed out of band
3 Freeze and hashData packerBuild the package, write the manifest with per-file hashes, hash the manifestManifest hashPackage still changing
4 EncryptData packerEncrypt to the verified key, or under a fresh data key for this delivery onlyCiphertext hashes, key identifierSame key used for another recipient
5 Send the dataData packerTransfer by the agreed channel with expiring accessTransfer report or tracking referenceChannel differs from the agreement
6 Confirm ciphertext receiptRecipientRecipient reports ciphertext hashes before any key is releasedMatching ciphertext hashesAny hash differs
7 Release the key or grantKey custodianRelease by the second channel to the verified person, or enable the scoped grantChannel, time, recipient check resultRequest comes from anyone other than the named contact
8 Confirm plaintext manifestRecipientDecrypt, recompute manifest hash, reportMatching manifest hashMismatch: re-send, do not patch
9 CloseKey custodianRevoke grant, expire link, destroy any shared secret copiesRevocation time and methodGrant still works after closure

How do you verify the recipient before releasing anything?

Verify the recipient against something you already trust, through a channel you did not get from the request. The contact named in the signed agreement, reached at a number from your own records, is a sound anchor; a phone number in the email that asks for the key is not.

For public keys, compare the full fingerprint with the owner. The GNU Privacy Handbook calls key verification a weak point in public-key cryptography and says to check a key's fingerprint with its owner, in person, by phone or by any means that confirms you are communicating with the key's true owner. The same discipline applies to an age recipient string or a cloud account ID: read it back, character by character or by a checksum both sides compute, on the second channel.

Record what you checked. A note that says the fingerprint was confirmed by phone with the named contact at a stated time is evidence a reviewer can test; a note that says recipient verified is not.

  • Anchor: named person and role from the agreement.
  • Channel: phone or video at a number from your own records, not from the request.
  • Check: full fingerprint, recipient string or account ID read back and matched.
  • Record: who checked, with whom, when, how, and the value matched.
  • Re-check: whenever the recipient sends a new key or the contact changes.

Which two hash checks bracket the key release, and how are access limits confirmed?

Both parties verify with two hash comparisons and one access check. Before the key is released, the recipient reports the hashes of the encrypted files it received; after decryption, it recomputes the plaintext manifest hash. If both match what the sender recorded, both sides can show the same package arrived intact and was the one approved.

Ordering matters. Comparing ciphertext hashes before releasing the key means a tampered, truncated or misdirected package is caught while it is still unreadable. Comparing the plaintext manifest afterward confirms the decryption produced the approved version, not an earlier draft that happened to be encrypted to the same key.

Access limits are checked from the sender's side: the link has an expiry, the cloud grant names specific principals and only the decrypt permission they need, and closure is confirmed by a request that now fails. AWS notes that naming an account in a key policy lets that account delegate use through IAM policies, so name specific roles when you want to limit who on the recipient's side can decrypt.

How do you separate duties inside each company?

Inside your own company, split the packer and the key custodian into different people with different system access. The packer can build and send the ciphertext but cannot see the key; the custodian can release the key but has no access to the delivery bucket or drive. On the recipient's side, the person who downloads should ideally not be the only person who can decrypt.

For high-sensitivity deliveries, split the key itself. NIST defines split knowledge as dividing a key into shares so that any set of k shares can recreate it while k minus 1 shares reveal nothing about the key beyond possibly its length. Two custodians each holding a share means no single person can release the key alone.

Use a fresh data key per delivery and keep it independent of any long-lived key. OWASP's guidance is that where multiple keys are used, such as separate data-encrypting and key-encrypting keys, they should be fully independent, and that limiting a key's cryptoperiod limits the amount of data exposed if that key is compromised.

Worked example and the exception that changes the procedure

Illustrative example, invented to show structure. A regional accounting firm licenses a de-identified archive of engagement workpapers. The licensee's data engineer is named in the agreement. The firm's IT manager packs and hashes the archive; its operations director is the key custodian.

The engineer sends an age public key by email. The operations director calls the engineer at the number in the agreement and they read back the recipient string; the director records the call. The IT manager encrypts to that recipient and uploads to a bucket with a seven-day link. The engineer reports matching ciphertext hashes. Because age public-key encryption was used, there is no secret to send at step 7: only the engineer's private key can decrypt, so the director records that step 7 rests on the recipient check made at step 2, and the engineer decrypts and reports a matching manifest hash. The link expires and the IT manager confirms it no longer works.

The exception is a very small company where one person does everything. Custody separation is then impossible inside the sender, so move it outward: use public-key encryption so no secret exists to leak, have someone outside the delivery, such as the owner or an outside advisor, confirm the recipient fingerprint, and keep the evidence record anyway.

What if the key and the data travel together by mistake?

Treat it as exposure of the plaintext. Stop the delivery, revoke access to the package, and replace the key: re-encrypt the data under a new key and release that one properly. Do not argue that the mistake was harmless because the package was encrypted; with the key alongside, it effectively was not.

At a glance

What if the key and the data travel together by mistake

With a cloud key service, disabling the key stops its use immediately while you investigate. Deletion is a different decision: in AWS KMS, scheduled deletion takes a waiting period of 7 to 30 days, and once the key is deleted, data encrypted under it is unrecoverable. That is useful at the end of a license as a form of crypto-erasure, and dangerous during an incident if it destroys your own only copy.

  • Record when, how and to whom the key and data were exposed together.
  • Revoke the link, grant or account that exposed them.
  • Re-encrypt under a new key; never reuse the exposed one.
  • Ask the recipient to delete both copies and confirm in writing.
  • Bring in privacy review if the package could contain personal data, and counsel if notification duties may apply.

What should the agreement say about key handling?

Write the procedure's anchors into the agreement or its delivery schedule, so neither side improvises under time pressure. The agreement is what makes the named contact authoritative, and it is the document both parties will reach for if a key goes to the wrong place.

Keep the clauses short and operational. They do not need to name a tool; they need to name people, channels, ordering and what happens on failure. Counsel should draft the wording; the list below is the substance an engineer would want to see covered.

  • Named key contacts on each side, with a verification channel for each, and how a change of contact is notified and confirmed.
  • The separation model to be used, for example encryption to the recipient's public key or a scoped grant in a named key service.
  • The rule that the key or grant is released only after the recipient confirms matching ciphertext hashes.
  • Expiry of links and grants, and who confirms closure.
  • What counts as exposure, such as key and data in one message, and the notice period and steps that follow.
  • Destruction of shared secrets after use and the end-of-term decision on keys protecting retained copies.

Which deliveries need a security engineer, and where SourceX fits

Stop and ask a security engineer when the recipient cannot hold a key pair and insists on a shared secret for a large or sensitive dataset, when keys will be managed in a cloud account neither party fully controls, or when hardware drives need a validated encryption module. Ask counsel when the agreement is silent on key handling, deletion or what happens on exposure; this page is general information, not legal advice.

When the license runs through SourceX, key handling is one part of a process that also takes in qualification, rights review, the contract, preparation and payment. SourceX never hosts multi-terabyte datasets, so large packages stay in storage the seller controls or travel on encrypted drives, which is precisely where the separation models above earn their keep. The company signs an agreement covering an approved scope before any record reaches SourceX, and a short eligibility assessment needs nothing uploaded.

Whichever path you take, keep the evidence from each step of the procedure in your own files. It is the record that shows, later, that the key reached only the person the agreement named.

Frequently asked questions

Is it enough to send the password by text message instead of email?

A second channel is better than the same channel, but it is only half the procedure. The key should also go only to a recipient verified against the agreement, and only after the recipient confirms the encrypted files arrived intact. Text messages to an unverified number fail the verification step.

Do I need to send a key at all if I use public-key encryption?

No secret key travels when you encrypt to the recipient's public key; only their private key can decrypt. The risk shifts to confirming that the public key really belongs to the named recipient, which is why the fingerprint check by a separate channel is the critical step.

Why should the recipient confirm hashes before the key is released?

Confirming ciphertext hashes first catches a truncated, tampered or misdirected package while it is still unreadable. If anything is wrong, you can abandon that package without having exposed the data.

Can the same encryption key be reused for the next delivery?

Use a fresh data key per delivery and per recipient. A reused key links deliveries together, so a single compromise exposes more data, and it makes it harder to revoke one recipient without affecting another.

What should happen to the key when the license ends?

Destroy shared secrets and revoke grants when the delivery closes, and decide at term end whether to destroy the key that protects any retained copy. Deleting a managed key can make data under it unrecoverable, so record the decision and confirm no needed copy depends on it.

Sources

  • OWASP's Cryptographic Storage Cheat Sheet says keys should be stored separately from encrypted data where possible and that separate data-encrypting and key-encrypting keys should be fully independent. Source
  • OWASP's Key Management Cheat Sheet says limiting cryptoperiods restricts the data protected by one key and the exposure window if it is compromised. Source
  • NIST defines split knowledge as dividing a key into shares where k shares recreate it and k-1 shares reveal nothing beyond possibly its length. Source
  • The GNU Privacy Handbook says key verification is a weak point and that a key's fingerprint should be checked with its owner by a means that confirms the true owner. Source
  • The age README shows encryption to age or SSH public keys and to multiple recipients, each of whom can decrypt. Source
  • AWS KMS documentation says cross-account use of a KMS key requires both the key policy and an IAM policy in the external account. Source
  • AWS KMS documentation says key deletion has a 7 to 30 day waiting period, data under a deleted key is unrecoverable, and disabling is an alternative. Source
  • Microsoft's Azure Data Box security documentation says device access is controlled by an unlock passkey and that the service stores the unlock password. Source

See if your company qualifies

A short company assessment. No data uploads are needed.

See if your company qualifies