ctp-py 1.5.0__tar.gz

ctp_py-1.5.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: ctp-py
+Version: 1.5.0
+Summary: Crypto Transfer Protocol v1.5
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: cryptography>=42.0.0
+
+# CTP v1.5
+Crypto Transfer Protocol for secure, high-speed data exchange.

ctp_py-1.5.0/README.md

@@ -0,0 +1,2 @@
+# CTP v1.5
+Crypto Transfer Protocol for secure, high-speed data exchange.

ctp_py-1.5.0/pyproject.toml

@@ -0,0 +1,13 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build-meta"
+
+[project]
+name = "ctp-py"  # The name used for 'pip install'
+version = "1.5.0"
+description = "Crypto Transfer Protocol v1.5"
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = [
+    "cryptography>=42.0.0",
+]

ctp_py-1.5.0/setup.cfg

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

ctp_py-1.5.0/setup.py

@@ -0,0 +1,2 @@
+from setuptools import setup
+setup()

ctp_py-1.5.0/src/ctp/__init__.py

@@ -0,0 +1,190 @@
+import socket, threading, struct, os, hashlib, hmac, time
+from cryptography.hazmat.primitives.asymmetric import ec
+from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.hazmat.primitives.kdf.hkdf import HKDF
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+
+# --- CONSTANTS ---
+CTP_SECRET = b"CTP_CRYPTO_TRANSFER_SHARED_SECRET_2026"
+VERSION = b"CTP/1.5"
+MAX_SKEW = 5.0 
+
+MSG_HANDSHAKE = 0x01
+MSG_AUTH      = 0x02
+MSG_DATA      = 0x03
+MSG_ERROR     = 0xFF
+
+class CTPEngine:
+    def __init__(self, is_server=False):
+        self.is_server = is_server
+        self.private_key = ec.generate_private_key(ec.SECP521R1())
+        self.public_key = self.private_key.public_key()
+        self.session_key = None
+        self.aesgcm = None
+        self.transcript = hashlib.sha3_512()
+        self.my_nonce = os.urandom(16)
+        
+        pub_bytes = self.public_key.public_bytes(
+            encoding=serialization.Encoding.X962,
+            format=serialization.PublicFormat.UncompressedPoint
+        )
+        ts = struct.pack('>Q', int(time.time() * 1000000))
+        self.local_handshake_blob = pub_bytes + self.my_nonce + VERSION + ts
+
+    def get_handshake_blob(self) -> bytes:
+        return self.local_handshake_blob
+
+    def finalize_handshake(self, peer_blob: bytes):
+        if not peer_blob or len(peer_blob) < 164:
+            raise Exception("INVALID_HANDSHAKE_BLOB")
+
+        peer_pub_bytes = peer_blob[:133]
+        peer_nonce = peer_blob[133:149]
+        peer_version = peer_blob[149:156]
+        peer_ts = struct.unpack('>Q', peer_blob[156:164])[0] / 1000000.0
+
+        if abs(time.time() - peer_ts) > MAX_SKEW:
+            raise Exception(f"REPLAY/SKEW_DETECTED: {abs(time.time() - peer_ts):.2f}s")
+
+        if peer_version != VERSION:
+            raise Exception("VERSION_MISMATCH")
+
+        if self.is_server:
+            client_blob, server_blob = peer_blob, self.local_handshake_blob
+            c_nonce, s_nonce = peer_nonce, self.my_nonce
+        else:
+            client_blob, server_blob = self.local_handshake_blob, peer_blob
+            c_nonce, s_nonce = self.my_nonce, peer_nonce
+
+        self.transcript.update(b"CTP_1.5_BIND")
+        self.transcript.update(b"C:")
+        self.transcript.update(client_blob)
+        self.transcript.update(b"S:")
+        self.transcript.update(server_blob)
+        
+        peer_pk = ec.EllipticCurvePublicKey.from_encoded_point(ec.SECP521R1(), peer_pub_bytes)
+        shared = self.private_key.exchange(ec.ECDH(), peer_pk)
+        
+        self.session_key = HKDF(
+            algorithm=hashes.SHA256(), length=32,
+            salt=c_nonce + s_nonce,
+            info=CTP_SECRET + b"CTP_BIND_v1.5",
+        ).derive(shared)
+        
+        self.aesgcm = AESGCM(self.session_key)
+
+    def get_auth_verify(self):
+        return hmac.new(CTP_SECRET, self.transcript.digest(), hashlib.sha256).digest()
+
+    def seal(self, data: bytes) -> bytes:
+        if not self.aesgcm: raise Exception("ENGINE_NOT_READY")
+        n = os.urandom(12)
+        return n + self.aesgcm.encrypt(n, data, None)
+
+    def unseal(self, data: bytes) -> bytes:
+        if not self.aesgcm or not data: raise Exception("DECRYPTION_FAILED")
+        return self.aesgcm.decrypt(data[:12], data[12:], None)
+
+# --- UTILS ---
+def _send(s, t, p): s.sendall(struct.pack('>BI', t, len(p)) + p)
+def _recvall(s, n):
+    d = bytearray()
+    while len(d) < n:
+        p = s.recv(n - len(d))
+        if not p: return None
+        d.extend(p)
+    return bytes(d)
+def _recv(s):
+    h = _recvall(s, 5)
+    if not h: return None, None
+    t, l = struct.unpack('>BI', h)
+    return t, _recvall(s, l)
+
+# --- PUBLIC API ---
+
+class CTPServer:
+    def __init__(self, host='127.0.0.1', port=8937):
+        self.host = host
+        self.port = port
+        self.running = False
+
+    def start(self, handler_callback):
+        """handler_callback(engine, conn) will be called after Auth."""
+        s = socket.socket()
+        s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        s.bind((self.host, self.port))
+        s.listen(10)
+        self.running = True
+        print(f"[*] CTP Server listening on {self.port}...")
+
+        while self.running:
+            try:
+                conn, _ = s.accept()
+                threading.Thread(target=self._session_thread, args=(conn, handler_callback), daemon=True).start()
+            except KeyboardInterrupt: break
+        s.close()
+
+    def _session_thread(self, conn, callback):
+        try:
+            engine = CTPEngine(is_server=True)
+            t, c_blob = _recv(conn)
+            if t != MSG_HANDSHAKE: return
+            _send(conn, MSG_HANDSHAKE, engine.get_handshake_blob())
+            engine.finalize_handshake(c_blob)
+
+            t, enc_auth = _recv(conn)
+            if t != MSG_AUTH: return
+            if not hmac.compare_digest(engine.unseal(enc_auth), engine.get_auth_verify()):
+                return # Auth Failure
+            
+            _send(conn, MSG_AUTH, engine.seal(engine.get_auth_verify()))
+            callback(engine, conn) # Pass off to user logic
+        except Exception as e: print(f"[!] Server Error: {e}")
+        finally: conn.close()
+
+class CTPClient:
+    def __init__(self, host='127.0.0.1', port=8937):
+        self.host = host
+        self.port = port
+        self.engine = CTPEngine(is_server=False)
+        self.conn = socket.socket()
+
+    def connect(self):
+        self.conn.connect((self.host, self.port))
+        _send(self.conn, MSG_HANDSHAKE, self.engine.get_handshake_blob())
+        t, s_blob = _recv(self.conn)
+        self.engine.finalize_handshake(s_blob)
+        
+        _send(self.conn, MSG_AUTH, self.engine.seal(self.engine.get_auth_verify()))
+        t, enc_s_auth = _recv(self.conn)
+        if not hmac.compare_digest(self.engine.unseal(enc_s_auth), self.engine.get_auth_verify()):
+            raise Exception("SERVER_AUTH_FAILED")
+        return True
+
+    def send_data(self, data: bytes):
+        _send(self.conn, MSG_DATA, self.engine.seal(data))
+
+    def recv_data(self):
+        t, enc_p = _recv(self.conn)
+        if t == MSG_DATA: return self.engine.unseal(enc_p)
+        return None
+
+    def close(self):
+        self.conn.close()
+
+def runserver(port=8937):
+    def default_logic(engine, conn):
+        t, enc_req = _recv(conn)
+        if t == MSG_DATA:
+            print(f"[>] Request: {engine.unseal(enc_req).decode()}")
+            _send(conn, MSG_DATA, engine.seal(b"CTP_ACK"))
+    
+    srv = CTPServer(port=port)
+    srv.start(default_logic)
+
+def runclient(port=8937):
+    client = CTPClient(port=port)
+    if client.connect():
+        client.send_data(b"HELLO_CTP")
+        print(f"[<] Response: {client.recv_data().decode()}")
+        client.close()

ctp_py-1.5.0/src/ctp_py.egg-info/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: ctp-py
+Version: 1.5.0
+Summary: Crypto Transfer Protocol v1.5
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: cryptography>=42.0.0
+
+# CTP v1.5
+Crypto Transfer Protocol for secure, high-speed data exchange.

ctp_py-1.5.0/src/ctp_py.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+pyproject.toml
+setup.py
+src/ctp/__init__.py
+src/ctp_py.egg-info/PKG-INFO
+src/ctp_py.egg-info/SOURCES.txt
+src/ctp_py.egg-info/dependency_links.txt
+src/ctp_py.egg-info/requires.txt
+src/ctp_py.egg-info/top_level.txt

ctp_py-1.5.0/src/ctp_py.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ctp_py-1.5.0/src/ctp_py.egg-info/requires.txt

@@ -0,0 +1 @@
+cryptography>=42.0.0

ctp_py-1.5.0/src/ctp_py.egg-info/top_level.txt

@@ -0,0 +1 @@
+ctp