Beginning SSH on Ubuntu

Matrix Trinity SSH

So let’s say you have a private network running in your secret underground lab. Maybe you’ve got a Linux box hardwired to a WiFi router, and maybe a Mac or Linux laptop floating around somewhere, and you need a quick way to transfer files or execute shell commands remotely.

What you need is SSH, the Secure Shell. SSH is a powerful tool which allows secure remote login over insecure networks. It provides an encrypted terminal session with strong authentication of both the server and client using public-key cryptography. This tutorial will cover the basics of SSH’s most useful features:

  • Logging into a remote computer over a secure connection.
  • Transferring files and directories between computers over a secure connection.
  • Enabling public-key authentication.
  • Passwordless authentication for use with scripts and cron jobs.

The following assumptions are made about the reader:

  • You know what a terminal/command line/shell is and how to start a session.
  • You have at least a basic familiarity with Linux/Mac command-line syntax.
  • You’re on a private LAN with access to at least two Linux/Mac computers (or, you have a user account on a remote server that accepts SSH connections).

As always, comments, corrections, and suggestions for improvement are appreciated.

Installing OpenSSH

The Ubuntu (and MacOS X) flavor of SSH is called OpenSSH, a free, open-source implementation of the ssh protocol. It consists of two basic components, an openssh-client and an openssh-server. SSH clients communicate with SSH servers over encrypted network connections.

The openssh-client software should already be installed by default on Ubuntu. If you want to be able to accept SSH connections as well as request them, you’ll need the server software as well. The easiest way to ensure you have both is simply to run:

sudo apt-get install openssh-client openssh-server

Using SSH to Log into a Remote Computer

Once OpenSSH is installed, you can login to a remote SSH server by using the ssh command:

ssh remoteuser@remotebox

where remoteuser is the username of the remote account you’re trying to access, and remotebox is the remote server’s hostname or IP address.

For example, if you know that your Ubuntu desktop box (now running openssh-server) has a user account named joebanks and that the IP address of that computer on your private LAN is 192.168.0.12, you could login remotely to that account from your Linux/Mac laptop by typing:

ssh joebanks@192.168.0.12

If you’re unsure of a computer’s local IP address, try running ifconfig on that machine. This will display the status of the active network interfaces, and the local IP address of that device will be listed after inet addr. It will most likely be in the form of 192.168.0.xx.

Or, if you’ve got a web hosting account that allows shell access with a domain name like cooldomain.com, your syntax might look like:

ssh joebanks@cooldomain.com

Now, the first time an SSH client encounters a new remote server, it will report that it’s never seen the machine before, by printing the following message:

The authenticity of host 'remotebox (192.168.0.12)' can't be established.
RSA key fingerprint is 53:b4:ad:c8:51:17:99:4b:c9:08:ac:c1:b6:05:71:9b.
Are you sure you want to continue connecting (yes/no)?

This is just an extra security measure to ensure that you’re actually connecting to the machine you think you are. If you type yes (the most common response), you’ll see the following:

Warning: Permanently added 'remotebox' (RSA) to the list of known hosts.

Subsequent login attempts to this machine will omit the warning message. You’ll then be asked for the remoteuser‘s password:

remoteuser@remotebox's password:

And after correctly entering it, like magic, you’ll be logged into the remote machine, and instead of your local machine’s command prompt, you’ll see the following:

remoteuser@remotebox:~$

And, voila! You can execute commands on the remote machine just as you would on your local box. To close the connection to the remote server, type exit, or use Ctrl-D.

Copying Files

To transfer files and directories from your local machine to the remote server and vice-versa, you’ll use SSH’s “secure copy” command, or scp. To copy a single file from your local machine to the server, use the following syntax:

scp file.txt remoteuser@remotebox:/directory

where file.txt is the name of a file in the current directory of your local machine, remoteuser@remotebox is the username and hostname or IP address of the server (just like in the above ssh examples), and /directory is the directory path on the server where you want your file copied.

For example, if you want to copy the local file.txt to the /home/joebanks/docs directory on the server you logged into above, you’ll run the following command from a local terminal session:

scp file.txt joebanks@192.168.0.12:/home/joebanks/docs

By “local terminal session,” I mean that you DO NOT first ssh in to the remote computer and then run the scp command. Secure copy opens the ssh tunnel on its own. Since secure copy uses the ssh protocol for a secure connection, whenever you run the scp command, you’ll be prompted for a password (or passphrase) if the ssh connection requires it.

You can be as verbose as you want with the local and remote filenames and directories, even changing the filename in the process, like so:

scp ~/docs/old.txt joebanks@192.168.0.12:/home/joebanks/docs/new.txt

To copy a file from the server to your local machine, use the following syntax:

scp remoteuser@remotebox:file.txt /local/directory

where remoteuser@remotebox is the username and hostname or IP address of the server, file.txt is a file in the /home/remoteuser directory, and /local/directory is the local directory path into which the file will be copied.

Again, you can be as verbose as necessary, for example:

scp joebanks@192.168.0.12:~/docs/newfile.txt /home/joe/downloads

Copying Directories

To copy an entire directory (and all of its contents) from the local machine to the remote server, use the recursive -r option, like so:

scp -r /local/directory remoteuser@remotebox:/remote/directory

where /local/directory is the path to the local directory you want copied, and /remote/directory is the remote directory into which you want the directory to be copied.

To copy an entire directory (and all of its contents) from the remote server to the local machine, use the following:

scp -r remoteuser@remotebox:/remote/directory /local/directory

where /remote/directory is the path to the remote directory you want copied, and /local/directory is the local directory into which you want the directory to be copied.

Stop Typing the Stupid IP Address All Day, Will You?

By now you’re no doubt getting sick of typing joebanks@192.168.0.12 or whatever. It sure would be nice to type something shorter. Let’s fix that.

OpenSSH uses a client configuration file, located at ~/.ssh/config, to simplify some of the tedious typing associated with logging into remote machines. To edit (or create) that file, we’ll use the nano text editor, like so:

nano ~/.ssh/config

The simplest configuration file might look something like this:

Host volcano
  HostName 192.168.0.12

This associates the Host volcano with the HostName (or IP address) 192.168.0.12, so now to login you’ll only need to type:

ssh joebanks@volcano

That’s cool, but let’s get a little more lazy, shall we? How about this:

Host bigwoo
  HostName 192.168.0.12
  User joebanks

Now all we need to type is:

ssh bigwoo

Far out! You can add as much configuration data as you need to this Host, and as many different Hosts as you like. And this shorthand will also work with all the scp examples:

scp file.txt bigwoo:

To learn more visit the OpenSSH docs, or run man ssh_config.

Public-Key Authentication

To increase the security of your SSH session, or to set up passwordless authentication, you can enable SSH’s built-in public-key cryptography. Then, instead of entering the remoteuser‘s password on each login attempt, SSH will initiate a challenge-and-response protocol which attempts to match an encrypted public key (stored on the server) with a protected private key (stored on the local machine). This completely eliminates the need to send sensitive information (like a password) over the network, encrypted or not.

To generate a public/private key pair on your local machine, open a terminal and type:

ssh-keygen -t dsa

You’ll see the following message:

Generating public/private dsa key pair.
Enter file in which to save the key (~/.ssh/id_dsa):

Hit Enter. This selects the default location. Next you’ll see:

Enter passphrase (empty for no passphrase):

Enter a secure passphrase, ideally something unique and unguessable. Unlike a password, a passphrase is usually a phrase or complete sentence, with spaces and punctuation if you like. The longer and more obscure the phrase, the stronger it is.

Note: It is also acceptable to just hit Enter at this point, thereby selecting no passphrase. This can be appropriate in some instances (see below), but you should be aware that it is not as secure. While ssh will still use an encrypted public/private keypair (which is almost certainly more secure than typing the remote user’s password like you’ve been doing), anyone gaining access to your local account will thereby also gain unfettered access to any remote hosts which recognize your public key.

After typing a passphrase and hitting Enter, you’ll see:

Enter same passphrase again:

Enter the same passphrase again. And finally:

Your identification has been saved in ~/.ssh/id_dsa.
Your public key has been saved in ~/.ssh/id_dsa.pub.
The key fingerprint is:
42:ac:8a:81:31:81:e5:7b:d2:01:42:2d:64:32:0f:dd localuser@localbox

Now copy your public key, which is stored in the local file ~/.ssh/id_dsa.pub to the remote machine, by running the following command from a local terminal session:

ssh-copy-id -i ~/.ssh/id_dsa.pub remoteuser@remotebox

You’ll be prompted for the remoteuser‘s password one last time, and then you’ll see the message:

Now try logging into the machine, with "ssh 'remoteuser@remotebox'", and check in:

  .ssh/authorized_keys

to make sure we haven't added extra keys that you weren't expecting.

OSX Users: If the ssh-copy-id method doesn’t work with your version of OpenSSH, try the following command:

cat ~/.ssh/id_dsa.pub | ssh remoteuser@remotebox 'cat >> .ssh/authorized_keys'

Or, if the ~/.ssh directory doesn’t yet exist on the remote machine, you can create the directory and copy the public key all in one fell swoop, like so:

cat ~/.ssh/id_dsa.pub | ssh remoteuser@remotebox 'mkdir .ssh; cat >> .ssh/authorized_keys'

Once the ~/.ssh/authorized_keys file on the remote machine contains your public key, you’ll be prompted for your passphrase at each login attempt, rather than the remoteuser‘s system password, like so:

Enter passphrase for key '~/.ssh/id_dsa':

Finally, it’s a good idea to change the permissions of the ~/.ssh directory and the ~/.ssh/id_dsa file on your local machine, to disable any outside access to your private key.

chmod 700 ~/.ssh
chmod 600 ~/.ssh/id_dsa

Passwordless Authentication for Automated Tasks

You can use ssh and scp in shell scripts and cron jobs to automate repetitive tasks, such as remote backups of critical files. To do so, however, you’ll need to implement some sort of passwordless authentication scheme, so that scripts can run without human intervention.

Two methods are presented below, the first is the easiest to implement (and possibly the most prevalent), while the second is the most secure.

Method 1: Sans Passphrase

If you want your scripts to have access to the ssh command without requiring a password or passphrase, simply go through the steps outlined above for enabling public-key authentication, but instead of entering a passphrase when prompted, simply press Enter.

The ssh-keygen program will generate a public/private key pair for you that will allow password- and passphrase-less access to any remote server which has your public key stored in its authorized_keys file.

Is this secure? Well, no. And yes. It’s probably more secure than typing in the remoteuser‘s password and sending it over the network. Sure it’s encrypted, but it could still be intercepted.

Public-key authentication sends no password or passphrase data over the network. The “challenge” sent by the server is encrypted with your public key, and can only be decrypted with your private key, which only you have.

However, as mentioned above, if someone gains access to your local computer, they’ll also have access to every remote server with your public key.

So, you’ll need to decide the level of security required. In my opinion, if you’re only communicating with machines on a private LAN, under your control, behind a router’s firewall, then this method is adequate. Others may disagree.

Method 2: Using ssh-agent and keychain

The “proper” and secure way to achieve passwordless authentication is by using the ssh-agent and keychain daemons to store your passphrase between terminal sessions, so you don’t need to type it every time.

Setup of this method is beyond the scope of this article, but the following tutorials will walk you through the entire process, as well as the theory behind it:

1. OpenSSH key management, Part 1
2. OpenSSH key management, Part 2

Go Forth and SSHify!

I hope this tutorial serves as a gentle introduction to the Secure Shell. For further reading and advanced topics, check out the references listed below, and browse the OpenSSH Documentation. Thanks for reading.

References

1. SSH Tutorial for Linux
2. SSH: Ubuntu Community Documentation
3. Secure Communications with OpenSSH
4. Getting Started with SSH
5. Indiana University Knowledge Base: SCP
6. Example Syntax for Secure Copy
7. Bash Reference Manual

Advertisements

31 responses to “Beginning SSH on Ubuntu

  1. Re: Public-Key Authentication

    Once you’ve made your public key the rest of the instructions can be completed with a single command:

    $ ssh-copy-id remoteuser@remote.host.com
    

    You can use -i /path/to/ident if it doesn’t automatically find your identity.

  2. Zed, thanks for the recommendation. Using ssh-copy-id is clearly better than the scp method, especially since it appends to the authorized_keys file, rather than overwriting. It will also create the file (and the ~/.ssh directory) and chmods them appropriately. I’ve implemented the change in the text.

  3. Thank you for this wonderful guide. I would like to add for any OSX users who are reading this, and realize we don’t have ssh-copy-id. Just use this simple command:

    cat ~/.ssh/id_dsa.pub | ssh account@remoteserver.com "cat >> .ssh/authorized_keys"
    
  4. Great article! Just one question though. If I wanted to connect to my home network from somewhere on the internet, and didn’t want to connect only to my firewall server (connected directly to the internet), what would the syntax be? For example, if my networks’ IP is 71.58.214.207 (firewall server eth0) and I want to access 192.168.0.123 (ftp server connected to firewall server eth1), how would I do that?

    I know that you can just ssh into the firewall server and then into the ftp one, but I would imagine there is an easier/more secure way.

  5. Nick, thanks for the kudos. I’m probably not qualified to comment directly on your setup. To connect to my SSH server from the WAN, I simply forward a port on my router’s config page, and link it to LAN IP of the Linux box running the server. Then, instead of typing ssh myaccount@192.168.xx.xx, I type ssh myaccount@my.WAN.IP, and the router takes care of the rest.

  6. Useful article. There’s a possible discrepancy with the info here

    https://help.ubuntu.com/8.04/serverguide/C/openssh-server.html

    you advise using authorized_keys, the Ubuntu site uses authorized_keys2.

    I’m guessing that it depends on what’s in the sshd_config file, but the debian site (http://www.debian-administration.org/articles/152) is also a little confusing. I thought RSA was older but, not according to this.

    I’m here because the Ubuntu page above isn’t working for me — trying to get passwordless authentication working. The first problem was I had forgotten I had a firewall rule blocking port 22 (smacks forehead!). It would be good in such docs if assumptions were enumerated with tests to verify applicability.

    I think it’s particularly important for anything that will enable a new (to Ubuntu) user to set up a good backup regime. I’m looking to run rsync from my laptop over ssh.

    Your docs are considerably better than the official ones! Thanks

  7. PS

    You don’t mention the need to have

    PubkeyAuthentication yes

    in sshd_config. I have done this but I’m not clear (yet) on what other things I should do at the same time, if any.

    Loved the “Go forth and SSHify!”

  8. Update:

    My mistake was painfully simple: trying to SSH in the wrong direction, from the machine with the public key.

    I’m not the only one to have done this so I posted a note to launchpad suggesting some clarification of the docs which are not at all clear on this (as well as on the authorized-keys filename). A diagram would help too.

    I should say that the PubkeyAuthentication was already done and that no changes are needed to sshd_config at all.

    This is helpful:

    http://ubuntuforums.org/showthread.php?t=238672

  9. After much hunting through the web, wasting a lot of time plus a number of false starts, your tutorial for setting up an SSH client/server was the only one that got my system configured correctly. It’s well written and follows a logical pattern – thanks very much.

    Alan

    ps fancy having a go at “howto” set up a chroot jail!!!!

  10. Hmmm. Doesn’t work for me. After entering the host info and trying
    “ssh cinemaloha”
    I get…
    “ssh: connect to host cinemaloha port 22: No route to host”
    :(

    Any suggestions?

  11. A bit more info…

    I had ssh’ed into cinemaloha when it was using DHCP. At that time, I was (successfully) using the name rather than the IP. When I saw this wonderful guide, I thought, “better give it a static IP before setting up the host entry.” After doing so I was still able to ssh via the IP, but not by the hostname. I then setup the host entry per this guide, tried to ssh in, got the err msg above. Next I tried pinging cinemaloha. The pings were going to the old (DHCP) address (and of course, failing.) Is there some sort of local DNS cache?

  12. Great tutorial! Well written and easy to follow. Inspired me to install ubuntu on an old computer I had lying around without keyboard or screen and now I can talk to it using ssh.
    Thanks!

  13. Thanks a lot for this. Clearly explained and is going to save me countless hours in looking up long-winded passwords for various servers I access daily.

  14. Thank you so much. I have been wondering how to get my laptop to accept ssh connections for three weeks and now it works.

Leave a Reply

Please log in using one of these methods to post your comment:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s