add support for creating initial users and groups

Added "userless" mode to cloud-init for handling the creation of the users
and the default user on Ubuntu. The end goal of this is to remove the need
for the 'ubuntu' user in the cloud images and to allow individuals to
choose the default user name.

LP: #1028503

1 files changed, 196 insertions, 0 deletions

diff --git a/cloudinit/distros/__init__.py b/cloudinit/distros/__init__.py
index 357209a4..686c6a9b 100644
--- a/cloudinit/distros/__init__.py
+++ b/cloudinit/distros/__init__.py
@@ -7,6 +7,7 @@
 #    Author: Scott Moser <scott.moser@canonical.com>
 #    Author: Juerg Haefliger <juerg.haefliger@hp.com>
 #    Author: Joshua Harlow <harlowja@yahoo-inc.com>
+#    Author: Ben Howard <ben.howard@canonical.com>
 #
 #    This program is free software: you can redistribute it and/or modify
 #    it under the terms of the GNU General Public License version 3, as
@@ -23,11 +24,14 @@
 from StringIO import StringIO
 
 import abc
+import grp
 import os
+import pwd
 import re
 
 from cloudinit import importer
 from cloudinit import log as logging
+from cloudinit import ssh_util
 from cloudinit import util
 
 # TODO(harlowja): Make this via config??
@@ -42,12 +46,32 @@ LOG = logging.getLogger(__name__)
 class Distro(object):
 
     __metaclass__ = abc.ABCMeta
+    default_user = None
 
     def __init__(self, name, cfg, paths):
         self._paths = paths
         self._cfg = cfg
         self.name = name
 
+    def add_default_user(self):
+        # Adds the distro user using the rules:
+        #  - Password is same as username but is locked
+        #  - nopasswd sudo access
+
+        user = self.get_default_user()
+        if not user:
+            raise NotImplementedError("No Default user")
+
+        self.create_user(user,
+                        plain_text_passwd=user,
+                        home="/home/%s" % user,
+                        shell="/bin/bash",
+                        lockpasswd=True,
+                        gecos="%s%s" % (user[0:1].upper(), user[1:]),
+                        sudo="ALL=(ALL) NOPASSWD:ALL")
+
+        LOG.info("Added default '%s' user with passwordless sudo", user)
+
     @abc.abstractmethod
     def install_packages(self, pkglist):
         raise NotImplementedError()
@@ -170,6 +194,178 @@ class Distro(object):
             util.logexc(LOG, "Running interface command %s failed", cmd)
             return False
 
+    def isuser(self, name):
+        try:
+            if pwd.getpwnam(name):
+                return True
+        except KeyError:
+            return False
+
+    def get_default_user(self):
+        return self.default_user
+
+    def create_user(self, name, **kwargs):
+        """
+            Creates users for the system using the GNU passwd tools. This
+            will work on an GNU system. This should be overriden on
+            distros where useradd is not desirable or not available.
+        """
+
+        adduser_cmd = ['useradd', name]
+        x_adduser_cmd = ['useradd', name]
+
+        # Since we are creating users, we want to carefully validate the
+        # inputs. If something goes wrong, we can end up with a system
+        # that nobody can login to.
+        adduser_opts = {
+                "gecos": '--comment',
+                "homedir": '--home',
+                "primarygroup": '--gid',
+                "groups": '--groups',
+                "passwd": '--password',
+                "shell": '--shell',
+                "expiredate": '--expiredate',
+                "inactive": '--inactive',
+                }
+
+        adduser_opts_flags = {
+                "nousergroup": '--no-user-group',
+                "system": '--system',
+                "nologinit": '--no-log-init',
+                "nocreatehome": "-M",
+                }
+
+        # Now check the value and create the command
+        for option in kwargs:
+            value = kwargs[option]
+            if option in adduser_opts and value \
+                and isinstance(value, str):
+                adduser_cmd.extend([adduser_opts[option], value])
+
+                # Redact the password field from the logs
+                if option != "password":
+                    x_adduser_cmd.extend([adduser_opts[option], value])
+                else:
+                    x_adduser_cmd.extend([adduser_opts[option], 'REDACTED'])
+
+            elif option in adduser_opts_flags and value:
+                adduser_cmd.append(adduser_opts_flags[option])
+                x_adduser_cmd.append(adduser_opts_flags[option])
+
+        # Default to creating home directory unless otherwise directed
+        #  Also, we do not create home directories for system users.
+        if "nocreatehome" not in kwargs and "system" not in kwargs:
+            adduser_cmd.append('-m')
+
+        # Create the user
+        if self.isuser(name):
+            LOG.warn("User %s already exists, skipping." % name)
+        else:
+            LOG.debug("Creating name %s" % name)
+            try:
+                util.subp(adduser_cmd, logstring=x_adduser_cmd)
+            except Exception as e:
+                util.logexc(LOG, "Failed to create user %s due to error.", e)
+                raise e
+
+        # Set password if plain-text password provided
+        if 'plain_text_passwd' in kwargs and kwargs['plain_text_passwd']:
+            self.set_passwd(name, kwargs['plain_text_passwd'])
+
+        # Default locking down the account.
+        if ('lockpasswd' not in kwargs and
+            ('lockpasswd' in kwargs and kwargs['lockpasswd']) or
+            'system' not in kwargs):
+            try:
+                util.subp(['passwd', '--lock', name])
+            except Exception as e:
+                util.logexc(LOG, ("Failed to disable password logins for"
+                            "user %s" % name), e)
+                raise e
+
+        # Configure sudo access
+        if 'sudo' in kwargs:
+            self.write_sudo_rules(name, kwargs['sudo'])
+
+        # Import SSH keys
+        if 'sshauthorizedkeys' in kwargs:
+            keys = set(kwargs['sshauthorizedkeys']) or []
+            ssh_util.setup_user_keys(keys, name, None, self._paths)
+
+        return True
+
+    def set_passwd(self, user, passwd, hashed=False):
+        pass_string = '%s:%s' % (user, passwd)
+        cmd = ['chpasswd']
+
+        if hashed:
+            cmd.append('--encrypted')
+
+        try:
+            util.subp(cmd, pass_string, logstring="chpasswd for %s" % user)
+        except Exception as e:
+            util.logexc(LOG, "Failed to set password for %s" % user)
+            raise e
+
+        return True
+
+    def write_sudo_rules(self,
+        user,
+        rules,
+        sudo_file="/etc/sudoers.d/90-cloud-init-users",
+        ):
+
+        content_header = "# user rules for %s" % user
+        content = "%s\n%s %s\n\n" % (content_header, user, rules)
+
+        if isinstance(rules, list):
+            content = "%s\n" % content_header
+            for rule in rules:
+                content += "%s %s\n" % (user, rule)
+            content += "\n"
+
+        if not os.path.exists(sudo_file):
+            util.write_file(sudo_file, content, 0644)
+
+        else:
+            try:
+                with open(sudo_file, 'a') as f:
+                    f.write(content)
+            except IOError as e:
+                util.logexc(LOG, "Failed to write %s" % sudo_file, e)
+                raise e
+
+    def isgroup(self, name):
+        try:
+            if grp.getgrnam(name):
+                return True
+        except:
+            return False
+
+    def create_group(self, name, members):
+        group_add_cmd = ['groupadd', name]
+
+        # Check if group exists, and then add it doesn't
+        if self.isgroup(name):
+            LOG.warn("Skipping creation of existing group '%s'" % name)
+        else:
+            try:
+                util.subp(group_add_cmd)
+                LOG.info("Created new group %s" % name)
+            except Exception as e:
+                util.logexc("Failed to create group %s" % name, e)
+
+        # Add members to the group, if so defined
+        if len(members) > 0:
+            for member in members:
+                if not self.isuser(member):
+                    LOG.warn("Unable to add group member '%s' to group '%s'"
+                            "; user does not exist." % (member, name))
+                    continue
+
+                util.subp(['usermod', '-a', '-G', name, member])
+                LOG.info("Added user '%s' to group '%s'" % (member, name))
+
 
 def _get_package_mirror_info(mirror_info, availability_zone=None,
                              mirror_filter=util.search_for_mirror):