secsh 0.1 "bulbasaur" release, 18 sep 2003 (c) 2003 Robey Pointer http://www.lag.net/~robey/secsh/ *** WHAT secsh is a module for python 2.3 that implements the SSH2 protocol for secure (encrypted and authenticated) connections to remote machines. unlike SSL (aka TLS), SSH2 protocol does not require heirarchical certificates signed by a powerful central authority. you may know SSH2 as the protocol that replaced telnet and rsh for secure access to remote shells, but the protocol also includes the ability to open arbitrary channels to remote services across the encrypted tunnel (this is how sftp works, for example). the module works by taking a socket-like object that you pass in, negotiating with the remote server, authenticating (using a password or a given private key), and opening flow-controled "channels" to the server, which are returned as socket-like objects. you are responsible for verifying that the server's host key is the one you expected to see, and you have control over which kinds of encryption or hashing you prefer (if you care), but all of the heavy lifting is done by the secsh module. it is written entirely in python (no C or platform-dependent code) and is released under the GNU LGPL (lesser GPL). *** REQUIREMENTS python 2.3 pyCrypto *** PORTABILITY i code and test this library on Linux and MacOS X. for that reason, i'm pretty sure that it works for all posix platforms, including MacOS. i also think it will work on Windows, though i've never tested it there. if you run into Windows problems, send me a patch: portability is important to me. the Channel object supports a "fileno()" call so that it can be passed into select or poll, for polling on posix. once you call "fileno()" on a Channel, it changes behavior in some fundamental ways, and these ways require posix. so don't call "fileno()" on a Channel on Windows. (the problem is that pipes are used to simulate an open socket, so that the ssh "socket" has an OS-level file descriptor. i haven't figured out how to make pipes on Windows go into non-blocking mode yet. [if you don't understand this last sentence, don't be afraid. the point is to make the API simple enough that you don't HAVE to know these screwy steps. i just don't understand windows enough.]) *** DEMO the demo app (demo.py) is a raw implementation of the normal 'ssh' CLI tool. while the secsh library should work on all platforms, the demo app will only run on posix, because it uses select. you can run demo.py with no arguments, or you can give a hostname (or username@hostname) on the command line. if you don't, it'll prompt you for a hostname and username. if you have an ".ssh/" folder, it will try to read the host keys from there, though it's easily confused. you can choose to authenticate with a password, or with an RSA or DSS key, but it can only read your private key file(s) if they're not password-protected. the demo app leaves a logfile called "demo.log" so you can see what secsh logs as it works. but the most interesting part is probably the code itself, which hopefully demonstrates how you can use the secsh library. *** USE (this section could probably be improved a lot.) first, create a Transport by passing in an existing socket (connected to the desired server). call "start_client(event)", passing in an event which will be triggered when the negotiation is finished (either successfully or not). the event is required because each new Transport creates a new worker thread to handle incoming data asynchronously. after the event triggers, use "is_active()" to determine if the Transport was successfully connected. if so, you should check the server's host key to make sure it's what you expected. don't worry, i don't mean "check" in any crypto sense: i mean compare the key, byte for byte, with what you saw last time, to make sure it's the same key. Transport will handle verifying that the server's key works. next, authenticate, using either "auth_key" or "auth_password". in the future, this API may change to accomodate servers that require both forms of auth. pass another event in so you can determine when the authentication dance is over. if it was successful, "is_authenticated()" will return true. once authentication is successful, the Transport is ready to use. call "open_channel" or "open_session" to create new channels over the Transport (SSH2 supports many different channels over the same connection). these calls block until they succeed or fail, and return a Channel object on success, or None on failure. Channel objects can be treated as "socket-like objects": they implement: recv(nbytes) send(data) settimeout(timeout_in_seconds) close() fileno() [* see note below] because SSH2 has a windowing kind of flow control, if you stop reading data from a Channel and its buffer fills up, the server will be unable to send you any more data until you read some of it. (this won't affect other channels on the Transport, though.) * NOTE that if you use "fileno()", the behavior of the Channel will change slightly, underneath. this shouldn't be noticable outside the library, but this alternate implementation will not work on non-posix systems. so don't try calling "fileno()" on Windows! this has the side effect that you can't pass a Channel to "select" or "poll" on Windows (which should be fine, since those calls don't exist on Windows). calling "fileno()" creates an OS-level pipe and generates a real file descriptor which can be used for polling, BUT should not be used for reading data from the channel: use "recv" instead. because each Transport has a worker thread running in the background, you must call "close()" on the Transport to kill this thread. on many platforms, the python interpreter will refuse to exit cleanly if any of these threads are still running (and you'll have to kill -9 from another shell window). *** CHANGELOG 2003-08-24: * implemented the other hashes: all 4 from the draft are working now * added 'aes128-cbc' and '3des-cbc' cipher support * fixed channel eof/close semantics 2003-09-12: version "aerodactyl" * implemented group-exchange kex ("kex-gex") * implemented RSA/DSA private key auth 2003-09-13: * fixed inflate_long and deflate_long to handle negatives, even though they're never used in the current ssh protocol 2003-09-14: * fixed session_id handling: re-keying works now * added the ability for a Channel to have a fileno() for select/poll purposes, although this will cause worse window performance if the client app isn't careful 2003-09-16: version "bulbasaur" * fixed pipe (fileno) method to be nonblocking and it seems to work now * fixed silly bug that caused large blocks to be truncated 2003-10-08: * patch to fix Channel.invoke_subsystem and add Channel.exec_command [vaclav dvorak] * patch to add Channel.sendall [vaclav dvorak] * patch to add Channel.shutdown [vaclav dvorak] * patch to add Channel.makefile and a ChannelFile class which emulates a python file object [vaclav dvorak] 2003-10-26: * thread creation no longer happens during construction -- use the new method "start_client(event)" to get things rolling * re-keying now takes place after 1GB of data or 1 billion packets (these limits can be easily changed per-session if needed) *** MISSING LINKS * ctr forms of ciphers are missing (blowfish-ctr, aes128-ctr, aes256-ctr) * can't handle password-protected private key files * multi-part auth not supported (ie, need username AND pk) * should have a simple synchronous method that handles all auth & events, by pre-seeding the password or key info, and the expected key