././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.8188577 certbot-apache-1.21.0/0000755000076500000240000000000000000000000013125 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/LICENSE.txt0000644000076500000240000002504200000000000014753 0ustar00bmwstaff Copyright 2015 Electronic Frontier Foundation and others Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/MANIFEST.in0000644000076500000240000000036000000000000014662 0ustar00bmwstaffinclude LICENSE.txt include README.rst recursive-include tests * recursive-include certbot_apache/_internal/augeas_lens *.aug recursive-include certbot_apache/_internal/tls_configs *.conf global-exclude __pycache__ global-exclude *.py[cod] ././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1635888463.818931 certbot-apache-1.21.0/PKG-INFO0000644000076500000240000000214700000000000014226 0ustar00bmwstaffMetadata-Version: 2.1 Name: certbot-apache Version: 1.21.0 Summary: Apache plugin for Certbot Home-page: https://github.com/letsencrypt/letsencrypt Author: Certbot Project Author-email: certbot-dev@eff.org License: Apache License 2.0 Platform: UNKNOWN Classifier: Development Status :: 5 - Production/Stable Classifier: Environment :: Plugins Classifier: Intended Audience :: System Administrators Classifier: License :: OSI Approved :: Apache Software License Classifier: Operating System :: POSIX :: Linux Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.6 Classifier: Programming Language :: Python :: 3.7 Classifier: Programming Language :: Python :: 3.8 Classifier: Programming Language :: Python :: 3.9 Classifier: Topic :: Internet :: WWW/HTTP Classifier: Topic :: Security Classifier: Topic :: System :: Installation/Setup Classifier: Topic :: System :: Networking Classifier: Topic :: System :: Systems Administration Classifier: Topic :: Utilities Requires-Python: >=3.6 Provides-Extra: dev License-File: LICENSE.txt UNKNOWN ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/README.rst0000644000076500000240000000003200000000000014607 0ustar00bmwstaffApache plugin for Certbot ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.7914495 certbot-apache-1.21.0/certbot_apache/0000755000076500000240000000000000000000000016070 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/certbot_apache/__init__.py0000644000076500000240000000003500000000000020177 0ustar00bmwstaff"""Certbot Apache plugin.""" ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.7952623 certbot-apache-1.21.0/certbot_apache/_internal/0000755000076500000240000000000000000000000020043 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/certbot_apache/_internal/__init__.py0000644000076500000240000000003500000000000022152 0ustar00bmwstaff"""Certbot Apache plugin.""" ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/certbot_apache/_internal/apache_util.py0000644000076500000240000001573100000000000022702 0ustar00bmwstaff""" Utility functions for certbot-apache plugin """ import binascii import fnmatch import logging import re import subprocess import pkg_resources from certbot import errors from certbot import util from certbot.compat import os logger = logging.getLogger(__name__) def get_mod_deps(mod_name): """Get known module dependencies. .. note:: This does not need to be accurate in order for the client to run. This simply keeps things clean if the user decides to revert changes. .. warning:: If all deps are not included, it may cause incorrect parsing behavior, due to enable_mod's shortcut for updating the parser's currently defined modules (`.ApacheParser.add_mod`) This would only present a major problem in extremely atypical configs that use ifmod for the missing deps. """ deps = { "ssl": ["setenvif", "mime"] } return deps.get(mod_name, []) def get_file_path(vhost_path): """Get file path from augeas_vhost_path. Takes in Augeas path and returns the file name :param str vhost_path: Augeas virtual host path :returns: filename of vhost :rtype: str """ if not vhost_path or not vhost_path.startswith("/files/"): return None return _split_aug_path(vhost_path)[0] def get_internal_aug_path(vhost_path): """Get the Augeas path for a vhost with the file path removed. :param str vhost_path: Augeas virtual host path :returns: Augeas path to vhost relative to the containing file :rtype: str """ return _split_aug_path(vhost_path)[1] def _split_aug_path(vhost_path): """Splits an Augeas path into a file path and an internal path. After removing "/files", this function splits vhost_path into the file path and the remaining Augeas path. :param str vhost_path: Augeas virtual host path :returns: file path and internal Augeas path :rtype: `tuple` of `str` """ # Strip off /files file_path = vhost_path[6:] internal_path = [] # Remove components from the end of file_path until it becomes valid while not os.path.exists(file_path): file_path, _, internal_path_part = file_path.rpartition("/") internal_path.append(internal_path_part) return file_path, "/".join(reversed(internal_path)) def parse_define_file(filepath, varname): """ Parses Defines from a variable in configuration file :param str filepath: Path of file to parse :param str varname: Name of the variable :returns: Dict of Define:Value pairs :rtype: `dict` """ return_vars = {} # Get list of words in the variable a_opts = util.get_var_from_file(varname, filepath).split() for i, v in enumerate(a_opts): # Handle Define statements and make sure it has an argument if v == "-D" and len(a_opts) >= i+2: var_parts = a_opts[i+1].partition("=") return_vars[var_parts[0]] = var_parts[2] elif len(v) > 2 and v.startswith("-D"): # Found var with no whitespace separator var_parts = v[2:].partition("=") return_vars[var_parts[0]] = var_parts[2] return return_vars def unique_id(): """ Returns an unique id to be used as a VirtualHost identifier""" return binascii.hexlify(os.urandom(16)).decode("utf-8") def included_in_paths(filepath, paths): """ Returns true if the filepath is included in the list of paths that may contain full paths or wildcard paths that need to be expanded. :param str filepath: Filepath to check :params list paths: List of paths to check against :returns: True if included :rtype: bool """ return any(fnmatch.fnmatch(filepath, path) for path in paths) def parse_defines(apachectl): """ Gets Defines from httpd process and returns a dictionary of the defined variables. :param str apachectl: Path to apachectl executable :returns: dictionary of defined variables :rtype: dict """ variables = {} define_cmd = [apachectl, "-t", "-D", "DUMP_RUN_CFG"] matches = parse_from_subprocess(define_cmd, r"Define: ([^ \n]*)") try: matches.remove("DUMP_RUN_CFG") except ValueError: return {} for match in matches: # Value could also contain = so split only once parts = match.split('=', 1) value = parts[1] if len(parts) == 2 else '' variables[parts[0]] = value return variables def parse_includes(apachectl): """ Gets Include directives from httpd process and returns a list of their values. :param str apachectl: Path to apachectl executable :returns: list of found Include directive values :rtype: list of str """ inc_cmd = [apachectl, "-t", "-D", "DUMP_INCLUDES"] return parse_from_subprocess(inc_cmd, r"\(.*\) (.*)") def parse_modules(apachectl): """ Get loaded modules from httpd process, and return the list of loaded module names. :param str apachectl: Path to apachectl executable :returns: list of found LoadModule module names :rtype: list of str """ mod_cmd = [apachectl, "-t", "-D", "DUMP_MODULES"] return parse_from_subprocess(mod_cmd, r"(.*)_module") def parse_from_subprocess(command, regexp): """Get values from stdout of subprocess command :param list command: Command to run :param str regexp: Regexp for parsing :returns: list parsed from command output :rtype: list """ stdout = _get_runtime_cfg(command) return re.compile(regexp).findall(stdout) def _get_runtime_cfg(command): """ Get runtime configuration info. :param command: Command to run :returns: stdout from command """ try: proc = subprocess.run( command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True, check=False, env=util.env_no_snap_for_external_calls()) stdout, stderr = proc.stdout, proc.stderr except (OSError, ValueError): logger.error( "Error running command %s for runtime parameters!%s", command, os.linesep) raise errors.MisconfigurationError( "Error accessing loaded Apache parameters: {0}".format( command)) # Small errors that do not impede if proc.returncode != 0: logger.warning("Error in checking parameter list: %s", stderr) raise errors.MisconfigurationError( "Apache is unable to check whether or not the module is " "loaded because Apache is misconfigured.") return stdout def find_ssl_apache_conf(prefix): """ Find a TLS Apache config file in the dedicated storage. :param str prefix: prefix of the TLS Apache config file to find :return: the path the TLS Apache config file :rtype: str """ return pkg_resources.resource_filename( "certbot_apache", os.path.join("_internal", "tls_configs", "{0}-options-ssl-apache.conf".format(prefix))) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/certbot_apache/_internal/apacheparser.py0000644000076500000240000001624400000000000023062 0ustar00bmwstaff""" apacheconfig implementation of the ParserNode interfaces """ from typing import Tuple from certbot_apache._internal import assertions from certbot_apache._internal import interfaces from certbot_apache._internal import parsernode_util as util class ApacheParserNode(interfaces.ParserNode): """ apacheconfig implementation of ParserNode interface. Expects metadata `ac_ast` to be passed in, where `ac_ast` is the AST provided by parsing the equivalent configuration text using the apacheconfig library. """ def __init__(self, **kwargs): ancestor, dirty, filepath, metadata = util.parsernode_kwargs(kwargs) # pylint: disable=unused-variable super().__init__(**kwargs) self.ancestor = ancestor self.filepath = filepath self.dirty = dirty self.metadata = metadata self._raw = self.metadata["ac_ast"] def save(self, msg): # pragma: no cover pass def find_ancestors(self, name): # pylint: disable=unused-variable """Find ancestor BlockNodes with a given name""" return [ApacheBlockNode(name=assertions.PASS, parameters=assertions.PASS, ancestor=self, filepath=assertions.PASS, metadata=self.metadata)] class ApacheCommentNode(ApacheParserNode): """ apacheconfig implementation of CommentNode interface """ def __init__(self, **kwargs): comment, kwargs = util.commentnode_kwargs(kwargs) # pylint: disable=unused-variable super().__init__(**kwargs) self.comment = comment def __eq__(self, other): # pragma: no cover if isinstance(other, self.__class__): return (self.comment == other.comment and self.dirty == other.dirty and self.ancestor == other.ancestor and self.metadata == other.metadata and self.filepath == other.filepath) return False class ApacheDirectiveNode(ApacheParserNode): """ apacheconfig implementation of DirectiveNode interface """ def __init__(self, **kwargs): name, parameters, enabled, kwargs = util.directivenode_kwargs(kwargs) super().__init__(**kwargs) self.name = name self.parameters = parameters self.enabled = enabled self.include = None def __eq__(self, other): # pragma: no cover if isinstance(other, self.__class__): return (self.name == other.name and self.filepath == other.filepath and self.parameters == other.parameters and self.enabled == other.enabled and self.dirty == other.dirty and self.ancestor == other.ancestor and self.metadata == other.metadata) return False def set_parameters(self, _parameters): # pragma: no cover """Sets the parameters for DirectiveNode""" return class ApacheBlockNode(ApacheDirectiveNode): """ apacheconfig implementation of BlockNode interface """ def __init__(self, **kwargs): super().__init__(**kwargs) self.children: Tuple[ApacheParserNode, ...] = () def __eq__(self, other): # pragma: no cover if isinstance(other, self.__class__): return (self.name == other.name and self.filepath == other.filepath and self.parameters == other.parameters and self.children == other.children and self.enabled == other.enabled and self.dirty == other.dirty and self.ancestor == other.ancestor and self.metadata == other.metadata) return False # pylint: disable=unused-argument def add_child_block(self, name, parameters=None, position=None): # pragma: no cover """Adds a new BlockNode to the sequence of children""" new_block = ApacheBlockNode(name=assertions.PASS, parameters=assertions.PASS, ancestor=self, filepath=assertions.PASS, metadata=self.metadata) self.children += (new_block,) return new_block # pylint: disable=unused-argument def add_child_directive(self, name, parameters=None, position=None): # pragma: no cover """Adds a new DirectiveNode to the sequence of children""" new_dir = ApacheDirectiveNode(name=assertions.PASS, parameters=assertions.PASS, ancestor=self, filepath=assertions.PASS, metadata=self.metadata) self.children += (new_dir,) return new_dir # pylint: disable=unused-argument def add_child_comment(self, comment="", position=None): # pragma: no cover """Adds a new CommentNode to the sequence of children""" new_comment = ApacheCommentNode(comment=assertions.PASS, ancestor=self, filepath=assertions.PASS, metadata=self.metadata) self.children += (new_comment,) return new_comment def find_blocks(self, name, exclude=True): # pylint: disable=unused-argument """Recursive search of BlockNodes from the sequence of children""" return [ApacheBlockNode(name=assertions.PASS, parameters=assertions.PASS, ancestor=self, filepath=assertions.PASS, metadata=self.metadata)] def find_directives(self, name, exclude=True): # pylint: disable=unused-argument """Recursive search of DirectiveNodes from the sequence of children""" return [ApacheDirectiveNode(name=assertions.PASS, parameters=assertions.PASS, ancestor=self, filepath=assertions.PASS, metadata=self.metadata)] # pylint: disable=unused-argument def find_comments(self, comment, exact=False): # pragma: no cover """Recursive search of DirectiveNodes from the sequence of children""" return [ApacheCommentNode(comment=assertions.PASS, ancestor=self, filepath=assertions.PASS, metadata=self.metadata)] def delete_child(self, child): # pragma: no cover """Deletes a ParserNode from the sequence of children""" return def unsaved_files(self): # pragma: no cover """Returns a list of unsaved filepaths""" return [assertions.PASS] def parsed_paths(self): # pragma: no cover """Returns a list of parsed configuration file paths""" return [assertions.PASS] interfaces.CommentNode.register(ApacheCommentNode) interfaces.DirectiveNode.register(ApacheDirectiveNode) interfaces.BlockNode.register(ApacheBlockNode) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/certbot_apache/_internal/assertions.py0000644000076500000240000001166100000000000022614 0ustar00bmwstaff"""Dual parser node assertions""" import fnmatch from certbot_apache._internal import interfaces PASS = "CERTBOT_PASS_ASSERT" def assertEqual(first, second): """ Equality assertion """ if isinstance(first, interfaces.CommentNode): assertEqualComment(first, second) elif isinstance(first, interfaces.DirectiveNode): assertEqualDirective(first, second) # Do an extra interface implementation assertion, as the contents were # already checked for BlockNode in the assertEqualDirective if isinstance(first, interfaces.BlockNode): assert isinstance(second, interfaces.BlockNode) # Skip tests if filepath includes the pass value. This is done # because filepath is variable of the base ParserNode interface, and # unless the implementation is actually done, we cannot assume getting # correct results from boolean assertion for dirty if not isPass(first.filepath) and not isPass(second.filepath): assert first.dirty == second.dirty # We might want to disable this later if testing with two separate # (but identical) directory structures. assert first.filepath == second.filepath def assertEqualComment(first, second): # pragma: no cover """ Equality assertion for CommentNode """ assert isinstance(first, interfaces.CommentNode) assert isinstance(second, interfaces.CommentNode) if not isPass(first.comment) and not isPass(second.comment): # type: ignore assert first.comment == second.comment # type: ignore def _assertEqualDirectiveComponents(first, second): # pragma: no cover """ Handles assertion for instance variables for DirectiveNode and BlockNode""" # Enabled value cannot be asserted, because Augeas implementation # is unable to figure that out. # assert first.enabled == second.enabled if not isPass(first.name) and not isPass(second.name): assert first.name == second.name if not isPass(first.parameters) and not isPass(second.parameters): assert first.parameters == second.parameters def assertEqualDirective(first, second): """ Equality assertion for DirectiveNode """ assert isinstance(first, interfaces.DirectiveNode) assert isinstance(second, interfaces.DirectiveNode) _assertEqualDirectiveComponents(first, second) def isPass(value): # pragma: no cover """Checks if the value is set to PASS""" if isinstance(value, bool): return True return PASS in value def isPassDirective(block): """ Checks if BlockNode or DirectiveNode should pass the assertion """ if isPass(block.name): return True if isPass(block.parameters): # pragma: no cover return True if isPass(block.filepath): # pragma: no cover return True return False def isPassComment(comment): """ Checks if CommentNode should pass the assertion """ if isPass(comment.comment): return True if isPass(comment.filepath): # pragma: no cover return True return False def isPassNodeList(nodelist): # pragma: no cover """ Checks if a ParserNode in the nodelist should pass the assertion, this function is used for results of find_* methods. Unimplemented find_* methods should return a sequence containing a single ParserNode instance with assertion pass string.""" try: node = nodelist[0] except IndexError: node = None if not node: # pragma: no cover return False if isinstance(node, interfaces.DirectiveNode): return isPassDirective(node) return isPassComment(node) def assertEqualSimple(first, second): """ Simple assertion """ if not isPass(first) and not isPass(second): assert first == second def isEqualVirtualHost(first, second): """ Checks that two VirtualHost objects are similar. There are some built in differences with the implementations: VirtualHost created by ParserNode implementation doesn't have "path" defined, as it was used for Augeas path and that cannot obviously be used in the future. Similarly the legacy version lacks "node" variable, that has a reference to the BlockNode for the VirtualHost. """ return ( first.name == second.name and first.aliases == second.aliases and first.filep == second.filep and first.addrs == second.addrs and first.ssl == second.ssl and first.enabled == second.enabled and first.modmacro == second.modmacro and first.ancestor == second.ancestor ) def assertEqualPathsList(first, second): # pragma: no cover """ Checks that the two lists of file paths match. This assertion allows for wildcard paths. """ if any(isPass(path) for path in first): return if any(isPass(path) for path in second): return for fpath in first: assert any(fnmatch.fnmatch(fpath, spath) for spath in second) for spath in second: assert any(fnmatch.fnmatch(fpath, spath) for fpath in first) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.7953832 certbot-apache-1.21.0/certbot_apache/_internal/augeas_lens/0000755000076500000240000000000000000000000022331 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/certbot_apache/_internal/augeas_lens/httpd.aug0000644000076500000240000001655000000000000024161 0ustar00bmwstaff(* Apache HTTPD lens for Augeas Authors: David Lutterkort Francis Giraldeau Raphael Pinson About: Reference Online Apache configuration manual: https://httpd.apache.org/docs/trunk/ About: License This file is licensed under the LGPL v2+. About: Lens Usage Sample usage of this lens in augtool Apache configuration is represented by two main structures, nested sections and directives. Sections are used as labels, while directives are kept as a value. Sections and directives can have positional arguments inside values of "arg" nodes. Arguments of sections must be the firsts child of the section node. This lens doesn't support automatic string quoting. Hence, the string must be quoted when containing a space. Create a new VirtualHost section with one directive: > clear /files/etc/apache2/sites-available/foo/VirtualHost > set /files/etc/apache2/sites-available/foo/VirtualHost/arg "172.16.0.1:80" > set /files/etc/apache2/sites-available/foo/VirtualHost/directive "ServerAdmin" > set /files/etc/apache2/sites-available/foo/VirtualHost/*[self::directive="ServerAdmin"]/arg "admin@example.com" About: Configuration files This lens applies to files in /etc/httpd and /etc/apache2. See . *) module Httpd = autoload xfm (****************************************************************** * Utilities lens *****************************************************************) let dels (s:string) = del s s (* The continuation sequence that indicates that we should consider the * next line part of the current line *) let cont = /\\\\\r?\n/ (* Whitespace within a line: space, tab, and the continuation sequence *) let ws = /[ \t]/ | cont (* Any possible character - '.' does not match \n *) let any = /(.|\n)/ (* Any character preceded by a backslash *) let esc_any = /\\\\(.|\n)/ (* Newline sequence - both for Unix and DOS newlines *) let nl = /\r?\n/ (* Whitespace at the end of a line *) let eol = del (ws* . nl) "\n" (* deal with continuation lines *) let sep_spc = del ws+ " " let sep_osp = del ws* "" let sep_eq = del (ws* . "=" . ws*) "=" let nmtoken = /[a-zA-Z:_][a-zA-Z0-9:_.-]*/ let word = /[a-z][a-z0-9._-]*/i (* A complete line that is either just whitespace or a comment that only * contains whitespace *) let empty = [ del (ws* . /#?/ . ws* . nl) "\n" ] let indent = Util.indent (* A comment that is not just whitespace. We define it in terms of the * things that are not allowed as part of such a comment: * 1) Starts with whitespace * 2) Ends with whitespace, a backslash or \r * 3) Unescaped newlines *) let comment = let comment_start = del (ws* . "#" . ws* ) "# " in let unesc_eol = /[^\]?/ . nl in let w = /[^\t\n\r \\]/ in let r = /[\r\\]/ in let s = /[\t\r ]/ in (* * we'd like to write * let b = /\\\\/ in * let t = /[\t\n\r ]/ in * let x = b . (t? . (s|w)* ) in * but the definition of b depends on commit 244c0edd in 1.9.0 and * would make the lens unusable with versions before 1.9.0. So we write * x out which works in older versions, too *) let x = /\\\\[\t\n\r ]?[^\n\\]*/ in let line = ((r . s* . w|w|r) . (s|w)* . x*|(r.s* )?).w.(s*.w)* in [ label "#comment" . comment_start . store line . eol ] (* borrowed from shellvars.aug *) let char_arg_sec = /([^\\ '"\t\r\n>]|[^ '"\t\r\n>]+[^\\ \t\r\n>])|\\\\"|\\\\'|\\\\ / let char_arg_wl = /([^\\ '"},\t\r\n]|[^ '"},\t\r\n]+[^\\ '"},\t\r\n])/ let dquot = let no_dquot = /[^"\\\r\n]/ in /"/ . (no_dquot|esc_any)* . /"/ let dquot_msg = let no_dquot = /([^ \t"\\\r\n]|[^"\\\r\n]+[^ \t"\\\r\n])/ in /"/ . (no_dquot|esc_any)* . no_dquot let squot = let no_squot = /[^'\\\r\n]/ in /'/ . (no_squot|esc_any)* . /'/ let comp = /[<>=]?=/ (****************************************************************** * Attributes *****************************************************************) (* The arguments for a directive come in two flavors: quoted with single or * double quotes, or bare. Bare arguments may not start with a single or * double quote; since we also treat "word lists" special, i.e. lists * enclosed in curly braces, bare arguments may not start with those, * either. * * Bare arguments may not contain unescaped spaces, but we allow escaping * with '\\'. Quoted arguments can contain anything, though the quote must * be escaped with '\\'. *) let bare = /([^{"' \t\n\r]|\\\\.)([^ \t\n\r]|\\\\.)*[^ \t\n\r\\]|[^{"' \t\n\r\\]/ let arg_quoted = [ label "arg" . store (dquot|squot) ] let arg_bare = [ label "arg" . store bare ] (* message argument starts with " but ends at EOL *) let arg_dir_msg = [ label "arg" . store dquot_msg ] let arg_wl = [ label "arg" . store (char_arg_wl+|dquot|squot) ] (* comma-separated wordlist as permitted in the SSLRequire directive *) let arg_wordlist = let wl_start = dels "{" in let wl_end = dels "}" in let wl_sep = del /[ \t]*,[ \t]*/ ", " in [ label "wordlist" . wl_start . arg_wl . (wl_sep . arg_wl)* . wl_end ] let argv (l:lens) = l . (sep_spc . l)* (* the arguments of a directive. We use this once we have parsed the name * of the directive, and the space right after it. When dir_args is used, * we also know that we have at least one argument. We need to be careful * with the spacing between arguments: quoted arguments and word lists do * not need to have space between them, but bare arguments do. * * Apache apparently is also happy if the last argument starts with a double * quote, but has no corresponding closing duoble quote, which is what * arg_dir_msg handles *) let dir_args = let arg_nospc = arg_quoted|arg_wordlist in (arg_bare . sep_spc | arg_nospc . sep_osp)* . (arg_bare|arg_nospc|arg_dir_msg) let directive = [ indent . label "directive" . store word . (sep_spc . dir_args)? . eol ] let arg_sec = [ label "arg" . store (char_arg_sec+|comp|dquot|squot) ] let section (body:lens) = (* opt_eol includes empty lines *) let opt_eol = del /([ \t]*#?[ \t]*\r?\n)*/ "\n" in let inner = (sep_spc . argv arg_sec)? . sep_osp . dels ">" . opt_eol . ((body|comment) . (body|empty|comment)*)? . indent . dels "[ \t\n\r]*/ ">\n" ] let perl_section = [ indent . label "Perl" . del //i "" . store /[^<]*/ . del /<\/perl>/i "" . eol ] let rec content = section (content|directive) | perl_section let lns = (content|directive|comment|empty)* let filter = (incl "/etc/apache2/apache2.conf") . (incl "/etc/apache2/httpd.conf") . (incl "/etc/apache2/ports.conf") . (incl "/etc/apache2/conf.d/*") . (incl "/etc/apache2/conf-available/*.conf") . (incl "/etc/apache2/mods-available/*") . (incl "/etc/apache2/sites-available/*") . (incl "/etc/apache2/vhosts.d/*.conf") . (incl "/etc/httpd/conf.d/*.conf") . (incl "/etc/httpd/httpd.conf") . (incl "/etc/httpd/conf/httpd.conf") . (incl "/etc/httpd/conf.modules.d/*.conf") . Util.stdexcl let xfm = transform lns filter ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/certbot_apache/_internal/augeasparser.py0000644000076500000240000004625100000000000023107 0ustar00bmwstaff""" Augeas implementation of the ParserNode interfaces. Augeas works internally by using XPATH notation. The following is a short example of how this all works internally, to better understand what's going on under the hood. A configuration file /etc/apache2/apache2.conf with the following content: # First comment line # Second comment line WhateverDirective whatevervalue DirectiveInABlock dirvalue SomeDirective somedirectivevalue AnotherDirectiveInABlock dirvalue # Yet another comment Translates over to Augeas path notation (of immediate children), when calling for example: aug.match("/files/etc/apache2/apache2.conf/*") [ "/files/etc/apache2/apache2.conf/#comment[1]", "/files/etc/apache2/apache2.conf/#comment[2]", "/files/etc/apache2/apache2.conf/directive[1]", "/files/etc/apache2/apache2.conf/ABlock[1]", "/files/etc/apache2/apache2.conf/directive[2]", "/files/etc/apache2/apache2.conf/ABlock[2]", "/files/etc/apache2/apache2.conf/#comment[3]" ] Regardless of directives name, its key in the Augeas tree is always "directive", with index where needed of course. Comments work similarly, while blocks have their own key in the Augeas XPATH notation. It's important to note that all of the unique keys have their own indices. Augeas paths are case sensitive, while Apache configuration is case insensitive. It looks like this: directive value Directive Value directive value DiReCtiVe VaLuE Translates over to: [ "/files/etc/apache2/apache2.conf/block[1]", "/files/etc/apache2/apache2.conf/Block[1]", "/files/etc/apache2/apache2.conf/block[2]", "/files/etc/apache2/apache2.conf/bLoCk[1]", ] """ from typing import Set from certbot import errors from certbot.compat import os from certbot_apache._internal import apache_util from certbot_apache._internal import assertions from certbot_apache._internal import interfaces from certbot_apache._internal import parser from certbot_apache._internal import parsernode_util as util class AugeasParserNode(interfaces.ParserNode): """ Augeas implementation of ParserNode interface """ def __init__(self, **kwargs): ancestor, dirty, filepath, metadata = util.parsernode_kwargs(kwargs) # pylint: disable=unused-variable super().__init__(**kwargs) self.ancestor = ancestor self.filepath = filepath self.dirty = dirty self.metadata = metadata self.parser = self.metadata.get("augeasparser") try: if self.metadata["augeaspath"].endswith("/"): raise errors.PluginError( "Augeas path: {} has a trailing slash".format( self.metadata["augeaspath"] ) ) except KeyError: raise errors.PluginError("Augeas path is required") def save(self, msg): self.parser.save(msg) def find_ancestors(self, name): """ Searches for ancestor BlockNodes with a given name. :param str name: Name of the BlockNode parent to search for :returns: List of matching ancestor nodes. :rtype: list of AugeasBlockNode """ ancestors = [] parent = self.metadata["augeaspath"] while True: # Get the path of ancestor node parent = parent.rpartition("/")[0] # Root of the tree if not parent or parent == "/files": break anc = self._create_blocknode(parent) if anc.name.lower() == name.lower(): ancestors.append(anc) return ancestors def _create_blocknode(self, path): """ Helper function to create a BlockNode from Augeas path. This is used by AugeasParserNode.find_ancestors and AugeasBlockNode. and AugeasBlockNode.find_blocks """ name = self._aug_get_name(path) metadata = {"augeasparser": self.parser, "augeaspath": path} # Check if the file was included from the root config or initial state enabled = self.parser.parsed_in_original( apache_util.get_file_path(path) ) return AugeasBlockNode(name=name, enabled=enabled, ancestor=assertions.PASS, filepath=apache_util.get_file_path(path), metadata=metadata) def _aug_get_name(self, path): """ Helper function to get name of a configuration block or variable from path. """ # Remove the ending slash if any if path[-1] == "/": # pragma: no cover path = path[:-1] # Get the block name name = path.split("/")[-1] # remove [...], it's not allowed in Apache configuration and is used # for indexing within Augeas name = name.split("[")[0] return name class AugeasCommentNode(AugeasParserNode): """ Augeas implementation of CommentNode interface """ def __init__(self, **kwargs): comment, kwargs = util.commentnode_kwargs(kwargs) # pylint: disable=unused-variable super().__init__(**kwargs) # self.comment = comment self.comment = comment def __eq__(self, other): if isinstance(other, self.__class__): return (self.comment == other.comment and self.filepath == other.filepath and self.dirty == other.dirty and self.ancestor == other.ancestor and self.metadata == other.metadata) return False class AugeasDirectiveNode(AugeasParserNode): """ Augeas implementation of DirectiveNode interface """ def __init__(self, **kwargs): name, parameters, enabled, kwargs = util.directivenode_kwargs(kwargs) super().__init__(**kwargs) self.name = name self.enabled = enabled if parameters: self.set_parameters(parameters) def __eq__(self, other): if isinstance(other, self.__class__): return (self.name == other.name and self.filepath == other.filepath and self.parameters == other.parameters and self.enabled == other.enabled and self.dirty == other.dirty and self.ancestor == other.ancestor and self.metadata == other.metadata) return False def set_parameters(self, parameters): """ Sets parameters of a DirectiveNode or BlockNode object. :param list parameters: List of all parameters for the node to set. """ orig_params = self._aug_get_params(self.metadata["augeaspath"]) # Clear out old parameters for _ in orig_params: # When the first parameter is removed, the indices get updated param_path = "{}/arg[1]".format(self.metadata["augeaspath"]) self.parser.aug.remove(param_path) # Insert new ones for pi, param in enumerate(parameters): param_path = "{}/arg[{}]".format(self.metadata["augeaspath"], pi+1) self.parser.aug.set(param_path, param) @property def parameters(self): """ Fetches the parameters from Augeas tree, ensuring that the sequence always represents the current state :returns: Tuple of parameters for this DirectiveNode :rtype: tuple: """ return tuple(self._aug_get_params(self.metadata["augeaspath"])) def _aug_get_params(self, path): """Helper function to get parameters for DirectiveNodes and BlockNodes""" arg_paths = self.parser.aug.match(path + "/arg") return [self.parser.get_arg(apath) for apath in arg_paths] class AugeasBlockNode(AugeasDirectiveNode): """ Augeas implementation of BlockNode interface """ def __init__(self, **kwargs): super().__init__(**kwargs) self.children = () def __eq__(self, other): if isinstance(other, self.__class__): return (self.name == other.name and self.filepath == other.filepath and self.parameters == other.parameters and self.children == other.children and self.enabled == other.enabled and self.dirty == other.dirty and self.ancestor == other.ancestor and self.metadata == other.metadata) return False # pylint: disable=unused-argument def add_child_block(self, name, parameters=None, position=None): # pragma: no cover """Adds a new BlockNode to the sequence of children""" insertpath, realpath, before = self._aug_resolve_child_position( name, position ) new_metadata = {"augeasparser": self.parser, "augeaspath": realpath} # Create the new block self.parser.aug.insert(insertpath, name, before) # Check if the file was included from the root config or initial state enabled = self.parser.parsed_in_original( apache_util.get_file_path(realpath) ) # Parameters will be set at the initialization of the new object new_block = AugeasBlockNode(name=name, parameters=parameters, enabled=enabled, ancestor=assertions.PASS, filepath=apache_util.get_file_path(realpath), metadata=new_metadata) return new_block # pylint: disable=unused-argument def add_child_directive(self, name, parameters=None, position=None): # pragma: no cover """Adds a new DirectiveNode to the sequence of children""" if not parameters: raise errors.PluginError("Directive requires parameters and none were set.") insertpath, realpath, before = self._aug_resolve_child_position( "directive", position ) new_metadata = {"augeasparser": self.parser, "augeaspath": realpath} # Create the new directive self.parser.aug.insert(insertpath, "directive", before) # Set the directive key self.parser.aug.set(realpath, name) # Check if the file was included from the root config or initial state enabled = self.parser.parsed_in_original( apache_util.get_file_path(realpath) ) new_dir = AugeasDirectiveNode(name=name, parameters=parameters, enabled=enabled, ancestor=assertions.PASS, filepath=apache_util.get_file_path(realpath), metadata=new_metadata) return new_dir def add_child_comment(self, comment="", position=None): """Adds a new CommentNode to the sequence of children""" insertpath, realpath, before = self._aug_resolve_child_position( "#comment", position ) new_metadata = {"augeasparser": self.parser, "augeaspath": realpath} # Create the new comment self.parser.aug.insert(insertpath, "#comment", before) # Set the comment content self.parser.aug.set(realpath, comment) new_comment = AugeasCommentNode(comment=comment, ancestor=assertions.PASS, filepath=apache_util.get_file_path(realpath), metadata=new_metadata) return new_comment def find_blocks(self, name, exclude=True): """Recursive search of BlockNodes from the sequence of children""" nodes = [] paths = self._aug_find_blocks(name) if exclude: paths = self.parser.exclude_dirs(paths) for path in paths: nodes.append(self._create_blocknode(path)) return nodes def find_directives(self, name, exclude=True): """Recursive search of DirectiveNodes from the sequence of children""" nodes = [] ownpath = self.metadata.get("augeaspath") directives = self.parser.find_dir(name, start=ownpath, exclude=exclude) already_parsed: Set[str] = set() for directive in directives: # Remove the /arg part from the Augeas path directive = directive.partition("/arg")[0] # find_dir returns an object for each _parameter_ of a directive # so we need to filter out duplicates. if directive not in already_parsed: nodes.append(self._create_directivenode(directive)) already_parsed.add(directive) return nodes def find_comments(self, comment): """ Recursive search of DirectiveNodes from the sequence of children. :param str comment: Comment content to search for. """ nodes = [] ownpath = self.metadata.get("augeaspath") comments = self.parser.find_comments(comment, start=ownpath) for com in comments: nodes.append(self._create_commentnode(com)) return nodes def delete_child(self, child): """ Deletes a ParserNode from the sequence of children, and raises an exception if it's unable to do so. :param AugeasParserNode: child: A node to delete. """ if not self.parser.aug.remove(child.metadata["augeaspath"]): raise errors.PluginError( ("Could not delete child node, the Augeas path: {} doesn't " + "seem to exist.").format(child.metadata["augeaspath"]) ) def unsaved_files(self): """Returns a list of unsaved filepaths""" return self.parser.unsaved_files() def parsed_paths(self): """ Returns a list of file paths that have currently been parsed into the parser tree. The returned list may include paths with wildcard characters, for example: ['/etc/apache2/conf.d/*.load'] This is typically called on the root node of the ParserNode tree. :returns: list of file paths of files that have been parsed """ res_paths = [] paths = self.parser.existing_paths for directory in paths: for filename in paths[directory]: res_paths.append(os.path.join(directory, filename)) return res_paths def _create_commentnode(self, path): """Helper function to create a CommentNode from Augeas path""" comment = self.parser.aug.get(path) metadata = {"augeasparser": self.parser, "augeaspath": path} # Because of the dynamic nature of AugeasParser and the fact that we're # not populating the complete node tree, the ancestor has a dummy value return AugeasCommentNode(comment=comment, ancestor=assertions.PASS, filepath=apache_util.get_file_path(path), metadata=metadata) def _create_directivenode(self, path): """Helper function to create a DirectiveNode from Augeas path""" name = self.parser.get_arg(path) metadata = {"augeasparser": self.parser, "augeaspath": path} # Check if the file was included from the root config or initial state enabled = self.parser.parsed_in_original( apache_util.get_file_path(path) ) return AugeasDirectiveNode(name=name, ancestor=assertions.PASS, enabled=enabled, filepath=apache_util.get_file_path(path), metadata=metadata) def _aug_find_blocks(self, name): """Helper function to perform a search to Augeas DOM tree to search configuration blocks with a given name""" # The code here is modified from configurator.get_virtual_hosts() blk_paths = set() for vhost_path in list(self.parser.parser_paths): paths = self.parser.aug.match( ("/files%s//*[label()=~regexp('%s')]" % (vhost_path, parser.case_i(name)))) blk_paths.update([path for path in paths if name.lower() in os.path.basename(path).lower()]) return blk_paths def _aug_resolve_child_position(self, name, position): """ Helper function that iterates through the immediate children and figures out the insertion path for a new AugeasParserNode. Augeas also generalizes indices for directives and comments, simply by using "directive" or "comment" respectively as their names. This function iterates over the existing children of the AugeasBlockNode, returning their insertion path, resulting Augeas path and if the new node should be inserted before or after the returned insertion path. Note: while Apache is case insensitive, Augeas is not, and blocks like Nameofablock and NameOfABlock have different indices. :param str name: Name of the AugeasBlockNode to insert, "directive" for AugeasDirectiveNode or "comment" for AugeasCommentNode :param int position: The position to insert the child AugeasParserNode to :returns: Tuple of insert path, resulting path and a boolean if the new node should be inserted before it. :rtype: tuple of str, str, bool """ # Default to appending before = False all_children = self.parser.aug.match("{}/*".format( self.metadata["augeaspath"]) ) # Calculate resulting_path # Augeas indices start at 1. We use counter to calculate the index to # be used in resulting_path. counter = 1 for i, child in enumerate(all_children): if position is not None and i >= position: # We're not going to insert the new node to an index after this break childname = self._aug_get_name(child) if name == childname: counter += 1 resulting_path = "{}/{}[{}]".format( self.metadata["augeaspath"], name, counter ) # Form the correct insert_path # Inserting the only child and appending as the last child work # similarly in Augeas. append = not all_children or position is None or position >= len(all_children) if append: insert_path = "{}/*[last()]".format( self.metadata["augeaspath"] ) elif position == 0: # Insert as the first child, before the current first one. insert_path = all_children[0] before = True else: insert_path = "{}/*[{}]".format( self.metadata["augeaspath"], position ) return (insert_path, resulting_path, before) interfaces.CommentNode.register(AugeasCommentNode) interfaces.DirectiveNode.register(AugeasDirectiveNode) interfaces.BlockNode.register(AugeasBlockNode) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/certbot_apache/_internal/configurator.py0000644000076500000240000033242400000000000023127 0ustar00bmwstaff"""Apache Configurator.""" # pylint: disable=too-many-lines from collections import defaultdict import copy from distutils.version import LooseVersion import fnmatch import logging import re import socket import time from typing import DefaultDict from typing import Dict from typing import List from typing import Optional from typing import Set from typing import Union from acme import challenges from certbot import errors from certbot import interfaces from certbot import util from certbot.achallenges import KeyAuthorizationAnnotatedChallenge # pylint: disable=unused-import from certbot.compat import filesystem from certbot.compat import os from certbot.display import util as display_util from certbot.plugins import common from certbot.plugins.enhancements import AutoHSTSEnhancement from certbot.plugins.util import path_surgery from certbot_apache._internal import apache_util from certbot_apache._internal import assertions from certbot_apache._internal import constants from certbot_apache._internal import display_ops from certbot_apache._internal import dualparser from certbot_apache._internal import http_01 from certbot_apache._internal import obj from certbot_apache._internal import parser from certbot_apache._internal.dualparser import DualBlockNode from certbot_apache._internal.obj import VirtualHost from certbot_apache._internal.parser import ApacheParser try: import apacheconfig HAS_APACHECONFIG = True except ImportError: # pragma: no cover HAS_APACHECONFIG = False logger = logging.getLogger(__name__) class OsOptions: """ Dedicated class to describe the OS specificities (eg. paths, binary names) that the Apache configurator needs to be aware to operate properly. """ def __init__(self, server_root="/etc/apache2", vhost_root="/etc/apache2/sites-available", vhost_files="*", logs_root="/var/log/apache2", ctl="apache2ctl", version_cmd: Optional[List[str]] = None, restart_cmd: Optional[List[str]] = None, restart_cmd_alt: Optional[List[str]] = None, conftest_cmd: Optional[List[str]] = None, enmod: Optional[str] = None, dismod: Optional[str] = None, le_vhost_ext="-le-ssl.conf", handle_modules=False, handle_sites=False, challenge_location="/etc/apache2", apache_bin: Optional[str] = None, ): self.server_root = server_root self.vhost_root = vhost_root self.vhost_files = vhost_files self.logs_root = logs_root self.ctl = ctl self.version_cmd = ['apache2ctl', '-v'] if not version_cmd else version_cmd self.restart_cmd = ['apache2ctl', 'graceful'] if not restart_cmd else restart_cmd self.restart_cmd_alt = restart_cmd_alt self.conftest_cmd = ['apache2ctl', 'configtest'] if not conftest_cmd else conftest_cmd self.enmod = enmod self.dismod = dismod self.le_vhost_ext = le_vhost_ext self.handle_modules = handle_modules self.handle_sites = handle_sites self.challenge_location = challenge_location self.bin = apache_bin # TODO: Augeas sections ie. , beginning and closing # tags need to be the same case, otherwise Augeas doesn't recognize them. # This is not able to be completely remedied by regular expressions because # Augeas views as an error. This will just # require another check_parsing_errors() after all files are included... # (after a find_directive search is executed currently). It can be a one # time check however because all of LE's transactions will ensure # only properly formed sections are added. # Note: This protocol works for filenames with spaces in it, the sites are # properly set up and directives are changed appropriately, but Apache won't # recognize names in sites-enabled that have spaces. These are not added to the # Apache configuration. It may be wise to warn the user if they are trying # to use vhost filenames that contain spaces and offer to change ' ' to '_' # Note: FILEPATHS and changes to files are transactional. They are copied # over before the updates are made to the existing files. NEW_FILES is # transactional due to the use of register_file_creation() # TODO: Verify permissions on configuration root... it is easier than # checking permissions on each of the relative directories and less error # prone. # TODO: Write a server protocol finder. Listen or # Protocol . This can verify partial setups are correct # TODO: Add directives to sites-enabled... not sites-available. # sites-available doesn't allow immediate find_dir search even with save() # and load() class ApacheConfigurator(common.Installer, interfaces.Authenticator): """Apache configurator. :ivar config: Configuration. :type config: certbot.configuration.NamespaceConfig :ivar parser: Handles low level parsing :type parser: :class:`~certbot_apache._internal.parser` :ivar tup version: version of Apache :ivar list vhosts: All vhosts found in the configuration (:class:`list` of :class:`~certbot_apache._internal.obj.VirtualHost`) :ivar dict assoc: Mapping between domains and vhosts """ description = "Apache Web Server plugin" if os.environ.get("CERTBOT_DOCS") == "1": description += ( # pragma: no cover " (Please note that the default values of the Apache plugin options" " change depending on the operating system Certbot is run on.)" ) OS_DEFAULTS = OsOptions() def pick_apache_config(self, warn_on_no_mod_ssl=True): """ Pick the appropriate TLS Apache configuration file for current version of Apache and OS. :param bool warn_on_no_mod_ssl: True if we should warn if mod_ssl is not found. :return: the path to the TLS Apache configuration file to use :rtype: str """ # Disabling TLS session tickets is supported by Apache 2.4.11+ and OpenSSL 1.0.2l+. # So for old versions of Apache we pick a configuration without this option. openssl_version = self.openssl_version(warn_on_no_mod_ssl) if self.version < (2, 4, 11) or not openssl_version or\ LooseVersion(openssl_version) < LooseVersion('1.0.2l'): return apache_util.find_ssl_apache_conf("old") return apache_util.find_ssl_apache_conf("current") def _prepare_options(self): """ Set the values possibly changed by command line parameters to OS_DEFAULTS constant dictionary """ opts = ["enmod", "dismod", "le_vhost_ext", "server_root", "vhost_root", "logs_root", "challenge_location", "handle_modules", "handle_sites", "ctl", "bin"] for o in opts: # Config options use dashes instead of underscores if self.conf(o.replace("_", "-")) is not None: setattr(self.options, o, self.conf(o.replace("_", "-"))) else: setattr(self.options, o, getattr(self.OS_DEFAULTS, o)) # Special cases self.options.version_cmd[0] = self.options.ctl self.options.restart_cmd[0] = self.options.ctl self.options.conftest_cmd[0] = self.options.ctl @classmethod def add_parser_arguments(cls, add): # When adding, modifying or deleting command line arguments, be sure to # include the changes in the list used in method _prepare_options() to # ensure consistent behavior. # Respect CERTBOT_DOCS environment variable and use default values from # base class regardless of the underlying distribution (overrides). if os.environ.get("CERTBOT_DOCS") == "1": DEFAULTS = ApacheConfigurator.OS_DEFAULTS else: # cls.OS_DEFAULTS can be distribution specific, see override classes DEFAULTS = cls.OS_DEFAULTS add("enmod", default=DEFAULTS.enmod, help="Path to the Apache 'a2enmod' binary") add("dismod", default=DEFAULTS.dismod, help="Path to the Apache 'a2dismod' binary") add("le-vhost-ext", default=DEFAULTS.le_vhost_ext, help="SSL vhost configuration extension") add("server-root", default=DEFAULTS.server_root, help="Apache server root directory") add("vhost-root", default=None, help="Apache server VirtualHost configuration root") add("logs-root", default=DEFAULTS.logs_root, help="Apache server logs directory") add("challenge-location", default=DEFAULTS.challenge_location, help="Directory path for challenge configuration") add("handle-modules", default=DEFAULTS.handle_modules, help="Let installer handle enabling required modules for you " + "(Only Ubuntu/Debian currently)") add("handle-sites", default=DEFAULTS.handle_sites, help="Let installer handle enabling sites for you " + "(Only Ubuntu/Debian currently)") add("ctl", default=DEFAULTS.ctl, help="Full path to Apache control script") add("bin", default=DEFAULTS.bin, help="Full path to apache2/httpd binary") def __init__(self, *args, **kwargs): """Initialize an Apache Configurator. :param tup version: version of Apache as a tuple (2, 4, 7) (used mostly for unittesting) """ version = kwargs.pop("version", None) use_parsernode = kwargs.pop("use_parsernode", False) openssl_version = kwargs.pop("openssl_version", None) super().__init__(*args, **kwargs) # Add name_server association dict self.assoc: Dict[str, obj.VirtualHost] = {} # Outstanding challenges self._chall_out: Set[KeyAuthorizationAnnotatedChallenge] = set() # List of vhosts configured per wildcard domain on this run. # used by deploy_cert() and enhance() self._wildcard_vhosts: Dict[str, List[obj.VirtualHost]] = {} # Maps enhancements to vhosts we've enabled the enhancement for self._enhanced_vhosts: DefaultDict[str, Set[obj.VirtualHost]] = defaultdict(set) # Temporary state for AutoHSTS enhancement self._autohsts: Dict[str, Dict[str, Union[int, float]]] = {} # Reverter save notes self.save_notes = "" # Should we use ParserNode implementation instead of the old behavior self.USE_PARSERNODE = use_parsernode # Saves the list of file paths that were parsed initially, and # not added to parser tree by self.conf("vhost-root") for example. self.parsed_paths: List[str] = [] # These will be set in the prepare function self._prepared = False self.parser: ApacheParser self.parser_root: Optional[DualBlockNode] = None self.version = version self._openssl_version = openssl_version self.vhosts: List[VirtualHost] self.options = copy.deepcopy(self.OS_DEFAULTS) self._enhance_func = {"redirect": self._enable_redirect, "ensure-http-header": self._set_http_header, "staple-ocsp": self._enable_ocsp_stapling} @property def mod_ssl_conf(self): """Full absolute path to SSL configuration file.""" return os.path.join(self.config.config_dir, constants.MOD_SSL_CONF_DEST) @property def updated_mod_ssl_conf_digest(self): """Full absolute path to digest of updated SSL configuration file.""" return os.path.join(self.config.config_dir, constants.UPDATED_MOD_SSL_CONF_DIGEST) def _open_module_file(self, ssl_module_location): """Extract the open lines of openssl_version for testing purposes""" try: with open(ssl_module_location, mode="rb") as f: contents = f.read() except IOError as error: logger.debug(str(error), exc_info=True) return None return contents def openssl_version(self, warn_on_no_mod_ssl=True): """Lazily retrieve openssl version :param bool warn_on_no_mod_ssl: `True` if we should warn if mod_ssl is not found. Set to `False` when we know we'll try to enable mod_ssl later. This is currently debian/ubuntu, when called from `prepare`. :return: the OpenSSL version as a string, or None. :rtype: str or None """ if self._openssl_version: return self._openssl_version # Step 1. Determine the location of ssl_module try: ssl_module_location = self.parser.modules['ssl_module'] except KeyError: if warn_on_no_mod_ssl: logger.warning("Could not find ssl_module; not disabling session tickets.") return None if ssl_module_location: # Possibility A: ssl_module is a DSO ssl_module_location = self.parser.standard_path_from_server_root(ssl_module_location) else: # Possibility B: ssl_module is statically linked into Apache if self.options.bin: ssl_module_location = self.options.bin else: logger.warning("ssl_module is statically linked but --apache-bin is " "missing; not disabling session tickets.") return None # Step 2. Grep in the binary for openssl version contents = self._open_module_file(ssl_module_location) if not contents: logger.warning("Unable to read ssl_module file; not disabling session tickets.") return None # looks like: OpenSSL 1.0.2s 28 May 2019 matches = re.findall(br"OpenSSL ([0-9]\.[^ ]+) ", contents) if not matches: logger.warning("Could not find OpenSSL version; not disabling session tickets.") return None self._openssl_version = matches[0].decode('UTF-8') return self._openssl_version def prepare(self): """Prepare the authenticator/installer. :raises .errors.NoInstallationError: If Apache configs cannot be found :raises .errors.MisconfigurationError: If Apache is misconfigured :raises .errors.NotSupportedError: If Apache version is not supported :raises .errors.PluginError: If there is any other error """ self._prepare_options() # Verify Apache is installed self._verify_exe_availability(self.options.ctl) # Make sure configuration is valid self.config_test() # Set Version if self.version is None: self.version = self.get_version() logger.debug('Apache version is %s', '.'.join(str(i) for i in self.version)) if self.version < (2, 2): raise errors.NotSupportedError( "Apache Version {0} not supported.".format(str(self.version))) elif self.version < (2, 4): logger.warning('Support for Apache 2.2 is deprecated and will be removed in a ' 'future release.') # Recover from previous crash before Augeas initialization to have the # correct parse tree from the get go. self.recovery_routine() # Perform the actual Augeas initialization to be able to react self.parser = self.get_parser() # Set up ParserNode root pn_meta = {"augeasparser": self.parser, "augeaspath": self.parser.get_root_augpath(), "ac_ast": None} if self.USE_PARSERNODE: parser_root = self.get_parsernode_root(pn_meta) self.parser_root = parser_root self.parsed_paths = parser_root.parsed_paths() # Check for errors in parsing files with Augeas self.parser.check_parsing_errors("httpd.aug") # Get all of the available vhosts self.vhosts = self.get_virtual_hosts() # We may try to enable mod_ssl later. If so, we shouldn't warn if we can't find it now. # This is currently only true for debian/ubuntu. warn_on_no_mod_ssl = not self.options.handle_modules self.install_ssl_options_conf(self.mod_ssl_conf, self.updated_mod_ssl_conf_digest, warn_on_no_mod_ssl) # Prevent two Apache plugins from modifying a config at once try: util.lock_dir_until_exit(self.options.server_root) except (OSError, errors.LockError): logger.debug("Encountered error:", exc_info=True) raise errors.PluginError( "Unable to create a lock file in {0}. Are you running" " Certbot with sufficient privileges to modify your" " Apache configuration?".format(self.options.server_root)) self._prepared = True def save(self, title=None, temporary=False): """Saves all changes to the configuration files. This function first checks for save errors, if none are found, all configuration changes made will be saved. According to the function parameters. If an exception is raised, a new checkpoint was not created. :param str title: The title of the save. If a title is given, the configuration will be saved as a new checkpoint and put in a timestamped directory. :param bool temporary: Indicates whether the changes made will be quickly reversed in the future (ie. challenges) """ save_files = self.parser.unsaved_files() if save_files: self.add_to_checkpoint(save_files, self.save_notes, temporary=temporary) # Handle the parser specific tasks self.parser.save(save_files) if title and not temporary: self.finalize_checkpoint(title) def recovery_routine(self): """Revert all previously modified files. Reverts all modified files that have not been saved as a checkpoint :raises .errors.PluginError: If unable to recover the configuration """ super().recovery_routine() # Reload configuration after these changes take effect if needed # ie. ApacheParser has been initialized. if hasattr(self, "parser"): # TODO: wrap into non-implementation specific parser interface self.parser.aug.load() def revert_challenge_config(self): """Used to cleanup challenge configurations. :raises .errors.PluginError: If unable to revert the challenge config. """ self.revert_temporary_config() self.parser.aug.load() def rollback_checkpoints(self, rollback=1): """Rollback saved checkpoints. :param int rollback: Number of checkpoints to revert :raises .errors.PluginError: If there is a problem with the input or the function is unable to correctly revert the configuration """ super().rollback_checkpoints(rollback) self.parser.aug.load() def _verify_exe_availability(self, exe): """Checks availability of Apache executable""" if not util.exe_exists(exe): if not path_surgery(exe): raise errors.NoInstallationError( 'Cannot find Apache executable {0}'.format(exe)) def get_parser(self): """Initializes the ApacheParser""" # If user provided vhost_root value in command line, use it return parser.ApacheParser( self.options.server_root, self.conf("vhost-root"), self.version, configurator=self) def get_parsernode_root(self, metadata): """Initializes the ParserNode parser root instance.""" if HAS_APACHECONFIG: apache_vars = {} apache_vars["defines"] = apache_util.parse_defines(self.options.ctl) apache_vars["includes"] = apache_util.parse_includes(self.options.ctl) apache_vars["modules"] = apache_util.parse_modules(self.options.ctl) metadata["apache_vars"] = apache_vars with open(self.parser.loc["root"]) as f: with apacheconfig.make_loader(writable=True, **apacheconfig.flavors.NATIVE_APACHE) as loader: metadata["ac_ast"] = loader.loads(f.read()) return dualparser.DualBlockNode( name=assertions.PASS, ancestor=None, filepath=self.parser.loc["root"], metadata=metadata ) def deploy_cert(self, domain, cert_path, key_path, chain_path=None, fullchain_path=None): """Deploys certificate to specified virtual host. Currently tries to find the last directives to deploy the certificate in the VHost associated with the given domain. If it can't find the directives, it searches the "included" confs. The function verifies that it has located the three directives and finally modifies them to point to the correct destination. After the certificate is installed, the VirtualHost is enabled if it isn't already. .. todo:: Might be nice to remove chain directive if none exists This shouldn't happen within certbot though :raises errors.PluginError: When unable to deploy certificate due to a lack of directives """ vhosts = self.choose_vhosts(domain) for vhost in vhosts: self._deploy_cert(vhost, cert_path, key_path, chain_path, fullchain_path) display_util.notify("Successfully deployed certificate for {} to {}" .format(domain, vhost.filep)) def choose_vhosts(self, domain, create_if_no_ssl=True): """ Finds VirtualHosts that can be used with the provided domain :param str domain: Domain name to match VirtualHosts to :param bool create_if_no_ssl: If found VirtualHost doesn't have a HTTPS counterpart, should one get created :returns: List of VirtualHosts or None :rtype: `list` of :class:`~certbot_apache._internal.obj.VirtualHost` """ if util.is_wildcard_domain(domain): if domain in self._wildcard_vhosts: # Vhosts for a wildcard domain were already selected return self._wildcard_vhosts[domain] # Ask user which VHosts to support. # Returned objects are guaranteed to be ssl vhosts return self._choose_vhosts_wildcard(domain, create_if_no_ssl) else: return [self.choose_vhost(domain, create_if_no_ssl)] def _vhosts_for_wildcard(self, domain): """ Get VHost objects for every VirtualHost that the user wants to handle with the wildcard certificate. """ # Collect all vhosts that match the name matched = set() for vhost in self.vhosts: for name in vhost.get_names(): if self._in_wildcard_scope(name, domain): matched.add(vhost) return list(matched) def _raise_no_suitable_vhost_error(self, target_name: str): """ Notifies the user that Certbot could not find a vhost to secure and raises an error. :param str target_name: The server name that could not be mapped :raises errors.PluginError: Raised unconditionally """ raise errors.PluginError( "Certbot could not find a VirtualHost for {0} in the Apache " "configuration. Please create a VirtualHost with a ServerName " "matching {0} and try again.".format(target_name) ) def _in_wildcard_scope(self, name, domain): """ Helper method for _vhosts_for_wildcard() that makes sure that the domain is in the scope of wildcard domain. eg. in scope: domain = *.wild.card, name = 1.wild.card not in scope: domain = *.wild.card, name = 1.2.wild.card """ if len(name.split(".")) == len(domain.split(".")): return fnmatch.fnmatch(name, domain) return None def _choose_vhosts_wildcard(self, domain, create_ssl=True): """Prompts user to choose vhosts to install a wildcard certificate for""" # Get all vhosts that are covered by the wildcard domain vhosts = self._vhosts_for_wildcard(domain) # Go through the vhosts, making sure that we cover all the names # present, but preferring the SSL vhosts filtered_vhosts = {} for vhost in vhosts: for name in vhost.get_names(): if vhost.ssl: # Always prefer SSL vhosts filtered_vhosts[name] = vhost elif name not in filtered_vhosts and create_ssl: # Add if not in list previously filtered_vhosts[name] = vhost # Only unique VHost objects dialog_input = set(filtered_vhosts.values()) # Ask the user which of names to enable, expect list of names back dialog_output = display_ops.select_vhost_multiple(list(dialog_input)) if not dialog_output: self._raise_no_suitable_vhost_error(domain) # Make sure we create SSL vhosts for the ones that are HTTP only # if requested. return_vhosts = [] for vhost in dialog_output: if not vhost.ssl: return_vhosts.append(self.make_vhost_ssl(vhost)) else: return_vhosts.append(vhost) self._wildcard_vhosts[domain] = return_vhosts return return_vhosts def _deploy_cert(self, vhost, cert_path, key_path, chain_path, fullchain_path): """ Helper function for deploy_cert() that handles the actual deployment this exists because we might want to do multiple deployments per domain originally passed for deploy_cert(). This is especially true with wildcard certificates """ # This is done first so that ssl module is enabled and cert_path, # cert_key... can all be parsed appropriately self.prepare_server_https("443") # If we haven't managed to enable mod_ssl by this point, error out if "ssl_module" not in self.parser.modules: raise errors.MisconfigurationError("Could not find ssl_module; " "not installing certificate.") # Add directives and remove duplicates self._add_dummy_ssl_directives(vhost.path) self._clean_vhost(vhost) path = {"cert_path": self.parser.find_dir("SSLCertificateFile", None, vhost.path), "cert_key": self.parser.find_dir("SSLCertificateKeyFile", None, vhost.path)} # Only include if a certificate chain is specified if chain_path is not None: path["chain_path"] = self.parser.find_dir( "SSLCertificateChainFile", None, vhost.path) logger.info("Deploying Certificate to VirtualHost %s", vhost.filep) if self.version < (2, 4, 8) or (chain_path and not fullchain_path): # install SSLCertificateFile, SSLCertificateKeyFile, # and SSLCertificateChainFile directives set_cert_path = cert_path self.parser.aug.set(path["cert_path"][-1], cert_path) self.parser.aug.set(path["cert_key"][-1], key_path) if chain_path is not None: self.parser.add_dir(vhost.path, "SSLCertificateChainFile", chain_path) else: raise errors.PluginError("--chain-path is required for your " "version of Apache") else: if not fullchain_path: raise errors.PluginError("Please provide the --fullchain-path " "option pointing to your full chain file") set_cert_path = fullchain_path self.parser.aug.set(path["cert_path"][-1], fullchain_path) self.parser.aug.set(path["cert_key"][-1], key_path) # Enable the new vhost if needed if not vhost.enabled: self.enable_site(vhost) # Save notes about the transaction that took place self.save_notes += ("Changed vhost at %s with addresses of %s\n" "\tSSLCertificateFile %s\n" "\tSSLCertificateKeyFile %s\n" % (vhost.filep, ", ".join(str(addr) for addr in vhost.addrs), set_cert_path, key_path)) if chain_path is not None: self.save_notes += "\tSSLCertificateChainFile %s\n" % chain_path def choose_vhost(self, target_name, create_if_no_ssl=True): """Chooses a virtual host based on the given domain name. If there is no clear virtual host to be selected, the user is prompted with all available choices. The returned vhost is guaranteed to have TLS enabled unless create_if_no_ssl is set to False, in which case there is no such guarantee and the result is not cached. :param str target_name: domain name :param bool create_if_no_ssl: If found VirtualHost doesn't have a HTTPS counterpart, should one get created :returns: vhost associated with name :rtype: :class:`~certbot_apache._internal.obj.VirtualHost` :raises .errors.PluginError: If no vhost is available or chosen """ # Allows for domain names to be associated with a virtual host if target_name in self.assoc: return self.assoc[target_name] # Try to find a reasonable vhost vhost = self._find_best_vhost(target_name) if vhost is not None: if not create_if_no_ssl: return vhost if not vhost.ssl: vhost = self.make_vhost_ssl(vhost) self._add_servername_alias(target_name, vhost) self.assoc[target_name] = vhost return vhost # Negate create_if_no_ssl value to indicate if we want a SSL vhost # to get created if a non-ssl vhost is selected. return self._choose_vhost_from_list(target_name, temp=not create_if_no_ssl) def _choose_vhost_from_list(self, target_name, temp=False): # Select a vhost from a list vhost = display_ops.select_vhost(target_name, self.vhosts) if vhost is None: self._raise_no_suitable_vhost_error(target_name) if temp: return vhost if not vhost.ssl: addrs = self._get_proposed_addrs(vhost, "443") # TODO: Conflicts is too conservative if not any(vhost.enabled and vhost.conflicts(addrs) for vhost in self.vhosts): vhost = self.make_vhost_ssl(vhost) else: logger.error( "The selected vhost would conflict with other HTTPS " "VirtualHosts within Apache. Please select another " "vhost or add ServerNames to your configuration.") raise errors.PluginError( "VirtualHost not able to be selected.") self._add_servername_alias(target_name, vhost) self.assoc[target_name] = vhost return vhost def domain_in_names(self, names, target_name): """Checks if target domain is covered by one or more of the provided names. The target name is matched by wildcard as well as exact match. :param names: server aliases :type names: `collections.Iterable` of `str` :param str target_name: name to compare with wildcards :returns: True if target_name is covered by a wildcard, otherwise, False :rtype: bool """ # use lowercase strings because fnmatch can be case sensitive target_name = target_name.lower() for name in names: name = name.lower() # fnmatch treats "[seq]" specially and [ or ] characters aren't # valid in Apache but Apache doesn't error out if they are present if "[" not in name and fnmatch.fnmatch(target_name, name): return True return False def find_best_http_vhost(self, target, filter_defaults, port="80"): """Returns non-HTTPS vhost objects found from the Apache config :param str target: Domain name of the desired VirtualHost :param bool filter_defaults: whether _default_ vhosts should be included if it is the best match :param str port: port number the vhost should be listening on :returns: VirtualHost object that's the best match for target name :rtype: `obj.VirtualHost` or None """ filtered_vhosts = [] for vhost in self.vhosts: if any(a.is_wildcard() or a.get_port() == port for a in vhost.addrs) and not vhost.ssl: filtered_vhosts.append(vhost) return self._find_best_vhost(target, filtered_vhosts, filter_defaults) def _find_best_vhost(self, target_name, vhosts=None, filter_defaults=True): """Finds the best vhost for a target_name. This does not upgrade a vhost to HTTPS... it only finds the most appropriate vhost for the given target_name. :param str target_name: domain handled by the desired vhost :param vhosts: vhosts to consider :type vhosts: `collections.Iterable` of :class:`~certbot_apache._internal.obj.VirtualHost` :param bool filter_defaults: whether a vhost with a _default_ addr is acceptable :returns: VHost or None """ # Points 6 - Servername SSL # Points 5 - Wildcard SSL # Points 4 - Address name with SSL # Points 3 - Servername no SSL # Points 2 - Wildcard no SSL # Points 1 - Address name with no SSL best_candidate = None best_points = 0 if vhosts is None: vhosts = self.vhosts for vhost in vhosts: if vhost.modmacro is True: continue names = vhost.get_names() if target_name in names: points = 3 elif self.domain_in_names(names, target_name): points = 2 elif any(addr.get_addr() == target_name for addr in vhost.addrs): points = 1 else: # No points given if names can't be found. # This gets hit but doesn't register continue # pragma: no cover if vhost.ssl: points += 3 if points > best_points: best_points = points best_candidate = vhost # No winners here... is there only one reasonable vhost? if best_candidate is None: if filter_defaults: vhosts = self._non_default_vhosts(vhosts) # remove mod_macro hosts from reasonable vhosts reasonable_vhosts = [vh for vh in vhosts if vh.modmacro is False] if len(reasonable_vhosts) == 1: best_candidate = reasonable_vhosts[0] return best_candidate def _non_default_vhosts(self, vhosts): """Return all non _default_ only vhosts.""" return [vh for vh in vhosts if not all( addr.get_addr() == "_default_" for addr in vh.addrs )] def get_all_names(self): """Returns all names found in the Apache Configuration. :returns: All ServerNames, ServerAliases, and reverse DNS entries for virtual host addresses :rtype: set """ all_names: Set[str] = set() vhost_macro = [] for vhost in self.vhosts: all_names.update(vhost.get_names()) if vhost.modmacro: vhost_macro.append(vhost.filep) for addr in vhost.addrs: if common.hostname_regex.match(addr.get_addr()): all_names.add(addr.get_addr()) else: name = self.get_name_from_ip(addr) if name: all_names.add(name) if vhost_macro: display_util.notification( "Apache mod_macro seems to be in use in file(s):\n{0}" "\n\nUnfortunately mod_macro is not yet supported".format( "\n ".join(vhost_macro)), force_interactive=True) return util.get_filtered_names(all_names) def get_name_from_ip(self, addr): """Returns a reverse dns name if available. :param addr: IP Address :type addr: ~.common.Addr :returns: name or empty string if name cannot be determined :rtype: str """ # If it isn't a private IP, do a reverse DNS lookup if not common.private_ips_regex.match(addr.get_addr()): try: socket.inet_aton(addr.get_addr()) return socket.gethostbyaddr(addr.get_addr())[0] except (socket.error, socket.herror, socket.timeout): pass return "" def _get_vhost_names(self, path): """Helper method for getting the ServerName and ServerAlias values from vhost in path :param path: Path to read ServerName and ServerAliases from :returns: Tuple including ServerName and `list` of ServerAlias strings """ servername_match = self.parser.find_dir( "ServerName", None, start=path, exclude=False) serveralias_match = self.parser.find_dir( "ServerAlias", None, start=path, exclude=False) serveraliases = [] for alias in serveralias_match: serveralias = self.parser.get_arg(alias) serveraliases.append(serveralias) servername = None if servername_match: # Get last ServerName as each overwrites the previous servername = self.parser.get_arg(servername_match[-1]) return (servername, serveraliases) def _add_servernames(self, host): """Helper function for get_virtual_hosts(). :param host: In progress vhost whose names will be added :type host: :class:`~certbot_apache._internal.obj.VirtualHost` """ servername, serveraliases = self._get_vhost_names(host.path) for alias in serveraliases: if not host.modmacro: host.aliases.add(alias) if not host.modmacro: host.name = servername def _create_vhost(self, path): """Used by get_virtual_hosts to create vhost objects :param str path: Augeas path to virtual host :returns: newly created vhost :rtype: :class:`~certbot_apache._internal.obj.VirtualHost` """ addrs = set() try: args = self.parser.aug.match(path + "/arg") except RuntimeError: logger.warning("Encountered a problem while parsing file: %s, skipping", path) return None for arg in args: addrs.add(obj.Addr.fromstring(self.parser.get_arg(arg))) is_ssl = False if self.parser.find_dir("SSLEngine", "on", start=path, exclude=False): is_ssl = True # "SSLEngine on" might be set outside of # Treat vhosts with port 443 as ssl vhosts for addr in addrs: if addr.get_port() == "443": is_ssl = True filename = apache_util.get_file_path( self.parser.aug.get("/augeas/files%s/path" % apache_util.get_file_path(path))) if filename is None: return None macro = False if "/macro/" in path.lower(): macro = True vhost_enabled = self.parser.parsed_in_original(filename) vhost = obj.VirtualHost(filename, path, addrs, is_ssl, vhost_enabled, modmacro=macro) self._add_servernames(vhost) return vhost def get_virtual_hosts(self): """ Temporary wrapper for legacy and ParserNode version for get_virtual_hosts. This should be replaced with the ParserNode implementation when ready. """ v1_vhosts = self.get_virtual_hosts_v1() if self.USE_PARSERNODE and HAS_APACHECONFIG: v2_vhosts = self.get_virtual_hosts_v2() for v1_vh in v1_vhosts: found = False for v2_vh in v2_vhosts: if assertions.isEqualVirtualHost(v1_vh, v2_vh): found = True break if not found: raise AssertionError("Equivalent for {} was not found".format(v1_vh.path)) return v2_vhosts return v1_vhosts def get_virtual_hosts_v1(self): """Returns list of virtual hosts found in the Apache configuration. :returns: List of :class:`~certbot_apache._internal.obj.VirtualHost` objects found in configuration :rtype: list """ # Search base config, and all included paths for VirtualHosts file_paths: Dict[str, str] = {} internal_paths: DefaultDict[str, Set[str]] = defaultdict(set) vhs = [] # Make a list of parser paths because the parser_paths # dictionary may be modified during the loop. for vhost_path in list(self.parser.parser_paths): paths = self.parser.aug.match( ("/files%s//*[label()=~regexp('%s')]" % (vhost_path, parser.case_i("VirtualHost")))) paths = [path for path in paths if "virtualhost" in os.path.basename(path).lower()] for path in paths: new_vhost = self._create_vhost(path) if not new_vhost: continue internal_path = apache_util.get_internal_aug_path(new_vhost.path) realpath = filesystem.realpath(new_vhost.filep) if realpath not in file_paths: file_paths[realpath] = new_vhost.filep internal_paths[realpath].add(internal_path) vhs.append(new_vhost) elif (realpath == new_vhost.filep and realpath != file_paths[realpath]): # Prefer "real" vhost paths instead of symlinked ones # ex: sites-enabled/vh.conf -> sites-available/vh.conf # remove old (most likely) symlinked one new_vhs = [] for v in vhs: if v.filep == file_paths[realpath]: internal_paths[realpath].remove( apache_util.get_internal_aug_path(v.path)) else: new_vhs.append(v) vhs = new_vhs file_paths[realpath] = realpath internal_paths[realpath].add(internal_path) vhs.append(new_vhost) elif internal_path not in internal_paths[realpath]: internal_paths[realpath].add(internal_path) vhs.append(new_vhost) return vhs def get_virtual_hosts_v2(self): """Returns list of virtual hosts found in the Apache configuration using ParserNode interface. :returns: List of :class:`~certbot_apache.obj.VirtualHost` objects found in configuration :rtype: list """ if not self.parser_root: raise errors.Error("This ApacheConfigurator instance is not" # pragma: no cover " configured to use a node parser.") vhs = [] vhosts = self.parser_root.find_blocks("VirtualHost", exclude=False) for vhblock in vhosts: vhs.append(self._create_vhost_v2(vhblock)) return vhs def _create_vhost_v2(self, node): """Used by get_virtual_hosts_v2 to create vhost objects using ParserNode interfaces. :param interfaces.BlockNode node: The BlockNode object of VirtualHost block :returns: newly created vhost :rtype: :class:`~certbot_apache.obj.VirtualHost` """ addrs = set() for param in node.parameters: addrs.add(obj.Addr.fromstring(param)) is_ssl = False # Exclusion to match the behavior in get_virtual_hosts_v2 sslengine = node.find_directives("SSLEngine", exclude=False) if sslengine: for directive in sslengine: if directive.parameters[0].lower() == "on": is_ssl = True break # "SSLEngine on" might be set outside of # Treat vhosts with port 443 as ssl vhosts for addr in addrs: if addr.get_port() == "443": is_ssl = True enabled = apache_util.included_in_paths(node.filepath, self.parsed_paths) macro = False # Check if the VirtualHost is contained in a mod_macro block if node.find_ancestors("Macro"): macro = True vhost = obj.VirtualHost( node.filepath, None, addrs, is_ssl, enabled, modmacro=macro, node=node ) self._populate_vhost_names_v2(vhost) return vhost def _populate_vhost_names_v2(self, vhost): """Helper function that populates the VirtualHost names. :param host: In progress vhost whose names will be added :type host: :class:`~certbot_apache.obj.VirtualHost` """ servername_match = vhost.node.find_directives("ServerName", exclude=False) serveralias_match = vhost.node.find_directives("ServerAlias", exclude=False) servername = None if servername_match: servername = servername_match[-1].parameters[-1] if not vhost.modmacro: for alias in serveralias_match: for serveralias in alias.parameters: vhost.aliases.add(serveralias) vhost.name = servername def is_name_vhost(self, target_addr): """Returns if vhost is a name based vhost NameVirtualHost was deprecated in Apache 2.4 as all VirtualHosts are now NameVirtualHosts. If version is earlier than 2.4, check if addr has a NameVirtualHost directive in the Apache config :param certbot_apache._internal.obj.Addr target_addr: vhost address :returns: Success :rtype: bool """ # Mixed and matched wildcard NameVirtualHost with VirtualHost # behavior is undefined. Make sure that an exact match exists # search for NameVirtualHost directive for ip_addr # note ip_addr can be FQDN although Apache does not recommend it return (self.version >= (2, 4) or self.parser.find_dir("NameVirtualHost", str(target_addr))) def add_name_vhost(self, addr): """Adds NameVirtualHost directive for given address. :param addr: Address that will be added as NameVirtualHost directive :type addr: :class:`~certbot_apache._internal.obj.Addr` """ loc = parser.get_aug_path(self.parser.loc["name"]) if addr.get_port() == "443": self.parser.add_dir_to_ifmodssl( loc, "NameVirtualHost", [str(addr)]) else: self.parser.add_dir(loc, "NameVirtualHost", [str(addr)]) msg = "Setting {0} to be NameBasedVirtualHost\n".format(addr) logger.debug(msg) self.save_notes += msg def prepare_server_https(self, port, temp=False): """Prepare the server for HTTPS. Make sure that the ssl_module is loaded and that the server is appropriately listening on port. :param str port: Port to listen on """ self.prepare_https_modules(temp) self.ensure_listen(port, https=True) def ensure_listen(self, port, https=False): """Make sure that Apache is listening on the port. Checks if the Listen statement for the port already exists, and adds it to the configuration if necessary. :param str port: Port number to check and add Listen for if not in place already :param bool https: If the port will be used for HTTPS """ # If HTTPS requested for nonstandard port, add service definition if https and port != "443": port_service = "%s %s" % (port, "https") else: port_service = port # Check for Listen # Note: This could be made to also look for ip:443 combo listens = [self.parser.get_arg(x).split()[0] for x in self.parser.find_dir("Listen")] # Listen already in place if self._has_port_already(listens, port): return listen_dirs = set(listens) if not listens: listen_dirs.add(port_service) for listen in listens: # For any listen statement, check if the machine also listens on # the given port. If not, add such a listen statement. if len(listen.split(":")) == 1: # Its listening to all interfaces if port not in listen_dirs and port_service not in listen_dirs: listen_dirs.add(port_service) else: # The Listen statement specifies an ip _, ip = listen[::-1].split(":", 1) ip = ip[::-1] if "%s:%s" % (ip, port_service) not in listen_dirs and ( "%s:%s" % (ip, port_service) not in listen_dirs): listen_dirs.add("%s:%s" % (ip, port_service)) if https: self._add_listens_https(listen_dirs, listens, port) else: self._add_listens_http(listen_dirs, listens, port) def _add_listens_http(self, listens, listens_orig, port): """Helper method for ensure_listen to figure out which new listen statements need adding for listening HTTP on port :param set listens: Set of all needed Listen statements :param list listens_orig: List of existing listen statements :param string port: Port number we're adding """ new_listens = listens.difference(listens_orig) if port in new_listens: # We have wildcard, skip the rest self.parser.add_dir(parser.get_aug_path(self.parser.loc["listen"]), "Listen", port) self.save_notes += "Added Listen %s directive to %s\n" % ( port, self.parser.loc["listen"]) else: for listen in new_listens: self.parser.add_dir(parser.get_aug_path( self.parser.loc["listen"]), "Listen", listen.split(" ")) self.save_notes += ("Added Listen %s directive to " "%s\n") % (listen, self.parser.loc["listen"]) def _add_listens_https(self, listens, listens_orig, port): """Helper method for ensure_listen to figure out which new listen statements need adding for listening HTTPS on port :param set listens: Set of all needed Listen statements :param list listens_orig: List of existing listen statements :param string port: Port number we're adding """ # Add service definition for non-standard ports if port != "443": port_service = "%s %s" % (port, "https") else: port_service = port new_listens = listens.difference(listens_orig) if port in new_listens or port_service in new_listens: # We have wildcard, skip the rest self.parser.add_dir_to_ifmodssl( parser.get_aug_path(self.parser.loc["listen"]), "Listen", port_service.split(" ")) self.save_notes += "Added Listen %s directive to %s\n" % ( port_service, self.parser.loc["listen"]) else: for listen in new_listens: self.parser.add_dir_to_ifmodssl( parser.get_aug_path(self.parser.loc["listen"]), "Listen", listen.split(" ")) self.save_notes += ("Added Listen %s directive to " "%s\n") % (listen, self.parser.loc["listen"]) def _has_port_already(self, listens, port): """Helper method for prepare_server_https to find out if user already has an active Listen statement for the port we need :param list listens: List of listen variables :param string port: Port in question """ if port in listens: return True # Check if Apache is already listening on a specific IP for listen in listens: if len(listen.split(":")) > 1: # Ugly but takes care of protocol def, eg: 1.1.1.1:443 https if listen.split(":")[-1].split(" ")[0] == port: return True return None def prepare_https_modules(self, temp): """Helper method for prepare_server_https, taking care of enabling needed modules :param boolean temp: If the change is temporary """ if self.options.handle_modules: if self.version >= (2, 4) and ("socache_shmcb_module" not in self.parser.modules): self.enable_mod("socache_shmcb", temp=temp) if "ssl_module" not in self.parser.modules: self.enable_mod("ssl", temp=temp) # Make sure we're not throwing away any unwritten changes to the config self.parser.ensure_augeas_state() self.parser.aug.load() self.parser.reset_modules() # Reset to load the new ssl_module path # Call again because now we can gate on openssl version self.install_ssl_options_conf(self.mod_ssl_conf, self.updated_mod_ssl_conf_digest, warn_on_no_mod_ssl=True) def make_vhost_ssl(self, nonssl_vhost): """Makes an ssl_vhost version of a nonssl_vhost. Duplicates vhost and adds default ssl options New vhost will reside as (nonssl_vhost.path) + ``self.options.le_vhost_ext`` .. note:: This function saves the configuration :param nonssl_vhost: Valid VH that doesn't have SSLEngine on :type nonssl_vhost: :class:`~certbot_apache._internal.obj.VirtualHost` :returns: SSL vhost :rtype: :class:`~certbot_apache._internal.obj.VirtualHost` :raises .errors.PluginError: If more than one virtual host is in the file or if plugin is unable to write/read vhost files. """ avail_fp = nonssl_vhost.filep ssl_fp = self._get_ssl_vhost_path(avail_fp) orig_matches = self.parser.aug.match("/files%s//* [label()=~regexp('%s')]" % (self._escape(ssl_fp), parser.case_i("VirtualHost"))) self._copy_create_ssl_vhost_skeleton(nonssl_vhost, ssl_fp) # Reload augeas to take into account the new vhost self.parser.aug.load() # Get Vhost augeas path for new vhost new_matches = self.parser.aug.match("/files%s//* [label()=~regexp('%s')]" % (self._escape(ssl_fp), parser.case_i("VirtualHost"))) vh_p = self._get_new_vh_path(orig_matches, new_matches) if not vh_p: # The vhost was not found on the currently parsed paths # Make Augeas aware of the new vhost self.parser.parse_file(ssl_fp) # Try to search again new_matches = self.parser.aug.match( "/files%s//* [label()=~regexp('%s')]" % (self._escape(ssl_fp), parser.case_i("VirtualHost"))) vh_p = self._get_new_vh_path(orig_matches, new_matches) if not vh_p: raise errors.PluginError( "Could not reverse map the HTTPS VirtualHost to the original") # Update Addresses self._update_ssl_vhosts_addrs(vh_p) # Log actions and create save notes logger.info("Created an SSL vhost at %s", ssl_fp) self.save_notes += "Created ssl vhost at %s\n" % ssl_fp self.save() # We know the length is one because of the assertion above # Create the Vhost object ssl_vhost = self._create_vhost(vh_p) ssl_vhost.ancestor = nonssl_vhost self.vhosts.append(ssl_vhost) # NOTE: Searches through Augeas seem to ruin changes to directives # The configuration must also be saved before being searched # for the new directives; For these reasons... this is tacked # on after fully creating the new vhost # Now check if addresses need to be added as NameBasedVhost addrs # This is for compliance with versions of Apache < 2.4 self._add_name_vhost_if_necessary(ssl_vhost) return ssl_vhost def _get_new_vh_path(self, orig_matches, new_matches): """ Helper method for make_vhost_ssl for matching augeas paths. Returns VirtualHost path from new_matches that's not present in orig_matches. Paths are normalized, because augeas leaves indices out for paths with only single directive with a similar key """ orig_matches = [i.replace("[1]", "") for i in orig_matches] for match in new_matches: if match.replace("[1]", "") not in orig_matches: # Return the unmodified path return match return None def _get_ssl_vhost_path(self, non_ssl_vh_fp): """ Get a file path for SSL vhost, uses user defined path as priority, but if the value is invalid or not defined, will fall back to non-ssl vhost filepath. :param str non_ssl_vh_fp: Filepath of non-SSL vhost :returns: Filepath for SSL vhost :rtype: str """ if self.conf("vhost-root") and os.path.exists(self.conf("vhost-root")): fp = os.path.join(filesystem.realpath(self.options.vhost_root), os.path.basename(non_ssl_vh_fp)) else: # Use non-ssl filepath fp = filesystem.realpath(non_ssl_vh_fp) if fp.endswith(".conf"): return fp[:-(len(".conf"))] + self.options.le_vhost_ext return fp + self.options.le_vhost_ext def _sift_rewrite_rule(self, line): """Decides whether a line should be copied to a SSL vhost. A canonical example of when sifting a line is required: When the http vhost contains a RewriteRule that unconditionally redirects any request to the https version of the same site. e.g: RewriteRule ^ https://%{SERVER_NAME}%{REQUEST_URI} [L,QSA,R=permanent] Copying the above line to the ssl vhost would cause a redirection loop. :param str line: a line extracted from the http vhost. :returns: True - don't copy line from http vhost to SSL vhost. :rtype: bool """ if not line.lower().lstrip().startswith("rewriterule"): return False # According to: https://httpd.apache.org/docs/2.4/rewrite/flags.html # The syntax of a RewriteRule is: # RewriteRule pattern target [Flag1,Flag2,Flag3] # i.e. target is required, so it must exist. target = line.split()[2].strip() # target may be surrounded with quotes if target[0] in ("'", '"') and target[0] == target[-1]: target = target[1:-1] # Sift line if it redirects the request to a HTTPS site return target.startswith("https://") def _copy_create_ssl_vhost_skeleton(self, vhost, ssl_fp): """Copies over existing Vhost with IfModule mod_ssl.c> skeleton. :param obj.VirtualHost vhost: Original VirtualHost object :param str ssl_fp: Full path where the new ssl_vhost will reside. A new file is created on the filesystem. """ # First register the creation so that it is properly removed if # configuration is rolled back if os.path.exists(ssl_fp): notes = "Appended new VirtualHost directive to file %s" % ssl_fp files = set() files.add(ssl_fp) self.reverter.add_to_checkpoint(files, notes) else: self.reverter.register_file_creation(False, ssl_fp) sift = False try: orig_contents = self._get_vhost_block(vhost) ssl_vh_contents, sift = self._sift_rewrite_rules(orig_contents) with open(ssl_fp, "a") as new_file: new_file.write("\n") new_file.write("\n".join(ssl_vh_contents)) # The content does not include the closing tag, so add it new_file.write("\n") new_file.write("\n") # Add new file to augeas paths if we're supposed to handle # activation (it's not included as default) if not self.parser.parsed_in_current(ssl_fp): self.parser.parse_file(ssl_fp) except IOError: logger.critical("Error writing/reading to file in make_vhost_ssl", exc_info=True) raise errors.PluginError("Unable to write/read in make_vhost_ssl") if sift: display_util.notify( f"Some rewrite rules copied from {vhost.filep} were disabled in the " f"vhost for your HTTPS site located at {ssl_fp} because they have " "the potential to create redirection loops." ) self.parser.aug.set("/augeas/files%s/mtime" % (self._escape(ssl_fp)), "0") self.parser.aug.set("/augeas/files%s/mtime" % (self._escape(vhost.filep)), "0") def _sift_rewrite_rules(self, contents): """ Helper function for _copy_create_ssl_vhost_skeleton to prepare the new HTTPS VirtualHost contents. Currently disabling the rewrites """ result = [] sift = False contents = iter(contents) comment = ("# Some rewrite rules in this file were " "disabled on your HTTPS site,\n" "# because they have the potential to create " "redirection loops.\n") for line in contents: A = line.lower().lstrip().startswith("rewritecond") B = line.lower().lstrip().startswith("rewriterule") if not (A or B): result.append(line) continue # A RewriteRule that doesn't need filtering if B and not self._sift_rewrite_rule(line): result.append(line) continue # A RewriteRule that does need filtering if B and self._sift_rewrite_rule(line): if not sift: result.append(comment) sift = True result.append("# " + line) continue # We save RewriteCond(s) and their corresponding # RewriteRule in 'chunk'. # We then decide whether we comment out the entire # chunk based on its RewriteRule. chunk = [] if A: chunk.append(line) line = next(contents) # RewriteCond(s) must be followed by one RewriteRule while not line.lower().lstrip().startswith("rewriterule"): chunk.append(line) line = next(contents) # Now, current line must start with a RewriteRule chunk.append(line) if self._sift_rewrite_rule(line): if not sift: result.append(comment) sift = True result.append('\n'.join('# ' + l for l in chunk)) else: result.append('\n'.join(chunk)) return result, sift def _get_vhost_block(self, vhost): """ Helper method to get VirtualHost contents from the original file. This is done with help of augeas span, which returns the span start and end positions :returns: `list` of VirtualHost block content lines without closing tag """ try: span_val = self.parser.aug.span(vhost.path) except ValueError: logger.critical("Error while reading the VirtualHost %s from " "file %s", vhost.name, vhost.filep, exc_info=True) raise errors.PluginError("Unable to read VirtualHost from file") span_filep = span_val[0] span_start = span_val[5] span_end = span_val[6] with open(span_filep, 'r') as fh: fh.seek(span_start) vh_contents = fh.read(span_end-span_start).split("\n") self._remove_closing_vhost_tag(vh_contents) return vh_contents def _remove_closing_vhost_tag(self, vh_contents): """Removes the closing VirtualHost tag if it exists. This method modifies vh_contents directly to remove the closing tag. If the closing vhost tag is found, everything on the line after it is also removed. Whether or not this tag is included in the result of span depends on the Augeas version. :param list vh_contents: VirtualHost block contents to check """ for offset, line in enumerate(reversed(vh_contents)): if line: line_index = line.lower().find("") if line_index != -1: content_index = len(vh_contents) - offset - 1 vh_contents[content_index] = line[:line_index] break def _update_ssl_vhosts_addrs(self, vh_path): ssl_addrs = set() ssl_addr_p = self.parser.aug.match(vh_path + "/arg") for addr in ssl_addr_p: old_addr = obj.Addr.fromstring( str(self.parser.get_arg(addr))) ssl_addr = old_addr.get_addr_obj("443") self.parser.aug.set(addr, str(ssl_addr)) ssl_addrs.add(ssl_addr) return ssl_addrs def _clean_vhost(self, vhost): # remove duplicated or conflicting ssl directives self._deduplicate_directives(vhost.path, ["SSLCertificateFile", "SSLCertificateKeyFile"]) # remove all problematic directives self._remove_directives(vhost.path, ["SSLCertificateChainFile"]) def _deduplicate_directives(self, vh_path, directives): for directive in directives: while len(self.parser.find_dir(directive, None, vh_path, False)) > 1: directive_path = self.parser.find_dir(directive, None, vh_path, False) self.parser.aug.remove(re.sub(r"/\w*$", "", directive_path[0])) def _remove_directives(self, vh_path, directives): for directive in directives: while self.parser.find_dir(directive, None, vh_path, False): directive_path = self.parser.find_dir(directive, None, vh_path, False) self.parser.aug.remove(re.sub(r"/\w*$", "", directive_path[0])) def _add_dummy_ssl_directives(self, vh_path): self.parser.add_dir(vh_path, "SSLCertificateFile", "insert_cert_file_path") self.parser.add_dir(vh_path, "SSLCertificateKeyFile", "insert_key_file_path") # Only include the TLS configuration if not already included existing_inc = self.parser.find_dir("Include", self.mod_ssl_conf, vh_path) if not existing_inc: self.parser.add_dir(vh_path, "Include", self.mod_ssl_conf) def _add_servername_alias(self, target_name, vhost): vh_path = vhost.path sname, saliases = self._get_vhost_names(vh_path) if target_name == sname or target_name in saliases: return if self._has_matching_wildcard(vh_path, target_name): return if not self.parser.find_dir("ServerName", None, start=vh_path, exclude=False): self.parser.add_dir(vh_path, "ServerName", target_name) else: self.parser.add_dir(vh_path, "ServerAlias", target_name) self._add_servernames(vhost) def _has_matching_wildcard(self, vh_path, target_name): """Is target_name already included in a wildcard in the vhost? :param str vh_path: Augeas path to the vhost :param str target_name: name to compare with wildcards :returns: True if there is a wildcard covering target_name in the vhost in vhost_path, otherwise, False :rtype: bool """ matches = self.parser.find_dir( "ServerAlias", start=vh_path, exclude=False) aliases = (self.parser.aug.get(match) for match in matches) return self.domain_in_names(aliases, target_name) def _add_name_vhost_if_necessary(self, vhost): """Add NameVirtualHost Directives if necessary for new vhost. NameVirtualHosts was a directive in Apache < 2.4 https://httpd.apache.org/docs/2.2/mod/core.html#namevirtualhost :param vhost: New virtual host that was recently created. :type vhost: :class:`~certbot_apache._internal.obj.VirtualHost` """ need_to_save = False # See if the exact address appears in any other vhost # Remember 1.1.1.1:* == 1.1.1.1 -> hence any() for addr in vhost.addrs: # In Apache 2.2, when a NameVirtualHost directive is not # set, "*" and "_default_" will conflict when sharing a port addrs = {addr,} if addr.get_addr() in ("*", "_default_"): addrs.update(obj.Addr((a, addr.get_port(),)) for a in ("*", "_default_")) for test_vh in self.vhosts: if (vhost.filep != test_vh.filep and any(test_addr in addrs for test_addr in test_vh.addrs) and not self.is_name_vhost(addr)): self.add_name_vhost(addr) logger.info("Enabling NameVirtualHosts on %s", addr) need_to_save = True break if need_to_save: self.save() def find_vhost_by_id(self, id_str): """ Searches through VirtualHosts and tries to match the id in a comment :param str id_str: Id string for matching :returns: The matched VirtualHost or None :rtype: :class:`~certbot_apache._internal.obj.VirtualHost` or None :raises .errors.PluginError: If no VirtualHost is found """ for vh in self.vhosts: if self._find_vhost_id(vh) == id_str: return vh msg = "No VirtualHost with ID {} was found.".format(id_str) logger.warning(msg) raise errors.PluginError(msg) def _find_vhost_id(self, vhost): """Tries to find the unique ID from the VirtualHost comments. This is used for keeping track of VirtualHost directive over time. :param vhost: Virtual host to add the id :type vhost: :class:`~certbot_apache._internal.obj.VirtualHost` :returns: The unique ID or None :rtype: str or None """ # Strip the {} off from the format string search_comment = constants.MANAGED_COMMENT_ID.format("") id_comment = self.parser.find_comments(search_comment, vhost.path) if id_comment: # Use the first value, multiple ones shouldn't exist comment = self.parser.get_arg(id_comment[0]) return comment.split(" ")[-1] return None def add_vhost_id(self, vhost): """Adds an unique ID to the VirtualHost as a comment for mapping back to it on later invocations, as the config file order might have changed. If ID already exists, returns that instead. :param vhost: Virtual host to add or find the id :type vhost: :class:`~certbot_apache._internal.obj.VirtualHost` :returns: The unique ID for vhost :rtype: str or None """ vh_id = self._find_vhost_id(vhost) if vh_id: return vh_id id_string = apache_util.unique_id() comment = constants.MANAGED_COMMENT_ID.format(id_string) self.parser.add_comment(vhost.path, comment) return id_string def _escape(self, fp): fp = fp.replace(",", "\\,") fp = fp.replace("[", "\\[") fp = fp.replace("]", "\\]") fp = fp.replace("|", "\\|") fp = fp.replace("=", "\\=") fp = fp.replace("(", "\\(") fp = fp.replace(")", "\\)") fp = fp.replace("!", "\\!") return fp ###################################################################### # Enhancements ###################################################################### def supported_enhancements(self): """Returns currently supported enhancements.""" return ["redirect", "ensure-http-header", "staple-ocsp"] def enhance(self, domain, enhancement, options=None): """Enhance configuration. :param str domain: domain to enhance :param str enhancement: enhancement type defined in :const:`~certbot.plugins.enhancements.ENHANCEMENTS` :param options: options for the enhancement See :const:`~certbot.plugins.enhancements.ENHANCEMENTS` documentation for appropriate parameter. :raises .errors.PluginError: If Enhancement is not supported, or if there is any other problem with the enhancement. """ try: func = self._enhance_func[enhancement] except KeyError: raise errors.PluginError( "Unsupported enhancement: {0}".format(enhancement)) matched_vhosts = self.choose_vhosts(domain, create_if_no_ssl=False) # We should be handling only SSL vhosts for enhancements vhosts = [vhost for vhost in matched_vhosts if vhost.ssl] if not vhosts: msg_tmpl = ("Certbot was not able to find SSL VirtualHost for a " "domain {0} for enabling enhancement \"{1}\". The requested " "enhancement was not configured.") msg_enhancement = enhancement if options: msg_enhancement += ": " + options msg = msg_tmpl.format(domain, msg_enhancement) logger.error(msg) raise errors.PluginError(msg) try: for vhost in vhosts: func(vhost, options) except errors.PluginError: logger.error("Failed %s for %s", enhancement, domain) raise def _autohsts_increase(self, vhost, id_str, nextstep): """Increase the AutoHSTS max-age value :param vhost: Virtual host object to modify :type vhost: :class:`~certbot_apache._internal.obj.VirtualHost` :param str id_str: The unique ID string of VirtualHost :param int nextstep: Next AutoHSTS max-age value index """ nextstep_value = constants.AUTOHSTS_STEPS[nextstep] self._autohsts_write(vhost, nextstep_value) self._autohsts[id_str] = {"laststep": nextstep, "timestamp": time.time()} def _autohsts_write(self, vhost, nextstep_value): """ Write the new HSTS max-age value to the VirtualHost file """ hsts_dirpath = None header_path = self.parser.find_dir("Header", None, vhost.path) if header_path: pat = '(?:[ "]|^)(strict-transport-security)(?:[ "]|$)' for match in header_path: if re.search(pat, self.parser.aug.get(match).lower()): hsts_dirpath = match if not hsts_dirpath: err_msg = ("Certbot was unable to find the existing HSTS header " "from the VirtualHost at path {0}.").format(vhost.filep) raise errors.PluginError(err_msg) # Prepare the HSTS header value hsts_maxage = "\"max-age={0}\"".format(nextstep_value) # Update the header # Our match statement was for string strict-transport-security, but # we need to update the value instead. The next index is for the value hsts_dirpath = hsts_dirpath.replace("arg[3]", "arg[4]") self.parser.aug.set(hsts_dirpath, hsts_maxage) note_msg = ("Increasing HSTS max-age value to {0} for VirtualHost " "in {1}\n".format(nextstep_value, vhost.filep)) logger.debug(note_msg) self.save_notes += note_msg self.save(note_msg) def _autohsts_fetch_state(self): """ Populates the AutoHSTS state from the pluginstorage """ try: self._autohsts = self.storage.fetch("autohsts") except KeyError: self._autohsts = {} def _autohsts_save_state(self): """ Saves the state of AutoHSTS object to pluginstorage """ self.storage.put("autohsts", self._autohsts) self.storage.save() def _autohsts_vhost_in_lineage(self, vhost, lineage): """ Searches AutoHSTS managed VirtualHosts that belong to the lineage. Matches the private key path. """ return bool( self.parser.find_dir("SSLCertificateKeyFile", lineage.key_path, vhost.path)) def _enable_ocsp_stapling(self, ssl_vhost, unused_options): """Enables OCSP Stapling In OCSP, each client (e.g. browser) would have to query the OCSP Responder to validate that the site certificate was not revoked. Enabling OCSP Stapling, would allow the web-server to query the OCSP Responder, and staple its response to the offered certificate during TLS. i.e. clients would not have to query the OCSP responder. OCSP Stapling enablement on Apache implicitly depends on SSLCertificateChainFile being set by other code. .. note:: This function saves the configuration :param ssl_vhost: Destination of traffic, an ssl enabled vhost :type ssl_vhost: :class:`~certbot_apache._internal.obj.VirtualHost` :param unused_options: Not currently used :type unused_options: Not Available :returns: Success, general_vhost (HTTP vhost) :rtype: (bool, :class:`~certbot_apache._internal.obj.VirtualHost`) """ min_apache_ver = (2, 3, 3) if self.get_version() < min_apache_ver: raise errors.PluginError( "Unable to set OCSP directives.\n" "Apache version is below 2.3.3.") if "socache_shmcb_module" not in self.parser.modules: self.enable_mod("socache_shmcb") # Check if there's an existing SSLUseStapling directive on. use_stapling_aug_path = self.parser.find_dir("SSLUseStapling", "on", start=ssl_vhost.path) if not use_stapling_aug_path: self.parser.add_dir(ssl_vhost.path, "SSLUseStapling", "on") ssl_vhost_aug_path = self._escape(parser.get_aug_path(ssl_vhost.filep)) # Check if there's an existing SSLStaplingCache directive. stapling_cache_aug_path = self.parser.find_dir('SSLStaplingCache', None, ssl_vhost_aug_path) # We'll simply delete the directive, so that we'll have a # consistent OCSP cache path. if stapling_cache_aug_path: self.parser.aug.remove( re.sub(r"/\w*$", "", stapling_cache_aug_path[0])) self.parser.add_dir_to_ifmodssl(ssl_vhost_aug_path, "SSLStaplingCache", ["shmcb:/var/run/apache2/stapling_cache(128000)"]) msg = "OCSP Stapling was enabled on SSL Vhost: %s.\n"%( ssl_vhost.filep) self.save_notes += msg self.save() logger.info(msg) def _set_http_header(self, ssl_vhost, header_substring): """Enables header that is identified by header_substring on ssl_vhost. If the header identified by header_substring is not already set, a new Header directive is placed in ssl_vhost's configuration with arguments from: constants.HTTP_HEADER[header_substring] .. note:: This function saves the configuration :param ssl_vhost: Destination of traffic, an ssl enabled vhost :type ssl_vhost: :class:`~certbot_apache._internal.obj.VirtualHost` :param header_substring: string that uniquely identifies a header. e.g: Strict-Transport-Security, Upgrade-Insecure-Requests. :type str :returns: Success, general_vhost (HTTP vhost) :rtype: (bool, :class:`~certbot_apache._internal.obj.VirtualHost`) :raises .errors.PluginError: If no viable HTTP host can be created or set with header header_substring. """ if "headers_module" not in self.parser.modules: self.enable_mod("headers") # Check if selected header is already set self._verify_no_matching_http_header(ssl_vhost, header_substring) # Add directives to server self.parser.add_dir(ssl_vhost.path, "Header", constants.HEADER_ARGS[header_substring]) self.save_notes += ("Adding %s header to ssl vhost in %s\n" % (header_substring, ssl_vhost.filep)) self.save() logger.info("Adding %s header to ssl vhost in %s", header_substring, ssl_vhost.filep) def _verify_no_matching_http_header(self, ssl_vhost, header_substring): """Checks to see if there is an existing Header directive that contains the string header_substring. :param ssl_vhost: vhost to check :type vhost: :class:`~certbot_apache._internal.obj.VirtualHost` :param header_substring: string that uniquely identifies a header. e.g: Strict-Transport-Security, Upgrade-Insecure-Requests. :type str :returns: boolean :rtype: (bool) :raises errors.PluginEnhancementAlreadyPresent When header header_substring exists """ header_path = self.parser.find_dir("Header", None, start=ssl_vhost.path) if header_path: # "Existing Header directive for virtualhost" pat = '(?:[ "]|^)(%s)(?:[ "]|$)' % (header_substring.lower()) for match in header_path: if re.search(pat, self.parser.aug.get(match).lower()): raise errors.PluginEnhancementAlreadyPresent( "Existing %s header" % (header_substring)) def _enable_redirect(self, ssl_vhost, unused_options): """Redirect all equivalent HTTP traffic to ssl_vhost. .. todo:: This enhancement should be rewritten and will unfortunately require lots of debugging by hand. Adds Redirect directive to the port 80 equivalent of ssl_vhost First the function attempts to find the vhost with equivalent ip addresses that serves on non-ssl ports The function then adds the directive .. note:: This function saves the configuration :param ssl_vhost: Destination of traffic, an ssl enabled vhost :type ssl_vhost: :class:`~certbot_apache._internal.obj.VirtualHost` :param unused_options: Not currently used :type unused_options: Not Available :raises .errors.PluginError: If no viable HTTP host can be created or used for the redirect. """ if "rewrite_module" not in self.parser.modules: self.enable_mod("rewrite") general_vh = self._get_http_vhost(ssl_vhost) if general_vh is None: # Add virtual_server with redirect logger.debug("Did not find http version of ssl virtual host " "attempting to create") redirect_addrs = self._get_proposed_addrs(ssl_vhost) for vhost in self.vhosts: if vhost.enabled and vhost.conflicts(redirect_addrs): raise errors.PluginError( "Unable to find corresponding HTTP vhost; " "Unable to create one as intended addresses conflict; " "Current configuration does not support automated " "redirection") self._create_redirect_vhost(ssl_vhost) else: if general_vh in self._enhanced_vhosts["redirect"]: logger.debug("Already enabled redirect for this vhost") return # Check if Certbot redirection already exists self._verify_no_certbot_redirect(general_vh) # Note: if code flow gets here it means we didn't find the exact # certbot RewriteRule config for redirection. Finding # another RewriteRule is likely to be fine in most or all cases, # but redirect loops are possible in very obscure cases; see #1620 # for reasoning. if self._is_rewrite_exists(general_vh): logger.warning("Added an HTTP->HTTPS rewrite in addition to " "other RewriteRules; you may wish to check for " "overall consistency.") # Add directives to server # Note: These are not immediately searchable in sites-enabled # even with save() and load() if not self._is_rewrite_engine_on(general_vh): self.parser.add_dir(general_vh.path, "RewriteEngine", "on") names = ssl_vhost.get_names() for idx, name in enumerate(names): args = ["%{SERVER_NAME}", "={0}".format(name), "[OR]"] if idx == len(names) - 1: args.pop() self.parser.add_dir(general_vh.path, "RewriteCond", args) self._set_https_redirection_rewrite_rule(general_vh) self.save_notes += ("Redirecting host in %s to ssl vhost in %s\n" % (general_vh.filep, ssl_vhost.filep)) self.save() self._enhanced_vhosts["redirect"].add(general_vh) logger.info("Redirecting vhost in %s to ssl vhost in %s", general_vh.filep, ssl_vhost.filep) def _set_https_redirection_rewrite_rule(self, vhost): if self.get_version() >= (2, 3, 9): self.parser.add_dir(vhost.path, "RewriteRule", constants.REWRITE_HTTPS_ARGS_WITH_END) else: self.parser.add_dir(vhost.path, "RewriteRule", constants.REWRITE_HTTPS_ARGS) def _verify_no_certbot_redirect(self, vhost): """Checks to see if a redirect was already installed by certbot. Checks to see if virtualhost already contains a rewrite rule that is identical to Certbot's redirection rewrite rule. For graceful transition to new rewrite rules for HTTPS redireciton we delete certbot's old rewrite rules and set the new one instead. :param vhost: vhost to check :type vhost: :class:`~certbot_apache._internal.obj.VirtualHost` :raises errors.PluginEnhancementAlreadyPresent: When the exact certbot redirection WriteRule exists in virtual host. """ rewrite_path = self.parser.find_dir( "RewriteRule", None, start=vhost.path) # There can be other RewriteRule directive lines in vhost config. # rewrite_args_dict keys are directive ids and the corresponding value # for each is a list of arguments to that directive. rewrite_args_dict: DefaultDict[str, List[str]] = defaultdict(list) pat = r'(.*directive\[\d+\]).*' for match in rewrite_path: m = re.match(pat, match) if m: dir_path = m.group(1) rewrite_args_dict[dir_path].append(match) if rewrite_args_dict: redirect_args = [constants.REWRITE_HTTPS_ARGS, constants.REWRITE_HTTPS_ARGS_WITH_END] for dir_path, args_paths in rewrite_args_dict.items(): arg_vals = [self.parser.aug.get(x) for x in args_paths] # Search for past redirection rule, delete it, set the new one if arg_vals in constants.OLD_REWRITE_HTTPS_ARGS: self.parser.aug.remove(dir_path) self._set_https_redirection_rewrite_rule(vhost) self.save() raise errors.PluginEnhancementAlreadyPresent( "Certbot has already enabled redirection") if arg_vals in redirect_args: raise errors.PluginEnhancementAlreadyPresent( "Certbot has already enabled redirection") def _is_rewrite_exists(self, vhost): """Checks if there exists a RewriteRule directive in vhost :param vhost: vhost to check :type vhost: :class:`~certbot_apache._internal.obj.VirtualHost` :returns: True if a RewriteRule directive exists. :rtype: bool """ rewrite_path = self.parser.find_dir( "RewriteRule", None, start=vhost.path) return bool(rewrite_path) def _is_rewrite_engine_on(self, vhost): """Checks if a RewriteEngine directive is on :param vhost: vhost to check :type vhost: :class:`~certbot_apache._internal.obj.VirtualHost` """ rewrite_engine_path_list = self.parser.find_dir("RewriteEngine", "on", start=vhost.path) if rewrite_engine_path_list: for re_path in rewrite_engine_path_list: # A RewriteEngine directive may also be included in per # directory .htaccess files. We only care about the VirtualHost. if 'virtualhost' in re_path.lower(): return self.parser.get_arg(re_path) return False def _create_redirect_vhost(self, ssl_vhost): """Creates an http_vhost specifically to redirect for the ssl_vhost. :param ssl_vhost: ssl vhost :type ssl_vhost: :class:`~certbot_apache._internal.obj.VirtualHost` :returns: tuple of the form (`success`, :class:`~certbot_apache._internal.obj.VirtualHost`) :rtype: tuple """ text = self._get_redirect_config_str(ssl_vhost) redirect_filepath = self._write_out_redirect(ssl_vhost, text) self.parser.aug.load() # Make a new vhost data structure and add it to the lists new_vhost = self._create_vhost(parser.get_aug_path(self._escape(redirect_filepath))) self.vhosts.append(new_vhost) self._enhanced_vhosts["redirect"].add(new_vhost) # Finally create documentation for the change self.save_notes += ("Created a port 80 vhost, %s, for redirection to " "ssl vhost %s\n" % (new_vhost.filep, ssl_vhost.filep)) def _get_redirect_config_str(self, ssl_vhost): # get servernames and serveraliases serveralias = "" servername = "" if ssl_vhost.name is not None: servername = "ServerName " + ssl_vhost.name if ssl_vhost.aliases: serveralias = "ServerAlias " + " ".join(ssl_vhost.aliases) rewrite_rule_args: List[str] = [] if self.get_version() >= (2, 3, 9): rewrite_rule_args = constants.REWRITE_HTTPS_ARGS_WITH_END else: rewrite_rule_args = constants.REWRITE_HTTPS_ARGS return ("\n" "%s \n" "%s \n" "ServerSignature Off\n" "\n" "RewriteEngine On\n" "RewriteRule %s\n" "\n" "ErrorLog %s/redirect.error.log\n" "LogLevel warn\n" "\n" % (" ".join(str(addr) for addr in self._get_proposed_addrs(ssl_vhost)), servername, serveralias, " ".join(rewrite_rule_args), self.options.logs_root)) def _write_out_redirect(self, ssl_vhost, text): # This is the default name redirect_filename = "le-redirect.conf" # See if a more appropriate name can be applied if ssl_vhost.name is not None: # make sure servername doesn't exceed filename length restriction if len(ssl_vhost.name) < (255 - (len(redirect_filename) + 1)): redirect_filename = "le-redirect-%s.conf" % ssl_vhost.name redirect_filepath = os.path.join(self.options.vhost_root, redirect_filename) # Register the new file that will be created # Note: always register the creation before writing to ensure file will # be removed in case of unexpected program exit self.reverter.register_file_creation(False, redirect_filepath) # Write out file with open(redirect_filepath, "w") as redirect_file: redirect_file.write(text) # Add new include to configuration if it doesn't exist yet if not self.parser.parsed_in_current(redirect_filepath): self.parser.parse_file(redirect_filepath) logger.info("Created redirect file: %s", redirect_filename) return redirect_filepath def _get_http_vhost(self, ssl_vhost): """Find appropriate HTTP vhost for ssl_vhost.""" # First candidate vhosts filter if ssl_vhost.ancestor: return ssl_vhost.ancestor candidate_http_vhs = [ vhost for vhost in self.vhosts if not vhost.ssl ] # Second filter - check addresses for http_vh in candidate_http_vhs: if http_vh.same_server(ssl_vhost): return http_vh # Third filter - if none with same names, return generic for http_vh in candidate_http_vhs: if http_vh.same_server(ssl_vhost, generic=True): return http_vh return None def _get_proposed_addrs(self, vhost, port="80"): """Return all addrs of vhost with the port replaced with the specified. :param obj.VirtualHost ssl_vhost: Original Vhost :param str port: Desired port for new addresses :returns: `set` of :class:`~obj.Addr` """ redirects = set() for addr in vhost.addrs: redirects.add(addr.get_addr_obj(port)) return redirects def enable_site(self, vhost): """Enables an available site, Apache reload required. .. note:: Does not make sure that the site correctly works or that all modules are enabled appropriately. .. note:: The distribution specific override replaces functionality of this method where available. :param vhost: vhost to enable :type vhost: :class:`~certbot_apache._internal.obj.VirtualHost` :raises .errors.NotSupportedError: If filesystem layout is not supported. """ if vhost.enabled: return if not self.parser.parsed_in_original(vhost.filep): # Add direct include to root conf logger.info("Enabling site %s by adding Include to root configuration", vhost.filep) self.save_notes += "Enabled site %s\n" % vhost.filep self.parser.add_include(self.parser.loc["default"], vhost.filep) vhost.enabled = True return def enable_mod(self, mod_name, temp=False): # pylint: disable=unused-argument """Enables module in Apache. Both enables and reloads Apache so module is active. :param str mod_name: Name of the module to enable. (e.g. 'ssl') :param bool temp: Whether or not this is a temporary action. .. note:: The distribution specific override replaces functionality of this method where available. :raises .errors.MisconfigurationError: We cannot enable modules in generic fashion. """ mod_message = ("Apache needs to have module \"{0}\" active for the " + "requested installation options. Unfortunately Certbot is unable " + "to install or enable it for you. Please install the module, and " + "run Certbot again.") raise errors.MisconfigurationError(mod_message.format(mod_name)) def restart(self): """Runs a config test and reloads the Apache server. :raises .errors.MisconfigurationError: If either the config test or reload fails. """ self.config_test() self._reload() def _reload(self): """Reloads the Apache server. :raises .errors.MisconfigurationError: If reload fails """ try: util.run_script(self.options.restart_cmd) except errors.SubprocessError as err: logger.warning("Unable to restart apache using %s", self.options.restart_cmd) alt_restart = self.options.restart_cmd_alt if alt_restart: logger.debug("Trying alternative restart command: %s", alt_restart) # There is an alternative restart command available # This usually is "restart" verb while original is "graceful" try: util.run_script(self.options.restart_cmd_alt) return except errors.SubprocessError as secerr: error = str(secerr) else: error = str(err) raise errors.MisconfigurationError(error) def config_test(self): """Check the configuration of Apache for errors. :raises .errors.MisconfigurationError: If config_test fails """ try: util.run_script(self.options.conftest_cmd) except errors.SubprocessError as err: raise errors.MisconfigurationError(str(err)) def get_version(self): """Return version of Apache Server. Version is returned as tuple. (ie. 2.4.7 = (2, 4, 7)) :returns: version :rtype: tuple :raises .PluginError: if unable to find Apache version """ try: stdout, _ = util.run_script(self.options.version_cmd) except errors.SubprocessError: raise errors.PluginError( "Unable to run %s -v" % self.options.version_cmd) regex = re.compile(r"Apache/([0-9\.]*)", re.IGNORECASE) matches = regex.findall(stdout) if len(matches) != 1: raise errors.PluginError("Unable to find Apache version") return tuple(int(i) for i in matches[0].split(".")) def more_info(self): """Human-readable string to help understand the module""" return ( "Configures Apache to authenticate and install HTTPS.{0}" "Server root: {root}{0}" "Version: {version}".format( os.linesep, root=self.parser.loc["root"], version=".".join(str(i) for i in self.version)) ) def auth_hint(self, failed_achalls): # pragma: no cover return ("The Certificate Authority failed to verify the temporary Apache configuration " "changes made by Certbot. Ensure that the listed domains point to this Apache " "server and that it is accessible from the internet.") ########################################################################### # Challenges Section ########################################################################### def get_chall_pref(self, unused_domain): """Return list of challenge preferences.""" return [challenges.HTTP01] def perform(self, achalls): """Perform the configuration related challenge. This function currently assumes all challenges will be fulfilled. If this turns out not to be the case in the future. Cleanup and outstanding challenges will have to be designed better. """ self._chall_out.update(achalls) responses = [None] * len(achalls) http_doer = http_01.ApacheHttp01(self) for i, achall in enumerate(achalls): # Currently also have chall_doer hold associated index of the # challenge. This helps to put all of the responses back together # when they are all complete. http_doer.add_chall(achall, i) http_response = http_doer.perform() if http_response: # Must reload in order to activate the challenges. # Handled here because we may be able to load up other challenge # types self.restart() # TODO: Remove this dirty hack. We need to determine a reliable way # of identifying when the new configuration is being used. time.sleep(3) self._update_responses(responses, http_response, http_doer) return responses def _update_responses(self, responses, chall_response, chall_doer): # Go through all of the challenges and assign them to the proper # place in the responses return value. All responses must be in the # same order as the original challenges. for i, resp in enumerate(chall_response): responses[chall_doer.indices[i]] = resp def cleanup(self, achalls): """Revert all challenges.""" self._chall_out.difference_update(achalls) # If all of the challenges have been finished, clean up everything if not self._chall_out: self.revert_challenge_config() self.restart() self.parser.reset_modules() def install_ssl_options_conf(self, options_ssl, options_ssl_digest, warn_on_no_mod_ssl=True): """Copy Certbot's SSL options file into the system's config dir if required. :param bool warn_on_no_mod_ssl: True if we should warn if mod_ssl is not found. """ # XXX if we ever try to enforce a local privilege boundary (eg, running # certbot for unprivileged users via setuid), this function will need # to be modified. apache_config_path = self.pick_apache_config(warn_on_no_mod_ssl) return common.install_version_controlled_file( options_ssl, options_ssl_digest, apache_config_path, constants.ALL_SSL_OPTIONS_HASHES) def enable_autohsts(self, _unused_lineage, domains): """ Enable the AutoHSTS enhancement for defined domains :param _unused_lineage: Certificate lineage object, unused :type _unused_lineage: certbot._internal.storage.RenewableCert :param domains: List of domains in certificate to enhance :type domains: `list` of `str` """ self._autohsts_fetch_state() _enhanced_vhosts = [] for d in domains: matched_vhosts = self.choose_vhosts(d, create_if_no_ssl=False) # We should be handling only SSL vhosts for AutoHSTS vhosts = [vhost for vhost in matched_vhosts if vhost.ssl] if not vhosts: msg_tmpl = ("Certbot was not able to find SSL VirtualHost for a " "domain {0} for enabling AutoHSTS enhancement.") msg = msg_tmpl.format(d) logger.error(msg) raise errors.PluginError(msg) for vh in vhosts: try: self._enable_autohsts_domain(vh) _enhanced_vhosts.append(vh) except errors.PluginEnhancementAlreadyPresent: if vh in _enhanced_vhosts: continue msg = ("VirtualHost for domain {0} in file {1} has a " + "String-Transport-Security header present, exiting.") raise errors.PluginEnhancementAlreadyPresent( msg.format(d, vh.filep)) if _enhanced_vhosts: note_msg = "Enabling AutoHSTS" self.save(note_msg) logger.info(note_msg) self.restart() # Save the current state to pluginstorage self._autohsts_save_state() def _enable_autohsts_domain(self, ssl_vhost): """Do the initial AutoHSTS deployment to a vhost :param ssl_vhost: The VirtualHost object to deploy the AutoHSTS :type ssl_vhost: :class:`~certbot_apache._internal.obj.VirtualHost` or None :raises errors.PluginEnhancementAlreadyPresent: When already enhanced """ # This raises the exception self._verify_no_matching_http_header(ssl_vhost, "Strict-Transport-Security") if "headers_module" not in self.parser.modules: self.enable_mod("headers") # Prepare the HSTS header value hsts_header = constants.HEADER_ARGS["Strict-Transport-Security"][:-1] initial_maxage = constants.AUTOHSTS_STEPS[0] hsts_header.append("\"max-age={0}\"".format(initial_maxage)) # Add ID to the VirtualHost for mapping back to it later uniq_id = self.add_vhost_id(ssl_vhost) self.save_notes += "Adding unique ID {0} to VirtualHost in {1}\n".format( uniq_id, ssl_vhost.filep) # Add the actual HSTS header self.parser.add_dir(ssl_vhost.path, "Header", hsts_header) note_msg = ("Adding gradually increasing HSTS header with initial value " "of {0} to VirtualHost in {1}\n".format( initial_maxage, ssl_vhost.filep)) self.save_notes += note_msg # Save the current state to pluginstorage self._autohsts[uniq_id] = {"laststep": 0, "timestamp": time.time()} def update_autohsts(self, _unused_domain): """ Increase the AutoHSTS values of VirtualHosts that the user has enabled this enhancement for. :param _unused_domain: Not currently used :type _unused_domain: Not Available """ self._autohsts_fetch_state() if not self._autohsts: # No AutoHSTS enabled for any domain return curtime = time.time() save_and_restart = False for id_str, config in list(self._autohsts.items()): if config["timestamp"] + constants.AUTOHSTS_FREQ > curtime: # Skip if last increase was < AUTOHSTS_FREQ ago continue nextstep = config["laststep"] + 1 if nextstep < len(constants.AUTOHSTS_STEPS): # If installer hasn't been prepared yet, do it now if not self._prepared: self.prepare() # Have not reached the max value yet try: vhost = self.find_vhost_by_id(id_str) except errors.PluginError: msg = ("Could not find VirtualHost with ID {0}, disabling " "AutoHSTS for this VirtualHost").format(id_str) logger.error(msg) # Remove the orphaned AutoHSTS entry from pluginstorage self._autohsts.pop(id_str) continue self._autohsts_increase(vhost, id_str, nextstep) msg = ("Increasing HSTS max-age value for VirtualHost with id " "{0}").format(id_str) self.save_notes += msg save_and_restart = True if save_and_restart: self.save("Increased HSTS max-age values") self.restart() self._autohsts_save_state() def deploy_autohsts(self, lineage): """ Checks if autohsts vhost has reached maximum auto-increased value and changes the HSTS max-age to a high value. :param lineage: Certificate lineage object :type lineage: certbot._internal.storage.RenewableCert """ self._autohsts_fetch_state() if not self._autohsts: # No autohsts enabled for any vhost return vhosts = [] affected_ids = [] # Copy, as we are removing from the dict inside the loop for id_str, config in list(self._autohsts.items()): if config["laststep"]+1 >= len(constants.AUTOHSTS_STEPS): # max value reached, try to make permanent try: vhost = self.find_vhost_by_id(id_str) except errors.PluginError: msg = ("VirtualHost with id {} was not found, unable to " "make HSTS max-age permanent.").format(id_str) logger.error(msg) self._autohsts.pop(id_str) continue if self._autohsts_vhost_in_lineage(vhost, lineage): vhosts.append(vhost) affected_ids.append(id_str) save_and_restart = False for vhost in vhosts: self._autohsts_write(vhost, constants.AUTOHSTS_PERMANENT) msg = ("Strict-Transport-Security max-age value for " "VirtualHost in {0} was made permanent.").format(vhost.filep) logger.debug(msg) self.save_notes += msg+"\n" save_and_restart = True if save_and_restart: self.save("Made HSTS max-age permanent") self.restart() for id_str in affected_ids: self._autohsts.pop(id_str) # Update AutoHSTS storage (We potentially removed vhosts from managed) self._autohsts_save_state() AutoHSTSEnhancement.register(ApacheConfigurator) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/certbot_apache/_internal/constants.py0000644000076500000240000000630700000000000022437 0ustar00bmwstaff"""Apache plugin constants.""" import pkg_resources from certbot.compat import os MOD_SSL_CONF_DEST = "options-ssl-apache.conf" """Name of the mod_ssl config file as saved in `certbot.configuration.NamespaceConfig.config_dir`.""" UPDATED_MOD_SSL_CONF_DIGEST = ".updated-options-ssl-apache-conf-digest.txt" """Name of the hash of the updated or informed mod_ssl_conf as saved in `certbot.configuration.NamespaceConfig.config_dir`.""" # NEVER REMOVE A SINGLE HASH FROM THIS LIST UNLESS YOU KNOW EXACTLY WHAT YOU ARE DOING! ALL_SSL_OPTIONS_HASHES = [ '2086bca02db48daf93468332543c60ac6acdb6f0b58c7bfdf578a5d47092f82a', '4844d36c9a0f587172d9fa10f4f1c9518e3bcfa1947379f155e16a70a728c21a', '5a922826719981c0a234b1fbcd495f3213e49d2519e845ea0748ba513044b65b', '4066b90268c03c9ba0201068eaa39abbc02acf9558bb45a788b630eb85dadf27', 'f175e2e7c673bd88d0aff8220735f385f916142c44aa83b09f1df88dd4767a88', 'cfdd7c18d2025836ea3307399f509cfb1ebf2612c87dd600a65da2a8e2f2797b', '80720bd171ccdc2e6b917ded340defae66919e4624962396b992b7218a561791', 'c0c022ea6b8a51ecc8f1003d0a04af6c3f2bc1c3ce506b3c2dfc1f11ef931082', '717b0a89f5e4c39b09a42813ac6e747cfbdeb93439499e73f4f70a1fe1473f20', '0fcdc81280cd179a07ec4d29d3595068b9326b455c488de4b09f585d5dafc137', '86cc09ad5415cd6d5f09a947fe2501a9344328b1e8a8b458107ea903e80baa6c', '06675349e457eae856120cdebb564efe546f0b87399f2264baeb41e442c724c7', '5cc003edd93fb9cd03d40c7686495f8f058f485f75b5e764b789245a386e6daf', '007cd497a56a3bb8b6a2c1aeb4997789e7e38992f74e44cc5d13a625a738ac73', '34783b9e2210f5c4a23bced2dfd7ec289834716673354ed7c7abf69fe30192a3', ] """SHA256 hashes of the contents of previous versions of all versions of MOD_SSL_CONF_SRC""" AUGEAS_LENS_DIR = pkg_resources.resource_filename( "certbot_apache", os.path.join("_internal", "augeas_lens")) """Path to the Augeas lens directory""" REWRITE_HTTPS_ARGS = [ "^", "https://%{SERVER_NAME}%{REQUEST_URI}", "[L,NE,R=permanent]"] """Apache version<2.3.9 rewrite rule arguments used for redirections to https vhost""" REWRITE_HTTPS_ARGS_WITH_END = [ "^", "https://%{SERVER_NAME}%{REQUEST_URI}", "[END,NE,R=permanent]"] """Apache version >= 2.3.9 rewrite rule arguments used for redirections to https vhost""" OLD_REWRITE_HTTPS_ARGS = [ ["^", "https://%{SERVER_NAME}%{REQUEST_URI}", "[L,QSA,R=permanent]"], ["^", "https://%{SERVER_NAME}%{REQUEST_URI}", "[END,QSA,R=permanent]"]] HSTS_ARGS = ["always", "set", "Strict-Transport-Security", "\"max-age=31536000\""] """Apache header arguments for HSTS""" UIR_ARGS = ["always", "set", "Content-Security-Policy", "upgrade-insecure-requests"] HEADER_ARGS = {"Strict-Transport-Security": HSTS_ARGS, "Upgrade-Insecure-Requests": UIR_ARGS} AUTOHSTS_STEPS = [60, 300, 900, 3600, 21600, 43200, 86400] """AutoHSTS increase steps: 1min, 5min, 15min, 1h, 6h, 12h, 24h""" AUTOHSTS_PERMANENT = 31536000 """Value for the last max-age of HSTS""" AUTOHSTS_FREQ = 172800 """Minimum time since last increase to perform a new one: 48h""" MANAGED_COMMENT = "DO NOT REMOVE - Managed by Certbot" MANAGED_COMMENT_ID = MANAGED_COMMENT+", VirtualHost id: {0}" """Managed by Certbot comments and the VirtualHost identification template""" ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/certbot_apache/_internal/display_ops.py0000644000076500000240000001005200000000000022741 0ustar00bmwstaff"""Contains UI methods for Apache operations.""" import logging from certbot import errors from certbot.compat import os from certbot.display import util as display_util logger = logging.getLogger(__name__) def select_vhost_multiple(vhosts): """Select multiple Vhosts to install the certificate for :param vhosts: Available Apache VirtualHosts :type vhosts: :class:`list` of type `~obj.Vhost` :returns: List of VirtualHosts :rtype: :class:`list`of type `~obj.Vhost` """ if not vhosts: return [] tags_list = [vhost.display_repr()+"\n" for vhost in vhosts] # Remove the extra newline from the last entry if tags_list: tags_list[-1] = tags_list[-1][:-1] code, names = display_util.checklist( "Which VirtualHosts would you like to install the wildcard certificate for?", tags=tags_list, force_interactive=True) if code == display_util.OK: return_vhosts = _reversemap_vhosts(names, vhosts) return return_vhosts return [] def _reversemap_vhosts(names, vhosts): """Helper function for select_vhost_multiple for mapping string representations back to actual vhost objects""" return_vhosts = [] for selection in names: for vhost in vhosts: if vhost.display_repr().strip() == selection.strip(): return_vhosts.append(vhost) return return_vhosts def select_vhost(domain, vhosts): """Select an appropriate Apache Vhost. :param vhosts: Available Apache VirtualHosts :type vhosts: :class:`list` of type `~obj.Vhost` :returns: VirtualHost or `None` :rtype: `~obj.Vhost` or `None` """ if not vhosts: return None code, tag = _vhost_menu(domain, vhosts) if code == display_util.OK: return vhosts[tag] return None def _vhost_menu(domain, vhosts): """Select an appropriate Apache Vhost. :param vhosts: Available Apache Virtual Hosts :type vhosts: :class:`list` of type `~obj.Vhost` :returns: Display tuple - ('code', tag') :rtype: `tuple` """ # Free characters in the line of display text (9 is for ' | ' formatting) free_chars = display_util.WIDTH - len("HTTPS") - len("Enabled") - 9 if free_chars < 2: logger.debug("Display size is too small for " "certbot_apache._internal.display_ops._vhost_menu()") # This runs the edge off the screen, but it doesn't cause an "error" filename_size = 1 disp_name_size = 1 else: # Filename is a bit more important and probably longer with 000-* filename_size = int(free_chars * .6) disp_name_size = free_chars - filename_size choices = [] for vhost in vhosts: if len(vhost.get_names()) == 1: disp_name = next(iter(vhost.get_names())) elif not vhost.get_names(): disp_name = "" else: disp_name = "Multiple Names" choices.append( "{fn:{fn_size}s} | {name:{name_size}s} | {https:5s} | " "{active:7s}".format( fn=os.path.basename(vhost.filep)[:filename_size], name=disp_name[:disp_name_size], https="HTTPS" if vhost.ssl else "", active="Enabled" if vhost.enabled else "", fn_size=filename_size, name_size=disp_name_size) ) try: code, tag = display_util.menu( "We were unable to find a vhost with a ServerName " "or Address of {0}.{1}Which virtual host would you " "like to choose?".format(domain, os.linesep), choices, force_interactive=True) except errors.MissingCommandlineFlag: msg = ( "Encountered vhost ambiguity when trying to find a vhost for " "{0} but was unable to ask for user " "guidance in non-interactive mode. Certbot may need " "vhosts to be explicitly labelled with ServerName or " "ServerAlias directives.".format(domain)) logger.error(msg) raise errors.MissingCommandlineFlag(msg) return code, tag ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/certbot_apache/_internal/dualparser.py0000644000076500000240000003116400000000000022564 0ustar00bmwstaff""" Dual ParserNode implementation """ from certbot_apache._internal import apacheparser from certbot_apache._internal import assertions from certbot_apache._internal import augeasparser class DualNodeBase: """ Dual parser interface for in development testing. This is used as the base class for dual parser interface classes. This class handles runtime attribute value assertions.""" def save(self, msg): # pragma: no cover """ Call save for both parsers """ self.primary.save(msg) self.secondary.save(msg) def __getattr__(self, aname): """ Attribute value assertion """ firstval = getattr(self.primary, aname) secondval = getattr(self.secondary, aname) exclusions = [ # Metadata will inherently be different, as ApacheParserNode does # not have Augeas paths and so on. aname == "metadata", callable(firstval) ] if not any(exclusions): assertions.assertEqualSimple(firstval, secondval) return firstval def find_ancestors(self, name): """ Traverses the ancestor tree and returns ancestors matching name """ return self._find_helper(DualBlockNode, "find_ancestors", name) def _find_helper(self, nodeclass, findfunc, search, **kwargs): """A helper for find_* functions. The function specific attributes should be passed as keyword arguments. :param interfaces.ParserNode nodeclass: The node class for results. :param str findfunc: Name of the find function to call :param str search: The search term """ primary_res = getattr(self.primary, findfunc)(search, **kwargs) secondary_res = getattr(self.secondary, findfunc)(search, **kwargs) # The order of search results for Augeas implementation cannot be # assured. pass_primary = assertions.isPassNodeList(primary_res) pass_secondary = assertions.isPassNodeList(secondary_res) new_nodes = [] if pass_primary and pass_secondary: # Both unimplemented new_nodes.append(nodeclass(primary=primary_res[0], secondary=secondary_res[0])) # pragma: no cover elif pass_primary: for c in secondary_res: new_nodes.append(nodeclass(primary=primary_res[0], secondary=c)) elif pass_secondary: for c in primary_res: new_nodes.append(nodeclass(primary=c, secondary=secondary_res[0])) else: assert len(primary_res) == len(secondary_res) matches = self._create_matching_list(primary_res, secondary_res) for p, s in matches: new_nodes.append(nodeclass(primary=p, secondary=s)) return new_nodes class DualCommentNode(DualNodeBase): """ Dual parser implementation of CommentNode interface """ def __init__(self, **kwargs): """ This initialization implementation allows ordinary initialization of CommentNode objects as well as creating a DualCommentNode object using precreated or fetched CommentNode objects if provided as optional arguments primary and secondary. Parameters other than the following are from interfaces.CommentNode: :param CommentNode primary: Primary pre-created CommentNode, mainly used when creating new DualParser nodes using add_* methods. :param CommentNode secondary: Secondary pre-created CommentNode """ kwargs.setdefault("primary", None) kwargs.setdefault("secondary", None) primary = kwargs.pop("primary") secondary = kwargs.pop("secondary") if primary or secondary: assert primary and secondary self.primary = primary self.secondary = secondary else: self.primary = augeasparser.AugeasCommentNode(**kwargs) self.secondary = apacheparser.ApacheCommentNode(**kwargs) assertions.assertEqual(self.primary, self.secondary) class DualDirectiveNode(DualNodeBase): """ Dual parser implementation of DirectiveNode interface """ def __init__(self, **kwargs): """ This initialization implementation allows ordinary initialization of DirectiveNode objects as well as creating a DualDirectiveNode object using precreated or fetched DirectiveNode objects if provided as optional arguments primary and secondary. Parameters other than the following are from interfaces.DirectiveNode: :param DirectiveNode primary: Primary pre-created DirectiveNode, mainly used when creating new DualParser nodes using add_* methods. :param DirectiveNode secondary: Secondary pre-created DirectiveNode """ kwargs.setdefault("primary", None) kwargs.setdefault("secondary", None) primary = kwargs.pop("primary") secondary = kwargs.pop("secondary") if primary or secondary: assert primary and secondary self.primary = primary self.secondary = secondary else: self.primary = augeasparser.AugeasDirectiveNode(**kwargs) self.secondary = apacheparser.ApacheDirectiveNode(**kwargs) assertions.assertEqual(self.primary, self.secondary) def set_parameters(self, parameters): """ Sets parameters and asserts that both implementation successfully set the parameter sequence """ self.primary.set_parameters(parameters) self.secondary.set_parameters(parameters) assertions.assertEqual(self.primary, self.secondary) class DualBlockNode(DualNodeBase): """ Dual parser implementation of BlockNode interface """ def __init__(self, **kwargs): """ This initialization implementation allows ordinary initialization of BlockNode objects as well as creating a DualBlockNode object using precreated or fetched BlockNode objects if provided as optional arguments primary and secondary. Parameters other than the following are from interfaces.BlockNode: :param BlockNode primary: Primary pre-created BlockNode, mainly used when creating new DualParser nodes using add_* methods. :param BlockNode secondary: Secondary pre-created BlockNode """ kwargs.setdefault("primary", None) kwargs.setdefault("secondary", None) primary = kwargs.pop("primary") secondary = kwargs.pop("secondary") if primary or secondary: assert primary and secondary self.primary = primary self.secondary = secondary else: self.primary = augeasparser.AugeasBlockNode(**kwargs) self.secondary = apacheparser.ApacheBlockNode(**kwargs) assertions.assertEqual(self.primary, self.secondary) def add_child_block(self, name, parameters=None, position=None): """ Creates a new child BlockNode, asserts that both implementations did it in a similar way, and returns a newly created DualBlockNode object encapsulating both of the newly created objects """ primary_new = self.primary.add_child_block(name, parameters, position) secondary_new = self.secondary.add_child_block(name, parameters, position) assertions.assertEqual(primary_new, secondary_new) new_block = DualBlockNode(primary=primary_new, secondary=secondary_new) return new_block def add_child_directive(self, name, parameters=None, position=None): """ Creates a new child DirectiveNode, asserts that both implementations did it in a similar way, and returns a newly created DualDirectiveNode object encapsulating both of the newly created objects """ primary_new = self.primary.add_child_directive(name, parameters, position) secondary_new = self.secondary.add_child_directive(name, parameters, position) assertions.assertEqual(primary_new, secondary_new) new_dir = DualDirectiveNode(primary=primary_new, secondary=secondary_new) return new_dir def add_child_comment(self, comment="", position=None): """ Creates a new child CommentNode, asserts that both implementations did it in a similar way, and returns a newly created DualCommentNode object encapsulating both of the newly created objects """ primary_new = self.primary.add_child_comment(comment, position) secondary_new = self.secondary.add_child_comment(comment, position) assertions.assertEqual(primary_new, secondary_new) new_comment = DualCommentNode(primary=primary_new, secondary=secondary_new) return new_comment def _create_matching_list(self, primary_list, secondary_list): """ Matches the list of primary_list to a list of secondary_list and returns a list of tuples. This is used to create results for find_ methods. This helper function exists, because we cannot ensure that the list of search results returned by primary.find_* and secondary.find_* are ordered in a same way. The function pairs the same search results from both implementations to a list of tuples. """ matched = [] for p in primary_list: match = None for s in secondary_list: try: assertions.assertEqual(p, s) match = s break except AssertionError: continue if match: matched.append((p, match)) else: raise AssertionError("Could not find a matching node.") return matched def find_blocks(self, name, exclude=True): """ Performs a search for BlockNodes using both implementations and does simple checks for results. This is built upon the assumption that unimplemented find_* methods return a list with a single assertion passing object. After the assertion, it creates a list of newly created DualBlockNode instances that encapsulate the pairs of returned BlockNode objects. """ return self._find_helper(DualBlockNode, "find_blocks", name, exclude=exclude) def find_directives(self, name, exclude=True): """ Performs a search for DirectiveNodes using both implementations and checks the results. This is built upon the assumption that unimplemented find_* methods return a list with a single assertion passing object. After the assertion, it creates a list of newly created DualDirectiveNode instances that encapsulate the pairs of returned DirectiveNode objects. """ return self._find_helper(DualDirectiveNode, "find_directives", name, exclude=exclude) def find_comments(self, comment): """ Performs a search for CommentNodes using both implementations and checks the results. This is built upon the assumption that unimplemented find_* methods return a list with a single assertion passing object. After the assertion, it creates a list of newly created DualCommentNode instances that encapsulate the pairs of returned CommentNode objects. """ return self._find_helper(DualCommentNode, "find_comments", comment) def delete_child(self, child): """Deletes a child from the ParserNode implementations. The actual ParserNode implementations are used here directly in order to be able to match a child to the list of children.""" self.primary.delete_child(child.primary) self.secondary.delete_child(child.secondary) def unsaved_files(self): """ Fetches the list of unsaved file paths and asserts that the lists match """ primary_files = self.primary.unsaved_files() secondary_files = self.secondary.unsaved_files() assertions.assertEqualSimple(primary_files, secondary_files) return primary_files def parsed_paths(self): """ Returns a list of file paths that have currently been parsed into the parser tree. The returned list may include paths with wildcard characters, for example: ['/etc/apache2/conf.d/*.load'] This is typically called on the root node of the ParserNode tree. :returns: list of file paths of files that have been parsed """ primary_paths = self.primary.parsed_paths() secondary_paths = self.secondary.parsed_paths() assertions.assertEqualPathsList(primary_paths, secondary_paths) return primary_paths ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/certbot_apache/_internal/entrypoint.py0000644000076500000240000000532700000000000022637 0ustar00bmwstaff""" Entry point for Apache Plugin """ from distutils.version import LooseVersion from certbot import util from certbot_apache._internal import configurator from certbot_apache._internal import override_arch from certbot_apache._internal import override_centos from certbot_apache._internal import override_darwin from certbot_apache._internal import override_debian from certbot_apache._internal import override_fedora from certbot_apache._internal import override_gentoo from certbot_apache._internal import override_suse from certbot_apache._internal import override_void OVERRIDE_CLASSES = { "arch": override_arch.ArchConfigurator, "cloudlinux": override_centos.CentOSConfigurator, "darwin": override_darwin.DarwinConfigurator, "debian": override_debian.DebianConfigurator, "ubuntu": override_debian.DebianConfigurator, "centos": override_centos.CentOSConfigurator, "centos linux": override_centos.CentOSConfigurator, "fedora_old": override_centos.CentOSConfigurator, "fedora": override_fedora.FedoraConfigurator, "linuxmint": override_debian.DebianConfigurator, "ol": override_centos.CentOSConfigurator, "oracle": override_centos.CentOSConfigurator, "redhatenterpriseserver": override_centos.CentOSConfigurator, "red hat enterprise linux server": override_centos.CentOSConfigurator, "rhel": override_centos.CentOSConfigurator, "amazon": override_centos.CentOSConfigurator, "gentoo": override_gentoo.GentooConfigurator, "gentoo base system": override_gentoo.GentooConfigurator, "opensuse": override_suse.OpenSUSEConfigurator, "suse": override_suse.OpenSUSEConfigurator, "sles": override_suse.OpenSUSEConfigurator, "scientific": override_centos.CentOSConfigurator, "scientific linux": override_centos.CentOSConfigurator, "void": override_void.VoidConfigurator, } def get_configurator(): """ Get correct configurator class based on the OS fingerprint """ os_name, os_version = util.get_os_info() os_name = os_name.lower() override_class = None # Special case for older Fedora versions if os_name == 'fedora' and LooseVersion(os_version) < LooseVersion('29'): os_name = 'fedora_old' try: override_class = OVERRIDE_CLASSES[os_name] except KeyError: # OS not found in the list os_like = util.get_systemd_os_like() if os_like: for os_name in os_like: if os_name in OVERRIDE_CLASSES.keys(): override_class = OVERRIDE_CLASSES[os_name] if not override_class: # No override class found, return the generic configurator override_class = configurator.ApacheConfigurator return override_class ENTRYPOINT = get_configurator() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/certbot_apache/_internal/http_01.py0000644000076500000240000002103500000000000021675 0ustar00bmwstaff"""A class that performs HTTP-01 challenges for Apache""" import errno import logging from typing import List from typing import Set from certbot import errors from certbot.compat import filesystem from certbot.compat import os from certbot.plugins import common from certbot_apache._internal.obj import VirtualHost # pylint: disable=unused-import from certbot_apache._internal.parser import get_aug_path logger = logging.getLogger(__name__) class ApacheHttp01(common.ChallengePerformer): """Class that performs HTTP-01 challenges within the Apache configurator.""" CONFIG_TEMPLATE22_PRE = """\ RewriteEngine on RewriteRule ^/\\.well-known/acme-challenge/([A-Za-z0-9-_=]+)$ {0}/$1 [L] """ CONFIG_TEMPLATE22_POST = """\ Order Allow,Deny Allow from all Order Allow,Deny Allow from all """ CONFIG_TEMPLATE24_PRE = """\ RewriteEngine on RewriteRule ^/\\.well-known/acme-challenge/([A-Za-z0-9-_=]+)$ {0}/$1 [END] """ CONFIG_TEMPLATE24_POST = """\ Require all granted Require all granted """ def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.challenge_conf_pre = os.path.join( self.configurator.conf("challenge-location"), "le_http_01_challenge_pre.conf") self.challenge_conf_post = os.path.join( self.configurator.conf("challenge-location"), "le_http_01_challenge_post.conf") self.challenge_dir = os.path.join( self.configurator.config.work_dir, "http_challenges") self.moded_vhosts: Set[VirtualHost] = set() def perform(self): """Perform all HTTP-01 challenges.""" if not self.achalls: return [] # Save any changes to the configuration as a precaution # About to make temporary changes to the config self.configurator.save("Changes before challenge setup", True) self.configurator.ensure_listen(str( self.configurator.config.http01_port)) self.prepare_http01_modules() responses = self._set_up_challenges() self._mod_config() # Save reversible changes self.configurator.save("HTTP Challenge", True) return responses def prepare_http01_modules(self): """Make sure that we have the needed modules available for http01""" if self.configurator.conf("handle-modules"): needed_modules = ["rewrite"] if self.configurator.version < (2, 4): needed_modules.append("authz_host") else: needed_modules.append("authz_core") for mod in needed_modules: if mod + "_module" not in self.configurator.parser.modules: self.configurator.enable_mod(mod, temp=True) def _mod_config(self): selected_vhosts: List[VirtualHost] = [] http_port = str(self.configurator.config.http01_port) # Search for VirtualHosts matching by name for chall in self.achalls: selected_vhosts += self._matching_vhosts(chall.domain) # Ensure that we have one or more VirtualHosts that we can continue # with. (one that listens to port configured with --http-01-port) found = False for vhost in selected_vhosts: if any(a.is_wildcard() or a.get_port() == http_port for a in vhost.addrs): found = True # If there's at least one eligible VirtualHost, also add all unnamed VirtualHosts # because they might match at runtime (#8890) if found: selected_vhosts += self._unnamed_vhosts() # Otherwise, add every Virtualhost which listens on the right port else: selected_vhosts += self._relevant_vhosts() # Add the challenge configuration for vh in selected_vhosts: self._set_up_include_directives(vh) self.configurator.reverter.register_file_creation( True, self.challenge_conf_pre) self.configurator.reverter.register_file_creation( True, self.challenge_conf_post) if self.configurator.version < (2, 4): config_template_pre = self.CONFIG_TEMPLATE22_PRE config_template_post = self.CONFIG_TEMPLATE22_POST else: config_template_pre = self.CONFIG_TEMPLATE24_PRE config_template_post = self.CONFIG_TEMPLATE24_POST config_text_pre = config_template_pre.format(self.challenge_dir) config_text_post = config_template_post.format(self.challenge_dir) logger.debug("writing a pre config file with text:\n %s", config_text_pre) with open(self.challenge_conf_pre, "w") as new_conf: new_conf.write(config_text_pre) logger.debug("writing a post config file with text:\n %s", config_text_post) with open(self.challenge_conf_post, "w") as new_conf: new_conf.write(config_text_post) def _matching_vhosts(self, domain): """Return all VirtualHost objects that have the requested domain name or a wildcard name that would match the domain in ServerName or ServerAlias directive. """ matching_vhosts = [] for vhost in self.configurator.vhosts: if self.configurator.domain_in_names(vhost.get_names(), domain): # domain_in_names also matches the exact names, so no need # to check "domain in vhost.get_names()" explicitly here matching_vhosts.append(vhost) return matching_vhosts def _relevant_vhosts(self): http01_port = str(self.configurator.config.http01_port) relevant_vhosts = [] for vhost in self.configurator.vhosts: if any(a.is_wildcard() or a.get_port() == http01_port for a in vhost.addrs): if not vhost.ssl: relevant_vhosts.append(vhost) if not relevant_vhosts: raise errors.PluginError( "Unable to find a virtual host listening on port {0} which is" " currently needed for Certbot to prove to the CA that you" " control your domain. Please add a virtual host for port" " {0}.".format(http01_port)) return relevant_vhosts def _unnamed_vhosts(self) -> List[VirtualHost]: """Return all VirtualHost objects with no ServerName""" return [vh for vh in self.configurator.vhosts if vh.name is None] def _set_up_challenges(self): if not os.path.isdir(self.challenge_dir): old_umask = filesystem.umask(0o022) try: filesystem.makedirs(self.challenge_dir, 0o755) except OSError as exception: if exception.errno not in (errno.EEXIST, errno.EISDIR): raise errors.PluginError( "Couldn't create root for http-01 challenge") finally: filesystem.umask(old_umask) responses = [] for achall in self.achalls: responses.append(self._set_up_challenge(achall)) return responses def _set_up_challenge(self, achall): response, validation = achall.response_and_validation() name = os.path.join(self.challenge_dir, achall.chall.encode("token")) self.configurator.reverter.register_file_creation(True, name) with open(name, 'wb') as f: f.write(validation.encode()) filesystem.chmod(name, 0o644) return response def _set_up_include_directives(self, vhost): """Includes override configuration to the beginning and to the end of VirtualHost. Note that this include isn't added to Augeas search tree""" if vhost not in self.moded_vhosts: logger.debug( "Adding a temporary challenge validation Include for name: %s in: %s", vhost.name, vhost.filep) self.configurator.parser.add_dir_beginning( vhost.path, "Include", self.challenge_conf_pre) self.configurator.parser.add_dir( vhost.path, "Include", self.challenge_conf_post) if not vhost.enabled: self.configurator.parser.add_dir( get_aug_path(self.configurator.parser.loc["default"]), "Include", vhost.filep) self.moded_vhosts.add(vhost) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/certbot_apache/_internal/interfaces.py0000644000076500000240000005302600000000000022546 0ustar00bmwstaff"""ParserNode interface for interacting with configuration tree. General description ------------------- The ParserNode interfaces are designed to be able to contain all the parsing logic, while allowing their users to interact with the configuration tree in a Pythonic and well structured manner. The structure allows easy traversal of the tree of ParserNodes. Each ParserNode stores a reference to its ancestor and immediate children, allowing the user to traverse the tree using built in interface methods as well as accessing the interface properties directly. ParserNode interface implementation should stand between the actual underlying parser functionality and the business logic within Configurator code, interfacing with both. The ParserNode tree is a result of configuration parsing action. ParserNode tree will be in charge of maintaining the parser state and hence the abstract syntax tree (AST). Interactions between ParserNode tree and underlying parser should involve only parsing the configuration files to this structure, and writing it back to the filesystem - while preserving the format including whitespaces. For some implementations (Apache for example) it's important to keep track of and to use state information while parsing conditional blocks and directives. This allows the implementation to set a flag to parts of the parsed configuration structure as not being in effect in a case of unmatched conditional block. It's important to store these blocks in the tree as well in order to not to conduct destructive actions (failing to write back parts of the configuration) while writing the AST back to the filesystem. The ParserNode tree is in charge of maintaining the its own structure while every child node fetched with find - methods or by iterating its list of children can be changed in place. When making changes the affected nodes should be flagged as "dirty" in order for the parser implementation to figure out the parts of the configuration that need to be written back to disk during the save() operation. Metadata -------- The metadata holds all the implementation specific attributes of the ParserNodes - things like the positional information related to the AST, file paths, whitespacing, and any other information relevant to the underlying parser engine. Access to the metadata should be handled by implementation specific methods, allowing the Configurator functionality to access the underlying information where needed. For some implementations the node can be initialized using the information carried in metadata alone. This is useful especially when populating the ParserNode tree while parsing the configuration. Apache implementation --------------------- The Apache implementation of ParserNode interface requires some implementation specific functionalities that are not described by the interface itself. Initialization When the user of a ParserNode class is creating these objects, they must specify the parameters as described in the documentation for the __init__ methods below. When these objects are created internally, however, some parameters may not be needed because (possibly more detailed) information is included in the metadata parameter. In this case, implementations can deviate from the required parameters from __init__, however, they should still behave the same when metadata is not provided. For consistency internally, if an argument is provided directly in the ParserNode initialization parameters as well as within metadata it's recommended to establish clear behavior around this scenario within the implementation. Conditional blocks Apache configuration can have conditional blocks, for example: , resulting the directives and subblocks within it being either enabled or disabled. While find_* interface methods allow including the disabled parts of the configuration tree in searches a special care needs to be taken while parsing the structure in order to reflect the active state of configuration. Whitespaces Each ParserNode object is responsible of storing its prepending whitespace characters in order to be able to write the AST back to filesystem like it was, preserving the format, this applies for parameters of BlockNode and DirectiveNode as well. When parameters of ParserNode are changed, the pre-existing whitespaces in the parameter sequence are discarded, as the general reason for storing them is to maintain the ability to write the configuration back to filesystem exactly like it was. This loses its meaning when we have to change the directives or blocks parameters for other reasons. Searches and matching Apache configuration is largely case insensitive, so the Apache implementation of ParserNode interface needs to provide the user means to match block and directive names and parameters in case insensitive manner. This does not apply to everything however, for example the parameters of a conditional statement may be case sensitive. For this reason the internal representation of data should not ignore the case. """ import abc class ParserNode(object, metaclass=abc.ABCMeta): """ ParserNode is the basic building block of the tree of such nodes, representing the structure of the configuration. It is largely meant to keep the structure information intact and idiomatically accessible. The root node as well as the child nodes of it should be instances of ParserNode. Nodes keep track of their differences to on-disk representation of configuration by marking modified ParserNodes as dirty to enable partial write-to-disk for different files in the configuration structure. While for the most parts the usage and the child types are obvious, "include"- and similar directives are an exception to this rule. This is because of the nature of include directives - which unroll the contents of another file or configuration block to their place. While we could unroll the included nodes to the parent tree, it remains important to keep the context of include nodes separate in order to write back the original configuration as it was. For parsers that require the implementation to keep track of the whitespacing, it's responsibility of each ParserNode object itself to store its prepending whitespaces in order to be able to reconstruct the complete configuration file as it was when originally read from the disk. ParserNode objects should have the following attributes: # Reference to ancestor node, or None if the node is the root node of the # configuration tree. ancestor: Optional[ParserNode] # True if this node has been modified since last save. dirty: bool # Filepath of the file where the configuration element for this ParserNode # object resides. For root node, the value for filepath is the httpd root # configuration file. Filepath can be None if a configuration directive is # defined in for example the httpd command line. filepath: Optional[str] # Metadata dictionary holds all the implementation specific key-value pairs # for the ParserNode instance. metadata: Dict[str, Any] """ @abc.abstractmethod def __init__(self, **kwargs): """ Initializes the ParserNode instance, and sets the ParserNode specific instance variables. This is not meant to be used directly, but through specific classes implementing ParserNode interface. :param ancestor: BlockNode ancestor for this CommentNode. Required. :type ancestor: BlockNode or None :param filepath: Filesystem path for the file where this CommentNode does or should exist in the filesystem. Required. :type filepath: str or None :param dirty: Boolean flag for denoting if this CommentNode has been created or changed after the last save. Default: False. :type dirty: bool :param metadata: Dictionary of metadata values for this ParserNode object. Metadata information should be used only internally in the implementation. Default: {} :type metadata: dict """ @abc.abstractmethod def save(self, msg): """ Save traverses the children, and attempts to write the AST to disk for all the objects that are marked dirty. The actual operation of course depends on the underlying implementation. save() shouldn't be called from the Configurator outside of its designated save() method in order to ensure that the Reverter checkpoints are created properly. Note: this approach of keeping internal structure of the configuration within the ParserNode tree does not represent the file inclusion structure of actual configuration files that reside in the filesystem. To handle file writes properly, the file specific temporary trees should be extracted from the full ParserNode tree where necessary when writing to disk. :param str msg: Message describing the reason for the save. """ @abc.abstractmethod def find_ancestors(self, name): """ Traverses the ancestor tree up, searching for BlockNodes with a specific name. :param str name: Name of the ancestor BlockNode to search for :returns: A list of ancestor BlockNodes that match the name :rtype: list of BlockNode """ class CommentNode(ParserNode, metaclass=abc.ABCMeta): """ CommentNode class is used for representation of comments within the parsed configuration structure. Because of the nature of comments, it is not able to have child nodes and hence it is always treated as a leaf node. CommentNode stores its contents in class variable 'comment' and does not have a specific name. CommentNode objects should have the following attributes in addition to the ones described in ParserNode: # Contains the contents of the comment without the directive notation # (typically # or /* ... */). comment: str """ @abc.abstractmethod def __init__(self, **kwargs): """ Initializes the CommentNode instance and sets its instance variables. :param comment: Contents of the comment. Required. :type comment: str :param ancestor: BlockNode ancestor for this CommentNode. Required. :type ancestor: BlockNode or None :param filepath: Filesystem path for the file where this CommentNode does or should exist in the filesystem. Required. :type filepath: str or None :param dirty: Boolean flag for denoting if this CommentNode has been created or changed after the last save. Default: False. :type dirty: bool """ super().__init__(ancestor=kwargs['ancestor'], dirty=kwargs.get('dirty', False), filepath=kwargs['filepath'], metadata=kwargs.get('metadata', {})) # pragma: no cover class DirectiveNode(ParserNode, metaclass=abc.ABCMeta): """ DirectiveNode class represents a configuration directive within the configuration. It can have zero or more parameters attached to it. Because of the nature of single directives, it is not able to have child nodes and hence it is always treated as a leaf node. If a this directive was defined on the httpd command line, the ancestor instance variable for this DirectiveNode should be None, and it should be inserted to the beginning of root BlockNode children sequence. DirectiveNode objects should have the following attributes in addition to the ones described in ParserNode: # True if this DirectiveNode is enabled and False if it is inside of an # inactive conditional block. enabled: bool # Name, or key of the configuration directive. If BlockNode subclass of # DirectiveNode is the root configuration node, the name should be None. name: Optional[str] # Tuple of parameters of this ParserNode object, excluding whitespaces. parameters: Tuple[str, ...] """ @abc.abstractmethod def __init__(self, **kwargs): """ Initializes the DirectiveNode instance and sets its instance variables. :param name: Name or key of the DirectiveNode object. Required. :type name: str or None :param tuple parameters: Tuple of str parameters for this DirectiveNode. Default: (). :type parameters: tuple :param ancestor: BlockNode ancestor for this DirectiveNode, or None for root configuration node. Required. :type ancestor: BlockNode or None :param filepath: Filesystem path for the file where this DirectiveNode does or should exist in the filesystem, or None for directives introduced in the httpd command line. Required. :type filepath: str or None :param dirty: Boolean flag for denoting if this DirectiveNode has been created or changed after the last save. Default: False. :type dirty: bool :param enabled: True if this DirectiveNode object is parsed in the active configuration of the httpd. False if the DirectiveNode exists within a unmatched conditional configuration block. Default: True. :type enabled: bool """ super().__init__(ancestor=kwargs['ancestor'], dirty=kwargs.get('dirty', False), filepath=kwargs['filepath'], metadata=kwargs.get('metadata', {})) # pragma: no cover @abc.abstractmethod def set_parameters(self, parameters): """ Sets the sequence of parameters for this ParserNode object without whitespaces. While the whitespaces for parameters are discarded when using this method, the whitespacing preceding the ParserNode itself should be kept intact. :param list parameters: sequence of parameters """ class BlockNode(DirectiveNode, metaclass=abc.ABCMeta): """ BlockNode class represents a block of nested configuration directives, comments and other blocks as its children. A BlockNode can have zero or more parameters attached to it. Configuration blocks typically consist of one or more child nodes of all possible types. Because of this, the BlockNode class has various discovery and structure management methods. Lists of parameters used as an optional argument for some of the methods should be lists of strings that are applicable parameters for each specific BlockNode or DirectiveNode type. As an example, for a following configuration example: ... The node type would be BlockNode, name would be 'VirtualHost' and its parameters would be: ['*:80']. While for the following example: LoadModule alias_module /usr/lib/apache2/modules/mod_alias.so The node type would be DirectiveNode, name would be 'LoadModule' and its parameters would be: ['alias_module', '/usr/lib/apache2/modules/mod_alias.so'] The applicable parameters are dependent on the underlying configuration language and its grammar. BlockNode objects should have the following attributes in addition to the ones described in DirectiveNode: # Tuple of direct children of this BlockNode object. The order of children # in this tuple retain the order of elements in the parsed configuration # block. children: Tuple[ParserNode, ...] """ @abc.abstractmethod def add_child_block(self, name, parameters=None, position=None): """ Adds a new BlockNode child node with provided values and marks the callee BlockNode dirty. This is used to add new children to the AST. The preceding whitespaces should not be added based on the ancestor or siblings for the newly created object. This is to match the current behavior of the legacy parser implementation. :param str name: The name of the child node to add :param list parameters: list of parameters for the node :param int position: Position in the list of children to add the new child node to. Defaults to None, which appends the newly created node to the list. If an integer is given, the child is inserted before that index in the list similar to list().insert. :returns: BlockNode instance of the created child block """ @abc.abstractmethod def add_child_directive(self, name, parameters=None, position=None): """ Adds a new DirectiveNode child node with provided values and marks the callee BlockNode dirty. This is used to add new children to the AST. The preceding whitespaces should not be added based on the ancestor or siblings for the newly created object. This is to match the current behavior of the legacy parser implementation. :param str name: The name of the child node to add :param list parameters: list of parameters for the node :param int position: Position in the list of children to add the new child node to. Defaults to None, which appends the newly created node to the list. If an integer is given, the child is inserted before that index in the list similar to list().insert. :returns: DirectiveNode instance of the created child directive """ @abc.abstractmethod def add_child_comment(self, comment="", position=None): """ Adds a new CommentNode child node with provided value and marks the callee BlockNode dirty. This is used to add new children to the AST. The preceding whitespaces should not be added based on the ancestor or siblings for the newly created object. This is to match the current behavior of the legacy parser implementation. :param str comment: Comment contents :param int position: Position in the list of children to add the new child node to. Defaults to None, which appends the newly created node to the list. If an integer is given, the child is inserted before that index in the list similar to list().insert. :returns: CommentNode instance of the created child comment """ @abc.abstractmethod def find_blocks(self, name, exclude=True): """ Find a configuration block by name. This method walks the child tree of ParserNodes under the instance it was called from. This way it is possible to search for the whole configuration tree, when starting from root node or to do a partial search when starting from a specified branch. The lookup should be case insensitive. :param str name: The name of the directive to search for :param bool exclude: If the search results should exclude the contents of ParserNode objects that reside within conditional blocks and because of current state are not enabled. :returns: A list of found BlockNode objects. """ @abc.abstractmethod def find_directives(self, name, exclude=True): """ Find a directive by name. This method walks the child tree of ParserNodes under the instance it was called from. This way it is possible to search for the whole configuration tree, when starting from root node, or to do a partial search when starting from a specified branch. The lookup should be case insensitive. :param str name: The name of the directive to search for :param bool exclude: If the search results should exclude the contents of ParserNode objects that reside within conditional blocks and because of current state are not enabled. :returns: A list of found DirectiveNode objects. """ @abc.abstractmethod def find_comments(self, comment): """ Find comments with value containing the search term. This method walks the child tree of ParserNodes under the instance it was called from. This way it is possible to search for the whole configuration tree, when starting from root node, or to do a partial search when starting from a specified branch. The lookup should be case sensitive. :param str comment: The content of comment to search for :returns: A list of found CommentNode objects. """ @abc.abstractmethod def delete_child(self, child): """ Remove a specified child node from the list of children of the called BlockNode object. :param ParserNode child: Child ParserNode object to remove from the list of children of the callee. """ @abc.abstractmethod def unsaved_files(self): """ Returns a list of file paths that have been changed since the last save (or the initial configuration parse). The intended use for this method is to tell the Reverter which files need to be included in a checkpoint. This is typically called for the root of the ParserNode tree. :returns: list of file paths of files that have been changed but not yet saved to disk. """ @abc.abstractmethod def parsed_paths(self): """ Returns a list of file paths that have currently been parsed into the parser tree. The returned list may include paths with wildcard characters, for example: ['/etc/apache2/conf.d/*.load'] This is typically called on the root node of the ParserNode tree. :returns: list of file paths of files that have been parsed """ ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/certbot_apache/_internal/obj.py0000644000076500000240000002126700000000000021177 0ustar00bmwstaff"""Module contains classes used by the Apache Configurator.""" import re from typing import Set from certbot.plugins import common class Addr(common.Addr): """Represents an Apache address.""" def __eq__(self, other): """This is defined as equivalent within Apache. ip_addr:* == ip_addr """ if isinstance(other, self.__class__): return ((self.tup == other.tup) or (self.tup[0] == other.tup[0] and self.is_wildcard() and other.is_wildcard())) return False def __repr__(self): return "certbot_apache._internal.obj.Addr(" + repr(self.tup) + ")" def __hash__(self): # pylint: disable=useless-super-delegation # Python 3 requires explicit overridden for __hash__ if __eq__ or # __cmp__ is overridden. See https://bugs.python.org/issue2235 return super().__hash__() def _addr_less_specific(self, addr): """Returns if addr.get_addr() is more specific than self.get_addr().""" # pylint: disable=protected-access return addr._rank_specific_addr() > self._rank_specific_addr() def _rank_specific_addr(self): """Returns numerical rank for get_addr() :returns: 2 - FQ, 1 - wildcard, 0 - _default_ :rtype: int """ if self.get_addr() == "_default_": return 0 elif self.get_addr() == "*": return 1 return 2 def conflicts(self, addr): r"""Returns if address could conflict with correct function of self. Could addr take away service provided by self within Apache? .. note::IP Address is more important than wildcard. Connection from 127.0.0.1:80 with choices of *:80 and 127.0.0.1:* chooses 127.0.0.1:\* .. todo:: Handle domain name addrs... Examples: ========================================= ===== ``127.0.0.1:\*.conflicts(127.0.0.1:443)`` True ``127.0.0.1:443.conflicts(127.0.0.1:\*)`` False ``\*:443.conflicts(\*:80)`` False ``_default_:443.conflicts(\*:443)`` True ========================================= ===== """ if self._addr_less_specific(addr): return True elif self.get_addr() == addr.get_addr(): if self.is_wildcard() or self.get_port() == addr.get_port(): return True return False def is_wildcard(self): """Returns if address has a wildcard port.""" return self.tup[1] == "*" or not self.tup[1] def get_sni_addr(self, port): """Returns the least specific address that resolves on the port. Examples: - ``1.2.3.4:443`` -> ``1.2.3.4:`` - ``1.2.3.4:*`` -> ``1.2.3.4:*`` :param str port: Desired port """ if self.is_wildcard(): return self return self.get_addr_obj(port) class VirtualHost: """Represents an Apache Virtualhost. :ivar str filep: file path of VH :ivar str path: Augeas path to virtual host :ivar set addrs: Virtual Host addresses (:class:`set` of :class:`common.Addr`) :ivar str name: ServerName of VHost :ivar list aliases: Server aliases of vhost (:class:`list` of :class:`str`) :ivar bool ssl: SSLEngine on in vhost :ivar bool enabled: Virtual host is enabled :ivar bool modmacro: VirtualHost is using mod_macro :ivar VirtualHost ancestor: A non-SSL VirtualHost this is based on https://httpd.apache.org/docs/2.4/vhosts/details.html .. todo:: Any vhost that includes the magic _default_ wildcard is given the same ServerName as the main server. """ # ?: is used for not returning enclosed characters strip_name = re.compile(r"^(?:.+://)?([^ :$]*)") def __init__(self, filep, path, addrs, ssl, enabled, name=None, aliases=None, modmacro=False, ancestor=None, node=None): """Initialize a VH.""" self.filep = filep self.path = path self.addrs = addrs self.name = name self.aliases = aliases if aliases is not None else set() self.ssl = ssl self.enabled = enabled self.modmacro = modmacro self.ancestor = ancestor self.node = node def get_names(self): """Return a set of all names.""" all_names: Set[str] = set() all_names.update(self.aliases) # Strip out any scheme:// and field from servername if self.name is not None: all_names.add(VirtualHost.strip_name.findall(self.name)[0]) return all_names def __str__(self): return ( "File: {filename}\n" "Vhost path: {vhpath}\n" "Addresses: {addrs}\n" "Name: {name}\n" "Aliases: {aliases}\n" "TLS Enabled: {tls}\n" "Site Enabled: {active}\n" "mod_macro Vhost: {modmacro}".format( filename=self.filep, vhpath=self.path, addrs=", ".join(str(addr) for addr in self.addrs), name=self.name if self.name is not None else "", aliases=", ".join(name for name in self.aliases), tls="Yes" if self.ssl else "No", active="Yes" if self.enabled else "No", modmacro="Yes" if self.modmacro else "No")) def display_repr(self): """Return a representation of VHost to be used in dialog""" return ( "File: {filename}\n" "Addresses: {addrs}\n" "Names: {names}\n" "HTTPS: {https}\n".format( filename=self.filep, addrs=", ".join(str(addr) for addr in self.addrs), names=", ".join(self.get_names()), https="Yes" if self.ssl else "No")) def __eq__(self, other): if isinstance(other, self.__class__): return (self.filep == other.filep and self.path == other.path and self.addrs == other.addrs and self.get_names() == other.get_names() and self.ssl == other.ssl and self.enabled == other.enabled and self.modmacro == other.modmacro) return False def __hash__(self): return hash((self.filep, self.path, tuple(self.addrs), tuple(self.get_names()), self.ssl, self.enabled, self.modmacro)) def conflicts(self, addrs): """See if vhost conflicts with any of the addrs. This determines whether or not these addresses would/could overwrite the vhost addresses. :param addrs: Iterable Addresses :type addrs: Iterable :class:~obj.Addr :returns: If addresses conflicts with vhost :rtype: bool """ for pot_addr in addrs: for addr in self.addrs: if addr.conflicts(pot_addr): return True return False def same_server(self, vhost, generic=False): """Determines if the vhost is the same 'server'. Used in redirection - indicates whether or not the two virtual hosts serve on the exact same IP combinations, but different ports. The generic flag indicates that that we're trying to match to a default or generic vhost .. todo:: Handle _default_ """ if not generic: if vhost.get_names() != self.get_names(): return False # If equal and set is not empty... assume same server if self.name is not None or self.aliases: return True # If we're looking for a generic vhost, # don't return one with a ServerName elif self.name: return False # Both sets of names are empty. # Make conservative educated guess... this is very restrictive # Consider adding more safety checks. if len(vhost.addrs) != len(self.addrs): return False # already_found acts to keep everything very conservative. # Don't allow multiple ip:ports in same set. already_found: Set[str] = set() for addr in vhost.addrs: for local_addr in self.addrs: if (local_addr.get_addr() == addr.get_addr() and local_addr != addr and local_addr.get_addr() not in already_found): # This intends to make sure we aren't double counting... # e.g. 127.0.0.1:* - We require same number of addrs # currently already_found.add(local_addr.get_addr()) break else: return False return True ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/certbot_apache/_internal/override_arch.py0000644000076500000240000000124400000000000023232 0ustar00bmwstaff""" Distribution specific override class for Arch Linux """ from certbot_apache._internal import configurator from certbot_apache._internal.configurator import OsOptions class ArchConfigurator(configurator.ApacheConfigurator): """Arch Linux specific ApacheConfigurator override class""" OS_DEFAULTS = OsOptions( server_root="/etc/httpd", vhost_root="/etc/httpd/conf", vhost_files="*.conf", logs_root="/var/log/httpd", ctl="apachectl", version_cmd=['apachectl', '-v'], restart_cmd=['apachectl', 'graceful'], conftest_cmd=['apachectl', 'configtest'], challenge_location="/etc/httpd/conf", ) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/certbot_apache/_internal/override_centos.py0000644000076500000240000002017400000000000023613 0ustar00bmwstaff""" Distribution specific override class for CentOS family (RHEL, Fedora) """ import logging from typing import cast from typing import List from certbot import errors from certbot import util from certbot.errors import MisconfigurationError from certbot_apache._internal import apache_util from certbot_apache._internal import configurator from certbot_apache._internal import parser from certbot_apache._internal.configurator import OsOptions logger = logging.getLogger(__name__) class CentOSConfigurator(configurator.ApacheConfigurator): """CentOS specific ApacheConfigurator override class""" OS_DEFAULTS = OsOptions( server_root="/etc/httpd", vhost_root="/etc/httpd/conf.d", vhost_files="*.conf", logs_root="/var/log/httpd", ctl="apachectl", version_cmd=['apachectl', '-v'], restart_cmd=['apachectl', 'graceful'], restart_cmd_alt=['apachectl', 'restart'], conftest_cmd=['apachectl', 'configtest'], challenge_location="/etc/httpd/conf.d", ) def config_test(self): """ Override config_test to mitigate configtest error in vanilla installation of mod_ssl in Fedora. The error is caused by non-existent self-signed certificates referenced by the configuration, that would be autogenerated during the first (re)start of httpd. """ os_info = util.get_os_info() fedora = os_info[0].lower() == "fedora" try: super().config_test() except errors.MisconfigurationError: if fedora: self._try_restart_fedora() else: raise def _try_restart_fedora(self): """ Tries to restart httpd using systemctl to generate the self signed key pair. """ try: util.run_script(['systemctl', 'restart', 'httpd']) except errors.SubprocessError as err: raise errors.MisconfigurationError(str(err)) # Finish with actual config check to see if systemctl restart helped super().config_test() def _prepare_options(self): """ Override the options dictionary initialization in order to support alternative restart cmd used in CentOS. """ super()._prepare_options() if not self.options.restart_cmd_alt: # pragma: no cover raise ValueError("OS option restart_cmd_alt must be set for CentOS.") self.options.restart_cmd_alt[0] = self.options.ctl def get_parser(self): """Initializes the ApacheParser""" return CentOSParser( self.options.server_root, self.options.vhost_root, self.version, configurator=self) def _deploy_cert(self, *args, **kwargs): # pylint: disable=arguments-differ """ Override _deploy_cert in order to ensure that the Apache configuration has "LoadModule ssl_module..." before parsing the VirtualHost configuration that was created by Certbot """ super()._deploy_cert(*args, **kwargs) if self.version < (2, 4, 0): self._deploy_loadmodule_ssl_if_needed() def _deploy_loadmodule_ssl_if_needed(self): """ Add "LoadModule ssl_module " to main httpd.conf if it doesn't exist there already. """ loadmods = self.parser.find_dir("LoadModule", "ssl_module", exclude=False) correct_ifmods: List[str] = [] loadmod_args: List[str] = [] loadmod_paths: List[str] = [] for m in loadmods: noarg_path = m.rpartition("/")[0] path_args = self.parser.get_all_args(noarg_path) if loadmod_args: if loadmod_args != path_args: msg = ("Certbot encountered multiple LoadModule directives " "for LoadModule ssl_module with differing library paths. " "Please remove or comment out the one(s) that are not in " "use, and run Certbot again.") raise MisconfigurationError(msg) else: loadmod_args = path_args centos_parser: CentOSParser = cast(CentOSParser, self.parser) if centos_parser.not_modssl_ifmodule(noarg_path): if centos_parser.loc["default"] in noarg_path: # LoadModule already in the main configuration file if ("ifmodule/" in noarg_path.lower() or "ifmodule[1]" in noarg_path.lower()): # It's the first or only IfModule in the file return # Populate the list of known !mod_ssl.c IfModules nodir_path = noarg_path.rpartition("/directive")[0] correct_ifmods.append(nodir_path) else: loadmod_paths.append(noarg_path) if not loadmod_args: # Do not try to enable mod_ssl return # Force creation as the directive wasn't found from the beginning of # httpd.conf rootconf_ifmod = self.parser.create_ifmod( parser.get_aug_path(self.parser.loc["default"]), "!mod_ssl.c", beginning=True) # parser.get_ifmod returns a path postfixed with "/", remove that self.parser.add_dir(rootconf_ifmod[:-1], "LoadModule", loadmod_args) correct_ifmods.append(rootconf_ifmod[:-1]) self.save_notes += "Added LoadModule ssl_module to main configuration.\n" # Wrap LoadModule mod_ssl inside of if it's not # configured like this already. for loadmod_path in loadmod_paths: nodir_path = loadmod_path.split("/directive")[0] # Remove the old LoadModule directive self.parser.aug.remove(loadmod_path) # Create a new IfModule !mod_ssl.c if not already found on path ssl_ifmod = self.parser.get_ifmod(nodir_path, "!mod_ssl.c", beginning=True)[:-1] if ssl_ifmod not in correct_ifmods: self.parser.add_dir(ssl_ifmod, "LoadModule", loadmod_args) correct_ifmods.append(ssl_ifmod) self.save_notes += ("Wrapped pre-existing LoadModule ssl_module " "inside of block.\n") class CentOSParser(parser.ApacheParser): """CentOS specific ApacheParser override class""" def __init__(self, *args, **kwargs): # CentOS specific configuration file for Apache self.sysconfig_filep = "/etc/sysconfig/httpd" super().__init__(*args, **kwargs) def update_runtime_variables(self): """ Override for update_runtime_variables for custom parsing """ # Opportunistic, works if SELinux not enforced super().update_runtime_variables() self.parse_sysconfig_var() def parse_sysconfig_var(self): """ Parses Apache CLI options from CentOS configuration file """ defines = apache_util.parse_define_file(self.sysconfig_filep, "OPTIONS") for k, v in defines.items(): self.variables[k] = v def not_modssl_ifmodule(self, path): """Checks if the provided Augeas path has argument !mod_ssl""" if "ifmodule" not in path.lower(): return False # Trim the path to the last ifmodule workpath = path.lower() while workpath: # Get path to the last IfModule (ignore the tail) parts = workpath.rpartition("ifmodule") if not parts[0]: # IfModule not found break ifmod_path = parts[0] + parts[1] # Check if ifmodule had an index if parts[2].startswith("["): # Append the index from tail ifmod_path += parts[2].partition("/")[0] # Get the original path trimmed to correct length # This is required to preserve cases ifmod_real_path = path[0:len(ifmod_path)] if "!mod_ssl.c" in self.get_all_args(ifmod_real_path): return True # Set the workpath to the heading part workpath = parts[0] return False ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/certbot_apache/_internal/override_darwin.py0000644000076500000240000000113400000000000023577 0ustar00bmwstaff""" Distribution specific override class for macOS """ from certbot_apache._internal import configurator from certbot_apache._internal.configurator import OsOptions class DarwinConfigurator(configurator.ApacheConfigurator): """macOS specific ApacheConfigurator override class""" OS_DEFAULTS = OsOptions( vhost_root="/etc/apache2/other", vhost_files="*.conf", ctl="apachectl", version_cmd=['apachectl', '-v'], restart_cmd=['apachectl', 'graceful'], conftest_cmd=['apachectl', 'configtest'], challenge_location="/etc/apache2/other", ) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/certbot_apache/_internal/override_debian.py0000644000076500000240000001176100000000000023544 0ustar00bmwstaff""" Distribution specific override class for Debian family (Ubuntu/Debian) """ import logging from certbot import errors from certbot import util from certbot.compat import filesystem from certbot.compat import os from certbot_apache._internal import apache_util from certbot_apache._internal import configurator from certbot_apache._internal.configurator import OsOptions logger = logging.getLogger(__name__) class DebianConfigurator(configurator.ApacheConfigurator): """Debian specific ApacheConfigurator override class""" OS_DEFAULTS = OsOptions( enmod="a2enmod", dismod="a2dismod", handle_modules=True, handle_sites=True, ) def enable_site(self, vhost): """Enables an available site, Apache reload required. .. note:: Does not make sure that the site correctly works or that all modules are enabled appropriately. :param vhost: vhost to enable :type vhost: :class:`~certbot_apache._internal.obj.VirtualHost` :raises .errors.NotSupportedError: If filesystem layout is not supported. """ if vhost.enabled: return None enabled_path = ("%s/sites-enabled/%s" % (self.parser.root, os.path.basename(vhost.filep))) if not os.path.isdir(os.path.dirname(enabled_path)): # For some reason, sites-enabled / sites-available do not exist # Call the parent method return super().enable_site(vhost) self.reverter.register_file_creation(False, enabled_path) try: os.symlink(vhost.filep, enabled_path) except OSError as err: if os.path.islink(enabled_path) and filesystem.realpath( enabled_path) == vhost.filep: # Already in shape vhost.enabled = True return None logger.error( "Could not symlink %s to %s, got error: %s", enabled_path, vhost.filep, err.strerror) errstring = ("Encountered error while trying to enable a " + "newly created VirtualHost located at {0} by " + "linking to it from {1}") raise errors.NotSupportedError(errstring.format(vhost.filep, enabled_path)) vhost.enabled = True logger.info("Enabling available site: %s", vhost.filep) self.save_notes += "Enabled site %s\n" % vhost.filep return None def enable_mod(self, mod_name, temp=False): """Enables module in Apache. Both enables and reloads Apache so module is active. :param str mod_name: Name of the module to enable. (e.g. 'ssl') :param bool temp: Whether or not this is a temporary action. :raises .errors.NotSupportedError: If the filesystem layout is not supported. :raises .errors.MisconfigurationError: If a2enmod or a2dismod cannot be run. """ avail_path = os.path.join(self.parser.root, "mods-available") enabled_path = os.path.join(self.parser.root, "mods-enabled") if not os.path.isdir(avail_path) or not os.path.isdir(enabled_path): raise errors.NotSupportedError( "Unsupported directory layout. You may try to enable mod %s " "and try again." % mod_name) deps = apache_util.get_mod_deps(mod_name) # Enable all dependencies for dep in deps: if (dep + "_module") not in self.parser.modules: self._enable_mod_debian(dep, temp) self.parser.add_mod(dep) note = "Enabled dependency of %s module - %s" % (mod_name, dep) if not temp: self.save_notes += note + os.linesep logger.debug(note) # Enable actual module self._enable_mod_debian(mod_name, temp) self.parser.add_mod(mod_name) if not temp: self.save_notes += "Enabled %s module in Apache\n" % mod_name logger.info("Enabled Apache %s module", mod_name) # Modules can enable additional config files. Variables may be defined # within these new configuration sections. # Reload is not necessary as DUMP_RUN_CFG uses latest config. self.parser.update_runtime_variables() def _enable_mod_debian(self, mod_name, temp): """Assumes mods-available, mods-enabled layout.""" # Generate reversal command. # Try to be safe here... check that we can probably reverse before # applying enmod command if not util.exe_exists(self.options.dismod): raise errors.MisconfigurationError( "Unable to find a2dismod, please make sure a2enmod and " "a2dismod are configured correctly for certbot.") self.reverter.register_undo_command( temp, [self.options.dismod, "-f", mod_name]) util.run_script([self.options.enmod, mod_name]) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/certbot_apache/_internal/override_fedora.py0000644000076500000240000000647100000000000023564 0ustar00bmwstaff""" Distribution specific override class for Fedora 29+ """ from certbot import errors from certbot import util from certbot_apache._internal import apache_util from certbot_apache._internal import configurator from certbot_apache._internal import parser from certbot_apache._internal.configurator import OsOptions class FedoraConfigurator(configurator.ApacheConfigurator): """Fedora 29+ specific ApacheConfigurator override class""" OS_DEFAULTS = OsOptions( server_root="/etc/httpd", vhost_root="/etc/httpd/conf.d", vhost_files="*.conf", logs_root="/var/log/httpd", ctl="httpd", version_cmd=['httpd', '-v'], restart_cmd=['apachectl', 'graceful'], restart_cmd_alt=['apachectl', 'restart'], conftest_cmd=['apachectl', 'configtest'], challenge_location="/etc/httpd/conf.d", ) def config_test(self): """ Override config_test to mitigate configtest error in vanilla installation of mod_ssl in Fedora. The error is caused by non-existent self-signed certificates referenced by the configuration, that would be autogenerated during the first (re)start of httpd. """ try: super().config_test() except errors.MisconfigurationError: self._try_restart_fedora() def get_parser(self): """Initializes the ApacheParser""" return FedoraParser( self.options.server_root, self.options.vhost_root, self.version, configurator=self) def _try_restart_fedora(self): """ Tries to restart httpd using systemctl to generate the self signed key pair. """ try: util.run_script(['systemctl', 'restart', 'httpd']) except errors.SubprocessError as err: raise errors.MisconfigurationError(str(err)) # Finish with actual config check to see if systemctl restart helped super().config_test() def _prepare_options(self): """ Override the options dictionary initialization to keep using apachectl instead of httpd and so take advantages of this new bash script in newer versions of Fedora to restart httpd. """ super()._prepare_options() self.options.restart_cmd[0] = 'apachectl' if not self.options.restart_cmd_alt: # pragma: no cover raise ValueError("OS option restart_cmd_alt must be set for Fedora.") self.options.restart_cmd_alt[0] = 'apachectl' self.options.conftest_cmd[0] = 'apachectl' class FedoraParser(parser.ApacheParser): """Fedora 29+ specific ApacheParser override class""" def __init__(self, *args, **kwargs): # Fedora 29+ specific configuration file for Apache self.sysconfig_filep = "/etc/sysconfig/httpd" super().__init__(*args, **kwargs) def update_runtime_variables(self): """ Override for update_runtime_variables for custom parsing """ # Opportunistic, works if SELinux not enforced super().update_runtime_variables() self._parse_sysconfig_var() def _parse_sysconfig_var(self): """ Parses Apache CLI options from Fedora configuration file """ defines = apache_util.parse_define_file(self.sysconfig_filep, "OPTIONS") for k, v in defines.items(): self.variables[k] = v ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/certbot_apache/_internal/override_gentoo.py0000644000076500000240000000447000000000000023614 0ustar00bmwstaff""" Distribution specific override class for Gentoo Linux """ from certbot_apache._internal import apache_util from certbot_apache._internal import configurator from certbot_apache._internal import parser from certbot_apache._internal.configurator import OsOptions class GentooConfigurator(configurator.ApacheConfigurator): """Gentoo specific ApacheConfigurator override class""" OS_DEFAULTS = OsOptions( server_root="/etc/apache2", vhost_root="/etc/apache2/vhosts.d", vhost_files="*.conf", restart_cmd_alt=['apache2ctl', 'restart'], challenge_location="/etc/apache2/vhosts.d", ) def _prepare_options(self): """ Override the options dictionary initialization in order to support alternative restart cmd used in Gentoo. """ super()._prepare_options() if not self.options.restart_cmd_alt: # pragma: no cover raise ValueError("OS option restart_cmd_alt must be set for Gentoo.") self.options.restart_cmd_alt[0] = self.options.ctl def get_parser(self): """Initializes the ApacheParser""" return GentooParser( self.options.server_root, self.options.vhost_root, self.version, configurator=self) class GentooParser(parser.ApacheParser): """Gentoo specific ApacheParser override class""" def __init__(self, *args, **kwargs): # Gentoo specific configuration file for Apache2 self.apacheconfig_filep = "/etc/conf.d/apache2" super().__init__(*args, **kwargs) def update_runtime_variables(self): """ Override for update_runtime_variables for custom parsing """ self.parse_sysconfig_var() self.update_modules() def parse_sysconfig_var(self): """ Parses Apache CLI options from Gentoo configuration file """ defines = apache_util.parse_define_file(self.apacheconfig_filep, "APACHE2_OPTS") for k, v in defines.items(): self.variables[k] = v def update_modules(self): """Get loaded modules from httpd process, and add them to DOM""" mod_cmd = [self.configurator.options.ctl, "modules"] matches = apache_util.parse_from_subprocess(mod_cmd, r"(.*)_module") for mod in matches: self.add_mod(mod.strip()) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/certbot_apache/_internal/override_suse.py0000644000076500000240000000123600000000000023275 0ustar00bmwstaff""" Distribution specific override class for OpenSUSE """ from certbot_apache._internal import configurator from certbot_apache._internal.configurator import OsOptions class OpenSUSEConfigurator(configurator.ApacheConfigurator): """OpenSUSE specific ApacheConfigurator override class""" OS_DEFAULTS = OsOptions( vhost_root="/etc/apache2/vhosts.d", vhost_files="*.conf", ctl="apachectl", version_cmd=['apachectl', '-v'], restart_cmd=['apachectl', 'graceful'], conftest_cmd=['apachectl', 'configtest'], enmod="a2enmod", dismod="a2dismod", challenge_location="/etc/apache2/vhosts.d", ) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/certbot_apache/_internal/override_void.py0000644000076500000240000000125100000000000023254 0ustar00bmwstaff""" Distribution specific override class for Void Linux """ from certbot_apache._internal import configurator from certbot_apache._internal.configurator import OsOptions class VoidConfigurator(configurator.ApacheConfigurator): """Void Linux specific ApacheConfigurator override class""" OS_DEFAULTS = OsOptions( server_root="/etc/apache", vhost_root="/etc/apache/extra", vhost_files="*.conf", logs_root="/var/log/httpd", ctl="apachectl", version_cmd=['apachectl', '-v'], restart_cmd=['apachectl', 'graceful'], conftest_cmd=['apachectl', 'configtest'], challenge_location="/etc/apache/extra", ) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/certbot_apache/_internal/parser.py0000644000076500000240000010621500000000000021716 0ustar00bmwstaff"""ApacheParser is a member object of the ApacheConfigurator class.""" import copy import fnmatch import logging import re from typing import Dict from typing import List from typing import Optional from certbot import errors from certbot.compat import os from certbot_apache._internal import apache_util from certbot_apache._internal import constants try: from augeas import Augeas except ImportError: # pragma: no cover Augeas = None logger = logging.getLogger(__name__) class ApacheParser: """Class handles the fine details of parsing the Apache Configuration. .. todo:: Make parsing general... remove sites-available etc... :ivar str root: Normalized absolute path to the server root directory. Without trailing slash. :ivar set modules: All module names that are currently enabled. :ivar dict loc: Location to place directives, root - configuration origin, default - user config file, name - NameVirtualHost, """ arg_var_interpreter = re.compile(r"\$\{[^ \}]*}") fnmatch_chars = {"*", "?", "\\", "[", "]"} def __init__(self, root, vhostroot=None, version=(2, 4), configurator=None): # Note: Order is important here. # Needed for calling save() with reverter functionality that resides in # AugeasConfigurator superclass of ApacheConfigurator. This resolves # issues with aug.load() after adding new files / defines to parse tree self.configurator = configurator # Initialize augeas self.aug = init_augeas() if not self.check_aug_version(): raise errors.NotSupportedError( "Apache plugin support requires libaugeas0 and augeas-lenses " "version 1.2.0 or higher, please make sure you have you have " "those installed.") self.modules: Dict[str, Optional[str]] = {} self.parser_paths: Dict[str, List[str]] = {} self.variables: Dict[str, str] = {} # Find configuration root and make sure augeas can parse it. self.root = os.path.abspath(root) self.loc = {"root": self._find_config_root()} self.parse_file(self.loc["root"]) if version >= (2, 4): # Look up variables from httpd and add to DOM if not already parsed self.update_runtime_variables() # This problem has been fixed in Augeas 1.0 self.standardize_excl() # Parse LoadModule directives from configuration files self.parse_modules() # Set up rest of locations self.loc.update(self._set_locations()) # list of the active include paths, before modifications self.existing_paths = copy.deepcopy(self.parser_paths) # Must also attempt to parse additional virtual host root if vhostroot: self.parse_file(os.path.abspath(vhostroot) + "/" + self.configurator.options.vhost_files) # check to see if there were unparsed define statements if version < (2, 4): if self.find_dir("Define", exclude=False): raise errors.PluginError("Error parsing runtime variables") def check_parsing_errors(self, lens): """Verify Augeas can parse all of the lens files. :param str lens: lens to check for errors :raises .errors.PluginError: If there has been an error in parsing with the specified lens. """ error_files = self.aug.match("/augeas//error") for path in error_files: # Check to see if it was an error resulting from the use of # the httpd lens lens_path = self.aug.get(path + "/lens") # As aug.get may return null if lens_path and lens in lens_path: msg = ( "There has been an error in parsing the file {0} on line {1}: " "{2}".format( # Strip off /augeas/files and /error path[13:len(path) - 6], self.aug.get(path + "/line"), self.aug.get(path + "/message"))) raise errors.PluginError(msg) def check_aug_version(self): """ Checks that we have recent enough version of libaugeas. If augeas version is recent enough, it will support case insensitive regexp matching""" self.aug.set("/test/path/testing/arg", "aRgUMeNT") try: matches = self.aug.match( "/test//*[self::arg=~regexp('argument', 'i')]") except RuntimeError: self.aug.remove("/test/path") return False self.aug.remove("/test/path") return matches def unsaved_files(self): """Lists files that have modified Augeas DOM but the changes have not been written to the filesystem yet, used by `self.save()` and ApacheConfigurator to check the file state. :raises .errors.PluginError: If there was an error in Augeas, in an attempt to save the configuration, or an error creating a checkpoint :returns: `set` of unsaved files """ save_state = self.aug.get("/augeas/save") self.aug.set("/augeas/save", "noop") # Existing Errors ex_errs = self.aug.match("/augeas//error") try: # This is a noop save self.aug.save() except (RuntimeError, IOError): self._log_save_errors(ex_errs) # Erase Save Notes self.configurator.save_notes = "" raise errors.PluginError( "Error saving files, check logs for more info.") # Return the original save method self.aug.set("/augeas/save", save_state) # Retrieve list of modified files # Note: Noop saves can cause the file to be listed twice, I used a # set to remove this possibility. This is a known augeas 0.10 error. save_paths = self.aug.match("/augeas/events/saved") save_files = set() if save_paths: for path in save_paths: save_files.add(self.aug.get(path)[6:]) return save_files def ensure_augeas_state(self): """Makes sure that all Augeas dom changes are written to files to avoid loss of configuration directives when doing additional augeas parsing, causing a possible augeas.load() resulting dom reset """ if self.unsaved_files(): self.configurator.save_notes += "(autosave)" self.configurator.save() def save(self, save_files): """Saves all changes to the configuration files. save() is called from ApacheConfigurator to handle the parser specific tasks of saving. :param list save_files: list of strings of file paths that we need to save. """ self.configurator.save_notes = "" self.aug.save() # Force reload if files were modified # This is needed to recalculate augeas directive span if save_files: for sf in save_files: self.aug.remove("/files/"+sf) self.aug.load() def _log_save_errors(self, ex_errs): """Log errors due to bad Augeas save. :param list ex_errs: Existing errors before save """ # Check for the root of save problems new_errs = self.aug.match("/augeas//error") # logger.error("During Save - %s", mod_conf) logger.error("Unable to save files: %s. Attempted Save Notes: %s", ", ".join(err[13:len(err) - 6] for err in new_errs # Only new errors caused by recent save if err not in ex_errs), self.configurator.save_notes) def add_include(self, main_config, inc_path): """Add Include for a new configuration file if one does not exist :param str main_config: file path to main Apache config file :param str inc_path: path of file to include """ if not self.find_dir(case_i("Include"), inc_path): logger.debug("Adding Include %s to %s", inc_path, get_aug_path(main_config)) self.add_dir( get_aug_path(main_config), "Include", inc_path) # Add new path to parser paths new_dir = os.path.dirname(inc_path) new_file = os.path.basename(inc_path) self.existing_paths.setdefault(new_dir, []).append(new_file) def add_mod(self, mod_name): """Shortcut for updating parser modules.""" if mod_name + "_module" not in self.modules: self.modules[mod_name + "_module"] = None if "mod_" + mod_name + ".c" not in self.modules: self.modules["mod_" + mod_name + ".c"] = None def reset_modules(self): """Reset the loaded modules list. This is called from cleanup to clear temporarily loaded modules.""" self.modules = {} self.update_modules() self.parse_modules() def parse_modules(self): """Iterates on the configuration until no new modules are loaded. ..todo:: This should be attempted to be done with a binary to avoid the iteration issue. Else... parse and enable mods at same time. """ mods: Dict[str, str] = {} matches = self.find_dir("LoadModule") iterator = iter(matches) # Make sure prev_size != cur_size for do: while: iteration prev_size = -1 while len(mods) != prev_size: prev_size = len(mods) for match_name, match_filename in zip( iterator, iterator): mod_name = self.get_arg(match_name) mod_filename = self.get_arg(match_filename) if mod_name and mod_filename: mods[mod_name] = mod_filename mods[os.path.basename(mod_filename)[:-2] + "c"] = mod_filename else: logger.debug("Could not read LoadModule directive from Augeas path: %s", match_name[6:]) self.modules.update(mods) def update_runtime_variables(self): """Update Includes, Defines and Includes from httpd config dump data""" self.update_defines() self.update_includes() self.update_modules() def update_defines(self): """Updates the dictionary of known variables in the configuration""" self.variables = apache_util.parse_defines(self.configurator.options.ctl) def update_includes(self): """Get includes from httpd process, and add them to DOM if needed""" # Find_dir iterates over configuration for Include and IncludeOptional # directives to make sure we see the full include tree present in the # configuration files _ = self.find_dir("Include") matches = apache_util.parse_includes(self.configurator.options.ctl) if matches: for i in matches: if not self.parsed_in_current(i): self.parse_file(i) def update_modules(self): """Get loaded modules from httpd process, and add them to DOM""" matches = apache_util.parse_modules(self.configurator.options.ctl) for mod in matches: self.add_mod(mod.strip()) def filter_args_num(self, matches, args): """Filter out directives with specific number of arguments. This function makes the assumption that all related arguments are given in order. Thus /files/apache/directive[5]/arg[2] must come immediately after /files/apache/directive[5]/arg[1]. Runs in 1 linear pass. :param string matches: Matches of all directives with arg nodes :param int args: Number of args you would like to filter :returns: List of directives that contain # of arguments. (arg is stripped off) """ filtered = [] if args == 1: for i, match in enumerate(matches): if match.endswith("/arg"): filtered.append(matches[i][:-4]) else: for i, match in enumerate(matches): if match.endswith("/arg[%d]" % args): # Make sure we don't cause an IndexError (end of list) # Check to make sure arg + 1 doesn't exist if (i == (len(matches) - 1) or not matches[i + 1].endswith("/arg[%d]" % (args + 1))): filtered.append(matches[i][:-len("/arg[%d]" % args)]) return filtered def add_dir_to_ifmodssl(self, aug_conf_path, directive, args): """Adds directive and value to IfMod ssl block. Adds given directive and value along configuration path within an IfMod mod_ssl.c block. If the IfMod block does not exist in the file, it is created. :param str aug_conf_path: Desired Augeas config path to add directive :param str directive: Directive you would like to add, e.g. Listen :param args: Values of the directive; str "443" or list of str :type args: list """ # TODO: Add error checking code... does the path given even exist? # Does it throw exceptions? if_mod_path = self.get_ifmod(aug_conf_path, "mod_ssl.c") # IfModule can have only one valid argument, so append after self.aug.insert(if_mod_path + "arg", "directive", False) nvh_path = if_mod_path + "directive[1]" self.aug.set(nvh_path, directive) if len(args) == 1: self.aug.set(nvh_path + "/arg", args[0]) else: for i, arg in enumerate(args): self.aug.set("%s/arg[%d]" % (nvh_path, i + 1), arg) def get_ifmod(self, aug_conf_path, mod, beginning=False): """Returns the path to and creates one if it doesn't exist. :param str aug_conf_path: Augeas configuration path :param str mod: module ie. mod_ssl.c :param bool beginning: If the IfModule should be created to the beginning of augeas path DOM tree. :returns: Augeas path of the requested IfModule directive that pre-existed or was created during the process. The path may be dynamic, i.e. .../IfModule[last()] :rtype: str """ if_mods = self.aug.match(("%s/IfModule/*[self::arg='%s']" % (aug_conf_path, mod))) if not if_mods: return self.create_ifmod(aug_conf_path, mod, beginning) # Strip off "arg" at end of first ifmod path return if_mods[0].rpartition("arg")[0] def create_ifmod(self, aug_conf_path, mod, beginning=False): """Creates a new and returns its path. :param str aug_conf_path: Augeas configuration path :param str mod: module ie. mod_ssl.c :param bool beginning: If the IfModule should be created to the beginning of augeas path DOM tree. :returns: Augeas path of the newly created IfModule directive. The path may be dynamic, i.e. .../IfModule[last()] :rtype: str """ if beginning: c_path_arg = "{}/IfModule[1]/arg".format(aug_conf_path) # Insert IfModule before the first directive self.aug.insert("{}/directive[1]".format(aug_conf_path), "IfModule", True) retpath = "{}/IfModule[1]/".format(aug_conf_path) else: c_path = "{}/IfModule[last() + 1]".format(aug_conf_path) c_path_arg = "{}/IfModule[last()]/arg".format(aug_conf_path) self.aug.set(c_path, "") retpath = "{}/IfModule[last()]/".format(aug_conf_path) self.aug.set(c_path_arg, mod) return retpath def add_dir(self, aug_conf_path, directive, args): """Appends directive to the end fo the file given by aug_conf_path. .. note:: Not added to AugeasConfigurator because it may depend on the lens :param str aug_conf_path: Augeas configuration path to add directive :param str directive: Directive to add :param args: Value of the directive. ie. Listen 443, 443 is arg :type args: list or str """ self.aug.set(aug_conf_path + "/directive[last() + 1]", directive) if isinstance(args, list): for i, value in enumerate(args, 1): self.aug.set( "%s/directive[last()]/arg[%d]" % (aug_conf_path, i), value) else: self.aug.set(aug_conf_path + "/directive[last()]/arg", args) def add_dir_beginning(self, aug_conf_path, dirname, args): """Adds the directive to the beginning of defined aug_conf_path. :param str aug_conf_path: Augeas configuration path to add directive :param str dirname: Directive to add :param args: Value of the directive. ie. Listen 443, 443 is arg :type args: list or str """ first_dir = aug_conf_path + "/directive[1]" if self.aug.get(first_dir): self.aug.insert(first_dir, "directive", True) else: self.aug.set(first_dir, "directive") self.aug.set(first_dir, dirname) if isinstance(args, list): for i, value in enumerate(args, 1): self.aug.set(first_dir + "/arg[%d]" % (i), value) else: self.aug.set(first_dir + "/arg", args) def add_comment(self, aug_conf_path, comment): """Adds the comment to the augeas path :param str aug_conf_path: Augeas configuration path to add directive :param str comment: Comment content """ self.aug.set(aug_conf_path + "/#comment[last() + 1]", comment) def find_comments(self, arg, start=None): """Finds a comment with specified content from the provided DOM path :param str arg: Comment content to search :param str start: Beginning Augeas path to begin looking :returns: List of augeas paths containing the comment content :rtype: list """ if not start: start = get_aug_path(self.root) comments = self.aug.match("%s//*[label() = '#comment']" % start) results = [] for comment in comments: c_content = self.aug.get(comment) if c_content and arg in c_content: results.append(comment) return results def find_dir(self, directive, arg=None, start=None, exclude=True): """Finds directive in the configuration. Recursively searches through config files to find directives Directives should be in the form of a case insensitive regex currently .. todo:: arg should probably be a list .. todo:: arg search currently only supports direct matching. It does not handle the case of variables or quoted arguments. This should be adapted to use a generic search for the directive and then do a case-insensitive self.get_arg filter Note: Augeas is inherently case sensitive while Apache is case insensitive. Augeas 1.0 allows case insensitive regexes like regexp(/Listen/, "i"), however the version currently supported by Ubuntu 0.10 does not. Thus I have included my own case insensitive transformation by calling case_i() on everything to maintain compatibility. :param str directive: Directive to look for :param arg: Specific value directive must have, None if all should be considered :type arg: str or None :param str start: Beginning Augeas path to begin looking :param bool exclude: Whether or not to exclude directives based on variables and enabled modules """ # Cannot place member variable in the definition of the function so... if not start: start = get_aug_path(self.loc["root"]) # No regexp code # if arg is None: # matches = self.aug.match(start + # "//*[self::directive='" + directive + "']/arg") # else: # matches = self.aug.match(start + # "//*[self::directive='" + directive + # "']/* [self::arg='" + arg + "']") # includes = self.aug.match(start + # "//* [self::directive='Include']/* [label()='arg']") regex = "(%s)|(%s)|(%s)" % (case_i(directive), case_i("Include"), case_i("IncludeOptional")) matches = self.aug.match( "%s//*[self::directive=~regexp('%s')]" % (start, regex)) if exclude: matches = self.exclude_dirs(matches) if arg is None: arg_suffix = "/arg" else: arg_suffix = "/*[self::arg=~regexp('%s')]" % case_i(arg) ordered_matches: List[str] = [] # TODO: Wildcards should be included in alphabetical order # https://httpd.apache.org/docs/2.4/mod/core.html#include for match in matches: dir_ = self.aug.get(match).lower() if dir_ in ("include", "includeoptional"): ordered_matches.extend(self.find_dir( directive, arg, self._get_include_path(self.get_arg(match + "/arg")), exclude)) # This additionally allows Include if dir_ == directive.lower(): ordered_matches.extend(self.aug.match(match + arg_suffix)) return ordered_matches def get_all_args(self, match): """ Tries to fetch all arguments for a directive. See get_arg. Note that if match is an ancestor node, it returns all names of child directives as well as the list of arguments. """ if match[-1] != "/": match = match+"/" allargs = self.aug.match(match + '*') return [self.get_arg(arg) for arg in allargs] def get_arg(self, match): """Uses augeas.get to get argument value and interprets result. This also converts all variables and parameters appropriately. """ value = self.aug.get(match) # No need to strip quotes for variables, as apache2ctl already does # this, but we do need to strip quotes for all normal arguments. # Note: normal argument may be a quoted variable # e.g. strip now, not later if not value: return None value = value.strip("'\"") variables = ApacheParser.arg_var_interpreter.findall(value) for var in variables: # Strip off ${ and } try: value = value.replace(var, self.variables[var[2:-1]]) except KeyError: raise errors.PluginError("Error Parsing variable: %s" % var) return value def get_root_augpath(self): """ Returns the Augeas path of root configuration. """ return get_aug_path(self.loc["root"]) def exclude_dirs(self, matches): """Exclude directives that are not loaded into the configuration.""" filters = [("ifmodule", self.modules.keys()), ("ifdefine", self.variables)] valid_matches = [] for match in matches: for filter_ in filters: if not self._pass_filter(match, filter_): break else: valid_matches.append(match) return valid_matches def _pass_filter(self, match, filter_): """Determine if directive passes a filter. :param str match: Augeas path :param list filter: list of tuples of form [("lowercase if directive", set of relevant parameters)] """ match_l = match.lower() last_match_idx = match_l.find(filter_[0]) while last_match_idx != -1: # Check args end_of_if = match_l.find("/", last_match_idx) # This should be aug.get (vars are not used e.g. parser.aug_get) expression = self.aug.get(match[:end_of_if] + "/arg") if expression.startswith("!"): # Strip off "!" if expression[1:] in filter_[1]: return False else: if expression not in filter_[1]: return False last_match_idx = match_l.find(filter_[0], end_of_if) return True def standard_path_from_server_root(self, arg): """Ensure paths are consistent and absolute :param str arg: Argument of directive :returns: Standardized argument path :rtype: str """ # Remove beginning and ending quotes arg = arg.strip("'\"") # Standardize the include argument based on server root if not arg.startswith("/"): # Normpath will condense ../ arg = os.path.normpath(os.path.join(self.root, arg)) else: arg = os.path.normpath(arg) return arg def _get_include_path(self, arg): """Converts an Apache Include directive into Augeas path. Converts an Apache Include directive argument into an Augeas searchable path .. todo:: convert to use os.path.join() :param str arg: Argument of Include directive :returns: Augeas path string :rtype: str """ # Check to make sure only expected characters are used <- maybe remove # validChars = re.compile("[a-zA-Z0-9.*?_-/]*") # matchObj = validChars.match(arg) # if matchObj.group() != arg: # logger.error("Error: Invalid regexp characters in %s", arg) # return [] arg = self.standard_path_from_server_root(arg) # Attempts to add a transform to the file if one does not already exist if os.path.isdir(arg): self.parse_file(os.path.join(arg, "*")) else: self.parse_file(arg) # Argument represents an fnmatch regular expression, convert it # Split up the path and convert each into an Augeas accepted regex # then reassemble split_arg = arg.split("/") for idx, split in enumerate(split_arg): if any(char in ApacheParser.fnmatch_chars for char in split): # Turn it into an augeas regex # TODO: Can this instead be an augeas glob instead of regex split_arg[idx] = ("* [label()=~regexp('%s')]" % self.fnmatch_to_re(split)) # Reassemble the argument # Note: This also normalizes the argument /serverroot/ -> /serverroot arg = "/".join(split_arg) return get_aug_path(arg) def fnmatch_to_re(self, clean_fn_match): """Method converts Apache's basic fnmatch to regular expression. Assumption - Configs are assumed to be well-formed and only writable by privileged users. https://apr.apache.org/docs/apr/2.0/apr__fnmatch_8h_source.html :param str clean_fn_match: Apache style filename match, like globs :returns: regex suitable for augeas :rtype: str """ # Since Python 3.6, it returns a different pattern like (?s:.*\.load)\Z return fnmatch.translate(clean_fn_match)[4:-3] # pragma: no cover def parse_file(self, filepath): """Parse file with Augeas Checks to see if file_path is parsed by Augeas If filepath isn't parsed, the file is added and Augeas is reloaded :param str filepath: Apache config file path """ use_new, remove_old = self._check_path_actions(filepath) # Ensure that we have the latest Augeas DOM state on disk before # calling aug.load() which reloads the state from disk self.ensure_augeas_state() # Test if augeas included file for Httpd.lens # Note: This works for augeas globs, ie. *.conf if use_new: inc_test = self.aug.match( "/augeas/load/Httpd['%s' =~ glob(incl)]" % filepath) if not inc_test: # Load up files # This doesn't seem to work on TravisCI # self.aug.add_transform("Httpd.lns", [filepath]) if remove_old: self._remove_httpd_transform(filepath) self._add_httpd_transform(filepath) self.aug.load() def parsed_in_current(self, filep): """Checks if the file path is parsed by current Augeas parser config ie. returns True if the file is found on a path that's found in live Augeas configuration. :param str filep: Path to match :returns: True if file is parsed in existing configuration tree :rtype: bool """ return self._parsed_by_parser_paths(filep, self.parser_paths) def parsed_in_original(self, filep): """Checks if the file path is parsed by existing Apache config. ie. returns True if the file is found on a path that matches Include or IncludeOptional statement in the Apache configuration. :param str filep: Path to match :returns: True if file is parsed in existing configuration tree :rtype: bool """ return self._parsed_by_parser_paths(filep, self.existing_paths) def _parsed_by_parser_paths(self, filep, paths): """Helper function that searches through provided paths and returns True if file path is found in the set""" for directory in paths: for filename in paths[directory]: if fnmatch.fnmatch(filep, os.path.join(directory, filename)): return True return False def _check_path_actions(self, filepath): """Determine actions to take with a new augeas path This helper function will return a tuple that defines if we should try to append the new filepath to augeas parser paths, and / or remove the old one with more narrow matching. :param str filepath: filepath to check the actions for """ try: new_file_match = os.path.basename(filepath) existing_matches = self.parser_paths[os.path.dirname(filepath)] if "*" in existing_matches: use_new = False else: use_new = True remove_old = new_file_match == "*" except KeyError: use_new = True remove_old = False return use_new, remove_old def _remove_httpd_transform(self, filepath): """Remove path from Augeas transform :param str filepath: filepath to remove """ remove_basenames = self.parser_paths[os.path.dirname(filepath)] remove_dirname = os.path.dirname(filepath) for name in remove_basenames: remove_path = remove_dirname + "/" + name remove_inc = self.aug.match( "/augeas/load/Httpd/incl [. ='%s']" % remove_path) self.aug.remove(remove_inc[0]) self.parser_paths.pop(remove_dirname) def _add_httpd_transform(self, incl): """Add a transform to Augeas. This function will correctly add a transform to augeas The existing augeas.add_transform in python doesn't seem to work for Travis CI as it loads in libaugeas.so.0.10.0 :param str incl: filepath to include for transform """ last_include = self.aug.match("/augeas/load/Httpd/incl [last()]") if last_include: # Insert a new node immediately after the last incl self.aug.insert(last_include[0], "incl", False) self.aug.set("/augeas/load/Httpd/incl[last()]", incl) # On first use... must load lens and add file to incl else: # Augeas uses base 1 indexing... insert at beginning... self.aug.set("/augeas/load/Httpd/lens", "Httpd.lns") self.aug.set("/augeas/load/Httpd/incl", incl) # Add included path to paths dictionary try: self.parser_paths[os.path.dirname(incl)].append( os.path.basename(incl)) except KeyError: self.parser_paths[os.path.dirname(incl)] = [ os.path.basename(incl)] def standardize_excl(self): """Standardize the excl arguments for the Httpd lens in Augeas. Note: Hack! Standardize the excl arguments for the Httpd lens in Augeas Servers sometimes give incorrect defaults Note: This problem should be fixed in Augeas 1.0. Unfortunately, Augeas 0.10 appears to be the most popular version currently. """ # attempt to protect against augeas error in 0.10.0 - ubuntu # *.augsave -> /*.augsave upon augeas.load() # Try to avoid bad httpd files # There has to be a better way... but after a day and a half of testing # I had no luck # This is a hack... work around... submit to augeas if still not fixed excl = ["*.augnew", "*.augsave", "*.dpkg-dist", "*.dpkg-bak", "*.dpkg-new", "*.dpkg-old", "*.rpmsave", "*.rpmnew", "*~", self.root + "/*.augsave", self.root + "/*~", self.root + "/*/*augsave", self.root + "/*/*~", self.root + "/*/*/*.augsave", self.root + "/*/*/*~"] for i, excluded in enumerate(excl, 1): self.aug.set("/augeas/load/Httpd/excl[%d]" % i, excluded) self.aug.load() def _set_locations(self): """Set default location for directives. Locations are given as file_paths .. todo:: Make sure that files are included """ default = self.loc["root"] temp = os.path.join(self.root, "ports.conf") if os.path.isfile(temp): listen = temp name = temp else: listen = default name = default return {"default": default, "listen": listen, "name": name} def _find_config_root(self): """Find the Apache Configuration Root file.""" location = ["apache2.conf", "httpd.conf", "conf/httpd.conf"] for name in location: if os.path.isfile(os.path.join(self.root, name)): return os.path.join(self.root, name) raise errors.NoInstallationError("Could not find configuration root") def case_i(string): """Returns case insensitive regex. Returns a sloppy, but necessary version of a case insensitive regex. Any string should be able to be submitted and the string is escaped and then made case insensitive. May be replaced by a more proper /i once augeas 1.0 is widely supported. :param str string: string to make case i regex """ return "".join("[" + c.upper() + c.lower() + "]" if c.isalpha() else c for c in re.escape(string)) def get_aug_path(file_path): """Return augeas path for full filepath. :param str file_path: Full filepath """ return "/files%s" % file_path def init_augeas() -> Augeas: """ Initialize the actual Augeas instance """ if not Augeas: # pragma: no cover raise errors.NoInstallationError("Problem in Augeas installation") return Augeas( # specify a directory to load our preferred lens from loadpath=constants.AUGEAS_LENS_DIR, # Do not save backup (we do it ourselves), do not load # anything by default flags=(Augeas.NONE | Augeas.NO_MODL_AUTOLOAD | Augeas.ENABLE_SPAN)) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/certbot_apache/_internal/parsernode_util.py0000644000076500000240000001226600000000000023623 0ustar00bmwstaff"""ParserNode utils""" def validate_kwargs(kwargs, required_names): """ Ensures that the kwargs dict has all the expected values. This function modifies the kwargs dictionary, and hence the returned dictionary should be used instead in the caller function instead of the original kwargs. :param dict kwargs: Dictionary of keyword arguments to validate. :param list required_names: List of required parameter names. """ validated_kwargs = {} for name in required_names: try: validated_kwargs[name] = kwargs.pop(name) except KeyError: raise TypeError("Required keyword argument: {} undefined.".format(name)) # Raise exception if unknown key word arguments are found. if kwargs: unknown = ", ".join(kwargs.keys()) raise TypeError("Unknown keyword argument(s): {}".format(unknown)) return validated_kwargs def parsernode_kwargs(kwargs): """ Validates keyword arguments for ParserNode. This function modifies the kwargs dictionary, and hence the returned dictionary should be used instead in the caller function instead of the original kwargs. If metadata is provided, the otherwise required argument "filepath" may be omitted if the implementation is able to extract its value from the metadata. This usecase is handled within this function. Filepath defaults to None. :param dict kwargs: Keyword argument dictionary to validate. :returns: Tuple of validated and prepared arguments. """ # As many values of ParserNode instances can be derived from the metadata, # (ancestor being a common exception here) make sure we permit it here as well. if "metadata" in kwargs: # Filepath can be derived from the metadata in Augeas implementation. # Default is None, as in this case the responsibility of populating this # variable lies on the implementation. kwargs.setdefault("filepath", None) kwargs.setdefault("dirty", False) kwargs.setdefault("metadata", {}) kwargs = validate_kwargs(kwargs, ["ancestor", "dirty", "filepath", "metadata"]) return kwargs["ancestor"], kwargs["dirty"], kwargs["filepath"], kwargs["metadata"] def commentnode_kwargs(kwargs): """ Validates keyword arguments for CommentNode and sets the default values for optional kwargs. This function modifies the kwargs dictionary, and hence the returned dictionary should be used instead in the caller function instead of the original kwargs. If metadata is provided, the otherwise required argument "comment" may be omitted if the implementation is able to extract its value from the metadata. This usecase is handled within this function. :param dict kwargs: Keyword argument dictionary to validate. :returns: Tuple of validated and prepared arguments and ParserNode kwargs. """ # As many values of ParserNode instances can be derived from the metadata, # (ancestor being a common exception here) make sure we permit it here as well. if "metadata" in kwargs: kwargs.setdefault("comment", None) # Filepath can be derived from the metadata in Augeas implementation. # Default is None, as in this case the responsibility of populating this # variable lies on the implementation. kwargs.setdefault("filepath", None) kwargs.setdefault("dirty", False) kwargs.setdefault("metadata", {}) kwargs = validate_kwargs(kwargs, ["ancestor", "dirty", "filepath", "comment", "metadata"]) comment = kwargs.pop("comment") return comment, kwargs def directivenode_kwargs(kwargs): """ Validates keyword arguments for DirectiveNode and BlockNode and sets the default values for optional kwargs. This function modifies the kwargs dictionary, and hence the returned dictionary should be used instead in the caller function instead of the original kwargs. If metadata is provided, the otherwise required argument "name" may be omitted if the implementation is able to extract its value from the metadata. This usecase is handled within this function. :param dict kwargs: Keyword argument dictionary to validate. :returns: Tuple of validated and prepared arguments and ParserNode kwargs. """ # As many values of ParserNode instances can be derived from the metadata, # (ancestor being a common exception here) make sure we permit it here as well. if "metadata" in kwargs: kwargs.setdefault("name", None) # Filepath can be derived from the metadata in Augeas implementation. # Default is None, as in this case the responsibility of populating this # variable lies on the implementation. kwargs.setdefault("filepath", None) kwargs.setdefault("dirty", False) kwargs.setdefault("enabled", True) kwargs.setdefault("parameters", ()) kwargs.setdefault("metadata", {}) kwargs = validate_kwargs(kwargs, ["ancestor", "dirty", "filepath", "name", "parameters", "enabled", "metadata"]) name = kwargs.pop("name") parameters = kwargs.pop("parameters") enabled = kwargs.pop("enabled") return name, parameters, enabled, kwargs ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.7956157 certbot-apache-1.21.0/certbot_apache/_internal/tls_configs/0000755000076500000240000000000000000000000022355 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/certbot_apache/_internal/tls_configs/current-options-ssl-apache.conf0000644000076500000240000000167000000000000030421 0ustar00bmwstaff# This file contains important security parameters. If you modify this file # manually, Certbot will be unable to automatically provide future security # updates. Instead, Certbot will print and log an error message with a path to # the up-to-date file that you will need to refer to when manually updating # this file. SSLEngine on # Intermediate configuration, tweak to your needs SSLProtocol all -SSLv2 -SSLv3 -TLSv1 -TLSv1.1 SSLCipherSuite ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384 SSLHonorCipherOrder off SSLSessionTickets off SSLOptions +StrictRequire # Add vhost name to log entries: LogFormat "%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-agent}i\"" vhost_combined LogFormat "%v %h %l %u %t \"%r\" %>s %b" vhost_common ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/certbot_apache/_internal/tls_configs/old-options-ssl-apache.conf0000644000076500000240000000163400000000000027515 0ustar00bmwstaff# This file contains important security parameters. If you modify this file # manually, Certbot will be unable to automatically provide future security # updates. Instead, Certbot will print and log an error message with a path to # the up-to-date file that you will need to refer to when manually updating # this file. SSLEngine on # Intermediate configuration, tweak to your needs SSLProtocol all -SSLv2 -SSLv3 -TLSv1 -TLSv1.1 SSLCipherSuite ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384 SSLHonorCipherOrder off SSLOptions +StrictRequire # Add vhost name to log entries: LogFormat "%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-agent}i\"" vhost_combined LogFormat "%v %h %l %u %t \"%r\" %>s %b" vhost_common ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.7923636 certbot-apache-1.21.0/certbot_apache.egg-info/0000755000076500000240000000000000000000000017562 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888463.0 certbot-apache-1.21.0/certbot_apache.egg-info/PKG-INFO0000644000076500000240000000214700000000000020663 0ustar00bmwstaffMetadata-Version: 2.1 Name: certbot-apache Version: 1.21.0 Summary: Apache plugin for Certbot Home-page: https://github.com/letsencrypt/letsencrypt Author: Certbot Project Author-email: certbot-dev@eff.org License: Apache License 2.0 Platform: UNKNOWN Classifier: Development Status :: 5 - Production/Stable Classifier: Environment :: Plugins Classifier: Intended Audience :: System Administrators Classifier: License :: OSI Approved :: Apache Software License Classifier: Operating System :: POSIX :: Linux Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.6 Classifier: Programming Language :: Python :: 3.7 Classifier: Programming Language :: Python :: 3.8 Classifier: Programming Language :: Python :: 3.9 Classifier: Topic :: Internet :: WWW/HTTP Classifier: Topic :: Security Classifier: Topic :: System :: Installation/Setup Classifier: Topic :: System :: Networking Classifier: Topic :: System :: Systems Administration Classifier: Topic :: Utilities Requires-Python: >=3.6 Provides-Extra: dev License-File: LICENSE.txt UNKNOWN ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888463.0 certbot-apache-1.21.0/certbot_apache.egg-info/SOURCES.txt0000644000076500000240000003505200000000000021453 0ustar00bmwstaffLICENSE.txt MANIFEST.in README.rst setup.cfg setup.py certbot_apache/__init__.py certbot_apache.egg-info/PKG-INFO certbot_apache.egg-info/SOURCES.txt certbot_apache.egg-info/dependency_links.txt certbot_apache.egg-info/entry_points.txt certbot_apache.egg-info/requires.txt certbot_apache.egg-info/top_level.txt certbot_apache/_internal/__init__.py certbot_apache/_internal/apache_util.py certbot_apache/_internal/apacheparser.py certbot_apache/_internal/assertions.py certbot_apache/_internal/augeasparser.py certbot_apache/_internal/configurator.py certbot_apache/_internal/constants.py certbot_apache/_internal/display_ops.py certbot_apache/_internal/dualparser.py certbot_apache/_internal/entrypoint.py certbot_apache/_internal/http_01.py certbot_apache/_internal/interfaces.py certbot_apache/_internal/obj.py certbot_apache/_internal/override_arch.py certbot_apache/_internal/override_centos.py certbot_apache/_internal/override_darwin.py certbot_apache/_internal/override_debian.py certbot_apache/_internal/override_fedora.py certbot_apache/_internal/override_gentoo.py certbot_apache/_internal/override_suse.py certbot_apache/_internal/override_void.py certbot_apache/_internal/parser.py certbot_apache/_internal/parsernode_util.py certbot_apache/_internal/augeas_lens/httpd.aug certbot_apache/_internal/tls_configs/current-options-ssl-apache.conf certbot_apache/_internal/tls_configs/old-options-ssl-apache.conf tests/augeasnode_test.py tests/autohsts_test.py tests/centos6_test.py tests/centos_test.py tests/complex_parsing_test.py tests/configurator_reverter_test.py tests/configurator_test.py tests/debian_test.py tests/display_ops_test.py tests/dualnode_test.py tests/entrypoint_test.py tests/fedora_test.py tests/gentoo_test.py tests/http_01_test.py tests/obj_test.py tests/parser_test.py tests/parsernode_configurator_test.py tests/parsernode_test.py tests/parsernode_util_test.py tests/util.py tests/apache-conf-files/NEEDED.txt tests/apache-conf-files/apache-conf-test tests/apache-conf-files/apache-conf-test-pebble.py tests/apache-conf-files/failing/missing-double-quote-1724.conf tests/apache-conf-files/failing/multivhost-1093.conf tests/apache-conf-files/failing/multivhost-1093b.conf tests/apache-conf-files/passing/1626-1531.conf tests/apache-conf-files/passing/README.modules tests/apache-conf-files/passing/anarcat-1531.conf tests/apache-conf-files/passing/comment-continuations-2050.conf tests/apache-conf-files/passing/drupal-errordocument-arg-1724.conf tests/apache-conf-files/passing/drupal-htaccess-1531.conf tests/apache-conf-files/passing/escaped-space-arguments-2735.conf tests/apache-conf-files/passing/example-1755.conf tests/apache-conf-files/passing/example-ssl.conf tests/apache-conf-files/passing/example.conf tests/apache-conf-files/passing/finalize-1243.apache2.conf.txt tests/apache-conf-files/passing/finalize-1243.conf tests/apache-conf-files/passing/graphite-quote-1934.conf tests/apache-conf-files/passing/ipv6-1143.conf tests/apache-conf-files/passing/ipv6-1143b.conf tests/apache-conf-files/passing/ipv6-1143c.conf tests/apache-conf-files/passing/ipv6-1143d.conf tests/apache-conf-files/passing/missing-quote-1724.conf tests/apache-conf-files/passing/modmacro-1385.conf tests/apache-conf-files/passing/owncloud-1264.conf tests/apache-conf-files/passing/rewrite-quote-1960.conf tests/apache-conf-files/passing/roundcube-1222.conf tests/apache-conf-files/passing/section-continuations-2525.conf tests/apache-conf-files/passing/section-empty-continuations-2731.conf tests/apache-conf-files/passing/semacode-1598.conf tests/apache-conf-files/passing/sslrequire-wordlist-1827.htaccess tests/apache-conf-files/passing/two-blocks-one-line-1693.conf tests/testdata/centos6_apache/apache/httpd/conf/httpd.conf tests/testdata/centos6_apache/apache/httpd/conf.d/README tests/testdata/centos6_apache/apache/httpd/conf.d/ssl.conf tests/testdata/centos6_apache/apache/httpd/conf.d/test.example.com.conf tests/testdata/centos6_apache/apache/httpd/conf.d/welcome.conf tests/testdata/centos7_apache/apache/sites tests/testdata/centos7_apache/apache/httpd/conf/httpd.conf tests/testdata/centos7_apache/apache/httpd/conf/magic tests/testdata/centos7_apache/apache/httpd/conf.d/README tests/testdata/centos7_apache/apache/httpd/conf.d/autoindex.conf tests/testdata/centos7_apache/apache/httpd/conf.d/centos.example.com.conf tests/testdata/centos7_apache/apache/httpd/conf.d/ssl.conf tests/testdata/centos7_apache/apache/httpd/conf.d/userdir.conf tests/testdata/centos7_apache/apache/httpd/conf.d/welcome.conf tests/testdata/centos7_apache/apache/httpd/conf.modules.d/00-base.conf tests/testdata/centos7_apache/apache/httpd/conf.modules.d/00-dav.conf tests/testdata/centos7_apache/apache/httpd/conf.modules.d/00-lua.conf tests/testdata/centos7_apache/apache/httpd/conf.modules.d/00-mpm.conf tests/testdata/centos7_apache/apache/httpd/conf.modules.d/00-proxy.conf tests/testdata/centos7_apache/apache/httpd/conf.modules.d/00-ssl.conf tests/testdata/centos7_apache/apache/httpd/conf.modules.d/00-systemd.conf tests/testdata/centos7_apache/apache/httpd/conf.modules.d/01-cgi.conf tests/testdata/centos7_apache/apache/sysconfig/httpd tests/testdata/complex_parsing/apache2.conf tests/testdata/complex_parsing/test_fnmatch.conf tests/testdata/complex_parsing/test_variables.conf tests/testdata/complex_parsing/conf-enabled/dummy.conf tests/testdata/debian_apache_2_4/augeas_vhosts/sites tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/apache2.conf tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/envvars tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/ports.conf tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/conf-available/bad_conf_file.conf tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/conf-available/other-vhosts-access-log.conf tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/conf-available/security.conf tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/conf-available/serve-cgi-bin.conf tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/conf-enabled/other-vhosts-access-log.conf tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/conf-enabled/security.conf tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/conf-enabled/serve-cgi-bin.conf tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/mods-available/authz_svn.load tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/mods-available/dav.load tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/mods-available/dav_svn.conf tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/mods-available/dav_svn.load tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/mods-available/rewrite.load tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/mods-available/ssl.conf tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/mods-available/ssl.load tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/mods-enabled/authz_svn.load tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/mods-enabled/dav.load tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/mods-enabled/dav_svn.conf tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/mods-enabled/dav_svn.load tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/sites-available/another_wildcard.conf tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/sites-available/old-and-default.conf tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/sites-available/wildcard.conf tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/sites-enabled/another_wildcard.conf tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/sites-enabled/old-and-default.conf tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/sites-enabled/wildcard.conf tests/testdata/debian_apache_2_4/default_vhost/sites tests/testdata/debian_apache_2_4/default_vhost/apache2/apache2.conf tests/testdata/debian_apache_2_4/default_vhost/apache2/envvars tests/testdata/debian_apache_2_4/default_vhost/apache2/ports.conf tests/testdata/debian_apache_2_4/default_vhost/apache2/conf-available/other-vhosts-access-log.conf tests/testdata/debian_apache_2_4/default_vhost/apache2/conf-available/security.conf tests/testdata/debian_apache_2_4/default_vhost/apache2/conf-available/serve-cgi-bin.conf tests/testdata/debian_apache_2_4/default_vhost/apache2/conf-enabled/other-vhosts-access-log.conf tests/testdata/debian_apache_2_4/default_vhost/apache2/conf-enabled/security.conf tests/testdata/debian_apache_2_4/default_vhost/apache2/conf-enabled/serve-cgi-bin.conf tests/testdata/debian_apache_2_4/default_vhost/apache2/mods-available/ssl.conf tests/testdata/debian_apache_2_4/default_vhost/apache2/mods-available/ssl.load tests/testdata/debian_apache_2_4/default_vhost/apache2/sites-available/000-default.conf tests/testdata/debian_apache_2_4/default_vhost/apache2/sites-available/default-ssl.conf tests/testdata/debian_apache_2_4/default_vhost/apache2/sites-enabled/000-default.conf tests/testdata/debian_apache_2_4/multi_vhosts/apache2/apache2.conf tests/testdata/debian_apache_2_4/multi_vhosts/apache2/envvars tests/testdata/debian_apache_2_4/multi_vhosts/apache2/ports.conf tests/testdata/debian_apache_2_4/multi_vhosts/apache2/sites-available/default.conf tests/testdata/debian_apache_2_4/multi_vhosts/apache2/sites-available/multi-vhost.conf tests/testdata/debian_apache_2_4/multi_vhosts/apache2/sites-enabled/default.conf tests/testdata/debian_apache_2_4/multi_vhosts/apache2/sites-enabled/multi-vhost.conf tests/testdata/debian_apache_2_4/multiple_vhosts/sites tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/apache2.conf tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/envvars tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/ports.conf tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/conf-available/bad_conf_file.conf tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/conf-available/other-vhosts-access-log.conf tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/conf-available/security.conf tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/conf-available/serve-cgi-bin.conf tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/conf-enabled/other-vhosts-access-log.conf tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/conf-enabled/security.conf tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/conf-enabled/serve-cgi-bin.conf tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/mods-available/authz_svn.load tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/mods-available/dav.load tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/mods-available/dav_svn.conf tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/mods-available/dav_svn.load tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/mods-available/rewrite.load tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/mods-available/ssl.conf tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/mods-available/ssl.load tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/mods-enabled/authz_svn.load tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/mods-enabled/dav.load tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/mods-enabled/dav_svn.conf tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/mods-enabled/dav_svn.load tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-available/000-default.conf tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-available/certbot.conf tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-available/default-ssl-port-only.conf tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-available/default-ssl.conf tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-available/duplicatehttp.conf tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-available/duplicatehttps.conf tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-available/empty.conf tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-available/encryption-example.conf tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-available/mod_macro-example.conf tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-available/no-directives.conf tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-available/ocsp-ssl.conf tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-available/wildcard.conf tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-enabled/000-default.conf tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-enabled/certbot.conf tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-enabled/default-ssl-port-only.conf tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-enabled/default-ssl.conf tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-enabled/duplicatehttp.conf tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-enabled/duplicatehttps.conf tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-enabled/encryption-example.conf tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-enabled/mod_macro-example.conf tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-enabled/non-symlink.conf tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-enabled/ocsp-ssl.conf tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-enabled/wildcard.conf tests/testdata/gentoo_apache/apache/sites tests/testdata/gentoo_apache/apache/apache2/httpd.conf tests/testdata/gentoo_apache/apache/apache2/magic tests/testdata/gentoo_apache/apache/apache2/modules.d/00_default_settings.conf tests/testdata/gentoo_apache/apache/apache2/modules.d/00_error_documents.conf tests/testdata/gentoo_apache/apache/apache2/modules.d/00_languages.conf tests/testdata/gentoo_apache/apache/apache2/modules.d/00_mod_autoindex.conf tests/testdata/gentoo_apache/apache/apache2/modules.d/00_mod_info.conf tests/testdata/gentoo_apache/apache/apache2/modules.d/00_mod_log_config.conf tests/testdata/gentoo_apache/apache/apache2/modules.d/00_mod_mime.conf tests/testdata/gentoo_apache/apache/apache2/modules.d/00_mod_status.conf tests/testdata/gentoo_apache/apache/apache2/modules.d/00_mod_userdir.conf tests/testdata/gentoo_apache/apache/apache2/modules.d/00_mpm.conf tests/testdata/gentoo_apache/apache/apache2/modules.d/10_mod_mem_cache.conf tests/testdata/gentoo_apache/apache/apache2/modules.d/40_mod_ssl.conf tests/testdata/gentoo_apache/apache/apache2/modules.d/41_mod_http2.conf tests/testdata/gentoo_apache/apache/apache2/modules.d/45_mod_dav.conf tests/testdata/gentoo_apache/apache/apache2/modules.d/46_mod_ldap.conf tests/testdata/gentoo_apache/apache/apache2/vhosts.d/00_default_ssl_vhost.conf tests/testdata/gentoo_apache/apache/apache2/vhosts.d/00_default_vhost.conf tests/testdata/gentoo_apache/apache/apache2/vhosts.d/default_vhost.include tests/testdata/gentoo_apache/apache/apache2/vhosts.d/gentoo.example.com.conf tests/testdata/gentoo_apache/apache/conf.d/apache2././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888463.0 certbot-apache-1.21.0/certbot_apache.egg-info/dependency_links.txt0000644000076500000240000000000100000000000023630 0ustar00bmwstaff ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888463.0 certbot-apache-1.21.0/certbot_apache.egg-info/entry_points.txt0000644000076500000240000000011300000000000023053 0ustar00bmwstaff[certbot.plugins] apache = certbot_apache._internal.entrypoint:ENTRYPOINT ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888463.0 certbot-apache-1.21.0/certbot_apache.egg-info/requires.txt0000644000076500000240000000013100000000000022155 0ustar00bmwstaffacme>=1.21.0 certbot>=1.21.0 python-augeas setuptools>=39.0.1 [dev] apacheconfig>=0.3.2 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888463.0 certbot-apache-1.21.0/certbot_apache.egg-info/top_level.txt0000644000076500000240000000001700000000000022312 0ustar00bmwstaffcertbot_apache ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.8191502 certbot-apache-1.21.0/setup.cfg0000644000076500000240000000010300000000000014740 0ustar00bmwstaff[bdist_wheel] universal = 1 [egg_info] tag_build = tag_date = 0 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888439.0 certbot-apache-1.21.0/setup.py0000644000076500000240000000343200000000000014641 0ustar00bmwstafffrom setuptools import find_packages from setuptools import setup version = '1.21.0' install_requires = [ # We specify the minimum acme and certbot version as the current plugin # version for simplicity. See # https://github.com/certbot/certbot/issues/8761 for more info. f'acme>={version}', f'certbot>={version}', 'python-augeas', 'setuptools>=39.0.1', ] dev_extras = [ 'apacheconfig>=0.3.2', ] setup( name='certbot-apache', version=version, description="Apache plugin for Certbot", url='https://github.com/letsencrypt/letsencrypt', author="Certbot Project", author_email='certbot-dev@eff.org', license='Apache License 2.0', python_requires='>=3.6', classifiers=[ 'Development Status :: 5 - Production/Stable', 'Environment :: Plugins', 'Intended Audience :: System Administrators', 'License :: OSI Approved :: Apache Software License', 'Operating System :: POSIX :: Linux', 'Programming Language :: Python', 'Programming Language :: Python :: 3', 'Programming Language :: Python :: 3.6', 'Programming Language :: Python :: 3.7', 'Programming Language :: Python :: 3.8', 'Programming Language :: Python :: 3.9', 'Topic :: Internet :: WWW/HTTP', 'Topic :: Security', 'Topic :: System :: Installation/Setup', 'Topic :: System :: Networking', 'Topic :: System :: Systems Administration', 'Topic :: Utilities', ], packages=find_packages(), include_package_data=True, install_requires=install_requires, extras_require={ 'dev': dev_extras, }, entry_points={ 'certbot.plugins': [ 'apache = certbot_apache._internal.entrypoint:ENTRYPOINT', ], }, ) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.7979543 certbot-apache-1.21.0/tests/0000755000076500000240000000000000000000000014267 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.7982986 certbot-apache-1.21.0/tests/apache-conf-files/0000755000076500000240000000000000000000000017533 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/apache-conf-files/NEEDED.txt0000644000076500000240000000030300000000000021214 0ustar00bmwstaffIssues for which some kind of test case should be constructable, but we do not currently have one: https://github.com/certbot/certbot/issues/1213 https://github.com/certbot/certbot/issues/1602 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/apache-conf-files/apache-conf-test0000755000076500000240000000461700000000000022612 0ustar00bmwstaff#!/bin/bash # A hackish script to see if the client is behaving as expected # with each of the "passing" conf files. if [ -z "$SERVER" ]; then echo "Please set SERVER to the ACME server's directory URL." exit 1 fi export EA=/etc/apache2/ TESTDIR="`dirname $0`" cd $TESTDIR/passing function CleanupExit() { echo control c, exiting tests... if [ "$f" != "" ] ; then Cleanup fi exit 1 } function Setup() { if [ "$APPEND_APACHECONF" = "" ] ; then sudo cp "$f" "$EA"/sites-available/ sudo ln -sf "$EA/sites-available/$f" "$EA/sites-enabled/$f" echo " ServerName example.com DocumentRoot /tmp/ ErrorLog /tmp/error.log CustomLog /tmp/requests.log combined " | sudo tee $EA/sites-available/throwaway-example.conf >/dev/null sudo ln -sf $EA/sites-available/throwaway-example.conf $EA/sites-enabled/throwaway-example.conf else TMP="/tmp/`basename \"$APPEND_APACHECONF\"`.$$" sudo cp -a "$APPEND_APACHECONF" "$TMP" sudo bash -c "cat \"$f\" >> \"$APPEND_APACHECONF\"" fi } function Cleanup() { if [ "$APPEND_APACHECONF" = "" ] ; then sudo rm /etc/apache2/sites-{enabled,available}/"$f" sudo rm $EA/sites-available/throwaway-example.conf sudo rm $EA/sites-enabled/throwaway-example.conf else sudo mv "$TMP" "$APPEND_APACHECONF" fi } # if our environment asks us to enable modules, do our best! if [ "$1" = --debian-modules ] ; then sudo apt-get install -y apache2 sudo apt-get install -y libapache2-mod-wsgi-py3 sudo apt-get install -y libapache2-mod-macro for mod in ssl rewrite macro wsgi deflate userdir version mime setenvif ; do echo -n enabling $mod sudo a2enmod $mod done fi CERTBOT_CMD="sudo $(command -v certbot) --server $SERVER -vvvv" CERTBOT_CMD="$CERTBOT_CMD --debug --apache --register-unsafely-without-email" CERTBOT_CMD="$CERTBOT_CMD --agree-tos certonly -t --no-verify-ssl" FAILS=0 trap CleanupExit INT for f in *.conf ; do echo -n testing "$f"... Setup RESULT=`echo c | $CERTBOT_CMD 2>&1` if echo $RESULT | grep -Eq \("Which names would you like"\|"mod_macro is not yet"\) ; then echo passed else echo failed echo $RESULT echo echo FAILS=`expr $FAILS + 1` fi Cleanup done if [ "$FAILS" -ne 0 ] ; then exit 1 fi exit 0 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/apache-conf-files/apache-conf-test-pebble.py0000755000076500000240000000142100000000000024456 0ustar00bmwstaff#!/usr/bin/env python """ This executable script wraps the apache-conf-test bash script, in order to setup a pebble instance before its execution. Directory URL is passed through the SERVER environment variable. """ import os import subprocess import sys from certbot_integration_tests.utils import acme_server SCRIPT_DIRNAME = os.path.dirname(__file__) def main(args=None): if not args: args = sys.argv[1:] with acme_server.ACMEServer('pebble', [], False) as acme_xdist: environ = os.environ.copy() environ['SERVER'] = acme_xdist['directory_url'] command = [os.path.join(SCRIPT_DIRNAME, 'apache-conf-test')] command.extend(args) return subprocess.call(command, env=environ) if __name__ == '__main__': sys.exit(main()) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.7986472 certbot-apache-1.21.0/tests/apache-conf-files/failing/0000755000076500000240000000000000000000000021144 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/apache-conf-files/failing/missing-double-quote-1724.conf0000644000076500000240000000334700000000000026471 0ustar00bmwstaff ServerAdmin webmaster@localhost ServerAlias www.example.com ServerName example.com DocumentRoot /var/www/example.com/www/ SSLEngine on SSLProtocol all -SSLv2 -SSLv3 SSLCipherSuite "EECDH+ECDSA+AESGCM EECDH+aRSA+AESGCM EECDH+ECDSA+SHA384 EECDH+ECDSA+SHA256 EECDH+aRS$ SSLCertificateFile /etc/ssl/certs/ssl-cert-snakeoil.pem SSLCertificateKeyFile /etc/ssl/private/ssl-cert-snakeoil.key Options FollowSymLinks AllowOverride All Options Indexes FollowSymLinks MultiViews AllowOverride All Order allow,deny allow from all # This directive allows us to have apache2's default start page # in /apache2-default/, but still have / go to the right place ScriptAlias /cgi-bin/ /usr/lib/cgi-bin/ AllowOverride None Options +ExecCGI -MultiViews +SymLinksIfOwnerMatch Order allow,deny Allow from all ErrorLog /var/log/apache2/error.log # Possible values include: debug, info, notice, warn, error, crit, # alert, emerg. LogLevel warn CustomLog /var/log/apache2/access.log combined ServerSignature On Alias /apache_doc/ "/usr/share/doc/" Options Indexes MultiViews FollowSymLinks AllowOverride None Order deny,allow Deny from all Allow from 127.0.0.0/255.0.0.0 ::1/128 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/apache-conf-files/failing/multivhost-1093.conf0000644000076500000240000003422500000000000024631 0ustar00bmwstaff AllowOverride None Require all denied DocumentRoot /var/www/sjau.ch/web ServerName sjau.ch ServerAlias www.sjau.ch ServerAdmin webmaster@sjau.ch ErrorLog /var/log/ispconfig/httpd/sjau.ch/error.log Alias /error/ "/var/www/sjau.ch/web/error/" ErrorDocument 400 /error/400.html ErrorDocument 401 /error/401.html ErrorDocument 403 /error/403.html ErrorDocument 404 /error/404.html ErrorDocument 405 /error/405.html ErrorDocument 500 /error/500.html ErrorDocument 502 /error/502.html ErrorDocument 503 /error/503.html # Clear PHP settings of this website SetHandler None Options +FollowSymLinks AllowOverride All Require all granted # Clear PHP settings of this website SetHandler None Options +FollowSymLinks AllowOverride All Require all granted Options +ExecCGI RubyRequire apache/ruby-run #RubySafeLevel 0 AddType text/html .rb AddType text/html .rbx SetHandler ruby-object RubyHandler Apache::RubyRun.instance SetHandler ruby-object RubyHandler Apache::RubyRun.instance SetHandler mod_python PythonHandler mod_python.publisher PythonDebug On # cgi enabled Require all granted ScriptAlias /cgi-bin/ /var/www/clients/client1/web2/cgi-bin/ SetHandler cgi-script # suexec enabled SuexecUserGroup web2 client1 # php as fast-cgi enabled # For config options see: http://httpd.apache.org/mod_fcgid/mod/mod_fcgid.html IdleTimeout 300 ProcessLifeTime 3600 # MaxProcessCount 1000 DefaultMinClassProcessCount 0 DefaultMaxClassProcessCount 100 IPCConnectTimeout 3 IPCCommTimeout 600 BusyTimeout 3600 SetHandler fcgid-script FCGIWrapper /var/www/php-fcgi-scripts/web2/.php-fcgi-starter .php FCGIWrapper /var/www/php-fcgi-scripts/web2/.php-fcgi-starter .php3 FCGIWrapper /var/www/php-fcgi-scripts/web2/.php-fcgi-starter .php4 FCGIWrapper /var/www/php-fcgi-scripts/web2/.php-fcgi-starter .php5 Options +ExecCGI AllowOverride All Require all granted SetHandler fcgid-script FCGIWrapper /var/www/php-fcgi-scripts/web2/.php-fcgi-starter .php FCGIWrapper /var/www/php-fcgi-scripts/web2/.php-fcgi-starter .php3 FCGIWrapper /var/www/php-fcgi-scripts/web2/.php-fcgi-starter .php4 FCGIWrapper /var/www/php-fcgi-scripts/web2/.php-fcgi-starter .php5 Options +ExecCGI AllowOverride All Require all granted # add support for apache mpm_itk AssignUserId web2 client1 # Do not execute PHP files in webdav directory SecRuleRemoveById 960015 SecRuleRemoveById 960032 SetHandler None DavLockDB /var/www/clients/client1/web2/tmp/DavLock # DO NOT REMOVE THE COMMENTS! # IF YOU REMOVE THEM, WEBDAV WILL NOT WORK ANYMORE! # WEBDAV BEGIN # WEBDAV END DocumentRoot /var/www/sjau.ch/web ServerName sjau.ch ServerAlias www.sjau.ch ServerAdmin webmaster@sjau.ch ErrorLog /var/log/ispconfig/httpd/sjau.ch/error.log Alias /error/ "/var/www/sjau.ch/web/error/" ErrorDocument 400 /error/400.html ErrorDocument 401 /error/401.html ErrorDocument 403 /error/403.html ErrorDocument 404 /error/404.html ErrorDocument 405 /error/405.html ErrorDocument 500 /error/500.html ErrorDocument 502 /error/502.html ErrorDocument 503 /error/503.html # Clear PHP settings of this website SetHandler None Options +FollowSymLinks AllowOverride All Require all granted # Clear PHP settings of this website SetHandler None Options +FollowSymLinks AllowOverride All Require all granted Options +ExecCGI RubyRequire apache/ruby-run #RubySafeLevel 0 AddType text/html .rb AddType text/html .rbx SetHandler ruby-object RubyHandler Apache::RubyRun.instance SetHandler ruby-object RubyHandler Apache::RubyRun.instance SetHandler mod_python PythonHandler mod_python.publisher PythonDebug On # cgi enabled Require all granted ScriptAlias /cgi-bin/ /var/www/clients/client1/web2/cgi-bin/ SetHandler cgi-script # suexec enabled SuexecUserGroup web2 client1 # php as fast-cgi enabled # For config options see: http://httpd.apache.org/mod_fcgid/mod/mod_fcgid.html IdleTimeout 300 ProcessLifeTime 3600 # MaxProcessCount 1000 DefaultMinClassProcessCount 0 DefaultMaxClassProcessCount 100 IPCConnectTimeout 3 IPCCommTimeout 600 BusyTimeout 3600 SetHandler fcgid-script FCGIWrapper /var/www/php-fcgi-scripts/web2/.php-fcgi-starter .php FCGIWrapper /var/www/php-fcgi-scripts/web2/.php-fcgi-starter .php3 FCGIWrapper /var/www/php-fcgi-scripts/web2/.php-fcgi-starter .php4 FCGIWrapper /var/www/php-fcgi-scripts/web2/.php-fcgi-starter .php5 Options +ExecCGI AllowOverride All Require all granted SetHandler fcgid-script FCGIWrapper /var/www/php-fcgi-scripts/web2/.php-fcgi-starter .php FCGIWrapper /var/www/php-fcgi-scripts/web2/.php-fcgi-starter .php3 FCGIWrapper /var/www/php-fcgi-scripts/web2/.php-fcgi-starter .php4 FCGIWrapper /var/www/php-fcgi-scripts/web2/.php-fcgi-starter .php5 Options +ExecCGI AllowOverride All Require all granted # add support for apache mpm_itk AssignUserId web2 client1 # Do not execute PHP files in webdav directory SecRuleRemoveById 960015 SecRuleRemoveById 960032 SetHandler None DavLockDB /var/www/clients/client1/web2/tmp/DavLock # DO NOT REMOVE THE COMMENTS! # IF YOU REMOVE THEM, WEBDAV WILL NOT WORK ANYMORE! # WEBDAV BEGIN # WEBDAV END ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/apache-conf-files/failing/multivhost-1093b.conf0000644000076500000240000007150600000000000024776 0ustar00bmwstaff AllowOverride None Require all denied DocumentRoot /var/www/ensemen.ch/web ServerName ensemen.ch ServerAlias www.ensemen.ch ServerAdmin webmaster@ensemen.ch ErrorLog /var/log/ispconfig/httpd/ensemen.ch/error.log Alias /error/ "/var/www/ensemen.ch/web/error/" ErrorDocument 400 /error/400.html ErrorDocument 401 /error/401.html ErrorDocument 403 /error/403.html ErrorDocument 404 /error/404.html ErrorDocument 405 /error/405.html ErrorDocument 500 /error/500.html ErrorDocument 502 /error/502.html ErrorDocument 503 /error/503.html # Clear PHP settings of this website SetHandler None Options +FollowSymLinks AllowOverride All Require all granted # Clear PHP settings of this website SetHandler None Options +FollowSymLinks AllowOverride All Require all granted Options +ExecCGI RubyRequire apache/ruby-run #RubySafeLevel 0 AddType text/html .rb AddType text/html .rbx SetHandler ruby-object RubyHandler Apache::RubyRun.instance SetHandler ruby-object RubyHandler Apache::RubyRun.instance SetHandler mod_python PythonHandler mod_python.publisher PythonDebug On # cgi enabled Require all granted ScriptAlias /cgi-bin/ /var/www/clients/client4/web17/cgi-bin/ SetHandler cgi-script # suexec enabled SuexecUserGroup web17 client4 # php as fast-cgi enabled # For config options see: http://httpd.apache.org/mod_fcgid/mod/mod_fcgid.html IdleTimeout 300 ProcessLifeTime 3600 # MaxProcessCount 1000 DefaultMinClassProcessCount 0 DefaultMaxClassProcessCount 100 IPCConnectTimeout 3 IPCCommTimeout 600 BusyTimeout 3600 SetHandler fcgid-script FCGIWrapper /var/www/php-fcgi-scripts/web17/.php-fcgi-starter .php FCGIWrapper /var/www/php-fcgi-scripts/web17/.php-fcgi-starter .php3 FCGIWrapper /var/www/php-fcgi-scripts/web17/.php-fcgi-starter .php4 FCGIWrapper /var/www/php-fcgi-scripts/web17/.php-fcgi-starter .php5 Options +ExecCGI AllowOverride All Require all granted SetHandler fcgid-script FCGIWrapper /var/www/php-fcgi-scripts/web17/.php-fcgi-starter .php FCGIWrapper /var/www/php-fcgi-scripts/web17/.php-fcgi-starter .php3 FCGIWrapper /var/www/php-fcgi-scripts/web17/.php-fcgi-starter .php4 FCGIWrapper /var/www/php-fcgi-scripts/web17/.php-fcgi-starter .php5 Options +ExecCGI AllowOverride All Require all granted # add support for apache mpm_itk AssignUserId web17 client4 # Do not execute PHP files in webdav directory SecRuleRemoveById 960015 SecRuleRemoveById 960032 SetHandler None DavLockDB /var/www/clients/client4/web17/tmp/DavLock # DO NOT REMOVE THE COMMENTS! # IF YOU REMOVE THEM, WEBDAV WILL NOT WORK ANYMORE! # WEBDAV BEGIN # WEBDAV END DocumentRoot /var/www/ensemen.ch/web ServerName ensemen.ch ServerAlias www.ensemen.ch ServerAdmin webmaster@ensemen.ch ErrorLog /var/log/ispconfig/httpd/ensemen.ch/error.log Alias /error/ "/var/www/ensemen.ch/web/error/" ErrorDocument 400 /error/400.html ErrorDocument 401 /error/401.html ErrorDocument 403 /error/403.html ErrorDocument 404 /error/404.html ErrorDocument 405 /error/405.html ErrorDocument 500 /error/500.html ErrorDocument 502 /error/502.html ErrorDocument 503 /error/503.html SSLEngine on SSLProtocol All -SSLv2 -SSLv3 SSLCertificateFile /var/www/clients/client4/web17/ssl/ensemen.ch.crt SSLCertificateKeyFile /var/www/clients/client4/web17/ssl/ensemen.ch.key # Clear PHP settings of this website SetHandler None Options +FollowSymLinks AllowOverride All Require all granted # Clear PHP settings of this website SetHandler None Options +FollowSymLinks AllowOverride All Require all granted Options +ExecCGI RubyRequire apache/ruby-run #RubySafeLevel 0 AddType text/html .rb AddType text/html .rbx SetHandler ruby-object RubyHandler Apache::RubyRun.instance SetHandler ruby-object RubyHandler Apache::RubyRun.instance SetHandler mod_python PythonHandler mod_python.publisher PythonDebug On # cgi enabled Require all granted ScriptAlias /cgi-bin/ /var/www/clients/client4/web17/cgi-bin/ SetHandler cgi-script # suexec enabled SuexecUserGroup web17 client4 # php as fast-cgi enabled # For config options see: http://httpd.apache.org/mod_fcgid/mod/mod_fcgid.html IdleTimeout 300 ProcessLifeTime 3600 # MaxProcessCount 1000 DefaultMinClassProcessCount 0 DefaultMaxClassProcessCount 100 IPCConnectTimeout 3 IPCCommTimeout 600 BusyTimeout 3600 SetHandler fcgid-script FCGIWrapper /var/www/php-fcgi-scripts/web17/.php-fcgi-starter .php FCGIWrapper /var/www/php-fcgi-scripts/web17/.php-fcgi-starter .php3 FCGIWrapper /var/www/php-fcgi-scripts/web17/.php-fcgi-starter .php4 FCGIWrapper /var/www/php-fcgi-scripts/web17/.php-fcgi-starter .php5 Options +ExecCGI AllowOverride All Require all granted SetHandler fcgid-script FCGIWrapper /var/www/php-fcgi-scripts/web17/.php-fcgi-starter .php FCGIWrapper /var/www/php-fcgi-scripts/web17/.php-fcgi-starter .php3 FCGIWrapper /var/www/php-fcgi-scripts/web17/.php-fcgi-starter .php4 FCGIWrapper /var/www/php-fcgi-scripts/web17/.php-fcgi-starter .php5 Options +ExecCGI AllowOverride All Require all granted # add support for apache mpm_itk AssignUserId web17 client4 # Do not execute PHP files in webdav directory SecRuleRemoveById 960015 SecRuleRemoveById 960032 SetHandler None DavLockDB /var/www/clients/client4/web17/tmp/DavLock # DO NOT REMOVE THE COMMENTS! # IF YOU REMOVE THEM, WEBDAV WILL NOT WORK ANYMORE! # WEBDAV BEGIN # WEBDAV END DocumentRoot /var/www/ensemen.ch/web ServerName ensemen.ch ServerAlias www.ensemen.ch ServerAdmin webmaster@ensemen.ch ErrorLog /var/log/ispconfig/httpd/ensemen.ch/error.log Alias /error/ "/var/www/ensemen.ch/web/error/" ErrorDocument 400 /error/400.html ErrorDocument 401 /error/401.html ErrorDocument 403 /error/403.html ErrorDocument 404 /error/404.html ErrorDocument 405 /error/405.html ErrorDocument 500 /error/500.html ErrorDocument 502 /error/502.html ErrorDocument 503 /error/503.html # Clear PHP settings of this website SetHandler None Options +FollowSymLinks AllowOverride All Require all granted # Clear PHP settings of this website SetHandler None Options +FollowSymLinks AllowOverride All Require all granted Options +ExecCGI RubyRequire apache/ruby-run #RubySafeLevel 0 AddType text/html .rb AddType text/html .rbx SetHandler ruby-object RubyHandler Apache::RubyRun.instance SetHandler ruby-object RubyHandler Apache::RubyRun.instance SetHandler mod_python PythonHandler mod_python.publisher PythonDebug On # cgi enabled Require all granted ScriptAlias /cgi-bin/ /var/www/clients/client4/web17/cgi-bin/ SetHandler cgi-script # suexec enabled SuexecUserGroup web17 client4 # php as fast-cgi enabled # For config options see: http://httpd.apache.org/mod_fcgid/mod/mod_fcgid.html IdleTimeout 300 ProcessLifeTime 3600 # MaxProcessCount 1000 DefaultMinClassProcessCount 0 DefaultMaxClassProcessCount 100 IPCConnectTimeout 3 IPCCommTimeout 600 BusyTimeout 3600 SetHandler fcgid-script FCGIWrapper /var/www/php-fcgi-scripts/web17/.php-fcgi-starter .php FCGIWrapper /var/www/php-fcgi-scripts/web17/.php-fcgi-starter .php3 FCGIWrapper /var/www/php-fcgi-scripts/web17/.php-fcgi-starter .php4 FCGIWrapper /var/www/php-fcgi-scripts/web17/.php-fcgi-starter .php5 Options +ExecCGI AllowOverride All Require all granted SetHandler fcgid-script FCGIWrapper /var/www/php-fcgi-scripts/web17/.php-fcgi-starter .php FCGIWrapper /var/www/php-fcgi-scripts/web17/.php-fcgi-starter .php3 FCGIWrapper /var/www/php-fcgi-scripts/web17/.php-fcgi-starter .php4 FCGIWrapper /var/www/php-fcgi-scripts/web17/.php-fcgi-starter .php5 Options +ExecCGI AllowOverride All Require all granted # add support for apache mpm_itk AssignUserId web17 client4 # Do not execute PHP files in webdav directory SecRuleRemoveById 960015 SecRuleRemoveById 960032 SetHandler None DavLockDB /var/www/clients/client4/web17/tmp/DavLock # DO NOT REMOVE THE COMMENTS! # IF YOU REMOVE THEM, WEBDAV WILL NOT WORK ANYMORE! # WEBDAV BEGIN # WEBDAV END DocumentRoot /var/www/ensemen.ch/web ServerName ensemen.ch ServerAlias www.ensemen.ch ServerAdmin webmaster@ensemen.ch ErrorLog /var/log/ispconfig/httpd/ensemen.ch/error.log Alias /error/ "/var/www/ensemen.ch/web/error/" ErrorDocument 400 /error/400.html ErrorDocument 401 /error/401.html ErrorDocument 403 /error/403.html ErrorDocument 404 /error/404.html ErrorDocument 405 /error/405.html ErrorDocument 500 /error/500.html ErrorDocument 502 /error/502.html ErrorDocument 503 /error/503.html SSLEngine on SSLProtocol All -SSLv2 -SSLv3 SSLCertificateFile /var/www/clients/client4/web17/ssl/ensemen.ch.crt SSLCertificateKeyFile /var/www/clients/client4/web17/ssl/ensemen.ch.key # Clear PHP settings of this website SetHandler None Options +FollowSymLinks AllowOverride All Require all granted # Clear PHP settings of this website SetHandler None Options +FollowSymLinks AllowOverride All Require all granted Options +ExecCGI RubyRequire apache/ruby-run #RubySafeLevel 0 AddType text/html .rb AddType text/html .rbx SetHandler ruby-object RubyHandler Apache::RubyRun.instance SetHandler ruby-object RubyHandler Apache::RubyRun.instance SetHandler mod_python PythonHandler mod_python.publisher PythonDebug On # cgi enabled Require all granted ScriptAlias /cgi-bin/ /var/www/clients/client4/web17/cgi-bin/ SetHandler cgi-script # suexec enabled SuexecUserGroup web17 client4 # php as fast-cgi enabled # For config options see: http://httpd.apache.org/mod_fcgid/mod/mod_fcgid.html IdleTimeout 300 ProcessLifeTime 3600 # MaxProcessCount 1000 DefaultMinClassProcessCount 0 DefaultMaxClassProcessCount 100 IPCConnectTimeout 3 IPCCommTimeout 600 BusyTimeout 3600 SetHandler fcgid-script FCGIWrapper /var/www/php-fcgi-scripts/web17/.php-fcgi-starter .php FCGIWrapper /var/www/php-fcgi-scripts/web17/.php-fcgi-starter .php3 FCGIWrapper /var/www/php-fcgi-scripts/web17/.php-fcgi-starter .php4 FCGIWrapper /var/www/php-fcgi-scripts/web17/.php-fcgi-starter .php5 Options +ExecCGI AllowOverride All Require all granted SetHandler fcgid-script FCGIWrapper /var/www/php-fcgi-scripts/web17/.php-fcgi-starter .php FCGIWrapper /var/www/php-fcgi-scripts/web17/.php-fcgi-starter .php3 FCGIWrapper /var/www/php-fcgi-scripts/web17/.php-fcgi-starter .php4 FCGIWrapper /var/www/php-fcgi-scripts/web17/.php-fcgi-starter .php5 Options +ExecCGI AllowOverride All Require all granted # add support for apache mpm_itk AssignUserId web17 client4 # Do not execute PHP files in webdav directory SecRuleRemoveById 960015 SecRuleRemoveById 960032 SetHandler None DavLockDB /var/www/clients/client4/web17/tmp/DavLock # DO NOT REMOVE THE COMMENTS! # IF YOU REMOVE THEM, WEBDAV WILL NOT WORK ANYMORE! # WEBDAV BEGIN # WEBDAV END ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.8015766 certbot-apache-1.21.0/tests/apache-conf-files/passing/0000755000076500000240000000000000000000000021177 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/apache-conf-files/passing/1626-1531.conf0000644000076500000240000000310200000000000023027 0ustar00bmwstaff ServerAdmin denver@ossguy.com ServerName c-beta.ossguy.com Alias /robots.txt /home/denver/www/c-beta.ossguy.com/static/robots.txt Alias /favicon.ico /home/denver/www/c-beta.ossguy.com/static/favicon.ico AliasMatch /(.*\.css) /home/denver/www/c-beta.ossguy.com/static/$1 AliasMatch /(.*\.js) /home/denver/www/c-beta.ossguy.com/static/$1 AliasMatch /(.*\.png) /home/denver/www/c-beta.ossguy.com/static/$1 AliasMatch /(.*\.gif) /home/denver/www/c-beta.ossguy.com/static/$1 AliasMatch /(.*\.jpg) /home/denver/www/c-beta.ossguy.com/static/$1 WSGIScriptAlias / /home/denver/www/c-beta.ossguy.com/django.wsgi WSGIDaemonProcess c-beta-ossguy user=www-data group=www-data home=/var/www processes=5 threads=10 maximum-requests=1000 umask=0007 display-name=c-beta-ossguy WSGIProcessGroup c-beta-ossguy WSGIApplicationGroup %{GLOBAL} DocumentRoot /home/denver/www/c-beta.ossguy.com/static Options -Indexes +FollowSymLinks -MultiViews Require all granted AllowOverride None Options +Indexes +FollowSymLinks -MultiViews Require all granted AllowOverride None # Custom log file locations LogLevel warn ErrorLog /tmp/error.log CustomLog /tmp/access.log combined ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/apache-conf-files/passing/README.modules0000644000076500000240000000011500000000000023523 0ustar00bmwstaff# Modules required to parse these conf files: ssl rewrite macro wsgi deflate ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/apache-conf-files/passing/anarcat-1531.conf0000644000076500000240000000055300000000000024051 0ustar00bmwstaff ServerAdmin root@localhost ServerName anarcat.wiki.orangeseeds.org:80 UserDir disabled RewriteEngine On RewriteRule ^/(.*) http\:\/\/anarc\.at\/$1 [L,R,NE] ErrorLog /var/log/apache2/1531error.log LogLevel warn CustomLog /var/log/apache2/1531access.log combined ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/apache-conf-files/passing/comment-continuations-2050.conf0000644000076500000240000003236500000000000027000 0ustar00bmwstaff# --------------------------------------------------------------- # Core ModSecurity Rule Set ver.2.2.6 # Copyright (C) 2006-2012 Trustwave All rights reserved. # # The OWASP ModSecurity Core Rule Set is distributed under # Apache Software License (ASL) version 2 # Please see the enclosed LICENCE file for full details. # --------------------------------------------------------------- # # -- [[ Recommended Base Configuration ]] ------------------------------------------------- # # The configuration directives/settings in this file are used to control # the OWASP ModSecurity CRS. These settings do **NOT** configure the main # ModSecurity settings such as: # # - SecRuleEngine # - SecRequestBodyAccess # - SecAuditEngine # - SecDebugLog # # You should use the modsecurity.conf-recommended file that comes with the # ModSecurity source code archive. # # Ref: http://mod-security.svn.sourceforge.net/viewvc/mod-security/m2/trunk/modsecurity.conf-recommended # # # -- [[ Rule Version ]] ------------------------------------------------------------------- # # Rule version data is added to the "Producer" line of Section H of the Audit log: # # - Producer: ModSecurity for Apache/2.7.0-rc1 (http://www.modsecurity.org/); OWASP_CRS/2.2.4. # # Ref: https://sourceforge.net/apps/mediawiki/mod-security/index.php?title=Reference_Manual#SecComponentSignature # #SecComponentSignature "OWASP_CRS/2.2.6" # # -- [[ Modes of Operation: Self-Contained vs. Collaborative Detection ]] ----------------- # # Each detection rule uses the "block" action which will inherit the SecDefaultAction # specified below. Your settings here will determine which mode of operation you use. # # -- [[ Self-Contained Mode ]] -- # Rules inherit the "deny" disruptive action. The first rule that matches will block. # # -- [[ Collaborative Detection Mode ]] -- # This is a "delayed blocking" mode of operation where each matching rule will inherit # the "pass" action and will only contribute to anomaly scores. Transactional blocking # can be applied # # -- [[ Alert Logging Control ]] -- # You have three options - # # - To log to both the Apache error_log and ModSecurity audit_log file use: "log" # - To log *only* to the ModSecurity audit_log file use: "nolog,auditlog" # - To log *only* to the Apache error_log file use: "log,noauditlog" # # Ref: http://blog.spiderlabs.com/2010/11/advanced-topic-of-the-week-traditional-vs-anomaly-scoring-detection-modes.html # Ref: https://sourceforge.net/apps/mediawiki/mod-security/index.php?title=Reference_Manual#SecDefaultAction # #SecDefaultAction "phase:1,deny,log" # # -- [[ Collaborative Detection Severity Levels ]] ---------------------------------------- # # These are the default scoring points for each severity level. You may # adjust these to you liking. These settings will be used in macro expansion # in the rules to increment the anomaly scores when rules match. # # These are the default Severity ratings (with anomaly scores) of the individual rules - # # - 2: Critical - Anomaly Score of 5. # Is the highest severity level possible without correlation. It is # normally generated by the web attack rules (40 level files). # - 3: Error - Anomaly Score of 4. # Is generated mostly from outbound leakage rules (50 level files). # - 4: Warning - Anomaly Score of 3. # Is generated by malicious client rules (35 level files). # - 5: Notice - Anomaly Score of 2. # Is generated by the Protocol policy and anomaly files. # #SecAction \ "id:'900001', \ phase:1, \ t:none, \ setvar:tx.critical_anomaly_score=5, \ setvar:tx.error_anomaly_score=4, \ setvar:tx.warning_anomaly_score=3, \ setvar:tx.notice_anomaly_score=2, \ nolog, \ pass" # # -- [[ Collaborative Detection Scoring Threshold Levels ]] ------------------------------ # # These variables are used in macro expansion in the 49 inbound blocking and 59 # outbound blocking files. # # **MUST HAVE** ModSecurity v2.5.12 or higher to use macro expansion in numeric # operators. If you have an earlier version, edit the 49/59 files directly to # set the appropriate anomaly score levels. # # You should set the score to the proper threshold you would prefer. If set to "5" # it will work similarly to previous Mod CRS rules and will create an event in the error_log # file if there are any rules that match. If you would like to lessen the number of events # generated in the error_log file, you should increase the anomaly score threshold to # something like "20". This would only generate an event in the error_log file if # there are multiple lower severity rule matches or if any 1 higher severity item matches. # #SecAction \ "id:'900002', \ phase:1, \ t:none, \ setvar:tx.inbound_anomaly_score_level=5, \ nolog, \ pass" #SecAction \ "id:'900003', \ phase:1, \ t:none, \ setvar:tx.outbound_anomaly_score_level=4, \ nolog, \ pass" # # -- [[ Collaborative Detection Blocking ]] ----------------------------------------------- # # This is a collaborative detection mode where each rule will increment an overall # anomaly score for the transaction. The scores are then evaluated in the following files: # # Inbound anomaly score - checked in the modsecurity_crs_49_inbound_blocking.conf file # Outbound anomaly score - checked in the modsecurity_crs_59_outbound_blocking.conf file # # If you want to use anomaly scoring mode, then uncomment this line. # #SecAction \ "id:'900004', \ phase:1, \ t:none, \ setvar:tx.anomaly_score_blocking=on, \ nolog, \ pass" # # -- [[ GeoIP Database ]] ----------------------------------------------------------------- # # There are some rulesets that need to inspect the GEO data of the REMOTE_ADDR data. # # You must first download the MaxMind GeoIP Lite City DB - # # http://geolite.maxmind.com/download/geoip/database/GeoLiteCity.dat.gz # # You then need to define the proper path for the SecGeoLookupDb directive # # Ref: http://blog.spiderlabs.com/2010/10/detecting-malice-with-modsecurity-geolocation-data.html # Ref: http://blog.spiderlabs.com/2010/11/detecting-malice-with-modsecurity-ip-forensics.html # #SecGeoLookupDb /opt/modsecurity/lib/GeoLiteCity.dat # # -- [[ Regression Testing Mode ]] -------------------------------------------------------- # # If you are going to run the regression testing mode, you should uncomment the # following rule. It will enable DetectionOnly mode for the SecRuleEngine and # will enable Response Header tagging so that the client testing script can see # which rule IDs have matched. # # You must specify the your source IP address where you will be running the tests # from. # #SecRule REMOTE_ADDR "@ipMatch 192.168.1.100" \ "id:'900005', \ phase:1, \ t:none, \ ctl:ruleEngine=DetectionOnly, \ setvar:tx.regression_testing=1, \ nolog, \ pass" # # -- [[ HTTP Policy Settings ]] ---------------------------------------------------------- # # Set the following policy settings here and they will be propagated to the 23 rules # file (modsecurity_common_23_request_limits.conf) by using macro expansion. # If you run into false positives, you can adjust the settings here. # # Only the max number of args is uncommented by default as there are a high rate # of false positives. Uncomment the items you wish to set. # # # -- Maximum number of arguments in request limited #SecAction \ "id:'900006', \ phase:1, \ t:none, \ setvar:tx.max_num_args=255, \ nolog, \ pass" # # -- Limit argument name length #SecAction \ "id:'900007', \ phase:1, \ t:none, \ setvar:tx.arg_name_length=100, \ nolog, \ pass" # # -- Limit value name length #SecAction \ "id:'900008', \ phase:1, \ t:none, \ setvar:tx.arg_length=400, \ nolog, \ pass" # # -- Limit arguments total length #SecAction \ "id:'900009', \ phase:1, \ t:none, \ setvar:tx.total_arg_length=64000, \ nolog, \ pass" # # -- Individual file size is limited #SecAction \ "id:'900010', \ phase:1, \ t:none, \ setvar:tx.max_file_size=1048576, \ nolog, \ pass" # # -- Combined file size is limited #SecAction \ "id:'900011', \ phase:1, \ t:none, \ setvar:tx.combined_file_sizes=1048576, \ nolog, \ pass" # # Set the following policy settings here and they will be propagated to the 30 rules # file (modsecurity_crs_30_http_policy.conf) by using macro expansion. # If you run into false positives, you can adjust the settings here. # #SecAction \ "id:'900012', \ phase:1, \ t:none, \ setvar:'tx.allowed_methods=GET HEAD POST OPTIONS', \ setvar:'tx.allowed_request_content_type=application/x-www-form-urlencoded|multipart/form-data|text/xml|application/xml|application/x-amf', \ setvar:'tx.allowed_http_versions=HTTP/0.9 HTTP/1.0 HTTP/1.1', \ setvar:'tx.restricted_extensions=.asa/ .asax/ .ascx/ .axd/ .backup/ .bak/ .bat/ .cdx/ .cer/ .cfg/ .cmd/ .com/ .config/ .conf/ .cs/ .csproj/ .csr/ .dat/ .db/ .dbf/ .dll/ .dos/ .htr/ .htw/ .ida/ .idc/ .idq/ .inc/ .ini/ .key/ .licx/ .lnk/ .log/ .mdb/ .old/ .pass/ .pdb/ .pol/ .printer/ .pwd/ .resources/ .resx/ .sql/ .sys/ .vb/ .vbs/ .vbproj/ .vsdisco/ .webinfo/ .xsd/ .xsx/', \ setvar:'tx.restricted_headers=/Proxy-Connection/ /Lock-Token/ /Content-Range/ /Translate/ /via/ /if/', \ nolog, \ pass" # # -- [[ Content Security Policy (CSP) Settings ]] ----------------------------------------- # # The purpose of these settings is to send CSP response headers to # Mozilla FireFox users so that you can enforce how dynamic content # is used. CSP usage helps to prevent XSS attacks against your users. # # Reference Link: # # https://developer.mozilla.org/en/Security/CSP # # Uncomment this SecAction line if you want use CSP enforcement. # You need to set the appropriate directives and settings for your site/domain and # and activate the CSP file in the experimental_rules directory. # # Ref: http://blog.spiderlabs.com/2011/04/modsecurity-advanced-topic-of-the-week-integrating-content-security-policy-csp.html # #SecAction \ "id:'900013', \ phase:1, \ t:none, \ setvar:tx.csp_report_only=1, \ setvar:tx.csp_report_uri=/csp_violation_report, \ setenv:'csp_policy=allow \'self\'; img-src *.yoursite.com; media-src *.yoursite.com; style-src *.yoursite.com; frame-ancestors *.yoursite.com; script-src *.yoursite.com; report-uri %{tx.csp_report_uri}', \ nolog, \ pass" # # -- [[ Brute Force Protection ]] --------------------------------------------------------- # # If you are using the Brute Force Protection rule set, then uncomment the following # lines and set the following variables: # - Protected URLs: resources to protect (e.g. login pages) - set to your login page # - Burst Time Slice Interval: time interval window to monitor for bursts # - Request Threshold: request # threshold to trigger a burst # - Block Period: temporary block timeout # #SecAction \ "id:'900014', \ phase:1, \ t:none, \ setvar:'tx.brute_force_protected_urls=/login.jsp /partner_login.php', \ setvar:'tx.brute_force_burst_time_slice=60', \ setvar:'tx.brute_force_counter_threshold=10', \ setvar:'tx.brute_force_block_timeout=300', \ nolog, \ pass" # # -- [[ DoS Protection ]] ---------------------------------------------------------------- # # If you are using the DoS Protection rule set, then uncomment the following # lines and set the following variables: # - Burst Time Slice Interval: time interval window to monitor for bursts # - Request Threshold: request # threshold to trigger a burst # - Block Period: temporary block timeout # #SecAction \ "id:'900015', \ phase:1, \ t:none, \ setvar:'tx.dos_burst_time_slice=60', \ setvar:'tx.dos_counter_threshold=100', \ setvar:'tx.dos_block_timeout=600', \ nolog, \ pass" # # -- [[ Check UTF encoding ]] ----------------------------------------------------------- # # We only want to apply this check if UTF-8 encoding is actually used by the site, otherwise # it will result in false positives. # # Uncomment this line if your site uses UTF8 encoding #SecAction \ "id:'900016', \ phase:1, \ t:none, \ setvar:tx.crs_validate_utf8_encoding=1, \ nolog, \ pass" # # -- [[ Enable XML Body Parsing ]] ------------------------------------------------------- # # The rules in this file will trigger the XML parser upon an XML request # # Initiate XML Processor in case of xml content-type # #SecRule REQUEST_HEADERS:Content-Type "text/xml" \ "id:'900017', \ phase:1, \ t:none,t:lowercase, \ nolog, \ pass, \ chain" #SecRule REQBODY_PROCESSOR "!@streq XML" \ "ctl:requestBodyProcessor=XML" # # -- [[ Global and IP Collections ]] ----------------------------------------------------- # # Create both Global and IP collections for rules to use # There are some CRS rules that assume that these two collections # have already been initiated. # #SecRule REQUEST_HEADERS:User-Agent "^(.*)$" \ "id:'900018', \ phase:1, \ t:none,t:sha1,t:hexEncode, \ setvar:tx.ua_hash=%{matched_var}, \ nolog, \ pass" #SecRule REQUEST_HEADERS:x-forwarded-for "^\b(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})\b" \ "id:'900019', \ phase:1, \ t:none, \ capture, \ setvar:tx.real_ip=%{tx.1}, \ nolog, \ pass" #SecRule &TX:REAL_IP "!@eq 0" \ "id:'900020', \ phase:1, \ t:none, \ initcol:global=global, \ initcol:ip=%{tx.real_ip}_%{tx.ua_hash}, \ nolog, \ pass" #SecRule &TX:REAL_IP "@eq 0" \ "id:'900021', \ phase:1, \ t:none, \ initcol:global=global, \ initcol:ip=%{remote_addr}_%{tx.ua_hash}, \ nolog, \ pass" ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/apache-conf-files/passing/drupal-errordocument-arg-1724.conf0000644000076500000240000001010100000000000027356 0ustar00bmwstaff# # Apache/PHP/Drupal settings: # # Protect files and directories from prying eyes. Order allow,deny # Don't show directory listings for URLs which map to a directory. Options -Indexes # Follow symbolic links in this directory. Options +FollowSymLinks # Make Drupal handle any 404 errors. ErrorDocument 404 /index.php # Force simple error message for requests for non-existent favicon.ico. # There is no end quote below, for compatibility with Apache 1.3. ErrorDocument 404 "The requested file favicon.ico was not found. # Set the default handler. DirectoryIndex index.php # Override PHP settings. More in sites/default/settings.php # but the following cannot be changed at runtime. # PHP 4, Apache 1. php_value magic_quotes_gpc 0 php_value register_globals 0 php_value session.auto_start 0 php_value mbstring.http_input pass php_value mbstring.http_output pass php_value mbstring.encoding_translation 0 # PHP 4, Apache 2. php_value magic_quotes_gpc 0 php_value register_globals 0 php_value session.auto_start 0 php_value mbstring.http_input pass php_value mbstring.http_output pass php_value mbstring.encoding_translation 0 # PHP 5, Apache 1 and 2. php_value magic_quotes_gpc 0 php_value register_globals 0 php_value session.auto_start 0 php_value mbstring.http_input pass php_value mbstring.http_output pass php_value mbstring.encoding_translation 0 # Requires mod_expires to be enabled. # Enable expirations. ExpiresActive On # Cache all files for 2 weeks after access (A). ExpiresDefault A1209600 # Do not allow PHP scripts to be cached unless they explicitly send cache # headers themselves. Otherwise all scripts would have to overwrite the # headers set by mod_expires if they want another caching behavior. This may # fail if an error occurs early in the bootstrap process, and it may cause # problems if a non-Drupal PHP file is installed in a subdirectory. ExpiresActive Off # Various rewrite rules. RewriteEngine on # If your site can be accessed both with and without the 'www.' prefix, you # can use one of the following settings to redirect users to your preferred # URL, either WITH or WITHOUT the 'www.' prefix. Choose ONLY one option: # # To redirect all users to access the site WITH the 'www.' prefix, # (http://example.com/... will be redirected to http://www.example.com/...) # adapt and uncomment the following: # RewriteCond %{HTTP_HOST} ^example\.com$ [NC] # RewriteRule ^(.*)$ http://www.example.com/$1 [L,R=301] # # To redirect all users to access the site WITHOUT the 'www.' prefix, # (http://www.example.com/... will be redirected to http://example.com/...) # uncomment and adapt the following: # RewriteCond %{HTTP_HOST} ^www\.example\.com$ [NC] # RewriteRule ^(.*)$ http://example.com/$1 [L,R=301] # Modify the RewriteBase if you are using Drupal in a subdirectory or in a # VirtualDocumentRoot and the rewrite rules are not working properly. # For example if your site is at http://example.com/drupal uncomment and # modify the following line: # RewriteBase /drupal # # If your site is running in a VirtualDocumentRoot at http://example.com/, # uncomment the following line: # RewriteBase / # Rewrite URLs of the form 'x' to the form 'index.php?q=x'. RewriteCond %{REQUEST_FILENAME} !-f RewriteCond %{REQUEST_FILENAME} !-d RewriteCond %{REQUEST_URI} !=/favicon.ico RewriteRule ^(.*)$ index.php?q=$1 [L,QSA] # $Id$ ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/apache-conf-files/passing/drupal-htaccess-1531.conf0000644000076500000240000001346700000000000025532 0ustar00bmwstaff# # Apache/PHP/Drupal settings: # # Protect files and directories from prying eyes. Order allow,deny # Don't show directory listings for URLs which map to a directory. Options -Indexes # Follow symbolic links in this directory. Options +FollowSymLinks # Make Drupal handle any 404 errors. ErrorDocument 404 /index.php # Set the default handler. DirectoryIndex index.php index.html index.htm # Override PHP settings that cannot be changed at runtime. See # sites/default/default.settings.php and drupal_environment_initialize() in # includes/bootstrap.inc for settings that can be changed at runtime. # PHP 5, Apache 1 and 2. php_flag magic_quotes_gpc off php_flag magic_quotes_sybase off php_flag register_globals off php_flag session.auto_start off php_value mbstring.http_input pass php_value mbstring.http_output pass php_flag mbstring.encoding_translation off # Requires mod_expires to be enabled. # Enable expirations. ExpiresActive On # Cache all files for 2 weeks after access (A). ExpiresDefault A1209600 # Do not allow PHP scripts to be cached unless they explicitly send cache # headers themselves. Otherwise all scripts would have to overwrite the # headers set by mod_expires if they want another caching behavior. This may # fail if an error occurs early in the bootstrap process, and it may cause # problems if a non-Drupal PHP file is installed in a subdirectory. ExpiresActive Off # Various rewrite rules. RewriteEngine on # Set "protossl" to "s" if we were accessed via https://. This is used later # if you enable "www." stripping or enforcement, in order to ensure that # you don't bounce between http and https. RewriteRule ^ - [E=protossl] RewriteCond %{HTTPS} on RewriteRule ^ - [E=protossl:s] # Make sure Authorization HTTP header is available to PHP # even when running as CGI or FastCGI. RewriteRule ^ - [E=HTTP_AUTHORIZATION:%{HTTP:Authorization}] # Block access to "hidden" directories whose names begin with a period. This # includes directories used by version control systems such as Subversion or # Git to store control files. Files whose names begin with a period, as well # as the control files used by CVS, are protected by the FilesMatch directive # above. # # NOTE: This only works when mod_rewrite is loaded. Without mod_rewrite, it is # not possible to block access to entire directories from .htaccess, because # is not allowed here. # # If you do not have mod_rewrite installed, you should remove these # directories from your webroot or otherwise protect them from being # downloaded. RewriteRule "(^|/)\." - [F] # If your site can be accessed both with and without the 'www.' prefix, you # can use one of the following settings to redirect users to your preferred # URL, either WITH or WITHOUT the 'www.' prefix. Choose ONLY one option: # # To redirect all users to access the site WITH the 'www.' prefix, # (http://example.com/... will be redirected to http://www.example.com/...) # uncomment the following: # RewriteCond %{HTTP_HOST} . # RewriteCond %{HTTP_HOST} !^www\. [NC] # RewriteRule ^ http%{ENV:protossl}://www.%{HTTP_HOST}%{REQUEST_URI} [L,R=301] # # To redirect all users to access the site WITHOUT the 'www.' prefix, # (http://www.example.com/... will be redirected to http://example.com/...) # uncomment the following: # RewriteCond %{HTTP_HOST} ^www\.(.+)$ [NC] # RewriteRule ^ http%{ENV:protossl}://%1%{REQUEST_URI} [L,R=301] # Modify the RewriteBase if you are using Drupal in a subdirectory or in a # VirtualDocumentRoot and the rewrite rules are not working properly. # For example if your site is at http://example.com/drupal uncomment and # modify the following line: # RewriteBase /drupal # # If your site is running in a VirtualDocumentRoot at http://example.com/, # uncomment the following line: # RewriteBase / # Pass all requests not referring directly to files in the filesystem to # index.php. Clean URLs are handled in drupal_environment_initialize(). RewriteCond %{REQUEST_FILENAME} !-f RewriteCond %{REQUEST_FILENAME} !-d RewriteCond %{REQUEST_URI} !=/favicon.ico RewriteRule ^ index.php [L] # Rules to correctly serve gzip compressed CSS and JS files. # Requires both mod_rewrite and mod_headers to be enabled. # Serve gzip compressed CSS files if they exist and the client accepts gzip. RewriteCond %{HTTP:Accept-encoding} gzip RewriteCond %{REQUEST_FILENAME}\.gz -s RewriteRule ^(.*)\.css $1\.css\.gz [QSA] # Serve gzip compressed JS files if they exist and the client accepts gzip. RewriteCond %{HTTP:Accept-encoding} gzip RewriteCond %{REQUEST_FILENAME}\.gz -s RewriteRule ^(.*)\.js $1\.js\.gz [QSA] # Serve correct content types, and prevent mod_deflate double gzip. RewriteRule .css.gz$ - [T=text/css,E=no-gzip:1] RewriteRule .js.gz$ - [T=text/javascript,E=no-gzip:1] # Serve correct encoding type. Header set Content-Encoding gzip # Force proxies to cache gzipped & non-gzipped css/js files separately. Header append Vary Accept-Encoding # Add headers to all responses. # Disable content sniffing, since it's an attack vector. Header always set X-Content-Type-Options nosniff ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/apache-conf-files/passing/escaped-space-arguments-2735.conf0000644000076500000240000000016700000000000027150 0ustar00bmwstaffRewriteCond %{HTTP:Content-Disposition} \.php [NC] RewriteCond %{THE_REQUEST} ^[A-Z]{3,9}\ /.+/trackback/?\ HTTP/ [NC] ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/apache-conf-files/passing/example-1755.conf0000644000076500000240000000300100000000000024072 0ustar00bmwstaff # The ServerName directive sets the request scheme, hostname and port that # the server uses to identify itself. This is used when creating # redirection URLs. In the context of virtual hosts, the ServerName # specifies what hostname must appear in the request's Host: header to # match this virtual host. For the default virtual host (this file) this # value is not decisive as it is used as a last resort host regardless. # However, you must set it for any further virtual host explicitly. ServerName www.example.com ServerAlias example.com SetOutputFilter DEFLATE # Do not attempt to compress the following extensions SetEnvIfNoCase Request_URI \ \.(?:gif|jpe?g|png|swf|flv|zip|gz|tar|mp3|mp4|m4v)$ no-gzip dont-vary ServerAdmin webmaster@localhost DocumentRoot /var/www/proof # Available loglevels: trace8, ..., trace1, debug, info, notice, warn, # error, crit, alert, emerg. # It is also possible to configure the loglevel for particular # modules, e.g. #LogLevel info ssl:warn ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined # For most configuration files from conf-available/, which are # enabled or disabled at a global level, it is possible to # include a line for only one particular virtual host. For example the # following line enables the CGI configuration for this host only # after it has been globally disabled with "a2disconf". #Include conf-available/serve-cgi-bin.conf # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/apache-conf-files/passing/example-ssl.conf0000644000076500000240000001506700000000000024311 0ustar00bmwstaff ServerName example.com ServerAlias www.example.com ServerAdmin webmaster@localhost DocumentRoot /var/www/html # Available loglevels: trace8, ..., trace1, debug, info, notice, warn, # error, crit, alert, emerg. # It is also possible to configure the loglevel for particular # modules, e.g. #LogLevel info ssl:warn ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined # For most configuration files from conf-available/, which are # enabled or disabled at a global level, it is possible to # include a line for only one particular virtual host. For example the # following line enables the CGI configuration for this host only # after it has been globally disabled with "a2disconf". #Include conf-available/serve-cgi-bin.conf # SSL Engine Switch: # Enable/Disable SSL for this virtual host. SSLEngine on # A self-signed (snakeoil) certificate can be created by installing # the ssl-cert package. See # /usr/share/doc/apache2/README.Debian.gz for more info. # If both key and certificate are stored in the same file, only the # SSLCertificateFile directive is needed. SSLCertificateFile /etc/ssl/certs/ssl-cert-snakeoil.pem SSLCertificateKeyFile /etc/ssl/private/ssl-cert-snakeoil.key # Server Certificate Chain: # Point SSLCertificateChainFile at a file containing the # concatenation of PEM encoded CA certificates which form the # certificate chain for the server certificate. Alternatively # the referenced file can be the same as SSLCertificateFile # when the CA certificates are directly appended to the server # certificate for convenience. #SSLCertificateChainFile /etc/apache2/ssl.crt/server-ca.crt # Certificate Authority (CA): # Set the CA certificate verification path where to find CA # certificates for client authentication or alternatively one # huge file containing all of them (file must be PEM encoded) # Note: Inside SSLCACertificatePath you need hash symlinks # to point to the certificate files. Use the provided # Makefile to update the hash symlinks after changes. #SSLCACertificatePath /etc/ssl/certs/ #SSLCACertificateFile /etc/apache2/ssl.crt/ca-bundle.crt # Certificate Revocation Lists (CRL): # Set the CA revocation path where to find CA CRLs for client # authentication or alternatively one huge file containing all # of them (file must be PEM encoded) # Note: Inside SSLCARevocationPath you need hash symlinks # to point to the certificate files. Use the provided # Makefile to update the hash symlinks after changes. #SSLCARevocationPath /etc/apache2/ssl.crl/ #SSLCARevocationFile /etc/apache2/ssl.crl/ca-bundle.crl # Client Authentication (Type): # Client certificate verification type and depth. Types are # none, optional, require and optional_no_ca. Depth is a # number which specifies how deeply to verify the certificate # issuer chain before deciding the certificate is not valid. #SSLVerifyClient require #SSLVerifyDepth 10 # SSL Engine Options: # Set various options for the SSL engine. # o FakeBasicAuth: # Translate the client X.509 into a Basic Authorisation. This means that # the standard Auth/DBMAuth methods can be used for access control. The # user name is the `one line' version of the client's X.509 certificate. # Note that no password is obtained from the user. Every entry in the user # file needs this password: `xxj31ZMTZzkVA'. # o ExportCertData: # This exports two additional environment variables: SSL_CLIENT_CERT and # SSL_SERVER_CERT. These contain the PEM-encoded certificates of the # server (always existing) and the client (only existing when client # authentication is used). This can be used to import the certificates # into CGI scripts. # o StdEnvVars: # This exports the standard SSL/TLS related `SSL_*' environment variables. # Per default this exportation is switched off for performance reasons, # because the extraction step is an expensive operation and is usually # useless for serving static content. So one usually enables the # exportation for CGI and SSI requests only. # o OptRenegotiate: # This enables optimized SSL connection renegotiation handling when SSL # directives are used in per-directory context. #SSLOptions +FakeBasicAuth +ExportCertData +StrictRequire SSLOptions +StdEnvVars SSLOptions +StdEnvVars # SSL Protocol Adjustments: # The safe and default but still SSL/TLS standard compliant shutdown # approach is that mod_ssl sends the close notify alert but doesn't wait for # the close notify alert from client. When you need a different shutdown # approach you can use one of the following variables: # o ssl-unclean-shutdown: # This forces an unclean shutdown when the connection is closed, i.e. no # SSL close notify alert is send or allowed to received. This violates # the SSL/TLS standard but is needed for some brain-dead browsers. Use # this when you receive I/O errors because of the standard approach where # mod_ssl sends the close notify alert. # o ssl-accurate-shutdown: # This forces an accurate shutdown when the connection is closed, i.e. a # SSL close notify alert is send and mod_ssl waits for the close notify # alert of the client. This is 100% SSL/TLS standard compliant, but in # practice often causes hanging connections with brain-dead browsers. Use # this only for browsers where you know that their SSL implementation # works correctly. # Notice: Most problems of broken clients are also related to the HTTP # keep-alive facility, so you usually additionally want to disable # keep-alive for those clients, too. Use variable "nokeepalive" for this. # Similarly, one has to force some clients to use HTTP/1.0 to workaround # their broken HTTP/1.1 implementation. Use variables "downgrade-1.0" and # "force-response-1.0" for this. BrowserMatch "MSIE [2-6]" \ nokeepalive ssl-unclean-shutdown \ downgrade-1.0 force-response-1.0 # MSIE 7 and newer should be able to use keepalive BrowserMatch "MSIE [17-9]" ssl-unclean-shutdown # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/apache-conf-files/passing/example.conf0000644000076500000240000000251700000000000023506 0ustar00bmwstaff # The ServerName directive sets the request scheme, hostname and port that # the server uses to identify itself. This is used when creating # redirection URLs. In the context of virtual hosts, the ServerName # specifies what hostname must appear in the request's Host: header to # match this virtual host. For the default virtual host (this file) this # value is not decisive as it is used as a last resort host regardless. # However, you must set it for any further virtual host explicitly. ServerName www.example.com ServerAlias example.com ServerAdmin webmaster@localhost DocumentRoot /var/www/html # Available loglevels: trace8, ..., trace1, debug, info, notice, warn, # error, crit, alert, emerg. # It is also possible to configure the loglevel for particular # modules, e.g. #LogLevel info ssl:warn ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined # For most configuration files from conf-available/, which are # enabled or disabled at a global level, it is possible to # include a line for only one particular virtual host. For example the # following line enables the CGI configuration for this host only # after it has been globally disabled with "a2disconf". #Include conf-available/serve-cgi-bin.conf # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/apache-conf-files/passing/finalize-1243.apache2.conf.txt0000644000076500000240000001606200000000000026363 0ustar00bmwstaff# This is the main Apache server configuration file. It contains the # configuration directives that give the server its instructions. # See http://httpd.apache.org/docs/2.4/ for detailed information about # the directives and /usr/share/doc/apache2/README.Debian about Debian specific # hints. # # # Summary of how the Apache 2 configuration works in Debian: # The Apache 2 web server configuration in Debian is quite different to # upstream's suggested way to configure the web server. This is because Debian's # default Apache2 installation attempts to make adding and removing modules, # virtual hosts, and extra configuration directives as flexible as possible, in # order to make automating the changes and administering the server as easy as # possible. # It is split into several files forming the configuration hierarchy outlined # below, all located in the /etc/apache2/ directory: # # /etc/apache2/ # |-- apache2.conf # | `-- ports.conf # |-- mods-enabled # | |-- *.load # | `-- *.conf # |-- conf-enabled # | `-- *.conf # `-- sites-enabled # `-- *.conf # # # * apache2.conf is the main configuration file (this file). It puts the pieces # together by including all remaining configuration files when starting up the # web server. # # * ports.conf is always included from the main configuration file. It is # supposed to determine listening ports for incoming connections which can be # customized anytime. # # * Configuration files in the mods-enabled/, conf-enabled/ and sites-enabled/ # directories contain particular configuration snippets which manage modules, # global configuration fragments, or virtual host configurations, # respectively. # # They are activated by symlinking available configuration files from their # respective *-available/ counterparts. These should be managed by using our # helpers a2enmod/a2dismod, a2ensite/a2dissite and a2enconf/a2disconf. See # their respective man pages for detailed information. # # * The binary is called apache2. Due to the use of environment variables, in # the default configuration, apache2 needs to be started/stopped with # /etc/init.d/apache2 or apache2ctl. Calling /usr/bin/apache2 directly will not # work with the default configuration. # Global configuration # # # ServerRoot: The top of the directory tree under which the server's # configuration, error, and log files are kept. # # NOTE! If you intend to place this on an NFS (or otherwise network) # mounted filesystem then please read the Mutex documentation (available # at ); # you will save yourself a lot of trouble. # # Do NOT add a slash at the end of the directory path. # #ServerRoot "/etc/apache2" # # The accept serialization lock file MUST BE STORED ON A LOCAL DISK. # Mutex file:${APACHE_LOCK_DIR} default # # PidFile: The file in which the server should record its process # identification number when it starts. # This needs to be set in /etc/apache2/envvars # PidFile ${APACHE_PID_FILE} # # Timeout: The number of seconds before receives and sends time out. # Timeout 300 # # KeepAlive: Whether or not to allow persistent connections (more than # one request per connection). Set to "Off" to deactivate. # KeepAlive On # # MaxKeepAliveRequests: The maximum number of requests to allow # during a persistent connection. Set to 0 to allow an unlimited amount. # We recommend you leave this number high, for maximum performance. # MaxKeepAliveRequests 100 # # KeepAliveTimeout: Number of seconds to wait for the next request from the # same client on the same connection. # KeepAliveTimeout 5 # These need to be set in /etc/apache2/envvars User ${APACHE_RUN_USER} Group ${APACHE_RUN_GROUP} # # HostnameLookups: Log the names of clients or just their IP addresses # e.g., www.apache.org (on) or 204.62.129.132 (off). # The default is off because it'd be overall better for the net if people # had to knowingly turn this feature on, since enabling it means that # each client request will result in AT LEAST one lookup request to the # nameserver. # HostnameLookups Off # ErrorLog: The location of the error log file. # If you do not specify an ErrorLog directive within a # container, error messages relating to that virtual host will be # logged here. If you *do* define an error logfile for a # container, that host's errors will be logged there and not here. # ErrorLog ${APACHE_LOG_DIR}/error.log # # LogLevel: Control the severity of messages logged to the error_log. # Available values: trace8, ..., trace1, debug, info, notice, warn, # error, crit, alert, emerg. # It is also possible to configure the log level for particular modules, e.g. # "LogLevel info ssl:warn" # LogLevel warn # Include module configuration: IncludeOptional mods-enabled/*.load IncludeOptional mods-enabled/*.conf # Include list of ports to listen on Include ports.conf # Sets the default security model of the Apache2 HTTPD server. It does # not allow access to the root filesystem outside of /usr/share and /var/www. # The former is used by web applications packaged in Debian, # the latter may be used for local directories served by the web server. If # your system is serving content from a sub-directory in /srv you must allow # access here, or in any related virtual host. Options FollowSymLinks AllowOverride None Require all denied AllowOverride None Require all granted Options Indexes FollowSymLinks AllowOverride None Require all granted # # Options Indexes FollowSymLinks # AllowOverride None # Require all granted # # AccessFileName: The name of the file to look for in each directory # for additional configuration directives. See also the AllowOverride # directive. # AccessFileName .htaccess # # The following lines prevent .htaccess and .htpasswd files from being # viewed by Web clients. # Require all denied # # The following directives define some format nicknames for use with # a CustomLog directive. # # These deviate from the Common Log Format definitions in that they use %O # (the actual bytes sent including headers) instead of %b (the size of the # requested file), because the latter makes it impossible to detect partial # requests. # # Note that the use of %{X-Forwarded-For}i instead of %h is not recommended. # Use mod_remoteip instead. # #LogFormat "%v:%p %h %l %u %t \"%r\" %>s %O \"%{Referer}i\" \"%{User-Agent}i\"" vhost_combined LogFormat "%t \"%r\" %>s %O \"%{User-Agent}i\"" vhost_combined #LogFormat "%h %l %u %t \"%r\" %>s %O \"%{Referer}i\" \"%{User-Agent}i\"" combined #LogFormat "%h %l %u %t \"%r\" %>s %O" common LogFormat "- %t \"%r\" %>s %b" noip LogFormat "%{Referer}i -> %U" referer LogFormat "%{User-agent}i" agent # Include of directories ignores editors' and dpkg's backup files, # see README.Debian for details. # Include generic snippets of statements IncludeOptional conf-enabled/*.conf # Include the virtual host configurations: #IncludeOptional sites-enabled/*.conf # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/apache-conf-files/passing/finalize-1243.conf0000644000076500000240000000435000000000000024240 0ustar00bmwstaff#LoadModule ssl_module modules/mod_ssl.so Listen 4443 # The ServerName directive sets the request scheme, hostname and port that # the server uses to identify itself. This is used when creating # redirection URLs. In the context of virtual hosts, the ServerName # specifies what hostname must appear in the request's Host: header to # match this virtual host. For the default virtual host (this file) this # value is not decisive as it is used as a last resort host regardless. # However, you must set it for any further virtual host explicitly. ServerName www.eiserneketten.de SSLEngine on ServerAdmin webmaster@localhost DocumentRoot /var/www/html # Available loglevels: trace8, ..., trace1, debug, info, notice, warn, # error, crit, alert, emerg. # It is also possible to configure the loglevel for particular # modules, e.g. #LogLevel info ssl:warn ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log noip # For most configuration files from conf-available/, which are # enabled or disabled at a global level, it is possible to # include a line for only one particular virtual host. For example the # following line enables the CGI configuration for this host only # after it has been globally disabled with "a2disconf". #Include conf-available/serve-cgi-bin.conf Options FollowSymLinks AllowOverride None Order Deny,Allow #Deny from All Alias / /eiserneketten/pages/eiserneketten.html SSLCertificateFile /etc/ssl/certs/ssl-cert-snakeoil.pem SSLCertificateKeyFile /etc/ssl/private/ssl-cert-snakeoil.key SSLCertificateChainFile /etc/ssl/certs/ssl-cert-snakeoil.pem Include /etc/letsencrypt/options-ssl-apache.conf # vim: syntax=apache ts=4 sw=4 sts=4 sr noet # # Directives to allow use of AWStats as a CGI # Alias /awstatsclasses "/usr/local/awstats/wwwroot/classes/" Alias /awstatscss "/usr/local/awstats/wwwroot/css/" Alias /awstatsicons "/usr/local/awstats/wwwroot/icon/" ScriptAlias /awstats/ "/usr/local/awstats/wwwroot/cgi-bin/" # # This is to permit URL access to scripts/files in AWStats directory. # Options None AllowOverride None Order allow,deny Allow from all ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/apache-conf-files/passing/graphite-quote-1934.conf0000644000076500000240000000140700000000000025404 0ustar00bmwstaff WSGIDaemonProcess _graphite processes=5 threads=5 display-name='%{GROUP}' inactivity-timeout=120 user=www-data group=www-data WSGIProcessGroup _graphite WSGIImportScript /usr/share/graphite-web/graphite.wsgi process-group=_graphite application-group=%{GLOBAL} WSGIScriptAlias / /usr/share/graphite-web/graphite.wsgi Alias /content/ /usr/share/graphite-web/static/ SetHandler None ErrorLog ${APACHE_LOG_DIR}/graphite-web_error.log # Possible values include: debug, info, notice, warn, error, crit, # alert, emerg. LogLevel warn CustomLog ${APACHE_LOG_DIR}/graphite-web_access.log combined ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/apache-conf-files/passing/ipv6-1143.conf0000644000076500000240000000032400000000000023317 0ustar00bmwstaff DocumentRoot /tmp ServerName example.com ServerAlias www.example.com CustomLog ${APACHE_LOG_DIR}/example.log combined AllowOverride All ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/apache-conf-files/passing/ipv6-1143b.conf0000644000076500000240000000116300000000000023463 0ustar00bmwstaff DocumentRoot /tmp ServerName example.com ServerAlias www.example.com CustomLog ${APACHE_LOG_DIR}/example.log combined AllowOverride All SSLEngine on SSLHonorCipherOrder On SSLProtocol all -SSLv2 -SSLv3 SSLCipherSuite "EECDH+ECDSA+AESGCM EECDH+aRSA+AESGCM EECDH+ECDSA+SHA384 EECDH+ECDSA+SHA256 EECDH+aRSA+SHA384 EECDH+aRSA+SHA256 EECDH+aRSA+RC4 EECDH EDH +aRSA RC4 !aNULL !eNULL !LOW !3DES !MD5 !EXP !PSK !SRP !DSS" SSLCertificateFile /etc/ssl/certs/ssl-cert-snakeoil.pem SSLCertificateKeyFile /etc/ssl/private/ssl-cert-snakeoil.key ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/apache-conf-files/passing/ipv6-1143c.conf0000644000076500000240000000032400000000000023462 0ustar00bmwstaff DocumentRoot /tmp ServerName example.com ServerAlias www.example.com CustomLog ${APACHE_LOG_DIR}/example.log combined AllowOverride All ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/apache-conf-files/passing/ipv6-1143d.conf0000644000076500000240000000116300000000000023465 0ustar00bmwstaff DocumentRoot /tmp ServerName example.com ServerAlias www.example.com CustomLog ${APACHE_LOG_DIR}/example.log combined AllowOverride All SSLEngine on SSLHonorCipherOrder On SSLProtocol all -SSLv2 -SSLv3 SSLCipherSuite "EECDH+ECDSA+AESGCM EECDH+aRSA+AESGCM EECDH+ECDSA+SHA384 EECDH+ECDSA+SHA256 EECDH+aRSA+SHA384 EECDH+aRSA+SHA256 EECDH+aRSA+RC4 EECDH EDH +aRSA RC4 !aNULL !eNULL !LOW !3DES !MD5 !EXP !PSK !SRP !DSS" SSLCertificateFile /etc/ssl/certs/ssl-cert-snakeoil.pem SSLCertificateKeyFile /etc/ssl/private/ssl-cert-snakeoil.key ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/apache-conf-files/passing/missing-quote-1724.conf0000644000076500000240000000334700000000000025254 0ustar00bmwstaff ServerAdmin webmaster@localhost ServerAlias www.example.com ServerName example.com DocumentRoot /var/www/example.com/www/ SSLEngine on SSLProtocol all -SSLv2 -SSLv3 SSLCipherSuite "EECDH+ECDSA+AESGCM EECDH+aRSA+AESGCM EECDH+ECDSA+SHA384 EECDH+ECDSA+SHA256 EECDH+aRS$ SSLCertificateFile /etc/ssl/certs/ssl-cert-snakeoil.pem SSLCertificateKeyFile /etc/ssl/private/ssl-cert-snakeoil.key Options FollowSymLinks AllowOverride All Options Indexes FollowSymLinks MultiViews AllowOverride All Order allow,deny allow from all # This directive allows us to have apache2's default start page # in /apache2-default/, but still have / go to the right place ScriptAlias /cgi-bin/ /usr/lib/cgi-bin/ AllowOverride None Options +ExecCGI -MultiViews +SymLinksIfOwnerMatch Order allow,deny Allow from all ErrorLog /var/log/apache2/error.log # Possible values include: debug, info, notice, warn, error, crit, # alert, emerg. LogLevel warn CustomLog /var/log/apache2/access.log combined ServerSignature On Alias /apache_doc/ "/usr/share/doc/" Options Indexes MultiViews FollowSymLinks AllowOverride None Order deny,allow Deny from all Allow from 127.0.0.0/255.0.0.0 ::1/128 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/apache-conf-files/passing/modmacro-1385.conf0000644000076500000240000000333600000000000024252 0ustar00bmwstaff # The ServerName directive sets the request scheme, hostname and port that # the server uses to identify itself. This is used when creating # redirection URLs. In the context of virtual hosts, the ServerName # specifies what hostname must appear in the request's Host: header to # match this virtual host. For the default virtual host (this file) this # value is not decisive as it is used as a last resort host regardless. # However, you must set it for any further virtual host explicitly. ServerName $host ServerAdmin webmaster@localhost DocumentRoot $dir # Available loglevels: trace8, ..., trace1, debug, info, notice, warn, # error, crit, alert, emerg. # It is also possible to configure the loglevel for particular # modules, e.g. #LogLevel info ssl:warn ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined # For most configuration files from conf-available/, which are # enabled or disabled at a global level, it is possible to # include a line for only one particular virtual host. For example the # following line enables the CGI configuration for this host only # after it has been globally disabled with "a2disconf". #Include conf-available/serve-cgi-bin.conf Use Vhost goxogle.com 80 /var/www/goxogle/ # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/apache-conf-files/passing/owncloud-1264.conf0000644000076500000240000000044000000000000024270 0ustar00bmwstaffAlias /owncloud /usr/share/owncloud Options +FollowSymLinks AllowOverride All order allow,deny allow from all = 2.3> Require all granted ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/apache-conf-files/passing/rewrite-quote-1960.conf0000644000076500000240000000044200000000000025257 0ustar00bmwstaff RewriteEngine On RewriteCond %{REQUEST_URI} ^.*(,|;|:|<|>|">|"<|/|\\\.\.\\).* [NC,OR] RewriteCond %{REQUEST_URI} ^.*(\=|\@|\[|\]|\^|\`|\{|\}|\~).* [NC,OR] RewriteCond %{REQUEST_URI} ^.*(\'|%0A|%0D|%27|%3C|%3E|%00).* [NC] RewriteRule ^(.*)$ - [F,L] ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/apache-conf-files/passing/roundcube-1222.conf0000644000076500000240000000312500000000000024421 0ustar00bmwstaff# Those aliases do not work properly with several hosts on your apache server # Uncomment them to use it or adapt them to your configuration # Alias /roundcube/program/js/tiny_mce/ /usr/share/tinymce/www/ # Alias /roundcube /var/lib/roundcube # Access to tinymce files Options Indexes MultiViews FollowSymLinks AllowOverride None = 2.3> Require all granted Order allow,deny Allow from all Options +FollowSymLinks # This is needed to parse /var/lib/roundcube/.htaccess. See its # content before setting AllowOverride to None. AllowOverride All = 2.3> Require all granted Order allow,deny Allow from all # Protecting basic directories: Options -FollowSymLinks AllowOverride None Options -FollowSymLinks AllowOverride None = 2.3> Require all denied Order allow,deny Deny from all Options -FollowSymLinks AllowOverride None = 2.3> Require all denied Order allow,deny Deny from all ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/apache-conf-files/passing/section-continuations-2525.conf0000644000076500000240000001310500000000000027000 0ustar00bmwstaff NameVirtualHost 0.0.0.0:7080 NameVirtualHost [00000:000:000:000::0]:7080 NameVirtualHost 0.0.0.0:7080 NameVirtualHost 127.0.0.1:7080 NameVirtualHost 0.0.0.0:7081 NameVirtualHost [0000:000:000:000::2]:7081 NameVirtualHost 0.0.0.0:7081 NameVirtualHost 127.0.0.1:7081 ServerName "example.com" ServerAdmin "srv@example.com" DocumentRoot /tmp LogFormat "%a %l %u %t \"%r\" %>s %O \"%{Referer}i\" \"%{User-Agent}i\"" plesklog LogFormat "%a %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\"" plesklog TraceEnable off ServerTokens ProductOnly AllowOverride "All" Options SymLinksIfOwnerMatch Order allow,deny Allow from all php_admin_flag engine off php_admin_flag engine off AllowOverride "All" Options SymLinksIfOwnerMatch Order allow,deny Allow from all php_admin_flag engine off php_admin_flag engine off Header add X-Powered-By PleskLin SecRuleEngine DetectionOnly SecRequestBodyAccess On SecRequestBodyLimit 134217728 SecResponseBodyAccess Off SecResponseBodyLimit 524288 SecAuditEngine On SecAuditLog "/var/log/modsec_audit.log" SecAuditLogType serial #Include "/etc/httpd/conf/plesk.conf.d/ip_default/*.conf" ServerName "default" UseCanonicalName Off DocumentRoot /tmp ScriptAlias "/cgi-bin/" "/var/www/vhosts/default/cgi-bin" SSLEngine off AllowOverride None Options None Order allow,deny Allow from all php_admin_flag engine on php_admin_flag engine on ServerName "default-0_0_0_0" UseCanonicalName Off DocumentRoot /tmp ScriptAlias "/cgi-bin/" "/var/www/vhosts/default/cgi-bin" SSLEngine on SSLVerifyClient none SSLCertificateFile /etc/ssl/certs/ssl-cert-snakeoil.pem AllowOverride None Options None Order allow,deny Allow from all php_admin_flag engine on php_admin_flag engine on ServerName "default-0000_000_000_00000__2" UseCanonicalName Off DocumentRoot /tmp ScriptAlias "/cgi-bin/" "/var/www/vhosts/default/cgi-bin" SSLEngine on SSLVerifyClient none SSLCertificateFile /etc/ssl/certs/ssl-cert-snakeoil.pem AllowOverride None Options None Order allow,deny Allow from all php_admin_flag engine on php_admin_flag engine on ServerName "default-0_0_0_0" UseCanonicalName Off DocumentRoot /tmp ScriptAlias "/cgi-bin/" "/var/www/vhosts/default/cgi-bin" SSLEngine on SSLVerifyClient none SSLCertificateFile /etc/ssl/certs/ssl-cert-snakeoil.pem #SSLCACertificateFile "/usr/local/psa/var/certificates/cert-nLy6Z1" AllowOverride None Options None Order allow,deny Allow from all php_admin_flag engine on php_admin_flag engine on DocumentRoot /tmp ServerName lists ServerAlias lists.* UseCanonicalName Off ScriptAlias "/mailman/" "/usr/lib/mailman/cgi-bin/" Alias "/icons/" "/var/www/icons/" Alias "/pipermail/" "/var/lib/mailman/archives/public/" SSLEngine off Options FollowSymLinks Order allow,deny Allow from all DocumentRoot /tmp ServerName lists ServerAlias lists.* UseCanonicalName Off ScriptAlias "/mailman/" "/usr/lib/mailman/cgi-bin/" Alias "/icons/" "/var/www/icons/" Alias "/pipermail/" "/var/lib/mailman/archives/public/" SSLEngine on SSLVerifyClient none SSLCertificateFile /etc/ssl/certs/ssl-cert-snakeoil.pem Options FollowSymLinks Order allow,deny Allow from all RPAFproxy_ips 0.0.0.0 [00000:000:000:00000::2] 0.0.0.0 RPAFproxy_ips 0.0.0.0 [0000:000:000:0000::2] 0.0.0.0 RemoteIPInternalProxy 0.0.0.0 [0000:000:000:0000::2] 0.0.0.0 RemoteIPHeader X-Forwarded-For ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/apache-conf-files/passing/section-empty-continuations-2731.conf0000644000076500000240000001237700000000000030145 0ustar00bmwstaff#ATTENTION! # #DO NOT MODIFY THIS FILE BECAUSE IT WAS GENERATED AUTOMATICALLY, #SO ALL YOUR CHANGES WILL BE LOST THE NEXT TIME THE FILE IS GENERATED. NameVirtualHost 192.168.100.218:80 NameVirtualHost 10.128.178.192:80 NameVirtualHost 192.168.100.218:443 NameVirtualHost 10.128.178.192:443 ServerName "254020-web1.example.com" ServerAdmin "name@example.com" DocumentRoot "/tmp" LogFormat "%h %l %u %t \"%r\" %>s %O \"%{Referer}i\" \"%{User-Agent}i\"" plesklog LogFormat "%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\"" plesklog TraceEnable off ServerTokens ProductOnly AllowOverride "All" Options SymLinksIfOwnerMatch Order allow,deny Allow from all php_admin_flag engine off php_admin_flag engine off AllowOverride All Options SymLinksIfOwnerMatch Order allow,deny Allow from all php_admin_flag engine off php_admin_flag engine off Header add X-Powered-By PleskLin JkWorkersFile "/etc/httpd/conf/workers.properties" JkLogFile /var/log/httpd/mod_jk.log JkLogLevel info #Include "/etc/httpd/conf/plesk.conf.d/ip_default/*.conf" ServerName "default" UseCanonicalName Off DocumentRoot "/tmp" ScriptAlias /cgi-bin/ "/var/www/vhosts/default/cgi-bin" SSLEngine off AllowOverride None Options None Order allow,deny Allow from all php_admin_flag engine on php_admin_flag engine on ServerName "default-192_168_100_218" UseCanonicalName Off DocumentRoot "/tmp" ScriptAlias /cgi-bin/ "/var/www/vhosts/default/cgi-bin" SSLEngine on SSLVerifyClient none #SSLCertificateFile "/usr/local/psa/var/certificates/cert-9MgutN" #SSLCACertificateFile "/usr/local/psa/var/certificates/cert-s6Wx3P" AllowOverride None Options None Order allow,deny Allow from all php_admin_flag engine on php_admin_flag engine on ServerName "default-10_128_178_192" UseCanonicalName Off DocumentRoot "/tmp" ScriptAlias /cgi-bin/ "/var/www/vhosts/default/cgi-bin" SSLEngine on SSLVerifyClient none #SSLCertificateFile "/usr/local/psa/var/certificates/certxfb6025" AllowOverride None Options None Order allow,deny Allow from all php_admin_flag engine on php_admin_flag engine on DocumentRoot "/tmp" ServerName lists ServerAlias lists.* UseCanonicalName Off ScriptAlias "/mailman/" "/usr/lib/mailman/cgi-bin/" Alias "/icons/" "/var/www/icons/" Alias "/pipermail/" "/var/lib/mailman/archives/public/" SSLEngine off Options FollowSymLinks Order allow,deny Allow from all DocumentRoot "/tmp" ServerName lists ServerAlias lists.* UseCanonicalName Off ScriptAlias "/mailman/" "/usr/lib/mailman/cgi-bin/" Alias "/icons/" "/var/www/icons/" Alias "/pipermail/" "/var/lib/mailman/archives/public/" SSLEngine on SSLVerifyClient none #SSLCertificateFile "/usr/local/psa/var/certificates/certxfb6025" Options FollowSymLinks Order allow,deny Allow from all RPAFproxy_ips 192.168.100.218 10.128.178.192 RPAFproxy_ips 192.168.100.218 10.128.178.192 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/apache-conf-files/passing/semacode-1598.conf0000644000076500000240000000275300000000000024241 0ustar00bmwstaff ServerName semacode.com ServerAlias www.semacode.com DocumentRoot /tmp/ TransferLog /tmp/access ErrorLog /tmp/error Redirect /posts/rss http://semacode.com/feed Redirect permanent /weblog http://semacode.com/blog #ProxyPreserveHost On # ProxyPass /past http://old.semacode.com #ProxyPassReverse /past http://old.semacode.com # # Order allow,deny #Allow from all # Redirect /stylesheets/inside.css http://old.semacode.com/stylesheets/inside.css RedirectMatch /images/portal/(.*) http://old.semacode.com/images/portal/$1 Redirect /images/invisible.gif http://old.semacode.com/images/invisible.gif RedirectMatch /javascripts/(.*) http://old.semacode.com/javascripts/$1 RewriteEngine on RewriteRule ^/past/(.*) http://old.semacode.com/past/$1 [L,P] RewriteCond %{HTTP_HOST} !^semacode\.com$ [NC] RewriteCond %{HTTP_HOST} !^$ RewriteRule ^/(.*) http://semacode.com/$1 [L,R] ServerName old.semacode.com ServerAlias www.old.semacode.com DocumentRoot /home/simon/semacode-server/semacode/website/trunk/public TransferLog /tmp/access-old ErrorLog /tmp/error-old Options FollowSymLinks AllowOverride None Order allow,deny Allow from all ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/apache-conf-files/passing/sslrequire-wordlist-1827.htaccess0000644000076500000240000000010300000000000027352 0ustar00bmwstaffSSLRequire %{SSL_CLIENT_S_DN_CN} in {"foo@bar.com", "bar@foo.com"} ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/apache-conf-files/passing/two-blocks-one-line-1693.conf0000644000076500000240000000254200000000000026241 0ustar00bmwstaff ServerAdmin info@somethingnewentertainment.com ServerName somethingnewentertainment.com DocumentRoot /var/www/html ErrorLog /var/log/apache2/error.log CustomLog /var/log/apache2/access.log combined SSLEngine on SSLProtocol all -SSLv2 -SSLv3 SSLHonorCipherOrder on SSLCipherSuite "EECDH+ECDSA+AESGCM EECDH+aRSA+AESGCM EECDH+ECDSA+SHA384 EEC DH+ECDSA+SHA256 EECDH+aRSA+SHA384 EECDH+aRSA+SHA256 EECDH+aRSA+RC4 EECDH EDH+aRS A RC4 !aNULL !eNULL !LOW !3DES !MD5 !EXP !PSK !SRP !DSS !RC4" SSLCertificateFile /etc/ssl/certs/ssl-cert-snakeoil.pem SSLCertificateKeyFile /etc/ssl/private/ssl-cert-snakeoil.key SSLOptions +StdEnvVars SSLOptions +StdEnvVars BrowserMatch "MSIE [2-6]" \ nokeepalive ssl-unclean-shutdown \ downgrade-1.0 force-response-1.0 BrowserMatch "MSIE [17-9]" ssl-unclean-shutdown ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/augeasnode_test.py0000644000076500000240000003213200000000000020014 0ustar00bmwstaff"""Tests for AugeasParserNode classes""" from typing import List try: import mock except ImportError: # pragma: no cover from unittest import mock # type: ignore import os import util from certbot import errors from certbot_apache._internal import assertions from certbot_apache._internal import augeasparser def _get_augeasnode_mock(filepath): """ Helper function for mocking out DualNode instance with an AugeasNode """ def augeasnode_mock(metadata): return augeasparser.AugeasBlockNode( name=assertions.PASS, ancestor=None, filepath=filepath, metadata=metadata) return augeasnode_mock class AugeasParserNodeTest(util.ApacheTest): # pylint: disable=too-many-public-methods """Test AugeasParserNode using available test configurations""" def setUp(self): # pylint: disable=arguments-differ super().setUp() with mock.patch("certbot_apache._internal.configurator.ApacheConfigurator.get_parsernode_root") as mock_parsernode: mock_parsernode.side_effect = _get_augeasnode_mock( os.path.join(self.config_path, "apache2.conf")) self.config = util.get_apache_configurator( self.config_path, self.vhost_path, self.config_dir, self.work_dir, use_parsernode=True) self.vh_truth = util.get_vh_truth( self.temp_dir, "debian_apache_2_4/multiple_vhosts") def test_save(self): with mock.patch('certbot_apache._internal.parser.ApacheParser.save') as mock_save: self.config.parser_root.save("A save message") self.assertTrue(mock_save.called) self.assertEqual(mock_save.call_args[0][0], "A save message") def test_unsaved_files(self): with mock.patch('certbot_apache._internal.parser.ApacheParser.unsaved_files') as mock_uf: mock_uf.return_value = ["first", "second"] files = self.config.parser_root.unsaved_files() self.assertEqual(files, ["first", "second"]) def test_get_block_node_name(self): from certbot_apache._internal.augeasparser import AugeasBlockNode block = AugeasBlockNode( name=assertions.PASS, ancestor=None, filepath=assertions.PASS, metadata={"augeasparser": mock.Mock(), "augeaspath": "/files/anything"} ) testcases = { "/some/path/FirstNode/SecondNode": "SecondNode", "/some/path/FirstNode/SecondNode/": "SecondNode", "OnlyPathItem": "OnlyPathItem", "/files/etc/apache2/apache2.conf/VirtualHost": "VirtualHost", "/Anything": "Anything", } for test in testcases: self.assertEqual(block._aug_get_name(test), testcases[test]) # pylint: disable=protected-access def test_find_blocks(self): blocks = self.config.parser_root.find_blocks("VirtualHost", exclude=False) self.assertEqual(len(blocks), 12) def test_find_blocks_case_insensitive(self): vhs = self.config.parser_root.find_blocks("VirtualHost") vhs2 = self.config.parser_root.find_blocks("viRtuAlHoST") self.assertEqual(len(vhs), len(vhs2)) def test_find_directive_found(self): directives = self.config.parser_root.find_directives("Listen") self.assertEqual(len(directives), 1) self.assertTrue(directives[0].filepath.endswith("/apache2/ports.conf")) self.assertEqual(directives[0].parameters, (u'80',)) def test_find_directive_notfound(self): directives = self.config.parser_root.find_directives("Nonexistent") self.assertEqual(len(directives), 0) def test_find_directive_from_block(self): blocks = self.config.parser_root.find_blocks("virtualhost") found = False for vh in blocks: if vh.filepath.endswith("sites-enabled/certbot.conf"): servername = vh.find_directives("servername") self.assertEqual(servername[0].parameters[0], "certbot.demo") found = True self.assertTrue(found) def test_find_comments(self): rootcomment = self.config.parser_root.find_comments( "This is the main Apache server configuration file. " ) self.assertEqual(len(rootcomment), 1) self.assertTrue(rootcomment[0].filepath.endswith( "debian_apache_2_4/multiple_vhosts/apache2/apache2.conf" )) def test_set_parameters(self): servernames = self.config.parser_root.find_directives("servername") names: List[str] = [] for servername in servernames: names += servername.parameters self.assertFalse("going_to_set_this" in names) servernames[0].set_parameters(["something", "going_to_set_this"]) servernames = self.config.parser_root.find_directives("servername") names = [] for servername in servernames: names += servername.parameters self.assertTrue("going_to_set_this" in names) def test_set_parameters_atinit(self): from certbot_apache._internal.augeasparser import AugeasDirectiveNode servernames = self.config.parser_root.find_directives("servername") setparam = "certbot_apache._internal.augeasparser.AugeasDirectiveNode.set_parameters" with mock.patch(setparam) as mock_set: AugeasDirectiveNode( name=servernames[0].name, parameters=["test", "setting", "these"], ancestor=assertions.PASS, metadata=servernames[0].metadata ) self.assertTrue(mock_set.called) self.assertEqual( mock_set.call_args_list[0][0][0], ["test", "setting", "these"] ) def test_set_parameters_delete(self): # Set params servername = self.config.parser_root.find_directives("servername")[0] servername.set_parameters(["thisshouldnotexistpreviously", "another", "third"]) # Delete params servernames = self.config.parser_root.find_directives("servername") found = False for servername in servernames: if "thisshouldnotexistpreviously" in servername.parameters: self.assertEqual(len(servername.parameters), 3) servername.set_parameters(["thisshouldnotexistpreviously"]) found = True self.assertTrue(found) # Verify params servernames = self.config.parser_root.find_directives("servername") found = False for servername in servernames: if "thisshouldnotexistpreviously" in servername.parameters: self.assertEqual(len(servername.parameters), 1) servername.set_parameters(["thisshouldnotexistpreviously"]) found = True self.assertTrue(found) def test_add_child_comment(self): newc = self.config.parser_root.add_child_comment("The content") comments = self.config.parser_root.find_comments("The content") self.assertEqual(len(comments), 1) self.assertEqual( newc.metadata["augeaspath"], comments[0].metadata["augeaspath"] ) self.assertEqual(newc.comment, comments[0].comment) def test_delete_child(self): listens = self.config.parser_root.find_directives("Listen") self.assertEqual(len(listens), 1) self.config.parser_root.delete_child(listens[0]) listens = self.config.parser_root.find_directives("Listen") self.assertEqual(len(listens), 0) def test_delete_child_not_found(self): listen = self.config.parser_root.find_directives("Listen")[0] listen.metadata["augeaspath"] = "/files/something/nonexistent" self.assertRaises( errors.PluginError, self.config.parser_root.delete_child, listen ) def test_add_child_block(self): nb = self.config.parser_root.add_child_block( "NewBlock", ["first", "second"] ) rpath, _, directive = nb.metadata["augeaspath"].rpartition("/") self.assertEqual( rpath, self.config.parser_root.metadata["augeaspath"] ) self.assertTrue(directive.startswith("NewBlock")) def test_add_child_block_beginning(self): self.config.parser_root.add_child_block( "Beginning", position=0 ) parser = self.config.parser_root.parser root_path = self.config.parser_root.metadata["augeaspath"] # Get first child first = parser.aug.match("{}/*[1]".format(root_path)) self.assertTrue(first[0].endswith("Beginning")) def test_add_child_block_append(self): self.config.parser_root.add_child_block( "VeryLast", ) parser = self.config.parser_root.parser root_path = self.config.parser_root.metadata["augeaspath"] # Get last child last = parser.aug.match("{}/*[last()]".format(root_path)) self.assertTrue(last[0].endswith("VeryLast")) def test_add_child_block_append_alt(self): self.config.parser_root.add_child_block( "VeryLastAlt", position=99999 ) parser = self.config.parser_root.parser root_path = self.config.parser_root.metadata["augeaspath"] # Get last child last = parser.aug.match("{}/*[last()]".format(root_path)) self.assertTrue(last[0].endswith("VeryLastAlt")) def test_add_child_block_middle(self): self.config.parser_root.add_child_block( "Middle", position=5 ) parser = self.config.parser_root.parser root_path = self.config.parser_root.metadata["augeaspath"] # Augeas indices start at 1 :( middle = parser.aug.match("{}/*[6]".format(root_path)) self.assertTrue(middle[0].endswith("Middle")) def test_add_child_block_existing_name(self): parser = self.config.parser_root.parser root_path = self.config.parser_root.metadata["augeaspath"] # There already exists a single VirtualHost in the base config new_block = parser.aug.match("{}/VirtualHost[2]".format(root_path)) self.assertEqual(len(new_block), 0) vh = self.config.parser_root.add_child_block( "VirtualHost", ) new_block = parser.aug.match("{}/VirtualHost[2]".format(root_path)) self.assertEqual(len(new_block), 1) self.assertTrue(vh.metadata["augeaspath"].endswith("VirtualHost[2]")) def test_node_init_error_bad_augeaspath(self): from certbot_apache._internal.augeasparser import AugeasBlockNode parameters = { "name": assertions.PASS, "ancestor": None, "filepath": assertions.PASS, "metadata": { "augeasparser": mock.Mock(), "augeaspath": "/files/path/endswith/slash/" } } self.assertRaises( errors.PluginError, AugeasBlockNode, **parameters ) def test_node_init_error_missing_augeaspath(self): from certbot_apache._internal.augeasparser import AugeasBlockNode parameters = { "name": assertions.PASS, "ancestor": None, "filepath": assertions.PASS, "metadata": { "augeasparser": mock.Mock(), } } self.assertRaises( errors.PluginError, AugeasBlockNode, **parameters ) def test_add_child_directive(self): self.config.parser_root.add_child_directive( "ThisWasAdded", ["with", "parameters"], position=0 ) dirs = self.config.parser_root.find_directives("ThisWasAdded") self.assertEqual(len(dirs), 1) self.assertEqual(dirs[0].parameters, ("with", "parameters")) # The new directive was added to the very first line of the config self.assertTrue(dirs[0].metadata["augeaspath"].endswith("[1]")) def test_add_child_directive_exception(self): self.assertRaises( errors.PluginError, self.config.parser_root.add_child_directive, "ThisRaisesErrorBecauseMissingParameters" ) def test_parsed_paths(self): paths = self.config.parser_root.parsed_paths() self.assertEqual(len(paths), 6) def test_find_ancestors(self): vhsblocks = self.config.parser_root.find_blocks("VirtualHost") macro_test = False nonmacro_test = False for vh in vhsblocks: if "/macro/" in vh.metadata["augeaspath"].lower(): ancs = vh.find_ancestors("Macro") self.assertEqual(len(ancs), 1) macro_test = True else: ancs = vh.find_ancestors("Macro") self.assertEqual(len(ancs), 0) nonmacro_test = True self.assertTrue(macro_test) self.assertTrue(nonmacro_test) def test_find_ancestors_bad_path(self): self.config.parser_root.metadata["augeaspath"] = "" ancs = self.config.parser_root.find_ancestors("Anything") self.assertEqual(len(ancs), 0) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/autohsts_test.py0000644000076500000240000002172700000000000017563 0ustar00bmwstaff# pylint: disable=too-many-lines """Test for certbot_apache._internal.configurator AutoHSTS functionality""" import re import unittest try: import mock except ImportError: # pragma: no cover from unittest import mock # type: ignore from certbot import errors from certbot_apache._internal import constants import util class AutoHSTSTest(util.ApacheTest): """Tests for AutoHSTS feature""" # pylint: disable=protected-access def setUp(self): # pylint: disable=arguments-differ super().setUp() self.config = util.get_apache_configurator( self.config_path, self.vhost_path, self.config_dir, self.work_dir) self.config.parser.modules["headers_module"] = None self.config.parser.modules["mod_headers.c"] = None self.config.parser.modules["ssl_module"] = None self.config.parser.modules["mod_ssl.c"] = None self.vh_truth = util.get_vh_truth( self.temp_dir, "debian_apache_2_4/multiple_vhosts") def get_autohsts_value(self, vh_path): """ Get value from Strict-Transport-Security header """ header_path = self.config.parser.find_dir("Header", None, vh_path) if header_path: pat = '(?:[ "]|^)(strict-transport-security)(?:[ "]|$)' for head in header_path: if re.search(pat, self.config.parser.aug.get(head).lower()): return self.config.parser.aug.get( head.replace("arg[3]", "arg[4]")) return None # pragma: no cover @mock.patch("certbot_apache._internal.configurator.ApacheConfigurator.restart") @mock.patch("certbot_apache._internal.configurator.ApacheConfigurator.enable_mod") def test_autohsts_enable_headers_mod(self, mock_enable, _restart): self.config.parser.modules.pop("headers_module", None) self.config.parser.modules.pop("mod_header.c", None) self.config.enable_autohsts(mock.MagicMock(), ["ocspvhost.com"]) self.assertTrue(mock_enable.called) @mock.patch("certbot_apache._internal.configurator.ApacheConfigurator.restart") def test_autohsts_deploy_already_exists(self, _restart): self.config.enable_autohsts(mock.MagicMock(), ["ocspvhost.com"]) self.assertRaises(errors.PluginEnhancementAlreadyPresent, self.config.enable_autohsts, mock.MagicMock(), ["ocspvhost.com"]) @mock.patch("certbot_apache._internal.constants.AUTOHSTS_FREQ", 0) @mock.patch("certbot_apache._internal.configurator.ApacheConfigurator.restart") @mock.patch("certbot_apache._internal.configurator.ApacheConfigurator.prepare") def test_autohsts_increase(self, mock_prepare, _mock_restart): self.config._prepared = False maxage = "\"max-age={0}\"" initial_val = maxage.format(constants.AUTOHSTS_STEPS[0]) inc_val = maxage.format(constants.AUTOHSTS_STEPS[1]) self.config.enable_autohsts(mock.MagicMock(), ["ocspvhost.com"]) # Verify initial value self.assertEqual(self.get_autohsts_value(self.vh_truth[7].path), initial_val) # Increase self.config.update_autohsts(mock.MagicMock()) # Verify increased value self.assertEqual(self.get_autohsts_value(self.vh_truth[7].path), inc_val) self.assertTrue(mock_prepare.called) @mock.patch("certbot_apache._internal.configurator.ApacheConfigurator.restart") @mock.patch("certbot_apache._internal.configurator.ApacheConfigurator._autohsts_increase") def test_autohsts_increase_noop(self, mock_increase, _restart): maxage = "\"max-age={0}\"" initial_val = maxage.format(constants.AUTOHSTS_STEPS[0]) self.config.enable_autohsts(mock.MagicMock(), ["ocspvhost.com"]) # Verify initial value self.assertEqual(self.get_autohsts_value(self.vh_truth[7].path), initial_val) self.config.update_autohsts(mock.MagicMock()) # Freq not patched, so value shouldn't increase self.assertFalse(mock_increase.called) @mock.patch("certbot_apache._internal.configurator.ApacheConfigurator.restart") @mock.patch("certbot_apache._internal.constants.AUTOHSTS_FREQ", 0) def test_autohsts_increase_no_header(self, _restart): self.config.enable_autohsts(mock.MagicMock(), ["ocspvhost.com"]) # Remove the header dir_locs = self.config.parser.find_dir("Header", None, self.vh_truth[7].path) dir_loc = "/".join(dir_locs[0].split("/")[:-1]) self.config.parser.aug.remove(dir_loc) self.assertRaises(errors.PluginError, self.config.update_autohsts, mock.MagicMock()) @mock.patch("certbot_apache._internal.constants.AUTOHSTS_FREQ", 0) @mock.patch("certbot_apache._internal.configurator.ApacheConfigurator.restart") def test_autohsts_increase_and_make_permanent(self, _mock_restart): maxage = "\"max-age={0}\"" max_val = maxage.format(constants.AUTOHSTS_PERMANENT) mock_lineage = mock.MagicMock() mock_lineage.key_path = "/etc/apache2/ssl/key-certbot_15.pem" self.config.enable_autohsts(mock.MagicMock(), ["ocspvhost.com"]) for i in range(len(constants.AUTOHSTS_STEPS)-1): # Ensure that value is not made permanent prematurely self.config.deploy_autohsts(mock_lineage) self.assertNotEqual(self.get_autohsts_value(self.vh_truth[7].path), max_val) self.config.update_autohsts(mock.MagicMock()) # Value should match pre-permanent increment step cur_val = maxage.format(constants.AUTOHSTS_STEPS[i+1]) self.assertEqual(self.get_autohsts_value(self.vh_truth[7].path), cur_val) # Ensure that the value is raised to max self.assertEqual(self.get_autohsts_value(self.vh_truth[7].path), maxage.format(constants.AUTOHSTS_STEPS[-1])) # Make permanent self.config.deploy_autohsts(mock_lineage) self.assertEqual(self.get_autohsts_value(self.vh_truth[7].path), max_val) def test_autohsts_update_noop(self): with mock.patch("time.time") as mock_time: # Time mock is used to make sure that the execution does not # continue when no autohsts entries exist in pluginstorage self.config.update_autohsts(mock.MagicMock()) self.assertFalse(mock_time.called) def test_autohsts_make_permanent_noop(self): self.config.storage.put = mock.MagicMock() self.config.deploy_autohsts(mock.MagicMock()) # Make sure that the execution does not continue when no entries in store self.assertFalse(self.config.storage.put.called) @mock.patch("certbot_apache._internal.display_ops.select_vhost") def test_autohsts_no_ssl_vhost(self, mock_select): mock_select.return_value = self.vh_truth[0] with mock.patch("certbot_apache._internal.configurator.logger.error") as mock_log: self.assertRaises(errors.PluginError, self.config.enable_autohsts, mock.MagicMock(), "invalid.example.com") self.assertTrue( "Certbot was not able to find SSL" in mock_log.call_args[0][0]) @mock.patch("certbot_apache._internal.configurator.ApacheConfigurator.restart") @mock.patch("certbot_apache._internal.configurator.ApacheConfigurator.add_vhost_id") def test_autohsts_dont_enhance_twice(self, mock_id, _restart): mock_id.return_value = "1234567" self.config.enable_autohsts(mock.MagicMock(), ["ocspvhost.com", "ocspvhost.com"]) self.assertEqual(mock_id.call_count, 1) def test_autohsts_remove_orphaned(self): # pylint: disable=protected-access self.config._autohsts_fetch_state() self.config._autohsts["orphan_id"] = {"laststep": 0, "timestamp": 0} self.config._autohsts_save_state() self.config.update_autohsts(mock.MagicMock()) self.assertFalse("orphan_id" in self.config._autohsts) # Make sure it's removed from the pluginstorage file as well self.config._autohsts = None self.config._autohsts_fetch_state() self.assertFalse(self.config._autohsts) def test_autohsts_make_permanent_vhost_not_found(self): # pylint: disable=protected-access self.config._autohsts_fetch_state() self.config._autohsts["orphan_id"] = {"laststep": 999, "timestamp": 0} self.config._autohsts_save_state() with mock.patch("certbot_apache._internal.configurator.logger.error") as mock_log: self.config.deploy_autohsts(mock.MagicMock()) self.assertTrue(mock_log.called) self.assertTrue( "VirtualHost with id orphan_id was not" in mock_log.call_args[0][0]) if __name__ == "__main__": unittest.main() # pragma: no cover ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/centos6_test.py0000644000076500000240000002371200000000000017266 0ustar00bmwstaff"""Test for certbot_apache._internal.configurator for CentOS 6 overrides""" import unittest from unittest import mock from certbot.compat import os from certbot.errors import MisconfigurationError from certbot_apache._internal import obj from certbot_apache._internal import override_centos from certbot_apache._internal import parser import util def get_vh_truth(temp_dir, config_name): """Return the ground truth for the specified directory.""" prefix = os.path.join( temp_dir, config_name, "httpd/conf.d") aug_pre = "/files" + prefix vh_truth = [ obj.VirtualHost( os.path.join(prefix, "test.example.com.conf"), os.path.join(aug_pre, "test.example.com.conf/VirtualHost"), {obj.Addr.fromstring("*:80")}, False, True, "test.example.com"), obj.VirtualHost( os.path.join(prefix, "ssl.conf"), os.path.join(aug_pre, "ssl.conf/VirtualHost"), {obj.Addr.fromstring("_default_:443")}, True, True, None) ] return vh_truth class CentOS6Tests(util.ApacheTest): """Tests for CentOS 6""" def setUp(self): # pylint: disable=arguments-differ test_dir = "centos6_apache/apache" config_root = "centos6_apache/apache/httpd" vhost_root = "centos6_apache/apache/httpd/conf.d" super().setUp(test_dir=test_dir, config_root=config_root, vhost_root=vhost_root) self.config = util.get_apache_configurator( self.config_path, self.vhost_path, self.config_dir, self.work_dir, version=(2, 2, 15), os_info="centos") self.vh_truth = get_vh_truth( self.temp_dir, "centos6_apache/apache") def test_get_parser(self): self.assertTrue(isinstance(self.config.parser, override_centos.CentOSParser)) def test_get_virtual_hosts(self): """Make sure all vhosts are being properly found.""" vhs = self.config.get_virtual_hosts() self.assertEqual(len(vhs), 2) found = 0 for vhost in vhs: for centos_truth in self.vh_truth: if vhost == centos_truth: found += 1 break else: raise Exception("Missed: %s" % vhost) # pragma: no cover self.assertEqual(found, 2) @mock.patch("certbot_apache._internal.configurator.display_util.notify") def test_loadmod_default(self, unused_mock_notify): ssl_loadmods = self.config.parser.find_dir( "LoadModule", "ssl_module", exclude=False) self.assertEqual(len(ssl_loadmods), 1) # Make sure the LoadModule ssl_module is in ssl.conf (default) self.assertTrue("ssl.conf" in ssl_loadmods[0]) # ...and that it's not inside of self.assertFalse("IfModule" in ssl_loadmods[0]) # Get the example vhost self.config.assoc["test.example.com"] = self.vh_truth[0] self.config.deploy_cert( "random.demo", "example/cert.pem", "example/key.pem", "example/cert_chain.pem", "example/fullchain.pem") self.config.save() post_loadmods = self.config.parser.find_dir( "LoadModule", "ssl_module", exclude=False) # We should now have LoadModule ssl_module in root conf and ssl.conf self.assertEqual(len(post_loadmods), 2) for lm in post_loadmods: # lm[:-7] removes "/arg[#]" from the path arguments = self.config.parser.get_all_args(lm[:-7]) self.assertEqual(arguments, ["ssl_module", "modules/mod_ssl.so"]) # ...and both of them should be wrapped in # lm[:-17] strips off /directive/arg[1] from the path. ifmod_args = self.config.parser.get_all_args(lm[:-17]) self.assertTrue("!mod_ssl.c" in ifmod_args) @mock.patch("certbot_apache._internal.configurator.display_util.notify") def test_loadmod_multiple(self, unused_mock_notify): sslmod_args = ["ssl_module", "modules/mod_ssl.so"] # Adds another LoadModule to main httpd.conf in addtition to ssl.conf self.config.parser.add_dir(self.config.parser.loc["default"], "LoadModule", sslmod_args) self.config.save() pre_loadmods = self.config.parser.find_dir( "LoadModule", "ssl_module", exclude=False) # LoadModules are not within IfModule blocks self.assertFalse(any("ifmodule" in m.lower() for m in pre_loadmods)) self.config.assoc["test.example.com"] = self.vh_truth[0] self.config.deploy_cert( "random.demo", "example/cert.pem", "example/key.pem", "example/cert_chain.pem", "example/fullchain.pem") post_loadmods = self.config.parser.find_dir( "LoadModule", "ssl_module", exclude=False) for mod in post_loadmods: self.assertTrue(self.config.parser.not_modssl_ifmodule(mod)) #pylint: disable=no-member @mock.patch("certbot_apache._internal.configurator.display_util.notify") def test_loadmod_rootconf_exists(self, unused_mock_notify): sslmod_args = ["ssl_module", "modules/mod_ssl.so"] rootconf_ifmod = self.config.parser.get_ifmod( parser.get_aug_path(self.config.parser.loc["default"]), "!mod_ssl.c", beginning=True) self.config.parser.add_dir(rootconf_ifmod[:-1], "LoadModule", sslmod_args) self.config.save() # Get the example vhost self.config.assoc["test.example.com"] = self.vh_truth[0] self.config.deploy_cert( "random.demo", "example/cert.pem", "example/key.pem", "example/cert_chain.pem", "example/fullchain.pem") self.config.save() root_loadmods = self.config.parser.find_dir( "LoadModule", "ssl_module", start=parser.get_aug_path(self.config.parser.loc["default"]), exclude=False) mods = [lm for lm in root_loadmods if self.config.parser.loc["default"] in lm] self.assertEqual(len(mods), 1) # [:-7] removes "/arg[#]" from the path self.assertEqual( self.config.parser.get_all_args(mods[0][:-7]), sslmod_args) @mock.patch("certbot_apache._internal.configurator.display_util.notify") def test_neg_loadmod_already_on_path(self, unused_mock_notify): loadmod_args = ["ssl_module", "modules/mod_ssl.so"] ifmod = self.config.parser.get_ifmod( self.vh_truth[1].path, "!mod_ssl.c", beginning=True) self.config.parser.add_dir(ifmod[:-1], "LoadModule", loadmod_args) self.config.parser.add_dir(self.vh_truth[1].path, "LoadModule", loadmod_args) self.config.save() pre_loadmods = self.config.parser.find_dir( "LoadModule", "ssl_module", start=self.vh_truth[1].path, exclude=False) self.assertEqual(len(pre_loadmods), 2) # The ssl.conf now has two LoadModule directives, one inside of # !mod_ssl.c IfModule self.config.assoc["test.example.com"] = self.vh_truth[0] self.config.deploy_cert( "random.demo", "example/cert.pem", "example/key.pem", "example/cert_chain.pem", "example/fullchain.pem") self.config.save() # Ensure that the additional LoadModule wasn't written into the IfModule post_loadmods = self.config.parser.find_dir( "LoadModule", "ssl_module", start=self.vh_truth[1].path, exclude=False) self.assertEqual(len(post_loadmods), 1) def test_loadmod_non_duplicate(self): # the modules/mod_ssl.so exists in ssl.conf sslmod_args = ["ssl_module", "modules/mod_somethingelse.so"] rootconf_ifmod = self.config.parser.get_ifmod( parser.get_aug_path(self.config.parser.loc["default"]), "!mod_ssl.c", beginning=True) self.config.parser.add_dir(rootconf_ifmod[:-1], "LoadModule", sslmod_args) self.config.save() self.config.assoc["test.example.com"] = self.vh_truth[0] pre_matches = self.config.parser.find_dir("LoadModule", "ssl_module", exclude=False) self.assertRaises(MisconfigurationError, self.config.deploy_cert, "random.demo", "example/cert.pem", "example/key.pem", "example/cert_chain.pem", "example/fullchain.pem") post_matches = self.config.parser.find_dir("LoadModule", "ssl_module", exclude=False) # Make sure that none was changed self.assertEqual(pre_matches, post_matches) @mock.patch("certbot_apache._internal.configurator.display_util.notify") def test_loadmod_not_found(self, unused_mock_notify): # Remove all existing LoadModule ssl_module... directives orig_loadmods = self.config.parser.find_dir("LoadModule", "ssl_module", exclude=False) for mod in orig_loadmods: noarg_path = mod.rpartition("/")[0] self.config.parser.aug.remove(noarg_path) self.config.save() self.config.deploy_cert( "random.demo", "example/cert.pem", "example/key.pem", "example/cert_chain.pem", "example/fullchain.pem") post_loadmods = self.config.parser.find_dir("LoadModule", "ssl_module", exclude=False) self.assertFalse(post_loadmods) def test_no_ifmod_search_false(self): #pylint: disable=no-member self.assertFalse(self.config.parser.not_modssl_ifmodule( "/path/does/not/include/ifmod" )) self.assertFalse(self.config.parser.not_modssl_ifmodule( "" )) self.assertFalse(self.config.parser.not_modssl_ifmodule( "/path/includes/IfModule/but/no/arguments" )) if __name__ == "__main__": unittest.main() # pragma: no cover ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/centos_test.py0000644000076500000240000002027200000000000017176 0ustar00bmwstaff"""Test for certbot_apache._internal.configurator for Centos overrides""" import unittest try: import mock except ImportError: # pragma: no cover from unittest import mock # type: ignore from certbot import errors from certbot.compat import filesystem from certbot.compat import os from certbot_apache._internal import obj from certbot_apache._internal import override_centos import util def get_vh_truth(temp_dir, config_name): """Return the ground truth for the specified directory.""" prefix = os.path.join( temp_dir, config_name, "httpd/conf.d") aug_pre = "/files" + prefix vh_truth = [ obj.VirtualHost( os.path.join(prefix, "centos.example.com.conf"), os.path.join(aug_pre, "centos.example.com.conf/VirtualHost"), {obj.Addr.fromstring("*:80")}, False, True, "centos.example.com"), obj.VirtualHost( os.path.join(prefix, "ssl.conf"), os.path.join(aug_pre, "ssl.conf/VirtualHost"), {obj.Addr.fromstring("_default_:443")}, True, True, None) ] return vh_truth class FedoraRestartTest(util.ApacheTest): """Tests for Fedora specific self-signed certificate override""" def setUp(self): # pylint: disable=arguments-differ test_dir = "centos7_apache/apache" config_root = "centos7_apache/apache/httpd" vhost_root = "centos7_apache/apache/httpd/conf.d" super().setUp(test_dir=test_dir, config_root=config_root, vhost_root=vhost_root) self.config = util.get_apache_configurator( self.config_path, self.vhost_path, self.config_dir, self.work_dir, os_info="fedora_old") self.vh_truth = get_vh_truth( self.temp_dir, "centos7_apache/apache") def _run_fedora_test(self): self.assertIsInstance(self.config, override_centos.CentOSConfigurator) with mock.patch("certbot.util.get_os_info") as mock_info: mock_info.return_value = ["fedora", "28"] self.config.config_test() def test_non_fedora_error(self): c_test = "certbot_apache._internal.configurator.ApacheConfigurator.config_test" with mock.patch(c_test) as mock_test: mock_test.side_effect = errors.MisconfigurationError with mock.patch("certbot.util.get_os_info") as mock_info: mock_info.return_value = ["not_fedora"] self.assertRaises(errors.MisconfigurationError, self.config.config_test) def test_fedora_restart_error(self): c_test = "certbot_apache._internal.configurator.ApacheConfigurator.config_test" with mock.patch(c_test) as mock_test: # First call raises error, second doesn't mock_test.side_effect = [errors.MisconfigurationError, ''] with mock.patch("certbot.util.run_script") as mock_run: mock_run.side_effect = errors.SubprocessError self.assertRaises(errors.MisconfigurationError, self._run_fedora_test) def test_fedora_restart(self): c_test = "certbot_apache._internal.configurator.ApacheConfigurator.config_test" with mock.patch(c_test) as mock_test: with mock.patch("certbot.util.run_script") as mock_run: # First call raises error, second doesn't mock_test.side_effect = [errors.MisconfigurationError, ''] self._run_fedora_test() self.assertEqual(mock_test.call_count, 2) self.assertEqual(mock_run.call_args[0][0], ['systemctl', 'restart', 'httpd']) class MultipleVhostsTestCentOS(util.ApacheTest): """Multiple vhost tests for CentOS / RHEL family of distros""" _multiprocess_can_split_ = True def setUp(self): # pylint: disable=arguments-differ test_dir = "centos7_apache/apache" config_root = "centos7_apache/apache/httpd" vhost_root = "centos7_apache/apache/httpd/conf.d" super().setUp(test_dir=test_dir, config_root=config_root, vhost_root=vhost_root) self.config = util.get_apache_configurator( self.config_path, self.vhost_path, self.config_dir, self.work_dir, os_info="centos") self.vh_truth = get_vh_truth( self.temp_dir, "centos7_apache/apache") def test_get_parser(self): self.assertIsInstance(self.config.parser, override_centos.CentOSParser) @mock.patch("certbot_apache._internal.apache_util._get_runtime_cfg") def test_opportunistic_httpd_runtime_parsing(self, mock_get): define_val = ( 'Define: TEST1\n' 'Define: TEST2\n' 'Define: DUMP_RUN_CFG\n' ) mod_val = ( 'Loaded Modules:\n' ' mock_module (static)\n' ' another_module (static)\n' ) def mock_get_cfg(command): """Mock httpd process stdout""" if command == ['apachectl', '-t', '-D', 'DUMP_RUN_CFG']: return define_val elif command == ['apachectl', '-t', '-D', 'DUMP_MODULES']: return mod_val return "" mock_get.side_effect = mock_get_cfg self.config.parser.modules = {} self.config.parser.variables = {} with mock.patch("certbot.util.get_os_info") as mock_osi: # Make sure we have the have the CentOS httpd constants mock_osi.return_value = ("centos", "7") self.config.parser.update_runtime_variables() self.assertEqual(mock_get.call_count, 3) self.assertEqual(len(self.config.parser.modules), 4) self.assertEqual(len(self.config.parser.variables), 2) self.assertTrue("TEST2" in self.config.parser.variables) self.assertTrue("mod_another.c" in self.config.parser.modules) def test_get_virtual_hosts(self): """Make sure all vhosts are being properly found.""" vhs = self.config.get_virtual_hosts() self.assertEqual(len(vhs), 2) found = 0 for vhost in vhs: for centos_truth in self.vh_truth: if vhost == centos_truth: found += 1 break else: raise Exception("Missed: %s" % vhost) # pragma: no cover self.assertEqual(found, 2) @mock.patch("certbot_apache._internal.apache_util._get_runtime_cfg") def test_get_sysconfig_vars(self, mock_cfg): """Make sure we read the sysconfig OPTIONS variable correctly""" # Return nothing for the process calls mock_cfg.return_value = "" self.config.parser.sysconfig_filep = filesystem.realpath( os.path.join(self.config.parser.root, "../sysconfig/httpd")) self.config.parser.variables = {} with mock.patch("certbot.util.get_os_info") as mock_osi: # Make sure we have the have the CentOS httpd constants mock_osi.return_value = ("centos", "7") self.config.parser.update_runtime_variables() self.assertTrue("mock_define" in self.config.parser.variables) self.assertTrue("mock_define_too" in self.config.parser.variables) self.assertTrue("mock_value" in self.config.parser.variables) self.assertEqual("TRUE", self.config.parser.variables["mock_value"]) self.assertTrue("MOCK_NOSEP" in self.config.parser.variables) self.assertEqual("NOSEP_VAL", self.config.parser.variables["NOSEP_TWO"]) @mock.patch("certbot_apache._internal.configurator.util.run_script") def test_alt_restart_works(self, mock_run_script): mock_run_script.side_effect = [None, errors.SubprocessError, None] self.config.restart() self.assertEqual(mock_run_script.call_count, 3) @mock.patch("certbot_apache._internal.configurator.util.run_script") def test_alt_restart_errors(self, mock_run_script): mock_run_script.side_effect = [None, errors.SubprocessError, errors.SubprocessError] self.assertRaises(errors.MisconfigurationError, self.config.restart) if __name__ == "__main__": unittest.main() # pragma: no cover ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/complex_parsing_test.py0000644000076500000240000001065600000000000021102 0ustar00bmwstaff"""Tests for certbot_apache._internal.parser.""" import shutil import unittest from certbot import errors from certbot.compat import os import util class ComplexParserTest(util.ParserTest): """Apache Parser Test.""" def setUp(self): # pylint: disable=arguments-differ super().setUp( "complex_parsing", "complex_parsing") self.setup_variables() # This needs to happen after due to setup_variables not being run # until after self.parser.parse_modules() # pylint: disable=protected-access def tearDown(self): shutil.rmtree(self.temp_dir) shutil.rmtree(self.config_dir) shutil.rmtree(self.work_dir) def setup_variables(self): """Set up variables for parser.""" self.parser.variables.update( { "COMPLEX": "", "tls_port": "1234", "fnmatch_filename": "test_fnmatch.conf", "tls_port_str": "1234" } ) def test_filter_args_num(self): """Note: This may also fail do to Include conf-enabled/ syntax.""" matches = self.parser.find_dir("TestArgsDirective") self.assertEqual(len(self.parser.filter_args_num(matches, 1)), 3) self.assertEqual(len(self.parser.filter_args_num(matches, 2)), 2) self.assertEqual(len(self.parser.filter_args_num(matches, 3)), 1) def test_basic_variable_parsing(self): matches = self.parser.find_dir("TestVariablePort") self.assertEqual(len(matches), 1) self.assertEqual(self.parser.get_arg(matches[0]), "1234") def test_basic_variable_parsing_quotes(self): matches = self.parser.find_dir("TestVariablePortStr") self.assertEqual(len(matches), 1) self.assertEqual(self.parser.get_arg(matches[0]), "1234") def test_invalid_variable_parsing(self): del self.parser.variables["tls_port"] matches = self.parser.find_dir("TestVariablePort") self.assertRaises( errors.PluginError, self.parser.get_arg, matches[0]) def test_basic_ifdefine(self): self.assertEqual(len(self.parser.find_dir("VAR_DIRECTIVE")), 2) self.assertEqual(len(self.parser.find_dir("INVALID_VAR_DIRECTIVE")), 0) def test_basic_ifmodule(self): self.assertEqual(len(self.parser.find_dir("MOD_DIRECTIVE")), 2) self.assertEqual( len(self.parser.find_dir("INVALID_MOD_DIRECTIVE")), 0) def test_nested(self): self.assertEqual(len(self.parser.find_dir("NESTED_DIRECTIVE")), 3) self.assertEqual( len(self.parser.find_dir("INVALID_NESTED_DIRECTIVE")), 0) def test_load_modules(self): """If only first is found, there is bad variable parsing.""" self.assertTrue("status_module" in self.parser.modules) self.assertTrue("mod_status.c" in self.parser.modules) # This is in an IfDefine self.assertTrue("ssl_module" in self.parser.modules) self.assertTrue("mod_ssl.c" in self.parser.modules) def verify_fnmatch(self, arg, hit=True): """Test if Include was correctly parsed.""" from certbot_apache._internal import parser self.parser.add_dir(parser.get_aug_path(self.parser.loc["default"]), "Include", [arg]) if hit: self.assertTrue(self.parser.find_dir("FNMATCH_DIRECTIVE")) else: self.assertFalse(self.parser.find_dir("FNMATCH_DIRECTIVE")) # NOTE: Only run one test per function otherwise you will have # inf recursion def test_include(self): self.verify_fnmatch("test_fnmatch.?onf") def test_include_complex(self): self.verify_fnmatch("../complex_parsing/[te][te]st_*.?onf") def test_include_fullpath(self): self.verify_fnmatch(os.path.join(self.config_path, "test_fnmatch.conf")) def test_include_fullpath_trailing_slash(self): self.verify_fnmatch(self.config_path + "//") def test_include_single_quotes(self): self.verify_fnmatch("'" + self.config_path + "'") def test_include_double_quotes(self): self.verify_fnmatch('"' + self.config_path + '"') def test_include_variable(self): self.verify_fnmatch("../complex_parsing/${fnmatch_filename}") def test_include_missing(self): # This should miss self.verify_fnmatch("test_*.onf", False) if __name__ == "__main__": unittest.main() # pragma: no cover ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/configurator_reverter_test.py0000644000076500000240000000547000000000000022326 0ustar00bmwstaff"""Test for certbot_apache._internal.configurator implementations of reverter""" import shutil import unittest try: import mock except ImportError: # pragma: no cover from unittest import mock # type: ignore from certbot import errors import util class ConfiguratorReverterTest(util.ApacheTest): """Test for ApacheConfigurator reverter methods""" def setUp(self): # pylint: disable=arguments-differ super().setUp() self.config = util.get_apache_configurator( self.config_path, self.vhost_path, self.config_dir, self.work_dir) self.vh_truth = util.get_vh_truth( self.temp_dir, "debian_apache_2_4/multiple_vhosts") def tearDown(self): shutil.rmtree(self.config_dir) shutil.rmtree(self.work_dir) shutil.rmtree(self.temp_dir) def test_bad_save_checkpoint(self): self.config.reverter.add_to_checkpoint = mock.Mock( side_effect=errors.ReverterError) self.config.parser.add_dir( self.vh_truth[0].path, "Test", "bad_save_ckpt") self.assertRaises(errors.PluginError, self.config.save) def test_bad_save_finalize_checkpoint(self): self.config.reverter.finalize_checkpoint = mock.Mock( side_effect=errors.ReverterError) self.config.parser.add_dir( self.vh_truth[0].path, "Test", "bad_save_ckpt") self.assertRaises(errors.PluginError, self.config.save, "Title") def test_finalize_save(self): mock_finalize = mock.Mock() self.config.reverter = mock_finalize self.config.save("Example Title") self.assertTrue(mock_finalize.is_called) def test_revert_challenge_config(self): mock_load = mock.Mock() self.config.parser.aug.load = mock_load self.config.revert_challenge_config() self.assertEqual(mock_load.call_count, 1) def test_revert_challenge_config_error(self): self.config.reverter.revert_temporary_config = mock.Mock( side_effect=errors.ReverterError) self.assertRaises( errors.PluginError, self.config.revert_challenge_config) def test_rollback_checkpoints(self): mock_load = mock.Mock() self.config.parser.aug.load = mock_load self.config.rollback_checkpoints() self.assertEqual(mock_load.call_count, 1) def test_rollback_error(self): self.config.reverter.rollback_checkpoints = mock.Mock( side_effect=errors.ReverterError) self.assertRaises(errors.PluginError, self.config.rollback_checkpoints) def test_recovery_routine_reload(self): mock_load = mock.Mock() self.config.parser.aug.load = mock_load self.config.recovery_routine() self.assertEqual(mock_load.call_count, 1) if __name__ == "__main__": unittest.main() # pragma: no cover ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/configurator_test.py0000644000076500000240000023766400000000000020424 0ustar00bmwstaff# pylint: disable=too-many-lines """Test for certbot_apache._internal.configurator.""" import copy import shutil import socket import tempfile import unittest try: import mock except ImportError: # pragma: no cover from unittest import mock # type: ignore from acme import challenges from certbot import achallenges from certbot import crypto_util from certbot import errors from certbot.compat import filesystem from certbot.compat import os from certbot.tests import acme_util from certbot.tests import util as certbot_util from certbot_apache._internal import apache_util from certbot_apache._internal import constants from certbot_apache._internal import obj from certbot_apache._internal import parser import util class MultipleVhostsTest(util.ApacheTest): """Test two standard well-configured HTTP vhosts.""" def setUp(self): # pylint: disable=arguments-differ super().setUp() self.config = util.get_apache_configurator( self.config_path, self.vhost_path, self.config_dir, self.work_dir) self.config = self.mock_deploy_cert(self.config) self.vh_truth = util.get_vh_truth( self.temp_dir, "debian_apache_2_4/multiple_vhosts") def mock_deploy_cert(self, config): """A test for a mock deploy cert""" config.real_deploy_cert = self.config.deploy_cert def mocked_deploy_cert(*args, **kwargs): """a helper to mock a deployed cert""" g_mod = "certbot_apache._internal.configurator.ApacheConfigurator.enable_mod" with mock.patch(g_mod): config.real_deploy_cert(*args, **kwargs) self.config.deploy_cert = mocked_deploy_cert return self.config @mock.patch("certbot_apache._internal.configurator.path_surgery") def test_prepare_no_install(self, mock_surgery): silly_path = {"PATH": "/tmp/nothingness2342"} mock_surgery.return_value = False with mock.patch.dict('os.environ', silly_path): self.assertRaises(errors.NoInstallationError, self.config.prepare) self.assertEqual(mock_surgery.call_count, 1) @mock.patch("certbot_apache._internal.parser.ApacheParser") @mock.patch("certbot_apache._internal.configurator.util.exe_exists") def test_prepare_version(self, mock_exe_exists, _): mock_exe_exists.return_value = True self.config.version = None self.config.config_test = mock.Mock() self.config.get_version = mock.Mock(return_value=(1, 1)) self.assertRaises( errors.NotSupportedError, self.config.prepare) def test_prepare_locked(self): server_root = self.config.conf("server-root") self.config.config_test = mock.Mock() os.remove(os.path.join(server_root, ".certbot.lock")) certbot_util.lock_and_call(self._test_prepare_locked, server_root) @mock.patch("certbot_apache._internal.parser.ApacheParser") @mock.patch("certbot_apache._internal.configurator.util.exe_exists") @mock.patch("certbot_apache._internal.configurator.ApacheConfigurator.get_parsernode_root") def _test_prepare_locked(self, _node, _exists, _parser): try: self.config.prepare() except errors.PluginError as err: err_msg = str(err) self.assertTrue("lock" in err_msg) self.assertTrue(self.config.conf("server-root") in err_msg) else: # pragma: no cover self.fail("Exception wasn't raised!") def test_add_parser_arguments(self): # pylint: disable=no-self-use from certbot_apache._internal.configurator import ApacheConfigurator # Weak test.. ApacheConfigurator.add_parser_arguments(mock.MagicMock()) def test_docs_parser_arguments(self): os.environ["CERTBOT_DOCS"] = "1" from certbot_apache._internal.configurator import ApacheConfigurator mock_add = mock.MagicMock() ApacheConfigurator.add_parser_arguments(mock_add) parserargs = ["server_root", "enmod", "dismod", "le_vhost_ext", "vhost_root", "logs_root", "challenge_location", "handle_modules", "handle_sites", "ctl"] exp = {} for k in ApacheConfigurator.OS_DEFAULTS.__dict__.keys(): if k in parserargs: exp[k.replace("_", "-")] = getattr(ApacheConfigurator.OS_DEFAULTS, k) # Special cases exp["vhost-root"] = None found = set() for call in mock_add.call_args_list: found.add(call[0][0]) # Make sure that all (and only) the expected values exist self.assertEqual(len(mock_add.call_args_list), len(found)) for e in exp: self.assertTrue(e in found) del os.environ["CERTBOT_DOCS"] def test_add_parser_arguments_all_configurators(self): # pylint: disable=no-self-use from certbot_apache._internal.entrypoint import OVERRIDE_CLASSES for cls in OVERRIDE_CLASSES.values(): cls.add_parser_arguments(mock.MagicMock()) def test_all_configurators_defaults_defined(self): from certbot_apache._internal.entrypoint import OVERRIDE_CLASSES from certbot_apache._internal.configurator import ApacheConfigurator parameters = set(ApacheConfigurator.OS_DEFAULTS.__dict__.keys()) for cls in OVERRIDE_CLASSES.values(): self.assertTrue(parameters.issubset(set(cls.OS_DEFAULTS.__dict__.keys()))) def test_constant(self): self.assertTrue("debian_apache_2_4/multiple_vhosts/apache" in self.config.options.server_root) @certbot_util.patch_display_util() def test_get_all_names(self, mock_getutility): mock_utility = mock_getutility() mock_utility.notification = mock.MagicMock(return_value=True) names = self.config.get_all_names() self.assertEqual(names, {"certbot.demo", "ocspvhost.com", "encryption-example.demo", "nonsym.link", "vhost.in.rootconf", "www.certbot.demo", "duplicate.example.com"}) @certbot_util.patch_display_util() @mock.patch("certbot_apache._internal.configurator.socket.gethostbyaddr") def test_get_all_names_addrs(self, mock_gethost, mock_getutility): mock_gethost.side_effect = [("google.com", "", ""), socket.error] mock_utility = mock_getutility() mock_utility.notification.return_value = True vhost = obj.VirtualHost( "fp", "ap", {obj.Addr(("8.8.8.8", "443")), obj.Addr(("zombo.com",)), obj.Addr(("192.168.1.2"))}, True, False) self.config.vhosts.append(vhost) names = self.config.get_all_names() self.assertEqual(len(names), 9) self.assertTrue("zombo.com" in names) self.assertTrue("google.com" in names) self.assertTrue("certbot.demo" in names) def test_get_bad_path(self): self.assertEqual(apache_util.get_file_path(None), None) self.assertEqual(apache_util.get_file_path("nonexistent"), None) self.assertEqual(self.config._create_vhost("nonexistent"), None) # pylint: disable=protected-access def test_get_aug_internal_path(self): from certbot_apache._internal.apache_util import get_internal_aug_path internal_paths = [ "Virtualhost", "IfModule/VirtualHost", "VirtualHost", "VirtualHost", "Macro/VirtualHost", "IfModule/VirtualHost", "VirtualHost", "IfModule/VirtualHost"] for i, internal_path in enumerate(internal_paths): self.assertEqual( get_internal_aug_path(self.vh_truth[i].path), internal_path) def test_bad_servername_alias(self): ssl_vh1 = obj.VirtualHost( "fp1", "ap1", {obj.Addr(("*", "443"))}, True, False) # pylint: disable=protected-access self.config._add_servernames(ssl_vh1) self.assertTrue( self.config._add_servername_alias("oy_vey", ssl_vh1) is None) def test_add_servernames_alias(self): self.config.parser.add_dir( self.vh_truth[2].path, "ServerAlias", ["*.le.co"]) # pylint: disable=protected-access self.config._add_servernames(self.vh_truth[2]) self.assertEqual( self.vh_truth[2].get_names(), {"*.le.co", "ip-172-30-0-17"}) def test_get_virtual_hosts(self): """Make sure all vhosts are being properly found.""" vhs = self.config.get_virtual_hosts() self.assertEqual(len(vhs), 12) found = 0 for vhost in vhs: for truth in self.vh_truth: if vhost == truth: found += 1 break else: raise Exception("Missed: %s" % vhost) # pragma: no cover self.assertEqual(found, 12) # Handle case of non-debian layout get_virtual_hosts with mock.patch( "certbot_apache._internal.configurator.ApacheConfigurator.conf" ) as mock_conf: mock_conf.return_value = False vhs = self.config.get_virtual_hosts() self.assertEqual(len(vhs), 12) @mock.patch("certbot_apache._internal.display_ops.select_vhost") def test_choose_vhost_none_avail(self, mock_select): mock_select.return_value = None self.assertRaises( errors.PluginError, self.config.choose_vhost, "none.com") @mock.patch("certbot_apache._internal.display_ops.select_vhost") def test_choose_vhost_select_vhost_ssl(self, mock_select): mock_select.return_value = self.vh_truth[1] self.assertEqual( self.vh_truth[1], self.config.choose_vhost("none.com")) @mock.patch("certbot_apache._internal.display_ops.select_vhost") @mock.patch("certbot_apache._internal.obj.VirtualHost.conflicts") def test_choose_vhost_select_vhost_non_ssl(self, mock_conf, mock_select): mock_select.return_value = self.vh_truth[0] mock_conf.return_value = False chosen_vhost = self.config.choose_vhost("none.com") self.vh_truth[0].aliases.add("none.com") self.assertEqual( self.vh_truth[0].get_names(), chosen_vhost.get_names()) # Make sure we go from HTTP -> HTTPS self.assertFalse(self.vh_truth[0].ssl) self.assertTrue(chosen_vhost.ssl) @mock.patch("certbot_apache._internal.configurator.ApacheConfigurator._find_best_vhost") @mock.patch("certbot_apache._internal.parser.ApacheParser.add_dir") def test_choose_vhost_and_servername_addition(self, mock_add, mock_find): ret_vh = self.vh_truth[8] ret_vh.enabled = False mock_find.return_value = self.vh_truth[8] self.config.choose_vhost("whatever.com") self.assertTrue(mock_add.called) @mock.patch("certbot_apache._internal.display_ops.select_vhost") def test_choose_vhost_select_vhost_with_temp(self, mock_select): mock_select.return_value = self.vh_truth[0] chosen_vhost = self.config.choose_vhost("none.com", create_if_no_ssl=False) self.assertEqual(self.vh_truth[0], chosen_vhost) @mock.patch("certbot_apache._internal.display_ops.select_vhost") def test_choose_vhost_select_vhost_conflicting_non_ssl(self, mock_select): mock_select.return_value = self.vh_truth[3] conflicting_vhost = obj.VirtualHost( "path", "aug_path", {obj.Addr.fromstring("*:443")}, True, True) self.config.vhosts.append(conflicting_vhost) self.assertRaises( errors.PluginError, self.config.choose_vhost, "none.com") def test_find_best_http_vhost_default(self): vh = obj.VirtualHost( "fp", "ap", {obj.Addr.fromstring("_default_:80")}, False, True) self.config.vhosts = [vh] self.assertEqual(self.config.find_best_http_vhost("foo.bar", False), vh) def test_find_best_http_vhost_port(self): port = "8080" vh = obj.VirtualHost( "fp", "ap", {obj.Addr.fromstring("*:" + port)}, False, True, "encryption-example.demo") self.config.vhosts.append(vh) self.assertEqual(self.config.find_best_http_vhost("foo.bar", False, port), vh) def test_findbest_continues_on_short_domain(self): # pylint: disable=protected-access chosen_vhost = self.config._find_best_vhost("purple.com") self.assertEqual(None, chosen_vhost) def test_findbest_continues_on_long_domain(self): # pylint: disable=protected-access chosen_vhost = self.config._find_best_vhost("green.red.purple.com") self.assertEqual(None, chosen_vhost) def test_find_best_vhost(self): # pylint: disable=protected-access self.assertEqual( self.vh_truth[3], self.config._find_best_vhost("certbot.demo")) self.assertEqual( self.vh_truth[0], self.config._find_best_vhost("encryption-example.demo")) self.assertEqual( self.config._find_best_vhost("does-not-exist.com"), None) def test_find_best_vhost_variety(self): # pylint: disable=protected-access ssl_vh = obj.VirtualHost( "fp", "ap", {obj.Addr(("*", "443")), obj.Addr(("zombo.com",))}, True, False) self.config.vhosts.append(ssl_vh) self.assertEqual(self.config._find_best_vhost("zombo.com"), ssl_vh) def test_find_best_vhost_default(self): # pylint: disable=protected-access # Assume only the two default vhosts. self.config.vhosts = [ vh for vh in self.config.vhosts if vh.name not in ["certbot.demo", "nonsym.link", "encryption-example.demo", "duplicate.example.com", "ocspvhost.com", "vhost.in.rootconf"] and "*.blue.purple.com" not in vh.aliases ] self.assertEqual( self.config._find_best_vhost("encryption-example.demo"), self.vh_truth[2]) def test_non_default_vhosts(self): # pylint: disable=protected-access vhosts = self.config._non_default_vhosts(self.config.vhosts) self.assertEqual(len(vhosts), 10) @mock.patch('certbot_apache._internal.configurator.display_util.notify') def test_deploy_cert_enable_new_vhost(self, unused_mock_notify): # Create ssl_vhost = self.config.make_vhost_ssl(self.vh_truth[0]) self.config.parser.modules["ssl_module"] = None self.config.parser.modules["mod_ssl.c"] = None self.config.parser.modules["socache_shmcb_module"] = None self.assertFalse(ssl_vhost.enabled) self.config.deploy_cert( "encryption-example.demo", "example/cert.pem", "example/key.pem", "example/cert_chain.pem", "example/fullchain.pem") self.assertTrue(ssl_vhost.enabled) def test_no_duplicate_include(self): def mock_find_dir(directive, argument, _): """Mock method for parser.find_dir""" if directive == "Include" and argument.endswith("options-ssl-apache.conf"): return ["/path/to/whatever"] return None # pragma: no cover mock_add = mock.MagicMock() self.config.parser.add_dir = mock_add self.config._add_dummy_ssl_directives(self.vh_truth[0]) # pylint: disable=protected-access tried_to_add = False for a in mock_add.call_args_list: if a[0][1] == "Include" and a[0][2] == self.config.mod_ssl_conf: tried_to_add = True # Include should be added, find_dir is not patched, and returns falsy self.assertTrue(tried_to_add) self.config.parser.find_dir = mock_find_dir mock_add.reset_mock() self.config._add_dummy_ssl_directives(self.vh_truth[0]) # pylint: disable=protected-access for a in mock_add.call_args_list: if a[0][1] == "Include" and a[0][2] == self.config.mod_ssl_conf: self.fail("Include shouldn't be added, as patched find_dir 'finds' existing one") \ # pragma: no cover @mock.patch('certbot_apache._internal.configurator.display_util.notify') def test_deploy_cert(self, unused_mock_notify): self.config.parser.modules["ssl_module"] = None self.config.parser.modules["mod_ssl.c"] = None self.config.parser.modules["socache_shmcb_module"] = None # Patch _add_dummy_ssl_directives to make sure we write them correctly # pylint: disable=protected-access orig_add_dummy = self.config._add_dummy_ssl_directives def mock_add_dummy_ssl(vhostpath): """Mock method for _add_dummy_ssl_directives""" def find_args(path, directive): """Return list of arguments in requested directive at path""" f_args = [] dirs = self.config.parser.find_dir(directive, None, path) for d in dirs: f_args.append(self.config.parser.get_arg(d)) return f_args # Verify that the dummy directives do not exist self.assertFalse( "insert_cert_file_path" in find_args(vhostpath, "SSLCertificateFile")) self.assertFalse( "insert_key_file_path" in find_args(vhostpath, "SSLCertificateKeyFile")) orig_add_dummy(vhostpath) # Verify that the dummy directives exist self.assertTrue( "insert_cert_file_path" in find_args(vhostpath, "SSLCertificateFile")) self.assertTrue( "insert_key_file_path" in find_args(vhostpath, "SSLCertificateKeyFile")) # pylint: disable=protected-access self.config._add_dummy_ssl_directives = mock_add_dummy_ssl # Get the default 443 vhost self.config.assoc["random.demo"] = self.vh_truth[1] self.config.deploy_cert( "random.demo", "example/cert.pem", "example/key.pem", "example/cert_chain.pem") self.config.save() # Verify ssl_module was enabled. self.assertTrue(self.vh_truth[1].enabled) self.assertTrue("ssl_module" in self.config.parser.modules) loc_cert = self.config.parser.find_dir( "sslcertificatefile", "example/cert.pem", self.vh_truth[1].path) loc_key = self.config.parser.find_dir( "sslcertificateKeyfile", "example/key.pem", self.vh_truth[1].path) loc_chain = self.config.parser.find_dir( "SSLCertificateChainFile", "example/cert_chain.pem", self.vh_truth[1].path) # Verify one directive was found in the correct file self.assertEqual(len(loc_cert), 1) self.assertEqual( apache_util.get_file_path(loc_cert[0]), self.vh_truth[1].filep) self.assertEqual(len(loc_key), 1) self.assertEqual( apache_util.get_file_path(loc_key[0]), self.vh_truth[1].filep) self.assertEqual(len(loc_chain), 1) self.assertEqual( apache_util.get_file_path(loc_chain[0]), self.vh_truth[1].filep) # One more time for chain directive setting self.config.deploy_cert( "random.demo", "two/cert.pem", "two/key.pem", "two/cert_chain.pem") self.assertTrue(self.config.parser.find_dir( "SSLCertificateChainFile", "two/cert_chain.pem", self.vh_truth[1].path)) def test_is_name_vhost(self): addr = obj.Addr.fromstring("*:80") self.assertTrue(self.config.is_name_vhost(addr)) self.config.version = (2, 2) self.assertFalse(self.config.is_name_vhost(addr)) def test_add_name_vhost(self): self.config.add_name_vhost(obj.Addr.fromstring("*:443")) self.config.add_name_vhost(obj.Addr.fromstring("*:80")) self.assertTrue(self.config.parser.find_dir( "NameVirtualHost", "*:443", exclude=False)) self.assertTrue(self.config.parser.find_dir( "NameVirtualHost", "*:80")) def test_add_listen_80(self): mock_find = mock.Mock() mock_add_dir = mock.Mock() mock_find.return_value = [] self.config.parser.find_dir = mock_find self.config.parser.add_dir = mock_add_dir self.config.ensure_listen("80") self.assertTrue(mock_add_dir.called) self.assertTrue(mock_find.called) self.assertEqual(mock_add_dir.call_args[0][1], "Listen") self.assertEqual(mock_add_dir.call_args[0][2], "80") def test_add_listen_80_named(self): mock_find = mock.Mock() mock_find.return_value = ["test1", "test2", "test3"] mock_get = mock.Mock() mock_get.side_effect = ["1.2.3.4:80", "[::1]:80", "1.1.1.1:443"] mock_add_dir = mock.Mock() self.config.parser.find_dir = mock_find self.config.parser.get_arg = mock_get self.config.parser.add_dir = mock_add_dir self.config.ensure_listen("80") self.assertEqual(mock_add_dir.call_count, 0) # Reset return lists and inputs mock_add_dir.reset_mock() mock_get.side_effect = ["1.2.3.4:80", "[::1]:80", "1.1.1.1:443"] # Test self.config.ensure_listen("8080") self.assertEqual(mock_add_dir.call_count, 3) self.assertTrue(mock_add_dir.called) self.assertEqual(mock_add_dir.call_args[0][1], "Listen") call_found = False for mock_call in mock_add_dir.mock_calls: if mock_call[1][2] == ['1.2.3.4:8080']: call_found = True self.assertTrue(call_found) @mock.patch("certbot_apache._internal.parser.ApacheParser.reset_modules") def test_prepare_server_https(self, mock_reset): mock_enable = mock.Mock() self.config.enable_mod = mock_enable mock_find = mock.Mock() mock_add_dir = mock.Mock() mock_find.return_value = [] # This will test the Add listen self.config.parser.find_dir = mock_find self.config.parser.add_dir_to_ifmodssl = mock_add_dir self.config.prepare_server_https("443") # Changing the order these modules are enabled breaks the reverter self.assertEqual(mock_enable.call_args_list[0][0][0], "socache_shmcb") self.assertEqual(mock_enable.call_args[0][0], "ssl") self.assertEqual(mock_enable.call_args[1], {"temp": False}) self.config.prepare_server_https("8080", temp=True) # Changing the order these modules are enabled breaks the reverter self.assertEqual(mock_enable.call_args_list[2][0][0], "socache_shmcb") self.assertEqual(mock_enable.call_args[0][0], "ssl") # Enable mod is temporary self.assertEqual(mock_enable.call_args[1], {"temp": True}) self.assertEqual(mock_add_dir.call_count, 2) @mock.patch("certbot_apache._internal.parser.ApacheParser.reset_modules") def test_prepare_server_https_named_listen(self, mock_reset): mock_find = mock.Mock() mock_find.return_value = ["test1", "test2", "test3"] mock_get = mock.Mock() mock_get.side_effect = ["1.2.3.4:80", "[::1]:80", "1.1.1.1:443"] mock_add_dir = mock.Mock() mock_enable = mock.Mock() self.config.parser.find_dir = mock_find self.config.parser.get_arg = mock_get self.config.parser.add_dir_to_ifmodssl = mock_add_dir self.config.enable_mod = mock_enable # Test Listen statements with specific ip listeed self.config.prepare_server_https("443") # Should be 0 as one interface already listens to 443 self.assertEqual(mock_add_dir.call_count, 0) # Reset return lists and inputs mock_add_dir.reset_mock() mock_get.side_effect = ["1.2.3.4:80", "[::1]:80", "1.1.1.1:443"] # Test self.config.prepare_server_https("8080", temp=True) self.assertEqual(mock_add_dir.call_count, 3) call_args_list = [mock_add_dir.call_args_list[i][0][2] for i in range(3)] self.assertEqual( sorted(call_args_list), sorted([["1.2.3.4:8080", "https"], ["[::1]:8080", "https"], ["1.1.1.1:8080", "https"]])) # mock_get.side_effect = ["1.2.3.4:80", "[::1]:80"] # mock_find.return_value = ["test1", "test2", "test3"] # self.config.parser.get_arg = mock_get # self.config.prepare_server_https("8080", temp=True) # self.assertEqual(self.listens, 0) @mock.patch("certbot_apache._internal.parser.ApacheParser.reset_modules") def test_prepare_server_https_needed_listen(self, mock_reset): mock_find = mock.Mock() mock_find.return_value = ["test1", "test2"] mock_get = mock.Mock() mock_get.side_effect = ["1.2.3.4:8080", "80"] mock_add_dir = mock.Mock() mock_enable = mock.Mock() self.config.parser.find_dir = mock_find self.config.parser.get_arg = mock_get self.config.parser.add_dir_to_ifmodssl = mock_add_dir self.config.enable_mod = mock_enable self.config.prepare_server_https("443") self.assertEqual(mock_add_dir.call_count, 1) @mock.patch("certbot_apache._internal.parser.ApacheParser.reset_modules") def test_prepare_server_https_mixed_listen(self, mock_reset): mock_find = mock.Mock() mock_find.return_value = ["test1", "test2"] mock_get = mock.Mock() mock_get.side_effect = ["1.2.3.4:8080", "443"] mock_add_dir = mock.Mock() mock_enable = mock.Mock() self.config.parser.find_dir = mock_find self.config.parser.get_arg = mock_get self.config.parser.add_dir_to_ifmodssl = mock_add_dir self.config.enable_mod = mock_enable # Test Listen statements with specific ip listeed self.config.prepare_server_https("443") # Should only be 2 here, as the third interface # already listens to the correct port self.assertEqual(mock_add_dir.call_count, 0) def test_make_vhost_ssl_with_mock_span(self): # span excludes the closing tag in older versions # of Augeas return_value = [self.vh_truth[0].filep, 1, 12, 0, 0, 0, 1142] with mock.patch.object(self.config.parser.aug, 'span') as mock_span: mock_span.return_value = return_value self.test_make_vhost_ssl() def test_make_vhost_ssl_with_mock_span2(self): # span includes the closing tag in newer versions # of Augeas return_value = [self.vh_truth[0].filep, 1, 12, 0, 0, 0, 1157] with mock.patch.object(self.config.parser.aug, 'span') as mock_span: mock_span.return_value = return_value self.test_make_vhost_ssl() def test_make_vhost_ssl_nonsymlink(self): ssl_vhost_slink = self.config.make_vhost_ssl(self.vh_truth[8]) self.assertTrue(ssl_vhost_slink.ssl) self.assertTrue(ssl_vhost_slink.enabled) self.assertEqual(ssl_vhost_slink.name, "nonsym.link") def test_make_vhost_ssl_nonexistent_vhost_path(self): ssl_vhost = self.config.make_vhost_ssl(self.vh_truth[1]) self.assertEqual(os.path.dirname(ssl_vhost.filep), os.path.dirname(filesystem.realpath(self.vh_truth[1].filep))) def test_make_vhost_ssl(self): ssl_vhost = self.config.make_vhost_ssl(self.vh_truth[0]) self.assertEqual( ssl_vhost.filep, os.path.join(self.config_path, "sites-available", "encryption-example-le-ssl.conf")) self.assertEqual(ssl_vhost.path, "/files" + ssl_vhost.filep + "/IfModule/Virtualhost") self.assertEqual(len(ssl_vhost.addrs), 1) self.assertEqual({obj.Addr.fromstring("*:443")}, ssl_vhost.addrs) self.assertEqual(ssl_vhost.name, "encryption-example.demo") self.assertTrue(ssl_vhost.ssl) self.assertFalse(ssl_vhost.enabled) self.assertEqual(self.config.is_name_vhost(self.vh_truth[0]), self.config.is_name_vhost(ssl_vhost)) self.assertEqual(len(self.config.vhosts), 13) def test_clean_vhost_ssl(self): # pylint: disable=protected-access for directive in ["SSLCertificateFile", "SSLCertificateKeyFile", "SSLCertificateChainFile", "SSLCACertificatePath"]: for _ in range(10): self.config.parser.add_dir(self.vh_truth[1].path, directive, ["bogus"]) self.config.save() self.config._clean_vhost(self.vh_truth[1]) self.config.save() loc_cert = self.config.parser.find_dir( 'SSLCertificateFile', None, self.vh_truth[1].path, False) loc_key = self.config.parser.find_dir( 'SSLCertificateKeyFile', None, self.vh_truth[1].path, False) loc_chain = self.config.parser.find_dir( 'SSLCertificateChainFile', None, self.vh_truth[1].path, False) loc_cacert = self.config.parser.find_dir( 'SSLCACertificatePath', None, self.vh_truth[1].path, False) self.assertEqual(len(loc_cert), 1) self.assertEqual(len(loc_key), 1) self.assertEqual(len(loc_chain), 0) self.assertEqual(len(loc_cacert), 10) def test_deduplicate_directives(self): # pylint: disable=protected-access DIRECTIVE = "Foo" for _ in range(10): self.config.parser.add_dir(self.vh_truth[1].path, DIRECTIVE, ["bar"]) self.config.save() self.config._deduplicate_directives(self.vh_truth[1].path, [DIRECTIVE]) self.config.save() self.assertEqual( len(self.config.parser.find_dir( DIRECTIVE, None, self.vh_truth[1].path, False)), 1) def test_remove_directives(self): # pylint: disable=protected-access DIRECTIVES = ["Foo", "Bar"] for directive in DIRECTIVES: for _ in range(10): self.config.parser.add_dir(self.vh_truth[2].path, directive, ["baz"]) self.config.save() self.config._remove_directives(self.vh_truth[2].path, DIRECTIVES) self.config.save() for directive in DIRECTIVES: self.assertEqual( len(self.config.parser.find_dir( directive, None, self.vh_truth[2].path, False)), 0) def test_make_vhost_ssl_bad_write(self): mock_open = mock.mock_open() # This calls open self.config.reverter.register_file_creation = mock.Mock() mock_open.side_effect = IOError with mock.patch("builtins.open", mock_open): self.assertRaises( errors.PluginError, self.config.make_vhost_ssl, self.vh_truth[0]) def test_get_ssl_vhost_path(self): # pylint: disable=protected-access self.assertTrue( self.config._get_ssl_vhost_path("example_path").endswith(".conf")) def test_add_name_vhost_if_necessary(self): # pylint: disable=protected-access self.config.add_name_vhost = mock.Mock() self.config.version = (2, 2) self.config._add_name_vhost_if_necessary(self.vh_truth[0]) self.assertTrue(self.config.add_name_vhost.called) new_addrs = set() for addr in self.vh_truth[0].addrs: new_addrs.add(obj.Addr(("_default_", addr.get_port(),))) self.vh_truth[0].addrs = new_addrs self.config._add_name_vhost_if_necessary(self.vh_truth[0]) self.assertEqual(self.config.add_name_vhost.call_count, 2) @mock.patch("certbot_apache._internal.configurator.http_01.ApacheHttp01.perform") @mock.patch("certbot_apache._internal.configurator.ApacheConfigurator.restart") def test_perform(self, mock_restart, mock_http_perform): # Only tests functionality specific to configurator.perform # Note: As more challenges are offered this will have to be expanded account_key, achalls = self.get_key_and_achalls() expected = [achall.response(account_key) for achall in achalls] mock_http_perform.return_value = expected responses = self.config.perform(achalls) self.assertEqual(mock_http_perform.call_count, 1) self.assertEqual(responses, expected) self.assertEqual(mock_restart.call_count, 1) @mock.patch("certbot_apache._internal.configurator.ApacheConfigurator.restart") @mock.patch("certbot_apache._internal.apache_util._get_runtime_cfg") def test_cleanup(self, mock_cfg, mock_restart): mock_cfg.return_value = "" _, achalls = self.get_key_and_achalls() for achall in achalls: self.config._chall_out.add(achall) # pylint: disable=protected-access for i, achall in enumerate(achalls): self.config.cleanup([achall]) if i == len(achalls) - 1: self.assertTrue(mock_restart.called) else: self.assertFalse(mock_restart.called) @mock.patch("certbot_apache._internal.configurator.ApacheConfigurator.restart") @mock.patch("certbot_apache._internal.apache_util._get_runtime_cfg") def test_cleanup_no_errors(self, mock_cfg, mock_restart): mock_cfg.return_value = "" _, achalls = self.get_key_and_achalls() self.config.http_doer = mock.MagicMock() for achall in achalls: self.config._chall_out.add(achall) # pylint: disable=protected-access self.config.cleanup([achalls[-1]]) self.assertFalse(mock_restart.called) self.config.cleanup(achalls) self.assertTrue(mock_restart.called) @mock.patch("certbot.util.run_script") def test_get_version(self, mock_script): mock_script.return_value = ( "Server Version: Apache/2.4.2 (Debian)", "") self.assertEqual(self.config.get_version(), (2, 4, 2)) mock_script.return_value = ( "Server Version: Apache/2 (Linux)", "") self.assertEqual(self.config.get_version(), (2,)) mock_script.return_value = ( "Server Version: Apache (Debian)", "") self.assertRaises(errors.PluginError, self.config.get_version) mock_script.return_value = ( "Server Version: Apache/2.3{0} Apache/2.4.7".format( os.linesep), "") self.assertRaises(errors.PluginError, self.config.get_version) mock_script.side_effect = errors.SubprocessError("Can't find program") self.assertRaises(errors.PluginError, self.config.get_version) @mock.patch("certbot_apache._internal.configurator.util.run_script") def test_restart(self, _): self.config.restart() @mock.patch("certbot_apache._internal.configurator.util.run_script") def test_restart_bad_process(self, mock_run_script): mock_run_script.side_effect = [None, errors.SubprocessError] self.assertRaises(errors.MisconfigurationError, self.config.restart) @mock.patch("certbot.util.run_script") def test_config_test(self, _): self.config.config_test() @mock.patch("certbot.util.run_script") def test_config_test_bad_process(self, mock_run_script): mock_run_script.side_effect = errors.SubprocessError self.assertRaises(errors.MisconfigurationError, self.config.config_test) def test_more_info(self): self.assertTrue(self.config.more_info()) def test_get_chall_pref(self): self.assertTrue(isinstance(self.config.get_chall_pref(""), list)) def test_install_ssl_options_conf(self): path = os.path.join(self.work_dir, "test_it") other_path = os.path.join(self.work_dir, "other_test_it") self.config.install_ssl_options_conf(path, other_path) self.assertTrue(os.path.isfile(path)) self.assertTrue(os.path.isfile(other_path)) # TEST ENHANCEMENTS def test_supported_enhancements(self): self.assertTrue(isinstance(self.config.supported_enhancements(), list)) def test_find_http_vhost_without_ancestor(self): # pylint: disable=protected-access vhost = self.vh_truth[0] vhost.ssl = True vhost.ancestor = None res = self.config._get_http_vhost(vhost) self.assertEqual(self.vh_truth[0].name, res.name) self.assertEqual(self.vh_truth[0].aliases, res.aliases) @mock.patch("certbot_apache._internal.configurator.ApacheConfigurator._get_http_vhost") @mock.patch("certbot_apache._internal.display_ops.select_vhost") @mock.patch("certbot.util.exe_exists") def test_enhance_unknown_vhost(self, mock_exe, mock_sel_vhost, mock_get): self.config.parser.modules["rewrite_module"] = None mock_exe.return_value = True ssl_vh1 = obj.VirtualHost( "fp1", "ap1", {obj.Addr(("*", "443"))}, True, False) ssl_vh1.name = "satoshi.com" self.config.vhosts.append(ssl_vh1) mock_sel_vhost.return_value = None mock_get.return_value = None self.assertRaises( errors.PluginError, self.config.enhance, "satoshi.com", "redirect") def test_enhance_unknown_enhancement(self): self.assertRaises( errors.PluginError, self.config.enhance, "certbot.demo", "unknown_enhancement") def test_enhance_no_ssl_vhost(self): with mock.patch("certbot_apache._internal.configurator.logger.error") as mock_log: self.assertRaises(errors.PluginError, self.config.enhance, "certbot.demo", "redirect") # Check that correct logger.warning was printed self.assertTrue("not able to find" in mock_log.call_args[0][0]) self.assertTrue("\"redirect\"" in mock_log.call_args[0][0]) mock_log.reset_mock() self.assertRaises(errors.PluginError, self.config.enhance, "certbot.demo", "ensure-http-header", "Test") # Check that correct logger.warning was printed self.assertTrue("not able to find" in mock_log.call_args[0][0]) self.assertTrue("Test" in mock_log.call_args[0][0]) @mock.patch("certbot.util.exe_exists") def test_ocsp_stapling(self, mock_exe): self.config.parser.update_runtime_variables = mock.Mock() self.config.parser.modules["mod_ssl.c"] = None self.config.parser.modules["socache_shmcb_module"] = None self.config.get_version = mock.Mock(return_value=(2, 4, 7)) mock_exe.return_value = True # This will create an ssl vhost for certbot.demo self.config.choose_vhost("certbot.demo") self.config.enhance("certbot.demo", "staple-ocsp") # Get the ssl vhost for certbot.demo ssl_vhost = self.config.assoc["certbot.demo"] ssl_use_stapling_aug_path = self.config.parser.find_dir( "SSLUseStapling", "on", ssl_vhost.path) self.assertEqual(len(ssl_use_stapling_aug_path), 1) ssl_vhost_aug_path = parser.get_aug_path(ssl_vhost.filep) stapling_cache_aug_path = self.config.parser.find_dir('SSLStaplingCache', "shmcb:/var/run/apache2/stapling_cache(128000)", ssl_vhost_aug_path) self.assertEqual(len(stapling_cache_aug_path), 1) @mock.patch("certbot.util.exe_exists") def test_ocsp_stapling_twice(self, mock_exe): self.config.parser.update_runtime_variables = mock.Mock() self.config.parser.modules["mod_ssl.c"] = None self.config.parser.modules["socache_shmcb_module"] = None self.config.get_version = mock.Mock(return_value=(2, 4, 7)) mock_exe.return_value = True # Checking the case with already enabled ocsp stapling configuration self.config.choose_vhost("ocspvhost.com") self.config.enhance("ocspvhost.com", "staple-ocsp") # Get the ssl vhost for letsencrypt.demo ssl_vhost = self.config.assoc["ocspvhost.com"] ssl_use_stapling_aug_path = self.config.parser.find_dir( "SSLUseStapling", "on", ssl_vhost.path) self.assertEqual(len(ssl_use_stapling_aug_path), 1) ssl_vhost_aug_path = parser.get_aug_path(ssl_vhost.filep) stapling_cache_aug_path = self.config.parser.find_dir('SSLStaplingCache', "shmcb:/var/run/apache2/stapling_cache(128000)", ssl_vhost_aug_path) self.assertEqual(len(stapling_cache_aug_path), 1) @mock.patch("certbot.util.exe_exists") def test_ocsp_unsupported_apache_version(self, mock_exe): mock_exe.return_value = True self.config.parser.update_runtime_variables = mock.Mock() self.config.parser.modules["mod_ssl.c"] = None self.config.parser.modules["socache_shmcb_module"] = None self.config.get_version = mock.Mock(return_value=(2, 2, 0)) self.config.choose_vhost("certbot.demo") self.assertRaises(errors.PluginError, self.config.enhance, "certbot.demo", "staple-ocsp") def test_get_http_vhost_third_filter(self): ssl_vh = obj.VirtualHost( "fp", "ap", {obj.Addr(("*", "443"))}, True, False) ssl_vh.name = "satoshi.com" self.config.vhosts.append(ssl_vh) # pylint: disable=protected-access http_vh = self.config._get_http_vhost(ssl_vh) self.assertFalse(http_vh.ssl) @mock.patch("certbot.util.run_script") @mock.patch("certbot.util.exe_exists") def test_http_header_hsts(self, mock_exe, _): self.config.parser.update_runtime_variables = mock.Mock() self.config.parser.modules["mod_ssl.c"] = None self.config.parser.modules["headers_module"] = None mock_exe.return_value = True # This will create an ssl vhost for certbot.demo self.config.choose_vhost("certbot.demo") self.config.enhance("certbot.demo", "ensure-http-header", "Strict-Transport-Security") # Get the ssl vhost for certbot.demo ssl_vhost = self.config.assoc["certbot.demo"] # These are not immediately available in find_dir even with save() and # load(). They must be found in sites-available hsts_header = self.config.parser.find_dir( "Header", None, ssl_vhost.path) # four args to HSTS header self.assertEqual(len(hsts_header), 4) def test_http_header_hsts_twice(self): self.config.parser.modules["mod_ssl.c"] = None # skip the enable mod self.config.parser.modules["headers_module"] = None # This will create an ssl vhost for encryption-example.demo self.config.choose_vhost("encryption-example.demo") self.config.enhance("encryption-example.demo", "ensure-http-header", "Strict-Transport-Security") self.assertRaises( errors.PluginEnhancementAlreadyPresent, self.config.enhance, "encryption-example.demo", "ensure-http-header", "Strict-Transport-Security") @mock.patch("certbot.util.run_script") @mock.patch("certbot.util.exe_exists") def test_http_header_uir(self, mock_exe, _): self.config.parser.update_runtime_variables = mock.Mock() self.config.parser.modules["mod_ssl.c"] = None self.config.parser.modules["headers_module"] = None mock_exe.return_value = True # This will create an ssl vhost for certbot.demo self.config.choose_vhost("certbot.demo") self.config.enhance("certbot.demo", "ensure-http-header", "Upgrade-Insecure-Requests") self.assertTrue("headers_module" in self.config.parser.modules) # Get the ssl vhost for certbot.demo ssl_vhost = self.config.assoc["certbot.demo"] # These are not immediately available in find_dir even with save() and # load(). They must be found in sites-available uir_header = self.config.parser.find_dir( "Header", None, ssl_vhost.path) # four args to HSTS header self.assertEqual(len(uir_header), 4) def test_http_header_uir_twice(self): self.config.parser.modules["mod_ssl.c"] = None # skip the enable mod self.config.parser.modules["headers_module"] = None # This will create an ssl vhost for encryption-example.demo self.config.choose_vhost("encryption-example.demo") self.config.enhance("encryption-example.demo", "ensure-http-header", "Upgrade-Insecure-Requests") self.assertRaises( errors.PluginEnhancementAlreadyPresent, self.config.enhance, "encryption-example.demo", "ensure-http-header", "Upgrade-Insecure-Requests") @mock.patch("certbot.util.run_script") @mock.patch("certbot.util.exe_exists") def test_redirect_well_formed_http(self, mock_exe, _): self.config.parser.modules["rewrite_module"] = None self.config.parser.update_runtime_variables = mock.Mock() mock_exe.return_value = True self.config.get_version = mock.Mock(return_value=(2, 2)) # This will create an ssl vhost for certbot.demo self.config.choose_vhost("certbot.demo") self.config.enhance("certbot.demo", "redirect") # These are not immediately available in find_dir even with save() and # load(). They must be found in sites-available rw_engine = self.config.parser.find_dir( "RewriteEngine", "on", self.vh_truth[3].path) rw_rule = self.config.parser.find_dir( "RewriteRule", None, self.vh_truth[3].path) self.assertEqual(len(rw_engine), 1) # three args to rw_rule self.assertEqual(len(rw_rule), 3) # [:-3] to remove the vhost index number self.assertTrue(rw_engine[0].startswith(self.vh_truth[3].path[:-3])) self.assertTrue(rw_rule[0].startswith(self.vh_truth[3].path[:-3])) def test_rewrite_rule_exists(self): # Skip the enable mod self.config.parser.modules["rewrite_module"] = None self.config.get_version = mock.Mock(return_value=(2, 3, 9)) self.config.parser.add_dir( self.vh_truth[3].path, "RewriteRule", ["Unknown"]) # pylint: disable=protected-access self.assertTrue(self.config._is_rewrite_exists(self.vh_truth[3])) def test_rewrite_engine_exists(self): # Skip the enable mod self.config.parser.modules["rewrite_module"] = None self.config.get_version = mock.Mock(return_value=(2, 3, 9)) self.config.parser.add_dir( self.vh_truth[3].path, "RewriteEngine", "on") # pylint: disable=protected-access self.assertTrue(self.config._is_rewrite_engine_on(self.vh_truth[3])) @mock.patch("certbot.util.run_script") @mock.patch("certbot.util.exe_exists") def test_redirect_with_existing_rewrite(self, mock_exe, _): self.config.parser.modules["rewrite_module"] = None self.config.parser.update_runtime_variables = mock.Mock() mock_exe.return_value = True self.config.get_version = mock.Mock(return_value=(2, 2, 0)) # Create a preexisting rewrite rule self.config.parser.add_dir( self.vh_truth[3].path, "RewriteRule", ["UnknownPattern", "UnknownTarget"]) self.config.save() # This will create an ssl vhost for certbot.demo self.config.choose_vhost("certbot.demo") self.config.enhance("certbot.demo", "redirect") # These are not immediately available in find_dir even with save() and # load(). They must be found in sites-available rw_engine = self.config.parser.find_dir( "RewriteEngine", "on", self.vh_truth[3].path) rw_rule = self.config.parser.find_dir( "RewriteRule", None, self.vh_truth[3].path) self.assertEqual(len(rw_engine), 1) # three args to rw_rule + 1 arg for the pre existing rewrite self.assertEqual(len(rw_rule), 5) # [:-3] to remove the vhost index number self.assertTrue(rw_engine[0].startswith(self.vh_truth[3].path[:-3])) self.assertTrue(rw_rule[0].startswith(self.vh_truth[3].path[:-3])) self.assertTrue("rewrite_module" in self.config.parser.modules) @mock.patch("certbot.util.run_script") @mock.patch("certbot.util.exe_exists") def test_redirect_with_old_https_redirection(self, mock_exe, _): self.config.parser.modules["rewrite_module"] = None self.config.parser.update_runtime_variables = mock.Mock() mock_exe.return_value = True self.config.get_version = mock.Mock(return_value=(2, 2, 0)) ssl_vhost = self.config.choose_vhost("certbot.demo") # pylint: disable=protected-access http_vhost = self.config._get_http_vhost(ssl_vhost) # Create an old (previously suppoorted) https redirectoin rewrite rule self.config.parser.add_dir( http_vhost.path, "RewriteRule", ["^", "https://%{SERVER_NAME}%{REQUEST_URI}", "[L,QSA,R=permanent]"]) self.config.save() try: self.config.enhance("certbot.demo", "redirect") except errors.PluginEnhancementAlreadyPresent: args_paths = self.config.parser.find_dir( "RewriteRule", None, http_vhost.path, False) arg_vals = [self.config.parser.aug.get(x) for x in args_paths] self.assertEqual(arg_vals, constants.REWRITE_HTTPS_ARGS) def test_redirect_with_conflict(self): self.config.parser.modules["rewrite_module"] = None ssl_vh = obj.VirtualHost( "fp", "ap", {obj.Addr(("*", "443")), obj.Addr(("zombo.com",))}, True, False) # No names ^ this guy should conflict. # pylint: disable=protected-access self.assertRaises( errors.PluginError, self.config._enable_redirect, ssl_vh, "") def test_redirect_two_domains_one_vhost(self): # Skip the enable mod self.config.parser.modules["rewrite_module"] = None self.config.get_version = mock.Mock(return_value=(2, 3, 9)) # Creates ssl vhost for the domain self.config.choose_vhost("red.blue.purple.com") self.config.enhance("red.blue.purple.com", "redirect") verify_no_redirect = ("certbot_apache._internal.configurator." "ApacheConfigurator._verify_no_certbot_redirect") with mock.patch(verify_no_redirect) as mock_verify: self.config.enhance("green.blue.purple.com", "redirect") self.assertFalse(mock_verify.called) def test_redirect_from_previous_run(self): # Skip the enable mod self.config.parser.modules["rewrite_module"] = None self.config.get_version = mock.Mock(return_value=(2, 3, 9)) self.config.choose_vhost("red.blue.purple.com") self.config.enhance("red.blue.purple.com", "redirect") # Clear state about enabling redirect on this run # pylint: disable=protected-access self.config._enhanced_vhosts["redirect"].clear() self.assertRaises( errors.PluginEnhancementAlreadyPresent, self.config.enhance, "green.blue.purple.com", "redirect") def test_create_own_redirect(self): self.config.parser.modules["rewrite_module"] = None self.config.get_version = mock.Mock(return_value=(2, 3, 9)) # For full testing... give names... self.vh_truth[1].name = "default.com" self.vh_truth[1].aliases = {"yes.default.com"} # pylint: disable=protected-access self.config._enable_redirect(self.vh_truth[1], "") self.assertEqual(len(self.config.vhosts), 13) def test_create_own_redirect_for_old_apache_version(self): self.config.parser.modules["rewrite_module"] = None self.config.get_version = mock.Mock(return_value=(2, 2)) # For full testing... give names... self.vh_truth[1].name = "default.com" self.vh_truth[1].aliases = {"yes.default.com"} # pylint: disable=protected-access self.config._enable_redirect(self.vh_truth[1], "") self.assertEqual(len(self.config.vhosts), 13) def test_sift_rewrite_rule(self): # pylint: disable=protected-access small_quoted_target = "RewriteRule ^ \"http://\"" self.assertFalse(self.config._sift_rewrite_rule(small_quoted_target)) https_target = "RewriteRule ^ https://satoshi" self.assertTrue(self.config._sift_rewrite_rule(https_target)) normal_target = "RewriteRule ^/(.*) http://www.a.com:1234/$1 [L,R]" self.assertFalse(self.config._sift_rewrite_rule(normal_target)) not_rewriterule = "NotRewriteRule ^ ..." self.assertFalse(self.config._sift_rewrite_rule(not_rewriterule)) def get_key_and_achalls(self): """Return testing achallenges.""" account_key = self.rsa512jwk achall1 = achallenges.KeyAuthorizationAnnotatedChallenge( challb=acme_util.chall_to_challb( challenges.HTTP01( token=b"jIq_Xy1mXGN37tb4L6Xj_es58fW571ZNyXekdZzhh7Q"), "pending"), domain="encryption-example.demo", account_key=account_key) achall2 = achallenges.KeyAuthorizationAnnotatedChallenge( challb=acme_util.chall_to_challb( challenges.HTTP01( token=b"uqnaPzxtrndteOqtrXb0Asl5gOJfWAnnx6QJyvcmlDU"), "pending"), domain="certbot.demo", account_key=account_key) achall3 = achallenges.KeyAuthorizationAnnotatedChallenge( challb=acme_util.chall_to_challb( challenges.HTTP01(token=(b'x' * 16)), "pending"), domain="example.org", account_key=account_key) return account_key, (achall1, achall2, achall3) def test_enable_site_nondebian(self): inc_path = "/path/to/wherever" vhost = self.vh_truth[0] vhost.enabled = False vhost.filep = inc_path self.assertFalse(self.config.parser.find_dir("Include", inc_path)) self.assertFalse( os.path.dirname(inc_path) in self.config.parser.existing_paths) self.config.enable_site(vhost) self.assertTrue(self.config.parser.find_dir("Include", inc_path)) self.assertTrue( os.path.dirname(inc_path) in self.config.parser.existing_paths) self.assertTrue( os.path.basename(inc_path) in self.config.parser.existing_paths[ os.path.dirname(inc_path)]) @mock.patch('certbot_apache._internal.configurator.display_util.notify') def test_deploy_cert_not_parsed_path(self, unused_mock_notify): # Make sure that we add include to root config for vhosts when # handle-sites is false self.config.parser.modules["ssl_module"] = None self.config.parser.modules["mod_ssl.c"] = None self.config.parser.modules["socache_shmcb_module"] = None tmp_path = filesystem.realpath(tempfile.mkdtemp("vhostroot")) filesystem.chmod(tmp_path, 0o755) mock_p = "certbot_apache._internal.configurator.ApacheConfigurator._get_ssl_vhost_path" mock_a = "certbot_apache._internal.parser.ApacheParser.add_include" with mock.patch(mock_p) as mock_path: mock_path.return_value = os.path.join(tmp_path, "whatever.conf") with mock.patch(mock_a) as mock_add: self.config.deploy_cert( "encryption-example.demo", "example/cert.pem", "example/key.pem", "example/cert_chain.pem") # Test that we actually called add_include self.assertTrue(mock_add.called) shutil.rmtree(tmp_path) def test_deploy_cert_no_mod_ssl(self): # Create ssl_vhost = self.config.make_vhost_ssl(self.vh_truth[0]) self.config.parser.modules["socache_shmcb_module"] = None self.config.prepare_server_https = mock.Mock() self.assertRaises(errors.MisconfigurationError, self.config.deploy_cert, "encryption-example.demo", "example/cert.pem", "example/key.pem", "example/cert_chain.pem", "example/fullchain.pem") @mock.patch("certbot_apache._internal.parser.ApacheParser.parsed_in_original") def test_choose_vhost_and_servername_addition_parsed(self, mock_parsed): ret_vh = self.vh_truth[8] ret_vh.enabled = True self.config.enable_site(ret_vh) # Make sure that we return early self.assertFalse(mock_parsed.called) def test_enable_mod_unsupported(self): self.assertRaises(errors.MisconfigurationError, self.config.enable_mod, "whatever") def test_choose_vhosts_wildcard(self): # pylint: disable=protected-access mock_path = "certbot_apache._internal.display_ops.select_vhost_multiple" with mock.patch(mock_path) as mock_select_vhs: mock_select_vhs.return_value = [self.vh_truth[3]] vhs = self.config._choose_vhosts_wildcard("*.certbot.demo", create_ssl=True) # Check that the dialog was called with one vh: certbot.demo self.assertEqual(mock_select_vhs.call_args[0][0][0], self.vh_truth[3]) self.assertEqual(len(mock_select_vhs.call_args_list), 1) # And the actual returned values self.assertEqual(len(vhs), 1) self.assertEqual(vhs[0].name, "certbot.demo") self.assertTrue(vhs[0].ssl) self.assertNotEqual(vhs[0], self.vh_truth[3]) @mock.patch("certbot_apache._internal.configurator.ApacheConfigurator.make_vhost_ssl") def test_choose_vhosts_wildcard_no_ssl(self, mock_makessl): # pylint: disable=protected-access mock_path = "certbot_apache._internal.display_ops.select_vhost_multiple" with mock.patch(mock_path) as mock_select_vhs: mock_select_vhs.return_value = [self.vh_truth[1]] vhs = self.config._choose_vhosts_wildcard("*.certbot.demo", create_ssl=False) self.assertFalse(mock_makessl.called) self.assertEqual(vhs[0], self.vh_truth[1]) @mock.patch("certbot_apache._internal.configurator.ApacheConfigurator._vhosts_for_wildcard") @mock.patch("certbot_apache._internal.configurator.ApacheConfigurator.make_vhost_ssl") def test_choose_vhosts_wildcard_already_ssl(self, mock_makessl, mock_vh_for_w): # pylint: disable=protected-access # Already SSL vhost mock_vh_for_w.return_value = [self.vh_truth[7]] mock_path = "certbot_apache._internal.display_ops.select_vhost_multiple" with mock.patch(mock_path) as mock_select_vhs: mock_select_vhs.return_value = [self.vh_truth[7]] vhs = self.config._choose_vhosts_wildcard("whatever", create_ssl=True) self.assertEqual(mock_select_vhs.call_args[0][0][0], self.vh_truth[7]) self.assertEqual(len(mock_select_vhs.call_args_list), 1) # Ensure that make_vhost_ssl was not called, vhost.ssl == true self.assertFalse(mock_makessl.called) # And the actual returned values self.assertEqual(len(vhs), 1) self.assertTrue(vhs[0].ssl) self.assertEqual(vhs[0], self.vh_truth[7]) @mock.patch('certbot_apache._internal.configurator.display_util.notify') def test_deploy_cert_wildcard(self, unused_mock_notify): # pylint: disable=protected-access mock_choose_vhosts = mock.MagicMock() mock_choose_vhosts.return_value = [self.vh_truth[7]] self.config._choose_vhosts_wildcard = mock_choose_vhosts mock_d = "certbot_apache._internal.configurator.ApacheConfigurator._deploy_cert" with mock.patch(mock_d) as mock_dep: self.config.deploy_cert("*.wildcard.example.org", "/tmp/path", "/tmp/path", "/tmp/path", "/tmp/path") self.assertTrue(mock_dep.called) self.assertEqual(len(mock_dep.call_args_list), 1) self.assertEqual(self.vh_truth[7], mock_dep.call_args_list[0][0][0]) @mock.patch("certbot_apache._internal.display_ops.select_vhost_multiple") def test_deploy_cert_wildcard_no_vhosts(self, mock_dialog): # pylint: disable=protected-access mock_dialog.return_value = [] self.assertRaises(errors.PluginError, self.config.deploy_cert, "*.wild.cat", "/tmp/path", "/tmp/path", "/tmp/path", "/tmp/path") @mock.patch("certbot_apache._internal.configurator.ApacheConfigurator._choose_vhosts_wildcard") def test_enhance_wildcard_after_install(self, mock_choose): # pylint: disable=protected-access self.config.parser.modules["mod_ssl.c"] = None self.config.parser.modules["headers_module"] = None self.vh_truth[3].ssl = True self.config._wildcard_vhosts["*.certbot.demo"] = [self.vh_truth[3]] self.config.enhance("*.certbot.demo", "ensure-http-header", "Upgrade-Insecure-Requests") self.assertFalse(mock_choose.called) @mock.patch("certbot_apache._internal.configurator.ApacheConfigurator._choose_vhosts_wildcard") def test_enhance_wildcard_no_install(self, mock_choose): self.vh_truth[3].ssl = True mock_choose.return_value = [self.vh_truth[3]] self.config.parser.modules["mod_ssl.c"] = None self.config.parser.modules["headers_module"] = None self.config.enhance("*.certbot.demo", "ensure-http-header", "Upgrade-Insecure-Requests") self.assertTrue(mock_choose.called) def test_add_vhost_id(self): for vh in [self.vh_truth[0], self.vh_truth[1], self.vh_truth[2]]: vh_id = self.config.add_vhost_id(vh) self.assertEqual(vh, self.config.find_vhost_by_id(vh_id)) def test_find_vhost_by_id_404(self): self.assertRaises(errors.PluginError, self.config.find_vhost_by_id, "nonexistent") def test_add_vhost_id_already_exists(self): first_id = self.config.add_vhost_id(self.vh_truth[0]) second_id = self.config.add_vhost_id(self.vh_truth[0]) self.assertEqual(first_id, second_id) def test_realpath_replaces_symlink(self): orig_match = self.config.parser.aug.match mock_vhost = copy.deepcopy(self.vh_truth[0]) mock_vhost.filep = mock_vhost.filep.replace('sites-enabled', u'sites-available') mock_vhost.path = mock_vhost.path.replace('sites-enabled', 'sites-available') mock_vhost.enabled = False self.config.parser.parse_file(mock_vhost.filep) def mock_match(aug_expr): """Return a mocked match list of VirtualHosts""" if "/mocked/path" in aug_expr: return [self.vh_truth[1].path, self.vh_truth[0].path, mock_vhost.path] return orig_match(aug_expr) self.config.parser.parser_paths = ["/mocked/path"] self.config.parser.aug.match = mock_match vhs = self.config.get_virtual_hosts() self.assertEqual(len(vhs), 2) self.assertEqual(vhs[0], self.vh_truth[1]) # mock_vhost should have replaced the vh_truth[0], because its filepath # isn't a symlink self.assertEqual(vhs[1], mock_vhost) class AugeasVhostsTest(util.ApacheTest): """Test vhosts with illegal names dependent on augeas version.""" # pylint: disable=protected-access def setUp(self): # pylint: disable=arguments-differ td = "debian_apache_2_4/augeas_vhosts" cr = "debian_apache_2_4/augeas_vhosts/apache2" vr = "debian_apache_2_4/augeas_vhosts/apache2/sites-available" super().setUp(test_dir=td, config_root=cr, vhost_root=vr) self.config = util.get_apache_configurator( self.config_path, self.vhost_path, self.config_dir, self.work_dir) def test_choosevhost_with_illegal_name(self): self.config.parser.aug = mock.MagicMock() self.config.parser.aug.match.side_effect = RuntimeError path = "debian_apache_2_4/augeas_vhosts/apache2/sites-available/old-and-default.conf" chosen_vhost = self.config._create_vhost(path) self.assertEqual(None, chosen_vhost) def test_choosevhost_works(self): path = "debian_apache_2_4/augeas_vhosts/apache2/sites-available/old-and-default.conf" chosen_vhost = self.config._create_vhost(path) self.assertTrue(chosen_vhost is None or chosen_vhost.path == path) @mock.patch("certbot_apache._internal.configurator.ApacheConfigurator._create_vhost") def test_get_vhost_continue(self, mock_vhost): mock_vhost.return_value = None vhs = self.config.get_virtual_hosts() self.assertEqual([], vhs) def test_choose_vhost_with_matching_wildcard(self): names = ( "an.example.net", "another.example.net", "an.other.example.net") for name in names: self.assertFalse(name in self.config.choose_vhost(name).aliases) @mock.patch("certbot_apache._internal.obj.VirtualHost.conflicts") def test_choose_vhost_without_matching_wildcard(self, mock_conflicts): mock_conflicts.return_value = False mock_path = "certbot_apache._internal.display_ops.select_vhost" with mock.patch(mock_path, lambda _, vhosts: vhosts[0]): for name in ("a.example.net", "other.example.net"): self.assertTrue(name in self.config.choose_vhost(name).aliases) @mock.patch("certbot_apache._internal.obj.VirtualHost.conflicts") def test_choose_vhost_wildcard_not_found(self, mock_conflicts): mock_conflicts.return_value = False mock_path = "certbot_apache._internal.display_ops.select_vhost" names = ( "abc.example.net", "not.there.tld", "aa.wildcard.tld" ) with mock.patch(mock_path) as mock_select: mock_select.return_value = self.config.vhosts[0] for name in names: orig_cc = mock_select.call_count self.config.choose_vhost(name) self.assertEqual(mock_select.call_count - orig_cc, 1) def test_choose_vhost_wildcard_found(self): mock_path = "certbot_apache._internal.display_ops.select_vhost" names = ( "ab.example.net", "a.wildcard.tld", "yetanother.example.net" ) with mock.patch(mock_path) as mock_select: mock_select.return_value = self.config.vhosts[0] for name in names: self.config.choose_vhost(name) self.assertEqual(mock_select.call_count, 0) def test_augeas_span_error(self): broken_vhost = self.config.vhosts[0] broken_vhost.path = broken_vhost.path + "/nonexistent" self.assertRaises(errors.PluginError, self.config.make_vhost_ssl, broken_vhost) class MultiVhostsTest(util.ApacheTest): """Test configuration with multiple virtualhosts in a single file.""" # pylint: disable=protected-access def setUp(self): # pylint: disable=arguments-differ td = "debian_apache_2_4/multi_vhosts" cr = "debian_apache_2_4/multi_vhosts/apache2" vr = "debian_apache_2_4/multi_vhosts/apache2/sites-available" super().setUp(test_dir=td, config_root=cr, vhost_root=vr) self.config = util.get_apache_configurator( self.config_path, self.vhost_path, self.config_dir, self.work_dir, conf_vhost_path=self.vhost_path) self.vh_truth = util.get_vh_truth( self.temp_dir, "debian_apache_2_4/multi_vhosts") def test_make_vhost_ssl(self): ssl_vhost = self.config.make_vhost_ssl(self.vh_truth[1]) self.assertEqual( ssl_vhost.filep, os.path.join(self.config_path, "sites-available", "default-le-ssl.conf")) self.assertEqual(ssl_vhost.path, "/files" + ssl_vhost.filep + "/IfModule/VirtualHost") self.assertEqual(len(ssl_vhost.addrs), 1) self.assertEqual({obj.Addr.fromstring("*:443")}, ssl_vhost.addrs) self.assertEqual(ssl_vhost.name, "banana.vomit.com") self.assertTrue(ssl_vhost.ssl) self.assertFalse(ssl_vhost.enabled) self.assertEqual(self.config.is_name_vhost(self.vh_truth[1]), self.config.is_name_vhost(ssl_vhost)) mock_path = "certbot_apache._internal.configurator.ApacheConfigurator._get_new_vh_path" with mock.patch(mock_path) as mock_getpath: mock_getpath.return_value = None self.assertRaises(errors.PluginError, self.config.make_vhost_ssl, self.vh_truth[1]) def test_get_new_path(self): with_index_1 = ["/path[1]/section[1]"] without_index = ["/path/section"] with_index_2 = ["/path[2]/section[2]"] self.assertEqual(self.config._get_new_vh_path(without_index, with_index_1), None) self.assertEqual(self.config._get_new_vh_path(without_index, with_index_2), with_index_2[0]) both = with_index_1 + with_index_2 self.assertEqual(self.config._get_new_vh_path(without_index, both), with_index_2[0]) @mock.patch("certbot_apache._internal.configurator.display_util.notify") def test_make_vhost_ssl_with_existing_rewrite_rule(self, mock_notify): self.config.parser.modules["rewrite_module"] = None ssl_vhost = self.config.make_vhost_ssl(self.vh_truth[4]) self.assertTrue(self.config.parser.find_dir( "RewriteEngine", "on", ssl_vhost.path, False)) with open(ssl_vhost.filep) as the_file: conf_text = the_file.read() commented_rewrite_rule = ("# RewriteRule \"^/secrets/(.+)\" " "\"https://new.example.com/docs/$1\" [R,L]") uncommented_rewrite_rule = ("RewriteRule \"^/docs/(.+)\" " "\"http://new.example.com/docs/$1\" [R,L]") self.assertTrue(commented_rewrite_rule in conf_text) self.assertTrue(uncommented_rewrite_rule in conf_text) self.assertEqual(mock_notify.call_count, 1) self.assertIn("Some rewrite rules", mock_notify.call_args[0][0]) @mock.patch("certbot_apache._internal.configurator.display_util.notify") def test_make_vhost_ssl_with_existing_rewrite_conds(self, mock_notify): self.config.parser.modules["rewrite_module"] = None ssl_vhost = self.config.make_vhost_ssl(self.vh_truth[3]) with open(ssl_vhost.filep) as the_file: conf_lines = the_file.readlines() conf_line_set = [l.strip() for l in conf_lines] not_commented_cond1 = ("RewriteCond " "%{DOCUMENT_ROOT}/%{REQUEST_FILENAME} !-f") not_commented_rewrite_rule = ("RewriteRule " "^(.*)$ b://u%{REQUEST_URI} [P,NE,L]") commented_cond1 = "# RewriteCond %{HTTPS} !=on" commented_cond2 = "# RewriteCond %{HTTPS} !^$" commented_rewrite_rule = ("# RewriteRule ^ " "https://%{SERVER_NAME}%{REQUEST_URI} " "[L,NE,R=permanent]") self.assertTrue(not_commented_cond1 in conf_line_set) self.assertTrue(not_commented_rewrite_rule in conf_line_set) self.assertTrue(commented_cond1 in conf_line_set) self.assertTrue(commented_cond2 in conf_line_set) self.assertTrue(commented_rewrite_rule in conf_line_set) self.assertEqual(mock_notify.call_count, 1) self.assertIn("Some rewrite rules", mock_notify.call_args[0][0]) class InstallSslOptionsConfTest(util.ApacheTest): """Test that the options-ssl-nginx.conf file is installed and updated properly.""" def setUp(self): # pylint: disable=arguments-differ super().setUp() self.config = util.get_apache_configurator( self.config_path, self.vhost_path, self.config_dir, self.work_dir) def _call(self): self.config.install_ssl_options_conf(self.config.mod_ssl_conf, self.config.updated_mod_ssl_conf_digest) def _current_ssl_options_hash(self): return crypto_util.sha256sum(self.config.pick_apache_config()) def _assert_current_file(self): self.assertTrue(os.path.isfile(self.config.mod_ssl_conf)) self.assertEqual(crypto_util.sha256sum(self.config.mod_ssl_conf), self._current_ssl_options_hash()) def test_no_file(self): # prepare should have placed a file there self._assert_current_file() os.remove(self.config.mod_ssl_conf) self.assertFalse(os.path.isfile(self.config.mod_ssl_conf)) self._call() self._assert_current_file() def test_current_file(self): self._assert_current_file() self._call() self._assert_current_file() def test_prev_file_updates_to_current(self): from certbot_apache._internal.constants import ALL_SSL_OPTIONS_HASHES ALL_SSL_OPTIONS_HASHES.insert(0, "test_hash_does_not_match") with mock.patch('certbot.crypto_util.sha256sum') as mock_sha256: mock_sha256.return_value = ALL_SSL_OPTIONS_HASHES[0] self._call() self._assert_current_file() def test_manually_modified_current_file_does_not_update(self): with open(self.config.mod_ssl_conf, "a") as mod_ssl_conf: mod_ssl_conf.write("a new line for the wrong hash\n") with mock.patch("certbot.plugins.common.logger") as mock_logger: self._call() self.assertFalse(mock_logger.warning.called) self.assertTrue(os.path.isfile(self.config.mod_ssl_conf)) self.assertEqual(crypto_util.sha256sum( self.config.pick_apache_config()), self._current_ssl_options_hash()) self.assertNotEqual(crypto_util.sha256sum(self.config.mod_ssl_conf), self._current_ssl_options_hash()) def test_manually_modified_past_file_warns(self): with open(self.config.mod_ssl_conf, "a") as mod_ssl_conf: mod_ssl_conf.write("a new line for the wrong hash\n") with open(self.config.updated_mod_ssl_conf_digest, "w") as f: f.write("hashofanoldversion") with mock.patch("certbot.plugins.common.logger") as mock_logger: self._call() self.assertEqual(mock_logger.warning.call_args[0][0], "%s has been manually modified; updated file " "saved to %s. We recommend updating %s for security purposes.") self.assertEqual(crypto_util.sha256sum( self.config.pick_apache_config()), self._current_ssl_options_hash()) # only print warning once with mock.patch("certbot.plugins.common.logger") as mock_logger: self._call() self.assertFalse(mock_logger.warning.called) def test_ssl_config_files_hash_in_all_hashes(self): """ It is really critical that all TLS Apache config files have their SHA256 hash registered in constants.ALL_SSL_OPTIONS_HASHES. Otherwise Certbot will mistakenly assume that the config file has been manually edited by the user, and will refuse to update it. This test ensures that all necessary hashes are present. """ from certbot_apache._internal.constants import ALL_SSL_OPTIONS_HASHES import pkg_resources tls_configs_dir = pkg_resources.resource_filename( "certbot_apache", os.path.join("_internal", "tls_configs")) all_files = [os.path.join(tls_configs_dir, name) for name in os.listdir(tls_configs_dir) if name.endswith('options-ssl-apache.conf')] self.assertTrue(all_files) for one_file in all_files: file_hash = crypto_util.sha256sum(one_file) self.assertTrue(file_hash in ALL_SSL_OPTIONS_HASHES, "Constants.ALL_SSL_OPTIONS_HASHES must be appended with the sha256 " "hash of {0} when it is updated.".format(one_file)) def test_openssl_version(self): self.config._openssl_version = None some_string_contents = b""" SSLOpenSSLConfCmd OpenSSL configuration command SSLv3 not supported by this version of OpenSSL '%s': invalid OpenSSL configuration command OpenSSL 1.0.2g 1 Mar 2016 OpenSSL AH02407: "SSLOpenSSLConfCmd %s %s" failed for %s AH02556: "SSLOpenSSLConfCmd %s %s" applied to %s OpenSSL 1.0.2g 1 Mar 2016 """ # ssl_module as a DSO self.config.parser.modules['ssl_module'] = '/fake/path' with mock.patch("certbot_apache._internal.configurator." "ApacheConfigurator._open_module_file") as mock_omf: mock_omf.return_value = some_string_contents self.assertEqual(self.config.openssl_version(), "1.0.2g") # ssl_module statically linked self.config._openssl_version = None self.config.parser.modules['ssl_module'] = None self.config.options.bin = '/fake/path/to/httpd' with mock.patch("certbot_apache._internal.configurator." "ApacheConfigurator._open_module_file") as mock_omf: mock_omf.return_value = some_string_contents self.assertEqual(self.config.openssl_version(), "1.0.2g") def test_current_version(self): self.config.version = (2, 4, 10) self.config._openssl_version = '1.0.2m' self.assertTrue('old' in self.config.pick_apache_config()) self.config.version = (2, 4, 11) self.config._openssl_version = '1.0.2m' self.assertTrue('current' in self.config.pick_apache_config()) self.config._openssl_version = '1.0.2a' self.assertTrue('old' in self.config.pick_apache_config()) def test_openssl_version_warns(self): self.config._openssl_version = '1.0.2a' self.assertEqual(self.config.openssl_version(), '1.0.2a') self.config._openssl_version = None with mock.patch("certbot_apache._internal.configurator.logger.warning") as mock_log: self.assertEqual(self.config.openssl_version(), None) self.assertTrue("Could not find ssl_module" in mock_log.call_args[0][0]) # When no ssl_module is present at all self.config._openssl_version = None self.assertTrue("ssl_module" not in self.config.parser.modules) with mock.patch("certbot_apache._internal.configurator.logger.warning") as mock_log: self.assertEqual(self.config.openssl_version(), None) self.assertTrue("Could not find ssl_module" in mock_log.call_args[0][0]) # When ssl_module is statically linked but --apache-bin not provided self.config._openssl_version = None self.config.options.bin = None self.config.parser.modules['ssl_module'] = None with mock.patch("certbot_apache._internal.configurator.logger.warning") as mock_log: self.assertEqual(self.config.openssl_version(), None) self.assertTrue("ssl_module is statically linked but" in mock_log.call_args[0][0]) self.config.parser.modules['ssl_module'] = "/fake/path" with mock.patch("certbot_apache._internal.configurator.logger.warning") as mock_log: # Check that correct logger.warning was printed self.assertEqual(self.config.openssl_version(), None) self.assertTrue("Unable to read" in mock_log.call_args[0][0]) contents_missing_openssl = b"these contents won't match the regex" with mock.patch("certbot_apache._internal.configurator." "ApacheConfigurator._open_module_file") as mock_omf: mock_omf.return_value = contents_missing_openssl with mock.patch("certbot_apache._internal.configurator.logger.warning") as mock_log: # Check that correct logger.warning was printed self.assertEqual(self.config.openssl_version(), None) self.assertTrue("Could not find OpenSSL" in mock_log.call_args[0][0]) def test_open_module_file(self): mock_open = mock.mock_open(read_data="testing 12 3") with mock.patch("builtins.open", mock_open): self.assertEqual(self.config._open_module_file("/nonsense/"), "testing 12 3") if __name__ == "__main__": unittest.main() # pragma: no cover ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/debian_test.py0000644000076500000240000002246100000000000017127 0ustar00bmwstaff"""Test for certbot_apache._internal.configurator for Debian overrides""" import shutil import unittest try: import mock except ImportError: # pragma: no cover from unittest import mock # type: ignore from certbot import errors from certbot.compat import os from certbot.tests import util as certbot_util from certbot_apache._internal import apache_util from certbot_apache._internal import obj import util class MultipleVhostsTestDebian(util.ApacheTest): """Multiple vhost tests for Debian family of distros""" _multiprocess_can_split_ = True def setUp(self): # pylint: disable=arguments-differ super().setUp() self.config = util.get_apache_configurator( self.config_path, self.vhost_path, self.config_dir, self.work_dir, os_info="debian") self.config = self.mock_deploy_cert(self.config) self.vh_truth = util.get_vh_truth(self.temp_dir, "debian_apache_2_4/multiple_vhosts") def mock_deploy_cert(self, config): """A test for a mock deploy cert""" config.real_deploy_cert = self.config.deploy_cert def mocked_deploy_cert(*args, **kwargs): """a helper to mock a deployed cert""" g_mod = "certbot_apache._internal.configurator.ApacheConfigurator.enable_mod" d_mod = "certbot_apache._internal.override_debian.DebianConfigurator.enable_mod" with mock.patch(g_mod): with mock.patch(d_mod): config.real_deploy_cert(*args, **kwargs) self.config.deploy_cert = mocked_deploy_cert return self.config def test_enable_mod_unsupported_dirs(self): shutil.rmtree(os.path.join(self.config.parser.root, "mods-enabled")) self.assertRaises( errors.NotSupportedError, self.config.enable_mod, "ssl") @mock.patch("certbot.util.run_script") @mock.patch("certbot.util.exe_exists") @mock.patch("certbot_apache._internal.apache_util.subprocess.run") def test_enable_mod(self, mock_run, mock_exe_exists, mock_run_script): mock_run.return_value.stdout = "Define: DUMP_RUN_CFG" mock_run.return_value.stderr = "" mock_run.return_value.returncode = 0 mock_exe_exists.return_value = True self.config.enable_mod("ssl") self.assertTrue("ssl_module" in self.config.parser.modules) self.assertTrue("mod_ssl.c" in self.config.parser.modules) self.assertTrue(mock_run_script.called) def test_deploy_cert_enable_new_vhost(self): # Create ssl_vhost = self.config.make_vhost_ssl(self.vh_truth[0]) self.config.parser.modules["ssl_module"] = None self.config.parser.modules["mod_ssl.c"] = None self.assertFalse(ssl_vhost.enabled) with certbot_util.patch_display_util(): self.config.deploy_cert( "encryption-example.demo", "example/cert.pem", "example/key.pem", "example/cert_chain.pem", "example/fullchain.pem") self.assertTrue(ssl_vhost.enabled) # Make sure that we don't error out if symlink already exists ssl_vhost.enabled = False self.assertFalse(ssl_vhost.enabled) self.config.deploy_cert( "encryption-example.demo", "example/cert.pem", "example/key.pem", "example/cert_chain.pem", "example/fullchain.pem") self.assertTrue(ssl_vhost.enabled) def test_enable_site_failure(self): self.config.parser.root = "/tmp/nonexistent" with mock.patch("certbot.compat.os.path.isdir") as mock_dir: mock_dir.return_value = True with mock.patch("certbot.compat.os.path.islink") as mock_link: mock_link.return_value = False self.assertRaises( errors.NotSupportedError, self.config.enable_site, obj.VirtualHost("asdf", "afsaf", set(), False, False)) def test_deploy_cert_newssl(self): self.config = util.get_apache_configurator( self.config_path, self.vhost_path, self.config_dir, self.work_dir, version=(2, 4, 16)) self.config = self.mock_deploy_cert(self.config) self.config.parser.modules["ssl_module"] = None self.config.parser.modules["mod_ssl.c"] = None # Get the default 443 vhost self.config.assoc["random.demo"] = self.vh_truth[1] with certbot_util.patch_display_util(): self.config.deploy_cert( "random.demo", "example/cert.pem", "example/key.pem", "example/cert_chain.pem", "example/fullchain.pem") self.config.save() # Verify ssl_module was enabled. self.assertTrue(self.vh_truth[1].enabled) self.assertTrue("ssl_module" in self.config.parser.modules) loc_cert = self.config.parser.find_dir( "sslcertificatefile", "example/fullchain.pem", self.vh_truth[1].path) loc_key = self.config.parser.find_dir( "sslcertificateKeyfile", "example/key.pem", self.vh_truth[1].path) # Verify one directive was found in the correct file self.assertEqual(len(loc_cert), 1) self.assertEqual( apache_util.get_file_path(loc_cert[0]), self.vh_truth[1].filep) self.assertEqual(len(loc_key), 1) self.assertEqual( apache_util.get_file_path(loc_key[0]), self.vh_truth[1].filep) def test_deploy_cert_newssl_no_fullchain(self): self.config = util.get_apache_configurator( self.config_path, self.vhost_path, self.config_dir, self.work_dir, version=(2, 4, 16)) self.config = self.mock_deploy_cert(self.config) self.config.parser.modules["ssl_module"] = None self.config.parser.modules["mod_ssl.c"] = None # Get the default 443 vhost self.config.assoc["random.demo"] = self.vh_truth[1] self.assertRaises(errors.PluginError, lambda: self.config.deploy_cert( "random.demo", "example/cert.pem", "example/key.pem")) def test_deploy_cert_old_apache_no_chain(self): self.config = util.get_apache_configurator( self.config_path, self.vhost_path, self.config_dir, self.work_dir, version=(2, 4, 7)) self.config = self.mock_deploy_cert(self.config) self.config.parser.modules["ssl_module"] = None self.config.parser.modules["mod_ssl.c"] = None # Get the default 443 vhost self.config.assoc["random.demo"] = self.vh_truth[1] self.assertRaises(errors.PluginError, lambda: self.config.deploy_cert( "random.demo", "example/cert.pem", "example/key.pem")) @mock.patch("certbot.util.run_script") @mock.patch("certbot.util.exe_exists") def test_ocsp_stapling_enable_mod(self, mock_exe, _): self.config.parser.update_runtime_variables = mock.Mock() self.config.parser.modules["mod_ssl.c"] = None self.config.get_version = mock.Mock(return_value=(2, 4, 7)) mock_exe.return_value = True # This will create an ssl vhost for certbot.demo self.config.choose_vhost("certbot.demo") self.config.enhance("certbot.demo", "staple-ocsp") self.assertTrue("socache_shmcb_module" in self.config.parser.modules) @mock.patch("certbot.util.run_script") @mock.patch("certbot.util.exe_exists") def test_ensure_http_header_enable_mod(self, mock_exe, _): self.config.parser.update_runtime_variables = mock.Mock() self.config.parser.modules["mod_ssl.c"] = None mock_exe.return_value = True # This will create an ssl vhost for certbot.demo self.config.choose_vhost("certbot.demo") self.config.enhance("certbot.demo", "ensure-http-header", "Strict-Transport-Security") self.assertTrue("headers_module" in self.config.parser.modules) @mock.patch("certbot.util.run_script") @mock.patch("certbot.util.exe_exists") def test_redirect_enable_mod(self, mock_exe, _): self.config.parser.update_runtime_variables = mock.Mock() mock_exe.return_value = True self.config.get_version = mock.Mock(return_value=(2, 2)) # This will create an ssl vhost for certbot.demo self.config.choose_vhost("certbot.demo") self.config.enhance("certbot.demo", "redirect") self.assertTrue("rewrite_module" in self.config.parser.modules) def test_enable_site_already_enabled(self): self.assertTrue(self.vh_truth[1].enabled) self.config.enable_site(self.vh_truth[1]) def test_enable_site_call_parent(self): with mock.patch( "certbot_apache._internal.configurator.ApacheConfigurator.enable_site") as e_s: self.config.parser.root = "/tmp/nonexistent" vh = self.vh_truth[0] vh.enabled = False self.config.enable_site(vh) self.assertTrue(e_s.called) @mock.patch("certbot.util.exe_exists") def test_enable_mod_no_disable(self, mock_exe_exists): mock_exe_exists.return_value = False self.assertRaises( errors.MisconfigurationError, self.config.enable_mod, "ssl") if __name__ == "__main__": unittest.main() # pragma: no cover ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/display_ops_test.py0000644000076500000240000000735700000000000020242 0ustar00bmwstaff"""Test certbot_apache._internal.display_ops.""" import unittest try: import mock except ImportError: # pragma: no cover from unittest import mock # type: ignore from certbot import errors from certbot.display import util as display_util from certbot.tests import util as certbot_util from certbot_apache._internal import obj from certbot_apache._internal.display_ops import select_vhost_multiple import util class SelectVhostMultiTest(unittest.TestCase): """Tests for certbot_apache._internal.display_ops.select_vhost_multiple.""" def setUp(self): self.base_dir = "/example_path" self.vhosts = util.get_vh_truth( self.base_dir, "debian_apache_2_4/multiple_vhosts") def test_select_no_input(self): self.assertFalse(select_vhost_multiple([])) @certbot_util.patch_display_util() def test_select_correct(self, mock_util): mock_util().checklist.return_value = ( display_util.OK, [self.vhosts[3].display_repr(), self.vhosts[2].display_repr()]) vhs = select_vhost_multiple([self.vhosts[3], self.vhosts[2], self.vhosts[1]]) self.assertTrue(self.vhosts[2] in vhs) self.assertTrue(self.vhosts[3] in vhs) self.assertFalse(self.vhosts[1] in vhs) @certbot_util.patch_display_util() def test_select_cancel(self, mock_util): mock_util().checklist.return_value = (display_util.CANCEL, "whatever") vhs = select_vhost_multiple([self.vhosts[2], self.vhosts[3]]) self.assertFalse(vhs) class SelectVhostTest(unittest.TestCase): """Tests for certbot_apache._internal.display_ops.select_vhost.""" def setUp(self): self.base_dir = "/example_path" self.vhosts = util.get_vh_truth( self.base_dir, "debian_apache_2_4/multiple_vhosts") @classmethod def _call(cls, vhosts): from certbot_apache._internal.display_ops import select_vhost return select_vhost("example.com", vhosts) @certbot_util.patch_display_util() def test_successful_choice(self, mock_util): mock_util().menu.return_value = (display_util.OK, 3) self.assertEqual(self.vhosts[3], self._call(self.vhosts)) @certbot_util.patch_display_util() def test_noninteractive(self, mock_util): mock_util().menu.side_effect = errors.MissingCommandlineFlag("no vhost default") try: self._call(self.vhosts) except errors.MissingCommandlineFlag as e: self.assertTrue("vhost ambiguity" in str(e)) @certbot_util.patch_display_util() def test_more_info_cancel(self, mock_util): mock_util().menu.side_effect = [ (display_util.CANCEL, -1), ] self.assertEqual(None, self._call(self.vhosts)) def test_no_vhosts(self): self.assertEqual(self._call([]), None) @mock.patch("certbot_apache._internal.display_ops.display_util") @mock.patch("certbot_apache._internal.display_ops.logger") def test_small_display(self, mock_logger, mock_display_util): mock_display_util.WIDTH = 20 mock_display_util.menu.return_value = (display_util.OK, 0) self._call(self.vhosts) self.assertEqual(mock_logger.debug.call_count, 1) @certbot_util.patch_display_util() def test_multiple_names(self, mock_util): mock_util().menu.return_value = (display_util.OK, 5) self.vhosts.append( obj.VirtualHost( "path", "aug_path", {obj.Addr.fromstring("*:80")}, False, False, "wildcard.com", {"*.wildcard.com"})) self.assertEqual(self.vhosts[5], self._call(self.vhosts)) if __name__ == "__main__": unittest.main() # pragma: no cover ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/dualnode_test.py0000644000076500000240000005726000000000000017505 0ustar00bmwstaff"""Tests for DualParserNode implementation""" import unittest try: import mock except ImportError: # pragma: no cover from unittest import mock # type: ignore from certbot_apache._internal import assertions from certbot_apache._internal import augeasparser from certbot_apache._internal import dualparser class DualParserNodeTest(unittest.TestCase): # pylint: disable=too-many-public-methods """DualParserNode tests""" def setUp(self): # pylint: disable=arguments-differ parser_mock = mock.MagicMock() parser_mock.aug.match.return_value = [] parser_mock.get_arg.return_value = [] self.metadata = {"augeasparser": parser_mock, "augeaspath": "/invalid", "ac_ast": None} self.block = dualparser.DualBlockNode(name="block", ancestor=None, filepath="/tmp/something", metadata=self.metadata) self.block_two = dualparser.DualBlockNode(name="block", ancestor=self.block, filepath="/tmp/something", metadata=self.metadata) self.directive = dualparser.DualDirectiveNode(name="directive", ancestor=self.block, filepath="/tmp/something", metadata=self.metadata) self.comment = dualparser.DualCommentNode(comment="comment", ancestor=self.block, filepath="/tmp/something", metadata=self.metadata) def test_create_with_precreated(self): cnode = dualparser.DualCommentNode(comment="comment", ancestor=self.block, filepath="/tmp/something", primary=self.comment.secondary, secondary=self.comment.primary) dnode = dualparser.DualDirectiveNode(name="directive", ancestor=self.block, filepath="/tmp/something", primary=self.directive.secondary, secondary=self.directive.primary) bnode = dualparser.DualBlockNode(name="block", ancestor=self.block, filepath="/tmp/something", primary=self.block.secondary, secondary=self.block.primary) # Switched around self.assertTrue(cnode.primary is self.comment.secondary) self.assertTrue(cnode.secondary is self.comment.primary) self.assertTrue(dnode.primary is self.directive.secondary) self.assertTrue(dnode.secondary is self.directive.primary) self.assertTrue(bnode.primary is self.block.secondary) self.assertTrue(bnode.secondary is self.block.primary) def test_set_params(self): params = ("first", "second") self.directive.primary.set_parameters = mock.Mock() self.directive.secondary.set_parameters = mock.Mock() self.directive.set_parameters(params) self.assertTrue(self.directive.primary.set_parameters.called) self.assertTrue(self.directive.secondary.set_parameters.called) def test_set_parameters(self): pparams = mock.MagicMock() sparams = mock.MagicMock() pparams.parameters = ("a", "b") sparams.parameters = ("a", "b") self.directive.primary.set_parameters = pparams self.directive.secondary.set_parameters = sparams self.directive.set_parameters(("param", "seq")) self.assertTrue(pparams.called) self.assertTrue(sparams.called) def test_delete_child(self): pdel = mock.MagicMock() sdel = mock.MagicMock() self.block.primary.delete_child = pdel self.block.secondary.delete_child = sdel self.block.delete_child(self.comment) self.assertTrue(pdel.called) self.assertTrue(sdel.called) def test_unsaved_files(self): puns = mock.MagicMock() suns = mock.MagicMock() puns.return_value = assertions.PASS suns.return_value = assertions.PASS self.block.primary.unsaved_files = puns self.block.secondary.unsaved_files = suns self.block.unsaved_files() self.assertTrue(puns.called) self.assertTrue(suns.called) def test_getattr_equality(self): self.directive.primary.variableexception = "value" self.directive.secondary.variableexception = "not_value" with self.assertRaises(AssertionError): _ = self.directive.variableexception self.directive.primary.variable = "value" self.directive.secondary.variable = "value" try: self.directive.variable except AssertionError: # pragma: no cover self.fail("getattr check raised an AssertionError where it shouldn't have") def test_parsernode_dirty_assert(self): # disable assertion pass self.comment.primary.comment = "value" self.comment.secondary.comment = "value" self.comment.primary.filepath = "x" self.comment.secondary.filepath = "x" self.comment.primary.dirty = False self.comment.secondary.dirty = True with self.assertRaises(AssertionError): assertions.assertEqual(self.comment.primary, self.comment.secondary) def test_parsernode_filepath_assert(self): # disable assertion pass self.comment.primary.comment = "value" self.comment.secondary.comment = "value" self.comment.primary.filepath = "first" self.comment.secondary.filepath = "second" with self.assertRaises(AssertionError): assertions.assertEqual(self.comment.primary, self.comment.secondary) def test_add_child_block(self): mock_first = mock.MagicMock(return_value=self.block.primary) mock_second = mock.MagicMock(return_value=self.block.secondary) self.block.primary.add_child_block = mock_first self.block.secondary.add_child_block = mock_second self.block.add_child_block("Block") self.assertTrue(mock_first.called) self.assertTrue(mock_second.called) def test_add_child_directive(self): mock_first = mock.MagicMock(return_value=self.directive.primary) mock_second = mock.MagicMock(return_value=self.directive.secondary) self.block.primary.add_child_directive = mock_first self.block.secondary.add_child_directive = mock_second self.block.add_child_directive("Directive") self.assertTrue(mock_first.called) self.assertTrue(mock_second.called) def test_add_child_comment(self): mock_first = mock.MagicMock(return_value=self.comment.primary) mock_second = mock.MagicMock(return_value=self.comment.secondary) self.block.primary.add_child_comment = mock_first self.block.secondary.add_child_comment = mock_second self.block.add_child_comment("Comment") self.assertTrue(mock_first.called) self.assertTrue(mock_second.called) def test_find_comments(self): pri_comments = [augeasparser.AugeasCommentNode(comment="some comment", ancestor=self.block, filepath="/path/to/whatever", metadata=self.metadata)] sec_comments = [augeasparser.AugeasCommentNode(comment=assertions.PASS, ancestor=self.block, filepath=assertions.PASS, metadata=self.metadata)] find_coms_primary = mock.MagicMock(return_value=pri_comments) find_coms_secondary = mock.MagicMock(return_value=sec_comments) self.block.primary.find_comments = find_coms_primary self.block.secondary.find_comments = find_coms_secondary dcoms = self.block.find_comments("comment") p_dcoms = [d.primary for d in dcoms] s_dcoms = [d.secondary for d in dcoms] p_coms = self.block.primary.find_comments("comment") s_coms = self.block.secondary.find_comments("comment") # Check that every comment response is represented in the list of # DualParserNode instances. for p in p_dcoms: self.assertTrue(p in p_coms) for s in s_dcoms: self.assertTrue(s in s_coms) def test_find_blocks_first_passing(self): youshallnotpass = [augeasparser.AugeasBlockNode(name="notpassing", ancestor=self.block, filepath="/path/to/whatever", metadata=self.metadata)] youshallpass = [augeasparser.AugeasBlockNode(name=assertions.PASS, ancestor=self.block, filepath=assertions.PASS, metadata=self.metadata)] find_blocks_primary = mock.MagicMock(return_value=youshallpass) find_blocks_secondary = mock.MagicMock(return_value=youshallnotpass) self.block.primary.find_blocks = find_blocks_primary self.block.secondary.find_blocks = find_blocks_secondary blocks = self.block.find_blocks("something") for block in blocks: try: assertions.assertEqual(block.primary, block.secondary) except AssertionError: # pragma: no cover self.fail("Assertion should have passed") self.assertTrue(assertions.isPassDirective(block.primary)) self.assertFalse(assertions.isPassDirective(block.secondary)) def test_find_blocks_second_passing(self): youshallnotpass = [augeasparser.AugeasBlockNode(name="notpassing", ancestor=self.block, filepath="/path/to/whatever", metadata=self.metadata)] youshallpass = [augeasparser.AugeasBlockNode(name=assertions.PASS, ancestor=self.block, filepath=assertions.PASS, metadata=self.metadata)] find_blocks_primary = mock.MagicMock(return_value=youshallnotpass) find_blocks_secondary = mock.MagicMock(return_value=youshallpass) self.block.primary.find_blocks = find_blocks_primary self.block.secondary.find_blocks = find_blocks_secondary blocks = self.block.find_blocks("something") for block in blocks: try: assertions.assertEqual(block.primary, block.secondary) except AssertionError: # pragma: no cover self.fail("Assertion should have passed") self.assertFalse(assertions.isPassDirective(block.primary)) self.assertTrue(assertions.isPassDirective(block.secondary)) def test_find_dirs_first_passing(self): notpassing = [augeasparser.AugeasDirectiveNode(name="notpassing", ancestor=self.block, filepath="/path/to/whatever", metadata=self.metadata)] passing = [augeasparser.AugeasDirectiveNode(name=assertions.PASS, ancestor=self.block, filepath=assertions.PASS, metadata=self.metadata)] find_dirs_primary = mock.MagicMock(return_value=passing) find_dirs_secondary = mock.MagicMock(return_value=notpassing) self.block.primary.find_directives = find_dirs_primary self.block.secondary.find_directives = find_dirs_secondary directives = self.block.find_directives("something") for directive in directives: try: assertions.assertEqual(directive.primary, directive.secondary) except AssertionError: # pragma: no cover self.fail("Assertion should have passed") self.assertTrue(assertions.isPassDirective(directive.primary)) self.assertFalse(assertions.isPassDirective(directive.secondary)) def test_find_dirs_second_passing(self): notpassing = [augeasparser.AugeasDirectiveNode(name="notpassing", ancestor=self.block, filepath="/path/to/whatever", metadata=self.metadata)] passing = [augeasparser.AugeasDirectiveNode(name=assertions.PASS, ancestor=self.block, filepath=assertions.PASS, metadata=self.metadata)] find_dirs_primary = mock.MagicMock(return_value=notpassing) find_dirs_secondary = mock.MagicMock(return_value=passing) self.block.primary.find_directives = find_dirs_primary self.block.secondary.find_directives = find_dirs_secondary directives = self.block.find_directives("something") for directive in directives: try: assertions.assertEqual(directive.primary, directive.secondary) except AssertionError: # pragma: no cover self.fail("Assertion should have passed") self.assertFalse(assertions.isPassDirective(directive.primary)) self.assertTrue(assertions.isPassDirective(directive.secondary)) def test_find_coms_first_passing(self): notpassing = [augeasparser.AugeasCommentNode(comment="notpassing", ancestor=self.block, filepath="/path/to/whatever", metadata=self.metadata)] passing = [augeasparser.AugeasCommentNode(comment=assertions.PASS, ancestor=self.block, filepath=assertions.PASS, metadata=self.metadata)] find_coms_primary = mock.MagicMock(return_value=passing) find_coms_secondary = mock.MagicMock(return_value=notpassing) self.block.primary.find_comments = find_coms_primary self.block.secondary.find_comments = find_coms_secondary comments = self.block.find_comments("something") for comment in comments: try: assertions.assertEqual(comment.primary, comment.secondary) except AssertionError: # pragma: no cover self.fail("Assertion should have passed") self.assertTrue(assertions.isPassComment(comment.primary)) self.assertFalse(assertions.isPassComment(comment.secondary)) def test_find_coms_second_passing(self): notpassing = [augeasparser.AugeasCommentNode(comment="notpassing", ancestor=self.block, filepath="/path/to/whatever", metadata=self.metadata)] passing = [augeasparser.AugeasCommentNode(comment=assertions.PASS, ancestor=self.block, filepath=assertions.PASS, metadata=self.metadata)] find_coms_primary = mock.MagicMock(return_value=notpassing) find_coms_secondary = mock.MagicMock(return_value=passing) self.block.primary.find_comments = find_coms_primary self.block.secondary.find_comments = find_coms_secondary comments = self.block.find_comments("something") for comment in comments: try: assertions.assertEqual(comment.primary, comment.secondary) except AssertionError: # pragma: no cover self.fail("Assertion should have passed") self.assertFalse(assertions.isPassComment(comment.primary)) self.assertTrue(assertions.isPassComment(comment.secondary)) def test_find_blocks_no_pass_equal(self): notpassing1 = [augeasparser.AugeasBlockNode(name="notpassing", ancestor=self.block, filepath="/path/to/whatever", metadata=self.metadata)] notpassing2 = [augeasparser.AugeasBlockNode(name="notpassing", ancestor=self.block, filepath="/path/to/whatever", metadata=self.metadata)] find_blocks_primary = mock.MagicMock(return_value=notpassing1) find_blocks_secondary = mock.MagicMock(return_value=notpassing2) self.block.primary.find_blocks = find_blocks_primary self.block.secondary.find_blocks = find_blocks_secondary blocks = self.block.find_blocks("anything") for block in blocks: self.assertEqual(block.primary, block.secondary) self.assertTrue(block.primary is not block.secondary) def test_find_dirs_no_pass_equal(self): notpassing1 = [augeasparser.AugeasDirectiveNode(name="notpassing", ancestor=self.block, filepath="/path/to/whatever", metadata=self.metadata)] notpassing2 = [augeasparser.AugeasDirectiveNode(name="notpassing", ancestor=self.block, filepath="/path/to/whatever", metadata=self.metadata)] find_dirs_primary = mock.MagicMock(return_value=notpassing1) find_dirs_secondary = mock.MagicMock(return_value=notpassing2) self.block.primary.find_directives = find_dirs_primary self.block.secondary.find_directives = find_dirs_secondary directives = self.block.find_directives("anything") for directive in directives: self.assertEqual(directive.primary, directive.secondary) self.assertTrue(directive.primary is not directive.secondary) def test_find_comments_no_pass_equal(self): notpassing1 = [augeasparser.AugeasCommentNode(comment="notpassing", ancestor=self.block, filepath="/path/to/whatever", metadata=self.metadata)] notpassing2 = [augeasparser.AugeasCommentNode(comment="notpassing", ancestor=self.block, filepath="/path/to/whatever", metadata=self.metadata)] find_coms_primary = mock.MagicMock(return_value=notpassing1) find_coms_secondary = mock.MagicMock(return_value=notpassing2) self.block.primary.find_comments = find_coms_primary self.block.secondary.find_comments = find_coms_secondary comments = self.block.find_comments("anything") for comment in comments: self.assertEqual(comment.primary, comment.secondary) self.assertTrue(comment.primary is not comment.secondary) def test_find_blocks_no_pass_notequal(self): notpassing1 = [augeasparser.AugeasBlockNode(name="notpassing", ancestor=self.block, filepath="/path/to/whatever", metadata=self.metadata)] notpassing2 = [augeasparser.AugeasBlockNode(name="different", ancestor=self.block, filepath="/path/to/whatever", metadata=self.metadata)] find_blocks_primary = mock.MagicMock(return_value=notpassing1) find_blocks_secondary = mock.MagicMock(return_value=notpassing2) self.block.primary.find_blocks = find_blocks_primary self.block.secondary.find_blocks = find_blocks_secondary with self.assertRaises(AssertionError): _ = self.block.find_blocks("anything") def test_parsernode_notequal(self): ne_block = augeasparser.AugeasBlockNode(name="different", ancestor=self.block, filepath="/path/to/whatever", metadata=self.metadata) ne_directive = augeasparser.AugeasDirectiveNode(name="different", ancestor=self.block, filepath="/path/to/whatever", metadata=self.metadata) ne_comment = augeasparser.AugeasCommentNode(comment="different", ancestor=self.block, filepath="/path/to/whatever", metadata=self.metadata) self.assertNotEqual(self.block, ne_block) self.assertNotEqual(self.directive, ne_directive) self.assertNotEqual(self.comment, ne_comment) def test_parsed_paths(self): mock_p = mock.MagicMock(return_value=['/path/file.conf', '/another/path', '/path/other.conf']) mock_s = mock.MagicMock(return_value=['/path/*.conf', '/another/path']) self.block.primary.parsed_paths = mock_p self.block.secondary.parsed_paths = mock_s self.block.parsed_paths() self.assertTrue(mock_p.called) self.assertTrue(mock_s.called) def test_parsed_paths_error(self): mock_p = mock.MagicMock(return_value=['/path/file.conf']) mock_s = mock.MagicMock(return_value=['/path/*.conf', '/another/path']) self.block.primary.parsed_paths = mock_p self.block.secondary.parsed_paths = mock_s with self.assertRaises(AssertionError): self.block.parsed_paths() def test_find_ancestors(self): primarymock = mock.MagicMock(return_value=[]) secondarymock = mock.MagicMock(return_value=[]) self.block.primary.find_ancestors = primarymock self.block.secondary.find_ancestors = secondarymock self.block.find_ancestors("anything") self.assertTrue(primarymock.called) self.assertTrue(secondarymock.called) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/entrypoint_test.py0000644000076500000240000000371700000000000020123 0ustar00bmwstaff"""Test for certbot_apache._internal.entrypoint for override class resolution""" import unittest try: import mock except ImportError: # pragma: no cover from unittest import mock # type: ignore from certbot_apache._internal import configurator from certbot_apache._internal import entrypoint class EntryPointTest(unittest.TestCase): """Entrypoint tests""" _multiprocess_can_split_ = True def test_get_configurator(self): with mock.patch("certbot.util.get_os_info") as mock_info: for distro in entrypoint.OVERRIDE_CLASSES: return_value = (distro, "whatever") if distro == 'fedora_old': return_value = ('fedora', '28') elif distro == 'fedora': return_value = ('fedora', '29') mock_info.return_value = return_value self.assertEqual(entrypoint.get_configurator(), entrypoint.OVERRIDE_CLASSES[distro]) def test_nonexistent_like(self): with mock.patch("certbot.util.get_os_info") as mock_info: mock_info.return_value = ("nonexistent", "irrelevant") with mock.patch("certbot.util.get_systemd_os_like") as mock_like: for like in entrypoint.OVERRIDE_CLASSES: mock_like.return_value = [like] self.assertEqual(entrypoint.get_configurator(), entrypoint.OVERRIDE_CLASSES[like]) def test_nonexistent_generic(self): with mock.patch("certbot.util.get_os_info") as mock_info: mock_info.return_value = ("nonexistent", "irrelevant") with mock.patch("certbot.util.get_systemd_os_like") as mock_like: mock_like.return_value = ["unknown"] self.assertEqual(entrypoint.get_configurator(), configurator.ApacheConfigurator) if __name__ == "__main__": unittest.main() # pragma: no cover ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/fedora_test.py0000644000076500000240000002021100000000000017134 0ustar00bmwstaff"""Test for certbot_apache._internal.configurator for Fedora 29+ overrides""" import unittest try: import mock except ImportError: # pragma: no cover from unittest import mock # type: ignore from certbot import errors from certbot.compat import filesystem from certbot.compat import os from certbot_apache._internal import obj from certbot_apache._internal import override_fedora import util def get_vh_truth(temp_dir, config_name): """Return the ground truth for the specified directory.""" prefix = os.path.join( temp_dir, config_name, "httpd/conf.d") aug_pre = "/files" + prefix # TODO: eventually, these tests should have a dedicated configuration instead # of reusing the ones from centos_test vh_truth = [ obj.VirtualHost( os.path.join(prefix, "centos.example.com.conf"), os.path.join(aug_pre, "centos.example.com.conf/VirtualHost"), {obj.Addr.fromstring("*:80")}, False, True, "centos.example.com"), obj.VirtualHost( os.path.join(prefix, "ssl.conf"), os.path.join(aug_pre, "ssl.conf/VirtualHost"), {obj.Addr.fromstring("_default_:443")}, True, True, None) ] return vh_truth class FedoraRestartTest(util.ApacheTest): """Tests for Fedora specific self-signed certificate override""" # TODO: eventually, these tests should have a dedicated configuration instead # of reusing the ones from centos_test def setUp(self): # pylint: disable=arguments-differ test_dir = "centos7_apache/apache" config_root = "centos7_apache/apache/httpd" vhost_root = "centos7_apache/apache/httpd/conf.d" super().setUp(test_dir=test_dir, config_root=config_root, vhost_root=vhost_root) self.config = util.get_apache_configurator( self.config_path, self.vhost_path, self.config_dir, self.work_dir, os_info="fedora") self.vh_truth = get_vh_truth( self.temp_dir, "centos7_apache/apache") def _run_fedora_test(self): self.assertIsInstance(self.config, override_fedora.FedoraConfigurator) self.config.config_test() def test_fedora_restart_error(self): c_test = "certbot_apache._internal.configurator.ApacheConfigurator.config_test" with mock.patch(c_test) as mock_test: # First call raises error, second doesn't mock_test.side_effect = [errors.MisconfigurationError, ''] with mock.patch("certbot.util.run_script") as mock_run: mock_run.side_effect = errors.SubprocessError self.assertRaises(errors.MisconfigurationError, self._run_fedora_test) def test_fedora_restart(self): c_test = "certbot_apache._internal.configurator.ApacheConfigurator.config_test" with mock.patch(c_test) as mock_test: with mock.patch("certbot.util.run_script") as mock_run: # First call raises error, second doesn't mock_test.side_effect = [errors.MisconfigurationError, ''] self._run_fedora_test() self.assertEqual(mock_test.call_count, 2) self.assertEqual(mock_run.call_args[0][0], ['systemctl', 'restart', 'httpd']) class MultipleVhostsTestFedora(util.ApacheTest): """Multiple vhost tests for CentOS / RHEL family of distros""" _multiprocess_can_split_ = True def setUp(self): # pylint: disable=arguments-differ test_dir = "centos7_apache/apache" config_root = "centos7_apache/apache/httpd" vhost_root = "centos7_apache/apache/httpd/conf.d" super().setUp(test_dir=test_dir, config_root=config_root, vhost_root=vhost_root) self.config = util.get_apache_configurator( self.config_path, self.vhost_path, self.config_dir, self.work_dir, os_info="fedora") self.vh_truth = get_vh_truth( self.temp_dir, "centos7_apache/apache") def test_get_parser(self): self.assertIsInstance(self.config.parser, override_fedora.FedoraParser) @mock.patch("certbot_apache._internal.apache_util._get_runtime_cfg") def test_opportunistic_httpd_runtime_parsing(self, mock_get): define_val = ( 'Define: TEST1\n' 'Define: TEST2\n' 'Define: DUMP_RUN_CFG\n' ) mod_val = ( 'Loaded Modules:\n' ' mock_module (static)\n' ' another_module (static)\n' ) def mock_get_cfg(command): """Mock httpd process stdout""" if command == ['httpd', '-t', '-D', 'DUMP_RUN_CFG']: return define_val elif command == ['httpd', '-t', '-D', 'DUMP_MODULES']: return mod_val return "" mock_get.side_effect = mock_get_cfg self.config.parser.modules = {} self.config.parser.variables = {} with mock.patch("certbot.util.get_os_info") as mock_osi: # Make sure we have the have the CentOS httpd constants mock_osi.return_value = ("fedora", "29") self.config.parser.update_runtime_variables() self.assertEqual(mock_get.call_count, 3) self.assertEqual(len(self.config.parser.modules), 4) self.assertEqual(len(self.config.parser.variables), 2) self.assertTrue("TEST2" in self.config.parser.variables) self.assertTrue("mod_another.c" in self.config.parser.modules) @mock.patch("certbot_apache._internal.configurator.util.run_script") def test_get_version(self, mock_run_script): mock_run_script.return_value = ('', None) self.assertRaises(errors.PluginError, self.config.get_version) self.assertEqual(mock_run_script.call_args[0][0][0], 'httpd') def test_get_virtual_hosts(self): """Make sure all vhosts are being properly found.""" vhs = self.config.get_virtual_hosts() self.assertEqual(len(vhs), 2) found = 0 for vhost in vhs: for centos_truth in self.vh_truth: if vhost == centos_truth: found += 1 break else: raise Exception("Missed: %s" % vhost) # pragma: no cover self.assertEqual(found, 2) @mock.patch("certbot_apache._internal.apache_util._get_runtime_cfg") def test_get_sysconfig_vars(self, mock_cfg): """Make sure we read the sysconfig OPTIONS variable correctly""" # Return nothing for the process calls mock_cfg.return_value = "" self.config.parser.sysconfig_filep = filesystem.realpath( os.path.join(self.config.parser.root, "../sysconfig/httpd")) self.config.parser.variables = {} with mock.patch("certbot.util.get_os_info") as mock_osi: # Make sure we have the have the CentOS httpd constants mock_osi.return_value = ("fedora", "29") self.config.parser.update_runtime_variables() self.assertTrue("mock_define" in self.config.parser.variables) self.assertTrue("mock_define_too" in self.config.parser.variables) self.assertTrue("mock_value" in self.config.parser.variables) self.assertEqual("TRUE", self.config.parser.variables["mock_value"]) self.assertTrue("MOCK_NOSEP" in self.config.parser.variables) self.assertEqual("NOSEP_VAL", self.config.parser.variables["NOSEP_TWO"]) @mock.patch("certbot_apache._internal.configurator.util.run_script") def test_alt_restart_works(self, mock_run_script): mock_run_script.side_effect = [None, errors.SubprocessError, None] self.config.restart() self.assertEqual(mock_run_script.call_count, 3) @mock.patch("certbot_apache._internal.configurator.util.run_script") def test_alt_restart_errors(self, mock_run_script): mock_run_script.side_effect = [None, errors.SubprocessError, errors.SubprocessError] self.assertRaises(errors.MisconfigurationError, self.config.restart) if __name__ == "__main__": unittest.main() # pragma: no cover ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/gentoo_test.py0000644000076500000240000001313600000000000017177 0ustar00bmwstaff"""Test for certbot_apache._internal.configurator for Gentoo overrides""" import unittest try: import mock except ImportError: # pragma: no cover from unittest import mock # type: ignore from certbot import errors from certbot.compat import filesystem from certbot.compat import os from certbot_apache._internal import obj from certbot_apache._internal import override_gentoo import util def get_vh_truth(temp_dir, config_name): """Return the ground truth for the specified directory.""" prefix = os.path.join( temp_dir, config_name, "apache2/vhosts.d") aug_pre = "/files" + prefix vh_truth = [ obj.VirtualHost( os.path.join(prefix, "gentoo.example.com.conf"), os.path.join(aug_pre, "gentoo.example.com.conf/VirtualHost"), {obj.Addr.fromstring("*:80")}, False, True, "gentoo.example.com"), obj.VirtualHost( os.path.join(prefix, "00_default_vhost.conf"), os.path.join(aug_pre, "00_default_vhost.conf/IfDefine/VirtualHost"), {obj.Addr.fromstring("*:80")}, False, True, "localhost"), obj.VirtualHost( os.path.join(prefix, "00_default_ssl_vhost.conf"), os.path.join(aug_pre, "00_default_ssl_vhost.conf" + "/IfDefine/IfDefine/IfModule/VirtualHost"), {obj.Addr.fromstring("_default_:443")}, True, True, "localhost") ] return vh_truth class MultipleVhostsTestGentoo(util.ApacheTest): """Multiple vhost tests for non-debian distro""" _multiprocess_can_split_ = True def setUp(self): # pylint: disable=arguments-differ test_dir = "gentoo_apache/apache" config_root = "gentoo_apache/apache/apache2" vhost_root = "gentoo_apache/apache/apache2/vhosts.d" super().setUp(test_dir=test_dir, config_root=config_root, vhost_root=vhost_root) # pylint: disable=line-too-long with mock.patch("certbot_apache._internal.override_gentoo.GentooParser.update_runtime_variables"): self.config = util.get_apache_configurator( self.config_path, self.vhost_path, self.config_dir, self.work_dir, os_info="gentoo") self.vh_truth = get_vh_truth( self.temp_dir, "gentoo_apache/apache") def test_get_parser(self): self.assertTrue(isinstance(self.config.parser, override_gentoo.GentooParser)) def test_get_virtual_hosts(self): """Make sure all vhosts are being properly found.""" vhs = self.config.get_virtual_hosts() self.assertEqual(len(vhs), 3) found = 0 for vhost in vhs: for gentoo_truth in self.vh_truth: if vhost == gentoo_truth: found += 1 break else: raise Exception("Missed: %s" % vhost) # pragma: no cover self.assertEqual(found, 3) def test_get_sysconfig_vars(self): """Make sure we read the Gentoo APACHE2_OPTS variable correctly""" defines = ['DEFAULT_VHOST', 'INFO', 'SSL', 'SSL_DEFAULT_VHOST', 'LANGUAGE'] self.config.parser.apacheconfig_filep = filesystem.realpath( os.path.join(self.config.parser.root, "../conf.d/apache2")) self.config.parser.variables = {} with mock.patch("certbot_apache._internal.override_gentoo.GentooParser.update_modules"): self.config.parser.update_runtime_variables() for define in defines: self.assertTrue(define in self.config.parser.variables) @mock.patch("certbot_apache._internal.apache_util.parse_from_subprocess") def test_no_binary_configdump(self, mock_subprocess): """Make sure we don't call binary dumps other than modules from Apache as this is not supported in Gentoo currently""" with mock.patch("certbot_apache._internal.override_gentoo.GentooParser.update_modules"): self.config.parser.update_runtime_variables() self.config.parser.reset_modules() self.assertFalse(mock_subprocess.called) self.config.parser.update_runtime_variables() self.config.parser.reset_modules() self.assertTrue(mock_subprocess.called) @mock.patch("certbot_apache._internal.apache_util._get_runtime_cfg") def test_opportunistic_httpd_runtime_parsing(self, mock_get): mod_val = ( 'Loaded Modules:\n' ' mock_module (static)\n' ' another_module (static)\n' ) def mock_get_cfg(command): """Mock httpd process stdout""" if command == ['apache2ctl', 'modules']: return mod_val return None # pragma: no cover mock_get.side_effect = mock_get_cfg self.config.parser.modules = {} with mock.patch("certbot.util.get_os_info") as mock_osi: # Make sure we have the have the Gentoo httpd constants mock_osi.return_value = ("gentoo", "123") self.config.parser.update_runtime_variables() self.assertEqual(mock_get.call_count, 1) self.assertEqual(len(self.config.parser.modules), 4) self.assertTrue("mod_another.c" in self.config.parser.modules) @mock.patch("certbot_apache._internal.configurator.util.run_script") def test_alt_restart_works(self, mock_run_script): mock_run_script.side_effect = [None, errors.SubprocessError, None] self.config.restart() self.assertEqual(mock_run_script.call_count, 3) if __name__ == "__main__": unittest.main() # pragma: no cover ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/http_01_test.py0000644000076500000240000002371500000000000017167 0ustar00bmwstaff"""Test for certbot_apache._internal.http_01.""" import unittest import errno from typing import List try: import mock except ImportError: # pragma: no cover from unittest import mock # type: ignore from acme import challenges from certbot import achallenges from certbot import errors from certbot.compat import filesystem from certbot.compat import os from certbot.tests import acme_util from certbot_apache._internal.parser import get_aug_path import util NUM_ACHALLS = 3 class ApacheHttp01Test(util.ApacheTest): """Test for certbot_apache._internal.http_01.ApacheHttp01.""" def setUp(self, *args, **kwargs): # pylint: disable=arguments-differ super().setUp(*args, **kwargs) self.account_key = self.rsa512jwk self.achalls: List[achallenges.KeyAuthorizationAnnotatedChallenge] = [] vh_truth = util.get_vh_truth( self.temp_dir, "debian_apache_2_4/multiple_vhosts") # Takes the vhosts for encryption-example.demo, certbot.demo # and vhost.in.rootconf self.vhosts = [vh_truth[0], vh_truth[3], vh_truth[10]] for i in range(NUM_ACHALLS): self.achalls.append( achallenges.KeyAuthorizationAnnotatedChallenge( challb=acme_util.chall_to_challb( challenges.HTTP01(token=((chr(ord('a') + i).encode() * 16))), "pending"), domain=self.vhosts[i].name, account_key=self.account_key)) modules = ["ssl", "rewrite", "authz_core", "authz_host"] for mod in modules: self.config.parser.modules["mod_{0}.c".format(mod)] = None self.config.parser.modules[mod + "_module"] = None from certbot_apache._internal.http_01 import ApacheHttp01 self.http = ApacheHttp01(self.config) def test_empty_perform(self): self.assertFalse(self.http.perform()) @mock.patch("certbot_apache._internal.configurator.ApacheConfigurator.enable_mod") def test_enable_modules_apache_2_2(self, mock_enmod): self.config.version = (2, 2) del self.config.parser.modules["authz_host_module"] del self.config.parser.modules["mod_authz_host.c"] enmod_calls = self.common_enable_modules_test(mock_enmod) self.assertEqual(enmod_calls[0][0][0], "authz_host") @mock.patch("certbot_apache._internal.configurator.ApacheConfigurator.enable_mod") def test_enable_modules_apache_2_4(self, mock_enmod): del self.config.parser.modules["authz_core_module"] del self.config.parser.modules["mod_authz_host.c"] enmod_calls = self.common_enable_modules_test(mock_enmod) self.assertEqual(enmod_calls[0][0][0], "authz_core") def common_enable_modules_test(self, mock_enmod): """Tests enabling mod_rewrite and other modules.""" del self.config.parser.modules["rewrite_module"] del self.config.parser.modules["mod_rewrite.c"] self.http.prepare_http01_modules() self.assertTrue(mock_enmod.called) calls = mock_enmod.call_args_list other_calls = [] for call in calls: if call[0][0] != "rewrite": other_calls.append(call) # If these lists are equal, we never enabled mod_rewrite self.assertNotEqual(calls, other_calls) return other_calls def test_same_vhost(self): vhost = next(v for v in self.config.vhosts if v.name == "certbot.demo") achalls = [ achallenges.KeyAuthorizationAnnotatedChallenge( challb=acme_util.chall_to_challb( challenges.HTTP01(token=((b'a' * 16))), "pending"), domain=vhost.name, account_key=self.account_key), achallenges.KeyAuthorizationAnnotatedChallenge( challb=acme_util.chall_to_challb( challenges.HTTP01(token=((b'b' * 16))), "pending"), domain=next(iter(vhost.aliases)), account_key=self.account_key) ] self.common_perform_test(achalls, [vhost]) def test_anonymous_vhost(self): vhosts = [v for v in self.config.vhosts if not v.ssl] achalls = [ achallenges.KeyAuthorizationAnnotatedChallenge( challb=acme_util.chall_to_challb( challenges.HTTP01(token=((b'a' * 16))), "pending"), domain="something.nonexistent", account_key=self.account_key)] self.common_perform_test(achalls, vhosts) def test_configure_multiple_vhosts(self): vhosts = [v for v in self.config.vhosts if "duplicate.example.com" in v.get_names()] self.assertEqual(len(vhosts), 2) achalls = [ achallenges.KeyAuthorizationAnnotatedChallenge( challb=acme_util.chall_to_challb( challenges.HTTP01(token=((b'a' * 16))), "pending"), domain="duplicate.example.com", account_key=self.account_key)] self.common_perform_test(achalls, vhosts) def test_configure_name_and_blank(self): domain = "certbot.demo" vhosts = [v for v in self.config.vhosts if v.name == domain or v.name is None] achalls = [ achallenges.KeyAuthorizationAnnotatedChallenge( challb=acme_util.chall_to_challb( challenges.HTTP01(token=((b'a' * 16))), "pending"), domain=domain, account_key=self.account_key), ] self.common_perform_test(achalls, vhosts) def test_no_vhost(self): for achall in self.achalls: self.http.add_chall(achall) self.config.config.http01_port = 12345 self.assertRaises(errors.PluginError, self.http.perform) def test_perform_1_achall_apache_2_2(self): self.combinations_perform_test(num_achalls=1, minor_version=2) def test_perform_1_achall_apache_2_4(self): self.combinations_perform_test(num_achalls=1, minor_version=4) def test_perform_2_achall_apache_2_2(self): self.combinations_perform_test(num_achalls=2, minor_version=2) def test_perform_2_achall_apache_2_4(self): self.combinations_perform_test(num_achalls=2, minor_version=4) def test_perform_3_achall_apache_2_2(self): self.combinations_perform_test(num_achalls=3, minor_version=2) def test_perform_3_achall_apache_2_4(self): self.combinations_perform_test(num_achalls=3, minor_version=4) def test_activate_disabled_vhost(self): vhosts = [v for v in self.config.vhosts if v.name == "certbot.demo"] achalls = [ achallenges.KeyAuthorizationAnnotatedChallenge( challb=acme_util.chall_to_challb( challenges.HTTP01(token=((b'a' * 16))), "pending"), domain="certbot.demo", account_key=self.account_key)] vhosts[0].enabled = False self.common_perform_test(achalls, vhosts) matches = self.config.parser.find_dir( "Include", vhosts[0].filep, get_aug_path(self.config.parser.loc["default"])) self.assertEqual(len(matches), 1) def combinations_perform_test(self, num_achalls, minor_version): """Test perform with the given achall count and Apache version.""" achalls = self.achalls[:num_achalls] vhosts = self.vhosts[:num_achalls] self.config.version = (2, minor_version) self.common_perform_test(achalls, vhosts) def common_perform_test(self, achalls, vhosts): """Tests perform with the given achalls.""" challenge_dir = self.http.challenge_dir self.assertFalse(os.path.exists(challenge_dir)) for achall in achalls: self.http.add_chall(achall) expected_response = [ achall.response(self.account_key) for achall in achalls] self.assertEqual(self.http.perform(), expected_response) self.assertTrue(os.path.isdir(self.http.challenge_dir)) self.assertTrue(filesystem.has_min_permissions(self.http.challenge_dir, 0o755)) self._test_challenge_conf() for achall in achalls: self._test_challenge_file(achall) for vhost in vhosts: matches = self.config.parser.find_dir("Include", self.http.challenge_conf_pre, vhost.path) self.assertEqual(len(matches), 1) matches = self.config.parser.find_dir("Include", self.http.challenge_conf_post, vhost.path) self.assertEqual(len(matches), 1) self.assertTrue(os.path.exists(challenge_dir)) @mock.patch("certbot_apache._internal.http_01.filesystem.makedirs") def test_failed_makedirs(self, mock_makedirs): mock_makedirs.side_effect = OSError(errno.EACCES, "msg") self.http.add_chall(self.achalls[0]) self.assertRaises(errors.PluginError, self.http.perform) def _test_challenge_conf(self): with open(self.http.challenge_conf_pre) as f: pre_conf_contents = f.read() with open(self.http.challenge_conf_post) as f: post_conf_contents = f.read() self.assertTrue("RewriteEngine on" in pre_conf_contents) self.assertTrue("RewriteRule" in pre_conf_contents) self.assertTrue(self.http.challenge_dir in post_conf_contents) if self.config.version < (2, 4): self.assertTrue("Allow from all" in post_conf_contents) else: self.assertTrue("Require all granted" in post_conf_contents) def _test_challenge_file(self, achall): name = os.path.join(self.http.challenge_dir, achall.chall.encode("token")) validation = achall.validation(self.account_key) self.assertTrue(filesystem.has_min_permissions(name, 0o644)) with open(name, 'rb') as f: self.assertEqual(f.read(), validation.encode()) if __name__ == "__main__": unittest.main() # pragma: no cover ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/obj_test.py0000644000076500000240000001243600000000000016460 0ustar00bmwstaff"""Tests for certbot_apache._internal.obj.""" import unittest class VirtualHostTest(unittest.TestCase): """Test the VirtualHost class.""" def setUp(self): from certbot_apache._internal.obj import Addr from certbot_apache._internal.obj import VirtualHost self.addr1 = Addr.fromstring("127.0.0.1") self.addr2 = Addr.fromstring("127.0.0.1:443") self.addr_default = Addr.fromstring("_default_:443") self.vhost1 = VirtualHost( "filep", "vh_path", {self.addr1}, False, False, "localhost") self.vhost1b = VirtualHost( "filep", "vh_path", {self.addr1}, False, False, "localhost") self.vhost2 = VirtualHost( "fp", "vhp", {self.addr2}, False, False, "localhost") def test_repr(self): self.assertEqual(repr(self.addr2), "certbot_apache._internal.obj.Addr(('127.0.0.1', '443'))") def test_eq(self): self.assertEqual(self.vhost1b, self.vhost1) self.assertNotEqual(self.vhost1, self.vhost2) self.assertEqual(str(self.vhost1b), str(self.vhost1)) self.assertNotEqual(self.vhost1b, 1234) def test_ne(self): self.assertNotEqual(self.vhost1, self.vhost2) self.assertEqual(self.vhost1, self.vhost1b) def test_conflicts(self): from certbot_apache._internal.obj import Addr from certbot_apache._internal.obj import VirtualHost complex_vh = VirtualHost( "fp", "vhp", {Addr.fromstring("*:443"), Addr.fromstring("1.2.3.4:443")}, False, False) self.assertTrue(complex_vh.conflicts([self.addr1])) self.assertTrue(complex_vh.conflicts([self.addr2])) self.assertFalse(complex_vh.conflicts([self.addr_default])) self.assertTrue(self.vhost1.conflicts([self.addr2])) self.assertFalse(self.vhost1.conflicts([self.addr_default])) self.assertFalse(self.vhost2.conflicts([self.addr1, self.addr_default])) def test_same_server(self): from certbot_apache._internal.obj import VirtualHost no_name1 = VirtualHost( "fp", "vhp", {self.addr1}, False, False, None) no_name2 = VirtualHost( "fp", "vhp", {self.addr2}, False, False, None) no_name3 = VirtualHost( "fp", "vhp", {self.addr_default}, False, False, None) no_name4 = VirtualHost( "fp", "vhp", {self.addr2, self.addr_default}, False, False, None) self.assertTrue(self.vhost1.same_server(self.vhost2)) self.assertTrue(no_name1.same_server(no_name2)) self.assertFalse(self.vhost1.same_server(no_name1)) self.assertFalse(no_name1.same_server(no_name3)) self.assertFalse(no_name1.same_server(no_name4)) class AddrTest(unittest.TestCase): """Test obj.Addr.""" def setUp(self): from certbot_apache._internal.obj import Addr self.addr = Addr.fromstring("*:443") self.addr1 = Addr.fromstring("127.0.0.1") self.addr2 = Addr.fromstring("127.0.0.1:*") self.addr_defined = Addr.fromstring("127.0.0.1:443") self.addr_default = Addr.fromstring("_default_:443") def test_wildcard(self): self.assertFalse(self.addr.is_wildcard()) self.assertTrue(self.addr1.is_wildcard()) self.assertTrue(self.addr2.is_wildcard()) def test_get_sni_addr(self): from certbot_apache._internal.obj import Addr self.assertEqual( self.addr.get_sni_addr("443"), Addr.fromstring("*:443")) self.assertEqual( self.addr.get_sni_addr("225"), Addr.fromstring("*:225")) self.assertEqual( self.addr1.get_sni_addr("443"), Addr.fromstring("127.0.0.1")) def test_conflicts(self): # Note: Defined IP is more important than defined port in match self.assertTrue(self.addr.conflicts(self.addr1)) self.assertTrue(self.addr.conflicts(self.addr2)) self.assertTrue(self.addr.conflicts(self.addr_defined)) self.assertFalse(self.addr.conflicts(self.addr_default)) self.assertFalse(self.addr1.conflicts(self.addr)) self.assertTrue(self.addr1.conflicts(self.addr_defined)) self.assertFalse(self.addr1.conflicts(self.addr_default)) self.assertFalse(self.addr_defined.conflicts(self.addr1)) self.assertFalse(self.addr_defined.conflicts(self.addr2)) self.assertFalse(self.addr_defined.conflicts(self.addr)) self.assertFalse(self.addr_defined.conflicts(self.addr_default)) self.assertTrue(self.addr_default.conflicts(self.addr)) self.assertTrue(self.addr_default.conflicts(self.addr1)) self.assertTrue(self.addr_default.conflicts(self.addr_defined)) # Self test self.assertTrue(self.addr.conflicts(self.addr)) self.assertTrue(self.addr1.conflicts(self.addr1)) # This is a tricky one... self.assertTrue(self.addr1.conflicts(self.addr2)) def test_equal(self): self.assertEqual(self.addr1, self.addr2) self.assertNotEqual(self.addr, self.addr1) self.assertNotEqual(self.addr, 123) def test_not_equal(self): self.assertEqual(self.addr1, self.addr2) self.assertNotEqual(self.addr, self.addr1) if __name__ == "__main__": unittest.main() # pragma: no cover ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/parser_test.py0000644000076500000240000004100700000000000017176 0ustar00bmwstaff"""Tests for certbot_apache._internal.parser.""" import shutil import unittest try: import mock except ImportError: # pragma: no cover from unittest import mock # type: ignore from certbot import errors from certbot.compat import os import util class BasicParserTest(util.ParserTest): """Apache Parser Test.""" def setUp(self): # pylint: disable=arguments-differ super().setUp() def tearDown(self): shutil.rmtree(self.temp_dir) shutil.rmtree(self.config_dir) shutil.rmtree(self.work_dir) def test_bad_parse(self): self.parser.parse_file(os.path.join(self.parser.root, "conf-available", "bad_conf_file.conf")) self.assertRaises( errors.PluginError, self.parser.check_parsing_errors, "httpd.aug") def test_bad_save(self): mock_save = mock.Mock() mock_save.side_effect = IOError self.parser.aug.save = mock_save self.assertRaises(errors.PluginError, self.parser.unsaved_files) def test_aug_version(self): mock_match = mock.Mock(return_value=["something"]) self.parser.aug.match = mock_match # pylint: disable=protected-access self.assertEqual(self.parser.check_aug_version(), ["something"]) self.parser.aug.match.side_effect = RuntimeError self.assertFalse(self.parser.check_aug_version()) def test_find_config_root_no_root(self): # pylint: disable=protected-access os.remove(self.parser.loc["root"]) self.assertRaises( errors.NoInstallationError, self.parser._find_config_root) def test_parse_file(self): """Test parse_file. certbot.conf is chosen as the test file as it will not be included during the normal course of execution. """ file_path = os.path.join( self.config_path, "not-parsed-by-default", "certbot.conf") self.parser.parse_file(file_path) # pylint: disable=protected-access # search for the httpd incl matches = self.parser.aug.match( "/augeas/load/Httpd/incl [. ='%s']" % file_path) self.assertTrue(matches) def test_find_dir(self): test = self.parser.find_dir("Listen", "80") # This will only look in enabled hosts test2 = self.parser.find_dir("documentroot") self.assertEqual(len(test), 1) self.assertEqual(len(test2), 8) def test_add_dir(self): aug_default = "/files" + self.parser.loc["default"] self.parser.add_dir(aug_default, "AddDirective", "test") self.assertTrue( self.parser.find_dir("AddDirective", "test", aug_default)) self.parser.add_dir(aug_default, "AddList", ["1", "2", "3", "4"]) matches = self.parser.find_dir("AddList", None, aug_default) for i, match in enumerate(matches): self.assertEqual(self.parser.aug.get(match), str(i + 1)) def test_add_dir_beginning(self): aug_default = "/files" + self.parser.loc["default"] self.parser.add_dir_beginning(aug_default, "AddDirectiveBeginning", "testBegin") self.assertTrue( self.parser.find_dir("AddDirectiveBeginning", "testBegin", aug_default)) self.assertEqual( self.parser.aug.get(aug_default+"/directive[1]"), "AddDirectiveBeginning") self.parser.add_dir_beginning(aug_default, "AddList", ["1", "2", "3", "4"]) matches = self.parser.find_dir("AddList", None, aug_default) for i, match in enumerate(matches): self.assertEqual(self.parser.aug.get(match), str(i + 1)) for name in ("empty.conf", "no-directives.conf"): conf = "/files" + os.path.join(self.parser.root, "sites-available", name) self.parser.add_dir_beginning(conf, "AddDirectiveBeginning", "testBegin") self.assertTrue(self.parser.find_dir("AddDirectiveBeginning", "testBegin", conf)) def test_empty_arg(self): self.assertEqual(None, self.parser.get_arg("/files/whatever/nonexistent")) def test_add_dir_to_ifmodssl(self): """test add_dir_to_ifmodssl. Path must be valid before attempting to add to augeas """ from certbot_apache._internal.parser import get_aug_path # This makes sure that find_dir will work self.parser.modules["mod_ssl.c"] = "/fake/path" self.parser.add_dir_to_ifmodssl( get_aug_path(self.parser.loc["default"]), "FakeDirective", ["123"]) matches = self.parser.find_dir("FakeDirective", "123") self.assertEqual(len(matches), 1) self.assertTrue("IfModule" in matches[0]) def test_add_dir_to_ifmodssl_multiple(self): from certbot_apache._internal.parser import get_aug_path # This makes sure that find_dir will work self.parser.modules["mod_ssl.c"] = "/fake/path" self.parser.add_dir_to_ifmodssl( get_aug_path(self.parser.loc["default"]), "FakeDirective", ["123", "456", "789"]) matches = self.parser.find_dir("FakeDirective") self.assertEqual(len(matches), 3) self.assertTrue("IfModule" in matches[0]) def test_get_aug_path(self): from certbot_apache._internal.parser import get_aug_path self.assertEqual("/files/etc/apache", get_aug_path("/etc/apache")) def test_set_locations(self): with mock.patch("certbot_apache._internal.parser.os.path") as mock_path: mock_path.isfile.side_effect = [False, False] # pylint: disable=protected-access results = self.parser._set_locations() self.assertEqual(results["default"], results["listen"]) self.assertEqual(results["default"], results["name"]) @mock.patch("certbot_apache._internal.parser.ApacheParser.find_dir") @mock.patch("certbot_apache._internal.parser.ApacheParser.get_arg") def test_parse_modules_bad_syntax(self, mock_arg, mock_find): mock_find.return_value = ["1", "2", "3", "4", "5", "6", "7", "8"] mock_arg.return_value = None with mock.patch("certbot_apache._internal.parser.logger") as mock_logger: self.parser.parse_modules() # Make sure that we got None return value and logged the file self.assertTrue(mock_logger.debug.called) @mock.patch("certbot_apache._internal.parser.ApacheParser.find_dir") @mock.patch("certbot_apache._internal.apache_util._get_runtime_cfg") def test_update_runtime_variables(self, mock_cfg, _): define_val = ( 'ServerRoot: "/etc/apache2"\n' 'Main DocumentRoot: "/var/www"\n' 'Main ErrorLog: "/var/log/apache2/error.log"\n' 'Mutex ssl-stapling: using_defaults\n' 'Mutex ssl-cache: using_defaults\n' 'Mutex default: dir="/var/lock/apache2" mechanism=fcntl\n' 'Mutex watchdog-callback: using_defaults\n' 'PidFile: "/var/run/apache2/apache2.pid"\n' 'Define: TEST\n' 'Define: DUMP_RUN_CFG\n' 'Define: U_MICH\n' 'Define: TLS=443\n' 'Define: WITH_ASSIGNMENT=URL=http://example.com\n' 'Define: EMPTY=\n' 'Define: example_path=Documents/path\n' 'User: name="www-data" id=33 not_used\n' 'Group: name="www-data" id=33 not_used\n' ) inc_val = ( 'Included configuration files:\n' ' (*) /etc/apache2/apache2.conf\n' ' (146) /etc/apache2/mods-enabled/access_compat.load\n' ' (146) /etc/apache2/mods-enabled/alias.load\n' ' (146) /etc/apache2/mods-enabled/auth_basic.load\n' ' (146) /etc/apache2/mods-enabled/authn_core.load\n' ' (146) /etc/apache2/mods-enabled/authn_file.load\n' ' (146) /etc/apache2/mods-enabled/authz_core.load\n' ' (146) /etc/apache2/mods-enabled/authz_host.load\n' ' (146) /etc/apache2/mods-enabled/authz_user.load\n' ' (146) /etc/apache2/mods-enabled/autoindex.load\n' ' (146) /etc/apache2/mods-enabled/deflate.load\n' ' (146) /etc/apache2/mods-enabled/dir.load\n' ' (146) /etc/apache2/mods-enabled/env.load\n' ' (146) /etc/apache2/mods-enabled/filter.load\n' ' (146) /etc/apache2/mods-enabled/mime.load\n' ' (146) /etc/apache2/mods-enabled/mpm_event.load\n' ' (146) /etc/apache2/mods-enabled/negotiation.load\n' ' (146) /etc/apache2/mods-enabled/reqtimeout.load\n' ' (146) /etc/apache2/mods-enabled/setenvif.load\n' ' (146) /etc/apache2/mods-enabled/socache_shmcb.load\n' ' (146) /etc/apache2/mods-enabled/ssl.load\n' ' (146) /etc/apache2/mods-enabled/status.load\n' ' (147) /etc/apache2/mods-enabled/alias.conf\n' ' (147) /etc/apache2/mods-enabled/autoindex.conf\n' ' (147) /etc/apache2/mods-enabled/deflate.conf\n' ) mod_val = ( 'Loaded Modules:\n' ' core_module (static)\n' ' so_module (static)\n' ' watchdog_module (static)\n' ' http_module (static)\n' ' log_config_module (static)\n' ' logio_module (static)\n' ' version_module (static)\n' ' unixd_module (static)\n' ' access_compat_module (shared)\n' ' alias_module (shared)\n' ' auth_basic_module (shared)\n' ' authn_core_module (shared)\n' ' authn_file_module (shared)\n' ' authz_core_module (shared)\n' ' authz_host_module (shared)\n' ' authz_user_module (shared)\n' ' autoindex_module (shared)\n' ' deflate_module (shared)\n' ' dir_module (shared)\n' ' env_module (shared)\n' ' filter_module (shared)\n' ' mime_module (shared)\n' ' mpm_event_module (shared)\n' ' negotiation_module (shared)\n' ' reqtimeout_module (shared)\n' ' setenvif_module (shared)\n' ' socache_shmcb_module (shared)\n' ' ssl_module (shared)\n' ' status_module (shared)\n' ) def mock_get_vars(cmd): """Mock command output""" if cmd[-1] == "DUMP_RUN_CFG": return define_val elif cmd[-1] == "DUMP_INCLUDES": return inc_val elif cmd[-1] == "DUMP_MODULES": return mod_val return None # pragma: no cover mock_cfg.side_effect = mock_get_vars expected_vars = {"TEST": "", "U_MICH": "", "TLS": "443", "example_path": "Documents/path", "WITH_ASSIGNMENT": "URL=http://example.com", "EMPTY": "", } self.parser.modules = {} with mock.patch( "certbot_apache._internal.parser.ApacheParser.parse_file") as mock_parse: self.parser.update_runtime_variables() self.assertEqual(self.parser.variables, expected_vars) self.assertEqual(len(self.parser.modules), 58) # None of the includes in inc_val should be in parsed paths. # Make sure we tried to include them all. self.assertEqual(mock_parse.call_count, 25) @mock.patch("certbot_apache._internal.parser.ApacheParser.find_dir") @mock.patch("certbot_apache._internal.apache_util._get_runtime_cfg") def test_update_runtime_variables_alt_values(self, mock_cfg, _): inc_val = ( 'Included configuration files:\n' ' (*) {0}\n' ' (146) /etc/apache2/mods-enabled/access_compat.load\n' ' (146) {1}/mods-enabled/alias.load\n' ).format(self.parser.loc["root"], os.path.dirname(self.parser.loc["root"])) mock_cfg.return_value = inc_val self.parser.modules = {} with mock.patch( "certbot_apache._internal.parser.ApacheParser.parse_file") as mock_parse: self.parser.update_runtime_variables() # No matching modules should have been found self.assertEqual(len(self.parser.modules), 0) # Only one of the three includes do not exist in already parsed # path derived from root configuration Include statements self.assertEqual(mock_parse.call_count, 1) @mock.patch("certbot_apache._internal.apache_util.subprocess.run") def test_update_runtime_vars_bad_ctl(self, mock_run): mock_run.side_effect = OSError self.assertRaises( errors.MisconfigurationError, self.parser.update_runtime_variables) @mock.patch("certbot_apache._internal.apache_util.subprocess.run") def test_update_runtime_vars_bad_exit(self, mock_run): mock_proc = mock_run.return_value mock_proc.stdout = "" mock_proc.stderr = "" mock_proc.returncode = -1 self.assertRaises( errors.MisconfigurationError, self.parser.update_runtime_variables) def test_add_comment(self): from certbot_apache._internal.parser import get_aug_path self.parser.add_comment(get_aug_path(self.parser.loc["name"]), "123456") comm = self.parser.find_comments("123456") self.assertEqual(len(comm), 1) self.assertTrue(self.parser.loc["name"] in comm[0]) class ParserInitTest(util.ApacheTest): def setUp(self): # pylint: disable=arguments-differ super().setUp() def tearDown(self): shutil.rmtree(self.temp_dir) shutil.rmtree(self.config_dir) shutil.rmtree(self.work_dir) @mock.patch("certbot_apache._internal.parser.init_augeas") def test_prepare_no_augeas(self, mock_init_augeas): from certbot_apache._internal.parser import ApacheParser mock_init_augeas.side_effect = errors.NoInstallationError self.config.config_test = mock.Mock() self.assertRaises( errors.NoInstallationError, ApacheParser, os.path.relpath(self.config_path), "/dummy/vhostpath", version=(2, 4, 22), configurator=self.config) def test_init_old_aug(self): from certbot_apache._internal.parser import ApacheParser with mock.patch("certbot_apache._internal.parser.ApacheParser.check_aug_version") as mock_c: mock_c.return_value = False self.assertRaises( errors.NotSupportedError, ApacheParser, os.path.relpath(self.config_path), "/dummy/vhostpath", version=(2, 4, 22), configurator=self.config) @mock.patch("certbot_apache._internal.apache_util._get_runtime_cfg") def test_unparseable(self, mock_cfg): from certbot_apache._internal.parser import ApacheParser mock_cfg.return_value = ('Define: TEST') self.assertRaises( errors.PluginError, ApacheParser, os.path.relpath(self.config_path), "/dummy/vhostpath", version=(2, 2, 22), configurator=self.config) def test_root_normalized(self): from certbot_apache._internal.parser import ApacheParser with mock.patch("certbot_apache._internal.parser.ApacheParser." "update_runtime_variables"): path = os.path.join( self.temp_dir, "debian_apache_2_4/////multiple_vhosts/../multiple_vhosts/apache2") parser = ApacheParser(path, "/dummy/vhostpath", configurator=self.config) self.assertEqual(parser.root, self.config_path) def test_root_absolute(self): from certbot_apache._internal.parser import ApacheParser with mock.patch("certbot_apache._internal.parser.ApacheParser." "update_runtime_variables"): parser = ApacheParser( os.path.relpath(self.config_path), "/dummy/vhostpath", configurator=self.config) self.assertEqual(parser.root, self.config_path) def test_root_no_trailing_slash(self): from certbot_apache._internal.parser import ApacheParser with mock.patch("certbot_apache._internal.parser.ApacheParser." "update_runtime_variables"): parser = ApacheParser( self.config_path + os.path.sep, "/dummy/vhostpath", configurator=self.config) self.assertEqual(parser.root, self.config_path) if __name__ == "__main__": unittest.main() # pragma: no cover ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/parsernode_configurator_test.py0000644000076500000240000000313000000000000022621 0ustar00bmwstaff"""Tests for ApacheConfigurator for AugeasParserNode classes""" import unittest try: import mock except ImportError: # pragma: no cover from unittest import mock # type: ignore import util try: import apacheconfig HAS_APACHECONFIG = True except ImportError: # pragma: no cover HAS_APACHECONFIG = False @unittest.skipIf(not HAS_APACHECONFIG, reason='Tests require apacheconfig dependency') class ConfiguratorParserNodeTest(util.ApacheTest): # pylint: disable=too-many-public-methods """Test AugeasParserNode using available test configurations""" def setUp(self): # pylint: disable=arguments-differ super().setUp() self.config = util.get_apache_configurator( self.config_path, self.vhost_path, self.config_dir, self.work_dir, use_parsernode=True) self.vh_truth = util.get_vh_truth( self.temp_dir, "debian_apache_2_4/multiple_vhosts") def test_parsernode_get_vhosts(self): self.config.USE_PARSERNODE = True vhosts = self.config.get_virtual_hosts() # Legacy get_virtual_hosts() do not set the node self.assertTrue(vhosts[0].node is not None) def test_parsernode_get_vhosts_mismatch(self): vhosts = self.config.get_virtual_hosts_v2() # One of the returned VirtualHost objects differs vhosts[0].name = "IdidntExpectThat" self.config.get_virtual_hosts_v2 = mock.MagicMock(return_value=vhosts) with self.assertRaises(AssertionError): _ = self.config.get_virtual_hosts() if __name__ == "__main__": unittest.main() # pragma: no cover ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/parsernode_test.py0000644000076500000240000000705500000000000020051 0ustar00bmwstaff""" Tests for ParserNode interface """ import unittest from certbot_apache._internal import interfaces from certbot_apache._internal import parsernode_util as util class DummyParserNode(interfaces.ParserNode): """ A dummy class implementing ParserNode interface """ def __init__(self, **kwargs): """ Initializes the ParserNode instance. """ ancestor, dirty, filepath, metadata = util.parsernode_kwargs(kwargs) self.ancestor = ancestor self.dirty = dirty self.filepath = filepath self.metadata = metadata super().__init__(**kwargs) def save(self, msg): # pragma: no cover """Save""" pass def find_ancestors(self, name): # pragma: no cover """ Find ancestors """ return [] class DummyCommentNode(DummyParserNode): """ A dummy class implementing CommentNode interface """ def __init__(self, **kwargs): """ Initializes the CommentNode instance and sets its instance variables. """ comment, kwargs = util.commentnode_kwargs(kwargs) self.comment = comment super().__init__(**kwargs) class DummyDirectiveNode(DummyParserNode): """ A dummy class implementing DirectiveNode interface """ # pylint: disable=too-many-arguments def __init__(self, **kwargs): """ Initializes the DirectiveNode instance and sets its instance variables. """ name, parameters, enabled, kwargs = util.directivenode_kwargs(kwargs) self.name = name self.parameters = parameters self.enabled = enabled super().__init__(**kwargs) def set_parameters(self, parameters): # pragma: no cover """Set parameters""" pass class DummyBlockNode(DummyDirectiveNode): """ A dummy class implementing BlockNode interface """ def add_child_block(self, name, parameters=None, position=None): # pragma: no cover """Add child block""" pass def add_child_directive(self, name, parameters=None, position=None): # pragma: no cover """Add child directive""" pass def add_child_comment(self, comment="", position=None): # pragma: no cover """Add child comment""" pass def find_blocks(self, name, exclude=True): # pragma: no cover """Find blocks""" pass def find_directives(self, name, exclude=True): # pragma: no cover """Find directives""" pass def find_comments(self, comment, exact=False): # pragma: no cover """Find comments""" pass def delete_child(self, child): # pragma: no cover """Delete child""" pass def unsaved_files(self): # pragma: no cover """Unsaved files""" pass interfaces.CommentNode.register(DummyCommentNode) interfaces.DirectiveNode.register(DummyDirectiveNode) interfaces.BlockNode.register(DummyBlockNode) class ParserNodeTest(unittest.TestCase): """Dummy placeholder test case for ParserNode interfaces""" def test_dummy(self): dummyblock = DummyBlockNode( name="None", parameters=(), ancestor=None, dirty=False, filepath="/some/random/path" ) dummydirective = DummyDirectiveNode( name="Name", ancestor=None, filepath="/another/path" ) dummycomment = DummyCommentNode( comment="Comment", ancestor=dummyblock, filepath="/some/file" ) if __name__ == "__main__": unittest.main() # pragma: no cover ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/parsernode_util_test.py0000644000076500000240000000731700000000000021107 0ustar00bmwstaff""" Tests for ParserNode utils """ import unittest from certbot_apache._internal import parsernode_util as util class ParserNodeUtilTest(unittest.TestCase): """Tests for ParserNode utils""" def _setup_parsernode(self): """ Sets up kwargs dict for ParserNode """ return { "ancestor": None, "dirty": False, "filepath": "/tmp", } def _setup_commentnode(self): """ Sets up kwargs dict for CommentNode """ pn = self._setup_parsernode() pn["comment"] = "x" return pn def _setup_directivenode(self): """ Sets up kwargs dict for DirectiveNode """ pn = self._setup_parsernode() pn["name"] = "Name" pn["parameters"] = ("first",) pn["enabled"] = True return pn def test_unknown_parameter(self): params = self._setup_parsernode() params["unknown"] = "unknown" self.assertRaises(TypeError, util.parsernode_kwargs, params) params = self._setup_commentnode() params["unknown"] = "unknown" self.assertRaises(TypeError, util.commentnode_kwargs, params) params = self._setup_directivenode() params["unknown"] = "unknown" self.assertRaises(TypeError, util.directivenode_kwargs, params) def test_parsernode(self): params = self._setup_parsernode() ctrl = self._setup_parsernode() ancestor, dirty, filepath, metadata = util.parsernode_kwargs(params) self.assertEqual(ancestor, ctrl["ancestor"]) self.assertEqual(dirty, ctrl["dirty"]) self.assertEqual(filepath, ctrl["filepath"]) self.assertEqual(metadata, {}) def test_parsernode_from_metadata(self): params = self._setup_parsernode() params.pop("filepath") md = {"some": "value"} params["metadata"] = md # Just testing that error from missing required parameters is not raised _, _, _, metadata = util.parsernode_kwargs(params) self.assertEqual(metadata, md) def test_commentnode(self): params = self._setup_commentnode() ctrl = self._setup_commentnode() comment, _ = util.commentnode_kwargs(params) self.assertEqual(comment, ctrl["comment"]) def test_commentnode_from_metadata(self): params = self._setup_commentnode() params.pop("comment") params["metadata"] = {} # Just testing that error from missing required parameters is not raised util.commentnode_kwargs(params) def test_directivenode(self): params = self._setup_directivenode() ctrl = self._setup_directivenode() name, parameters, enabled, _ = util.directivenode_kwargs(params) self.assertEqual(name, ctrl["name"]) self.assertEqual(parameters, ctrl["parameters"]) self.assertEqual(enabled, ctrl["enabled"]) def test_directivenode_from_metadata(self): params = self._setup_directivenode() params.pop("filepath") params.pop("name") params["metadata"] = {"irrelevant": "value"} # Just testing that error from missing required parameters is not raised util.directivenode_kwargs(params) def test_missing_required(self): c_params = self._setup_commentnode() c_params.pop("comment") self.assertRaises(TypeError, util.commentnode_kwargs, c_params) d_params = self._setup_directivenode() d_params.pop("ancestor") self.assertRaises(TypeError, util.directivenode_kwargs, d_params) p_params = self._setup_parsernode() p_params.pop("filepath") self.assertRaises(TypeError, util.parsernode_kwargs, p_params) if __name__ == "__main__": unittest.main() # pragma: no cover ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.7903838 certbot-apache-1.21.0/tests/testdata/0000755000076500000240000000000000000000000016100 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.7873616 certbot-apache-1.21.0/tests/testdata/centos6_apache/0000755000076500000240000000000000000000000020762 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1635888463.787408 certbot-apache-1.21.0/tests/testdata/centos6_apache/apache/0000755000076500000240000000000000000000000022203 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.7875142 certbot-apache-1.21.0/tests/testdata/centos6_apache/apache/httpd/0000755000076500000240000000000000000000000023326 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.8016953 certbot-apache-1.21.0/tests/testdata/centos6_apache/apache/httpd/conf/0000755000076500000240000000000000000000000024253 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/centos6_apache/apache/httpd/conf/httpd.conf0000644000076500000240000010316400000000000026252 0ustar00bmwstaff# # This is the main Apache server configuration file. It contains the # configuration directives that give the server its instructions. # See for detailed information. # In particular, see # # for a discussion of each configuration directive. # # # Do NOT simply read the instructions in here without understanding # what they do. They're here only as hints or reminders. If you are unsure # consult the online docs. You have been warned. # # The configuration directives are grouped into three basic sections: # 1. Directives that control the operation of the Apache server process as a # whole (the 'global environment'). # 2. Directives that define the parameters of the 'main' or 'default' server, # which responds to requests that aren't handled by a virtual host. # These directives also provide default values for the settings # of all virtual hosts. # 3. Settings for virtual hosts, which allow Web requests to be sent to # different IP addresses or hostnames and have them handled by the # same Apache server process. # # Configuration and logfile names: If the filenames you specify for many # of the server's control files begin with "/" (or "drive:/" for Win32), the # server will use that explicit path. If the filenames do *not* begin # with "/", the value of ServerRoot is prepended -- so "logs/foo.log" # with ServerRoot set to "/etc/httpd" will be interpreted by the # server as "/etc/httpd/logs/foo.log". # ### Section 1: Global Environment # # The directives in this section affect the overall operation of Apache, # such as the number of concurrent requests it can handle or where it # can find its configuration files. # # # Don't give away too much information about all the subcomponents # we are running. Comment out this line if you don't mind remote sites # finding out what major optional modules you are running ServerTokens OS # # ServerRoot: The top of the directory tree under which the server's # configuration, error, and log files are kept. # # NOTE! If you intend to place this on an NFS (or otherwise network) # mounted filesystem then please read the LockFile documentation # (available at ); # you will save yourself a lot of trouble. # # Do NOT add a slash at the end of the directory path. # ServerRoot "/etc/httpd" # # PidFile: The file in which the server should record its process # identification number when it starts. Note the PIDFILE variable in # /etc/sysconfig/httpd must be set appropriately if this location is # changed. # PidFile run/httpd.pid # # Timeout: The number of seconds before receives and sends time out. # Timeout 60 # # KeepAlive: Whether or not to allow persistent connections (more than # one request per connection). Set to "Off" to deactivate. # KeepAlive Off # # MaxKeepAliveRequests: The maximum number of requests to allow # during a persistent connection. Set to 0 to allow an unlimited amount. # We recommend you leave this number high, for maximum performance. # MaxKeepAliveRequests 100 # # KeepAliveTimeout: Number of seconds to wait for the next request from the # same client on the same connection. # KeepAliveTimeout 15 ## ## Server-Pool Size Regulation (MPM specific) ## # prefork MPM # StartServers: number of server processes to start # MinSpareServers: minimum number of server processes which are kept spare # MaxSpareServers: maximum number of server processes which are kept spare # ServerLimit: maximum value for MaxClients for the lifetime of the server # MaxClients: maximum number of server processes allowed to start # MaxRequestsPerChild: maximum number of requests a server process serves StartServers 8 MinSpareServers 5 MaxSpareServers 20 ServerLimit 256 MaxClients 256 MaxRequestsPerChild 4000 # worker MPM # StartServers: initial number of server processes to start # MaxClients: maximum number of simultaneous client connections # MinSpareThreads: minimum number of worker threads which are kept spare # MaxSpareThreads: maximum number of worker threads which are kept spare # ThreadsPerChild: constant number of worker threads in each server process # MaxRequestsPerChild: maximum number of requests a server process serves StartServers 4 MaxClients 300 MinSpareThreads 25 MaxSpareThreads 75 ThreadsPerChild 25 MaxRequestsPerChild 0 # # Listen: Allows you to bind Apache to specific IP addresses and/or # ports, in addition to the default. See also the # directive. # # Change this to Listen on specific IP addresses as shown below to # prevent Apache from glomming onto all bound IP addresses (0.0.0.0) # #Listen 12.34.56.78:80 Listen 80 # # Dynamic Shared Object (DSO) Support # # To be able to use the functionality of a module which was built as a DSO you # have to place corresponding `LoadModule' lines at this location so the # directives contained in it are actually available _before_ they are used. # Statically compiled modules (those listed by `httpd -l') do not need # to be loaded here. # # Example: # LoadModule foo_module modules/mod_foo.so # LoadModule auth_basic_module modules/mod_auth_basic.so LoadModule auth_digest_module modules/mod_auth_digest.so LoadModule authn_file_module modules/mod_authn_file.so LoadModule authn_alias_module modules/mod_authn_alias.so LoadModule authn_anon_module modules/mod_authn_anon.so LoadModule authn_dbm_module modules/mod_authn_dbm.so LoadModule authn_default_module modules/mod_authn_default.so LoadModule authz_host_module modules/mod_authz_host.so LoadModule authz_user_module modules/mod_authz_user.so LoadModule authz_owner_module modules/mod_authz_owner.so LoadModule authz_groupfile_module modules/mod_authz_groupfile.so LoadModule authz_dbm_module modules/mod_authz_dbm.so LoadModule authz_default_module modules/mod_authz_default.so LoadModule ldap_module modules/mod_ldap.so LoadModule authnz_ldap_module modules/mod_authnz_ldap.so LoadModule include_module modules/mod_include.so LoadModule log_config_module modules/mod_log_config.so LoadModule logio_module modules/mod_logio.so LoadModule env_module modules/mod_env.so LoadModule ext_filter_module modules/mod_ext_filter.so LoadModule mime_magic_module modules/mod_mime_magic.so LoadModule expires_module modules/mod_expires.so LoadModule deflate_module modules/mod_deflate.so LoadModule headers_module modules/mod_headers.so LoadModule usertrack_module modules/mod_usertrack.so LoadModule setenvif_module modules/mod_setenvif.so LoadModule mime_module modules/mod_mime.so LoadModule dav_module modules/mod_dav.so LoadModule status_module modules/mod_status.so LoadModule autoindex_module modules/mod_autoindex.so LoadModule info_module modules/mod_info.so LoadModule dav_fs_module modules/mod_dav_fs.so LoadModule vhost_alias_module modules/mod_vhost_alias.so LoadModule negotiation_module modules/mod_negotiation.so LoadModule dir_module modules/mod_dir.so LoadModule actions_module modules/mod_actions.so LoadModule speling_module modules/mod_speling.so LoadModule userdir_module modules/mod_userdir.so LoadModule alias_module modules/mod_alias.so LoadModule substitute_module modules/mod_substitute.so LoadModule rewrite_module modules/mod_rewrite.so LoadModule proxy_module modules/mod_proxy.so LoadModule proxy_balancer_module modules/mod_proxy_balancer.so LoadModule proxy_ftp_module modules/mod_proxy_ftp.so LoadModule proxy_http_module modules/mod_proxy_http.so LoadModule proxy_ajp_module modules/mod_proxy_ajp.so LoadModule proxy_connect_module modules/mod_proxy_connect.so LoadModule cache_module modules/mod_cache.so LoadModule suexec_module modules/mod_suexec.so LoadModule disk_cache_module modules/mod_disk_cache.so LoadModule cgi_module modules/mod_cgi.so LoadModule version_module modules/mod_version.so # # The following modules are not loaded by default: # #LoadModule asis_module modules/mod_asis.so #LoadModule authn_dbd_module modules/mod_authn_dbd.so #LoadModule cern_meta_module modules/mod_cern_meta.so #LoadModule cgid_module modules/mod_cgid.so #LoadModule dbd_module modules/mod_dbd.so #LoadModule dumpio_module modules/mod_dumpio.so #LoadModule filter_module modules/mod_filter.so #LoadModule ident_module modules/mod_ident.so #LoadModule log_forensic_module modules/mod_log_forensic.so #LoadModule unique_id_module modules/mod_unique_id.so # # # Load config files from the config directory "/etc/httpd/conf.d". # Include conf.d/*.conf # # ExtendedStatus controls whether Apache will generate "full" status # information (ExtendedStatus On) or just basic information (ExtendedStatus # Off) when the "server-status" handler is called. The default is Off. # #ExtendedStatus On # # If you wish httpd to run as a different user or group, you must run # httpd as root initially and it will switch. # # User/Group: The name (or #number) of the user/group to run httpd as. # . On SCO (ODT 3) use "User nouser" and "Group nogroup". # . On HPUX you may not be able to use shared memory as nobody, and the # suggested workaround is to create a user www and use that user. # NOTE that some kernels refuse to setgid(Group) or semctl(IPC_SET) # when the value of (unsigned)Group is above 60000; # don't use Group #-1 on these systems! # User apache Group apache ### Section 2: 'Main' server configuration # # The directives in this section set up the values used by the 'main' # server, which responds to any requests that aren't handled by a # definition. These values also provide defaults for # any containers you may define later in the file. # # All of these directives may appear inside containers, # in which case these default settings will be overridden for the # virtual host being defined. # # # ServerAdmin: Your address, where problems with the server should be # e-mailed. This address appears on some server-generated pages, such # as error documents. e.g. admin@your-domain.com # ServerAdmin root@localhost # # ServerName gives the name and port that the server uses to identify itself. # This can often be determined automatically, but we recommend you specify # it explicitly to prevent problems during startup. # # If this is not set to valid DNS name for your host, server-generated # redirections will not work. See also the UseCanonicalName directive. # # If your host doesn't have a registered DNS name, enter its IP address here. # You will have to access it by its address anyway, and this will make # redirections work in a sensible way. # #ServerName www.example.com:80 # # UseCanonicalName: Determines how Apache constructs self-referencing # URLs and the SERVER_NAME and SERVER_PORT variables. # When set "Off", Apache will use the Hostname and Port supplied # by the client. When set "On", Apache will use the value of the # ServerName directive. # UseCanonicalName Off # # DocumentRoot: The directory out of which you will serve your # documents. By default, all requests are taken from this directory, but # symbolic links and aliases may be used to point to other locations. # DocumentRoot "/var/www/html" # # Each directory to which Apache has access can be configured with respect # to which services and features are allowed and/or disabled in that # directory (and its subdirectories). # # First, we configure the "default" to be a very restrictive set of # features. # Options FollowSymLinks AllowOverride None # # Note that from this point forward you must specifically allow # particular features to be enabled - so if something's not working as # you might expect, make sure that you have specifically enabled it # below. # # # This should be changed to whatever you set DocumentRoot to. # # # Possible values for the Options directive are "None", "All", # or any combination of: # Indexes Includes FollowSymLinks SymLinksifOwnerMatch ExecCGI MultiViews # # Note that "MultiViews" must be named *explicitly* --- "Options All" # doesn't give it to you. # # The Options directive is both complicated and important. Please see # http://httpd.apache.org/docs/2.2/mod/core.html#options # for more information. # Options Indexes FollowSymLinks # # AllowOverride controls what directives may be placed in .htaccess files. # It can be "All", "None", or any combination of the keywords: # Options FileInfo AuthConfig Limit # AllowOverride None # # Controls who can get stuff from this server. # Order allow,deny Allow from all # # UserDir: The name of the directory that is appended onto a user's home # directory if a ~user request is received. # # The path to the end user account 'public_html' directory must be # accessible to the webserver userid. This usually means that ~userid # must have permissions of 711, ~userid/public_html must have permissions # of 755, and documents contained therein must be world-readable. # Otherwise, the client will only receive a "403 Forbidden" message. # # See also: http://httpd.apache.org/docs/misc/FAQ.html#forbidden # # # UserDir is disabled by default since it can confirm the presence # of a username on the system (depending on home directory # permissions). # UserDir disabled # # To enable requests to /~user/ to serve the user's public_html # directory, remove the "UserDir disabled" line above, and uncomment # the following line instead: # #UserDir public_html # # Control access to UserDir directories. The following is an example # for a site where these directories are restricted to read-only. # # # AllowOverride FileInfo AuthConfig Limit # Options MultiViews Indexes SymLinksIfOwnerMatch IncludesNoExec # # Order allow,deny # Allow from all # # # Order deny,allow # Deny from all # # # # DirectoryIndex: sets the file that Apache will serve if a directory # is requested. # # The index.html.var file (a type-map) is used to deliver content- # negotiated documents. The MultiViews Option can be used for the # same purpose, but it is much slower. # DirectoryIndex index.html index.html.var # # AccessFileName: The name of the file to look for in each directory # for additional configuration directives. See also the AllowOverride # directive. # AccessFileName .htaccess # # The following lines prevent .htaccess and .htpasswd files from being # viewed by Web clients. # Order allow,deny Deny from all Satisfy All # # TypesConfig describes where the mime.types file (or equivalent) is # to be found. # TypesConfig /etc/mime.types # # DefaultType is the default MIME type the server will use for a document # if it cannot otherwise determine one, such as from filename extensions. # If your server contains mostly text or HTML documents, "text/plain" is # a good value. If most of your content is binary, such as applications # or images, you may want to use "application/octet-stream" instead to # keep browsers from trying to display binary files as though they are # text. # DefaultType text/plain # # The mod_mime_magic module allows the server to use various hints from the # contents of the file itself to determine its type. The MIMEMagicFile # directive tells the module where the hint definitions are located. # # MIMEMagicFile /usr/share/magic.mime MIMEMagicFile conf/magic # # HostnameLookups: Log the names of clients or just their IP addresses # e.g., www.apache.org (on) or 204.62.129.132 (off). # The default is off because it'd be overall better for the net if people # had to knowingly turn this feature on, since enabling it means that # each client request will result in AT LEAST one lookup request to the # nameserver. # HostnameLookups Off # # EnableMMAP: Control whether memory-mapping is used to deliver # files (assuming that the underlying OS supports it). # The default is on; turn this off if you serve from NFS-mounted # filesystems. On some systems, turning it off (regardless of # filesystem) can improve performance; for details, please see # http://httpd.apache.org/docs/2.2/mod/core.html#enablemmap # #EnableMMAP off # # EnableSendfile: Control whether the sendfile kernel support is # used to deliver files (assuming that the OS supports it). # The default is on; turn this off if you serve from NFS-mounted # filesystems. Please see # http://httpd.apache.org/docs/2.2/mod/core.html#enablesendfile # #EnableSendfile off # # ErrorLog: The location of the error log file. # If you do not specify an ErrorLog directive within a # container, error messages relating to that virtual host will be # logged here. If you *do* define an error logfile for a # container, that host's errors will be logged there and not here. # ErrorLog logs/error_log # # LogLevel: Control the number of messages logged to the error_log. # Possible values include: debug, info, notice, warn, error, crit, # alert, emerg. # LogLevel warn # # The following directives define some format nicknames for use with # a CustomLog directive (see below). # LogFormat "%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\"" combined LogFormat "%h %l %u %t \"%r\" %>s %b" common LogFormat "%{Referer}i -> %U" referer LogFormat "%{User-agent}i" agent # "combinedio" includes actual counts of actual bytes received (%I) and sent (%O); this # requires the mod_logio module to be loaded. #LogFormat "%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\" %I %O" combinedio # # The location and format of the access logfile (Common Logfile Format). # If you do not define any access logfiles within a # container, they will be logged here. Contrariwise, if you *do* # define per- access logfiles, transactions will be # logged therein and *not* in this file. # #CustomLog logs/access_log common # # If you would like to have separate agent and referer logfiles, uncomment # the following directives. # #CustomLog logs/referer_log referer #CustomLog logs/agent_log agent # # For a single logfile with access, agent, and referer information # (Combined Logfile Format), use the following directive: # CustomLog logs/access_log combined # # Optionally add a line containing the server version and virtual host # name to server-generated pages (internal error documents, FTP directory # listings, mod_status and mod_info output etc., but not CGI generated # documents or custom error documents). # Set to "EMail" to also include a mailto: link to the ServerAdmin. # Set to one of: On | Off | EMail # ServerSignature On # # Aliases: Add here as many aliases as you need (with no limit). The format is # Alias fakename realname # # Note that if you include a trailing / on fakename then the server will # require it to be present in the URL. So "/icons" isn't aliased in this # example, only "/icons/". If the fakename is slash-terminated, then the # realname must also be slash terminated, and if the fakename omits the # trailing slash, the realname must also omit it. # # We include the /icons/ alias for FancyIndexed directory listings. If you # do not use FancyIndexing, you may comment this out. # Alias /icons/ "/var/www/icons/" Options Indexes MultiViews FollowSymLinks AllowOverride None Order allow,deny Allow from all # # WebDAV module configuration section. # # Location of the WebDAV lock database. DAVLockDB /var/lib/dav/lockdb # # ScriptAlias: This controls which directories contain server scripts. # ScriptAliases are essentially the same as Aliases, except that # documents in the realname directory are treated as applications and # run by the server when requested rather than as documents sent to the client. # The same rules about trailing "/" apply to ScriptAlias directives as to # Alias. # ScriptAlias /cgi-bin/ "/var/www/cgi-bin/" # # "/var/www/cgi-bin" should be changed to whatever your ScriptAliased # CGI directory exists, if you have that configured. # AllowOverride None Options None Order allow,deny Allow from all # # Redirect allows you to tell clients about documents which used to exist in # your server's namespace, but do not anymore. This allows you to tell the # clients where to look for the relocated document. # Example: # Redirect permanent /foo http://www.example.com/bar # # Directives controlling the display of server-generated directory listings. # # # IndexOptions: Controls the appearance of server-generated directory # listings. # IndexOptions FancyIndexing VersionSort NameWidth=* HTMLTable Charset=UTF-8 # # AddIcon* directives tell the server which icon to show for different # files or filename extensions. These are only displayed for # FancyIndexed directories. # AddIconByEncoding (CMP,/icons/compressed.gif) x-compress x-gzip AddIconByType (TXT,/icons/text.gif) text/* AddIconByType (IMG,/icons/image2.gif) image/* AddIconByType (SND,/icons/sound2.gif) audio/* AddIconByType (VID,/icons/movie.gif) video/* AddIcon /icons/binary.gif .bin .exe AddIcon /icons/binhex.gif .hqx AddIcon /icons/tar.gif .tar AddIcon /icons/world2.gif .wrl .wrl.gz .vrml .vrm .iv AddIcon /icons/compressed.gif .Z .z .tgz .gz .zip AddIcon /icons/a.gif .ps .ai .eps AddIcon /icons/layout.gif .html .shtml .htm .pdf AddIcon /icons/text.gif .txt AddIcon /icons/c.gif .c AddIcon /icons/p.gif .pl .py AddIcon /icons/f.gif .for AddIcon /icons/dvi.gif .dvi AddIcon /icons/uuencoded.gif .uu AddIcon /icons/script.gif .conf .sh .shar .csh .ksh .tcl AddIcon /icons/tex.gif .tex AddIcon /icons/bomb.gif /core AddIcon /icons/back.gif .. AddIcon /icons/hand.right.gif README AddIcon /icons/folder.gif ^^DIRECTORY^^ AddIcon /icons/blank.gif ^^BLANKICON^^ # # DefaultIcon is which icon to show for files which do not have an icon # explicitly set. # DefaultIcon /icons/unknown.gif # # AddDescription allows you to place a short description after a file in # server-generated indexes. These are only displayed for FancyIndexed # directories. # Format: AddDescription "description" filename # #AddDescription "GZIP compressed document" .gz #AddDescription "tar archive" .tar #AddDescription "GZIP compressed tar archive" .tgz # # ReadmeName is the name of the README file the server will look for by # default, and append to directory listings. # # HeaderName is the name of a file which should be prepended to # directory indexes. ReadmeName README.html HeaderName HEADER.html # # IndexIgnore is a set of filenames which directory indexing should ignore # and not include in the listing. Shell-style wildcarding is permitted. # IndexIgnore .??* *~ *# HEADER* README* RCS CVS *,v *,t # # DefaultLanguage and AddLanguage allows you to specify the language of # a document. You can then use content negotiation to give a browser a # file in a language the user can understand. # # Specify a default language. This means that all data # going out without a specific language tag (see below) will # be marked with this one. You probably do NOT want to set # this unless you are sure it is correct for all cases. # # * It is generally better to not mark a page as # * being a certain language than marking it with the wrong # * language! # # DefaultLanguage nl # # Note 1: The suffix does not have to be the same as the language # keyword --- those with documents in Polish (whose net-standard # language code is pl) may wish to use "AddLanguage pl .po" to # avoid the ambiguity with the common suffix for perl scripts. # # Note 2: The example entries below illustrate that in some cases # the two character 'Language' abbreviation is not identical to # the two character 'Country' code for its country, # E.g. 'Danmark/dk' versus 'Danish/da'. # # Note 3: In the case of 'ltz' we violate the RFC by using a three char # specifier. There is 'work in progress' to fix this and get # the reference data for rfc1766 cleaned up. # # Catalan (ca) - Croatian (hr) - Czech (cs) - Danish (da) - Dutch (nl) # English (en) - Esperanto (eo) - Estonian (et) - French (fr) - German (de) # Greek-Modern (el) - Hebrew (he) - Italian (it) - Japanese (ja) # Korean (ko) - Luxembourgeois* (ltz) - Norwegian Nynorsk (nn) # Norwegian (no) - Polish (pl) - Portuguese (pt) # Brazilian Portuguese (pt-BR) - Russian (ru) - Swedish (sv) # Simplified Chinese (zh-CN) - Spanish (es) - Traditional Chinese (zh-TW) # AddLanguage ca .ca AddLanguage cs .cz .cs AddLanguage da .dk AddLanguage de .de AddLanguage el .el AddLanguage en .en AddLanguage eo .eo AddLanguage es .es AddLanguage et .et AddLanguage fr .fr AddLanguage he .he AddLanguage hr .hr AddLanguage it .it AddLanguage ja .ja AddLanguage ko .ko AddLanguage ltz .ltz AddLanguage nl .nl AddLanguage nn .nn AddLanguage no .no AddLanguage pl .po AddLanguage pt .pt AddLanguage pt-BR .pt-br AddLanguage ru .ru AddLanguage sv .sv AddLanguage zh-CN .zh-cn AddLanguage zh-TW .zh-tw # # LanguagePriority allows you to give precedence to some languages # in case of a tie during content negotiation. # # Just list the languages in decreasing order of preference. We have # more or less alphabetized them here. You probably want to change this. # LanguagePriority en ca cs da de el eo es et fr he hr it ja ko ltz nl nn no pl pt pt-BR ru sv zh-CN zh-TW # # ForceLanguagePriority allows you to serve a result page rather than # MULTIPLE CHOICES (Prefer) [in case of a tie] or NOT ACCEPTABLE (Fallback) # [in case no accepted languages matched the available variants] # ForceLanguagePriority Prefer Fallback # # Specify a default charset for all content served; this enables # interpretation of all content as UTF-8 by default. To use the # default browser choice (ISO-8859-1), or to allow the META tags # in HTML content to override this choice, comment out this # directive: # AddDefaultCharset UTF-8 # # AddType allows you to add to or override the MIME configuration # file mime.types for specific file types. # #AddType application/x-tar .tgz # # AddEncoding allows you to have certain browsers uncompress # information on the fly. Note: Not all browsers support this. # Despite the name similarity, the following Add* directives have nothing # to do with the FancyIndexing customization directives above. # #AddEncoding x-compress .Z #AddEncoding x-gzip .gz .tgz # If the AddEncoding directives above are commented-out, then you # probably should define those extensions to indicate media types: # AddType application/x-compress .Z AddType application/x-gzip .gz .tgz # # MIME-types for downloading Certificates and CRLs # AddType application/x-x509-ca-cert .crt AddType application/x-pkcs7-crl .crl # # AddHandler allows you to map certain file extensions to "handlers": # actions unrelated to filetype. These can be either built into the server # or added with the Action directive (see below) # # To use CGI scripts outside of ScriptAliased directories: # (You will also need to add "ExecCGI" to the "Options" directive.) # #AddHandler cgi-script .cgi # # For files that include their own HTTP headers: # #AddHandler send-as-is asis # # For type maps (negotiated resources): # (This is enabled by default to allow the Apache "It Worked" page # to be distributed in multiple languages.) # AddHandler type-map var # # Filters allow you to process content before it is sent to the client. # # To parse .shtml files for server-side includes (SSI): # (You will also need to add "Includes" to the "Options" directive.) # AddType text/html .shtml AddOutputFilter INCLUDES .shtml # # Action lets you define media types that will execute a script whenever # a matching file is called. This eliminates the need for repeated URL # pathnames for oft-used CGI file processors. # Format: Action media/type /cgi-script/location # Format: Action handler-name /cgi-script/location # # # Customizable error responses come in three flavors: # 1) plain text 2) local redirects 3) external redirects # # Some examples: #ErrorDocument 500 "The server made a boo boo." #ErrorDocument 404 /missing.html #ErrorDocument 404 "/cgi-bin/missing_handler.pl" #ErrorDocument 402 http://www.example.com/subscription_info.html # # # Putting this all together, we can internationalize error responses. # # We use Alias to redirect any /error/HTTP_.html.var response to # our collection of by-error message multi-language collections. We use # includes to substitute the appropriate text. # # You can modify the messages' appearance without changing any of the # default HTTP_.html.var files by adding the line: # # Alias /error/include/ "/your/include/path/" # # which allows you to create your own set of files by starting with the # /var/www/error/include/ files and # copying them to /your/include/path/, even on a per-VirtualHost basis. # Alias /error/ "/var/www/error/" AllowOverride None Options IncludesNoExec AddOutputFilter Includes html AddHandler type-map var Order allow,deny Allow from all LanguagePriority en es de fr ForceLanguagePriority Prefer Fallback # ErrorDocument 400 /error/HTTP_BAD_REQUEST.html.var # ErrorDocument 401 /error/HTTP_UNAUTHORIZED.html.var # ErrorDocument 403 /error/HTTP_FORBIDDEN.html.var # ErrorDocument 404 /error/HTTP_NOT_FOUND.html.var # ErrorDocument 405 /error/HTTP_METHOD_NOT_ALLOWED.html.var # ErrorDocument 408 /error/HTTP_REQUEST_TIME_OUT.html.var # ErrorDocument 410 /error/HTTP_GONE.html.var # ErrorDocument 411 /error/HTTP_LENGTH_REQUIRED.html.var # ErrorDocument 412 /error/HTTP_PRECONDITION_FAILED.html.var # ErrorDocument 413 /error/HTTP_REQUEST_ENTITY_TOO_LARGE.html.var # ErrorDocument 414 /error/HTTP_REQUEST_URI_TOO_LARGE.html.var # ErrorDocument 415 /error/HTTP_UNSUPPORTED_MEDIA_TYPE.html.var # ErrorDocument 500 /error/HTTP_INTERNAL_SERVER_ERROR.html.var # ErrorDocument 501 /error/HTTP_NOT_IMPLEMENTED.html.var # ErrorDocument 502 /error/HTTP_BAD_GATEWAY.html.var # ErrorDocument 503 /error/HTTP_SERVICE_UNAVAILABLE.html.var # ErrorDocument 506 /error/HTTP_VARIANT_ALSO_VARIES.html.var # # The following directives modify normal HTTP response behavior to # handle known problems with browser implementations. # BrowserMatch "Mozilla/2" nokeepalive BrowserMatch "MSIE 4\.0b2;" nokeepalive downgrade-1.0 force-response-1.0 BrowserMatch "RealPlayer 4\.0" force-response-1.0 BrowserMatch "Java/1\.0" force-response-1.0 BrowserMatch "JDK/1\.0" force-response-1.0 # # The following directive disables redirects on non-GET requests for # a directory that does not include the trailing slash. This fixes a # problem with Microsoft WebFolders which does not appropriately handle # redirects for folders with DAV methods. # Same deal with Apple's DAV filesystem and Gnome VFS support for DAV. # BrowserMatch "Microsoft Data Access Internet Publishing Provider" redirect-carefully BrowserMatch "MS FrontPage" redirect-carefully BrowserMatch "^WebDrive" redirect-carefully BrowserMatch "^WebDAVFS/1.[0123]" redirect-carefully BrowserMatch "^gnome-vfs/1.0" redirect-carefully BrowserMatch "^XML Spy" redirect-carefully BrowserMatch "^Dreamweaver-WebDAV-SCM1" redirect-carefully # # Allow server status reports generated by mod_status, # with the URL of http://servername/server-status # Change the ".example.com" to match your domain to enable. # # # SetHandler server-status # Order deny,allow # Deny from all # Allow from .example.com # # # Allow remote server configuration reports, with the URL of # http://servername/server-info (requires that mod_info.c be loaded). # Change the ".example.com" to match your domain to enable. # # # SetHandler server-info # Order deny,allow # Deny from all # Allow from .example.com # # # Proxy Server directives. Uncomment the following lines to # enable the proxy server: # # #ProxyRequests On # # # Order deny,allow # Deny from all # Allow from .example.com # # # Enable/disable the handling of HTTP/1.1 "Via:" headers. # ("Full" adds the server version; "Block" removes all outgoing Via: headers) # Set to one of: Off | On | Full | Block # #ProxyVia On # # To enable a cache of proxied content, uncomment the following lines. # See http://httpd.apache.org/docs/2.2/mod/mod_cache.html for more details. # # # CacheEnable disk / # CacheRoot "/var/cache/mod_proxy" # # # # End of proxy directives. ### Section 3: Virtual Hosts # # VirtualHost: If you want to maintain multiple domains/hostnames on your # machine you can setup VirtualHost containers for them. Most configurations # use only name-based virtual hosts so the server doesn't need to worry about # IP addresses. This is indicated by the asterisks in the directives below. # # Please see the documentation at # # for further details before you try to setup virtual hosts. # # You may use the command line option '-S' to verify your virtual host # configuration. # # Use name-based virtual hosting. # #NameVirtualHost *:80 # # NOTE: NameVirtualHost cannot be used without a port specifier # (e.g. :80) if mod_ssl is being used, due to the nature of the # SSL protocol. # # # VirtualHost example: # Almost any Apache directive may go into a VirtualHost container. # The first VirtualHost section is used for requests without a known # server name. # # # ServerAdmin webmaster@dummy-host.example.com # DocumentRoot /www/docs/dummy-host.example.com # ServerName dummy-host.example.com # ErrorLog logs/dummy-host.example.com-error_log # CustomLog logs/dummy-host.example.com-access_log common # ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.8021789 certbot-apache-1.21.0/tests/testdata/centos6_apache/apache/httpd/conf.d/0000755000076500000240000000000000000000000024475 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/centos6_apache/apache/httpd/conf.d/README0000644000076500000240000000061000000000000025352 0ustar00bmwstaff This directory holds Apache 2.0 module-specific configuration files; any files in this directory which have the ".conf" extension will be processed as Apache configuration files. Files are processed in alphabetical order, so if using configuration directives which depend on, say, mod_perl being loaded, ensure that these are placed in a filename later in the sort order than "perl.conf". ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/centos6_apache/apache/httpd/conf.d/ssl.conf0000644000076500000240000002237200000000000026153 0ustar00bmwstaff# # This is the Apache server configuration file providing SSL support. # It contains the configuration directives to instruct the server how to # serve pages over an https connection. For detailing information about these # directives see # # Do NOT simply read the instructions in here without understanding # what they do. They're here only as hints or reminders. If you are unsure # consult the online docs. You have been warned. # LoadModule ssl_module modules/mod_ssl.so # # When we also provide SSL we have to listen to the # the HTTPS port in addition. # Listen 443 ## ## SSL Global Context ## ## All SSL configuration in this context applies both to ## the main server and all SSL-enabled virtual hosts. ## # Pass Phrase Dialog: # Configure the pass phrase gathering process. # The filtering dialog program (`builtin' is an internal # terminal dialog) has to provide the pass phrase on stdout. SSLPassPhraseDialog builtin # Inter-Process Session Cache: # Configure the SSL Session Cache: First the mechanism # to use and second the expiring timeout (in seconds). SSLSessionCache shmcb:/var/cache/mod_ssl/scache(512000) SSLSessionCacheTimeout 300 # Semaphore: # Configure the path to the mutual exclusion semaphore the # SSL engine uses internally for inter-process synchronization. SSLMutex default # Pseudo Random Number Generator (PRNG): # Configure one or more sources to seed the PRNG of the # SSL library. The seed data should be of good random quality. # WARNING! On some platforms /dev/random blocks if not enough entropy # is available. This means you then cannot use the /dev/random device # because it would lead to very long connection times (as long as # it requires to make more entropy available). But usually those # platforms additionally provide a /dev/urandom device which doesn't # block. So, if available, use this one instead. Read the mod_ssl User # Manual for more details. SSLRandomSeed startup file:/dev/urandom 256 SSLRandomSeed connect builtin #SSLRandomSeed startup file:/dev/random 512 #SSLRandomSeed connect file:/dev/random 512 #SSLRandomSeed connect file:/dev/urandom 512 # # Use "SSLCryptoDevice" to enable any supported hardware # accelerators. Use "openssl engine -v" to list supported # engine names. NOTE: If you enable an accelerator and the # server does not start, consult the error logs and ensure # your accelerator is functioning properly. # SSLCryptoDevice builtin #SSLCryptoDevice ubsec ## ## SSL Virtual Host Context ## # General setup for the virtual host, inherited from global configuration #DocumentRoot "/var/www/html" #ServerName www.example.com:443 # Use separate log files for the SSL virtual host; note that LogLevel # is not inherited from httpd.conf. ErrorLog logs/ssl_error_log TransferLog logs/ssl_access_log LogLevel warn # SSL Engine Switch: # Enable/Disable SSL for this virtual host. SSLEngine on # SSL Protocol support: # List the enable protocol levels with which clients will be able to # connect. Disable SSLv2 access by default: SSLProtocol all -SSLv2 # SSL Cipher Suite: # List the ciphers that the client is permitted to negotiate. # See the mod_ssl documentation for a complete list. SSLCipherSuite DEFAULT:!EXP:!SSLv2:!DES:!IDEA:!SEED:+3DES # Server Certificate: # Point SSLCertificateFile at a PEM encoded certificate. If # the certificate is encrypted, then you will be prompted for a # pass phrase. Note that a kill -HUP will prompt again. A new # certificate can be generated using the genkey(1) command. SSLCertificateFile /etc/pki/tls/certs/localhost.crt # Server Private Key: # If the key is not combined with the certificate, use this # directive to point at the key file. Keep in mind that if # you've both a RSA and a DSA private key you can configure # both in parallel (to also allow the use of DSA ciphers, etc.) SSLCertificateKeyFile /etc/pki/tls/private/localhost.key # Server Certificate Chain: # Point SSLCertificateChainFile at a file containing the # concatenation of PEM encoded CA certificates which form the # certificate chain for the server certificate. Alternatively # the referenced file can be the same as SSLCertificateFile # when the CA certificates are directly appended to the server # certificate for convinience. #SSLCertificateChainFile /etc/pki/tls/certs/server-chain.crt # Certificate Authority (CA): # Set the CA certificate verification path where to find CA # certificates for client authentication or alternatively one # huge file containing all of them (file must be PEM encoded) #SSLCACertificateFile /etc/pki/tls/certs/ca-bundle.crt # Client Authentication (Type): # Client certificate verification type and depth. Types are # none, optional, require and optional_no_ca. Depth is a # number which specifies how deeply to verify the certificate # issuer chain before deciding the certificate is not valid. #SSLVerifyClient require #SSLVerifyDepth 10 # Access Control: # With SSLRequire you can do per-directory access control based # on arbitrary complex boolean expressions containing server # variable checks and other lookup directives. The syntax is a # mixture between C and Perl. See the mod_ssl documentation # for more details. # #SSLRequire ( %{SSL_CIPHER} !~ m/^(EXP|NULL)/ \ # and %{SSL_CLIENT_S_DN_O} eq "Snake Oil, Ltd." \ # and %{SSL_CLIENT_S_DN_OU} in {"Staff", "CA", "Dev"} \ # and %{TIME_WDAY} >= 1 and %{TIME_WDAY} <= 5 \ # and %{TIME_HOUR} >= 8 and %{TIME_HOUR} <= 20 ) \ # or %{REMOTE_ADDR} =~ m/^192\.76\.162\.[0-9]+$/ # # SSL Engine Options: # Set various options for the SSL engine. # o FakeBasicAuth: # Translate the client X.509 into a Basic Authorisation. This means that # the standard Auth/DBMAuth methods can be used for access control. The # user name is the `one line' version of the client's X.509 certificate. # Note that no password is obtained from the user. Every entry in the user # file needs this password: `xxj31ZMTZzkVA'. # o ExportCertData: # This exports two additional environment variables: SSL_CLIENT_CERT and # SSL_SERVER_CERT. These contain the PEM-encoded certificates of the # server (always existing) and the client (only existing when client # authentication is used). This can be used to import the certificates # into CGI scripts. # o StdEnvVars: # This exports the standard SSL/TLS related `SSL_*' environment variables. # Per default this exportation is switched off for performance reasons, # because the extraction step is an expensive operation and is usually # useless for serving static content. So one usually enables the # exportation for CGI and SSI requests only. # o StrictRequire: # This denies access when "SSLRequireSSL" or "SSLRequire" applied even # under a "Satisfy any" situation, i.e. when it applies access is denied # and no other module can change it. # o OptRenegotiate: # This enables optimized SSL connection renegotiation handling when SSL # directives are used in per-directory context. #SSLOptions +FakeBasicAuth +ExportCertData +StrictRequire SSLOptions +StdEnvVars SSLOptions +StdEnvVars # SSL Protocol Adjustments: # The safe and default but still SSL/TLS standard compliant shutdown # approach is that mod_ssl sends the close notify alert but doesn't wait for # the close notify alert from client. When you need a different shutdown # approach you can use one of the following variables: # o ssl-unclean-shutdown: # This forces an unclean shutdown when the connection is closed, i.e. no # SSL close notify alert is send or allowed to received. This violates # the SSL/TLS standard but is needed for some brain-dead browsers. Use # this when you receive I/O errors because of the standard approach where # mod_ssl sends the close notify alert. # o ssl-accurate-shutdown: # This forces an accurate shutdown when the connection is closed, i.e. a # SSL close notify alert is send and mod_ssl waits for the close notify # alert of the client. This is 100% SSL/TLS standard compliant, but in # practice often causes hanging connections with brain-dead browsers. Use # this only for browsers where you know that their SSL implementation # works correctly. # Notice: Most problems of broken clients are also related to the HTTP # keep-alive facility, so you usually additionally want to disable # keep-alive for those clients, too. Use variable "nokeepalive" for this. # Similarly, one has to force some clients to use HTTP/1.0 to workaround # their broken HTTP/1.1 implementation. Use variables "downgrade-1.0" and # "force-response-1.0" for this. SetEnvIf User-Agent ".*MSIE.*" \ nokeepalive ssl-unclean-shutdown \ downgrade-1.0 force-response-1.0 # Per-Server Logging: # The home of a custom SSL log file. Use this when you want a # compact non-error SSL logfile on a virtual host basis. CustomLog logs/ssl_request_log \ "%t %h %{SSL_PROTOCOL}x %{SSL_CIPHER}x \"%r\" %b" ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/centos6_apache/apache/httpd/conf.d/test.example.com.conf0000644000076500000240000000040300000000000030527 0ustar00bmwstaff ServerName test.example.com ServerAdmin webmaster@dummy-host.example.com DocumentRoot /var/www/htdocs ErrorLog logs/dummy-host.example.com-error_log CustomLog logs/dummy-host.example.com-access_log common ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/centos6_apache/apache/httpd/conf.d/welcome.conf0000644000076500000240000000045300000000000027001 0ustar00bmwstaff# # This configuration file enables the default "Welcome" # page if there is no default index page present for # the root URL. To disable the Welcome page, comment # out all the lines below. # Options -Indexes ErrorDocument 403 /error/noindex.html ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.7876382 certbot-apache-1.21.0/tests/testdata/centos7_apache/0000755000076500000240000000000000000000000020763 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.8022847 certbot-apache-1.21.0/tests/testdata/centos7_apache/apache/0000755000076500000240000000000000000000000022204 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.7879474 certbot-apache-1.21.0/tests/testdata/centos7_apache/apache/httpd/0000755000076500000240000000000000000000000023327 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1635888463.802509 certbot-apache-1.21.0/tests/testdata/centos7_apache/apache/httpd/conf/0000755000076500000240000000000000000000000024254 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/centos7_apache/apache/httpd/conf/httpd.conf0000644000076500000240000002675100000000000026261 0ustar00bmwstaff# # This is the main Apache HTTP server configuration file. It contains the # configuration directives that give the server its instructions. # See for detailed information. # In particular, see # # for a discussion of each configuration directive. # # Do NOT simply read the instructions in here without understanding # what they do. They're here only as hints or reminders. If you are unsure # consult the online docs. You have been warned. # # Configuration and logfile names: If the filenames you specify for many # of the server's control files begin with "/" (or "drive:/" for Win32), the # server will use that explicit path. If the filenames do *not* begin # with "/", the value of ServerRoot is prepended -- so 'log/access_log' # with ServerRoot set to '/www' will be interpreted by the # server as '/www/log/access_log', where as '/log/access_log' will be # interpreted as '/log/access_log'. # # ServerRoot: The top of the directory tree under which the server's # configuration, error, and log files are kept. # # Do not add a slash at the end of the directory path. If you point # ServerRoot at a non-local disk, be sure to specify a local disk on the # Mutex directive, if file-based mutexes are used. If you wish to share the # same ServerRoot for multiple httpd daemons, you will need to change at # least PidFile. # ServerRoot "/etc/httpd" # # Listen: Allows you to bind Apache to specific IP addresses and/or # ports, instead of the default. See also the # directive. # # Change this to Listen on specific IP addresses as shown below to # prevent Apache from glomming onto all bound IP addresses. # #Listen 12.34.56.78:80 Listen 80 # # Dynamic Shared Object (DSO) Support # # To be able to use the functionality of a module which was built as a DSO you # have to place corresponding `LoadModule' lines at this location so the # directives contained in it are actually available _before_ they are used. # Statically compiled modules (those listed by `httpd -l') do not need # to be loaded here. # # Example: # LoadModule foo_module modules/mod_foo.so # Include conf.modules.d/*.conf # # If you wish httpd to run as a different user or group, you must run # httpd as root initially and it will switch. # # User/Group: The name (or #number) of the user/group to run httpd as. # It is usually good practice to create a dedicated user and group for # running httpd, as with most system services. # User apache Group apache # 'Main' server configuration # # The directives in this section set up the values used by the 'main' # server, which responds to any requests that aren't handled by a # definition. These values also provide defaults for # any containers you may define later in the file. # # All of these directives may appear inside containers, # in which case these default settings will be overridden for the # virtual host being defined. # # # ServerAdmin: Your address, where problems with the server should be # e-mailed. This address appears on some server-generated pages, such # as error documents. e.g. admin@your-domain.com # ServerAdmin root@localhost # # ServerName gives the name and port that the server uses to identify itself. # This can often be determined automatically, but we recommend you specify # it explicitly to prevent problems during startup. # # If your host doesn't have a registered DNS name, enter its IP address here. # #ServerName www.example.com:80 # # Deny access to the entirety of your server's filesystem. You must # explicitly permit access to web content directories in other # blocks below. # AllowOverride none Require all denied # # Note that from this point forward you must specifically allow # particular features to be enabled - so if something's not working as # you might expect, make sure that you have specifically enabled it # below. # # # DocumentRoot: The directory out of which you will serve your # documents. By default, all requests are taken from this directory, but # symbolic links and aliases may be used to point to other locations. # DocumentRoot "/var/www/html" # # Relax access to content within /var/www. # AllowOverride None # Allow open access: Require all granted # Further relax access to the default document root: # # Possible values for the Options directive are "None", "All", # or any combination of: # Indexes Includes FollowSymLinks SymLinksifOwnerMatch ExecCGI MultiViews # # Note that "MultiViews" must be named *explicitly* --- "Options All" # doesn't give it to you. # # The Options directive is both complicated and important. Please see # http://httpd.apache.org/docs/2.4/mod/core.html#options # for more information. # Options Indexes FollowSymLinks # # AllowOverride controls what directives may be placed in .htaccess files. # It can be "All", "None", or any combination of the keywords: # Options FileInfo AuthConfig Limit # AllowOverride None # # Controls who can get stuff from this server. # Require all granted # # DirectoryIndex: sets the file that Apache will serve if a directory # is requested. # DirectoryIndex index.html # # The following lines prevent .htaccess and .htpasswd files from being # viewed by Web clients. # Require all denied # # ErrorLog: The location of the error log file. # If you do not specify an ErrorLog directive within a # container, error messages relating to that virtual host will be # logged here. If you *do* define an error logfile for a # container, that host's errors will be logged there and not here. # ErrorLog "logs/error_log" # # LogLevel: Control the number of messages logged to the error_log. # Possible values include: debug, info, notice, warn, error, crit, # alert, emerg. # LogLevel warn # # The following directives define some format nicknames for use with # a CustomLog directive (see below). # LogFormat "%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\"" combined LogFormat "%h %l %u %t \"%r\" %>s %b" common # You need to enable mod_logio.c to use %I and %O LogFormat "%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\" %I %O" combinedio # # The location and format of the access logfile (Common Logfile Format). # If you do not define any access logfiles within a # container, they will be logged here. Contrariwise, if you *do* # define per- access logfiles, transactions will be # logged therein and *not* in this file. # #CustomLog "logs/access_log" common # # If you prefer a logfile with access, agent, and referer information # (Combined Logfile Format) you can use the following directive. # CustomLog "logs/access_log" combined # # Redirect: Allows you to tell clients about documents that used to # exist in your server's namespace, but do not anymore. The client # will make a new request for the document at its new location. # Example: # Redirect permanent /foo http://www.example.com/bar # # Alias: Maps web paths into filesystem paths and is used to # access content that does not live under the DocumentRoot. # Example: # Alias /webpath /full/filesystem/path # # If you include a trailing / on /webpath then the server will # require it to be present in the URL. You will also likely # need to provide a section to allow access to # the filesystem path. # # ScriptAlias: This controls which directories contain server scripts. # ScriptAliases are essentially the same as Aliases, except that # documents in the target directory are treated as applications and # run by the server when requested rather than as documents sent to the # client. The same rules about trailing "/" apply to ScriptAlias # directives as to Alias. # ScriptAlias /cgi-bin/ "/var/www/cgi-bin/" # # "/var/www/cgi-bin" should be changed to whatever your ScriptAliased # CGI directory exists, if you have that configured. # AllowOverride None Options None Require all granted # # TypesConfig points to the file containing the list of mappings from # filename extension to MIME-type. # TypesConfig /etc/mime.types # # AddType allows you to add to or override the MIME configuration # file specified in TypesConfig for specific file types. # #AddType application/x-gzip .tgz # # AddEncoding allows you to have certain browsers uncompress # information on the fly. Note: Not all browsers support this. # #AddEncoding x-compress .Z #AddEncoding x-gzip .gz .tgz # # If the AddEncoding directives above are commented-out, then you # probably should define those extensions to indicate media types: # AddType application/x-compress .Z AddType application/x-gzip .gz .tgz # # AddHandler allows you to map certain file extensions to "handlers": # actions unrelated to filetype. These can be either built into the server # or added with the Action directive (see below) # # To use CGI scripts outside of ScriptAliased directories: # (You will also need to add "ExecCGI" to the "Options" directive.) # #AddHandler cgi-script .cgi # For type maps (negotiated resources): #AddHandler type-map var # # Filters allow you to process content before it is sent to the client. # # To parse .shtml files for server-side includes (SSI): # (You will also need to add "Includes" to the "Options" directive.) # AddType text/html .shtml AddOutputFilter INCLUDES .shtml # # Specify a default charset for all content served; this enables # interpretation of all content as UTF-8 by default. To use the # default browser choice (ISO-8859-1), or to allow the META tags # in HTML content to override this choice, comment out this # directive: # AddDefaultCharset UTF-8 # # The mod_mime_magic module allows the server to use various hints from the # contents of the file itself to determine its type. The MIMEMagicFile # directive tells the module where the hint definitions are located. # MIMEMagicFile conf/magic # # Customizable error responses come in three flavors: # 1) plain text 2) local redirects 3) external redirects # # Some examples: #ErrorDocument 500 "The server made a boo boo." #ErrorDocument 404 /missing.html #ErrorDocument 404 "/cgi-bin/missing_handler.pl" #ErrorDocument 402 http://www.example.com/subscription_info.html # # # EnableMMAP and EnableSendfile: On systems that support it, # memory-mapping or the sendfile syscall may be used to deliver # files. This usually improves server performance, but must # be turned off when serving from networked-mounted # filesystems or if support for these functions is otherwise # broken on your system. # Defaults if commented: EnableMMAP On, EnableSendfile Off # #EnableMMAP off EnableSendfile on # Supplemental configuration # # Load config files in the "/etc/httpd/conf.d" directory, if any. IncludeOptional conf.d/*.conf ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/centos7_apache/apache/httpd/conf/magic0000644000076500000240000003142500000000000025264 0ustar00bmwstaff# Magic data for mod_mime_magic Apache module (originally for file(1) command) # The module is described in /manual/mod/mod_mime_magic.html # # The format is 4-5 columns: # Column #1: byte number to begin checking from, ">" indicates continuation # Column #2: type of data to match # Column #3: contents of data to match # Column #4: MIME type of result # Column #5: MIME encoding of result (optional) #------------------------------------------------------------------------------ # Localstuff: file(1) magic for locally observed files # Add any locally observed files here. #------------------------------------------------------------------------------ # end local stuff #------------------------------------------------------------------------------ #------------------------------------------------------------------------------ # Java 0 short 0xcafe >2 short 0xbabe application/java #------------------------------------------------------------------------------ # audio: file(1) magic for sound formats # # from Jan Nicolai Langfeldt , # # Sun/NeXT audio data 0 string .snd >12 belong 1 audio/basic >12 belong 2 audio/basic >12 belong 3 audio/basic >12 belong 4 audio/basic >12 belong 5 audio/basic >12 belong 6 audio/basic >12 belong 7 audio/basic >12 belong 23 audio/x-adpcm # DEC systems (e.g. DECstation 5000) use a variant of the Sun/NeXT format # that uses little-endian encoding and has a different magic number # (0x0064732E in little-endian encoding). 0 lelong 0x0064732E >12 lelong 1 audio/x-dec-basic >12 lelong 2 audio/x-dec-basic >12 lelong 3 audio/x-dec-basic >12 lelong 4 audio/x-dec-basic >12 lelong 5 audio/x-dec-basic >12 lelong 6 audio/x-dec-basic >12 lelong 7 audio/x-dec-basic # compressed (G.721 ADPCM) >12 lelong 23 audio/x-dec-adpcm # Bytes 0-3 of AIFF, AIFF-C, & 8SVX audio files are "FORM" # AIFF audio data 8 string AIFF audio/x-aiff # AIFF-C audio data 8 string AIFC audio/x-aiff # IFF/8SVX audio data 8 string 8SVX audio/x-aiff # Creative Labs AUDIO stuff # Standard MIDI data 0 string MThd audio/unknown #>9 byte >0 (format %d) #>11 byte >1 using %d channels # Creative Music (CMF) data 0 string CTMF audio/unknown # SoundBlaster instrument data 0 string SBI audio/unknown # Creative Labs voice data 0 string Creative\ Voice\ File audio/unknown ## is this next line right? it came this way... #>19 byte 0x1A #>23 byte >0 - version %d #>22 byte >0 \b.%d # [GRR 950115: is this also Creative Labs? Guessing that first line # should be string instead of unknown-endian long...] #0 long 0x4e54524b MultiTrack sound data #0 string NTRK MultiTrack sound data #>4 long x - version %ld # Microsoft WAVE format (*.wav) # [GRR 950115: probably all of the shorts and longs should be leshort/lelong] # Microsoft RIFF 0 string RIFF audio/unknown # - WAVE format >8 string WAVE audio/x-wav # MPEG audio. 0 beshort&0xfff0 0xfff0 audio/mpeg # C64 SID Music files, from Linus Walleij 0 string PSID audio/prs.sid #------------------------------------------------------------------------------ # c-lang: file(1) magic for C programs or various scripts # # XPM icons (Greg Roelofs, newt@uchicago.edu) # ideally should go into "images", but entries below would tag XPM as C source 0 string /*\ XPM image/x-xbm 7bit # this first will upset you if you're a PL/1 shop... (are there any left?) # in which case rm it; ascmagic will catch real C programs # C or REXX program text 0 string /* text/plain # C++ program text 0 string // text/plain #------------------------------------------------------------------------------ # compress: file(1) magic for pure-compression formats (no archives) # # compress, gzip, pack, compact, huf, squeeze, crunch, freeze, yabba, whap, etc. # # Formats for various forms of compressed data # Formats for "compress" proper have been moved into "compress.c", # because it tries to uncompress it to figure out what's inside. # standard unix compress 0 string \037\235 application/octet-stream x-compress # gzip (GNU zip, not to be confused with [Info-ZIP/PKWARE] zip archiver) 0 string \037\213 application/octet-stream x-gzip # According to gzip.h, this is the correct byte order for packed data. 0 string \037\036 application/octet-stream # # This magic number is byte-order-independent. # 0 short 017437 application/octet-stream # XXX - why *two* entries for "compacted data", one of which is # byte-order independent, and one of which is byte-order dependent? # # compacted data 0 short 0x1fff application/octet-stream 0 string \377\037 application/octet-stream # huf output 0 short 0145405 application/octet-stream # Squeeze and Crunch... # These numbers were gleaned from the Unix versions of the programs to # handle these formats. Note that I can only uncrunch, not crunch, and # I didn't have a crunched file handy, so the crunch number is untested. # Keith Waclena #0 leshort 0x76FF squeezed data (CP/M, DOS) #0 leshort 0x76FE crunched data (CP/M, DOS) # Freeze #0 string \037\237 Frozen file 2.1 #0 string \037\236 Frozen file 1.0 (or gzip 0.5) # lzh? #0 string \037\240 LZH compressed data #------------------------------------------------------------------------------ # frame: file(1) magic for FrameMaker files # # This stuff came on a FrameMaker demo tape, most of which is # copyright, but this file is "published" as witness the following: # 0 string \ # and Anna Shergold # 0 string \ 0 string \14 byte 12 (OS/2 1.x format) #>14 byte 64 (OS/2 2.x format) #>14 byte 40 (Windows 3.x format) #0 string IC icon #0 string PI pointer #0 string CI color icon #0 string CP color pointer #0 string BA bitmap array 0 string \x89PNG image/png 0 string FWS application/x-shockwave-flash 0 string CWS application/x-shockwave-flash #------------------------------------------------------------------------------ # lisp: file(1) magic for lisp programs # # various lisp types, from Daniel Quinlan (quinlan@yggdrasil.com) 0 string ;; text/plain 8bit # Emacs 18 - this is always correct, but not very magical. 0 string \012( application/x-elc # Emacs 19 0 string ;ELC\023\000\000\000 application/x-elc #------------------------------------------------------------------------------ # mail.news: file(1) magic for mail and news # # There are tests to ascmagic.c to cope with mail and news. 0 string Relay-Version: message/rfc822 7bit 0 string #!\ rnews message/rfc822 7bit 0 string N#!\ rnews message/rfc822 7bit 0 string Forward\ to message/rfc822 7bit 0 string Pipe\ to message/rfc822 7bit 0 string Return-Path: message/rfc822 7bit 0 string Path: message/news 8bit 0 string Xref: message/news 8bit 0 string From: message/rfc822 7bit 0 string Article message/news 8bit #------------------------------------------------------------------------------ # msword: file(1) magic for MS Word files # # Contributor claims: # Reversed-engineered MS Word magic numbers # 0 string \376\067\0\043 application/msword 0 string \333\245-\0\0\0 application/msword # disable this one because it applies also to other # Office/OLE documents for which msword is not correct. See PR#2608. #0 string \320\317\021\340\241\261 application/msword #------------------------------------------------------------------------------ # printer: file(1) magic for printer-formatted files # # PostScript 0 string %! application/postscript 0 string \004%! application/postscript # Acrobat # (due to clamen@cs.cmu.edu) 0 string %PDF- application/pdf #------------------------------------------------------------------------------ # sc: file(1) magic for "sc" spreadsheet # 38 string Spreadsheet application/x-sc #------------------------------------------------------------------------------ # tex: file(1) magic for TeX files # # XXX - needs byte-endian stuff (big-endian and little-endian DVI?) # # From # Although we may know the offset of certain text fields in TeX DVI # and font files, we can't use them reliably because they are not # zero terminated. [but we do anyway, christos] 0 string \367\002 application/x-dvi #0 string \367\203 TeX generic font data #0 string \367\131 TeX packed font data #0 string \367\312 TeX virtual font data #0 string This\ is\ TeX, TeX transcript text #0 string This\ is\ METAFONT, METAFONT transcript text # There is no way to detect TeX Font Metric (*.tfm) files without # breaking them apart and reading the data. The following patterns # match most *.tfm files generated by METAFONT or afm2tfm. #2 string \000\021 TeX font metric data #2 string \000\022 TeX font metric data #>34 string >\0 (%s) # Texinfo and GNU Info, from Daniel Quinlan (quinlan@yggdrasil.com) #0 string \\input\ texinfo Texinfo source text #0 string This\ is\ Info\ file GNU Info text # correct TeX magic for Linux (and maybe more) # from Peter Tobias (tobias@server.et-inf.fho-emden.de) # 0 leshort 0x02f7 application/x-dvi # RTF - Rich Text Format 0 string {\\rtf application/rtf #------------------------------------------------------------------------------ # animation: file(1) magic for animation/movie formats # # animation formats, originally from vax@ccwf.cc.utexas.edu (VaX#n8) # MPEG file 0 string \000\000\001\263 video/mpeg # # The contributor claims: # I couldn't find a real magic number for these, however, this # -appears- to work. Note that it might catch other files, too, # so BE CAREFUL! # # Note that title and author appear in the two 20-byte chunks # at decimal offsets 2 and 22, respectively, but they are XOR'ed with # 255 (hex FF)! DL format SUCKS BIG ROCKS. # # DL file version 1 , medium format (160x100, 4 images/screen) 0 byte 1 video/unknown 0 byte 2 video/unknown # Quicktime video, from Linus Walleij # from Apple quicktime file format documentation. 4 string moov video/quicktime 4 string mdat video/quicktime ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.8031597 certbot-apache-1.21.0/tests/testdata/centos7_apache/apache/httpd/conf.d/0000755000076500000240000000000000000000000024476 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/centos7_apache/apache/httpd/conf.d/README0000644000076500000240000000055600000000000025364 0ustar00bmwstaff This directory holds configuration files for the Apache HTTP Server; any files in this directory which have the ".conf" extension will be processed as httpd configuration files. The directory is used in addition to the directory /etc/httpd/conf.modules.d/, which contains configuration files necessary to load modules. Files are processed in alphabetical order. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/centos7_apache/apache/httpd/conf.d/autoindex.conf0000644000076500000240000000555600000000000027360 0ustar00bmwstaff# # Directives controlling the display of server-generated directory listings. # # Required modules: mod_authz_core, mod_authz_host, # mod_autoindex, mod_alias # # To see the listing of a directory, the Options directive for the # directory must include "Indexes", and the directory must not contain # a file matching those listed in the DirectoryIndex directive. # # # IndexOptions: Controls the appearance of server-generated directory # listings. # IndexOptions FancyIndexing HTMLTable VersionSort # We include the /icons/ alias for FancyIndexed directory listings. If # you do not use FancyIndexing, you may comment this out. # Alias /icons/ "/usr/share/httpd/icons/" Options Indexes MultiViews FollowSymlinks AllowOverride None Require all granted # # AddIcon* directives tell the server which icon to show for different # files or filename extensions. These are only displayed for # FancyIndexed directories. # AddIconByEncoding (CMP,/icons/compressed.gif) x-compress x-gzip AddIconByType (TXT,/icons/text.gif) text/* AddIconByType (IMG,/icons/image2.gif) image/* AddIconByType (SND,/icons/sound2.gif) audio/* AddIconByType (VID,/icons/movie.gif) video/* AddIcon /icons/binary.gif .bin .exe AddIcon /icons/binhex.gif .hqx AddIcon /icons/tar.gif .tar AddIcon /icons/world2.gif .wrl .wrl.gz .vrml .vrm .iv AddIcon /icons/compressed.gif .Z .z .tgz .gz .zip AddIcon /icons/a.gif .ps .ai .eps AddIcon /icons/layout.gif .html .shtml .htm .pdf AddIcon /icons/text.gif .txt AddIcon /icons/c.gif .c AddIcon /icons/p.gif .pl .py AddIcon /icons/f.gif .for AddIcon /icons/dvi.gif .dvi AddIcon /icons/uuencoded.gif .uu AddIcon /icons/script.gif .conf .sh .shar .csh .ksh .tcl AddIcon /icons/tex.gif .tex AddIcon /icons/bomb.gif /core AddIcon /icons/bomb.gif */core.* AddIcon /icons/back.gif .. AddIcon /icons/hand.right.gif README AddIcon /icons/folder.gif ^^DIRECTORY^^ AddIcon /icons/blank.gif ^^BLANKICON^^ # # DefaultIcon is which icon to show for files which do not have an icon # explicitly set. # DefaultIcon /icons/unknown.gif # # AddDescription allows you to place a short description after a file in # server-generated indexes. These are only displayed for FancyIndexed # directories. # Format: AddDescription "description" filename # #AddDescription "GZIP compressed document" .gz #AddDescription "tar archive" .tar #AddDescription "GZIP compressed tar archive" .tgz # # ReadmeName is the name of the README file the server will look for by # default, and append to directory listings. # # HeaderName is the name of a file which should be prepended to # directory indexes. ReadmeName README.html HeaderName HEADER.html # # IndexIgnore is a set of filenames which directory indexing should ignore # and not include in the listing. Shell-style wildcarding is permitted. # IndexIgnore .??* *~ *# HEADER* README* RCS CVS *,v *,t ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/centos7_apache/apache/httpd/conf.d/centos.example.com.conf0000644000076500000240000000032500000000000031047 0ustar00bmwstaff ServerName centos.example.com ServerAdmin webmaster@localhost DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/centos7_apache/apache/httpd/conf.d/ssl.conf0000644000076500000240000002211700000000000026151 0ustar00bmwstaff# # When we also provide SSL we have to listen to the # the HTTPS port in addition. # Listen 443 https ## ## SSL Global Context ## ## All SSL configuration in this context applies both to ## the main server and all SSL-enabled virtual hosts. ## # Pass Phrase Dialog: # Configure the pass phrase gathering process. # The filtering dialog program (`builtin' is an internal # terminal dialog) has to provide the pass phrase on stdout. SSLPassPhraseDialog exec:/usr/libexec/httpd-ssl-pass-dialog # Inter-Process Session Cache: # Configure the SSL Session Cache: First the mechanism # to use and second the expiring timeout (in seconds). SSLSessionCache shmcb:/run/httpd/sslcache(512000) SSLSessionCacheTimeout 300 # Pseudo Random Number Generator (PRNG): # Configure one or more sources to seed the PRNG of the # SSL library. The seed data should be of good random quality. # WARNING! On some platforms /dev/random blocks if not enough entropy # is available. This means you then cannot use the /dev/random device # because it would lead to very long connection times (as long as # it requires to make more entropy available). But usually those # platforms additionally provide a /dev/urandom device which doesn't # block. So, if available, use this one instead. Read the mod_ssl User # Manual for more details. SSLRandomSeed startup file:/dev/urandom 256 SSLRandomSeed connect builtin #SSLRandomSeed startup file:/dev/random 512 #SSLRandomSeed connect file:/dev/random 512 #SSLRandomSeed connect file:/dev/urandom 512 # # Use "SSLCryptoDevice" to enable any supported hardware # accelerators. Use "openssl engine -v" to list supported # engine names. NOTE: If you enable an accelerator and the # server does not start, consult the error logs and ensure # your accelerator is functioning properly. # SSLCryptoDevice builtin #SSLCryptoDevice ubsec ## ## SSL Virtual Host Context ## # General setup for the virtual host, inherited from global configuration #DocumentRoot "/var/www/html" #ServerName www.example.com:443 # Use separate log files for the SSL virtual host; note that LogLevel # is not inherited from httpd.conf. ErrorLog logs/ssl_error_log TransferLog logs/ssl_access_log LogLevel warn # SSL Engine Switch: # Enable/Disable SSL for this virtual host. SSLEngine on # SSL Protocol support: # List the enable protocol levels with which clients will be able to # connect. Disable SSLv2 access by default: SSLProtocol all -SSLv2 # SSL Cipher Suite: # List the ciphers that the client is permitted to negotiate. # See the mod_ssl documentation for a complete list. SSLCipherSuite HIGH:MEDIUM:!aNULL:!MD5:!SEED:!IDEA # Speed-optimized SSL Cipher configuration: # If speed is your main concern (on busy HTTPS servers e.g.), # you might want to force clients to specific, performance # optimized ciphers. In this case, prepend those ciphers # to the SSLCipherSuite list, and enable SSLHonorCipherOrder. # Caveat: by giving precedence to RC4-SHA and AES128-SHA # (as in the example below), most connections will no longer # have perfect forward secrecy - if the server's key is # compromised, captures of past or future traffic must be # considered compromised, too. #SSLCipherSuite RC4-SHA:AES128-SHA:HIGH:MEDIUM:!aNULL:!MD5 #SSLHonorCipherOrder on # Server Certificate: # Point SSLCertificateFile at a PEM encoded certificate. If # the certificate is encrypted, then you will be prompted for a # pass phrase. Note that a kill -HUP will prompt again. A new # certificate can be generated using the genkey(1) command. # Server Private Key: # If the key is not combined with the certificate, use this # directive to point at the key file. Keep in mind that if # you've both a RSA and a DSA private key you can configure # both in parallel (to also allow the use of DSA ciphers, etc.) # Server Certificate Chain: # Point SSLCertificateChainFile at a file containing the # concatenation of PEM encoded CA certificates which form the # certificate chain for the server certificate. Alternatively # the referenced file can be the same as SSLCertificateFile # when the CA certificates are directly appended to the server # certificate for convinience. #SSLCertificateChainFile /etc/pki/tls/certs/server-chain.crt # Certificate Authority (CA): # Set the CA certificate verification path where to find CA # certificates for client authentication or alternatively one # huge file containing all of them (file must be PEM encoded) #SSLCACertificateFile /etc/pki/tls/certs/ca-bundle.crt # Client Authentication (Type): # Client certificate verification type and depth. Types are # none, optional, require and optional_no_ca. Depth is a # number which specifies how deeply to verify the certificate # issuer chain before deciding the certificate is not valid. #SSLVerifyClient require #SSLVerifyDepth 10 # Access Control: # With SSLRequire you can do per-directory access control based # on arbitrary complex boolean expressions containing server # variable checks and other lookup directives. The syntax is a # mixture between C and Perl. See the mod_ssl documentation # for more details. # #SSLRequire ( %{SSL_CIPHER} !~ m/^(EXP|NULL)/ \ # and %{SSL_CLIENT_S_DN_O} eq "Snake Oil, Ltd." \ # and %{SSL_CLIENT_S_DN_OU} in {"Staff", "CA", "Dev"} \ # and %{TIME_WDAY} >= 1 and %{TIME_WDAY} <= 5 \ # and %{TIME_HOUR} >= 8 and %{TIME_HOUR} <= 20 ) \ # or %{REMOTE_ADDR} =~ m/^192\.76\.162\.[0-9]+$/ # # SSL Engine Options: # Set various options for the SSL engine. # o FakeBasicAuth: # Translate the client X.509 into a Basic Authorisation. This means that # the standard Auth/DBMAuth methods can be used for access control. The # user name is the `one line' version of the client's X.509 certificate. # Note that no password is obtained from the user. Every entry in the user # file needs this password: `xxj31ZMTZzkVA'. # o ExportCertData: # This exports two additional environment variables: SSL_CLIENT_CERT and # SSL_SERVER_CERT. These contain the PEM-encoded certificates of the # server (always existing) and the client (only existing when client # authentication is used). This can be used to import the certificates # into CGI scripts. # o StdEnvVars: # This exports the standard SSL/TLS related `SSL_*' environment variables. # Per default this exportation is switched off for performance reasons, # because the extraction step is an expensive operation and is usually # useless for serving static content. So one usually enables the # exportation for CGI and SSI requests only. # o StrictRequire: # This denies access when "SSLRequireSSL" or "SSLRequire" applied even # under a "Satisfy any" situation, i.e. when it applies access is denied # and no other module can change it. # o OptRenegotiate: # This enables optimized SSL connection renegotiation handling when SSL # directives are used in per-directory context. #SSLOptions +FakeBasicAuth +ExportCertData +StrictRequire SSLOptions +StdEnvVars SSLOptions +StdEnvVars # SSL Protocol Adjustments: # The safe and default but still SSL/TLS standard compliant shutdown # approach is that mod_ssl sends the close notify alert but doesn't wait for # the close notify alert from client. When you need a different shutdown # approach you can use one of the following variables: # o ssl-unclean-shutdown: # This forces an unclean shutdown when the connection is closed, i.e. no # SSL close notify alert is send or allowed to received. This violates # the SSL/TLS standard but is needed for some brain-dead browsers. Use # this when you receive I/O errors because of the standard approach where # mod_ssl sends the close notify alert. # o ssl-accurate-shutdown: # This forces an accurate shutdown when the connection is closed, i.e. a # SSL close notify alert is send and mod_ssl waits for the close notify # alert of the client. This is 100% SSL/TLS standard compliant, but in # practice often causes hanging connections with brain-dead browsers. Use # this only for browsers where you know that their SSL implementation # works correctly. # Notice: Most problems of broken clients are also related to the HTTP # keep-alive facility, so you usually additionally want to disable # keep-alive for those clients, too. Use variable "nokeepalive" for this. # Similarly, one has to force some clients to use HTTP/1.0 to workaround # their broken HTTP/1.1 implementation. Use variables "downgrade-1.0" and # "force-response-1.0" for this. BrowserMatch "MSIE [2-5]" nokeepalive ssl-unclean-shutdown downgrade-1.0 force-response-1.0 # Per-Server Logging: # The home of a custom SSL log file. Use this when you want a # compact non-error SSL logfile on a virtual host basis. CustomLog logs/ssl_request_log "%t %h %{SSL_PROTOCOL}x %{SSL_CIPHER}x \"%r\" %b" ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/centos7_apache/apache/httpd/conf.d/userdir.conf0000644000076500000240000000234400000000000027025 0ustar00bmwstaff# # UserDir: The name of the directory that is appended onto a user's home # directory if a ~user request is received. # # The path to the end user account 'public_html' directory must be # accessible to the webserver userid. This usually means that ~userid # must have permissions of 711, ~userid/public_html must have permissions # of 755, and documents contained therein must be world-readable. # Otherwise, the client will only receive a "403 Forbidden" message. # # # UserDir is disabled by default since it can confirm the presence # of a username on the system (depending on home directory # permissions). # UserDir disabled # # To enable requests to /~user/ to serve the user's public_html # directory, remove the "UserDir disabled" line above, and uncomment # the following line instead: # #UserDir public_html # # Control access to UserDir directories. The following is an example # for a site where these directories are restricted to read-only. # AllowOverride FileInfo AuthConfig Limit Indexes Options MultiViews Indexes SymLinksIfOwnerMatch IncludesNoExec Require method GET POST OPTIONS ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/centos7_apache/apache/httpd/conf.d/welcome.conf0000644000076500000240000000147000000000000027002 0ustar00bmwstaff# # This configuration file enables the default "Welcome" page if there # is no default index page present for the root URL. To disable the # Welcome page, comment out all the lines below. # # NOTE: if this file is removed, it will be restored on upgrades. # Options -Indexes ErrorDocument 403 /.noindex.html AllowOverride None Require all granted Alias /.noindex.html /usr/share/httpd/noindex/index.html Alias /noindex/css/bootstrap.min.css /usr/share/httpd/noindex/css/bootstrap.min.css Alias /noindex/css/open-sans.css /usr/share/httpd/noindex/css/open-sans.css Alias /images/apache_pb.gif /usr/share/httpd/noindex/images/apache_pb.gif Alias /images/poweredby.png /usr/share/httpd/noindex/images/poweredby.png ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.8040078 certbot-apache-1.21.0/tests/testdata/centos7_apache/apache/httpd/conf.modules.d/0000755000076500000240000000000000000000000026145 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/centos7_apache/apache/httpd/conf.modules.d/00-base.conf0000644000076500000240000000723300000000000030150 0ustar00bmwstaff# # This file loads most of the modules included with the Apache HTTP # Server itself. # LoadModule access_compat_module modules/mod_access_compat.so LoadModule actions_module modules/mod_actions.so LoadModule alias_module modules/mod_alias.so LoadModule allowmethods_module modules/mod_allowmethods.so LoadModule auth_basic_module modules/mod_auth_basic.so LoadModule auth_digest_module modules/mod_auth_digest.so LoadModule authn_anon_module modules/mod_authn_anon.so LoadModule authn_core_module modules/mod_authn_core.so LoadModule authn_dbd_module modules/mod_authn_dbd.so LoadModule authn_dbm_module modules/mod_authn_dbm.so LoadModule authn_file_module modules/mod_authn_file.so LoadModule authn_socache_module modules/mod_authn_socache.so LoadModule authz_core_module modules/mod_authz_core.so LoadModule authz_dbd_module modules/mod_authz_dbd.so LoadModule authz_dbm_module modules/mod_authz_dbm.so LoadModule authz_groupfile_module modules/mod_authz_groupfile.so LoadModule authz_host_module modules/mod_authz_host.so LoadModule authz_owner_module modules/mod_authz_owner.so LoadModule authz_user_module modules/mod_authz_user.so LoadModule autoindex_module modules/mod_autoindex.so LoadModule cache_module modules/mod_cache.so LoadModule cache_disk_module modules/mod_cache_disk.so LoadModule data_module modules/mod_data.so LoadModule dbd_module modules/mod_dbd.so LoadModule deflate_module modules/mod_deflate.so LoadModule dir_module modules/mod_dir.so LoadModule dumpio_module modules/mod_dumpio.so LoadModule echo_module modules/mod_echo.so LoadModule env_module modules/mod_env.so LoadModule expires_module modules/mod_expires.so LoadModule ext_filter_module modules/mod_ext_filter.so LoadModule filter_module modules/mod_filter.so LoadModule headers_module modules/mod_headers.so LoadModule include_module modules/mod_include.so LoadModule info_module modules/mod_info.so LoadModule log_config_module modules/mod_log_config.so LoadModule logio_module modules/mod_logio.so LoadModule mime_magic_module modules/mod_mime_magic.so LoadModule mime_module modules/mod_mime.so LoadModule negotiation_module modules/mod_negotiation.so LoadModule remoteip_module modules/mod_remoteip.so LoadModule reqtimeout_module modules/mod_reqtimeout.so LoadModule rewrite_module modules/mod_rewrite.so LoadModule setenvif_module modules/mod_setenvif.so LoadModule slotmem_plain_module modules/mod_slotmem_plain.so LoadModule slotmem_shm_module modules/mod_slotmem_shm.so LoadModule socache_dbm_module modules/mod_socache_dbm.so LoadModule socache_memcache_module modules/mod_socache_memcache.so LoadModule socache_shmcb_module modules/mod_socache_shmcb.so LoadModule status_module modules/mod_status.so LoadModule substitute_module modules/mod_substitute.so LoadModule suexec_module modules/mod_suexec.so LoadModule unique_id_module modules/mod_unique_id.so LoadModule unixd_module modules/mod_unixd.so LoadModule userdir_module modules/mod_userdir.so LoadModule version_module modules/mod_version.so LoadModule vhost_alias_module modules/mod_vhost_alias.so #LoadModule buffer_module modules/mod_buffer.so #LoadModule watchdog_module modules/mod_watchdog.so #LoadModule heartbeat_module modules/mod_heartbeat.so #LoadModule heartmonitor_module modules/mod_heartmonitor.so #LoadModule usertrack_module modules/mod_usertrack.so #LoadModule dialup_module modules/mod_dialup.so #LoadModule charset_lite_module modules/mod_charset_lite.so #LoadModule log_debug_module modules/mod_log_debug.so #LoadModule ratelimit_module modules/mod_ratelimit.so #LoadModule reflector_module modules/mod_reflector.so #LoadModule request_module modules/mod_request.so #LoadModule sed_module modules/mod_sed.so #LoadModule speling_module modules/mod_speling.so ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/centos7_apache/apache/httpd/conf.modules.d/00-dav.conf0000644000076500000240000000021300000000000027777 0ustar00bmwstaffLoadModule dav_module modules/mod_dav.so LoadModule dav_fs_module modules/mod_dav_fs.so LoadModule dav_lock_module modules/mod_dav_lock.so ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/centos7_apache/apache/httpd/conf.modules.d/00-lua.conf0000644000076500000240000000005100000000000030006 0ustar00bmwstaffLoadModule lua_module modules/mod_lua.so ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/centos7_apache/apache/httpd/conf.modules.d/00-mpm.conf0000644000076500000240000000134600000000000030026 0ustar00bmwstaff# Select the MPM module which should be used by uncommenting exactly # one of the following LoadModule lines: # prefork MPM: Implements a non-threaded, pre-forking web server # See: http://httpd.apache.org/docs/2.4/mod/prefork.html LoadModule mpm_prefork_module modules/mod_mpm_prefork.so # worker MPM: Multi-Processing Module implementing a hybrid # multi-threaded multi-process web server # See: http://httpd.apache.org/docs/2.4/mod/worker.html # #LoadModule mpm_worker_module modules/mod_mpm_worker.so # event MPM: A variant of the worker MPM with the goal of consuming # threads only for connections with active processing # See: http://httpd.apache.org/docs/2.4/mod/event.html # #LoadModule mpm_event_module modules/mod_mpm_event.so ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/centos7_apache/apache/httpd/conf.modules.d/00-proxy.conf0000644000076500000240000000167500000000000030423 0ustar00bmwstaff# This file configures all the proxy modules: LoadModule proxy_module modules/mod_proxy.so LoadModule lbmethod_bybusyness_module modules/mod_lbmethod_bybusyness.so LoadModule lbmethod_byrequests_module modules/mod_lbmethod_byrequests.so LoadModule lbmethod_bytraffic_module modules/mod_lbmethod_bytraffic.so LoadModule lbmethod_heartbeat_module modules/mod_lbmethod_heartbeat.so LoadModule proxy_ajp_module modules/mod_proxy_ajp.so LoadModule proxy_balancer_module modules/mod_proxy_balancer.so LoadModule proxy_connect_module modules/mod_proxy_connect.so LoadModule proxy_express_module modules/mod_proxy_express.so LoadModule proxy_fcgi_module modules/mod_proxy_fcgi.so LoadModule proxy_fdpass_module modules/mod_proxy_fdpass.so LoadModule proxy_ftp_module modules/mod_proxy_ftp.so LoadModule proxy_http_module modules/mod_proxy_http.so LoadModule proxy_scgi_module modules/mod_proxy_scgi.so LoadModule proxy_wstunnel_module modules/mod_proxy_wstunnel.so ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/centos7_apache/apache/httpd/conf.modules.d/00-ssl.conf0000644000076500000240000000005100000000000030026 0ustar00bmwstaffLoadModule ssl_module modules/mod_ssl.so ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/centos7_apache/apache/httpd/conf.modules.d/00-systemd.conf0000644000076500000240000000013000000000000030713 0ustar00bmwstaff# This file configures systemd module: LoadModule systemd_module modules/mod_systemd.so ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/centos7_apache/apache/httpd/conf.modules.d/01-cgi.conf0000644000076500000240000000070300000000000027774 0ustar00bmwstaff# This configuration file loads a CGI module appropriate to the MPM # which has been configured in 00-mpm.conf. mod_cgid should be used # with a threaded MPM; mod_cgi with the prefork MPM. LoadModule cgid_module modules/mod_cgid.so LoadModule cgid_module modules/mod_cgid.so LoadModule cgi_module modules/mod_cgi.so ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/centos7_apache/apache/sites0000644000076500000240000000006300000000000023255 0ustar00bmwstaffconf.d/centos.example.com.conf, centos.example.com ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.8041162 certbot-apache-1.21.0/tests/testdata/centos7_apache/apache/sysconfig/0000755000076500000240000000000000000000000024210 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/centos7_apache/apache/sysconfig/httpd0000644000076500000240000000157200000000000025263 0ustar00bmwstaff# # This file can be used to set additional environment variables for # the httpd process, or pass additional options to the httpd # executable. # # Note: With previous versions of httpd, the MPM could be changed by # editing an "HTTPD" variable here. With the current version, that # variable is now ignored. The MPM is a loadable module, and the # choice of MPM can be changed by editing the configuration file # /etc/httpd/conf.modules.d/00-mpm.conf. # # # To pass additional options (for instance, -D definitions) to the # httpd binary at startup, set OPTIONS here. # OPTIONS="-D mock_define -D mock_define_too -D mock_value=TRUE -DMOCK_NOSEP -DNOSEP_TWO=NOSEP_VAL" # # This setting ensures the httpd process is started in the "C" locale # by default. (Some modules will not behave correctly if # case-sensitive string comparisons are performed in a different # locale.) # LANG=C ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.8044345 certbot-apache-1.21.0/tests/testdata/complex_parsing/0000755000076500000240000000000000000000000021272 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/complex_parsing/apache2.conf0000644000076500000240000000206600000000000023450 0ustar00bmwstaff# Global configuration PidFile ${APACHE_PID_FILE} # # Timeout: The number of seconds before receives and sends time out. # Timeout 300 # # KeepAlive: Whether or not to allow persistent connections (more than # one request per connection). Set to "Off" to deactivate. # KeepAlive On # These need to be set in /etc/apache2/envvars User ${APACHE_RUN_USER} Group ${APACHE_RUN_GROUP} ErrorLog ${APACHE_LOG_DIR}/error.log LogLevel warn # Include module configuration: IncludeOptional mods-enabled/*.load IncludeOptional mods-enabled/*.conf Options FollowSymLinks AllowOverride None Require all denied Options Indexes FollowSymLinks AllowOverride None Require all granted # Include generic snippets of statements IncludeOptional conf-enabled/ # Include the virtual host configurations: IncludeOptional sites-enabled/*.conf Define COMPLEX Define tls_port 1234 Define tls_port_str "1234" Define fnmatch_filename test_fnmatch.conf Include test_variables.conf # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.8045404 certbot-apache-1.21.0/tests/testdata/complex_parsing/conf-enabled/0000755000076500000240000000000000000000000023607 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/complex_parsing/conf-enabled/dummy.conf0000644000076500000240000000041300000000000025607 0ustar00bmwstaff# 3 - one arg directives # 2 - two arg directives # 1 - three arg directives TestArgsDirective one_arg TestArgsDirective one_arg two_arg TestArgsDirective one_arg TestArgsDirective one_arg two_arg TestArgsDirective one_arg two_arg three_arg TestArgsDirective one_arg ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/complex_parsing/test_fnmatch.conf0000644000076500000240000000003200000000000024613 0ustar00bmwstaffFNMATCH_DIRECTIVE Success ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/complex_parsing/test_variables.conf0000644000076500000240000000232200000000000025147 0ustar00bmwstaffTestVariablePort ${tls_port} TestVariablePortStr "${tls_port_str}" LoadModule status_module modules/mod_status.so # Basic IfDefine VAR_DIRECTIVE success LoadModule ssl_module modules/mod_ssl.so INVALID_VAR_DIRECTIVE failure INVALID_VAR_DIRECTIVE failure VAR_DIRECTIVE failure # Basic IfModule MOD_DIRECTIVE Success INVALID_MOD_DIRECTIVE failure INVALID_MOD_DIRECTIVE failure MOD_DIRECTIVE Success # Nested Tests NESTED_DIRECTIVE success NESTED_DIRECTIVE success INVALID_NESTED_DIRECTIVE failure INVALID_NESTED_DIRECTIVE failure INVALID_NESTED_DIRECTIVE failure NESTED_DIRECTIVE success ././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1635888463.789727 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/0000755000076500000240000000000000000000000021267 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.8046503 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/0000755000076500000240000000000000000000000024142 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.8049972 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/0000755000076500000240000000000000000000000025445 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/apache2.conf0000644000076500000240000001460500000000000027625 0ustar00bmwstaff# This is the main Apache server configuration file. It contains the # configuration directives that give the server its instructions. # See http://httpd.apache.org/docs/2.4/ for detailed information about # the directives and /usr/share/doc/apache2/README.Debian about Debian specific # hints. # # # Summary of how the Apache 2 configuration works in Debian: # The Apache 2 web server configuration in Debian is quite different to # upstream's suggested way to configure the web server. This is because Debian's # default Apache2 installation attempts to make adding and removing modules, # virtual hosts, and extra configuration directives as flexible as possible, in # order to make automating the changes and administering the server as easy as # possible. # It is split into several files forming the configuration hierarchy outlined # below, all located in the /etc/apache2/ directory: # # /etc/apache2/ # |-- apache2.conf # | `-- ports.conf # |-- mods-enabled # | |-- *.load # | `-- *.conf # |-- conf-enabled # | `-- *.conf # `-- sites-enabled # `-- *.conf # # # * apache2.conf is the main configuration file (this file). It puts the pieces # together by including all remaining configuration files when starting up the # web server. # # * ports.conf is always included from the main configuration file. It is # supposed to determine listening ports for incoming connections which can be # customized anytime. # # * Configuration files in the mods-enabled/, conf-enabled/ and sites-enabled/ # directories contain particular configuration snippets which manage modules, # global configuration fragments, or virtual host configurations, # respectively. # # They are activated by symlinking available configuration files from their # respective *-available/ counterparts. These should be managed by using our # helpers a2enmod/a2dismod, a2ensite/a2dissite and a2enconf/a2disconf. See # their respective man pages for detailed information. # # * The binary is called apache2. Due to the use of environment variables, in # the default configuration, apache2 needs to be started/stopped with # /etc/init.d/apache2 or apache2ctl. Calling /usr/bin/apache2 directly will not # work with the default configuration. # Global configuration # # The accept serialization lock file MUST BE STORED ON A LOCAL DISK. # Mutex file:${APACHE_LOCK_DIR} default # # PidFile: The file in which the server should record its process # identification number when it starts. # This needs to be set in /etc/apache2/envvars # PidFile ${APACHE_PID_FILE} # # Timeout: The number of seconds before receives and sends time out. # Timeout 300 # # KeepAlive: Whether or not to allow persistent connections (more than # one request per connection). Set to "Off" to deactivate. # KeepAlive On # # MaxKeepAliveRequests: The maximum number of requests to allow # during a persistent connection. Set to 0 to allow an unlimited amount. # We recommend you leave this number high, for maximum performance. # MaxKeepAliveRequests 100 # # KeepAliveTimeout: Number of seconds to wait for the next request from the # same client on the same connection. # KeepAliveTimeout 5 # These need to be set in /etc/apache2/envvars User ${APACHE_RUN_USER} Group ${APACHE_RUN_GROUP} # # HostnameLookups: Log the names of clients or just their IP addresses # e.g., www.apache.org (on) or 204.62.129.132 (off). # The default is off because it'd be overall better for the net if people # had to knowingly turn this feature on, since enabling it means that # each client request will result in AT LEAST one lookup request to the # nameserver. # HostnameLookups Off # ErrorLog: The location of the error log file. # If you do not specify an ErrorLog directive within a # container, error messages relating to that virtual host will be # logged here. If you *do* define an error logfile for a # container, that host's errors will be logged there and not here. # ErrorLog ${APACHE_LOG_DIR}/error.log # # LogLevel: Control the severity of messages logged to the error_log. # Available values: trace8, ..., trace1, debug, info, notice, warn, # error, crit, alert, emerg. # It is also possible to configure the log level for particular modules, e.g. # "LogLevel info ssl:warn" # LogLevel warn # Include module configuration: IncludeOptional mods-enabled/*.load IncludeOptional mods-enabled/*.conf # Include list of ports to listen on Include ports.conf # Sets the default security model of the Apache2 HTTPD server. It does # not allow access to the root filesystem outside of /usr/share and /var/www. # The former is used by web applications packaged in Debian, # the latter may be used for local directories served by the web server. If # your system is serving content from a sub-directory in /srv you must allow # access here, or in any related virtual host. Options FollowSymLinks AllowOverride None Require all denied AllowOverride None Require all granted Options Indexes FollowSymLinks AllowOverride None Require all granted # AccessFileName: The name of the file to look for in each directory # for additional configuration directives. See also the AllowOverride # directive. # AccessFileName .htaccess # # The following lines prevent .htaccess and .htpasswd files from being # viewed by Web clients. # Require all denied # The following directives define some format nicknames for use with # a CustomLog directive. # # These deviate from the Common Log Format definitions in that they use %O # (the actual bytes sent including headers) instead of %b (the size of the # requested file), because the latter makes it impossible to detect partial # requests. # # Note that the use of %{X-Forwarded-For}i instead of %h is not recommended. # Use mod_remoteip instead. # LogFormat "%v:%p %h %l %u %t \"%r\" %>s %O \"%{Referer}i\" \"%{User-Agent}i\"" vhost_combined LogFormat "%h %l %u %t \"%r\" %>s %O \"%{Referer}i\" \"%{User-Agent}i\"" combined LogFormat "%h %l %u %t \"%r\" %>s %O" common LogFormat "%{Referer}i -> %U" referer LogFormat "%{User-agent}i" agent # Include of directories ignores editors' and dpkg's backup files, # see README.Debian for details. # Include generic snippets of statements IncludeOptional conf-enabled/*.conf # Include the virtual host configurations: IncludeOptional sites-enabled/*.conf # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.8054528 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/conf-available/0000755000076500000240000000000000000000000030310 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000021600000000000010214 xustar00120 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/conf-available/bad_conf_file.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/conf-available/bad_conf0000644000076500000240000000005600000000000031767 0ustar00bmwstaff ServerName invalid.net ././@PaxHeader0000000000000000000000000000023000000000000010210 xustar00130 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/conf-available/other-vhosts-access-log.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/conf-available/other-vh0000644000076500000240000000027500000000000031773 0ustar00bmwstaff# Define an access log for VirtualHosts that don't define their own logfile CustomLog ${APACHE_LOG_DIR}/other_vhosts_access.log vhost_combined # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000021100000000000010207 xustar00115 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/conf-available/security.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/conf-available/security0000644000076500000240000000221500000000000032102 0ustar00bmwstaff# Changing the following options will not really affect the security of the # server, but might make attacks slightly more difficult in some cases. # # ServerTokens # This directive configures what you return as the Server HTTP response # Header. The default is 'Full' which sends information about the OS-Type # and compiled in modules. # Set to one of: Full | OS | Minimal | Minor | Major | Prod # where Full conveys the most information, and Prod the least. #ServerTokens Minimal ServerTokens OS #ServerTokens Full # # Optionally add a line containing the server version and virtual host # name to server-generated pages (internal error documents, FTP directory # listings, mod_status and mod_info output etc., but not CGI generated # documents or custom error documents). # Set to "EMail" to also include a mailto: link to the ServerAdmin. # Set to one of: On | Off | EMail #ServerSignature Off ServerSignature On # # Allow TRACE method # # Set to "extended" to also reflect the request body (only for testing and # diagnostic purposes). # # Set to one of: On | Off | extended TraceEnable Off #TraceEnable On # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000021600000000000010214 xustar00120 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/conf-available/serve-cgi-bin.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/conf-available/serve-cg0000644000076500000240000000070700000000000031752 0ustar00bmwstaff Define ENABLE_USR_LIB_CGI_BIN Define ENABLE_USR_LIB_CGI_BIN ScriptAlias /cgi-bin/ /usr/lib/cgi-bin/ AllowOverride None Options +ExecCGI -MultiViews +SymLinksIfOwnerMatch Require all granted # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1635888463.805792 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/conf-enabled/0000755000076500000240000000000000000000000027762 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000022600000000000010215 xustar00128 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/conf-enabled/other-vhosts-access-log.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/conf-enabled/other-vhos0000644000076500000240000000027500000000000032007 0ustar00bmwstaff# Define an access log for VirtualHosts that don't define their own logfile CustomLog ${APACHE_LOG_DIR}/other_vhosts_access.log vhost_combined # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000020700000000000010214 xustar00113 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/conf-enabled/security.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/conf-enabled/security.c0000644000076500000240000000221500000000000031775 0ustar00bmwstaff# Changing the following options will not really affect the security of the # server, but might make attacks slightly more difficult in some cases. # # ServerTokens # This directive configures what you return as the Server HTTP response # Header. The default is 'Full' which sends information about the OS-Type # and compiled in modules. # Set to one of: Full | OS | Minimal | Minor | Major | Prod # where Full conveys the most information, and Prod the least. #ServerTokens Minimal ServerTokens OS #ServerTokens Full # # Optionally add a line containing the server version and virtual host # name to server-generated pages (internal error documents, FTP directory # listings, mod_status and mod_info output etc., but not CGI generated # documents or custom error documents). # Set to "EMail" to also include a mailto: link to the ServerAdmin. # Set to one of: On | Off | EMail #ServerSignature Off ServerSignature On # # Allow TRACE method # # Set to "extended" to also reflect the request body (only for testing and # diagnostic purposes). # # Set to one of: On | Off | extended TraceEnable Off #TraceEnable On # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000021400000000000010212 xustar00118 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/conf-enabled/serve-cgi-bin.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/conf-enabled/serve-cgi-0000644000076500000240000000070700000000000031652 0ustar00bmwstaff Define ENABLE_USR_LIB_CGI_BIN Define ENABLE_USR_LIB_CGI_BIN ScriptAlias /cgi-bin/ /usr/lib/cgi-bin/ AllowOverride None Options +ExecCGI -MultiViews +SymLinksIfOwnerMatch Require all granted # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/envvars0000644000076500000240000000172600000000000027062 0ustar00bmwstaff# envvars - default environment variables for apache2ctl # this won't be correct after changing uid unset HOME # for supporting multiple apache2 instances if [ "${APACHE_CONFDIR##/etc/apache2-}" != "${APACHE_CONFDIR}" ] ; then SUFFIX="-${APACHE_CONFDIR##/etc/apache2-}" else SUFFIX= fi # Since there is no sane way to get the parsed apache2 config in scripts, some # settings are defined via environment variables and then used in apache2ctl, # /etc/init.d/apache2, /etc/logrotate.d/apache2, etc. export APACHE_RUN_USER=www-data export APACHE_RUN_GROUP=www-data # temporary state file location. This might be changed to /run in Wheezy+1 export APACHE_PID_FILE=/var/run/apache2/apache2$SUFFIX.pid export APACHE_RUN_DIR=/var/run/apache2$SUFFIX export APACHE_LOCK_DIR=/var/lock/apache2$SUFFIX # Only /var/log/apache2 is handled by /etc/logrotate.d/apache2. export APACHE_LOG_DIR=/var/log/apache2$SUFFIX ## The locale used by some modules like mod_dav export LANG=C export LANG ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.8065865 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/mods-available/0000755000076500000240000000000000000000000030325 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000021200000000000010210 xustar00116 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/mods-available/authz_svn.load 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/mods-available/authz_sv0000644000076500000240000000024500000000000032114 0ustar00bmwstaff# Depends: dav_svn Include mods-enabled/dav_svn.load LoadModule authz_svn_module /usr/lib/apache2/modules/mod_authz_svn.so ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/mods-available/dav.load0000644000076500000240000000013500000000000031737 0ustar00bmwstaff LoadModule dav_module /usr/lib/apache2/modules/mod_dav.so ././@PaxHeader0000000000000000000000000000021000000000000010206 xustar00114 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/mods-available/dav_svn.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/mods-available/dav_svn.0000644000076500000240000000450400000000000031771 0ustar00bmwstaff# dav_svn.conf - Example Subversion/Apache configuration # # For details and further options see the Apache user manual and # the Subversion book. # # NOTE: for a setup with multiple vhosts, you will want to do this # configuration in /etc/apache2/sites-available/*, not here. # ... # URL controls how the repository appears to the outside world. # In this example clients access the repository as http://hostname/svn/ # Note, a literal /svn should NOT exist in your document root. # # Uncomment this to enable the repository #DAV svn # Set this to the path to your repository #SVNPath /var/lib/svn # Alternatively, use SVNParentPath if you have multiple repositories under # under a single directory (/var/lib/svn/repo1, /var/lib/svn/repo2, ...). # You need either SVNPath and SVNParentPath, but not both. #SVNParentPath /var/lib/svn # Access control is done at 3 levels: (1) Apache authentication, via # any of several methods. A "Basic Auth" section is commented out # below. (2) Apache and , also commented out # below. (3) mod_authz_svn is a svn-specific authorization module # which offers fine-grained read/write access control for paths # within a repository. (The first two layers are coarse-grained; you # can only enable/disable access to an entire repository.) Note that # mod_authz_svn is noticeably slower than the other two layers, so if # you don't need the fine-grained control, don't configure it. # Basic Authentication is repository-wide. It is not secure unless # you are using https. See the 'htpasswd' command to create and # manage the password file - and the documentation for the # 'auth_basic' and 'authn_file' modules, which you will need for this # (enable them with 'a2enmod'). #AuthType Basic #AuthName "Subversion Repository" #AuthUserFile /etc/apache2/dav_svn.passwd # To enable authorization via mod_authz_svn (enable that module separately): # #AuthzSVNAccessFile /etc/apache2/dav_svn.authz # # The following three lines allow anonymous read, but make # committers authenticate themselves. It requires the 'authz_user' # module (enable it with 'a2enmod'). # #Require valid-user # # ././@PaxHeader0000000000000000000000000000021000000000000010206 xustar00114 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/mods-available/dav_svn.load 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/mods-available/dav_svn.0000644000076500000240000000031300000000000031763 0ustar00bmwstaff# Depends: dav Include mods-enabled/dav.load LoadModule dav_svn_module /usr/lib/apache2/modules/mod_dav_svn.so ././@PaxHeader0000000000000000000000000000021000000000000010206 xustar00114 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/mods-available/rewrite.load 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/mods-available/rewrite.0000644000076500000240000000010200000000000032000 0ustar00bmwstaffLoadModule rewrite_module /usr/lib/apache2/modules/mod_rewrite.so ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/mods-available/ssl.conf0000644000076500000240000000651500000000000032004 0ustar00bmwstaff # Pseudo Random Number Generator (PRNG): # Configure one or more sources to seed the PRNG of the SSL library. # The seed data should be of good random quality. # WARNING! On some platforms /dev/random blocks if not enough entropy # is available. This means you then cannot use the /dev/random device # because it would lead to very long connection times (as long as # it requires to make more entropy available). But usually those # platforms additionally provide a /dev/urandom device which doesn't # block. So, if available, use this one instead. Read the mod_ssl User # Manual for more details. # SSLRandomSeed startup builtin SSLRandomSeed startup file:/dev/urandom 512 SSLRandomSeed connect builtin SSLRandomSeed connect file:/dev/urandom 512 ## ## SSL Global Context ## ## All SSL configuration in this context applies both to ## the main server and all SSL-enabled virtual hosts. ## # # Some MIME-types for downloading Certificates and CRLs # AddType application/x-x509-ca-cert .crt AddType application/x-pkcs7-crl .crl # Pass Phrase Dialog: # Configure the pass phrase gathering process. # The filtering dialog program (`builtin' is an internal # terminal dialog) has to provide the pass phrase on stdout. SSLPassPhraseDialog exec:/usr/share/apache2/ask-for-passphrase # Inter-Process Session Cache: # Configure the SSL Session Cache: First the mechanism # to use and second the expiring timeout (in seconds). # (The mechanism dbm has known memory leaks and should not be used). #SSLSessionCache dbm:${APACHE_RUN_DIR}/ssl_scache SSLSessionCache shmcb:${APACHE_RUN_DIR}/ssl_scache(512000) SSLSessionCacheTimeout 300 # Semaphore: # Configure the path to the mutual exclusion semaphore the # SSL engine uses internally for inter-process synchronization. # (Disabled by default, the global Mutex directive consolidates by default # this) #Mutex file:${APACHE_LOCK_DIR}/ssl_mutex ssl-cache # SSL Cipher Suite: # List the ciphers that the client is permitted to negotiate. See the # ciphers(1) man page from the openssl package for list of all available # options. # Enable only secure ciphers: SSLCipherSuite HIGH:MEDIUM:!aNULL:!MD5 # Speed-optimized SSL Cipher configuration: # If speed is your main concern (on busy HTTPS servers e.g.), # you might want to force clients to specific, performance # optimized ciphers. In this case, prepend those ciphers # to the SSLCipherSuite list, and enable SSLHonorCipherOrder. # Caveat: by giving precedence to RC4-SHA and AES128-SHA # (as in the example below), most connections will no longer # have perfect forward secrecy - if the server's key is # compromised, captures of past or future traffic must be # considered compromised, too. #SSLCipherSuite RC4-SHA:AES128-SHA:HIGH:MEDIUM:!aNULL:!MD5 #SSLHonorCipherOrder on # The protocols to enable. # Available values: all, SSLv3, TLSv1, TLSv1.1, TLSv1.2 # SSL v2 is no longer supported SSLProtocol all # Allow insecure renegotiation with clients which do not yet support the # secure renegotiation protocol. Default: Off #SSLInsecureRenegotiation on # Whether to forbid non-SNI clients to access name based virtual hosts. # Default: Off #SSLStrictSNIVHostCheck On # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/mods-available/ssl.load0000644000076500000240000000014100000000000031763 0ustar00bmwstaff# Depends: setenvif mime socache_shmcb LoadModule ssl_module /usr/lib/apache2/modules/mod_ssl.so ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.8070505 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/mods-enabled/0000755000076500000240000000000000000000000027777 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000021000000000000010206 xustar00114 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/mods-enabled/authz_svn.load 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/mods-enabled/authz_svn.0000644000076500000240000000024500000000000032022 0ustar00bmwstaff# Depends: dav_svn Include mods-enabled/dav_svn.load LoadModule authz_svn_module /usr/lib/apache2/modules/mod_authz_svn.so ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/mods-enabled/dav.load0000644000076500000240000000013500000000000031411 0ustar00bmwstaff LoadModule dav_module /usr/lib/apache2/modules/mod_dav.so ././@PaxHeader0000000000000000000000000000020600000000000010213 xustar00112 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/mods-enabled/dav_svn.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/mods-enabled/dav_svn.co0000644000076500000240000000450400000000000031765 0ustar00bmwstaff# dav_svn.conf - Example Subversion/Apache configuration # # For details and further options see the Apache user manual and # the Subversion book. # # NOTE: for a setup with multiple vhosts, you will want to do this # configuration in /etc/apache2/sites-available/*, not here. # ... # URL controls how the repository appears to the outside world. # In this example clients access the repository as http://hostname/svn/ # Note, a literal /svn should NOT exist in your document root. # # Uncomment this to enable the repository #DAV svn # Set this to the path to your repository #SVNPath /var/lib/svn # Alternatively, use SVNParentPath if you have multiple repositories under # under a single directory (/var/lib/svn/repo1, /var/lib/svn/repo2, ...). # You need either SVNPath and SVNParentPath, but not both. #SVNParentPath /var/lib/svn # Access control is done at 3 levels: (1) Apache authentication, via # any of several methods. A "Basic Auth" section is commented out # below. (2) Apache and , also commented out # below. (3) mod_authz_svn is a svn-specific authorization module # which offers fine-grained read/write access control for paths # within a repository. (The first two layers are coarse-grained; you # can only enable/disable access to an entire repository.) Note that # mod_authz_svn is noticeably slower than the other two layers, so if # you don't need the fine-grained control, don't configure it. # Basic Authentication is repository-wide. It is not secure unless # you are using https. See the 'htpasswd' command to create and # manage the password file - and the documentation for the # 'auth_basic' and 'authn_file' modules, which you will need for this # (enable them with 'a2enmod'). #AuthType Basic #AuthName "Subversion Repository" #AuthUserFile /etc/apache2/dav_svn.passwd # To enable authorization via mod_authz_svn (enable that module separately): # #AuthzSVNAccessFile /etc/apache2/dav_svn.authz # # The following three lines allow anonymous read, but make # committers authenticate themselves. It requires the 'authz_user' # module (enable it with 'a2enmod'). # #Require valid-user # # ././@PaxHeader0000000000000000000000000000020600000000000010213 xustar00112 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/mods-enabled/dav_svn.load 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/mods-enabled/dav_svn.lo0000644000076500000240000000031300000000000031770 0ustar00bmwstaff# Depends: dav Include mods-enabled/dav.load LoadModule dav_svn_module /usr/lib/apache2/modules/mod_dav_svn.so ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/ports.conf0000644000076500000240000000050000000000000027456 0ustar00bmwstaff# If you just change the port or add more ports here, you will likely also # have to change the VirtualHost statement in # /etc/apache2/sites-enabled/000-default.conf Listen 80 Listen 443 Listen 443 # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1635888463.807396 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/sites-available/0000755000076500000240000000000000000000000030512 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000022200000000000010211 xustar00124 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/sites-available/another_wildcard.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/sites-available/another0000644000076500000240000000043200000000000032074 0ustar00bmwstaff ServerName wildcard.tld ServerAlias ?.wildcard.tld ServerAdmin webmaster@localhost DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000022100000000000010210 xustar00123 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/sites-available/old-and-default.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/sites-available/old-and0000644000076500000240000000041200000000000031750 0ustar00bmwstaff ServerName ip-172-30-0-17 ServerAdmin webmaster@localhost DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000021200000000000010210 xustar00116 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/sites-available/wildcard.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/sites-available/wildcar0000644000076500000240000000050200000000000032057 0ustar00bmwstaff ServerName example.net ServerAlias ??.example.net *.other.example.net *another.example.net ServerAdmin webmaster@localhost DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.8077724 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/sites-enabled/0000755000076500000240000000000000000000000030164 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000022000000000000010207 xustar00122 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/sites-enabled/another_wildcard.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/sites-enabled/another_w0000644000076500000240000000043200000000000032074 0ustar00bmwstaff ServerName wildcard.tld ServerAlias ?.wildcard.tld ServerAdmin webmaster@localhost DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000021700000000000010215 xustar00121 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/sites-enabled/old-and-default.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/sites-enabled/old-and-d0000644000076500000240000000041200000000000031643 0ustar00bmwstaff ServerName ip-172-30-0-17 ServerAdmin webmaster@localhost DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000021000000000000010206 xustar00114 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/sites-enabled/wildcard.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/sites-enabled/wildcard.0000644000076500000240000000050200000000000031753 0ustar00bmwstaff ServerName example.net ServerAlias ??.example.net *.other.example.net *another.example.net ServerAdmin webmaster@localhost DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/augeas_vhosts/sites0000644000076500000240000000023100000000000025210 0ustar00bmwstaffsites-available/certbot.conf, certbot.demo sites-available/encryption-example.conf, encryption-example.demo sites-available/ocsp-ssl.conf, ocspvhost.com ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.8078947 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/default_vhost/0000755000076500000240000000000000000000000024136 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.8082745 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/default_vhost/apache2/0000755000076500000240000000000000000000000025441 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/default_vhost/apache2/apache2.conf0000644000076500000240000001461000000000000027615 0ustar00bmwstaff# This is the main Apache server configuration file. It contains the # configuration directives that give the server its instructions. # See http://httpd.apache.org/docs/2.4/ for detailed information about # the directives and /usr/share/doc/apache2/README.Debian about Debian specific # hints. # # # Summary of how the Apache 2 configuration works in Debian: # The Apache 2 web server configuration in Debian is quite different to # upstream's suggested way to configure the web server. This is because Debian's # default Apache2 installation attempts to make adding and removing modules, # virtual hosts, and extra configuration directives as flexible as possible, in # order to make automating the changes and administering the server as easy as # possible. # It is split into several files forming the configuration hierarchy outlined # below, all located in the /etc/apache2/ directory: # # /etc/apache2/ # |-- apache2.conf # | `-- ports.conf # |-- mods-enabled # | |-- *.load # | `-- *.conf # |-- conf-enabled # | `-- *.conf # `-- sites-enabled # `-- *.conf # # # * apache2.conf is the main configuration file (this file). It puts the pieces # together by including all remaining configuration files when starting up the # web server. # # * ports.conf is always included from the main configuration file. It is # supposed to determine listening ports for incoming connections which can be # customized anytime. # # * Configuration files in the mods-enabled/, conf-enabled/ and sites-enabled/ # directories contain particular configuration snippets which manage modules, # global configuration fragments, or virtual host configurations, # respectively. # # They are activated by symlinking available configuration files from their # respective *-available/ counterparts. These should be managed by using our # helpers a2enmod/a2dismod, a2ensite/a2dissite and a2enconf/a2disconf. See # their respective man pages for detailed information. # # * The binary is called apache2. Due to the use of environment variables, in # the default configuration, apache2 needs to be started/stopped with # /etc/init.d/apache2 or apache2ctl. Calling /usr/bin/apache2 directly will not # work with the default configuration. # Global configuration # # The accept serialization lock file MUST BE STORED ON A LOCAL DISK. # Mutex file:${APACHE_LOCK_DIR} default # # PidFile: The file in which the server should record its process # identification number when it starts. # This needs to be set in /etc/apache2/envvars # PidFile ${APACHE_PID_FILE} # # Timeout: The number of seconds before receives and sends time out. # Timeout 300 # # KeepAlive: Whether or not to allow persistent connections (more than # one request per connection). Set to "Off" to deactivate. # KeepAlive On # # MaxKeepAliveRequests: The maximum number of requests to allow # during a persistent connection. Set to 0 to allow an unlimited amount. # We recommend you leave this number high, for maximum performance. # MaxKeepAliveRequests 100 # # KeepAliveTimeout: Number of seconds to wait for the next request from the # same client on the same connection. # KeepAliveTimeout 5 # These need to be set in /etc/apache2/envvars User ${APACHE_RUN_USER} Group ${APACHE_RUN_GROUP} # # HostnameLookups: Log the names of clients or just their IP addresses # e.g., www.apache.org (on) or 204.62.129.132 (off). # The default is off because it'd be overall better for the net if people # had to knowingly turn this feature on, since enabling it means that # each client request will result in AT LEAST one lookup request to the # nameserver. # HostnameLookups Off # ErrorLog: The location of the error log file. # If you do not specify an ErrorLog directive within a # container, error messages relating to that virtual host will be # logged here. If you *do* define an error logfile for a # container, that host's errors will be logged there and not here. # ErrorLog ${APACHE_LOG_DIR}/error.log # # LogLevel: Control the severity of messages logged to the error_log. # Available values: trace8, ..., trace1, debug, info, notice, warn, # error, crit, alert, emerg. # It is also possible to configure the log level for particular modules, e.g. # "LogLevel info ssl:warn" # LogLevel warn # Include module configuration: IncludeOptional mods-enabled/*.load IncludeOptional mods-enabled/*.conf # Include list of ports to listen on Include ports.conf # Sets the default security model of the Apache2 HTTPD server. It does # not allow access to the root filesystem outside of /usr/share and /var/www. # The former is used by web applications packaged in Debian, # the latter may be used for local directories served by the web server. If # your system is serving content from a sub-directory in /srv you must allow # access here, or in any related virtual host. Options FollowSymLinks AllowOverride None Require all denied AllowOverride None Require all granted Options Indexes FollowSymLinks AllowOverride None Require all granted # AccessFileName: The name of the file to look for in each directory # for additional configuration directives. See also the AllowOverride # directive. # AccessFileName .htaccess # # The following lines prevent .htaccess and .htpasswd files from being # viewed by Web clients. # Require all denied # # The following directives define some format nicknames for use with # a CustomLog directive. # # These deviate from the Common Log Format definitions in that they use %O # (the actual bytes sent including headers) instead of %b (the size of the # requested file), because the latter makes it impossible to detect partial # requests. # # Note that the use of %{X-Forwarded-For}i instead of %h is not recommended. # Use mod_remoteip instead. # LogFormat "%v:%p %h %l %u %t \"%r\" %>s %O \"%{Referer}i\" \"%{User-Agent}i\"" vhost_combined LogFormat "%h %l %u %t \"%r\" %>s %O \"%{Referer}i\" \"%{User-Agent}i\"" combined LogFormat "%h %l %u %t \"%r\" %>s %O" common LogFormat "%{Referer}i -> %U" referer LogFormat "%{User-agent}i" agent # Include of directories ignores editors' and dpkg's backup files, # see README.Debian for details. # Include generic snippets of statements IncludeOptional conf-enabled/*.conf # Include the virtual host configurations: IncludeOptional sites-enabled/*.conf # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.8086438 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/default_vhost/apache2/conf-available/0000755000076500000240000000000000000000000030304 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000023000000000000010210 xustar00130 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/default_vhost/apache2/conf-available/other-vhosts-access-log.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/default_vhost/apache2/conf-available/other-vh0000644000076500000240000000027500000000000031767 0ustar00bmwstaff# Define an access log for VirtualHosts that don't define their own logfile CustomLog ${APACHE_LOG_DIR}/other_vhosts_access.log vhost_combined # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000021100000000000010207 xustar00115 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/default_vhost/apache2/conf-available/security.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/default_vhost/apache2/conf-available/security0000644000076500000240000000176600000000000032110 0ustar00bmwstaff# ServerTokens # This directive configures what you return as the Server HTTP response # Header. The default is 'Full' which sends information about the OS-Type # and compiled in modules. # Set to one of: Full | OS | Minimal | Minor | Major | Prod # where Full conveys the most information, and Prod the least. #ServerTokens Minimal ServerTokens OS #ServerTokens Full # # Optionally add a line containing the server version and virtual host # name to server-generated pages (internal error documents, FTP directory # listings, mod_status and mod_info output etc., but not CGI generated # documents or custom error documents). # Set to "EMail" to also include a mailto: link to the ServerAdmin. # Set to one of: On | Off | EMail #ServerSignature Off ServerSignature On # # Allow TRACE method # # Set to "extended" to also reflect the request body (only for testing and # diagnostic purposes). # # Set to one of: On | Off | extended TraceEnable Off #TraceEnable On # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000021600000000000010214 xustar00120 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/default_vhost/apache2/conf-available/serve-cgi-bin.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/default_vhost/apache2/conf-available/serve-cg0000644000076500000240000000070700000000000031746 0ustar00bmwstaff Define ENABLE_USR_LIB_CGI_BIN Define ENABLE_USR_LIB_CGI_BIN ScriptAlias /cgi-bin/ /usr/lib/cgi-bin/ AllowOverride None Options +ExecCGI -MultiViews +SymLinksIfOwnerMatch Require all granted # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.8090117 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/default_vhost/apache2/conf-enabled/0000755000076500000240000000000000000000000027756 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000022600000000000010215 xustar00128 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/default_vhost/apache2/conf-enabled/other-vhosts-access-log.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/default_vhost/apache2/conf-enabled/other-vhos0000644000076500000240000000027500000000000032003 0ustar00bmwstaff# Define an access log for VirtualHosts that don't define their own logfile CustomLog ${APACHE_LOG_DIR}/other_vhosts_access.log vhost_combined # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000020700000000000010214 xustar00113 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/default_vhost/apache2/conf-enabled/security.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/default_vhost/apache2/conf-enabled/security.c0000644000076500000240000000176600000000000032003 0ustar00bmwstaff# ServerTokens # This directive configures what you return as the Server HTTP response # Header. The default is 'Full' which sends information about the OS-Type # and compiled in modules. # Set to one of: Full | OS | Minimal | Minor | Major | Prod # where Full conveys the most information, and Prod the least. #ServerTokens Minimal ServerTokens OS #ServerTokens Full # # Optionally add a line containing the server version and virtual host # name to server-generated pages (internal error documents, FTP directory # listings, mod_status and mod_info output etc., but not CGI generated # documents or custom error documents). # Set to "EMail" to also include a mailto: link to the ServerAdmin. # Set to one of: On | Off | EMail #ServerSignature Off ServerSignature On # # Allow TRACE method # # Set to "extended" to also reflect the request body (only for testing and # diagnostic purposes). # # Set to one of: On | Off | extended TraceEnable Off #TraceEnable On # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000021400000000000010212 xustar00118 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/default_vhost/apache2/conf-enabled/serve-cgi-bin.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/default_vhost/apache2/conf-enabled/serve-cgi-0000644000076500000240000000070700000000000031646 0ustar00bmwstaff Define ENABLE_USR_LIB_CGI_BIN Define ENABLE_USR_LIB_CGI_BIN ScriptAlias /cgi-bin/ /usr/lib/cgi-bin/ AllowOverride None Options +ExecCGI -MultiViews +SymLinksIfOwnerMatch Require all granted # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/default_vhost/apache2/envvars0000644000076500000240000000172500000000000027055 0ustar00bmwstaff# envvars - default environment variables for apache2ctl # this won't be correct after changing uid unset HOME # for supporting multiple apache2 instances if [ "${APACHE_CONFDIR##/etc/apache2-}" != "${APACHE_CONFDIR}" ] ; then SUFFIX="-${APACHE_CONFDIR##/etc/apache2-}" else SUFFIX= fi # Since there is no sane way to get the parsed apache2 config in scripts, some # settings are defined via environment variables and then used in apache2ctl, # /etc/init.d/apache2, /etc/logrotate.d/apache2, etc. export APACHE_RUN_USER=www-data export APACHE_RUN_GROUP=www-data # temporary state file location. This might be changed to /run in Wheezy+1 export APACHE_PID_FILE=/var/run/apache2/apache2$SUFFIX.pid export APACHE_RUN_DIR=/var/run/apache2$SUFFIX export APACHE_LOCK_DIR=/var/lock/apache2$SUFFIX # Only /var/log/apache2 is handled by /etc/logrotate.d/apache2. export APACHE_LOG_DIR=/var/log/apache2$SUFFIX ## The locale used by some modules like mod_dav export LANG=C export LANG ././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1635888463.809264 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/default_vhost/apache2/mods-available/0000755000076500000240000000000000000000000030321 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/default_vhost/apache2/mods-available/ssl.conf0000644000076500000240000000651500000000000032000 0ustar00bmwstaff # Pseudo Random Number Generator (PRNG): # Configure one or more sources to seed the PRNG of the SSL library. # The seed data should be of good random quality. # WARNING! On some platforms /dev/random blocks if not enough entropy # is available. This means you then cannot use the /dev/random device # because it would lead to very long connection times (as long as # it requires to make more entropy available). But usually those # platforms additionally provide a /dev/urandom device which doesn't # block. So, if available, use this one instead. Read the mod_ssl User # Manual for more details. # SSLRandomSeed startup builtin SSLRandomSeed startup file:/dev/urandom 512 SSLRandomSeed connect builtin SSLRandomSeed connect file:/dev/urandom 512 ## ## SSL Global Context ## ## All SSL configuration in this context applies both to ## the main server and all SSL-enabled virtual hosts. ## # # Some MIME-types for downloading Certificates and CRLs # AddType application/x-x509-ca-cert .crt AddType application/x-pkcs7-crl .crl # Pass Phrase Dialog: # Configure the pass phrase gathering process. # The filtering dialog program (`builtin' is an internal # terminal dialog) has to provide the pass phrase on stdout. SSLPassPhraseDialog exec:/usr/share/apache2/ask-for-passphrase # Inter-Process Session Cache: # Configure the SSL Session Cache: First the mechanism # to use and second the expiring timeout (in seconds). # (The mechanism dbm has known memory leaks and should not be used). #SSLSessionCache dbm:${APACHE_RUN_DIR}/ssl_scache SSLSessionCache shmcb:${APACHE_RUN_DIR}/ssl_scache(512000) SSLSessionCacheTimeout 300 # Semaphore: # Configure the path to the mutual exclusion semaphore the # SSL engine uses internally for inter-process synchronization. # (Disabled by default, the global Mutex directive consolidates by default # this) #Mutex file:${APACHE_LOCK_DIR}/ssl_mutex ssl-cache # SSL Cipher Suite: # List the ciphers that the client is permitted to negotiate. See the # ciphers(1) man page from the openssl package for list of all available # options. # Enable only secure ciphers: SSLCipherSuite HIGH:MEDIUM:!aNULL:!MD5 # Speed-optimized SSL Cipher configuration: # If speed is your main concern (on busy HTTPS servers e.g.), # you might want to force clients to specific, performance # optimized ciphers. In this case, prepend those ciphers # to the SSLCipherSuite list, and enable SSLHonorCipherOrder. # Caveat: by giving precedence to RC4-SHA and AES128-SHA # (as in the example below), most connections will no longer # have perfect forward secrecy - if the server's key is # compromised, captures of past or future traffic must be # considered compromised, too. #SSLCipherSuite RC4-SHA:AES128-SHA:HIGH:MEDIUM:!aNULL:!MD5 #SSLHonorCipherOrder on # The protocols to enable. # Available values: all, SSLv3, TLSv1, TLSv1.1, TLSv1.2 # SSL v2 is no longer supported SSLProtocol all # Allow insecure renegotiation with clients which do not yet support the # secure renegotiation protocol. Default: Off #SSLInsecureRenegotiation on # Whether to forbid non-SNI clients to access name based virtual hosts. # Default: Off #SSLStrictSNIVHostCheck On # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/default_vhost/apache2/mods-available/ssl.load0000644000076500000240000000014100000000000031757 0ustar00bmwstaff# Depends: setenvif mime socache_shmcb LoadModule ssl_module /usr/lib/apache2/modules/mod_ssl.so ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/default_vhost/apache2/ports.conf0000644000076500000240000000061500000000000027461 0ustar00bmwstaff# If you just change the port or add more ports here, you will likely also # have to change the VirtualHost statement in # /etc/apache2/sites-enabled/000-default.conf Listen 80 NameVirtualHost *:80 Listen 443 Listen 443 # vim: syntax=apache ts=4 sw=4 sts=4 sr noet NameVirtualHost *:443 ././@PaxHeader0000000000000000000000000000003200000000000010210 xustar0026 mtime=1635888463.80949 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/default_vhost/apache2/sites-available/0000755000076500000240000000000000000000000030506 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000021500000000000010213 xustar00119 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/default_vhost/apache2/sites-available/000-default.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/default_vhost/apache2/sites-available/000-def0000644000076500000240000000044700000000000031471 0ustar00bmwstaff # How well does Certbot work without a ServerName/Alias? ServerAdmin webmaster@localhost DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000021500000000000010213 xustar00119 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/default_vhost/apache2/sites-available/default-ssl.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/default_vhost/apache2/sites-available/default0000644000076500000240000000216400000000000032060 0ustar00bmwstaff ServerAdmin webmaster@localhost DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined # SSL Engine Switch: # Enable/Disable SSL for this virtual host. SSLEngine on # A self-signed (snakeoil) certificate can be created by installing # the ssl-cert package. See # /usr/share/doc/apache2/README.Debian.gz for more info. # If both key and certificate are stored in the same file, only the # SSLCertificateFile directive is needed. SSLCertificateFile /etc/apache2/certs/certbot-cert_5.pem SSLCertificateKeyFile /etc/apache2/ssl/key-certbot_15.pem SSLOptions +StdEnvVars SSLOptions +StdEnvVars BrowserMatch "MSIE [2-6]" \ nokeepalive ssl-unclean-shutdown \ downgrade-1.0 force-response-1.0 # MSIE 7 and newer should be able to use keepalive BrowserMatch "MSIE [17-9]" ssl-unclean-shutdown # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.8096123 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/default_vhost/apache2/sites-enabled/0000755000076500000240000000000000000000000030160 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000021300000000000010211 xustar00117 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/default_vhost/apache2/sites-enabled/000-default.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/default_vhost/apache2/sites-enabled/000-defau0000644000076500000240000000044700000000000031471 0ustar00bmwstaff # How well does Certbot work without a ServerName/Alias? ServerAdmin webmaster@localhost DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/default_vhost/sites0000644000076500000240000000005700000000000025212 0ustar00bmwstaffsites-available/000-default.conf, default.com ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.7895095 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multi_vhosts/0000755000076500000240000000000000000000000024027 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.8099432 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multi_vhosts/apache2/0000755000076500000240000000000000000000000025332 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multi_vhosts/apache2/apache2.conf0000644000076500000240000001460500000000000027512 0ustar00bmwstaff# This is the main Apache server configuration file. It contains the # configuration directives that give the server its instructions. # See http://httpd.apache.org/docs/2.4/ for detailed information about # the directives and /usr/share/doc/apache2/README.Debian about Debian specific # hints. # # # Summary of how the Apache 2 configuration works in Debian: # The Apache 2 web server configuration in Debian is quite different to # upstream's suggested way to configure the web server. This is because Debian's # default Apache2 installation attempts to make adding and removing modules, # virtual hosts, and extra configuration directives as flexible as possible, in # order to make automating the changes and administering the server as easy as # possible. # It is split into several files forming the configuration hierarchy outlined # below, all located in the /etc/apache2/ directory: # # /etc/apache2/ # |-- apache2.conf # | `-- ports.conf # |-- mods-enabled # | |-- *.load # | `-- *.conf # |-- conf-enabled # | `-- *.conf # `-- sites-enabled # `-- *.conf # # # * apache2.conf is the main configuration file (this file). It puts the pieces # together by including all remaining configuration files when starting up the # web server. # # * ports.conf is always included from the main configuration file. It is # supposed to determine listening ports for incoming connections which can be # customized anytime. # # * Configuration files in the mods-enabled/, conf-enabled/ and sites-enabled/ # directories contain particular configuration snippets which manage modules, # global configuration fragments, or virtual host configurations, # respectively. # # They are activated by symlinking available configuration files from their # respective *-available/ counterparts. These should be managed by using our # helpers a2enmod/a2dismod, a2ensite/a2dissite and a2enconf/a2disconf. See # their respective man pages for detailed information. # # * The binary is called apache2. Due to the use of environment variables, in # the default configuration, apache2 needs to be started/stopped with # /etc/init.d/apache2 or apache2ctl. Calling /usr/bin/apache2 directly will not # work with the default configuration. # Global configuration # # The accept serialization lock file MUST BE STORED ON A LOCAL DISK. # Mutex file:${APACHE_LOCK_DIR} default # # PidFile: The file in which the server should record its process # identification number when it starts. # This needs to be set in /etc/apache2/envvars # PidFile ${APACHE_PID_FILE} # # Timeout: The number of seconds before receives and sends time out. # Timeout 300 # # KeepAlive: Whether or not to allow persistent connections (more than # one request per connection). Set to "Off" to deactivate. # KeepAlive On # # MaxKeepAliveRequests: The maximum number of requests to allow # during a persistent connection. Set to 0 to allow an unlimited amount. # We recommend you leave this number high, for maximum performance. # MaxKeepAliveRequests 100 # # KeepAliveTimeout: Number of seconds to wait for the next request from the # same client on the same connection. # KeepAliveTimeout 5 # These need to be set in /etc/apache2/envvars User ${APACHE_RUN_USER} Group ${APACHE_RUN_GROUP} # # HostnameLookups: Log the names of clients or just their IP addresses # e.g., www.apache.org (on) or 204.62.129.132 (off). # The default is off because it'd be overall better for the net if people # had to knowingly turn this feature on, since enabling it means that # each client request will result in AT LEAST one lookup request to the # nameserver. # HostnameLookups Off # ErrorLog: The location of the error log file. # If you do not specify an ErrorLog directive within a # container, error messages relating to that virtual host will be # logged here. If you *do* define an error logfile for a # container, that host's errors will be logged there and not here. # ErrorLog ${APACHE_LOG_DIR}/error.log # # LogLevel: Control the severity of messages logged to the error_log. # Available values: trace8, ..., trace1, debug, info, notice, warn, # error, crit, alert, emerg. # It is also possible to configure the log level for particular modules, e.g. # "LogLevel info ssl:warn" # LogLevel warn # Include module configuration: IncludeOptional mods-enabled/*.load IncludeOptional mods-enabled/*.conf # Include list of ports to listen on Include ports.conf # Sets the default security model of the Apache2 HTTPD server. It does # not allow access to the root filesystem outside of /usr/share and /var/www. # The former is used by web applications packaged in Debian, # the latter may be used for local directories served by the web server. If # your system is serving content from a sub-directory in /srv you must allow # access here, or in any related virtual host. Options FollowSymLinks AllowOverride None Require all denied AllowOverride None Require all granted Options Indexes FollowSymLinks AllowOverride None Require all granted # AccessFileName: The name of the file to look for in each directory # for additional configuration directives. See also the AllowOverride # directive. # AccessFileName .htaccess # # The following lines prevent .htaccess and .htpasswd files from being # viewed by Web clients. # Require all denied # The following directives define some format nicknames for use with # a CustomLog directive. # # These deviate from the Common Log Format definitions in that they use %O # (the actual bytes sent including headers) instead of %b (the size of the # requested file), because the latter makes it impossible to detect partial # requests. # # Note that the use of %{X-Forwarded-For}i instead of %h is not recommended. # Use mod_remoteip instead. # LogFormat "%v:%p %h %l %u %t \"%r\" %>s %O \"%{Referer}i\" \"%{User-Agent}i\"" vhost_combined LogFormat "%h %l %u %t \"%r\" %>s %O \"%{Referer}i\" \"%{User-Agent}i\"" combined LogFormat "%h %l %u %t \"%r\" %>s %O" common LogFormat "%{Referer}i -> %U" referer LogFormat "%{User-agent}i" agent # Include of directories ignores editors' and dpkg's backup files, # see README.Debian for details. # Include generic snippets of statements IncludeOptional conf-enabled/*.conf # Include the virtual host configurations: IncludeOptional sites-enabled/*.conf # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multi_vhosts/apache2/envvars0000644000076500000240000000172600000000000026747 0ustar00bmwstaff# envvars - default environment variables for apache2ctl # this won't be correct after changing uid unset HOME # for supporting multiple apache2 instances if [ "${APACHE_CONFDIR##/etc/apache2-}" != "${APACHE_CONFDIR}" ] ; then SUFFIX="-${APACHE_CONFDIR##/etc/apache2-}" else SUFFIX= fi # Since there is no sane way to get the parsed apache2 config in scripts, some # settings are defined via environment variables and then used in apache2ctl, # /etc/init.d/apache2, /etc/logrotate.d/apache2, etc. export APACHE_RUN_USER=www-data export APACHE_RUN_GROUP=www-data # temporary state file location. This might be changed to /run in Wheezy+1 export APACHE_PID_FILE=/var/run/apache2/apache2$SUFFIX.pid export APACHE_RUN_DIR=/var/run/apache2$SUFFIX export APACHE_LOCK_DIR=/var/lock/apache2$SUFFIX # Only /var/log/apache2 is handled by /etc/logrotate.d/apache2. export APACHE_LOG_DIR=/var/log/apache2$SUFFIX ## The locale used by some modules like mod_dav export LANG=C export LANG ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multi_vhosts/apache2/ports.conf0000644000076500000240000000050000000000000027343 0ustar00bmwstaff# If you just change the port or add more ports here, you will likely also # have to change the VirtualHost statement in # /etc/apache2/sites-enabled/000-default.conf Listen 80 Listen 443 Listen 443 # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.8101718 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multi_vhosts/apache2/sites-available/0000755000076500000240000000000000000000000030377 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000021000000000000010206 xustar00114 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multi_vhosts/apache2/sites-available/default.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multi_vhosts/apache2/sites-available/default.0000644000076500000240000000073200000000000032026 0ustar00bmwstaff ServerName banana.vomit.net ServerAdmin webmaster@localhost DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined ServerName banana.vomit.com ServerAdmin webmaster@localhost DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000021400000000000010212 xustar00118 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multi_vhosts/apache2/sites-available/multi-vhost.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multi_vhosts/apache2/sites-available/multi-vh0000644000076500000240000000240000000000000032063 0ustar00bmwstaff ServerName 1.multi.vhost.tld ServerAlias first.multi.vhost.tld ServerAdmin webmaster@localhost DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined ServerName 2.multi.vhost.tld ServerAlias second.multi.vhost.tld ServerAdmin webmaster@localhost DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined RewriteEngine on RewriteCond %{DOCUMENT_ROOT}/%{REQUEST_FILENAME} !-f RewriteRule ^(.*)$ b://u%{REQUEST_URI} [P,NE,L] RewriteCond %{HTTPS} !=on RewriteCond %{HTTPS} !^$ RewriteRule ^ https://%{SERVER_NAME}%{REQUEST_URI} [L,NE,R=permanent] ServerName 3.multi.vhost.tld ServerAlias third.multi.vhost.tld ServerAdmin webmaster@localhost DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined RewriteEngine on RewriteRule "^/secrets/(.+)" "https://new.example.com/docs/$1" [R,L] RewriteRule "^/docs/(.+)" "http://new.example.com/docs/$1" [R,L] ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.8103878 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multi_vhosts/apache2/sites-enabled/0000755000076500000240000000000000000000000030051 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000020600000000000010213 xustar00112 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multi_vhosts/apache2/sites-enabled/default.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multi_vhosts/apache2/sites-enabled/default.co0000644000076500000240000000073200000000000032022 0ustar00bmwstaff ServerName banana.vomit.net ServerAdmin webmaster@localhost DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined ServerName banana.vomit.com ServerAdmin webmaster@localhost DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000021200000000000010210 xustar00116 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multi_vhosts/apache2/sites-enabled/multi-vhost.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multi_vhosts/apache2/sites-enabled/multi-vhos0000644000076500000240000000240000000000000032077 0ustar00bmwstaff ServerName 1.multi.vhost.tld ServerAlias first.multi.vhost.tld ServerAdmin webmaster@localhost DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined ServerName 2.multi.vhost.tld ServerAlias second.multi.vhost.tld ServerAdmin webmaster@localhost DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined RewriteEngine on RewriteCond %{DOCUMENT_ROOT}/%{REQUEST_FILENAME} !-f RewriteRule ^(.*)$ b://u%{REQUEST_URI} [P,NE,L] RewriteCond %{HTTPS} !=on RewriteCond %{HTTPS} !^$ RewriteRule ^ https://%{SERVER_NAME}%{REQUEST_URI} [L,NE,R=permanent] ServerName 3.multi.vhost.tld ServerAlias third.multi.vhost.tld ServerAdmin webmaster@localhost DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined RewriteEngine on RewriteRule "^/secrets/(.+)" "https://new.example.com/docs/$1" [R,L] RewriteRule "^/docs/(.+)" "http://new.example.com/docs/$1" [R,L] ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.8104942 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/0000755000076500000240000000000000000000000024530 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.8108728 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/0000755000076500000240000000000000000000000026033 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/apache2.conf0000644000076500000240000001513500000000000030212 0ustar00bmwstaff# This is the main Apache server configuration file. It contains the # configuration directives that give the server its instructions. # See http://httpd.apache.org/docs/2.4/ for detailed information about # the directives and /usr/share/doc/apache2/README.Debian about Debian specific # hints. # # # Summary of how the Apache 2 configuration works in Debian: # The Apache 2 web server configuration in Debian is quite different to # upstream's suggested way to configure the web server. This is because Debian's # default Apache2 installation attempts to make adding and removing modules, # virtual hosts, and extra configuration directives as flexible as possible, in # order to make automating the changes and administering the server as easy as # possible. # It is split into several files forming the configuration hierarchy outlined # below, all located in the /etc/apache2/ directory: # # /etc/apache2/ # |-- apache2.conf # | `-- ports.conf # |-- mods-enabled # | |-- *.load # | `-- *.conf # |-- conf-enabled # | `-- *.conf # `-- sites-enabled # `-- *.conf # # # * apache2.conf is the main configuration file (this file). It puts the pieces # together by including all remaining configuration files when starting up the # web server. # # * ports.conf is always included from the main configuration file. It is # supposed to determine listening ports for incoming connections which can be # customized anytime. # # * Configuration files in the mods-enabled/, conf-enabled/ and sites-enabled/ # directories contain particular configuration snippets which manage modules, # global configuration fragments, or virtual host configurations, # respectively. # # They are activated by symlinking available configuration files from their # respective *-available/ counterparts. These should be managed by using our # helpers a2enmod/a2dismod, a2ensite/a2dissite and a2enconf/a2disconf. See # their respective man pages for detailed information. # # * The binary is called apache2. Due to the use of environment variables, in # the default configuration, apache2 needs to be started/stopped with # /etc/init.d/apache2 or apache2ctl. Calling /usr/bin/apache2 directly will not # work with the default configuration. # Global configuration # # The accept serialization lock file MUST BE STORED ON A LOCAL DISK. # Mutex file:${APACHE_LOCK_DIR} default # # PidFile: The file in which the server should record its process # identification number when it starts. # This needs to be set in /etc/apache2/envvars # PidFile ${APACHE_PID_FILE} # # Timeout: The number of seconds before receives and sends time out. # Timeout 300 # # KeepAlive: Whether or not to allow persistent connections (more than # one request per connection). Set to "Off" to deactivate. # KeepAlive On # # MaxKeepAliveRequests: The maximum number of requests to allow # during a persistent connection. Set to 0 to allow an unlimited amount. # We recommend you leave this number high, for maximum performance. # MaxKeepAliveRequests 100 # # KeepAliveTimeout: Number of seconds to wait for the next request from the # same client on the same connection. # KeepAliveTimeout 5 # These need to be set in /etc/apache2/envvars User ${APACHE_RUN_USER} Group ${APACHE_RUN_GROUP} # # HostnameLookups: Log the names of clients or just their IP addresses # e.g., www.apache.org (on) or 204.62.129.132 (off). # The default is off because it'd be overall better for the net if people # had to knowingly turn this feature on, since enabling it means that # each client request will result in AT LEAST one lookup request to the # nameserver. # HostnameLookups Off # ErrorLog: The location of the error log file. # If you do not specify an ErrorLog directive within a # container, error messages relating to that virtual host will be # logged here. If you *do* define an error logfile for a # container, that host's errors will be logged there and not here. # ErrorLog ${APACHE_LOG_DIR}/error.log # # LogLevel: Control the severity of messages logged to the error_log. # Available values: trace8, ..., trace1, debug, info, notice, warn, # error, crit, alert, emerg. # It is also possible to configure the log level for particular modules, e.g. # "LogLevel info ssl:warn" # LogLevel warn # Include module configuration: IncludeOptional mods-enabled/*.load IncludeOptional mods-enabled/*.conf # Include list of ports to listen on Include ports.conf # Sets the default security model of the Apache2 HTTPD server. It does # not allow access to the root filesystem outside of /usr/share and /var/www. # The former is used by web applications packaged in Debian, # the latter may be used for local directories served by the web server. If # your system is serving content from a sub-directory in /srv you must allow # access here, or in any related virtual host. Options FollowSymLinks AllowOverride None Require all denied AllowOverride None Require all granted Options Indexes FollowSymLinks AllowOverride None Require all granted # AccessFileName: The name of the file to look for in each directory # for additional configuration directives. See also the AllowOverride # directive. # AccessFileName .htaccess # # The following lines prevent .htaccess and .htpasswd files from being # viewed by Web clients. # Require all denied # The following directives define some format nicknames for use with # a CustomLog directive. # # These deviate from the Common Log Format definitions in that they use %O # (the actual bytes sent including headers) instead of %b (the size of the # requested file), because the latter makes it impossible to detect partial # requests. # # Note that the use of %{X-Forwarded-For}i instead of %h is not recommended. # Use mod_remoteip instead. # LogFormat "%v:%p %h %l %u %t \"%r\" %>s %O \"%{Referer}i\" \"%{User-Agent}i\"" vhost_combined LogFormat "%h %l %u %t \"%r\" %>s %O \"%{Referer}i\" \"%{User-Agent}i\"" combined LogFormat "%h %l %u %t \"%r\" %>s %O" common LogFormat "%{Referer}i -> %U" referer LogFormat "%{User-agent}i" agent # Include of directories ignores editors' and dpkg's backup files, # see README.Debian for details. # Include generic snippets of statements IncludeOptional conf-enabled/*.conf # Include the virtual host configurations: IncludeOptional sites-enabled/*.conf ServerName vhost.in.rootconf ServerAdmin webmaster@localhost DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1635888463.811441 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/conf-available/0000755000076500000240000000000000000000000030676 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000022000000000000010207 xustar00122 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/conf-available/bad_conf_file.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/conf-available/bad_co0000644000076500000240000000005600000000000032031 0ustar00bmwstaff ServerName invalid.net ././@PaxHeader0000000000000000000000000000023200000000000010212 xustar00132 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/conf-available/other-vhosts-access-log.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/conf-available/other-0000644000076500000240000000027500000000000032023 0ustar00bmwstaff# Define an access log for VirtualHosts that don't define their own logfile CustomLog ${APACHE_LOG_DIR}/other_vhosts_access.log vhost_combined # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000021300000000000010211 xustar00117 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/conf-available/security.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/conf-available/securi0000644000076500000240000000221500000000000032113 0ustar00bmwstaff# Changing the following options will not really affect the security of the # server, but might make attacks slightly more difficult in some cases. # # ServerTokens # This directive configures what you return as the Server HTTP response # Header. The default is 'Full' which sends information about the OS-Type # and compiled in modules. # Set to one of: Full | OS | Minimal | Minor | Major | Prod # where Full conveys the most information, and Prod the least. #ServerTokens Minimal ServerTokens OS #ServerTokens Full # # Optionally add a line containing the server version and virtual host # name to server-generated pages (internal error documents, FTP directory # listings, mod_status and mod_info output etc., but not CGI generated # documents or custom error documents). # Set to "EMail" to also include a mailto: link to the ServerAdmin. # Set to one of: On | Off | EMail #ServerSignature Off ServerSignature On # # Allow TRACE method # # Set to "extended" to also reflect the request body (only for testing and # diagnostic purposes). # # Set to one of: On | Off | extended TraceEnable Off #TraceEnable On # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000022000000000000010207 xustar00122 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/conf-available/serve-cgi-bin.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/conf-available/serve-0000644000076500000240000000070700000000000032026 0ustar00bmwstaff Define ENABLE_USR_LIB_CGI_BIN Define ENABLE_USR_LIB_CGI_BIN ScriptAlias /cgi-bin/ /usr/lib/cgi-bin/ AllowOverride None Options +ExecCGI -MultiViews +SymLinksIfOwnerMatch Require all granted # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1635888463.811862 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/conf-enabled/0000755000076500000240000000000000000000000030350 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000023000000000000010210 xustar00130 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/conf-enabled/other-vhosts-access-log.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/conf-enabled/other-vh0000644000076500000240000000027500000000000032033 0ustar00bmwstaff# Define an access log for VirtualHosts that don't define their own logfile CustomLog ${APACHE_LOG_DIR}/other_vhosts_access.log vhost_combined # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000021100000000000010207 xustar00115 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/conf-enabled/security.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/conf-enabled/security0000644000076500000240000000221500000000000032142 0ustar00bmwstaff# Changing the following options will not really affect the security of the # server, but might make attacks slightly more difficult in some cases. # # ServerTokens # This directive configures what you return as the Server HTTP response # Header. The default is 'Full' which sends information about the OS-Type # and compiled in modules. # Set to one of: Full | OS | Minimal | Minor | Major | Prod # where Full conveys the most information, and Prod the least. #ServerTokens Minimal ServerTokens OS #ServerTokens Full # # Optionally add a line containing the server version and virtual host # name to server-generated pages (internal error documents, FTP directory # listings, mod_status and mod_info output etc., but not CGI generated # documents or custom error documents). # Set to "EMail" to also include a mailto: link to the ServerAdmin. # Set to one of: On | Off | EMail #ServerSignature Off ServerSignature On # # Allow TRACE method # # Set to "extended" to also reflect the request body (only for testing and # diagnostic purposes). # # Set to one of: On | Off | extended TraceEnable Off #TraceEnable On # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000021600000000000010214 xustar00120 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/conf-enabled/serve-cgi-bin.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/conf-enabled/serve-cg0000644000076500000240000000070700000000000032012 0ustar00bmwstaff Define ENABLE_USR_LIB_CGI_BIN Define ENABLE_USR_LIB_CGI_BIN ScriptAlias /cgi-bin/ /usr/lib/cgi-bin/ AllowOverride None Options +ExecCGI -MultiViews +SymLinksIfOwnerMatch Require all granted # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/envvars0000644000076500000240000000172600000000000027450 0ustar00bmwstaff# envvars - default environment variables for apache2ctl # this won't be correct after changing uid unset HOME # for supporting multiple apache2 instances if [ "${APACHE_CONFDIR##/etc/apache2-}" != "${APACHE_CONFDIR}" ] ; then SUFFIX="-${APACHE_CONFDIR##/etc/apache2-}" else SUFFIX= fi # Since there is no sane way to get the parsed apache2 config in scripts, some # settings are defined via environment variables and then used in apache2ctl, # /etc/init.d/apache2, /etc/logrotate.d/apache2, etc. export APACHE_RUN_USER=www-data export APACHE_RUN_GROUP=www-data # temporary state file location. This might be changed to /run in Wheezy+1 export APACHE_PID_FILE=/var/run/apache2/apache2$SUFFIX.pid export APACHE_RUN_DIR=/var/run/apache2$SUFFIX export APACHE_LOCK_DIR=/var/lock/apache2$SUFFIX # Only /var/log/apache2 is handled by /etc/logrotate.d/apache2. export APACHE_LOG_DIR=/var/log/apache2$SUFFIX ## The locale used by some modules like mod_dav export LANG=C export LANG ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.8128386 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/mods-available/0000755000076500000240000000000000000000000030713 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000021400000000000010212 xustar00118 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/mods-available/authz_svn.load 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/mods-available/authz_0000644000076500000240000000024500000000000032131 0ustar00bmwstaff# Depends: dav_svn Include mods-enabled/dav_svn.load LoadModule authz_svn_module /usr/lib/apache2/modules/mod_authz_svn.so ././@PaxHeader0000000000000000000000000000020600000000000010213 xustar00112 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/mods-available/dav.load 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/mods-available/dav.lo0000644000076500000240000000013500000000000032020 0ustar00bmwstaff LoadModule dav_module /usr/lib/apache2/modules/mod_dav.so ././@PaxHeader0000000000000000000000000000021200000000000010210 xustar00116 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/mods-available/dav_svn.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/mods-available/dav_sv0000644000076500000240000000450400000000000032123 0ustar00bmwstaff# dav_svn.conf - Example Subversion/Apache configuration # # For details and further options see the Apache user manual and # the Subversion book. # # NOTE: for a setup with multiple vhosts, you will want to do this # configuration in /etc/apache2/sites-available/*, not here. # ... # URL controls how the repository appears to the outside world. # In this example clients access the repository as http://hostname/svn/ # Note, a literal /svn should NOT exist in your document root. # # Uncomment this to enable the repository #DAV svn # Set this to the path to your repository #SVNPath /var/lib/svn # Alternatively, use SVNParentPath if you have multiple repositories under # under a single directory (/var/lib/svn/repo1, /var/lib/svn/repo2, ...). # You need either SVNPath and SVNParentPath, but not both. #SVNParentPath /var/lib/svn # Access control is done at 3 levels: (1) Apache authentication, via # any of several methods. A "Basic Auth" section is commented out # below. (2) Apache and , also commented out # below. (3) mod_authz_svn is a svn-specific authorization module # which offers fine-grained read/write access control for paths # within a repository. (The first two layers are coarse-grained; you # can only enable/disable access to an entire repository.) Note that # mod_authz_svn is noticeably slower than the other two layers, so if # you don't need the fine-grained control, don't configure it. # Basic Authentication is repository-wide. It is not secure unless # you are using https. See the 'htpasswd' command to create and # manage the password file - and the documentation for the # 'auth_basic' and 'authn_file' modules, which you will need for this # (enable them with 'a2enmod'). #AuthType Basic #AuthName "Subversion Repository" #AuthUserFile /etc/apache2/dav_svn.passwd # To enable authorization via mod_authz_svn (enable that module separately): # #AuthzSVNAccessFile /etc/apache2/dav_svn.authz # # The following three lines allow anonymous read, but make # committers authenticate themselves. It requires the 'authz_user' # module (enable it with 'a2enmod'). # #Require valid-user # # ././@PaxHeader0000000000000000000000000000021200000000000010210 xustar00116 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/mods-available/dav_svn.load 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/mods-available/dav_sv0000644000076500000240000000031300000000000032115 0ustar00bmwstaff# Depends: dav Include mods-enabled/dav.load LoadModule dav_svn_module /usr/lib/apache2/modules/mod_dav_svn.so ././@PaxHeader0000000000000000000000000000021200000000000010210 xustar00116 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/mods-available/rewrite.load 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/mods-available/rewrit0000644000076500000240000000010200000000000032143 0ustar00bmwstaffLoadModule rewrite_module /usr/lib/apache2/modules/mod_rewrite.so ././@PaxHeader0000000000000000000000000000020600000000000010213 xustar00112 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/mods-available/ssl.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/mods-available/ssl.co0000644000076500000240000000651500000000000032046 0ustar00bmwstaff # Pseudo Random Number Generator (PRNG): # Configure one or more sources to seed the PRNG of the SSL library. # The seed data should be of good random quality. # WARNING! On some platforms /dev/random blocks if not enough entropy # is available. This means you then cannot use the /dev/random device # because it would lead to very long connection times (as long as # it requires to make more entropy available). But usually those # platforms additionally provide a /dev/urandom device which doesn't # block. So, if available, use this one instead. Read the mod_ssl User # Manual for more details. # SSLRandomSeed startup builtin SSLRandomSeed startup file:/dev/urandom 512 SSLRandomSeed connect builtin SSLRandomSeed connect file:/dev/urandom 512 ## ## SSL Global Context ## ## All SSL configuration in this context applies both to ## the main server and all SSL-enabled virtual hosts. ## # # Some MIME-types for downloading Certificates and CRLs # AddType application/x-x509-ca-cert .crt AddType application/x-pkcs7-crl .crl # Pass Phrase Dialog: # Configure the pass phrase gathering process. # The filtering dialog program (`builtin' is an internal # terminal dialog) has to provide the pass phrase on stdout. SSLPassPhraseDialog exec:/usr/share/apache2/ask-for-passphrase # Inter-Process Session Cache: # Configure the SSL Session Cache: First the mechanism # to use and second the expiring timeout (in seconds). # (The mechanism dbm has known memory leaks and should not be used). #SSLSessionCache dbm:${APACHE_RUN_DIR}/ssl_scache SSLSessionCache shmcb:${APACHE_RUN_DIR}/ssl_scache(512000) SSLSessionCacheTimeout 300 # Semaphore: # Configure the path to the mutual exclusion semaphore the # SSL engine uses internally for inter-process synchronization. # (Disabled by default, the global Mutex directive consolidates by default # this) #Mutex file:${APACHE_LOCK_DIR}/ssl_mutex ssl-cache # SSL Cipher Suite: # List the ciphers that the client is permitted to negotiate. See the # ciphers(1) man page from the openssl package for list of all available # options. # Enable only secure ciphers: SSLCipherSuite HIGH:MEDIUM:!aNULL:!MD5 # Speed-optimized SSL Cipher configuration: # If speed is your main concern (on busy HTTPS servers e.g.), # you might want to force clients to specific, performance # optimized ciphers. In this case, prepend those ciphers # to the SSLCipherSuite list, and enable SSLHonorCipherOrder. # Caveat: by giving precedence to RC4-SHA and AES128-SHA # (as in the example below), most connections will no longer # have perfect forward secrecy - if the server's key is # compromised, captures of past or future traffic must be # considered compromised, too. #SSLCipherSuite RC4-SHA:AES128-SHA:HIGH:MEDIUM:!aNULL:!MD5 #SSLHonorCipherOrder on # The protocols to enable. # Available values: all, SSLv3, TLSv1, TLSv1.1, TLSv1.2 # SSL v2 is no longer supported SSLProtocol all # Allow insecure renegotiation with clients which do not yet support the # secure renegotiation protocol. Default: Off #SSLInsecureRenegotiation on # Whether to forbid non-SNI clients to access name based virtual hosts. # Default: Off #SSLStrictSNIVHostCheck On # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000020600000000000010213 xustar00112 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/mods-available/ssl.load 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/mods-available/ssl.lo0000644000076500000240000000014100000000000032044 0ustar00bmwstaff# Depends: setenvif mime socache_shmcb LoadModule ssl_module /usr/lib/apache2/modules/mod_ssl.so ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.8133492 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/mods-enabled/0000755000076500000240000000000000000000000030365 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000021200000000000010210 xustar00116 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/mods-enabled/authz_svn.load 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/mods-enabled/authz_sv0000644000076500000240000000024500000000000032154 0ustar00bmwstaff# Depends: dav_svn Include mods-enabled/dav_svn.load LoadModule authz_svn_module /usr/lib/apache2/modules/mod_authz_svn.so ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/mods-enabled/dav.load0000644000076500000240000000013500000000000031777 0ustar00bmwstaff LoadModule dav_module /usr/lib/apache2/modules/mod_dav.so ././@PaxHeader0000000000000000000000000000021000000000000010206 xustar00114 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/mods-enabled/dav_svn.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/mods-enabled/dav_svn.0000644000076500000240000000450400000000000032031 0ustar00bmwstaff# dav_svn.conf - Example Subversion/Apache configuration # # For details and further options see the Apache user manual and # the Subversion book. # # NOTE: for a setup with multiple vhosts, you will want to do this # configuration in /etc/apache2/sites-available/*, not here. # ... # URL controls how the repository appears to the outside world. # In this example clients access the repository as http://hostname/svn/ # Note, a literal /svn should NOT exist in your document root. # # Uncomment this to enable the repository #DAV svn # Set this to the path to your repository #SVNPath /var/lib/svn # Alternatively, use SVNParentPath if you have multiple repositories under # under a single directory (/var/lib/svn/repo1, /var/lib/svn/repo2, ...). # You need either SVNPath and SVNParentPath, but not both. #SVNParentPath /var/lib/svn # Access control is done at 3 levels: (1) Apache authentication, via # any of several methods. A "Basic Auth" section is commented out # below. (2) Apache and , also commented out # below. (3) mod_authz_svn is a svn-specific authorization module # which offers fine-grained read/write access control for paths # within a repository. (The first two layers are coarse-grained; you # can only enable/disable access to an entire repository.) Note that # mod_authz_svn is noticeably slower than the other two layers, so if # you don't need the fine-grained control, don't configure it. # Basic Authentication is repository-wide. It is not secure unless # you are using https. See the 'htpasswd' command to create and # manage the password file - and the documentation for the # 'auth_basic' and 'authn_file' modules, which you will need for this # (enable them with 'a2enmod'). #AuthType Basic #AuthName "Subversion Repository" #AuthUserFile /etc/apache2/dav_svn.passwd # To enable authorization via mod_authz_svn (enable that module separately): # #AuthzSVNAccessFile /etc/apache2/dav_svn.authz # # The following three lines allow anonymous read, but make # committers authenticate themselves. It requires the 'authz_user' # module (enable it with 'a2enmod'). # #Require valid-user # # ././@PaxHeader0000000000000000000000000000021000000000000010206 xustar00114 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/mods-enabled/dav_svn.load 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/mods-enabled/dav_svn.0000644000076500000240000000031300000000000032023 0ustar00bmwstaff# Depends: dav Include mods-enabled/dav.load LoadModule dav_svn_module /usr/lib/apache2/modules/mod_dav_svn.so ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/ports.conf0000644000076500000240000000050000000000000030044 0ustar00bmwstaff# If you just change the port or add more ports here, you will likely also # have to change the VirtualHost statement in # /etc/apache2/sites-enabled/000-default.conf Listen 80 Listen 443 Listen 443 # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.8148634 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-available/0000755000076500000240000000000000000000000031100 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000021700000000000010215 xustar00121 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-available/000-default.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-available/000-d0000644000076500000240000000041200000000000031540 0ustar00bmwstaff ServerName ip-172-30-0-17 ServerAdmin webmaster@localhost DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000021300000000000010211 xustar00117 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-available/certbot.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-available/certb0000644000076500000240000000165500000000000032131 0ustar00bmwstaff ServerName certbot.demo ServerAlias www.certbot.demo ServerAdmin webmaster@localhost DocumentRoot /var/www-certbot-reworld/static/ Options FollowSymLinks AllowOverride None Options Indexes FollowSymLinks MultiViews AllowOverride None Order allow,deny allow from all ScriptAlias /cgi-bin/ /usr/lib/cgi-bin/ AllowOverride None Options +ExecCGI -MultiViews +SymLinksIfOwnerMatch Order allow,deny Allow from all ErrorLog ${APACHE_LOG_DIR}/error.log # Possible values include: debug, info, notice, warn, error, crit, # alert, emerg. LogLevel warn CustomLog ${APACHE_LOG_DIR}/access.log combined Alias /doc/ "/usr/share/doc/" Options Indexes MultiViews FollowSymLinks AllowOverride None Order deny,allow Deny from all Allow from 127.0.0.0/255.0.0.0 ::1/128 ././@PaxHeader0000000000000000000000000000023100000000000010211 xustar00131 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-available/default-ssl-port-only.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-available/defau0000644000076500000240000000213000000000000032103 0ustar00bmwstaff ServerAdmin webmaster@localhost DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined # A self-signed (snakeoil) certificate can be created by installing # the ssl-cert package. See # /usr/share/doc/apache2/README.Debian.gz for more info. # If both key and certificate are stored in the same file, only the # SSLCertificateFile directive is needed. SSLCertificateFile /etc/apache2/certs/certbot-cert_5.pem SSLCertificateKeyFile /etc/apache2/ssl/key-certbot_15.pem #SSLOptions +FakeBasicAuth +ExportCertData +StrictRequire SSLOptions +StdEnvVars SSLOptions +StdEnvVars BrowserMatch "MSIE [2-6]" \ nokeepalive ssl-unclean-shutdown \ downgrade-1.0 force-response-1.0 # MSIE 7 and newer should be able to use keepalive BrowserMatch "MSIE [17-9]" ssl-unclean-shutdown # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000021700000000000010215 xustar00121 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-available/default-ssl.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-available/defau0000644000076500000240000000226100000000000032110 0ustar00bmwstaff ServerAdmin webmaster@localhost DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined # SSL Engine Switch: # Enable/Disable SSL for this virtual host. SSLEngine on # A self-signed (snakeoil) certificate can be created by installing # the ssl-cert package. See # /usr/share/doc/apache2/README.Debian.gz for more info. # If both key and certificate are stored in the same file, only the # SSLCertificateFile directive is needed. SSLCertificateFile /etc/apache2/certs/certbot-cert_5.pem SSLCertificateKeyFile /etc/apache2/ssl/key-certbot_15.pem #SSLOptions +FakeBasicAuth +ExportCertData +StrictRequire SSLOptions +StdEnvVars SSLOptions +StdEnvVars BrowserMatch "MSIE [2-6]" \ nokeepalive ssl-unclean-shutdown \ downgrade-1.0 force-response-1.0 # MSIE 7 and newer should be able to use keepalive BrowserMatch "MSIE [17-9]" ssl-unclean-shutdown # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000022100000000000010210 xustar00123 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-available/duplicatehttp.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-available/dupli0000644000076500000240000000034400000000000032141 0ustar00bmwstaff ServerName duplicate.example.com ServerAdmin webmaster@certbot.demo DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined ././@PaxHeader0000000000000000000000000000022200000000000010211 xustar00124 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-available/duplicatehttps.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-available/dupli0000644000076500000240000000057200000000000032144 0ustar00bmwstaff ServerName duplicate.example.com ServerAdmin webmaster@certbot.demo DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined SSLCertificateFile /etc/apache2/certs/certbot-cert_5.pem SSLCertificateKeyFile /etc/apache2/ssl/key-certbot_15.pem ././@PaxHeader0000000000000000000000000000021100000000000010207 xustar00115 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-available/empty.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-available/empty0000644000076500000240000000000000000000000032147 0ustar00bmwstaff././@PaxHeader0000000000000000000000000000022600000000000010215 xustar00128 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-available/encryption-example.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-available/encry0000644000076500000240000000220500000000000032142 0ustar00bmwstaff ServerName encryption-example.demo ServerAdmin webmaster@localhost DocumentRoot /var/www-encryption-example/static/ Options FollowSymLinks AllowOverride None Options Indexes FollowSymLinks MultiViews AllowOverride None Order allow,deny allow from all ScriptAlias /cgi-bin/ /usr/lib/cgi-bin/ AllowOverride None Options +ExecCGI -MultiViews +SymLinksIfOwnerMatch Order allow,deny Allow from all ErrorLog ${APACHE_LOG_DIR}/error.log # Possible values include: debug, info, notice, warn, error, crit, # alert, emerg. LogLevel warn CustomLog ${APACHE_LOG_DIR}/access.log combined Alias /doc/ "/usr/share/doc/" Options Indexes MultiViews FollowSymLinks AllowOverride None Order deny,allow Deny from all Allow from 127.0.0.0/255.0.0.0 ::1/128 ././@PaxHeader0000000000000000000000000000022500000000000010214 xustar00127 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-available/mod_macro-example.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-available/mod_m0000644000076500000240000000057100000000000032121 0ustar00bmwstaff ServerName $domain ServerAlias www.$domain DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined Use VHost macro1 test.com Use VHost macro2 hostname.org Use VHost macro3 apache.org # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000022100000000000010210 xustar00123 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-available/no-directives.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-available/no-di0000644000076500000240000000013200000000000032025 0ustar00bmwstaff Require all denied ././@PaxHeader0000000000000000000000000000021400000000000010212 xustar00118 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-available/ocsp-ssl.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-available/ocsp-0000644000076500000240000000304000000000000032041 0ustar00bmwstaff SSLStaplingCache shmcb:/var/run/apache2/stapling_cache(128000) # The ServerName directive sets the request scheme, hostname and port that # the server uses to identify itself. This is used when creating # redirection URLs. In the context of virtual hosts, the ServerName # specifies what hostname must appear in the request's Host: header to # match this virtual host. For the default virtual host (this file) this # value is not decisive as it is used as a last resort host regardless. # However, you must set it for any further virtual host explicitly. ServerName ocspvhost.com ServerAdmin webmaster@dumpbits.com DocumentRoot /var/www/html # Available loglevels: trace8, ..., trace1, debug, info, notice, warn, # error, crit, alert, emerg. # It is also possible to configure the loglevel for particular # modules, e.g. #LogLevel info ssl:warn ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined # For most configuration files from conf-available/, which are # enabled or disabled at a global level, it is possible to # include a line for only one particular virtual host. For example the # following line enables the CGI configuration for this host only # after it has been globally disabled with "a2disconf". #Include conf-available/serve-cgi-bin.conf SSLCertificateFile /etc/apache2/certs/certbot-cert_5.pem SSLCertificateKeyFile /etc/apache2/ssl/key-certbot_15.pem SSLUseStapling on # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000021400000000000010212 xustar00118 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-available/wildcard.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-available/wildc0000644000076500000240000000044100000000000032124 0ustar00bmwstaff ServerName ip-172-30-0-17 ServerAdmin webmaster@localhost DocumentRoot /var/www/html ServerAlias *.blue.purple.com ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1635888463.816096 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-enabled/0000755000076500000240000000000000000000000030552 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000021500000000000010213 xustar00119 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-enabled/000-default.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-enabled/000-def0000644000076500000240000000041200000000000031525 0ustar00bmwstaff ServerName ip-172-30-0-17 ServerAdmin webmaster@localhost DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000021100000000000010207 xustar00115 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-enabled/certbot.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-enabled/certbot0000644000076500000240000000165500000000000032146 0ustar00bmwstaff ServerName certbot.demo ServerAlias www.certbot.demo ServerAdmin webmaster@localhost DocumentRoot /var/www-certbot-reworld/static/ Options FollowSymLinks AllowOverride None Options Indexes FollowSymLinks MultiViews AllowOverride None Order allow,deny allow from all ScriptAlias /cgi-bin/ /usr/lib/cgi-bin/ AllowOverride None Options +ExecCGI -MultiViews +SymLinksIfOwnerMatch Order allow,deny Allow from all ErrorLog ${APACHE_LOG_DIR}/error.log # Possible values include: debug, info, notice, warn, error, crit, # alert, emerg. LogLevel warn CustomLog ${APACHE_LOG_DIR}/access.log combined Alias /doc/ "/usr/share/doc/" Options Indexes MultiViews FollowSymLinks AllowOverride None Order deny,allow Deny from all Allow from 127.0.0.0/255.0.0.0 ::1/128 ././@PaxHeader0000000000000000000000000000022700000000000010216 xustar00129 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-enabled/default-ssl-port-only.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-enabled/default0000644000076500000240000000213000000000000032115 0ustar00bmwstaff ServerAdmin webmaster@localhost DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined # A self-signed (snakeoil) certificate can be created by installing # the ssl-cert package. See # /usr/share/doc/apache2/README.Debian.gz for more info. # If both key and certificate are stored in the same file, only the # SSLCertificateFile directive is needed. SSLCertificateFile /etc/apache2/certs/certbot-cert_5.pem SSLCertificateKeyFile /etc/apache2/ssl/key-certbot_15.pem #SSLOptions +FakeBasicAuth +ExportCertData +StrictRequire SSLOptions +StdEnvVars SSLOptions +StdEnvVars BrowserMatch "MSIE [2-6]" \ nokeepalive ssl-unclean-shutdown \ downgrade-1.0 force-response-1.0 # MSIE 7 and newer should be able to use keepalive BrowserMatch "MSIE [17-9]" ssl-unclean-shutdown # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000021500000000000010213 xustar00119 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-enabled/default-ssl.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-enabled/default0000644000076500000240000000226100000000000032122 0ustar00bmwstaff ServerAdmin webmaster@localhost DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined # SSL Engine Switch: # Enable/Disable SSL for this virtual host. SSLEngine on # A self-signed (snakeoil) certificate can be created by installing # the ssl-cert package. See # /usr/share/doc/apache2/README.Debian.gz for more info. # If both key and certificate are stored in the same file, only the # SSLCertificateFile directive is needed. SSLCertificateFile /etc/apache2/certs/certbot-cert_5.pem SSLCertificateKeyFile /etc/apache2/ssl/key-certbot_15.pem #SSLOptions +FakeBasicAuth +ExportCertData +StrictRequire SSLOptions +StdEnvVars SSLOptions +StdEnvVars BrowserMatch "MSIE [2-6]" \ nokeepalive ssl-unclean-shutdown \ downgrade-1.0 force-response-1.0 # MSIE 7 and newer should be able to use keepalive BrowserMatch "MSIE [17-9]" ssl-unclean-shutdown # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000021700000000000010215 xustar00121 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-enabled/duplicatehttp.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-enabled/duplica0000644000076500000240000000034400000000000032117 0ustar00bmwstaff ServerName duplicate.example.com ServerAdmin webmaster@certbot.demo DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined ././@PaxHeader0000000000000000000000000000022000000000000010207 xustar00122 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-enabled/duplicatehttps.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-enabled/duplica0000644000076500000240000000057200000000000032122 0ustar00bmwstaff ServerName duplicate.example.com ServerAdmin webmaster@certbot.demo DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined SSLCertificateFile /etc/apache2/certs/certbot-cert_5.pem SSLCertificateKeyFile /etc/apache2/ssl/key-certbot_15.pem ././@PaxHeader0000000000000000000000000000022400000000000010213 xustar00126 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-enabled/encryption-example.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-enabled/encrypt0000644000076500000240000000220500000000000032160 0ustar00bmwstaff ServerName encryption-example.demo ServerAdmin webmaster@localhost DocumentRoot /var/www-encryption-example/static/ Options FollowSymLinks AllowOverride None Options Indexes FollowSymLinks MultiViews AllowOverride None Order allow,deny allow from all ScriptAlias /cgi-bin/ /usr/lib/cgi-bin/ AllowOverride None Options +ExecCGI -MultiViews +SymLinksIfOwnerMatch Order allow,deny Allow from all ErrorLog ${APACHE_LOG_DIR}/error.log # Possible values include: debug, info, notice, warn, error, crit, # alert, emerg. LogLevel warn CustomLog ${APACHE_LOG_DIR}/access.log combined Alias /doc/ "/usr/share/doc/" Options Indexes MultiViews FollowSymLinks AllowOverride None Order deny,allow Deny from all Allow from 127.0.0.0/255.0.0.0 ::1/128 ././@PaxHeader0000000000000000000000000000022300000000000010212 xustar00125 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-enabled/mod_macro-example.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-enabled/mod_mac0000644000076500000240000000057100000000000032077 0ustar00bmwstaff ServerName $domain ServerAlias www.$domain DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined Use VHost macro1 test.com Use VHost macro2 hostname.org Use VHost macro3 apache.org # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000021500000000000010213 xustar00119 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-enabled/non-symlink.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-enabled/non-sym0000644000076500000240000000033600000000000032077 0ustar00bmwstaff ServerName nonsym.link ServerAdmin webmaster@localhost DocumentRoot /var/www-certbot-reworld/static/ ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined ././@PaxHeader0000000000000000000000000000021200000000000010210 xustar00116 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-enabled/ocsp-ssl.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-enabled/ocsp-ss0000644000076500000240000000304000000000000032061 0ustar00bmwstaff SSLStaplingCache shmcb:/var/run/apache2/stapling_cache(128000) # The ServerName directive sets the request scheme, hostname and port that # the server uses to identify itself. This is used when creating # redirection URLs. In the context of virtual hosts, the ServerName # specifies what hostname must appear in the request's Host: header to # match this virtual host. For the default virtual host (this file) this # value is not decisive as it is used as a last resort host regardless. # However, you must set it for any further virtual host explicitly. ServerName ocspvhost.com ServerAdmin webmaster@dumpbits.com DocumentRoot /var/www/html # Available loglevels: trace8, ..., trace1, debug, info, notice, warn, # error, crit, alert, emerg. # It is also possible to configure the loglevel for particular # modules, e.g. #LogLevel info ssl:warn ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined # For most configuration files from conf-available/, which are # enabled or disabled at a global level, it is possible to # include a line for only one particular virtual host. For example the # following line enables the CGI configuration for this host only # after it has been globally disabled with "a2disconf". #Include conf-available/serve-cgi-bin.conf SSLCertificateFile /etc/apache2/certs/certbot-cert_5.pem SSLCertificateKeyFile /etc/apache2/ssl/key-certbot_15.pem SSLUseStapling on # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000021200000000000010210 xustar00116 path=certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-enabled/wildcard.conf 22 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/sites-enabled/wildcar0000644000076500000240000000044100000000000032121 0ustar00bmwstaff ServerName ip-172-30-0-17 ServerAdmin webmaster@localhost DocumentRoot /var/www/html ServerAlias *.blue.purple.com ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined # vim: syntax=apache ts=4 sw=4 sts=4 sr noet ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/debian_apache_2_4/multiple_vhosts/sites0000644000076500000240000000023100000000000025576 0ustar00bmwstaffsites-available/certbot.conf, certbot.demo sites-available/encryption-example.conf, encryption-example.demo sites-available/ocsp-ssl.conf, ocspvhost.com ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.7904325 certbot-apache-1.21.0/tests/testdata/gentoo_apache/0000755000076500000240000000000000000000000020674 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.8163106 certbot-apache-1.21.0/tests/testdata/gentoo_apache/apache/0000755000076500000240000000000000000000000022115 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.8165343 certbot-apache-1.21.0/tests/testdata/gentoo_apache/apache/apache2/0000755000076500000240000000000000000000000023420 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/gentoo_apache/apache/apache2/httpd.conf0000644000076500000240000001423700000000000025421 0ustar00bmwstaff# This is a modification of the default Apache 2.4 configuration file # for Gentoo Linux. # # Support: # http://www.gentoo.org/main/en/lists.xml [mailing lists] # http://forums.gentoo.org/ [web forums] # irc://irc.freenode.net#gentoo-apache [irc chat] # # Bug Reports: # http://bugs.gentoo.org [gentoo related bugs] # http://httpd.apache.org/bug_report.html [apache httpd related bugs] # # # This is the main Apache HTTP server configuration file. It contains the # configuration directives that give the server its instructions. # See for detailed information. # In particular, see # # for a discussion of each configuration directive. # # Do NOT simply read the instructions in here without understanding # what they do. They're here only as hints or reminders. If you are unsure # consult the online docs. You have been warned. # # Configuration and logfile names: If the filenames you specify for many # of the server's control files begin with "/" (or "drive:/" for Win32), the # server will use that explicit path. If the filenames do *not* begin # with "/", the value of ServerRoot is prepended -- so "var/log/apache2/foo_log" # with ServerRoot set to "/usr" will be interpreted by the # server as "/usr/var/log/apache2/foo.log". # ServerRoot: The top of the directory tree under which the server's # configuration, error, and log files are kept. # # Do not add a slash at the end of the directory path. If you point # ServerRoot at a non-local disk, be sure to point the LockFile directive # at a local disk. If you wish to share the same ServerRoot for multiple # httpd daemons, you will need to change at least LockFile and PidFile. # Comment: The LockFile directive has been replaced by the Mutex directive ServerRoot "/usr/lib64/apache2" # Dynamic Shared Object (DSO) Support # # To be able to use the functionality of a module which was built as a DSO you # have to place corresponding `LoadModule' lines at this location so the # directives contained in it are actually available _before_ they are used. # Statically compiled modules (those listed by `httpd -l') do not need # to be loaded here. # # Example: # LoadModule foo_module modules/mod_foo.so # # GENTOO: Automatically defined based on APACHE2_MODULES USE_EXPAND variable. # Do not change manually, it will be overwritten on upgrade. # # The following modules are considered as the default configuration. # If you wish to disable one of them, you may have to alter other # configuration directives. # # Change these at your own risk! LoadModule actions_module modules/mod_actions.so LoadModule alias_module modules/mod_alias.so LoadModule auth_basic_module modules/mod_auth_basic.so LoadModule authn_anon_module modules/mod_authn_anon.so LoadModule authn_core_module modules/mod_authn_core.so LoadModule authn_dbm_module modules/mod_authn_dbm.so LoadModule authn_file_module modules/mod_authn_file.so LoadModule authz_core_module modules/mod_authz_core.so LoadModule authz_dbm_module modules/mod_authz_dbm.so LoadModule authz_groupfile_module modules/mod_authz_groupfile.so LoadModule authz_host_module modules/mod_authz_host.so LoadModule authz_owner_module modules/mod_authz_owner.so LoadModule authz_user_module modules/mod_authz_user.so LoadModule autoindex_module modules/mod_autoindex.so LoadModule cache_module modules/mod_cache.so LoadModule cgi_module modules/mod_cgi.so LoadModule cgid_module modules/mod_cgid.so LoadModule dav_module modules/mod_dav.so LoadModule dav_fs_module modules/mod_dav_fs.so LoadModule dav_lock_module modules/mod_dav_lock.so LoadModule deflate_module modules/mod_deflate.so LoadModule dir_module modules/mod_dir.so LoadModule env_module modules/mod_env.so LoadModule expires_module modules/mod_expires.so LoadModule ext_filter_module modules/mod_ext_filter.so LoadModule file_cache_module modules/mod_file_cache.so LoadModule filter_module modules/mod_filter.so LoadModule headers_module modules/mod_headers.so LoadModule include_module modules/mod_include.so LoadModule info_module modules/mod_info.so LoadModule log_config_module modules/mod_log_config.so LoadModule logio_module modules/mod_logio.so LoadModule mime_module modules/mod_mime.so LoadModule mime_magic_module modules/mod_mime_magic.so LoadModule negotiation_module modules/mod_negotiation.so LoadModule rewrite_module modules/mod_rewrite.so LoadModule setenvif_module modules/mod_setenvif.so LoadModule socache_shmcb_module modules/mod_socache_shmcb.so LoadModule speling_module modules/mod_speling.so LoadModule ssl_module modules/mod_ssl.so LoadModule status_module modules/mod_status.so LoadModule unique_id_module modules/mod_unique_id.so LoadModule unixd_module modules/mod_unixd.so LoadModule userdir_module modules/mod_userdir.so LoadModule usertrack_module modules/mod_usertrack.so LoadModule vhost_alias_module modules/mod_vhost_alias.so # If you wish httpd to run as a different user or group, you must run # httpd as root initially and it will switch. # # User/Group: The name (or #number) of the user/group to run httpd as. # It is usually good practice to create a dedicated user and group for # running httpd, as with most system services. User apache Group apache # Supplemental configuration # # Most of the configuration files in the /etc/apache2/modules.d/ directory can # be turned on using APACHE2_OPTS in /etc/conf.d/apache2 to add extra features # or to modify the default configuration of the server. # # To know which flag to add to APACHE2_OPTS, look at the first line of the # the file, which will usually be an where OPTION is the # flag to use. Include modules.d/*.conf # Virtual-host support # # Gentoo has made using virtual-hosts easy. In /etc/apache2/vhosts.d/ we # include a default vhost (enabled by adding -D DEFAULT_VHOST to # APACHE2_OPTS in /etc/conf.d/apache2). Include vhosts.d/*.conf # vim: ts=4 filetype=apache ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/gentoo_apache/apache/apache2/magic0000644000076500000240000003142500000000000024430 0ustar00bmwstaff# Magic data for mod_mime_magic Apache module (originally for file(1) command) # The module is described in /manual/mod/mod_mime_magic.html # # The format is 4-5 columns: # Column #1: byte number to begin checking from, ">" indicates continuation # Column #2: type of data to match # Column #3: contents of data to match # Column #4: MIME type of result # Column #5: MIME encoding of result (optional) #------------------------------------------------------------------------------ # Localstuff: file(1) magic for locally observed files # Add any locally observed files here. #------------------------------------------------------------------------------ # end local stuff #------------------------------------------------------------------------------ #------------------------------------------------------------------------------ # Java 0 short 0xcafe >2 short 0xbabe application/java #------------------------------------------------------------------------------ # audio: file(1) magic for sound formats # # from Jan Nicolai Langfeldt , # # Sun/NeXT audio data 0 string .snd >12 belong 1 audio/basic >12 belong 2 audio/basic >12 belong 3 audio/basic >12 belong 4 audio/basic >12 belong 5 audio/basic >12 belong 6 audio/basic >12 belong 7 audio/basic >12 belong 23 audio/x-adpcm # DEC systems (e.g. DECstation 5000) use a variant of the Sun/NeXT format # that uses little-endian encoding and has a different magic number # (0x0064732E in little-endian encoding). 0 lelong 0x0064732E >12 lelong 1 audio/x-dec-basic >12 lelong 2 audio/x-dec-basic >12 lelong 3 audio/x-dec-basic >12 lelong 4 audio/x-dec-basic >12 lelong 5 audio/x-dec-basic >12 lelong 6 audio/x-dec-basic >12 lelong 7 audio/x-dec-basic # compressed (G.721 ADPCM) >12 lelong 23 audio/x-dec-adpcm # Bytes 0-3 of AIFF, AIFF-C, & 8SVX audio files are "FORM" # AIFF audio data 8 string AIFF audio/x-aiff # AIFF-C audio data 8 string AIFC audio/x-aiff # IFF/8SVX audio data 8 string 8SVX audio/x-aiff # Creative Labs AUDIO stuff # Standard MIDI data 0 string MThd audio/unknown #>9 byte >0 (format %d) #>11 byte >1 using %d channels # Creative Music (CMF) data 0 string CTMF audio/unknown # SoundBlaster instrument data 0 string SBI audio/unknown # Creative Labs voice data 0 string Creative\ Voice\ File audio/unknown ## is this next line right? it came this way... #>19 byte 0x1A #>23 byte >0 - version %d #>22 byte >0 \b.%d # [GRR 950115: is this also Creative Labs? Guessing that first line # should be string instead of unknown-endian long...] #0 long 0x4e54524b MultiTrack sound data #0 string NTRK MultiTrack sound data #>4 long x - version %ld # Microsoft WAVE format (*.wav) # [GRR 950115: probably all of the shorts and longs should be leshort/lelong] # Microsoft RIFF 0 string RIFF audio/unknown # - WAVE format >8 string WAVE audio/x-wav # MPEG audio. 0 beshort&0xfff0 0xfff0 audio/mpeg # C64 SID Music files, from Linus Walleij 0 string PSID audio/prs.sid #------------------------------------------------------------------------------ # c-lang: file(1) magic for C programs or various scripts # # XPM icons (Greg Roelofs, newt@uchicago.edu) # ideally should go into "images", but entries below would tag XPM as C source 0 string /*\ XPM image/x-xbm 7bit # this first will upset you if you're a PL/1 shop... (are there any left?) # in which case rm it; ascmagic will catch real C programs # C or REXX program text 0 string /* text/plain # C++ program text 0 string // text/plain #------------------------------------------------------------------------------ # compress: file(1) magic for pure-compression formats (no archives) # # compress, gzip, pack, compact, huf, squeeze, crunch, freeze, yabba, whap, etc. # # Formats for various forms of compressed data # Formats for "compress" proper have been moved into "compress.c", # because it tries to uncompress it to figure out what's inside. # standard unix compress 0 string \037\235 application/octet-stream x-compress # gzip (GNU zip, not to be confused with [Info-ZIP/PKWARE] zip archiver) 0 string \037\213 application/octet-stream x-gzip # According to gzip.h, this is the correct byte order for packed data. 0 string \037\036 application/octet-stream # # This magic number is byte-order-independent. # 0 short 017437 application/octet-stream # XXX - why *two* entries for "compacted data", one of which is # byte-order independent, and one of which is byte-order dependent? # # compacted data 0 short 0x1fff application/octet-stream 0 string \377\037 application/octet-stream # huf output 0 short 0145405 application/octet-stream # Squeeze and Crunch... # These numbers were gleaned from the Unix versions of the programs to # handle these formats. Note that I can only uncrunch, not crunch, and # I didn't have a crunched file handy, so the crunch number is untested. # Keith Waclena #0 leshort 0x76FF squeezed data (CP/M, DOS) #0 leshort 0x76FE crunched data (CP/M, DOS) # Freeze #0 string \037\237 Frozen file 2.1 #0 string \037\236 Frozen file 1.0 (or gzip 0.5) # lzh? #0 string \037\240 LZH compressed data #------------------------------------------------------------------------------ # frame: file(1) magic for FrameMaker files # # This stuff came on a FrameMaker demo tape, most of which is # copyright, but this file is "published" as witness the following: # 0 string \ # and Anna Shergold # 0 string \ 0 string \14 byte 12 (OS/2 1.x format) #>14 byte 64 (OS/2 2.x format) #>14 byte 40 (Windows 3.x format) #0 string IC icon #0 string PI pointer #0 string CI color icon #0 string CP color pointer #0 string BA bitmap array 0 string \x89PNG image/png 0 string FWS application/x-shockwave-flash 0 string CWS application/x-shockwave-flash #------------------------------------------------------------------------------ # lisp: file(1) magic for lisp programs # # various lisp types, from Daniel Quinlan (quinlan@yggdrasil.com) 0 string ;; text/plain 8bit # Emacs 18 - this is always correct, but not very magical. 0 string \012( application/x-elc # Emacs 19 0 string ;ELC\023\000\000\000 application/x-elc #------------------------------------------------------------------------------ # mail.news: file(1) magic for mail and news # # There are tests to ascmagic.c to cope with mail and news. 0 string Relay-Version: message/rfc822 7bit 0 string #!\ rnews message/rfc822 7bit 0 string N#!\ rnews message/rfc822 7bit 0 string Forward\ to message/rfc822 7bit 0 string Pipe\ to message/rfc822 7bit 0 string Return-Path: message/rfc822 7bit 0 string Path: message/news 8bit 0 string Xref: message/news 8bit 0 string From: message/rfc822 7bit 0 string Article message/news 8bit #------------------------------------------------------------------------------ # msword: file(1) magic for MS Word files # # Contributor claims: # Reversed-engineered MS Word magic numbers # 0 string \376\067\0\043 application/msword 0 string \333\245-\0\0\0 application/msword # disable this one because it applies also to other # Office/OLE documents for which msword is not correct. See PR#2608. #0 string \320\317\021\340\241\261 application/msword #------------------------------------------------------------------------------ # printer: file(1) magic for printer-formatted files # # PostScript 0 string %! application/postscript 0 string \004%! application/postscript # Acrobat # (due to clamen@cs.cmu.edu) 0 string %PDF- application/pdf #------------------------------------------------------------------------------ # sc: file(1) magic for "sc" spreadsheet # 38 string Spreadsheet application/x-sc #------------------------------------------------------------------------------ # tex: file(1) magic for TeX files # # XXX - needs byte-endian stuff (big-endian and little-endian DVI?) # # From # Although we may know the offset of certain text fields in TeX DVI # and font files, we can't use them reliably because they are not # zero terminated. [but we do anyway, christos] 0 string \367\002 application/x-dvi #0 string \367\203 TeX generic font data #0 string \367\131 TeX packed font data #0 string \367\312 TeX virtual font data #0 string This\ is\ TeX, TeX transcript text #0 string This\ is\ METAFONT, METAFONT transcript text # There is no way to detect TeX Font Metric (*.tfm) files without # breaking them apart and reading the data. The following patterns # match most *.tfm files generated by METAFONT or afm2tfm. #2 string \000\021 TeX font metric data #2 string \000\022 TeX font metric data #>34 string >\0 (%s) # Texinfo and GNU Info, from Daniel Quinlan (quinlan@yggdrasil.com) #0 string \\input\ texinfo Texinfo source text #0 string This\ is\ Info\ file GNU Info text # correct TeX magic for Linux (and maybe more) # from Peter Tobias (tobias@server.et-inf.fho-emden.de) # 0 leshort 0x02f7 application/x-dvi # RTF - Rich Text Format 0 string {\\rtf application/rtf #------------------------------------------------------------------------------ # animation: file(1) magic for animation/movie formats # # animation formats, originally from vax@ccwf.cc.utexas.edu (VaX#n8) # MPEG file 0 string \000\000\001\263 video/mpeg # # The contributor claims: # I couldn't find a real magic number for these, however, this # -appears- to work. Note that it might catch other files, too, # so BE CAREFUL! # # Note that title and author appear in the two 20-byte chunks # at decimal offsets 2 and 22, respectively, but they are XOR'ed with # 255 (hex FF)! DL format SUCKS BIG ROCKS. # # DL file version 1 , medium format (160x100, 4 images/screen) 0 byte 1 video/unknown 0 byte 2 video/unknown # Quicktime video, from Linus Walleij # from Apple quicktime file format documentation. 4 string moov video/quicktime 4 string mdat video/quicktime ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.8181834 certbot-apache-1.21.0/tests/testdata/gentoo_apache/apache/apache2/modules.d/0000755000076500000240000000000000000000000025312 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/gentoo_apache/apache/apache2/modules.d/00_default_settings.conf0000644000076500000240000001227400000000000032032 0ustar00bmwstaff# This configuration file reflects default settings for Apache HTTP Server. # You may change these, but chances are that you may not need to. # Timeout: The number of seconds before receives and sends time out. Timeout 300 # KeepAlive: Whether or not to allow persistent connections (more than # one request per connection). Set to "Off" to deactivate. KeepAlive On # MaxKeepAliveRequests: The maximum number of requests to allow # during a persistent connection. Set to 0 to allow an unlimited amount. # We recommend you leave this number high, for maximum performance. MaxKeepAliveRequests 100 # KeepAliveTimeout: Number of seconds to wait for the next request from the # same client on the same connection. KeepAliveTimeout 15 # UseCanonicalName: Determines how Apache constructs self-referencing # URLs and the SERVER_NAME and SERVER_PORT variables. # When set "Off", Apache will use the Hostname and Port supplied # by the client. When set "On", Apache will use the value of the # ServerName directive. UseCanonicalName Off # AccessFileName: The name of the file to look for in each directory # for additional configuration directives. See also the AllowOverride # directive. AccessFileName .htaccess # ServerTokens # This directive configures what you return as the Server HTTP response # Header. The default is 'Full' which sends information about the OS-Type # and compiled in modules. # Set to one of: Full | OS | Minor | Minimal | Major | Prod # where Full conveys the most information, and Prod the least. ServerTokens Prod # TraceEnable # This directive overrides the behavior of TRACE for both the core server and # mod_proxy. The default TraceEnable on permits TRACE requests per RFC 2616, # which disallows any request body to accompany the request. TraceEnable off # causes the core server and mod_proxy to return a 405 (Method not allowed) # error to the client. # For security reasons this is turned off by default. (bug #240680) TraceEnable off # Optionally add a line containing the server version and virtual host # name to server-generated pages (internal error documents, FTP directory # listings, mod_status and mod_info output etc., but not CGI generated # documents or custom error documents). # Set to "EMail" to also include a mailto: link to the ServerAdmin. # Set to one of: On | Off | EMail ServerSignature On # HostnameLookups: Log the names of clients or just their IP addresses # e.g., www.apache.org (on) or 204.62.129.132 (off). # The default is off because it'd be overall better for the net if people # had to knowingly turn this feature on, since enabling it means that # each client request will result in AT LEAST one lookup request to the # nameserver. HostnameLookups Off # EnableMMAP and EnableSendfile: On systems that support it, # memory-mapping or the sendfile syscall is used to deliver # files. This usually improves server performance, but must # be turned off when serving from networked-mounted # filesystems or if support for these functions is otherwise # broken on your system. EnableMMAP On EnableSendfile Off # FileETag: Configures the file attributes that are used to create # the ETag (entity tag) response header field when the document is # based on a static file. (The ETag value is used in cache management # to save network bandwidth.) FileETag MTime Size # ContentDigest: This directive enables the generation of Content-MD5 # headers as defined in RFC1864 respectively RFC2616. # The Content-MD5 header provides an end-to-end message integrity # check (MIC) of the entity-body. A proxy or client may check this # header for detecting accidental modification of the entity-body # in transit. # Note that this can cause performance problems on your server since # the message digest is computed on every request (the values are # not cached). # Content-MD5 is only sent for documents served by the core, and not # by any module. For example, SSI documents, output from CGI scripts, # and byte range responses do not have this header. ContentDigest Off # ErrorLog: The location of the error log file. # If you do not specify an ErrorLog directive within a # container, error messages relating to that virtual host will be # logged here. If you *do* define an error logfile for a # container, that host's errors will be logged there and not here. ErrorLog /var/log/apache2/error_log # LogLevel: Control the number of messages logged to the error_log. # Possible values include: debug, info, notice, warn, error, crit, # alert, emerg. LogLevel warn # We configure the "default" to be a very restrictive set of features. Options FollowSymLinks AllowOverride None Require all denied # DirectoryIndex: sets the file that Apache will serve if a directory # is requested. # # The index.html.var file (a type-map) is used to deliver content- # negotiated documents. The MultiViews Options can be used for the # same purpose, but it is much slower. # # Do not change this entry unless you know what you are doing. DirectoryIndex index.html index.html.var # The following lines prevent .htaccess and .htpasswd files from being # viewed by Web clients. Require all denied # vim: ts=4 filetype=apache ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/gentoo_apache/apache/apache2/modules.d/00_error_documents.conf0000644000076500000240000000473000000000000031676 0ustar00bmwstaff# The configuration below implements multi-language error documents through # content-negotiation. # Customizable error responses come in three flavors: # 1) plain text 2) local redirects 3) external redirects # Some examples: #ErrorDocument 500 "The server made a boo boo." #ErrorDocument 404 /missing.html #ErrorDocument 404 "/cgi-bin/missing_handler.pl" #ErrorDocument 402 http://www.example.com/subscription_info.html # Required modules: mod_alias, mod_include, mod_negotiation # We use Alias to redirect any /error/HTTP_.html.var response to # our collection of by-error message multi-language collections. We use # includes to substitute the appropriate text. # You can modify the messages' appearance without changing any of the # default HTTP_.html.var files by adding the line: # Alias /error/include/ "/your/include/path/" # which allows you to create your own set of files by starting with the # /var/www/localhost/error/include/ files and copying them to /your/include/path/, # even on a per-VirtualHost basis. The default include files will display # your Apache version number and your ServerAdmin email address regardless # of the setting of ServerSignature. Alias /error/ "/usr/share/apache2/error/" AllowOverride None Options IncludesNoExec AddOutputFilter Includes html AddHandler type-map var Require all granted LanguagePriority en cs de es fr it ja ko nl pl pt-br ro sv tr ForceLanguagePriority Prefer Fallback ErrorDocument 400 /error/HTTP_BAD_REQUEST.html.var ErrorDocument 401 /error/HTTP_UNAUTHORIZED.html.var ErrorDocument 403 /error/HTTP_FORBIDDEN.html.var ErrorDocument 404 /error/HTTP_NOT_FOUND.html.var ErrorDocument 405 /error/HTTP_METHOD_NOT_ALLOWED.html.var ErrorDocument 408 /error/HTTP_REQUEST_TIME_OUT.html.var ErrorDocument 410 /error/HTTP_GONE.html.var ErrorDocument 411 /error/HTTP_LENGTH_REQUIRED.html.var ErrorDocument 412 /error/HTTP_PRECONDITION_FAILED.html.var ErrorDocument 413 /error/HTTP_REQUEST_ENTITY_TOO_LARGE.html.var ErrorDocument 414 /error/HTTP_REQUEST_URI_TOO_LARGE.html.var ErrorDocument 415 /error/HTTP_UNSUPPORTED_MEDIA_TYPE.html.var ErrorDocument 500 /error/HTTP_INTERNAL_SERVER_ERROR.html.var ErrorDocument 501 /error/HTTP_NOT_IMPLEMENTED.html.var ErrorDocument 502 /error/HTTP_BAD_GATEWAY.html.var ErrorDocument 503 /error/HTTP_SERVICE_UNAVAILABLE.html.var ErrorDocument 506 /error/HTTP_VARIANT_ALSO_VARIES.html.var # vim: ts=4 filetype=apache ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/gentoo_apache/apache/apache2/modules.d/00_languages.conf0000644000076500000240000001166100000000000030433 0ustar00bmwstaff# Settings for hosting different languages. # DefaultLanguage and AddLanguage allows you to specify the language of # a document. You can then use content negotiation to give a browser a # file in a language the user can understand. # # Specify a default language. This means that all data # going out without a specific language tag (see below) will # be marked with this one. You probably do NOT want to set # this unless you are sure it is correct for all cases. # # It is generally better to not mark a page as # being a certain language than marking it with the wrong # language! # # DefaultLanguage nl # # Note 1: The suffix does not have to be the same as the language # keyword --- those with documents in Polish (whose net-standard # language code is pl) may wish to use "AddLanguage pl .po" to # avoid the ambiguity with the common suffix for perl scripts. # # Note 2: The example entries below illustrate that in some cases # the two character 'Language' abbreviation is not identical to # the two character 'Country' code for its country, # E.g. 'Danmark/dk' versus 'Danish/da'. # # Note 3: In the case of 'ltz' we violate the RFC by using a three char # specifier. There is 'work in progress' to fix this and get # the reference data for rfc1766 cleaned up. # # Catalan (ca) - Croatian (hr) - Czech (cs) - Danish (da) - Dutch (nl) # English (en) - Esperanto (eo) - Estonian (et) - French (fr) - German (de) # Greek-Modern (el) - Hebrew (he) - Italian (it) - Japanese (ja) # Korean (ko) - Luxembourgeois* (ltz) - Norwegian Nynorsk (nn) # Norwegian (no) - Polish (pl) - Portuguese (pt) # Brazilian Portuguese (pt-BR) - Russian (ru) - Swedish (sv) # Simplified Chinese (zh-CN) - Spanish (es) - Traditional Chinese (zh-TW) AddLanguage ca .ca AddLanguage cs .cz .cs AddLanguage da .dk AddLanguage de .de AddLanguage el .el AddLanguage en .en AddLanguage eo .eo AddLanguage es .es AddLanguage et .et AddLanguage fr .fr AddLanguage he .he AddLanguage hr .hr AddLanguage it .it AddLanguage ja .ja AddLanguage ko .ko AddLanguage ltz .ltz AddLanguage nl .nl AddLanguage nn .nn AddLanguage no .no AddLanguage pl .po AddLanguage pt .pt AddLanguage pt-BR .pt-br AddLanguage ru .ru AddLanguage sv .sv AddLanguage zh-CN .zh-cn AddLanguage zh-TW .zh-tw # LanguagePriority allows you to give precedence to some languages # in case of a tie during content negotiation. # # Just list the languages in decreasing order of preference. We have # more or less alphabetized them here. You probably want to change this. LanguagePriority en ca cs da de el eo es et fr he hr it ja ko ltz nl nn no pl pt pt-BR ru sv zh-CN zh-TW # ForceLanguagePriority allows you to serve a result page rather than # MULTIPLE CHOICES (Prefer) [in case of a tie] or NOT ACCEPTABLE (Fallback) # [in case no accepted languages matched the available variants] ForceLanguagePriority Prefer Fallback # Commonly used filename extensions to character sets. You probably # want to avoid clashes with the language extensions, unless you # are good at carefully testing your setup after each change. # See http://www.iana.org/assignments/character-sets for the # official list of charset names and their respective RFCs. AddCharset us-ascii.ascii .us-ascii AddCharset ISO-8859-1 .iso8859-1 .latin1 AddCharset ISO-8859-2 .iso8859-2 .latin2 .cen AddCharset ISO-8859-3 .iso8859-3 .latin3 AddCharset ISO-8859-4 .iso8859-4 .latin4 AddCharset ISO-8859-5 .iso8859-5 .cyr .iso-ru AddCharset ISO-8859-6 .iso8859-6 .arb .arabic AddCharset ISO-8859-7 .iso8859-7 .grk .greek AddCharset ISO-8859-8 .iso8859-8 .heb .hebrew AddCharset ISO-8859-9 .iso8859-9 .latin5 .trk AddCharset ISO-8859-10 .iso8859-10 .latin6 AddCharset ISO-8859-13 .iso8859-13 AddCharset ISO-8859-14 .iso8859-14 .latin8 AddCharset ISO-8859-15 .iso8859-15 .latin9 AddCharset ISO-8859-16 .iso8859-16 .latin10 AddCharset ISO-2022-JP .iso2022-jp .jis AddCharset ISO-2022-KR .iso2022-kr .kis AddCharset ISO-2022-CN .iso2022-cn .cis AddCharset Big5.Big5 .big5 .b5 AddCharset cn-Big5 .cn-big5 # For russian, more than one charset is used (depends on client, mostly): AddCharset WINDOWS-1251 .cp-1251 .win-1251 AddCharset CP866 .cp866 AddCharset KOI8 .koi8 AddCharset KOI8-E .koi8-e AddCharset KOI8-r .koi8-r .koi8-ru AddCharset KOI8-U .koi8-u AddCharset KOI8-ru .koi8-uk .ua AddCharset ISO-10646-UCS-2 .ucs2 AddCharset ISO-10646-UCS-4 .ucs4 AddCharset UTF-7 .utf7 AddCharset UTF-8 .utf8 AddCharset UTF-16 .utf16 AddCharset UTF-16BE .utf16be AddCharset UTF-16LE .utf16le AddCharset UTF-32 .utf32 AddCharset UTF-32BE .utf32be AddCharset UTF-32LE .utf32le AddCharset euc-cn .euc-cn AddCharset euc-gb .euc-gb AddCharset euc-jp .euc-jp AddCharset euc-kr .euc-kr # Not sure how euc-tw got in - IANA doesn't list it??? AddCharset EUC-TW .euc-tw AddCharset gb2312 .gb2312 .gb AddCharset iso-10646-ucs-2 .ucs-2 .iso-10646-ucs-2 AddCharset iso-10646-ucs-4 .ucs-4 .iso-10646-ucs-4 AddCharset shift_jis .shift_jis .sjis # vim: ts=4 filetype=apache ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/gentoo_apache/apache/apache2/modules.d/00_mod_autoindex.conf0000644000076500000240000000550300000000000031322 0ustar00bmwstaff # We include the /icons/ alias for FancyIndexed directory listings. If # you do not use FancyIndexing, you may comment this out. Alias /icons/ "/usr/share/apache2/icons/" Options Indexes MultiViews AllowOverride None Require all granted # Directives controlling the display of server-generated directory listings. # # To see the listing of a directory, the Options directive for the # directory must include "Indexes", and the directory must not contain # a file matching those listed in the DirectoryIndex directive. # IndexOptions: Controls the appearance of server-generated directory # listings. IndexOptions FancyIndexing VersionSort # AddIcon* directives tell the server which icon to show for different # files or filename extensions. These are only displayed for # FancyIndexed directories. AddIconByEncoding (CMP,/icons/compressed.gif) x-compress x-gzip AddIconByType (TXT,/icons/text.gif) text/* AddIconByType (IMG,/icons/image2.gif) image/* AddIconByType (SND,/icons/sound2.gif) audio/* AddIconByType (VID,/icons/movie.gif) video/* AddIcon /icons/binary.gif .bin .exe AddIcon /icons/binhex.gif .hqx AddIcon /icons/tar.gif .tar AddIcon /icons/world2.gif .wrl .wrl.gz .vrml .vrm .iv AddIcon /icons/compressed.gif .Z .z .tgz .gz .zip AddIcon /icons/a.gif .ps .ai .eps AddIcon /icons/layout.gif .html .shtml .htm .pdf AddIcon /icons/text.gif .txt AddIcon /icons/c.gif .c AddIcon /icons/p.gif .pl .py AddIcon /icons/f.gif .for AddIcon /icons/dvi.gif .dvi AddIcon /icons/uuencoded.gif .uu AddIcon /icons/script.gif .conf .sh .shar .csh .ksh .tcl AddIcon /icons/tex.gif .tex AddIcon /icons/bomb.gif core AddIcon /icons/back.gif .. AddIcon /icons/hand.right.gif README AddIcon /icons/folder.gif ^^DIRECTORY^^ AddIcon /icons/blank.gif ^^BLANKICON^^ # DefaultIcon is which icon to show for files which do not have an icon # explicitly set. DefaultIcon /icons/unknown.gif # AddDescription allows you to place a short description after a file in # server-generated indexes. These are only displayed for FancyIndexed # directories. # Format: AddDescription "description" filename #AddDescription "GZIP compressed document" .gz #AddDescription "tar archive" .tar #AddDescription "GZIP compressed tar archive" .tgz # ReadmeName is the name of the README file the server will look for by # default, and append to directory listings. # HeaderName is the name of a file which should be prepended to # directory indexes. ReadmeName README.html HeaderName HEADER.html # IndexIgnore is a set of filenames which directory indexing should ignore # and not include in the listing. Shell-style wildcarding is permitted. IndexIgnore .??* *~ *# HEADER* README* RCS CVS *,v *,t # vim: ts=4 filetype=apache ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/gentoo_apache/apache/apache2/modules.d/00_mod_info.conf0000644000076500000240000000034100000000000030250 0ustar00bmwstaff # Allow remote server configuration reports, with the URL of # http://servername/server-info SetHandler server-info Require local # vim: ts=4 filetype=apache ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/gentoo_apache/apache/apache2/modules.d/00_mod_log_config.conf0000644000076500000240000000275600000000000031437 0ustar00bmwstaff # The following directives define some format nicknames for use with # a CustomLog directive (see below). LogFormat "%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\"" combined LogFormat "%h %l %u %t \"%r\" %>s %b" common LogFormat "%{Referer}i -> %U" referer LogFormat "%{User-Agent}i" agent LogFormat "%v %h %l %u %t \"%r\" %>s %b %T" script LogFormat "%v %h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\" VLOG=%{VLOG}e" vhost # You need to enable mod_logio.c to use %I and %O LogFormat "%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\" %I %O" combinedio LogFormat "%v %h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\" %I %O" vhostio # The location and format of the access logfile (Common Logfile Format). # If you do not define any access logfiles within a # container, they will be logged here. Contrariwise, if you *do* # define per- access logfiles, transactions will be # logged therein and *not* in this file. CustomLog /var/log/apache2/access_log common # If you would like to have agent and referer logfiles, # uncomment the following directives. #CustomLog /var/log/apache2/referer_log referer #CustomLog /var/log/apache2/agent_logs agent # If you prefer a logfile with access, agent, and referer information # (Combined Logfile Format) you can use the following directive. #CustomLog /var/log/apache2/access_log combined # vim: ts=4 filetype=apache ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/gentoo_apache/apache/apache2/modules.d/00_mod_mime.conf0000644000076500000240000000325300000000000030251 0ustar00bmwstaff # TypesConfig points to the file containing the list of mappings from # filename extension to MIME-type. TypesConfig /etc/mime.types # AddType allows you to add to or override the MIME configuration # file specified in TypesConfig for specific file types. #AddType application/x-gzip .tgz # AddEncoding allows you to have certain browsers uncompress # information on the fly. Note: Not all browsers support this. #AddEncoding x-compress .Z #AddEncoding x-gzip .gz .tgz # If the AddEncoding directives above are commented-out, then you # probably should define those extensions to indicate media types: AddType application/x-compress .Z AddType application/x-gzip .gz .tgz # AddHandler allows you to map certain file extensions to "handlers": # actions unrelated to filetype. These can be either built into the server # or added with the Action directive (see below) # To use CGI scripts outside of ScriptAliased directories: # (You will also need to add "ExecCGI" to the "Options" directive.) #AddHandler cgi-script .cgi # For type maps (negotiated resources): #AddHandler type-map var # Filters allow you to process content before it is sent to the client. # # To parse .shtml files for server-side includes (SSI): # (You will also need to add "Includes" to the "Options" directive.) #AddType text/html .shtml #AddOutputFilter INCLUDES .shtml # The mod_mime_magic module allows the server to use various hints from the # contents of the file itself to determine its type. The MIMEMagicFile # directive tells the module where the hint definitions are located. MIMEMagicFile /etc/apache2/magic # vim: ts=4 filetype=apache ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/gentoo_apache/apache/apache2/modules.d/00_mod_status.conf0000644000076500000240000000071200000000000030642 0ustar00bmwstaff # Allow server status reports generated by mod_status, # with the URL of http://servername/server-status SetHandler server-status Require local # ExtendedStatus controls whether Apache will generate "full" status # information (ExtendedStatus On) or just basic information (ExtendedStatus # Off) when the "server-status" handler is called. ExtendedStatus On # vim: ts=4 filetype=apache ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/gentoo_apache/apache/apache2/modules.d/00_mod_userdir.conf0000644000076500000240000000176700000000000031007 0ustar00bmwstaff# Settings for user home directories # UserDir: The name of the directory that is appended onto a user's home # directory if a ~user request is received. Note that you must also set # the default access control for these directories, as in the example below. UserDir public_html # Control access to UserDir directories. The following is an example # for a site where these directories are restricted to read-only. AllowOverride FileInfo AuthConfig Limit Indexes Options MultiViews Indexes SymLinksIfOwnerMatch IncludesNoExec Require all granted Require all denied # Suexec isn't really required to run cgi-scripts, but it's a really good # idea if you have multiple users serving websites... Options ExecCGI SetHandler cgi-script # vim: ts=4 filetype=apache ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/gentoo_apache/apache/apache2/modules.d/00_mpm.conf0000644000076500000240000000561700000000000027262 0ustar00bmwstaff# Server-Pool Management (MPM specific) # PidFile: The file in which the server should record its process # identification number when it starts. # # DO NOT CHANGE UNLESS YOU KNOW WHAT YOU ARE DOING PidFile /run/apache2.pid # The accept serialization lock file MUST BE STORED ON A LOCAL DISK. # Mutex file:/run/apache_mpm_mutex # Only one of the below sections will be relevant on your # installed httpd. Use "/usr/sbin/apache2 -l" to find out the # active mpm. # common MPM configuration # These configuration directives apply to all MPMs # # StartServers: Number of child server processes created at startup # MaxRequestWorkers: Maximum number of child processes to serve requests # MaxConnectionsPerChild: Limit on the number of connections that an individual # child server will handle during its life # prefork MPM # This is the default MPM if USE=-threads # # MinSpareServers: Minimum number of idle child server processes # MaxSpareServers: Maximum number of idle child server processes StartServers 5 MinSpareServers 5 MaxSpareServers 10 MaxRequestWorkers 150 MaxConnectionsPerChild 10000 # worker MPM # This is the default MPM if USE=threads # # MinSpareThreads: Minimum number of idle threads available to handle request spikes # MaxSpareThreads: Maximum number of idle threads # ThreadsPerChild: Number of threads created by each child process StartServers 2 MinSpareThreads 25 MaxSpareThreads 75 ThreadsPerChild 25 MaxRequestWorkers 150 MaxConnectionsPerChild 10000 # event MPM # # MinSpareThreads: Minimum number of idle threads available to handle request spikes # MaxSpareThreads: Maximum number of idle threads # ThreadsPerChild: Number of threads created by each child process StartServers 2 MinSpareThreads 25 MaxSpareThreads 75 ThreadsPerChild 25 MaxRequestWorkers 150 MaxConnectionsPerChild 10000 # peruser MPM # # MinSpareProcessors: Minimum number of idle child server processes # MinProcessors: Minimum number of processors per virtual host # MaxProcessors: Maximum number of processors per virtual host # ExpireTimeout: Maximum idle time before a child is killed, 0 to disable # Multiplexer: Specify a Multiplexer child configuration. # Processor: Specify a user and group for a specific child process MinSpareProcessors 2 MinProcessors 2 MaxProcessors 10 MaxRequestWorkers 150 MaxConnectionsPerChild 1000 ExpireTimeout 1800 Multiplexer nobody nobody Processor apache apache # itk MPM # # MinSpareServers: Minimum number of idle child server processes # MaxSpareServers: Maximum number of idle child server processes StartServers 5 MinSpareServers 5 MaxSpareServers 10 MaxRequestWorkers 150 MaxConnectionsPerChild 10000 # vim: ts=4 filetype=apache ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/gentoo_apache/apache/apache2/modules.d/10_mod_mem_cache.conf0000644000076500000240000000031600000000000031221 0ustar00bmwstaff # 128MB cache for objects < 2MB CacheEnable mem / MCacheSize 131072 MCacheMaxObjectCount 1000 MCacheMinObjectSize 1 MCacheMaxObjectSize 2097152 # vim: ts=4 filetype=apache ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/gentoo_apache/apache/apache2/modules.d/40_mod_ssl.conf0000644000076500000240000000513400000000000030127 0ustar00bmwstaff# Note: The following must must be present to support # starting without SSL on platforms with no /dev/random equivalent # but a statically compiled-in mod_ssl. SSLRandomSeed startup builtin SSLRandomSeed connect builtin # This is the Apache server configuration file providing SSL support. # It contains the configuration directives to instruct the server how to # serve pages over an https connection. For detailing information about these # directives see # Do NOT simply read the instructions in here without understanding # what they do. They're here only as hints or reminders. If you are unsure # consult the online docs. You have been warned. ## Pseudo Random Number Generator (PRNG): # Configure one or more sources to seed the PRNG of the SSL library. # The seed data should be of good random quality. # WARNING! On some platforms /dev/random blocks if not enough entropy # is available. This means you then cannot use the /dev/random device # because it would lead to very long connection times (as long as # it requires to make more entropy available). But usually those # platforms additionally provide a /dev/urandom device which doesn't # block. So, if available, use this one instead. Read the mod_ssl User # Manual for more details. #SSLRandomSeed startup file:/dev/random 512 #SSLRandomSeed startup file:/dev/urandom 512 #SSLRandomSeed connect file:/dev/random 512 #SSLRandomSeed connect file:/dev/urandom 512 ## SSL Global Context: # All SSL configuration in this context applies both to the main server and # all SSL-enabled virtual hosts. # Some MIME-types for downloading Certificates and CRLs AddType application/x-x509-ca-cert .crt AddType application/x-pkcs7-crl .crl ## Pass Phrase Dialog: # Configure the pass phrase gathering process. The filtering dialog program # (`builtin' is an internal terminal dialog) has to provide the pass phrase on # stdout. SSLPassPhraseDialog builtin ## Inter-Process Session Cache: # Configure the SSL Session Cache: First the mechanism to use and second the # expiring timeout (in seconds). #SSLSessionCache dbm:/run/ssl_scache SSLSessionCache shmcb:/run/ssl_scache(512000) SSLSessionCacheTimeout 300 ## Semaphore: # Configure the path to the mutual exclusion semaphore the SSL engine uses # internally for inter-process synchronization. Mutex file:/run/apache_ssl_mutex ssl-cache ## SSL Compression: # Known to be vulnerable thus disabled by default (bug #507324). SSLCompression off # vim: ts=4 filetype=apache ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/gentoo_apache/apache/apache2/modules.d/41_mod_http2.conf0000644000076500000240000000027500000000000030371 0ustar00bmwstaff # enable debugging for this module #LogLevel http2:info #Enable HTTP/2 support Protocols h2 h2c http/1.1 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/gentoo_apache/apache/apache2/modules.d/45_mod_dav.conf0000644000076500000240000000136600000000000030110 0ustar00bmwstaff DavLockDB "/var/lib/dav/lockdb" # The following directives disable redirects on non-GET requests for # a directory that does not include the trailing slash. This fixes a # problem with several clients that do not appropriately handle # redirects for folders with DAV methods. BrowserMatch "Microsoft Data Access Internet Publishing Provider" redirect-carefully BrowserMatch "MS FrontPage" redirect-carefully BrowserMatch "^WebDrive" redirect-carefully BrowserMatch "^WebDAVFS/1.[012345678]" redirect-carefully BrowserMatch "^gnome-vfs/1.0" redirect-carefully BrowserMatch "^XML Spy" redirect-carefully BrowserMatch "^Dreamweaver-WebDAV-SCM1" redirect-carefully # vim: ts=4 filetype=apache ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/gentoo_apache/apache/apache2/modules.d/46_mod_ldap.conf0000644000076500000240000000062600000000000030255 0ustar00bmwstaff# Examples below are taken from the online documentation # Refer to: # http://localhost/manual/mod/mod_ldap.html # http://localhost/manual/mod/mod_auth_ldap.html LDAPSharedCacheSize 200000 LDAPCacheEntries 1024 LDAPCacheTTL 600 LDAPOpCacheEntries 1024 LDAPOpCacheTTL 600 SetHandler ldap-status Require local # vim: ts=4 filetype=apache ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.8186386 certbot-apache-1.21.0/tests/testdata/gentoo_apache/apache/apache2/vhosts.d/0000755000076500000240000000000000000000000025170 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/gentoo_apache/apache/apache2/vhosts.d/00_default_ssl_vhost.conf0000644000076500000240000002062400000000000032072 0ustar00bmwstaff # see bug #178966 why this is in here # When we also provide SSL we have to listen to the HTTPS port # Note: Configurations that use IPv6 but not IPv4-mapped addresses need two # Listen directives: "Listen [::]:443" and "Listen 0.0.0.0:443" Listen 443 ServerName localhost Include /etc/apache2/vhosts.d/default_vhost.include ErrorLog /var/log/apache2/ssl_error_log TransferLog /var/log/apache2/ssl_access_log ## SSL Engine Switch: # Enable/Disable SSL for this virtual host. SSLEngine on ## SSLProtocol: # Don't use SSLv2 anymore as it's considered to be broken security-wise. # Also disable SSLv3 as most modern browsers are capable of TLS. SSLProtocol ALL -SSLv2 -SSLv3 ## SSL Cipher Suite: # List the ciphers that the client is permitted to negotiate. # See the mod_ssl documentation for a complete list. # This list of ciphers is recommended by mozilla and was stripped off # its RC4 ciphers. (bug #506924) SSLCipherSuite ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:kEDH+AESGCM:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-DSS-AES128-SHA256:DHE-RSA-AES256-SHA256:DHE-DSS-AES256-SHA:DHE-RSA-AES256-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128:AES256:HIGH:!RC4:!aNULL:!eNULL:!EXPORT:!DES:!3DES:!MD5:!PSK ## SSLHonorCipherOrder: # Prefer the server's cipher preference order as the client may have a # weak default order. SSLHonorCipherOrder On ## Server Certificate: # Point SSLCertificateFile at a PEM encoded certificate. If the certificate # is encrypted, then you will be prompted for a pass phrase. Note that a # kill -HUP will prompt again. Keep in mind that if you have both an RSA # and a DSA certificate you can configure both in parallel (to also allow # the use of DSA ciphers, etc.) SSLCertificateFile /etc/ssl/apache2/server.crt ## Server Private Key: # If the key is not combined with the certificate, use this directive to # point at the key file. Keep in mind that if you've both a RSA and a DSA # private key you can configure both in parallel (to also allow the use of # DSA ciphers, etc.) SSLCertificateKeyFile /etc/ssl/apache2/server.key ## Server Certificate Chain: # Point SSLCertificateChainFile at a file containing the concatenation of # PEM encoded CA certificates which form the certificate chain for the # server certificate. Alternatively the referenced file can be the same as # SSLCertificateFile when the CA certificates are directly appended to the # server certificate for convinience. #SSLCertificateChainFile /etc/ssl/apache2/ca.crt ## Certificate Authority (CA): # Set the CA certificate verification path where to find CA certificates # for client authentication or alternatively one huge file containing all # of them (file must be PEM encoded). # Note: Inside SSLCACertificatePath you need hash symlinks to point to the # certificate files. Use the provided Makefile to update the hash symlinks # after changes. #SSLCACertificatePath /etc/ssl/apache2/ssl.crt #SSLCACertificateFile /etc/ssl/apache2/ca-bundle.crt ## Certificate Revocation Lists (CRL): # Set the CA revocation path where to find CA CRLs for client authentication # or alternatively one huge file containing all of them (file must be PEM # encoded). # Note: Inside SSLCARevocationPath you need hash symlinks to point to the # certificate files. Use the provided Makefile to update the hash symlinks # after changes. #SSLCARevocationPath /etc/ssl/apache2/ssl.crl #SSLCARevocationFile /etc/ssl/apache2/ca-bundle.crl ## Client Authentication (Type): # Client certificate verification type and depth. Types are none, optional, # require and optional_no_ca. Depth is a number which specifies how deeply # to verify the certificate issuer chain before deciding the certificate is # not valid. #SSLVerifyClient require #SSLVerifyDepth 10 ## Access Control: # With SSLRequire you can do per-directory access control based on arbitrary # complex boolean expressions containing server variable checks and other # lookup directives. The syntax is a mixture between C and Perl. See the # mod_ssl documentation for more details. # # #SSLRequire ( %{SSL_CIPHER} !~ m/^(EXP|NULL)/ \ # and %{SSL_CLIENT_S_DN_O} eq "Snake Oil, Ltd." \ # and %{SSL_CLIENT_S_DN_OU} in {"Staff", "CA", "Dev"} \ # and %{TIME_WDAY} >= 1 and %{TIME_WDAY} <= 5 \ # and %{TIME_HOUR} >= 8 and %{TIME_HOUR} <= 20 ) \ # or %{REMOTE_ADDR} =~ m/^192\.76\.162\.[0-9]+$/ # ## SSL Engine Options: # Set various options for the SSL engine. ## FakeBasicAuth: # Translate the client X.509 into a Basic Authorisation. This means that the # standard Auth/DBMAuth methods can be used for access control. The user # name is the `one line' version of the client's X.509 certificate. # Note that no password is obtained from the user. Every entry in the user # file needs this password: `xxj31ZMTZzkVA'. ## ExportCertData: # This exports two additional environment variables: SSL_CLIENT_CERT and # SSL_SERVER_CERT. These contain the PEM-encoded certificates of the server # (always existing) and the client (only existing when client # authentication is used). This can be used to import the certificates into # CGI scripts. ## StdEnvVars: # This exports the standard SSL/TLS related `SSL_*' environment variables. # Per default this exportation is switched off for performance reasons, # because the extraction step is an expensive operation and is usually # useless for serving static content. So one usually enables the exportation # for CGI and SSI requests only. ## StrictRequire: # This denies access when "SSLRequireSSL" or "SSLRequire" applied even under # a "Satisfy any" situation, i.e. when it applies access is denied and no # other module can change it. ## OptRenegotiate: # This enables optimized SSL connection renegotiation handling when SSL # directives are used in per-directory context. #SSLOptions +FakeBasicAuth +ExportCertData +StrictRequire SSLOptions +StdEnvVars SSLOptions +StdEnvVars ## SSL Protocol Adjustments: # The safe and default but still SSL/TLS standard compliant shutdown # approach is that mod_ssl sends the close notify alert but doesn't wait # for the close notify alert from client. When you need a different # shutdown approach you can use one of the following variables: ## ssl-unclean-shutdown: # This forces an unclean shutdown when the connection is closed, i.e. no # SSL close notify alert is send or allowed to received. This violates the # SSL/TLS standard but is needed for some brain-dead browsers. Use this when # you receive I/O errors because of the standard approach where mod_ssl # sends the close notify alert. ## ssl-accurate-shutdown: # This forces an accurate shutdown when the connection is closed, i.e. a # SSL close notify alert is send and mod_ssl waits for the close notify # alert of the client. This is 100% SSL/TLS standard compliant, but in # practice often causes hanging connections with brain-dead browsers. Use # this only for browsers where you know that their SSL implementation works # correctly. # Notice: Most problems of broken clients are also related to the HTTP # keep-alive facility, so you usually additionally want to disable # keep-alive for those clients, too. Use variable "nokeepalive" for this. # Similarly, one has to force some clients to use HTTP/1.0 to workaround # their broken HTTP/1.1 implementation. Use variables "downgrade-1.0" and # "force-response-1.0" for this. BrowserMatch ".*MSIE.*" \ nokeepalive ssl-unclean-shutdown \ downgrade-1.0 force-response-1.0 ## Per-Server Logging: # The home of a custom SSL log file. Use this when you want a compact # non-error SSL logfile on a virtual host basis. CustomLog /var/log/apache2/ssl_request_log \ "%t %h %{SSL_PROTOCOL}x %{SSL_CIPHER}x \"%r\" %b" # vim: ts=4 filetype=apache ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/gentoo_apache/apache/apache2/vhosts.d/00_default_vhost.conf0000644000076500000240000000266600000000000031217 0ustar00bmwstaff# Virtual Hosts # # If you want to maintain multiple domains/hostnames on your # machine you can setup VirtualHost containers for them. Most configurations # use only name-based virtual hosts so the server doesn't need to worry about # IP addresses. This is indicated by the asterisks in the directives below. # # Please see the documentation at # # for further details before you try to setup virtual hosts. # # You may use the command line option '-S' to verify your virtual host # configuration. # see bug #178966 why this is in here # Listen: Allows you to bind Apache to specific IP addresses and/or # ports, instead of the default. See also the # directive. # # Change this to Listen on specific IP addresses as shown below to # prevent Apache from glomming onto all bound IP addresses. # #Listen 12.34.56.78:80 Listen 80 # When virtual hosts are enabled, the main host defined in the default # httpd.conf configuration will go away. We redefine it here so that it is # still available. # # If you disable this vhost by removing -D DEFAULT_VHOST from # /etc/conf.d/apache2, the first defined virtual host elsewhere will be # the default. ServerName localhost Include /etc/apache2/vhosts.d/default_vhost.include ServerEnvironment apache apache # vim: ts=4 filetype=apache ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/gentoo_apache/apache/apache2/vhosts.d/default_vhost.include0000644000076500000240000000536400000000000031414 0ustar00bmwstaff# ServerAdmin: Your address, where problems with the server should be # e-mailed. This address appears on some server-generated pages, such # as error documents. e.g. admin@your-domain.com ServerAdmin root@localhost # DocumentRoot: The directory out of which you will serve your # documents. By default, all requests are taken from this directory, but # symbolic links and aliases may be used to point to other locations. # # If you change this to something that isn't under /var/www then suexec # will no longer work. DocumentRoot "/var/www/localhost/htdocs" # This should be changed to whatever you set DocumentRoot to. # Possible values for the Options directive are "None", "All", # or any combination of: # Indexes Includes FollowSymLinks SymLinksifOwnerMatch ExecCGI MultiViews # # Note that "MultiViews" must be named *explicitly* --- "Options All" # doesn't give it to you. # # The Options directive is both complicated and important. Please see # http://httpd.apache.org/docs/2.4/mod/core.html#options # for more information. Options Indexes FollowSymLinks # AllowOverride controls what directives may be placed in .htaccess files. # It can be "All", "None", or any combination of the keywords: # Options FileInfo AuthConfig Limit AllowOverride All # Controls who can get stuff from this server. Require all granted # Redirect: Allows you to tell clients about documents that used to # exist in your server's namespace, but do not anymore. The client # will make a new request for the document at its new location. # Example: # Redirect permanent /foo http://www.example.com/bar # Alias: Maps web paths into filesystem paths and is used to # access content that does not live under the DocumentRoot. # Example: # Alias /webpath /full/filesystem/path # # If you include a trailing / on /webpath then the server will # require it to be present in the URL. You will also likely # need to provide a section to allow access to # the filesystem path. # ScriptAlias: This controls which directories contain server scripts. # ScriptAliases are essentially the same as Aliases, except that # documents in the target directory are treated as applications and # run by the server when requested rather than as documents sent to the # client. The same rules about trailing "/" apply to ScriptAlias # directives as to Alias. ScriptAlias /cgi-bin/ "/var/www/localhost/cgi-bin/" # "/var/www/localhost/cgi-bin" should be changed to whatever your ScriptAliased # CGI directory exists, if you have that configured. AllowOverride None Options None Require all granted # vim: ts=4 filetype=apache ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/gentoo_apache/apache/apache2/vhosts.d/gentoo.example.com.conf0000644000076500000240000000032500000000000031541 0ustar00bmwstaff ServerName gentoo.example.com ServerAdmin webmaster@localhost DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1635888463.8187575 certbot-apache-1.21.0/tests/testdata/gentoo_apache/apache/conf.d/0000755000076500000240000000000000000000000023264 5ustar00bmwstaff././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/gentoo_apache/apache/conf.d/apache20000644000076500000240000000610000000000000024507 0ustar00bmwstaff# /etc/conf.d/apache2: config file for /etc/init.d/apache2 # When you install a module it is easy to activate or deactivate the modules # and other features of apache using the APACHE2_OPTS line. Every module should # install a configuration in /etc/apache2/modules.d. In that file will have an # directive where NNN is the option to enable that module. # # Here are the options available in the default configuration: # # AUTH_DIGEST Enables mod_auth_digest # AUTHNZ_LDAP Enables authentication through mod_ldap (available if USE=ldap) # CACHE Enables mod_cache # DAV Enables mod_dav # ERRORDOCS Enables default error documents for many languages. # INFO Enables mod_info, a useful module for debugging # LANGUAGE Enables content-negotiation based on language and charset. # LDAP Enables mod_ldap (available if USE=ldap) # MANUAL Enables /manual/ to be the apache manual (available if USE=docs) # MEM_CACHE Enables default configuration mod_mem_cache # PROXY Enables mod_proxy # SSL Enables SSL (available if USE=ssl) # STATUS Enabled mod_status, a useful module for statistics # SUEXEC Enables running CGI scripts (in USERDIR) through suexec. # USERDIR Enables /~username mapping to /home/username/public_html # # # The following two options provide the default virtual host for the HTTP and # HTTPS protocol. YOU NEED TO ENABLE AT LEAST ONE OF THEM, otherwise apache # will not listen for incomming connections on the approriate port. # # DEFAULT_VHOST Enables name-based virtual hosts, with the default # virtual host being in /var/www/localhost/htdocs # SSL_DEFAULT_VHOST Enables default vhost for SSL (you should enable this # when you enable SSL) # APACHE2_OPTS="-D DEFAULT_VHOST -D INFO -D SSL -D SSL_DEFAULT_VHOST -D LANGUAGE" # Extended options for advanced uses of Apache ONLY # You don't need to edit these unless you are doing crazy Apache stuff # As not having them set correctly, or feeding in an incorrect configuration # via them will result in Apache failing to start # YOU HAVE BEEN WARNED. # PID file #PIDFILE=/var/run/apache2.pid # timeout for startup/shutdown checks #TIMEOUT=10 # ServerRoot setting #SERVERROOT=/usr/lib64/apache2 # Configuration file location # - If this does NOT start with a '/', then it is treated relative to # $SERVERROOT by Apache #CONFIGFILE=/etc/apache2/httpd.conf # Location to log startup errors to # They are normally dumped to your terminal. #STARTUPERRORLOG="/var/log/apache2/startuperror.log" # A command that outputs a formatted text version of the HTML at the URL # of the command line. Designed for lynx, however other programs may work. #LYNX="lynx -dump" # The URL to your server's mod_status status page. # Required for status and fullstatus #STATUSURL="http://localhost/server-status" # Method to use when reloading the server # Valid options are 'restart' and 'graceful' # See http://httpd.apache.org/docs/2.2/stopping.html for information on # what they do and how they differ. #RELOAD_TYPE="graceful" ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/testdata/gentoo_apache/apache/sites0000644000076500000240000000021500000000000023165 0ustar00bmwstaffvhosts.d/gentoo.example.com.conf, gentoo.example.com vhosts.d/00_default_vhost.conf, localhost vhosts.d/00_default_ssl_vhost.conf, localhost ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635888438.0 certbot-apache-1.21.0/tests/util.py0000644000076500000240000002520100000000000015616 0ustar00bmwstaff"""Common utilities for certbot_apache.""" import shutil import sys import unittest import augeas import josepy as jose try: import mock except ImportError: # pragma: no cover from unittest import mock # type: ignore from certbot.compat import os from certbot.plugins import common from certbot.tests import util as test_util from certbot.display import util as display_util from certbot_apache._internal import configurator from certbot_apache._internal import entrypoint from certbot_apache._internal import obj class ApacheTest(unittest.TestCase): def setUp(self, test_dir="debian_apache_2_4/multiple_vhosts", config_root="debian_apache_2_4/multiple_vhosts/apache2", vhost_root="debian_apache_2_4/multiple_vhosts/apache2/sites-available"): # pylint: disable=arguments-differ self.temp_dir, self.config_dir, self.work_dir = common.dir_setup( test_dir=test_dir, pkg=__name__) self.config_path = os.path.join(self.temp_dir, config_root) self.vhost_path = os.path.join(self.temp_dir, vhost_root) self.rsa512jwk = jose.JWKRSA.load(test_util.load_vector( "rsa512_key.pem")) self.config = get_apache_configurator(self.config_path, vhost_root, self.config_dir, self.work_dir) # Make sure all vhosts in sites-enabled are symlinks (Python packaging # does not preserve symlinks) sites_enabled = os.path.join(self.config_path, "sites-enabled") if not os.path.exists(sites_enabled): return for vhost_basename in os.listdir(sites_enabled): # Keep the one non-symlink test vhost in place if vhost_basename == "non-symlink.conf": continue vhost = os.path.join(sites_enabled, vhost_basename) if not os.path.islink(vhost): # pragma: no cover os.remove(vhost) target = os.path.join( os.path.pardir, "sites-available", vhost_basename) os.symlink(target, vhost) def tearDown(self): shutil.rmtree(self.temp_dir) shutil.rmtree(self.config_dir) shutil.rmtree(self.work_dir) class ParserTest(ApacheTest): def setUp(self, test_dir="debian_apache_2_4/multiple_vhosts", config_root="debian_apache_2_4/multiple_vhosts/apache2", vhost_root="debian_apache_2_4/multiple_vhosts/apache2/sites-available"): super().setUp(test_dir, config_root, vhost_root) from certbot_apache._internal.parser import ApacheParser self.aug = augeas.Augeas( flags=augeas.Augeas.NONE | augeas.Augeas.NO_MODL_AUTOLOAD) with mock.patch("certbot_apache._internal.parser.ApacheParser." "update_runtime_variables"): self.parser = ApacheParser( self.config_path, self.vhost_path, configurator=self.config) def get_apache_configurator( config_path, vhost_path, config_dir, work_dir, version=(2, 4, 7), os_info="generic", conf_vhost_path=None, use_parsernode=False, openssl_version="1.1.1a"): """Create an Apache Configurator with the specified options. :param conf: Function that returns binary paths. self.conf in Configurator """ backups = os.path.join(work_dir, "backups") mock_le_config = mock.MagicMock( apache_server_root=config_path, apache_vhost_root=None, apache_le_vhost_ext="-le-ssl.conf", apache_challenge_location=config_path, apache_enmod=None, backup_dir=backups, config_dir=config_dir, http01_port=80, temp_checkpoint_dir=os.path.join(work_dir, "temp_checkpoints"), in_progress_dir=os.path.join(backups, "IN_PROGRESS"), work_dir=work_dir) with mock.patch("certbot_apache._internal.configurator.util.run_script"): with mock.patch("certbot_apache._internal.configurator.util." "exe_exists") as mock_exe_exists: mock_exe_exists.return_value = True with mock.patch("certbot_apache._internal.parser.ApacheParser." "update_runtime_variables"): with mock.patch("certbot_apache._internal.apache_util.parse_from_subprocess") as mock_sp: mock_sp.return_value = [] try: config_class = entrypoint.OVERRIDE_CLASSES[os_info] except KeyError: config_class = configurator.ApacheConfigurator config = config_class(config=mock_le_config, name="apache", version=version, use_parsernode=use_parsernode, openssl_version=openssl_version) if not conf_vhost_path: config_class.OS_DEFAULTS.vhost_root = vhost_path else: # Custom virtualhost path was requested config.config.apache_vhost_root = conf_vhost_path config.config.apache_ctl = config_class.OS_DEFAULTS.ctl config.prepare() return config def get_vh_truth(temp_dir, config_name): """Return the ground truth for the specified directory.""" if config_name == "debian_apache_2_4/multiple_vhosts": prefix = os.path.join( temp_dir, config_name, "apache2/sites-enabled") aug_pre = "/files" + prefix vh_truth = [ obj.VirtualHost( os.path.join(prefix, "encryption-example.conf"), os.path.join(aug_pre, "encryption-example.conf/Virtualhost"), {obj.Addr.fromstring("*:80")}, False, True, "encryption-example.demo"), obj.VirtualHost( os.path.join(prefix, "default-ssl.conf"), os.path.join(aug_pre, "default-ssl.conf/IfModule/VirtualHost"), {obj.Addr.fromstring("_default_:443")}, True, True), obj.VirtualHost( os.path.join(prefix, "000-default.conf"), os.path.join(aug_pre, "000-default.conf/VirtualHost"), {obj.Addr.fromstring("*:80"), obj.Addr.fromstring("[::]:80")}, False, True, "ip-172-30-0-17"), obj.VirtualHost( os.path.join(prefix, "certbot.conf"), os.path.join(aug_pre, "certbot.conf/VirtualHost"), {obj.Addr.fromstring("*:80")}, False, True, "certbot.demo", aliases=["www.certbot.demo"]), obj.VirtualHost( os.path.join(prefix, "mod_macro-example.conf"), os.path.join(aug_pre, "mod_macro-example.conf/Macro/VirtualHost"), {obj.Addr.fromstring("*:80")}, False, True, modmacro=True), obj.VirtualHost( os.path.join(prefix, "default-ssl-port-only.conf"), os.path.join(aug_pre, ("default-ssl-port-only.conf/" "IfModule/VirtualHost")), {obj.Addr.fromstring("_default_:443")}, True, True), obj.VirtualHost( os.path.join(prefix, "wildcard.conf"), os.path.join(aug_pre, "wildcard.conf/VirtualHost"), {obj.Addr.fromstring("*:80")}, False, True, "ip-172-30-0-17", aliases=["*.blue.purple.com"]), obj.VirtualHost( os.path.join(prefix, "ocsp-ssl.conf"), os.path.join(aug_pre, "ocsp-ssl.conf/IfModule/VirtualHost"), {obj.Addr.fromstring("10.2.3.4:443")}, True, True, "ocspvhost.com"), obj.VirtualHost( os.path.join(prefix, "non-symlink.conf"), os.path.join(aug_pre, "non-symlink.conf/VirtualHost"), {obj.Addr.fromstring("*:80")}, False, True, "nonsym.link"), obj.VirtualHost( os.path.join(prefix, "default-ssl-port-only.conf"), os.path.join(aug_pre, "default-ssl-port-only.conf/VirtualHost"), {obj.Addr.fromstring("*:80")}, True, True, ""), obj.VirtualHost( os.path.join(temp_dir, config_name, "apache2/apache2.conf"), "/files" + os.path.join(temp_dir, config_name, "apache2/apache2.conf/VirtualHost"), {obj.Addr.fromstring("*:80")}, False, True, "vhost.in.rootconf"), obj.VirtualHost( os.path.join(prefix, "duplicatehttp.conf"), os.path.join(aug_pre, "duplicatehttp.conf/VirtualHost"), {obj.Addr.fromstring("10.2.3.4:80")}, False, True, "duplicate.example.com"), obj.VirtualHost( os.path.join(prefix, "duplicatehttps.conf"), os.path.join(aug_pre, "duplicatehttps.conf/IfModule/VirtualHost"), {obj.Addr.fromstring("10.2.3.4:443")}, True, True, "duplicate.example.com")] return vh_truth if config_name == "debian_apache_2_4/multi_vhosts": prefix = os.path.join( temp_dir, config_name, "apache2/sites-available") aug_pre = "/files" + prefix vh_truth = [ obj.VirtualHost( os.path.join(prefix, "default.conf"), os.path.join(aug_pre, "default.conf/VirtualHost[1]"), {obj.Addr.fromstring("*:80")}, False, True, "ip-172-30-0-17"), obj.VirtualHost( os.path.join(prefix, "default.conf"), os.path.join(aug_pre, "default.conf/VirtualHost[2]"), {obj.Addr.fromstring("*:80")}, False, True, "banana.vomit.com"), obj.VirtualHost( os.path.join(prefix, "multi-vhost.conf"), os.path.join(aug_pre, "multi-vhost.conf/VirtualHost[1]"), {obj.Addr.fromstring("*:80")}, False, True, "1.multi.vhost.tld"), obj.VirtualHost( os.path.join(prefix, "multi-vhost.conf"), os.path.join(aug_pre, "multi-vhost.conf/IfModule/VirtualHost"), {obj.Addr.fromstring("*:80")}, False, True, "2.multi.vhost.tld"), obj.VirtualHost( os.path.join(prefix, "multi-vhost.conf"), os.path.join(aug_pre, "multi-vhost.conf/VirtualHost[2]"), {obj.Addr.fromstring("*:80")}, False, True, "3.multi.vhost.tld")] return vh_truth return None # pragma: no cover