Metadata-Version: 2.4
Name: meshvpn
Version: 1.0.0
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 Server
Центральный сервер для **координации** пиров. НЕ участвует в передаче данных.
- Регистрирует узлы и их endpoint'ы
- Представляет пиры друг другу
- Координирует UDP hole punching

### 2. UDP Hole Punching (NAT Traversal)
После представления пиры подключаются **напрямую**:
1. Оба пира подключаются к rendezvous серверу
2. Сервер обменивается endpoint'ами
3. Каждый пир шлёт UDP пакеты на внешний endpoint пира
4. Это "пробивает дыру" в NAT
5. Пиры общаются **напрямую** (P2P)

### 3. Шифрование
Весь трафик шифруется:
- **Curve25519** — Diffie-Hellman key exchange
- **XSalsa20-Poly1305** — аутентифицированное шифрование
- Каждая пара пиров имеет уникальную сессию

### 4. Виртуальный адаптер
- **Linux**: TUN устройство (`/dev/net/tun`)
- **Windows**: Wintun или raw socket fallback
- **User-space**: Без драйвера (для тестирования)

## Установка

```bash
pip install pynacl
```

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

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

```python
from meshvpn import MeshVPNServer

server = MeshVPNServer(port=9877)
server.start()
print("Сервер запущен на порту 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
```

## Полный API

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

```python
from meshvpn import (
    create_network,     # Создать сеть
    join_network,       # Подключиться к сети
    disconnect,         # Отключиться
    get_my_ip,          # Получить VPN IP
    get_nodes,          # Список узлов
)

# Создание
network = create_network("Name", "password")

# Подключение
network = join_network("network_id", "password")

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

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

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

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

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

# Клиент
client = MeshVPNClient(
    server_host="127.0.0.1",
    server_port=9877,
    name="MyNode",
)

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

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

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

# Отправка данных узлу
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()
```

### MeshNetwork (высокий уровень)

```python
from meshvpn.network import MeshNetwork

net = MeshNetwork()

# Создать или подключиться
net.create("Office", "secret")
# или
net.join("network_id", "secret")

# Отправка
net.send("10.192.1.2", b"Hello peer!")
net.broadcast(b"Hello everyone!")

# Получение
net.on_message("*", lambda data: print(f"Got: {data}"))
net.on_message("10.192.1.2", lambda data: handle_specific(data))

# Отключение
net.leave()
```

## Примеры

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

## Компоненты библиотеки

### `meshvpn.core.crypto`
```python
from meshvpn.core.crypto import CryptoEngine, Session

crypto = CryptoEngine()
crypto.generate_keys()

# Создание сессии с пиром
session = crypto.create_session(peer_public_key)

# Шифрование
encrypted = session.encrypt(b"Secret data")
decrypted = session.decrypt(encrypted)
```

### `meshvpn.core.packet`
```python
from meshvpn.core.packet import Packet, PacketType, PacketBuilder

# Создание пакета
pkt = Packet(PacketType.DATA, b"node_id", b"payload")
raw = pkt.serialize()

# Парсинг
parsed = Packet.deserialize(raw)

# Builder
builder = PacketBuilder("my_node_id")
pkt = builder.ping()
pkt = builder.handshake(public_key, "10.0.0.1", 9878)
```

### `meshvpn.core.nat`
```python
from meshvpn.core.nat import HolePuncher, NATType

puncher = HolePuncher(local_port=9878)
local_ip, local_port = puncher.start()

# Hole punching к пиру
puncher.connect_to_peer("1.2.3.4", 9878)

# Отправка данных
puncher.send_to_peer("1.2.3.4", 9878, b"data")

# Callback
puncher.set_data_callback(lambda ip, port, data: handle(ip, data))
```

### `meshvpn.core.tap`
```python
from meshvpn.core.tap import create_virtual_adapter, UserSpaceAdapter

# Создание адаптера
tap = create_virtual_adapter("meshvpn0")
tap.create("10.192.1.1", "255.255.0.0")

# Чтение пакетов
tap.set_callback(lambda pkt: route_packet(pkt))
tap.start_reading()

# Отправка
tap.send(b"\x08\x00...")  # Ethernet/IP packet
```

## Принцип работы (пошагово)

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

```
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)           │                          │
```

## Отличия от Radmin VPN

| Функция | Radmin VPN | MeshVPN |
|---------|-----------|---------|
| P2P UDP | ✓ | ✓ |
| NAT Traversal | ✓ | ✓ |
| Шифрование | OpenSSL RSA | NaCl Curve25519 |
| TAP адаптер | Свой драйвер | Wintun/TUN/User-space |
| Rendezvous сервер | Свой (radminte.com) | Встроенный Python |
| GUI | Qt/QML | Нет (только API) |
| Relay fallback | TCP relay | TCP relay |

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

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

## Лицензия

MIT
