Wireless Encryption Generations

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.

// 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],
];

// 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.

// 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.