1 /*
2 * This work is licensed under the terms of the GNU GPL, version 2 or later.
3 * See the COPYING file in the top-level directory.
4 */
5 #include "qemu/osdep.h"
6
7 #include <glib-unix.h>
8 #include <glib/gstdio.h>
9 #include <locale.h>
10 #include <pwd.h>
11
12 #include "commands-common-ssh.h"
13 #include "qapi/error.h"
14 #include "qga-qapi-commands.h"
15
16 #ifdef QGA_BUILD_UNIT_TEST
17 static struct passwd *
test_get_passwd_entry(const gchar * user_name,GError ** error)18 test_get_passwd_entry(const gchar *user_name, GError **error)
19 {
20 struct passwd *p;
21 int ret;
22
23 if (!user_name || g_strcmp0(user_name, g_get_user_name())) {
24 g_set_error(error, G_UNIX_ERROR, 0, "Invalid user name");
25 return NULL;
26 }
27
28 p = g_new0(struct passwd, 1);
29 p->pw_dir = (char *)g_get_home_dir();
30 p->pw_uid = geteuid();
31 p->pw_gid = getegid();
32
33 ret = g_mkdir_with_parents(p->pw_dir, 0700);
34 g_assert(ret == 0);
35
36 return p;
37 }
38
39 #define g_unix_get_passwd_entry(username, err) \
40 test_get_passwd_entry(username, err)
41 #endif
42
43 static struct passwd *
get_passwd_entry(const char * username,Error ** errp)44 get_passwd_entry(const char *username, Error **errp)
45 {
46 g_autoptr(GError) err = NULL;
47 struct passwd *p;
48
49 p = g_unix_get_passwd_entry(username, &err);
50 if (p == NULL) {
51 error_setg(errp, "failed to lookup user '%s': %s",
52 username, err->message);
53 return NULL;
54 }
55
56 return p;
57 }
58
59 static bool
mkdir_for_user(const char * path,const struct passwd * p,mode_t mode,Error ** errp)60 mkdir_for_user(const char *path, const struct passwd *p,
61 mode_t mode, Error **errp)
62 {
63 if (g_mkdir(path, mode) == -1) {
64 error_setg(errp, "failed to create directory '%s': %s",
65 path, g_strerror(errno));
66 return false;
67 }
68
69 if (chown(path, p->pw_uid, p->pw_gid) == -1) {
70 error_setg(errp, "failed to set ownership of directory '%s': %s",
71 path, g_strerror(errno));
72 return false;
73 }
74
75 if (chmod(path, mode) == -1) {
76 error_setg(errp, "failed to set permissions of directory '%s': %s",
77 path, g_strerror(errno));
78 return false;
79 }
80
81 return true;
82 }
83
84 static bool
write_authkeys(const char * path,const GStrv keys,const struct passwd * p,Error ** errp)85 write_authkeys(const char *path, const GStrv keys,
86 const struct passwd *p, Error **errp)
87 {
88 g_autofree char *contents = NULL;
89 g_autoptr(GError) err = NULL;
90
91 contents = g_strjoinv("\n", keys);
92 if (!g_file_set_contents(path, contents, -1, &err)) {
93 error_setg(errp, "failed to write to '%s': %s", path, err->message);
94 return false;
95 }
96
97 if (chown(path, p->pw_uid, p->pw_gid) == -1) {
98 error_setg(errp, "failed to set ownership of directory '%s': %s",
99 path, g_strerror(errno));
100 return false;
101 }
102
103 if (chmod(path, 0600) == -1) {
104 error_setg(errp, "failed to set permissions of '%s': %s",
105 path, g_strerror(errno));
106 return false;
107 }
108
109 return true;
110 }
111
112 void
qmp_guest_ssh_add_authorized_keys(const char * username,strList * keys,bool has_reset,bool reset,Error ** errp)113 qmp_guest_ssh_add_authorized_keys(const char *username, strList *keys,
114 bool has_reset, bool reset,
115 Error **errp)
116 {
117 g_autofree struct passwd *p = NULL;
118 g_autofree char *ssh_path = NULL;
119 g_autofree char *authkeys_path = NULL;
120 g_auto(GStrv) authkeys = NULL;
121 strList *k;
122 size_t nkeys, nauthkeys;
123
124 reset = has_reset && reset;
125
126 if (!check_openssh_pub_keys(keys, &nkeys, errp)) {
127 return;
128 }
129
130 p = get_passwd_entry(username, errp);
131 if (p == NULL) {
132 return;
133 }
134
135 ssh_path = g_build_filename(p->pw_dir, ".ssh", NULL);
136 authkeys_path = g_build_filename(ssh_path, "authorized_keys", NULL);
137
138 if (!reset) {
139 authkeys = read_authkeys(authkeys_path, NULL);
140 }
141 if (authkeys == NULL) {
142 if (!g_file_test(ssh_path, G_FILE_TEST_IS_DIR) &&
143 !mkdir_for_user(ssh_path, p, 0700, errp)) {
144 return;
145 }
146 }
147
148 nauthkeys = authkeys ? g_strv_length(authkeys) : 0;
149 authkeys = g_realloc_n(authkeys, nauthkeys + nkeys + 1, sizeof(char *));
150 memset(authkeys + nauthkeys, 0, (nkeys + 1) * sizeof(char *));
151
152 for (k = keys; k != NULL; k = k->next) {
153 if (g_strv_contains((const gchar * const *)authkeys, k->value)) {
154 continue;
155 }
156 authkeys[nauthkeys++] = g_strdup(k->value);
157 }
158
159 write_authkeys(authkeys_path, authkeys, p, errp);
160 }
161
162 void
qmp_guest_ssh_remove_authorized_keys(const char * username,strList * keys,Error ** errp)163 qmp_guest_ssh_remove_authorized_keys(const char *username, strList *keys,
164 Error **errp)
165 {
166 g_autofree struct passwd *p = NULL;
167 g_autofree char *authkeys_path = NULL;
168 g_autofree GStrv new_keys = NULL; /* do not own the strings */
169 g_auto(GStrv) authkeys = NULL;
170 GStrv a;
171 size_t nkeys = 0;
172
173 if (!check_openssh_pub_keys(keys, NULL, errp)) {
174 return;
175 }
176
177 p = get_passwd_entry(username, errp);
178 if (p == NULL) {
179 return;
180 }
181
182 authkeys_path = g_build_filename(p->pw_dir, ".ssh",
183 "authorized_keys", NULL);
184 if (!g_file_test(authkeys_path, G_FILE_TEST_EXISTS)) {
185 return;
186 }
187 authkeys = read_authkeys(authkeys_path, errp);
188 if (authkeys == NULL) {
189 return;
190 }
191
192 new_keys = g_new0(char *, g_strv_length(authkeys) + 1);
193 for (a = authkeys; *a != NULL; a++) {
194 strList *k;
195
196 for (k = keys; k != NULL; k = k->next) {
197 if (g_str_equal(k->value, *a)) {
198 break;
199 }
200 }
201 if (k != NULL) {
202 continue;
203 }
204
205 new_keys[nkeys++] = *a;
206 }
207
208 write_authkeys(authkeys_path, new_keys, p, errp);
209 }
210
211 GuestAuthorizedKeys *
qmp_guest_ssh_get_authorized_keys(const char * username,Error ** errp)212 qmp_guest_ssh_get_authorized_keys(const char *username, Error **errp)
213 {
214 g_autofree struct passwd *p = NULL;
215 g_autofree char *authkeys_path = NULL;
216 g_auto(GStrv) authkeys = NULL;
217 g_autoptr(GuestAuthorizedKeys) ret = NULL;
218 int i;
219
220 p = get_passwd_entry(username, errp);
221 if (p == NULL) {
222 return NULL;
223 }
224
225 authkeys_path = g_build_filename(p->pw_dir, ".ssh",
226 "authorized_keys", NULL);
227 authkeys = read_authkeys(authkeys_path, errp);
228 if (authkeys == NULL) {
229 return NULL;
230 }
231
232 ret = g_new0(GuestAuthorizedKeys, 1);
233 for (i = 0; authkeys[i] != NULL; i++) {
234 g_strstrip(authkeys[i]);
235 if (!authkeys[i][0] || authkeys[i][0] == '#') {
236 continue;
237 }
238
239 QAPI_LIST_PREPEND(ret->keys, g_strdup(authkeys[i]));
240 }
241
242 return g_steal_pointer(&ret);
243 }
244
245 #ifdef QGA_BUILD_UNIT_TEST
246 static const strList test_key2 = {
247 .value = (char *)"algo key2 comments"
248 };
249
250 static const strList test_key1_2 = {
251 .value = (char *)"algo key1 comments",
252 .next = (strList *)&test_key2,
253 };
254
255 static char *
test_get_authorized_keys_path(void)256 test_get_authorized_keys_path(void)
257 {
258 return g_build_filename(g_get_home_dir(), ".ssh", "authorized_keys", NULL);
259 }
260
261 static void
test_authorized_keys_set(const char * contents)262 test_authorized_keys_set(const char *contents)
263 {
264 g_autoptr(GError) err = NULL;
265 g_autofree char *path = NULL;
266 int ret;
267
268 path = g_build_filename(g_get_home_dir(), ".ssh", NULL);
269 ret = g_mkdir_with_parents(path, 0700);
270 g_assert(ret == 0);
271 g_free(path);
272
273 path = test_get_authorized_keys_path();
274 g_file_set_contents(path, contents, -1, &err);
275 g_assert(err == NULL);
276 }
277
278 static void
test_authorized_keys_equal(const char * expected)279 test_authorized_keys_equal(const char *expected)
280 {
281 g_autoptr(GError) err = NULL;
282 g_autofree char *path = NULL;
283 g_autofree char *contents = NULL;
284
285 path = test_get_authorized_keys_path();
286 g_file_get_contents(path, &contents, NULL, &err);
287 g_assert(err == NULL);
288
289 g_assert(g_strcmp0(contents, expected) == 0);
290 }
291
292 static void
test_invalid_user(void)293 test_invalid_user(void)
294 {
295 Error *err = NULL;
296
297 qmp_guest_ssh_add_authorized_keys("", NULL, FALSE, FALSE, &err);
298 error_free_or_abort(&err);
299
300 qmp_guest_ssh_remove_authorized_keys("", NULL, &err);
301 error_free_or_abort(&err);
302 }
303
304 static void
test_invalid_key(void)305 test_invalid_key(void)
306 {
307 strList key = {
308 .value = (char *)"not a valid\nkey"
309 };
310 Error *err = NULL;
311
312 qmp_guest_ssh_add_authorized_keys(g_get_user_name(), &key,
313 FALSE, FALSE, &err);
314 error_free_or_abort(&err);
315
316 qmp_guest_ssh_remove_authorized_keys(g_get_user_name(), &key, &err);
317 error_free_or_abort(&err);
318 }
319
320 static void
test_add_keys(void)321 test_add_keys(void)
322 {
323 Error *err = NULL;
324
325 qmp_guest_ssh_add_authorized_keys(g_get_user_name(),
326 (strList *)&test_key2,
327 FALSE, FALSE,
328 &err);
329 g_assert(err == NULL);
330
331 test_authorized_keys_equal("algo key2 comments");
332
333 qmp_guest_ssh_add_authorized_keys(g_get_user_name(),
334 (strList *)&test_key1_2,
335 FALSE, FALSE,
336 &err);
337 g_assert(err == NULL);
338
339 /* key2 came first, and shouldn't be duplicated */
340 test_authorized_keys_equal("algo key2 comments\n"
341 "algo key1 comments");
342 }
343
344 static void
test_add_reset_keys(void)345 test_add_reset_keys(void)
346 {
347 Error *err = NULL;
348
349 qmp_guest_ssh_add_authorized_keys(g_get_user_name(),
350 (strList *)&test_key1_2,
351 FALSE, FALSE,
352 &err);
353 g_assert(err == NULL);
354
355 /* reset with key2 only */
356 test_authorized_keys_equal("algo key1 comments\n"
357 "algo key2 comments");
358
359 qmp_guest_ssh_add_authorized_keys(g_get_user_name(),
360 (strList *)&test_key2,
361 TRUE, TRUE,
362 &err);
363 g_assert(err == NULL);
364
365 test_authorized_keys_equal("algo key2 comments");
366
367 /* empty should clear file */
368 qmp_guest_ssh_add_authorized_keys(g_get_user_name(),
369 (strList *)NULL,
370 TRUE, TRUE,
371 &err);
372 g_assert(err == NULL);
373
374 test_authorized_keys_equal("");
375 }
376
377 static void
test_remove_keys(void)378 test_remove_keys(void)
379 {
380 Error *err = NULL;
381 static const char *authkeys =
382 "algo key1 comments\n"
383 /* originally duplicated */
384 "algo key1 comments\n"
385 "# a commented line\n"
386 "algo some-key another\n";
387
388 test_authorized_keys_set(authkeys);
389 qmp_guest_ssh_remove_authorized_keys(g_get_user_name(),
390 (strList *)&test_key2, &err);
391 g_assert(err == NULL);
392 test_authorized_keys_equal(authkeys);
393
394 qmp_guest_ssh_remove_authorized_keys(g_get_user_name(),
395 (strList *)&test_key1_2, &err);
396 g_assert(err == NULL);
397 test_authorized_keys_equal("# a commented line\n"
398 "algo some-key another\n");
399 }
400
401 static void
test_get_keys(void)402 test_get_keys(void)
403 {
404 Error *err = NULL;
405 static const char *authkeys =
406 "algo key1 comments\n"
407 "# a commented line\n"
408 "algo some-key another\n";
409 g_autoptr(GuestAuthorizedKeys) ret = NULL;
410 strList *k;
411 size_t len = 0;
412
413 test_authorized_keys_set(authkeys);
414
415 ret = qmp_guest_ssh_get_authorized_keys(g_get_user_name(), &err);
416 g_assert(err == NULL);
417
418 for (len = 0, k = ret->keys; k != NULL; k = k->next) {
419 g_assert(g_str_has_prefix(k->value, "algo "));
420 len++;
421 }
422
423 g_assert(len == 2);
424 }
425
main(int argc,char * argv[])426 int main(int argc, char *argv[])
427 {
428 setlocale(LC_ALL, "");
429
430 g_test_init(&argc, &argv, G_TEST_OPTION_ISOLATE_DIRS, NULL);
431
432 g_test_add_func("/qga/ssh/invalid_user", test_invalid_user);
433 g_test_add_func("/qga/ssh/invalid_key", test_invalid_key);
434 g_test_add_func("/qga/ssh/add_keys", test_add_keys);
435 g_test_add_func("/qga/ssh/add_reset_keys", test_add_reset_keys);
436 g_test_add_func("/qga/ssh/remove_keys", test_remove_keys);
437 g_test_add_func("/qga/ssh/get_keys", test_get_keys);
438
439 return g_test_run();
440 }
441 #endif /* BUILD_UNIT_TEST */
442