Apple Cryptographer (Mid-Level) Interview Preparation Guide

Direct answer

Start from the decision the ritual has to produce, not the calendar slot. Invite only the people who can actually make or unblock that decision, not everyone with an interest in the topic. Set the cadence to match how fast the underlying work changes, and instrument the ritual itself so you can tell whether it is producing decisions or just producing a meeting.

Structured elaboration

1. Name the single output first. Before picking attendees or a cadence, write down the one decision or artifact the ritual exists to produce (for example, "which cross-team dependencies get prioritized this cycle"). If you cannot name it, you are designing a status meeting, not a working ritual.
2. Minimum viable roster. Invite decision-owners, not stakeholders who only want visibility. A rule of thumb: if someone in the room has to say "let me check with my team" before committing to anything, they are a proxy, not an owner, and the room is one person too big.
3. Cadence tied to decision half-life. Match the frequency to how fast the thing being decided actually changes, not to habit. Too frequent and there is nothing new to decide between sessions; too infrequent and blockers age past the point where the ritual could have caught them early.
4. Session shape. Require light pre-work (so room time is spent deciding, not getting everyone up to speed), time-box the agenda to the decision at hand, and keep a running decision log so the group is not re-litigating the same question every time.
5. How you would know it is working (leading indicators, not attendance):

Worked example

Say the ritual is a recurring dependency review for a platform initiative touching four delivery teams. The roster is the four team leads plus the program owner as facilitator, five to six people, not the fifteen who are merely affected. The teams plan in two-week sprints, so a dependency raised today needs to be resolved before the next sprint's planning starts or it blocks that team. That reasoning sets the floor: the review has to run at least once per sprint, so biweekly, thirty minutes, is the minimum cadence that keeps blockers from aging past one planning cycle. A weekly cadence would mean showing up with nothing new most weeks; a monthly one would let a blocker sit for up to two sprints before anyone with authority to fix it even hears about it.

Trade-offs & pitfalls

• The most common wrong turn is defaulting the invite list to "everyone affected." The ritual becomes a broadcast, decision-owners tune out because nothing gets decided with fifteen people in the room, and the ritual quietly becomes theater.
• Choosing cadence by convention ("let's do it weekly like standup") instead of the decision's actual refresh rate produces either a hollow meeting or a slow one, and both erode trust in the ritual over time.
• Junior candidates describe running the meeting well. Senior candidates describe designing the meeting so it can be evaluated and retired: a built-in check for whether it is still adding value, and a plan for what replaces it if it is not.
• Skipping the decision log is a quiet failure mode: without a record of what was already decided and why, the group re-opens the same debate every session and the ritual's real cost shows up as fatigue, not as an obvious complaint.

Summary / Goals
AES-SIV is an authenticated-encryption mode that is misuse‑resistant: even if nonces are reused, it preserves confidentiality and detects forgery. It separates authentication (S2V) from final encryption (CTR with the synthetic IV).

S2V (Synthetic IV) — high level

• S2V takes associated data blocks and plaintext and computes a deterministic "synthetic IV" by iterated CMAC-like operations: process each AD with a doubling/ xor mix, then incorporate the plaintext to produce a single tag.
• That tag serves both as an authentication tag and as the IV for the subsequent AES-CTR encryption.

Why deterministic & misuse-resistant

• Deterministic: S2V produces the same IV for identical inputs; AES-CTR with that IV yields deterministic ciphertext.
• Misuse resistance: If a nonce is accidentally reused, authenticity still relies on the S2V tag bound to AD and plaintext. Reuse cannot trivially produce related plaintexts or allow forgery because the tag depends on the full message and AD under a separate MAC key.

When deterministic encryption is acceptable

• Encrypting keys, database fields where equality leaks are acceptable (e.g., deduplication), secure logging with integrity, or any case requiring nonce-free operation.
• Not acceptable for high-privacy data where revealing equality patterns enables profiling (web tracking, user content) — use randomized AEAD instead.

Role note
As a cryptographer, choose AES-SIV when robustness against nonce misuse is critical or when deterministic outputs are required; otherwise prefer nonce-based randomized AEAD for stronger privacy.

Direct answer

Common Vulnerability Scoring System (CVSS) and DREAD (Damage potential, Reproducibility, Exploitability, Affected users, Discoverability) answer different questions, CVSS is a standardized technical severity score, DREAD is a lightweight, team-scored relative-priority tool, and neither alone tells you whether something is actually likely to be attacked. A modern addition, the Exploit Prediction Scoring System (EPSS), closes that specific gap by estimating the probability of real-world exploitation. The strongest practice combines a standardized severity or exploitability signal with an organization-specific business-impact rating, then presents that combination differently to technical and business audiences rather than reporting the same raw number to both.

Structured elaboration

CVSS. A standardized, vendor-neutral score from 0 to 10, maintained by the Forum of Incident Response and Security Teams (FIRST), based on exploitability and impact metrics: attack vector, attack complexity, privileges required, user interaction, scope, and impact on confidentiality, integrity, and availability for the base score, with optional temporal and environmental metric groups that adjust the score for real-world exploit maturity and the specific deployment context. Strengths: standardized and widely adopted, giving a shared, comparable vocabulary across security teams, vendors, and researchers, and technically precise about exploit mechanics. Weaknesses: the base score alone does not reflect the actual likelihood of exploitation against a specific system or the asset's business importance, so a 9.8 against an internal system with no interesting data can rank the same as a 9.8 against a crown-jewel payment system unless the environmental metrics are actually used, which many organizations skip, and speaking a raw CVSS number directly to business stakeholders does not naturally translate into a business decision without added context.

DREAD. Each of the five factors, damage potential, reproducibility, exploitability, affected users, and discoverability, is rated on a scale and combined, commonly averaged, into a single relative score. It was originally developed for lightweight, rater-driven relative prioritization rather than as a standardized industry benchmark. Strengths: simple and fast to apply, and each of its five factors is easy to explain in plain language, how bad, how repeatable, how hard to pull off, how many affected, how easy to find, which can actually make it more approachable to a mixed audience than CVSS's more technical metric vocabulary. Weaknesses: subjective, since ratings depend heavily on who is scoring, unlike CVSS's more structured metric definitions, so scores from different raters or teams are not reliably comparable to each other, and it lacks CVSS's broad industry standardization, a DREAD score is really only meaningful within one team's own consistent rating practice, not across organizations or against externally published scores.

A modern alternative: EPSS. A data-driven score estimating the probability that a vulnerability will actually be exploited in the wild within a near-term window, based on observed exploitation activity and vulnerability characteristics, also maintained by FIRST. Strength: it directly addresses CVSS's biggest practical gap, distinguishing "severe if exploited" from "likely to actually be exploited," the same realized-risk signal that matters for prioritizing a large backlog of findings. Weakness: it is a probability of exploitation, not a measure of impact to a specific organization, so it needs to be combined with asset criticality or business impact rather than used alone. The broader best practice, regardless of which specific score, is to combine a standardized technical or exploitability signal (CVSS and, where available, EPSS) with an organization-specific business-impact rating, rather than relying on any single score as a complete answer.

Choosing and combining scores for two audiences. For technical stakeholders, engineers and security analysts, lead with the standardized, precise scores: CVSS's metric breakdown to explain exactly why something is severe, which specific vector, what privilege is needed, and, where relevant, EPSS or observed-exploitation status to explain urgency. This audience wants the mechanism, not just a label. For business stakeholders, executives, product, or compliance leadership, translate the same underlying findings into business terms: likelihood expressed as "how likely, in plain terms, and why" rather than a raw percentage, and impact expressed in terms the business already tracks, regulatory exposure, customer-facing downtime, or a financial-loss magnitude tier, rather than a confidentiality, integrity, and availability breakdown. A small number of prioritized tiers, critical, high, medium, low, communicates far better to this audience than the underlying numeric scores themselves. The bridge between the two: maintain one underlying scoring approach and present two views of it, a detailed technical view for engineers and a summarized tiered view for business stakeholders, rather than two disconnected narratives that can drift apart or contradict each other when someone compares them.

Worked example

(Illustrative scenario, not a specific published vulnerability.) Consider a hypothetical flaw in a cryptographic library: a weak pseudo-random number generator used for session-key generation, producing predictable keys under specific conditions.

CVSS v3.1 (illustrative): the flaw is reachable over the network, needs no privileges and no user interaction, and breaks the confidentiality of session data without directly altering it, which is the vector AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N and a base score of 7.5. Quote the vector, not just the number: the vector is what makes the score reproducible by anyone who wants to recompute it, and it is exactly the mechanism-level detail the technical audience below is asking for.

DREAD (illustrative, each factor rated 1-10, then averaged): Damage 8 (compromised session keys enable session hijacking); Reproducibility 6 (requires specific, not universal, conditions to trigger predictable output); Exploitability 7 (once conditions are known, exploitation is straightforward); Affected users 9 (affects any session using the library under the vulnerable configuration); Discoverability 5 (requires cryptographic analysis to notice, not immediately obvious from black-box testing).

EPSS (illustrative): a low-to-moderate initial exploitation probability, since weaponizing the flaw requires cryptographic expertise, flagged for ongoing re-monitoring because EPSS updates as real-world exploitation activity is observed, and a public proof-of-concept would likely raise it quickly.

To technical stakeholders: "CVSS 7.5, vector AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N, so network-reachable, low complexity, no privileges needed, breaking confidentiality via predictable session-key generation; exploitation probability currently low but expected to rise if a public proof-of-concept for the random-number-generator weakness appears."

To business stakeholders: "A high-severity flaw in how we generate session keys could let an attacker hijack user sessions under specific conditions. Current real-world exploitation likelihood is low but could rise quickly, and because this touches every session across the platform, we are prioritizing a fix within the critical remediation window rather than the normal patch cycle."

Trade-offs and pitfalls

Reporting a raw DREAD or CVSS number to business stakeholders with no translation is a common failure; "it's a 7.0" means nothing to someone who does not work with the scale daily, and repeatedly doing this trains business stakeholders to tune out security reporting entirely. Relying on CVSS base score alone for prioritization, ignoring exploitation evidence and business impact, systematically over-invests in high-severity-but-unlikely findings and under-invests in moderate-severity-but-actively-exploited ones. DREAD's subjectivity means using it for cross-team or cross-organization comparison, for example benchmarking one team's DREAD scores against a vendor's, is not meaningful; it is only self-consistent within one team's own disciplined rating practice. For cryptographic findings specifically, discoverability and exploitability ratings can be systematically mis-scored by raters without cryptographic expertise, rating a subtle cryptographic weakness as hard to discover and low priority when it is actually well known in the cryptographic research community, so pull in genuine cryptographic expertise for that specific factor rather than defaulting to a generalist's intuition.

High-level design

• Global control plane + per-region KMS gateways. Root keys (master KSKs) live only in HSM clusters (FIPS 140-2/3) per region with cross-region replication using signed backups and quorum. Application-level envelope encryption: data encrypted with ephemeral DEK (AES-256-GCM); DEK wrapped (KWP/AES-GCM or RSA-OAEP/ECIES) by regional KMS using HSM-backed Key Encryption Keys (KEKs).

Architecture components

• HSM clusters (one per region, automated secure backup to other HSMs via encrypted, signed blobs).
• KMS gateway fleet (stateless, autoscaled) for API, caching, KDF/wrapping, audit logging.
• Secure in-memory DEK cache cluster (per region) inside TEE or dedicated application servers with mTLS to clients.
• Control plane DB (strong consistency for key metadata, rotation schedules) replicated geo-distributed with consensus (Raft).
• Audit pipeline: append-only signed ledger (WORM) + SIEM integration.

Encrypt / Decrypt flows

• Encrypt:
  1. Client generates ephemeral DEK (or requests KMS to create DEK).
  2. Data encrypted with DEK (AES-256-GCM).
  3. Client calls regional KMS to WrapKey(DEK) → KMS uses KEK in HSM to AES-GCM-wrap DEK, returns WrappedDEK + key-id/version.
  4. Store ciphertext + wrappedDEK + key metadata.
• Decrypt:
  1. Client fetches wrappedDEK and calls regional KMS Decrypt API.
  2. KMS checks auth/policies, consults DEK-cache:
     • If cached plaintext DEK present and allowed, return DEK (or decrypt data server-side).
     • If cache miss, KMS calls HSM Unwrap to recover DEK, caches it in secure cache with TTL and usage counters, returns plaintext DEK to caller (or performs AEAD decrypt server-side and returns plaintext).
  3. Client performs data decryption locally (preferred for scale/latency).

Caching strategies (to hit 100k decrypts/sec)

• Envelope encryption minimizes HSM ops. Cache plaintext DEKs in-memory in regional TEE-backed cache with 1) short TTL (e.g., 1–15 min) and 2) per-key rate limiting and usage counters.
• For very high throughput, return decrypted data from KMS gateway after server-side decrypt (only for approved workloads) to avoid client-side compute.
• Key derivation: derive region-specific KEKs from HSM root via HKDF to avoid frequent HSM calls for metadata-only operations.
• Cache eviction: LRU + hot-key pinning for keys used > threshold. Use bloom filter to avoid stale cache lookups.
• Protect caches: encrypt in-memory with locally derived ephemeral key from TEE or use OS FIPS libs; audit all accesses.

Failure modes & mitigations

• HSM outage: regional fallback to cached KEKs/DEKs; promote read-only mode; failover to replicated HSM in another region with mutual authentication; emergency key export using pre-authorized quorum-signed wrapped backups.
• Network partition: allow local region to serve cached DEKs; throttle decrypts that require HSM unwrapping; use monotonic sequence numbers and conflict resolution in control plane.
• Key compromise: immediate rotation—generate new KEK in HSM and rewrap DEKs lazily (on access) using double-wrapping during rotation; revoke compromised key and mark metadata; full re-encryption plan for high-sensitivity data.
• Cache poisoning / theft: TEEs, mTLS, process-level sealing; short TTLs; mandatory rotation and forward secrecy via ephemeral DEKs reduce exposure.

Rotation & atomicity

• Periodic automated rotation of KEKs in HSM with overlap windows. Use double-wrap pattern: new KEK encrypts data while old KEK can still unwrap until all DEKs rewrapped. Rotation orchestrator writes atomic metadata version and publishes to replicas.

Auditability & compliance

• All KMS actions signed by HSM key, immutable append-only ledger with signed checkpoints, fine-grained policy logs (who/where/why), integration with offline key ceremony logs for root key changes.

Capacity planning (target 100k decrypts/sec)

• Aim for <1 HSM unwrap/sec by caching. Example:
  • If average DEK reused for 1 minute and each DEK decrypts 10k pieces/sec → most decrypts hit cache.
  • For worst-case cold-starts: design gateway fleet to handle 100k/sec symmetric AEAD decrypts (AES-GCM) in CPU: ~1000 cores can handle 100k AES-GCM ops at <1ms/op; use hardware AES-NI.
  • HSMs: provision for steady-state HSM ops ~100–1000 ops/sec for unwraps/wraps during rotations or cold-cache bursts; choose HSM model accordingly and allow bursting via warm standby HSM or cached derived KEKs.
• Metrics: cache hit ratio, HSM queue length, p99 latency. SLOs: p99 decryption < 5 ms region-local; HSM unwrap p99 < 50 ms.

Cryptographer considerations

• Use AEAD (AES-256-GCM or AES-256-GCM-SIV) for DEK and data encryption; use HKDF-SHA-256 for KDFs; prefer elliptic curve (P-384/Ed25519) for signing of metadata; formalize threat model and proofs for rotation/compromise scenarios. Ensure constant-time ops in libs, strict RNG entropy, and side-channel resistant HSM usage.

This design balances cryptographic safety (HSM roots, AEAD, KDF), operational scalability (cache-first envelope model), and global availability with auditable controls and measured capacity for 100k decrypts/sec.

Situation & objectives
I would lead a rapid, measurable response to stop abuse, restore trust, and prove root-cause — preserving forensic evidence and minimizing impact to customers.

Detection & Triage

• Immediately validate compromise indicators (suspicious certs in CT logs, unexpected issuance patterns, anomalous signing key use).
• Snapshot and preserve CA HSM logs, audit trails, OCSP/CRL servers, and CT records; isolate systems for forensic imaging.
• Raise severity to incident response (IR) and legal teams; brief execs with impact assessment.

Containment

• Take compromised intermediate offline and revoke its signing capabilities at the CA orchestration layer.
• Quarantine affected CA servers/HSMs; rotate admin credentials and revoke API keys.
• Implement short-term mitigations: block issuance endpoints, enforce strict issuance approvals.

Revocation & Blacklisting

• Immediately issue CRLs and OCSP responses marking the intermediate revoked with high priority.
• Publish revocation in CT-equivalent feeds and coordinate with major browsers/OS vendors to push short-lived blacklist entries (safari/chrome/moz/Windows).
• Use Certificate Authority Authorization (CAA) and DNS records to prevent new issuance from other CAs unless authorized.

Re-issuing Keys & Certificates

• Generate new intermediate on hardened HSM with fresh key material, using multi‑party authorization (MPC or quorum HSM policies).
• Re-issue end-entity certs only when necessary (high-value / actively used). Prefer short-lived certs and automated re-issuance pipelines (ACME-like) to reduce manual workload.
• Communicate clear revocation/reissue lists and provide tooling/scripts for customers to validate and replace.

Root/Intermediate Replacement

• If root is unaffected: create a new intermediate with strong assurance and revoke compromised intermediate.
• If root is suspected: schedule coordinated root rollover with cross-signed transition intermediates, publish timelines, and provide compatibility guidance.
• Ensure new keys use current best-practice algorithms/curves and HSM FIPS/CC compliance.

Coordination with Browser/OS Vendors

• Engage immediately through security channels (bug trackers, security@, vendor PSIRT). Provide evidence, timelines, and CT entries.
• Request expedited distrust/blacklist where necessary and provide wording for security advisories.
• Publish transparent timelines and progress updates for vendors to synchronize trust store changes.

Using CT/OCSP to Propagate Revocation

• Log all revoked certs to CT with explicit revocation markers to aid detection.
• Set OCSP responses to “revoked” and use short OCSP TTLs; publish CRLs and Delta-CRLs aggressively.
• Encourage clients to use OCSP stapling and short-lived certs; monitor CT logs for remaining fraudulent certs and request CT operators to block submissions if applicable.

Legal, Audit & Postmortem

• Preserve chain-of-custody; work with forensics and legal to document evidence for prosecution/regulatory reporting.
• Trigger mandatory breach notifications per law and industry regulations; offer affected customers remediation support.
• Conduct a root-cause analysis, produce an internal/external report, update CA policies (e.g., multi-signer, offline signing, improved monitoring), and run tabletop exercises to validate improvements.

Key principles

• Rapid containment + transparency, cryptographic best practices (HSM + MPC), coordinated vendor engagement, and durable audit evidence to restore trust.

Situation & assumptions
Server is fully compromised (attacker reads persistent storage, intercepts/forges traffic). Clients and their keys and endpoints are assumed uncompromised and honest.

Confidential properties that remain

• End-to-end confidentiality of message plaintexts between clients — if clients hold uncompromised long-term private keys and use proper authenticated key exchange (e.g., X25519 + ECDH + AEAD), server cannot decrypt past or future ciphertexts.
• Forward secrecy — when ephemeral DH is used per session/message, compromise of server does not reveal prior message keys.
• Recipient unlinkability if clients use unlinkable ephemeral keys or one-time prekeys: server cannot trivially map ciphertexts to long-term plaintext content.

Remaining risks

• Metadata exposure: message timing, sizes, routing, and participant identifiers visible to attacker.
• Active MITM on delivery: server can drop, delay, replay, reorder, or withhold messages.
• Key-injection/rollback: server can supply stale/precomputed state or replay old prekeys to induce predictable keys.
• Stored encrypted backups or attachments on server may be stolen for offline guessing if weak client-side encryption used.

Three mitigations

1. Client-side: Strict authenticated key exchange with mutual authentication and key confirmation (e.g., X3DH + Double Ratchet) and key freshness checks — reject sessions whose key IDs or signed key bundles are stale; log and surface anomalous key rotations to users.
2. Client-side: Metadata-minimizing features — padding, batching, cover traffic, and use of anonymous identifiers / unlinkable prekeys to reduce profiling.
3. Server-side / protocol: Use verifiable append-only logs and signed key directories (transparency) so clients can audit server-stored public keys and detect tampering; combine with gossip between clients to detect inconsistent server views.

Design goals

• Secure-by-default, minimal footguns, clear lifecycle, constant-time where promised, explicit error model.

API prototypes (core)

// Opaque key type
typedef struct sym_key sym_key_t;

// Errors
typedef enum { SE_OK=0, SE_ERR_INVALID, SE_ERR_LEN, SE_ERR_AUTH, SE_ERR_ALLOC, SE_ERR_STATE } se_error_t;

// Key lifecycle
se_error_t sym_key_alloc(sym_key_t **k, size_t bits);   // zeros on alloc
se_error_t sym_key_import(sym_key_t *k, const void *raw, size_t len); // copies
se_error_t sym_key_generate(sym_key_t *k); 
void        sym_key_zero_free(sym_key_t *k);

// One-shot AEAD
se_error_t aead_encrypt_one_shot(const sym_key_t *k,
                                 const uint8_t *nonce, size_t nlen,
                                 const uint8_t *aad, size_t aad_len,
                                 const uint8_t *pt, size_t pt_len,
                                 uint8_t *ct, size_t *ct_len); // ct includes tag

se_error_t aead_decrypt_one_shot(const sym_key_t *k,
                                 const uint8_t *nonce, size_t nlen,
                                 const uint8_t *aad, size_t aad_len,
                                 const uint8_t *ct, size_t ct_len,
                                 uint8_t *pt, size_t *pt_len);

Streaming API

typedef struct aead_stream aead_stream_t;
se_error_t aead_stream_init(aead_stream_t **s, const sym_key_t *k, const uint8_t *nonce, size_t nlen);
se_error_t aead_stream_aad(aead_stream_t *s, const void *aad, size_t len);
se_error_t aead_stream_update(aead_stream_t *s, const void *in, size_t in_len, void *out, size_t *out_len);
se_error_t aead_stream_finish(aead_stream_t *s, void *tag, size_t *tag_len);
void        aead_stream_free(aead_stream_t *s);

Constant-time guarantees

• Export function: const char *se_runtime_properties(void);
• Document which primitives are constant-time (e.g., HMAC/HKDF internals constant-time for secret ops; AES-GCM uses AES-NI when available — data-dependent branches avoided in crypto paths). Provide build-time macro SE_ASSUME_CT to assert CT.

Examples

• AES-GCM one-shot: allocate sym_key, import raw 256-bit key, call aead_encrypt_one_shot with 12-byte nonce, check SE_OK, then zero_free key.
• HKDF: provide hkdf_extract / hkdf_expand APIs that accept sym_key_t or raw salt/prk buffers; operations do not expose intermediate secrets and zero-buffer outputs on error.

Error handling convention

• Return se_error_t; outputs via out-params only when SE_OK. Functions validate lengths and nonce sizes and fail fast.

Documentation & testing

• Docs: per-function guarantees (memory, thread-safety, CT), required nonce lengths, max message sizes, recommended usage patterns and misuse examples.
• Tests: unit tests for edge cases, FIPS test vectors, property tests (nonce reuse detection helpers), fault-injection, valgrind/ASAN checks, constant-time regression tests (frequency/statistical timing, ct-verifier), fuzzing for streaming and boundary conditions, and API misuse tests (double-free, use-after-free).

Role of randomness in asymmetric keys
Randomness provides unpredictability for private keys, nonces, and ephemeral secrets in key exchange (e.g., ECDH ephemeral private scalar). Without sufficient entropy, keys become guessable and protocols collapse.

CSPRNG properties

• Unpredictability: future outputs infeasible to predict from past.
• Forward secrecy: compromise of state should not reveal prior outputs.
• Backward secrecy (resilience): compromise shouldn't reveal future outputs after reseed.
• Uniformity and absence of bias.
• Resistance to state recovery (entropy stretching without leaking seed).

Entropy sources & seeding

• TRNGs: hardware sources (ring oscillators, jitter, photon counts) — high-quality raw entropy.
• OS sources: /dev/random, getrandom(), Windows CNG — mix in multiple sources (timers, interrupts) vetted by OS.
• Seeding strategy: collect sufficient min-entropy, mix using a vetted extractor (e.g., HKDF, SHA-256-based DRBG), seed CSPRNG at boot and reseed regularly from TRNG/OS entropy, protect seed in memory.

Consequences of weak randomness

• Predictable private keys, replayable nonces, broken signatures (e.g., repeated k in ECDSA leaks private key).
• System-wide compromise and undetectable backdoors.

Historical example
Debian OpenSSL (2006): a maintainer removed entropy-mixing code, shrinking keyspace and producing predictable SSH/TLS keys — millions of weak keys issued and required replacement.

My practical habit: use vetted primitives (NIST/DRBG or libsodium), ensure TRNG health checks, and enforce regular reseeding and key rotation.

Approach (high level)
Use per-device asymmetric keys in a hardware-protected root (TEE/SE), a signed one-time QR payload from factory, and a cloud PKI + challenge-response to prevent cloning and bind identity. Recovery uses multi-party escrow and authenticated out-of-band (OOB) approval.

Protocol (stepwise)

• Factory: for each device generate DeviceKeyPair (sk_D in SE, pk_D exported), create FactoryToken = { device_id, pk_D, expiry, nonce } signed by ManufacturerSK. Encode FactoryToken and a one-time ProvisioningSecret S (high-entropy random) into QR; print QR and store hashed S in manufacturer/cloud DB. QR marked single-use.
• Boot (offline): sealed image reads QR, SE imports nothing—SE uses internal key to sign a proof-of-possession of pk_D (or reveals pk_D via attestation). Device connects to cloud, sends FactoryToken, manufacturer signature, attestation statement from SE, and a challenge-response proving possession of S or sk_D. Cloud verifies manufacturer signature, checks one-time S hash, verifies attestation and freshness, then mints DeviceCertificate bound to cloud account and records pk_D.

Preventing QR cloning

• QR contains a one-time S and manufacturer signature over device_id+nonce; cloud marks S used on first successful provisioning.
• DeviceKeyPair protected in SE—an attacker cloning QR without SE cannot complete challenge-response or produce SE attestation.
• Use tamper-evident packaging and printing secure holographic markers to raise bar for physical cloning.

Identity binding

• Cloud issues X.509/ED25519 certificate for pk_D tied to user account after mutual attestation and optional user authentication (email/phone + OTP). Certificates include device_id and attestation claims.

Secure recovery if QR lost

• Multi-option recovery: (1) Account-based recovery: user authenticates to cloud (MFA) and requests issuance; cloud requires manufacturer attestation or proof from other enrolled devices. (2) Escrow: manufacturer stores encrypted recovery token K_enc = Enc( user_pubkey, K ) where K is wrapped with SE-protected key; release requires user OOB MFA plus manufacturer policy checks. (3) Hardware fallback: bring device to authorized service with physical attestation and manufacturer private approval.

Security considerations / properties

• Freshness: nonces + timestamps prevent replay.
• Forward secrecy: short-lived provisioning tokens; DeviceCertificate rotation.
• Compromise containment: revocation CRL/OCSP; mark S as used.
• Privacy: avoid embedding user-identifying info in QR; use linking only after cloud minting.

Rationale: asymmetric keys + SE attestation enforce that possession of QR alone is insufficient; one-time secret prevents replay/cloning; multi-factor recovery balances usability and security.

Approach (brief)
Use deterministic authenticated encryption (DAE) per field so equal plaintexts map to equal ciphertexts enabling exact-match search while providing integrity. Use a keyed AES-SIV or AES-GCM-SIV in deterministic mode with a key derived per-tenant/field.

Pseudocode (key derivation + encrypt/search)

# Python-like pseudocode
def derive_key(master_k, tenant_id, field_id):
    return HMAC(master_k, b"DET_KEY" || tenant_id || field_id)[:32]

def det_encrypt(key, plaintext):
    # AES-SIV deterministic AE; nonce-free, provides misuse resistance
    return AES_SIV_seal(key, plaintext, associated_data=None)

def det_search_token(key, value):
    return det_encrypt(key, value)  # server matches ciphertexts

# Usage:
k = derive_key(MASTER_KEY, tenant_id, "email")
ct = det_encrypt(k, b"user@example.com")
# store ct in DB, indexable; to search compute det_search_token and query equality

Exact leakage profile

• Equality leakage: server learns which records share identical plaintext values (frequency and equality classes).
• Access pattern on queries: server sees which ciphertexts are retrieved for a token (repeated queries reveal correlation).
• No plaintext leakage if keys and algorithms are secure; integrity preserved by AE.

Frequency-analysis risks

• High-frequency values (e.g., common emails, "US" country codes) can be mapped to plaintext via external frequency priors or profiling.
• Large cohorts with identical deterministic ciphertexts amplify risk.

Practical mitigations

• Per-tenant and per-field keys (reduces cross-tenant correlation).
• Prefix/salt variants: include low-entropy random salt in key-derivation per rotation window so equality holds only within window — trades some searchability.
• Bucketization: map plaintexts into buckets (hash-to-buckets) to reduce granularity; requires application-level post-filtering.
• Rate-limit or pad query patterns to reduce access-pattern leakage.
• Periodic key rotation with re-encryption limits long-term profiling.

Stronger alternatives

• Order-preserving or order-revealing encryption only if ordering needed (more leakage).
• Searchable symmetric encryption (SSE) or inverted-index SSE: supports exact-match with reduced frequency leakage using tokenized index and secure postings lists (requires more complex server-side structures).
• Homomorphic PEKS or ORAM-backed SSE for minimal leakage but higher complexity/latency.

Trade-offs & recommendation
Deterministic AE is pragmatic for indexed exact-match with simple deployment; accept equality leakage and mitigate via per-tenant keys, bucketing/salting, access controls, and consider SSE/ORAM when stronger privacy guarantees are required.