SyntaxPilot
Courses/Cybersecurity Fundamentals/Lesson 35
Video coming soonThis lesson’s video is being made

Start with the notes below; the video appears here as soon as it is on YouTube.

Cybersecurity Fundamentals · Lesson 35 of 90

Zero trust architecture

perimeter (castle-and-moat) modelimplicit trustzero trustnever trust always verifyNIST SP 800-207policy enginepolicy administratorcontinuous verificationdevice postureidentity as the new perimeterZTNA vs VPNmicrosegmentation revisitedBeyondCorpzero trust maturity model

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:

  1. Device inventory: is this a device we know about, and does the company manage it (a managed device)? Unknown devices get little or nothing.
  2. Patched: is the operating system up to date (episode 9)?
  3. Disk encrypted (episode 27, data at rest) and screen lock on, so a stolen laptop leaks nothing.
  4. 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

  1. 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.
  2. 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.
  3. 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).
  4. 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).
  5. 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).
  6. What is step-up authentication? Asking for stronger proof only when risk increases, rather than for every action.
  7. 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.
  8. 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).
  9. 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.
  10. 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.
  11. 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.