lanmess 1.0.0__py3-none-any.whl

lanmess-1.0.0.dist-info/METADATA

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: lanmess
+Version: 1.0.0
+Summary: LAN-only end-to-end encrypted messenger with a TUI
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Environment :: Console
+Classifier: Topic :: Communications :: Chat
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: textual>=0.52.0
+Requires-Dist: cryptography>=41.0.0
+Dynamic: license-file
+
+# LANMess
+
+LAN-only end-to-end encrypted messenger with a terminal UI.
+
+## Install
+
+pip install lanmess
+
+## Run
+
+lanmess

lanmess-1.0.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+lanmess-1.0.0.dist-info/licenses/LICENSE,sha256=0SJU1dVe5uk0rKC9g3BKPevyAWTYQxcqVtDVW9ORk5Y,1065
+lanmess_files/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lanmess_files/config.py,sha256=rN3aq3EeaUH2WNbi714HTR3ta8OpNUDJBDY_y0ABPcc,514
+lanmess_files/crypto.py,sha256=U2r_PqF7aHa7cc0HxQuA9HgazFNfIWfT6r5oIDWIxEk,2912
+lanmess_files/database.py,sha256=o11khcmcq-BrnoL-y9a5dC10wRV8GkEV1rLAosD2vqA,8224
+lanmess_files/discovery.py,sha256=_4fymXCcD__3KzSR-Zdl6EEHhuWJ_er11rI82cW_F84,3188
+lanmess_files/main.py,sha256=kZne8r-Fvi622aL8GKy4ocZ4Aatx4t5W6B2xtF_-s5E,104
+lanmess_files/network.py,sha256=SFPSjjN3Glge3WxqpXbQxrfQNdFos_U7zn114qz7w_U,2116
+lanmess_files/tui.py,sha256=EP93DpzC3Fqy7K3_xOlIZrztBWxw169seBaMCFKgapc,50138
+lanmess-1.0.0.dist-info/METADATA,sha256=3t7nlEaED4oKKB21INycZEVMDECV7a9rOgxr8Wgjk8w,584
+lanmess-1.0.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+lanmess-1.0.0.dist-info/entry_points.txt,sha256=A94GkXbd8m2nhKKtGrgCUTutqQRl755gMowFuUtUCkM,52
+lanmess-1.0.0.dist-info/top_level.txt,sha256=sp8e6gQbW9akFqA-aLjUfeZQ98q_WB4LWkSJSpti0Fw,14
+lanmess-1.0.0.dist-info/RECORD,,

lanmess-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

lanmess-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+lanmess = lanmess_files.main:main

lanmess-1.0.0.dist-info/licenses/LICENSE

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

lanmess-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+lanmess_files

lanmess_files/config.py

@@ -0,0 +1,23 @@
+from pathlib import Path
+
+APP_NAME = "LANMess"
+APP_VERSION = "1.0.0"
+DISCOVERY_PORT = 50505
+DISCOVERY_INTERVAL = 2.0
+DISCOVERY_TTL = 15.0
+TCP_PORT_RANGE = (50510, 50600)
+LOGIN_CODE_PERIOD = 60
+LOGIN_CODE_DIGITS = 8
+PBKDF2_ITERATIONS = 200_000
+GROUP_SALT = b"lanmess-group-key-v1"
+REQUEST_TIMEOUT = 6.0
+BASE_DIR = Path.home() / ".lanmess"
+DB_PATH = BASE_DIR / "lanmess.db"
+
+
+def ensure_dirs():
+    BASE_DIR.mkdir(parents=True, exist_ok=True)
+    try:
+        BASE_DIR.chmod(0o700)
+    except Exception:
+        pass

lanmess_files/crypto.py

@@ -0,0 +1,113 @@
+import hashlib
+import hmac
+import os
+import struct
+import time
+
+from cryptography.exceptions import InvalidSignature
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric.ed25519 import (
+    Ed25519PrivateKey,
+    Ed25519PublicKey,
+)
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+
+from .config import (
+    GROUP_SALT,
+    LOGIN_CODE_DIGITS,
+    LOGIN_CODE_PERIOD,
+    PBKDF2_ITERATIONS,
+)
+
+
+def derive_group_key(group_code: str) -> bytes:
+    return hashlib.pbkdf2_hmac(
+        "sha256",
+        group_code.encode("utf-8"),
+        GROUP_SALT,
+        PBKDF2_ITERATIONS,
+        32,
+    )
+
+
+def group_key_hash(key: bytes) -> str:
+    return hashlib.sha256(key).hexdigest()
+
+
+def generate_ed25519_private() -> Ed25519PrivateKey:
+    return Ed25519PrivateKey.generate()
+
+
+def ed_private_to_bytes(sk: Ed25519PrivateKey) -> bytes:
+    return sk.private_bytes(
+        encoding=serialization.Encoding.Raw,
+        format=serialization.PrivateFormat.Raw,
+        encryption_algorithm=serialization.NoEncryption(),
+    )
+
+
+def ed_public_to_bytes(pk: Ed25519PublicKey) -> bytes:
+    return pk.public_bytes(
+        encoding=serialization.Encoding.Raw,
+        format=serialization.PublicFormat.Raw,
+    )
+
+
+def ed_private_from_bytes(raw: bytes) -> Ed25519PrivateKey:
+    return Ed25519PrivateKey.from_private_bytes(raw)
+
+
+def ed_public_from_bytes(raw: bytes) -> Ed25519PublicKey:
+    return Ed25519PublicKey.from_public_bytes(raw)
+
+
+def sign_bytes(sk: Ed25519PrivateKey, data: bytes) -> bytes:
+    return sk.sign(data)
+
+
+def verify_bytes(pk: Ed25519PublicKey, sig: bytes, data: bytes) -> bool:
+    try:
+        pk.verify(sig, data)
+        return True
+    except InvalidSignature:
+        return False
+
+
+def encrypt_aes(key: bytes, plaintext: bytes, aad: bytes = b""):
+    nonce = os.urandom(12)
+    ct = AESGCM(key).encrypt(nonce, plaintext, aad)
+    return nonce, ct
+
+
+def decrypt_aes(key: bytes, nonce: bytes, ct: bytes, aad: bytes = b"") -> bytes:
+    return AESGCM(key).decrypt(nonce, ct, aad)
+
+
+def generate_totp_secret() -> bytes:
+    return os.urandom(20)
+
+
+def compute_totp(secret: bytes, offset: int = 0) -> str:
+    counter = int(time.time() // LOGIN_CODE_PERIOD) + offset
+    msg = struct.pack(">Q", counter)
+    digest = hmac.new(secret, msg, hashlib.sha256).digest()
+    off = digest[-1] & 0x0F
+    code = (
+        struct.unpack(">I", digest[off:off + 4])[0] & 0x7FFFFFFF
+    ) % (10 ** LOGIN_CODE_DIGITS)
+    return f"{code:0{LOGIN_CODE_DIGITS}d}"
+
+
+def verify_totp(secret: bytes, code: str) -> bool:
+    for offset in (0, -1):
+        if hmac.compare_digest(compute_totp(secret, offset), code):
+            return True
+    return False
+
+
+def totp_remaining() -> int:
+    return LOGIN_CODE_PERIOD - int(time.time() % LOGIN_CODE_PERIOD)
+
+
+def code_tag(code: str) -> str:
+    return hashlib.sha256(code.encode("utf-8")).hexdigest()[:16]

lanmess_files/database.py

@@ -0,0 +1,237 @@
+import sqlite3
+import threading
+import time
+
+
+class Database:
+    def __init__(self, path):
+        self.path = str(path)
+        self.lock = threading.RLock()
+        self.conn = sqlite3.connect(self.path, check_same_thread=False)
+        self.conn.row_factory = sqlite3.Row
+        try:
+            self.conn.execute("PRAGMA journal_mode=WAL")
+            self.conn.execute("PRAGMA synchronous=NORMAL")
+            self.conn.execute("PRAGMA secure_delete=ON")
+        except Exception:
+            pass
+        self._init()
+
+    def _init(self):
+        with self.lock:
+            self.conn.executescript(
+                """
+                CREATE TABLE IF NOT EXISTS identity (
+                    id INTEGER PRIMARY KEY CHECK (id = 1),
+                    name TEXT NOT NULL,
+                    group_key_hash TEXT NOT NULL,
+                    ed_private_hex TEXT NOT NULL,
+                    ed_public_hex TEXT NOT NULL,
+                    totp_secret_hex TEXT NOT NULL,
+                    tcp_port INTEGER NOT NULL
+                );
+                CREATE TABLE IF NOT EXISTS contacts (
+                    name TEXT PRIMARY KEY,
+                    ip TEXT,
+                    port INTEGER,
+                    ed_public_hex TEXT NOT NULL,
+                    chat_started INTEGER NOT NULL DEFAULT 0,
+                    incoming_request INTEGER NOT NULL DEFAULT 0,
+                    blocked INTEGER NOT NULL DEFAULT 0,
+                    pending INTEGER NOT NULL DEFAULT 0,
+                    clear_pending INTEGER NOT NULL DEFAULT 0,
+                    added_at REAL NOT NULL
+                );
+                CREATE TABLE IF NOT EXISTS messages (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    contact_name TEXT NOT NULL,
+                    direction TEXT NOT NULL,
+                    content TEXT NOT NULL,
+                    timestamp REAL NOT NULL
+                );
+                """
+            )
+            try:
+                self.conn.execute(
+                    "ALTER TABLE contacts ADD COLUMN pending INTEGER NOT NULL DEFAULT 0"
+                )
+            except sqlite3.OperationalError:
+                pass
+            try:
+                self.conn.execute(
+                    "ALTER TABLE contacts ADD COLUMN clear_pending INTEGER NOT NULL DEFAULT 0"
+                )
+            except sqlite3.OperationalError:
+                pass
+            self.conn.commit()
+
+    def get_identity(self):
+        with self.lock:
+            row = self.conn.execute("SELECT * FROM identity WHERE id = 1").fetchone()
+            return dict(row) if row else None
+
+    def create_identity(
+        self,
+        name,
+        group_key_hash,
+        ed_private_hex,
+        ed_public_hex,
+        totp_secret_hex,
+        tcp_port,
+    ):
+        with self.lock:
+            self.conn.execute(
+                "INSERT OR REPLACE INTO identity "
+                "(id, name, group_key_hash, ed_private_hex, ed_public_hex, "
+                "totp_secret_hex, tcp_port) VALUES (1, ?, ?, ?, ?, ?, ?)",
+                (
+                    name,
+                    group_key_hash,
+                    ed_private_hex,
+                    ed_public_hex,
+                    totp_secret_hex,
+                    tcp_port,
+                ),
+            )
+            self.conn.commit()
+
+    def update_tcp_port(self, port):
+        with self.lock:
+            self.conn.execute("UPDATE identity SET tcp_port = ? WHERE id = 1", (port,))
+            self.conn.commit()
+
+    def get_contacts(self):
+        with self.lock:
+            rows = self.conn.execute(
+                "SELECT * FROM contacts ORDER BY name"
+            ).fetchall()
+            return [dict(r) for r in rows]
+
+    def get_contact(self, name):
+        with self.lock:
+            row = self.conn.execute(
+                "SELECT * FROM contacts WHERE name = ?", (name,)
+            ).fetchone()
+            return dict(row) if row else None
+
+    def upsert_contact(self, name, ip, port, ed_public_hex):
+        with self.lock:
+            existing = self.conn.execute(
+                "SELECT name FROM contacts WHERE name = ?", (name,)
+            ).fetchone()
+            if existing:
+                self.conn.execute(
+                    "UPDATE contacts SET ip=?, port=?, ed_public_hex=?, added_at=? "
+                    "WHERE name=?",
+                    (ip, port, ed_public_hex, time.time(), name),
+                )
+            else:
+                self.conn.execute(
+                    "INSERT INTO contacts "
+                    "(name, ip, port, ed_public_hex, chat_started, "
+                    "incoming_request, blocked, added_at) "
+                    "VALUES (?, ?, ?, ?, 0, 0, 0, ?)",
+                    (name, ip, port, ed_public_hex, time.time()),
+                )
+            self.conn.commit()
+
+    def set_contact_state(
+        self,
+        name,
+        chat_started=None,
+        incoming_request=None,
+        blocked=None,
+        pending=None,
+        clear_pending=None,
+        ip=None,
+        port=None,
+    ):
+        with self.lock:
+            fields = []
+            values = []
+            if chat_started is not None:
+                fields.append("chat_started=?")
+                values.append(int(chat_started))
+            if incoming_request is not None:
+                fields.append("incoming_request=?")
+                values.append(int(incoming_request))
+            if blocked is not None:
+                fields.append("blocked=?")
+                values.append(int(blocked))
+            if pending is not None:
+                fields.append("pending=?")
+                values.append(int(pending))
+            if clear_pending is not None:
+                fields.append("clear_pending=?")
+                values.append(int(clear_pending))
+            if ip is not None:
+                fields.append("ip=?")
+                values.append(ip)
+            if port is not None:
+                fields.append("port=?")
+                values.append(port)
+            if not fields:
+                return
+            values.append(name)
+            self.conn.execute(
+                f"UPDATE contacts SET {', '.join(fields)} WHERE name=?", values
+            )
+            self.conn.commit()
+
+    def add_message(self, contact_name, direction, content):
+        with self.lock:
+            self.conn.execute(
+                "INSERT INTO messages (contact_name, direction, content, timestamp) "
+                "VALUES (?, ?, ?, ?)",
+                (contact_name, direction, content, time.time()),
+            )
+            self.conn.commit()
+
+    def get_messages(self, contact_name, limit=500):
+        with self.lock:
+            rows = self.conn.execute(
+                "SELECT * FROM messages WHERE contact_name = ? "
+                "ORDER BY id DESC LIMIT ?",
+                (contact_name, limit),
+            ).fetchall()
+            return [dict(r) for r in reversed(rows)]
+
+    def clear_messages(self, contact_name):
+        with self.lock:
+            self.conn.execute(
+                "DELETE FROM messages WHERE contact_name = ?", (contact_name,)
+            )
+            self.conn.commit()
+
+    def delete_message(self, message_id):
+        with self.lock:
+            self.conn.execute("DELETE FROM messages WHERE id = ?", (message_id,))
+            self.conn.commit()
+
+    def delete_contact(self, contact_name):
+        with self.lock:
+            self.conn.execute(
+                "DELETE FROM contacts WHERE name = ?", (contact_name,)
+            )
+            self.conn.execute(
+                "DELETE FROM messages WHERE contact_name = ?", (contact_name,)
+            )
+            self.conn.commit()
+
+    def reset_all(self):
+        with self.lock:
+            self.conn.execute("DELETE FROM messages")
+            self.conn.execute("DELETE FROM contacts")
+            self.conn.execute("DELETE FROM identity")
+            self.conn.commit()
+            try:
+                self.conn.execute("VACUUM")
+            except Exception:
+                pass
+
+    def close(self):
+        with self.lock:
+            try:
+                self.conn.close()
+            except Exception:
+                pass

lanmess_files/discovery.py

@@ -0,0 +1,107 @@
+import asyncio
+import json
+import socket
+import time
+
+from .config import (
+    DISCOVERY_INTERVAL,
+    DISCOVERY_PORT,
+    DISCOVERY_TTL,
+)
+
+
+class _Protocol(asyncio.DatagramProtocol):
+    def __init__(self, on_packet):
+        self.on_packet = on_packet
+
+    def datagram_received(self, data, addr):
+        try:
+            msg = json.loads(data.decode("utf-8"))
+        except Exception:
+            return
+        if not isinstance(msg, dict):
+            return
+        if msg.get("app") != "lanmess":
+            return
+        try:
+            self.on_packet(addr[0], msg)
+        except Exception:
+            pass
+
+
+class Discovery:
+    def __init__(self):
+        self.peers = {}
+        self.transport = None
+
+    async def start(self):
+        loop = asyncio.get_running_loop()
+        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        try:
+            sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
+        except Exception:
+            pass
+        try:
+            sock.bind(("", DISCOVERY_PORT))
+        except Exception:
+            sock.bind(("", 0))
+        sock.setblocking(False)
+        self.transport, _ = await loop.create_datagram_endpoint(
+            lambda: _Protocol(self._on_packet), sock=sock
+        )
+
+    def _on_packet(self, ip, msg):
+        name = msg.get("name")
+        if not isinstance(name, str) or not name:
+            return
+        tcp_port = msg.get("tcp_port")
+        if not isinstance(tcp_port, int) or tcp_port <= 0:
+            return
+        self.peers[name] = {
+            "ip": ip,
+            "tcp_port": tcp_port,
+            "code_tag": str(msg.get("code_tag", "")),
+            "last_seen": time.time(),
+        }
+
+    def get_live_peers(self):
+        now = time.time()
+        return {
+            n: i
+            for n, i in self.peers.items()
+            if now - i["last_seen"] < DISCOVERY_TTL
+        }
+
+    def find_by_name(self, name):
+        return self.get_live_peers().get(name)
+
+    def find_by_code_tag(self, tag, exclude_name=None):
+        for name, info in self.get_live_peers().items():
+            if name == exclude_name:
+                continue
+            if info["code_tag"] == tag:
+                return name, info
+        return None, None
+
+    async def broadcaster(self, name, tcp_port, get_code_tag):
+        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+        sock.setblocking(False)
+        while True:
+            try:
+                tag = get_code_tag()
+                payload = json.dumps(
+                    {
+                        "app": "lanmess",
+                        "version": 1,
+                        "name": name,
+                        "tcp_port": tcp_port,
+                        "code_tag": tag,
+                    }
+                ).encode("utf-8")
+                sock.sendto(payload, ("255.255.255.255", DISCOVERY_PORT))
+                sock.sendto(payload, ("127.0.0.1", DISCOVERY_PORT))
+            except Exception:
+                pass
+            await asyncio.sleep(DISCOVERY_INTERVAL)

lanmess_files/main.py

@@ -0,0 +1,9 @@
+from .tui import LanMessApp
+
+
+def main():
+    LanMessApp().run()
+
+
+if __name__ == "__main__":
+    main()

lanmess_files/network.py

@@ -0,0 +1,76 @@
+import asyncio
+import json
+
+from .config import REQUEST_TIMEOUT
+
+
+async def send_request(ip, port, payload, timeout=REQUEST_TIMEOUT):
+    try:
+        reader, writer = await asyncio.wait_for(
+            asyncio.open_connection(ip, port), timeout=timeout
+        )
+    except Exception:
+        return None
+    try:
+        writer.write((json.dumps(payload) + "\n").encode("utf-8"))
+        await writer.drain()
+        line = await asyncio.wait_for(reader.readline(), timeout=timeout)
+        if not line:
+            return None
+        try:
+            return json.loads(line.decode("utf-8"))
+        except Exception:
+            return None
+    except Exception:
+        return None
+    finally:
+        try:
+            writer.close()
+            await writer.wait_closed()
+        except Exception:
+            pass
+
+
+class Server:
+    def __init__(self, port, handler):
+        self.port = port
+        self.handler = handler
+        self.server = None
+
+    async def start(self):
+        self.server = await asyncio.start_server(
+            self._client, "0.0.0.0", self.port
+        )
+
+    async def _client(self, reader, writer):
+        try:
+            line = await asyncio.wait_for(reader.readline(), timeout=10.0)
+            if not line:
+                return
+            try:
+                msg = json.loads(line.decode("utf-8"))
+            except Exception:
+                return
+            peer = writer.get_extra_info("peername")
+            if peer:
+                msg["_peer_ip"] = peer[0]
+            resp = await self.handler(msg)
+            if resp is not None:
+                writer.write((json.dumps(resp) + "\n").encode("utf-8"))
+                await writer.drain()
+        except Exception:
+            pass
+        finally:
+            try:
+                writer.close()
+                await writer.wait_closed()
+            except Exception:
+                pass
+
+    async def stop(self):
+        if self.server is not None:
+            self.server.close()
+            try:
+                await self.server.wait_closed()
+            except Exception:
+                pass