Skip to main content

Import from SecureCRT

Complete guide to import your SecureCRT sessions into Xermius.

Overview​

SecureCRT is a popular enterprise SSH client that stores sessions in INI format files. Xermius can import these session files directly.

What Gets Imported:

  • ✅ Session names → Host names
  • ✅ Hostname/IP addresses
  • ✅ Port numbers
  • ✅ Usernames
  • ✅ Description field → Group
  • ✅ SSH2 protocol sessions
  • ❌ Passwords (encrypted in SecureCRT)
  • ❌ SSH keys (will need re-configure)
  • ❌ Terminal colors/fonts
  • ❌ Port forwarding rules
  • ❌ Firewall settings

Note: Only SSH2 protocol sessions are imported. Telnet, serial, and other protocols are skipped.

SecureCRT Session Format​

INI File Structure​

[Session]
SessionName=production-web
Description=Production Web Server
Protocol=SSH2
Host=192.168.1.100
Port=22
Username=admin
Emulation=Xterm

[Session]
SessionName=staging-server
Description=Staging Environment
Protocol=SSH2
Host=staging.example.com
Port=2222
Username=ubuntu
Emulation=Xterm

[Session]
SessionName=database-server
Description=MySQL Database
Protocol=SSH2
Host=db.example.com
Port=3306
Username=dbadmin
Emulation=Xterm

Key Fields​

SecureCRT FieldXermius FieldNotes
SessionNameHost NameDirect mapping
Host/HostnameHost AddressIP or hostname
PortPortDefault: 22
UsernameUsernameSSH username
DescriptionGroupBecomes group name
ProtocolFilterOnly SSH2 imported

Export from SecureCRT​

Locate Session Files​

Windows:

C:\Users\YourUsername\AppData\Roaming\VanDyke\Config\Sessions\

macOS:

~/Library/Application Support/VanDyke/SecureCRT/Config/Sessions/

Linux:

~/.vandyke/SecureCRT/Config/Sessions/

Session File Types​

SecureCRT stores sessions as:

  1. Individual .ini files - One per session

    production-web.ini
    staging-server.ini
    database-server.ini

  2. Folders with subfolders - Organized structure

    Sessions/
    ├── Production/
    │   ├── web-server.ini
    │   └── database.ini
    ├── Staging/
    │   └── staging-server.ini
    └── Development/
        └── dev-server.ini

Option 1: Export Single File​

Manually combine sessions:

  1. Open each session .ini file
  2. Copy all [Session] blocks
  3. Paste into one combined file
  4. Save as securecrt-sessions.ini

Example combined file:

[Session]
SessionName=prod-web
Protocol=SSH2
Host=192.168.1.100
Port=22
Username=admin
Description=Production

[Session]
SessionName=stag-web
Protocol=SSH2
Host=192.168.1.101
Port=22
Username=admin
Description=Staging

Option 2: Export via Script​

PowerShell script (Windows):

$sessionsPath = "$env:APPDATA\VanDyke\Config\Sessions"
$outputFile = "$HOME\Desktop\securecrt-sessions.ini"

Get-ChildItem -Path $sessionsPath -Filter *.ini -Recurse | 
    Get-Content | 
    Out-File -FilePath $outputFile

Write-Host "Exported to: $outputFile"

Bash script (Linux/macOS):

#!/bin/bash
SESSIONS_PATH=~/.vandyke/SecureCRT/Config/Sessions
OUTPUT_FILE=~/Desktop/securecrt-sessions.ini

find "$SESSIONS_PATH" -name "*.ini" -exec cat {} \; > "$OUTPUT_FILE"

echo "Exported to: $OUTPUT_FILE"

Import to Xermius​

Step 1: Prepare Session File​

Ensure your file has valid [Session] blocks with SSH2 protocol.

Step 2: Open Import Dialog​

  1. Open Xermius
  2. Click NEW HOST dropdown
  3. Select Import Hosts
  4. Click SecureCRT tab

Step 3: Select File​

  1. Click Browse File
  2. Navigate to your session file
  3. Select the .ini file
  4. Click Open

Step 4: Preview & Confirm​

┌──────────────────────────────────────────────┐
│ Import Preview                               │
├──────────────────────────────────────────────┤
│ Found 8 SecureCRT sessions                   │
│                                              │
│ ✓ production-web                             │
│   admin@192.168.1.100:22                     │
│   Group: Production                          │
│                                              │
│ ✓ staging-server                             │
│   ubuntu@staging.example.com:2222            │
│   Group: Staging Environment                 │
│                                              │
│ ✓ database-server                            │
│   dbadmin@db.example.com:3306                │
│   Group: MySQL Database                      │
│                                              │
│ ... 5 more                                   │
├──────────────────────────────────────────────┤
│        [Cancel]            [Import 8]        │
└──────────────────────────────────────────────┘
  1. Review sessions
  2. Notice Description → Group mapping
  3. Click Import

Step 5: Complete Import​

✓ Successfully imported 8 hosts from SecureCRT
  - 8 new hosts added
  - 3 groups created (Production, Staging, MySQL Database)
  - 0 duplicates skipped

Your SecureCRT sessions are now in Xermius!

Configuration Mapping​

What Transfers Automatically​

SecureCRTXermiusExample
Session NameHost Nameproduction-web
Host/HostnameHost Address192.168.1.100
PortPort22 (or custom)
UsernameUsernameadmin
DescriptionGroupProduction Web
Protocol SSH2Imported✓
Protocol TelnetSkipped✗

What Needs Manual Setup​

Passwords:

  • SecureCRT encrypts passwords with master password
  • Cannot be exported
  • Add manually or use SSH keys

SSH Keys:

  • SecureCRT uses its own key storage
  • Export keys if possible
  • Import to Xermius keychain

Terminal Settings:

  • Colors, fonts, cursor style
  • Configure in Xermius Settings

Port Forwarding:

  • Not included in session files
  • Recreate in Xermius

Firewall/Proxy:

  • Not transferred
  • Configure separately if needed

Post-Import Tasks​

1. Verify Imported Hosts​

Check dashboard:
- All expected hosts present?
- Names correct?
- Groups organized well?

If not:
- Re-check session file format
- Verify Protocol=SSH2 in each session

2. Reorganize Groups​

Description field may create many groups:

Before (from descriptions):

├── Production Web Server
├── Production Database
├── Staging Environment  
├── MySQL Database
└── Development Server

After (cleaned up):

├── Production
│   ├── Web Server
│   └── Database
├── Staging
│   └── Environment
└── Development
    └── Server

How to reorganize:

  1. Select hosts
  2. Right-click → Edit
  3. Change group
  4. Use nested groups: Production/Web

3. Configure Authentication​

For each host:

Option A: Password Auth

  1. Right-click host → Edit
  2. Enter password
  3. Save

Option B: SSH Key (Recommended)

  1. SSH Keys tab → Import Key
  2. Select key file
  3. Edit host
  4. Select imported key
  5. Save

4. Import SSH Keys​

If you used keys in SecureCRT:

Locate keys:

  • Windows: C:\Users\YourUsername\.ssh\
  • macOS/Linux: ~/.ssh/

Import to Xermius:

  1. SSH Keys tab
  2. Click Import Key
  3. Select key files
  4. Assign to hosts

5. Recreate Port Forwarding​

If you used port forwarding in SecureCRT:

  1. Document your forwarding rules
  2. For each host in Xermius:
    • Right-click → Port Forwarding
    • Add Local/Remote/Dynamic forwards
    • Save

6. Test Connections​

1. Start with one host per group
2. Click Connect
3. Enter password (if prompted)
4. Verify connection works
5. Test SFTP, port forwarding if used

Advanced Migration​

Preserving Folder Structure​

If SecureCRT sessions are in folders:

SecureCRT:

Sessions/
├── Clients/
│   ├── ClientA/
│   │   └── web-server.ini
│   └── ClientB/
│       └── database.ini
└── Internal/
    └── dev-server.ini

Import with folder names:

Create combined file with folder paths in Description:

[Session]
SessionName=clienta-web
Description=Clients/ClientA
Protocol=SSH2
Host=192.168.1.100
Port=22
Username=admin

[Session]
SessionName=clientb-db
Description=Clients/ClientB
Protocol=SSH2
Host=192.168.1.101
Port=3306
Username=dbadmin

Result in Xermius:

├── Clients
│   ├── ClientA
│   │   └── clienta-web
│   └── ClientB
│       └── clientb-db
└── Internal
    └── dev-server

Batch Processing Multiple Files​

Python script:

import os
import glob

sessions_dir = os.path.expanduser("~/.vandyke/SecureCRT/Config/Sessions")
output_file = os.path.expanduser("~/Desktop/all-sessions.ini")

with open(output_file, 'w') as outfile:
    for ini_file in glob.glob(f"{sessions_dir}/**/*.ini", recursive=True):
        with open(ini_file, 'r') as infile:
            outfile.write(infile.read())
            outfile.write('\n\n')

print(f"Combined {len(glob.glob(f'{sessions_dir}/**/*.ini', recursive=True))} files")
print(f"Output: {output_file}")

Run: python3 combine-sessions.py

Troubleshooting​

No Sessions Found​

Problem: Import shows "No valid hosts found"

Solution:

  • Check file has [Session] headers
  • Verify Protocol=SSH2 (not Telnet, Serial, etc.)
  • Ensure Host/Hostname field exists
  • Check file is actually .ini format

Missing Hostnames​

Problem: Some sessions not imported

Solution:

  • Open session file
  • Check if Host or Hostname field exists
  • Sessions without hostname are skipped
  • Add hostname manually in SecureCRT, re-export

Wrong Protocol Sessions​

Problem: Telnet/Serial sessions skipped

Solution:

  • Only SSH2 protocol imported
  • This is intentional (Xermius is SSH-only)
  • Convert Telnet to SSH if possible
  • Or use SecureCRT for non-SSH

Special Characters in Names​

Problem: Session names with spaces/special chars

Solution:

  • Xermius handles most characters
  • If issues, rename in SecureCRT before export
  • Or rename after import in Xermius

Large Number of Sessions​

Problem: Have 100+ sessions, import slow

Solution:

  • Import in batches (25-50 at a time)
  • Split by folder/client
  • Test small batch first
  • Import rest if successful

Enterprise Tips​

Team Migration​

Scenario: Migrate 50 users from SecureCRT to Xermius

Approach:

1. Create standard session export script
2. Run on each user's machine
3. Collect all session files
4. Distribute import guide to team
5. Each user imports their sessions
6. IT provides SSH keys centrally
7. Users assign keys to hosts

Session Templates​

Create standard templates:

[Session]
SessionName=TEMPLATE-web
Description=Production/Web
Protocol=SSH2
Host=CHANGEME
Port=22
Username=admin
Emulation=Xterm

[Session]
SessionName=TEMPLATE-db
Description=Production/Database
Protocol=SSH2
Host=CHANGEME
Port=3306
Username=dbadmin
Emulation=Xterm

Distribute to team, they fill in hostnames.

Audit Trail​

Before migration:

  1. Export all sessions to CSV for audit
  2. Document server inventory
  3. Track migration progress
  4. Verify all users migrated

After migration:

  1. Keep SecureCRT backups
  2. Document new Xermius structure
  3. Update team procedures
  4. Retire SecureCRT licenses

Tips for Smooth Migration​

Before Export​

✅ Clean up sessions - Remove old/unused
✅ Organize folders - Structure becomes groups
✅ Add descriptions - These become group names
✅ Export keys - Save to safe location
✅ Document special settings - Port forwards, etc.

During Export​

✅ Test small batch - 2-3 sessions first
✅ Verify file format - Check [Session] blocks
✅ Include all needed - Don't miss folders
✅ Backup originals - Keep SecureCRT sessions

After Import​

✅ Verify count - All sessions imported?
✅ Test connections - One per group
✅ Reorganize - Clean up auto-created groups
✅ Set up keys - Import and assign
✅ Recreate special - Port forwards, etc.
✅ Train team - Show Xermius features

Example: Full Enterprise Migration​

Company: TechCorp, 25 users, 200+ servers

Goal: Migrate from SecureCRT (licensed) to Xermius (Freemium/Pro)

Plan:

Week 1: Preparation

1. Install Xermius on 3 test users
2. Export their SecureCRT sessions
3. Import to Xermius
4. Test for one week
5. Gather feedback

Week 2: Pilot

6. Export sessions for 10 users
7. Create import guide
8. Distribute to pilot group
9. Each user imports
10. IT helps with issues

Week 3: Full Rollout

11. Export for remaining users
12. Company-wide migration day
13. IT support available
14. All users import sessions
15. Verify SSH keys work

Week 4: Cleanup

16. Collect feedback
17. Document new processes
18. Archive SecureCRT sessions
19. Update IT procedures
20. Cancel SecureCRT licenses

Result:

  • ✅ 25 users migrated
  • ✅ 200+ sessions imported
  • ✅ $5,000/year saved on licenses
  • ✅ Better features (tunnels, snippets)
  • ✅ Team happy with Xermius

Enterprise tip: For large migrations, create a dedicated Slack channel for migration support and questions!