[Zope3-checkins] SVN: Zope3/trunk/src/zope/app/ Modified decorator security checker to work with security proxied objects. This allows LocationProxies to wrap security proxied objects and behave themselves wrt Zope security. See doctest for examples.

Garrett Smith garrett at mojave-corp.com
Thu Mar 10 23:45:45 EST 2005


Log message for revision 29438:
  Modified decorator security checker to work with security proxied objects. This allows LocationProxies to wrap security proxied objects and behave themselves wrt Zope security. See doctest for examples.

Changed:
  U   Zope3/trunk/src/zope/app/decorator.py
  U   Zope3/trunk/src/zope/app/tests/test_decorator.py

-=-
Modified: Zope3/trunk/src/zope/app/decorator.py
===================================================================
--- Zope3/trunk/src/zope/app/decorator.py	2005-03-11 04:40:45 UTC (rev 29437)
+++ Zope3/trunk/src/zope/app/decorator.py	2005-03-11 04:45:45 UTC (rev 29438)
@@ -20,6 +20,7 @@
 """
 from zope.proxy import getProxiedObject, ProxyBase
 from zope.security.checker import selectChecker, CombinedChecker
+from zope.security.proxy import Proxy, getChecker
 from zope.interface.declarations import ObjectSpecificationDescriptor
 from zope.interface.declarations import getObjectSpecification
 from zope.interface.declarations import ObjectSpecification
@@ -74,21 +75,156 @@
 
             # Use type rather than __class__ because inst is a proxy and
             # will return the proxied object's class.
-            cls = type(inst) 
+            cls = type(inst)
             return ObjectSpecification(provided, cls)
 
 
 class DecoratedSecurityCheckerDescriptor(object):
     """Descriptor for a Decorator that provides a decorated security checker.
+
+    To illustrate, we'll create a class that will be proxied:
+
+      >>> class Foo(object):
+      ...     a = 'a'
+
+    and a class to proxy it that uses a decorated security checker:
+
+      >>> class Wrapper(ProxyBase):
+      ...     b = 'b'
+      ...     __Security_checker__ = DecoratedSecurityCheckerDescriptor()
+
+    Next we'll create and register a checker for Foo:
+
+      >>> from zope.security.checker import NamesChecker, defineChecker
+      >>> fooChecker = NamesChecker(['a'])
+      >>> defineChecker(Foo, fooChecker)
+
+    along with a checker for Wrapper:
+
+      >>> wrapperChecker = NamesChecker(['b'])
+      >>> defineChecker(Wrapper, wrapperChecker)
+
+    Using selectChecker, we can confirm that a Foo object uses fooChecker:
+
+      >>> foo = Foo()
+      >>> selectChecker(foo) is fooChecker
+      True
+      >>> fooChecker.check(foo, 'a')
+      >>> fooChecker.check(foo, 'b')  # doctest: +ELLIPSIS
+      Traceback (most recent call last):
+      ForbiddenAttribute: ('b', <zope.app.decorator.Foo object ...>)
+
+    and that a Wrapper object uses wrappeChecker:
+
+      >>> wrapper = Wrapper(foo)
+      >>> selectChecker(wrapper) is wrapperChecker
+      True
+      >>> wrapperChecker.check(wrapper, 'b')
+      >>> wrapperChecker.check(wrapper, 'a')  # doctest: +ELLIPSIS
+      Traceback (most recent call last):
+      ForbiddenAttribute: ('a', <zope.app.decorator.Foo object ...>)
+
+    (Note that the object description says 'Foo' because the object is a
+    proxy and generally looks and acts like the object it's proxying.)
+
+    When we access wrapper's __Security_checker__ attribute, we invoke
+    the decorated security checker descriptor. The decorator's job is to make
+    sure checkers from both objects are used when available. In this case,
+    because both objects have checkers, we get a combined checker:
+
+      >>> checker = wrapper.__Security_checker__
+      >>> type(checker)
+      <class 'zope.security.checker.CombinedChecker'>
+      >>> checker.check(wrapper, 'a')
+      >>> checker.check(wrapper, 'b')
+
+    The decorator checker will work even with security proxied objects. To
+    illustrate, we'll proxify foo:
+
+      >>> from zope.security.proxy import ProxyFactory
+      >>> secure_foo = ProxyFactory(foo)
+      >>> secure_foo.a
+      'a'
+      >>> secure_foo.b  # doctest: +ELLIPSIS
+      Traceback (most recent call last):
+      ForbiddenAttribute: ('b', <zope.app.decorator.Foo object ...>)
+
+    when we wrap the secured foo:
+
+      >>> wrapper = Wrapper(secure_foo)
+
+    we still get a combined checker:
+
+      >>> checker = wrapper.__Security_checker__
+      >>> type(checker)
+      <class 'zope.security.checker.CombinedChecker'>
+      >>> checker.check(wrapper, 'a')
+      >>> checker.check(wrapper, 'b')
+
+    The decorator checker has three other scenarios:
+
+      - the wrapper has a checker but the proxied object doesn't
+      - the proxied object has a checker but the wrapper doesn't
+      - neither the wrapper nor the proxied object have checkers
+
+    When the wrapper has a checker but the proxied object doesn't:
+
+      >>> from zope.security.checker import NoProxy, _checkers
+      >>> del _checkers[Foo]
+      >>> defineChecker(Foo, NoProxy)
+      >>> selectChecker(foo) is None
+      True
+      >>> selectChecker(wrapper) is wrapperChecker
+      True
+
+    the decorator uses only the wrapper checker:
+
+      >>> wrapper = Wrapper(foo)
+      >>> wrapper.__Security_checker__ is wrapperChecker
+      True
+
+    When the proxied object has a checker but the wrapper doesn't:
+
+      >>> del _checkers[Wrapper]
+      >>> defineChecker(Wrapper, NoProxy)
+      >>> selectChecker(wrapper) is None
+      True
+      >>> del _checkers[Foo]
+      >>> defineChecker(Foo, fooChecker)
+      >>> selectChecker(foo) is fooChecker
+      True
+
+    the decorator uses only the proxied object checker:
+
+      >>> wrapper.__Security_checker__ is fooChecker
+      True
+
+    Finally, if neither the wrapper not the proxied have checkers:
+
+      >>> del _checkers[Foo]
+      >>> defineChecker(Foo, NoProxy)
+      >>> selectChecker(foo) is None
+      True
+      >>> selectChecker(wrapper) is None
+      True
+
+    the decorator doesn't have a checker:
+
+      >>> wrapper.__Security_checker__ is None
+      True
+
     """
     def __get__(self, inst, cls=None):
         if inst is None:
             return self
         else:
             proxied_object = getProxiedObject(inst)
-            checker = getattr(proxied_object, '__Security_checker__', None)
-            if checker is None:
-                checker = selectChecker(proxied_object)
+            if type(proxied_object) is Proxy:
+                checker = getChecker(proxied_object)
+            else:
+                checker = getattr(proxied_object, '__Security_checker__', None)
+                if checker is None:
+                    checker = selectChecker(proxied_object)
             wrapper_checker = selectChecker(inst)
             if wrapper_checker is None:
                 return checker
@@ -101,7 +237,7 @@
 class Decorator(ProxyBase):
     """Decorator base class
     """
-    
+
     __providedBy__ = DecoratorSpecificationDescriptor()
     __Security_checker__ = DecoratedSecurityCheckerDescriptor()
 

Modified: Zope3/trunk/src/zope/app/tests/test_decorator.py
===================================================================
--- Zope3/trunk/src/zope/app/tests/test_decorator.py	2005-03-11 04:40:45 UTC (rev 29437)
+++ Zope3/trunk/src/zope/app/tests/test_decorator.py	2005-03-11 04:45:45 UTC (rev 29438)
@@ -83,64 +83,6 @@
     ['I4', 'I3', 'I1', 'I2']
     """
 
-
-class Thing(object):
-    pass
-
-def test_SecurityCheckerDescriptor():
-    """Descriptor for a Decorator that provides a decorated security checker.
-
-    >>> from zope.security.checker import defineChecker, NamesChecker, NoProxy
-    >>> from zope.app.decorator import DecoratedSecurityCheckerDescriptor
-    >>> class MyDecorator(Decorator):
-    ...     __Security_checker__ = DecoratedSecurityCheckerDescriptor()
-
-    >>> class Foo(object):
-    ...     a = 1
-    ...     b = 2
-    ...     c = 3
-
-    >>> defineChecker(Foo, NamesChecker(['a']))
-    >>> defineChecker(MyDecorator, NoProxy)
-
-    >>> w = MyDecorator(Foo())
-    >>> from zope.security.checker import selectChecker
-    >>> print selectChecker(w)
-    None
-    >>> c = w.__Security_checker__
-    >>> c.__class__.__module__, c.__class__.__name__
-    ('zope.security.checker', 'Checker')
-    >>> c.check_getattr(w, 'a')
-
-    >>> check_forbidden_call(c.check_getattr, w, 'b')
-    'ForbiddenAttribute: b'
-    >>> check_forbidden_call(c.check_getattr, w, 'c')
-    'ForbiddenAttribute: c'
-
-    >>> class MyDecorator2(Decorator):
-    ...     __Security_checker__ = DecoratedSecurityCheckerDescriptor()
-    >>> defineChecker(MyDecorator2, NamesChecker(['b']))
-    >>> w = MyDecorator2(Foo())
-    >>> c = w.__Security_checker__
-    >>> print type(c)
-    <class 'zope.security.checker.CombinedChecker'>
-    >>> c.check_getattr(w, 'a')
-
-    >>> c.check_getattr(w, 'b')
-
-    >>> check_forbidden_call(c.check_getattr, w, 'c')
-    'ForbiddenAttribute: c'
-
-    >>> w = MyDecorator(None)
-    >>> int(w.__Security_checker__ is None)
-    1
-    >>> w = MyDecorator2(None)
-    >>> c = w.__Security_checker__
-    >>> c.__class__.__module__, c.__class__.__name__
-    ('zope.security.checker', 'Checker')
-    """
-
-
 def test_suite():
     suite = DocTestSuite()
     suite.addTest(DocTestSuite('zope.app.decorator'))



More information about the Zope3-Checkins mailing list