But first, let’s install some dependencies. I assume that you will try the code on a machine aimed for testing, so I won’t be using the system’s package manager but instead use easy_install to install the needed Python modules. Other commands like pip could be used as well. If you do not want to mess with your system-wide python installation, just use virtualenv and pip, but I won’t go into the details about how to use these tools in the current document.

Install the needed dependencies:

easy_install pycrypto
easy_install pyasn1
easy_install pam
easy_install twisted

Make sure you have gcc installed, because it will be needed to complete the installation of Twisted and PyCrypto.

I have created a project for this code at Bitbucket, called RapidSSH. This will make it easier to share code and ideas about SSH server implementations in Python using Twisted.

Filename: scripts/rapidsshd_unix.py

#!/usr/bin/env python
#
# This file is part of rapidssh - http://bitbucket.org/gnotaras/rapidssh/
#
# rapidssh - A set of Secure Shell (SSH) server implementations in Python
#            using Twisted.conch, part of the Twisted Framework.
#
# Copyright (c) 2010 George Notaras - http://www.g-loaded.eu
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
# Initially based on the sshsimpleserver.py kindly published by:
# Twisted Matrix Laboratories - http://twistedmatrix.com
#
 
import sys
import pam
 
from twisted.conch.unix import UnixSSHRealm
from twisted.cred import portal
from twisted.cred.credentials import IUsernamePassword
from twisted.cred.checkers import ICredentialsChecker
from twisted.cred.error import UnauthorizedLogin
from twisted.conch.checkers import SSHPublicKeyDatabase
from twisted.conch.ssh import factory, userauth, connection, keys, session
from twisted.internet import reactor, defer
from zope.interface import implements
from twisted.python import log
 
# Logging
# Currently logging to STDERR
log.startLogging(sys.stderr)
 
# Server-side public and private keys. These are the keys found in
# sshsimpleserver.py. Make sure you generate your own using ssh-keygen!
 
publicKey = 'ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAGEArzJx8OYOnJmzf4tfBEvLi8DVPrJ3/c9k2I/Az64fxjHf9imyRJbixtQhlH9lfNjUIx+4LmrJH5QNRsFporcHDKOTwTTYLh5KmRpslkYHRivcJSkbh/C+BR3utDS555mV'
 
privateKey = """-----BEGIN RSA PRIVATE KEY-----
MIIByAIBAAJhAK8ycfDmDpyZs3+LXwRLy4vA1T6yd/3PZNiPwM+uH8Yx3/YpskSW
4sbUIZR/ZXzY1CMfuC5qyR+UDUbBaaK3Bwyjk8E02C4eSpkabJZGB0Yr3CUpG4fw
vgUd7rQ0ueeZlQIBIwJgbh+1VZfr7WftK5lu7MHtqE1S1vPWZQYE3+VUn8yJADyb
Z4fsZaCrzW9lkIqXkE3GIY+ojdhZhkO1gbG0118sIgphwSWKRxK0mvh6ERxKqIt1
xJEJO74EykXZV4oNJ8sjAjEA3J9r2ZghVhGN6V8DnQrTk24Td0E8hU8AcP0FVP+8
PQm/g/aXf2QQkQT+omdHVEJrAjEAy0pL0EBH6EVS98evDCBtQw22OZT52qXlAwZ2
gyTriKFVoqjeEjt3SZKKqXHSApP/AjBLpF99zcJJZRq2abgYlf9lv1chkrWqDHUu
DZttmYJeEfiFBBavVYIF1dOlZT0G8jMCMBc7sOSZodFnAiryP+Qg9otSBjJ3bQML
pSTqy7c3a2AScC/YyOwkDaICHnnD3XyjMwIxALRzl0tQEKMXs6hH8ToUdlLROCrP
EhQ0wahUTCk1gKA4uPD6TMTChavbh4K63OvbKg==
-----END RSA PRIVATE KEY-----"""
 
 
class PamPasswordDatabase:
    """Authentication/authorization backend using the 'login' PAM service"""
    credentialInterfaces = IUsernamePassword,
    implements(ICredentialsChecker)
 
    def requestAvatarId(self, credentials):
        if pam.authenticate(credentials.username, credentials.password):
            return defer.succeed(credentials.username)
        return defer.fail(UnauthorizedLogin("invalid password"))
 
 
class UnixSSHdFactory(factory.SSHFactory):
    publicKeys = {
        'ssh-rsa': keys.Key.fromString(data=publicKey)
    }
    privateKeys = {
        'ssh-rsa': keys.Key.fromString(data=privateKey)
    }
    services = {
        'ssh-userauth': userauth.SSHUserAuthServer,
        'ssh-connection': connection.SSHConnection
    }
 
# Components have already been registered in twisted.conch.unix
 
portal = portal.Portal(UnixSSHRealm())
portal.registerChecker(PamPasswordDatabase())   # Supports PAM
portal.registerChecker(SSHPublicKeyDatabase())  # Supports PKI
UnixSSHdFactory.portal = portal
 
if __name__ == '__main__':
    reactor.listenTCP(5022, UnixSSHdFactory())
    reactor.run()

Some notes:

• The server uses the very same public and private keys as found in the sshsimpleserver.py script. Make sure you generate new keys using ssh-keygen if you plan to run this on a public server (although this not recommended).
• Twisted included a module for PAM authentication, twisted.cred.pamauth, but unfortunately I could not locate one of its dependencies to make it work. So, I used the excellent python-pam to create a custom PAM authenticator class.
• I can guess what you might thought when you read about this code:
  

  Python is a cross-platform programming language. Twisted runs on Windows. So, is this a solution for running a SSH server on Win32?

  Well, at the moment it won’t run because internally it uses some Python modules that are available on UNIX platforms only. But, I intend to investigate the possibility of running this on Windows since I already need something like that.

We can now enjoy our Python SSH server. Run as root:

python scripts/rapidsshd_unix.py

From another machine, connect to the server using an ssh client:

ssh -p 5022 rocky@arena

If you have deployed your public key in the ~/.ssh/authorized_keys file on the remote machine (arena), you should be able to authenticate using the public key:

ssh -p 5022 -i /path/to/private.key rocky@arena

You should get output like the following on the server:

[root@arena ~]# python ssh.py
2010-03-26 21:30:05+0000 [-] Log opened.
2010-03-26 21:30:05+0000 [-] __main__.UnixSSHdFactory starting on 5022
2010-03-26 21:30:05+0000 [-] Starting factory <__main__.UnixSSHdFactory instance at 0xb7a0b0cc>
2010-03-26 21:30:13+0000 [__main__.UnixSSHdFactory] disabling diffie-hellman-group-exchange because we cannot find moduli file
2010-03-26 21:30:13+0000 [SSHServerTransport,0,192.168.0.172] kex alg, key alg: diffie-hellman-group1-sha1 ssh-rsa
2010-03-26 21:30:13+0000 [SSHServerTransport,0,192.168.0.172] outgoing: aes256-ctr hmac-sha1 none
2010-03-26 21:30:13+0000 [SSHServerTransport,0,192.168.0.172] incoming: aes256-ctr hmac-sha1 none
2010-03-26 21:30:14+0000 [SSHServerTransport,0,192.168.0.172] NEW KEYS
2010-03-26 21:30:14+0000 [SSHServerTransport,0,192.168.0.172] starting service ssh-userauth
2010-03-26 21:30:17+0000 [SSHService ssh-userauth on SSHServerTransport,0,192.168.0.172] rocky trying auth none
2010-03-26 21:30:17+0000 [SSHService ssh-userauth on SSHServerTransport,0,192.168.0.172] rocky trying auth publickey
2010-03-26 21:30:17+0000 [SSHService ssh-userauth on SSHServerTransport,0,192.168.0.172] rocky trying auth publickey
2010-03-26 21:30:17+0000 [SSHService ssh-userauth on SSHServerTransport,0,192.168.0.172] rocky authenticated with publickey
2010-03-26 21:30:17+0000 [SSHService ssh-userauth on SSHServerTransport,0,192.168.0.172] starting service ssh-connection
2010-03-26 21:30:17+0000 [SSHService ssh-connection on SSHServerTransport,0,192.168.0.172] got channel session request
2010-03-26 21:30:17+0000 [SSHChannel session (0) on SSHService ssh-connection on SSHServerTransport,0,192.168.0.172] channel open
2010-03-26 21:30:17+0000 [SSHChannel session (0) on SSHService ssh-connection on SSHServerTransport,0,192.168.0.172] pty request: xterm (24L, 80L, 0L, 0L)
2010-03-26 21:30:17+0000 [SSHChannel session (0) on SSHService ssh-connection on SSHServerTransport,0,192.168.0.172] getting shell

This first release of the RapidSSH project exists solely for demonstration purposes. Don’t get fooled by the small amount of code. Information about how to put the pieces together is scarce and it required a lot trial&error and source code reading. The above implementation contains none of the customizations I had in mind. These will be done as soon as I find some time to do so. Until then it will be nice to hear about your experiences or implementations you have worked on.

Related Articles

• Use Python to get the web page data in Epiphany
• Epiphany Python Console – Open New Tab
• Python IRC Bot
• Python Crash Course
• Set up the VNC Server in Fedora

Anyhow, the phone’s internal web browser is the default viewer for plain text files, but this browser will never let you either copy the text in order to paste it in the sms editor or send the file that is being viewed as a text message directly. On the other hand, the phone’s OS will not let you send the file’s contents as text directly either.

…and when things like this happen, it is time for some monkey stuff. I tried to send the contents of the file as SMS through the phone by using two programs, gnokii and gammu, from my fedora desktop. The phone is a Sony-Ericsson K320i. I should state from the beginning that nothing worked.

gnokii & gammu

The bluetooth service (hcid) has been configured properly and the device pairing between the usb dongle and the phone has been accomplished succesfully. Here follow a couple of examples of what I have tried with gnokii and gammu. These are provided for informational purposes only, as nothing worked out. Also, note that the configuration files contain only the absolutely required options in order to work with the phone over the bluetooth interface.

XX:XX:XX:XX:XX:XX represents the phone’s hardware address. Also, channel 2 is used as the rfcomm channel, as the phone’s serial port service “listens” on that channel (see the detailed K320i services over the bluetooth interface).

The gnokii configuration file: /etc/gnokiirc

[global]
port = XX:XX:XX:XX:XX:XX
model = AT
connection = bluetooth
rfcomm_channel = 2

A failed attempt to send the sms directly:

$ echo "test" | gnokii --sendsms +306911111111 -r
GNOKII Version 0.6.14
SMS Send failed (The specified memory is full.)

No, the memory is not full. You make a mistake!

The gammu configuration file: /etc/gammurc

[gammu]
port = XX:XX:XX:XX:XX:XX
connection = blueat

In this example, I will try to save the SMS to an SMS specific folder on the phone. But first, in order to get information about those folders, I issue the command:

$ gammu --getsmsfolders
1. "                         Inbox", SIM memory, Inbox folder
2. "                        Outbox", SIM memory, Outbox folder
3. "                         Inbox", phone memory, Inbox folder
4. "                        Outbox", phone memory, Outbox folder

Then I try to store the message on the phone:

$ echo "test" | gammu --savesms TEXT -folder 4
Saving SMS 1/1
Unknown error.

Ladies and gentlemen… the error is unknown! Unknown error in sight!

Original Monkey Stuff

Having wasted enough time for a single SMS, I started thinking of other ways to get the job done. I noticed that the phone’s OS would let me send calendar appointments, tasks and notes as a text message. So, all I had to do was to save the contents of the text file as one of the aforementioned types of data on the phone.

Although, gnokii and gammu support management of those data types, I did not even try to use either of them.

Instead, I created a task in Evolution, pasted the text file contents in the task descrtiption field and then used multisync (at least this works) in order to transfer the task to the phone. Finally, I sent the task as a text message from the phone’s interface.

I wonder who will give me my wasted time back…

Related Articles

• Sony Ericsson K320i – Advanced Feature List
• Another way to create a text file
• Size text with em in your CSS – Explained with example
• Send to Desktop – Create Symlink
• File and Directory diff in color in Midnight Commander

• Run through cron at predefined intervals. In this case it reads the saved rtorrent session data, creates a summary about the loaded torrent files status and prints the HTML code to stdout, which can then be redirected to a file and thus be made publicly available by a web server.
• Run as a CGI script, which makes it possible to dynamically generate the HTML page on-demand. This method, compared to running rtorstat through cron at short pre-defined intervals, has the advantage of limiting system resource waste by parsing the session data only when a user runs the CGI script through the web browser. Also, depending on your rtorrent settings, the displayed information is usually more current than that of the HTML page generated through cron, unless cron runs the script very often.

rtorstat does not support or will never support any kind of remote rTorrent administration. It is not supposed to be a web-based rtorrent frontend, but, as the title says, a simple status page generator (status web interface).

Requirements

rtorstat is not dependency-free. Here is the list of the required software in order to run rtorstat:

• Python
• rTorrent (configured to save session data – see below)
• The file “bencode.py“, part of the official Bittorrent client (Mainline) distribution, has been included in the rtorstat distribution package, so the Mainline Bittorrent client is no longer a dependency for rtorstat.

rTorrent Configuration

rtorstat needs to read the torrent session data, so rTorrent needs to be configured to save this information to a pre-defined directory. The following shows all the session-data specific configuration rTorrent (.rtorrent.rc) options:

# Sets the directory where session data files are stored
session = /opt/bittorrent/sessiondata
# Keeps session data files even if torrent has finished
session_on_completion = yes
# Not really required, but recommended - see rtorrent(1) man page
session_lock = yes
# Setup A: Run through CRON
# Save session data every 5 mins, with a 4 min offset
schedule = session_save,240,300,session_save=
# Setup B: Run as a CGI
# Save session data every 300 seconds
# (This is an example value. Setting it to a lower value is highly recommended)
#schedule = session_save,300,300,session_save=

The last directive (schedule) instructs rtorrent to save session data at the specified interval.

Usage

rtorstat can be run through cron or as a CGI script. Running it as a CGI is the preferred way of running it as the parsing of the session data and the HTML page generation take place dynamically only when you visit the web page. This leads to wasting less system resources.

Running rtorstat through cron

No special installation is needed as the location of rtorstat.py can be set within the cron job. Just make sure that the file bencode.py exists in the same directory as rtorstat.py.

rtorstat requires one argument; that is the path to the directory where the session data is saved:

$ python rtorstat.py /opt/bittorrent/sessiondata/

Having parsed the session data files and having created the summary, the HTML code is printed to stdout, from where it can be redirected to a html file. For example:

$ python rtorstat.py /opt/bittorrent/sessiondata/ > /var/www/index.html

rtorstat is supposed to be run through cron at regular intervals. In the example configuration above (Setup A), rtorrent saves the session data every 5 minutes (300 sec), so rtorstat needs to be run at the same interval through cron. The 4 min offset (240 sec) that had been set in the rtorrent scheduler serves so that there is good timing between rTorrent saving the session data and rtorstat parsing it.

Such a cron job would be:

*/5 * * * *   root python /path/to/rtorstat.py /opt/bittorrent/sessiondata/ > /var/www/index.html

rtorstat will parse the session data files, for example, at 00:05, 00:10 etc.

Having adjusted the paths according to your configuration, save the above cronjob to a file inside the /etc/cron.d/ directory and you are set.

Running rtorstat as a CGI script

In this case, you need to place 3 files in your cgi-bin: rtorstat.py, rtorstat.cgi and bencode.py.

Apart from the rtorrent configuration, it is required to set the path of the directory where rtorrent saves session data in rtorstat.cgi. So, open rtorstat.cgi in your favourite text editor and fill-in the required information:

session_dir = "/path/to/rtorrent/session/dir/"

Now, you can visit the web page http://yourdomain.example.org/cgi-bin/rtorstat.cgi

Setting up a scriptaliased directory is covered by your web server’s documentation and is outside of the scope of this document.

Security

rtorstat generates a HTML page which is made publicly available through a web server (most probably). Therefore it is your responsibility to secure this location using any of your web server’s access control methods.

License

This project is released under the terms of the Apache License version 2.

Download

All versions of the software, including the latest stable release, are available from the development web site’s download area.

Donate

This software is released as free software. Nevertheless, its development requires time and effort. A small donation, as a sign of appreciation of the effort, is welcome. Please, use the following button to visit the Donations page. Thank you.

Support

This software is released as free software without any warranties or official support. You can still get first class support from the community of users.

Bugs and Feature Requests

Found a bug? Want to suggest a new feature for the upcoming release? Feel free to file your requests in the issue database on the development website.

Things to consider

It has been mentioned before, but here it goes again:

Note that by making the rtorrent status page publicly available through a web server, the world will know what you download at any time. It is your exclusive responsibility to keep this page private, if this is what you really want. This piece of information is of course beyond the scope of this article.

This script was written in a quick and dirty way. If you encounter any bugs, please notify me through the g-loaded forums and I will get back to you when I have the time.

Last, but not least, if you improve the looks, consider contributing back your string template.

Related Articles

• Remove-Generator-Meta-Tag WordPress Plugin
• Write A Man Page
• Use Python to get the web page data in Epiphany
• Print a Man Page
• Simple-Recent-Comments WordPress Plugin

Related Articles

• dircproxy IRC Proxy
• Creative Commons v3.0 Licenses Launched
• CC Configurator plugin version 1.0 is out!
• Bot-Allow-Content and CC-Configurator plugin updates
• Best Practices of Software Licensing

• connect to a server and try to reconnect automatically if the connection is lost
• identify my nick to the server
• join the specified channel and keep a log of the conversation
• play the request-response (ping-pong) game with the server so to be able to stay online as long as I want
• be extremely reliable.

Well, this is not a hell of features! I guess a bot with these capabilities would be very easy to implement in Python, but no time for this kind of stuff… A google search returned some interesting results about such bots. I think I’ll stick to clients written in Python only because this is the language I know well enough, so, in case I need to modify anything, it will be rather easy.

So, here is supybot, phenny, pynfo and pyfibot. All seem to cover my needs, but I think I’ll stick to the supybot. Its website seemed more organised and I have the feeling that I will find any kind of help easily, if I need it.

Apart from these ready-made clients, here are a few articles where the authors document the creation of such a bot with very primitive functionality: IRC bot in python from scratch and a simple IRC bot written in python.

Furthermore, if help about the IRC commands or the protocol itself is required, take a loog at IRChelp.org and at IRC RFCs .

PS: so where am I supposed to test these bots? Freenode or should I quickly set up a local IRC server?

Related Articles

• dircproxy IRC Proxy
• Python SSH Server for UNIX Systems using Twisted.conch
• Use Python to get the web page data in Epiphany
• Python Crash Course
• Epiphany Python Console – Open New Tab

Related Articles

• Creative Commons v3.0 Licenses Launched
• Effectively remove a user from the system
• Troubleshooting with strace
• A CSS trap for comment spambots
• Set up the VNC Server in Fedora

What is a tunnel

Assume that an SSH and a VNC server are up and running on the machine remote.example.org. The remote firewall does not allow direct connections to the VNC port – assume that this is TCP port 5901 – from the network, which is generally a good idea. In this case, we will connect to the remote VNC service from the local workstation through the remote SSH server, by using a feature of the SSH protocol, called local port forwarding or, simply, tunneling.

Such a tunnel can be initialized from the local workstation with the following:

[me@local]$ ssh -L 25901:127.0.0.1:5901 me@remote.example.org

When executed, the above statement has the following results:

1. forwards the local port 25901 on the local workstation to port 5901 on the remote machine through the ssh connection. The port 25901 is an example and it could be any other available TCP port on the local machine. The result is that any request made on the local port 25901 is transfered to port 5901 on the remote machine through the encrypted SSH connection.
2. connects us to the remote SSH server and logs our remote user “me” in.

In order to connect to the remote VNC service through that tunnel, it is required to keep the connection to the ssh server open and, from another local terminal, connect to the local port 25901 with the vnc client:

[me@local]$ vncviewer 127.0.0.1:25901:1

By closing the vnc client and by logging out of the remote shell, the tunnel is destroyed too.

A better way

The previous method is too far from being convenient in the everyday use. Things could be a lot better if we could just create the SSH tunnel and launch vncviewer in one line of code. This can be achieved by using the -f and -N flags when connecting to the remote SSH server:

[me@local]$ ssh -f -N -L 25901:127.0.0.1:5901 me@remote.example.org; \
              vncviewer 127.0.0.1:25901:1

The -f switch instructs the ssh client to fork the ssh session to the background. Therefore, we remain at our local terminal’s prompt, from where we can execute more commands on our local machine. In this case, with a single line of code, we created the tunnel and executed vncviewer. However, the -f switch has one requirement. It cannot be used on its own. It needs to be accompanied either by the -N switch or we have to execute a specific command on the remote machine.

In this case, the -f -N combination keeps the tunnel up and running in the background, but the drawback is that it runs forever, requiring us to explicitly kill the ssh process if the tunnel is not needed any more. Even if we close vncviewer, the following command confirms that the tunnel is still running, which was actually expected:

[me@local]$ ps ax | grep ssh | grep -v grep

The best way – Tunnels that auto-close

As it has been mentioned previously, instead of using the -f -N switch combination, we can just use -f alone, but also execute a command on the remote machine. But, which command should be executed, since we only need to initialize a tunnel?

This is when sleep can be the most useful command of all! In this particular situation, sleep has two advantages:

1. it does nothing, so no resources are consumed
2. the user can specify for how long it will be executed

How these help in auto-closing the ssh tunnel is explained below.

We start the ssh session in the background, while executing the sleep command for 10 seconds on the remote machine. The number of seconds is not crucial. At the same time, we execute vncviewer exactly as before:

[me@local]$ ssh -f -L 25901:127.0.0.1:5901 me@remote.example.org sleep 10; \
              vncviewer 127.0.0.1:25901:1

In this case, the ssh client is instructed to fork the ssh session to the background (-f), create the tunnel (-L 25901:127.0.0.1:5901) and execute the sleep command on the remote server for 10 seconds (sleep 10).

The difference between this method and the previous one (-N switch), basically, is that in this case the ssh client’s primary goal is not to create the tunnel, but rather to execute the sleep command for 10 seconds. The creation of the tunnel is some kind of side-effect, a secondary goal. If vncviewer was not used, the ssh client would exit after the 10 sec period, as it would have no more jobs to do, destroying the tunnel at the same time.

During the execution of the sleep command, if another process, vncviewer in this case, starts using that tunnel and keeps it occupied beyond the 10 sec period, then, even if the ssh client finishes its remote job (execution of sleep), it cannot exit because another process occupies the tunnel. In other words, the ssh client cannot destroy the tunnel because it would have to kill vncviewer as well. When vncviewer stops using the tunnel, then the ssh client exits too, as it has already accomplished its goal.

This way, no ssh processes are left running in the background.

Further Enhancements

Although this is not a general article about the SSH protocol, the following ssh client switches may prove useful in some situations.

The -C switch may be used in order to apply compression to the transfered data between the local workstation and the remote server. This will save some bandwidth, but will increase the cpu load.

Also, a specific encryption algorithm may be specified with the -c option. The blowfish cipher is a rather good choice, which offers good encryption and low cpu utilization.

[me@local]$ ssh -C -c blowfish -f -L 25901:127.0.0.1:5901 me@remote.example.org sleep 10; \
              vncviewer 127.0.0.1:25901:1

Finally, the -v flag can also be used for verbose output.

Related Articles

• SSH Tunnels Headaches
• Set up the VNC Server in Fedora
• Netcat – a couple of useful examples
• Partition images with Partimage and Partimaged
• Setup the SSH server to use keys for authentication

$ nc -l 3333

On the other end, connect to the server with the following:

$ nc 192.168.0.1 3333

In this case, the keyboard acts as the stdin. Anything you type in the server machine’s terminal is transfered to the client machine and vice-versa.

Transfering Files

In the very same way it can be used to transfer files between two computers. You can create a server that serves the file with the following:

$ cat backup.iso | nc -l 3333

Receive backup.iso on the client machine with the following:

$ nc 192.168.0.1 3333 > backup.iso

As you may have noticed, netcat does not show any info about the progress of the data transfer. This is inconvenient when dealing with large files. In such cases, a pipe-monitoring utility like pv can be used to show a progress indicator. For example, the following shows the total amount of data that has been transfered in real-time on the server side:

$ cat backup.iso | pv -b | nc -l 3333

Of course, the same can be implemented on the client side by piping netcat’s output through pv:

$ nc 192.168.0.1 3333 | pv -b > backup.iso

Other Examples

Netcat is extremely useful for creating a partition image and sending it to a remote machine on-the-fly:

$ dd if=/dev/hdb5 | gzip -9 | nc -l 3333

On the remote machine, connect to the server and receive the partition image with the following command:

$ nc 192.168.0.1 3333 | pv -b > myhdb5partition.img.gz

This might not be as classy as the partition backups using partimage, but it is efficient.

Another useful thing is to compress the critical files on the server machine with tar and have them pulled by a remote machine:

$ tar -czf - /etc/ | nc -l 3333

As you can see, there is a dash in the tar options instead of a filename. This is because tar’s output needs to be passed to netcat.

On the remote machine, the backup is pulled in the same way as before:

$ nc 192.168.0.1 3333 | pv -b > mybackup.tar.gz

Security

It is obvious that using netcat in the way described above, the data travels in the clear across the network. This is acceptable in case of a local network, but, in case of transfers across the internet, then it would be a wise choice to do it through an SSH tunnel.

Using an SSH tunnel has two advantages:

1. The data is transfered inside an encrypted tunnel, so it is well-protected.
2. You do not need to keep any open ports in the firewall configuration of the machine that will act as the server, as the connections will take place through SSH.

You pipe the file to a listening socket on the server machine in the same way as before. It is assumed that an SSH server runs on this machine too.

$ cat backup.iso | nc -l 3333

On the client machine connect to the listening socket through an SSH tunnel:

$ ssh -f -L 23333:127.0.0.1:3333 me@192.168.0.1 sleep 10; \
        nc 127.0.0.1 23333 | pv -b > backup.iso

This way of creating and using the SSH tunnel has the advantage that the tunnel is automagically closed after file transfer finishes. For more information and explanation about it please read my article about auto-closing SSH tunnels.

Telnet-like Usage

Netcat can be used in order to talk to servers like telnet does. For example, in order to get the definition of the word “server” from the “WordNet” database at the dict.org dictionary server, I’d do:

$ nc dict.org 2628
220 ..............some WELCOME.....
DEFINE wn server
150 1 definitions retrieved
151 "server" wn "WordNet (r) 2.0"
server
     n 1: a person whose occupation is to serve at table (as in a
          restaurant) [syn: {waiter}]
     2: (court games) the player who serves to start a point
     3: (computer science) a computer that provides client stations
        with access to files and printers as shared resources to a
        computer network [syn: {host}]
     4: utensil used in serving food or drink
.
250 ok [d/m/c = 1/0/18; 0.000r 0.000u 0.000s]
QUIT
221 bye [d/m/c = 0/0/0; 16.000r 0.000u 0.000s]

Works as a Port Scanner too

A useful command line flag is -z. When it is used, netcat does not initiate a connection to the server, but just informs about the open port it has found. Also, instead of a single port, it can accept a port-range to scan. For example:

$ nc -z 192.168.0.1 80-90
Connection to 192.168.0.1 80 port [tcp/http] succeeded!

In this example, netcat scanned the 80-90 range of ports and reported that port 80 is open on the remote machine.

The man page contains some more interesting examples, so take the time to read it.

Notes

All the above examples have been performed on Fedora 5/6. Netcat syntax may vary slightly among Linux distributions, so read the man page carefully.

Netcat provides a primitive way to transfer data between two networked computers. I wouldn’t say it’s an absolutely necessary tool in the everyday use, but there are times that this primitive functionality is very useful.

Related Articles

• Auto-closing SSH tunnels
• SSH Tunnels Headaches
• Set up the VNC Server in Fedora
• Partition images with Partimage and Partimaged
• Use wget or curl to download from RapidShare Premium

Related Articles

• Watch Videos in ASCII Art
• How to author DVD with menus under Linux
• How to recover lost files
• Creative Commons v3.0 Licenses Launched
• The hole trick

Information about its usage can be found inside the script. It is completely unsupported and it will not be further developed.

Special Note: My script visits the blog 60 times/hour, so do not run it on a production blog, unless you have adjusted your web server statistics analysis software to ignore those visits.

Related Articles

• Fast-Static-Feed WordPress Plugin
• Creative-Commons-Configurator WordPress Plugin
• WordPress 2.5 – Plugin Compatibility
• More-Feed-Excerpt WordPress Plugin
• Bot-Allow-Content WordPress plugin