src/ask-password/ask-password.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   This file is part of systemd.
   4
   5   Copyright 2010 Lennart Poettering
   6
   7   systemd is free software; you can redistribute it and/or modify it
   8   under the terms of the GNU Lesser General Public License as published by
   9   the Free Software Foundation; either version 2.1 of the License, or
  10   (at your option) any later version.
  11
  12   systemd is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   Lesser General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  19 ***/
  20
  21 #include <errno.h>
  22 #include <getopt.h>
  23 #include <stddef.h>
  24 #include <unistd.h>
  25
  26 #include "ask-password-api.h"
  27 #include "def.h"
  28 #include "log.h"
  29 #include "macro.h"
  30 #include "strv.h"
  31
  32 static const char *arg_icon = NULL;
  33 static const char *arg_id = NULL;
  34 static const char *arg_keyname = NULL;
  35 static char *arg_message = NULL;
  36 static usec_t arg_timeout = DEFAULT_TIMEOUT_USEC;
  37 static bool arg_multiple = false;
  38 static bool arg_no_output = false;
  39 static AskPasswordFlags arg_flags = ASK_PASSWORD_PUSH_CACHE;
  40
  41 static void help(void) {
  42         printf("%s [OPTIONS...] MESSAGE\n\n"
  43                "Query the user for a system passphrase, via the TTY or an UI agent.\n\n"
  44                "  -h --help           Show this help\n"
  45                "     --icon=NAME      Icon name\n"
  46                "     --id=ID          Query identifier (e.g. \"cryptsetup:/dev/sda5\")\n"
  47                "     --keyname=NAME   Kernel key name for caching passwords (e.g. \"cryptsetup\")\n"
  48                "     --timeout=SEC    Timeout in seconds\n"
  49                "     --echo           Do not mask input (useful for usernames)\n"
  50                "     --no-tty         Ask question via agent even on TTY\n"
  51                "     --accept-cached  Accept cached passwords\n"
  52                "     --multiple       List multiple passwords if available\n"
  53                "     --no-output      Do not print password to standard output\n"
  54                , program_invocation_short_name);
  55 }
  56
  57 static int parse_argv(int argc, char *argv[]) {
  58
  59         enum {
  60                 ARG_ICON = 0x100,
  61                 ARG_TIMEOUT,
  62                 ARG_ECHO,
  63                 ARG_NO_TTY,
  64                 ARG_ACCEPT_CACHED,
  65                 ARG_MULTIPLE,
  66                 ARG_ID,
  67                 ARG_KEYNAME,
  68                 ARG_NO_OUTPUT,
  69         };
  70
  71         static const struct option options[] = {
  72                 { "help",          no_argument,       NULL, 'h'               },
  73                 { "icon",          required_argument, NULL, ARG_ICON          },
  74                 { "timeout",       required_argument, NULL, ARG_TIMEOUT       },
  75                 { "echo",          no_argument,       NULL, ARG_ECHO          },
  76                 { "no-tty",        no_argument,       NULL, ARG_NO_TTY        },
  77                 { "accept-cached", no_argument,       NULL, ARG_ACCEPT_CACHED },
  78                 { "multiple",      no_argument,       NULL, ARG_MULTIPLE      },
  79                 { "id",            required_argument, NULL, ARG_ID            },
  80                 { "keyname",       required_argument, NULL, ARG_KEYNAME       },
  81                 { "no-output",     no_argument,       NULL, ARG_NO_OUTPUT     },
  82                 {}
  83         };
  84
  85         int c;
  86
  87         assert(argc >= 0);
  88         assert(argv);
  89
  90         while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0)
  91
  92                 switch (c) {
  93
  94                 case 'h':
  95                         help();
  96                         return 0;
  97
  98                 case ARG_ICON:
  99                         arg_icon = optarg;
 100                         break;
 101
 102                 case ARG_TIMEOUT:
 103                         if (parse_sec(optarg, &arg_timeout) < 0) {
 104                                 log_error("Failed to parse --timeout parameter %s", optarg);
 105                                 return -EINVAL;
 106                         }
 107                         break;
 108
 109                 case ARG_ECHO:
 110                         arg_flags |= ASK_PASSWORD_ECHO;
 111                         break;
 112
 113                 case ARG_NO_TTY:
 114                         arg_flags |= ASK_PASSWORD_NO_TTY;
 115                         break;
 116
 117                 case ARG_ACCEPT_CACHED:
 118                         arg_flags |= ASK_PASSWORD_ACCEPT_CACHED;
 119                         break;
 120
 121                 case ARG_MULTIPLE:
 122                         arg_multiple = true;
 123                         break;
 124
 125                 case ARG_ID:
 126                         arg_id = optarg;
 127                         break;
 128
 129                 case ARG_KEYNAME:
 130                         arg_keyname = optarg;
 131                         break;
 132
 133                 case ARG_NO_OUTPUT:
 134                         arg_no_output = true;
 135                         break;
 136
 137                 case '?':
 138                         return -EINVAL;
 139
 140                 default:
 141                         assert_not_reached("Unhandled option");
 142                 }
 143
 144         if (argc > optind) {
 145                 arg_message = strv_join(argv + optind, " ");
 146                 if (!arg_message)
 147                         return log_oom();
 148         }
 149
 150         return 1;
 151 }
 152
 153 int main(int argc, char *argv[]) {
 154         _cleanup_strv_free_erase_ char **l = NULL;
 155         usec_t timeout;
 156         char **p;
 157         int r;
 158
 159         log_parse_environment();
 160         log_open();
 161
 162         r = parse_argv(argc, argv);
 163         if (r <= 0)
 164                 goto finish;
 165
 166         if (arg_timeout > 0)
 167                 timeout = now(CLOCK_MONOTONIC) + arg_timeout;
 168         else
 169                 timeout = 0;
 170
 171         r = ask_password_auto(arg_message, arg_icon, arg_id, arg_keyname, timeout, arg_flags, &l);
 172         if (r < 0) {
 173                 log_error_errno(r, "Failed to query password: %m");
 174                 goto finish;
 175         }
 176
 177         STRV_FOREACH(p, l) {
 178                 if (!arg_no_output)
 179                         puts(*p);
 180
 181                 if (!arg_multiple)
 182                         break;
 183         }
 184
 185 finish:
 186         free(arg_message);
 187
 188         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
 189 }