Slic3r::PluginAuditDetail Namespace Reference

Functions
PyObject *	tuple_item (PyObject *args, Py_ssize_t index)
std::string	python_unicode (PyObject *object)
bool	python_text (PyObject *object, std::string &out)
std::string	python_path (PyObject *object)
std::string	python_str (PyObject *object)
void	collect_stdlib_dirs ()
bool	is_stdlib_frame (PyObject *frame)
std::vector< PyObject * >	stack_frames ()
void	take_returned_frames (std::vector< PyObject * > &held, std::vector< PyObject * > &dropped)
AuditEventCategory	open_category (PyObject *args)
std::vector< std::string >	audit_targets (const std::string &event_name, AuditEventCategory category, PyObject *args)
std::vector< std::string > *	permission_list_for (AuditEventCategory category, bool by_event, PluginPermissions &permissions)
std::string	event_grant_key (AuditEventCategory category, const std::string &event_name)
bool	tree_grant_root (const std::string &grant, boost::filesystem::path &root)
std::string	absolute_tree_grant (const std::string &grant)
bool	fs_grant_covers (const std::string &grant, const std::string &target)
bool	has_permission (AuditEventCategory category, bool by_event, const std::vector< std::string > &granted, const std::string &target)
bool	has_network_permission (const PluginPermissions &permissions, const std::string &target)
bool	has_any_network_permission (const PluginPermissions &permissions)
void	seed_install_metadata (const PluginDescriptor &descriptor, PluginInstallState &state)
bool	persist_permission (const std::string &plugin_key, PluginInstallState &state, AuditEventCategory category, bool by_event, std::vector< std::string > &permission_list, const std::string &target)
int	report_denied (PluginAuditManager &mgr, const std::string &event_name, const AuditDecision &decision, const std::string &target={})
wxString	audit_message (AuditEventCategory category, const wxString &plugin_name, const wxString &event_name, const wxString &target_list, size_t target_count)
bool	prompt_for_targets (AuditEventCategory category, const std::string &plugin_name, const std::string &event_name, const std::vector< std::string > &unresolved)
bool	prompt_for_permission_message (const wxString &message)
void	persist_grant (const std::string &plugin_key, AuditEventCategory category, bool by_event, const std::vector< std::string > &keys)
static const char *	audit_category_name (AuditEventCategory category)
bool	request_permission (AuditEventCategory category, const std::string &plugin_key, const std::string &plugin_name, const std::string &event_name, bool by_event, const std::vector< std::string > &keys)
int	decide_audited_event (PluginAuditManager &mgr, PluginInstallState &state, const std::string &plugin_key, const std::string &plugin_name, const std::string &event_name, AuditEventCategory category, const std::vector< std::string > &targets)
int	audit_plugin_event (PluginAuditManager &mgr, const std::string &event_name, AuditEventCategory event_type, PyObject *args)

Variables
static std::vector< boost::filesystem::path >	s_stdlib_dirs
static std::vector< boost::filesystem::path >	s_site_package_dirs
static std::unordered_map< std::string, bool >	s_stdlib_file_verdicts
static const std::unordered_set< std::string >	two_path_fs_events
static const std::unordered_map< std::string, std::vector< Py_ssize_t > >	audit_target_arg_indices
static PluginAuditManager::PermissionPrompt	s_permission_prompt_for_testing
static PluginAuditManager::PermissionMessagePrompt	s_permission_message_prompt_for_testing

Function Documentation

absolute_tree_grant()

std::string Slic3r::PluginAuditDetail::absolute_tree_grant

(

const std::string &

grant

)

{
    boost::filesystem::path root;
    if (!tree_grant_root(grant, root) || root.is_absolute())
        return grant;
 
    boost::system::error_code ec;
    const boost::filesystem::path absolute_root = boost::filesystem::absolute(root, ec);
    if (ec || !absolute_root.is_absolute())
        return grant;
 
    return (absolute_root.lexically_normal() / "*").string();
}

References tree_grant_root().

Referenced by Slic3r::PluginAuditManager::request_permissions().

Here is the call graph for this function:

Here is the caller graph for this function:

audit_category_name()

const char * Slic3r::PluginAuditDetail::audit_category_name ( AuditEventCategory category )

static

{
    switch (category) {
    case AuditEventCategory::FsRead: return "FsRead";
    case AuditEventCategory::FsReadWrite: return "FsReadWrite";
    case AuditEventCategory::FsCreate: return "FsCreate";
    case AuditEventCategory::FsDelete: return "FsDelete";
    case AuditEventCategory::Http: return "Http";
    case AuditEventCategory::Socket: return "Socket";
    case AuditEventCategory::ProcessCreate: return "ProcessCreate";
    case AuditEventCategory::ProcessReplace: return "ProcessReplace";
    case AuditEventCategory::Threading: return "Threading";
    default: return "None";
    }
}

References Slic3r::FsCreate, Slic3r::FsDelete, Slic3r::FsRead, Slic3r::FsReadWrite, Slic3r::Http, Slic3r::ProcessCreate, Slic3r::ProcessReplace, Slic3r::Socket, and Slic3r::Threading.

Referenced by request_permission().

Here is the caller graph for this function:

audit_message()

wxString Slic3r::PluginAuditDetail::audit_message	(	AuditEventCategory	category,
		const wxString &	plugin_name,
		const wxString &	event_name,
		const wxString &	target_list,
		size_t	target_count )

{
    if (target_list.IsEmpty())
        return wxString::Format(
            _L("Plugin \"%s\" is requesting permission for the Python audit event \"%s\".\n\n"
                "This operation does not expose a target the audit hook can display."),
            plugin_name, event_name);
 
    switch (category) {
    case AuditEventCategory::FsRead:
        return wxString::Format(_L_PLURAL("Plugin \"%s\" is requesting to read the following file:\n%s",
                                          "Plugin \"%s\" is requesting to read the following files:\n%s", target_count),
                                plugin_name, target_list);
    case AuditEventCategory::FsReadWrite:
        return wxString::Format(_L_PLURAL("Plugin \"%s\" is requesting to read/write the following file:\n%s",
                                          "Plugin \"%s\" is requesting to read/write the following files:\n%s", target_count),
                                plugin_name, target_list);
    case AuditEventCategory::FsCreate:
        return wxString::Format(_L_PLURAL("Plugin \"%s\" is requesting to create the following file:\n%s",
                                          "Plugin \"%s\" is requesting to create the following files:\n%s", target_count),
                                plugin_name, target_list);
    case AuditEventCategory::FsDelete:
        return wxString::Format(_L_PLURAL("Plugin \"%s\" is requesting to delete the following file:\n%s",
                                          "Plugin \"%s\" is requesting to delete the following files:\n%s", target_count),
                                plugin_name, target_list);
    case AuditEventCategory::Http:
        return wxString::Format(
            _L("Plugin \"%s\" is requesting network access to:\n%s\n\n"
               "Approval covers HTTP or HTTPS access and raw network connections to the listed hosts. "
               "It does not restrict ports. A URL with a path, query or port is covered only for that "
               "exact URL."),
            plugin_name, target_list);
    case AuditEventCategory::Socket:
        return wxString::Format(
            _L("Plugin \"%s\" is requesting network access to:\n%s\n\n"
               "Approval covers raw network connections to the listed hosts. It does not restrict ports."),
            plugin_name, target_list);
    case AuditEventCategory::ProcessCreate:
        return wxString::Format(_L_PLURAL("Plugin \"%s\" is requesting to run the following command:\n%s",
                                          "Plugin \"%s\" is requesting to run the following commands:\n%s", target_count),
                                plugin_name, target_list);
    case AuditEventCategory::Threading:
        return wxString::Format(_L("Plugin \"%s\" is requesting permission to create a thread."), plugin_name);
    case AuditEventCategory::ProcessReplace:
        return wxString::Format(_L("Plugin \"%s\" is requesting to replace the running application with:\n%s"), plugin_name, target_list);
    default:
        return wxString::Format(_L("Plugin \"%s\" is requesting permission for the Python audit event \"%s\"."), plugin_name, event_name);
    }
}

References _L, _L_PLURAL, Slic3r::FsCreate, Slic3r::FsDelete, Slic3r::FsRead, Slic3r::FsReadWrite, Slic3r::Http, Slic3r::ProcessCreate, Slic3r::ProcessReplace, Slic3r::Socket, and Slic3r::Threading.

Referenced by prompt_for_targets(), and Slic3r::PluginAuditManager::request_permissions().

Here is the caller graph for this function:

audit_plugin_event()

int Slic3r::PluginAuditDetail::audit_plugin_event	(	PluginAuditManager &	mgr,
		const std::string &	event_name,
		AuditEventCategory	event_type,
		PyObject *	args )

{
    const bool                      fs_category = is_fs_category(event_type);
    const std::vector<std::string>  targets      = audit_targets(event_name, event_type, args);
 
    // A denied path (secrets, certificates, config files -- see is_denied_path) is an
    // unconditional block: checked before the running-operation check below, so no granted
    // operation can launder access to one, and before the allowed-root shortcut further down,
    // so an allowed root (e.g. the read-only resources folder) cannot make a denied path
    // underneath it reachable.
    if (fs_category) {
        for (const auto& target : targets) {
            if (mgr.is_denied_path(boost::filesystem::path(target)))
                return report_denied(mgr, event_name, {false, "denied path"}, target);
        }
    }
 
    // A nested event of an operation already granted, e.g. socket.connect inside an approved
    // urlopen(), is not asked again. urllib.Request is always judged on its own URL, so a
    // redirect or a nested urlopen() inside a running request is not covered by it.
    if (event_name != "urllib.Request" && mgr.covered_by_root_frame())
        return 0;
 
    // A filesystem target that resolves entirely inside a pre-determined allowed root -- the
    // plugin system's own data_dir() tree (which holds each plugin's storage folder and the
    // installed/system profile cache), the read-only bundled resources folder, or a per-call
    // scoped root such as the current G-code folder -- is part of the plugin system's normal
    // workflow and does not need a prompt.
    if (fs_category && !targets.empty()) {
        const bool is_write = event_type != AuditEventCategory::FsRead;
        const bool all_inside_allowed_root =
            std::all_of(targets.begin(), targets.end(), [&](const std::string& target) {
                return mgr.check_path_access(boost::filesystem::path(target), is_write).allowed;
            });
        if (all_inside_allowed_root)
            return 0;
    }
 
    PluginInstallState state;
    const bool have_install_state = PluginManager::instance().get_install_state(mgr.current_plugin(), state);
    if (!have_install_state) {
        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << " Failed to get install state for " << mgr.current_plugin();
    }
 
    const std::string plugin_name = state.plugin_name.empty() ? mgr.current_plugin() : state.plugin_name;
 
    const int result = decide_audited_event(mgr, state, mgr.current_plugin(), plugin_name, event_name, event_type, targets);
 
    // A granted operation covers its nested events while it runs. A targetless grant names no
    // operation, so it covers nothing else.
    if (result == 0 && !targets.empty() && operation_root_events.count(event_name))
        mgr.record_root_frame();
    return result;
}

References audit_targets(), Slic3r::PluginAuditManager::covered_by_root_frame(), Slic3r::PluginAuditManager::current_plugin(), decide_audited_event(), Slic3r::FsRead, Slic3r::PluginManager::get_install_state(), Slic3r::PluginManager::instance(), Slic3r::PluginAuditManager::is_denied_path(), Slic3r::is_fs_category(), Slic3r::operation_root_events, Slic3r::PluginInstallState::plugin_name, Slic3r::PluginAuditManager::record_root_frame(), and report_denied().

Referenced by Slic3r::PluginAuditManager::audit_hook().

Here is the call graph for this function:

Here is the caller graph for this function:

audit_targets()

std::vector< std::string > Slic3r::PluginAuditDetail::audit_targets	(	const std::string &	event_name,
		AuditEventCategory	category,
		PyObject *	args )

{
    std::vector<std::string> targets;
 
    switch (category) {
    case AuditEventCategory::FsRead:
    case AuditEventCategory::FsReadWrite:
    case AuditEventCategory::FsCreate:
    case AuditEventCategory::FsDelete: {
        const Py_ssize_t path_count = two_path_fs_events.count(event_name) ? 2 : 1;
        for (Py_ssize_t index = 0; index < path_count; ++index) {
            const std::string path = python_path(tuple_item(args, index));
            if (!path.empty())
                targets.push_back(path);
        }
        return targets;
    }
    case AuditEventCategory::Threading:
        // Thread creation exposes no user-supplied target. Use a fixed sentinel so the grant
        // persists per plugin: the permission list matches targets by exact string, and the
        // started function's repr embeds an address that changes every run.
        targets.emplace_back(kThreadPermissionTarget);
        return targets;
    default:
        break;
    }
 
    const auto it = audit_target_arg_indices.find(event_name);
    if (it != audit_target_arg_indices.end()) {
        for (const Py_ssize_t index : it->second) {
            // None is an argument left out (sendmsg without an address), not a target named "None".
            PyObject* const item = tuple_item(args, index);
            if (item == Py_None)
                continue;
            std::string value = python_str(item);
            if (!value.empty()) {
                targets.push_back(std::move(value));
                break;
            }
        }
    }
 
    return targets;
}

References audit_target_arg_indices, Slic3r::FsCreate, Slic3r::FsDelete, Slic3r::FsRead, Slic3r::FsReadWrite, Slic3r::kThreadPermissionTarget, python_path(), python_str(), Slic3r::Threading, tuple_item(), and two_path_fs_events.

Referenced by audit_plugin_event().

Here is the call graph for this function:

Here is the caller graph for this function:

collect_stdlib_dirs()

void Slic3r::PluginAuditDetail::collect_stdlib_dirs

(

)

{
    s_stdlib_dirs.clear();
    s_site_package_dirs.clear();
    s_stdlib_file_verdicts.clear();
 
    PyObject* sysconfig = PyImport_ImportModule("sysconfig");
    PyObject* paths     = sysconfig ? PyObject_CallMethod(sysconfig, "get_paths", nullptr) : nullptr;
    if (paths && PyDict_Check(paths)) {
        const auto collect = [paths](const char* key, std::vector<boost::filesystem::path>& out) {
            const std::string dir = python_unicode(PyDict_GetItemString(paths, key)); // borrowed
            if (dir.empty())
                return;
            boost::system::error_code ec;
            const boost::filesystem::path resolved = boost::filesystem::weakly_canonical(dir, ec);
            out.push_back(ec ? boost::filesystem::path(dir) : resolved);
        };
        collect("stdlib", s_stdlib_dirs);
        collect("platstdlib", s_stdlib_dirs);
        collect("purelib", s_site_package_dirs);
        collect("platlib", s_site_package_dirs);
    }
    Py_XDECREF(paths);
    Py_XDECREF(sysconfig);
    if (PyErr_Occurred()) {
        PyErr_Clear();
        BOOST_LOG_TRIVIAL(error) << "[AUDIT] Failed to read the stdlib folders from sysconfig";
    }
}

References python_unicode(), s_site_package_dirs, s_stdlib_dirs, and s_stdlib_file_verdicts.

Referenced by Slic3r::PluginAuditManager::install_hook().

Here is the call graph for this function:

Here is the caller graph for this function:

decide_audited_event()

int Slic3r::PluginAuditDetail::decide_audited_event	(	PluginAuditManager &	mgr,
		PluginInstallState &	state,
		const std::string &	plugin_key,
		const std::string &	plugin_name,
		const std::string &	event_name,
		AuditEventCategory	category,
		const std::vector< std::string > &	targets )

{
    const bool                     by_event = targets.empty();
    const std::vector<std::string> keys     = by_event ? std::vector<std::string>{event_grant_key(category, event_name)} : targets;
    std::vector<std::string>*      permission_list = permission_list_for(category, by_event, state.permissions);
 
    std::vector<std::string> unresolved = keys;
    if (permission_list || is_network_category(category)) {
        unresolved.clear();
        for (const auto& key : keys) {
            // A network grant authorizes a specific host, except for a targetless event such as
            // http.client.send, which names no host: any network grant covers that.
            const bool granted_network =
                is_network_category(category) &&
                (by_event ? has_any_network_permission(state.permissions)
                          : has_network_permission(state.permissions, key));
            if (!(permission_list && has_permission(category, by_event, *permission_list, key)) && !granted_network)
                unresolved.push_back(key);
        }
        if (unresolved.empty())
            return 0;
    }
 
    // Letting a root frame go runs finalizers inside a scope destructor or another event's hook,
    // where no dialog may open: what they do must already be granted.
    if (mgr.releasing_frames())
        return report_denied(mgr, event_name, {false, "audit permission required"});
 
    if (!request_permission(category, plugin_key, plugin_name, event_name, by_event, unresolved))
        return report_denied(mgr, event_name, {false, "audit permission required"});
 
    if (permission_list)
        for (const auto& key : unresolved)
            persist_permission(plugin_key, state, category, by_event, *permission_list, key);
    return 0;
}

References event_grant_key(), has_any_network_permission(), has_network_permission(), has_permission(), Slic3r::is_network_category(), permission_list_for(), Slic3r::PluginInstallState::permissions, persist_permission(), Slic3r::PluginAuditManager::releasing_frames(), report_denied(), and request_permission().

Referenced by audit_plugin_event().

Here is the call graph for this function:

Here is the caller graph for this function:

event_grant_key()

std::string Slic3r::PluginAuditDetail::event_grant_key	(	AuditEventCategory	category,
		const std::string &	event_name )

{
    return std::string(category_name(category)) + ":" + event_name;
}

References Slic3r::category_name().

Referenced by decide_audited_event().

Here is the call graph for this function:

Here is the caller graph for this function:

fs_grant_covers()

bool Slic3r::PluginAuditDetail::fs_grant_covers	(	const std::string &	grant,
		const std::string &	target )

{
    if (grant == target)
        return true;
    if (target.empty())
        return false;
 
    boost::filesystem::path root;
    if (!tree_grant_root(grant, root))
        return false;
 
    return is_inside_allowed_root(boost::filesystem::path(target), root);
}

References Slic3r::is_inside_allowed_root(), and tree_grant_root().

Referenced by has_permission().

Here is the call graph for this function:

Here is the caller graph for this function:

has_any_network_permission()

bool Slic3r::PluginAuditDetail::has_any_network_permission

(

const PluginPermissions &

permissions

)

{
    return !permissions.network_http.empty() || !permissions.network_socket.empty();
}

References Slic3r::PluginPermissions::network_http, and Slic3r::PluginPermissions::network_socket.

Referenced by decide_audited_event().

Here is the caller graph for this function:

has_network_permission()

bool Slic3r::PluginAuditDetail::has_network_permission	(	const PluginPermissions &	permissions,
		const std::string &	target )

{
    return PluginAuditManager::network_permission_matches(permissions.network_http, target) ||
           PluginAuditManager::network_permission_matches(permissions.network_socket, target);
}

References Slic3r::PluginPermissions::network_http, Slic3r::PluginAuditManager::network_permission_matches(), and Slic3r::PluginPermissions::network_socket.

Referenced by decide_audited_event(), and Slic3r::PluginAuditManager::request_permissions().

Here is the call graph for this function:

Here is the caller graph for this function:

has_permission()

bool Slic3r::PluginAuditDetail::has_permission	(	AuditEventCategory	category,
		bool	by_event,
		const std::vector< std::string > &	granted,
		const std::string &	target )

{
    const bool fs_bucket =
        !by_event && (category == AuditEventCategory::FsRead || category == AuditEventCategory::FsReadWrite);
    for (const auto& grant : granted) {
        if (grant == target)
            return true;
        if (fs_bucket && fs_grant_covers(grant, target))
            return true;
    }
    return false;
}

References fs_grant_covers(), Slic3r::FsRead, and Slic3r::FsReadWrite.

Referenced by decide_audited_event(), persist_permission(), and Slic3r::PluginAuditManager::request_permissions().

Here is the call graph for this function:

Here is the caller graph for this function:

is_stdlib_frame()

bool Slic3r::PluginAuditDetail::is_stdlib_frame

(

PyObject *

frame

)

{
    PyCodeObject* code = PyFrame_GetCode(reinterpret_cast<PyFrameObject*>(frame)); // new reference
    const std::string filename = python_unicode(code->co_filename);
    Py_DECREF(code);
    return PluginAuditManager::is_stdlib_file(filename);
}

References Slic3r::PluginAuditManager::is_stdlib_file(), and python_unicode().

Referenced by Slic3r::PluginAuditManager::covered_by_root_frame(), and Slic3r::PluginAuditManager::record_root_frame().

Here is the call graph for this function:

Here is the caller graph for this function:

open_category()

AuditEventCategory Slic3r::PluginAuditDetail::open_category

(

PyObject *

args

)

{
    const std::string mode = python_unicode(tuple_item(args, 1));
    if (!mode.empty() && mode.find_first_of("wax+") == std::string::npos)
        return AuditEventCategory::FsRead;
    return AuditEventCategory::FsReadWrite;
}

References Slic3r::FsRead, Slic3r::FsReadWrite, python_unicode(), and tuple_item().

Referenced by Slic3r::PluginAuditManager::audit_hook().

Here is the call graph for this function:

Here is the caller graph for this function:

permission_list_for()

std::vector< std::string > * Slic3r::PluginAuditDetail::permission_list_for	(	AuditEventCategory	category,
		bool	by_event,
		PluginPermissions &	permissions )

{
    if (by_event)
        return &permissions.events;
 
    switch (category) {
    case AuditEventCategory::FsRead:        return &permissions.fs_read;
    case AuditEventCategory::FsReadWrite:   return &permissions.fs_readwrite;
    case AuditEventCategory::Http:          return &permissions.network_http;
    case AuditEventCategory::Socket:        return &permissions.network_socket;
    case AuditEventCategory::ProcessCreate: return &permissions.process;
    case AuditEventCategory::Threading:     return &permissions.threading;
    case AuditEventCategory::ProcessReplace: return &permissions.process;
    default:                                return nullptr;
    }
}

References Slic3r::PluginPermissions::events, Slic3r::PluginPermissions::fs_read, Slic3r::PluginPermissions::fs_readwrite, Slic3r::FsRead, Slic3r::FsReadWrite, Slic3r::Http, Slic3r::PluginPermissions::network_http, Slic3r::PluginPermissions::network_socket, Slic3r::PluginPermissions::process, Slic3r::ProcessCreate, Slic3r::ProcessReplace, Slic3r::Socket, Slic3r::Threading, and Slic3r::PluginPermissions::threading.

Referenced by decide_audited_event(), persist_grant(), and Slic3r::PluginAuditManager::request_permissions().

Here is the caller graph for this function:

persist_grant()

void Slic3r::PluginAuditDetail::persist_grant	(	const std::string &	plugin_key,
		AuditEventCategory	category,
		bool	by_event,
		const std::vector< std::string > &	keys )

{
    PluginInstallState state;
    if (!PluginManager::instance().get_install_state(plugin_key, state))
        return;
 
    std::vector<std::string>* permission_list = permission_list_for(category, by_event, state.permissions);
    if (!permission_list)
        return;
 
    for (const auto& key : keys)
        persist_permission(plugin_key, state, category, by_event, *permission_list, key);
}

References Slic3r::PluginManager::instance(), permission_list_for(), Slic3r::PluginInstallState::permissions, and persist_permission().

Referenced by request_permission().

Here is the call graph for this function:

Here is the caller graph for this function:

persist_permission()

bool Slic3r::PluginAuditDetail::persist_permission	(	const std::string &	plugin_key,
		PluginInstallState &	state,
		AuditEventCategory	category,
		bool	by_event,
		std::vector< std::string > &	permission_list,
		const std::string &	target )

{
    PluginDescriptor descriptor;
    if (!PluginManager::instance().try_get_plugin_descriptor(plugin_key, descriptor) || descriptor.plugin_root.empty())
        return false;
 
    seed_install_metadata(descriptor, state);
 
    if (!has_permission(category, by_event, permission_list, target))
        permission_list.push_back(target);
    return write_install_state(boost::filesystem::path(descriptor.plugin_root), state);
}

References has_permission(), Slic3r::PluginManager::instance(), Slic3r::PluginDescriptor::plugin_root, seed_install_metadata(), and Slic3r::write_install_state().

Referenced by decide_audited_event(), and persist_grant().

Here is the call graph for this function:

Here is the caller graph for this function:

prompt_for_permission_message()

bool Slic3r::PluginAuditDetail::prompt_for_permission_message

(

const wxString &

message

)

{
    wxMessageDialog dialog(nullptr, message, _L("Plugin permissions"), wxYES_NO | wxICON_WARNING);
    return dialog.ShowModal() == wxID_YES;
}

References _L.

Referenced by Slic3r::PluginAuditManager::request_permissions().

Here is the caller graph for this function:

prompt_for_targets()

bool Slic3r::PluginAuditDetail::prompt_for_targets	(	AuditEventCategory	category,
		const std::string &	plugin_name,
		const std::string &	event_name,
		const std::vector< std::string > &	unresolved )

{
    wxString target_list;
    for (const auto& target : unresolved)
        target_list += wxString::FromUTF8(target.c_str()) + "\n";
 
    return show_permission_dialog(
        audit_message(category, wxString::FromUTF8(plugin_name.c_str()), wxString::FromUTF8(event_name.c_str()),
                      target_list, unresolved.size()),
        _L("Plugin permission request"));
}

References _L, and audit_message().

Referenced by request_permission().

Here is the call graph for this function:

Here is the caller graph for this function:

python_path()

std::string Slic3r::PluginAuditDetail::python_path

(

PyObject *

object

)

{
    if (!object)
        return {};
 
    PyObject* path_object = PyOS_FSPath(object);
    if (!path_object) {
        PyErr_Clear();
        return {};
    }
 
    std::string result;
    python_text(path_object, result);
    Py_DECREF(path_object);
    return result;
}

References python_text().

Referenced by audit_targets().

Here is the call graph for this function:

Here is the caller graph for this function:

python_str()

std::string Slic3r::PluginAuditDetail::python_str

(

PyObject *

object

)

{
    if (!object)
        return {};
 
    PyObject* str_object = PyObject_Str(object);
    if (!str_object) {
        PyErr_Clear();
        return {};
    }
 
    const std::string result = python_unicode(str_object);
    Py_DECREF(str_object);
    return result;
}

References python_unicode().

Referenced by audit_targets().

Here is the call graph for this function:

Here is the caller graph for this function:

python_text()

bool Slic3r::PluginAuditDetail::python_text	(	PyObject *	object,
		std::string &	out )

{
    if (PyUnicode_Check(object)) {
        out = python_unicode(object);
        return true;
    }
    if (PyBytes_Check(object)) {
        const char* value = PyBytes_AsString(object);
        if (!value) {
            PyErr_Clear();
            out.clear();
            return true;
        }
        out = value;
        return true;
    }
    return false;
}

References python_unicode().

Referenced by python_path().

Here is the call graph for this function:

Here is the caller graph for this function:

python_unicode()

std::string Slic3r::PluginAuditDetail::python_unicode

(

PyObject *

object

)

{
    if (!object || !PyUnicode_Check(object))
        return {};
    const char* text = PyUnicode_AsUTF8(object);
    if (!text) {
        PyErr_Clear();
        return {};
    }
    return text;
}

Referenced by collect_stdlib_dirs(), is_stdlib_frame(), open_category(), python_str(), and python_text().

Here is the caller graph for this function:

report_denied()

int Slic3r::PluginAuditDetail::report_denied	(	PluginAuditManager &	mgr,
		const std::string &	event_name,
		const AuditDecision &	decision,
		const std::string &	target = {} )

                                                        {})
{
    AuditViolation violation;
    violation.plugin_key = mgr.current_plugin();
    violation.event_name = event_name;
    violation.reason     = decision.reason;
    mgr.report_violation(violation);
 
    std::string message = "Plugin attempted audited operation \"" + event_name + "\" without permission";
    if (!decision.reason.empty())
        message += ": " + decision.reason;
    if (!target.empty())
        message += ": " + target;
 
    PyErr_SetString(PyExc_PermissionError, message.c_str());
    return -1;
}

Referenced by audit_plugin_event(), and decide_audited_event().

Here is the caller graph for this function:

request_permission()

bool Slic3r::PluginAuditDetail::request_permission	(	AuditEventCategory	category,
		const std::string &	plugin_key,
		const std::string &	plugin_name,
		const std::string &	event_name,
		bool	by_event,
		const std::vector< std::string > &	keys )

{
    const std::vector<std::string> shown = by_event ? std::vector<std::string>{} : keys;
    std::string targets_text = by_event ? "<none>" : "";
    for (const auto& target : shown) {
        if (!targets_text.empty())
            targets_text += ", ";
        targets_text += target;
    }
 
    BOOST_LOG_TRIVIAL(info) << "[AUDIT PROMPT] plugin=" << plugin_key << " event=" << event_name
                            << " category=" << audit_category_name(category) << " targets=[" << targets_text << "]"
                            << (by_event && !keys.empty() ? " grant=" + keys.front() : std::string{});
 
    if (s_permission_prompt_for_testing)
        return s_permission_prompt_for_testing(event_name, shown);
 
    if (wxTheApp == nullptr || GUI::wxGetApp().is_closing())
        return false;
 
    if (wxIsMainThread())
        return prompt_for_targets(category, plugin_name, event_name, shown);
 
    GUI::wxGetApp().CallAfter([category, plugin_key, plugin_name, event_name, by_event, keys, shown]() {
        if (wxTheApp == nullptr || GUI::wxGetApp().is_closing())
            return;
        if (prompt_for_targets(category, plugin_name, event_name, shown))
            persist_grant(plugin_key, category, by_event, keys);
    });
    return false;
}

References audit_category_name(), persist_grant(), prompt_for_targets(), and s_permission_prompt_for_testing.

Referenced by decide_audited_event().

Here is the call graph for this function:

Here is the caller graph for this function:

seed_install_metadata()

void Slic3r::PluginAuditDetail::seed_install_metadata	(	const PluginDescriptor &	descriptor,
		PluginInstallState &	state )

{
    if (!state.plugin_name.empty())
        return;
 
    state.installed_from    = descriptor.is_cloud_plugin() ? "cloud" : "local";
    state.installed_version = !descriptor.installed_version.empty() ? descriptor.installed_version : descriptor.version;
    state.plugin_name       = descriptor.name;
    state.cloud_uuid        = descriptor.cloud_uuid();
    state.enabled           = true;
}

References Slic3r::PluginDescriptor::cloud_uuid(), Slic3r::PluginInstallState::cloud_uuid, Slic3r::PluginInstallState::enabled, Slic3r::PluginInstallState::installed_from, Slic3r::PluginDescriptor::installed_version, Slic3r::PluginInstallState::installed_version, Slic3r::PluginDescriptor::is_cloud_plugin(), Slic3r::PluginDescriptor::name, Slic3r::PluginInstallState::plugin_name, and Slic3r::PluginDescriptor::version.

Referenced by persist_permission(), and Slic3r::PluginAuditManager::request_permissions().

Here is the call graph for this function:

Here is the caller graph for this function:

stack_frames()

std::vector< PyObject * > Slic3r::PluginAuditDetail::stack_frames

(

)

{
    std::vector<PyObject*> frames;
    PyFrameObject* frame = PyEval_GetFrame(); // borrowed reference
    Py_XINCREF(frame);                        // normalize to an owned reference for the loop below
    while (frame) {
        frames.push_back(reinterpret_cast<PyObject*>(frame));
        PyFrameObject* back = PyFrame_GetBack(frame); // new reference, or nullptr at the top of the stack
        Py_DECREF(frame);
        frame = back;
    }
    return frames;
}

Referenced by Slic3r::PluginAuditManager::covered_by_root_frame(), and take_returned_frames().

Here is the caller graph for this function:

take_returned_frames()

void Slic3r::PluginAuditDetail::take_returned_frames	(	std::vector< PyObject * > &	held,
		std::vector< PyObject * > &	dropped )

{
    if (held.empty())
        return;
 
    const std::vector<PyObject*> stack = stack_frames();
    const auto running = [&stack](PyObject* frame) {
        if (std::find(stack.begin(), stack.end(), frame) != stack.end())
            return true;
        // NULL once the generator has finished or been deleted: its frame then owns its own data.
        PyObject* generator = PyFrame_GetGenerator(reinterpret_cast<PyFrameObject*>(frame)); // new reference
        const bool suspended = generator != nullptr;
        Py_XDECREF(generator);
        return suspended;
    };
    const auto returned = std::stable_partition(held.begin(), held.end(), running);
    dropped.insert(dropped.end(), returned, held.end());
    held.erase(returned, held.end());
}

References stack_frames().

Referenced by Slic3r::PluginAuditManager::audit_hook().

Here is the call graph for this function:

Here is the caller graph for this function:

tree_grant_root()

bool Slic3r::PluginAuditDetail::tree_grant_root	(	const std::string &	grant,
		boost::filesystem::path &	root )

{
    if (grant.size() < 2 || grant.back() != '*' || grant.find('*') != grant.size() - 1)
        return false;
 
    const boost::filesystem::path path(grant);
    if (path.filename() != "*")
        return false;
 
    const boost::filesystem::path parent = path.parent_path();
    if (parent.empty())
        return false;
 
    // Never resolve ".." here: a grant shown to the user as "/a/../*" must not silently become
    // the root or another ancestor. Without a wildcard the string still matches verbatim.
    for (const boost::filesystem::path& component : parent) {
        if (component == "..")
            return false;
    }
 
    // Rebuild from the components so "." and duplicate separators do not affect the canonical
    // comparison below.
    boost::filesystem::path normalized;
    for (const boost::filesystem::path& component : parent.lexically_normal()) {
        if (!component.empty())
            normalized /= component;
    }
    root = std::move(normalized);
    return !root.empty();
}

Referenced by absolute_tree_grant(), and fs_grant_covers().

Here is the caller graph for this function:

tuple_item()

PyObject * Slic3r::PluginAuditDetail::tuple_item	(	PyObject *	args,
		Py_ssize_t	index )

{
    if (!args || !PyTuple_Check(args) || index < 0 || index >= PyTuple_GET_SIZE(args))
        return nullptr;
    return PyTuple_GET_ITEM(args, index);
}

Referenced by audit_targets(), and open_category().

Here is the caller graph for this function:

Variable Documentation

audit_target_arg_indices

const std::unordered_map<std::string, std::vector<Py_ssize_t> > Slic3r::PluginAuditDetail::audit_target_arg_indices

static

Initial value:

{
    {"http.client.connect", {1}},
    {"urllib.Request", {0}},
 
    {"socket.connect", {1}},
    {"socket.bind", {1}},
    {"socket.getaddrinfo", {0}},
    {"socket.gethostbyname", {0}},
    {"socket.gethostbyaddr", {0}},
    {"socket.getnameinfo", {0}},
    {"socket.getservbyname", {0}},
    {"socket.getservbyport", {0}},
    {"socket.sendto", {1}},
    {"socket.sendmsg", {1}},
 
    {"os.system", {0}},
    {"subprocess.Popen", {1, 0}},
    {"os.posix_spawn", {1, 0}},
    {"os.spawn", {2, 1}},
    {"os.startfile", {0}},
    {"os.startfile/2", {0}},
    {"pty.spawn", {0}},
    {"_winapi.CreateProcess", {1, 0}},
    {"_posixsubprocess.fork_exec", {0}},
    {"os.exec", {0}},
}

                                                                                        {
    {"http.client.connect", {1}},
    {"urllib.Request", {0}},
 
    {"socket.connect", {1}},
    {"socket.bind", {1}},
    {"socket.getaddrinfo", {0}},
    {"socket.gethostbyname", {0}},
    {"socket.gethostbyaddr", {0}},
    {"socket.getnameinfo", {0}},
    {"socket.getservbyname", {0}},
    {"socket.getservbyport", {0}},
    {"socket.sendto", {1}},
    {"socket.sendmsg", {1}},
 
    {"os.system", {0}},
    {"subprocess.Popen", {1, 0}},
    {"os.posix_spawn", {1, 0}},
    {"os.spawn", {2, 1}},
    {"os.startfile", {0}},
    {"os.startfile/2", {0}},
    {"pty.spawn", {0}},
    {"_winapi.CreateProcess", {1, 0}},
    {"_posixsubprocess.fork_exec", {0}},
    {"os.exec", {0}},
};

Referenced by audit_targets().

s_permission_message_prompt_for_testing

PluginAuditManager::PermissionMessagePrompt Slic3r::PluginAuditDetail::s_permission_message_prompt_for_testing

static

Referenced by Slic3r::PluginAuditManager::request_permissions(), and Slic3r::PluginAuditManager::set_permission_message_prompt_for_testing().

s_permission_prompt_for_testing

PluginAuditManager::PermissionPrompt Slic3r::PluginAuditDetail::s_permission_prompt_for_testing

static

Referenced by request_permission(), and Slic3r::PluginAuditManager::set_permission_prompt_for_testing().

s_site_package_dirs

std::vector<boost::filesystem::path> Slic3r::PluginAuditDetail::s_site_package_dirs

static

Referenced by collect_stdlib_dirs(), Slic3r::PluginAuditManager::is_stdlib_file(), and Slic3r::PluginAuditManager::is_stdlib_path().

s_stdlib_dirs

std::vector<boost::filesystem::path> Slic3r::PluginAuditDetail::s_stdlib_dirs

static

Referenced by collect_stdlib_dirs(), Slic3r::PluginAuditManager::is_stdlib_file(), and Slic3r::PluginAuditManager::is_stdlib_path().

s_stdlib_file_verdicts

std::unordered_map<std::string, bool> Slic3r::PluginAuditDetail::s_stdlib_file_verdicts

static

Referenced by collect_stdlib_dirs(), and Slic3r::PluginAuditManager::is_stdlib_file().

two_path_fs_events

const std::unordered_set<std::string> Slic3r::PluginAuditDetail::two_path_fs_events

static

Initial value:

{
    "os.rename",       "os.link",          "os.symlink",         "shutil.copyfile",
    "shutil.copytree", "shutil.copymode",  "shutil.copystat",    "shutil.move",
    "shutil.unpack_archive", "_winapi.CreateJunction",
}

                                                           {
    "os.rename",       "os.link",          "os.symlink",         "shutil.copyfile",
    "shutil.copytree", "shutil.copymode",  "shutil.copystat",    "shutil.move",
    "shutil.unpack_archive", "_winapi.CreateJunction",
};

Referenced by audit_targets().