ciphertoken 0.1.2__cp310-cp310-win_amd64.whl

ciphertoken/__init__.pyi

@@ -0,0 +1,5 @@
+from .secret import secret_key, secret_key_with_size, generate_hmac_secret, generate_hmac_secret_async,generate_rsa_keypair
+from .utils import DEFAULT_SECRET_SIZE, EDDSA,ES256,ES384,HS256,HS384,HS512,MIN_SECRET_SIZE,PS256,PS384,PS512,RS256,RS384,RS512,TOKEN_ACCESS,TOKEN_REFRESH
+from .time import seconds, minutes, hours, days, weeks,now
+
+from .ciphertoken import CipherToken, is_jwt_format,validate_jwt_format

ciphertoken/algorithms.pyi

@@ -0,0 +1,12 @@
+HS256: str
+HS384: str
+HS512: str
+RS256: str
+RS384: str
+RS512: str
+ES256: str
+ES384: str
+PS256: str
+PS384: str
+PS512: str
+EDDSA: str

ciphertoken/ciphertoken.pyi

@@ -0,0 +1,26 @@
+from typing import Optional, Dict, Any, Tuple, Awaitable
+
+class CipherToken:
+    def __init__(self, secret: str, algorithm: str, access_ttl: int, refresh_ttl: int) -> None: ...
+    
+    # Sync methods
+    def access(self, user_id: int, extra_payload: Optional[Dict[str, Any]] = None) -> str: ...
+    def refresh(self, user_id: int, extra_payload: Optional[Dict[str, Any]] = None) -> str: ...
+    def decode(self, token: str) -> Dict[str, Any]: ...
+    def verify(self, token: str) -> bool: ...
+    def rotation(self, refresh_token: str, extra_payload: Optional[Dict[str, Any]] = None) -> Tuple[str, str]: ...
+    def inspect(self, token: str) -> Dict[str, Any]: ...
+    def remaining_time(self, token: str) -> Optional[int]: ...
+    def algorithm_name(self) -> str: ...
+    
+    # Async methods
+    async def access_async(self, user_id: int, extra_payload: Optional[Dict[str, Any]] = None) -> Awaitable[str]: ...
+    async def refresh_async(self, user_id: int, extra_payload: Optional[Dict[str, Any]] = None) -> Awaitable[str]: ...
+    async def decode_async(self, token: str) -> Awaitable[Dict[str, Any]]: ...
+    async def verify_async(self, token: str) -> Awaitable[bool]: ...
+    async def rotation_async(self, refresh_token: str, extra_payload: Optional[Dict[str, Any]] = None) -> Awaitable[Tuple[str, str]]: ...
+
+# Utility functions
+def is_jwt_format(token: str) -> bool: ...
+def validate_jwt_format(token: str) -> bool: ...
+

ciphertoken/secret.pyi

@@ -0,0 +1,7 @@
+from typing import Awaitable, Tuple, Optional
+
+def secret_key() -> str: ...
+def secret_key_with_size(size: int) -> str: ...
+def generate_hmac_secret(size: int) -> str: ...
+async def generate_hmac_secret_async(size: int) -> Awaitable[str]: ...
+def generate_rsa_keypair(bits: Optional[int] = 2048) -> Tuple[str, str]:...

ciphertoken/time.pyi

@@ -0,0 +1,7 @@
+
+def now() -> int: ...
+def seconds(n: int) -> int: ...
+def minutes(n: int) -> int: ...
+def hours(n: int) -> int: ...
+def days(n: int) -> int: ...
+def weeks(n: int) -> int: ...

ciphertoken/utils.pyi

@@ -0,0 +1,7 @@
+
+
+# Constants
+DEFAULT_SECRET_SIZE: int
+MIN_SECRET_SIZE: int
+TOKEN_ACCESS: str
+TOKEN_REFRESH: str

ciphertoken-0.1.2.dist-info/METADATA

@@ -0,0 +1,170 @@
+Metadata-Version: 2.4
+Name: ciphertoken
+Version: 0.1.2
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Rust
+Classifier: Operating System :: OS Independent
+Summary: High-performance token and crypto utilities written in Rust with PyO3
+Author: Cipher-Unit
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+<img src="https://raw.githubusercontent.com/cipher-unit/CipherToken/refs/heads/main/logo.png" width=100>
+
+# CipherToken
+
+**CipherToken** is a modern, high-performance Python library for cryptography and JWT (JSON Web Token) management.  
+It is implemented in **Rust** using **PyO3**, providing both speed and security for generating, encoding, decoding, and verifying tokens.  
+
+The library is designed to be modular, organized into **submodules** for secret management, time utilities, algorithms, and token handling.  
+It supports both **synchronous** and **asynchronous** operations
+
+---
+
+## Library Overview
+
+CipherToken is structured into the following main parts:
+
+### 1. `secret` Module
+Handles key generation for symmetric (HMAC) and asymmetric (RSA) algorithms:
+
+- `secret_key()` – Generate a random HMAC key (default 32 bytes)
+- `secret_key_with_size(size: int)` – Generate HMAC key with a custom size
+- `generate_hmac_secret(size: int)` – Generate an HMAC secret key
+- `generate_hmac_secret_async(size: int)` – Async version of HMAC key generation
+- `generate_rsa_keypair(bits: Optional[int] = 2048)` – Generate RSA private/public key pair
+
+---
+
+### 2. `time` Module
+Provides utility functions for time conversion and timestamps:
+
+- `now()` – Current UNIX timestamp
+- `seconds(n: int)` – Convert n seconds to seconds
+- `minutes(n: int)` – Convert n minutes to seconds
+- `hours(n: int)` – Convert n hours to seconds
+- `days(n: int)` – Convert n days to seconds
+- `weeks(n: int)` – Convert n weeks to seconds
+
+---
+
+### 3. `utils` Module
+Contains useful constants:
+
+- `DEFAULT_SECRET_SIZE` – Default key size
+- `MIN_SECRET_SIZE` – Minimum allowed key size
+- `TOKEN_ACCESS` – Access token type
+- `TOKEN_REFRESH` – Refresh token type
+
+---
+
+### 4. `algorithms` Module
+Defines algorithm constants for token signing:
+
+- HMAC: `HS256`, `HS384`, `HS512`
+- RSA: `RS256`, `RS384`, `RS512`
+- ECDSA: `ES256`, `ES384`
+- RSA-PSS: `PS256`, `PS384`, `PS512`
+- Edwards Curve: `EDDSA`
+
+---
+
+### 5. `CipherToken` Class
+Main class for managing JWTs:
+
+- **Constructor:**
+```python
+from ciphertoken import CipherToken
+
+CipherToken(secret: str, algorithm: str, access_ttl: int, refresh_ttl: int)
+```
+
+### Synchronous methods:
+```python
+access(user_id: int, extra_payload: Optional[dict] = None) -> str
+refresh(user_id: int, extra_payload: Optional[dict] = None) -> str
+decode(token: str) -> dict
+verify(token: str) -> bool
+rotation(refresh_token: str, extra_payload: Optional[dict] = None) -> Tuple[str, str]
+inspect(token: str) -> dict
+remaining_time(token: str) -> Optional[int]
+algorithm_name() -> str
+```
+
+### Asynchronous methods:
+```python
+await access_async(user_id: int, extra_payload: Optional[dict] = None) -> str
+await refresh_async(user_id: int, extra_payload: Optional[dict] = None) -> str
+await decode_async(token: str) -> dict
+await verify_async(token: str) -> bool
+await rotation_async(refresh_token: str, extra_payload: Optional[dict] = None) -> Tuple[str, str]
+```
+
+### Helper Functions:
+
+`is_jwt_format(token: str) – Check if a string is a valid JWT`
+
+`validate_jwt_format(token: str) – Validate JWT structure`
+
+## Installation
+
+CipherToken is available via PyPI. Install it with:
+
+`pip install ciphertoken`
+
+---
+
+### Usage Example
+
+```python
+from ciphertoken.secret import secret_key
+from ciphertoken import CipherToken
+from ciphertoken.time import minutes, days
+from ciphertoken.utils import TOKEN_REFRESH
+from ciphertoken.algorithms import HS256
+
+# Generate a secret key
+key = secret_key()
+
+# Create a CipherToken instance
+token = CipherToken(secret=key, algorithm=HS256, access_ttl=minutes(10), refresh_ttl=days(7))
+
+# Generate access and refresh tokens
+access_token = token.access(user_id=123)
+refresh_token = token.refresh(user_id=123)
+
+# Verify and decode tokens
+payload = token.decode(access_token)
+is_valid = token.verify(access_token)
+
+# Async usage
+import asyncio
+
+async def generate_async_token():
+    access_token = await token.access_async(user_id=123)
+    payload = await token.decode_async(access_token)
+    return payload
+
+asyncio.run(generate_async_token())
+
+```
+
+### Implementation Notes
+
+- Built in Rust using PyO3 for maximum speed and memory safety
+
+- Supports synchronous and asynchronous workflows
+
+- Fully modular: secret, time, utils, algorithms, and CipherToken class
+
+- Secure key handling with HMAC and RSA support
+
+- Easily extendable for additional algorithms
+
+
+### Summary
+
+CipherToken is a modern, Rust-backed Python library for authentication and JWT management.
+It is ideal for web APIs, microservices, or any system that requires secure token generation, verification, and rotation.

ciphertoken-0.1.2.dist-info/RECORD

@@ -0,0 +1,11 @@
+ciphertoken/__init__.pyi,sha256=8VC9YMMj_UblS3kpvPnuBpuukGrtaAq90RdrDcMg9bU,414
+ciphertoken/algorithms.pyi,sha256=i1izi1n0I11ObAXSmNNkblbZKuaTUob3EBoaSw0wS-g,144
+ciphertoken/ciphertoken.cp310-win_amd64.pyd,sha256=7pbo4GjyX1LqlClmq5H2dRVAVDis1riJ-BzsU2OmZuw,2319360
+ciphertoken/ciphertoken.pyi,sha256=cgAXn7FazrkXxlvUphLUwx3a93lZ0owvThfrgbPMwtg,1458
+ciphertoken/secret.pyi,sha256=4ZeBaU7VR3pAKq076xrW5Tp1PUEApttARJ7ii1hdCnQ,324
+ciphertoken/time.pyi,sha256=TwRIF6lr6c3D8Auq9RZXG4VZ_bAcuHBvLOhcaRG639A,181
+ciphertoken/utils.pyi,sha256=UUjB6TKffjlaMg-V3b8rNtJRl_ASw4Qa3ATF65z1bzg,104
+ciphertoken-0.1.2.dist-info/METADATA,sha256=sHuMlwCqpfW7Ci73Ye_Vhcr8tqj0_MHX34In3oNBJTU,5265
+ciphertoken-0.1.2.dist-info/WHEEL,sha256=qztQ23OdXtRBO3SW-Pa5eKaAgySi2gewLIEhihDaoD4,97
+ciphertoken-0.1.2.dist-info/sboms/ciphertoken.cyclonedx.json,sha256=Y0IlWHHuTy8VOdamEsbzwW1r6-z0q8Ig2XzjfuFN34c,142894
+ciphertoken-0.1.2.dist-info/RECORD,,

ciphertoken-0.1.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.13.1)
+Root-Is-Purelib: false
+Tag: cp310-cp310-win_amd64