{"id":8473,"date":"2018-03-05T07:39:56","date_gmt":"2018-03-05T12:39:56","guid":{"rendered":"https:\/\/qxf2.com\/blog\/?p=8473"},"modified":"2020-01-30T11:58:06","modified_gmt":"2020-01-30T16:58:06","slug":"ssh-using-python-paramiko","status":"publish","type":"post","link":"https:\/\/qxf2.com\/blog\/ssh-using-python-paramiko\/","title":{"rendered":"SSH using Python Paramiko"},"content":{"rendered":"

Recently, as part of an automated test, we needed to SSH<\/a> into a server, toggle a service and then check the response on a web application. We used the Python module Paramiko<\/a>. We ended up writing simple wrappers around the most common actions test automation may need to perform over SSH. In this post, we will share the same. <\/p>\n

We have written this tutorial for absolute beginners. If you are already familiar with SSH (there are people who are not!) and comfortable with Python, please jump ahead to the section ‘Putting it all together’.<\/p>\n

Note 1:<\/strong> We have also integrated this code into our open-sourced Python test automation framework<\/a><\/strong>.
\nNote 2:<\/strong> The Python 3 code for this article is here<\/a><\/strong><\/p>\n

\n

How SSH Works<\/h3>\n

The SSH connection is implemented using a client-server model. To establish a connection the server should be running and clients generally authenticated either using passwords or SSH keys. Password Authentication is simple and straightforward. To authenticate using SSH keys, a user must have an SSH key pair (Public and Private key). On the remote server, the list of public keys is maintained (usually) in the ~\/.ssh\/authorized_keys directory. When the client connects to the remote server using the public key, the server checks for it and sends an encrypted message which can only be decrypted with the associated private key at the client side. We will be using a Python module called Paramiko<\/a>. The Paramiko module gives an abstraction of the SSHv2 protocol with both the client side and server side functionality. As a client, you can authenticate yourself using a password or key and as a server, you can decide which users are allowed access and the channels you allow.<\/p>\n

\n

Installing Paramiko<\/h3>\n

Installing Paramiko is straightforward, it has only one direct hard dependency: the Cryptography<\/a> library. If pip is above 8.x, nothing else is required. pip will install statically compiled binary archives of Cryptography its dependencies. For more details on installation, please refer to this Paramiko\u2019s documentation<\/a>.<\/p>\n

To install Paramiko on Windows<\/p>\n

pip install paramiko\r\n<\/pre>\n
\n
Overview of the Parmiko tutorial<\/h3>\n
In the coming sections, we will be talking about below items:<\/p>\n
  • Connecting to the remote server using Paramiko<\/li>\n
  • Executing commands on the server<\/li>\n
  • File transfers<\/li>\n
  • Putting it all together<\/li>\n
    We have written different methods for each functionality. All the parameters are read from a configuration file. We are reading the parameters like credentials, commands & file paths from the conf file because when there is any change in the machine or any credential changes, changing the configuration file alone is enough instead of changing the script.<\/p>\n
    After importing Paramiko, to make everything more modular, we created a class called Ssh_Util and wrote different methods for each functionality.<\/p>\n
    \n
    Connecting to the remote server using Paramiko<\/h3>\n
    Firstly, we created an initialization function inside the class and initialized required variables. Some of the parameters like host, username, password etc., are read from a configuration file.<\/p>\n
    \r\ndef __init__(self):\r\n        self.ssh_output = None\r\n        self.ssh_error = None\r\n        self.client = None\r\n        self.host= conf_file.HOST\r\n        self.username = conf_file.USERNAME\r\n        self.password = conf_file.PASSWORD\r\n        self.timeout = float(conf_file.TIMEOUT)\r\n        self.commands = conf_file.COMMANDS\r\n        self.pkey = conf_file.PKEY\r\n        self.port = conf_file.PORT\r\n        self.uploadremotefilepath = conf_file.UPLOADREMOTEFILEPATH\r\n        self.uploadlocalfilepath = conf_file.UPLOADLOCALFILEPATH\r\n        self.downloadremotefilepath = conf_file.DOWNLOADREMOTEFILEPATH\r\n        self.downloadlocalfilepath = conf_file.DOWNLOADLOCALFILEPATH\r\n<\/pre>\n
    We created a function connect() and placed inside the Ssh_Util class. This function will be used to connect to the remote server.<\/p>\n
    \r\ndef connect(self):\r\n        \"Login to the remote server\"\r\n        try:\r\n            #Paramiko.SSHClient can be used to make connections to the remote server and transfer files\r\n            print(\"Establishing ssh connection\")\r\n            self.client = paramiko.SSHClient()\r\n            #Parsing an instance of the AutoAddPolicy to set_missing_host_key_policy() changes it to allow any host.\r\n            self.client.set_missing_host_key_policy(paramiko.AutoAddPolicy())\r\n            #Connect to the server\r\n            if (self.password == ''):\r\n                private_key = paramiko.RSAKey.from_private_key_file(self.pkey)\r\n                self.client.connect(hostname=self.host, port=self.port, username=self.username, pkey=private_key, timeout=self.timeout, allow_agent=False,look_for_keys=False)\r\n                print(\"Connected to the server\",self.host)\r\n            else:\r\n                self.client.connect(hostname=self.host, port=self.port, username=self.username, password=self.password,timeout=self.timeout, allow_agent=False,look_for_keys=False)    \r\n                print(\"Connected to the server\",self.host)\r\n        except paramiko.AuthenticationException:\r\n            print(\"Authentication failed, please verify your credentials\")\r\n            result_flag = False\r\n        except paramiko.SSHException as sshException:\r\n            print(\"Could not establish SSH connection: %s\" % sshException)\r\n            result_flag = False\r\n        except socket.timeout as e:\r\n            print(\"Connection timed out\")\r\n            result_flag = False\r\n        except Exception,e:\r\n            print(\"Exception in connecting to the server\")\r\n            print(\"PYTHON SAYS:\",e)\r\n            result_flag = False\r\n            self.client.close()\r\n        else:\r\n            result_flag = True\r\n        \r\n        return result_flag \r\n<\/pre>\n
    Firstly, we created an instance ‘client’ of paramiko.SSHClient()<\/em>. Paramiko.SSHClient<\/a> is the primary client used to make connections to the remote server and execute commands. This class wraps Transport<\/a>, Channel<\/a>, and SFTPClient<\/a> to take care of most aspects of authenticating and opening channels. The creation of an SSHClient object allows establishing server connections via the connect() method.<\/p>\n
    When we try to connect to a server for the first time, we see an error message prompted saying that the machine is not informed about the remote server that we are trying to access. Paramiko’s client.set_missing_host_key_policy<\/a> is the method used for this purpose. By default, the paramiko.SSHclient sets the policy to the Reject<\/a> policy which means the policy rejects connection without validating. In our code, we are overriding this by passing AutoAddPolicy()<\/a> function where the new server will automatically add the server’s host key without prompting. Note:-<\/strong> In a testing environment, we can use set_missing_host_key_policy<\/em> and set AutoAddPolicy<\/em> but for security purpose, this is not a good idea to use in production.<\/p>\n
    Paramiko supports both password-based authentication and key-pair based authentication for accessing the server. In our code, we are checking for a password and if available, authentication is attempted using plain username\/password authentication. If the password is not available, authentication is attempted by reading the private key file.<\/p>\n
    client.Connect()<\/a> is to connect to an SSH server. This method also allows to provide our own private key, or connect to the SSH agent on the local machine or read from the user’s local key files. We also used timeout (in seconds) to wait for an authentication response. We are capturing a couple of exceptions like paramiko.AuthenticationException, paramiko.SSHException, Socket.timeout to handle the errors while connecting.<\/p>\n
    \n
    Executing commands on the server<\/h3>\n
    Now, you are connected to the remote server. The next step is to execute commands on the SSH server. To run a command on the server the exec_command()<\/a> function is called on the SSHClient with the command passed as input. When you execute commands using exec_command a new Channel is opened and the requested command is executed. The response is returned as Python file-like objects representing stdin, stdout, and stderr(as a 3-tuple)<\/p>\n