def __enter__(self): for server_number in range(self.number_of_servers): self.mock_server_address, mock_server_port = get_free_port() mock_server = TCPServer(('localhost', mock_server_port), MockEpoServerRequestHandler) mock_server.socket = ssl.wrap_socket( mock_server.socket, certfile=MOCK_EPOHTTPSERVER_CERTNAME, keyfile=MOCK_EPOHTTPSERVER_KEYNAME, server_side=True) mock_server_thread = Thread(target=mock_server.serve_forever) self.servers[server_number] = { "server": mock_server, "thread": mock_server_thread } self.servers[server_number]["thread"].setDaemon(True) self.servers[server_number]["thread"].start() self.server_info_list.append({ SERVER_INFO_SERVER_NAME_KEY: TEST_EPONAME_BASE + str(server_number), SERVER_INFO_SERVER_PORT_KEY: mock_server_port, }) return self.server_info_list
def serve(port_queue: "Queue[int]", shutdown_queue: "Queue[bool]") -> None: httpd = TCPServer(("", 0), handler_class) httpd.timeout = 0.1 if ssl_context: httpd.socket = ssl_context.wrap_socket(httpd.socket, server_side=True) port_queue.put(httpd.server_address[1]) while shutdown_queue.empty(): httpd.handle_request()
def tcp_listener(port): host = "localhost" cntx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER) cntx.load_cert_chain('cert.pem', 'cert.pem') server = TCPServer((host, port), tcp_handler) server.socket = cntx.wrap_socket(server.socket, server_side=True) try: server.serve_forever() except: print("listener shutting down") server.shutdown()
def https_server(address, path, cacert, cert, key, client_verification=False): os.chdir(path) httpd = TCPServer(address, NoLogHttpHandler) context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH, cafile=cacert) context.load_cert_chain(certfile=cert, keyfile=key) if client_verification: context.verify_mode = ssl.CERT_REQUIRED httpd.socket = context.wrap_socket(httpd.socket, server_side=True) httpd.serve_forever()
def serve_https(https_port=80, https=True, start_dir=None, handler_class=SimpleHTTPRequestHandler): ''' setting up server ''' TCPServer.allow_reuse_address = True httpd = TCPServer(("", https_port), handler_class) if https: # If you use SSL, create a ".ssl" directory under your boot directory and # store your private key and certificate in it. keyfile, certfile = cert.create_ssl_cert(socket.gethostname()) httpd.socket = ssl.wrap_socket(httpd.socket, keyfile=keyfile, certfile=certfile, server_side=True) if start_dir: logger.info("Changing dir to {cd}".format(cd=start_dir)) os.chdir(start_dir) socket_addr = httpd.socket.getsockname() print("Serving HTTP on", socket_addr[0], "port", socket_addr[1], "use <Ctrl-C> to stop...") httpd.serve_forever()
def serve_https(https_port=80, https=True, start_dir=None, handler_class=AuthRequestHandler): ''' setting up server ''' httpd = TCPServer(("", https_port), handler_class) if https: httpd.socket = ssl.wrap_socket(httpd.socket, keyfile=KEY_FILE, certfile=CERT_FILE, server_side=True) if start_dir: print("Changing dir to {cd}".format(cd=start_dir)) os.chdir(start_dir) socket_addr = httpd.socket.getsockname() print("Serving HTTP on", socket_addr[0], "port", socket_addr[1], "...") httpd.serve_forever()
def setup_proxy(listen_port: int, listen_ssl: bool, dst_url: str, record: bool, record_file: str, replay: bool, replay_throttle: bool, replay_clear_cache: bool, replay_clear_cache_seconds: int, config: str, verbose: int): with logerr(): with wrap_context('initialization'): extensions = load_extensions(config) _config = Config( listen_port=listen_port, listen_ssl=listen_ssl, dst_url=dst_url, record=record, record_file=record_file, replay=replay, replay_throttle=replay_throttle, replay_clear_cache=replay_clear_cache, replay_clear_cache_seconds=replay_clear_cache_seconds, verbose=verbose, ) if extensions.override_config: extensions.override_config(_config) log.info('Configuration set', **asdict(_config)) RequestHandler.extensions = extensions RequestHandler.config = _config RequestHandler.cache = RequestCache(extensions, _config) TCPServer.allow_reuse_address = True httpd = TCPServer((_config.listen_addr, _config.listen_port), RequestHandler) if _config.listen_ssl: httpd.socket = ssl.wrap_socket(httpd.socket, certfile='./dev-cert.pem', server_side=True) log.info( f'Listening on {_config.listen_scheme} port {_config.listen_port}...' ) try: httpd.serve_forever() finally: httpd.server_close()
httpd = TCPServer(("", opt.port), MyHandler) print("serving at port", opt.port) httpd.serve_forever() else: port = server.port if not port: port = int(opt.port) if port < 100: port = 443 import ssl import subprocess hostname = server.hostname if not hostname: hostname = "localhost" cc = hostname.split(".")[-1] og = hostname.split(".")[-2] if len(cc) > 2: cc = "US" cmd = "openssl req -x509 -newkey rsa:4096 -sha256 -days 3650 -nodes" cmd += " -keyout /tmp/{hostname}.key -out /tmp/{hostname}.crt -subj /C={cc}/L={og}/CN={hostname}".format( **locals()) print(cmd) subprocess.call(cmd, shell=True) cmd = "cat /tmp/{hostname}.key /tmp/{hostname}.crt > /tmp/{hostname}.pem".format( **locals()) subprocess.call(cmd, shell=True) httpd = TCPServer(("", port), MyHandler) httpd.socket = ssl.wrap_socket(httpd.socket, certfile='/tmp/%s.pem' % hostname, server_side=True) print("serving at port", port, "for", SSL) httpd.serve_forever()
def server_https(handler): httpd = TCPServer(("", PORT), handler) httpd.socket = ssl.wrap_socket(httpd.socket, keyfile=KEY_FILE, certfile=CERT_FILE, server_side=True) httpd.serve_forever()
if self.headers.get('Authorization') == None: self.do_AUTHHEAD() self.wfile.write(b'no auth header received') pass elif self.check_user(self.headers.get('Authorization')): SimpleHTTPRequestHandler.do_GET(self) pass else: self.do_AUTHHEAD() self.wfile.write(str.encode(self.headers.get('Authorization'))) self.wfile.write(b'\t!not authenticated\n') pass if certifacate_path is not None: if single_user_key is not None: httpd = TCPServer(('', 4443 if args.port is None else args.port), AuthHandler) else: httpd = TCPServer(('', 4443 if args.port is None else args.port), SimpleHTTPRequestHandler) httpd.socket = ssl.wrap_socket (httpd.socket, certfile=certifacate_path, server_side=True) sa = httpd.socket.getsockname() print("Serving HTTP on "+ str(sa[0])+ " port "+ str(sa[1])+ "...") httpd.serve_forever() else: if single_user_key is not None: httpd = TCPServer(('', 8080 if args.port is None else args.port), AuthHandler) else: httpd = TCPServer(('', 8080 if args.port is None else args.port), SimpleHTTPRequestHandler) sa = httpd.socket.getsockname() print("Serving HTTP on "+ str(sa[0])+ " port "+ str(sa[1])+ "...") httpd.serve_forever()
text = f.read() f.close() self.send_response(200) except IOError: print('Generating new') q.put((hash, origin, vals)) self.send_response(500) text = b'... And then what? Check back later to find out!' self.send_header("Content-type", "text/html") self.send_header("Content-length", len(text)) self.send_header('Access-Control-Allow-Origin', '*') self.end_headers() self.wfile.write(text) def do_OPTIONS(self): self.send_response(200, "ok") self.send_header('Access-Control-Allow-Origin', '*') self.end_headers() GeneratorThread(name='generator-thread').start() PORT = 443 httpd = TCPServer(("", PORT), MyHandler) print("serving at port", PORT) httpd.socket = ssl.wrap_socket (httpd.socket, certfile='/etc/letsencrypt/live/rebiasednews.ddns.net/fullchain.pem', keyfile='/etc/letsencrypt/live/rebiasednews.ddns.net/privkey.pem', server_side=True) httpd.serve_forever()