home *** CD-ROM | disk | FTP | other *** search
/ PC Extra 07 & 08 / pca1507.iso / Software / psp8 / Data1.cab / rexec.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2003-04-22  |  19.6 KB  |  466 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.2)
  3.  
  4. '''Restricted execution facilities.
  5.  
  6. The class RExec exports methods r_exec(), r_eval(), r_execfile(), and
  7. r_import(), which correspond roughly to the built-in operations
  8. exec, eval(), execfile() and import, but executing the code in an
  9. environment that only exposes those built-in operations that are
  10. deemed safe.  To this end, a modest collection of \'fake\' modules is
  11. created which mimics the standard modules by the same names.  It is a
  12. policy decision which built-in modules and operations are made
  13. available; this module provides a reasonable default, but derived
  14. classes can change the policies e.g. by overriding or extending class
  15. variables like ok_builtin_modules or methods like make_sys().
  16.  
  17. XXX To do:
  18. - r_open should allow writing tmp dir
  19. - r_exec etc. with explicit globals/locals? (Use rexec("exec ... in ...")?)
  20.  
  21. '''
  22. import sys
  23. import __builtin__
  24. import os
  25. import ihooks
  26. __all__ = [
  27.     'RExec']
  28.  
  29. class FileBase:
  30.     ok_file_methods = ('fileno', 'flush', 'isatty', 'read', 'readline', 'readlines', 'seek', 'tell', 'write', 'writelines')
  31.  
  32.  
  33. class FileWrapper(FileBase):
  34.     
  35.     def __init__(self, f):
  36.         self.f = f
  37.         for m in self.ok_file_methods:
  38.             if not hasattr(self, m) and hasattr(f, m):
  39.                 setattr(self, m, getattr(f, m))
  40.             
  41.         
  42.  
  43.     
  44.     def close(self):
  45.         self.flush()
  46.  
  47.  
  48. TEMPLATE = '\ndef %s(self, *args):\n        return apply(getattr(self.mod, self.name).%s, args)\n'
  49.  
  50. class FileDelegate(FileBase):
  51.     
  52.     def __init__(self, mod, name):
  53.         self.mod = mod
  54.         self.name = name
  55.  
  56.     for m in FileBase.ok_file_methods + ('close',):
  57.         exec TEMPLATE % (m, m)
  58.     
  59.  
  60.  
  61. class RHooks(ihooks.Hooks):
  62.     
  63.     def __init__(self, *args):
  64.         verbose = 0
  65.         rexec = None
  66.         if args and type(args[-1]) == type(0):
  67.             verbose = args[-1]
  68.             args = args[:-1]
  69.         
  70.         if args and hasattr(args[0], '__class__'):
  71.             rexec = args[0]
  72.             args = args[1:]
  73.         
  74.         if args:
  75.             raise TypeError, 'too many arguments'
  76.         
  77.         ihooks.Hooks.__init__(self, verbose)
  78.         self.rexec = rexec
  79.  
  80.     
  81.     def set_rexec(self, rexec):
  82.         self.rexec = rexec
  83.  
  84.     
  85.     def is_builtin(self, name):
  86.         return self.rexec.is_builtin(name)
  87.  
  88.     
  89.     def init_builtin(self, name):
  90.         m = __import__(name)
  91.         return self.rexec.copy_except(m, ())
  92.  
  93.     
  94.     def init_frozen(self, name):
  95.         raise SystemError, "don't use this"
  96.  
  97.     
  98.     def load_source(self, *args):
  99.         raise SystemError, "don't use this"
  100.  
  101.     
  102.     def load_compiled(self, *args):
  103.         raise SystemError, "don't use this"
  104.  
  105.     
  106.     def load_package(self, *args):
  107.         raise SystemError, "don't use this"
  108.  
  109.     
  110.     def load_dynamic(self, name, filename, file):
  111.         return self.rexec.load_dynamic(name, filename, file)
  112.  
  113.     
  114.     def add_module(self, name):
  115.         return self.rexec.add_module(name)
  116.  
  117.     
  118.     def modules_dict(self):
  119.         return self.rexec.modules
  120.  
  121.     
  122.     def default_path(self):
  123.         return self.rexec.modules['sys'].path
  124.  
  125.  
  126. RModuleLoader = ihooks.FancyModuleLoader
  127. RModuleImporter = ihooks.ModuleImporter
  128.  
  129. class RExec(ihooks._Verbose):
  130.     '''Restricted Execution environment.'''
  131.     ok_path = tuple(sys.path)
  132.     ok_builtin_modules = ('audioop', 'array', 'binascii', 'cmath', 'errno', 'imageop', 'marshal', 'math', 'md5', 'operator', 'parser', 'regex', 'pcre', 'rotor', 'select', 'sha', '_sre', 'strop', 'struct', 'time')
  133.     ok_posix_names = ('error', 'fstat', 'listdir', 'lstat', 'readlink', 'stat', 'times', 'uname', 'getpid', 'getppid', 'getcwd', 'getuid', 'getgid', 'geteuid', 'getegid')
  134.     ok_sys_names = ('ps1', 'ps2', 'copyright', 'version', 'platform', 'exit', 'maxint')
  135.     nok_builtin_names = ('open', 'file', 'reload', '__import__')
  136.     
  137.     def __init__(self, hooks = None, verbose = 0):
  138.         ihooks._Verbose.__init__(self, verbose)
  139.         if not hooks:
  140.             pass
  141.         self.hooks = RHooks(verbose)
  142.         self.hooks.set_rexec(self)
  143.         self.modules = { }
  144.         self.ok_dynamic_modules = self.ok_builtin_modules
  145.         list = []
  146.         for mname in self.ok_builtin_modules:
  147.             if mname in sys.builtin_module_names:
  148.                 list.append(mname)
  149.             
  150.         
  151.         self.ok_builtin_modules = tuple(list)
  152.         self.set_trusted_path()
  153.         self.make_builtin()
  154.         self.make_initial_modules()
  155.         self.make_sys()
  156.         self.loader = RModuleLoader(self.hooks, verbose)
  157.         self.importer = RModuleImporter(self.loader, verbose)
  158.  
  159.     
  160.     def set_trusted_path(self):
  161.         self.trusted_path = filter(os.path.isabs, sys.path)
  162.  
  163.     
  164.     def load_dynamic(self, name, filename, file):
  165.         if name not in self.ok_dynamic_modules:
  166.             raise ImportError, 'untrusted dynamic module: %s' % name
  167.         
  168.         if sys.modules.has_key(name):
  169.             src = sys.modules[name]
  170.         else:
  171.             import imp
  172.             src = imp.load_dynamic(name, filename, file)
  173.         dst = self.copy_except(src, [])
  174.         return dst
  175.  
  176.     
  177.     def make_initial_modules(self):
  178.         self.make_main()
  179.         self.make_osname()
  180.  
  181.     
  182.     def is_builtin(self, mname):
  183.         return mname in self.ok_builtin_modules
  184.  
  185.     
  186.     def make_builtin(self):
  187.         m = self.copy_except(__builtin__, self.nok_builtin_names)
  188.         m.__import__ = self.r_import
  189.         m.reload = self.r_reload
  190.         m.open = m.file = self.r_open
  191.  
  192.     
  193.     def make_main(self):
  194.         m = self.add_module('__main__')
  195.  
  196.     
  197.     def make_osname(self):
  198.         osname = os.name
  199.         src = __import__(osname)
  200.         dst = self.copy_only(src, self.ok_posix_names)
  201.         dst.environ = e = { }
  202.         for key, value in os.environ.items():
  203.             e[key] = value
  204.         
  205.  
  206.     
  207.     def make_sys(self):
  208.         m = self.copy_only(sys, self.ok_sys_names)
  209.         m.modules = self.modules
  210.         m.argv = [
  211.             'RESTRICTED']
  212.         m.path = map(None, self.ok_path)
  213.         m.exc_info = self.r_exc_info
  214.         m = self.modules['sys']
  215.         l = self.modules.keys() + list(self.ok_builtin_modules)
  216.         l.sort()
  217.         m.builtin_module_names = tuple(l)
  218.  
  219.     
  220.     def copy_except(self, src, exceptions):
  221.         dst = self.copy_none(src)
  222.         for name in dir(src):
  223.             setattr(dst, name, getattr(src, name))
  224.         
  225.         for name in exceptions:
  226.             
  227.             try:
  228.                 delattr(dst, name)
  229.             except AttributeError:
  230.                 pass
  231.  
  232.         
  233.         return dst
  234.  
  235.     
  236.     def copy_only(self, src, names):
  237.         dst = self.copy_none(src)
  238.         for name in names:
  239.             
  240.             try:
  241.                 value = getattr(src, name)
  242.             except AttributeError:
  243.                 continue
  244.  
  245.             setattr(dst, name, value)
  246.         
  247.         return dst
  248.  
  249.     
  250.     def copy_none(self, src):
  251.         m = self.add_module(src.__name__)
  252.         m.__doc__ = src.__doc__
  253.         return m
  254.  
  255.     
  256.     def add_module(self, mname):
  257.         if self.modules.has_key(mname):
  258.             return self.modules[mname]
  259.         
  260.         self.modules[mname] = m = self.hooks.new_module(mname)
  261.         m.__builtins__ = self.modules['__builtin__']
  262.         return m
  263.  
  264.     
  265.     def r_exec(self, code):
  266.         m = self.add_module('__main__')
  267.         exec code in m.__dict__
  268.  
  269.     
  270.     def r_eval(self, code):
  271.         m = self.add_module('__main__')
  272.         return eval(code, m.__dict__)
  273.  
  274.     
  275.     def r_execfile(self, file):
  276.         m = self.add_module('__main__')
  277.         execfile(file, m.__dict__)
  278.  
  279.     
  280.     def r_import(self, mname, globals = { }, locals = { }, fromlist = []):
  281.         return self.importer.import_module(mname, globals, locals, fromlist)
  282.  
  283.     
  284.     def r_reload(self, m):
  285.         return self.importer.reload(m)
  286.  
  287.     
  288.     def r_unload(self, m):
  289.         return self.importer.unload(m)
  290.  
  291.     
  292.     def make_delegate_files(self):
  293.         s = self.modules['sys']
  294.         self.delegate_stdin = FileDelegate(s, 'stdin')
  295.         self.delegate_stdout = FileDelegate(s, 'stdout')
  296.         self.delegate_stderr = FileDelegate(s, 'stderr')
  297.         self.restricted_stdin = FileWrapper(sys.stdin)
  298.         self.restricted_stdout = FileWrapper(sys.stdout)
  299.         self.restricted_stderr = FileWrapper(sys.stderr)
  300.  
  301.     
  302.     def set_files(self):
  303.         if not hasattr(self, 'save_stdin'):
  304.             self.save_files()
  305.         
  306.         if not hasattr(self, 'delegate_stdin'):
  307.             self.make_delegate_files()
  308.         
  309.         s = self.modules['sys']
  310.         s.stdin = self.restricted_stdin
  311.         s.stdout = self.restricted_stdout
  312.         s.stderr = self.restricted_stderr
  313.         sys.stdin = self.delegate_stdin
  314.         sys.stdout = self.delegate_stdout
  315.         sys.stderr = self.delegate_stderr
  316.  
  317.     
  318.     def reset_files(self):
  319.         self.restore_files()
  320.         s = self.modules['sys']
  321.         self.restricted_stdin = s.stdin
  322.         self.restricted_stdout = s.stdout
  323.         self.restricted_stderr = s.stderr
  324.  
  325.     
  326.     def save_files(self):
  327.         self.save_stdin = sys.stdin
  328.         self.save_stdout = sys.stdout
  329.         self.save_stderr = sys.stderr
  330.  
  331.     
  332.     def restore_files(self):
  333.         sys.stdin = self.save_stdin
  334.         sys.stdout = self.save_stdout
  335.         sys.stderr = self.save_stderr
  336.  
  337.     
  338.     def s_apply(self, func, args = (), kw = None):
  339.         self.save_files()
  340.         
  341.         try:
  342.             self.set_files()
  343.             if kw:
  344.                 r = apply(func, args, kw)
  345.             else:
  346.                 r = apply(func, args)
  347.         finally:
  348.             self.restore_files()
  349.  
  350.         return r
  351.  
  352.     
  353.     def s_exec(self, *args):
  354.         return self.s_apply(self.r_exec, args)
  355.  
  356.     
  357.     def s_eval(self, *args):
  358.         return self.s_apply(self.r_eval, args)
  359.  
  360.     
  361.     def s_execfile(self, *args):
  362.         return self.s_apply(self.r_execfile, args)
  363.  
  364.     
  365.     def s_import(self, *args):
  366.         return self.s_apply(self.r_import, args)
  367.  
  368.     
  369.     def s_reload(self, *args):
  370.         return self.s_apply(self.r_reload, args)
  371.  
  372.     
  373.     def s_unload(self, *args):
  374.         return self.s_apply(self.r_unload, args)
  375.  
  376.     
  377.     def r_open(self, file, mode = 'r', buf = -1):
  378.         if mode not in ('r', 'rb'):
  379.             raise IOError, "can't open files for writing in restricted mode"
  380.         
  381.         return open(file, mode, buf)
  382.  
  383.     
  384.     def r_exc_info(self):
  385.         (ty, va, tr) = sys.exc_info()
  386.         tr = None
  387.         return (ty, va, tr)
  388.  
  389.  
  390.  
  391. def test():
  392.     import getopt
  393.     import traceback
  394.     (opts, args) = getopt.getopt(sys.argv[1:], 'vt:')
  395.     verbose = 0
  396.     trusted = []
  397.     for o, a in opts:
  398.         if o == '-v':
  399.             verbose = verbose + 1
  400.         
  401.         if o == '-t':
  402.             trusted.append(a)
  403.         
  404.     
  405.     r = RExec(verbose = verbose)
  406.     if trusted:
  407.         r.ok_builtin_modules = r.ok_builtin_modules + tuple(trusted)
  408.     
  409.     if args:
  410.         r.modules['sys'].argv = args
  411.         r.modules['sys'].path.insert(0, os.path.dirname(args[0]))
  412.     else:
  413.         r.modules['sys'].path.insert(0, '')
  414.     fp = sys.stdin
  415.     if args and args[0] != '-':
  416.         
  417.         try:
  418.             fp = open(args[0])
  419.         except IOError:
  420.             msg = None
  421.             print "%s: can't open file %s" % (sys.argv[0], `args[0]`)
  422.             return 1
  423.  
  424.     
  425.     if fp.isatty():
  426.         print '*** RESTRICTED *** Python', sys.version
  427.         print 'Type "help", "copyright", "credits" or "license" for more information.'
  428.         while 1:
  429.             
  430.             try:
  431.                 
  432.                 try:
  433.                     s = raw_input('>>> ')
  434.                 except EOFError:
  435.                     print 
  436.                     break
  437.  
  438.                 if s and s[0] != '#':
  439.                     s = s + '\n'
  440.                     c = compile(s, '<stdin>', 'single')
  441.                     r.s_exec(c)
  442.             except SystemExit:
  443.                 n = None
  444.                 return n
  445.             except:
  446.                 traceback.print_exc()
  447.  
  448.     else:
  449.         text = fp.read()
  450.         fp.close()
  451.         c = compile(text, fp.name, 'exec')
  452.         
  453.         try:
  454.             r.s_exec(c)
  455.         except SystemExit:
  456.             n = None
  457.             return n
  458.         except:
  459.             traceback.print_exc()
  460.             return 1
  461.  
  462.  
  463. if __name__ == '__main__':
  464.     sys.exit(test())
  465.  
  466.