Quelle conf.py Sprache: Python

from typing import Dict, Any

from pyhttpd.env import HttpdTestEnv

class HttpdConf(object):

    def __init__(self, env: HttpdTestEnv, extras: Dict[str, Any] = None):
        """ Create a new httpd configuration.
        :param env: then environment this operates in
        :param extras: extra configuration directive with ServerName as key and
                       'base' as special key for global configuration additions.
        """
        self.env = env
        self._indents = 0
        self._lines = []
        self._extras = extras.copy() if extras else {}
        if 'base' in self._extras:
            self.add(self._extras['base'])
        self._tls_engine_ports = set()

    def __repr__(self):
        s = '\n'.join(self._lines)
        return f"HttpdConf[{s}]"

    def install(self):
        self.env.install_test_conf(self._lines)

    def replacetlsstr(self, line):
            l = line.replace("TLS_", "")
            l = l.replace("\n", " ")
            l = l.replace("\\", " ")
            l = " ".join(l.split())
            l = l.replace(" ", ":")
            l = l.replace("_", "-")
            l = l.replace("-WITH", "")
            l = l.replace("AES-", "AES")
            l = l.replace("POLY1305-SHA256", "POLY1305")
            return l

    def replaceinstr(self, line):
        if line.startswith("TLSCiphersPrefer"):
            # the "TLS_" are changed into "".
            l = self.replacetlsstr(line)
            l = l.replace("TLSCiphersPrefer:", "SSLCipherSuite ")
        elif line.startswith("TLSCiphersSuppress"):
            # like SSLCipherSuite but with :!
            l = self.replacetlsstr(line)
            l = l.replace("TLSCiphersSuppress:", "SSLCipherSuite !")
            l = l.replace(":", ":!")
        elif line.startswith("TLSCertificate"):
            l = line.replace("TLSCertificate", "SSLCertificateFile")
        elif line.startswith("TLSProtocol"):
            # mod_ssl is different (+ no supported and 0x code have to be translated)
            l = line.replace("TLSProtocol", "SSLProtocol")
            l = l.replace("+", "")
            l = l.replace("default", "all")
            l = l.replace("0x0303", "1.2") # need to check 1.3 and 1.1
        elif line.startswith("SSLProtocol"):
            l = line # we have that in test/modules/tls/test_05_proto.py
        elif line.startswith("TLSHonorClientOrder"):
            # mod_ssl has SSLHonorCipherOrder on = use server off = use client.
            l = line.lower()
            if "on" in l:
                l = "SSLHonorCipherOrder off"
            else:
                l = "SSLHonorCipherOrder on"
        elif line.startswith("TLSEngine"):
            # In fact it should go in the corresponding VirtualHost... Not sure how to do that.
            l = "SSLEngine On"
        else:
            if line != "":
                l = line.replace("TLS", "SSL")
            else:
                l = line
        return l

    def add(self, line: Any):
        # make we transform the TLS to SSL if we are using mod_ssl
        if isinstance(line, str):
            if not HttpdTestEnv.has_shared_module("tls"):
                line = self.replaceinstr(line)
            if self._indents > 0:
                line = f"{' ' * self._indents}{line}"
            self._lines.append(line)
        else:
            if not HttpdTestEnv.has_shared_module("tls"):
                new = []
                previous = ""
                for l in line:
                    if previous.startswith("SSLCipherSuite"):
                        if l.startswith("TLSCiphersPrefer") or l.startswith("TLSCiphersSuppress"):
                            # we need to merge it
                            l = self.replaceinstr(l)
                            l = l.replace("SSLCipherSuite ", ":")
                            previous = previous + l
                            continue
                        else:
                            if self._indents > 0:
                                previous = f"{' ' * self._indents}{previous}"
                            new.append(previous)
                            previous = ""
                    l = self.replaceinstr(l)
                    if l.startswith("SSLCipherSuite"):
                        previous = l
                        continue
                    if self._indents > 0:
                        l = f"{' ' * self._indents}{l}"
                    new.append(l)
                if previous != "":
                    if self._indents > 0:
                        previous = f"{' ' * self._indents}{previous}"
                    new.append(previous)
                self._lines.extend(new)
            else:
                if self._indents > 0:
                    line = [f"{' ' * self._indents}{l}" for l in line]
                self._lines.extend(line)
        return self

    def add_certificate(self, cert_file, key_file, ssl_module=None):
        if ssl_module is None:
            ssl_module = self.env.ssl_module
        if ssl_module == 'mod_ssl':
            self.add([
                f"SSLCertificateFile {cert_file}",
                f"SSLCertificateKeyFile {key_file if key_file else cert_file}",
            ])
        elif ssl_module == 'mod_tls':
            self.add(f"TLSCertificate {cert_file} {key_file if key_file else ''}")
        elif ssl_module == 'mod_gnutls':
            self.add([
                f"GnuTLSCertificateFile {cert_file}",
                f"GnuTLSKeyFile {key_file if key_file else cert_file}",
            ])
        else:
            raise Exception(f"unsupported ssl module: {ssl_module}")

    def add_vhost(self, domains, port=None, doc_root="htdocs", with_ssl=None,
                  with_certificates=None, ssl_module=None):
        self.start_vhost(domains=domains, port=port, doc_root=doc_root,
                         with_ssl=with_ssl, with_certificates=with_certificates,
                         ssl_module=ssl_module)
        self.end_vhost()
        return self

    def start_vhost(self, domains, port=None, doc_root="htdocs", with_ssl=None,
                    ssl_module=None, with_certificates=None):
        if not isinstance(domains, list):
            domains = [domains]
        if port is None:
            port = self.env.https_port
        if ssl_module is None:
            ssl_module = self.env.ssl_module
        if with_ssl is None:
            with_ssl = self.env.https_port == port
        if with_ssl and ssl_module == 'mod_tls' and port not in self._tls_engine_ports:
            self.add(f"TLSEngine {port}")
            self._tls_engine_ports.add(port)
        self.add("")
        self.add(f"")
        self._indents += 1
        self.add(f"ServerName {domains[0]}")
        for alias in domains[1:]:
            self.add(f"ServerAlias {alias}")
        self.add(f"DocumentRoot {doc_root}")
        if with_ssl:
            if ssl_module == 'mod_ssl':
                self.add("SSLEngine on")
            elif ssl_module == 'mod_gnutls':
                self.add("GnuTLSEnable on")
            if with_certificates is not False:
                for cred in self.env.get_credentials_for_name(domains[0]):
                    self.add_certificate(cred.cert_file, cred.pkey_file, ssl_module=ssl_module)
        if domains[0] in self._extras:
            self.add(self._extras[domains[0]])
        return self

    def end_vhost(self):
        self._indents -= 1
        self.add("")
        self.add("")
        return self

    def add_proxies(self, host, proxy_self=False, h2proxy_self=False):
        if proxy_self or h2proxy_self:
            self.add("ProxyPreserveHost on")
        if proxy_self:
            self.add([
                f"ProxyPass /proxy/ http://127.0.0.1:{self.env.http_port}/",
                f"ProxyPassReverse /proxy/ http://{host}.{self.env.http_tld}:{self.env.http_port}/",
            ])
        if h2proxy_self:
            self.add([
                f"ProxyPass /h2proxy/ h2://127.0.0.1:{self.env.https_port}/",
                f"ProxyPassReverse /h2proxy/ https://{host}.{self.env.http_tld}:self.env.https_port/",
            ])
        return self

    def add_vhost_test1(self, proxy_self=False, h2proxy_self=False):
        domain = f"test1.{self.env.http_tld}"
        self.start_vhost(domains=[domain, f"www1.{self.env.http_tld}"],
                         port=self.env.http_port, doc_root="htdocs/test1")
        self.end_vhost()
        self.start_vhost(domains=[domain, f"www1.{self.env.http_tld}"],
                         port=self.env.https_port, doc_root="htdocs/test1")
        self.add([
            "",
            " Options +Indexes",
            "",
        ])
        self.add_proxies("test1", proxy_self, h2proxy_self)
        self.end_vhost()
        return self

    def add_vhost_test2(self):
        domain = f"test2.{self.env.http_tld}"
        self.start_vhost(domains=[domain, f"www2.{self.env.http_tld}"],
                         port=self.env.http_port, doc_root="htdocs/test2")
        self.end_vhost()
        self.start_vhost(domains=[domain, f"www2.{self.env.http_tld}"],
                         port=self.env.https_port, doc_root="htdocs/test2")
        self.add([
            "",
            " Options +Indexes",
            "",
        ])
        self.end_vhost()
        return self

    def add_vhost_cgi(self, proxy_self=False, h2proxy_self=False):
        domain = f"cgi.{self.env.http_tld}"
        if proxy_self:
            self.add(["ProxyStatus on", "ProxyTimeout 5",
                      "SSLProxyEngine on", "SSLProxyVerify none"])
        if h2proxy_self:
            self.add(["SSLProxyEngine on", "SSLProxyCheckPeerName off"])
        self.start_vhost(domains=[domain, f"cgi-alias.{self.env.http_tld}"],
                         port=self.env.https_port, doc_root="htdocs/cgi")
        self.add_proxies("cgi", proxy_self=proxy_self, h2proxy_self=h2proxy_self)
        self.end_vhost()
        self.start_vhost(domains=[domain, f"cgi-alias.{self.env.http_tld}"],
                         port=self.env.http_port, doc_root="htdocs/cgi")
        self.add("AddHandler cgi-script .py")
        self.add_proxies("cgi", proxy_self=proxy_self, h2proxy_self=h2proxy_self)
        self.end_vhost()
        return self

    @staticmethod
    def merge_extras(e1: Dict[str, Any], e2: Dict[str, Any]) -> Dict[str, Any]:
        def _concat(v1, v2):
            if isinstance(v1, str):
                v1 = [v1]
            if isinstance(v2, str):
                v2 = [v2]
            v1.extend(v2)
            return v1

        if e1 is None:
            return e2.copy() if e2 else None
        if e2 is None:
            return e1.copy()
        e3 = e1.copy()
        for name, val in e2.items():
            if name in e3:
                e3[name] = _concat(e3[name], val)
            else:
                e3[name] = val
        return e3

quality93%

¤ Dauer der Verarbeitung: 0.1 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.