moss-sdk 0.1.0__py3-none-any.whl

moss/__init__.py

@@ -0,0 +1,28 @@
+from .subject import Subject, VerifyResult
+from .envelope import Envelope
+from .errors import (
+    MossError,
+    InvalidSubject,
+    KeyNotFound,
+    InvalidEnvelope,
+    InvalidSignature,
+    PayloadMismatch,
+    ReplayDetected,
+    DecryptionFailed,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "Subject",
+    "Envelope",
+    "VerifyResult",
+    "MossError",
+    "InvalidSubject",
+    "KeyNotFound",
+    "InvalidEnvelope",
+    "InvalidSignature",
+    "PayloadMismatch",
+    "ReplayDetected",
+    "DecryptionFailed",
+]

moss/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

moss/canonical.py

@@ -0,0 +1,29 @@
+import json
+import hashlib
+
+from .encoding import b64url_encode
+
+
+def cjjson(obj: dict) -> bytes:
+    """
+    RFC 8785 JSON Canonicalization Scheme.
+    - Sort keys lexicographically (Unicode code point order)
+    - No whitespace
+    - UTF-8 encoding
+    """
+    return json.dumps(
+        obj,
+        separators=(',', ':'),
+        sort_keys=True,
+        ensure_ascii=False
+    ).encode('utf-8')
+
+
+def sha256_b64url(data: bytes) -> str:
+    """SHA-256 hash, returned as base64url (43 chars)."""
+    return b64url_encode(hashlib.sha256(data).digest())
+
+
+def payload_hash(payload: dict) -> str:
+    """Compute payload_hash per moss-0001."""
+    return sha256_b64url(cjjson(payload))

moss/cli.py

@@ -0,0 +1,109 @@
+import argparse
+import json
+import sys
+from . import Subject, Envelope
+
+
+def main():
+    parser = argparse.ArgumentParser(prog="moss", description="MOSS CLI - Sign and verify agent outputs")
+    subparsers = parser.add_subparsers(dest="command")
+
+    # moss subject create <subject>
+    sub_parser = subparsers.add_parser("subject", help="Manage subjects")
+    sub_sub = sub_parser.add_subparsers(dest="subcommand")
+    create_parser = sub_sub.add_parser("create", help="Create new subject")
+    create_parser.add_argument("subject", help="Subject ID (moss:namespace:name)")
+
+    # moss sign <subject> <payload_file>
+    sign_parser = subparsers.add_parser("sign", help="Sign a payload")
+    sign_parser.add_argument("subject", help="Subject to sign as")
+    sign_parser.add_argument("payload_file", help="JSON payload file (- for stdin)")
+
+    # moss verify <payload_file> <envelope_file>
+    verify_parser = subparsers.add_parser("verify", help="Verify an envelope")
+    verify_parser.add_argument("payload_file", help="JSON payload file")
+    verify_parser.add_argument("envelope_file", help="Envelope JSON file")
+    verify_parser.add_argument("--no-replay-check", action="store_true", help="Skip replay detection")
+
+    # moss diff <env1> <env2>
+    diff_parser = subparsers.add_parser("diff", help="Compare two envelopes")
+    diff_parser.add_argument("envelope1", help="First envelope file")
+    diff_parser.add_argument("envelope2", help="Second envelope file")
+
+    args = parser.parse_args()
+
+    try:
+        if args.command == "subject" and args.subcommand == "create":
+            subject = Subject.create(args.subject)
+            print(f"Created: {args.subject}")
+            print(f"  Public key: {subject.public_key.hex()[:32]}...")
+            sys.exit(0)
+
+        elif args.command == "sign":
+            subject = Subject.load(args.subject)
+            if args.payload_file == "-":
+                payload = json.load(sys.stdin)
+            else:
+                with open(args.payload_file) as f:
+                    payload = json.load(f)
+            envelope = subject.sign(payload)
+            print(json.dumps(envelope.to_dict(), indent=2))
+            sys.exit(0)
+
+        elif args.command == "verify":
+            with open(args.payload_file) as f:
+                payload = json.load(f)
+            with open(args.envelope_file) as f:
+                envelope_data = json.load(f)
+            envelope = Envelope.from_dict(envelope_data)
+            result = Subject.verify(
+                envelope,
+                payload,
+                check_replay=not args.no_replay_check
+            )
+            if result.valid:
+                print(f"Valid signature from {result.subject}")
+                sys.exit(0)
+            else:
+                print(f"Invalid: {result.reason} [{result.error_code}]")
+                sys.exit(1)
+
+        elif args.command == "diff":
+            with open(args.envelope1) as f:
+                env1 = json.load(f)
+            with open(args.envelope2) as f:
+                env2 = json.load(f)
+
+            diffs = []
+            all_keys = set(env1.keys()) | set(env2.keys())
+            for key in sorted(all_keys):
+                v1 = env1.get(key)
+                v2 = env2.get(key)
+                if v1 != v2:
+                    diffs.append(f"  {key}: {v1} -> {v2}")
+
+            if diffs:
+                print("Differences:")
+                print("\n".join(diffs))
+            else:
+                print("Envelopes are identical")
+            sys.exit(0)
+
+        else:
+            parser.print_help()
+            sys.exit(3)
+
+    except FileNotFoundError as e:
+        print(f"File not found: {e}", file=sys.stderr)
+        sys.exit(2)
+    except json.JSONDecodeError as e:
+        print(f"Invalid JSON: {e}", file=sys.stderr)
+        sys.exit(2)
+    except Exception as e:
+        code = getattr(e, 'code', 'MOSS_ERR_000')
+        print(f"{e} [{code}]", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

moss/crypto.py

@@ -0,0 +1,29 @@
+from dilithium_py.dilithium import Dilithium2
+
+
+class MossCrypto:
+    ALG = "ML-DSA-44"
+    EXPECTED_PK_LEN = 1312
+    EXPECTED_SIG_LEN = 2420
+
+    @classmethod
+    def keygen(cls) -> tuple[bytes, bytes]:
+        """Generate (public_key, secret_key) pair."""
+        pk, sk = Dilithium2.keygen()
+        assert len(pk) == cls.EXPECTED_PK_LEN, f"Bad pk length: {len(pk)}"
+        return pk, sk
+
+    @classmethod
+    def sign(cls, secret_key: bytes, message: bytes) -> bytes:
+        """Sign message with secret key."""
+        sig = Dilithium2.sign(secret_key, message)
+        assert len(sig) == cls.EXPECTED_SIG_LEN, f"Bad sig length: {len(sig)}"
+        return sig
+
+    @classmethod
+    def verify(cls, public_key: bytes, message: bytes, signature: bytes) -> bool:
+        """Verify signature. Returns True/False, never raises."""
+        try:
+            return Dilithium2.verify(public_key, message, signature)
+        except Exception:
+            return False

moss/encoding.py

@@ -0,0 +1,14 @@
+import base64
+
+
+def b64url_encode(data: bytes) -> str:
+    """base64url encode without padding."""
+    return base64.urlsafe_b64encode(data).rstrip(b'=').decode('ascii')
+
+
+def b64url_decode(s: str) -> bytes:
+    """base64url decode, handle missing padding."""
+    padding = 4 - (len(s) % 4)
+    if padding != 4:
+        s += '=' * padding
+    return base64.urlsafe_b64decode(s)

moss/envelope.py

@@ -0,0 +1,41 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class Envelope:
+    spec: str
+    version: int
+    alg: str
+    subject: str
+    key_version: int
+    seq: int
+    issued_at: int
+    payload_hash: str
+    signature: str
+
+    def to_dict(self) -> dict:
+        return {
+            "spec": self.spec,
+            "version": self.version,
+            "alg": self.alg,
+            "subject": self.subject,
+            "key_version": self.key_version,
+            "seq": self.seq,
+            "issued_at": self.issued_at,
+            "payload_hash": self.payload_hash,
+            "signature": self.signature
+        }
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "Envelope":
+        return cls(
+            spec=d["spec"],
+            version=d["version"],
+            alg=d["alg"],
+            subject=d["subject"],
+            key_version=d["key_version"],
+            seq=d["seq"],
+            issued_at=d["issued_at"],
+            payload_hash=d["payload_hash"],
+            signature=d["signature"]
+        )

moss/errors.py

@@ -0,0 +1,38 @@
+class MossError(Exception):
+    """Base exception for MOSS errors."""
+    code = "MOSS_ERR_000"
+
+
+class InvalidSubject(MossError):
+    """Invalid subject format."""
+    code = "MOSS_ERR_001"
+
+
+class KeyNotFound(MossError):
+    """No keys found for subject."""
+    code = "MOSS_ERR_002"
+
+
+class InvalidEnvelope(MossError):
+    """Malformed envelope."""
+    code = "MOSS_ERR_003"
+
+
+class InvalidSignature(MossError):
+    """Signature verification failed."""
+    code = "MOSS_ERR_004"
+
+
+class PayloadMismatch(MossError):
+    """Payload hash does not match envelope."""
+    code = "MOSS_ERR_005"
+
+
+class ReplayDetected(MossError):
+    """Sequence number already seen (replay attack)."""
+    code = "MOSS_ERR_006"
+
+
+class DecryptionFailed(MossError):
+    """Failed to decrypt keystore (wrong passphrase?)."""
+    code = "MOSS_ERR_007"

moss/keystore.py

@@ -0,0 +1,117 @@
+import os
+import json
+import time
+from pathlib import Path
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+from cryptography.hazmat.primitives.kdf.scrypt import Scrypt
+
+from .encoding import b64url_encode, b64url_decode
+from .errors import KeyNotFound, DecryptionFailed, InvalidSubject
+
+MOSS_DIR = Path.home() / ".moss"
+KEYS_DIR = MOSS_DIR / "keys"
+
+
+def _get_passphrase() -> bytes:
+    """Get passphrase from env or use default (for dev)."""
+    pp = os.environ.get("MOSS_KEY_PASSPHRASE", "moss-dev-passphrase")
+    return pp.encode('utf-8')
+
+
+def _derive_key(salt: bytes) -> bytes:
+    """Derive 256-bit key from passphrase using Scrypt."""
+    kdf = Scrypt(salt=salt, length=32, n=2**14, r=8, p=1)
+    return kdf.derive(_get_passphrase())
+
+
+def _encrypt(data: bytes, salt: bytes) -> tuple[bytes, bytes]:
+    """Encrypt data with AES-256-GCM. Returns (nonce, ciphertext)."""
+    key = _derive_key(salt)
+    nonce = os.urandom(12)
+    aesgcm = AESGCM(key)
+    ct = aesgcm.encrypt(nonce, data, None)
+    return nonce, ct
+
+
+def _decrypt(nonce: bytes, ciphertext: bytes, salt: bytes) -> bytes:
+    """Decrypt data with AES-256-GCM."""
+    key = _derive_key(salt)
+    aesgcm = AESGCM(key)
+    try:
+        return aesgcm.decrypt(nonce, ciphertext, None)
+    except Exception as e:
+        raise DecryptionFailed(f"Failed to decrypt key: {e}")
+
+
+def get_key_path(subject: str) -> Path:
+    """Convert subject to file path: moss:ns:name -> ns/name.json"""
+    parts = subject.split(":")
+    if len(parts) != 3 or parts[0] != "moss":
+        raise InvalidSubject(f"Invalid subject format: {subject}")
+    namespace, name = parts[1], parts[2]
+    return KEYS_DIR / namespace / f"{name}.json"
+
+
+def save_keys(subject: str, public_key: bytes, secret_key: bytes, key_version: int = 1):
+    """Save encrypted key pair to local storage."""
+    path = get_key_path(subject)
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    salt = os.urandom(16)
+    nonce, encrypted_sk = _encrypt(secret_key, salt)
+
+    data = {
+        "version": 1,
+        "subject": subject,
+        "key_version": key_version,
+        "alg": "ML-DSA-44",
+        "public_key": b64url_encode(public_key),
+        "encrypted_secret_key": b64url_encode(encrypted_sk),
+        "salt": b64url_encode(salt),
+        "nonce": b64url_encode(nonce),
+        "seq": 0,
+        "created_at": int(time.time())
+    }
+
+    path.write_text(json.dumps(data, indent=2))
+    os.chmod(path, 0o600)
+
+
+def load_keys(subject: str) -> dict:
+    """Load and decrypt key data from local storage."""
+    path = get_key_path(subject)
+    if not path.exists():
+        raise KeyNotFound(f"No keys found for {subject}")
+
+    data = json.loads(path.read_text())
+
+    salt = b64url_decode(data["salt"])
+    nonce = b64url_decode(data["nonce"])
+    encrypted_sk = b64url_decode(data["encrypted_secret_key"])
+    secret_key = _decrypt(nonce, encrypted_sk, salt)
+
+    return {
+        "subject": data["subject"],
+        "key_version": data["key_version"],
+        "public_key": b64url_decode(data["public_key"]),
+        "secret_key": secret_key,
+        "seq": data["seq"]
+    }
+
+
+def increment_seq(subject: str) -> int:
+    """Atomically increment and return next sequence number."""
+    path = get_key_path(subject)
+    data = json.loads(path.read_text())
+    data["seq"] += 1
+    path.write_text(json.dumps(data, indent=2))
+    return data["seq"]
+
+
+def get_public_key(subject: str) -> bytes:
+    """Get just the public key (no decryption needed)."""
+    path = get_key_path(subject)
+    if not path.exists():
+        raise KeyNotFound(f"No keys found for {subject}")
+    data = json.loads(path.read_text())
+    return b64url_decode(data["public_key"])

moss/sequence.py

@@ -0,0 +1,30 @@
+import json
+from pathlib import Path
+
+MOSS_DIR = Path.home() / ".moss"
+SEQ_DIR = MOSS_DIR / "seq"
+
+
+def get_last_seen_seq(subject: str, key_version: int) -> int:
+    """Get last seen sequence for (subject, key_version)."""
+    path = SEQ_DIR / f"{subject.replace(':', '_')}_{key_version}.json"
+    if not path.exists():
+        return 0
+    data = json.loads(path.read_text())
+    return data.get("last_seq", 0)
+
+
+def update_last_seen_seq(subject: str, key_version: int, seq: int):
+    """Update last seen sequence."""
+    SEQ_DIR.mkdir(parents=True, exist_ok=True)
+    path = SEQ_DIR / f"{subject.replace(':', '_')}_{key_version}.json"
+    path.write_text(json.dumps({"last_seq": seq}))
+
+
+def check_and_update_seq(subject: str, key_version: int, seq: int) -> bool:
+    """Check if seq is valid (greater than last seen) and update. Returns True if valid."""
+    last = get_last_seen_seq(subject, key_version)
+    if seq <= last:
+        return False
+    update_last_seen_seq(subject, key_version, seq)
+    return True

moss/subject.py

@@ -0,0 +1,183 @@
+import re
+import time
+from dataclasses import dataclass
+from typing import Any, Optional, Union
+
+from .crypto import MossCrypto
+from .canonical import cjjson, payload_hash
+from .encoding import b64url_encode, b64url_decode
+from .keystore import save_keys, load_keys, increment_seq, get_public_key
+from .sequence import check_and_update_seq
+from .envelope import Envelope
+from .errors import InvalidSubject
+
+SPEC = "moss-0001"
+VERSION = 1
+SUBJECT_PATTERN = re.compile(r"^moss:[a-z0-9_-]+:[a-z0-9_-]+$")
+
+
+@dataclass
+class VerifyResult:
+    valid: bool
+    subject: Optional[str] = None
+    payload_hash: Optional[str] = None
+    reason: Optional[str] = None
+    error_code: Optional[str] = None
+
+
+class Subject:
+    def __init__(self, subject: str, secret_key: bytes, public_key: bytes, key_version: int):
+        self.subject = subject
+        self.secret_key = secret_key
+        self.public_key = public_key
+        self.key_version = key_version
+
+    @classmethod
+    def create(cls, subject: str) -> "Subject":
+        """Create a new subject with fresh ML-DSA-44 keypair."""
+        if not SUBJECT_PATTERN.match(subject):
+            raise InvalidSubject(
+                f"Invalid subject format: {subject}. "
+                f"Expected: moss:namespace:name (lowercase alphanumeric, hyphens, underscores)"
+            )
+
+        pk, sk = MossCrypto.keygen()
+        save_keys(subject, pk, sk, key_version=1)
+
+        return cls(subject=subject, secret_key=sk, public_key=pk, key_version=1)
+
+    @classmethod
+    def load(cls, subject: str) -> "Subject":
+        """Load existing subject from local keystore."""
+        data = load_keys(subject)
+        return cls(
+            subject=data["subject"],
+            secret_key=data["secret_key"],
+            public_key=data["public_key"],
+            key_version=data["key_version"]
+        )
+
+    def sign(self, payload: Any) -> Envelope:
+        """Sign a payload and return an envelope."""
+        seq = increment_seq(self.subject)
+        issued_at = int(time.time())
+        p_hash = payload_hash(payload)
+
+        signed_bytes_obj = {
+            "spec": SPEC,
+            "version": VERSION,
+            "alg": MossCrypto.ALG,
+            "subject": self.subject,
+            "key_version": self.key_version,
+            "seq": seq,
+            "issued_at": issued_at,
+            "payload_hash": p_hash
+        }
+        signed_bytes = cjjson(signed_bytes_obj)
+
+        signature = MossCrypto.sign(self.secret_key, signed_bytes)
+
+        return Envelope(
+            spec=SPEC,
+            version=VERSION,
+            alg=MossCrypto.ALG,
+            subject=self.subject,
+            key_version=self.key_version,
+            seq=seq,
+            issued_at=issued_at,
+            payload_hash=p_hash,
+            signature=b64url_encode(signature)
+        )
+
+    @staticmethod
+    def verify(
+        envelope: Union[Envelope, dict],
+        payload: Any = None,
+        public_key: Optional[bytes] = None,
+        check_replay: bool = True
+    ) -> VerifyResult:
+        """
+        Verify an envelope.
+
+        Args:
+            envelope: Envelope object or dict
+            payload: Original payload (optional, for hash verification)
+            public_key: Public key bytes (optional, will load from keystore if not provided)
+            check_replay: Whether to check/update sequence numbers
+
+        Returns:
+            VerifyResult with valid=True/False and details
+        """
+        if isinstance(envelope, dict):
+            try:
+                envelope = Envelope.from_dict(envelope)
+            except (KeyError, TypeError) as e:
+                return VerifyResult(
+                    valid=False,
+                    reason=f"Malformed envelope: {e}",
+                    error_code="MOSS_ERR_003"
+                )
+
+        if envelope.spec != SPEC:
+            return VerifyResult(
+                valid=False,
+                reason=f"Unknown spec: {envelope.spec}",
+                error_code="MOSS_ERR_003"
+            )
+
+        if payload is not None:
+            computed_hash = payload_hash(payload)
+            if computed_hash != envelope.payload_hash:
+                return VerifyResult(
+                    valid=False,
+                    subject=envelope.subject,
+                    reason=f"Payload hash mismatch: expected {envelope.payload_hash}, got {computed_hash}",
+                    error_code="MOSS_ERR_005"
+                )
+
+        if check_replay:
+            if not check_and_update_seq(envelope.subject, envelope.key_version, envelope.seq):
+                return VerifyResult(
+                    valid=False,
+                    subject=envelope.subject,
+                    reason=f"Replay detected: seq {envelope.seq} already seen for {envelope.subject}",
+                    error_code="MOSS_ERR_006"
+                )
+
+        if public_key is None:
+            try:
+                public_key = get_public_key(envelope.subject)
+            except Exception as e:
+                return VerifyResult(
+                    valid=False,
+                    subject=envelope.subject,
+                    reason=f"Could not load public key: {e}",
+                    error_code="MOSS_ERR_002"
+                )
+
+        signed_bytes_obj = {
+            "spec": envelope.spec,
+            "version": envelope.version,
+            "alg": envelope.alg,
+            "subject": envelope.subject,
+            "key_version": envelope.key_version,
+            "seq": envelope.seq,
+            "issued_at": envelope.issued_at,
+            "payload_hash": envelope.payload_hash
+        }
+        signed_bytes = cjjson(signed_bytes_obj)
+
+        signature = b64url_decode(envelope.signature)
+        if not MossCrypto.verify(public_key, signed_bytes, signature):
+            return VerifyResult(
+                valid=False,
+                subject=envelope.subject,
+                reason="Invalid signature",
+                error_code="MOSS_ERR_004"
+            )
+
+        return VerifyResult(
+            valid=True,
+            subject=envelope.subject,
+            payload_hash=envelope.payload_hash
+        )

moss_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,166 @@
+Metadata-Version: 2.4
+Name: moss-sdk
+Version: 0.1.0
+Summary: Cryptographic identity and signed outputs for AI agents
+Project-URL: Homepage, https://mosscomputing.com
+Project-URL: Repository, https://github.com/mosscomputing/moss
+Author: MOSS Computing
+License-Expression: MIT
+Keywords: agents,ai,cryptography,identity,post-quantum,signing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
+Requires-Dist: cryptography>=41.0.0
+Requires-Dist: dilithium-py>=0.1.0
+Provides-Extra: dev
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# MOSS
+
+**Know exactly which agent produced what.**
+
+MOSS (Machine to Machine Operation Security System) is a cryptographic signing protocol for AI agents. Every agent gets an identity. Every output gets a signature. Verifiable, tamper-proof, reproducible.
+
+[![CI](https://github.com/mosscomputing/moss/actions/workflows/ci.yml/badge.svg)](https://github.com/mosscomputing/moss/actions/workflows/ci.yml)
+[![PyPI version](https://badge.fury.io/py/moss-sdk.svg)](https://badge.fury.io/py/moss-sdk)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Installation
+
+```bash
+pip install moss-sdk
+```
+
+## Quick Start
+
+```python
+from moss import Subject
+
+# Create an agent identity
+agent = Subject.create("moss:dev:my-agent")
+
+# Sign any output
+envelope = agent.sign({"action": "approved", "amount": 500})
+
+# Verify
+result = Subject.verify(envelope)
+assert result.valid
+print(result.subject)  # moss:dev:my-agent
+```
+
+## Why MOSS?
+
+Multi-agent pipeline breaks, four agents touched it, no idea which one — you've been there. MOSS gives every agent an identity and signs every output so you can trace, diff, and verify.
+
+**Security guarantees:**
+- **Identity** — Unique subject per agent, bound to cryptographic key pair
+- **Integrity** — Payload hash detects any modification
+- **Replay protection** — Sequence numbers prevent reuse
+- **Post-quantum** — ML-DSA-44 (FIPS 204) signatures survive quantum
+
+## CLI
+
+```bash
+# Create a subject
+moss subject create moss:dev:my-agent
+
+# Sign a payload
+echo '{"action": "test"}' | moss sign moss:dev:my-agent - > envelope.json
+
+# Verify
+moss verify payload.json envelope.json
+
+# Compare envelopes
+moss diff envelope1.json envelope2.json
+```
+
+## Framework Integrations
+
+```bash
+pip install moss-sdk-crewai    # CrewAI
+pip install moss-sdk-autogen   # AutoGen
+pip install moss-sdk-langgraph # LangGraph
+pip install moss-sdk-langchain # LangChain
+```
+
+## Specification
+
+MOSS implements the `moss-0001` specification. See [SPEC.md](SPEC.md) for the full protocol specification.
+
+### Envelope Format
+
+```json
+{
+  "spec": "moss-0001",
+  "version": 1,
+  "alg": "ML-DSA-44",
+  "subject": "moss:acme:order-bot",
+  "key_version": 1,
+  "seq": 42,
+  "issued_at": 1733200000,
+  "payload_hash": "<base64url(SHA-256(canonical(payload)))>",
+  "signature": "<base64url(ML-DSA-44 signature)>"
+}
+```
+
+### Verification Procedure
+
+1. Require `spec == "moss-0001"`
+2. Compute `hash = base64url(SHA-256(canonical(payload)))`
+3. Assert `hash == envelope.payload_hash`
+4. Resolve `(subject, key_version) → public_key`
+5. Verify `ML-DSA-44.verify(public_key, canonical(signed_bytes), signature)`
+
+## Local-First
+
+MOSS works entirely offline. Keys are stored locally at `~/.moss/keys/`. No account required. No cloud. No tracking.
+
+To encrypt keys at rest, set:
+```bash
+export MOSS_KEY_PASSPHRASE="your-secure-passphrase"
+```
+
+## What MOSS Collects
+
+**In the envelope:** `subject`, `payload_hash` (not the payload itself), `seq`, `issued_at`, `signature`
+
+**Never:** Your payload content, LLM prompts/responses, user data, PII, telemetry
+
+## Technical Details
+
+| Component | Value |
+|-----------|-------|
+| Signature | ML-DSA-44 (FIPS 204, Dilithium2) |
+| Hash | SHA-256 |
+| Encoding | base64url (no padding) |
+| Canonicalization | RFC 8785 (JCS) |
+| Key encryption | AES-256-GCM + Scrypt |
+| Public key size | 1312 bytes |
+| Signature size | 2420 bytes |
+| Overhead | <1ms sign, <1ms verify, ~2KB envelope |
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+## Security
+
+See [SECURITY.md](SECURITY.md) for reporting vulnerabilities.
+
+## License
+
+MIT — see [LICENSE](LICENSE)
+
+## Links
+
+- **Website:** [mosscomputing.com](https://mosscomputing.com)
+- **Spec:** [SPEC.md](SPEC.md)
+- **Discord:** [Join](https://discord.gg/2QewJsBc)

moss_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+moss/__init__.py,sha256=pGa_nS4JAM8w6KCU9qJXZn8m4d5rtJVYDfI7-0OGPeg,519
+moss/__main__.py,sha256=MSmt_5Xg84uHqzTN38JwgseJK8rsJn_11A8WD99VtEo,61
+moss/canonical.py,sha256=A8O_Chu1n49u4u_TfabmJqp3Fl4Parqi0s4N5EK2Fhw,684
+moss/cli.py,sha256=08aHw_LzhrMQt6fQIw8VImRrVt1G-sJXTY26HajMHho,4012
+moss/crypto.py,sha256=d4lhq0KfYwd4P7GQQsw-_LyToSK2Hdpq-sFNxAxRY-4,966
+moss/encoding.py,sha256=zn5ndDydH_-S5cbxz5RFKTZeKb-bW7e_PBtcmnByNLk,378
+moss/envelope.py,sha256=ucjDa2RViOv1OiRFk5_0Dvl776w2n6w0kckc9qPPpAY,1017
+moss/errors.py,sha256=KNO6haC1Sw6R453RTzafZgZbrwrhM7ZjhLIo2HPu3Fw,830
+moss/keystore.py,sha256=z6_0EtVuOY4u7UAbT-cAQSGWIqilclcji7vS1vD37sQ,3702
+moss/sequence.py,sha256=sb5u1Ead_5A_KI99NdFR-xvKQKtEPgagi563jBqeH_s,1018
+moss/subject.py,sha256=ojCXV--UlZHEa_ZJtHIJKpVPPArUb03FAqC7QOkOAS0,6120
+moss_sdk-0.1.0.dist-info/METADATA,sha256=zokkRsXiTCS-PyA2h4sP4zgFOkftTRkb_Dy-nwMetpM,4813
+moss_sdk-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+moss_sdk-0.1.0.dist-info/entry_points.txt,sha256=kc1MH_7F5_YF0TB7rUTdb33A9KachU9DZGmlNBBMA9Y,39
+moss_sdk-0.1.0.dist-info/RECORD,,

moss_sdk-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

moss_sdk-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+moss = moss.cli:main