mirror of
https://github.com/hanzoai/skills.git
synced 2026-11-19 00:47:36 +00:00
hanzoskills.com/llms.txt now opens with the install line, the API reference index and the company index, so an agent that lands on any one of the three can find the rest. robots.txt claimed 537 documents while llms.txt counts 920. The number is gone from robots.txt; llms.txt derives it. public/ is regenerated from scripts/site.py, which it had fallen behind: the copy-prompt menu and agent bar were in the generator and not in the committed pages. tests/site.mjs passes against the result. Co-authored-by: Hanzo Dev <[email protected]>
745 lines
31 KiB
HTML
745 lines
31 KiB
HTML
<!doctype html>
|
|
<html lang="en"><head>
|
|
<meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
|
|
<title>security-authorization</title>
|
|
<meta name="color-scheme" content="dark">
|
|
<style>
|
|
/* Committed to one visual world: a dark instrument panel. No light variant —
|
|
the dot field and the hairline rules only read on black, and a naive
|
|
inversion would wash both out. Every colour is painted explicitly so the page
|
|
never borrows a host background. */
|
|
@font-face{font-family:'Zen';src:url('/fonts/Zen-Variable.woff2') format('woff2');font-weight:100 900;font-style:normal;font-display:swap}
|
|
@font-face{font-family:'Zen';src:url('/fonts/Zen-Italic-Variable.woff2') format('woff2');font-weight:100 900;font-style:italic;font-display:swap}
|
|
@font-face{font-family:'Zen Mono';src:url('/fonts/ZenMono-Variable.woff2') format('woff2');font-weight:100 900;font-style:normal;font-display:swap}
|
|
@font-face{font-family:'Zen Mono';src:url('/fonts/ZenMono-Italic-Variable.woff2') format('woff2');font-weight:100 900;font-style:italic;font-display:swap}
|
|
@font-face{font-family:'Zen Pixel Square';src:url('/fonts/ZenPixel-Square.woff2') format('woff2');font-style:normal;font-display:swap}
|
|
|
|
:root{
|
|
--ink:#f4f4f2; --soft:#9c9c98; --faint:#6a6a66; --ground:#000; --panel:#0a0a0a;
|
|
--line:#232323; --line-hi:#3a3a3a; --accent:#f4f4f2;
|
|
--font-zen-sans:'Zen',-apple-system,BlinkMacSystemFont,"Segoe UI",Helvetica,Arial,sans-serif;
|
|
--font-zen-mono:'Zen Mono',ui-monospace,"SF Mono",SFMono-Regular,Menlo,Consolas,monospace;
|
|
--font-zen-pixel-square:'Zen Pixel Square',monospace;
|
|
--mono:var(--font-zen-mono);
|
|
--sans:var(--font-zen-sans);
|
|
/* Controls are pills and surfaces are soft, as on hanzo.ai. */
|
|
--r:999px; --r-soft:14px;
|
|
}
|
|
*{box-sizing:border-box}
|
|
html{-webkit-text-size-adjust:100%}
|
|
body{margin:0;background:var(--ground);color:var(--ink);font-family:var(--sans);
|
|
font-size:16px;line-height:1.65;-webkit-font-smoothing:antialiased}
|
|
.wrap{max-width:60rem;margin:0 auto;padding:0 1.75rem}
|
|
|
|
/* The dot field. A halftone made of one repeating radial-gradient, faded out
|
|
along the diagonal by a mask so it reads as a wave rather than wallpaper. */
|
|
/* No overflow clip here: the dot field is inset to the box already, and a clip
|
|
would cut off the copy-prompt menu. */
|
|
.hero{position:relative;border-bottom:1px solid var(--line)}
|
|
.hero::before{content:"";position:absolute;inset:0;
|
|
background-image:radial-gradient(var(--line-hi) 1px, transparent 1px);
|
|
background-size:7px 7px;
|
|
-webkit-mask-image:linear-gradient(115deg,#000 0%,rgba(0,0,0,.55) 38%,transparent 72%);
|
|
mask-image:linear-gradient(115deg,#000 0%,rgba(0,0,0,.55) 38%,transparent 72%);
|
|
pointer-events:none}
|
|
.hero .wrap{position:relative;padding-top:5.5rem;padding-bottom:4rem}
|
|
|
|
nav{border-bottom:1px solid var(--line)}
|
|
nav .in{max-width:60rem;margin:0 auto;padding:1.1rem 1.75rem;display:flex;
|
|
justify-content:space-between;align-items:center;gap:1rem}
|
|
.brand{font-family:var(--mono);font-size:.85rem;letter-spacing:.14em;
|
|
text-transform:uppercase;color:var(--ink);text-decoration:none;
|
|
display:inline-flex;align-items:center;gap:.6rem}
|
|
.brand i{font-style:normal;color:var(--faint)}
|
|
.mark{width:1.15em;height:1.15em;display:block;flex:0 0 auto}
|
|
nav a.up{font-family:var(--mono);font-size:.72rem;letter-spacing:.14em;
|
|
text-transform:uppercase;color:var(--soft);text-decoration:none}
|
|
nav a.up:hover{color:var(--ink)}
|
|
|
|
h1{font-family:var(--mono);font-size:clamp(2rem,5.4vw,3.4rem);line-height:1.12;
|
|
letter-spacing:-.02em;margin:0 0 1.1rem;font-weight:500;text-wrap:balance}
|
|
h1 em{font-style:normal;color:var(--faint)}
|
|
.lede{color:var(--soft);font-size:1.05rem;max-width:52ch;margin:0 0 2.25rem}
|
|
|
|
.btns{display:flex;flex-wrap:wrap;gap:.7rem;margin:0 0 .5rem;align-items:center}
|
|
.btn{display:inline-flex;align-items:center;gap:.5rem;font-family:var(--mono);
|
|
font-size:.72rem;letter-spacing:.14em;text-transform:uppercase;
|
|
padding:.8rem 1.4rem;border:1px solid var(--line-hi);border-radius:var(--r);
|
|
color:var(--ink);text-decoration:none;background:transparent;cursor:pointer;
|
|
line-height:1.2;font-weight:400}
|
|
.btn:hover{background:#141414;text-decoration:none;border-color:var(--soft)}
|
|
.btn.solid{background:var(--ink);color:#000;border-color:var(--ink)}
|
|
.btn.solid:hover{background:#d8d8d4}
|
|
.btn .chev{width:.7em;height:.7em;flex:0 0 auto;transition:transform .15s ease}
|
|
.btn[aria-expanded="true"] .chev{transform:rotate(180deg)}
|
|
|
|
/* Copy-prompt selector. Each row copies the prompt for its own target. */
|
|
.copy{position:relative;display:inline-flex}
|
|
.menu{position:absolute;top:calc(100% + .5rem);left:0;z-index:20;min-width:21rem;
|
|
background:var(--panel);border:1px solid var(--line-hi);border-radius:var(--r-soft);
|
|
padding:.4rem;display:flex;flex-direction:column;
|
|
box-shadow:0 12px 32px rgba(0,0,0,.75)}
|
|
.menu[hidden]{display:none}
|
|
.mi{display:flex;align-items:center;gap:.7rem;width:100%;text-align:left;
|
|
padding:.62rem .8rem;border:0;border-radius:calc(var(--r-soft) - .35rem);
|
|
background:transparent;color:var(--ink);font-family:var(--mono);font-size:.76rem;
|
|
letter-spacing:.04em;text-decoration:none;cursor:pointer;line-height:1.3;
|
|
white-space:nowrap}
|
|
.mi:hover,.mi:focus-visible{background:#181818;outline:none}
|
|
.mi .mark{width:1.05rem;height:1.05rem;color:var(--soft)}
|
|
.mi:hover .mark{color:var(--ink)}
|
|
.mi u{margin-left:auto;color:var(--faint);text-decoration:none;font-size:.68rem;
|
|
letter-spacing:.1em;text-transform:uppercase}
|
|
|
|
/* Works-with bar: one scrolling row, name and mark per agent. */
|
|
.strip{border-bottom:1px solid var(--line);background:var(--panel)}
|
|
.strip .in{max-width:60rem;margin:0 auto;padding:.9rem 1.75rem;display:flex;
|
|
align-items:center;gap:1.25rem;font-family:var(--mono);font-size:.72rem;
|
|
letter-spacing:.1em;text-transform:uppercase;color:var(--faint)}
|
|
.strip b{color:var(--soft);font-weight:400;flex:0 0 auto;
|
|
border-right:1px solid var(--line);padding-right:1.25rem;align-self:stretch;
|
|
display:flex;align-items:center}
|
|
.bar{display:flex;align-items:center;gap:.5rem;flex:1 1 auto;min-width:0;
|
|
overflow-x:auto;scrollbar-width:none;scroll-snap-type:x proximity;
|
|
-webkit-overflow-scrolling:touch;
|
|
-webkit-mask-image:linear-gradient(90deg,#000 calc(100% - 3rem),transparent);
|
|
mask-image:linear-gradient(90deg,#000 calc(100% - 3rem),transparent)}
|
|
.bar::-webkit-scrollbar{display:none}
|
|
.agent{display:inline-flex;align-items:center;gap:.45rem;flex:0 0 auto;
|
|
padding:.4rem .85rem;border:1px solid var(--line);border-radius:var(--r);
|
|
color:var(--soft);white-space:nowrap;scroll-snap-align:start;
|
|
text-decoration:none;background:var(--ground)}
|
|
.agent:hover{color:var(--ink);border-color:var(--line-hi);text-decoration:none}
|
|
.agent .mark{width:.95rem;height:.95rem}
|
|
|
|
h2{font-family:var(--mono);font-size:1.1rem;letter-spacing:-.01em;margin:2.75rem 0 .75rem;font-weight:500}
|
|
h3{font-size:1rem;margin:2rem 0 .5rem;font-weight:600}
|
|
h4,h5,h6{font-size:.94rem;margin:1.5rem 0 .5rem;font-weight:600}
|
|
p{margin:0 0 1rem;max-width:70ch}
|
|
ul,ol{margin:0 0 1rem;padding-left:1.35rem;max-width:70ch}
|
|
li{margin:.22rem 0}
|
|
a{color:var(--ink);text-decoration:underline;text-underline-offset:3px;
|
|
text-decoration-color:var(--line-hi)}
|
|
a:hover{text-decoration-color:var(--ink)}
|
|
a:focus-visible{outline:1px solid var(--ink);outline-offset:3px}
|
|
code{font-family:var(--mono);font-size:.85em;background:var(--panel);
|
|
border:1px solid var(--line);border-radius:5px;padding:.1em .36em}
|
|
pre{background:var(--panel);border:1px solid var(--line);padding:1rem 1.1rem;
|
|
border-radius:var(--r-soft);overflow-x:auto;margin:0 0 1.25rem}
|
|
pre code{background:none;border:0;padding:0;font-size:.82rem;line-height:1.7}
|
|
blockquote{margin:0 0 1rem;padding-left:1rem;border-left:1px solid var(--line-hi);color:var(--soft)}
|
|
hr{border:0;border-top:1px solid var(--line);margin:2.5rem 0}
|
|
table{border-collapse:collapse;width:100%;margin:0 0 1.25rem;font-size:.92rem;
|
|
display:block;overflow-x:auto}
|
|
th,td{border:1px solid var(--line);padding:.5rem .7rem;text-align:left}
|
|
|
|
.curl{display:block;background:var(--panel);border:1px solid var(--line);
|
|
border-radius:var(--r-soft);padding:.95rem 1.1rem;font-family:var(--mono);
|
|
font-size:.8rem;color:var(--soft);overflow-x:auto;margin:0 0 2.5rem;
|
|
white-space:pre;line-height:1.9}
|
|
.curl b{color:var(--ink);font-weight:400}
|
|
.curl i{font-style:normal;color:var(--faint)}
|
|
|
|
/* index */
|
|
#q{width:100%;padding:.85rem 1.2rem;font-family:var(--mono);font-size:.85rem;color:var(--ink);
|
|
background:var(--panel);border:1px solid var(--line);border-radius:var(--r);margin:0 0 .6rem}
|
|
#q::placeholder{color:var(--faint);text-transform:uppercase;letter-spacing:.1em;font-size:.72rem}
|
|
#q:focus{outline:none;border-color:var(--soft)}
|
|
#count{color:var(--faint);font-family:var(--mono);font-size:.72rem;letter-spacing:.1em;
|
|
text-transform:uppercase;margin:0 0 2rem}
|
|
.cat{margin:2.5rem 0 .5rem;font-family:var(--mono);font-size:.7rem;letter-spacing:.16em;
|
|
text-transform:uppercase;color:var(--faint);border-bottom:1px solid var(--line);
|
|
padding-bottom:.45rem}
|
|
.row{display:block;padding:.6rem .9rem;margin:0 -.9rem;border-bottom:1px solid var(--line);
|
|
border-radius:var(--r-soft);text-decoration:none}
|
|
.row:hover{background:#0a0a0a}
|
|
.nm{font-family:var(--mono);font-size:.84rem;color:var(--ink);display:block}
|
|
.ds{color:var(--soft);font-size:.9rem;display:block;margin-top:.12rem}
|
|
footer{margin-top:4rem;padding:2rem 0 4rem;border-top:1px solid var(--line);
|
|
color:var(--faint);font-size:.85rem}
|
|
footer a{color:var(--soft)}
|
|
.fmap{display:grid;gap:1.75rem;grid-template-columns:repeat(auto-fit,minmax(11rem,1fr));
|
|
margin:0 0 2rem;font-size:.85rem}
|
|
.fmap b{display:block;font-family:var(--mono);font-size:.68rem;letter-spacing:.16em;
|
|
text-transform:uppercase;color:var(--faint);font-weight:400;margin:0 0 .6rem;
|
|
border-bottom:1px solid var(--line);padding-bottom:.4rem}
|
|
.fmap a{display:inline-block;color:var(--ink);text-decoration:none;margin:.3rem .35rem 0 0}
|
|
.fmap a:hover{text-decoration:underline}
|
|
.fmap div{color:var(--faint);line-height:1.5}
|
|
.fend{border-top:1px solid var(--line);padding-top:1.25rem;font-size:.82rem}
|
|
|
|
@media (max-width:640px){
|
|
.hero .wrap{padding-top:3.25rem;padding-bottom:2.75rem}
|
|
.btns{gap:.5rem}
|
|
.btn{padding:.75rem 1.15rem;font-size:.68rem}
|
|
.copy,.copy .btn{width:100%;justify-content:center}
|
|
.menu{left:0;right:0;min-width:0}
|
|
.strip .in{flex-direction:column;align-items:flex-start;gap:.6rem;padding:.9rem 1.75rem}
|
|
.strip b{border-right:0;padding-right:0}
|
|
.bar{width:100%}
|
|
}
|
|
</style>
|
|
<link rel="alternate" type="text/markdown" href="/security-authorization.md">
|
|
|
|
<link rel="icon" href="/favicon.svg">
|
|
<link rel="canonical" href="https://hanzoskills.com/security-authorization">
|
|
</head>
|
|
<!-- Reading this with a machine? Every page here is also plain markdown.
|
|
This one: https://hanzoskills.com/security-authorization.md
|
|
Index: https://hanzoskills.com/llms.txt
|
|
Corpus: https://hanzoskills.com/all.md
|
|
Append .md to any path for the markdown twin. -->
|
|
<body>
|
|
<nav><div class="in">
|
|
<a class="brand" href="/"><svg class="mark" viewBox="0 0 67 67" fill="currentColor" aria-hidden="true"><path d="M22.21 67V44.6369H0V67H22.21Z"/><path d="M66.7038 22.3184H22.2534L0.0878906 44.6367H44.4634L66.7038 22.3184Z"/><path d="M22.21 0H0V22.3184H22.21V0Z"/><path d="M66.7198 0H44.5098V22.3184H66.7198V0Z"/><path d="M66.7198 67V44.6369H44.5098V67H66.7198Z"/></svg> HANZO<i>SKILLS</i></a>
|
|
<a class="up" href="/">All skills</a>
|
|
</div></nav>
|
|
|
|
<div class="wrap">
|
|
<h1>security-authorization</h1><p class="lede">Authorization models including RBAC, ABAC, policy engines, and access control patterns for securing resources</p><h1>Security: Authorization</h1>
|
|
<p><strong>Scope</strong>: Access control, RBAC, ABAC, policy engines, permissions <strong>Lines</strong>: ~360 <strong>Last Updated</strong>: 2025-10-27</p>
|
|
<h2>When to Use This Skill</h2>
|
|
<p>Activate this skill when:</p>
|
|
<ul><li>Implementing access control systems</li><li>Designing role-based or attribute-based authorization</li><li>Building permission systems for multi-tenant applications</li><li>Implementing policy engines (OPA, Casbin)</li><li>Securing API endpoints and resources</li><li>Preventing privilege escalation vulnerabilities</li><li>Auditing access control decisions</li></ul>
|
|
<h2>Authorization Fundamentals</h2>
|
|
<h3>Authentication vs Authorization</h3>
|
|
<p><strong>Authentication</strong>: "Who are you?" - Verifying identity <strong>Authorization</strong>: "What can you do?" - Verifying permissions</p>
|
|
<pre><code class="lang-python"># After authentication
|
|
user = authenticate(token)
|
|
|
|
# Before allowing action
|
|
if not user.can("delete", post):
|
|
raise ForbiddenError("You cannot delete this post")
|
|
|
|
# Perform action
|
|
delete_post(post)</code></pre>
|
|
<h2>Role-Based Access Control (RBAC)</h2>
|
|
<h3>Basic RBAC Implementation</h3>
|
|
<pre><code class="lang-python">from enum import Enum
|
|
from typing import Set
|
|
|
|
class Role(Enum):
|
|
ADMIN = "admin"
|
|
EDITOR = "editor"
|
|
VIEWER = "viewer"
|
|
|
|
class User:
|
|
def __init__(self, id: int, username: str, roles: Set[Role]):
|
|
self.id = id
|
|
self.username = username
|
|
self.roles = roles
|
|
|
|
def has_role(self, role: Role) -> bool:
|
|
return role in self.roles
|
|
|
|
# Permission mapping
|
|
ROLE_PERMISSIONS = {
|
|
Role.ADMIN: {"read", "write", "delete", "manage_users"},
|
|
Role.EDITOR: {"read", "write"},
|
|
Role.VIEWER: {"read"}
|
|
}
|
|
|
|
def user_can(user: User, permission: str) -> bool:
|
|
"""Check if user has permission through any role"""
|
|
for role in user.roles:
|
|
if permission in ROLE_PERMISSIONS.get(role, set()):
|
|
return True
|
|
return False
|
|
|
|
# Usage
|
|
user = User(1, "alice", {Role.EDITOR})
|
|
|
|
if user_can(user, "write"):
|
|
update_document(doc)
|
|
else:
|
|
raise ForbiddenError("Insufficient permissions")</code></pre>
|
|
<h3>Database Schema for RBAC</h3>
|
|
<pre><code class="lang-sql">-- Users table
|
|
CREATE TABLE users (
|
|
id SERIAL PRIMARY KEY,
|
|
username VARCHAR(255) UNIQUE NOT NULL,
|
|
email VARCHAR(255) UNIQUE NOT NULL,
|
|
created_at TIMESTAMP DEFAULT NOW()
|
|
);
|
|
|
|
-- Roles table
|
|
CREATE TABLE roles (
|
|
id SERIAL PRIMARY KEY,
|
|
name VARCHAR(50) UNIQUE NOT NULL,
|
|
description TEXT
|
|
);
|
|
|
|
-- User-Role assignment (many-to-many)
|
|
CREATE TABLE user_roles (
|
|
user_id INT REFERENCES users(id) ON DELETE CASCADE,
|
|
role_id INT REFERENCES roles(id) ON DELETE CASCADE,
|
|
granted_at TIMESTAMP DEFAULT NOW(),
|
|
granted_by INT REFERENCES users(id),
|
|
PRIMARY KEY (user_id, role_id)
|
|
);
|
|
|
|
-- Permissions table
|
|
CREATE TABLE permissions (
|
|
id SERIAL PRIMARY KEY,
|
|
name VARCHAR(100) UNIQUE NOT NULL,
|
|
resource VARCHAR(100) NOT NULL,
|
|
action VARCHAR(50) NOT NULL
|
|
);
|
|
|
|
-- Role-Permission assignment
|
|
CREATE TABLE role_permissions (
|
|
role_id INT REFERENCES roles(id) ON DELETE CASCADE,
|
|
permission_id INT REFERENCES permissions(id) ON DELETE CASCADE,
|
|
PRIMARY KEY (role_id, permission_id)
|
|
);
|
|
|
|
-- Indexes for performance
|
|
CREATE INDEX idx_user_roles_user ON user_roles(user_id);
|
|
CREATE INDEX idx_role_permissions_role ON role_permissions(role_id);</code></pre>
|
|
<h3>Hierarchical RBAC</h3>
|
|
<pre><code class="lang-python">from typing import Dict, Set
|
|
|
|
class RoleHierarchy:
|
|
"""Implement role inheritance"""
|
|
|
|
def __init__(self):
|
|
# Define role hierarchy (child -> parents)
|
|
self.hierarchy: Dict[Role, Set[Role]] = {
|
|
Role.ADMIN: {Role.EDITOR, Role.VIEWER},
|
|
Role.EDITOR: {Role.VIEWER},
|
|
Role.VIEWER: set()
|
|
}
|
|
|
|
def get_effective_roles(self, role: Role) -> Set[Role]:
|
|
"""Get role and all inherited roles"""
|
|
effective = {role}
|
|
effective.update(self.hierarchy.get(role, set()))
|
|
return effective
|
|
|
|
def has_permission(self, user: User, permission: str) -> bool:
|
|
"""Check permission considering hierarchy"""
|
|
for user_role in user.roles:
|
|
effective_roles = self.get_effective_roles(user_role)
|
|
for role in effective_roles:
|
|
if permission in ROLE_PERMISSIONS.get(role, set()):
|
|
return True
|
|
return False
|
|
|
|
# Usage
|
|
hierarchy = RoleHierarchy()
|
|
admin = User(1, "admin", {Role.ADMIN})
|
|
|
|
# Admin inherits EDITOR and VIEWER permissions
|
|
assert hierarchy.has_permission(admin, "read") # From VIEWER
|
|
assert hierarchy.has_permission(admin, "write") # From EDITOR
|
|
assert hierarchy.has_permission(admin, "manage_users") # From ADMIN</code></pre>
|
|
<h2>Attribute-Based Access Control (ABAC)</h2>
|
|
<h3>ABAC Implementation</h3>
|
|
<pre><code class="lang-python">from dataclasses import dataclass
|
|
from typing import Any, Dict
|
|
from datetime import datetime
|
|
|
|
@dataclass
|
|
class Resource:
|
|
id: int
|
|
type: str
|
|
owner_id: int
|
|
department: str
|
|
classification: str # public, internal, confidential
|
|
created_at: datetime
|
|
|
|
@dataclass
|
|
class Context:
|
|
ip_address: str
|
|
time: datetime
|
|
location: str
|
|
|
|
class ABACPolicy:
|
|
"""Attribute-based access control"""
|
|
|
|
def can_access(self, user: User, action: str, resource: Resource,
|
|
context: Context) -> bool:
|
|
"""Evaluate access based on attributes"""
|
|
|
|
# Rule 1: Owners can do anything with their resources
|
|
if user.id == resource.owner_id:
|
|
return True
|
|
|
|
# Rule 2: Admins can access everything
|
|
if Role.ADMIN in user.roles:
|
|
return True
|
|
|
|
# Rule 3: Department members can read internal resources
|
|
if (action == "read" and
|
|
user.department == resource.department and
|
|
resource.classification in ["public", "internal"]):
|
|
return True
|
|
|
|
# Rule 4: Everyone can read public resources
|
|
if action == "read" and resource.classification == "public":
|
|
return True
|
|
|
|
# Rule 5: Time-based access (business hours only)
|
|
if context.time.hour < 9 or context.time.hour > 17:
|
|
if resource.classification == "confidential":
|
|
return False
|
|
|
|
# Rule 6: Location-based access
|
|
if resource.classification == "confidential":
|
|
if context.location not in AUTHORIZED_LOCATIONS:
|
|
return False
|
|
|
|
return False
|
|
|
|
# Usage
|
|
policy = ABACPolicy()
|
|
|
|
user = User(id=1, username="alice", roles={Role.EDITOR},
|
|
department="engineering")
|
|
|
|
resource = Resource(
|
|
id=100,
|
|
type="document",
|
|
owner_id=2,
|
|
department="engineering",
|
|
classification="internal",
|
|
created_at=datetime.now()
|
|
)
|
|
|
|
context = Context(
|
|
ip_address="192.168.1.1",
|
|
time=datetime.now(),
|
|
location="office"
|
|
)
|
|
|
|
if policy.can_access(user, "read", resource, context):
|
|
serve_resource(resource)
|
|
else:
|
|
raise ForbiddenError("Access denied")</code></pre>
|
|
<h2>Policy Engines</h2>
|
|
<h3>Open Policy Agent (OPA)</h3>
|
|
<p><strong>Rego policy example</strong>:</p>
|
|
<pre><code class="lang-rego">package authz
|
|
|
|
import future.keywords.if
|
|
|
|
# Default deny
|
|
default allow := false
|
|
|
|
# Allow admins everything
|
|
allow if {
|
|
input.user.roles[_] == "admin"
|
|
}
|
|
|
|
# Allow resource owners
|
|
allow if {
|
|
input.user.id == input.resource.owner_id
|
|
}
|
|
|
|
# Allow department members to read internal resources
|
|
allow if {
|
|
input.action == "read"
|
|
input.user.department == input.resource.department
|
|
input.resource.classification == "internal"
|
|
}
|
|
|
|
# Allow everyone to read public resources
|
|
allow if {
|
|
input.action == "read"
|
|
input.resource.classification == "public"
|
|
}</code></pre>
|
|
<p><strong>Python integration</strong>:</p>
|
|
<pre><code class="lang-python">import requests
|
|
import json
|
|
|
|
class OPAClient:
|
|
def __init__(self, opa_url: str = "http://localhost:8181"):
|
|
self.opa_url = opa_url
|
|
|
|
def authorize(self, user: Dict, action: str, resource: Dict) -> bool:
|
|
"""Query OPA for authorization decision"""
|
|
policy_path = "authz/allow"
|
|
url = f"{self.opa_url}/v1/data/{policy_path}"
|
|
|
|
payload = {
|
|
"input": {
|
|
"user": user,
|
|
"action": action,
|
|
"resource": resource
|
|
}
|
|
}
|
|
|
|
response = requests.post(url, json=payload)
|
|
response.raise_for_status()
|
|
|
|
result = response.json()
|
|
return result.get("result", False)
|
|
|
|
# Usage
|
|
opa = OPAClient()
|
|
|
|
user_data = {
|
|
"id": 1,
|
|
"username": "alice",
|
|
"roles": ["editor"],
|
|
"department": "engineering"
|
|
}
|
|
|
|
resource_data = {
|
|
"id": 100,
|
|
"type": "document",
|
|
"owner_id": 2,
|
|
"department": "engineering",
|
|
"classification": "internal"
|
|
}
|
|
|
|
if opa.authorize(user_data, "read", resource_data):
|
|
serve_resource(resource_data)</code></pre>
|
|
<h3>Casbin (Policy Engine)</h3>
|
|
<pre><code class="lang-python">import casbin
|
|
|
|
# Model definition (RBAC with domains)
|
|
model_config = """
|
|
[request_definition]
|
|
r = sub, dom, obj, act
|
|
|
|
[policy_definition]
|
|
p = sub, dom, obj, act
|
|
|
|
[role_definition]
|
|
g = _, _, _
|
|
|
|
[policy_effect]
|
|
e = some(where (p.eft == allow))
|
|
|
|
[matchers]
|
|
m = g(r.sub, p.sub, r.dom) && r.dom == p.dom && r.obj == p.obj && r.act == p.act
|
|
"""
|
|
|
|
# Policy (CSV format)
|
|
policy = """
|
|
p, admin, domain1, data1, read
|
|
p, admin, domain1, data1, write
|
|
p, alice, domain1, data2, read
|
|
|
|
g, alice, admin, domain1
|
|
"""
|
|
|
|
# Create enforcer
|
|
enforcer = casbin.Enforcer("model.conf", "policy.csv")
|
|
|
|
# Check permissions
|
|
if enforcer.enforce("alice", "domain1", "data1", "write"):
|
|
# Alice inherits admin role, can write
|
|
perform_write()
|
|
|
|
# Add policy at runtime
|
|
enforcer.add_policy("bob", "domain1", "data3", "read")
|
|
|
|
# Add role assignment
|
|
enforcer.add_grouping_policy("bob", "editor", "domain1")</code></pre>
|
|
<h2>Resource-Based Authorization</h2>
|
|
<h3>Ownership Check</h3>
|
|
<pre><code class="lang-python">from fastapi import HTTPException, Depends
|
|
|
|
async def get_current_user() -> User:
|
|
# Extract from JWT, session, etc.
|
|
pass
|
|
|
|
async def get_post_or_404(post_id: int) -> Post:
|
|
post = await db.get_post(post_id)
|
|
if not post:
|
|
raise HTTPException(status_code=404, detail="Post not found")
|
|
return post
|
|
|
|
@app.delete("/posts/{post_id}")
|
|
async def delete_post(
|
|
post_id: int,
|
|
user: User = Depends(get_current_user),
|
|
post: Post = Depends(get_post_or_404)
|
|
):
|
|
# Check ownership
|
|
if post.author_id != user.id and not user.has_role(Role.ADMIN):
|
|
raise HTTPException(status_code=403, detail="Forbidden")
|
|
|
|
await db.delete_post(post_id)
|
|
return {"message": "Post deleted"}</code></pre>
|
|
<h3>Row-Level Security (PostgreSQL)</h3>
|
|
<pre><code class="lang-sql">-- Enable RLS on table
|
|
ALTER TABLE documents ENABLE ROW LEVEL SECURITY;
|
|
|
|
-- Policy: Users can only see their own documents
|
|
CREATE POLICY user_documents ON documents
|
|
FOR SELECT
|
|
USING (owner_id = current_setting('app.user_id')::int);
|
|
|
|
-- Policy: Users can update their own documents
|
|
CREATE POLICY user_update_documents ON documents
|
|
FOR UPDATE
|
|
USING (owner_id = current_setting('app.user_id')::int);
|
|
|
|
-- Policy: Admins can see everything
|
|
CREATE POLICY admin_all_documents ON documents
|
|
FOR ALL
|
|
USING (current_setting('app.user_role') = 'admin');</code></pre>
|
|
<pre><code class="lang-python"># Set user context in application
|
|
async def set_user_context(user: User):
|
|
await db.execute(f"SET LOCAL app.user_id = {user.id}")
|
|
await db.execute(f"SET LOCAL app.user_role = '{user.role}'")
|
|
|
|
# Queries automatically filtered by RLS
|
|
@app.get("/documents")
|
|
async def list_documents(user: User = Depends(get_current_user)):
|
|
await set_user_context(user)
|
|
|
|
# RLS automatically filters results
|
|
documents = await db.fetch_all("SELECT * FROM documents")
|
|
|
|
return documents</code></pre>
|
|
<h2>API Authorization Patterns</h2>
|
|
<h3>Decorator-Based Authorization</h3>
|
|
<pre><code class="lang-python">from functools import wraps
|
|
from flask import request, jsonify
|
|
|
|
def require_permission(permission: str):
|
|
"""Decorator to require specific permission"""
|
|
def decorator(f):
|
|
@wraps(f)
|
|
def decorated_function(*args, **kwargs):
|
|
user = get_current_user()
|
|
|
|
if not user:
|
|
return jsonify({"error": "Unauthorized"}), 401
|
|
|
|
if not user_can(user, permission):
|
|
return jsonify({"error": "Forbidden"}), 403
|
|
|
|
return f(*args, **kwargs)
|
|
return decorated_function
|
|
return decorator
|
|
|
|
@app.route('/admin/users', methods=['GET'])
|
|
@require_permission("manage_users")
|
|
def list_users():
|
|
users = db.get_all_users()
|
|
return jsonify(users)</code></pre>
|
|
<h3>Middleware-Based Authorization (FastAPI)</h3>
|
|
<pre><code class="lang-python">from fastapi import FastAPI, Depends, HTTPException
|
|
|
|
app = FastAPI()
|
|
|
|
async def check_permission(
|
|
required_permission: str,
|
|
user: User = Depends(get_current_user)
|
|
):
|
|
"""Dependency for permission checking"""
|
|
if not user_can(user, required_permission):
|
|
raise HTTPException(status_code=403, detail="Forbidden")
|
|
return user
|
|
|
|
@app.get("/admin/users")
|
|
async def list_users(
|
|
user: User = Depends(lambda: check_permission("manage_users"))
|
|
):
|
|
users = await db.get_all_users()
|
|
return users</code></pre>
|
|
<h2>Multi-Tenant Authorization</h2>
|
|
<h3>Tenant Isolation</h3>
|
|
<pre><code class="lang-python">from fastapi import Header, HTTPException
|
|
|
|
async def get_tenant_id(x_tenant_id: str = Header(...)) -> str:
|
|
"""Extract tenant ID from header"""
|
|
tenant = await db.get_tenant(x_tenant_id)
|
|
if not tenant:
|
|
raise HTTPException(status_code=400, detail="Invalid tenant")
|
|
return x_tenant_id
|
|
|
|
async def check_tenant_access(
|
|
user: User = Depends(get_current_user),
|
|
tenant_id: str = Depends(get_tenant_id)
|
|
):
|
|
"""Verify user has access to tenant"""
|
|
if not user.has_tenant_access(tenant_id):
|
|
raise HTTPException(status_code=403, detail="Access denied to tenant")
|
|
return tenant_id
|
|
|
|
@app.get("/tenants/{tenant_id}/documents")
|
|
async def list_documents(
|
|
tenant_id: str = Depends(check_tenant_access),
|
|
user: User = Depends(get_current_user)
|
|
):
|
|
# Query filtered by tenant
|
|
documents = await db.get_documents(tenant_id=tenant_id)
|
|
return documents</code></pre>
|
|
<h2>Security Best Practices</h2>
|
|
<h3>Authorization Checklist</h3>
|
|
<p><strong>Design</strong>:</p>
|
|
<ul><li>[ ] Principle of least privilege (deny by default)</li><li>[ ] Separate authentication from authorization</li><li>[ ] Use centralized authorization logic</li><li>[ ] Audit all authorization decisions</li><li>[ ] Fail securely (default deny)</li></ul>
|
|
<p><strong>Implementation</strong>:</p>
|
|
<ul><li>[ ] Check authorization on every request</li><li>[ ] Validate on server-side (never trust client)</li><li>[ ] Check both endpoint and resource-level permissions</li><li>[ ] Use parameterized queries to prevent injection</li><li>[ ] Log authorization failures</li></ul>
|
|
<p><strong>Testing</strong>:</p>
|
|
<ul><li>[ ] Test privilege escalation scenarios</li><li>[ ] Test cross-tenant access attempts</li><li>[ ] Test role/permission boundary cases</li><li>[ ] Test with different user contexts</li><li>[ ] Test authorization bypass attempts</li></ul>
|
|
<h2>Common Vulnerabilities</h2>
|
|
<h3>Insecure Direct Object Reference (IDOR)</h3>
|
|
<p><strong>Vulnerable code</strong>:</p>
|
|
<pre><code class="lang-python">@app.get("/users/{user_id}/profile")
|
|
def get_profile(user_id: int):
|
|
# ❌ No authorization check
|
|
profile = db.get_user_profile(user_id)
|
|
return profile</code></pre>
|
|
<p><strong>Fixed code</strong>:</p>
|
|
<pre><code class="lang-python">@app.get("/users/{user_id}/profile")
|
|
def get_profile(
|
|
user_id: int,
|
|
current_user: User = Depends(get_current_user)
|
|
):
|
|
# ✅ Check authorization
|
|
if user_id != current_user.id and not current_user.is_admin():
|
|
raise HTTPException(status_code=403, detail="Forbidden")
|
|
|
|
profile = db.get_user_profile(user_id)
|
|
return profile</code></pre>
|
|
<h3>Privilege Escalation</h3>
|
|
<p><strong>Vulnerable code</strong>:</p>
|
|
<pre><code class="lang-python">@app.post("/users/{user_id}/role")
|
|
def update_role(user_id: int, role: str):
|
|
# ❌ Any authenticated user can make anyone admin
|
|
db.update_user_role(user_id, role)</code></pre>
|
|
<p><strong>Fixed code</strong>:</p>
|
|
<pre><code class="lang-python">@app.post("/users/{user_id}/role")
|
|
@require_permission("manage_users")
|
|
def update_role(
|
|
user_id: int,
|
|
role: str,
|
|
current_user: User = Depends(get_current_user)
|
|
):
|
|
# ✅ Only admins can update roles
|
|
# ✅ Prevent self-modification
|
|
if user_id == current_user.id:
|
|
raise HTTPException(status_code=400, detail="Cannot modify own role")
|
|
|
|
db.update_user_role(user_id, role)</code></pre>
|
|
<h2>Related Skills</h2>
|
|
<ul><li><code>security-authentication.md</code> - User identity verification</li><li><code>security-input-validation.md</code> - Validating authorization inputs</li><li><code>api-authorization.md</code> - API-specific authorization patterns</li><li><code>database-security.md</code> - Row-level security and database permissions</li></ul>
|
|
<hr>
|
|
<p><strong>Last Updated</strong>: 2025-10-27 <strong>Format Version</strong>: 1.0 (Atomic)</p>
|
|
<footer>
|
|
<div class="fmap">
|
|
<div><b>Build</b>
|
|
<a href="https://hanzo.app">hanzo.app</a> app builder
|
|
<a href="https://hanzo.codes">hanzo.codes</a> code with an agent
|
|
<a href="https://hanzoskills.com">hanzoskills.com</a> what an agent reads</div>
|
|
<div><b>Run</b>
|
|
<a href="https://console.hanzo.ai">console.hanzo.ai</a> cloud console
|
|
<a href="https://api.hanzo.ai">api.hanzo.ai</a> the API</div>
|
|
<div><b>Account</b>
|
|
<a href="https://hanzo.id">hanzo.id</a> sign in
|
|
<a href="https://pay.hanzo.ai">pay.hanzo.ai</a> top up
|
|
<a href="https://billing.hanzo.ai">billing.hanzo.ai</a> invoices and usage</div>
|
|
<div><b>Company</b>
|
|
<a href="https://hanzo.ai">hanzo.ai</a> canonical
|
|
<a href="https://hanzo.ventures">hanzo.ventures</a> ventures</div>
|
|
</div>
|
|
<div class="fend"><a href="/security-authorization.md">This page as plain text</a> · <a href="/llms.txt">Index for agents</a></div>
|
|
</footer>
|
|
</div></body></html> |