In this tutorial on Linux ssh, 86 of 100, below find a 3-4 minute introductory video, a text-based tutorial and all of the code examples from the video.
Our eighty-sixth word, or command to memorize is
ssh from our category
Communication.
ssh allows you to remotely access a
server.
Common Linux ssh Options
-options
description
-l LOGIN
Specify a LOGIN on server
-o
Specify additional options for configuration files
Recall from video (tutorial) #84 on
ftp we used the
ftp Protocol to log in to a remote system, and saw
how improved client programs lftp and
sftp added much needed security.
Similarly here we'll see a new Protocol that improved on remote access
programs Telnet, rlogin and rsh.
Before we start, it helps to think of commands as mini programs and
most follow this structure:
command -option(s) argument(s).
The ssh command has
over 40 options, and the arguments are hosts and
credentials, and to grasp ssh, please
think in terms of clients and servers.
Unlike most commands, help is not available with double-dash
--help but typing
ssh without options and arguments will
show syntax. Use the -l LOGIN option
when the server login name differs from the client login. Seventy
other configuration options are passed with the
-o option.
So why is ssh an important command?
Well, in reality most work is performed on client machines requiring
that you get code and settings to a server remotely.
And now you know how to do that.
Demonstration
Okay, the best way to embed this in your memory is by typing in your
own terminal window.
Find this on your Mac using a program called Terminal. On Linux use
Terminal or Konsole, and currently Microsoft is adding this
functionality to Windows.
Here we go. Since you likely don't have a server hosting
ssh traffic on your end, instead,
let's touch on how ssh works. Every
data packet is encrypted. That's the first thing to think about.
Second, each party, meaning each client or server has two keys,
a public one and a private one. And it takes two keys to open any
packet. So that's all I can really get into in this short time frame.
With that as a start, read the man ssh
page sections Authentication and Files.
$ man ssh
(Below is the opening section of the man
page.)
SSH(1) BSD General Commands Manual SSH(1)
NAME
ssh — OpenSSH SSH client (remote login program)
SYNOPSIS
ssh [-1246AaCfgKkMNnqsTtVvXxYy] [-b bind_address] [-c cipher_spec]
[-D [bind_address:]port] [-E log_file] [-e escape_char] [-F configfile] [-I pkcs11]
[-i identity_file] [-L [bind_address:]port:host:hostport] [-l login_name]
[-m mac_spec] [-O ctl_cmd] [-o option] [-p port]
[-Q cipher | cipher-auth | mac | kex | key] [-R [bind_address:]port:host:hostport]
[-S ctl_path] [-W host:port] [-w local_tun[:remote_tun]] [user@]hostname [command]
DESCRIPTION
ssh (SSH client) is a program for logging into a remote machine and for executing commands on a remote
machine. It is intended to replace rlogin and rsh, and provide secure encrypted communications
between two untrusted hosts over an insecure network. X11 connections, arbitrary TCP ports and
UNIX-domain sockets can also be forwarded over the secure channel.
ssh connects and logs into the specified hostname (with optional user name). The user must prove
his/her identity to the remote machine using one of several methods depending on the protocol version
used (see below).
If command is specified, it is executed on the remote host instead of a login shell.
The options are as follows:
-1 Forces ssh to try protocol version 1 only.
-2 Forces ssh to try protocol version 2 only.
Manual page ssh(1) line 1 (press h for help or q to quit)
(Once inside the ssh man page, which
actually uses less for most by default
you can zoom to the AUTHENTICATION section by entering
/AUTHENTICATION followed by
Enter.)
AUTHENTICATION
The OpenSSH SSH client supports SSH protocols 1 and 2. The default is to use protocol
2 only, though this can be changed via the Protocol option in ssh_config(5) or the -1
and -2 options (see above). Both protocols support similar authentication methods, but
protocol 2 is the default since it provides additional mechanisms for confidentiality
(the traffic is encrypted using AES, 3DES, Blowfish, CAST128, or Arcfour) and integrity
(hmac-md5, hmac-sha1, hmac-sha2-256, hmac-sha2-512, umac-64, umac-128, hmac-ripemd160).
Protocol 1 lacks a strong mechanism for ensuring the integrity of the connection.
The methods available for authentication are: GSSAPI-based authentication, host-based
authentication, public key authentication, challenge-response authentication, and pass‐
word authentication. Authentication methods are tried in the order specified above,
though protocol 2 has a configuration option to change the default order:
PreferredAuthentications.
Host-based authentication works as follows: If the machine the user logs in from is
listed in /etc/hosts.equiv or /etc/ssh/shosts.equiv on the remote machine, and the user
names are the same on both sides, or if the files ~/.rhosts or ~/.shosts exist in the
user's home directory on the remote machine and contain a line containing the name of
the client machine and the name of the user on that machine, the user is considered for
login. Additionally, the server must be able to verify the client's host key (see the
description of /etc/ssh/ssh_known_hosts and ~/.ssh/known_hosts, below) for login to be
permitted. This authentication method closes security holes due to IP spoofing, DNS
spoofing, and routing spoofing. [Note to the administrator: /etc/hosts.equiv,
~/.rhosts, and the rlogin/rsh protocol in general, are inherently insecure and should
be disabled if security is desired.]
Public key authentication works as follows: The scheme is based on public-key cryptog‐
raphy, using cryptosystems where encryption and decryption are done using separate
keys, and it is unfeasible to derive the decryption key from the encryption key. The
idea is that each user creates a public/private key pair for authentication purposes.
The server knows the public key, and only the user knows the private key. ssh imple‐
ments public key authentication protocol automatically, using one of the DSA, ECDSA,
ED25519 or RSA algorithms. Protocol 1 is restricted to using only RSA keys, but proto‐
col 2 may use any. The HISTORY section of ssl(8) (on non-OpenBSD systems, see
http://www.openbsd.org/cgi-bin/man.cgi?query=ssl&sektion=8#HISTORY) contains a brief
discussion of the DSA and RSA algorithms.
The file ~/.ssh/authorized_keys lists the public keys that are permitted for logging
in. When the user logs in, the ssh program tells the server which key pair it would
like to use for authentication. The client proves that it has access to the private
key and the server checks that the corresponding public key is authorized to accept the
account.
The user creates his/her key pair by running ssh-keygen(1). This stores the private
key in ~/.ssh/identity (protocol 1), ~/.ssh/id_dsa (protocol 2 DSA), ~/.ssh/id_ecdsa
(protocol 2 ECDSA), ~/.ssh/id_ed25519 (protocol 2 ED25519), or ~/.ssh/id_rsa (protocol
2 RSA) and stores the public key in ~/.ssh/identity.pub (protocol 1), ~/.ssh/id_dsa.pub
(protocol 2 DSA), ~/.ssh/id_ecdsa.pub (protocol 2 ECDSA), ~/.ssh/id_ed25519.pub (proto‐
col 2 ED25519), or ~/.ssh/id_rsa.pub (protocol 2 RSA) in the user's home directory.
The user should then copy the public key to ~/.ssh/authorized_keys in his/her home
directory on the remote machine. The authorized_keys file corresponds to the conven‐
tional ~/.rhosts file, and has one key per line, though the lines can be very long.
After this, the user can log in without giving the password.
A variation on public key authentication is available in the form of certificate
authentication: instead of a set of public/private keys, signed certificates are used.
This has the advantage that a single trusted certification authority can be used in
place of many public/private keys. See the CERTIFICATES section of ssh-keygen(1) for
more information.
The most convenient way to use public key or certificate authentication may be with an
authentication agent. See ssh-agent(1) for more information.
Challenge-response authentication works as follows: The server sends an arbitrary
"challenge" text, and prompts for a response. Protocol 2 allows multiple challenges
and responses; protocol 1 is restricted to just one challenge/response. Examples of
challenge-response authentication include BSD Authentication (see login.conf(5)) and
PAM (some non-OpenBSD systems).
Finally, if other authentication methods fail, ssh prompts the user for a password.
The password is sent to the remote host for checking; however, since all communications
are encrypted, the password cannot be seen by someone listening on the network.
ssh automatically maintains and checks a database containing identification for all
hosts it has ever been used with. Host keys are stored in ~/.ssh/known_hosts in the
user's home directory. Additionally, the file /etc/ssh/ssh_known_hosts is automati‐
cally checked for known hosts. Any new hosts are automatically added to the user's
file. If a host's identification ever changes, ssh warns about this and disables pass‐
word authentication to prevent server spoofing or man-in-the-middle attacks, which
could otherwise be used to circumvent the encryption. The StrictHostKeyChecking option
can be used to control logins to machines whose host key is not known or has changed.
When the user's identity has been accepted by the server, the server either executes
the given command, or logs into the machine and gives the user a normal shell on the
remote machine. All communication with the remote command or shell will be automati‐
cally encrypted.
If a pseudo-terminal has been allocated (normal login session), the user may use the
escape characters noted below.
If no pseudo-tty has been allocated, the session is transparent and can be used to
reliably transfer binary data. On most systems, setting the escape character to “none”
will also make the session transparent even if a tty is used.
The session terminates when the command or shell on the remote machine exits and all
X11 and TCP connections have been closed.
AUTHORS
OpenSSH is a derivative of the original and free ssh 1.2.12 release by Tatu Ylonen.
Aaron Campbell, Bob Beck, Markus Friedl, Niels Provos, Theo de Raadt and Dug Song
removed many bugs, re-added newer features and created OpenSSH. Markus Friedl contributed the support for SSH protocol versions 1.5 and 2.0.
BSD August 9, 2017 BSD
(Zoom to the section below by entering
/FILES and
Enter.)
FILES
~/.rhosts
This file is used for host-based authentication (see above). On some machines
this file may need to be world-readable if the user's home directory is on an
NFS partition, because sshd(8) reads it as root. Additionally, this file must
be owned by the user, and must not have write permissions for anyone else. The
recommended permission for most machines is read/write for the user, and not
accessible by others.
~/.shosts
This file is used in exactly the same way as .rhosts, but allows host-based
authentication without permitting login with rlogin/rsh.
~/.ssh/
This directory is the default location for all user-specific configuration and
authentication information. There is no general requirement to keep the entire
contents of this directory secret, but the recommended permissions are
read/write/execute for the user, and not accessible by others.
~/.ssh/authorized_keys
Lists the public keys (DSA, ECDSA, ED25519, RSA) that can be used for logging
in as this user. The format of this file is described in the sshd(8) manual
page. This file is not highly sensitive, but the recommended permissions are
read/write for the user, and not accessible by others.
~/.ssh/config
This is the per-user configuration file. The file format and configuration
options are described in ssh_config(5). Because of the potential for abuse,
this file must have strict permissions: read/write for the user, and not
writable by others. It may be group-writable provided that the group in ques‐
tion contains only the user.
~/.ssh/environment
Contains additional definitions for environment variables; see ENVIRONMENT,
above.
~/.ssh/identity
~/.ssh/id_dsa
~/.ssh/id_ecdsa
~/.ssh/id_ed25519
~/.ssh/id_rsa
Contains the private key for authentication. These files contain sensitive
data and should be readable by the user but not accessible by others
(read/write/execute). ssh will simply ignore a private key file if it is
accessible by others. It is possible to specify a passphrase when generating
the key which will be used to encrypt the sensitive part of this file using
3DES.
~/.ssh/identity.pub
~/.ssh/id_dsa.pub
~/.ssh/id_ecdsa.pub
~/.ssh/id_ed25519.pub
~/.ssh/id_rsa.pub
Contains the public key for authentication. These files are not sensitive and
can (but need not) be readable by anyone.
~/.ssh/known_hosts
Contains a list of host keys for all hosts the user has logged into that are
not already in the systemwide list of known host keys. See sshd(8) for further
details of the format of this file.
~/.ssh/rc
Commands in this file are executed by ssh when the user logs in, just before
the user's shell (or command) is started. See the sshd(8) manual page for more
information.
/etc/hosts.equiv
This file is for host-based authentication (see above). It should only be
writable by root.
/etc/ssh/shosts.equiv
This file is used in exactly the same way as hosts.equiv, but allows host-based
authentication without permitting login with rlogin/rsh.
/etc/ssh/ssh_config
Systemwide configuration file. The file format and configuration options are
described in ssh_config(5).
/etc/ssh/ssh_host_key
/etc/ssh/ssh_host_dsa_key
/etc/ssh/ssh_host_ecdsa_key
/etc/ssh/ssh_host_ed25519_key
/etc/ssh/ssh_host_rsa_key
These files contain the private parts of the host keys and are used for host-
based authentication. If protocol version 1 is used, ssh must be setuid root,
since the host key is readable only by root. For protocol version 2, ssh uses
ssh-keysign(8) to access the host keys, eliminating the requirement that ssh be
setuid root when host-based authentication is used. By default ssh is not
setuid root.
/etc/ssh/ssh_known_hosts
Systemwide list of known host keys. This file should be prepared by the system
administrator to contain the public host keys of all machines in the organiza‐
tion. It should be world-readable. See sshd(8) for further details of the
format of this file.
/etc/ssh/sshrc
Commands in this file are executed by ssh when the user logs in, just before
the user's shell (or command) is started. See the sshd(8) manual page for more
information.
Then give it a try or have an administrator help you out with
ssh.
And last, let's type ssh alone to
view the syntax.
Okay now you know how to use ssh.
And you know the syntax for commands, options and arguments.
One last tip about the ssh
command. So sadly, I couldn't dive in adequately in 3 minutes, so
look for other resources in the (YouTube) Description. (links to
Wikipedia articles below open a new browser window)