saro-dat 1.0.0__tar.gz

saro_dat-1.0.0/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,60 @@
+# 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/pyproject.toml

@@ -0,0 +1,22 @@
+[project]
+name = "saro-dat"
+version = "1.0.0"
+description = "Distributed Access Token"
+keywords = ["dat", "distributed", "access", "token", "jwt", "security", "authentication"]
+readme = "README.md"
+authors = [{name = "Marker Seoul", email = "j@saro.me"}]
+requires-python = ">=3.9"
+dependencies = [
+    "cryptography>=47.0.0",
+    "readerwriterlock>=1.0.9",
+]
+
+[project.urls]
+"Homepage" = "https://dat.saro.me"
+"Repository" = "https://github.com/saro-lab/dat-pypi"
+"Documentation" = "https://dat.saro.me/ko/libs/pypi-saro-dat"
+
+[dependency-groups]
+dev = [
+    "pytest>=8.4.2",
+]

saro_dat-1.0.0/setup.cfg

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

saro_dat-1.0.0/src/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-1.0.0/src/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-1.0.0/src/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-1.0.0/src/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-1.0.0/src/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-1.0.0/src/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-1.0.0/src/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/src/saro_dat.egg-info/PKG-INFO

@@ -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/src/saro_dat.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+LICENSE
+README.md
+pyproject.toml
+src/saro_dat/__init__.py
+src/saro_dat/crypto.py
+src/saro_dat/dat.py
+src/saro_dat/dat_certificate.py
+src/saro_dat/dat_manager.py
+src/saro_dat/signature.py
+src/saro_dat/util.py
+src/saro_dat.egg-info/PKG-INFO
+src/saro_dat.egg-info/SOURCES.txt
+src/saro_dat.egg-info/dependency_links.txt
+src/saro_dat.egg-info/requires.txt
+src/saro_dat.egg-info/top_level.txt
+tests/test_bench.py
+tests/test_certificate.py
+tests/test_crypto.py
+tests/test_example.py
+tests/test_manager.py
+tests/test_signature.py
+tests/test_util.py

saro_dat-1.0.0/src/saro_dat.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

saro_dat-1.0.0/src/saro_dat.egg-info/requires.txt

@@ -0,0 +1,2 @@
+cryptography>=47.0.0
+readerwriterlock>=1.0.9

saro_dat-1.0.0/src/saro_dat.egg-info/top_level.txt

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

saro_dat-1.0.0/tests/test_bench.py

@@ -0,0 +1,94 @@
+import asyncio
+import secrets
+import string
+import time
+import unittest
+from concurrent.futures import ThreadPoolExecutor
+
+from saro_dat import DatSignatureAlgorithm, DatCryptoAlgorithm, DatCertificate, DatManager, DatSignatureKey, DatCryptoKey
+
+
+def generate_base62(length: int) -> str:
+    characters = string.ascii_letters + string.digits
+    return ''.join(secrets.choice(characters) for _ in range(length))
+
+
+def run_issue(cert, plain, secure):
+    return DatManager._issue(cert, plain, secure)
+
+
+def run_parse(cert, dat_str):
+    return DatManager._parse(cert, dat_str)
+
+
+async def loops(multi_thread: bool, loop_size: int, certificates: list[DatCertificate], plain: str, secure: str):
+    mode_name = "Multi-Thread" if multi_thread else "Single-Thread"
+    print(f"\n--- {mode_name} ---")
+
+    for cert in certificates:
+        pre = f"{cert._signature_key.algorithm.name} {cert._crypto_key.algorithm.name}"
+
+        start = time.perf_counter()
+        last_dat = ""
+
+        if multi_thread:
+            # 파이썬의 GIL 우회를 위해 ProcessPoolExecutor 사용 (실제 멀티코어 활용)
+            with ThreadPoolExecutor() as executor:
+                futures = [executor.submit(run_issue, cert, plain, secure) for _ in range(loop_size)]
+                for fut in futures:
+                    last_dat = fut.result()
+        else:
+            for _ in range(loop_size):
+                last_dat = DatManager._issue(cert, plain, secure)
+
+        duration_ms = (time.perf_counter() - start) * 1000
+        print(f"{pre} Issue * {loop_size} : {duration_ms:.2f}ms")
+
+        # 2. Parse Benchmark
+        start = time.perf_counter()
+        last_payload = None
+
+        if multi_thread:
+            with ThreadPoolExecutor() as executor:
+                futures = [executor.submit(run_parse, cert, last_dat) for _ in range(loop_size)]
+                for fut in futures:
+                    last_payload = fut.result()
+        else:
+            for _ in range(loop_size):
+                last_payload = DatManager._parse(cert, last_dat)
+
+        duration_ms = (time.perf_counter() - start) * 1000
+        print(f"{pre} Parse * {loop_size} : {duration_ms:.2f}ms")
+
+        # 검증
+        assert last_payload.plain == plain
+        assert last_payload.secure == secure
+
+
+async def benchmark(loop_size: int):
+    plain = generate_base62(100)
+    secure = generate_base62(100)
+
+    print("Performance Test (Plain, Secure)")
+    print(f"Plain: {plain}")
+    print(f"Secure: {secure}")
+
+    certificates = []
+    now = int(time.time())
+
+    for sa in DatSignatureAlgorithm:
+        for ca in DatCryptoAlgorithm:
+            certificates.append(DatCertificate(0, DatSignatureKey.generate(sa), DatCryptoKey.generate(ca), now - 10, now + 600, 60))
+
+    await loops(True, loop_size, certificates, plain, secure)
+    await loops(False, loop_size, certificates, plain, secure)
+
+
+class TestBench(unittest.TestCase):
+    def test(self):
+        loop_size = 100
+        asyncio.run(benchmark(loop_size))
+
+
+if __name__ == "__main__":
+    unittest.main()

saro_dat-1.0.0/tests/test_certificate.py

@@ -0,0 +1,74 @@
+import secrets
+import string
+import time
+import unittest
+
+from saro_dat import DatSignatureAlgorithm, DatCryptoAlgorithm, DatCertificate, DatSignatureKey, DatCryptoKey, \
+    DatSignatureKeyOutOption, DatManager
+
+
+def generate_base62(length: int) -> str:
+    characters = string.ascii_letters + string.digits
+    return ''.join(secrets.choice(characters) for _ in range(length))
+
+def generate_certificate(cid: int, sa: DatSignatureAlgorithm, ca: DatCryptoAlgorithm) -> DatCertificate:
+    now = int(time.time())
+    return DatCertificate(cid, DatSignatureKey.generate(sa), DatCryptoKey.generate(ca), now - 10, now + 100, 1800)
+
+def cert_test(test: TestCertificate, fail_cert: DatCertificate, cid: int, sa: DatSignatureAlgorithm, ca: DatCryptoAlgorithm):
+    tag = f"CERT {sa.value} {ca.value}"
+    original_plain = generate_base62(100)
+    original_secure = generate_base62(100)
+
+    new_cert = generate_certificate(cid, sa, ca)
+    export_full_cert: str = new_cert.exports(DatSignatureKeyOutOption.FULL)
+    export_signing_cert = new_cert.exports(DatSignatureKeyOutOption.SIGNING)
+    export_verifying_cert = new_cert.exports(DatSignatureKeyOutOption.VERIFYING)
+
+    reimport_full_cert = DatCertificate.imports(export_full_cert)
+    reimport_signing_cert = DatCertificate.imports(export_signing_cert)
+    reimport_verifying_cert = DatCertificate.imports(export_verifying_cert)
+
+    print(f"{tag} Generated-Imported cert: {export_full_cert}")
+
+    dat_1 = DatManager._issue(new_cert, original_plain, original_secure)
+    dat_2 = DatManager._issue(reimport_full_cert, original_plain, original_secure)
+    dat_3 = DatManager._issue(reimport_signing_cert, original_plain, original_secure)
+    dat_empty = DatManager._issue(new_cert, "", "")
+
+    print(f"{tag} Issue DAT: {dat_1}")
+    print(f"{tag} Issue DAT: {dat_2}")
+    print(f"{tag} Issue DAT: {dat_3}")
+
+    payload_1 = DatManager._parse(reimport_verifying_cert, dat_1)
+    payload_2 = DatManager._parse(reimport_signing_cert, dat_2)
+    payload_3 = DatManager._parse(reimport_full_cert, dat_3)
+    payload_empty = DatManager._parse(reimport_verifying_cert, dat_empty)
+
+    assert payload_1.plain == original_plain
+    assert payload_2.plain == original_plain
+    assert payload_3.plain == original_plain
+    assert payload_empty.plain == ""
+    assert payload_1.secure == original_secure
+    assert payload_2.secure == original_secure
+    assert payload_3.secure == original_secure
+    assert payload_empty.secure == ""
+    print(f"{tag} Verify DAT")
+
+    with test.assertRaises(RuntimeError):
+        DatManager._parse(fail_cert, dat_1)
+
+
+class TestCertificate(unittest.TestCase):
+
+
+    def test(self):
+        fail_cert = generate_certificate(3424342, DatSignatureAlgorithm.P256, DatCryptoAlgorithm.AES128GCMN)
+        for sa in DatSignatureAlgorithm:
+            for ca in DatCryptoAlgorithm:
+                for i in range(30):
+                    cert_test(self, fail_cert, i, sa, ca)
+
+
+if __name__ == "__main__":
+    unittest.main()

saro_dat-1.0.0/tests/test_crypto.py

@@ -0,0 +1,48 @@
+import secrets
+import string
+import unittest
+
+from saro_dat import util
+from saro_dat.crypto import DatCryptoKey, DatCryptoAlgorithm
+
+
+def generate_base62(length: int) -> str:
+    characters = string.ascii_letters + string.digits
+    return ''.join(secrets.choice(characters) for _ in range(length))
+
+def algorithm_test(algorithm: DatCryptoAlgorithm):
+    tag = algorithm.value
+    gen_key = DatCryptoKey.generate(algorithm)
+    out_key_bytes = gen_key.exports()
+    out_key_base64 = util.encode_base64_url_str(out_key_bytes)
+    copy_key = DatCryptoKey.imports(algorithm, util.decode_base64_url(out_key_base64))
+    print(f"{tag} Generated-Imported key [{len(out_key_bytes)}] {out_key_base64}")
+
+    original_text = ">!#2 유니코드" + generate_base62(80)
+    encrypted = util.encode_base64_url_str(gen_key.encrypt(original_text))
+    print(f"{tag} Encrypted: {encrypted}")
+
+    decrypted = copy_key.decrypt(encrypted).decode('utf-8')
+    print(f"{tag} Decrypted: {decrypted}")
+
+    # empty
+    original_text = ""
+    encrypted = util.encode_base64_url_str(gen_key.encrypt(original_text))
+    print(f"{tag} Encrypted: {encrypted}")
+
+    decrypted = copy_key.decrypt(encrypted).decode('utf-8')
+    print(f"{tag} Decrypted: {decrypted}")
+
+    assert(original_text == decrypted)
+
+
+class TestDatCrypto(unittest.TestCase):
+
+    def test(self):
+        for algorithm in DatCryptoAlgorithm:
+            for i in range(30):
+                algorithm_test(algorithm)
+
+
+if __name__ == "__main__":
+    unittest.main()

saro_dat-1.0.0/tests/test_example.py

@@ -0,0 +1,66 @@
+import time
+import unittest
+
+from saro_dat import DatManager, DatCertificate, DatSignatureKey, DatSignatureAlgorithm, DatCryptoKey, DatCryptoAlgorithm
+
+
+class TestDatManager(unittest.TestCase):
+
+
+    def test_issue_and_parse(self):
+        dat_manager = DatManager()
+
+        # create certificate
+        now = int(time.time())
+        cert = DatCertificate(0, DatSignatureKey.generate(DatSignatureAlgorithm.P256), DatCryptoKey.generate(DatCryptoAlgorithm.AES128GCMN), now - 10, now + 10, 1800)
+
+        # import certificate
+        dat_manager.import_certificates([cert])
+
+        example_plain = "plain text = 평문"
+        example_secure = "secure = 암호문"
+
+        dat = dat_manager.issue(example_plain, example_secure)
+        payload = dat_manager.parse(dat)
+
+        assert payload.plain == example_plain
+        assert payload.secure == example_secure
+        print(f"PARSE DAT: {dat}")
+        print(f"plain: {payload.plain}")
+        print(f"secure: {payload.secure}")
+
+
+
+    def test_hard(self):
+        example_certs = """0.P256.JH0wsVa7I1P2nyMKNi-REWeIyJ_ja30c8N7JmQpE2Ns.AES128GCMN.29dmalXRXXQT-YNV95HFvg.1.17786821880.1800
+1.P256.Gh9fb16c8XYdzKobpUwytD446_cMy3gWyncvViqeIZo.AES128GCMN.zX8sV8zO73-lDSfT-x8I1Q.1.17786821880.1800
+2.P256.fsufFa3ByNffCTG0fSQhEZqGF2z8pWxC3aLbZR6F0f8.AES128GCMN.e4h8InqvA5VvE8OtpjxRMQ.1.17786821880.1800
+3.P256.koYkmCZYmvLISg4-tPbksoZ71ay8hEVEWB6aBbexliA.AES128GCMN.7nQ7R5yuFQ3S5Vb07Brawg.1.17786821880.1800
+4.P256.Cda0iq0axjTeKhpnqfRFapk4innUjwbd2HEXAzYipAM.AES128GCMN.ttE0ydNaePVMVsGhRmyq8Q.1.17786821880.1800
+5.P256.Tf4ZFbD9ZmY_9kyQRlSXKpgy18uyMGAImh48_z4e9XE.AES128GCMN.ifsTUtiUzZY6-CUielQWkw.1.17786821880.1800
+6.P256.fRz08K1e3mtebqWwHADKl3G4nZR1V2v6knLU6-r7jG4.AES128GCMN.cEPBfYQVKKSd_adfRkrTJQ.1.17786821880.1800
+7.P256.HPDwUUi44EWESaenixl1uOkafSc5Yshi9Q5ht5JV-7o.AES128GCMN._WwtaqkFgvqkxv8T5-WHsg.1.17786821880.1800
+8.P256.2TSn2rl4Ucc7_tcgLFoba81zMGpdN4zInbgjD_IA0dM.AES128GCMN.zgj82h8PpS0nGxlhJBbUQQ.1.17786821880.1800
+9.P256.uKfLtmwS9-4o5_H5fflSoaiCULwHRQXdHan2JSK6-o0.AES128GCMN.w0WXojP3LeCCl68C_KTBMQ.1.1708680188.1800"""
+
+        example_plain = "plain text = 평문"
+        example_secure = "secure = 암호문"
+        example_dat = "19565503600.8.cGxhaW4gdGV4dCA9IO2PieusuA.1YswrtsIMWMz9dJjR2M1sRAZWxzcfTu7CQo-GXaCDMh6nF6g72HQn_F9HnK-kg.kgY9pxi5nITg-8Wk_vRFaUDDldyoSrrOP0-BBxVrwbP0-ZXlpuCmKQ1YiBZd4qv3KrO9vvwZdghpsiYHITbybA"
+
+
+        manager = DatManager()
+
+        manager.imports(example_certs, True)
+
+        payload = manager.parse(example_dat)
+
+        assert payload.plain == example_plain
+        assert payload.secure == example_secure
+        print(f"PARSE DAT: {example_dat}")
+        print(f"plain: {payload.plain}")
+        print(f"secure: {payload.secure}")
+
+if __name__ == "__main__":
+    unittest.main()
+
+

saro_dat-1.0.0/tests/test_manager.py

@@ -0,0 +1,75 @@
+import secrets
+import string
+import time
+import unittest
+
+from saro_dat import DatSignatureAlgorithm, DatCryptoAlgorithm, DatCertificate, DatSignatureKey, DatCryptoKey, \
+    DatSignatureKeyOutOption, DatManager
+
+
+def generate_base62(length: int) -> str:
+    characters = string.ascii_letters + string.digits
+    return ''.join(secrets.choice(characters) for _ in range(length))
+
+def generate_certificate(cid: int, sa: DatSignatureAlgorithm, ca: DatCryptoAlgorithm) -> DatCertificate:
+    now = int(time.time())
+    return DatCertificate(cid, DatSignatureKey.generate(sa), DatCryptoKey.generate(ca), now - 10, now + 100, 1800)
+
+class TestDatManager(unittest.TestCase):
+
+    def test(self):
+        original_plain = generate_base62(100)
+        original_secure = generate_base62(100)
+        dat_list: list[str] = []
+        manager = DatManager()
+
+        i = 0
+        for sa in DatSignatureAlgorithm:
+            for ca in DatCryptoAlgorithm:
+                for _ in range(30):
+                    i += 1
+                    cert = generate_certificate(i, sa, ca)
+                    manager.import_certificates([cert], False)
+                    dat = DatManager._issue(cert, original_plain, original_secure)
+                    dat_list.append(dat)
+
+        print(f"DAT Manager Import : {len(dat_list)} Certificates")
+
+        manager_full_export = manager.exports(DatSignatureKeyOutOption.FULL)
+        manager_signing_export = manager.exports(DatSignatureKeyOutOption.SIGNING)
+        manager_verifying_export = manager.exports(DatSignatureKeyOutOption.VERIFYING)
+
+
+        reimport_full_manager = DatManager()
+        reimport_full_manager.imports(manager_full_export)
+        reimport_signing_manager = DatManager()
+        reimport_signing_manager.imports(manager_signing_export)
+        reimport_verifying_manager = DatManager()
+        reimport_verifying_manager.imports(manager_verifying_export)
+
+        dat_list.append(reimport_full_manager.issue(original_plain, original_secure))
+        dat_list.append(reimport_signing_manager.issue(original_plain, original_secure))
+
+        with self.assertRaises(RuntimeError):
+            dat_list.append(reimport_verifying_manager.issue(original_plain, original_secure))
+
+        print(f"DAT Manager Re-Import")
+        print(f"ISSUE {len(dat_list)} DAT")
+
+        for dat in dat_list:
+            dat1 = manager.parse(dat)
+            dat2 = reimport_verifying_manager.parse(dat)
+            dat3 = reimport_signing_manager.parse(dat)
+            dat4 = reimport_full_manager.parse(dat)
+            assert dat1.plain == original_plain
+            assert dat1.secure == original_secure
+            assert dat2.plain == original_plain
+            assert dat2.secure == original_secure
+            assert dat3.plain == original_plain
+            assert dat3.secure == original_secure
+            assert dat4.plain == original_plain
+            assert dat4.secure == original_secure
+            print(f"PARSE DAT: {dat}")
+
+if __name__ == "__main__":
+    unittest.main()

saro_dat-1.0.0/tests/test_signature.py

@@ -0,0 +1,48 @@
+import secrets
+import string
+import unittest
+
+from saro_dat import DatSignatureAlgorithm, DatSignatureKey, DatSignatureKeyOutOption
+
+
+def generate_base62(length: int) -> str:
+    characters = string.ascii_letters + string.digits
+    return ''.join(secrets.choice(characters) for _ in range(length))
+
+def algorithm_test(algorithm: DatSignatureAlgorithm):
+    tag = algorithm.value
+    gen_key = DatSignatureKey.generate(algorithm)
+
+    out_key_full = gen_key.exports(DatSignatureKeyOutOption.FULL)
+    out_key_signing = gen_key.exports(DatSignatureKeyOutOption.SIGNING)
+    out_key_verifying = gen_key.exports(DatSignatureKeyOutOption.VERIFYING)
+
+    copy_out_key_full = DatSignatureKey.imports(algorithm, out_key_full)
+    copy_out_key_signing = DatSignatureKey.imports(algorithm, out_key_signing)
+    copy_out_key_verifying = DatSignatureKey.imports(algorithm, out_key_verifying)
+
+    print(f"{tag} Generated-Imported key: {out_key_full}")
+
+    original_text = ">!#2 유니코드" + generate_base62(80)
+    sign1 = gen_key.sign(original_text)
+    sign2 = copy_out_key_full.sign(original_text)
+    sign3 = copy_out_key_signing.sign(original_text)
+
+    assert gen_key.verify(original_text, sign3)
+    assert copy_out_key_full.verify(original_text, sign2)
+    assert copy_out_key_signing.verify(original_text, sign1)
+    assert copy_out_key_verifying.verify(original_text, sign1)
+    assert not copy_out_key_verifying.verify(b"", sign1)
+
+    print(f"{tag} Signing-Verify key")
+
+
+class TestSignature(unittest.TestCase):
+
+    def test(self):
+        for algorithm in DatSignatureAlgorithm:
+            for i in range(30):
+                algorithm_test(algorithm)
+
+if __name__ == "__main__":
+    unittest.main()

saro_dat-1.0.0/tests/test_util.py

@@ -0,0 +1,26 @@
+import unittest
+
+from saro_dat.util import encode_base64_url_str, decode_base64_url_str
+
+
+class TestBase64(unittest.TestCase):
+    def test_base64(self):
+        text = "$$><'2    ABC  유니코드"
+        b64 = "JCQ-PCcyICAgIEFCQyAg7Jyg64uI7L2U65Oc"
+
+        b64_1 = encode_base64_url_str(text)
+        self.assertEqual(b64, b64_1)
+        print(b64_1)
+
+        de_b64_1 = decode_base64_url_str(b64_1)
+        self.assertEqual(text, de_b64_1)
+        print(de_b64_1)
+
+        print("Test passed successfully")
+
+
+
+
+if __name__ == "__main__":
+    unittest.main()
+