quantumsafe 1.0.0__tar.gz

quantumsafe-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 QuantumSafe
+
+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.

quantumsafe-1.0.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include LICENSE
+include README.md
+recursive-exclude tests *

quantumsafe-1.0.0/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: quantumsafe
+Version: 1.0.0
+Summary: QuantumSafe — Post-quantum cryptography SDK for blockchain
+License: MIT
+Project-URL: Homepage, https://qsafe.dev
+Project-URL: Documentation, https://docs.qsafe.dev
+Project-URL: Repository, https://github.com/quantumsafe/sdk
+Keywords: quantum,pqc,blockchain,ml-dsa,post-quantum,cryptography,ethereum,solana,bitcoin
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Security :: Cryptography
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pqcrypto>=0.1.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23.0; extra == "dev"
+Requires-Dist: ruff>=0.4.0; extra == "dev"
+Requires-Dist: respx>=0.21.0; extra == "dev"
+Dynamic: license-file
+
+# quantumsafe
+
+Post-quantum cryptography SDK for blockchain. Scan wallets for quantum risk, generate PQC keys, and verify hybrid signatures.
+
+## Install
+
+```bash
+pip install quantumsafe
+```
+
+## Quick Start
+
+```python
+import asyncio
+from quantumsafe import QuantumSafe
+
+async def main():
+    qs = QuantumSafe(api_key="your-api-key")
+
+    # 1. Scan a wallet for quantum risk
+    scan = await qs.scan_wallet(chain="ethereum", address="0xYourAddress")
+    print(f"Risk score: {scan.risk_score}")
+
+    # 2. Generate a post-quantum key pair
+    keys = await qs.generate_key(algorithm="ml-dsa-65", chain="ethereum")
+    print(f"Public key: {keys.public_key}")
+
+    # 3. Register key on-chain & verify
+    registered = await qs.register_key(chain="ethereum", public_key=keys.public_key)
+
+    result = await qs.verify(
+        chain="ethereum",
+        address="0xYourAddress",
+        attestation_id=registered.attestation_id,
+    )
+    print(f"Verified: {result.verified}")
+
+asyncio.run(main())
+```
+
+## Supported Chains
+
+- Ethereum
+- Solana
+- Bitcoin
+- Polygon
+- Avalanche
+- Cosmos
+
+## Documentation
+
+Full API docs: [https://docs.qsafe.dev](https://docs.qsafe.dev)
+
+## License
+
+MIT — see [LICENSE](./LICENSE)

quantumsafe-1.0.0/README.md

@@ -0,0 +1,56 @@
+# quantumsafe
+
+Post-quantum cryptography SDK for blockchain. Scan wallets for quantum risk, generate PQC keys, and verify hybrid signatures.
+
+## Install
+
+```bash
+pip install quantumsafe
+```
+
+## Quick Start
+
+```python
+import asyncio
+from quantumsafe import QuantumSafe
+
+async def main():
+    qs = QuantumSafe(api_key="your-api-key")
+
+    # 1. Scan a wallet for quantum risk
+    scan = await qs.scan_wallet(chain="ethereum", address="0xYourAddress")
+    print(f"Risk score: {scan.risk_score}")
+
+    # 2. Generate a post-quantum key pair
+    keys = await qs.generate_key(algorithm="ml-dsa-65", chain="ethereum")
+    print(f"Public key: {keys.public_key}")
+
+    # 3. Register key on-chain & verify
+    registered = await qs.register_key(chain="ethereum", public_key=keys.public_key)
+
+    result = await qs.verify(
+        chain="ethereum",
+        address="0xYourAddress",
+        attestation_id=registered.attestation_id,
+    )
+    print(f"Verified: {result.verified}")
+
+asyncio.run(main())
+```
+
+## Supported Chains
+
+- Ethereum
+- Solana
+- Bitcoin
+- Polygon
+- Avalanche
+- Cosmos
+
+## Documentation
+
+Full API docs: [https://docs.qsafe.dev](https://docs.qsafe.dev)
+
+## License
+
+MIT — see [LICENSE](./LICENSE)

quantumsafe-1.0.0/pyproject.toml

@@ -0,0 +1,55 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "quantumsafe"
+version = "1.0.0"
+description = "QuantumSafe — Post-quantum cryptography SDK for blockchain"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+keywords = ["quantum", "pqc", "blockchain", "ml-dsa", "post-quantum", "cryptography", "ethereum", "solana", "bitcoin"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Security :: Cryptography",
+]
+dependencies = [
+    "httpx>=0.27.0",
+    "pqcrypto>=0.1.0",
+]
+
+[project.urls]
+Homepage = "https://qsafe.dev"
+Documentation = "https://docs.qsafe.dev"
+Repository = "https://github.com/quantumsafe/sdk"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.23.0",
+    "ruff>=0.4.0",
+    "respx>=0.21.0",
+]
+
+[tool.setuptools.packages.find]
+include = ["quantumsafe*"]
+
+[tool.ruff]
+target-version = "py310"
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I"]
+# SECURITY: 'import random' 금지 — CI에서 grep으로 별도 체크
+# ruff에서 커스텀 import 금지 rule이 없으므로 grep/CI로 보완
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]

quantumsafe-1.0.0/quantumsafe/__init__.py

@@ -0,0 +1,26 @@
+# SECURITY: Only use secrets/os.urandom for randomness. Never import random.
+"""QuantumSafe Python SDK — PQC 키 관리, 하이브리드 서명, 지갑 스캔"""
+
+from quantumsafe.client import QuantumSafe
+from quantumsafe.types import (
+    Algorithm,
+    Attestation,
+    Chain,
+    KeyPair,
+    RegisteredKey,
+    ScanResult,
+    VerifyResult,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "QuantumSafe",
+    "Algorithm",
+    "Chain",
+    "KeyPair",
+    "RegisteredKey",
+    "Attestation",
+    "VerifyResult",
+    "ScanResult",
+]

quantumsafe-1.0.0/quantumsafe/client.py

@@ -0,0 +1,114 @@
+# SECURITY: Only use secrets/os.urandom for randomness. Never import random.
+"""QuantumSafe SDK 메인 클라이언트"""
+
+import json
+import logging
+from typing import Any, Optional
+
+import httpx
+
+from quantumsafe.modules.keys import KeysModule
+from quantumsafe.modules.scan import ScanModule
+from quantumsafe.modules.sign import SignModule
+from quantumsafe.modules.verify import VerifyModule
+from quantumsafe.types import VerifyResult
+
+logger = logging.getLogger("quantumsafe")
+
+
+class QuantumSafe:
+    """QuantumSafe Python SDK 메인 클라이언트
+
+    Args:
+        api_key: API 키 (X-API-Key 헤더로 전송)
+        base_url: 백엔드 API 기본 URL
+        timeout: 요청 타임아웃 (초)
+
+    Example::
+
+        qs = QuantumSafe(api_key="qs_sec_live_...", base_url="https://api.qsafe.dev")
+        key_pair = qs.keys.generate(algorithm="ml-dsa-65")
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = "https://api.qsafe.dev",
+        timeout: float = 30.0,
+    ) -> None:
+        if not api_key:
+            raise ValueError("QuantumSafe: api_key는 필수입니다.")
+
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+
+        # HTTP 클라이언트 (연결 재사용)
+        self._http = httpx.Client(
+            base_url=self.base_url,
+            headers={
+                "Content-Type": "application/json",
+                "X-API-Key": self.api_key,
+            },
+            timeout=self.timeout,
+        )
+
+        # 모듈 초기화
+        self.keys = KeysModule(self)
+        self.sign = SignModule(self)
+        self._verify_module = VerifyModule(self)
+        self.scan = ScanModule(self)
+
+    def verify(
+        self,
+        public_key: str,
+        message: str,
+        signature: str,
+        algorithm: str = "ml-dsa-65",
+    ) -> VerifyResult:
+        """PQC 서명 검증 (최상위 메서드)"""
+        return self._verify_module.verify(
+            public_key=public_key,
+            message=message,
+            signature=signature,
+            algorithm=algorithm,
+        )
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        body: Optional[dict[str, Any]] = None,
+    ) -> dict[str, Any]:
+        """내부 HTTP 요청 헬퍼
+
+        CRITICAL: body에 private_key가 포함되면 즉시 에러
+        """
+        # ★ 프라이빗 키 유출 방지 런타임 체크
+        if body is not None:
+            body_str = json.dumps(body)
+            if '"private_key"' in body_str or '"privateKey"' in body_str:
+                raise SecurityError(
+                    "SECURITY: private_key가 네트워크 요청 body에 포함되었습니다. "
+                    "프라이빗 키는 절대 서버로 전송되면 안 됩니다."
+                )
+
+        url = path
+        response = self._http.request(method, url, json=body)
+        response.raise_for_status()
+        result: dict[str, Any] = response.json()
+        return result
+
+    def close(self) -> None:
+        """HTTP 클라이언트 종료"""
+        self._http.close()
+
+    def __enter__(self) -> "QuantumSafe":
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        self.close()
+
+
+class SecurityError(Exception):
+    """프라이빗 키 유출 방지 보안 에러"""

quantumsafe-1.0.0/quantumsafe/modules/__init__.py

@@ -0,0 +1 @@
+# SECURITY: Only use secrets/os.urandom for randomness. Never import random.

quantumsafe-1.0.0/quantumsafe/modules/keys.py

@@ -0,0 +1,153 @@
+# SECURITY: Only use secrets/os.urandom for randomness. Never import random.
+"""키 생성/등록 모듈 — 실 PQC 키 생성 (pqcrypto 사용)"""
+
+from __future__ import annotations
+
+import importlib
+import logging
+import warnings
+from typing import TYPE_CHECKING, Any
+
+from quantumsafe.types import AlgorithmInfo, KeyPair, RegisteredKey
+
+if TYPE_CHECKING:
+    from quantumsafe.client import QuantumSafe
+
+logger = logging.getLogger("quantumsafe.keys")
+
+# 알고리즘 메타정보 (NIST 표준명 → pqcrypto 모듈 매핑)
+ALGORITHM_INFO: dict[str, AlgorithmInfo] = {
+    "ml-dsa-44": AlgorithmInfo(
+        nist_level=2,
+        public_key_size=1312,
+        secret_key_size=2560,
+        signature_size=2420,
+        pqcrypto_module="pqcrypto.sign.ml_dsa_44",
+    ),
+    "ml-dsa-65": AlgorithmInfo(
+        nist_level=3,
+        public_key_size=1952,
+        secret_key_size=4032,
+        signature_size=3309,
+        pqcrypto_module="pqcrypto.sign.ml_dsa_65",
+    ),
+    "ml-dsa-87": AlgorithmInfo(
+        nist_level=5,
+        public_key_size=2592,
+        secret_key_size=4896,
+        signature_size=4627,
+        pqcrypto_module="pqcrypto.sign.ml_dsa_87",
+    ),
+    "slh-dsa-128s": AlgorithmInfo(
+        nist_level=1,
+        public_key_size=32,
+        secret_key_size=64,
+        signature_size=7856,
+        pqcrypto_module="pqcrypto.sign.sphincs_sha2_128s_simple",
+    ),
+}
+
+# pqcrypto 모듈 캐시
+_modules: dict[str, Any] = {}
+
+
+def _get_pqc_module(algorithm: str) -> Any:
+    """알고리즘에 해당하는 pqcrypto 모듈 로드 (캐시)"""
+    if algorithm not in _modules:
+        info = ALGORITHM_INFO.get(algorithm)
+        if not info:
+            raise ValueError(f"지원하지 않는 알고리즘: {algorithm}")
+        _modules[algorithm] = importlib.import_module(info.pqcrypto_module)
+    return _modules[algorithm]
+
+
+class KeysModule:
+    """키 생성/등록 모듈
+
+    - generate(): 로컬에서 실 PQC 키 쌍 생성 (pqcrypto 사용, 네트워크 미사용)
+    - register(): 공개키를 서버에 등록 (프라이빗 키 전송 안 함)
+    """
+
+    def __init__(self, client: QuantumSafe) -> None:
+        self._client = client
+
+    def generate(self, algorithm: str = "ml-dsa-65") -> KeyPair:
+        """로컬 PQC 키 쌍 생성 (pqcrypto 사용)
+
+        프라이빗 키는 절대 서버로 전송되지 않습니다.
+
+        Args:
+            algorithm: PQC 알고리즘 (기본: ml-dsa-65)
+
+        Returns:
+            KeyPair: 공개키/프라이빗키 (hex 인코딩)
+        """
+        info = ALGORITHM_INFO.get(algorithm)
+        if not info:
+            raise ValueError(f"지원하지 않는 알고리즘: {algorithm}")
+
+        # SLH-DSA KMS 비호환 경고
+        if algorithm == "slh-dsa-128s":
+            warnings.warn(
+                "QuantumSafe: SLH-DSA does not support Managed (KMS) mode upgrade. "
+                "Consider ML-DSA-65 for future KMS compatibility.",
+                UserWarning,
+                stacklevel=2,
+            )
+
+        # pqcrypto로 실 PQC 키 생성
+        mod = _get_pqc_module(algorithm)
+        pk, sk = mod.generate_keypair()
+
+        return KeyPair(
+            public_key=pk.hex(),
+            private_key=sk.hex(),
+            algorithm=algorithm,
+            nist_level=info.nist_level,
+        )
+
+    def register(
+        self,
+        public_key: str,
+        algorithm: str = "ml-dsa-65",
+        chain: str = "ethereum",
+    ) -> RegisteredKey:
+        """공개키를 서버에 등록 (BYOK)
+
+        프라이빗 키는 전송하지 않습니다.
+
+        Args:
+            public_key: hex 인코딩된 공개키
+            algorithm: PQC 알고리즘 (기본: ml-dsa-65)
+            chain: 블록체인 (기본: ethereum)
+
+        Returns:
+            RegisteredKey: 등록된 키 정보
+        """
+        # SLH-DSA KMS 비호환 경고
+        if algorithm == "slh-dsa-128s":
+            warnings.warn(
+                "QuantumSafe: SLH-DSA does not support Managed (KMS) mode upgrade. "
+                "Consider ML-DSA-65 for future KMS compatibility.",
+                UserWarning,
+                stacklevel=2,
+            )
+
+        res = self._client._request(
+            "POST",
+            "/v1/keys/generate",
+            body={
+                "algorithm": algorithm,
+                "chain": chain,
+                "format": "hex",
+                "public_key": public_key,
+            },
+        )
+
+        return RegisteredKey(
+            key_id=res["key_id"],
+            algorithm=res["algorithm"],
+            nist_level=res["nist_level"],
+            chain=res["chain"],
+            custody=res["custody"],
+        )

quantumsafe-1.0.0/quantumsafe/modules/scan.py

@@ -0,0 +1,76 @@
+# SECURITY: Only use secrets/os.urandom for randomness. Never import random.
+"""지갑 양자 위협 스캔 모듈"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from quantumsafe.types import ChainFactor, RiskFactor, ScanResult
+
+if TYPE_CHECKING:
+    from quantumsafe.client import QuantumSafe
+
+logger = logging.getLogger("quantumsafe.scan")
+
+
+class ScanModule:
+    """지갑 양자 위협 스캔 모듈"""
+
+    def __init__(self, client: QuantumSafe) -> None:
+        self._client = client
+
+    def wallet(
+        self,
+        address: str,
+        chain: str = "ethereum",
+    ) -> ScanResult:
+        """지갑 양자 위협 스캔
+
+        Args:
+            address: 이더리움 주소 (0x...)
+            chain: 블록체인 (기본: ethereum)
+
+        Returns:
+            ScanResult: 스캔 결과
+        """
+        res = self._client._request(
+            "POST",
+            "/v1/scan/wallet",
+            body={
+                "address": address,
+                "chain": chain,
+            },
+        )
+
+        risk_factors = [
+            RiskFactor(
+                category=f["category"],
+                name=f["name"],
+                score=f["score"],
+                max_score=f["max_score"],
+                detail=f["detail"],
+            )
+            for f in res.get("risk_factors", [])
+        ]
+
+        chain_factors = [
+            ChainFactor(
+                factor=f["factor"],
+                impact=f["impact"],
+            )
+            for f in res.get("chain_factors", [])
+        ]
+
+        return ScanResult(
+            address=res["address"],
+            chain=res["chain"],
+            address_risk_score=res["address_risk_score"],
+            address_risk_grade=res["address_risk_grade"],
+            chain_readiness_grade=res["chain_readiness_grade"],
+            methodology_version=res.get("methodology_version", "v1.0"),
+            risk_factors=risk_factors,
+            chain_factors=chain_factors,
+            scan_timestamp=res.get("scan_timestamp", ""),
+            asset_value_usd=res.get("asset_value_usd"),
+        )

quantumsafe-1.0.0/quantumsafe/modules/sign.py

@@ -0,0 +1,100 @@
+# SECURITY: Only use secrets/os.urandom for randomness. Never import random.
+"""하이브리드 서명 모듈 — 로컬 PQC 서명 + 서버 Attestation"""
+
+from __future__ import annotations
+
+import hashlib
+import logging
+from typing import TYPE_CHECKING, Optional
+
+from quantumsafe.modules.keys import _get_pqc_module
+from quantumsafe.types import Attestation
+
+if TYPE_CHECKING:
+    from quantumsafe.client import QuantumSafe
+
+logger = logging.getLogger("quantumsafe.sign")
+
+
+class SignModule:
+    """하이브리드 서명 모듈
+
+    로컬에서 PQC 서명 생성 후, 공개키 + 서명 + 메시지만 서버로 전송.
+    프라이빗 키는 절대 네트워크로 전송하지 않습니다.
+    """
+
+    def __init__(self, client: QuantumSafe) -> None:
+        self._client = client
+
+    def hybrid(
+        self,
+        message: str,
+        private_key: str,
+        ecdsa_signature: Optional[str] = None,
+        chain: str = "ethereum",
+        algorithm: str = "ml-dsa-65",
+        public_key: Optional[str] = None,
+        linked_tx_hash: Optional[str] = None,
+        tx_status: Optional[str] = None,
+    ) -> Attestation:
+        """하이브리드 서명 + 서버 Attestation
+
+        1. 로컬에서 PQC 서명 생성 (pqcrypto 사용)
+        2. combined_hash 생성
+        3. 서버에 공개키 + 서명 + 메시지 전송 (프라이빗 키 제외!)
+
+        Args:
+            message: hex 인코딩된 메시지
+            private_key: hex 인코딩된 PQC 프라이빗 키 (로컬 전용, 서버 미전송)
+            ecdsa_signature: hex 인코딩된 ECDSA 서명 (선택)
+            chain: 블록체인 (기본: ethereum)
+            algorithm: PQC 알고리즘 (기본: ml-dsa-65)
+            public_key: hex 인코딩된 공개키 (지정하지 않으면 프라이빗 키에서 추출 불가 → 필수)
+            linked_tx_hash: 연결된 온체인 TX 해시 (선택)
+            tx_status: TX 상태 (선택)
+
+        Returns:
+            Attestation: 서버 Attestation 결과
+        """
+        sk_bytes = bytes.fromhex(private_key)
+        msg_bytes = bytes.fromhex(message)
+
+        # pqcrypto로 실 PQC 서명 생성
+        mod = _get_pqc_module(algorithm)
+        pqc_sig = mod.sign(sk_bytes, msg_bytes)
+        pqc_sig_hex = pqc_sig.hex()
+
+        # combined_hash 생성
+        hash_input = pqc_sig_hex + (ecdsa_signature or "")
+        combined_hash = hashlib.sha256(hash_input.encode()).hexdigest()
+
+        if not public_key:
+            raise ValueError(
+                "public_key는 필수입니다. keys.generate()에서 받은 공개키를 전달하세요."
+            )
+
+        # ★ 서버 요청: 프라이빗 키 제외, 공개키 + 서명 + 메시지만 전송
+        body: dict = {
+            "public_key": public_key,
+            "message": message,
+            "pqc_signature": pqc_sig_hex,
+            "combined_hash": combined_hash,
+            "chain": chain,
+            "algorithm": algorithm,
+        }
+
+        if ecdsa_signature:
+            body["ecdsa_signature"] = ecdsa_signature
+        if linked_tx_hash:
+            body["linked_tx_hash"] = linked_tx_hash
+        if tx_status:
+            body["tx_status"] = tx_status
+
+        res = self._client._request("POST", "/v1/sign/hybrid", body=body)
+
+        return Attestation(
+            attestation_id=res["attestation_id"],
+            combined_hash=res["combined_hash"],
+            verified_at=res["verified_at"],
+            chain=res["chain"],
+        )

quantumsafe-1.0.0/quantumsafe/modules/verify.py

@@ -0,0 +1,61 @@
+# SECURITY: Only use secrets/os.urandom for randomness. Never import random.
+"""서명 검증 모듈"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from quantumsafe.types import VerifyResult
+
+if TYPE_CHECKING:
+    from quantumsafe.client import QuantumSafe
+
+logger = logging.getLogger("quantumsafe.verify")
+
+
+class VerifyModule:
+    """서명 검증 모듈
+
+    서버에서 PQC 서명을 검증합니다.
+    프라이빗 키는 요청에 포함되지 않습니다.
+    """
+
+    def __init__(self, client: QuantumSafe) -> None:
+        self._client = client
+
+    def verify(
+        self,
+        public_key: str,
+        message: str,
+        signature: str,
+        algorithm: str = "ml-dsa-65",
+    ) -> VerifyResult:
+        """PQC 서명 검증
+
+        Args:
+            public_key: hex 인코딩된 공개키
+            message: hex 인코딩된 메시지
+            signature: hex 인코딩된 서명
+            algorithm: PQC 알고리즘 (기본: ml-dsa-65)
+
+        Returns:
+            VerifyResult: 검증 결과
+        """
+        res = self._client._request(
+            "POST",
+            "/v1/verify",
+            body={
+                "public_key": public_key,
+                "message": message,
+                "signature": signature,
+                "algorithm": algorithm,
+            },
+        )
+
+        return VerifyResult(
+            valid=res["valid"],
+            algorithm=res["algorithm"],
+            nist_level=res["nist_level"],
+            verified_at=res["verified_at"],
+        )

quantumsafe-1.0.0/quantumsafe/types.py

@@ -0,0 +1,98 @@
+# SECURITY: Only use secrets/os.urandom for randomness. Never import random.
+"""QuantumSafe SDK 데이터 타입 정의"""
+
+from dataclasses import dataclass, field
+from typing import Literal, Optional
+
+# 지원 알고리즘 (NIST 표준명만)
+Algorithm = Literal["ml-dsa-44", "ml-dsa-65", "ml-dsa-87", "slh-dsa-128s"]
+
+# 지원 체인
+Chain = Literal["ethereum", "base", "arbitrum"]
+
+
+@dataclass(frozen=True)
+class AlgorithmInfo:
+    """알고리즘 메타정보"""
+
+    nist_level: int
+    public_key_size: int
+    secret_key_size: int
+    signature_size: int
+    pqcrypto_module: str
+
+
+@dataclass(frozen=True)
+class KeyPair:
+    """로컬 생성된 PQC 키 쌍"""
+
+    public_key: str
+    private_key: str
+    algorithm: str
+    nist_level: int
+
+
+@dataclass(frozen=True)
+class RegisteredKey:
+    """서버 등록된 공개키"""
+
+    key_id: str
+    algorithm: str
+    nist_level: int
+    chain: str
+    custody: str
+
+
+@dataclass(frozen=True)
+class Attestation:
+    """하이브리드 서명 Attestation 결과"""
+
+    attestation_id: str
+    combined_hash: str
+    verified_at: str
+    chain: str
+
+
+@dataclass(frozen=True)
+class VerifyResult:
+    """서명 검증 결과"""
+
+    valid: bool
+    algorithm: str
+    nist_level: int
+    verified_at: str
+
+
+@dataclass(frozen=True)
+class RiskFactor:
+    """위험 요인"""
+
+    category: str
+    name: str
+    score: int
+    max_score: int
+    detail: str
+
+
+@dataclass(frozen=True)
+class ChainFactor:
+    """체인 PQC 준비도 요인"""
+
+    factor: str
+    impact: str
+
+
+@dataclass(frozen=True)
+class ScanResult:
+    """지갑 양자 위협 스캔 결과"""
+
+    address: str
+    chain: str
+    address_risk_score: int
+    address_risk_grade: str
+    chain_readiness_grade: str
+    methodology_version: str
+    risk_factors: list[RiskFactor] = field(default_factory=list)
+    chain_factors: list[ChainFactor] = field(default_factory=list)
+    scan_timestamp: str = ""
+    asset_value_usd: Optional[float] = None

quantumsafe-1.0.0/quantumsafe.egg-info/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: quantumsafe
+Version: 1.0.0
+Summary: QuantumSafe — Post-quantum cryptography SDK for blockchain
+License: MIT
+Project-URL: Homepage, https://qsafe.dev
+Project-URL: Documentation, https://docs.qsafe.dev
+Project-URL: Repository, https://github.com/quantumsafe/sdk
+Keywords: quantum,pqc,blockchain,ml-dsa,post-quantum,cryptography,ethereum,solana,bitcoin
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Security :: Cryptography
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pqcrypto>=0.1.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23.0; extra == "dev"
+Requires-Dist: ruff>=0.4.0; extra == "dev"
+Requires-Dist: respx>=0.21.0; extra == "dev"
+Dynamic: license-file
+
+# quantumsafe
+
+Post-quantum cryptography SDK for blockchain. Scan wallets for quantum risk, generate PQC keys, and verify hybrid signatures.
+
+## Install
+
+```bash
+pip install quantumsafe
+```
+
+## Quick Start
+
+```python
+import asyncio
+from quantumsafe import QuantumSafe
+
+async def main():
+    qs = QuantumSafe(api_key="your-api-key")
+
+    # 1. Scan a wallet for quantum risk
+    scan = await qs.scan_wallet(chain="ethereum", address="0xYourAddress")
+    print(f"Risk score: {scan.risk_score}")
+
+    # 2. Generate a post-quantum key pair
+    keys = await qs.generate_key(algorithm="ml-dsa-65", chain="ethereum")
+    print(f"Public key: {keys.public_key}")
+
+    # 3. Register key on-chain & verify
+    registered = await qs.register_key(chain="ethereum", public_key=keys.public_key)
+
+    result = await qs.verify(
+        chain="ethereum",
+        address="0xYourAddress",
+        attestation_id=registered.attestation_id,
+    )
+    print(f"Verified: {result.verified}")
+
+asyncio.run(main())
+```
+
+## Supported Chains
+
+- Ethereum
+- Solana
+- Bitcoin
+- Polygon
+- Avalanche
+- Cosmos
+
+## Documentation
+
+Full API docs: [https://docs.qsafe.dev](https://docs.qsafe.dev)
+
+## License
+
+MIT — see [LICENSE](./LICENSE)

quantumsafe-1.0.0/quantumsafe.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+quantumsafe/__init__.py
+quantumsafe/client.py
+quantumsafe/types.py
+quantumsafe.egg-info/PKG-INFO
+quantumsafe.egg-info/SOURCES.txt
+quantumsafe.egg-info/dependency_links.txt
+quantumsafe.egg-info/requires.txt
+quantumsafe.egg-info/top_level.txt
+quantumsafe/modules/__init__.py
+quantumsafe/modules/keys.py
+quantumsafe/modules/scan.py
+quantumsafe/modules/sign.py
+quantumsafe/modules/verify.py

quantumsafe-1.0.0/quantumsafe.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

quantumsafe-1.0.0/quantumsafe.egg-info/requires.txt

@@ -0,0 +1,8 @@
+httpx>=0.27.0
+pqcrypto>=0.1.0
+
+[dev]
+pytest>=8.0
+pytest-asyncio>=0.23.0
+ruff>=0.4.0
+respx>=0.21.0

quantumsafe-1.0.0/quantumsafe.egg-info/top_level.txt

@@ -0,0 +1 @@
+quantumsafe

quantumsafe-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+