Built-in security subsystem

[mwr]

@petersuter

To build a secure sandbox, the whole Python process must be put in an external sandbox” with other core developers.

But it was since then that the event audit system appeared.
As for Victor’s arguments, could you put them together in a structured list like mine so that we can discuss them on the merits?
I have identified the following for myself:

possible to modify builtins using

It seemed to me that this was the main reasoned remark there.
But it’s strange to hear about such a problem, if in the future it’s possible to create readonly modules then it’s solved simply
globals()[__builtins __] = ModuleProxy(__builtins __)
Or let other ways to access builtins be listed.

the access to the type.bases attribute was also blocked

It is unclear what problems this is fraught with, if it’s impossible to replace any other important modular functions and classes.
But even if suddenly something deeper is hidden behind this, again, can implement the creation of proxy objects with read-only access.

First, the compile() builtin function was used to read line by line of an arbitrary file on the disk using a syntax error: the line is displayed in the traceback.

It’s not a problem at all. It’s just implemented in the event audit.

Second, a context manager was used to retrieve a traceback object: from traceback.tb_frame, it was possible to navigate in the frames (using frame.f_back) to retrieve a frame of the trusted namespace, and then use f_globals attribute of the frame to retrieve a global name.

There is a separate item about frames in my original message.

The problem is that after each release it becomes harder to write Python code in the sandbox. For example it becomes very hard to give access to objects from the trusted namespace to the untrusted namespace, because the whole object must be serialized to be passed to the child process. It becomes also harder to debug bugs in the sandboxeded code because the traceback feature doesn’t work well in the sandbox.

This looks very vague. Specific code examples are needed. For some reason, none of this interfered with the implementation of event auditing.