def __init__(self, server_address, RequestHandlerClass, maxthreads=100, pemfile=None, rest_handlers=None, userpass=None): try: if pemfile: #HTTPS server BaseServer.__init__(self, server_address, RequestHandlerClass) ctx = SSL.Context(SSL.SSLv23_METHOD) ctx.use_privatekey_file(pemfile) ctx.use_certificate_file(pemfile) self.socket = SSL.Connection(ctx, socket.socket(self.address_family, self.socket_type)) self.server_bind() self.server_activate() self.httpstyle = "HTTPS" else: #HTTP server BaseHTTPServer.__init__(self, server_address, RequestHandlerClass) self.httpstyle = "HTTP" except socket.error as e: if e.errno == 98: logging.log(logging.ERROR, "Cannot start HTTP server, address already in use") return else: raise self.lock = thread.allocate_lock() self.maxthreads = maxthreads self.threads = 0 self.rest_handlers = rest_handlers self.userpass = userpass
def __init__(self, server_address, handler_class, config, bind_and_activate=True): # pylint: disable=non-parent-init-called # Init just BaseServer, TCPServer creates a socket. BaseServer.__init__(self, server_address, handler_class) if isinstance(server_address, socket.socket): # It's a bound and activates socket from systemd. self.socket = server_address bind_and_activate = False else: self.socket = socket.socket(self.address_family, self.socket_type) # copied from TCPServer if bind_and_activate: try: self.server_bind() self.server_activate() except BaseException: self.server_close() raise if self.socket.family == socket.AF_UNIX: self.socket_file = self.socket.getsockname() if 'consumers' not in config: raise ValueError('Configuration does not provide any consumer') self.config = config if 'server_string' in self.config: self.server_string = self.config['server_string'] self.auditlog = log.auditlog
def __init__(self, server_address, HandlerClass, options): BaseServer.__init__(self, server_address, HandlerClass) pwd = os.path.dirname(os.path.realpath(__file__)) keys = os.path.join(pwd, options.key) certs = os.path.join(pwd, options.cert) self.options = options self.hook_set = HookSet() self.daemon_threads = True self.protocol_version = 'HTTP/1.1' if options.load: self.hook_set.load(options.load) if options.clientverify: self.socket = ssl.wrap_socket( socket.socket(self.address_family, self.socket_type), keyfile=keys, certfile=certs, server_side=True, cert_reqs=ssl.CERT_REQUIRED, ca_certs='/etc/ssl/certs/ca-certificates.crt') else: self.socket = ssl.wrap_socket(socket.socket( self.address_family, self.socket_type), keyfile=keys, certfile=certs, server_side=True) self.server_bind() self.server_activate()
def __init__(self, server_address, HandlerClass): BaseServer.__init__(self, server_address, HandlerClass) ctx = ssl.SSLContext(ssl.PROTOCOL_SSLv23) ctx.load_cert_chain(certfile=CERT, keyfile=KEY) self.socket = ctx.wrap_socket(socket.socket(self.address_family, self.socket_type), server_side=True) self.server_bind() self.server_activate()
def __init__(self, server_address, runner_factory, lifecycle_lock, request_complete_callback, handler_class=None, bind_and_activate=True): """Override of TCPServer.__init__(). N.B. the majority of this function is copied verbatim from TCPServer.__init__(). :param tuple server_address: An address tuple of (hostname, port) for socket.bind(). :param class runner_factory: A factory function for creating a DaemonPantsRunner for each run. :param threading.RLock lifecycle_lock: A lock used to guard against abrupt teardown of the servers execution thread during handling. All pailgun request handling will take place under care of this lock, which would be shared with a `PailgunServer`-external lifecycle manager to guard teardown. :param function request_complete_callback: A callback that will be called whenever a pailgun request is completed. :param class handler_class: The request handler class to use for each request. (Optional) :param bool bind_and_activate: If True, binds and activates networking at __init__ time. (Optional) """ # Old-style class, so we must invoke __init__() this way. BaseServer.__init__(self, server_address, handler_class or PailgunHandler) self.socket = RecvBufferedSocket(socket.socket(self.address_family, self.socket_type)) self.runner_factory = runner_factory self.lifecycle_lock = lifecycle_lock self.allow_reuse_address = True # Allow quick reuse of TCP_WAIT sockets. self.server_port = None # Set during server_bind() once the port is bound. self.request_complete_callback = request_complete_callback self.logger = logging.getLogger(__name__) self.free_to_handle_request_lock = PailgunHandleRequestLock() if bind_and_activate: try: self.server_bind() self.server_activate() except Exception: self.server_close() raise
def __init__(self, server_address, RequestHandlerClass, bind_and_activate=True): BaseServer.__init__(self, server_address, RequestHandlerClass) self.socket = socket.socket(self.address_family, self.socket_type, 262) if bind_and_activate: self.server_bind() self.server_activate()
def __init__(self, server_address, RequestHandlerClass, bind_and_activate=True): BaseServer.__init__(self, server_address, RequestHandlerClass) self.socket = ssl.wrap_socket(socket.socket(self.address_family, self.socket_type), "./server.key", "./server.crt", True, ssl.CERT_REQUIRED, ssl.PROTOCOL_TLSv1, "./trusted.crt") if bind_and_activate: self.server_bind() self.server_activate()
def __init__(self, server_address, HandlerClass): BaseServer.__init__(self, server_address, HandlerClass) self.socket = ssl.SSLSocket( sock=socket.socket(self.address_family, self.socket_type), ssl_version=ssl.PROTOCOL_TLSv1, certfile='server.pem', server_side=True) self.server_bind() self.server_activate()
def __init__(self, server_address, HandlerClass): BaseServer.__init__(self, server_address, HandlerClass) ctx = SSL.Context(SSL.SSLv23_METHOD) fpem = 'server.pem' # location of the server private key and the server certificate ctx.use_privatekey_file(fpem) ctx.use_certificate_file(fpem) self.socket = SSL.Connection( ctx, socket.socket(self.address_family, self.socket_type)) self.server_bind() self.server_activate()
def __init__(self, server_address, multicast_group, RequestHandlerClass, bind_and_activate=True, multicast_ttl = 1): BaseServer.__init__(self, server_address, RequestHandlerClass) self.socket = socket.socket(self.address_family, self.socket_type, self.protocol_type) self.multicast_group = multicast_group self.multicast_ttl = multicast_ttl if bind_and_activate: self.server_bind() self.server_activate()
def __init__(self,address,handler): BaseServer.__init__(self,address,handler) self.socket = ssl.SSLSocket( sock=socket.socket(self.address_family,self.socket_type), ssl_version=ssl.PROTOCOL_TLSv1, certfile=os.path.join(os.path.dirname(__file__), 'test.pem'), server_side=True) self.server_bind() self.server_activate()
def __init__(self, server_address, HandlerClass): BaseServer.__init__(self, server_address, HandlerClass) ctx = SSL.Context(SSL.SSLv23_METHOD) fpem = MongoServer.pem ctx.use_privatekey_file(fpem) ctx.use_certificate_file(fpem) self.socket = SSL.Connection(ctx, socket.socket(self.address_family, self.socket_type)) self.server_bind() self.server_activate()
def __init__(self, address, handler): """ Initialise the secure handlers for the SSL server if required.s """ BaseServer.__init__(self, address, handler) local_data = AppLocation.get_directory(AppLocation.DataDir) self.socket = ssl.SSLSocket( sock=socket.socket(self.address_family, self.socket_type), certfile=os.path.join(local_data, 'remotes', 'openlp.crt'), keyfile=os.path.join(local_data, 'remotes', 'openlp.key'), server_side=True) self.server_bind() self.server_activate()
def __init__(self, port, host='127.0.0.1', use_ssl = False, ssl_certfile = '', ssl_private_key = ''): self.port = port self.use_ssl = True if use_ssl: BaseServer.__init__(self, (host, port), WebSocketHandler) ctx = SSL.Context(SSL.SSLv23_METHOD) ctx.use_privatekey_file(ssl_private_key) ctx.use_certificate_file(ssl_certfile) self.socket = SSL.Connection(ctx, socket.socket(self.address_family, self.socket_type)) self.server_bind() self.server_activate() else: TCPServer.__init__(self, (host, port), WebSocketHandler)
def __init__(self, server_address, HandlerClass): BaseServer.__init__(self, server_address, HandlerClass) ctx = SSL.Context(SSL.SSLv23_METHOD) # server.pem's location (containing the server private key and # the server certificate). fpem_priv = 'newreq.pem' # server fpem_cli = 'newcert.pem' # cli ctx.use_privatekey_file(fpem_priv) ctx.use_certificate_file(fpem_cli) self.socket = SSL.Connection(ctx, socket.socket(self.address_family, self.socket_type)) self.server_bind() self.server_activate()
def __init__(self, server_address, HandlerClass): BaseServer.__init__(self, server_address, HandlerClass) ctx = ssl.SSLContext(ssl.PROTOCOL_SSLv23) fpem = '../cacert.crt' ctx.load_verify_locations(fpem) ctx.verify_mode = ssl.CERT_NONE self.socket = ssl.SSLSocket(ctx, socket.socket(self.address_family, self.socket_type), certfile = fpem) self.server_bind() self.server_activate()
def __init__ (self, address, handler): BaseServer.__init__ (self, address, handler) print (os.getcwd()) CERTFILE = os.path.abspath (os.path.join ('..', 'certs', 'wget-cert.pem')) print (CERTFILE) fop = open (CERTFILE) print (fop.readline()) self.socket = ssl.wrap_socket ( sock = socket.socket (self.address_family, self.socket_type), ssl_version = ssl.PROTOCOL_TLSv1, certfile = CERTFILE, server_side = True ) self.server_bind () self.server_activate ()
def __init__ (self, address, handler): import ssl BaseServer.__init__ (self, address, handler) # step one up because test suite change directory away from $srcdir (don't do that !!!) CERTFILE = os.path.abspath(os.path.join('..', os.getenv('srcdir', '.'), 'certs', 'wget-cert.pem')) fop = open (CERTFILE) print (fop.readline()) self.socket = ssl.wrap_socket ( sock = socket.socket (self.address_family, self.socket_type), ssl_version = ssl.PROTOCOL_TLSv1, certfile = CERTFILE, server_side = True ) self.server_bind() self.server_activate()
def __init__(self, address, handler): import ssl BaseServer.__init__(self, address, handler) # step one up because test suite change directory away from $srcdir (don't do that !!!) CERTFILE = os.path.abspath( os.path.join('..', os.getenv('srcdir', '.'), 'certs', 'wget-cert.pem')) fop = open(CERTFILE) print(fop.readline()) self.socket = ssl.wrap_socket(sock=socket.socket( self.address_family, self.socket_type), ssl_version=ssl.PROTOCOL_TLSv1, certfile=CERTFILE, server_side=True) self.server_bind() self.server_activate()
def __init__(self, server_address, HandlerClass): BaseServer.__init__(self, server_address, HandlerClass) # SSLv2 and SSLv3 supported ctx = SSL.Context(SSL.SSLv23_METHOD) # pem files defined before fpem_priv = 'newreq.pem' fpem_cli = 'newcert.pem' # establish private key ctx.use_privatekey_file(fpem_priv) # establish public/client certificate ctx.use_certificate_file(fpem_cli) # setup the ssl socket self.socket = SSL.Connection( ctx, socket.socket(self.address_family, self.socket_type)) # bind to interface self.server_bind() # activate the interface self.server_activate()
def __init__(self, server_address, HandlerClass, options): BaseServer.__init__(self, server_address, HandlerClass) pwd = os.path.dirname(os.path.realpath(__file__)) keys = os.path.join(pwd,options.key) certs = os.path.join(pwd,options.cert) self.options = options self.daemon_threads = True self.protocol_version = 'HTTP/1.1' if options.clientverify: self.socket = ssl.wrap_socket(socket.socket(self.address_family, self.socket_type), keyfile=keys, certfile=certs, server_side=True, cert_reqs=ssl.CERT_REQUIRED, ca_certs='/etc/ssl/certs/ca-certificates.crt') else: self.socket = ssl.wrap_socket(socket.socket(self.address_family, self.socket_type), keyfile=keys, certfile=certs, server_side=True) self.server_bind() self.server_activate()
def __init__(self, server_address, HandlerClass): BaseServer.__init__(self, server_address, HandlerClass) # SSLv2 and SSLv3 supported ctx = SSL.Context(SSL.SSLv23_METHOD) # pem files defined before fpem_priv = 'newreq.pem' fpem_cli = 'newcert.pem' # establish private key ctx.use_privatekey_file(fpem_priv) # establish public/client certificate ctx.use_certificate_file(fpem_cli) # setup the ssl socket self.socket = SSL.Connection(ctx, socket.socket( self.address_family, self.socket_type)) # bind to interface self.server_bind() # activate the interface self.server_activate()
def __init__(self, address, handler): global logger try: BaseServer.__init__(self, address, handler) self.socket = ssl.SSLSocket( sock=socket.socket(self.address_family, self.socket_type), ssl_version=ssl.PROTOCOL_TLSv1, certfile=settings.ServerParams["Certificate"], server_side=True) self.server_bind() self.server_activate() # create http logger logger = logging.getLogger('HTTP') logger.setLevel(settings.SystemParams["LogLevel"]) logger.addHandler(log.ch) logger.info('HTTPS server started. Press ^C to stop') except Exception as err: Logger.error('Error during HTTPS server starting')
def __init__(self, server_address, HandlerClass): BaseServer.__init__(self, server_address, HandlerClass); fpem = SnakeCharmer_config.fpem; http_socket = socket.socket( self.address_family, self.socket_type); print( fpem ); self.socket = ssl.wrap_socket( http_socket, server_side=True, certfile=fpem, cert_reqs=ssl.CERT_NONE, ssl_version=ssl.PROTOCOL_SSLv23, do_handshake_on_connect=False ); self.server_bind(); self.server_activate();
def __init__(self, address, handler): import ssl BaseServer.__init__(self, address, handler) # step one up because test suite change directory away from $srcdir # (don't do that !!!) CERTFILE = os.path.abspath(os.path.join('..', os.getenv('srcdir', '.'), 'certs', 'server-cert.pem')) KEYFILE = os.path.abspath(os.path.join('..', os.getenv('srcdir', '.'), 'certs', 'server-key.pem')) self.socket = ssl.wrap_socket( sock=socket.socket(self.address_family, self.socket_type), certfile=CERTFILE, keyfile=KEYFILE, server_side=True ) self.server_bind() self.server_activate()
def __init__(self, server_address, HandlerClass, cmd=None, env_term=None, ssl_enabled=True, ssl_cert=None, www_dir='www'): BaseServer.__init__(self, server_address, HandlerClass) self.webshell_files = {} for i in ['css', 'html', 'js', 'gif', 'jpg', 'png']: for j in glob.glob(www_dir + '/*.%s' % i): self.webshell_files[os.path.basename(j)] = open(j) self.webshell_mime = mimetypes.types_map.copy() self.webshell_multiplex = Multiplex(cmd, env_term) # Open socket self.socket = socket.socket(self.address_family, self.socket_type) if ssl_enabled: self.socket = ssl.wrap_socket(self.socket, certfile=ssl_cert, server_side=True) self.server_bind() self.server_activate()
def __init__( self, server_address: t.Tuple[str, int], RequestHandlerClass: t.Callable[..., ProxyHandler], bind_and_activate: bool = True, ) -> None: # NOTE # Extending the TCPServer.__init__() such as the router # can reuse the address. BaseServer.__init__(self, server_address, RequestHandlerClass) self.socket = socket.socket(self.address_family, self.socket_type) self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) if bind_and_activate: try: self.server_bind() self.server_activate() except: self.server_close() raise # NOTE # IN --> append() # OUT --> popleft() self._rooting2: t.Deque[int] = deque()
def __init__(self, server_address, RequestHandlerClass): BaseServer.__init__(self, server_address, RequestHandlerClass) self.server_bind()
def __init__(self, ip, port, keyFile=DEFAULTKEYFILE, certFile=DEFAULTCERTFILE, logRequests=True): self.logRequests = logRequests class VerifyingRequestHandler(SimpleXMLRPCRequestHandler): def setup(myself): myself.connection = myself.request myself.rfile = socket.socket.makefile(myself.request, "rb", myself.rbufsize) myself.wfile = socket.socket.makefile(myself.request, "wb", myself.wbufsize) def address_string(myself): "getting 'FQDN' from host seems to stall on some ip addresses, so... just (quickly!) return raw host address" host, port = myself.client_address #return socket.getfqdn(host) return host def do_POST(myself): """Handles the HTTPS POST request. It was copied out from SimpleXMLRPCServer.py and modified to shutdown the socket cleanly. """ try: # get arguments data = myself.rfile.read(int(myself.headers["content-length"])) # In previous versions of SimpleXMLRPCServer, _dispatch # could be overridden in this class, instead of in # SimpleXMLRPCDispatcher. To maintain backwards compatibility, # check to see if a subclass implements _dispatch and dispatch # using that method if present. response = myself.server._marshaled_dispatch(data, getattr(myself, '_dispatch', None)) except Exception as info: # This should only happen if the module is buggy print ("ERROR do_POST: ", info) print ("Traceback follows:", traceback.print_exc()) # internal error, report as HTTP server error myself.send_response(500) myself.end_headers() else: # got a valid XML RPC response myself.send_response(200) myself.send_header("Content-type", "text/xml") myself.send_header("Content-length", str(len(response))) myself.end_headers() myself.wfile.write(response) # shut down the connection myself.wfile.flush() myself.connection.shutdown() # Modified here! def do_GET(myself): """Handles the HTTP GET request. Interpret all HTTP GET requests as requests for server documentation. """ # Check that the path is legal if not myself.is_rpc_path_valid(): myself.report_404() return response = myself.server.generate_html_documentation() myself.send_response(200) myself.send_header("Content-type", "text/html") myself.send_header("Content-length", str(len(response))) myself.end_headers() myself.wfile.write(response) # shut down the connection myself.wfile.flush() myself.connection.shutdown() # Modified here! def report_404(myself): # Report a 404 error myself.send_response(404) response = 'No such page' myself.send_header("Content-type", "text/plain") myself.send_header("Content-length", str(len(response))) myself.end_headers() myself.wfile.write(response) # shut down the connection myself.wfile.flush() myself.connection.shutdown() # Modified here! def parse_request(myself): if SimpleXMLRPCRequestHandler.parse_request(myself): basic, foo, encoded = myself.headers.get('Authorization').partition(' ') username, foo, password = b64decode(encoded).decode('UTF-8').partition(':') if username == 'admin': return True else: myself.send_error(401, 'Authentication failed') return False SimpleXMLRPCDispatcher.__init__(self, False, None) BaseServer.__init__(self, (ip, port), VerifyingRequestHandler) # SSL socket stuff ctx = SSL.Context(SSL.SSLv23_METHOD) ctx.use_privatekey_file(keyFile) ctx.use_certificate_file(certFile) self.socket = SSL.Connection(ctx, socket.socket(self.address_family, self.socket_type)) self.server_bind() self.server_activate() self.funcs = {} self.register_introspection_functions() self.register_instance(Services()) # requests count and condition, to allow for keyboard quit via CTL-C self.requests = 0 self.rCondition = Condition()
def __init__(self, ip, port, keyFile=DEFAULTKEYFILE, certFile=DEFAULTCERTFILE, logRequests=True): self.logRequests = logRequests class VerifyingRequestHandler(SimpleXMLRPCRequestHandler): def setup(myself): myself.connection = myself.request myself.rfile = socket.socket.makefile(myself.request, "rb", myself.rbufsize) myself.wfile = socket.socket.makefile(myself.request, "wb", myself.wbufsize) def address_string(myself): "getting 'FQDN' from host seems to stall on some ip addresses, so... just (quickly!) return raw host address" host, port = myself.client_address #return socket.getfqdn(host) return host def do_POST(myself): """Handles the HTTPS POST request. It was copied out from SimpleXMLRPCServer.py and modified to shutdown the socket cleanly. """ try: # get arguments data = myself.rfile.read( int(myself.headers["content-length"])) # In previous versions of SimpleXMLRPCServer, _dispatch # could be overridden in this class, instead of in # SimpleXMLRPCDispatcher. To maintain backwards compatibility, # check to see if a subclass implements _dispatch and dispatch # using that method if present. response = myself.server._marshaled_dispatch( data, getattr(myself, '_dispatch', None)) except Exception as info: # This should only happen if the module is buggy print("ERROR do_POST: ", info) print("Traceback follows:", traceback.print_exc()) # internal error, report as HTTP server error myself.send_response(500) myself.end_headers() else: # got a valid XML RPC response myself.send_response(200) myself.send_header("Content-type", "text/xml") myself.send_header("Content-length", str(len(response))) myself.end_headers() myself.wfile.write(response) # shut down the connection myself.wfile.flush() myself.connection.shutdown() # Modified here! def do_GET(myself): """Handles the HTTP GET request. Interpret all HTTP GET requests as requests for server documentation. """ # Check that the path is legal if not myself.is_rpc_path_valid(): myself.report_404() return response = myself.server.generate_html_documentation() myself.send_response(200) myself.send_header("Content-type", "text/html") myself.send_header("Content-length", str(len(response))) myself.end_headers() myself.wfile.write(response) # shut down the connection myself.wfile.flush() myself.connection.shutdown() # Modified here! def report_404(myself): # Report a 404 error myself.send_response(404) response = 'No such page' myself.send_header("Content-type", "text/plain") myself.send_header("Content-length", str(len(response))) myself.end_headers() myself.wfile.write(response) # shut down the connection myself.wfile.flush() myself.connection.shutdown() # Modified here! def parse_request(myself): if SimpleXMLRPCRequestHandler.parse_request(myself): basic, foo, encoded = myself.headers.get( 'Authorization').partition(' ') username, foo, password = b64decode(encoded).decode( 'UTF-8').partition(':') if username == 'admin': return True else: myself.send_error(401, 'Authentication failed') return False SimpleXMLRPCDispatcher.__init__(self, False, None) BaseServer.__init__(self, (ip, port), VerifyingRequestHandler) # SSL socket stuff ctx = SSL.Context(SSL.SSLv23_METHOD) ctx.use_privatekey_file(keyFile) ctx.use_certificate_file(certFile) self.socket = SSL.Connection( ctx, socket.socket(self.address_family, self.socket_type)) self.server_bind() self.server_activate() self.funcs = {} self.register_introspection_functions() self.register_instance(Services()) # requests count and condition, to allow for keyboard quit via CTL-C self.requests = 0 self.rCondition = Condition()
def __init__(self, server_address, RequestHandlerClass, bind_and_activate=True): self.remove_file = None self.mode = None self.listen_fd = get_listen_fd() if self.listen_fd: server_address = self.listen_fd self.address_family = socket.AF_UNIX self.socket = socket.fromfd(self.listen_fd, socket.AF_UNIX, socket.SOCK_STREAM) elif server_address.startswith("unix:"): self.address_family = socket.AF_UNIX address = server_address[5:] m = address.rfind(';mode=') if m != -1: self.mode = address[m + 6:] address = address[:m] if address[0] == '@': address = address.replace('@', '\0', 1) self.mode = None else: self.remove_file = address server_address = address self.socket = socket.socket(self.address_family, self.socket_type) self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) elif server_address.startswith("tcp:"): address = server_address[4:] p = address.rfind(':') if p != -1: port = int(address[p + 1:]) address = address[:p] else: raise ConnectionError("Invalid address 'tcp:%s'" % address) address = address.replace('[', '') address = address.replace(']', '') try: res = socket.getaddrinfo(address, port, proto=socket.IPPROTO_TCP, flags=socket.AI_NUMERICHOST) except TypeError: res = socket.getaddrinfo(address, port, self.address_family, self.socket_type, socket.IPPROTO_TCP, socket.AI_NUMERICHOST) af, socktype, proto, canonname, sa = res[0] self.address_family = af self.socket_type = socktype self.socket = socket.socket(self.address_family, self.socket_type) server_address = sa[0:2] else: raise ConnectionError("Invalid address '%s'" % server_address) BaseServer.__init__(self, server_address, RequestHandlerClass) if bind_and_activate: try: self.server_bind() self.server_activate() except: self.server_close() raise