def run(self): self._host.run() if self._port != 443: run_simple(self._host_name, self._port, self, threaded=True) else: make_ssl_devcert('key', host=self._host_name) run_simple(self._host_name, self._port, self, threaded=True, ssl_context=('key.crt', 'key.key'))
def wrap(cls, app): host, port = cls.parse_args() if host: from wsgiref.simple_server import make_server server = make_server(host, port, app) if cls._argument_parser.parse_args().ssl: # Set HTTPS='1' makes wsgiref set wsgi.url_scheme='https' # This in turn makes pyramid set request.scheme='https' server.base_environ['HTTPS'] = '1' with tempfile.TemporaryDirectory() as td: # Generate temporary self-signed cert/key pair # using the library used by Flask for 'adhoc' ssl_context certpath = '{}/liveandletdie'.format(td) make_ssl_devcert(certpath) server.socket = ssl.wrap_socket( server.socket, server_side=True, certfile='{}.crt'.format(certpath), keyfile='{}.key'.format(certpath), ) server.serve_forever() server.server_close() sys.exit()
def ssl(module, host='127.0.0.1', path=None): """ Adds SSL support for development :param module: str Name of the module :param host: str Domain or IP of the server Default = '127.0.0.1' :param path: str Path to cert files (without .crt and .key ending) If empty you have to install python OpenSSL lib Default = None """ state_ = state(module) if path: state_.ssl = make_ssl_devcert(path, host=host) else: import importlib # noinspection PyDeprecation open_ssl = importlib.find_loader('OpenSSL') if open_ssl: state_.ssl = 'adhoc' else: raise ModuleNotFoundError( 'SSL generation requires the PyOpenSSl module. Please install it or pass the path\ to your self generated certificate')
def debug(): tempPath = tempfile.mkdtemp() + "/server" atexit.register(cleanup, tempPath) print(tempPath) context = make_ssl_devcert(tempPath, host='localhost') app.run(host="0.0.0.0", port=5000, debug=True, threaded=True, ssl_context=context)
def inner_run(): print "Validating models..." self.validate(display_num_errors=True) print "\nDjango version %s, using settings %r" % (django.get_version(), settings.SETTINGS_MODULE) print "Development server is running at http://%s:%s/" % (addr, port) print "Using the Werkzeug debugger (http://werkzeug.pocoo.org/)" print "Quit the server with %s." % quit_command path = options.get('admin_media_path', '') if not path: admin_media_path = os.path.join(django.__path__[0], 'contrib/admin/static/admin') if os.path.isdir(admin_media_path): path = admin_media_path else: path = os.path.join(django.__path__[0], 'contrib/admin/media') handler = WSGIHandler() if USE_ADMINMEDIAHANDLER: handler = AdminMediaHandler(handler, path) if USE_STATICFILES: use_static_handler = options.get('use_static_handler', True) insecure_serving = options.get('insecure_serving', False) if use_static_handler and (settings.DEBUG or insecure_serving): handler = StaticFilesHandler(handler) if open_browser: import webbrowser url = "http://%s:%s/" % (addr, port) webbrowser.open(url) if cert_path: try: from werkzeug.serving import make_ssl_devcert ssl_context = make_ssl_devcert(cert_path, host='localhost') run_simple( addr, int(port), DebuggedApplication(handler, True), use_reloader=use_reloader, use_debugger=True, threaded=threaded, ssl_context=ssl_context ) except ImportError: raise CommandError("""Werkzeug 0.8.2 or later is required to use runserver_plus with ssl support. Please visit http://werkzeug.pocoo.org/download""") else: run_simple( addr, int(port), DebuggedApplication(handler, True), use_reloader=use_reloader, use_debugger=True, threaded=threaded )
def create_app(config_name): # Flask instance app = Flask(__name__) app.config.from_object(config[config_name]) config[config_name].init_app(app) bootstrap.init_app(app) db.init_app(app) login_manager.init_app(app) make_ssl_devcert('./ssl', host='localhost') from catalog_items.main_app import main_blueprint app.register_blueprint(main_blueprint) from catalog_items.auth import auth_blueprint app.register_blueprint(auth_blueprint) app.register_error_handler(404, page_not_found) app.register_error_handler(500, internal_server_error) return app
def test_stdlib_ssl_contexts(dev_server, tmpdir): certificate, private_key = serving.make_ssl_devcert(str(tmpdir)) ctx = ssl.SSLContext(ssl.PROTOCOL_SSLv23) ctx.load_cert_chain(certificate, private_key) def hello(environ, start_response): start_response('200 OK', [('Content-Type', 'text/html')]) return [b'hello'] server, addr = dev_server(hello, ssl_context=ctx) assert addr is not None connection = httplib.HTTPSConnection(addr) connection.request('GET', '/') response = connection.getresponse() assert response.read() == b'hello'
def run_dev_server(http_only=False, threaded=False): # version of SSL included by werkzeug from pip is broken. Use github ssl_prefix = join(config.src_home, 'lib', 'tmp', 'ssl') if not isfile(ssl_prefix + '.key'): make_ssl_devcert(ssl_prefix, host='localhost', cn=None) ssl_context = ssl.Context(ssl.SSLv23_METHOD) ssl_context.use_certificate_file(ssl_prefix + '.crt') ssl_context.use_privatekey_file(ssl_prefix + '.key') # run_simple is not so simple def run_hive(port, ssl=False): run_simple( '0.0.0.0', port, application, threaded=threaded, use_reloader=True, use_debugger=config.debug_mode, use_evalex=config. debug_unsecure # from werkzeug.debug import DebuggedApplication , static_files={'/lib': join(config.src_home, 'lib')}, ssl_context=ssl_context if ssl else None #, processes = 0 ) if config.always_secure: run_hive(config.ssl_port, True) elif http_only: run_hive(config.plain_port) else: child = os.fork() if (child): run_hive(config.plain_port) else: run_hive(config.ssl_port, True)
def test_stdlib_ssl_contexts(dev_server, tmpdir): certificate, private_key = \ serving.make_ssl_devcert(str(tmpdir.mkdir('certs'))) server = dev_server(''' def app(environ, start_response): start_response('200 OK', [('Content-Type', 'text/html')]) return [b'hello'] import ssl ctx = ssl.SSLContext(ssl.PROTOCOL_SSLv23) ctx.load_cert_chain("%s", "%s") kwargs['ssl_context'] = ctx ''' % (certificate, private_key)) assert server.addr is not None r = requests.get(server.url, verify=False) assert r.content == b'hello'
def confd(global_datadir, tmp_path_factory) -> Path: datadir = global_datadir / "confd" develop = datadir / "odooconfig.develop.json" stage = datadir / "odooconfig.stage.json" prod = datadir / "odooconfig.prod.json" develop_dict = json.loads(develop.read_text()) stage_dict = json.loads(stage.read_text()) prod_dict = json.loads(prod.read_text()) persist_dir = tmp_path_factory.mktemp("persist") backup_dir = tmp_path_factory.mktemp("backup") addons_dir = tmp_path_factory.mktemp("addons") scoped_addons_dir = tmp_path_factory.mktemp("scoped_addons") geoip_database_dir = tmp_path_factory.mktemp("geoip_database") geoip_database_file = geoip_database_dir / "GeoLite2-City.mmdb" geoip_database_file.touch() upd = { "data_dir": str(persist_dir), "backup_dir": str(backup_dir), "addons_dir": str(addons_dir), "scoped_addons_dir": str(scoped_addons_dir), "geoip_database": str(geoip_database_file), } crt_path, key_path = make_ssl_devcert(str(global_datadir), host="localhost") develop_dict.update(**upd) develop_dict.update(ssl_keyfile=key_path, ssl_certfile=crt_path) stage_dict.update(**upd) prod_dict.update(**upd) with develop.open(mode="w") as f: f.write(json.dumps(develop_dict)) with stage.open(mode="w") as f: f.write(json.dumps(stage_dict)) with prod.open(mode="w") as f: f.write(json.dumps(prod_dict)) datadir.chmod(0o550) yield datadir datadir.chmod(0o777)
def test_stdlib_ssl_contexts(dev_server, tmpdir): certificate, private_key = \ serving.make_ssl_devcert(str(tmpdir.mkdir('certs'))) server = dev_server(''' def app(environ, start_response): start_response('200 OK', [('Content-Type', 'text/html')]) return [b'hello'] import ssl ctx = ssl.SSLContext(ssl.PROTOCOL_SSLv23) ctx.load_cert_chain("%s", "%s") kwargs['ssl_context'] = ctx ''' % (certificate, private_key)) assert server.addr is not None connection = httplib.HTTPSConnection(server.addr) connection.request('GET', '/') response = connection.getresponse() assert response.read() == b'hello'
from flask import Flask from OpenSSL import SSL import os from werkzeug.serving import make_ssl_devcert # make_ssl_devcert('key', host='localhost') make_ssl_devcert('key') context = SSL.Context(SSL.SSLv23_METHOD) cer = os.path.join(os.path.dirname(__file__), 'key.crt') key = os.path.join(os.path.dirname(__file__), 'key.key') app = Flask(__name__) @app.route('/') def hello_world(): return 'Hellokjnkj World!' if __name__ == '__main__': context = (cer, key) app.run(host='0.0.0.0', port=5000, debug=True, ssl_context=context)
def main() -> None: logging.basicConfig(level=logging.INFO) if not os.path.exists('./key.pem') or not os.path.exists('./key.crt'): logging.info('Creating dev cert') make_ssl_devcert('./key', host='localhost') server = ScoreboardTwitchExtensionServer() time.sleep(1) print( f'Please visit https://localhost:{PORT} in your browser and ensure that the page is loading and not presenting a SSL error' ) print( 'In chrome you can set the flag chrome://flags#allow-insecure-localhost, ' 'for other browsers you may need to install the generated "key.crt" as a trusted root cert, ' 'or launch the browser with a special argument.') print( 'Once you have confirmed this page loads with no error (the page should appear empty with no content), ' 'you should also be able to load it on twitch as a locally-hosted extension (see the readme for more info on setting this up).' ) print() if '--live' not in sys.argv: if len(sys.argv) != 4: print('-' * 32) print( 'You need to provide your twitch API client ID if not running in "live data" mode. ' 'You can find this on the first page when you create a new extension, ' 'or regenerate it under "Extension Authorization Settings" on your extension\'s Developer Console' ) client_id, secret_encoded, channel = sys.argv[1:] secret = base64.b64decode(secret_encoded) twitch = requests.Session() twitch.headers.update({'Client-ID': client_id}) r = twitch.get('https://api.twitch.tv/helix/users?login='******'data'][0]['id'] gui = ScoreboardGui.create() def update_extension(data: Dict): message = {'timestamp': time.time(), 'teams': data['teams']} auth = { 'user_id': str(user_id), 'exp': int(time.time() + 60), 'role': 'external', 'channel_id': str(user_id), 'pubsub_perms': { 'send': ['broadcast'] } } logging.info(f'Sending twitch broadcast: {message}') r = twitch.post( f'https://api.twitch.tv/extensions/message/{user_id}', json={ 'content_type': 'application/json', 'message': json.dumps(message), 'targets': ['broadcast'] }, headers={ 'Authorization': 'Bearer ' + jwt.encode(auth, secret).decode() }) try: r.raise_for_status() except Exception as e: logging.exception(f'Failed to publish update: {r.text}', exc_info=e) def update_loop(): while True: update_extension(gui.data) time.sleep(10) Thread(target=update_loop, daemon=True).start() last_update = None def rate_limited_update(data): nonlocal last_update if not last_update or time.time() - last_update > 1: last_update = time.time() update_extension(data) gui.callback = rate_limited_update gui.run() else: logging.info( f'Running without player selector GUI - you must provide live data from OverTrack' ) server.thread.join() logging.info(f'Shutting down')
def inner_run(self, options): if not HAS_WERKZEUG: raise CommandError( "Werkzeug is required to use runserver_plus. Please visit http://werkzeug.pocoo.org/ or install via pip. (pip install Werkzeug)" ) # Set colored output if settings.DEBUG: try: set_werkzeug_log_color() except Exception: # We are dealing with some internals, anything could go wrong if self.show_startup_messages: print( "Wrapping internal werkzeug logger for color highlighting has failed!" ) class WSGIRequestHandler(_WSGIRequestHandler): def make_environ(self): environ = super().make_environ() if not options['keep_meta_shutdown_func']: del environ['werkzeug.server.shutdown'] return environ threaded = options['threaded'] use_reloader = options['use_reloader'] open_browser = options['open_browser'] quit_command = 'CONTROL-C' if sys.platform != 'win32' else 'CTRL-BREAK' reloader_interval = options['reloader_interval'] reloader_type = options['reloader_type'] self.extra_files = set(options['extra_files']) self.nopin = options['nopin'] if self.show_startup_messages: print("Performing system checks...\n") try: check_errors( self.check)(display_num_errors=self.show_startup_messages) check_errors(self.check_migrations)() handler = check_errors(self.get_handler)(**options) except Exception as exc: self.stderr.write("Error occurred during checks: %r" % exc, ending="\n\n") handler = self.get_error_handler(exc, **options) if USE_STATICFILES: use_static_handler = options['use_static_handler'] insecure_serving = options['insecure_serving'] if use_static_handler and (settings.DEBUG or insecure_serving): handler = StaticFilesHandler(handler) if options["cert_path"] or options["key_file_path"]: if not HAS_OPENSSL: raise CommandError( "Python OpenSSL Library is " "required to use runserver_plus with ssl support. " "Install via pip (pip install pyOpenSSL).") certfile, keyfile = self.determine_ssl_files_paths(options) dir_path, root = os.path.split(certfile) root, _ = os.path.splitext(root) try: if os.path.exists(certfile) and os.path.exists(keyfile): ssl_context = (certfile, keyfile) else: # Create cert, key files ourselves. ssl_context = make_ssl_devcert(os.path.join( dir_path, root), host='localhost') except ImportError: if self.show_startup_messages: print( "Werkzeug version is less than 0.9, trying adhoc certificate." ) ssl_context = "adhoc" else: ssl_context = None bind_url = "%s://%s:%s/" % ("https" if ssl_context else "http", self.addr if not self._raw_ipv6 else '[%s]' % self.addr, self.port) if self.show_startup_messages: print("\nDjango version %s, using settings %r" % (django.get_version(), settings.SETTINGS_MODULE)) print("Development server is running at %s" % (bind_url, )) print("Using the Werkzeug debugger (http://werkzeug.pocoo.org/)") print("Quit the server with %s." % quit_command) if open_browser: webbrowser.open(bind_url) if use_reloader and settings.USE_I18N: self.extra_files |= set( filter(lambda filename: str(filename).endswith('.mo'), gen_filenames())) if getattr(settings, 'RUNSERVER_PLUS_EXTRA_FILES', []): self.extra_files |= set(settings.RUNSERVER_PLUS_EXTRA_FILES) # Werkzeug needs to be clued in its the main instance if running # without reloader or else it won't show key. # https://git.io/vVIgo if not use_reloader: os.environ['WERKZEUG_RUN_MAIN'] = 'true' # Don't run a second instance of the debugger / reloader # See also: https://github.com/django-extensions/django-extensions/issues/832 if os.environ.get('WERKZEUG_RUN_MAIN') != 'true': if self.nopin: os.environ['WERKZEUG_DEBUG_PIN'] = 'off' handler = DebuggedApplication(handler, True) runserver_plus_started.send(sender=self) run_simple( self.addr, int(self.port), handler, use_reloader=use_reloader, use_debugger=True, extra_files=self.extra_files, exclude_patterns=WERKZEUG_EXCLUDE_PATTERNS, reloader_interval=reloader_interval, reloader_type=reloader_type, threaded=threaded, request_handler=WSGIRequestHandler, ssl_context=ssl_context, )
# -*- coding: utf-8 -*- from flask import Flask from OpenSSL import SSL from werkzeug.serving import run_simple from werkzeug.serving import make_ssl_devcert from werkzeug.serving import is_running_from_reloader #from myproject import make_app app = Flask(__name__) bestand = open("C:/Users/Daniel van Liempd/Desktop/DANIEL.txt", 'r') #print (bestand.read()) make_ssl_devcert( 'C:/Users/Daniel van Liempd/PycharmProjects/Practicum-cloudinfra/venv', host='Daniel-PC', cn=None) is_running_from_reloader() run_simple(hostname='Daniel-PC', port=8080, application=(app), use_reloader=False, use_debugger=False, use_evalex=True, extra_files=None, reloader_interval=1, reloader_type='auto', threaded=False, processes=1, request_handler=None,
def create_crt(path, host): make_ssl_devcert(path, host=host)
if not result: print("got here insert user 2") return apology("Username already exists") # query database for username rows = db.execute("SELECT * FROM users WHERE username = :username", username=request.form.get("username")) # this is to initialize the user in the WINS table, with 0 # this made it easier to continually update win totals as opposed to insert OR update wins = 0 uid = rows[0]["userid"] wins_update = db.execute( "INSERT INTO wins (userid, wins) VALUES (:uid, :wins)", uid=uid, wins=wins) # remember which user has logged in session["userid"] = rows[0]["userid"] # redirect user to home page return redirect(url_for("index")) else: return render_template("register.html") if __name__ == "__main__": make_ssl_devcert('/home/pi/pickem/dheslin', host='www.bygtech.com') #run_simple('0.0.0.0', 5000, app, ssl_context=('/home/pi/pickem/dheslin/ssl.cert', '/home/pi/pickem/dheslin/ssl.key'))
def test_ssl_dev_cert(tmp_path, dev_server): client = dev_server(ssl_context=make_ssl_devcert(tmp_path)) r = client.request() assert r.json["wsgi.url_scheme"] == "https"
@app.route('/categories.JSON') def CategoriesJSON(): category = session.query(Categories).all() # CHECK IF THE USER LOGGED IN if 'username' not in login_session: return redirect('/login') return jsonify(categories=[c.serialize for c in category]) @app.route('/categories/<int:category_id>/items/<int:item_id>/JSON') def ArbitraryItemJSON(category_id, item_id): #categroy = session.query(Categories).filter_by( #id=category_id).one() item = session.query(Items).filter_by(categories_id=category_id).filter_by( id=item_id).all() # CHECK IF THE USER LOGGED IN if 'username' not in login_session: return redirect('/login') return jsonify(item=[i.serialize for i in item]) if __name__ == '__main__': app.secret_key = 'super_secret_key' app.debug = True make_ssl_devcert('key', host='localhost') app.run(host='0.0.0.0', port=80, ssl_context=('key.crt', 'key.key'))
def test_make_ssl_devcert(self): certificate, private_key = serving.make_ssl_devcert( get_temporary_directory()) assert os.path.isfile(certificate) assert os.path.isfile(private_key)
import argparse from werkzeug.serving import make_ssl_devcert parser = argparse.ArgumentParser(description='Generate SSL cert') parser.add_argument('host', type=str, help='host to be used in SSL cert') args = parser.parse_args() path = make_ssl_devcert('key', args.host) print "Keys written to ", path
def test_make_ssl_devcert(self): certificate, private_key = serving.make_ssl_devcert(get_temporary_directory()) assert os.path.isfile(certificate) assert os.path.isfile(private_key)
def inner_run(self, options): import django try: from werkzeug import run_simple, DebuggedApplication from werkzeug.serving import WSGIRequestHandler as _WSGIRequestHandler # Set colored output if settings.DEBUG: try: set_werkzeug_log_color() except Exception: # We are dealing with some internals, anything could go wrong if self.show_startup_messages: print("Wrapping internal werkzeug logger for color highlighting has failed!") pass except ImportError: raise CommandError("Werkzeug is required to use runserver_plus. Please visit http://werkzeug.pocoo.org/ or install via pip. (pip install Werkzeug)") class WSGIRequestHandler(_WSGIRequestHandler): def make_environ(self): environ = super(WSGIRequestHandler, self).make_environ() if not options.get('keep_meta_shutdown_func'): del environ['werkzeug.server.shutdown'] return environ threaded = options.get('threaded', True) use_reloader = options.get('use_reloader', True) open_browser = options.get('open_browser', False) cert_path = options.get("cert_path") quit_command = (sys.platform == 'win32') and 'CTRL-BREAK' or 'CONTROL-C' extra_files = options.get('extra_files', None) or [] reloader_interval = options.get('reloader_interval', 1) reloader_type = options.get('reloader_type', 'auto') self.nopin = options.get('nopin', False) if self.show_startup_messages: print("Performing system checks...\n") if hasattr(self, 'check'): self.check(display_num_errors=self.show_startup_messages) else: self.validate(display_num_errors=self.show_startup_messages) try: self.check_migrations() except ImproperlyConfigured: pass handler = get_internal_wsgi_application() if USE_STATICFILES: use_static_handler = options.get('use_static_handler', True) insecure_serving = options.get('insecure_serving', False) if use_static_handler and (settings.DEBUG or insecure_serving): handler = StaticFilesHandler(handler) if cert_path: """ OpenSSL is needed for SSL support. This will make flakes8 throw warning since OpenSSL is not used directly, alas, this is the only way to show meaningful error messages. See: http://lucumr.pocoo.org/2011/9/21/python-import-blackbox/ for more information on python imports. """ try: import OpenSSL # NOQA except ImportError: raise CommandError("Python OpenSSL Library is " "required to use runserver_plus with ssl support. " "Install via pip (pip install pyOpenSSL).") dir_path, cert_file = os.path.split(cert_path) if not dir_path: dir_path = os.getcwd() root, ext = os.path.splitext(cert_file) certfile = os.path.join(dir_path, root + ".crt") keyfile = os.path.join(dir_path, root + ".key") try: from werkzeug.serving import make_ssl_devcert if os.path.exists(certfile) and \ os.path.exists(keyfile): ssl_context = (certfile, keyfile) else: # Create cert, key files ourselves. ssl_context = make_ssl_devcert( os.path.join(dir_path, root), host='localhost') except ImportError: if self.show_startup_messages: print("Werkzeug version is less than 0.9, trying adhoc certificate.") ssl_context = "adhoc" else: ssl_context = None bind_url = "%s://%s:%s/" % ( "https" if ssl_context else "http", self.addr if not self._raw_ipv6 else '[%s]' % self.addr, self.port) if self.show_startup_messages: print("\nDjango version %s, using settings %r" % (django.get_version(), settings.SETTINGS_MODULE)) print("Development server is running at %s" % (bind_url,)) print("Using the Werkzeug debugger (http://werkzeug.pocoo.org/)") print("Quit the server with %s." % quit_command) if open_browser: import webbrowser webbrowser.open(bind_url) if use_reloader and settings.USE_I18N: extra_files.extend(filter(lambda filename: filename.endswith('.mo'), gen_filenames())) # Werkzeug needs to be clued in its the main instance if running # without reloader or else it won't show key. # https://git.io/vVIgo if not use_reloader: os.environ['WERKZEUG_RUN_MAIN'] = 'true' # Don't run a second instance of the debugger / reloader # See also: https://github.com/django-extensions/django-extensions/issues/832 if os.environ.get('WERKZEUG_RUN_MAIN') != 'true': if self.nopin: os.environ['WERKZEUG_DEBUG_PIN'] = 'off' handler = DebuggedApplication(handler, True) run_simple( self.addr, int(self.port), handler, use_reloader=use_reloader, use_debugger=True, extra_files=extra_files, reloader_interval=reloader_interval, reloader_type=reloader_type, threaded=threaded, request_handler=WSGIRequestHandler, ssl_context=ssl_context, )
#------------------------------------------------------------------------------- # Name: sslgen # Purpose: generate development ssl certs # # Author: a # Licence: MIT #------------------------------------------------------------------------------- from werkzeug.serving import run_simple from werkzeug.serving import make_ssl_devcert import os scriptdir = os.path.dirname(os.path.abspath(__file__)) make_ssl_devcert(scriptdir + '\\ast', host='localhost', cn=None) ##app = make_app(...) ##run_simple('localhost', 8080, app, use_reloader=True)
def inner_run(): if self.show_startup_messages: print("Performing system checks...\n") if hasattr(self, "check"): self.check(display_num_errors=self.show_startup_messages) else: self.validate(display_num_errors=self.show_startup_messages) if HAS_MIGRATIONS: try: self.check_migrations() except ImproperlyConfigured: pass if self.show_startup_messages: print("\nDjango version %s, using settings %r" % (django.get_version(), settings.SETTINGS_MODULE)) print("Development server is running at %s" % (bind_url,)) print("Using the Werkzeug debugger (http://werkzeug.pocoo.org/)") print("Quit the server with %s." % quit_command) path = options.get("admin_media_path", "") if not path: admin_media_path = os.path.join(django.__path__[0], "contrib/admin/static/admin") if os.path.isdir(admin_media_path): path = admin_media_path else: path = os.path.join(django.__path__[0], "contrib/admin/media") handler = WSGIHandler() if USE_ADMINMEDIAHANDLER: handler = AdminMediaHandler(handler, path) if USE_STATICFILES: use_static_handler = options.get("use_static_handler", True) insecure_serving = options.get("insecure_serving", False) if use_static_handler and (settings.DEBUG or insecure_serving): handler = StaticFilesHandler(handler) if open_browser: import webbrowser webbrowser.open(bind_url) if cert_path: """ OpenSSL is needed for SSL support. This will make flakes8 throw warning since OpenSSL is not used directly, alas, this is the only way to show meaningful error messages. See: http://lucumr.pocoo.org/2011/9/21/python-import-blackbox/ for more information on python imports. """ try: import OpenSSL # NOQA except ImportError: raise CommandError( "Python OpenSSL Library is " "required to use runserver_plus with ssl support. " "Install via pip (pip install pyOpenSSL)." ) dir_path, cert_file = os.path.split(cert_path) if not dir_path: dir_path = os.getcwd() root, ext = os.path.splitext(cert_file) certfile = os.path.join(dir_path, root + ".crt") keyfile = os.path.join(dir_path, root + ".key") try: from werkzeug.serving import make_ssl_devcert if os.path.exists(certfile) and os.path.exists(keyfile): ssl_context = (certfile, keyfile) else: # Create cert, key files ourselves. ssl_context = make_ssl_devcert(os.path.join(dir_path, root), host="localhost") except ImportError: if self.show_startup_messages: print("Werkzeug version is less than 0.9, trying adhoc certificate.") ssl_context = "adhoc" else: ssl_context = None if use_reloader and settings.USE_I18N: try: from django.utils.autoreload import gen_filenames except ImportError: pass else: extra_files.extend(filter(lambda filename: filename.endswith(".mo"), gen_filenames())) run_simple( self.addr, int(self.port), DebuggedApplication(handler, True), use_reloader=use_reloader, use_debugger=True, extra_files=extra_files, reloader_interval=reloader_interval, threaded=threaded, ssl_context=ssl_context, )
__author__ = 'lekez2005' from werkzeug.serving import make_ssl_devcert import socket, os def generate(regenerate): ip = 'localhost' try: s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) s.connect(("8.8.8.8",80)) ip = s.getsockname()[0] s.close() except Exception, e: print e base_dir = os.path.dirname(os.path.realpath(__file__)) path = os.path.join(base_dir, 'server') if regenerate: server_crt, server_key = make_ssl_devcert(path, host=ip) print 'Key created for ', ip return ip, server_crt, server_key else: server_crt = path + '.crt' server_key = path + '.key' return ip, server_crt, server_key
import argparse from werkzeug.serving import make_ssl_devcert parser = argparse.ArgumentParser(description='Generate SSL cert') parser.add_argument('host', type=str, help='host to be used in SSL cert') args = parser.parse_args() path=make_ssl_devcert('key', args.host) print "Keys written to ", path
#------------------------------------------------------------------------------- # Name: 模块1 # Purpose: # # Author: 1 # # Created: 25/02/2016 # Copyright: (c) 1 2016 # Licence: <your licence> #------------------------------------------------------------------------------- from werkzeug.serving import make_ssl_devcert make_ssl_devcert('./', host='localhost') ('./key.crt', './key.key')
import ssl import tempfile from werkzeug import serving def stdlib_ssl_app(environ, start_response): start_response("200 OK", [("Content-Type", "text/html")]) return [b"hello"] certificate, private_key = serving.make_ssl_devcert( str(tempfile.mkdtemp(suffix="certs"))) ctx = ssl.SSLContext(ssl.PROTOCOL_SSLv23) ctx.load_cert_chain(certificate, private_key) ssl_kwargs = {} ssl_kwargs["ssl_context"] = ctx
#------------------------------------------------------------------------------- # Name: sslgen # Purpose: generate development ssl certs # # Author: a # Licence: MIT #------------------------------------------------------------------------------- from werkzeug.serving import run_simple from werkzeug.serving import make_ssl_devcert import os scriptdir = os.path.dirname(os.path.abspath(__file__)) make_ssl_devcert(scriptdir+'\\ast', host='localhost', cn=None) ##app = make_app(...) ##run_simple('localhost', 8080, app, use_reloader=True)
def test_make_ssl_devcert(tmpdir): certificate, private_key = \ serving.make_ssl_devcert(str(tmpdir)) assert os.path.isfile(certificate) assert os.path.isfile(private_key)
# Generate fake ssl cert for development purposes from werkzeug.serving import make_ssl_devcert make_ssl_devcert("./config/ssl", host="localhost")
def inner_run(): print("Validating models...") try: self.check(display_num_errors=True) except AttributeError: self.validate(display_num_errors=True) print("\nDjango version %s, using settings %r" % (django.get_version(), settings.SETTINGS_MODULE)) print("Development server is running at %s" % (bind_url,)) print("Using the Werkzeug debugger (http://werkzeug.pocoo.org/)") print("Quit the server with %s." % quit_command) path = options.get('admin_media_path', '') if not path: admin_media_path = os.path.join(django.__path__[0], 'contrib/admin/static/admin') if os.path.isdir(admin_media_path): path = admin_media_path else: path = os.path.join(django.__path__[0], 'contrib/admin/media') handler = WSGIHandler() if USE_ADMINMEDIAHANDLER: handler = AdminMediaHandler(handler, path) if USE_STATICFILES: use_static_handler = options.get('use_static_handler', True) insecure_serving = options.get('insecure_serving', False) if use_static_handler and (settings.DEBUG or insecure_serving): handler = StaticFilesHandler(handler) if open_browser: import webbrowser webbrowser.open(bind_url) if cert_path: """ OpenSSL is needed for SSL support. This will make flakes8 throw warning since OpenSSL is not used directly, alas, this is the only way to show meaningful error messages. See: http://lucumr.pocoo.org/2011/9/21/python-import-blackbox/ for more information on python imports. """ try: import OpenSSL # NOQA except ImportError: raise CommandError("Python OpenSSL Library is " "required to use runserver_plus with ssl support. " "Install via pip (pip install pyOpenSSL).") dir_path, cert_file = os.path.split(cert_path) if not dir_path: dir_path = os.getcwd() root, ext = os.path.splitext(cert_file) certfile = os.path.join(dir_path, root + ".crt") keyfile = os.path.join(dir_path, root + ".key") try: from werkzeug.serving import make_ssl_devcert if os.path.exists(certfile) and \ os.path.exists(keyfile): ssl_context = (certfile, keyfile) else: # Create cert, key files ourselves. ssl_context = make_ssl_devcert( os.path.join(dir_path, root), host='localhost') except ImportError: print("Werkzeug version is less than 0.9, trying adhoc certificate.") ssl_context = "adhoc" else: ssl_context = None run_simple( self.addr, int(self.port), DebuggedApplication(handler, True), use_reloader=use_reloader, use_debugger=True, threaded=threaded, ssl_context=ssl_context )
from app import app from werkzeug.serving import make_ssl_devcert import os make_ssl_devcert('./ssl', host='localhost') os.environ['OAUTHLIB_INSECURE_TRANSPORT'] = '1' app.run(debug=True, ssl_context=('./ssl.crt', './ssl.key'))