pico-server-auth 0.1.0__py3-none-any.whl

pico_server_auth/__init__.py

@@ -0,0 +1,15 @@
+"""pico-server-auth: embeddable auth server module.
+
+Auto-discovered by pico-boot via the ``pico_boot.modules`` entry point.
+Provides JWT issuance, wallet challenge/verify login, password login,
+and JWKS endpoint as FastAPI controllers.
+
+Compatible with pico-client-auth — tokens issued here are validated
+by pico-client-auth in the same process or across services.
+"""
+
+from .challenge_store import ChallengeStore as ChallengeStore
+from .challenge_store import InMemoryChallengeStore as InMemoryChallengeStore
+from .config import ServerAuthSettings as ServerAuthSettings
+from .token_issuer import TokenIssuer as TokenIssuer
+from .wallet_verifier import WalletVerifier as WalletVerifier

pico_server_auth/_version.py

@@ -0,0 +1 @@
+__version__ = '0.1.0'

pico_server_auth/challenge_store.py

@@ -0,0 +1,57 @@
+import secrets
+import time
+from typing import Protocol
+
+from pico_ioc import component
+
+from pico_server_auth.config import ServerAuthSettings
+
+
+class ChallengeStore(Protocol):
+    """Protocol for storing and validating auth challenges.
+
+    Default implementation is in-memory with TTL expiry.
+    Replace with a Redis or DB-backed implementation by registering
+    your own @component that implements this protocol.
+    """
+
+    def create(self, address: str) -> str: ...
+
+    def validate(self, address: str, nonce: str) -> bool: ...
+
+    def cleanup(self) -> int: ...
+
+
+@component(on_missing_selector=ChallengeStore)
+class InMemoryChallengeStore:
+    """In-memory challenge store with TTL-based expiry.
+
+    Suitable for single-process deployments. For multi-instance setups,
+    register a shared-storage implementation of ChallengeStore.
+    """
+
+    def __init__(self, settings: ServerAuthSettings):
+        self._ttl = settings.challenge_ttl_seconds
+        self._challenges: dict[str, tuple[str, float]] = {}
+
+    def create(self, address: str) -> str:
+        self.cleanup()
+        nonce = secrets.token_hex(32)
+        self._challenges[address] = (nonce, time.time())
+        return nonce
+
+    def validate(self, address: str, nonce: str) -> bool:
+        entry = self._challenges.pop(address, None)
+        if entry is None:
+            return False
+        stored_nonce, created_at = entry
+        if time.time() - created_at > self._ttl:
+            return False
+        return secrets.compare_digest(stored_nonce, nonce)
+
+    def cleanup(self) -> int:
+        now = time.time()
+        expired = [k for k, (_, t) in self._challenges.items() if now - t > self._ttl]
+        for k in expired:
+            del self._challenges[k]
+        return len(expired)

pico_server_auth/config.py

@@ -0,0 +1,24 @@
+from dataclasses import dataclass, field
+
+from pico_ioc import configured
+
+
+@configured(target="self", prefix="server_auth", mapping="tree")
+@dataclass
+class ServerAuthSettings:
+    """Configuration for pico-server-auth.
+
+    When embedded alongside pico-client-auth, set ``issuer`` and ``audience``
+    to the same values so tokens issued here are accepted by the client middleware.
+    """
+
+    issuer: str = "http://localhost:8100"
+    audience: str = "pico"
+    algorithm: str = "RS256"
+    access_token_expire_minutes: int = 15
+    refresh_token_expire_days: int = 7
+    challenge_ttl_seconds: int = 60
+    auto_create_admin: bool = False
+    admin_email: str = "admin@pico.local"
+    admin_password: str = "admin"
+    supported_wallet_algorithms: list[str] = field(default_factory=lambda: ["ML-DSA-65", "Ed25519", "secp256k1"])

pico_server_auth/controllers.py

@@ -0,0 +1,129 @@
+from typing import Any
+
+from fastapi import HTTPException
+from pico_client_auth import allow_anonymous
+from pico_fastapi import controller, get, post
+
+from pico_server_auth.challenge_store import ChallengeStore
+from pico_server_auth.config import ServerAuthSettings
+from pico_server_auth.token_issuer import TokenIssuer
+from pico_server_auth.wallet_verifier import WalletVerifier
+
+
+@controller(prefix="/auth", tags=["Auth"])
+class AuthController:
+    """Auth endpoints — compatible with pico-client-auth validation.
+
+    JWKS endpoint allows pico-client-auth to validate tokens whether
+    this module runs in the same process or as a separate service.
+    """
+
+    def __init__(
+        self,
+        settings: ServerAuthSettings,
+        challenges: ChallengeStore,
+        verifier: WalletVerifier,
+        issuer: TokenIssuer,
+    ):
+        self._settings = settings
+        self._challenges = challenges
+        self._verifier = verifier
+        self._issuer = issuer
+
+    @allow_anonymous
+    @get("/jwks")
+    async def jwks(self):
+        """JWKS endpoint — pico-client-auth fetches this to validate tokens."""
+        return self._issuer.jwks()
+
+    @allow_anonymous
+    @post("/challenge")
+    async def challenge(self, body: dict[str, Any]):
+        """Request a challenge nonce for wallet auth.
+
+        Body: { "address": "0x..." }
+        Returns: { "challenge": "<nonce>", "ttl": 60 }
+        """
+        address = body.get("address")
+        if not address:
+            raise HTTPException(status_code=400, detail="address required")
+        nonce = self._challenges.create(str(address))
+        return {
+            "challenge": nonce,
+            "ttl": self._settings.challenge_ttl_seconds,
+        }
+
+    @allow_anonymous
+    @post("/wallet")
+    async def wallet_login(self, body: dict[str, Any]):
+        """Verify wallet signature and issue JWT.
+
+        Body: {
+            "address": "0x...",
+            "public_key": "<hex>",
+            "signature": "<hex>",
+            "challenge": "<nonce>",
+            "algorithm": "ML-DSA-65" | "Ed25519" | "secp256k1"
+        }
+        Returns: { "access_token": "...", "refresh_token": "...", "address": "..." }
+        """
+        address = str(body.get("address", ""))
+        public_key_hex = str(body.get("public_key", ""))
+        signature_hex = str(body.get("signature", ""))
+        challenge_nonce = str(body.get("challenge", ""))
+        algorithm = str(body.get("algorithm", "ML-DSA-65"))
+
+        if not all([address, public_key_hex, signature_hex, challenge_nonce]):
+            raise HTTPException(status_code=400, detail="address, public_key, signature, and challenge required")
+
+        if not self._challenges.validate(address, challenge_nonce):
+            raise HTTPException(status_code=401, detail="invalid or expired challenge")
+
+        try:
+            public_key = bytes.fromhex(public_key_hex)
+            signature = bytes.fromhex(signature_hex)
+            message = challenge_nonce.encode("utf-8")
+        except ValueError:
+            raise HTTPException(status_code=400, detail="invalid hex encoding")
+
+        if not self._verifier.verify(algorithm, public_key, message, signature):
+            raise HTTPException(status_code=401, detail="signature verification failed")
+
+        access_token = self._issuer.issue_access_token(
+            subject=address,
+            role="wallet",
+            extra_claims={"algorithm": algorithm, "wallet_address": address},
+        )
+        refresh_token = self._issuer.issue_refresh_token(subject=address)
+
+        return {
+            "access_token": access_token,
+            "refresh_token": refresh_token,
+            "address": address,
+            "algorithm": algorithm,
+        }
+
+    @allow_anonymous
+    @post("/login")
+    async def password_login(self, body: dict[str, Any]):
+        """Password-based login (for admin bootstrap).
+
+        Body: { "email": "...", "password": "..." }
+        Returns: { "access_token": "...", "refresh_token": "..." }
+        """
+        email = str(body.get("email", ""))
+        password = str(body.get("password", ""))
+
+        if not self._settings.auto_create_admin:
+            raise HTTPException(status_code=403, detail="password login disabled")
+
+        if email != self._settings.admin_email or password != self._settings.admin_password:
+            raise HTTPException(status_code=401, detail="invalid credentials")
+
+        access_token = self._issuer.issue_access_token(subject=email, role="admin")
+        refresh_token = self._issuer.issue_refresh_token(subject=email)
+
+        return {
+            "access_token": access_token,
+            "refresh_token": refresh_token,
+        }

pico_server_auth/token_issuer.py

@@ -0,0 +1,100 @@
+import time
+from typing import Any
+
+from cryptography.hazmat.primitives import serialization
+from pico_ioc import component
+
+from pico_server_auth.config import ServerAuthSettings
+
+
+@component
+class TokenIssuer:
+    """Issues JWT tokens compatible with pico-client-auth validation.
+
+    Tokens use the same issuer/audience as configured in pico-client-auth,
+    so they are accepted transparently whether issued in-process or remotely.
+    """
+
+    def __init__(self, settings: ServerAuthSettings):
+        self._settings = settings
+        self._private_key: Any = None
+        self._public_key: Any = None
+        self._jwk: dict | None = None
+        self._kid: str = "pico-server-auth-1"
+        self._init_keys()
+
+    def _init_keys(self) -> None:
+        alg = self._settings.algorithm
+        if alg == "RS256":
+            from cryptography.hazmat.primitives.asymmetric import rsa
+
+            self._private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
+            self._public_key = self._private_key.public_key()
+        elif alg in ("ML-DSA-65", "ML-DSA-87"):
+            pass  # TODO: post-quantum key generation
+        else:
+            raise ValueError(f"unsupported token algorithm: {alg}")
+
+    def issue_access_token(self, subject: str, role: str = "user", extra_claims: dict | None = None) -> str:
+        from jose import jwt
+
+        now = int(time.time())
+        payload = {
+            "sub": subject,
+            "iss": self._settings.issuer,
+            "aud": self._settings.audience,
+            "iat": now,
+            "exp": now + self._settings.access_token_expire_minutes * 60,
+            "role": role,
+            **(extra_claims or {}),
+        }
+
+        pem = self._private_key.private_bytes(
+            encoding=serialization.Encoding.PEM,
+            format=serialization.PrivateFormat.PKCS8,
+            encryption_algorithm=serialization.NoEncryption(),
+        )
+        return jwt.encode(payload, pem, algorithm="RS256", headers={"kid": self._kid})
+
+    def issue_refresh_token(self, subject: str) -> str:
+        from jose import jwt
+
+        now = int(time.time())
+        payload = {
+            "sub": subject,
+            "iss": self._settings.issuer,
+            "aud": self._settings.audience,
+            "iat": now,
+            "exp": now + self._settings.refresh_token_expire_days * 86400,
+            "type": "refresh",
+        }
+
+        pem = self._private_key.private_bytes(
+            encoding=serialization.Encoding.PEM,
+            format=serialization.PrivateFormat.PKCS8,
+            encryption_algorithm=serialization.NoEncryption(),
+        )
+        return jwt.encode(payload, pem, algorithm="RS256", headers={"kid": self._kid})
+
+    def jwks(self) -> dict:
+        """Returns JWKS for pico-client-auth to validate tokens.
+
+        When running in the same process, pico-client-auth can fetch
+        this from the /auth/jwks endpoint or directly from this component.
+        """
+        if self._jwk is None:
+            pub_numbers = self._public_key.public_numbers()
+            import base64
+
+            def _b64url(n: int, length: int) -> str:
+                return base64.urlsafe_b64encode(n.to_bytes(length, "big")).rstrip(b"=").decode()
+
+            self._jwk = {
+                "kty": "RSA",
+                "kid": self._kid,
+                "alg": "RS256",
+                "use": "sig",
+                "n": _b64url(pub_numbers.n, 256),
+                "e": _b64url(pub_numbers.e, 3),
+            }
+        return {"keys": [self._jwk]}

pico_server_auth/wallet_verifier.py

@@ -0,0 +1,81 @@
+from pico_ioc import component
+
+from pico_server_auth.config import ServerAuthSettings
+
+
+@component
+class WalletVerifier:
+    """Verifies wallet signatures for challenge-response auth.
+
+    Supports ML-DSA-65 (FIPS 204), Ed25519, and secp256k1.
+    Each backend is loaded on first use to avoid hard dependencies.
+    """
+
+    def __init__(self, settings: ServerAuthSettings):
+        self._supported = set(settings.supported_wallet_algorithms)
+
+    def verify(self, algorithm: str, public_key: bytes, message: bytes, signature: bytes) -> bool:
+        if algorithm not in self._supported:
+            raise ValueError(f"unsupported wallet algorithm: {algorithm}")
+
+        if algorithm == "ML-DSA-65":
+            return self._verify_mldsa65(public_key, message, signature)
+        elif algorithm == "Ed25519":
+            return self._verify_ed25519(public_key, message, signature)
+        elif algorithm == "secp256k1":
+            return self._verify_secp256k1(public_key, message, signature)
+        else:
+            raise ValueError(f"no verifier for algorithm: {algorithm}")
+
+    @staticmethod
+    def _verify_mldsa65(public_key: bytes, message: bytes, signature: bytes) -> bool:
+        # Try native SDK backend first
+        try:
+            from dilithia_sdk.crypto import load_native_crypto_adapter
+
+            adapter = load_native_crypto_adapter()
+            if adapter is not None:
+                return adapter.verify_message(
+                    public_key.hex(),
+                    message.decode("utf-8", errors="replace"),
+                    signature.hex(),
+                )
+        except ImportError:
+            pass
+
+        # Fallback: cryptography lib (when FIPS 204 support is available)
+        try:
+            from cryptography.hazmat.primitives.asymmetric import mldsa
+
+            pk = mldsa.MLDSA65PublicKey.from_public_bytes(public_key)
+            pk.verify(signature, message)
+            return True
+        except (ImportError, AttributeError):
+            pass
+        except Exception:
+            return False
+
+        raise RuntimeError("ML-DSA-65 verification requires a compatible crypto backend")
+
+    @staticmethod
+    def _verify_ed25519(public_key: bytes, message: bytes, signature: bytes) -> bool:
+        try:
+            from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
+
+            pk = Ed25519PublicKey.from_public_bytes(public_key)
+            pk.verify(signature, message)
+            return True
+        except Exception:
+            return False
+
+    @staticmethod
+    def _verify_secp256k1(public_key: bytes, message: bytes, signature: bytes) -> bool:
+        try:
+            from cryptography.hazmat.primitives import hashes
+            from cryptography.hazmat.primitives.asymmetric import ec
+
+            pk = ec.EllipticCurvePublicKey.from_encoded_point(ec.SECP256K1(), public_key)
+            pk.verify(signature, message, ec.ECDSA(hashes.SHA256()))
+            return True
+        except Exception:
+            return False

pico_server_auth-0.1.0.dist-info/METADATA

@@ -0,0 +1,169 @@
+Metadata-Version: 2.4
+Name: pico-server-auth
+Version: 0.1.0
+Summary: Embeddable auth server module for the pico ecosystem — JWT issuance, wallet login, JWKS endpoint
+Author-email: David Perez Cabrera <dperezcabrera@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/dperezcabrera/pico-server-auth
+Project-URL: Documentation, https://dperezcabrera.github.io/pico-server-auth/
+Project-URL: Repository, https://github.com/dperezcabrera/pico-server-auth
+Project-URL: Changelog, https://github.com/dperezcabrera/pico-server-auth/blob/main/CHANGELOG.md
+Project-URL: Issue Tracker, https://github.com/dperezcabrera/pico-server-auth/issues
+Keywords: auth,jwt,wallet,challenge-response,jwks,ml-dsa-65,ed25519,secp256k1,post-quantum,pico-ioc,pico-boot,dependency-injection
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Framework :: AsyncIO
+Classifier: Typing :: Typed
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pico-ioc[yaml]>=2.2.0
+Requires-Dist: pico-boot>=0.1.0
+Requires-Dist: pico-fastapi>=0.1.0
+Requires-Dist: python-jose[cryptography]>=3.3.0
+Requires-Dist: cryptography>=42.0.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.24.0; extra == "dev"
+Requires-Dist: pytest-cov>=5.0.0; extra == "dev"
+Requires-Dist: ruff>=0.9.0; extra == "dev"
+Requires-Dist: httpx; extra == "dev"
+Dynamic: license-file
+
+# pico-server-auth
+
+[![PyPI](https://img.shields.io/pypi/v/pico-server-auth.svg)](https://pypi.org/project/pico-server-auth/)
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/dperezcabrera/pico-server-auth)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+![CI](https://github.com/dperezcabrera/pico-server-auth/actions/workflows/ci.yml/badge.svg)
+[![codecov](https://codecov.io/gh/dperezcabrera/pico-server-auth/branch/main/graph/badge.svg)](https://codecov.io/gh/dperezcabrera/pico-server-auth)
+[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=dperezcabrera_pico-server-auth&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=dperezcabrera_pico-server-auth)
+[![Duplicated Lines (%)](https://sonarcloud.io/api/project_badges/measure?project=dperezcabrera_pico-server-auth&metric=duplicated_lines_density)](https://sonarcloud.io/summary/new_code?id=dperezcabrera_pico-server-auth)
+[![Maintainability Rating](https://sonarcloud.io/api/project_badges/measure?project=dperezcabrera_pico-server-auth&metric=sqale_rating)](https://sonarcloud.io/summary/new_code?id=dperezcabrera_pico-server-auth)
+[![PyPI Downloads](https://static.pepy.tech/personalized-badge/pico-server-auth?period=monthly&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=Monthly+downloads)](https://pepy.tech/projects/pico-server-auth)
+[![Docs](https://img.shields.io/badge/Docs-pico--server--auth-blue?style=flat&logo=readthedocs&logoColor=white)](https://dperezcabrera.github.io/pico-server-auth/)
+[![Interactive Lab](https://img.shields.io/badge/Learn-online-green?style=flat&logo=python&logoColor=white)](https://dperezcabrera.github.io/pico-learn/)
+
+Embeddable auth server module for the [pico-boot](https://github.com/dperezcabrera/pico-boot) ecosystem.
+
+Issues JWT tokens, handles wallet challenge-response login, and exposes JWKS — all compatible with [pico-client-auth](https://github.com/dperezcabrera/pico-client-auth) validation.
+
+## Two deployment modes
+
+**Embedded** — add to any pico-boot app, auth runs in the same process:
+
+```python
+container = init(modules=["myapp", "pico_server_auth"], config=config)
+# /auth/jwks, /auth/challenge, /auth/wallet, /auth/login — all available
+# pico-client-auth validates tokens from the same JWKS
+```
+
+**Standalone** — deploy as a separate auth service (like pico-auth):
+
+```python
+container = init(modules=["pico_server_auth"], config=config)
+app = container.get(FastAPI)
+# Other services point pico-client-auth JWKS to this service's /auth/jwks
+```
+
+## Endpoints
+
+```
+GET  /auth/jwks           JWKS public keys (pico-client-auth fetches this)
+POST /auth/challenge      Request nonce for wallet login
+POST /auth/wallet         Verify wallet signature, issue JWT
+POST /auth/login          Password login (admin bootstrap)
+```
+
+## Wallet login flow
+
+```
+Client                    pico-server-auth
+  │                            │
+  │ POST /auth/challenge       │
+  │ { address: "0x..." }       │
+  │───────────────────────────>│
+  │ { challenge: "<nonce>" }   │
+  │<───────────────────────────│
+  │                            │
+  │ sign(nonce) with wallet    │
+  │                            │
+  │ POST /auth/wallet          │
+  │ { address, public_key,     │
+  │   signature, challenge,    │
+  │   algorithm: "ML-DSA-65" } │
+  │───────────────────────────>│
+  │ { access_token, address }  │
+  │<───────────────────────────│
+```
+
+## Supported wallet algorithms
+
+| Algorithm | Type | Library |
+|-----------|------|---------|
+| ML-DSA-65 | Post-quantum lattice (FIPS 204) | `cryptography` |
+| Ed25519 | Edwards curve | `cryptography` |
+| secp256k1 | Elliptic curve (ECDSA) | `cryptography` |
+
+## Compatibility with pico-client-auth
+
+Tokens issued by pico-server-auth are standard JWT (RS256). pico-client-auth validates them by fetching JWKS from the `/auth/jwks` endpoint.
+
+**Same process**: pico-client-auth discovers the JWKS endpoint automatically (same FastAPI app).
+
+**Separate processes**: configure pico-client-auth to point to the server:
+
+```yaml
+auth_client:
+  issuer: "http://auth-server:8100"
+  audience: "pico"
+  # JWKS fetched from http://auth-server:8100/auth/jwks
+```
+
+## Challenge store
+
+By default, challenges are stored in memory with TTL expiry. For multi-instance deployments, register a custom `ChallengeStore` component:
+
+```python
+@component
+class RedisChallengeStore:
+    async def create(self, address: str) -> str: ...
+    async def validate(self, address: str, nonce: str) -> bool: ...
+    async def cleanup(self) -> int: ...
+```
+
+The in-memory default is replaced automatically via `on_missing_selector`.
+
+## Configuration
+
+```yaml
+server_auth:
+  issuer: "http://localhost:8100"
+  audience: "pico"
+  algorithm: "RS256"
+  access_token_expire_minutes: 15
+  challenge_ttl_seconds: 60
+  supported_wallet_algorithms:
+    - "ML-DSA-65"
+    - "Ed25519"
+    - "secp256k1"
+```
+
+## Stack
+
+- [pico-ioc](https://github.com/dperezcabrera/pico-ioc) — dependency injection
+- [pico-boot](https://github.com/dperezcabrera/pico-boot) — auto-discovery
+- [pico-fastapi](https://github.com/dperezcabrera/pico-fastapi) — controllers
+- [pico-client-auth](https://github.com/dperezcabrera/pico-client-auth) — token validation
+
+## License
+
+MIT

pico_server_auth-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+pico_server_auth/__init__.py,sha256=nxqUtnZj5BU61JTqapLnMYcqQ0mgbMyONiFWvakAarE,689
+pico_server_auth/_version.py,sha256=IMjkMO3twhQzluVTo8Z6rE7Eg-9U79_LGKMcsWLKBkY,22
+pico_server_auth/challenge_store.py,sha256=2bCFn82UrRmQDfrtxOUa0jXBxcAhTy_1rVg0oohjTh4,1771
+pico_server_auth/config.py,sha256=5Qw2hijL3bAeWkwJBMQ062GzEp6aehgBz56DGc_tLw4,834
+pico_server_auth/controllers.py,sha256=tRnDSbmfmaAxzezXMC6v4kaEpYDCLGhbKEQLYG_l4CQ,4692
+pico_server_auth/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pico_server_auth/token_issuer.py,sha256=LdcvUmvnEOorqu232Hukuz3-_KciajwwxNL62IKojuM,3540
+pico_server_auth/wallet_verifier.py,sha256=4Hgp-eynA6AS3-txaZaH9sRFGg533uh9HMIR3R-OtOw,3025
+pico_server_auth-0.1.0.dist-info/licenses/LICENSE,sha256=N1_nOvHTM6BobYnOTNXiQkroDqCEi6EzfGBv8lWtyZ0,1077
+pico_server_auth-0.1.0.dist-info/METADATA,sha256=RQffrhF89tPNKiKdUw_k029AEZMAIfI6cXW38F6NV20,7461
+pico_server_auth-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+pico_server_auth-0.1.0.dist-info/entry_points.txt,sha256=7KkDhxu1ehMGvMXuCalYAZhjQ5VBT8GyMrZQNZAshzE,56
+pico_server_auth-0.1.0.dist-info/top_level.txt,sha256=gSTx--rTRb0UA4YxYvCaraOTIHAuTN8OeSobhj7jgDE,17
+pico_server_auth-0.1.0.dist-info/RECORD,,

pico_server_auth-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pico_server_auth-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pico_boot.modules]
+pico_server_auth = pico_server_auth

pico_server_auth-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 David Pérez Cabrera
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pico_server_auth-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pico_server_auth