Definitive guide for creating ssl based server and client in Python 2.6 and higher

client.py

import socket
import sys
import ssl
    
class Client(object):
    recv_length=1024
    def __init__(self, server="localhost", port=5054):
        self.server = server
        self.port = port
        self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.connected = False
        
    def connect(self):
        self.socket.connect((self.server, self.port))
        self.connected = True
        
    def listen(self):
        if self.connected:
            message = self.socket.recv(self.recv_length)
            return message
        
    def send_message(self, message):
        if self.connected:
            self.socket.send("%s\n" % message)
            
    def send_command(self, message):
        self.send_message(message)
        return self.listen()
    
class SecureClient(Client):
    def __init__(self, cert_file_path, server="localhost", port=5054):
        super(FakeSecureClient, self).__init__(server="localhost", port=5054)
        self.socket = ssl.wrap_socket(self.socket, ca_certs=cert_file_path, cert_reqs=ssl.CERT_REQUIRED)
        
if __name__ == "__main__":
    client = SecureClient(sys.argv[1])
    client.connect()
    print client.listen()

generating-keys.md

Public/Private Key Combo

Command to generate keys

openssl genrsa 1024 > key.pem
openssl req -new -x509 -nodes -sha512 -days 3650 -key key.pem > cert.pem

Note

The certificate is the public key and the key is the private key.

server.py

import socket
import sys
import ssl
from multiprocessing import Process

class Server(object):
    def __init__(self, port=5054):
        self.port = port
        
        self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.incoming = []
        self.server_process = None
        
    def process_start(self, response):
        if not self.server_process:
            self.server_process = Process(target=self.start, args=(response,))
        self.server_process.start()
        
    def end(self):
        self.server_process.join(5)
        if self.server_process.is_alive():
            self.server_process.terminate()
            
    def start(self, response):
        self.socket.bind(('localhost', self.port))
        self.socket.listen(5)
        client_socket, _ = self.socket.accept()
        self.handle_client(client_socket, response)
            
    def handle_client(self, client_socket, response):
        client_socket.send(response)
        client_socket.close()
        
class SecureServer(Server):
    def __init__(self, key_file_path, cert_file_path, port=5054):
        super(FakeSecureServer, self).__init__(port=5054)
        self.key_file_path = key_file_path
        self.cert_file_path = cert_file_path
        
    def handle_client(self, client_socket, response):
        secure_socket = ssl.wrap_socket(client_socket, server_side=True, certfile=self.cert_file_path, keyfile=self.key_file_path, ssl_version=ssl.PROTOCOL_SSLv23)
        super(FakeSecureServer, self).handle_client(secure_socket, response)
        
if __name__ == "__main__":
    server = SecureServer(sys.argv[1], sys.argv[2])
    server.process_start("foo")
    server.server_process.join()