--- title: 'Wireless Encryption Generations' source: 'https://academia.sh/en/courses/network-security/wireless-encryption-generations' course: 'Network Security' language: en updated: '2026-09-26T03:02:54+00:00' license: 'CC BY-SA 4.0' objectives: - 'Lists the claims a wireless connection carries and counts how many each generation proves' - 'Compares the four generations against the same claim set, listing proven, weakly proven, and unproven claims separately' - 'Calculates the cost of a generation upgrade in the device inventory and derives the classes left out' - 'Measures how resistance to offline guessing depends on both the shared secret composition and the generation' --- # Wireless Encryption Generations Four wireless encryption generations are measured against the same set of ten claims: the old generation built on a stream cipher proves none of the ten claims, the generation using a block cipher in counter mode proves five, and the simultaneous-authentication generation raises that to seven. The cost of the transition is counted in the device inventory: when the top generation is made mandatory, four thousand three hundred twenty-one of four thousand five hundred forty devices are left out. The previous topic drew the perimeter: zones were separated, checkpoints were placed, and rules were put in order. All of those boundaries shared one common foundation — that a message had entered through a specific cable. The wireless layer has no such foundation. A signal does not stop at the building wall; whether the device receiving a frame is inside or outside the building cannot be read from the frame itself. So in this topic, encryption does the work the cable used to do. The difference between generations is not one of speed or compatibility; it is a difference in **which claim can be proven**. This lesson refers to the four generations not by generation name but by the properties they carry, and runs all of them against the same set of ten claims: how many are proven, how many stay open, and how many devices the upgrade costs. - **WS1.** The fictional regional measurement network is treated on its wireless side: branch networks, the field teams' handheld terminals, and the aggregation network the meter endpoints connect to. No real network is set up and no real network name or location is written; what is measured is the model built with `node`. - **WS2.** A claim is a proposition that one party asserts while a connection is being established and the other party accepts. It takes three values: proven, weakly proven (breakable with a finite amount of work), or unproven. - **WS3.** The generations are reduced to four classes: the old generation, which mixes a stream cipher with a static key and a short counter; the transitional generation, which keeps the same stream cipher but derives a separate key for every frame; the generation that uses a block cipher in counter mode and verifies integrity with the same key; and the simultaneous-authentication generation, which derives a fresh key from the shared secret for every session. - **WS4.** The device inventory is fictional; the top generation each class supports is a model decision. - **WS5.** The offline guessing rate is a fictional model constant and varies with hardware; the comparison is made for the ratio between two generations, not for absolute time. - **WS6.** The claims the generations carry are treated here only on the **verification** axis; the encryption algorithms themselves are the subject of M24/K04. ## The Claims a Connection Carries A device does not ask a single question when connecting to a wireless network. It accepts ten separate propositions, and it accepts most of them without asking. ```js // generations.mjs — claim table for wireless generations (model). Generations are referred to // not by name but by the property they carry. Fictional regional measurement network; no real network is set up. export const GENERATION = [ ['stream-cipher-short-counter', 'generation that mixes a stream cipher with a static key and a short counter'], ['stream-cipher-per-frame-key', 'generation that keeps the same stream cipher but derives a separate key for every frame'], ['block-cipher-counter-mode', 'generation that uses a block cipher in counter mode and verifies integrity with the same key'], ['simultaneous-authentication', 'simultaneous-authentication generation that derives a fresh key from the shared secret for every session'], ]; // Claims carried while a connection is being established. Value: 2 = proven, 1 = weak proof // (breakable with a finite amount of work), 0 = no proof at all. export const CLAIM = [ ['network name is correct', [0, 0, 0, 0]], ['client knows the secret', [1, 2, 2, 2]], ['access point knows the secret', [0, 1, 2, 2]], ['frame content is unchanged', [1, 1, 2, 2]], ['frame is not a replay', [0, 2, 2, 2]], ['key is specific to this session', [0, 1, 2, 2]], ['past traffic cannot be decrypted', [0, 0, 0, 2]], ['management frame came from the network', [0, 0, 0, 1]], ['passphrase cannot be tried offline', [0, 0, 0, 2]], ['source address is correct', [0, 0, 0, 0]], ]; // Device classes in the fictional measurement network: [class, count, top generation supported (index)] export const DEVICE = [ ['meter endpoint (old series)', 1840, 0], ['meter endpoint (new series)', 2260, 2], ['field handheld terminal', 145, 2], ['field handheld terminal (old)', 38, 1], ['branch laptop', 210, 3], ['barcode printer', 26, 1], ['panel display', 12, 2], ['maintenance laptop', 9, 3], ]; ``` ```js // run1.mjs — how many claims each generation proves, how many stay open import { GENERATION, CLAIM } from './generations.mjs'; const LEVEL = ['none', 'weak', 'proven']; const E = [41, 8, 8, 8, 8]; const row = (h) => h.map((d, i) => String(d)[i ? 'padStart' : 'padEnd'](E[i])).join(''); console.log(row(['claim', 'gen1', 'gen2', 'gen3', 'gen4'])); for (const [name, d] of CLAIM) console.log(row([name, ...d.map((v) => LEVEL[v])])); const count = (k, v) => CLAIM.filter(([, d]) => d[k] === v).length; const S = [34, 12, 8, 12, 14]; const row2 = (h) => h.map((d, i) => String(d)[i ? 'padStart' : 'padEnd'](S[i])).join(''); console.log('\n' + row2(['generation', 'proven', 'weak', 'unproven', 'open claims'])); GENERATION.forEach(([name], k) => console.log(row2([name, count(k, 2), count(k, 1), count(k, 0), count(k, 1) + count(k, 0)]))); ``` ``` claim gen1 gen2 gen3 gen4 network name is correct none none none none client knows the secret weak proven proven proven access point knows the secret none weak proven proven frame content is unchanged weak weak proven proven frame is not a replay none proven proven proven key is specific to this session none weak proven proven past traffic cannot be decrypted none none none proven management frame came from the network none none none weak passphrase cannot be tried offline none none none proven source address is correct none none none none generation proven weak unproven open claims stream-cipher-short-counter 0 2 8 10 stream-cipher-per-frame-key 2 3 5 8 block-cipher-counter-mode 5 0 5 5 simultaneous-authentication 7 1 2 3 ``` The number in the first row is the starting point of this topic: the old generation proves **none** of the ten claims. Two claims have weak proof, eight have none at all. The two weak ones are weak for the same reason: because the counter that changes per frame is short, the same value repeats once enough frames accumulate, and a repeated value makes both the content and the integrity sum solvable. This generation's problem is not the absence of encryption but that the proof is exhausted by a **finite amount of work**. The transitional generation ties two claims to proof and leaves three weak. The item it actually gains is replay protection: because a sequence counter is added, a previously seen frame being replayed is rejected. But because the stream cipher stays in place, integrity and session separation still rest on a derived mixing operation; there is proof, it is just not complete. The third generation ties five claims to proof and **zeroes out** the weak column. This is the most important thing to read in this table: weak proof disappears, but the number of unproven claims stays at five — from five to five, no change at all. Strengthening the encryption does not turn a claim that has **no** proof into a proven one. ## Two Claims That Never Close The fourth generation ties seven claims to proof, and two rows of the table stay empty **in all four columns**: the correctness of the network name and the correctness of the source address. These are not randomly chosen claims. The network name is an announcement the access point makes about itself, and it is broadcast before a connection is established — that is, before any key comes into play. Encryption begins after the connection; no generation signs the announcement made before the connection. The source address is in the same place: the address field in the frame header is not encrypted, because the frame has to be readable in order to reach the correct recipient. These two rows determine the rest of this topic. The third lesson will measure the network name claim, the fourth lesson will measure the management frame claim — both are claims that stay outside the encryption generation's scope, and upgrading the generation closes neither. The two items the fourth generation gains, however, belong to a separate class. **Past traffic cannot be decrypted** means that even if the shared secret is learned later, sessions recorded earlier cannot be solved; in the other three generations this claim has no proof at all, meaning traffic recorded today can be decrypted tomorrow with a password learned later. **The passphrase cannot be tried offline** is a measurable item, and the run below turns it into a number. ## The Cost of the Upgrade Choosing a generation is not a preference, it is an inventory decision. The lowest mandatory generation leaves out of the network every device that does not support it. ```js // run2.mjs — cost of the generation upgrade: devices left out and resistance to offline guessing import { GENERATION, CLAIM, DEVICE } from './generations.mjs'; const TOTAL = DEVICE.reduce((s, [, n]) => s + n, 0); const open = (k) => CLAIM.filter(([, d]) => d[k] < 2).length; const E = [34, 10, 12, 10, 13]; const row = (h) => h.map((d, i) => String(d)[i ? 'padStart' : 'padEnd'](E[i])).join(''); console.log(`devices ${TOTAL}, classes ${DEVICE.length}`); console.log(row(['minimum mandatory generation', 'connected', 'left out', 'classes', 'open claims'])); GENERATION.forEach(([name], k) => { const out = DEVICE.filter(([, , m]) => m < k); console.log(row([name, TOTAL - out.reduce((s, [, n]) => s + n, 0), out.reduce((s, [, n]) => s + n, 0), out.length, open(k)])); }); console.log('\nclasses left out (if the top generation is made mandatory):'); for (const [name, n, m] of DEVICE.filter(([, , m]) => m < GENERATION.length - 1)) console.log(` ${name.padEnd(32)}${String(n).padStart(6)} top support: gen${m + 1}`); // Offline guessing resistance. The rate is a fictional model constant; the real value depends on hardware. // Generations 1-3: a candidate passphrase can be tried from a captured handshake without talking to the network. // Generation 4: every attempt requires a round trip with the network; the access point's rate is the limit. const OFFLINE = 400000, ONLINE = 3, YEAR = 365 * 24 * 3600; const duration = (u, h) => u / h / YEAR; const format = (y) => y < 1 ? `${(y * 365).toFixed(1)} days` : y < 1e6 ? `${y.toFixed(0)} years` : `${y.toExponential(1)} years`; const P = [30, 14, 18, 21]; const row2 = (h) => h.map((d, i) => String(d)[i ? 'padStart' : 'padEnd'](P[i])).join(''); console.log('\n' + row2(['shared secret composition', 'candidate count', 'offline', 'network round trip'])); for (const [name, u] of [['8 lowercase letters', 26 ** 8], ['10 letters and digits', 36 ** 10], ['12 letters, digits, symbols', 72 ** 12], ['4 words (7776-word list)', 7776 ** 4]]) console.log(row2([name, u.toExponential(1), format(duration(u, OFFLINE)), format(duration(u, ONLINE))])); ``` ``` devices 4540, classes 8 minimum mandatory generation connected left out classes open claims stream-cipher-short-counter 4540 0 0 10 stream-cipher-per-frame-key 2700 1840 1 8 block-cipher-counter-mode 2636 1904 3 5 simultaneous-authentication 219 4321 6 3 classes left out (if the top generation is made mandatory): meter endpoint (old series) 1840 top support: gen1 meter endpoint (new series) 2260 top support: gen3 field handheld terminal 145 top support: gen3 field handheld terminal (old) 38 top support: gen2 barcode printer 26 top support: gen2 panel display 12 top support: gen3 shared secret composition candidate count offline network round trip 8 lowercase letters 2.1e+11 6.0 days 2207 years 10 letters and digits 3.7e+15 290 years 3.9e+7 years 12 letters, digits, symbols 1.9e+22 1.5e+9 years 2.1e+14 years 4 words (7776-word list) 3.7e+15 290 years 3.9e+7 years ``` Two columns of the first table decide this lesson's conclusion. When the third generation is made mandatory, **one thousand nine hundred four** of four thousand five hundred forty devices are left out, and open claims drop from ten to five. When the fourth generation is made mandatory, open claims drop to three, but connectable devices fall to **two hundred nineteen**: all of the meter endpoints, all of the field terminals, and the panel displays are left out. The second column read on its own cannot decide anything. Moving to the top generation closes two more open claims; in exchange, four thousand three hundred twenty-one devices do not work unless replaced. This is not a network decision, it is a budget decision, and that is why real organizations usually pick the third row: zeroing out weak proof in exchange for an acceptable device loss. The table has a silent assumption: every row assumes that a **single** generation is made mandatory. The common workaround for avoiding the device loss is to leave the access point accepting two generations at once. In that case no device is left out, but the number of open claims is not the top generation's number but the **bottom generation's**: a client chooses for itself which generation to connect with, and the lowest accepted generation is an accessible option for every connection on the network. A network that accepts two generations together measures not five but ten; the first row of the table is that network's row. The measurement does not show a second thing: where the left-out devices go. In practice they are not deleted, they are **moved to a separate network**. That network runs on the first or second generation, meaning it carries its own column's open-claim count. The second network opened for the one thousand eight hundred forty meter endpoints keeps a connection with ten open claims inside the organization; the five claims gained are not gained where those devices are. This is the correct reading: the upgrade does not reduce open claims, it **moves the open claim to a different zone** — and how that zone is separated is the segmentation question from the previous topic. ## The Measure of Offline Guessing The second table counts the fourth generation's most concrete item. In the first three generations, if the messages exchanged while a connection is being established can be captured, candidate shared secrets can be tried without ever talking to the network: the number of attempts is limited not by the network but by the processing power of the party doing the guessing. In the fourth generation, every attempt requires a round trip with the network, meaning the limit is the rate the access point accepts. The difference shows up in the numbers. An eight-lowercase-letter shared secret is exhausted offline in **six days**; the same secret takes two thousand two hundred years when a network round trip is required. The ratio between them is the ratio of the model constants: four hundred thousand per second against three per second. The bottom two rows deliver a second conclusion. A ten-character letter-and-digit composition and a four-word phrase give the **same** candidate count — three point seven times ten to the fifteenth — and both hold out offline for two hundred ninety years. The same resistance can be reached in two different forms; which one to choose is not a security question but a question of what can be typed into a device. The twelve-character wide composition already makes offline guessing meaningless, but it is also the most expensive string to enter by hand into a meter endpoint. The rule that follows is this: in the first three generations, the length of the shared secret is not a configuration preference, it is the **only line of defense**. In the fourth generation, the same secret cannot be tried offline even if it is short; the real thing the generation gains is that the protocol carries the weakness in the user's choice. ## Summary - A wireless connection carries ten claims. The old generation, which mixes a stream cipher with a short counter, proves **none** of them: two weak proofs, eight unproven claims. - The generation that uses a block cipher in counter mode zeroes out the weak-proof column and ties five claims to proof; the number of unproven claims stays at five. Strengthening the encryption does not turn a claim with no proof into a proven one. - The correctness of the network name and the source address stay unproven **in all four generations**; both are carried before a connection is established or openly in the header, so neither falls within any generation's scope. - When the third generation is made mandatory, 1,904 of 4,540 devices are left out; when the fourth generation is made mandatory, 4,321 are. The left-out devices are not deleted, they are moved to a separate network — the open claim does not decrease, it changes location. - An eight-lowercase-letter shared secret is exhausted offline in 6 days, and holds out for 2,207 years when a network round trip is required. A four-word phrase and a ten-character letter-and-digit composition give the same candidate count. ## Next Step This lesson measured the length of the shared secret but never asked **who it belongs to**. All four generations had a single string, and that string was identical across one thousand eight hundred forty meter endpoints, two hundred ten branch laptops, and one hundred forty-five field terminals. When a person leaves, a terminal is lost, or a meter endpoint is unmounted and taken, that string is still valid, and changing it means touching every device separately. The next lesson's question is where the trust root stands: how many items a single shared secret grants access to, how many items a per-person identity separates, how many steps revoking an identity takes, and what additional infrastructure items a per-person identity requires.