saro-dat 1.0.0__py3-none-any.whl

saro_dat/__init__.py

@@ -0,0 +1,17 @@
+from .crypto import DatCryptoAlgorithm, DatCryptoKey
+from .dat import Dat, DatPayload
+from .dat_certificate import DatCertificate
+from .dat_manager import DatManager
+from .signature import DatSignatureAlgorithm, DatSignatureKey, DatSignatureKeyOutOption
+
+__all__ = [
+    "DatManager",
+    "DatCertificate",
+    "Dat",
+    "DatPayload",
+    "DatCryptoKey",
+    "DatCryptoAlgorithm",
+    "DatSignatureKey",
+    "DatSignatureAlgorithm",
+    "DatSignatureKeyOutOption",
+]

saro_dat/crypto.py

@@ -0,0 +1,79 @@
+import os
+from enum import Enum
+from typing import Union, Dict, Optional
+
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+
+from .util import decode_base64_url
+
+
+class DatCryptoAlgorithm(str, Enum):
+    AES128GCMN = "AES128GCMN"
+    AES256GCMN = "AES256GCMN"
+
+CRYPTO_CONFIG: Dict[str, dict] = {
+    "AES128GCMN": {"name": "AES-GCM", "length": 16},
+    "AES256GCMN": {"name": "AES-GCM", "length": 32},
+}
+
+def get_crypto_config(algorithm: str) -> dict:
+    config = CRYPTO_CONFIG.get(algorithm)
+    if config:
+        return config
+    raise ValueError(f"Unsupported DAT Crypto Algorithm: {algorithm}")
+
+class DatCryptoKey:
+    def __init__(self, algorithm: DatCryptoAlgorithm, key_bytes: bytes, config: Optional[Dict[str, dict]] = None):
+        if config is None:
+            config = get_crypto_config(algorithm)
+        self.algorithm = algorithm
+        self._config = config
+        self._key_bytes = key_bytes
+        self._cipher = AESGCM(key_bytes)
+
+    @classmethod
+    def generate(cls, algorithm: DatCryptoAlgorithm) -> DatCryptoKey:
+        config = get_crypto_config(algorithm)
+        key_bytes = AESGCM.generate_key(bit_length=config['length'] * 8)
+        return cls(algorithm, key_bytes, config)
+
+    @classmethod
+    def imports(cls, algorithm: str, raw: bytes) -> DatCryptoKey:
+        return cls(DatCryptoAlgorithm(algorithm), raw)
+
+    def exports(self) -> bytes:
+        return self._key_bytes
+
+    def encrypt(self, data: Union[bytes, str, None]) -> bytes:
+        if isinstance(data, str):
+            data = data.encode('utf-8')
+
+        if not data:
+            return b""
+
+        #if self._config["name"] == "AES-GCM":
+
+        nonce = os.urandom(12)
+        ciphertext = self._cipher.encrypt(nonce, data, None)
+        return nonce + ciphertext
+
+        #raise ValueError(f"Unsupported DAT Crypto Algorithm: {self.algorithm}")
+
+    def decrypt(self, data: Union[bytes, str, None]) -> bytes:
+        if isinstance(data, str):
+            data = decode_base64_url(data)
+
+        if not data:
+            return b""
+
+        #if self._config["name"] == "AES-GCM":
+
+        if len(data) <= 12:
+            raise ValueError("Invalid data length")
+
+        nonce = data[:12]
+        ciphertext_with_tag = data[12:]
+
+        return self._cipher.decrypt(nonce, ciphertext_with_tag, None)
+
+        #raise ValueError(f"Unsupported DAT Crypto Algorithm: {self.algorithm}")

saro_dat/dat.py

@@ -0,0 +1,60 @@
+import time
+from typing import Optional, Union
+
+from .util import decode_base64_url
+
+
+class Dat:
+    def __init__(self, dat_str: Optional[str]):
+        self.dat = dat_str or ''
+        self._format = False
+        self._expire = 0
+        self._cid = 0
+        self._plain = b''
+        self._secure = b''
+        self._signature = b''
+
+        if self.dat:
+            parts = self.dat.split('.')
+            if len(parts) == 5:
+                try:
+                    # parts: [expire, cid(hex), plain(b64), secure(b64), signature(b64)]
+                    self._expire = int(parts[0])
+                    self._cid = int(parts[1], 16)
+                    self._plain = decode_base64_url(parts[2])
+                    self._secure = decode_base64_url(parts[3])
+                    self._signature = decode_base64_url(parts[4])
+                    self._format = (len(self._signature) > 0 and self._expire >= 0)
+                except (ValueError, RuntimeError):
+                    self._format = False
+
+    @classmethod
+    def from_value(cls, value: Union[Dat, str, None]) -> Dat:
+        if isinstance(value, Dat):
+            return value
+        return cls(value)
+
+    def expired(self) -> bool:
+        if not self._format:
+            return True
+        return int(time.time()) > self._expire
+
+    def body_string(self) -> str:
+        """서명 검증을 위한 서명 제외 나머지 본문 반환"""
+        if '.' not in self.dat:
+            return ""
+        return self.dat.rsplit('.', 1)[0]
+
+class DatPayload:
+    def __init__(self, expire: int, plain: bytes, secure: bytes):
+        self.expire = expire
+        self.plain_bytes = plain
+        self.secure_bytes = secure
+
+    @property
+    def plain(self) -> str:
+        return self.plain_bytes.decode('utf-8')
+
+    @property
+    def secure(self) -> str:
+        return self.secure_bytes.decode('utf-8')

saro_dat/dat_certificate.py

@@ -0,0 +1,57 @@
+import time
+
+from .crypto import DatCryptoKey
+from .signature import DatSignatureKey, DatSignatureKeyOutOption
+from .util import encode_base64_url_str, decode_base64_url
+
+
+class DatCertificate:
+    def __init__(
+            self,
+            cid: int,
+            signature_key: DatSignatureKey,
+            crypto_key: DatCryptoKey,
+            dat_issue_begin: int,
+            dat_issue_end: int,
+            dat_ttl: int
+    ):
+        self.cid = cid
+        self._signature_key = signature_key
+        self._crypto_key = crypto_key
+        self._dat_issue_begin = dat_issue_begin
+        self._dat_issue_end = dat_issue_end
+        self._dat_ttl = dat_ttl
+
+    def exports(self, option: DatSignatureKeyOutOption) -> str:
+        cid_hex = hex(self.cid)[2:]
+        sig_alg = self._signature_key.algorithm.value
+        sig_key = self._signature_key.exports(option)
+        cry_alg = self._crypto_key.algorithm.value
+        cry_key = encode_base64_url_str(self._crypto_key.exports())
+
+        return f"{cid_hex}.{sig_alg}.{sig_key}.{cry_alg}.{cry_key}.{self._dat_issue_begin}.{self._dat_issue_end}.{self._dat_ttl}"
+
+    @classmethod
+    def imports(cls, format_str: str) -> DatCertificate:
+        split = format_str.split(".")
+        if len(split) != 8:
+            raise ValueError("Invalid Certificate format")
+
+        cid = int(split[0], 16)
+        sig_key = DatSignatureKey.imports(split[1], split[2])
+        cry_key = DatCryptoKey.imports(split[3], decode_base64_url(split[4]))
+
+        return cls(
+            cid, sig_key, cry_key,
+            int(split[5]), int(split[6]), int(split[7])
+        )
+
+    def issuable(self) -> bool:
+        now = int(time.time())
+        return self.has_signing_key() and self._dat_issue_begin <= now <= self._dat_issue_end
+
+    def expired(self) -> bool:
+        return int(time.time()) > (self._dat_issue_end + self._dat_ttl)
+
+    def has_signing_key(self) -> bool:
+        return self._signature_key.has_signing_key()

saro_dat/dat_manager.py

@@ -0,0 +1,115 @@
+import time
+from typing import List, Optional, Union
+
+from readerwriterlock import rwlock
+
+from . import DatCertificate, Dat, DatPayload
+from .signature import DatSignatureKeyOutOption
+from .util import encode_base64_url_str
+
+
+class DatManager:
+    def __init__(self):
+        self._issuer = None
+        self._certificates = []
+        self._lock = rwlock.RWLockFairD()
+
+
+    def import_certificates(self, input_certs: List[DatCertificate], clear: bool = False):
+        certificates = []
+
+        if not clear:
+            with self._lock.gen_rlock():
+                certificates.extend(self._certificates)
+
+        before_cids = set(map(lambda x: x.cid,certificates))
+        seen_cids = set()
+
+        for cert in input_certs:
+            if cert.cid in seen_cids:
+                raise ValueError(f"Duplicate CID: {cert.cid}")
+            seen_cids.add(cert.cid)
+            if cert.expired():
+                continue
+            if cert.cid in before_cids:
+                continue
+            certificates.append(cert)
+
+        certificates.sort(key=lambda x: x._dat_issue_end)
+        issuer = next((c for c in reversed(certificates) if c.issuable()), None)
+
+        with self._lock.gen_wlock():
+            self._issuer = issuer
+            self._certificates = certificates
+
+
+    def imports(self, format_str: str, clear: bool = False):
+        certs = []
+        for line in format_str.strip().split('\n'):
+            if line.strip():
+                certs.append(DatCertificate.imports(line.strip()))
+        self.import_certificates(certs, clear)
+
+    def exports(self, option: DatSignatureKeyOutOption) -> str:
+        lines = []
+
+        with self._lock.gen_rlock():
+            for cert in self._certificates:
+                lines.append(cert.exports(option))
+
+        return '\n'.join(lines)
+
+    def _find_unsafe(self, cid: int) -> Optional[DatCertificate]:
+        return next((c for c in self._certificates if c.cid == cid), None)
+
+    def issue(self, plain: Union[bytes, str, None], secure: Union[bytes, str, None]) -> str:
+        with self._lock.gen_rlock():
+            if self._issuer:
+                return self._issue(self._issuer, plain, secure)
+        raise RuntimeError("Invalid DAT: Signing Key Does Not Exist")
+
+    def parse(self, dat_input: Union[Dat, str, None]) -> DatPayload:
+        dat = Dat.from_value(dat_input)
+        if not dat._format:
+            raise ValueError("Invalid DAT: Format")
+
+        with self._lock.gen_rlock():
+            certificate = self._find_unsafe(dat._cid)
+            if certificate is not None:
+                return self._parse(certificate, dat)
+        raise ValueError("Invalid DAT: CID(Certificate ID) Not Found")
+
+    @staticmethod
+    def _issue(cert: DatCertificate, plain: Union[bytes, str, None], secure: Union[bytes, str, None]) -> str:
+        now = int(time.time())
+        expire = now + cert._dat_ttl
+        cid_hex = hex(cert.cid)[2:]
+
+        # Plain 데이터 처리 (문자열인 경우 utf-8 바이트로)
+        plain_bytes = plain.encode() if isinstance(plain, str) else (plain or b'')
+        plain_b64 = encode_base64_url_str(plain_bytes)
+
+        # Secure 데이터 암호화
+        encrypted_secure = cert._crypto_key.encrypt(secure)
+        secure_b64 = encode_base64_url_str(encrypted_secure)
+
+        body = f"{expire}.{cid_hex}.{plain_b64}.{secure_b64}"
+        signature = encode_base64_url_str(cert._signature_key.sign(body))
+
+        return f"{body}.{signature}"
+
+    @staticmethod
+    def _parse(cert: DatCertificate, dat_input: Union[Dat, str, None]) -> DatPayload:
+        dat = Dat.from_value(dat_input)
+        if not dat._format:
+            raise RuntimeError("Invalid DAT: Format")
+        if dat.expired():
+            raise RuntimeError("Invalid DAT: Expired")
+
+        # 서명 검증
+        if not cert._signature_key.verify(dat.body_string(), dat._signature):
+            raise RuntimeError("Invalid DAT: Signature")
+
+        # 데이터 복호화
+        decrypted_secure = cert._crypto_key.decrypt(dat._secure)
+        return DatPayload(dat._expire, dat._plain, decrypted_secure)

saro_dat/signature.py

@@ -0,0 +1,174 @@
+from enum import Enum
+from typing import Union, Optional, TypeAlias
+
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric import ec
+from cryptography.hazmat.primitives.asymmetric.ec import EllipticCurve
+from cryptography.hazmat.primitives.hashes import HashAlgorithm
+
+from .util import decode_base64_url, encode_base64_url_str
+
+
+class DatSignatureAlgorithm(str, Enum):
+    P256 = "P256"
+    P384 = "P384"
+    P521 = "P521"
+
+class DatSignatureKeyOutOption(str, Enum):
+    FULL = "FULL"
+    SIGNING = "SIGNING"
+    VERIFYING = "VERIFYING"
+
+CurveType: TypeAlias = Union[EllipticCurve]
+HashType: TypeAlias = Union[HashAlgorithm]
+ConfigValue: TypeAlias = dict[str, Union[CurveType, HashAlgorithm]]
+
+SIGNATURE_CONFIG: dict[str, ConfigValue] = {
+    "P256": {"curve": ec.SECP256R1(), "hash": hashes.SHA256()},
+    "P384": {"curve": ec.SECP384R1(), "hash": hashes.SHA384()},
+    "P521": {"curve": ec.SECP521R1(), "hash": hashes.SHA512()},
+}
+
+def get_signature_config(algorithm: str) -> dict:
+    config = SIGNATURE_CONFIG.get(algorithm)
+    if config:
+        return config
+    raise ValueError(f"Unsupported DAT Crypto Algorithm: {algorithm}")
+
+class DatSignatureKey:
+    def __init__(
+            self,
+            algorithm: DatSignatureAlgorithm,
+            signing_key: Optional[ec.EllipticCurvePrivateKey],
+            verifying_key: ec.EllipticCurvePublicKey,
+            config: ConfigValue
+    ):
+        if config is None:
+            config = get_signature_config(algorithm)
+        self.algorithm = algorithm
+        self.signing_key = signing_key
+        self.verifying_key = verifying_key
+        self._config = config
+
+    @staticmethod
+    def generate(algorithm: Union[DatSignatureAlgorithm, str]) -> DatSignatureKey:
+        config = get_signature_config(algorithm)
+        if isinstance(algorithm, str):
+            algorithm = DatSignatureAlgorithm(algorithm)
+        private_key = ec.generate_private_key(config["curve"])
+        public_key = private_key.public_key()
+        return DatSignatureKey(algorithm, private_key, public_key, config)
+
+    @staticmethod
+    def imports(algorithm: Union[DatSignatureAlgorithm, str], format_str: str) -> DatSignatureKey:
+        config = get_signature_config(algorithm)
+        if isinstance(algorithm, str):
+            algorithm = DatSignatureAlgorithm(algorithm)
+
+        parts = format_str.split("~")
+        parts_len = len(parts)
+
+        if not (parts_len in range(1, 3)):
+            raise ValueError("Invalid DAT Signature Key Format: No keys found")
+
+        signing_key = None
+        verifying_key = None
+
+        if parts[0]:  # 첫 번째 파트가 비어있지 않으면 개인키 존재
+            d_value = int.from_bytes(decode_base64_url(parts[0]), 'big')
+            signing_key = ec.derive_private_key(d_value, config["curve"])
+
+        # 2. Public Key (Verifying Key) 처리
+        if parts_len == 2 and parts[1]:
+            public_bytes = decode_base64_url(parts[1])
+            verifying_key = ec.EllipticCurvePublicKey.from_encoded_point(
+                config["curve"], public_bytes
+            )
+        elif signing_key:
+            verifying_key = signing_key.public_key()
+        else:
+            raise ValueError("Invalid DAT Signature Key Format: No keys found")
+
+        return DatSignatureKey(algorithm, signing_key, verifying_key, config)
+
+    def exports(self, option: DatSignatureKeyOutOption) -> str:
+        rv_parts = ["", ""]  # [signing, verifying]
+
+        if option in ["FULL", "SIGNING"]:
+            if self.signing_key:
+                # Private Key 'd' 값을 고정된 길이의 바이트로 추출
+                private_numbers = self.signing_key.private_numbers()
+                curve_size = (self.signing_key.curve.key_size + 7) // 8
+                d_bytes = private_numbers.private_value.to_bytes(curve_size, 'big')
+                rv_parts[0] = encode_base64_url_str(d_bytes)
+            elif option == "SIGNING":
+                raise ValueError("Signature key is not supported - verifying only key")
+
+        if option in ["FULL", "VERIFYING"]:
+            # Public Key를 Raw Bytes(Uncompressed)로 추출
+            public_bytes = self.verifying_key.public_bytes(
+                encoding=serialization.Encoding.X962,
+                format=serialization.PublicFormat.UncompressedPoint
+            )
+            rv_parts[1] = encode_base64_url_str(public_bytes)
+
+        if option == "SIGNING":
+            return rv_parts[0]
+        if option == "VERIFYING":
+            return "~" + rv_parts[1]
+        return f"{rv_parts[0]}~{rv_parts[1]}"
+
+    def sign(self, body: Union[bytes, str]) -> bytes:
+        if not self.signing_key:
+            raise ValueError("Signature key is not supported - verifying only key")
+
+        if isinstance(body, str):
+            body = body.encode()
+
+        if not body:
+            raise ValueError("Sign Error - body is empty")
+
+        signature = self.signing_key.sign(
+            body,
+            ec.ECDSA(self._config["hash"])
+        )
+
+        return self._der_to_raw_signature(signature)
+
+    def verify(self, body: Union[bytes, str], signature: Union[bytes, str]) -> bool:
+        if isinstance(body, str):
+            body = body.encode('utf-8')
+        if not body:
+            return False
+
+        sig_bytes = decode_base64_url(signature) if isinstance(signature, str) else signature
+
+        try:
+            # Raw (R|S) -> DER 변환 후 검증
+            der_sig = self._raw_to_der_signature(sig_bytes)
+            self.verifying_key.verify(
+                der_sig,
+                body,
+                ec.ECDSA(self._config["hash"])
+            )
+            return True
+        except Exception:
+            return False
+
+    def has_signing_key(self) -> bool:
+        return self.signing_key is not None
+
+    # --- 유틸리티: Web Crypto (Raw R|S) <-> OpenSSL (DER) 변환 ---
+    def _der_to_raw_signature(self, signature: bytes) -> bytes:
+        from cryptography.hazmat.primitives.asymmetric.utils import decode_dss_signature
+        r, s = decode_dss_signature(signature)
+        size = (self.verifying_key.curve.key_size + 7) // 8
+        return r.to_bytes(size, 'big') + s.to_bytes(size, 'big')
+
+    def _raw_to_der_signature(self, signature: bytes) -> bytes:
+        from cryptography.hazmat.primitives.asymmetric.utils import encode_dss_signature
+        size = len(signature) // 2
+        r = int.from_bytes(signature[:size], 'big')
+        s = int.from_bytes(signature[size:], 'big')
+        return encode_dss_signature(r, s)

saro_dat/util.py

@@ -0,0 +1,30 @@
+import base64
+from typing import Union
+
+
+def encode_base64_url(s: Union[bytes, str, None]) -> bytes:
+    if isinstance(s, str):
+        if s == "":
+            return b""
+        s = s.encode('utf-8')
+    if s is None:
+        return b""
+    return base64.urlsafe_b64encode(s).rstrip(b'=')
+
+def encode_base64_url_str(s: Union[bytes, str, None]) -> str:
+    return encode_base64_url(s).decode('ascii')
+
+def decode_base64_url(s: Union[bytes, str, None]) -> bytes:
+    if isinstance(s, str):
+        if s == "":
+            return b""
+        s = s.encode('utf-8')
+    if s is None:
+        return b""
+    rem = len(s) % 4
+    if rem > 0:
+        s += b'=' * (4 - rem)
+    return base64.urlsafe_b64decode(s)
+
+def decode_base64_url_str(s: Union[bytes, str, None]) -> str:
+    return decode_base64_url(s).decode('utf-8')

saro_dat-1.0.0.dist-info/METADATA

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: saro-dat
+Version: 1.0.0
+Summary: Distributed Access Token
+Author-email: Marker Seoul <j@saro.me>
+Project-URL: Homepage, https://dat.saro.me
+Project-URL: Repository, https://github.com/saro-lab/dat-pypi
+Project-URL: Documentation, https://dat.saro.me/ko/libs/pypi-saro-dat
+Keywords: dat,distributed,access,token,jwt,security,authentication
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cryptography>=47.0.0
+Requires-Dist: readerwriterlock>=1.0.9
+Dynamic: license-file
+
+# DAT - Distributed Access Token
+
+## Document
+
+### [DAT Run Online](https://dat.saro.me)
+
+### [What is DAT](https://dat.saro.me/--/intro)
+
+### [Example](https://dat.saro.me/--/libs/pypi-saro-dat)
+
+## support signature algorithm
+| name   | algorithm  |
+|--------|------------|
+| P256   | secp256r1  |
+| P384   | secp384r1  |
+| P521   | secp521r1  |
+
+## support crypto algorithm
+| name       | algorithm                   |
+|------------|-----------------------------|
+| AES128GCMN | aes-128-gcm n(nonce + body) |
+| AES256GCMN | aes-256-cbc n(nonce + body) |
+
+
+# Performance
+- random plain and secure test
+- mac mini m4 2024 basic (10 core)
+- [test_bench.py](tests/test_bench.py)
+```
+Plain: A9wAt86DfDVQCXzfijnfB7j5GWk9TOO4lapQS7AzYenPoRAELwaiqKa8IikDmT8FAfNZJFocR66Rvqcae3JcSf3OVIppE0lYDg4G
+Secure: R2KJfHAFClJdS0je4TkU5JoTDfRMGjp5y5zn5sG2iCwsL6IVhjzCOXaVcQPAJwqiEJGDmd3Rdl6tCI0KwAcsjD4ZrqL3IEL5Jr2Q
+
+Multi-Thread
+P256 AES128GCMN Issue * 10000 : 192ms
+P256 AES128GCMN Parse * 10000 : 171ms
+P256 AES256GCMN Issue * 10000 : 191ms
+P256 AES256GCMN Parse * 10000 : 168ms
+P384 AES128GCMN Issue * 10000 : 847ms
+P384 AES128GCMN Parse * 10000 : 1841ms
+P384 AES256GCMN Issue * 10000 : 789ms
+P384 AES256GCMN Parse * 10000 : 1829ms
+P521 AES128GCMN Issue * 10000 : 684ms
+P521 AES128GCMN Parse * 10000 : 1355ms
+P521 AES256GCMN Issue * 10000 : 683ms
+P521 AES256GCMN Parse * 10000 : 1343ms
+
+Single-Thread
+P256 AES128GCMN Issue * 10000 : 223ms
+P256 AES128GCMN Parse * 10000 : 447ms
+P256 AES256GCMN Issue * 10000 : 213ms
+P256 AES256GCMN Parse * 10000 : 450ms
+P384 AES128GCMN Issue * 10000 : 4915ms
+P384 AES128GCMN Parse * 10000 : 11750ms
+P384 AES256GCMN Issue * 10000 : 4915ms
+P384 AES256GCMN Parse * 10000 : 11705ms
+P521 AES128GCMN Issue * 10000 : 3576ms
+P521 AES128GCMN Parse * 10000 : 7219ms
+P521 AES256GCMN Issue * 10000 : 3623ms
+P521 AES256GCMN Parse * 10000 : 7246ms
+```

saro_dat-1.0.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+saro_dat/__init__.py,sha256=WQAIkMRDxXdWeYP4N_DZZ0t-BFiXbZaoD_OeEdmRS3w,468
+saro_dat/crypto.py,sha256=sWNnfqyeJ4em7CLER2CYmZHI4HLC1wB2giA7A4jU95g,2403
+saro_dat/dat.py,sha256=38i4WFNjFPopbptmidFy9No1w1YwjhOyP3y52xqItkE,1877
+saro_dat/dat_certificate.py,sha256=AoDKEs31ORf7aWcj3LpenBcZtXOD4-vtJ_X04pDNRZY,1969
+saro_dat/dat_manager.py,sha256=B8l7_4cnE53gGdkHUCBJ7S6OcKQJLbW5UicSe85XTxk,4107
+saro_dat/signature.py,sha256=ejJqfHn2yL-pBBiVS1oBoh52OeIlv8Y71Cpgt-id34Q,6620
+saro_dat/util.py,sha256=h7KMrTXU1PaeqzFnMEp5zXA_diBMA2hzr6LYf7nc074,815
+saro_dat-1.0.0.dist-info/licenses/LICENSE,sha256=tdGaI3vE-m4CX8nJv11xod13MG4Mg5Eko3sbOpxkT_E,1065
+saro_dat-1.0.0.dist-info/METADATA,sha256=xCiNRKEX2zanKVgvtIOD7QwtvDKjwIQZQK296enyp-4,2408
+saro_dat-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+saro_dat-1.0.0.dist-info/top_level.txt,sha256=o6vG208t3QETZ0lg6ozgkkbkK0kDcSjVTbDa4dHTw4E,9
+saro_dat-1.0.0.dist-info/RECORD,,

saro_dat-1.0.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
+

saro_dat-1.0.0.dist-info/licenses/LICENSE

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

saro_dat-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+saro_dat