Best antiddos solutions

Support  support@0r.by

База знаний

Портал > База знаний > SSH Administration > PuTTY User Manual

PuTTY User Manual

                             PuTTY User Manual

PuTTY is a free (MIT-licensed) Win32 Telnet and SSH client. This manual
documents PuTTY, and its companion utilities PSCP, PSFTP, Plink, Pageant
and PuTTYgen.

_Note to Unix users:_ this manual currently primarily documents the Windows
versions of the PuTTY utilities. Some options are therefore mentioned
that are absent from the Unix version; the Unix version has features not
described here; and the pterm and command-line puttygen utilities are not
described at all. The only Unix-specific documentation that currently
exists is the man pages.

This manual is copyright 2001-2013 Simon Tatham. All rights reserved. You
may distribute this documentation under the MIT licence. See appendix C for
the licence text in full.

Chapter 1: Introduction to PuTTY

       PuTTY is a free SSH, Telnet and Rlogin client for 32-bit Windows

   1.1 What are SSH, Telnet and Rlogin?

       If you already know what SSH, Telnet and Rlogin are, you can safely
       skip on to the next section.

       SSH, Telnet and Rlogin are three ways of doing the same thing:
       logging in to a multi-user computer from another computer, over a

       Multi-user operating systems, such as Unix and VMS, usually present
       a command-line interface to the user, much like the `Command Prompt'
       or `MS-DOS Prompt' in Windows. The system prints a prompt, and you
       type commands which the system will obey.

       Using this type of interface, there is no need for you to be sitting
       at the same machine you are typing commands to. The commands,
       and responses, can be sent over a network, so you can sit at one
       computer and give commands to another one, or even to more than one.

       SSH, Telnet and Rlogin are _network protocols_ that allow you to do
       this. On the computer you sit at, you run a _client_, which makes a
       network connection to the other computer (the _server_). The network
       connection carries your keystrokes and commands from the client to
       the server, and carries the server's responses back to you.

       These protocols can also be used for other types of keyboard-based
       interactive session. In particular, there are a lot of bulletin
       boards, talker systems and MUDs (Multi-User Dungeons) which support
       access using Telnet. There are even a few that support SSH.

       You might want to use SSH, Telnet or Rlogin if:

        -  you have an account on a Unix or VMS system which you want to be
           able to access from somewhere else

        -  your Internet Service Provider provides you with a login account
           on a web server. (This might also be known as a _shell account_.
           A _shell_ is the program that runs on the server and interprets
           your commands for you.)

        -  you want to use a bulletin board system, talker or MUD which can
           be accessed using Telnet.

       You probably do _not_ want to use SSH, Telnet or Rlogin if:

        -  you only use Windows. Windows computers have their own ways
           of networking between themselves, and unless you are doing
           something fairly unusual, you will not need to use any of these
           remote login protocols.

   1.2 How do SSH, Telnet and Rlogin differ?

       This list summarises some of the differences between SSH, Telnet and

        -  SSH (which stands for `secure shell') is a recently designed,
           high-security protocol. It uses strong cryptography to protect
           your connection against eavesdropping, hijacking and other
           attacks. Telnet and Rlogin are both older protocols offering
           minimal security.

        -  SSH and Rlogin both allow you to log in to the server without
           having to type a password. (Rlogin's method of doing this is
           insecure, and can allow an attacker to access your account on
           the server. SSH's method is much more secure, and typically
           breaking the security requires the attacker to have gained
           access to your actual client machine.)

        -  SSH allows you to connect to the server and automatically send
           a command, so that the server will run that command and then
           disconnect. So you can use it in automated processing.

       The Internet is a hostile environment and security is everybody's
       responsibility. If you are connecting across the open Internet,
       then we recommend you use SSH. If the server you want to connect
       to doesn't support SSH, it might be worth trying to persuade the
       administrator to install it.

       If your client and server are both behind the same (good) firewall,
       it is more likely to be safe to use Telnet or Rlogin, but we still
       recommend you use SSH.

Chapter 2: Getting started with PuTTY

       This chapter gives a quick guide to the simplest types of
       interactive login session using PuTTY.

   2.1 Starting a session

       When you start PuTTY, you will see a dialog box. This dialog box
       allows you to control everything PuTTY can do. See chapter 4 for
       details of all the things you can control.

       You don't usually need to change most of the configuration options.
       To start the simplest kind of session, all you need to do is to
       enter a few basic parameters.

       In the `Host Name' box, enter the Internet host name of the server
       you want to connect to. You should have been told this by the
       provider of your login account.

       Now select a login protocol to use, from the `Connection type'
       buttons. For a login session, you should select Telnet, Rlogin or
       SSH. See section 1.2 for a description of the differences between
       the three protocols, and advice on which one to use. The fourth
       protocol, _Raw_, is not used for interactive login sessions; you
       would usually use this for debugging other Internet services (see
       section 3.6). The fifth option, _Serial_, is used for connecting to
       a local serial line, and works somewhat differently: see section 3.7
       for more information on this.

       When you change the selected protocol, the number in the `Port'
       box will change. This is normal: it happens because the various
       login services are usually provided on different network ports
       by the server machine. Most servers will use the standard port
       numbers, so you will not need to change the port setting. If your
       server provides login services on a non-standard port, your system
       administrator should have told you which one. (For example, many
       MUDs run Telnet service on a port other than 23.)

       Once you have filled in the `Host Name', `Protocol', and possibly
       `Port' settings, you are ready to connect. Press the `Open' button
       at the bottom of the dialog box, and PuTTY will begin trying to
       connect you to the server.

   2.2 Verifying the host key (SSH only)

       If you are not using the SSH protocol, you can skip this section.

       If you are using SSH to connect to a server for the first time, you
       will probably see a message looking something like this:

         The server's host key is not cached in the registry. You
         have no guarantee that the server is the computer you
         think it is.
         The server's rsa2 key fingerprint is:
         ssh-rsa 1024 7b:e5:6f:a7:f4:f9:81:62:5c:e3:1f:bf:8b:57:6c:5a
         If you trust this host, hit Yes to add the key to
         PuTTY's cache and carry on connecting.
         If you want to carry on connecting just once, without
         adding the key to the cache, hit No.
         If you do not trust this host, hit Cancel to abandon the

       This is a feature of the SSH protocol. It is designed to protect you
       against a network attack known as _spoofing_: secretly redirecting
       your connection to a different computer, so that you send your
       password to the wrong machine. Using this technique, an attacker
       would be able to learn the password that guards your login account,
       and could then log in as if they were you and use the account for
       their own purposes.

       To prevent this attack, each server has a unique identifying code,
       called a _host key_. These keys are created in a way that prevents
       one server from forging another server's key. So if you connect to a
       server and it sends you a different host key from the one you were
       expecting, PuTTY can warn you that the server may have been switched
       and that a spoofing attack might be in progress.

       PuTTY records the host key for each server you connect to, in the
       Windows Registry. Every time you connect to a server, it checks that
       the host key presented by the server is the same host key as it was
       the last time you connected. If it is not, you will see a warning,
       and you will have the chance to abandon your connection before you
       type any private information (such as a password) into it.

       However, when you connect to a server you have not connected to
       before, PuTTY has no way of telling whether the host key is the
       right one or not. So it gives the warning shown above, and asks you
       whether you want to trust this host key or not.

       Whether or not to trust the host key is your choice. If you are
       connecting within a company network, you might feel that all
       the network users are on the same side and spoofing attacks are
       unlikely, so you might choose to trust the key without checking
       it. If you are connecting across a hostile network (such as the
       Internet), you should check with your system administrator, perhaps
       by telephone or in person. (Some modern servers have more than
       one host key. If the system administrator sends you more than one
       fingerprint, you should make sure the one PuTTY shows you is on the
       list, but it doesn't matter which one it is.)

   2.3 Logging in

       After you have connected, and perhaps verified the server's host
       key, you will be asked to log in, probably using a username and a
       password. Your system administrator should have provided you with
       these. Enter the username and the password, and the server should
       grant you access and begin your session. If you have mistyped your
       password, most servers will give you several chances to get it

       If you are using SSH, be careful not to type your username wrongly,
       because you will not have a chance to correct it after you press
       Return; many SSH servers do not permit you to make two login
       attempts using different usernames. If you type your username
       wrongly, you must close PuTTY and start again.

       If your password is refused but you are sure you have typed it
       correctly, check that Caps Lock is not enabled. Many login servers,
       particularly Unix computers, treat upper case and lower case as
       different when checking your password; so if Caps Lock is on, your
       password will probably be refused.

   2.4 After logging in

       After you log in to the server, what happens next is up to the
       server! Most servers will print some sort of login message and then
       present a prompt, at which you can type commands which the server
       will carry out. Some servers will offer you on-line help; others
       might not. If you are in doubt about what to do next, consult your
       system administrator.

   2.5 Logging out

       When you have finished your session, you should log out by typing
       the server's own logout command. This might vary between servers; if
       in doubt, try `logout' or `exit', or consult a manual or your system
       administrator. When the server processes your logout command, the
       PuTTY window should close itself automatically.

       You _can_ close a PuTTY session using the Close button in the window
       border, but this might confuse the server - a bit like hanging up a
       telephone unexpectedly in the middle of a conversation. We recommend
       you do not do this unless the server has stopped responding to you
       and you cannot close the window any other way.

Chapter 3: Using PuTTY

       This chapter provides a general introduction to some more advanced
       features of PuTTY. For extreme detail and reference purposes,
       chapter 4 is likely to contain more information.

   3.1 During your session

       A lot of PuTTY's complexity and features are in the configuration
       panel. Once you have worked your way through that and started
       a session, things should be reasonably simple after that.
       Nevertheless, there are a few more useful features available.

 3.1.1 Copying and pasting text

       Often in a PuTTY session you will find text on your terminal screen
       which you want to type in again. Like most other terminal emulators,
       PuTTY allows you to copy and paste the text rather than having to
       type it again. Also, copy and paste uses the Windows clipboard, so
       that you can paste (for example) URLs into a web browser, or paste
       from a word processor or spreadsheet into your terminal session.

       PuTTY's copy and paste works entirely with the mouse. In order to
       copy text to the clipboard, you just click the left mouse button in
       the terminal window, and drag to select text. When you let go of the
       button, the text is _automatically_ copied to the clipboard. You
       do not need to press Ctrl-C or Ctrl-Ins; in fact, if you do press
       Ctrl-C, PuTTY will send a Ctrl-C character down your session to the
       server where it will probably cause a process to be interrupted.

       Pasting is done using the right button (or the middle mouse
       button, if you have a three-button mouse and have set it up; see
       section 4.11.2). (Pressing Shift-Ins, or selecting `Paste' from
       the Ctrl+right-click context menu, have the same effect.) When you
       click the right mouse button, PuTTY will read whatever is in the
       Windows clipboard and paste it into your session, _exactly_ as if it
       had been typed at the keyboard. (Therefore, be careful of pasting
       formatted text into an editor that does automatic indenting; you may
       find that the spaces pasted from the clipboard plus the spaces added
       by the editor add up to too many spaces and ruin the formatting.
       There is nothing PuTTY can do about this.)

       If you double-click the left mouse button, PuTTY will select a whole
       word. If you double-click, hold down the second click, and drag the
       mouse, PuTTY will select a sequence of whole words. (You can adjust
       precisely what PuTTY considers to be part of a word; see section
       4.11.5.) If you _triple_-click, or triple-click and drag, then PuTTY
       will select a whole line or sequence of lines.

       If you want to select a rectangular region instead of selecting to
       the end of each line, you can do this by holding down Alt when you
       make your selection. You can also configure rectangular selection to
       be the default, and then holding down Alt gives the normal behaviour
       instead: see section 4.11.4 for details.

       (In some Unix environments, Alt+drag is intercepted by the window
       manager. Shift+Alt+drag should work for rectangular selection as
       well, so you could try that instead.)

       If you have a middle mouse button, then you can use it to adjust an
       existing selection if you selected something slightly wrong. (If you
       have configured the middle mouse button to paste, then the right
       mouse button does this instead.) Click the button on the screen,
       and you can pick up the nearest end of the selection and drag it to
       somewhere else.

       It's possible for the server to ask to handle mouse clicks in the
       PuTTY window itself. If this happens, the mouse pointer will turn
       into an arrow, and using the mouse to copy and paste will only work
       if you hold down Shift. See section 4.6.2 and section 4.11.3 for
       details of this feature and how to configure it.

 3.1.2 Scrolling the screen back

       PuTTY keeps track of text that has scrolled up off the top of the
       terminal. So if something appears on the screen that you want to
       read, but it scrolls too fast and it's gone by the time you try to
       look for it, you can use the scrollbar on the right side of the
       window to look back up the session history and find it again.

       As well as using the scrollbar, you can also page the scrollback
       up and down by pressing Shift-PgUp and Shift-PgDn. You can scroll
       a line at a time using Ctrl-PgUp and Ctrl-PgDn. These are still
       available if you configure the scrollbar to be invisible.

       By default the last 200 lines scrolled off the top are preserved for
       you to look at. You can increase (or decrease) this value using the
       configuration box; see section 4.7.3.

 3.1.3 The System menu

       If you click the left mouse button on the icon in the top left
       corner of PuTTY's terminal window, or click the right mouse button
       on the title bar, you will see the standard Windows system menu
       containing items like Minimise, Move, Size and Close.

       PuTTY's system menu contains extra program features in addition
       to the Windows standard options. These extra menu commands are
       described below.

       (These options are also available in a context menu brought up by
       holding Ctrl and clicking with the right mouse button anywhere in
       the PuTTY window.) The PuTTY Event Log

       If you choose `Event Log' from the system menu, a small window will
       pop up in which PuTTY logs significant events during the connection.
       Most of the events in the log will probably take place during
       session startup, but a few can occur at any point in the session,
       and one or two occur right at the end.

       You can use the mouse to select one or more lines of the Event Log,
       and hit the Copy button to copy them to the clipboard. If you are
       reporting a bug, it's often useful to paste the contents of the
       Event Log into your bug report. Special commands

       Depending on the protocol used for the current session, there may
       be a submenu of `special commands'. These are protocol-specific
       tokens, such as a `break' signal, that can be sent down a connection
       in addition to normal data. Their precise effect is usually up to
       the server. Currently only Telnet, SSH, and serial connections have
       special commands.

       The `break' signal can also be invoked from the keyboard with Ctrl-

       The following special commands are available in Telnet:

        -  Are You There

        -  Break

        -  Synch

        -  Erase Character

           PuTTY can also be configured to send this when the Backspace key
           is pressed; see section 4.16.3.

        -  Erase Line

        -  Go Ahead

        -  No Operation

           Should have no effect.

        -  Abort Process

        -  Abort Output

        -  Interrupt Process

           PuTTY can also be configured to send this when Ctrl-C is typed;
           see section 4.16.3.

        -  Suspend Process

           PuTTY can also be configured to send this when Ctrl-Z is typed;
           see section 4.16.3.

        -  End Of Record

        -  End Of File

       In an SSH connection, the following special commands are available:

        -  IGNORE message

           Should have no effect.

        -  Repeat key exchange

           Only available in SSH-2. Forces a repeat key exchange
           immediately (and resets associated timers and counters). For
           more information about repeat key exchanges, see section 4.19.2.

        -  Break

           Only available in SSH-2, and only during a session. Optional
           extension; may not be supported by server. PuTTY requests the
           server's default break length.

        -  Signals (SIGINT, SIGTERM etc)

           Only available in SSH-2, and only during a session. Sends
           various POSIX signals. Not honoured by all servers.

       With a serial connection, the only available special command is
       `Break'. Starting new sessions

       PuTTY's system menu provides some shortcut ways to start new

        -  Selecting `New Session' will start a completely new instance of
           PuTTY, and bring up the configuration box as normal.

        -  Selecting `Duplicate Session' will start a session in a new
           window with precisely the same options as your current one -
           connecting to the same host using the same protocol, with all
           the same terminal settings and everything.

        -  In an inactive window, selecting `Restart Session' will do the
           same as `Duplicate Session', but in the current window.

        -  The `Saved Sessions' submenu gives you quick access to any sets
           of stored session details you have previously saved. See section
           4.1.2 for details of how to create saved sessions. Changing your session settings

       If you select `Change Settings' from the system menu, PuTTY will
       display a cut-down version of its initial configuration box. This
       allows you to adjust most properties of your current session. You
       can change the terminal size, the font, the actions of various
       keypresses, the colours, and so on.

       Some of the options that are available in the main configuration box
       are not shown in the cut-down Change Settings box. These are usually
       options which don't make sense to change in the middle of a session
       (for example, you can't switch from SSH to Telnet in mid-session).

       You can save the current settings to a saved session for future use
       from this dialog box. See section 4.1.2 for more on saved sessions. Copy All to Clipboard

       This system menu option provides a convenient way to copy the whole
       contents of the terminal screen (up to the last nonempty line) and
       scrollback to the clipboard in one go. Clearing and resetting the terminal

       The `Clear Scrollback' option on the system menu tells PuTTY to
       discard all the lines of text that have been kept after they
       scrolled off the top of the screen. This might be useful, for
       example, if you displayed sensitive information and wanted to make
       sure nobody could look over your shoulder and see it. (Note that
       this only prevents a casual user from using the scrollbar to view
       the information; the text is not guaranteed not to still be in
       PuTTY's memory.)

       The `Reset Terminal' option causes a full reset of the terminal
       emulation. A VT-series terminal is a complex piece of software and
       can easily get into a state where all the text printed becomes
       unreadable. (This can happen, for example, if you accidentally
       output a binary file to your terminal.) If this happens, selecting
       Reset Terminal should sort it out. Full screen mode

       If you find the title bar on a maximised window to be ugly or
       distracting, you can select Full Screen mode to maximise PuTTY `even
       more'. When you select this, PuTTY will expand to fill the whole
       screen and its borders, title bar and scrollbar will disappear. (You
       can configure the scrollbar not to disappear in full-screen mode if
       you want to keep it; see section 4.7.3.)

       When you are in full-screen mode, you can still access the system
       menu if you click the left mouse button in the _extreme_ top left
       corner of the screen.

   3.2 Creating a log file of your session

       For some purposes you may find you want to log everything that
       appears on your screen. You can do this using the `Logging' panel in
       the configuration box.

       To begin a session log, select `Change Settings' from the system
       menu and go to the Logging panel. Enter a log file name, and select
       a logging mode. (You can log all session output including the
       terminal control sequences, or you can just log the printable text.
       It depends what you want the log for.) Click `Apply' and your log
       will be started. Later on, you can go back to the Logging panel and
       select `Logging turned off completely' to stop logging; then PuTTY
       will close the log file and you can safely read it.

       See section 4.2 for more details and options.

   3.3 Altering your character set configuration

       If you find that special characters (accented characters, for
       example, or line-drawing characters) are not being displayed
       correctly in your PuTTY session, it may be that PuTTY is
       interpreting the characters sent by the server according to the
       wrong _character set_. There are a lot of different character sets
       available, so it's entirely possible for this to happen.

       If you click `Change Settings' and look at the `Translation' panel,
       you should see a large number of character sets which you can
       select, and other related options. Now all you need is to find out
       which of them you want! (See section 4.10 for more information.)

   3.4 Using X11 forwarding in SSH

       The SSH protocol has the ability to securely forward X Window System
       applications over your encrypted SSH connection, so that you can run
       an application on the SSH server machine and have it put its windows
       up on your local machine without sending any X network traffic in
       the clear.

       In order to use this feature, you will need an X display server
       for your Windows machine, such as Cygwin/X, X-Win32, or Exceed.
       This will probably install itself as display number 0 on your local
       machine; if it doesn't, the manual for the X server should tell you
       what it does do.

       You should then tick the `Enable X11 forwarding' box in the X11
       panel (see section 4.23) before starting your SSH session. The `X
       display location' box is blank by default, which means that PuTTY
       will try to use a sensible default such as `:0', which is the usual
       display location where your X server will be installed. If that
       needs changing, then change it.

       Now you should be able to log in to the SSH server as normal. To
       check that X forwarding has been successfully negotiated during
       connection startup, you can check the PuTTY Event Log (see section It should say something like this:

         2001-12-05 17:22:01 Requesting X11 forwarding
         2001-12-05 17:22:02 X11 forwarding enabled

       If the remote system is Unix or Unix-like, you should also be able
       to see that the `DISPLAY' environment variable has been set to point
       at display 10 or above on the SSH server machine itself:

         fred@unixbox:~$ echo $DISPLAY

       If this works, you should then be able to run X applications in the
       remote session and have them display their windows on your PC.

       For more options relating to X11 forwarding, see section 4.23.

   3.5 Using port forwarding in SSH

       The SSH protocol has the ability to forward arbitrary network
       connections over your encrypted SSH connection, to avoid the
       network traffic being sent in clear. For example, you could use
       this to connect from your home computer to a POP-3 server on a
       remote machine without your POP-3 password being visible to network

       In order to use port forwarding to connect from your local machine
       to a port on a remote server, you need to:

        -  Choose a port number on your local machine where PuTTY should
           listen for incoming connections. There are likely to be plenty
           of unused port numbers above 3000. (You can also use a local
           loopback address here; see below for more details.)

        -  Now, before you start your SSH connection, go to the Tunnels
           panel (see section 4.24). Make sure the `Local' radio button
           is set. Enter the local port number into the `Source port'
           box. Enter the destination host name and port number into
           the `Destination' box, separated by a colon (for example,
           `popserver.example.com:110' to connect to a POP-3 server).

        -  Now click the `Add' button. The details of your port forwarding
           should appear in the list box.

       Now start your session and log in. (Port forwarding will not be
       enabled until after you have logged in; otherwise it would be easy
       to perform completely anonymous network attacks, and gain access to
       anyone's virtual private network.) To check that PuTTY has set up
       the port forwarding correctly, you can look at the PuTTY Event Log
       (see section It should say something like this:

         2001-12-05 17:22:10 Local port 3110 forwarding to

       Now if you connect to the source port number on your local PC, you
       should find that it answers you exactly as if it were the service
       running on the destination machine. So in this example, you could
       then configure an e-mail client to use `localhost:3110' as a POP-
       3 server instead of `popserver.example.com:110'. (Of course, the
       forwarding will stop happening when your PuTTY session closes down.)

       You can also forward ports in the other direction: arrange for a
       particular port number on the _server_ machine to be forwarded back
       to your PC as a connection to a service on your PC or near it. To do
       this, just select the `Remote' radio button instead of the `Local'
       one. The `Source port' box will now specify a port number on the
       _server_ (note that most servers will not allow you to use port
       numbers under 1024 for this purpose).

       An alternative way to forward local connections to remote hosts
       is to use dynamic SOCKS proxying. In this mode, PuTTY acts as a
       SOCKS server, which SOCKS-aware programs can connect to and open
       forwarded connections to the destination of their choice, so this
       can be an alternative to long lists of static forwardings. To use
       this mode, you will need to select the `Dynamic' radio button
       instead of `Local', and then you should not enter anything into the
       `Destination' box (it will be ignored). PuTTY will then listen for
       SOCKS connections on the port you have specified. Most web browsers
       can be configured to connect to this SOCKS proxy service; also, you
       can forward other PuTTY connections through it by setting up the
       Proxy control panel (see section 4.15 for details).

       The source port for a forwarded connection usually does not accept
       connections from any machine except the SSH client or server machine
       itself (for local and remote forwardings respectively). There are
       controls in the Tunnels panel to change this:

        -  The `Local ports accept connections from other hosts' option
           allows you to set up local-to-remote port forwardings (including
           dynamic port forwardings) in such a way that machines other than
           your client PC can connect to the forwarded port.

        -  The `Remote ports do the same' option does the same thing for
           remote-to-local port forwardings (so that machines other than
           the SSH server machine can connect to the forwarded port.) Note
           that this feature is only available in the SSH-2 protocol, and
           not all SSH-2 servers honour it (in OpenSSH, for example, it's
           usually disabled by default).

       You can also specify an IP address to listen on. Typically a
       Windows machine can be asked to listen on any single IP address
       in the 127.*.*.* range, and all of these are loopback addresses
       available only to the local machine. So if you forward (for example)
       `' to a remote machine's finger port, then you should be
       able to run commands such as `finger fred@'. This can be
       useful if the program connecting to the forwarded port doesn't allow
       you to change the port number it uses. This feature is available
       for local-to-remote forwarded ports; SSH-1 is unable to support it
       for remote-to-local ports, while SSH-2 can support it in theory but
       servers will not necessarily cooperate.

       (Note that if you're using Windows XP Service Pack 2, you may need
       to obtain a fix from Microsoft in order to use addresses like - see question A.7.20.)

       For more options relating to port forwarding, see section 4.24.

       If the connection you are forwarding over SSH is itself a second
       SSH connection made by another copy of PuTTY, you might find the
       `logical host name' configuration option useful to warn PuTTY of
       which host key it should be expecting. See section 4.13.5 for
       details of this.

   3.6 Making raw TCP connections

       A lot of Internet protocols are composed of commands and responses
       in plain text. For example, SMTP (the protocol used to transfer e-
       mail), NNTP (the protocol used to transfer Usenet news), and HTTP
       (the protocol used to serve Web pages) all consist of commands in
       readable plain text.

       Sometimes it can be useful to connect directly to one of these
       services and speak the protocol `by hand', by typing protocol
       commands and watching the responses. On Unix machines, you can do
       this using the system's `telnet' command to connect to the right
       port number. For example, `telnet mailserver.example.com 25' might
       enable you to talk directly to the SMTP service running on a mail

       Although the Unix `telnet' program provides this functionality, the
       protocol being used is not really Telnet. Really there is no actual
       protocol at all; the bytes sent down the connection are exactly the
       ones you type, and the bytes shown on the screen are exactly the
       ones sent by the server. Unix `telnet' will attempt to detect or
       guess whether the service it is talking to is a real Telnet service
       or not; PuTTY prefers to be told for certain.

       In order to make a debugging connection to a service of this
       type, you simply select the fourth protocol name, `Raw', from the
       `Protocol' buttons in the `Session' configuration panel. (See
       section 4.1.1.) You can then enter a host name and a port number,
       and make the connection.

   3.7 Connecting to a local serial line

       PuTTY can connect directly to a local serial line as an alternative
       to making a network connection. In this mode, text typed into the
       PuTTY window will be sent straight out of your computer's serial
       port, and data received through that port will be displayed in the
       PuTTY window. You might use this mode, for example, if your serial
       port is connected to another computer which has a serial connection.

       To make a connection of this type, simply select `Serial' from the
       `Connection type' radio buttons on the `Session' configuration panel
       (see section 4.1.1). The `Host Name' and `Port' boxes will transform
       into `Serial line' and `Speed', allowing you to specify which serial
       line to use (if your computer has more than one) and what speed
       (baud rate) to use when transferring data. For further configuration
       options (data bits, stop bits, parity, flow control), you can use
       the `Serial' configuration panel (see section 4.26).

       After you start up PuTTY in serial mode, you might find that you
       have to make the first move, by sending some data out of the serial
       line in order to notify the device at the other end that someone is
       there for it to talk to. This probably depends on the device. If you
       start up a PuTTY serial session and nothing appears in the window,
       try pressing Return a few times and see if that helps.

       A serial line provides no well defined means for one end of the
       connection to notify the other that the connection is finished.
       Therefore, PuTTY in serial mode will remain connected until you
       close the window using the close button.

   3.8 The PuTTY command line

       PuTTY can be made to do various things without user intervention
       by supplying command-line arguments (e.g., from a command prompt
       window, or a Windows shortcut).

 3.8.1 Starting a session from the command line

       These options allow you to bypass the configuration window and
       launch straight into a session.

       To start a connection to a server called `host':

         putty.exe [-ssh | -telnet | -rlogin | -raw] [user@]host

       If this syntax is used, settings are taken from the Default Settings
       (see section 4.1.2); `user' overrides these settings if supplied.
       Also, you can specify a protocol, which will override the default
       protocol (see section

       For telnet sessions, the following alternative syntax is supported
       (this makes PuTTY suitable for use as a URL handler for telnet URLs
       in web browsers):

         putty.exe telnet://host[:port]/

       To start a connection to a serial port, e.g. COM1:

         putty.exe -serial com1

       In order to start an existing saved session called `sessionname',
       use the `-load' option (described in section

         putty.exe -load "session name"

 3.8.2 `-cleanup'

       If invoked with the `-cleanup' option, rather than running as
       normal, PuTTY will remove its registry entries and random seed file
       from the local machine (after confirming with the user).

       Note that on multi-user systems, `-cleanup' only removes registry
       entries and files associated with the currently logged-in user.

 3.8.3 Standard command-line options

       PuTTY and its associated tools support a range of command-line
       options, most of which are consistent across all the tools. This
       section lists the available options in all tools. Options which are
       specific to a particular tool are covered in the chapter about that
       tool. `-load': load a saved session

       The `-load' option causes PuTTY to load configuration details out
       of a saved session. If these details include a host name, then this
       option is all you need to make PuTTY start a session.

       You need double quotes around the session name if it contains

       If you want to create a Windows shortcut to start a PuTTY saved
       session, this is the option you should use: your shortcut should
       call something like

         d:\path\to\putty.exe -load "my session"

       (Note that PuTTY itself supports an alternative form of this option,
       for backwards compatibility. If you execute `putty @sessionname' it
       will have the same effect as `putty -load "sessionname"'. With the
       `@' form, no double quotes are required, and the `@' sign must be
       the very first thing on the command line. This form of the option is
       deprecated.) Selecting a protocol: `-ssh', `-telnet', `-rlogin', `-raw' `-

       To choose which protocol you want to connect with, you can use one
       of these options:

        -  `-ssh' selects the SSH protocol.

        -  `-telnet' selects the Telnet protocol.

        -  `-rlogin' selects the Rlogin protocol.

        -  `-raw' selects the raw protocol.

        -  `-serial' selects a serial connection.

       These options are not available in the file transfer tools PSCP and
       PSFTP (which only work with the SSH protocol).

       These options are equivalent to the protocol selection buttons
       in the Session panel of the PuTTY configuration box (see section
       4.1.1). `-v': increase verbosity

       Most of the PuTTY tools can be made to tell you more about what they
       are doing by supplying the `-v' option. If you are having trouble
       when making a connection, or you're simply curious, you can turn
       this switch on and hope to find out more about what is happening. `-l': specify a login name

       You can specify the user name to log in as on the remote server
       using the `-l' option. For example, `plink login.example.com -
       l fred'.

       These options are equivalent to the username selection box in
       the Connection panel of the PuTTY configuration box (see section
       4.14.1). `-L', `-R' and `-D': set up port forwardings

       As well as setting up port forwardings in the PuTTY configuration
       (see section 4.24), you can also set up forwardings on the command
       line. The command-line options work just like the ones in Unix `ssh'

       To forward a local port (say 5110) to a remote destination (say
       popserver.example.com port 110), you can write something like one of

         putty -L 5110:popserver.example.com:110 -load mysession
         plink mysession -L 5110:popserver.example.com:110

       To forward a remote port to a local destination, just use the `-R'
       option instead of `-L':

         putty -R 5023:mytelnetserver.myhouse.org:23 -load mysession
         plink mysession -R 5023:mytelnetserver.myhouse.org:23

       To specify an IP address for the listening end of the tunnel,
       prepend it to the argument:

         plink -L myhost

       To set up SOCKS-based dynamic port forwarding on a local port, use
       the `-D' option. For this one you only have to pass the port number:

         putty -D 4096 -load mysession

       For general information on port forwarding, see section 3.5.

       These options are not available in the file transfer tools PSCP and
       PSFTP. `-m': read a remote command or script from a file

       The `-m' option performs a similar function to the `Remote command'
       box in the SSH panel of the PuTTY configuration box (see section
       4.18.1). However, the `-m' option expects to be given a local file
       name, and it will read a command from that file.

       With some servers (particularly Unix systems), you can even put
       multiple lines in this file and execute more than one command in
       sequence, or a whole shell script; but this is arguably an abuse,
       and cannot be expected to work on all servers. In particular, it is
       known _not_ to work with certain `embedded' servers, such as Cisco

       This option is not available in the file transfer tools PSCP and
       PSFTP. `-P': specify a port number

       The `-P' option is used to specify the port number to connect to. If
       you have a Telnet server running on port 9696 of a machine instead
       of port 23, for example:

         putty -telnet -P 9696 host.name
         plink -telnet -P 9696 host.name

       (Note that this option is more useful in Plink than in PuTTY,
       because in PuTTY you can write `putty -telnet host.name 9696' in any

       This option is equivalent to the port number control in the Session
       panel of the PuTTY configuration box (see section 4.1.1). `-pw': specify a password

       A simple way to automate a remote login is to supply your password
       on the command line. This is _not recommended_ for reasons of
       security. If you possibly can, we recommend you set up public-key
       authentication instead. See chapter 8 for details.

       Note that the `-pw' option only works when you are using the SSH
       protocol. Due to fundamental limitations of Telnet and Rlogin, these
       protocols do not support automated password authentication. `-agent' and `-noagent': control use of Pageant for authentication

       The `-agent' option turns on SSH authentication using Pageant, and
       `-noagent' turns it off. These options are only meaningful if you
       are using SSH.

       See chapter 9 for general information on Pageant.

       These options are equivalent to the agent authentication checkbox in
       the Auth panel of the PuTTY configuration box (see section 4.20.3). `-A' and `-a': control agent forwarding

       The `-A' option turns on SSH agent forwarding, and `-a' turns it
       off. These options are only meaningful if you are using SSH.

       See chapter 9 for general information on Pageant, and section 9.4
       for information on agent forwarding. Note that there is a security
       risk involved with enabling this option; see section 9.5 for

       These options are equivalent to the agent forwarding checkbox in the
       Auth panel of the PuTTY configuration box (see section 4.20.6).

       These options are not available in the file transfer tools PSCP and
       PSFTP. `-X' and `-x': control X11 forwarding

       The `-X' option turns on X11 forwarding in SSH, and `-x' turns it
       off. These options are only meaningful if you are using SSH.

       For information on X11 forwarding, see section 3.4.

       These options are equivalent to the X11 forwarding checkbox in the
       X11 panel of the PuTTY configuration box (see section 4.23).

       These options are not available in the file transfer tools PSCP and
       PSFTP. `-t' and `-T': control pseudo-terminal allocation

       The `-t' option ensures PuTTY attempts to allocate a pseudo-terminal
       at the server, and `-T' stops it from allocating one. These options
       are only meaningful if you are using SSH.

       These options are equivalent to the `Don't allocate a pseudo-
       terminal' checkbox in the SSH panel of the PuTTY configuration box
       (see section 4.22.1).

       These options are not available in the file transfer tools PSCP and
       PSFTP. `-N': suppress starting a shell or command

       The `-N' option prevents PuTTY from attempting to start a shell or
       command on the remote server. You might want to use this option if
       you are only using the SSH connection for port forwarding, and your
       user account on the server does not have the ability to run a shell.

       This feature is only available in SSH protocol version 2 (since the
       version 1 protocol assumes you will always want to run a shell).

       This option is equivalent to the `Don't start a shell or command at
       all' checkbox in the SSH panel of the PuTTY configuration box (see
       section 4.18.2).

       This option is not available in the file transfer tools PSCP and
       PSFTP. `-nc': make a remote network connection in place of a remote shell
       or command

       The `-nc' option prevents Plink (or PuTTY) from attempting to start
       a shell or command on the remote server. Instead, it will instruct
       the remote server to open a network connection to a host name and
       port number specified by you, and treat that network connection as
       if it were the main session.

       You specify a host and port as an argument to the `-nc' option, with
       a colon separating the host name from the port number, like this:

         plink host1.example.com -nc host2.example.com:1234

       You might want to use this feature if you needed to make an SSH
       connection to a target host which you can only reach by going
       through a proxy host, and rather than using port forwarding you
       prefer to use the local proxy feature (see section 4.15.1 for more
       about local proxies). In this situation you might select `Local'
       proxy type, set your local proxy command to be `plink %proxyhost -
       nc %host:%port', enter the target host name on the Session panel,
       and enter the directly reachable proxy host name on the Proxy panel.

       This feature is only available in SSH protocol version 2 (since the
       version 1 protocol assumes you will always want to run a shell). It
       is not available in the file transfer tools PSCP and PSFTP. It is
       available in PuTTY itself, although it is unlikely to be very useful
       in any tool other than Plink. Also, `-nc' uses the same server
       functionality as port forwarding, so it will not work if your server
       administrator has disabled port forwarding.

       (The option is named `-nc' after the Unix program `nc', short for
       `netcat'. The command `plink host1 -nc host2:port' is very similar
       in functionality to `plink host1 nc host2 port', which invokes `nc'
       on the server and tells it to connect to the specified destination.
       However, Plink's built-in `-nc' option does not depend on the `nc'
       program being installed on the server.) `-C': enable compression

       The `-C' option enables compression of the data sent across the
       network. This option is only meaningful if you are using SSH.

       This option is equivalent to the `Enable compression' checkbox in
       the SSH panel of the PuTTY configuration box (see section 4.18.3). `-1' and `-2': specify an SSH protocol version

       The `-1' and `-2' options force PuTTY to use version 1 or version 2
       of the SSH protocol. These options are only meaningful if you are
       using SSH.

       These options are equivalent to selecting your preferred SSH
       protocol version as `1 only' or `2 only' in the SSH panel of the
       PuTTY configuration box (see section 4.18.4). `-4' and `-6': specify an Internet protocol version

       The `-4' and `-6' options force PuTTY to use the older Internet
       protocol IPv4 or the newer IPv6 for most outgoing connections.

       These options are equivalent to selecting your preferred Internet
       protocol version as `IPv4' or `IPv6' in the Connection panel of the
       PuTTY configuration box (see section 4.13.4). `-i': specify an SSH private key

       The `-i' option allows you to specify the name of a private key file
       in `*.PPK' format which PuTTY will use to authenticate with the
       server. This option is only meaningful if you are using SSH.

       For general information on public-key authentication, see chapter 8.

       This option is equivalent to the `Private key file for
       authentication' box in the Auth panel of the PuTTY configuration box
       (see section 4.20.8). `-loghost': specify a logical host name

       This option overrides PuTTY's normal SSH host key caching policy by
       telling it the name of the host you expect your connection to end up
       at (in cases where this differs from the location PuTTY thinks it's
       connecting to). It can be a plain host name, or a host name followed
       by a colon and a port number. See section 4.13.5 for more detail on
       this. `-pgpfp': display PGP key fingerprints

       This option causes the PuTTY tools not to run as normal, but instead
       to display the fingerprints of the PuTTY PGP Master Keys, in
       order to aid with verifying new versions. See appendix E for more
       information. `-sercfg': specify serial port configuration

       This option specifies the configuration parameters for the serial
       port (baud rate, stop bits etc). Its argument is interpreted as
       a comma-separated list of configuration options, which can be as

        -  Any single digit from 5 to 9 sets the number of data bits.

        -  `1', `1.5' or `2' sets the number of stop bits.

        -  Any other numeric string is interpreted as a baud rate.

        -  A single lower-case letter specifies the parity: `n' for none,
           `o' for odd, `e' for even, `m' for mark and `s' for space.

        -  A single upper-case letter specifies the flow control: `N' for
           none, `X' for XON/XOFF, `R' for RTS/CTS and `D' for DSR/DTR.

       For example, `-sercfg 19200,8,n,1,N' denotes a baud rate of 19200, 8
       data bits, no parity, 1 stop bit and no flow control.

Chapter 4: Configuring PuTTY

       This chapter describes all the configuration options in PuTTY.

       PuTTY is configured using the control panel that comes up before you
       start a session. Some options can also be changed in the middle of a
       session, by selecting `Change Settings' from the window menu.

   4.1 The Session panel

       The Session configuration panel contains the basic options you need
       to specify in order to open a session at all, and also allows you to
       save your settings to be reloaded later.

 4.1.1 The host name section

       The top box on the Session panel, labelled `Specify your connection
       by host name', contains the details that need to be filled in before
       PuTTY can open a session at all.

        -  The `Host Name' box is where you type the name, or the IP
           address, of the server you want to connect to.

        -  The `Connection type' radio buttons let you choose what type
           of connection you want to make: a raw connection, a Telnet
           connection, an Rlogin connection, an SSH connection, or a
           connection to a local serial line. (See section 1.2 for a
           summary of the differences between SSH, Telnet and rlogin; see
           section 3.6 for an explanation of `raw' connections; see section
           3.7 for information about using a serial line.)

        -  The `Port' box lets you specify which port number on the server
           to connect to. If you select Telnet, Rlogin, or SSH, this box
           will be filled in automatically to the usual value, and you will
           only need to change it if you have an unusual server. If you
           select Raw mode, you will almost certainly need to fill in the
           `Port' box yourself.

       If you select `Serial' from the `Connection type' radio buttons,
       the `Host Name' and `Port' boxes are replaced by `Serial line' and
       `Speed'; see section 4.26 for more details of these.

 4.1.2 Loading and storing saved sessions

       The next part of the Session configuration panel allows you to save
       your preferred PuTTY options so they will appear automatically the
       next time you start PuTTY. It also allows you to create _saved
       sessions_, which contain a full set of configuration options plus a
       host name and protocol. A saved session contains all the information
       PuTTY needs to start exactly the session you want.

        -  To save your default settings: first set up the settings the way
           you want them saved. Then come back to the Session panel. Select
           the `Default Settings' entry in the saved sessions list, with a
           single click. Then press the `Save' button.

       If there is a specific host you want to store the details of how
       to connect to, you should create a saved session, which will be
       separate from the Default Settings.

        -  To save a session: first go through the rest of the
           configuration box setting up all the options you want. Then come
           back to the Session panel. Enter a name for the saved session in
           the `Saved Sessions' input box. (The server name is often a good
           choice for a saved session name.) Then press the `Save' button.
           Your saved session name should now appear in the list box.

           You can also save settings in mid-session, from the `Change
           Settings' dialog. Settings changed since the start of the
           session will be saved with their current values; as well as
           settings changed through the dialog, this includes changes in
           window size, window title changes sent by the server, and so on.

        -  To reload a saved session: single-click to select the session
           name in the list box, and then press the `Load' button. Your
           saved settings should all appear in the configuration panel.

        -  To modify a saved session: first load it as described above.
           Then make the changes you want. Come back to the Session panel,
           and press the `Save' button. The new settings will be saved over
           the top of the old ones.

           To save the new settings under a different name, you can enter
           the new name in the `Saved Sessions' box, or single-click to
           select a session name in the list box to overwrite that session.
           To save `Default Settings', you must single-click the name
           before saving.

        -  To start a saved session immediately: double-click on the
           session name in the list box.

        -  To delete a saved session: single-click to select the session
           name in the list box, and then press the `Delete' button.

       Each saved session is independent of the Default Settings
       configuration. If you change your preferences and update Default
       Settings, you must also update every saved session separately.

       Saved sessions are stored in the Registry, at the location


       If you need to store them in a file, you could try the method
       described in section 4.27.

 4.1.3 `Close Window on Exit'

       Finally in the Session panel, there is an option labelled `Close
       Window on Exit'. This controls whether the PuTTY terminal window
       disappears as soon as the session inside it terminates. If you are
       likely to want to copy and paste text out of the session after it
       has terminated, or restart the session, you should arrange for this
       option to be off.

       `Close Window On Exit' has three settings. `Always' means always
       close the window on exit; `Never' means never close on exit (always
       leave the window open, but inactive). The third setting, and the
       default one, is `Only on clean exit'. In this mode, a session which
       terminates normally will cause its window to close, but one which is
       aborted unexpectedly by network trouble or a confusing message from
       the server will leave the window up.

   4.2 The Logging panel

       The Logging configuration panel allows you to save log files of your
       PuTTY sessions, for debugging, analysis or future reference.

       The main option is a radio-button set that specifies whether PuTTY
       will log anything at all. The options are:

        -  `None'. This is the default option; in this mode PuTTY will not
           create a log file at all.

        -  `Printable output'. In this mode, a log file will be created
           and written to, but only printable text will be saved into it.
           The various terminal control codes that are typically sent down
           an interactive session alongside the printable text will be
           omitted. This might be a useful mode if you want to read a log
           file in a text editor and hope to be able to make sense of it.

        -  `All session output'. In this mode, _everything_ sent by the
           server into your terminal session is logged. If you view the log
           file in a text editor, therefore, you may well find it full of
           strange control characters. This is a particularly useful mode
           if you are experiencing problems with PuTTY's terminal handling:
           you can record everything that went to the terminal, so that
           someone else can replay the session later in slow motion and
           watch to see what went wrong.

        -  `SSH packets'. In this mode (which is only used by SSH
           connections), the SSH message packets sent over the encrypted
           connection are written to the log file (as well as Event Log
           entries). You might need this to debug a network-level problem,
           or more likely to send to the PuTTY authors as part of a bug
           report. _BE WARNED_ that if you log in using a password, the
           password can appear in the log file; see section 4.2.4 for
           options that may help to remove sensitive material from the log
           file before you send it to anyone else.

        -  `SSH packets and raw data'. In this mode, as well as the
           decrypted packets (as in the previous mode), the _raw_
           (encrypted, compressed, etc) packets are _also_ logged. This
           could be useful to diagnose corruption in transit. (The same
           caveats as the previous mode apply, of course.)

       Note that the non-SSH logging options (`Printable output' and `All
       session output') only work with PuTTY proper; in programs without
       terminal emulation (such as Plink), they will have no effect, even
       if enabled via saved settings.

 4.2.1 `Log file name'

       In this edit box you enter the name of the file you want to log the
       session to. The `Browse' button will let you look around your file
       system to find the right place to put the file; or if you already
       know exactly where you want it to go, you can just type a pathname
       into the edit box.

       There are a few special features in this box. If you use the `&'
       character in the file name box, PuTTY will insert details of the
       current session in the name of the file it actually opens. The
       precise replacements it will do are:

        -  `&Y' will be replaced by the current year, as four digits.

        -  `&M' will be replaced by the current month, as two digits.

        -  `&D' will be replac

Этот ответ был полезен?

Добавить в избранное Добавить в избранное    Распечатать статью Распечатать статью

Также читают
Commands (просмотров: 4109)
Apache+PHP+MySql Install on Debian\Ubuntu (просмотров: 3824)