lanmess 1.0.0__tar.gz

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

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

@@ -0,0 +1,11 @@
+# LANMess
+
+LAN-only end-to-end encrypted messenger with a terminal UI.
+
+## Install
+
+pip install lanmess
+
+## Run
+
+lanmess

lanmess-1.0.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "lanmess"
+version = "1.0.0"
+description = "LAN-only end-to-end encrypted messenger with a TUI"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.9"
+
+dependencies = [
+    "textual>=0.52.0",
+    "cryptography>=41.0.0",
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Environment :: Console",
+    "Topic :: Communications :: Chat",
+]
+
+[project.scripts]
+lanmess = "lanmess_files.main:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

lanmess-1.0.0/setup.cfg

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

lanmess-1.0.0/src/lanmess.egg-info/PKG-INFO

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

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+pyproject.toml
+src/lanmess.egg-info/PKG-INFO
+src/lanmess.egg-info/SOURCES.txt
+src/lanmess.egg-info/dependency_links.txt
+src/lanmess.egg-info/entry_points.txt
+src/lanmess.egg-info/requires.txt
+src/lanmess.egg-info/top_level.txt
+src/lanmess_files/__init__.py
+src/lanmess_files/config.py
+src/lanmess_files/crypto.py
+src/lanmess_files/database.py
+src/lanmess_files/discovery.py
+src/lanmess_files/main.py
+src/lanmess_files/network.py
+src/lanmess_files/tui.py

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

@@ -0,0 +1 @@
+

lanmess-1.0.0/src/lanmess.egg-info/entry_points.txt

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

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

@@ -0,0 +1,2 @@
+textual>=0.52.0
+cryptography>=41.0.0

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

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

lanmess-1.0.0/src/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-1.0.0/src/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-1.0.0/src/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-1.0.0/src/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-1.0.0/src/lanmess_files/main.py

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