What cryptography promises, and what it does not
Cryptography is sold as a solution and is better understood as a transfer. It takes a problem you cannot manage — protecting data spread across disks, networks and backups — and converts it into a problem you can: protecting a small number of keys. The data becomes as safe as the keys and no safer.
The four properties, kept distinct, because they need different mechanisms and are routinely confused:
- Confidentiality. Only the intended party can read it. Encryption.
- Integrity. It has not been altered. Hashing, and a keyed construction where the alteration might be deliberate.
- Authenticity. It came from who it claims to. Signatures and message authentication codes.
- Non-repudiation. The sender cannot later deny it. Only digital signatures give this, and only because the private key is held by one party. A shared secret cannot, because either holder could have produced the result.
Encryption alone gives you the first and none of the others. A ciphertext an attacker can alter undetectably is confidential and useless, which is why modern practice uses authenticated encryption rather than encryption on its own.
The algorithm is public; the key is the secret. This is the most important structural fact in the field and the one most often inverted by people new to it. The algorithms are published standards, specified in open documents, implemented in software anyone can read, and attacked continuously by people who want to find the flaw first. That scrutiny is why they can be trusted. An algorithm whose security depends on nobody knowing how it works has not been tested; it has only been hidden.
What is yours is the key. Every operational problem in this course — generation, storage, rotation, destruction, recovery, inventory — is a key problem, not an algorithm problem.
Security strength, measured in bits. NIST expresses the protection an algorithm and key length provide as a security strength, and SP 800-90A notes that the value comes "from the set {112, 128, 192, 256}". It is a measure of work: 128 bits of security means roughly two to the one-hundred-and-twenty-eighth operations to break, which is not a large number but an unreachable one.
Strengths do not add and are not averaged — a chain is as strong as its weakest link. SP 800-175B makes the point concretely with RSA: a 2048-bit key supports 112 bits of security strength, and it is commonly paired with a hash function from the 256-bit family, which supports 128. The pair delivers 112, not 128, and not 120.
What cryptography cannot do. It cannot protect data from someone holding the key, which includes your own administrators and anyone who compromises them. It cannot make a bad protocol safe. It does not protect data while it is being used. And it does nothing about who is allowed to ask for a decryption — that is access control, and it is where most real losses happen.
A key has a life, and the risk is in it
Keys are treated as configuration and behave like assets. NIST SP 800-57 Part 1 sets out the states a key passes through, and the discipline of the whole field is knowing which state each of your keys is in.
The states. A key begins in pre-activation: generated but not yet authorised for use. SP 800-57 is specific that the inventory starts here — "Keys to be inventoried (e.g., longterm keys) shall be inventoried upon generation" — which means a key that exists and is not on the list is already outside your control. It then becomes active, may be suspended, and in due course is deactivated while still needed to read old data. If something goes wrong it is compromised. Finally it is destroyed.
The cryptoperiod is the governing idea. SP 800-57 defines it as "the time span during which a specific key is authorized for use by legitimate entities or the keys for a given system will remain in effect." The reasons to bound it are cumulative rather than theoretical: the longer a key is in use, the more data depends on it, the more copies exist, the more people have handled it, and the more material an attacker can gather.
Two periods, not one, and conflating them causes real outages. A symmetric key used to protect data has an originator-usage period, during which new data may be encrypted with it, and a longer recipient-usage period, during which old data may still be decrypted. SP 800-57's Table 1 gives under two years for the first and up to the originator period plus three years for the second. Stop encrypting with a key long before you stop needing it to read.
For a private signature key the table gives one to three years, and the standard adds a hard rule: "A private signature key shall be destroyed at the end of its cryptoperiod." A signature key that outlives its period is a standing ability to sign as you.
Rotation is the easy half. Generating a new key is a few lines of code. What makes rotation hard is everything attached to it: finding every system that holds the old key, re-wrapping or re-encrypting what depends on it, keeping the old key available for reads during the transition, and knowing when nothing needs it any more so it can be destroyed.
Organisations that cannot rotate are usually not short of a rotation procedure. They are short of an answer to "what would break", which is a question about inventory.
Destruction is a state, and it has to be reachable. SP 800-152 requires an approved destruction method, and specifies that the design must say how the key or the medium is securely destroyed after being written elsewhere. In practice the obstacle is copies: backups, snapshots, a configuration file in version control, a developer's laptop. A key is destroyed when the last copy is, and most organisations cannot name the last copy.
The primitives, and what each one is for
A small number of building blocks, each answering one question. Using the wrong one is a more common failure than using a weak one.
Symmetric encryption: one key, both ends. The standard is AES, specified in FIPS 197, which "is capable of using cryptographic keys of 128, 192, and 256 bits to encrypt and decrypt data in blocks of 128 bits." An implementation "shall support at least one of the three key lengths". AES is fast, well analysed and appropriate for bulk data. The weakness is distribution: both parties need the same secret, so every new pair of participants is a new key to deliver safely.
The mode matters as much as the cipher. AES encrypts one 128-bit block; a mode of operation extends it to a message. Modes differ in whether they detect tampering, whether they need a unique value per message, and what happens when that value repeats — which is usually catastrophic. Choose an authenticated mode and never reuse a nonce with the same key.
Asymmetric encryption: a pair, one public. A public key that anyone may hold and a private key that one party holds. This solves distribution, at a heavy cost in speed, which is why it is used to establish a symmetric key rather than to move data. It also gives signatures, and with them non-repudiation.
Hashing: a fixed-length fingerprint. FIPS 180-4 specifies seven algorithms, from the original 160-bit function through the 224, 384 and 512-bit variants and two truncated forms, with the property that "any change to the message will, with a very high probability, result in a different message digest." FIPS 202 adds the SHA-3 family — SHA3-224 through SHA3-512 — and the extendable-output functions SHAKE128 and SHAKE256, built on a different internal design, which is their main value: a structural break in one family would not carry to the other.
A hash takes no key, so it proves nothing about origin on its own. Anyone can recompute it. To bind a fingerprint to a sender you need a key: a message authentication code for a shared secret, or a signature for a key pair.
Password hashing is a different problem and uses different functions. A general-purpose hash is designed to be fast, which is exactly wrong for passwords, where the goal is to make each guess expensive. Use a function built to be slow and memory-hard, with a per-password salt.
Key wrapping: encrypting a key with a key. SP 800-175B defines it as "A method of cryptographically protecting the confidentiality and integrity of keys using a symmetric-key algorithm." SP 800-38F specifies two deterministic authenticated-encryption modes of AES for the purpose, the AES Key Wrap and Key Wrap With Padding modes, describing a key-wrap algorithm as one "intended for the protection of cryptographic keys". Both properties are needed: a wrapped key that can be altered undetectably is a key an attacker can substitute.
Where keys live: modules, HSMs and validation
A key in a process's memory is a key in a file one bug away from being readable. The purpose of a cryptographic module is to perform operations with a key without the key leaving it.
Hardware security modules. An HSM generates keys internally, performs operations on request, and is built so the private key cannot be read out. Applications send data in and get results back; they never hold the key. The important consequence is that a compromise of the application becomes a limited ability to use the key while the attacker has access, rather than a permanent copy of it — which converts an unbounded breach into a bounded one.
That distinction is why signing keys and root keys belong in hardware, and it is the lesson of the case in the final lesson of this course.
FIPS 140-3, and what it is. FIPS 140-3 states that it "supersedes FIPS 140-2, Security Requirements for Cryptographic Modules, in its entirety", and that it "aligns with ISO/IEC 19790:2012(E)". It is a standard for the module — the boundary, the physical protections, the key management inside it, the self-tests — not for the algorithms, which are specified elsewhere.
Validation is a programme, not a claim. The Cryptographic Module Validation Program tests modules against the standard. Two facts from its own timeline matter operationally. Modules are "placed on the Active list for 5 years (or 2 years for Interim Validations)", so a certificate has an expiry and a module validated six years ago may no longer be on the list you are required to buy from. And the programme "no longer accepts FIPS 140-2 submissions for new validation certificates", a change dated 22 September 2021, with FIPS 140-2 certificates moved to the Historical list after 21 September 2026 — a date now past.
If your procurement standard says "FIPS 140-2 validated", it is asking for something from a historical list. That is a sentence worth searching your own policies for.
Levels, briefly. The standard defines increasing levels of physical protection and role separation. Where a level matters, it is usually written into someone else's requirement rather than chosen freely: the CA/Browser Forum's Baseline Requirements, for instance, oblige a certificate authority to protect its private key in a system "validated as meeting at least FIPS 140-2 level 3, FIPS 140-3 level 3, or an appropriate Common Criteria Protection Profile or Security Target, EAL 4 (or higher)".
What validation does not tell you. That the module is configured correctly, that the right algorithms are enabled, that keys are backed up somewhere sensible, or that the people with access to it should have it. A validated module used badly is a validated module used badly. The certificate is a statement about the box, and every remaining lesson in this course is about what you do with it.
Envelope encryption and key hierarchies
Encrypting a large amount of data under one key is convenient and leaves you with one problem you cannot solve: rotating it means re-encrypting everything.
The hierarchy. Instead, each object is encrypted under its own data key, and the data key is wrapped — encrypted — under a key-encryption key held somewhere stronger. The wrapped data key is stored alongside the data it protects. To read the object you fetch the wrapped key, ask the key-encryption key to unwrap it, and use the result. This is envelope encryption, and it is how every cloud key management service you have used is built.
What it buys you. Three things that matter operationally:
- Rotation becomes possible. Rotating the key-encryption key means re-wrapping the data keys, which are small and few, rather than re-encrypting terabytes. The data is never touched.
- The strong key does little work. The key-encryption key performs small, infrequent operations, so it can live in an HSM without becoming a throughput bottleneck. The bulk work happens with data keys in the application.
- Deletion gets a shortcut. Destroy the key-encryption key and every data key under it becomes unrecoverable, and with them the data. This is sometimes called crypto-shredding, and it is genuinely useful for deleting data spread across backups you cannot reach individually.
And what it costs you. The same property, read the other way. Destroying or losing that one key destroys everything beneath it, which makes the key-encryption key the single most dangerous object in the estate. Its backup and recovery procedure deserves more attention than anything else in this course, and it should be tested — a recovery procedure nobody has performed is a theory.
Naming the layers. SP 800-152's framework lists twenty-one key types, including a symmetric key-wrapping key and a symmetric master key, which is a useful corrective to the habit of calling everything "the key". When an incident happens, "which key" is the first question, and an estate where every key is called the key cannot answer it.
Where the hierarchy leaks. Three places, in order of how often they are found:
- The plaintext data key in memory, after unwrapping. It is unavoidable but it should be short-lived and never written to a log, a crash dump or a cache.
- The authorisation to unwrap. The hierarchy protects keys from being read, not from being used. Anyone or anything permitted to call unwrap can read the data, so the access policy on the key-encryption key is the access control on the data. People build elaborate hierarchies and then grant unwrap broadly.
- Backups of the wrapped keys taken without the hierarchy, which produces an archive nobody can open — the failure mode that turns a key management mistake into permanent data loss, and the reason restoring from backup has to be tested with the keys of the day.
The design rule. Draw the hierarchy on one page, mark which key is held in hardware, and write beside each key who may use it and who may destroy it. If that page cannot be drawn, the estate does not have a hierarchy; it has an accumulation.
Randomness, the dependency nobody audits
Every key begins as a random number. If the randomness is predictable, the key is predictable, and no amount of algorithm strength matters — an attacker who can reproduce your generator does not need to break AES.
Two components. An entropy source collects genuine unpredictability from physical phenomena, and a deterministic random bit generator stretches it into as many bits as you need. SP 800-90A covers the second, SP 800-90B the first, and they are specified separately because they fail differently.
The seed is a secret. SP 800-90A is blunt about it: "The entropy input and the seed shall be kept secret. The secrecy of this information provides the basis for the security of the DRBG." A seed that is logged, checkpointed into a virtual machine image, or derived from something an attacker can observe makes every subsequent output predictable.
Entropy sources are tested continuously, not once. SP 800-90B exists to specify "the design principles and requirements for the entropy sources used by Random Bit Generators, and the tests for the validation of entropy sources", and it separates health tests into "three categories: start-up tests, continuous tests (primarily on the noise source), and on-demand tests". The reason for continuous testing is that a hardware noise source can degrade or fail while the system keeps running, and a failed noise source does not announce itself — the generator carries on producing output that looks fine.
Min-entropy is the measure, and it is a worst-case one: if a value has min-entropy H, the probability of guessing any particular value is no greater than two to the minus H. Average-case measures flatter a source that is usually unpredictable and occasionally not, which is precisely the source you must not use.
The historical lesson. SP 800-90A Revision 1's own revision history records that "The Dual_EC_DRBG has been removed, and section numbers adjusted accordingly." A standardised generator was withdrawn from the standard that specified it. The practical reading is not suspicion of standards bodies but the opposite: the correction is visible, dated and public, which is what a trustworthy process looks like. An algorithm nobody can inspect cannot be corrected this way.
Where this goes wrong in practice, and it is rarely the algorithm:
- Using the wrong function. Most languages ship a fast generator for simulations and shuffling, and a separate one for cryptography. The names are similar and the fast one is the default in more libraries than it should be.
- Virtual machines and containers cloned from an image. Two instances that start from the same snapshot can start from the same generator state, and will produce the same keys.
- Embedded and early-boot generation. A device generating a key seconds after power-on, before it has accumulated entropy, is the documented cause of real collisions in deployed certificates.
- Nobody checking. Randomness has no symptom when it fails. Nothing slows down and nothing errors.
Transport: what TLS settles and what it leaves
Almost all cryptography most organisations rely on is performed by TLS, configured once and not revisited.
What TLS 1.3 changed. RFC 8446 records the decision plainly: "Static RSA and Diffie-Hellman cipher suites have been removed; all public-key based key exchange mechanisms now provide forward secrecy." Forward secrecy is the property worth understanding: session keys are derived per connection and not recoverable from the server's long-term key, so an attacker who records traffic today and steals the private key next year cannot decrypt what they recorded. Under the older suites they could.
The protocol also narrowed the choices, which is a security feature. A compliant application must implement one named suite — AES in Galois/Counter Mode with a 128-bit key — and should implement two others, one using a 256-bit AES key and one built on the ChaCha20-Poly1305 construction. Three options rather than hundreds, and no way to negotiate down to a broken one.
The old versions are not deprecated as a matter of taste. RFC 8996 is a Best Current Practice and its language is absolute: "TLS 1.0 MUST NOT be used. Negotiation of TLS 1.0 from any version of TLS MUST NOT be permitted." The same for TLS 1.1. It updated an earlier recommendation by "changing SHOULD NOT to MUST NOT", which is the sentence to quote at anyone treating it as advisory. For public-sector requirements, NIST SP 800-52 Revision 2 set a date: "Agencies shall support TLS 1.3 by January 1, 2024."
One sharp edge: 0-RTT. TLS 1.3 allows a client to send data in its first message, which is good for latency and changes the security properties. RFC 8446 requires that a server "MUST ensure that any instance of it ... would accept 0-RTT for the same 0-RTT handshake at most once", and that is hard to guarantee across a fleet of load-balanced servers. Early data is replayable, so it must not carry a request that changes state. A payment submitted over 0-RTT is a payment that may happen twice.
What TLS does not give you. It authenticates the server to the client, by certificate. By default it does not authenticate the client to the server, which is what mutual TLS adds and why service-to-service traffic inside an estate often needs it. It protects data in transit between two endpoints and nothing beyond them — a proxy, a load balancer or a service mesh that terminates TLS sees plaintext, which is a design decision and should be a deliberate one.
And it says nothing about whether the right certificate is presented. Validating the chain is the client's job, and disabled certificate validation — a debugging change that reached production — remains one of the most common serious findings in application security reviews. It is invisible, because everything works.
Certificates became an operational problem
A certificate binds a public key to a name, vouched for by an authority the client trusts. The cryptography is settled; the lifecycle is not, and it has recently become much harder.
Validity periods are collapsing on a published schedule. The CA/Browser Forum's Baseline Requirements now step the maximum validity of a publicly trusted TLS server certificate down in stages — from 398 days to 200, then 100, then 47 — on 15 March 2026, 15 March 2027 and 15 March 2029. The requirement for the first step reads: "Subscriber Certificates issued on or after 2026-03-15 and before 2027-03-15 SHOULD NOT have a Validity Period greater than 199 days and MUST NOT have a Validity Period greater than 200 days." The last step is specified the same way: from 15 March 2029, not greater than 47 days.
The ballot that introduced the schedule, SC081v3, passed with twenty-five certificate issuers in favour and none against, and the four browser consumers — Apple, Google, Microsoft and Mozilla — also in favour. It is not a proposal under discussion.
What that actually means. A 47-day certificate must be replaced roughly eight times a year. Any process involving a person raising a ticket, a person approving it and a person installing it will fail, not occasionally but as a matter of arithmetic. Certificate renewal has to be automated before 2029, and the organisations that will struggle are the ones whose certificates are installed on appliances, embedded devices and systems whose vendors never anticipated this.
The same requirements shorten how long validation evidence may be reused — domain validation data reuse falls to ten days from 15 March 2029 — so the authorisation step is being automated too, not only the issuance.
Revocation is the weaker half. The requirements oblige a CA to revoke within 24 hours in defined circumstances, and the practical difficulty has always been the other end: clients check revocation inconsistently, and a client that cannot reach the status service usually proceeds. Short validity periods are, in part, an answer to this — a certificate that expires in 47 days limits the damage of one that cannot be revoked effectively.
The inventory problem, again. You cannot automate the renewal of a certificate you do not know about, and the expiry of an unknown certificate is an outage with no warning. Most organisations discover their certificate inventory is incomplete at the moment one expires.
What to do now, in order. Find them all, including internal ones and those on appliances. Automate issuance and installation where the platform allows it. For anything that cannot be automated, record why and who owns it, because that list is your 2029 work. And monitor expiry independently of the system that issues them, so a failed renewal is noticed before a customer notices it.
Deprecated, disallowed, and the ones you must stop using
Algorithms are retired on a schedule, and the vocabulary is precise. SP 800-131A Revision 2 defines it: "Deprecated means that the algorithm and key length may be used, but the user must accept some security risk". Disallowed means it may not be used for applying protection at all.
The distinction matters because it tells you what action is required. Deprecated is a decision to make and record. Disallowed is a date by which something must have changed.
Triple DES. SP 800-131A states that "encryption using three-key TDEA is deprecated through December 31, 2023 using the approved encryption modes", and SP 800-57 notes that although 3TDEA is listed as providing 112 bits of security strength, "its use has been deprecated (see SP 800-131A) through 2023, after which it will be disallowed". That date has passed. Three-key Triple DES is not a legacy option to be scheduled; it is disallowed, and it is still present in payment terminals, mainframe interfaces and bank-to-bank links across the industry.
SHA-1. SP 800-131A: "SHA-1 may only be used for digital signature generation where specifically allowed by NIST protocol-specific guidance." Collisions in SHA-1 have been demonstrated in practice, which breaks exactly the property a signature needs. It survives in legacy integrity checks, in older certificate chains, and in git object identifiers — the last being a case where the use is not a security claim, which is the kind of distinction worth making rather than issuing a blanket ban nobody can comply with.
Key lengths. RSA below 2048 bits is below 112 bits of security strength and belongs in the same category. The awkward cases are not the obvious ones but the embedded ones: a device with a 1024-bit key burned into firmware, a root certificate in a product shipped a decade ago, a hardware module that cannot be upgraded.
Why these persist, honestly. Not ignorance. They persist because the weak algorithm is on the far side of an interface you do not own — a payment network, a government gateway, a partner's system, a device with no update path. The work is therefore less about your own code than about a list of counterparties and a conversation with each.
So the deliverable is a list, not a policy. For every deprecated or disallowed algorithm still in use: where it is, why it is still there, who owns the dependency, what the replacement is, and the date. An entry reading "legacy, to be addressed" is not an entry.
And one caution about the word "weak". An algorithm being deprecated does not mean an attacker is currently reading your traffic. It means the margin has eroded and the standards body has decided the risk is no longer one it will underwrite. Treating every deprecation as an emergency exhausts the credibility you need for the ones that are — and the post-quantum transition in the next lesson is a decade of exactly this kind of judgement.
Post-quantum: what was standardised, and by when
A sufficiently capable quantum computer would break the public-key cryptography in use today — the key exchange that protects TLS, and the signatures that underpin certificates and software updates. Symmetric algorithms such as AES are far less affected. The threat is specific, not general.
It is standardised, not speculative. On 13 August 2024 NIST published three standards, each effective immediately on final publication:
- FIPS 203, ML-KEM, a key-encapsulation mechanism, with "three parameter sets ... In order of increasing security strength and decreasing performance, these are ML-KEM-512, ML-KEM-768, and ML-KEM-1024."
- FIPS 204, ML-DSA, a signature scheme, with the parameter choices ML-DSA-44, ML-DSA-65 and ML-DSA-87, and "believed to be secure, even against adversaries in possession of a large-scale quantum computer."
- FIPS 205, SLH-DSA, a second signature scheme built on hash functions rather than lattices — a deliberate hedge, so that a break in one mathematical family does not leave the world without signatures.
The sizes are the engineering problem. ML-KEM-768 has an encapsulation key of 1,184 bytes and a ciphertext of 1,088; ML-DSA public keys run from 1,312 to 2,592 bytes and signatures from 2,420 to 4,627. Those are an order of magnitude larger than the elliptic-curve equivalents they replace. Anything with a fixed-size field, a small packet budget, a constrained device or a certificate size assumption will need changing, and that is where the work is — not in the mathematics.
The dates. NIST IR 8547, published in October 2026, states the policy: "NIST will deprecate quantum-vulnerable public-key cryptography after 2030 and disallow its use under NIST standards and guidelines after 2035." Its transition table is explicit for RSA at 112 bits or more of classical strength — "Deprecated after 2030 Disallowed after 2035" — and it records that National Security Memorandum 10 "established 2035 as the target for completing the federal migration to post-quantum cryptography."
Read against the previous lesson's vocabulary, that is a decision to make by 2030 and a deadline of 2035.
Harvest now, decrypt later. The reason this is not a 2030 problem is that encrypted traffic recorded today can be decrypted later. For anything whose confidentiality must survive a decade or more — long-lived records, health data, state secrets, intellectual property — the exposure began when the data was first transmitted. Signatures are different: a signature only needs to resist attack while it is relied upon, so the urgency is lower but the dependency is deeper, since signatures sit inside firmware verification and certificate chains that are hard to change.
What to do first, and none of it requires choosing an algorithm: find out where public-key cryptography is used, which of it protects data that must stay confidential past 2035, and which of your vendors have published a plan. The next lesson is how that inventory gets built.
Crypto-agility, the inventory, and the law
The transitions in the last two lessons are not the last ones. The capability worth building is the ability to change algorithms at all.
The definition. NIST's CSWP 39-upd1 puts it as "the capabilities needed to replace and adapt cryptographic algorithms in protocols, applications, software, hardware, firmware, and infrastructures while preserving security and ongoing operations." The last clause is the hard part: changing algorithms while the service keeps running, for two parties who must agree.
Note the version. The original CSWP 39 was withdrawn on 29 June 2026 and "superseded in its entirety by NIST CSWP 39-upd1" — a reminder that guidance in this area moves, and that citing the document you read two years ago is a mistake with a date on it.
It starts with the inventory, and that is the whole difficulty. CSWP 39-upd1's strategic steps begin: "Inventory the use of cryptography for data protection across the organization by adopting an assets-centric approach informed by the criticality of the data." The joint CISA, NSA and NIST quantum-readiness factsheet makes the same point as a prerequisite: "Having an inventory of quantum-vulnerable systems and assets enables an organization to begin the quantum risk assessment processes, demonstrating the prioritization of migration." Its overall instruction is to prepare now "by creating quantum-readiness roadmaps, conducting inventories, applying risk assessments and analysis, and engaging vendors."
Engaging vendors is doing more work in that sentence than it appears to. Most cryptography in an estate is inside purchased software, appliances and services, and the organisation's migration timetable is the slowest of its suppliers'.
Automation is the only way this scales. CISA's strategy for automated discovery and inventory tools exists because manual inventories are out of date before they are finished: "The inventory tools automate the collection of the cryptographic characteristics required for the inventory." A manual inventory is a photograph; what is needed is a feed.
What agility looks like in code. Algorithms named in configuration rather than compiled in. Protocol versions negotiated rather than fixed. Key and signature sizes not assumed by a database column or a message field. Certificate handling that does not break on a larger key. And a tested path for changing an algorithm — because an untested path is a plan.
The legal layer, which drives the priority. Encryption appears in data protection law as a measure rather than a mandate, and the wording repays attention. The GDPR's Article 32 requires measures "including inter alia as appropriate: (a) the pseudonymisation and encryption of personal data". Article 34(3)(a) is the one with teeth: where measures render the data "unintelligible to any person who is not authorised to access it, such as encryption", notification to affected individuals may not be required.
Kenya's Data Protection Act, 2019 is framed the same way — section 41(4) says the controller or processor "shall consider measures such as ... the pseudonymisation and encryption of personal data", and section 2 defines encryption as "the process of converting the content of any readable data using technical means into coded form". It is a duty to consider, which means a documented decision, not an absolute requirement. Where there is a breach, section 43(1)(a) requires notifying the Data Commissioner "without delay, within seventy-two hours of becoming aware" where there is a real risk of harm. Encryption is what can keep a lost dataset from becoming a notifiable breach — which is the clearest commercial argument for getting key management right.
One national example, on who may issue a certificate at all. The Communications Authority of Kenya licenses Electronic Certification Service Providers under the Kenya Information and Communications Act, Cap 411A. Its licence terms run for fifteen years, and condition 4.1 is the one to notice: a licensee may provide electronic certification services only once it has obtained accreditation from the Authority. A licence is therefore not permission to issue certificates; accreditation is a separate gate. The Authority manages the National Public Key Infrastructure and has accredited the ICT Authority as the provider for the Government of Kenya. The licence also sets operational duties a buyer can ask about: on a verified suspension request, the revocation list must be updated and digitally signed within one hour, and subscribers informed within the hour.
It is widely reported that systems designated as critical information infrastructure must use certificates and public key infrastructure only from licensed and accredited providers from 1 January 2026, under Gazette Notice 1043. That obligation could not be checked against a primary document here: the published accounts disagree about the dates of the instruments involved. Read the Gazette itself before relying on the date.
When key management fails: a documented case
In July 2023 Microsoft disclosed that an actor it tracks as Storm-0558 had forged authentication tokens using a stolen signing key and accessed the Exchange Online mailboxes of around twenty-five organisations, including government agencies. The US Cyber Safety Review Board reviewed it and published its findings in March 2024. It is the best-documented key management failure available, and every lesson in this course appears in it.
Why a signing key. The Board's framing is worth quoting: "Signing keys, used for secure authentication into remote systems, are the cryptographic equivalent of crown jewels for any cloud service provider." A signing key does not decrypt data. It allows its holder to create credentials that systems will accept — which is why the consequence was access to many organisations rather than one.
The cryptoperiod that was not enforced. The key involved dated from 2016. The Board records that "this 2016 MSA key was originally intended to be retired in March 2021, but its removal was delayed due to unforeseen challenges associated with hardening the consumer key systems." A retirement date was set and passed, for reasons that were operational rather than careless. This is the ordinary way cryptoperiods fail — not a decision to keep a key forever, but a migration that was harder than expected and a date that slipped quietly.
Why it slipped. "Initially, the consumer MSA system had no process for automated signing key rotation or deactivation and utilized a manual process instead." Lesson two of this course in one sentence: rotation that depends on people is rotation that does not happen on schedule.
And the finding that should be read twice. "As of the date of this report, Microsoft does not know how or when Storm-0558 obtained the signing key." A mature organisation, after a lengthy investigation, could not establish how its most sensitive key left its control. That is what the absence of hardware protection and the absence of lifecycle logging look like after the event: not a wrong answer, but no answer.
What the Board recommended is the content of lessons two, four and five: "automated regular key rotation; storage of keys in segmented and isolated key systems (e.g., hardware security modules [HSMs] or similar)".
The lessons to carry out of this course:
- A signing key is more dangerous than an encryption key, because it manufactures trust rather than guarding data. Hold it in hardware, and nowhere else.
- A retirement date without automation is an intention. If rotation needs a person, write down who and when, and expect it to slip.
- Log the lifecycle, not just the use. Being unable to say how a key was obtained is a logging failure, and it is discovered at the worst possible moment.
- Scope the blast radius before the incident. Ask what a stolen key would let someone do, how many customers it reaches, and how you would know. If the answer is "we could not tell", that is the finding, and it is available to you today without anyone attacking anything.
Fifty questions
Answer all fifty questions, then check your answers. You need 45 out of 50 to pass and receive a certificate. If you score less, you will see which answers were right and wrong, and then go through the course again before you retake the check. Your answers, progress and times are kept only in this browser.
Your answers
Your certificate of completion
Enter your name as you want it to appear, then save the certificate as a PDF. In the print window, choose Save as PDF. A certificate is issued once per completion of the course.
Rate this course
How would you rate this course? Your rating is anonymous — just a number, with no name and no account.
Bring this to your team
Your colleagues can take this course too — it is free, needs no sign-up, and nothing they enter leaves their browser. If your institution wants the same ground covered as structured training for a team, with an instructor and your own cases, we run courses in a classroom or online for groups of ten or more.
Talk to us about training your team → See the paid courses →
Saolix does not record who takes this course, so it cannot verify these certificates. The certificate confirms completion of a free self-paced course and is not an accredited qualification.
Standards and frameworks covered
The published frameworks this course teaches toward. Saolix is not affiliated with, endorsed by or accredited by any of these bodies; naming a standard is a citation, not a claim about its author.
Sources
The official documents this course relies on. Laws and guidance change, so check the current version.
- SP 800-57 Part 1 Rev. 5: Recommendation for Key Management, Part 1 - General (May 2020) · US National Institute of Standards and Technology (NIST)
- SP 800-175B Rev. 1: Guideline for Using Cryptographic Standards in the Federal Government (March 2020) · NIST
- SP 800-152: A Profile for U.S. Federal Cryptographic Key Management Systems (October 2015) · NIST
- SP 800-38F: Methods for Key Wrapping (December 2012) · NIST
- FIPS 140-3: Security Requirements for Cryptographic Modules (March 2019) · NIST
- Cryptographic Module Validation Program: validation timeline · NIST Computer Security Resource Center
- FIPS 197: Advanced Encryption Standard (AES), updated May 2023 · NIST
- FIPS 180-4: Secure Hash Standard (August 2015) · NIST
- FIPS 202: SHA-3 Standard (August 2015) · NIST
- SP 800-90A Rev. 1: Random Number Generation Using Deterministic Random Bit Generators (June 2015) · NIST
- SP 800-90B: Entropy Sources Used for Random Bit Generation (January 2018) · NIST
- RFC 8446: The Transport Layer Security (TLS) Protocol Version 1.3 (August 2018) · Internet Engineering Task Force (IETF)
- RFC 8996: Deprecating TLS 1.0 and TLS 1.1 (BCP 195, March 2021) · IETF
- SP 800-52 Rev. 2: Selection, Configuration and Use of TLS Implementations (August 2019) · NIST
- Baseline Requirements for the Issuance and Management of Publicly-Trusted TLS Server Certificates, v2.3.1 (4 October 2026) · CA/Browser Forum
- Ballot SC081v3: Introduce Schedule of Reducing Validity and Data Reuse Periods (April 2025) · CA/Browser Forum
- SP 800-131A Rev. 2: Transitioning the Use of Cryptographic Algorithms and Key Lengths (March 2019) · NIST
- FIPS 203: Module-Lattice-Based Key-Encapsulation Mechanism Standard (ML-KEM, August 2024) · NIST
- FIPS 204: Module-Lattice-Based Digital Signature Standard (ML-DSA, August 2024) · NIST
- FIPS 205: Stateless Hash-Based Digital Signature Standard (SLH-DSA, August 2024) · NIST
- NIST IR 8547: Transition to Post-Quantum Cryptography Standards (October 2026) · NIST
- CSWP 39-upd1: Considerations for Achieving Crypto Agility (updated June 2026) · NIST
- Quantum-Readiness: Migration to Post-Quantum Cryptography (August 2023) · US Cybersecurity and Infrastructure Security Agency (CISA), with the NSA and NIST
- Strategy for Migrating to Automated Post-Quantum Cryptography Discovery and Inventory Tools (August 2024) · CISA
- Review of the Summer 2023 Microsoft Exchange Online Intrusion (March 2024) · US Cyber Safety Review Board
- Regulation (EU) 2016/679 (General Data Protection Regulation), Articles 32 to 34 · Official Journal of the European Union, via EUR-Lex
- Data Protection Act, 2019 (No. 24 of 2019), sections 2, 41 and 43 · Office of the Data Protection Commissioner, Kenya
- Electronic Certification Services Provider (E-CSP) licence terms (condition 4.1, accreditation; fifteen-year licence; one-hour revocation list duty) · Communications Authority of Kenya
- National Public Key Infrastructure (the Authority as manager; the ICT Authority accredited for the Government of Kenya) · Communications Authority of Kenya



