SSH Connections

Connect to remote servers with SSH, Telnet, Mosh, and serial protocols with advanced authentication and proxy support

Netcatty supports multiple connection protocols to access remote systems, from standard SSH to legacy Telnet and specialized serial connections for network equipment.

Supported Protocols

Netcatty provides first-class support for multiple connection types:

SSH

Industry-standard secure shell protocol with full feature support including key authentication, agent forwarding, and port forwarding.

Telnet

Legacy protocol for older systems and network equipment that don’t support SSH.

Telnet transmits data in plain text. Only use on trusted networks.

Mosh

Mobile Shell for roaming and intermittent connectivity, perfect for laptops and mobile devices.

Serial

Direct serial port connections for console access to routers, switches, and embedded devices.

Local Terminal

Launch local shell sessions (bash, zsh, PowerShell) without remote connection.

SSH Connections

Basic Configuration

Configure SSH connection parameters in the host form:

hostname · string · required

Server hostname or IP address (e.g., web.example.com or 192.168.1.100)

port · number · default: "22"

SSH port number. Standard is 22, but many servers use custom ports for security.

username · string · required

Username for authentication on the remote system

protocol · string · default: "ssh"

Connection protocol. Set to "ssh" for SSH connections.

Authentication Methods

SSH supports multiple authentication methods:

SSH Key

Recommended method using public-key cryptography:

{
  "authMethod": "key",
  "identityFileId": "key-uuid-here"
}

1. Generate or import an SSH key in the Keychain Manager
2. Copy the public key to the server (~/.ssh/authorized_keys)
3. Select the key in the host configuration

ED25519 keys are recommended for best security and performance. Netcatty can generate these for you.

Password

Simple password authentication:

{
  "authMethod": "password",
  "password": "your-password",
  "savePassword": true
}

Passwords are stored in the system keychain, but SSH keys are more secure for production systems.

Certificate

SSH certificate-based authentication:

{
  "authMethod": "certificate",
  "identityFileId": "cert-uuid-here"
}

Certificates include both the private key and certificate signed by a CA.

SSH Agent Forwarding

Enable agent forwarding to use your local SSH keys on the remote server:

{
  "agentForwarding": true
}

Use cases:

• Git operations on remote servers using your local SSH keys
• Jumping through bastion hosts without copying keys
• Running Ansible or deployment scripts

Only enable agent forwarding for trusted servers. Compromised servers could abuse forwarded credentials.

Multi-Protocol Support

A single host can support multiple protocols simultaneously. Configure additional protocols in the protocols array:

{
  "label": "Router-01",
  "hostname": "192.168.1.1",
  "protocol": "ssh",
  "port": 22,
  "username": "admin",
  "protocols": [
    {
      "protocol": "ssh",
      "port": 22,
      "enabled": true
    },
    {
      "protocol": "telnet",
      "port": 23,
      "enabled": true
    }
  ]
}

Switch between protocols:

1. Right-click the host in the vault
2. Select Connect with → Choose protocol
3. Netcatty opens a session using the selected protocol

Telnet Connections

For legacy systems and network equipment:

telnetEnabled · boolean · default: "false"

Enable Telnet protocol for this host

telnetPort · number · default: "23"

Telnet port (standard is 23)

telnetUsername · string

Username for Telnet login (if different from SSH username)

telnetPassword · string

Password for Telnet authentication

Security Notice: Telnet transmits all data, including passwords, in plain text. Only use Telnet:

• On isolated management networks
• For local/direct connections
• With legacy equipment that doesn’t support SSH

Mosh Connections

Mosh (Mobile Shell) is designed for mobile and intermittent connections:

moshEnabled · boolean · default: "false"

Enable Mosh protocol support

moshServerPath · string

Custom path to mosh-server binary on remote host (optional)

Requirements

1. Install Mosh on Server

   Install mosh package on the remote server:

   Ubuntu/Debian

   sudo apt install mosh
   

   CentOS/RHEL

   sudo yum install mosh
   

   macOS

   brew install mosh
   
2. Configure Firewall

   Mosh uses UDP ports 60000-61000. Ensure these are open:

   sudo ufw allow 60000:61000/udp
   
3. Enable in Netcatty

   Check Enable Mosh in the host configuration. Netcatty will use Mosh for connections when available.

Benefits

• Roaming support: Survives network changes (WiFi to cellular)
• Instant typing: Local echo reduces latency
• Resilient: Handles intermittent connectivity gracefully

Connection Features

Startup Commands

Automatically run commands after connection:

{
  "startupCommand": "cd /var/www && source venv/bin/activate"
}

Use cases:

• Change to project directory
• Activate virtual environments
• Source environment files
• Load tmux/screen sessions

Environment Variables

Set custom environment variables for the session:

{
  "environmentVariables": [
    { "name": "EDITOR", "value": "vim" },
    { "name": "PROJECT_ENV", "value": "production" }
  ]
}

Character Encoding

Configure character set for proper text display:

{
  "charset": "utf-8"
}

Supported encodings: utf-8, iso-8859-1, windows-1252, gbk, big5, and more.

Proxy and Jump Hosts

Connect through intermediate servers:

Jump Hosts

Use SSH bastion hosts:

{
  "hostChain": {
    "hostIds": ["bastion-id", "target-host-id"]
  }
}

Netcatty establishes connections in sequence: Local → Bastion → Target.

See Jump Hosts Integration for details.

HTTP/SOCKS Proxy

Connect through HTTP or SOCKS5 proxies:

{
  "proxyConfig": {
    "type": "socks5",
    "host": "proxy.example.com",
    "port": 1080,
    "username": "proxyuser",
    "password": "proxypass"
  }
}

Supported proxy types:

• http: HTTP CONNECT proxy
• socks5: SOCKS5 proxy with optional authentication

Legacy Algorithm Support

For older SSH servers (network equipment, legacy systems), enable legacy algorithms:

{
  "legacyAlgorithms": true
}

This enables older key exchange, cipher, and MAC algorithms that are disabled by default in modern SSH implementations.

Legacy algorithms are less secure. Only enable for equipment that requires them, and prefer upgrading firmware when possible.

See Legacy Algorithms for full details.

Connection Monitoring

Session Logs

Netcatty logs all connection events for troubleshooting:

• Connection attempts and results
• Authentication method used
• Disconnect reasons
• Error messages

Access logs: Settings → Logs → Connection Logs

Connection Status

The terminal tab shows connection status:

Indicator	Status
🟢 Green	Connected and active
🟡 Yellow	Connecting or reconnecting
🔴 Red	Disconnected or failed

Troubleshooting

Connection Refused

Cause: SSH service not running or firewall blocking connection.

Solutions:

• Verify SSH service is running: sudo systemctl status sshd
• Check firewall allows SSH: sudo ufw status
• Test connectivity: nc -zv hostname 22

Authentication Failed

Cause: Wrong credentials or SSH key not authorized.

Solutions:

• Verify username and password
• Check SSH key is added to ~/.ssh/authorized_keys on server
• Ensure correct key permissions: chmod 600 ~/.ssh/id_ed25519
• Check server logs: sudo tail /var/log/auth.log

Connection Timeout

Cause: Network issue, firewall, or wrong IP/hostname.

Solutions:

• Ping the server: ping hostname
• Check DNS resolution: nslookup hostname
• Verify SSH port is correct
• Check for network/VPN issues

Algorithm Negotiation Failed

Cause: Server uses legacy SSH algorithms not supported by modern clients.

Solution: Enable Legacy Algorithms in host configuration.

For more troubleshooting help, see Troubleshooting Guide.

Related Topics

Authentication Methods

Detailed guide to SSH keys, passwords, and certificates

Jump Hosts

Configure bastion hosts and proxy chains

Serial Connections

Connect to console ports on network equipment

Port Forwarding

Tunnel traffic through SSH connections