class FileBase:
- ok_file_methods = ('fileno', 'flush', 'isatty', 'read', 'readline',
- 'readlines', 'seek', 'tell', 'write', 'writelines')
+ ok_file_methods = ('fileno', 'flush', 'isatty', 'read', 'readline',
+ 'readlines', 'seek', 'tell', 'write', 'writelines')
class FileWrapper(FileBase):
- # XXX This is just like a Bastion -- should use that!
+ # XXX This is just like a Bastion -- should use that!
- def __init__(self, f):
- self.f = f
- for m in self.ok_file_methods:
- if not hasattr(self, m) and hasattr(f, m):
- setattr(self, m, getattr(f, m))
-
- def close(self):
- self.flush()
+ def __init__(self, f):
+ self.f = f
+ for m in self.ok_file_methods:
+ if not hasattr(self, m) and hasattr(f, m):
+ setattr(self, m, getattr(f, m))
+
+ def close(self):
+ self.flush()
TEMPLATE = """
def %s(self, *args):
- return apply(getattr(self.mod, self.name).%s, args)
+ return apply(getattr(self.mod, self.name).%s, args)
"""
class FileDelegate(FileBase):
- def __init__(self, mod, name):
- self.mod = mod
- self.name = name
-
- for m in FileBase.ok_file_methods + ('close',):
- exec TEMPLATE % (m, m)
+ def __init__(self, mod, name):
+ self.mod = mod
+ self.name = name
+
+ for m in FileBase.ok_file_methods + ('close',):
+ exec TEMPLATE % (m, m)
class RHooks(ihooks.Hooks):
def __init__(self, *args):
- # Hacks to support both old and new interfaces:
- # old interface was RHooks(rexec[, verbose])
- # new interface is RHooks([verbose])
- verbose = 0
- rexec = None
- if args and type(args[-1]) == type(0):
- verbose = args[-1]
- args = args[:-1]
- if args and hasattr(args[0], '__class__'):
- rexec = args[0]
- args = args[1:]
- if args:
- raise TypeError, "too many arguments"
- ihooks.Hooks.__init__(self, verbose)
- self.rexec = rexec
+ # Hacks to support both old and new interfaces:
+ # old interface was RHooks(rexec[, verbose])
+ # new interface is RHooks([verbose])
+ verbose = 0
+ rexec = None
+ if args and type(args[-1]) == type(0):
+ verbose = args[-1]
+ args = args[:-1]
+ if args and hasattr(args[0], '__class__'):
+ rexec = args[0]
+ args = args[1:]
+ if args:
+ raise TypeError, "too many arguments"
+ ihooks.Hooks.__init__(self, verbose)
+ self.rexec = rexec
def set_rexec(self, rexec):
- # Called by RExec instance to complete initialization
- self.rexec = rexec
+ # Called by RExec instance to complete initialization
+ self.rexec = rexec
def is_builtin(self, name):
- return self.rexec.is_builtin(name)
+ return self.rexec.is_builtin(name)
def init_builtin(self, name):
- m = __import__(name)
- return self.rexec.copy_except(m, ())
+ m = __import__(name)
+ return self.rexec.copy_except(m, ())
def init_frozen(self, name): raise SystemError, "don't use this"
def load_source(self, *args): raise SystemError, "don't use this"
def load_compiled(self, *args): raise SystemError, "don't use this"
def load_dynamic(self, name, filename, file):
- return self.rexec.load_dynamic(name, filename, file)
+ return self.rexec.load_dynamic(name, filename, file)
def add_module(self, name):
- return self.rexec.add_module(name)
+ return self.rexec.add_module(name)
def modules_dict(self):
- return self.rexec.modules
+ return self.rexec.modules
def default_path(self):
- return self.rexec.modules['sys'].path
+ return self.rexec.modules['sys'].path
class RModuleLoader(ihooks.FancyModuleLoader):
def reload(self, module, path=None):
if path is None and hasattr(module, '__filename__'):
- head, tail = os.path.split(module.__filename__)
- path = [os.path.join(head, '')]
+ head, tail = os.path.split(module.__filename__)
+ path = [os.path.join(head, '')]
return ihooks.ModuleImporter.reload(self, module, path)
"""Restricted Execution environment."""
- ok_path = tuple(sys.path) # That's a policy decision
+ ok_path = tuple(sys.path) # That's a policy decision
ok_builtin_modules = ('audioop', 'array', 'binascii',
- 'cmath', 'errno', 'imageop',
- 'marshal', 'math', 'md5', 'operator',
- 'parser', 'regex', 'pcre', 'rotor', 'select',
- 'strop', 'struct', 'time')
+ 'cmath', 'errno', 'imageop',
+ 'marshal', 'math', 'md5', 'operator',
+ 'parser', 'regex', 'pcre', 'rotor', 'select',
+ 'strop', 'struct', 'time')
ok_posix_names = ('error', 'fstat', 'listdir', 'lstat', 'readlink',
- 'stat', 'times', 'uname', 'getpid', 'getppid',
- 'getcwd', 'getuid', 'getgid', 'geteuid', 'getegid')
+ 'stat', 'times', 'uname', 'getpid', 'getppid',
+ 'getcwd', 'getuid', 'getgid', 'geteuid', 'getegid')
ok_sys_names = ('ps1', 'ps2', 'copyright', 'version',
- 'platform', 'exit', 'maxint')
+ 'platform', 'exit', 'maxint')
nok_builtin_names = ('open', 'reload', '__import__')
def __init__(self, hooks = None, verbose = 0):
- ihooks._Verbose.__init__(self, verbose)
- # XXX There's a circular reference here:
- self.hooks = hooks or RHooks(verbose)
- self.hooks.set_rexec(self)
- self.modules = {}
- self.ok_dynamic_modules = self.ok_builtin_modules
- list = []
- for mname in self.ok_builtin_modules:
- if mname in sys.builtin_module_names:
- list.append(mname)
- self.ok_builtin_modules = tuple(list)
- self.set_trusted_path()
- self.make_builtin()
- self.make_initial_modules()
- # make_sys must be last because it adds the already created
- # modules to its builtin_module_names
- self.make_sys()
- self.loader = RModuleLoader(self.hooks, verbose)
- self.importer = RModuleImporter(self.loader, verbose)
+ ihooks._Verbose.__init__(self, verbose)
+ # XXX There's a circular reference here:
+ self.hooks = hooks or RHooks(verbose)
+ self.hooks.set_rexec(self)
+ self.modules = {}
+ self.ok_dynamic_modules = self.ok_builtin_modules
+ list = []
+ for mname in self.ok_builtin_modules:
+ if mname in sys.builtin_module_names:
+ list.append(mname)
+ self.ok_builtin_modules = tuple(list)
+ self.set_trusted_path()
+ self.make_builtin()
+ self.make_initial_modules()
+ # make_sys must be last because it adds the already created
+ # modules to its builtin_module_names
+ self.make_sys()
+ self.loader = RModuleLoader(self.hooks, verbose)
+ self.importer = RModuleImporter(self.loader, verbose)
def set_trusted_path(self):
- # Set the path from which dynamic modules may be loaded.
- # Those dynamic modules must also occur in ok_builtin_modules
- self.trusted_path = filter(os.path.isabs, sys.path)
+ # Set the path from which dynamic modules may be loaded.
+ # Those dynamic modules must also occur in ok_builtin_modules
+ self.trusted_path = filter(os.path.isabs, sys.path)
def load_dynamic(self, name, filename, file):
- if name not in self.ok_dynamic_modules:
- raise ImportError, "untrusted dynamic module: %s" % name
- if sys.modules.has_key(name):
- src = sys.modules[name]
- else:
- import imp
- src = imp.load_dynamic(name, filename, file)
- dst = self.copy_except(src, [])
- return dst
+ if name not in self.ok_dynamic_modules:
+ raise ImportError, "untrusted dynamic module: %s" % name
+ if sys.modules.has_key(name):
+ src = sys.modules[name]
+ else:
+ import imp
+ src = imp.load_dynamic(name, filename, file)
+ dst = self.copy_except(src, [])
+ return dst
def make_initial_modules(self):
- self.make_main()
- self.make_osname()
+ self.make_main()
+ self.make_osname()
# Helpers for RHooks
def is_builtin(self, mname):
- return mname in self.ok_builtin_modules
+ return mname in self.ok_builtin_modules
# The make_* methods create specific built-in modules
def make_builtin(self):
- m = self.copy_except(__builtin__, self.nok_builtin_names)
- m.__import__ = self.r_import
- m.reload = self.r_reload
- m.open = self.r_open
+ m = self.copy_except(__builtin__, self.nok_builtin_names)
+ m.__import__ = self.r_import
+ m.reload = self.r_reload
+ m.open = self.r_open
def make_main(self):
- m = self.add_module('__main__')
+ m = self.add_module('__main__')
def make_osname(self):
- osname = os.name
- src = __import__(osname)
- dst = self.copy_only(src, self.ok_posix_names)
- dst.environ = e = {}
- for key, value in os.environ.items():
- e[key] = value
+ osname = os.name
+ src = __import__(osname)
+ dst = self.copy_only(src, self.ok_posix_names)
+ dst.environ = e = {}
+ for key, value in os.environ.items():
+ e[key] = value
def make_sys(self):
- m = self.copy_only(sys, self.ok_sys_names)
- m.modules = self.modules
- m.argv = ['RESTRICTED']
- m.path = map(None, self.ok_path)
- m = self.modules['sys']
- l = self.modules.keys() + list(self.ok_builtin_modules)
- l.sort()
- m.builtin_module_names = tuple(l)
+ m = self.copy_only(sys, self.ok_sys_names)
+ m.modules = self.modules
+ m.argv = ['RESTRICTED']
+ m.path = map(None, self.ok_path)
+ m = self.modules['sys']
+ l = self.modules.keys() + list(self.ok_builtin_modules)
+ l.sort()
+ m.builtin_module_names = tuple(l)
# The copy_* methods copy existing modules with some changes
def copy_except(self, src, exceptions):
- dst = self.copy_none(src)
- for name in dir(src):
- setattr(dst, name, getattr(src, name))
- for name in exceptions:
- try:
- delattr(dst, name)
- except AttributeError:
- pass
- return dst
+ dst = self.copy_none(src)
+ for name in dir(src):
+ setattr(dst, name, getattr(src, name))
+ for name in exceptions:
+ try:
+ delattr(dst, name)
+ except AttributeError:
+ pass
+ return dst
def copy_only(self, src, names):
- dst = self.copy_none(src)
- for name in names:
- try:
- value = getattr(src, name)
- except AttributeError:
- continue
- setattr(dst, name, value)
- return dst
+ dst = self.copy_none(src)
+ for name in names:
+ try:
+ value = getattr(src, name)
+ except AttributeError:
+ continue
+ setattr(dst, name, value)
+ return dst
def copy_none(self, src):
- return self.add_module(src.__name__)
+ return self.add_module(src.__name__)
# Add a module -- return an existing module or create one
def add_module(self, mname):
- if self.modules.has_key(mname):
- return self.modules[mname]
- self.modules[mname] = m = self.hooks.new_module(mname)
- m.__builtins__ = self.modules['__builtin__']
- return m
+ if self.modules.has_key(mname):
+ return self.modules[mname]
+ self.modules[mname] = m = self.hooks.new_module(mname)
+ m.__builtins__ = self.modules['__builtin__']
+ return m
# The r* methods are public interfaces
def r_exec(self, code):
- m = self.add_module('__main__')
- exec code in m.__dict__
+ m = self.add_module('__main__')
+ exec code in m.__dict__
def r_eval(self, code):
- m = self.add_module('__main__')
- return eval(code, m.__dict__)
+ m = self.add_module('__main__')
+ return eval(code, m.__dict__)
def r_execfile(self, file):
- m = self.add_module('__main__')
- return execfile(file, m.__dict__)
+ m = self.add_module('__main__')
+ return execfile(file, m.__dict__)
def r_import(self, mname, globals={}, locals={}, fromlist=[]):
- return self.importer.import_module(mname, globals, locals, fromlist)
+ return self.importer.import_module(mname, globals, locals, fromlist)
def r_reload(self, m):
return self.importer.reload(m)
def make_delegate_files(self):
s = self.modules['sys']
- self.delegate_stdin = FileDelegate(s, 'stdin')
- self.delegate_stdout = FileDelegate(s, 'stdout')
- self.delegate_stderr = FileDelegate(s, 'stderr')
+ self.delegate_stdin = FileDelegate(s, 'stdin')
+ self.delegate_stdout = FileDelegate(s, 'stdout')
+ self.delegate_stderr = FileDelegate(s, 'stderr')
self.restricted_stdin = FileWrapper(sys.stdin)
self.restricted_stdout = FileWrapper(sys.stdout)
self.restricted_stderr = FileWrapper(sys.stderr)
def set_files(self):
- if not hasattr(self, 'save_stdin'):
- self.save_files()
- if not hasattr(self, 'delegate_stdin'):
- self.make_delegate_files()
+ if not hasattr(self, 'save_stdin'):
+ self.save_files()
+ if not hasattr(self, 'delegate_stdin'):
+ self.make_delegate_files()
s = self.modules['sys']
- s.stdin = self.restricted_stdin
- s.stdout = self.restricted_stdout
- s.stderr = self.restricted_stderr
- sys.stdin = self.delegate_stdin
- sys.stdout = self.delegate_stdout
- sys.stderr = self.delegate_stderr
+ s.stdin = self.restricted_stdin
+ s.stdout = self.restricted_stdout
+ s.stderr = self.restricted_stderr
+ sys.stdin = self.delegate_stdin
+ sys.stdout = self.delegate_stdout
+ sys.stderr = self.delegate_stderr
def reset_files(self):
- self.restore_files()
+ self.restore_files()
s = self.modules['sys']
- self.restricted_stdin = s.stdin
- self.restricted_stdout = s.stdout
- self.restricted_stderr = s.stderr
-
+ self.restricted_stdin = s.stdin
+ self.restricted_stdout = s.stdout
+ self.restricted_stderr = s.stderr
+
def save_files(self):
self.save_stdin = sys.stdin
self.save_stderr = sys.stderr
def restore_files(self):
- sys.stdin = self.save_stdin
- sys.stdout = self.save_stdout
- sys.stderr = self.save_stderr
+ sys.stdin = self.save_stdin
+ sys.stdout = self.save_stdout
+ sys.stderr = self.save_stderr
def s_apply(self, func, args=(), kw=None):
- self.save_files()
- try:
- self.set_files()
- if kw:
- r = apply(func, args, kw)
- else:
- r = apply(func, args)
+ self.save_files()
+ try:
+ self.set_files()
+ if kw:
+ r = apply(func, args, kw)
+ else:
+ r = apply(func, args)
finally:
- self.restore_files()
+ self.restore_files()
def s_exec(self, *args):
self.s_apply(self.r_exec, args)
print "*** RESTRICTED *** Python", sys.version
print sys.copyright
while 1:
- try:
- try:
- s = raw_input('>>> ')
- except EOFError:
- print
- break
- if s and s[0] != '#':
- s = s + '\n'
- c = compile(s, '<stdin>', 'single')
- r.r_exec(c)
- except SystemExit, n:
- sys.exit(n)
- except:
- traceback.print_exc()
+ try:
+ try:
+ s = raw_input('>>> ')
+ except EOFError:
+ print
+ break
+ if s and s[0] != '#':
+ s = s + '\n'
+ c = compile(s, '<stdin>', 'single')
+ r.r_exec(c)
+ except SystemExit, n:
+ sys.exit(n)
+ except:
+ traceback.print_exc()
if __name__ == '__main__':
projects / python / commitdiff