AccessControl 7.4__tar.gz → 7.6__tar.gz

{accesscontrol-7.4 → accesscontrol-7.6}/.manylinux-install.sh

@@ -28,7 +28,6 @@ yum -y install libffi-devel
 
 tox_env_map() {
     case $1 in
-        *"cp310"*) echo 'py310';;
         *"cp311"*) echo 'py311';;
         *"cp312"*) echo 'py312';;
         *"cp313"*) echo 'py313';;
@@ -41,19 +40,13 @@ tox_env_map() {
 # Compile wheels
 for PYBIN in /opt/python/*/bin; do
     if \
-       [[ "${PYBIN}" == *"cp310/"* ]] || \
        [[ "${PYBIN}" == *"cp311/"* ]] || \
        [[ "${PYBIN}" == *"cp312/"* ]] || \
        [[ "${PYBIN}" == *"cp313/"* ]] || \
        [[ "${PYBIN}" == *"cp314/"* ]] || \
-       [[ "${PYBIN}" == *"cp315/"* ]] ; then
-        if [[ "${PYBIN}" == *"cp315/"* ]] ; then
-            "${PYBIN}/pip" install --pre -e /io/
-            "${PYBIN}/pip" wheel /io/ --pre -w wheelhouse/
-        else
-            "${PYBIN}/pip" install -e /io/
-            "${PYBIN}/pip" wheel /io/ -w wheelhouse/
-        fi
+       [[ "${PYBIN}" == *"cp315/"* ]]  ; then
+        "${PYBIN}/pip" install -e /io/
+        "${PYBIN}/pip" wheel /io/ -w wheelhouse/
         if [ `uname -m` == 'aarch64' ]; then
           cd /io/
           ${PYBIN}/pip install tox

{accesscontrol-7.4 → accesscontrol-7.6}/.pre-commit-config.yaml

@@ -2,6 +2,15 @@
 # https://github.com/zopefoundation/meta/tree/master/src/zope/meta/c-code
 minimum_pre_commit_version: '3.6'
 repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v6.0.0
+    hooks:
+    - id: check-case-conflict
+    - id: check-merge-conflict
+    - id: check-toml
+    - id: check-yaml
+    - id: end-of-file-fixer
+    - id: trailing-whitespace
   - repo: https://github.com/pycqa/isort
     rev: "8.0.1"
     hooks:
@@ -15,7 +24,7 @@ repos:
     rev: v3.21.2
     hooks:
     - id: pyupgrade
-      args: [--py310-plus]
+      args: [--py311-plus]
   - repo: https://github.com/isidentical/teyit
     rev: 0.4.3
     hooks:
@@ -27,3 +36,7 @@ repos:
     - id: flake8
       additional_dependencies:
         - flake8-debugger == 4.1.2
+  - repo: https://github.com/sphinx-contrib/sphinx-lint
+    rev: v1.0.2
+    hooks:
+    - id: sphinx-lint

{accesscontrol-7.4 → accesscontrol-7.6}/CHANGES.rst

@@ -4,9 +4,53 @@ Change log
 For changes before version 3.0, see ``HISTORY.rst``.
 
 
+7.6 (2026-10-30)
+----------------
+
+- Add ``freeze_security_declarations``.  Call it once all code has been
+  loaded, for example when Zope has started.  Afterwards, any change to
+  module security declarations, for example with ``allow_module`` or
+  ``ModuleSecurityInfo``, raises ``Forbidden``.  The same is true for
+  ``allow_class``, ``allow_type`` and other changes to
+  ``ContainerAssertions``.  Dangerous modules like ``os``, ``subprocess``,
+  ``AccessControl`` itself, and third-party network libraries like
+  ``requests`` and ``httpx``, that are
+  fully accessible from restricted code, for example with ``allow_module``,
+  are logged as a warning.  Pass ``dangerous_modules`` to change which
+  modules are dangerous.  Calling it a second time does nothing.  Call
+  ``check_dangerous_modules`` to check other modules, also after the freeze.
+
+- Remove module security declaration for ``sets``.
+  This module only existed in Python 2.
+
+- Add additional safeguards to ``SecurityInfo.allow_class`` / ``allow_module``
+  and ``SimpleObjectPolicies.allow_type`` to prevent use from untrusted code.
+
+- Add support for Python 3.15.
+
+- Drop support for Python 3.10.
+
+
+7.5 (2026-08-20)
+----------------
+
+- Add final support for Python 3.15.
+
+- Switch to PyPI Trusted Publishing.
+
+
 7.4 (2026-07-13)
 ----------------
 
+- Prevent information disclosure through the ``format`` and ``format_map``
+  methods of ``str`` subclasses: the guards which route these methods to the
+  safe formatter only covered ``str`` itself, so a subclass instance could be
+  used to read otherwise inaccessible objects via attribute access and
+  subscription in a format string
+  (fixes `GHSA-pq59-9fq7-m886
+  <https://github.com/zopefoundation/AccessControl/security/advisories/GHSA-pq59-9fq7-m886>`_,
+  CVE-2026-77401).
+
 - Fix a parity defect between the Python and C implementations of
   ``guarded_getattr``: the pure-Python implementation keyed the container
   assertion on ``type(value.__self__)`` instead of ``type(inst)``, so under

accesscontrol-7.6/COPYRIGHT.txt

@@ -0,0 +1 @@
+Zope Foundation and Contributors

{accesscontrol-7.4 → accesscontrol-7.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AccessControl
-Version: 7.4
+Version: 7.6
 Summary: Security framework for Zope
 Author-email: Zope Foundation and contributors <zope-dev@zope.dev>
 Maintainer-email: Plone Foundation and contributors <zope-dev@zope.dev>
@@ -16,14 +16,13 @@ Classifier: Framework :: Zope :: 5
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Programming Language :: Python :: Implementation :: CPython
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
 Requires-Dist: Acquisition
@@ -73,9 +72,53 @@ Change log
 For changes before version 3.0, see ``HISTORY.rst``.
 
 
+7.6 (2026-10-30)
+----------------
+
+- Add ``freeze_security_declarations``.  Call it once all code has been
+  loaded, for example when Zope has started.  Afterwards, any change to
+  module security declarations, for example with ``allow_module`` or
+  ``ModuleSecurityInfo``, raises ``Forbidden``.  The same is true for
+  ``allow_class``, ``allow_type`` and other changes to
+  ``ContainerAssertions``.  Dangerous modules like ``os``, ``subprocess``,
+  ``AccessControl`` itself, and third-party network libraries like
+  ``requests`` and ``httpx``, that are
+  fully accessible from restricted code, for example with ``allow_module``,
+  are logged as a warning.  Pass ``dangerous_modules`` to change which
+  modules are dangerous.  Calling it a second time does nothing.  Call
+  ``check_dangerous_modules`` to check other modules, also after the freeze.
+
+- Remove module security declaration for ``sets``.
+  This module only existed in Python 2.
+
+- Add additional safeguards to ``SecurityInfo.allow_class`` / ``allow_module``
+  and ``SimpleObjectPolicies.allow_type`` to prevent use from untrusted code.
+
+- Add support for Python 3.15.
+
+- Drop support for Python 3.10.
+
+
+7.5 (2026-08-20)
+----------------
+
+- Add final support for Python 3.15.
+
+- Switch to PyPI Trusted Publishing.
+
+
 7.4 (2026-07-13)
 ----------------
 
+- Prevent information disclosure through the ``format`` and ``format_map``
+  methods of ``str`` subclasses: the guards which route these methods to the
+  safe formatter only covered ``str`` itself, so a subclass instance could be
+  used to read otherwise inaccessible objects via attribute access and
+  subscription in a format string
+  (fixes `GHSA-pq59-9fq7-m886
+  <https://github.com/zopefoundation/AccessControl/security/advisories/GHSA-pq59-9fq7-m886>`_,
+  CVE-2026-77401).
+
 - Fix a parity defect between the Python and C implementations of
   ``guarded_getattr``: the pure-Python implementation keyed the container
   assertion on ``type(value.__self__)`` instead of ``type(inst)``, so under

{accesscontrol-7.4 → accesscontrol-7.6}/docs/AccessControl.rst

@@ -30,15 +30,15 @@ Types of access
 
 A "type of access" is a named grouping of 0 or more of the
 permissions defined by an object. All objects have one predefined
-type of access called Full Access (all permissions defined by that 
-object). A user who has the special role "Manager" always has Full 
-Access to all objects at or below the level in the object hierarchy 
+type of access called Full Access (all permissions defined by that
+object). A user who has the special role "Manager" always has Full
+Access to all objects at or below the level in the object hierarchy
 at which the user is defined.
 
 New types of access may be defined as combinations of the
 various permissions defined by a given object. These new
 types of access may be defined by the programmer, or by
-users at runtime. 
+users at runtime.
 
 
 
@@ -50,13 +50,13 @@ A role is a name that ties users (authentication of identity)
 to permissions (authorization for that identity) in the system.
 Roles may be defined in any Folder (or Folderish) object in the
 system. Sub folders can make use of roles defined higher in the
-hierarchy. These roles can be assigned to users. All users, 
-including non-authenticated users have the built-in role of 
-"Anonymous". 
+hierarchy. These roles can be assigned to users. All users,
+including non-authenticated users have the built-in role of
+"Anonymous".
 
-Principia objects allow the association of defined roles 
-with a single "type of access" each, in the context of that 
-object. A single role is associated with one and only one 
+Principia objects allow the association of defined roles
+with a single "type of access" each, in the context of that
+object. A single role is associated with one and only one
 type of access in the context of a given object.
 
 
@@ -191,14 +191,14 @@ Example:
     )
 
 The developer may also predefine useful types of access, by
-specifying an __ac_types__ attribute. This should be a tuple of 
-tuples, where each tuple represents a type of access and contains 
-a string name as its first element and a list of permission names 
+specifying an __ac_types__ attribute. This should be a tuple of
+tuples, where each tuple represents a type of access and contains
+a string name as its first element and a list of permission names
 as its second element.
 
 By default, only "Full Access" is defined (by the RoleManager mixin).
 If you wish to override __ac_types__ to provide convenient types of
-access, you must always be sure to define "Full Access" as containing 
+access, you must always be sure to define "Full Access" as containing
 the names of all possible permissions for your object.
 
 Example:

{accesscontrol-7.4 → accesscontrol-7.6}/pyproject.toml

@@ -9,11 +9,11 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "AccessControl"
-version = "7.4"
+version = "7.6"
 description = "Security framework for Zope"
 keywords = ["security", "access", "authorization"]
 dynamic = ["readme"]
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 license = "ZPL-2.1"
 authors = [
   { name = "Zope Foundation and contributors", email = "zope-dev@zope.dev" },
@@ -22,20 +22,19 @@ maintainers = [
   { name = "Plone Foundation and contributors", email = "zope-dev@zope.dev" },
 ]
 classifiers = [
-  "Development Status :: 6 - Mature",
-  "Environment :: Web Environment",
-  "Framework :: Zope",
-  "Framework :: Zope :: 5",
-  "Operating System :: OS Independent",
-  "Programming Language :: Python",
-  "Programming Language :: Python :: 3",
-  "Programming Language :: Python :: 3 :: Only",
-  "Programming Language :: Python :: 3.10",
-  "Programming Language :: Python :: 3.11",
-  "Programming Language :: Python :: 3.12",
-  "Programming Language :: Python :: 3.13",
-  "Programming Language :: Python :: 3.14",
-  "Programming Language :: Python :: Implementation :: CPython",
+    "Development Status :: 6 - Mature",
+    "Environment :: Web Environment",
+    "Framework :: Zope",
+    "Framework :: Zope :: 5",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
+    "Programming Language :: Python :: Implementation :: CPython",
 ]
 dependencies = [
   "Acquisition",
@@ -108,4 +107,5 @@ readme = {file = ["README.rst", "CHANGES.rst"]}
 
 [tool.zest-releaser]
 create-wheel = false
+extra-message = ""
 upload-pypi = false

{accesscontrol-7.4 → accesscontrol-7.6}/src/AccessControl/SecurityInfo.py

@@ -44,6 +44,7 @@ from logging import getLogger
 from Acquisition import Implicit
 from Persistence import Persistent
 
+from AccessControl import frozen
 from AccessControl.class_init import InitializeClass
 from AccessControl.ImplPython import _what_not_even_god_should_do
 
@@ -258,8 +259,8 @@ class ClassSecurityInformation(ClassSecurityInfo):
     access = 0
 
 
-_moduleSecurity = {}
-_appliedModuleSecurity = {}
+_moduleSecurity = frozen.FreezableDict()
+_appliedModuleSecurity = frozen.FreezableDict()
 
 
 def secureModule(mname, *imp):
@@ -333,6 +334,17 @@ class _ModuleSecurityInfo(SecurityInfo):
 
         return getattr(self, 'access', 0)
 
+    def _setaccess(self, names, access):
+        frozen.check_not_frozen()
+        super()._setaccess(names, access)
+
+    setDefaultAccess__roles__ = ACCESS_PRIVATE
+
+    def setDefaultAccess(self, access):
+        """Declare default attribute access policy."""
+        frozen.check_not_frozen()
+        super().setDefaultAccess(access)
+
     apply__roles__ = ACCESS_PRIVATE
 
     def apply(self, dict):
@@ -380,11 +392,111 @@ def allow_module(module_name):
         dot = module_name.find('.', dot + 1)
 
 
+allow_module.__roles__ = ACCESS_PRIVATE
+
+# Modules that should never be fully accessible from restricted code.
+# A declaration for one of these, or a submodule, is logged by
+# check_dangerous_modules, which freeze_security_declarations calls.
+# PLEASE NOTE: This listing cannot ever be complete and it cannot guard
+# against malicious or sloppy code exposing other unsafe modules! Its
+# purpose is just informational, it is not a safe catch-all.
+DANGEROUS_MODULES = frozenset((
+    # processes and code execution
+    '_posixsubprocess', '_thread', 'asyncio', 'atexit', 'bdb', 'builtins',
+    'code', 'codeop', 'concurrent', 'copyreg', 'cProfile', 'ctypes',
+    '_ctypes', 'doctest', 'faulthandler', 'gc', 'importlib', 'inspect',
+    'logging', 'marshal', 'multiprocessing', 'nt', 'operator', 'os', 'pdb',
+    'pickle', '_pickle', 'pkgutil', 'posix', 'profile', 'pty', 'pydoc',
+    'runpy', 'shelve', 'signal', 'site', 'subprocess', 'sys', 'threading',
+    'timeit', 'trace', 'traceback', 'types', 'unittest', 'webbrowser',
+    'zipimport',
+    # filesystem
+    'bz2', 'codecs', 'compileall', 'configparser', 'dbm', 'ensurepip',
+    'fcntl', 'filecmp', 'fileinput', 'genericpath', 'glob', 'gzip', 'io',
+    '_io', 'linecache', 'lzma', 'mailbox', 'mmap', 'netrc', 'ntpath',
+    'pathlib', 'posixpath', 'py_compile', 'shutil', 'sqlite3', 'sysconfig',
+    'tarfile', 'tempfile', 'venv', 'zipapp', 'zipfile',
+    # network
+    'ftplib', 'http', 'imaplib', 'poplib', 'select', 'selectors', 'smtplib',
+    'socket', 'socketserver', 'ssl', 'urllib', 'wsgiref', 'xmlrpc',
+    # information about the system, or process wide state
+    'getpass', 'grp', 'locale', 'platform', 'pwd', 'resource',
+    # Zope: security declarations and policy, switching users or sites,
+    # transactions, the database
+    'AccessControl', 'App', 'transaction', 'ZODB', 'Zope2',
+    'zope.component.hooks', 'zope.interface',
+    # third-party network libraries: requests from the server itself can
+    # reach internal services, and httpx can use local Unix sockets
+    'aiohttp', 'httpx', 'pycurl', 'requests', 'urllib3',
+))
+
+
+def freeze_security_declarations(dangerous_modules=DANGEROUS_MODULES):
+    """Refuse changes to security declarations from now on.
+
+    Call this once all code has been loaded, for example when Zope has
+    started.  Afterwards, ModuleSecurityInfo, allow_module, allow_class and
+    allow_type raise Forbidden for any change, so new modules, classes and
+    types cannot be opened up to restricted code.
+
+    Normal class security declarations with ClassSecurityInfo still work,
+    because classes may be imported later, for example when loading objects
+    from the database.
+
+    Pending declarations are applied first, because importing a module from
+    restricted code would otherwise still need to change them.  Dangerous
+    modules that are fully accessible are logged as a warning, see
+    check_dangerous_modules.
+
+    Calling this when security declarations are already frozen does nothing.
+    """
+    if frozen.is_frozen():
+        return
+    # Most of these modules have likely already been imported, because the
+    # declarations are usually made in the module itself or its package.
+    # So this is fast.
+    for name in sorted(_moduleSecurity):
+        try:
+            secureModule(name, {}, {})
+        except ImportError:
+            LOG.info(f'Could not import {name!r} to apply its'
+                     ' module security declarations.')
+
+    check_dangerous_modules(dangerous_modules)
+    frozen.freeze()
+
+
+def check_dangerous_modules(dangerous_modules=DANGEROUS_MODULES):
+    """Log a warning for dangerous modules accessible from restricted code.
+
+    Only modules that are fully accessible are logged, for example with
+    allow_module, not modules where only specific names are public.
+    A submodule of a dangerous module is dangerous as well.  Pass
+    dangerous_modules to check other modules, for example ``{'my.package'}``.
+    """
+    for name in sorted(set(_moduleSecurity) | set(_appliedModuleSecurity)):
+        modsec = _appliedModuleSecurity.get(name) or _moduleSecurity[name]
+        access = getattr(modsec, 'access', 0)
+        if not access or isinstance(access, dict):
+            # Only specific names are accessible.
+            continue
+        parts = name.split('.')
+        for index in range(1, len(parts) + 1):
+            if '.'.join(parts[:index]) in dangerous_modules:
+                LOG.warning(
+                    f'Module {name!r} is accessible from restricted code.')
+                break
+
+
 def allow_class(Class):
     """Allow a class and all of its methods to be used from a
     restricted Script.  The argument Class must be a class."""
+    frozen.check_not_frozen()
     Class._security = sec = ClassSecurityInfo()
     sec.declareObjectPublic()
     sec.setDefaultAccess(1)
     sec.apply(Class)
     InitializeClass(Class)
+
+
+allow_class.__roles__ = ACCESS_PRIVATE

{accesscontrol-7.4 → accesscontrol-7.6}/src/AccessControl/SimpleObjectPolicies.py

@@ -61,6 +61,8 @@ from BTrees.OOBTree import OOBTree
 from BTrees.OOBTree import OOBucket
 from BTrees.OOBTree import OOSet
 
+from AccessControl.frozen import FreezableDict
+
 
 _noroles = []  # this is imported in various places
 _marker = object()
@@ -84,12 +86,13 @@ _marker = object()
 #        The boolean values behave as above, but the functions do not.
 #        The value returned for attribute access is the result of
 #        calling the function with the object and the attribute name.
-ContainerAssertions = {
+# Changes are refused once security declarations are frozen.
+ContainerAssertions = FreezableDict({
     type(()): 1,
     bytes: 1,
     str: 1,
     range: 1,
-}
+})
 
 Containers = ContainerAssertions.get
 
@@ -106,6 +109,9 @@ def allow_type(Type, allowed=1):
     ContainerAssertions[Type] = allowed
 
 
+allow_type.__roles__ = ()  # Only accessible from trusted code
+
+
 for tree_type, has_values in [
     (OOBTree, 1),
     (OOBucket, 1),

{accesscontrol-7.4 → accesscontrol-7.6}/src/AccessControl/__init__.py

@@ -22,6 +22,7 @@ from AccessControl.SecurityInfo import ClassSecurityInfo
 from AccessControl.SecurityInfo import ModuleSecurityInfo
 from AccessControl.SecurityInfo import allow_class
 from AccessControl.SecurityInfo import allow_module
+from AccessControl.SecurityInfo import freeze_security_declarations
 from AccessControl.SecurityInfo import secureModule
 from AccessControl.SecurityManagement import getSecurityManager
 from AccessControl.SecurityManagement import setSecurityPolicy
@@ -36,7 +37,7 @@ ModuleSecurityInfo('AccessControl').declarePublic('getSecurityManager')  # NOQA
 
 # allow imports of utility_builtins
 
-for name in ('string', 'math', 'random', 'sets'):
+for name in ('string', 'math', 'random'):
     ModuleSecurityInfo(name).setDefaultAccess('allow')
 
 ModuleSecurityInfo('DateTime').declarePublic('DateTime')  # NOQA: D001

accesscontrol-7.6/src/AccessControl/frozen.py

@@ -0,0 +1,57 @@
+##############################################################################
+#
+# Copyright (c) 2026 Zope Foundation and Contributors.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE
+#
+##############################################################################
+"""Refuse changes to security declarations once they are frozen.
+
+See AccessControl.SecurityInfo.freeze_security_declarations.
+"""
+
+from zExceptions import Forbidden
+
+
+_frozen = False
+
+
+def freeze():
+    global _frozen
+    _frozen = True
+
+
+def is_frozen():
+    return _frozen
+
+
+def check_not_frozen():
+    if _frozen:
+        raise Forbidden('Security declarations are frozen.')
+
+
+def _guarded_dict_method(name):
+    method = getattr(dict, name)
+
+    def guarded(self, *args, **kwargs):
+        check_not_frozen()
+        return method(self, *args, **kwargs)
+    return guarded
+
+
+class FreezableDict(dict):
+    """dict that refuses changes once security declarations are frozen."""
+
+    __setitem__ = _guarded_dict_method('__setitem__')
+    __delitem__ = _guarded_dict_method('__delitem__')
+    __ior__ = _guarded_dict_method('__ior__')
+    clear = _guarded_dict_method('clear')
+    pop = _guarded_dict_method('pop')
+    popitem = _guarded_dict_method('popitem')
+    setdefault = _guarded_dict_method('setdefault')
+    update = _guarded_dict_method('update')

{accesscontrol-7.4 → accesscontrol-7.6}/src/AccessControl/meta.zcml

@@ -40,7 +40,7 @@
         name="permission"
         schema="zope.security.zcml.IPermissionDirective"
         handler=".security.PermissionDirective"/>
-    
+
     <meta:directive
         name="role"
         usedIn="zope.security.zcml.IPermissionDirective"

{accesscontrol-7.4 → accesscontrol-7.6}/src/AccessControl/tests/actual_python.py

@@ -127,9 +127,9 @@ def f7():
         iter_ = access()  # iterate twice on the same view
         assert list(iter_) == list(iter_)
 
-        assert sorted([k for k in getattr(d, meth)()]) == expected[kind]
+        assert sorted([*getattr(d, meth)()]) == expected[kind]
         assert sorted(k for k in getattr(d, meth)()) == expected[kind]
-    assert {k: v for k, v in d.items()} == d
+    assert {**d} == d
 
     assert 1 in d
     assert 1 in d.keys()

accesscontrol-7.6/src/AccessControl/tests/public_module/__init__.py

@@ -0,0 +1,11 @@
+# test module, public
+
+from Acquisition import aq_base  # Foil the old ZopeSecurityPolicy # NOQA: F401
+
+from AccessControl.SecurityInfo import allow_class  # NOQA: F401
+from AccessControl.SecurityInfo import allow_module  # NOQA: F401
+from AccessControl.SimpleObjectPolicies import allow_type  # NOQA: F401
+
+
+def pub():
+    pass