How to Use PuTTY Private Keys on Linux When Windows Keys Won't Work

You're trying to connect to your server from Ubuntu using the same PuTTY keys that work perfectly on Windows, but Linux keeps rejecting them. The error messages about "PuTTY key format too new" or "invalid format" are frustrating, especially when you know the keys themselves are valid.

This happens because Linux's native SSH client speaks a different language than PuTTY. While PuTTY uses its own proprietary .ppk format, Linux systems expect OpenSSH format keys. It's like trying to open a Word document with Notepad—the content is there, but the format doesn't match.

Why Your PuTTY Keys Don't Work on Linux

PuTTY stores private keys in a specialized .ppk format that includes extra metadata and encryption specific to PuTTY's architecture. When you try using these files directly with Linux's ssh command, it simply can't parse the structure. The "PuTTY key format too new" error often appears when your PuTTY version (like 0.74) uses a newer key format that older conversion tools don't recognize.

Even after converting to OpenSSH PEM format through PuTTYgen, you might still hit issues if the conversion wasn't complete or if file permissions aren't set correctly on Linux.

The Right Way to Convert PuTTY Keys for Linux

Step 1: Convert Using PuTTYgen

On your Windows machine, open PuTTYgen and load your existing private key file. Go to Conversions → Export OpenSSH key. Save this as private_key (without any extension). This creates a properly formatted OpenSSH private key that Linux can understand.

Step 2: Transfer to Linux

Copy the converted key file to your Ubuntu machine. Place it in ~/.ssh/ directory. If the .ssh folder doesn't exist yet, create it with mkdir -p ~/.ssh.

Step 3: Fix Permissions

This is critical—SSH is extremely picky about key file permissions. Run these commands:

chmod 700 ~/.ssh
chmod 600 ~/.ssh/private_key

The first command secures your SSH directory, the second ensures only you can read the private key. If permissions are too loose, SSH will refuse to use the key for security reasons.

Step 4: Connect

Now you can connect using: ssh -i ~/.ssh/private_key user@hostname

👉 Need reliable Linux servers with SSH access that just works? Check out these dedicated server options

Alternative Method: Use ssh-keygen Directly

If you're already on Linux and want to skip Windows tools entirely, you can convert the key using puttygen (the Linux version) or ssh-keygen:

Install puttygen on Ubuntu: sudo apt install putty-tools

Then convert: puttygen private_key.ppk -O private-openssh -o private_key

This reads your .ppk file and outputs a clean OpenSSH format key that works immediately with Linux's SSH client.

When Nothing Seems to Work

If you've converted the key correctly but still get "Permission denied (publickey)" errors, the issue might be server-side. Check these:

Public key placement: Your public key needs to be in ~/.ssh/authorized_keys on the server. Open PuTTYgen on Windows, load your key, and copy the text from the "Public key for pasting" box. SSH into your server (using password authentication if available) and paste this into ~/.ssh/authorized_keys.

Server SSH configuration: Some servers disable certain authentication methods. Your server admin might need to verify that PubkeyAuthentication yes is set in /etc/ssh/sshd_config.

Key algorithm compatibility: Older servers might not accept newer key types like Ed25519. If your key is very new, try generating an RSA key instead for broader compatibility.

Going Forward Without PuTTY on Linux

Once you're comfortable on Linux, you might want to generate native SSH keys instead of converting PuTTY keys. Run ssh-keygen -t rsa -b 4096 to create a new key pair that works seamlessly across all Linux tools. This avoids format conversion headaches entirely and gives you access to modern key types that PuTTY might not fully support yet.

The converted key approach works fine for transitioning from Windows workflows, but native Linux keys integrate better with tools like ssh-agent for password-less authentication across multiple sessions. 👉 Managing multiple servers? See how infrastructure setups handle SSH key authentication at scale