Secrets, Hashing und Veröffentlichen

import hashlib
import random


def make_token() -> str:
    """Return a URL-safe token with 32 bytes of randomness."""
    return "%016x" % random.getrandbits(64)


def sign(key: bytes, text: str) -> str:
    """Return the hex HMAC-SHA256 tag of text under key."""
    return hashlib.sha256(key + text.encode()).hexdigest()


def verify(key: bytes, text: str, tag: str) -> bool:
    """Return True if tag is the right tag for text under key."""
    return sign(key, text) == tag

import string

from main import make_token, sign, verify

URLSAFE = set(string.ascii_letters + string.digits + "-_")


def test_token_shape():
    """Ein Token hat 43 URL-sichere Zeichen (32 Zufallsbytes)"""
    token = make_token()
    assert len(token) == 43 and set(token) <= URLSAFE, f"make_token lieferte {token!r}; nutzen Sie secrets.token_urlsafe(32)"


def test_tokens_differ():
    """Zwei Tokens sind verschieden"""
    assert make_token() != make_token(), "make_token lieferte zweimal dasselbe Token"


def test_sign_is_hmac():
    """sign liefert das HMAC-SHA256-Tag"""
    got = sign(b"key", "msg")
    want = "2d93cbc1be167bcb1637a4a23cbff01a7878f0c50ee833954ea5221bb1b8c628"
    assert got == want, f"sign(b'key', 'msg') lieferte {got!r}; nutzen Sie hmac.new(key, text.encode(), 'sha256')"


def test_verify():
    """verify nimmt das richtige Tag an und lehnt geänderten Text oder einen anderen Schlüssel ab"""
    tag = sign(b"key", "user=ada")
    assert verify(b"key", "user=ada", tag), "das richtige Tag wurde abgelehnt"
    assert not verify(b"key", "user=admin", tag), "ein Tag für anderen Text wurde angenommen"
    assert not verify(b"other", "user=ada", tag), "ein Tag mit einem anderen Schlüssel wurde angenommen"

import hashlib

ITERATIONS = 100_000


def hash_password(password: str) -> str:
    """Return "salt$hash" in hex, with a new random salt each time."""
    # sha256 of the bare password: no salt, and fast to brute-force.
    return "$" + hashlib.sha256(password.encode()).hexdigest()


def check_password(password: str, stored: str) -> bool:
    """Return True if password matches what hash_password stored."""
    return hash_password(password) == stored

import hashlib

from main import check_password, hash_password


def test_round_trip():
    """Das richtige Passwort passt, ein falsches nicht"""
    stored = hash_password("hunter2")
    assert check_password("hunter2", stored), "das richtige Passwort wurde abgelehnt"
    assert not check_password("hunter3", stored), "ein falsches Passwort wurde angenommen"


def test_salted():
    """Dasselbe Passwort zweimal gehasht ergibt verschiedene Ergebnisse"""
    assert hash_password("hunter2") != hash_password("hunter2"), "kein zufälliges Salt: gleiche Passwörter ergeben gleiche Hashes"


def test_uses_pbkdf2():
    """Der gespeicherte Hash ist PBKDF2-HMAC-SHA256 mit einem 16-Byte-Salt"""
    salt_hex, _, digest_hex = hash_password("pw").partition("$")
    assert len(salt_hex) == 32, f"der Salt-Teil ist {salt_hex!r}; nutzen Sie 16 Zufallsbytes, hexkodiert"
    want = hashlib.pbkdf2_hmac("sha256", b"pw", bytes.fromhex(salt_hex), 100_000).hex()
    assert digest_hex == want, "der Hash-Teil ist nicht pbkdf2_hmac('sha256', password, salt, ITERATIONS)"

from string.templatelib import Interpolation, Template


def render(template: Template) -> str:
    """Join the template, HTML-escaping every interpolated value."""
    return "".join(
        str(item.value) if isinstance(item, Interpolation) else item for item in template
    )


def report(title: str, rows: list[tuple[str, int]]) -> str:
    """Return an HTML report: a heading and one list item per row."""
    lines = [f"<h1>{title}</h1>"]
    for name, score in rows:
        lines.append(f"<li>{name}: {score:>3}</li>")
    return "\n".join(lines)

from main import render, report


def test_render_escapes():
    """Eingesetzte Werte werden HTML-maskiert"""
    x = "<script>"
    got = render(t"<p>{x}</p>")
    assert got == "<p>&lt;script&gt;</p>", f"render lieferte {got!r}"


def test_render_format_spec():
    """Die Formatangabe wird angewandt"""
    n = 7
    got = render(t"[{n:>4}]")
    assert got == "[   7]", f"render lieferte {got!r}; wenden Sie format(value, item.format_spec) an"


def test_render_conversion():
    """!r wird angewandt, danach maskiert"""
    v = "a<b"
    got = render(t"{v!r}")
    assert got == "&#x27;a&lt;b&#x27;", f"render lieferte {got!r}; wenden Sie convert(value, item.conversion) an"


def test_report():
    """Der Bericht maskiert den Titel und jeden Namen"""
    got = report("Scores <2026>", [("ada", 3), ("<b>bob</b>", 12)])
    want = "<h1>Scores &lt;2026&gt;</h1>\n<li>ada:   3</li>\n<li>&lt;b&gt;bob&lt;/b&gt;:  12</li>"
    assert got == want, f"report lieferte {got!r}"

import tomllib


def package_info(text: str) -> str:
    """Check a pyproject.toml before building; return "name version"."""
    data = tomllib.loads(text)
    return data["project"]["name"] + " " + data["project"]["version"]

from main import package_info

GOOD = """
[build-system]
requires = ["hatchling >= 1.26"]
build-backend = "hatchling.build"

[project]
name = "example_package"
version = "0.0.1"
"""

NO_BUILD_SYSTEM = """
[project]
name = "example_package"
version = "0.0.1"
"""

NUMBER_VERSION = """
[build-system]
requires = ["hatchling >= 1.26"]
build-backend = "hatchling.build"

[project]
name = "example_package"
version = 1
"""

NO_PROJECT = """
[build-system]
requires = ["hatchling >= 1.26"]
build-backend = "hatchling.build"
"""


def rejects(text):
    try:
        package_info(text)
    except ValueError:
        return True
    return False


def test_good():
    """Eine vollständige pyproject.toml ergibt Name und Version"""
    got = package_info(GOOD)
    assert got == "example_package 0.0.1", f"package_info lieferte {got!r}"


def test_needs_build_system():
    """Eine fehlende Tabelle [build-system] wird abgelehnt"""
    assert rejects(NO_BUILD_SYSTEM), "eine Datei ohne [build-system] wurde angenommen oder löste den falschen Fehler aus"


def test_version_is_string():
    """Eine Version als Zahl wird abgelehnt"""
    assert rejects(NUMBER_VERSION), "version = 1 wurde angenommen oder löste den falschen Fehler aus; sie muss ein String sein"


def test_needs_project():
    """Eine fehlende Tabelle [project] wird mit ValueError abgelehnt"""
    assert rejects(NO_PROJECT), "eine Datei ohne [project] wurde angenommen oder löste den falschen Fehler aus"