haxtory/src/philes.js

// philes.js — the lore, and all of it in one place.
//
// Text files. The collectible. None of this is delivered by a cutscene and none of
// it is required. The design says the writing budget goes here, so it goes here:
// levels call ctx.phile('id') and the words live in this file, which means adding
// the next hundred is a writing job and not a code job.
//
// Voice rule: each one is written by somebody, in the year it happened, who did not
// know they were in a game. Nobody explains anything for the player's benefit.

export const PHILES = {

  // ── hop 1–9 ────────────────────────────────────────────────────────────

  'ring-buffer': {
    title: 'nic0: tx ring, 512 descriptors',
    from: 'a comment in a driver, 1994',
    body: `/* The ring is 512 entries because 512 is a nice number and because the
   card's DMA engine wraps at a power of two. Head chases tail. Tail chases
   head. Neither ever arrives.

   If you are reading this because something is stuck, check that you
   actually wrote the tail pointer back. It is always the tail pointer. */`,
  },

  'osi': {
    title: 'the seven layers, as built',
    from: 'ISO/IEC 7498-1, and what actually happened',
    body: `the model has seven layers.

the thing that won has four, does not match the model, was designed by
people who were not in the room, and shipped first.

everybody still teaches the seven. everybody still runs the four. the gap
between those two facts is where roughly half of this is hiding.`,
  },

  'layers': {
    title: 'what each layer is actually for',
    from: 'the thing the model is trying to tell you',
    body: `every layer is a different job, and the job is the interesting part.

presentation is about representation — the same bytes mean two things and
somebody has to agree which. session is about state that has to be kept
alive or it stops existing. transport is about order, because the network
does not promise you any. network is about which way to go and how many
hops it costs. data link is about sharing one wire without shouting over
each other. physical is a voltage on a piece of copper and nothing else.

none of that is "the same job at a different altitude". that is why the
model has seven of them.`,
  },

  'firewall': {
    title: 'stateful inspection',
    from: 'a whitepaper, 1994',
    body: `the innovation is that the firewall remembers.

it does not just look at a packet and decide. it keeps a table of every
conversation it has allowed, and when something arrives it asks: is this
part of something we already started?

which means the way in is not through the wall. the way in is to be
mistaken for the second half of a sentence the wall began.`,
  },

  'timewait': {
    title: 'why 2MSL',
    from: 'RFC 793, September 1981',
    body: `the connection stays in TIME-WAIT for twice the maximum segment lifetime.

this is so that any duplicate segments still wandering the network have
expired before the same pair of addresses and ports could be reused, and
be delivered to a connection that has nothing to do with them.

it is a waiting room for things that are already over, kept open in case
something arrives late. it is not for the connection. it is for the
segments that have not stopped travelling yet.`,
  },

  'fin': {
    title: 'the four-way close',
    from: 'FIN, FIN-ACK, ACK, and the one before it',
    body: `it takes three packets to open a connection and four to close one.

opening is quicker than closing. everybody who has ever run a network has
noticed this and nobody has ever found it strange enough to write down.`,
  },

  // ── hop 10–20 ──────────────────────────────────────────────────────────

  'netsplit': {
    title: 'riding the split',
    from: '#2600, EFnet, some time in 1998',
    body: `when the servers lose each other the channel tears in half. your half
still exists. it just has almost nobody in it.

so you take ops in a room with nobody in it, which nobody can stop you
doing, and you wait. when the servers find each other again they merge the
two channels, and the merge does not adjudicate. it just unions.

you were opped. now you are opped in the real one.

this was not a bug anybody could point at. it was two reasonable rules
having a child.`,
  },

  'sub7': {
    title: 'Back Orifice',
    from: 'cDc, DEF CON 6, 1 August 1998',
    body: `they shipped it as a remote administration tool, which is exactly what it
was, and named it after a Microsoft product, which is exactly what the
joke was.

the argument was: this is not new, this is what the operating system
already lets anyone do, and we have simply made it easy enough that you
will finally have to care.

they were right and it did not help anybody.`,
  },

  'ageout': {
    title: '2MSL expired',
    from: 'the chair by the wall',
    body: `they were halfway through a sentence.

nobody in the room looked up. not one of them. it is not callousness — it
is that every single person in there has watched it happen more times than
they can count, and there is no ceremony for it, and inventing one would
be worse.

the chair is still there. it goes on being a chair.`,
  },

  'msl': {
    title: 'a full lap',
    from: 'two minutes',
    body: `you stayed for the whole clock.

nothing was down here. no item, no door, no achievement. the clock is for
the segments, not for you, and you waited it out anyway on the off chance
that waiting was the point.

it was, a bit.`,
  },

  'armsrace': {
    title: 'the half-life of an exploit',
    from: 'every single one of them',
    body: `it works. for about a fortnight it works on everything, everywhere,
against everyone, and it feels like you have found a door in the world.

then somebody writes four lines of patch and posts it, and within a month
it works on nothing, and it will never work again, and the only thing you
actually own is having been there while it did.

an exploit is not a tool. it is a window that is already closing while you
are climbing through it.`,
  },

  'smurf': {
    title: 'smurf',
    from: 'ICMP, and a badly configured router',
    body: `you send one echo request. you forge the source address so it looks like
it came from whoever you dislike. you send it to a network's broadcast
address, so every machine on that network answers.

one packet in. two hundred packets out, all of them at somebody else.
find a few hundred of those networks and one person on a modem can put a
university off the air.

the fix was one line in one config: stop answering broadcast pings. it
took years to get it into enough routers, and then it was simply over.`,
  },

  'dcc': {
    title: 'PAMELA.JPG.EXE',
    from: 'they always take it',
    body: `the client offered to receive a file and the file had two extensions and
the operating system was configured, by default, to hide the second one.

so it looked like a picture. it was not a picture.

nobody was tricked by anything clever. they were tricked by a display
preference that shipped switched on, and it worked for about six years.`,
  },

  'irc': {
    title: 'how a channel is owned',
    from: 'a text file with no author on it',
    body: `nobody owns #anything. the server hands the first person in the room a
crown and then declines to have any further opinion.

everything after that — the takeovers, the split riding, the bots, the
three years of war — is people improvising a system of government inside a
program that does not have one and was never going to get one.`,
  },

  'canary': {
    title: 'the stack canary',
    from: 'StackGuard, 1997',
    body: `you put a random word on the stack between the buffer and the return
address, and before returning you check it is still the word you put there.

a linear overflow has to write through the canary to reach the return
address, so it dies loudly instead of quietly.

it stops the overflow that walks. it does nothing about the one that knows
where it is going, and it does nothing at all if you can read the value
first — at which point it is not a guard, it is a password you have.`,
  },

  'ret': {
    title: 'the return address',
    from: 'Smashing the Stack for Fun and Profit, Phrack 49, November 1996',
    body: `you did not break in.

the function was always going to return. it was always going to jump to
whatever address was sitting in that slot. you did not subvert anything —
you filled in a field, correctly, with a value of your choosing, and then
the machine did exactly what it was built to do, on time, without error.

that is the part nobody expects: none of this is the computer going wrong.
all of it is the computer going right about the wrong thing.`,
  },

  'nopsled': {
    title: '0x90',
    from: 'why the ramp',
    body: `you do not know exactly where your code landed. stack addresses move.

so you put a long run of do-nothing instructions in front of it and aim
somewhere in the middle. land anywhere on the ramp and you slide to the
bottom, and the bottom is where the work is.

it is the single most forgiving thing in the whole field. everything else
demands you be exactly right. the sled says: near enough.`,
  },

  'nx': {
    title: 'W^X',
    from: 'the page is writable or it is executable',
    body: `your shellcode is still there. every byte of it is correct. the return
address points at it exactly. and the processor will not run it, because the
page it is on is marked writable, and a page that is writable is not
executable, and it is never both.

nothing you did was wrong. the rules changed underneath a thing that was
already finished.`,
  },

  'ret2libc': {
    title: 'return-oriented programming',
    from: 'what you do when you are not allowed to write code',
    body: `you cannot introduce a single new instruction. fine.

the program is already full of instructions. so is every library it loaded.
and scattered through all of that are thousands of tiny fragments that
happen to end in a return — two or three useful operations and then a jump
back to whatever address is next on the stack.

so you do not write a program. you write a *list of addresses*, and the
machine walks the list, and out the other end comes a program that nobody
ever compiled and that exists nowhere on disk.

you did not smuggle in code. you rearranged theirs.`,
  },

  'climb': {
    title: 'the exam you did not know you were sitting',
    from: 'the way back up',
    body: `everything on the way down taught you a verb.

seize the trunk. mind the wiper. count the reversal. do not read the ansi.
ride the live half. do not stand on the red.

none of it was ever explained twice. you were simply expected to have been
paying attention, once, a long time ago, on the way past.`,
  },

  // ── hop 21–34 ──────────────────────────────────────────────────────────

  'morris': {
    title: 'the one in seven',
    from: '2 November 1988',
    body: `it asks a host whether it is already infected, so as not to waste it.

but a host could lie. a host could say yes to make the worm go away. so —
to defeat that — it reinfects anyway, one time in seven, regardless of the
answer.

that is the whole disaster. not the three exploits. not the copies. one
defensive line, written by somebody being careful, that turned a
self-limiting program into a machine for grinding a network into a stop.

about six thousand hosts. roughly a tenth of everything there was.`,
  },

  'antidote': {
    title: 'the fix that could not get there',
    from: 'the night of 2 November 1988',
    body: `he wrote one. within hours. it was correct.

it could not travel. the only road it had was the road he had already
broken — mail was down because the worm was in sendmail, the gateways were
being unplugged on purpose, and every machine that could have relayed it
was at load ninety trying to run forty copies of the thing it was supposed
to be curing.

people ended up driving tapes to each other in cars.

that is the shape of the whole night: the cure existed, immediately, and
the network was in no condition to carry it.`,
  },

  'cure': {
    title: 'what you saved',
    from: 'the reachable set',
    body: `it worked perfectly on every machine it could reach.

that is not a consolation. that is the exact measure of the damage: the
fix was never the hard part. the hard part was that you had already taken
the road.`,
  },

  'fingerd': {
    title: 'gets()',
    from: 'the actual line',
    body: `    gets(line);

there is no length. there was never a length. the function reads until it
finds a newline and writes wherever you told it to start, and it has no
way at all of knowing how much room it has, because nobody passed it that.

it was removed from the C standard in 2011. it had been the answer to
"how did they get in" for twenty-three years by then.`,
  },

  'stoll': {
    title: 'seventy-five cents',
    from: 'Lawrence Berkeley Lab, August 1986',
    body: `two accounting systems disagreed by seventy-five cents of connect time.

everybody who had ever seen that rounded it off. one astronomer, who had
been moved onto computing because the telescope time ran out, decided to
find the nine seconds.

it took ten months. he wired fifty printers to fifty lines in a basement
and slept next to a teletype with a pager taped to it. the answer was at
the other end of a satellite link and it was being paid in cocaine and
cash by people who wanted MILNET.

nobody believed him for most of it. the FBI asked how much money had been
stolen and he said seventy-five cents and they hung up.`,
  },

  'sdinet': {
    title: 'the file that was not real',
    from: 'the bait',
    body: `he could not trace the line because the intruder never stayed on long
enough.

so he wrote a fake project — a whole distribution list, memos, a
bureaucracy — full of the word the intruder kept searching for, and left
it where it would be found, and made it long.

it was very boring on purpose. reading it took thirty minutes. thirty
minutes was enough.`,
  },

  // ── hop 35–44, the board ───────────────────────────────────────────────

  'board-login': {
    title: 'THE LAST TRUNK — login screen',
    from: 'ANSI, 1987',
    body: `somebody sat and drew this with the eight block characters and sixteen
colours, one cell at a time, so that it would take exactly the right
amount of time to paint at 2400 baud and land its last line on the beat.

they were not paid. about forty people ever saw it.`,
  },

  'joy-ears': {
    title: 'the sound of a tired switch',
    from: 'JOYBUBBLES',
    body: `you can hear when a crossbar is worn. it comes back a half tone flat and
it takes an extra beat to answer.

i know six offices by ear and i have never seen any of them and i never
will and it does not matter one bit.

people keep telling me i am missing something. i am not missing anything.
i am the only one actually listening.`,
  },

  'nup-leak': {
    title: 'NEW USER POLICY — READ',
    from: 'TANDEM',
    body: `we do not take new users off the nodelist any more. too much heat.

if somebody vouched for you they gave you the word. type it at the ELITE
prompt.

(and no, i will not tell you the word. i am not going to type it into a
public message base, am i.)

— the entire security model of the scene, in four lines, defeated by the
person who designed it, in the same four lines.`,
  },

  'ansi-bomb': {
    title: 'the ANSI bomb',
    from: 'ANSI.SYS, and what it would do for you',
    body: `the terminal driver everybody loaded had a feature: an escape sequence
that redefines what a key produces.

it was meant for macros. it is in the manual.

so you put the sequence in a message, and the board sends the message to
the reader, and the reader's terminal driver reads it, and now their F1
key types FORMAT C: and presses return.

nobody exploited anything. it was a documented feature, working, on a
machine that had no concept of the message being from someone else.`,
  },

  'crunch': {
    title: 're: whistle',
    from: 'CAP N CRUNCH',
    body: `it is a toy. it came free in a box of cereal. it makes one note.

the note happens to be two thousand six hundred cycles, which happens to
be the note the long distance network uses to tell itself a trunk is idle.

nobody designed that coincidence. somebody just did not think anybody
would be listening. that is the whole of it. that is every single one of
these.`,
  },

  'conscience': {
    title: 'the conscience of a hacker',
    from: 'Phrack 7, 8 January 1986',
    body: `we explore, and you call us criminals.
we seek after knowledge, and you call us criminals.
we exist without skin colour, without nationality, without religious bias,
and you call us criminals.

you build atomic bombs, you wage wars, you murder, cheat and lie to us and
try to make us believe it is for our own good, yet we are the criminals.

yes, i am a criminal. my crime is that of curiosity.

— written the day after he was arrested. he was seventeen.`,
  },

  'sysop-chat': {
    title: 'TANDEM broke into chat',
    from: 'the sysop, watching',
    body: `he can see what you type before you send it.

not the message — the keystrokes. the board echoes your line to his screen
as you build it, because the board is a program running on his computer in
his house and there was never any layer in between.

every sysop could do this. most of them watched. nobody thought to mention
it because there was nothing to mention: where else would it have gone.`,
  },

  'lord': {
    title: 'LORD — you killed a Small Thief',
    from: 'Legend of the Red Dragon, v3.29',
    body: `you get three forest fights a day, and then you have to hang up and come
back tomorrow, because there is one phone line and forty people and the
only fair way to share a world is to ration time in it.

nobody has built a better multiplayer economy since. they have all built
faster ones.`,
  },

  'tradewars': {
    title: 'TRADE WARS 2002',
    from: 'a door game, running on somebody\'s spare computer',
    body: `ten sectors. seven ports. a fixed number of turns a day and then you have
to hang up and let somebody else have the line.

the entire economy is one idea: find two adjacent ports that disagree with
each other about what something is worth, and run between them until they
stop disagreeing.

people played this for years. on one phone line. taking turns.`,
  },

  'fido': {
    title: 'you posted to fidonet',
    from: 'zone 1, net 129, node 22',
    body: `at four in the morning your board will dial the next board up the tree and
hand over everything written today, and that board will dial the one above
it, and so on, all night, across the country, one long distance call at a
time, mostly to save money on the rates.

your message will reach the far side of the world in about four days,
having been physically carried there by a chain of hobbyists' modems while
everyone involved was asleep.

it worked for fifteen years. at its peak it had about forty thousand
nodes. nobody was in charge of it.`,
  },

  'the-trunk': {
    title: 'TANDEM — the trunk',
    from: 'the elite sub-board',
    body: `there is a way down out of the board and into the plant itself.

the switch will hold the line open for a few seconds after you drop. that
is the hole. it has been there since 1971 and nobody closed it because
nobody wrote it down.

hang up without typing goodbye.`,
  },

  'lastcall': {
    title: 'LAST CALL',
    from: 'TANDEM, the ninth year',
    body: `nine years. forty-four users. one phone line.

it was not one thing that killed it. the second line was never coming. the
long distance was forty dollars a month out of a job he did not much like.
and about a third of them had shell accounts by then and were not calling
any more, and he did not blame them, because it was better — genuinely,
obviously better, more out there in an afternoon than had been on his board
in nine years.

that is how nearly all of them went. not raided. not busted. just slowly
out-competed by something with no ratio and no busy signal and nobody
waiting for the line.`,
  },

  'fido-reply': {
    title: 'somebody wrote back',
    from: 'four days, three boards, one long distance call',
    body: `it went out on the 04:00 run and it got there by tuesday and somebody you
will never meet, in an area code you will never know, read it and typed an
answer and gave it to their own modem.

nobody was paid for any leg of that. nobody was in charge of it. it worked
for fifteen years.`,
  },

  'oneline': {
    title: 'the phone bill',
    from: 'why it was always engaged',
    body: `a second line was forty dollars a month before a single call.

that is the entire technical explanation for the busy signal, for the
ratios, for the time limits, for the fact that you could want to get in
somewhere. the scarcity that made all of it feel like somewhere was a
scarcity of one household phone line in one man's spare room.`,
  },

  'read-out': {
    title: 'somebody read it out to her',
    from: 'the girl from 2111',
    body: `she could not see the ANSI. she never could.

somebody read it out to her once — all of it, the whole login screen, every
block character, colour by colour — and it took eleven minutes.

she wanted somebody to know that happened.`,
  },

  'ratio': {
    title: 'adjusted to 1:1',
    from: 'ratio_cop, who was never actually angry',
    body: `he said he would and you did it anyway and he did.

it was a job somebody had to do on a board and he liked having a job on
a board. that is most of what the ratio was ever for.`,
  },

  'shell': {
    title: 'where im going',
    from: 'gh0st, on his way out',
    body: `a shell account at the university. eighteen dollars a month. on all the
time. no ratio, no time limit, nobody waiting for the line.

"it is better. it is so much better. i hate it."`,
  },

  'thenumber': {
    title: 'just the number',
    from: 'anonymous, last day',
    body: `5551212

no subject. no body. nothing else in the message at all.

it is the board's number. they posted the board's number, on the board, on
the last day, to nobody.`,
  },

  'echo': {
    title: 'found this place',
    from: 'a new user, two days too late',
    body: `somebody on another board pasted something you wrote on the fidonet echo,
and it had this board's number under it.

"i have been calling for two hours. it is engaged every time. i am going to
keep calling."`,
  },

  'tandem-last': {
    title: 'i said do not say anything sad',
    from: 'TANDEM',
    body: `"you have all completely ignored me. it is the last thing you will ever
ignore me about and i find that i do not mind."`,
  },

  // ── hop 43–44, the shell ───────────────────────────────────────────────

  'always-on': {
    title: 'no busy signal',
    from: 'the first thing you notice',
    body: `it is on.

not "it is on in the evenings when the sysop is not using the phone". not
"it is on if nobody else got there first". on, at four in the afternoon on
a tuesday, and at three in the morning, and in february when nobody has
touched it for ninety-one days.

everything the board was — the ratio, the time limit, the wanting, the
whole feeling of somewhere you had to get into — was a consequence of one
phone line in one man's spare room. take the scarcity away and all of it
goes, the bad and the good together.`,
  },

  'multiuser': {
    title: 'thirty-eight at once',
    from: 'who(1)',
    body: `the board had forty-four users in nine years and could hold exactly one
of them at a time.

this holds thirty-eight right now, and none of them know each other, and
none of them are waiting.`,
  },

  'multitask': {
    title: 'two things at once',
    from: 'make(1), in the background',
    body: `it is compiling a kernel in the top of the screen while you are talking
to somebody in the bottom of it.

on the board you could read a message or play a door game or download a
file, and while you did any one of those the other forty-three people got
a busy signal.

this is not a better version of that. it is a different kind of object.`,
  },

  'the-post': {
    title: 'what would you like to see most in minix?',
    from: 'comp.os.minix, 25 August 1991',
    body: `he says he is doing a free operating system. he says it is "just a hobby,
won't be big and professional like gnu". he says it will only ever run on
386 AT clones because that is the only hardware he has.

he wanted to call it Freax. the man who ran the FTP server did not like
Freax, so when he made the directory he called it linux, and never
mentioned it, and that was that.

version 0.01 was about ten thousand lines and a good deal of it was a
terminal driver, because what he had actually set out to write was a
program for dialling into the university with.

that is worth sitting with for a second. the thing that ended the era of
the board began life as a terminal emulator for calling one.`,
  },

  'talk': {
    title: 'talk(1)',
    from: 'every character, as you hit it',
    body: `no send button. no enter. it puts each character on their screen at the
moment you type it, and theirs on yours, both at once, on a split screen.

you watch people think. you watch them start a sentence, delete it, and
start again, and there is nothing you can do about having seen it.

we replaced it with something where you compose in private and then
publish, and we called that an improvement, and it might have been.`,
  },

  'vmlinux': {
    title: 'vmlinux',
    from: 'a whole operating system, on a machine you do not own',
    body: `version 0.12, January 1992: he relicenses it under the GPL. Anybody can
have it, change it, and give it away, provided they let the next person do
the same.

he was twenty-one. he could have sold it.

that one decision is why the machine this is running on, and the machine
in your pocket, and most of the machines between here and root, are all
running some descendant of a hobby project by a student in Helsinki who
mostly wanted a better way to dial into the university.`,
  },

  'gnu': {
    title: 'GNU/Linux',
    from: 'ttyp7, since six in the morning',
    body: `he is right, and it is worth saying plainly because the joke has almost
completely buried the fact.

the GNU project started in 1983 with the goal of a complete free operating
system. by 1991 they had written nearly all of it — the compiler, the
linker, make, the shell, the core utilities, the debugger, the libc. what
they did not have finished was a kernel; theirs was late and stayed late.

then a student in Helsinki wrote a kernel, and put it under their licence,
and the last piece fitted.

look at the build log in this level. every single line of it is gcc, and
gcc is GNU. the level then prints "a whole operating system" over the top
of it, which is exactly the error he has spent his life correcting, and
being extremely annoying about, and being correct about.

he has been on ttyp7 since six in the morning. he saw who(1) go past. he
waited until you called it an operating system.`,
  },

  'uname': {
    title: 'he rebuilt uname',
    from: 'ttyp7, having given up on you personally',
    body: `five times you ran it and five times it said Linux and five times he said
something, each one shorter and flatter than the last, until he stopped.

then he went and edited the program so that it says GNU/Linux, and
installed it, and did not ask anybody.

which is, in fairness, the entire strategy. he did not win the argument
about naming and he was never going to. what he did instead was write a
compiler, a linker, a shell, a libc, a debugger and a text editor, put all
of them under a licence that forces everyone downstream to keep them free,
and wait.

that part worked completely. you are reading this on it.`,
  },

  // ── hop 45–50, the handshake ───────────────────────────────────────────

  'dtmf': {
    title: 'the matrix',
    from: 'Bell Labs, 1963',
    body: `           1209   1336   1477   1633
    697      1      2      3      A
    770      4      5      6      B
    852      7      8      9      C
    941      *      0      #      D

a digit is not a tone. a digit is two tones, one from each set, chosen so
that no pair can be produced by the harmonics of any other pair, and so
that a human voice cannot accidentally make one.

the fourth column exists. your phone does not have it. it was for the
military, it is called A B C D, and it is still there.`,
  },

  'ansam': {
    title: 'why it goes bong',
    from: 'ITU-T V.8 / V.25',
    body: `the answering modem sends 2100 Hz, and every 450 milliseconds it reverses
the phase.

this is not decoration. the telephone network is full of echo cancellers,
which are extremely helpful for speech and completely ruinous for a modem
trying to run full duplex. the phase reversals are a specific, agreed
signal that means: turn yourselves off, we know what we are doing.

the noise you remember is not the modem talking to the other modem. most
of it is the two of them talking to the network about the network.`,
  },

  'v8bis': {
    title: 'the scream',
    from: 'capability negotiation',
    body: `the sound in the middle — the one that goes up — is both ends listing what
they can do, at each other, at once.

speeds, error correction, compression, whether the line will even carry it.
they try, they measure, they climb down until it works.

which is why two identical modems on two different lines connect at two
different speeds, and why the number it lands on is not a specification.
it is a measurement of the copper between you.`,
  },

  'retrain': {
    title: 'retrain',
    from: 'the line, changing its mind',
    body: `it did not stay the way you negotiated it.

the copper got wet, or somebody in the house picked up an extension, or
the exchange quietly rerouted you through a worse pair at three in the
morning — and the two modems stopped in the middle of whatever you were
doing and did the entire handshake again from the top.

sometimes you came back faster. usually you did not. and the number it
landed on the second time was the number you lived with, because nobody
was going to hang up and try again at those prices.`,
  },

  'connect': {
    title: 'CONNECT 14400/ARQ/V32B/LAPM/V42BIS',
    from: 'the line that told you what you got',
    body: `it is the only benchmark result anybody ever cared about that arrived
unprompted, in plain english, at the exact moment it was decided, about a
negotiation you had no part in.

nothing since has been this honest about what it actually managed.`,
  },

  // ── hop 51–58, the copper ──────────────────────────────────────────────

  'strowger': {
    title: 'Almon B. Strowger, undertaker',
    from: 'Kansas City, 1891',
    body: `he was losing business. people ringing for an undertaker were being put
through to his competitor.

his competitor's wife was the local telephone operator.

so he built a switch that connects calls without a person in the middle,
patented it, and removed her from the process entirely. it is called
step-by-step. it ran large parts of the world's telephone network for
about ninety years.

the entire automatic telephone exchange exists because one man in Missouri
was furious about a specific woman.`,
  },

  'loadcoil': {
    title: '88 millihenries, every six thousand feet',
    from: 'Pupin, 1900',
    body: `a long copper pair eats the high frequencies and the voice arrives dull
and quiet. you fix it by adding inductance at intervals — lumps of iron
and wire, in a case, in the ground, every mile and change.

it makes speech travel much further. it also puts a brick wall at about
3400 Hz, which is fine for a voice and fatal for a modem.

the network was tuned, physically, in steel, for the human throat. every
single thing after that had to be smuggled through a hole shaped like a
person talking.`,
  },

  'stepbystep': {
    title: 'how a step-by-step switch dials',
    from: 'Strowger, and every exchange that copied him',
    body: `there is no computer anywhere in this. the dial on the telephone is a
spring-loaded wheel that breaks the circuit a fixed number of times — once
for a one, nine times for a nine — at ten pulses a second.

at the other end a wiper steps up one contact per pulse and stops where the
pulses stop. that is the digit. that is the whole mechanism. seven digits
is seven banks of relays, each one physically climbing to the number you
dialled and then handing you to the next.

you can hear the number. it is being counted out in front of you.`,
  },

  'wrongnumber': {
    title: 'KL5-2368',
    from: 'a man who was not expecting anybody',
    body: `you followed one call across a hall the size of a cathedral, through seven
banks of relays, over about a mile of copper, at ten pulses a second.

it was a wrong number.

the switch did not mind. the switch does not know what a number is. it
counts pulses and closes contacts and it would have done exactly the same
thing for a declaration of war.`,
  },

  'beige': {
    title: 'the beige box',
    from: 'a handset and a pair of jaws',
    body: `it is a lineman's telephone. you clip it across the two wires at the box
on the side of somebody's house and you are on their line.

there is no exploit here. there is no cleverness. the pair is right there,
it is not encrypted because it is not anything, it is two bits of copper
with a voice on them, and the only thing that was ever protecting it was
that it is on the side of a house and people can see you.

it took no skill whatsoever. that is what makes it the worst one.`,
  },

  // ── hop 59–63, the blue box ────────────────────────────────────────────

  'inband': {
    title: 'in-band signalling',
    from: 'the original sin',
    body: `the control channel and the voice channel are the same channel.

the switches tell each other what to do by making noises down the line —
the same line your voice is on, because building a second network just for
the switches to gossip on would have cost a fortune, and in 1950 nobody
was going to be on the line who could make those noises on purpose.

that assumption held for about twenty years.`,
  },

  'conference': {
    title: '2111',
    from: 'a bridge somebody left up',
    body: `it is a loop-around in a switch in kansas that somebody wired wrong, or
wired deliberately, decades ago, and then left.

there is no operator. there is no list of members. there is no way to be
thrown off it. you dial four digits and you are in a room with whoever
else dialled the same four digits, and nobody says their name, and some of
them are fourteen and some of them work for the phone company and it does
not come up.

it exists because nobody is maintaining it. the moment anyone official
notices it is there, it stops being there. that was true of all of this.`,
  },

  'routing': {
    title: 'the card',
    from: 'worked out by hand, and traded',
    body: `nobody published these. you worked them out — dialling, listening,
writing down what answered — and then you copied them onto a card, and the
card went in your pocket, and if somebody was alright you copied it out
for them too.

it is the only documentation the entire long distance network had that was
written by the people using it rather than the people running it.`,
  },

  'tandem-loop': {
    title: 'you rang the payphone next to you',
    from: 'the set piece',
    body: `you stack trunks. each one takes the last one's far end and hands you a
fresh one, and you keep going: this coast, that coast, London, Sydney,
back.

and then you dial the payphone six feet behind you, and you walk over, and
you pick it up, and you hear yourself a quarter of a second late, having
gone all the way around the earth to travel two metres.

every switch on that path believed you. not one of them asked.`,
  },

  'ss7': {
    title: 'the day 2600 stopped working',
    from: 'Common Channel Signalling System No. 7',
    body: `they moved the signalling off the voice path and onto its own network.

that is all. no arrests, no patch, no announcement. the control channel
and the voice channel became two different things and one day the tone
just did not do anything any more, in one exchange, and then another, and
then everywhere.

you can still make the sound. the sound is just a sound now.

it is the only fix in this entire history that actually worked, and it
worked because it stopped being possible to say the thing, rather than
trying to stop people saying it.`,
  },

  // ── the climb ──────────────────────────────────────────────────────────

  'spectre': {
    title: 'the branch that did not happen',
    from: '2018',
    body: `the processor guesses which way a branch will go and starts work early. if
it guessed wrong it throws the work away and nobody is any the wiser.

except the work touched memory, and touching memory leaves a line in the
cache warm, and you can time how fast something loads.

so: get it to guess wrong, on purpose, in a direction it was never allowed
to go, and read the answer out of the temperature of the cache afterwards.

the timeline was discarded. the timeline still left a mark. it is in every
fast processor made in twenty years, because it is not a bug in any of
them — it is what "fast" meant.`,
  },

  'rowhammer': {
    title: 'rowhammer',
    from: '2014',
    body: `DRAM cells are so close together now that repeatedly reading one row leaks
charge out of its neighbours. do it enough times, fast enough, before the
refresh comes round, and a bit in a row you were never given access to
changes value.

you do not read it. you do not write it. you shout next to it.

it is the point at which software stopped being able to pretend that
memory is an abstraction and had to admit it is a warehouse of tiny
buckets of electricity that are leaking into each other.`,
  },

  'log4shell': {
    title: '${jndi:ldap://}',
    from: 'December 2021',
    body: `the logging library, when asked to write a line to a file, would notice a
particular pattern in the text and go and fetch what it pointed at, over
the network, and run it.

this was a feature. it had been a feature since 2013.

so you put it in your username. or your user agent. or the name of your
iPhone. anywhere that anything, anywhere, might eventually write down what
you said.

you did nothing. you held up a sign. it went and got it. it was very
helpful. that was the bug.`,
  },

  // ── hop 64 ─────────────────────────────────────────────────────────────

  'tuesday': {
    title: 'the reply',
    from: 'the 04:00 run, four days later',
    body: `you wrote something at four in the morning and gave it to a modem, and the
modem dialled another modem, and that one dialled another, all night,
across the country, while everyone involved was asleep.

it said it would get there by tuesday.

nothing since has been slower and nothing since has been more certain.`,
  },

  'root': {
    title: 'root',
    from: 'uid 0',
    body: `the room was empty.

root is not a person and it is not a place. it is a number, and the number
is zero, and everything else in the system agrees to defer to whatever is
wearing it.

the reply was not empty.`,
  },
};

// levels can still pass their own title/body inline; this is the shared store
export function lookup(id, title, body) {
  const p = PHILES[id];
  if (p) return { id, title: p.title, from: p.from || '', body: p.body };
  return { id, title: title || id, from: '', body: body || '' };
}

export const TOTAL = 200;   // what the counter counts up to. we are not there yet.