Metadata-Version: 2.4
Name: meshvpn
Version: 1.0.1
Summary: Autonomous P2P Mesh VPN Library - create peer-to-peer VPN networks like Radmin VPN
Home-page: https://github.com/meshvpn/meshvpn
Author: MeshVPN
Author-email: meshvpn@protonmail.com
License: MIT
Project-URL: Bug Reports, https://github.com/meshvpn/meshvpn/issues
Project-URL: Source, https://github.com/meshvpn/meshvpn
Keywords: p2p vpn mesh vpn tunnel encryption networking nat hole-punching
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Topic :: System :: Networking
Classifier: Topic :: Security :: Cryptography
Classifier: Topic :: Software Development :: Libraries
Requires-Python: >=3.7
Description-Content-Type: text/markdown
License-File: LICENSE
Requires-Dist: pynacl>=1.5.0
Provides-Extra: dev
Requires-Dist: pytest>=7.0; extra == "dev"
Requires-Dist: twine>=4.0; extra == "dev"
Requires-Dist: build>=0.10; extra == "dev"
Dynamic: author
Dynamic: author-email
Dynamic: classifier
Dynamic: description
Dynamic: description-content-type
Dynamic: home-page
Dynamic: keywords
Dynamic: license
Dynamic: license-file
Dynamic: project-url
Dynamic: provides-extra
Dynamic: requires-dist
Dynamic: requires-python
Dynamic: summary

# MeshVPN — Autonomous P2P Mesh VPN Library

Полностью автономная Python библиотека для создания peer-to-peer mesh VPN сетей.
Работает по принципу **Radmin VPN** — без необходимости установки стороннего ПО.

## Архитектура (как Radmin VPN)

```
┌─────────────────────────────────────────────────────────┐
│                  Ваше приложение                        │
│              (MeshVPN Client API)                       │
├──────────────────┬──────────────────────────────────────┤
│  Криптография    │  Hole Punching    │  Virtual TAP     │
│  NaCl/SecretBox  │  UDP NAT traversal│  User-space/TUN  │
├──────────────────┴───────────────────┴──────────────────┤
│                 Rendezvous Server                       │
│         (Peer Discovery & Coordination)                 │
└─────────────────────────────────────────────────────────┘
         │                    │                    │
    Peer 1 ◄────── P2P UDP ──►│◄──── P2P UDP ─────► Peer 2
         │                    │                    │
         └──── TCP Relay fallback (если P2P не работает)
```

## Быстрый старт

### 1. Запуск rendezvous сервера

```python
from meshvpn import MeshVPNServer, register_server_name

server = MeshVPNServer(port=9877)
server.start()

# Даём серверу буквенное имя
address = register_server_name("myoffice", port=9877)
print(f"Сервер доступен по адресу: {address}")
# Вывод: myoffice.meshvpn:9877
```

Или через CLI:
```bash
python examples/start_server.py
```

### 2. Создание сети

```python
from meshvpn import create_network, get_nodes, get_my_ip, disconnect

# Создаём сеть
network = create_network("MyOfficeLAN", password="secret123")

print(f"Сеть: {network.name}")
print(f"ID: {network.network_id}")  # <- Отправьте это другим!
print(f"Мой IP: {network.virtual_ip}")

input("Нажмите Enter для выхода...")
disconnect()
```

Или через CLI:
```bash
python examples/example_create.py
```

### 3. Подключение к сети

```python
from meshvpn import join_network, get_nodes, disconnect

# Подключаемся по ID
network = join_network(
    network_id="abc123def456",  # ID от создателя
    password="secret123"
)

print(f"Подключён! Мой IP: {network.virtual_ip}")

# Получаем список узлов
nodes = get_nodes()
for node in nodes:
    if node.is_online:
        print(f"  {node.name}: {node.ip_address}")

input("Нажмите Enter для выхода...")
disconnect()
```

Или через CLI:
```bash
python examples/example_join.py abc123def456
```

---

## Буквенные имена серверов

### Зачем?

Вместо запоминания IP-адресов (`192.168.1.100`, `93.184.216.34`) используйте **читаемые имена**:

```
"myoffice.meshvpn"
"home-vpn"
"server-alpha"
```

### Регистрация сервера

```python
from meshvpn import register_server_name, MeshVPNServer

# На сервере
server = MeshVPNServer(port=9877)
server.start()

# Регистрируем буквенное имя
address = register_server_name("myoffice", port=9877)
print(address)  # myoffice.meshvpn
```

### Подключение по имени

```python
from meshvpn import create_network, join_network

# Создатель — по буквенному имени
network = create_network(
    "Office LAN",
    password="secret",
    server_host="myoffice.meshvpn"  # вместо IP
)

# Другой пользователь — подключается по тому же имени
network = join_network(
    network_id="abc123def456",
    password="secret",
    server_host="myoffice"  # .meshvpn можно опустить
)
```

### Резолвинг имени

```python
from meshvpn import resolve_server_name, list_known_servers

# Резолвим имя в IP
result = resolve_server_name("myoffice")
if result:
    host, port = result
    print(f"myoffice.meshvpn -> {host}:{port}")
    # 192.168.1.100:9877

# Список всех известных серверов
servers = list_known_servers()
for s in servers:
    print(f"{s['name']}.meshvpn -> {s['host']}:{s['port']}")
```

### Как это работает

1. `register_server_name()` сохраняет `{name: {host, port}}` в файл `~/.meshvpn_registry.json`
2. `create_network()` / `join_network()` сначала ищут имя в реестре, потом пробуют DNS
3. Поддерживаются три формата:
   - `"myoffice"` — поиск в локальном реестре
   - `"myoffice.meshvpn"` — поиск в реестре (суффикс отбрасывается)
   - `"mesh.example.com"` — DNS резолвинг

---

## Полный API

### Функциональный API (простой)

```python
from meshvpn import (
    create_network,          # Создать сеть
    join_network,            # Подключиться к сети
    disconnect,              # Отключиться
    get_my_ip,               # Получить VPN IP
    get_nodes,               # Список узлов
    resolve_host,            # Резолвить hostname -> IP
    register_server_name,    # Зарегистрировать имя сервера
    resolve_server_name,     # Резолвить имя сервера
    list_known_servers,      # Список известных серверов
)

# Регистрация сервера с именем
register_server_name("myoffice", port=9877)

# Создание сети
network = create_network("Name", "password", server_host="myoffice.meshvpn")

# Подключение по буквенному имени
network = join_network("network_id", "password", server_host="myoffice")

# Информация
print(get_my_ip())
print(get_nodes())

# Выход
disconnect()
```

### Объектно-ориентированный API (продвинутый)

```python
from meshvpn.client import MeshVPNClient
from meshvpn.server import MeshVPNServer, ServerNameRegistry

# Rendezvous сервер
server = MeshVPNServer(port=9877)
server.start()

# Клиент — поддерживает IP, hostname, и буквенные имена
client = MeshVPNClient(
    server_host="myoffice.meshvpn",  # или "192.168.1.100", или "localhost"
    server_port=9877,
    name="MyNode",
)

# Создание сети
network = client.create_network("Office", "secret")

# Или подключение
network = client.join_network("network_id", "secret")

# Отправка данных узлу
client.send_to_node("10.192.1.2", b"Hello!")

# Callback'и
def on_connected(node_info):
    print(f"Узел подключился: {node_info.name}")

def on_data(src_ip, data):
    print(f"[{src_ip}]: {data.decode()}")

client.set_node_connected_callback(on_connected)
client.set_data_received_callback(on_data)

# Выход
client.disconnect()
```

### ServerNameRegistry API

```python
from meshvpn.server import ServerNameRegistry

registry = ServerNameRegistry()

# Зарегистрировать сервер
address = registry.register_local("home-vpn", port=9877)
print(address)  # home-vpn.meshvpn

# Резолвить имя
result = registry.resolve("home-vpn")
if result:
    host, port = result
    print(f"Host: {host}, Port: {port}")

# Список всех серверов
for server in registry.list_servers():
    print(f"{server['name']}.meshvpn -> {server['host']}:{server['port']}")
```

---

## Как это работает (пошагово)

### Создание сети:

```
User 1 (Creator)                 Rendezvous Server
      │                                  │
      │──── CREATE_NETWORK ─────────────►│
      │    (name, password_hash)         │
      │                                  │
      │◄──── OK + assigned_ip ──────────│
      │    network_id=abc123             │
      │                                  │
      │  Сеть создана, ожидает пиров    │
```

### Подключение к сети:

```
User 2 (Joiner)                Rendezvous Server          User 1 (Creator)
      │                                │                          │
      │──── JOIN_NETWORK ─────────────►│                          │
      │    network_id=abc123           │                          │
      │                                │                          │
      │◄─── OK + peers ───────────────│◄──── PEER_UPDATE ────────│
      │    peers=[User1]               │                          │
      │                                │                          │
      │──── HOLE PUNCH ──────────────────────────────────────────►│
      │◄─── HOLE PUNCH ──────────────────────────────────────────│
      │                                │                          │
      │──── HANDSHAKE ──────────────────────────────────────────►│
      │◄─── HANDSHAKE_REPLY ─────────────────────────────────────│
      │                                │                          │
      │◄────────── P2P CONNECTED ───────────────────────────────►│
      │           (encrypted)           │                          │
```

---

## Примеры

| Файл | Описание |
|------|----------|
| `examples/start_server.py` | Запуск rendezvous сервера |
| `examples/example_create.py` | Создание новой сети |
| `examples/example_join.py` | Подключение к сети |
| `examples/example_chat.py` | P2P чат между узлами |
| `messenger_host.py` | Хост мессенджера |
| `messenger_client.py` | Клиент мессенджера |

---

## Установка

```bash
pip install pynacl
```

## Требования

- Python 3.7+
- PyNaCl (libsodium bindings)
- Linux: `tun` module (`sudo modprobe tun`)
- Windows: Wintun driver (опционально)

## Лицензия

MIT
