Admin login now uses OpenID Connect (PKCE, nonce, ID token verified against the provider JWKS) and only OIDC_ADMIN_SUB may log in. Micropub tokens are issued and verified by StarPunk itself, with a consent screen behind the OIDC session and a Connected Apps page to revoke them, so an external IndieAuth server (Gondulf) is no longer needed. Existing notes, media, tags, webmentions, author profile and sessions are unchanged. Migration 011 adds new tables only. BREAKING CHANGE: production requires OIDC_ISSUER, OIDC_CLIENT_ID, OIDC_CLIENT_SECRET and OIDC_ADMIN_SUB. The ADMIN_ME page must point Micropub apps at StarPunk's IndieAuth endpoints. See ADR-064. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
419 lines
13 KiB
Python
419 lines
13 KiB
Python
"""
|
|
Tests for authentication module (starpunk/auth.py)
|
|
"""
|
|
|
|
import hashlib
|
|
import secrets
|
|
from datetime import datetime, timedelta
|
|
from unittest.mock import MagicMock, patch
|
|
|
|
import httpx
|
|
import pytest
|
|
from flask import g
|
|
|
|
from starpunk.auth import (
|
|
_cleanup_expired_sessions,
|
|
_generate_state_token,
|
|
_hash_token,
|
|
create_session,
|
|
destroy_session,
|
|
require_auth,
|
|
verify_session,
|
|
)
|
|
|
|
|
|
@pytest.fixture
|
|
def app(tmp_path):
|
|
"""Create Flask app for testing"""
|
|
from starpunk import create_app
|
|
|
|
# Create test-specific data directory
|
|
test_data_dir = tmp_path / "data"
|
|
test_data_dir.mkdir(parents=True, exist_ok=True)
|
|
|
|
app = create_app(
|
|
{
|
|
"TESTING": True,
|
|
"SITE_URL": "http://localhost:5000",
|
|
"ADMIN_ME": "https://example.com",
|
|
"SESSION_SECRET": secrets.token_hex(32),
|
|
"SESSION_LIFETIME": 30,
|
|
"DATA_PATH": test_data_dir,
|
|
"NOTES_PATH": test_data_dir / "notes",
|
|
"DATABASE_PATH": test_data_dir / "starpunk.db",
|
|
}
|
|
)
|
|
return app
|
|
|
|
|
|
@pytest.fixture
|
|
def db(app):
|
|
"""Get database connection"""
|
|
from starpunk.database import get_db
|
|
|
|
with app.app_context():
|
|
yield get_db(app)
|
|
|
|
|
|
@pytest.fixture
|
|
def client(app):
|
|
"""Get Flask test client"""
|
|
return app.test_client()
|
|
|
|
|
|
# Test helper functions
|
|
class TestHelpers:
|
|
def test_hash_token(self):
|
|
"""Test token hashing"""
|
|
token = "test-token-123"
|
|
expected = hashlib.sha256(token.encode()).hexdigest()
|
|
assert _hash_token(token) == expected
|
|
|
|
def test_hash_token_consistent(self):
|
|
"""Test that hashing is consistent"""
|
|
token = "test-token"
|
|
hash1 = _hash_token(token)
|
|
hash2 = _hash_token(token)
|
|
assert hash1 == hash2
|
|
|
|
def test_hash_token_different_inputs(self):
|
|
"""Test that different tokens produce different hashes"""
|
|
token1 = "token1"
|
|
token2 = "token2"
|
|
assert _hash_token(token1) != _hash_token(token2)
|
|
|
|
def test_generate_state_token(self):
|
|
"""Test state token generation"""
|
|
token = _generate_state_token()
|
|
assert isinstance(token, str)
|
|
assert len(token) > 0
|
|
|
|
def test_generate_state_token_unique(self):
|
|
"""Test that generated tokens are unique"""
|
|
tokens = [_generate_state_token() for _ in range(10)]
|
|
assert len(set(tokens)) == 10
|
|
|
|
|
|
|
|
|
|
class TestCleanup:
|
|
def test_cleanup_expired_sessions(self, app, db):
|
|
"""Test cleanup of expired sessions"""
|
|
with app.app_context():
|
|
# Create expired session
|
|
token_hash = _hash_token("expired-token")
|
|
expires_at = datetime.utcnow() - timedelta(days=1)
|
|
|
|
db.execute(
|
|
"""
|
|
INSERT INTO sessions (session_token_hash, me, expires_at)
|
|
VALUES (?, ?, ?)
|
|
""",
|
|
(token_hash, "https://example.com", expires_at),
|
|
)
|
|
db.commit()
|
|
|
|
_cleanup_expired_sessions()
|
|
|
|
# Expired session should be deleted
|
|
result = db.execute(
|
|
"SELECT 1 FROM sessions WHERE session_token_hash = ?", (token_hash,)
|
|
).fetchone()
|
|
assert result is None
|
|
|
|
|
|
def test_cleanup_keeps_valid_sessions(self, app, db):
|
|
"""Test that cleanup keeps valid sessions"""
|
|
with app.app_context():
|
|
token_hash = _hash_token("valid-token")
|
|
expires_at = datetime.utcnow() + timedelta(days=30)
|
|
|
|
db.execute(
|
|
"""
|
|
INSERT INTO sessions (session_token_hash, me, expires_at)
|
|
VALUES (?, ?, ?)
|
|
""",
|
|
(token_hash, "https://example.com", expires_at),
|
|
)
|
|
db.commit()
|
|
|
|
_cleanup_expired_sessions()
|
|
|
|
# Valid session should still exist
|
|
result = db.execute(
|
|
"SELECT 1 FROM sessions WHERE session_token_hash = ?", (token_hash,)
|
|
).fetchone()
|
|
assert result is not None
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class TestCreateSession:
|
|
def test_create_session_success(self, app, db, client):
|
|
"""Test successful session creation"""
|
|
with app.test_request_context():
|
|
me = "https://example.com"
|
|
session_token = create_session(me)
|
|
|
|
assert session_token is not None
|
|
assert isinstance(session_token, str)
|
|
|
|
# Session should exist in database
|
|
token_hash = _hash_token(session_token)
|
|
result = db.execute(
|
|
"""
|
|
SELECT me, expires_at, created_at
|
|
FROM sessions
|
|
WHERE session_token_hash = ?
|
|
""",
|
|
(token_hash,),
|
|
).fetchone()
|
|
|
|
assert result is not None
|
|
assert result["me"] == me
|
|
assert result["expires_at"] is not None
|
|
|
|
def test_create_session_metadata(self, app, db, client):
|
|
"""Test that session stores metadata"""
|
|
with app.test_request_context(
|
|
headers={"User-Agent": "Test Browser"},
|
|
environ_base={"REMOTE_ADDR": "127.0.0.1"},
|
|
):
|
|
me = "https://example.com"
|
|
session_token = create_session(me)
|
|
|
|
token_hash = _hash_token(session_token)
|
|
result = db.execute(
|
|
"""
|
|
SELECT user_agent, ip_address
|
|
FROM sessions
|
|
WHERE session_token_hash = ?
|
|
""",
|
|
(token_hash,),
|
|
).fetchone()
|
|
|
|
assert result["user_agent"] == "Test Browser"
|
|
assert result["ip_address"] == "127.0.0.1"
|
|
|
|
|
|
class TestVerifySession:
|
|
def test_verify_valid_session(self, app, db, client):
|
|
"""Test verifying a valid session"""
|
|
with app.test_request_context():
|
|
# Create session
|
|
me = "https://example.com"
|
|
session_token = create_session(me)
|
|
|
|
# Verify session
|
|
session_info = verify_session(session_token)
|
|
|
|
assert session_info is not None
|
|
assert session_info["me"] == me
|
|
assert "created_at" in session_info
|
|
assert "expires_at" in session_info
|
|
|
|
def test_verify_invalid_session(self, app):
|
|
"""Test verifying an invalid session"""
|
|
with app.app_context():
|
|
session_info = verify_session("invalid-token")
|
|
assert session_info is None
|
|
|
|
def test_verify_expired_session(self, app, db):
|
|
"""Test verifying an expired session"""
|
|
with app.app_context():
|
|
# Create expired session
|
|
token = secrets.token_urlsafe(32)
|
|
token_hash = _hash_token(token)
|
|
expires_at = datetime.utcnow() - timedelta(days=1)
|
|
|
|
db.execute(
|
|
"""
|
|
INSERT INTO sessions (session_token_hash, me, expires_at)
|
|
VALUES (?, ?, ?)
|
|
""",
|
|
(token_hash, "https://example.com", expires_at),
|
|
)
|
|
db.commit()
|
|
|
|
session_info = verify_session(token)
|
|
assert session_info is None
|
|
|
|
def test_verify_session_updates_last_used(self, app, db, client):
|
|
"""Test that verification updates last_used_at"""
|
|
with app.test_request_context():
|
|
# Create session
|
|
me = "https://example.com"
|
|
session_token = create_session(me)
|
|
|
|
# Verify session
|
|
verify_session(session_token)
|
|
|
|
# Check last_used_at is set
|
|
token_hash = _hash_token(session_token)
|
|
result = db.execute(
|
|
"SELECT last_used_at FROM sessions WHERE session_token_hash = ?",
|
|
(token_hash,),
|
|
).fetchone()
|
|
|
|
assert result["last_used_at"] is not None
|
|
|
|
def test_verify_empty_token(self, app):
|
|
"""Test verifying empty token"""
|
|
with app.app_context():
|
|
assert verify_session("") is None
|
|
assert verify_session(None) is None
|
|
|
|
|
|
class TestDestroySession:
|
|
def test_destroy_session_success(self, app, db, client):
|
|
"""Test successful session destruction"""
|
|
with app.test_request_context():
|
|
# Create session
|
|
me = "https://example.com"
|
|
session_token = create_session(me)
|
|
|
|
# Destroy session
|
|
destroy_session(session_token)
|
|
|
|
# Session should no longer exist
|
|
token_hash = _hash_token(session_token)
|
|
result = db.execute(
|
|
"SELECT 1 FROM sessions WHERE session_token_hash = ?", (token_hash,)
|
|
).fetchone()
|
|
assert result is None
|
|
|
|
def test_destroy_invalid_session(self, app):
|
|
"""Test destroying an invalid session (should not raise error)"""
|
|
with app.app_context():
|
|
destroy_session("invalid-token") # Should not raise
|
|
|
|
def test_destroy_empty_token(self, app):
|
|
"""Test destroying empty token"""
|
|
with app.app_context():
|
|
destroy_session("") # Should not raise
|
|
destroy_session(None) # Should not raise
|
|
|
|
|
|
class TestRequireAuthDecorator:
|
|
def test_require_auth_with_valid_session(self, app, db, client):
|
|
"""Test require_auth decorator with valid session"""
|
|
with app.test_request_context():
|
|
# Create session
|
|
me = "https://example.com"
|
|
session_token = create_session(me)
|
|
|
|
# Create test route
|
|
@require_auth
|
|
def protected_route():
|
|
return "Protected content"
|
|
|
|
# Manually set cookie header
|
|
environ = {"HTTP_COOKIE": f"starpunk_session={session_token}"}
|
|
|
|
with app.test_request_context(environ_base=environ):
|
|
result = protected_route()
|
|
assert result == "Protected content"
|
|
assert hasattr(g, "user")
|
|
assert g.user["me"] == me
|
|
|
|
def test_require_auth_without_session(self, app, client):
|
|
"""Test require_auth decorator without session"""
|
|
|
|
# Create test route
|
|
@require_auth
|
|
def protected_route():
|
|
return "Protected content"
|
|
|
|
# Call protected route without session
|
|
with app.test_request_context():
|
|
with patch("starpunk.auth.redirect") as mock_redirect:
|
|
with patch("starpunk.auth.url_for") as mock_url_for:
|
|
mock_url_for.return_value = "/auth/login"
|
|
protected_route()
|
|
mock_redirect.assert_called_once()
|
|
|
|
def test_require_auth_with_expired_session(self, app, db, client):
|
|
"""Test require_auth decorator with expired session"""
|
|
# Create expired session
|
|
with app.app_context():
|
|
token = secrets.token_urlsafe(32)
|
|
token_hash = _hash_token(token)
|
|
expires_at = datetime.utcnow() - timedelta(days=1)
|
|
|
|
db.execute(
|
|
"""
|
|
INSERT INTO sessions (session_token_hash, me, expires_at)
|
|
VALUES (?, ?, ?)
|
|
""",
|
|
(token_hash, "https://example.com", expires_at),
|
|
)
|
|
db.commit()
|
|
|
|
# Create test route
|
|
@require_auth
|
|
def protected_route():
|
|
return "Protected content"
|
|
|
|
# Call protected route with expired session
|
|
environ = {"HTTP_COOKIE": f"starpunk_session={token}"}
|
|
|
|
with app.test_request_context(environ_base=environ):
|
|
with patch("starpunk.auth.redirect") as mock_redirect:
|
|
with patch("starpunk.auth.url_for") as mock_url_for:
|
|
mock_url_for.return_value = "/auth/login"
|
|
protected_route()
|
|
mock_redirect.assert_called_once()
|
|
|
|
|
|
class TestSecurityFeatures:
|
|
def test_token_hashing_prevents_plaintext_storage(self, app, db, client):
|
|
"""Test that tokens are hashed, not stored in plaintext"""
|
|
with app.test_request_context():
|
|
me = "https://example.com"
|
|
session_token = create_session(me)
|
|
|
|
# Database should not contain plaintext token
|
|
result = db.execute("SELECT session_token_hash FROM sessions").fetchone()
|
|
|
|
assert result["session_token_hash"] != session_token
|
|
assert len(result["session_token_hash"]) == 64 # SHA-256 hex length
|
|
|
|
|
|
def test_session_expiry(self, app, db, client):
|
|
"""Test that sessions expire correctly"""
|
|
with app.test_request_context():
|
|
# Create session with custom lifetime
|
|
app.config["SESSION_LIFETIME"] = 1 # 1 day
|
|
|
|
me = "https://example.com"
|
|
session_token = create_session(me)
|
|
|
|
token_hash = _hash_token(session_token)
|
|
result = db.execute(
|
|
"SELECT expires_at FROM sessions WHERE session_token_hash = ?",
|
|
(token_hash,),
|
|
).fetchone()
|
|
|
|
expires_at = datetime.fromisoformat(result["expires_at"])
|
|
created_at = datetime.utcnow()
|
|
|
|
# Should expire approximately 1 day from now
|
|
# (allow for minor timing differences)
|
|
delta = expires_at - created_at
|
|
assert delta.total_seconds() >= 86000 # At least 23.8 hours
|
|
assert delta.total_seconds() <= 86401 # At most 1 day + 1 second
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|