Merge lp:~kissiel/checkbox/password-dialog into lp:checkbox

[Maciej Kisielewski]

This MR teaches Checkbox-Touch how to run jobs as different user (root usually)

Sequence of running jobs as different user in CBT is as follows:
When Checkbox-Touch session is started, CheckboxTouchApplication instance is
given list of controllers that can be used for job execution. One of the
controllers is TouchRootViaSudoExecutionController. To instantiate this
controller one must provide callable that will be used when executing sudo.
The reason we're defferring password polling is that we don't yet know if
password will be needed (for instance all selected jobs run as current user).
Once the session is started, Checkbox-Touch checks every job if job requires
user change. If that's the case, it displays QML password prompt and sends
entered password to CheckboxTouchApplication instance, so the
password-returning callable can provide controller with the pass.
It's crucial that password is stored in CheckboxTouchApplication prior to
execution of any sudo-related job.

d8fd76d checkbox-touch: make checkbox-touch ask for password
09258d7 checkbox-touch: add rememberPassword to App component on QML side
8ca815e checkbox-touch: use custom execution controllers
125b4c9 checkbox-touch: add storing of password in CheckboxTouchApplication
c1eba56 checkbox-touch: add PasswordDialog
a08900e checkbox-touch: add RootViaSudoWithPassExecutionController
2355c3d checkbox-touch: move perform*Test calls to distinctive function
8437551 checkbox-touch: add job's user field to 'test' model

[Zygmunt Krynicki (zyga)]

On piątek, 13 lutego 2015 19:45:30 CET, Maciej Kisielewski wrote:
> Maciej Kisielewski has proposed merging
> lp:~kissiel/checkbox/password-dialog into lp:checkbox.
>
> Requested reviews:
> Checkbox Developers (checkbox-dev)
>
> For more details, see:
> https://code.launchpad.net/~kissiel/checkbox/password-dialog/+merge/249700
>
> This MR teaches Checkbox-Touch how to run jobs as different
> user (root usually)
>
> Sequence of running jobs as different user in CBT is as follows:
> When Checkbox-Touch session is started,
> CheckboxTouchApplication instance is
> given list of controllers that can be used for job execution. One of the
> controllers is TouchRootViaSudoExecutionController. To instantiate this
> controller one must provide callable that will be used when executing sudo.
> The reason we're defferring password polling is that we don't yet know if
> password will be needed (for instance all selected jobs run as
> current user).

There is an existing, better mechanism for doing this, namely voting. Keep
this execution controller focused on just running root jobs

> Once the session is started, Checkbox-Touch checks every job if
> job requires
> user change. If that's the case, it displays QML password prompt and sends
> entered password to CheckboxTouchApplication instance, so the
> password-returning callable can provide controller with the pass.
> It's crucial that password is stored in CheckboxTouchApplication prior to
> execution of any sudo-related job.
>
> d8fd76d checkbox-touch: make checkbox-touch ask for password
> 09258d7 checkbox-touch: add rememberPassword to App component on QML side
> 8ca815e checkbox-touch: use custom execution controllers
> 125b4c9 checkbox-touch: add storing of password in CheckboxTouchApplication
> c1eba56 checkbox-touch: add PasswordDialog
> a08900e checkbox-touch: add RootViaSudoWithPassExecutionController
> 2355c3d checkbox-touch: move perform*Test calls to distinctive function
> 8437551 checkbox-touch: add job's user field to 'test' model
>
Ill read the rest later

Thanks for posting this
ZK

--
Sent using Dekko from my Ubuntu device

[Zygmunt Krynicki (zyga)]

Hey. This looks good. I only have one real comment below.

And I'm sorry for keeping this lingering so long.

review: Needs Fixing

[Maciej Kisielewski (kissiel)]

Options changed to long versions. Added comment for uncommon options. Repushed.

[Zygmunt Krynicki (zyga)]

+1

Thanks for pinging me. I don't see anything that would hold it anymore now.

review: Approve

=== modified file 'checkbox-touch/components/CheckboxTouchApplication.qml'
--- checkbox-touch/components/CheckboxTouchApplication.qml	2014-11-27 22:31:39 +0000
+++ checkbox-touch/components/CheckboxTouchApplication.qml	2015-03-10 12:19:50 +0000
@@ -146,6 +146,11 @@
         });
     }
 
+    function rememberPassword(password, continuation) {
+        // using low-level py.call() to 'silently' pass password string through pyotherside
+        py.call("py_invoke", [handle, "remember_password", [password]], continuation);
+    }
+
     // A wrapper around invoke() that works with the @view decorator. The fn_ok
     // and fn_err are called on a normal reply and on error, respectively.
     function request(name, args, fn_ok, fn_err) {

=== added file 'checkbox-touch/components/PasswordDialog.qml'
--- checkbox-touch/components/PasswordDialog.qml	1970-01-01 00:00:00 +0000
+++ checkbox-touch/components/PasswordDialog.qml	2015-03-10 12:19:50 +0000
@@ -0,0 +1,88 @@
+/*
+ * This file is part of Checkbox
+ *
+ * Copyright 2015 Canonical Ltd.
+ *
+ * Authors:
+ * - Maciej Kisielewski <[e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+import QtQuick 2.0
+import Ubuntu.Components 1.1
+import Ubuntu.Components.Popups 0.1
+
+/*! \brief Password prompt dialog.
+    \inherits Item
+
+    This component is a prompt for user's password.
+*/
+Item {
+    id: passwordDialog
+
+    /*!
+      This alias aids the process of popping up the dialog.
+      Usage: PopupUtils.open(passwordDialog.dialogComponent);
+     */
+    property alias dialogComponent: component
+
+    signal passwordEntered(string password)
+    signal dialogCancelled
+
+    Component {
+        id: component
+
+        Dialog {
+            id: dialog
+            title: i18n.tr("Enter password")
+
+            modal: true
+
+            TextField {
+                id: passwordBox
+                placeholderText: i18n.tr("password")
+                echoMode: TextInput.Password
+                onAccepted: okButton.clicked(text)
+            }
+
+            Button {
+                id: okButton
+                text: i18n.tr("OK")
+                color: UbuntuColors.green
+                onClicked: {
+                    PopupUtils.close(dialog);
+                    // once qml pam authentication goes live, we might want to
+                    // check if the password is correct in some QML-ish manner
+                    passwordEntered(passwordBox.text);
+                    passwordBox.text = "";
+                }
+            }
+
+            Button {
+                text: i18n.tr("Cancel")
+                color: UbuntuColors.red
+                onClicked: {
+                    passwordBox.text = "";
+                    PopupUtils.close(dialog);
+                    dialogCancelled();
+                }
+            }
+
+            Component.onCompleted: {
+                // let user type in password without tapping on
+                // the text field
+                passwordBox.forceActiveFocus();
+            }
+        }
+    }
+}

=== modified file 'checkbox-touch/main.qml'
--- checkbox-touch/main.qml	2015-02-09 14:19:48 +0000
+++ checkbox-touch/main.qml	2015-03-10 12:19:50 +0000
@@ -21,6 +21,7 @@
  */
 import QtQuick 2.0
 import Ubuntu.Components 1.1
+import Ubuntu.Components.Popups 0.1
 import QtQuick.Layouts 1.1
 import io.thp.pyotherside 1.2
 import "components"
@@ -302,6 +303,11 @@
             });
         }
     }
+
+    PasswordDialog {
+        id: passwordDialog
+    }
+
     function resumeOrStartSession() {
         app.isSessionResumable(function(result) {
             if(result.resumable === true) {
@@ -325,32 +331,55 @@
             if (test.plugin === undefined) { 
                 return showResultsScreen();
             }
-            switch (test['plugin']) {
-                case 'manual':
-                    performManualTest(test);
-                    break;
-                case 'user-interact-verify':
-                    performUserInteractVerifyTest(test);
-                    break;
-                case 'shell':
-                    performAutomatedTest(test);
-                    break;
-                case 'user-verify':
-                    performUserVerifyTest(test);
-                    break;
-                case 'user-interact':
-                    performUserInteractTest(test);
-                    break;
-                case 'qml':
-                    performQmlTest(test);
-                    break;
-                default:
-                    test.outcome = "skip";
-                    completeTest(test);
+            if (test.user) {
+                // running this test will require to be run as a different
+                // user (therefore requiring user to enter sudo password)
+                if (!appSettings.sudoPasswordProvided) {
+                    // ask user for password
+                    passwordDialog.passwordEntered.connect(function(pass) {
+                        app.rememberPassword(pass, function(){
+                            appSettings.sudoPasswordProvided = true;
+                            performTest(test);
+                        });
+                    });
+                    passwordDialog.dialogCancelled.connect(function() {
+                        test.outcome = "skip";
+                        completeTest(test);
+                    });
+                    PopupUtils.open(passwordDialog.dialogComponent);
+                    return;
+                }
             }
+            performTest(test);
         });
     }
 
+    function performTest(test) {
+        switch (test['plugin']) {
+            case 'manual':
+                performManualTest(test);
+                break;
+            case 'user-interact-verify':
+                performUserInteractVerifyTest(test);
+                break;
+            case 'shell':
+                performAutomatedTest(test);
+                break;
+            case 'user-verify':
+                performUserVerifyTest(test);
+                break;
+            case 'user-interact':
+                performUserInteractTest(test);
+                break;
+            case 'qml':
+                performQmlTest(test);
+                break;
+            default:
+                test.outcome = "skip";
+                completeTest(test);
+        }
+    }
+
     function completeTest(test) {
         app.registerTestResult(test, processNextTest);
     }

=== modified file 'checkbox-touch/py/checkbox_touch.py'
--- checkbox-touch/py/checkbox_touch.py	2015-02-12 08:24:52 +0000
+++ checkbox-touch/py/checkbox_touch.py	2015-03-10 12:19:50 +0000
@@ -1,6 +1,6 @@
 # This file is part of Checkbox.
 #
-# Copyright 2014 Canonical Ltd.
+# Copyright 2014-2015 Canonical Ltd.
 # Written by:
 #   Zygmunt Krynicki <[e-mail]>
 #   Maciej Kisielewski <[e-mail]>
@@ -337,6 +337,7 @@
         self.session_storage_repo = None
         self.timestamp = datetime.datetime.utcnow().isoformat()
         self.config = None
+        self._password = None
 
     def __repr__(self):
         return "app"
@@ -369,11 +370,22 @@
             # Checkpoint the session so that we have something to see
             self._checkpoint()
             self.config = PlainBoxConfig()
+
+            # Prepare custom execution controller list
+            from plainbox.impl.ctrl import UserJobExecutionController
+            from sudo_with_pass_ctrl import \
+                RootViaSudoWithPassExecutionController
+            controllers = [
+                RootViaSudoWithPassExecutionController(
+                    self.context.provider_list, self._password_provider),
+                UserJobExecutionController(self.context.provider_list),
+            ]
             self.runner = JobRunner(
                 self.manager.storage.location,
                 self.context.provider_list,
                 # TODO: tie this with well-known-dirs helper
-                os.path.join(self.manager.storage.location, 'io-logs'))
+                os.path.join(self.manager.storage.location, 'io-logs'),
+                execution_ctrl_list=controllers)
         app_cache_dir = self._get_app_cache_directory()
         if not os.path.exists(app_cache_dir):
             os.makedirs(app_cache_dir)
@@ -604,6 +616,7 @@
                 job.tr_verification() is not None else description,
                 "plugin": job.plugin,
                 "id": job.id,
+                "user": job.user,
                 "qml_file": job.qml_file,
                 "start_time": time.time(),
                 "test_number": self.index,
@@ -783,6 +796,21 @@
         provider_list.append(get_categories())
         return provider_list
 
+    def _password_provider(self):
+        if self._password is None:
+            raise RuntimeError("execute_job called without providing password"
+                               " first")
+        return self._password
+
+    def remember_password(self, password):
+        """
+        Save password in app instance
+
+        It deliberately doesn't use view decorator to omit all logging that
+        might happen
+        """
+        self._password = password
+
 
 def bootstrap():
     logging.basicConfig(level=logging.INFO, stream=sys.stderr)

=== added file 'checkbox-touch/py/sudo_with_pass_ctrl.py'
--- checkbox-touch/py/sudo_with_pass_ctrl.py	1970-01-01 00:00:00 +0000
+++ checkbox-touch/py/sudo_with_pass_ctrl.py	2015-03-10 12:19:50 +0000
@@ -0,0 +1,184 @@
+# This file is part of Checkbox.
+#
+# Copyright 2015 Canonical Ltd.
+# Written by:
+#   Maciej Kisielewski <[e-mail]>
+#
+# Checkbox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3,
+# as published by the Free Software Foundation.
+#
+# Checkbox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
+"""
+:mod:`sudo_with_pass_ctrl` -- Self Providing Sudo Execution Controller
+======================================================================
+
+This module defines an Execution Controller capable of running plainbox' jobs
+as the user supplied in job definition. It does so by launching `sudo -S (...)`
+in a subprocess and writing password to the subprocess' stdin.
+"""
+try:
+    import grp
+except ImportError:
+    grp = None
+import logging
+import os
+try:
+    import posix
+except ImportError:
+    posix = None
+import subprocess
+
+from plainbox.i18n import gettext as _
+from plainbox.impl.ctrl import CheckBoxDifferentialExecutionController
+
+logger = logging.getLogger("checkbox_touch.sudo_with_pass_ctrl")
+
+
+class RootViaSudoWithPassExecutionController(
+        CheckBoxDifferentialExecutionController):
+    """
+    Execution controller that gains root by using sudo, automatically
+    supplying password to the sudo process.
+
+    This controller should be used for jobs that need root in front-ends that
+    are not CLI based.
+    """
+
+    def __init__(self, provider_list, password_provider_cls):
+        """
+        Initialize a new RootViaSudoWithPassExecutionController
+
+        :param provider_list:
+            A list of Provider1 objects that will be available for script
+            dependency resolutions. Currently all of the scripts are makedirs
+            available but this will be refined to the minimal set later.
+        :param password_provider_cls:
+            A callable that will be used to obtain user's password.
+            It is called when the controller runs a sudo command.
+        """
+        super().__init__(provider_list)
+        try:
+            in_sudo_group = grp.getgrnam("sudo").gr_gid in posix.getgroups()
+        except KeyError:
+            in_sudo_group = False
+        try:
+            in_admin_group = grp.getgrnam("admin").gr_gid in posix.getgroups()
+        except KeyError:
+            in_admin_group = False
+        self.user_can_sudo = in_sudo_group or in_admin_group
+        self._password_provider = password_provider_cls
+
+    def get_execution_command(self, job, job_state, config, session_dir,
+                              nest_dir):
+        """
+        Get the command to execute the specified job
+
+        :param job:
+            job definition with the command and environment definitions
+        :param job_state:
+            The JobState associated to the job to execute.
+        :param config:
+            A PlainBoxConfig instance which can be used to load missing
+            environment definitions that apply to all jobs. It is used to
+            provide values for missing environment variables that are required
+            by the job (as expressed by the environ key in the job definition
+            file).
+        :param session_dir:
+            Base directory of the session this job will execute in.
+            This directory is used to co-locate some data that is unique to
+            this execution as well as data that is shared by all executions.
+        :param nest_dir:
+            A directory with a nest of symlinks to all executables required to
+            execute the specified job. This argument may or may not be used,
+            depending on how PATH is passed to the command (via environment or
+            via the commant line)
+        :returns:
+            List of command arguments
+        """
+        # Run env(1) as the required user
+        # --prompt is used to set sudo promp to an empty string so we don't
+        # pollute command output
+        # --reset-timestamp makes sudo ask for password even if it has been
+        # supplied recently
+        cmd = ['sudo', '--prompt=', '--reset-timestamp', '--stdin',
+               '--user', job.user, 'env']
+        # Append all environment data
+        env = self.get_differential_execution_environment(
+            job, job_state, config, session_dir, nest_dir)
+        cmd += ["{key}={value}".format(key=key, value=value)
+                for key, value in sorted(env.items())]
+        # Lastly use job.shell -c, to run our command
+        cmd += [job.shell, '-c', job.command]
+        return cmd
+
+    def execute_job(self, job, job_state, config, session_dir, extcmd_popen):
+        """
+        Execute the job using standard subprocess.Popen
+
+        :param job:
+            The JobDefinition to execute
+        :param job_state:
+            The JobState associated to the job to execute.
+        :param config:
+            A PlainBoxConfig instance which can be used to load missing
+            environment definitions that apply to all jobs. It is used to
+            provide values for missing environment variables that are required
+            by the job (as expressed by the environ key in the job definition
+            file).
+        :param session_dir:
+            Base directory of the session this job will execute in.
+            This directory is used to co-locate some data that is unique to
+            this execution as well as data that is shared by all executions.
+        :param extcmd_popen:
+            A subprocess.Popen like object - ignored
+        :returns:
+            The return code of the command, as returned by subprocess.call()
+
+        The reason behind not using extcmd_popen is that it doesn't support
+        connecting pipe to stdin of the process it spawns. And this is required
+        for running 'sudo -S'.
+        """
+        if not os.path.isdir(self.get_CHECKBOX_DATA(session_dir)):
+            os.makedirs(self.get_CHECKBOX_DATA(session_dir))
+        # Setup the executable nest directory
+        with self.configured_filesystem(job, config) as nest_dir:
+            # Get the command and the environment.
+            # of this execution controller
+            cmd = self.get_execution_command(
+                job, job_state, config, session_dir, nest_dir)
+            env = self.get_execution_environment(
+                job, job_state, config, session_dir, nest_dir)
+            with self.temporary_cwd(job, config) as cwd_dir:
+                # run the command
+                logger.debug(_("job[%s] executing %r with env %r in cwd %r"),
+                             job.id, cmd, env, cwd_dir)
+                p = subprocess.Popen(cmd, stdin=subprocess.PIPE,
+                                     env=env, cwd=cwd_dir)
+                #  sudo manpage explicitly states that \n should be appended
+                pass_bytes = bytes(self._password_provider() + '\n', 'UTF-8')
+                p.communicate(input=pass_bytes)
+                return_code = p.returncode
+                if 'noreturn' in job.get_flag_set():
+                    self._halt()
+                return return_code
+
+    def get_checkbox_score(self, job):
+        """
+        Compute how applicable this controller is for the specified job.
+
+        :returns:
+            -1 if the job does not have a user override or the user cannot use
+            sudo and 2 otherwise
+        """
+        # Only makes sense with jobs that need to run as another user
+        if job.user is not None and self.user_can_sudo:
+            return 2
+        else:
+            return -1