---
title: "Networks & Security"
description: "21 topics in Computing, in the order they build on each other."
canonical: https://lightmysky.com/learn/computing/areas/networks-and-security
source: https://lightmysky.com/learn/computing/areas/networks-and-security.md
retrieved: 2026-09-02
---

> **Agent view.** This is the Markdown twin of the page, for tools and assistants.
> When to use this site, and the call that answers each job: https://lightmysky.com/agent-instructions.md
> API description (OpenAPI 3.1): https://lightmysky.com/openapi.json · Authentication: https://lightmysky.com/auth.md
> Pricing: https://lightmysky.com/pricing.md · Catalog: https://lightmysky.com/llms.txt · Full catalog: https://lightmysky.com/llms-full.txt
> Every machine-readable file on this domain: https://lightmysky.com/.well-known/ai-catalog.json
> Ask for Markdown with `Accept: text/markdown`, a `.md` address, or `?mode=agent`.

# Networks & Security

21 topics in Computing, in the order they build on each other.

Page: https://lightmysky.com/learn/computing/areas/networks-and-security

- [Layering and Encapsulation in the Protocol Stack](https://lightmysky.com/learn/computing/layering-and-encapsulation-in-the-protocol-stack-mt_D33SEBslXH): Each layer wraps the layer above in a header and hands it down, so a message crossing the network is a set of nested envelopes. The arrangement means a change in how a link carries bits does not reach the application, and it also means a failure at one layer is reported in that layer's terms.
- [Reliable Delivery over an Unreliable Network](https://lightmysky.com/learn/computing/reliable-delivery-over-an-unreliable-network-mt_kCM411CSac): The network below may drop, duplicate, delay and reorder. A reliable transport rebuilds order and completeness on top of it using sequence numbers, acknowledgements, timeouts and retransmission, and a window so the sender need not wait for each reply.
- [Congestion Control and Sharing a Link](https://lightmysky.com/learn/computing/congestion-control-and-sharing-a-link-mt_y5hPUrdKyq): Nothing tells a sender how much of the path is free, so it probes: increase the rate while packets get through, and cut it sharply when they do not. That rule is what keeps a shared network from collapsing, and it makes loss a signal rather than only a fault.
- [Naming: DNS and the Resolution Path](https://lightmysky.com/learn/computing/naming-dns-and-the-resolution-path-mt_omttmGkEgW): People use names and machines use addresses, so a distributed directory translates between them by walking a hierarchy from the root down. Caching with a time to live is what keeps it fast, and it is also why a change takes a while to be seen everywhere.
- [Routing: How a Path Is Learned](https://lightmysky.com/learn/computing/routing-how-a-path-is-learned-mt_gyqPDrV6Uo): No router knows the whole network. Inside one organisation routers exchange what they know until their tables agree; between organisations the choice is shaped by policy and business relationships as much as by distance.
- [The Web as a Protocol: Requests, State and Caching](https://lightmysky.com/learn/computing/the-web-as-a-protocol-requests-state-and-caching-mt_MDiW4Vt0bo): The web runs on a request and response protocol that remembers nothing between calls, so any sense of a session is built on top with cookies or tokens. Caching headers decide what may be reused and for how long, which is most of what makes the web feel fast.
- [Clocks, Ordering and Happens-Before](https://lightmysky.com/learn/computing/clocks-ordering-and-happens-before-mt_ratia1eb_2): Separate machines have separate clocks that drift, so a timestamp cannot settle which of two events came first. What can be settled is causality: one event happened before another if a message carried information from the first to the second.
- [Failure Models and Replication](https://lightmysky.com/learn/computing/failure-models-and-replication-mt_aYK210-NIS): A distributed system has to say what kinds of failure it tolerates: a machine that stops, a message that never arrives, a machine that stops and comes back with old state. Replication is the usual answer, and it turns one copy's truth into a question about which copy to believe.
- [Consensus and Why Agreement Is Hard](https://lightmysky.com/learn/computing/consensus-and-why-agreement-is-hard-mt_cF-JiM_xRz): Several machines have to agree on one value even though some may fail and messages may be delayed. A majority quorum plus a leader gets there in practice, and the theory says no protocol can guarantee both safety and progress when delays have no bound.
- [Consistency Models and the CAP Trade-off](https://lightmysky.com/learn/computing/consistency-models-and-the-cap-trade-off-mt_j6qtpYPHsr): A replicated store can behave as though there were one copy, or it can keep serving both sides of a network split and reconcile later. It cannot do both during a partition, and the choice belongs to the application rather than to the database.
- [Symmetric Encryption and What a Cipher Promises](https://lightmysky.com/learn/computing/symmetric-encryption-and-what-a-cipher-promises-mt_egJQEiFWZA): A symmetric cipher turns readable data into something unreadable using a shared key, and the promise is narrow: an eavesdropper learns nothing about the contents. It says nothing about who sent the message, whether it was altered, or how the key got to both ends.
- [Public-Key Cryptography and Key Exchange](https://lightmysky.com/learn/computing/public-key-cryptography-and-key-exchange-mt_AHCtrer4eh): A key pair splits the secret: one half can be published, and only the other half undoes what the first did. That solves the problem symmetric ciphers cannot, which is agreeing on a shared key with someone you have never met, over a line somebody is reading.
- [Hashes, Signatures and Certificates](https://lightmysky.com/learn/computing/hashes-signatures-and-certificates-mt_qLHm767U87): A cryptographic hash gives a short fingerprint that is impractical to forge a match for, which makes tampering detectable. Signing a hash with a private key proves who produced it, and a certificate is that signature applied to the claim that a key belongs to a name.
- [TLS: Putting the Pieces Together](https://lightmysky.com/learn/computing/tls-putting-the-pieces-together-mt_JzIwi-BYG0): A secure connection is assembled from all of it: a certificate proves the server's key, a key exchange produces a fresh shared secret, and a symmetric cipher with an integrity check carries the traffic. Reading the handshake in order is how the pieces stop being separate ideas.
- [Threat Modelling: Assets, Adversaries and Trust Boundaries](https://lightmysky.com/learn/computing/threat-modelling-assets-adversaries-and-trust-boundaries-mt_VRXTkrNFvx): Security work starts by naming what is worth protecting, who might want it, and where data crosses from a place you control into one you do not. Without that, defences are chosen by habit, and the effort lands away from where the risk is.
- [Authentication, Authorisation and Secure Defaults](https://lightmysky.com/learn/computing/authentication-authorisation-and-secure-defaults-mt_ofIiD4Bbpk): Proving who someone is and deciding what they may do are two questions, and confusing them is a common source of holes. Storing credentials with a slow hash, giving each part the least access it needs, and failing closed are the defaults that hold up when something else goes wrong.
- [Impossibility Under Asynchrony: What Consensus Cannot Promise](https://lightmysky.com/learn/computing/impossibility-under-asynchrony-what-consensus-cannot-promise-mt_le54TNOeiR): With no bound on message delay and one process allowed to fail, no algorithm is guaranteed both to agree and to finish. Real systems live with this by giving up guaranteed termination and leaning on timeouts, which are a failure detector under another name.
- [Raft: Leader Election and Log Replication](https://lightmysky.com/learn/computing/raft-leader-election-and-log-replication-mt_JdHtEJSPSP): One consensus algorithm end to end. A term-numbered election picks a single leader, the leader appends entries to its followers, and an entry is committed once a majority holds it. Every rule in the protocol exists to stop one specific bad history.
- [Quorums, Leases and Changing the Membership](https://lightmysky.com/learn/computing/quorums-leases-and-changing-the-membership-mt_2uRmRqFutD): A majority is one point on a curve: any read set and write set that intersect will do, and the choice moves cost between reads and writes. A lease buys a leader a bounded window of authority, and changing the member set safely needs a protocol of its own.
- [Linearizability and Checking a History](https://lightmysky.com/learn/computing/linearizability-and-checking-a-history-mt_lTaHmlGtuo): Linearizability says every operation appears to take effect at one instant between its call and its return, so a replicated store can be reasoned about as a single object. Whether a recorded history satisfies it is a decidable question, and the check is expensive.
- [Cryptographic Security Definitions and Proof by Reduction](https://lightmysky.com/learn/computing/cryptographic-security-definitions-and-proof-by-reduction-mt_qPCwxkqYY2): A scheme is secure when a precisely stated game leaves every efficient adversary a negligible advantage. Security is then proved by reduction: an adversary that wins the game is turned into an algorithm for a problem assumed hard, so breaking the scheme would break the assumption.
