These are the notes for Cybersecurity Fundamentals (defensive), episode 35. Episode 34 put every identity on a lifecycle. Today we break one old habit that undoes all of it: trusting a computer just because it is inside the office network. We invent zero trust piece by piece: the castle-and-moat (perimeter) model and implicit trust, never trust, always verify, NIST SP 800-207, the policy engine, policy administrator and policy enforcement point, device posture, continuous verification, identity as the new perimeter, ZTNA vs VPN, microsegmentation revisited, Google's BeyondCorp, and CISA's Zero Trust Maturity Model. Every term is explained the first time it appears, and the Glossary at the end defines them all again.
Meera, Ravi, ChaiCart and every name and address here are made up (203.0.113.0/24 is a range reserved for documentation), and everything runs locally on toy data. Every code sample runs with Python 3 (standard library only); outputs are real, copied from actual runs.
The problems you'll solve
| Problem | Idea it teaches |
|---|---|
| Anything inside the office network is trusted | Castle and moat, implicit trust, lateral movement → zero trust |
| Who decides each request, and how? | Policy engine, policy administrator, policy enforcement point |
| The right person on an infected laptop | Device inventory, device posture, EDR |
| A decision made at login goes stale | Continuous verification, step-up authentication |
| One VPN connection reaches everything | ZTNA vs VPN; north-south vs east-west; microsegmentation |
| Is this real, and where do we start? | BeyondCorp; CISA Zero Trust Maturity Model |
Problem 1: the castle and moat
Real-life example: a housing society with one guard at the main gate, and every flat door unlocked inside because "we're all neighbours here".
| In a housing society | In a company network | Name |
|---|---|---|
| One guard at the main gate | A firewall at the edge (episode 24) and a VPN (episode 25) to let staff in | Perimeter / castle-and-moat model |
| Inside, every flat door is unlocked | Being inside the network counts as being trusted | Implicit trust |
| One thief past the gate finds every flat open | One foothold lets the attacker walk everywhere | Lateral movement (episode 4) |
Demo 1: the perimeter rule
# Castle and moat: anything INSIDE the office network is trusted. The obvious rule.
import ipaddress
OFFICE = ipaddress.ip_network("10.20.0.0/16") # the office LAN + VPN range
def perimeter_allows(ip, app):
return ipaddress.ip_address(ip) in OFFICE # inside = trusted, for every app
requests = [("Meera's laptop at her desk", "10.20.4.17", "payroll"),
("Meera at home, no VPN", "203.0.113.8", "payroll"),
("infected printer in the office", "10.20.9.200", "payroll"),
("contractor on the VPN", "10.20.250.31", "source-code")]
for who, ip, app in requests:
print(f"{who:31} -> {app:11}: {'ALLOW' if perimeter_allows(ip, app) else 'DENY'}")
Output:
Meera's laptop at her desk -> payroll : ALLOW
Meera at home, no VPN -> payroll : DENY
infected printer in the office -> payroll : ALLOW
contractor on the VPN -> source-code: ALLOW
The right person at home is denied, while an infected printer inside the office is allowed into payroll and a contractor on the VPN reaches the source code. Why? The rule only asks where the request comes from: not who is asking, not whether the device is healthy, not whether this person needs this app. The network location became the password, and everything inside the gate has it. Remote work, personal devices and cloud apps make the "inside" fuzzier every year.
Zero trust: NIST SP 800-207
Zero trust is a set of security principles that removes trust based on network location. The US standards body NIST (National Institute of Standards and Technology) describes it in Special Publication 800-207, "Zero Trust Architecture", published in August 2020. In its words, "Zero trust assumes there is no implicit trust granted to assets or user accounts" based solely on their network location (or on who owns the device). A zero trust architecture (ZTA) is an enterprise's plan for applying those principles.
The core ideas, following the publication's tenets:
| Idea | What it means | Example |
|---|---|---|
| Never trust, always verify | Every request is checked as if it came from the open internet | The office Wi-Fi gets no extra rights |
| Every resource counts | Data and computing services are all resources to protect | Payroll, the wiki, a printer's admin page |
| All communication is secured | Encrypt traffic regardless of network location | TLS even inside the office (episode 22) |
| Per-session access, least privilege | Access to one resource at a time, only what's needed | Meera gets payroll for this request |
| Dynamic policy | Decide from identity, device state, behaviour and environment | MFA done? Laptop patched? Usual country? |
| Monitor every asset | No device is trusted by default; watch their security posture | EDR on every laptop |
| Continuous authentication and authorization | Re-check, strictly, not once a day | Revoke when the device turns unhealthy |
| Assume breach | Design as if an attacker is already inside | Small zones, logs everywhere |
Problem 2: who decides? Policy engine, administrator and enforcement point
Real-life example: a hospital ICU door.
| At a hospital | NIST name | What it does |
|---|---|---|
| The duty doctor decides: who is this, which patient, hands washed? | Policy engine (PE) | Makes the decision to grant, deny or revoke access, using policy and signals, and logs it |
| The nurse calls the door and unlocks it for this one visit | Policy administrator (PA) | Carries out the decision: sets up or shuts down the connection, issues session credentials |
| The ICU door itself opens, watches, and closes again | Policy enforcement point (PEP) | The gate in front of the resource: enables, monitors and ends connections |
Together, the PE and PA are sometimes called the policy decision point (PDP) (episode 30 used PDP and PEP for authorization in code). Zero trust moves PEPs as close to each resource as possible, so the zone each gate trusts behind it (NIST calls it the implicit trust zone) is tiny.
Demo 2: a toy policy engine
# Zero trust: a policy engine decides EVERY request from identity, device and resource. Location ignored.
POLICY = {"payroll": {"roles": {"hr", "finance"}, "mfa": True, "device": True},
"source-code": {"roles": {"engineer"}, "mfa": True, "device": True},
"canteen-menu": {"roles": None, "mfa": False, "device": False}}
def policy_engine(r):
rule = POLICY[r["app"]]
if r.get("user") is None: return "DENY: no identity"
if rule["roles"] and r["role"] not in rule["roles"]: return "DENY: role not allowed"
if rule["mfa"] and not r["mfa"]: return "DENY: MFA required"
if rule["device"] and not r["device_ok"]: return "DENY: device not healthy"
return "ALLOW (this request only)"
meera = {"user": "meera", "role": "hr", "mfa": True, "device_ok": True}
reqs = [("Meera, HR, home Wi-Fi", {**meera, "app": "payroll"}),
("Meera, old unpatched PC", {**meera, "device_ok": False, "app": "payroll"}),
("infected office printer", {"user": None, "app": "payroll"}),
("contractor on source code", {**meera, "user": "ravi", "role": "contractor", "app": "source-code"})]
for who, r in reqs:
print(f"{who:26} -> {policy_engine(r)}")
Output:
Meera, HR, home Wi-Fi -> ALLOW (this request only)
Meera, old unpatched PC -> DENY: device not healthy
infected office printer -> DENY: no identity
contractor on source code -> DENY: role not allowed
There is no IP address anywhere in the decision. The right person at home now gets in; the wrong things inside the office stay out. This is what people mean by identity is the new perimeter: who you are and what device you're using replace where you are.
Problem 3: device posture
Meera on an infected laptop still has the right password and MFA. So zero trust also asks about the device. Its current health is called device posture:
- Device inventory: is this a device we know about, and does the company manage it (a managed device)? Unknown devices get little or nothing.
- Patched: is the operating system up to date (episode 9)?
- Disk encrypted (episode 27, data at rest) and screen lock on, so a stolen laptop leaks nothing.
- EDR running: endpoint detection and response is the security software on each computer (the endpoint) that watches for malware and suspicious behaviour and can isolate the machine.
A device that fails a check gets less access (for example webmail only) or none.
Problem 4: continuous verification
Meera logs in at 9 a.m. on a healthy laptop. At 11 a.m. malware switches off the EDR agent. Her session lasts until 6 p.m., so the 9 o'clock decision stands for seven hours: a decision made once goes stale.
Continuous verification re-makes the decision on every request (or every few minutes), using the latest signals.
Demo 3: re-deciding every request
# Continuous verification: the decision is re-made on EVERY request, not once at login
device = {"patched": True, "disk_encrypted": True, "edr_running": True} # device posture
signals = {"country": "IN"}
def failed_checks():
return [name for name, ok in device.items() if not ok]
def check(request_no):
if failed_checks(): return f"request {request_no}: DENY, device failed {failed_checks()}"
if signals["country"] != "IN": return f"request {request_no}: STEP-UP, new country, ask for MFA again"
return f"request {request_no}: ALLOW"
print(check(1))
print(check(2))
device["edr_running"] = False # malware switches off the endpoint protection agent
print(check(3))
device["edr_running"] = True; signals["country"] = "BR" # agent fixed; but now a login from Brazil
print(check(4))
Output:
request 1: ALLOW
request 2: ALLOW
request 3: DENY, device failed ['edr_running']
request 4: STEP-UP, new country, ask for MFA again
Step-up authentication means asking for a stronger proof, such as MFA again, only when the risk goes up (new country, unusual hour, sensitive action), instead of blocking outright or asking all the time. Signals like this feed a risk score in real products.
Problem 5: ZTNA vs VPN
Real-life example: a master key to a building vs a lift card that only goes to floor 4.
| VPN | ZTNA | |
|---|---|---|
| Full name | Virtual private network (episode 25) | Zero trust network access |
| What you join | The whole network: every subnet you can route to | One app at a time, through a broker (a PEP) |
| Decision | Once, when you connect | Per app, per request, with device posture |
| Apps visible from the internet? | The VPN gateway is; apps are reachable once you're on | Apps stay hidden; only the broker is exposed |
| If the laptop is stolen | Attacker reaches everything the network routes to | Attacker reaches only the allowed apps, and posture checks may fail |
Demo 4: what can one laptop reach?
# VPN vs ZTNA: what can one stolen laptop reach?
network = {"10.20.1.0/24": "payroll", "10.20.2.0/24": "source-code", "10.20.3.0/24": "hr-files",
"10.20.4.0/24": "printers", "10.20.5.0/24": "wiki", "10.20.6.0/24": "backups"}
allowed_apps = {"meera": {"wiki", "hr-files"}} # what the policy engine allows Meera
def vpn_reachable(user): # VPN: you join the NETWORK, so you can reach every subnet
return sorted(network.values())
def ztna_reachable(user): # ZTNA: a broker connects you to one APP at a time, per policy
return sorted(allowed_apps.get(user, set()))
print("VPN reaches:", ", ".join(vpn_reachable("meera")))
print("ZTNA reaches:", ", ".join(ztna_reachable("meera")))
print(f"attack surface: {len(vpn_reachable('meera'))} -> {len(ztna_reachable('meera'))} systems")
Output:
VPN reaches: backups, hr-files, payroll, printers, source-code, wiki
ZTNA reaches: hr-files, wiki
attack surface: 6 -> 2 systems
VPNs still have uses (for example site-to-site links between offices), but for people reaching apps, ZTNA gives per-app, continuously checked access.
Microsegmentation, revisited
- North-south traffic goes into and out of the network (people → apps). ZTNA guards it.
- East-west traffic goes sideways inside the data centre (server → server). It's the road lateral movement travels.
- Microsegmentation (episode 24) gives every workload (a server, container or app) its own small allowlist of who may talk to it, enforced right next to it. The web app may call the database; the printer may not call payroll.
BeyondCorp: zero trust in practice
Google described its own version in "BeyondCorp: A New Approach to Enterprise Security" by Rory Ward and Betsy Beyer, published in USENIX ;login: in December 2014. Google removed the requirement for a privileged intranet and moved its corporate applications onto the internet, behind access proxies (playing the role of PEPs). Access is decided from the user and the device (using a device inventory), and the rules are the same whether an engineer is in the office or in a café: the office network became just another network.
Problem 6: where to start? The Zero Trust Maturity Model
Zero trust isn't a product you buy; it's an architecture you grow into. The US Cybersecurity and Infrastructure Security Agency (CISA) published the Zero Trust Maturity Model (ZTMM), version 2.0, in April 2023:
| Part | Contents |
|---|---|
| Five pillars | Identity, Devices, Networks, Applications and Workloads, Data |
| Four stages for each pillar | Traditional → Initial → Advanced → Optimal |
| Cross-cutting capabilities | Visibility and Analytics, Automation and Orchestration, Governance |
In plain words: see everything, automate the responses, and have clear rules about who decides. Each pillar climbs the stages at its own pace.
Demo 5: a toy maturity self-check
# Zero trust is a journey: a toy self-check against CISA's five pillars and four stages
STAGES = ["Traditional", "Initial", "Advanced", "Optimal"]
chaicart = {"Identity": 2, # SSO + MFA everywhere, JIT for admins
"Devices": 1, # inventory exists, posture not checked yet
"Networks": 0, # flat office network, one big VPN
"Applications and Workloads": 1,
"Data": 0} # no data classification yet
for pillar, level in chaicart.items():
print(f"{pillar:27} {'#' * (level + 1):4} {STAGES[level]}")
weakest = min(chaicart, key=chaicart.get)
print("start next with:", weakest)
Output:
Identity ### Advanced
Devices ## Initial
Networks # Traditional
Applications and Workloads ## Initial
Data # Traditional
start next with: Networks
The habit: measure each pillar honestly, fix the weakest first, and measure again.
The next problem
Every request is now verified: who, from which device, for which app, again and again. But most of those apps are web apps, and a browser runs code from many websites side by side. Why can't one tab read another tab's bank page? That's the browser's security model, the same-origin policy, and the OWASP Top 10: episode 36 opens the web security part of the course.
The whole chain
| Step | Problem | Invention |
|---|---|---|
| 1 | Inside the network = trusted | Zero trust: never trust, always verify (NIST SP 800-207) |
| 2 | Who decides each request? | Policy engine, policy administrator, policy enforcement point |
| 3 | Right person, sick laptop | Device inventory and device posture (EDR) |
| 4 | A login decision goes stale | Continuous verification, step-up authentication |
| 5 | A VPN reaches everything | ZTNA; microsegmentation for east-west traffic |
| 6 | Is it real? Where to start? | BeyondCorp; CISA Zero Trust Maturity Model |
Common mistakes (and what they print)
| Mistake | What you see | Why it's wrong | Fix |
|---|---|---|---|
| Allow by network location | infected printer in the office -> payroll : ALLOW |
Implicit trust | Decide from identity + device + resource |
| Check once at login | Malware at 11 a.m., access until 6 p.m. | The decision goes stale | Re-check every request; revoke |
| Ignore the device | Meera, old unpatched PC would be allowed |
Right person, compromised machine | Device posture checks |
| One VPN for everything | VPN reaches: backups, hr-files, payroll, printers, source-code, wiki |
Network-level access | ZTNA: one app at a time |
| Flat internal network | A printer can talk to the payroll database | No east-west control | Microsegmentation allowlists |
| "We bought zero trust" | A new product, the same flat network | It's an architecture | Pillar by pillar, measured with the maturity model |
| MFA prompts all day | Users approve prompts without reading (episode 29) | Fatigue | Step-up only when risk rises |
Mini project: a tiny zero-trust gateway
The policy engine decides, the policy administrator opens a session, and the enforcement point checks every request against the session and the device's current posture, revoking the session when it fails.
# Mini project: a tiny zero-trust gateway. Policy engine decides, administrator opens a session,
# enforcement point checks EVERY request against the session and the device's current posture.
import secrets
POLICY = {"payroll": {"roles": {"hr"}, "mfa": True}, "wiki": {"roles": {"hr", "engineer"}, "mfa": False}}
devices = {"lap-17": {"patched": True, "edr_running": True}}
sessions, log = {}, []
def policy_engine(user, role, mfa, device, app): # PE: decide
rule = POLICY.get(app)
if not rule or role not in rule["roles"]: return False, "role not allowed"
if rule["mfa"] and not mfa: return False, "MFA required"
if not all(devices.get(device, {"known": False}).values()): return False, "device not healthy"
return True, "ok"
def policy_administrator(user, role, mfa, device, app): # PA: open or refuse a session
ok, why = policy_engine(user, role, mfa, device, app)
log.append(f"PE {user}->{app}: {'grant' if ok else 'deny'} ({why})")
if not ok: return None
sid = secrets.token_hex(4); sessions[sid] = (user, role, mfa, device, app); return sid
def enforcement_point(sid, app): # PEP: every request
if sid not in sessions or sessions[sid][4] != app: return "403 no session for this app"
ok, why = policy_engine(*sessions[sid]) # re-check: continuous
if not ok:
user = sessions.pop(sid)[0]; log.append(f"PE revoke {user}->{app}: {why}"); return f"403 revoked ({why})"
return "200 OK"
sid = policy_administrator("meera", "hr", True, "lap-17", "payroll")
print("request 1:", enforcement_point(sid, "payroll"))
print("same session, other app:", enforcement_point(sid, "wiki"))
devices["lap-17"]["edr_running"] = False # malware stops the agent
print("request 2:", enforcement_point(sid, "payroll"))
print("request 3:", enforcement_point(sid, "payroll"))
print("unknown device:", policy_administrator("meera", "hr", True, "lap-99", "payroll"))
print("\n".join(log))
Output:
request 1: 200 OK
same session, other app: 403 no session for this app
request 2: 403 revoked (device not healthy)
request 3: 403 no session for this app
unknown device: None
PE meera->payroll: grant (ok)
PE revoke meera->payroll: device not healthy
PE meera->payroll: deny (device not healthy)
Ideas to extend it: add a country signal with step-up, expire sessions after 15 minutes, and log every PEP decision too.
Practice
1. Disk encryption. Make payroll require a device that is patched, encrypted and running EDR.
Solution
# Practice 1: device health is several checks; payroll needs ALL of them
def device_ok(dev):
return dev["patched"] and dev["disk_encrypted"] and dev["edr_running"]
def policy_engine(r):
if r.get("user") is None: return "DENY: no identity"
if r["role"] not in {"hr", "finance"}: return "DENY: role not allowed"
if not r["mfa"]: return "DENY: MFA required"
if not device_ok(r["device"]): return "DENY: device not healthy"
return "ALLOW (this request only)"
good = {"patched": True, "disk_encrypted": True, "edr_running": True}
print("encrypted laptop: ", policy_engine({"user": "meera", "role": "hr", "mfa": True, "device": good}))
print("unencrypted laptop:", policy_engine({"user": "meera", "role": "hr", "mfa": True,
"device": {**good, "disk_encrypted": False}}))
encrypted laptop: ALLOW (this request only)
unencrypted laptop: DENY: device not healthy
2. A working-hours signal. Add a step-up outside 08:00-20:00 to Demo 3's checks.
Solution
# Practice 2: a working-hours signal. Outside 08:00-20:00, ask for MFA again (step-up)
def check(device_ok, country, hour):
if not device_ok: return "DENY: device posture failed"
if country != "IN": return "STEP-UP: new country"
if not 8 <= hour < 20: return "STEP-UP: outside working hours"
return "ALLOW"
for hour in (10, 19, 23, 3):
print(f"{hour:02d}:00 ->", check(True, "IN", hour))
10:00 -> ALLOW
19:00 -> ALLOW
23:00 -> STEP-UP: outside working hours
03:00 -> STEP-UP: outside working hours
3. A contractor. Give contractor Ravi ZTNA access to source-code only, and nothing once his contract ends.
Solution
# Practice 3: a contractor gets ZTNA access to exactly one app, and only until the contract ends
allowed_apps = {"meera": {"wiki", "hr-files"},
"ravi": {"source-code"}} # contractor
contract_ends = {"ravi": 500} # day number
def ztna_reachable(user, today):
if user in contract_ends and today >= contract_ends[user]:
return []
return sorted(allowed_apps.get(user, set()))
print("Ravi, day 120:", ztna_reachable("ravi", 120))
print("Ravi, day 501:", ztna_reachable("ravi", 501))
print("Meera, day 501:", ztna_reachable("meera", 501))
Ravi, day 120: ['source-code']
Ravi, day 501: []
Meera, day 501: ['hr-files', 'wiki']
4. Microsegmentation. Write an east-west allowlist so only the payroll app may reach the payroll database, and only the ZTNA broker may reach the apps.
Solution
# Practice 4: microsegmentation. Each workload lists who may talk to it (east-west allowlist)
ALLOW = {"payroll-db": {"payroll-app"},
"payroll-app": {"ztna-broker"},
"wiki": {"ztna-broker"}}
def connect(src, dst):
return f"{src:12} -> {dst:11}: {'ALLOW' if src in ALLOW.get(dst, set()) else 'BLOCK'}"
print(connect("payroll-app", "payroll-db"))
print(connect("printer-07", "payroll-db"))
print(connect("wiki", "payroll-app"))
print(connect("ztna-broker", "wiki"))
payroll-app -> payroll-db : ALLOW
printer-07 -> payroll-db : BLOCK
wiki -> payroll-app: BLOCK
ztna-broker -> wiki : ALLOW
5. Think it through. A company says: "We're zero trust now: we bought a new VPN with MFA." What would you ask them?
Answer
Does the VPN still put users on the whole network (network-level access)? Is the device's posture checked, and re-checked during the session? Are apps reachable one at a time through a policy enforcement point? Can a compromised server still talk to every other server (east-west)? Which pillars of the maturity model have they actually moved? MFA on a VPN is good identity hygiene, not zero trust by itself.
Quick quiz
Meera has the right password, MFA and role, but her laptop's EDR agent has just stopped, and her next payroll request is refused. In NIST's model, which part decided that? A policy enforcement point, B policy engine, C perimeter firewall, D VPN.
Answer
B, the policy engine. It makes the grant/deny/revoke decision from identity, device posture and policy. The policy administrator carries it out, and the policy enforcement point blocks the connection. A perimeter firewall or VPN never looked at the EDR agent.
Interview questions
- What is zero trust, in one sentence? An approach that grants no implicit trust based on network location or device ownership, and verifies every request from identity, device and context, continuously, with least privilege.
- What is wrong with the castle-and-moat model? It trusts everything inside the perimeter, so one breach, an insider, or a compromised VPN user can move laterally everywhere; and the perimeter dissolves with remote work and cloud.
- Name the three logical components in NIST SP 800-207. Policy engine (decides), policy administrator (sets up and tears down the session), policy enforcement point (the gate in front of the resource).
- What is device posture, and give three checks. The current security health of a device: patched OS, disk encryption, EDR running (also screen lock, managed status, OS version).
- What is continuous verification? Re-evaluating access during a session on every request or periodically, so access is revoked when signals change (device unhealthy, risky location).
- What is step-up authentication? Asking for stronger proof only when risk increases, rather than for every action.
- ZTNA vs VPN? A VPN joins the device to the network; ZTNA brokers access to individual apps per policy, checks posture continuously, and keeps apps hidden from the internet.
- North-south vs east-west traffic, and which controls fit each? North-south: in and out of the network (ZTNA, gateways). East-west: between internal workloads (microsegmentation).
- What was BeyondCorp? Google's zero-trust model (Ward and Beyer, 2014): no privileged intranet, corporate apps behind access proxies on the internet, access from user and device.
- What are CISA's ZTMM pillars and stages? Pillars: Identity, Devices, Networks, Applications and Workloads, Data. Stages: Traditional, Initial, Advanced, Optimal. Cross-cutting: Visibility and Analytics, Automation and Orchestration, Governance.
- Is zero trust a product? No: an architecture and set of principles implemented across identity, devices, networks, apps and data over time.
Glossary
| Term | Meaning in plain words | Example |
|---|---|---|
| Perimeter (castle-and-moat) model | Security that guards the network's edge and trusts what's inside | A firewall + VPN, open inside |
| Implicit trust | Trust given automatically, without a check, because of location | "It's on the office Wi-Fi" |
| Lateral movement | An attacker moving from one compromised system to others | Printer → payroll |
| Zero trust | No implicit trust from location or ownership; verify every request | Office Wi-Fi treated like a café |
| Never trust, always verify | The zero trust slogan | Check every request |
| Zero trust architecture (ZTA) | An organisation's plan for applying zero trust | ChaiCart's ZTA |
| NIST SP 800-207 | NIST's 2020 publication defining zero trust architecture | The reference document |
| Resource | Anything to protect: data, apps, services | Payroll |
| Subject | Whoever or whatever requests access: a user, device or program | Meera on lap-17 |
| Policy engine (PE) | The part that decides grant, deny or revoke | policy_engine() |
| Policy administrator (PA) | The part that sets up or shuts down the session the PE decided | policy_administrator() |
| Policy enforcement point (PEP) | The gate in front of the resource that enables, monitors and ends connections | enforcement_point(), an access proxy |
| Policy decision point (PDP) | The deciding side: PE + PA together | Episode 30's PDP |
| Implicit trust zone | The area behind a gate that is trusted to that gate's last check | Kept as small as possible |
| Assume breach | Designing as if an attacker is already inside | Small zones, logging |
| Identity as the new perimeter | Who you are and what device you use replace where you are | ZTNA policies |
| Device inventory | The list of devices the company knows and manages | lap-17 |
| Managed device | A device the company controls and configures | A company laptop |
| Device posture | A device's current security health | Patched, encrypted, EDR running |
| EDR | Endpoint detection and response: security software on each computer that detects and responds to threats | Isolates an infected laptop |
| Endpoint | A user's computer or phone | Meera's laptop |
| Continuous verification | Re-checking access throughout a session, not once | Demo 3 |
| Step-up authentication | Asking for stronger proof only when risk rises | MFA again from a new country |
| Risk score | A number combining signals to judge how risky a request is | High for a new country at 3 a.m. |
| VPN | Virtual private network: an encrypted tunnel that joins a device to a network | Remote-access VPN |
| ZTNA | Zero trust network access: per-app access through a broker, by policy | Lift card to floor 4 |
| Broker / access proxy | The ZTNA component users connect through to reach one app | Google's access proxies |
| North-south traffic | Traffic into or out of the network | Users → apps |
| East-west traffic | Traffic between internal workloads | Server → server |
| Microsegmentation | Per-workload allowlists enforced next to each workload | Only the payroll app may reach the payroll DB |
| Workload | A server, container or app that runs code | payroll-app |
| BeyondCorp | Google's zero trust model, described in 2014 | No privileged intranet |
| CISA | The US Cybersecurity and Infrastructure Security Agency | Published the ZTMM |
| Zero Trust Maturity Model (ZTMM) | CISA's map of zero trust progress: 5 pillars, 4 stages | Version 2.0, April 2023 |
| Pillar | One area of the maturity model | Identity, Devices, Networks, Applications and Workloads, Data |
| Maturity stage | How far a pillar has progressed | Traditional, Initial, Advanced, Optimal |
Summary
- The castle-and-moat perimeter gives implicit trust to anything inside, so one foothold enables lateral movement.
- Zero trust (NIST SP 800-207, 2020): no implicit trust from network location; never trust, always verify; per-session, least-privilege access; all traffic encrypted; assume breach.
- The policy engine decides, the policy administrator sets up or ends the session, and the policy enforcement point guards the resource. Identity and device replace location.
- Device posture (inventory, patches, encryption, EDR) and continuous verification with step-up authentication keep decisions fresh.
- ZTNA gives people one app at a time instead of a VPN's whole network; microsegmentation controls east-west traffic.
- BeyondCorp (Google, 2014) showed it at scale; CISA's Zero Trust Maturity Model 2.0 (2023) maps the journey: 5 pillars, 4 stages, 3 cross-cutting capabilities.
Next episode: web security foundations: the same-origin policy, origins, CORS and preflight requests, the browser security model, never trusting the client, input validation vs output encoding, and the OWASP Top 10 (2021 and 2025).
Sources: NIST SP 800-207 "Zero Trust Architecture" (S. Rose, O. Borchert, S. Mitchell, S. Connelly; August 2020), CSRC publication page and PDF; R. Ward and B. Beyer, "BeyondCorp: A New Approach to Enterprise Security", USENIX ;login: vol. 39 no. 6 (December 2014); SecurityWeek on CISA's Zero Trust Maturity Model version 2.0 (April 2023). Code outputs from Python 3. Fetched 6 Nov 2026.