# Termux Network Toolkit: Samba + mDNS + SSH

> Actualizado: 2026-03-25

Samba + descubrimiento mDNS + scripts de resolucion DNS para Termux (Android). Compatible con Windows 11, Kubuntu 24 y macOS.

## Instalacion rapida

```bash
git clone https://devops.ingeniumcodex.com/andresgarcia0313/termux-samba.git
cd termux-samba
bash install.sh
```

El instalador:
1. Instala `samba` y `python-zeroconf`
2. Crea directorios de config
3. Copia `smb.conf` y los 4 scripts de red a `~/.local/bin/`
4. Crea usuario Samba (pide usuario y contrasena)
5. Agrega autostart y aliases a `.bashrc`
6. Inicia Samba + mDNS

## Estructura del repo

```
termux-samba/
├── smb.conf              # Config Samba (SMB3, puerto 4450)
├── install.sh            # Instalador automatico
├── bashrc-snippet.sh     # Autostart + aliases para .bashrc
├── .gitignore            # Excluye datos runtime
└── scripts/
    ├── mdns-publish.py   # Publica SSH + SMB via mDNS (Zeroconf)
    ├── mdns-resolve      # Resuelve hostnames .local (multicast UDP)
    ├── ssh-mdns-proxy    # ProxyCommand SSH: mDNS → Tailscale → cache
    └── ssh-fallback      # ProxyCommand SSH: Tailscale → LAN
```

---

## Samba

### Resumen

- **Nombre en red:** MOVIL
- **Puerto:** 4450 (445 requiere root, no disponible en Termux)
- **Protocolo:** SMB2/SMB3 con cifrado y signing
- **Autostart:** Via `.bashrc` al abrir Termux

### Shares

| Share | Ruta | Contenido |
|-------|------|-----------|
| Almacenamiento | `/storage/emulated/0` | Toda la memoria interna Android |
| Termux | `$HOME` | Home de Termux (configs, scripts, desarrollo) |

### Archivos en disco

| Archivo | Proposito |
|---------|-----------|
| `~/.config/samba/smb.conf` | Config principal |
| `~/.config/samba/private/` | Base de datos de usuarios (tdbsam) |
| `~/.config/samba/samba.log` | Log de actividad |

### Parametros de compatibilidad

| Parametro | Valor | Motivo |
|-----------|-------|--------|
| `server min protocol` | SMB2 | Win11 y Kubuntu 24 ya no usan SMB1 |
| `server max protocol` | SMB3 | Maximo rendimiento y cifrado |
| `smb encrypt` | desired | Win11 lo prefiere, negocia automaticamente |
| `server signing` | desired | Win11 lo exige desde 2024 |
| `unix charset` | UTF-8 | Acentos en nombres de archivo |
| `dos charset` | CP850 | Compatibilidad Windows |

---

## Conexion desde otros equipos

### Kubuntu 24 / KDE Dolphin

El dispositivo aparece automaticamente en **Red** del panel lateral como **"movil"** gracias al servicio mDNS `_smb._tcp`.

Acceso manual en barra de direcciones:

```
smb://movil.local:4450/
smb://movil.local:4450/Almacenamiento
```

### Kubuntu 24 / Terminal

```bash
# Descubrir el servicio
avahi-browse -rt _smb._tcp

# Listar shares
smbclient -L movil.local -p 4450 -U andres

# Acceder a un share
smbclient //movil.local/Almacenamiento -p 4450 -U andres

# Montar como filesystem
sudo mount -t cifs //movil.local/Almacenamiento /mnt/movil \
  -o port=4450,username=andres,password=PASS,vers=3.0
```

### Windows 11

Windows no soporta puertos SMB alternativos de forma nativa. Opciones:

**Opcion A - Port proxy (requiere admin):**
```cmd
netsh interface portproxy add v4tov4 listenport=445 listenaddress=127.0.0.1 connectport=4450 connectaddress=IP_MOVIL
net use Z: \\127.0.0.1\Almacenamiento /user:andres
```

**Opcion B - Desde Explorador (algunos builds):**
```
\\IP_MOVIL:4450\Almacenamiento
```

### Android (mismo dispositivo)

Instalar [SambaLite](https://play.google.com/store/apps/details?id=de.schliweb.sambalite) (open source, sin ads).
Conectar a `127.0.0.1:4450` con usuario y contrasena.

---

## Scripts de red (mDNS / DNS)

Todos se instalan en `~/.local/bin/`. Requieren `PATH="$HOME/.local/bin:$PATH"`.

### mdns-publish.py — Publicar servicios en la red

Publica el dispositivo como `movil.local` via mDNS multicast (Zeroconf).

**Servicios publicados:**

| Servicio | Tipo DNS-SD | Puerto |
|----------|------------|--------|
| SSH | `_ssh._tcp.local.` | 8022 |
| Samba | `_smb._tcp.local.` | 4450 |

**Dependencia:** `pip install zeroconf`

**Uso:** Se ejecuta como daemon en background (autostart via `.bashrc`).

**Verificar desde Kubuntu:**
```bash
avahi-browse -rt _smb._tcp
# Debe mostrar: movil → movil.local → IP:4450
```

**Verificar desde Termux:**
```bash
python3 -c "
from zeroconf import Zeroconf, ServiceBrowser
import time
class L:
    def add_service(self, zc, t, n):
        info = zc.get_service_info(t, n)
        if info:
            a = '.'.join(str(b) for b in info.addresses[0])
            print(f'{n} -> {a}:{info.port}')
    def remove_service(self, *a): pass
    def update_service(self, *a): pass
zc = Zeroconf()
ServiceBrowser(zc, '_smb._tcp.local.', L())
ServiceBrowser(zc, '_ssh._tcp.local.', L())
time.sleep(3)
zc.close()
"
```

### mdns-resolve — Resolver hostnames .local

Resuelve hostnames `.local` via multicast UDP puro (sin Avahi, sin dependencias externas).

**Por que existe:** Termux no puede resolver `.local` nativamente (usa su propia libc, no la de Android).

**Uso:**
```bash
# Resolver un hostname
mdns-resolve lenovo-ideapad.local
# Output: 192.168.1.112

# Con timeout personalizado (segundos)
mdns-resolve hp62a.local 5
```

**Como funciona:**
1. Construye query DNS tipo A para el hostname
2. Envia al grupo multicast 224.0.0.251:5353
3. Parsea la respuesta y extrae la IP
4. Exit 0 con IP en stdout, o exit 1 si no resuelve

**Sin dependencias externas** — usa solo stdlib de Python (socket, struct, select).

### ssh-mdns-proxy — ProxyCommand SSH inteligente

ProxyCommand para `~/.ssh/config` que resuelve hostnames con fallback en cascada.

**Cadena de resolucion:**
1. mDNS (via `mdns-resolve`) — red local
2. Tailscale DNS (`*.tailb0bb74.ts.net`) — fuera de LAN
3. Cache local (`~/.ssh/mdns-cache`) — si todo falla

**Aliases soportados:**
- `dell` → `dell-latitude3400`
- `lenovo` → `lenovo-ideapad`

**Uso en `~/.ssh/config`:**
```
Host lenovo-ideapad
    User andres
    ProxyCommand ~/.local/bin/ssh-mdns-proxy %h %p

Host dell
    User andres
    ProxyCommand ~/.local/bin/ssh-mdns-proxy %h %p

Host hp62a
    User andres
    ProxyCommand ~/.local/bin/ssh-mdns-proxy %h %p
```

**Cache:** Guarda la ultima IP resuelta en `~/.ssh/mdns-cache` para reconexion rapida si mDNS y Tailscale fallan.

### ssh-fallback — ProxyCommand Tailscale + LAN

ProxyCommand simple con fallback de Tailscale a IP LAN.

**Cadena de resolucion:**
1. Ping al host Tailscale (1s timeout)
2. Si falla, ping a IP LAN (1s timeout)
3. Si ambos fallan, intenta Tailscale sin verificar

**Uso en `~/.ssh/config`:**
```
Host hp62a
    ProxyCommand ~/.local/bin/ssh-fallback hp62a.tailb0bb74.ts.net 192.168.1.16 %p
```

**Nota:** `ssh-mdns-proxy` es mas completo (mDNS + Tailscale + cache). `ssh-fallback` es mas simple (solo Tailscale + LAN con IPs fijas).

---

## Autostart en .bashrc

Samba y mDNS se inician al abrir Termux. Ver `bashrc-snippet.sh` para el codigo exacto.

No se usa Termux:Boot (no funciona en este dispositivo).

### Aliases de gestion

| Alias | Accion |
|-------|--------|
| `smb-start` | Iniciar Samba |
| `smb-stop` | Detener Samba |
| `smb-restart` | Reiniciar Samba |
| `smb-status` | Ver si esta corriendo |
| `smb-log` | Ver ultimas 50 lineas del log |
| `mdns-status` | Ver si mDNS esta corriendo |
| `mdns-restart` | Reiniciar mDNS |
| `mdns-stop` | Detener mDNS |

---

## Troubleshooting

### "Connection refused" desde otro equipo

1. Verificar que smbd corre: `smb-status`
2. Verificar puerto: `ss -tlnp | grep 4450`
3. Verificar firewall Android: Ajustes WiFi, sin restricciones

### No aparece en Dolphin (Red)

1. Verificar mDNS: `mdns-status`
2. Desde Kubuntu: `avahi-browse -rt _smb._tcp`
3. Si no aparece: `mdns-restart`
4. Acceso manual: `smb://movil.local:4450/`

### "NT_STATUS_LOGON_FAILURE"

```bash
printf 'PASS\nPASS\n' | smbpasswd -L -s -c ~/.config/samba/smb.conf USUARIO
```

### mDNS no resuelve .local en Termux

Termux usa su propia libc, no la de Android. Por eso `.local` no resuelve con `ping` o `getent`. Usar `mdns-resolve` en su lugar:
```bash
mdns-resolve hostname.local
```

### SSH no conecta por nombre

Verificar que `~/.ssh/config` usa `ProxyCommand` con `ssh-mdns-proxy`:
```bash
ssh -v hostname  # Ver que proxy se usa
```