pam_vbox.cpp@ 106945

Last change on this file since 106945 was 106061, checked in by vboxsync, 3 months ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 30.3 KB

Line
1	/* $Id: pam_vbox.cpp 106061 2024-09-16 14:03:52Z vboxsync $ */
2	/** @file
3	* pam_vbox - PAM module for auto logons.
4	*/
5
6	/*
7	* Copyright (C) 2008-2024 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	#define PAM_SM_AUTH
33	#define PAM_SM_ACCOUNT
34	#define PAM_SM_PASSWORD
35	#define PAM_SM_SESSION
36
37	#ifdef DEBUG
38	# define PAM_DEBUG
39	#endif
40
41	#include <security/pam_appl.h>
42	#ifdef RT_OS_LINUX
43	# include <security/_pam_macros.h>
44	#endif
45
46	#include <pwd.h>
47	#include <syslog.h>
48	#include <stdlib.h>
49
50	#include <iprt/assert.h>
51	#include <iprt/buildconfig.h>
52	#include <iprt/err.h>
53	#include <iprt/env.h>
54	#include <iprt/initterm.h>
55	#include <iprt/mem.h>
56	#include <iprt/stream.h>
57	#include <iprt/string.h>
58	#include <iprt/thread.h>
59	#include <iprt/time.h>
60
61	#include <VBox/VBoxGuestLib.h>
62
63	#include <VBox/log.h>
64	#include <VBox/HostServices/GuestPropertySvc.h>
65
66	#define VBOX_MODULE_NAME "pam_vbox"
67
68	#define VBOX_PAM_FLAG_SILENT "PAM_SILENT"
69	#define VBOX_PAM_FLAG_DISALLOW_NULL_AUTHTOK "PAM_DISALLOW_NULL_AUTHTOK"
70	#define VBOX_PAM_FLAG_ESTABLISH_CRED "PAM_ESTABLISH_CRED"
71	#define VBOX_PAM_FLAG_DELETE_CRED "PAM_DELETE_CRED"
72	#define VBOX_PAM_FLAG_REINITIALIZE_CRED "PAM_REINITIALIZE_CRED"
73	#define VBOX_PAM_FLAG_REFRESH_CRED "PAM_REFRESH_CRED"
74
75	RT_C_DECLS_BEGIN
76	DECLEXPORT(int) pam_sm_authenticate(pam_handle_t hPAM, int iFlags, int argc, const char *argv);
77	DECLEXPORT(int) pam_sm_setcred(pam_handle_t hPAM, int iFlags, int argc, const char *argv);
78	DECLEXPORT(int) pam_sm_acct_mgmt(pam_handle_t hPAM, int iFlags, int argc, const char *argv);
79	DECLEXPORT(int) pam_sm_open_session(pam_handle_t hPAM, int iFlags, int argc, const char *argv);
80	DECLEXPORT(int) pam_sm_close_session(pam_handle_t hPAM, int iFlags, int argc, const char *argv);
81	DECLEXPORT(int) pam_sm_chauthtok(pam_handle_t hPAM, int iFlags, int argc, const char *argv);
82	RT_C_DECLS_END
83
84	/** For debugging. */
85	#ifdef DEBUG
86	static pam_handle_t *g_pam_handle;
87	static int g_verbosity = 99;
88	#else
89	static int g_verbosity = 0;
90	#endif
91
92	/**
93	* User-provided thread data for the credentials waiting thread.
94	*/
95	typedef struct PAMVBOXTHREAD
96	{
97	/** The PAM handle. */
98	pam_handle_t *hPAM;
99	/** The timeout (in ms) to wait for credentials. */
100	uint32_t uTimeoutMS;
101	/** The overall result of the thread operation. */
102	int rc;
103	} PAMVBOXTHREAD, *PPAMVBOXTHREAD;
104
105	/**
106	* Write to system log.
107	*
108	* @param pszBuf Buffer to write to the log (NULL-terminated)
109	*/
110	static void pam_vbox_writesyslog(char *pszBuf)
111	{
112	#ifdef RT_OS_LINUX
113	openlog("pam_vbox", LOG_PID, LOG_AUTHPRIV);
114	syslog(LOG_ERR, "%s", pszBuf);
115	closelog();
116	#elif defined(RT_OS_SOLARIS)
117	syslog(LOG_ERR, "pam_vbox: %s\n", pszBuf);
118	#endif
119	}
120
121
122	/**
123	* Displays an error message.
124	*
125	* @param hPAM PAM handle.
126	* @param pszFormat The message text.
127	* @param ... Format arguments.
128	*/
129	static void pam_vbox_error(pam_handle_t hPAM, const char pszFormat, ...)
130	{
131	RT_NOREF1(hPAM);
132	va_list va;
133	char *buf;
134	va_start(va, pszFormat);
135	if (RT_SUCCESS(RTStrAPrintfV(&buf, pszFormat, va)))
136	{
137	LogRel(("%s: Error: %s", VBOX_MODULE_NAME, buf));
138	pam_vbox_writesyslog(buf);
139	RTStrFree(buf);
140	}
141	va_end(va);
142	}
143
144
145	/**
146	* Displays a debug message.
147	*
148	* @param hPAM PAM handle.
149	* @param pszFormat The message text.
150	* @param ... Format arguments.
151	*/
152	static void pam_vbox_log(pam_handle_t hPAM, const char pszFormat, ...)
153	{
154	RT_NOREF1(hPAM);
155	if (g_verbosity)
156	{
157	va_list va;
158	char *buf;
159	va_start(va, pszFormat);
160	if (RT_SUCCESS(RTStrAPrintfV(&buf, pszFormat, va)))
161	{
162	/* Only do normal logging in debug mode; could contain
163	* sensitive data! */
164	LogRel(("%s: %s", VBOX_MODULE_NAME, buf));
165	/* Log to syslog */
166	pam_vbox_writesyslog(buf);
167	RTStrFree(buf);
168	}
169	va_end(va);
170	}
171	}
172
173
174	/**
175	* Sets a message using PAM's conversation function.
176	*
177	* @return IPRT status code.
178	* @param hPAM PAM handle.
179	* @param iStyle Style of message (0 = Information, 1 = Prompt
180	* echo off, 2 = Prompt echo on, 3 = Error).
181	* @param pszText Message text to set.
182	*/
183	static int vbox_set_msg(pam_handle_t hPAM, int iStyle, const char pszText)
184	{
185	AssertPtrReturn(hPAM, VERR_INVALID_POINTER);
186	AssertPtrReturn(pszText, VERR_INVALID_POINTER);
187
188	if (!iStyle)
189	iStyle = PAM_TEXT_INFO;
190
191	int rc = VINF_SUCCESS;
192
193	pam_message msg;
194	msg.msg_style = iStyle;
195	#ifdef RT_OS_SOLARIS
196	msg.msg = (char*)pszText;
197	#else
198	msg.msg = pszText;
199	#endif
200
201	#ifdef RT_OS_SOLARIS
202	pam_conv *conv = NULL;
203	int pamrc = pam_get_item(hPAM, PAM_CONV, (void **)&conv);
204	#else
205	const pam_conv *conv = NULL;
206	int pamrc = pam_get_item(hPAM, PAM_CONV, (const void **)&conv);
207	#endif
208	if ( pamrc == PAM_SUCCESS
209	&& conv)
210	{
211	pam_response *resp = NULL;
212	#ifdef RT_OS_SOLARIS
213	pam_message *msg_p = &msg;
214	#else
215	const pam_message *msg_p = &msg;
216	#endif
217	pam_vbox_log(hPAM, "Showing message \"%s\" (type %d)", pszText, iStyle);
218
219	pamrc = conv->conv(1 /* One message only */, &msg_p, &resp, conv->appdata_ptr);
220	if (resp != NULL) /* If we use PAM_TEXT_INFO we never will get something back! */
221	{
222	if (resp->resp)
223	{
224	pam_vbox_log(hPAM, "Response to message \"%s\" was \"%s\"",
225	pszText, resp->resp);
226	/** @todo Save response! */
227	free(resp->resp);
228	}
229	free(resp);
230	}
231	}
232	else
233	rc = VERR_NOT_FOUND;
234	return rc;
235	}
236
237
238	/**
239	* Initializes pam_vbox.
240	*
241	* @return IPRT status code.
242	* @param hPAM PAM handle.
243	*/
244	static int pam_vbox_init(pam_handle_t *hPAM)
245	{
246	#ifdef DEBUG
247	g_pam_handle = hPAM; /* hack for getting assertion text */
248	#endif
249
250	/* Don't make assertions panic because the PAM stack +
251	* the current logon module won't work anymore (or just restart).
252	* This could result in not able to log into the system anymore. */
253	RTAssertSetMayPanic(false);
254
255	pam_vbox_log(hPAM, "pam_vbox: %sr%s, running on %s\n",
256	RTBldCfgVersion(), RTBldCfgRevisionStr(), RTBldCfgTargetArch());
257
258	int rc = RTR3InitDll(0);
259	if (RT_FAILURE(rc))
260	{
261	pam_vbox_error(hPAM, "pam_vbox_init: could not init runtime! rc=%Rrc. Aborting\n", rc);
262	return PAM_SUCCESS; /* Jump out as early as we can to not mess around. */
263	}
264
265	pam_vbox_log(hPAM, "pam_vbox_init: runtime initialized\n");
266	if (RT_SUCCESS(rc))
267	{
268	rc = VbglR3InitUser();
269	if (RT_FAILURE(rc))
270	{
271	switch(rc)
272	{
273	case VERR_ACCESS_DENIED:
274	pam_vbox_error(hPAM, "pam_vbox_init: access is denied to guest driver! Please make sure you run with sufficient rights. Aborting\n");
275	break;
276
277	case VERR_FILE_NOT_FOUND:
278	pam_vbox_error(hPAM, "pam_vbox_init: guest driver not found! Guest Additions installed? Aborting\n");
279	break;
280
281	default:
282	pam_vbox_error(hPAM, "pam_vbox_init: could not init VbglR3 library! rc=%Rrc. Aborting\n", rc);
283	break;
284	}
285	}
286	pam_vbox_log(hPAM, "pam_vbox_init: guest lib initialized\n");
287	}
288
289	if (RT_SUCCESS(rc))
290	{
291	char *rhost = NULL;
292	char *tty = NULL;
293	char *prompt = NULL;
294	#ifdef RT_OS_SOLARIS
295	pam_get_item(hPAM, PAM_RHOST, (void**) &rhost);
296	pam_get_item(hPAM, PAM_TTY, (void**) &tty);
297	pam_get_item(hPAM, PAM_USER_PROMPT, (void**) &prompt);
298	#else
299	pam_get_item(hPAM, PAM_RHOST, (const void**) &rhost);
300	pam_get_item(hPAM, PAM_TTY, (const void**) &tty);
301	pam_get_item(hPAM, PAM_USER_PROMPT, (const void**) &prompt);
302	#endif
303	pam_vbox_log(hPAM, "pam_vbox_init: rhost=%s, tty=%s, prompt=%s\n",
304	rhost ? rhost : "<none>", tty ? tty : "<none>", prompt ? prompt : "<none>");
305	}
306
307	return rc;
308	}
309
310
311	/**
312	* Shuts down pam_vbox.
313	*
314	* @param hPAM PAM handle.
315	*/
316	static void pam_vbox_shutdown(pam_handle_t *hPAM)
317	{
318	RT_NOREF1(hPAM);
319	VbglR3Term();
320	}
321
322
323	/**
324	* Checks for credentials provided by the host / HGCM.
325	*
326	* @return IPRT status code. VERR_NOT_FOUND if no credentials are available,
327	* VINF_SUCCESS on successful retrieval or another IPRT error.
328	* @param hPAM PAM handle.
329	*/
330	static int pam_vbox_check_creds(pam_handle_t *hPAM)
331	{
332	int rc = VbglR3CredentialsQueryAvailability();
333	if (RT_FAILURE(rc))
334	{
335	if (rc != VERR_NOT_FOUND)
336	pam_vbox_error(hPAM, "pam_vbox_check_creds: could not query for credentials! rc=%Rrc. Aborting\n", rc);
337	#ifdef DEBUG
338	else
339	pam_vbox_log(hPAM, "pam_vbox_check_creds: no credentials available\n");
340	#endif
341	}
342	else
343	{
344	char *pszUsername;
345	char *pszPassword;
346	char *pszDomain;
347
348	rc = VbglR3CredentialsRetrieve(&pszUsername, &pszPassword, &pszDomain);
349	if (RT_FAILURE(rc))
350	{
351	pam_vbox_error(hPAM, "pam_vbox_check_creds: could not retrieve credentials! rc=%Rrc. Aborting\n", rc);
352	}
353	else
354	{
355	#ifdef DEBUG
356	pam_vbox_log(hPAM, "pam_vbox_check_creds: credentials retrieved: user=%s, password=%s, domain=%s\n",
357	pszUsername, pszPassword, pszDomain);
358	#else
359	/* Don't log passwords in release mode! */
360	pam_vbox_log(hPAM, "pam_vbox_check_creds: credentials retrieved: user=%s, password=XXX, domain=%s\n",
361	pszUsername, pszDomain);
362	#endif
363	/* Fill credentials into PAM. */
364	int pamrc = pam_set_item(hPAM, PAM_USER, pszUsername);
365	if (pamrc != PAM_SUCCESS)
366	{
367	pam_vbox_error(hPAM, "pam_vbox_check_creds: could not set user name! pamrc=%d, msg=%s. Aborting\n",
368	pamrc, pam_strerror(hPAM, pamrc));
369	}
370	else
371	{
372	pamrc = pam_set_item(hPAM, PAM_AUTHTOK, pszPassword);
373	if (pamrc != PAM_SUCCESS)
374	pam_vbox_error(hPAM, "pam_vbox_check_creds: could not set password! pamrc=%d, msg=%s. Aborting\n",
375	pamrc, pam_strerror(hPAM, pamrc));
376
377	}
378	/** @todo Add handling domains as well. */
379	VbglR3CredentialsDestroy(pszUsername, pszPassword, pszDomain,
380	3 /* Three wipe passes */);
381	pam_vbox_log(hPAM, "pam_vbox_check_creds: returned with pamrc=%d, msg=%s\n",
382	pamrc, pam_strerror(hPAM, pamrc));
383	}
384	}
385
386	#ifdef DEBUG
387	pam_vbox_log(hPAM, "pam_vbox_check_creds: returned with rc=%Rrc\n", rc);
388	#endif
389	return rc;
390	}
391
392	/**
393	* Reads a guest property.
394	*
395	* @return IPRT status code.
396	* @param hPAM PAM handle.
397	* @param uClientID Guest property service client ID.
398	* @param pszKey Key (name) of guest property to read.
399	* @param fReadOnly Indicates whether this key needs to be
400	* checked if it only can be read (and not written)
401	* by the guest.
402	* @param pszValue Buffer where to store the key's value.
403	* @param cbValue Size of buffer (in bytes).
404	*/
405	static int pam_vbox_read_prop(pam_handle_t *hPAM, uint32_t uClientID,
406	const char *pszKey, bool fReadOnly,
407	char *pszValue, size_t cbValue)
408	{
409	AssertPtrReturn(hPAM, VERR_INVALID_POINTER);
410	AssertReturn(uClientID, VERR_INVALID_PARAMETER);
411	AssertPtrReturn(pszKey, VERR_INVALID_POINTER);
412	AssertPtrReturn(pszValue, VERR_INVALID_POINTER);
413
414	int rc;
415
416	uint64_t u64Timestamp = 0;
417	char *pszValTemp;
418	char *pszFlags = NULL;
419	/* The buffer for storing the data and its initial size. We leave a bit
420	* of space here in case the maximum values are raised. */
421	void *pvBuf = NULL;
422	uint32_t cbBuf = GUEST_PROP_MAX_VALUE_LEN + GUEST_PROP_MAX_FLAGS_LEN + _1K;
423
424	/* Because there is a race condition between our reading the size of a
425	* property and the guest updating it, we loop a few times here and
426	* hope. Actually this should never go wrong, as we are generous
427	* enough with buffer space. */
428	for (unsigned i = 0; ; i++)
429	{
430	void *pvTmpBuf = RTMemRealloc(pvBuf, cbBuf);
431	if (pvTmpBuf)
432	{
433	pvBuf = pvTmpBuf;
434	rc = VbglR3GuestPropRead(uClientID, pszKey, pvBuf, cbBuf,
435	&pszValTemp, &u64Timestamp, &pszFlags,
436	&cbBuf);
437	if (rc == VERR_BUFFER_OVERFLOW && i < 10)
438	{
439	/* Buffer too small, try it with a bigger one next time. */
440	cbBuf += _1K;
441	continue; /* Try next round. */
442	}
443	}
444	else
445	rc = VERR_NO_MEMORY;
446	break; /* Everything except VERR_BUFFER_OVERFLOW makes us bail out ... */
447	}
448
449	if (RT_SUCCESS(rc))
450	{
451	/* Check security bits. */
452	if (pszFlags)
453	{
454	if ( fReadOnly
455	&& !RTStrStr(pszFlags, "RDONLYGUEST"))
456	{
457	/* If we want a property which is read-only on the guest
458	* and it is not marked as such, deny access! */
459	pam_vbox_error(hPAM, "pam_vbox_read_prop: key \"%s\" should be read-only on guest but it is not\n", pszKey);
460	rc = VERR_ACCESS_DENIED;
461	}
462	}
463	else /* No flags, no access! */
464	{
465	pam_vbox_error(hPAM, "pam_vbox_read_prop: key \"%s\" contains no/wrong flags (%s)\n", pszKey, pszFlags);
466	rc = VERR_ACCESS_DENIED;
467	}
468
469	if (RT_SUCCESS(rc))
470	{
471	/* If everything went well copy property value to our destination buffer. */
472	if (!RTStrPrintf(pszValue, cbValue, "%s", pszValTemp))
473	{
474	pam_vbox_error(hPAM, "pam_vbox_read_prop: could not store value of key \"%s\"\n", pszKey);
475	rc = VERR_INVALID_PARAMETER;
476	}
477
478	if (RT_SUCCESS(rc))
479	pam_vbox_log(hPAM, "pam_vbox_read_prop: read key \"%s\"=\"%s\"\n", pszKey, pszValue);
480	}
481	}
482
483	RTMemFree(pvBuf);
484	pam_vbox_log(hPAM, "pam_vbox_read_prop: read key \"%s\" with rc=%Rrc\n",
485	pszKey, rc);
486	return rc;
487	}
488
489
490	/**
491	* Waits for a guest property to be changed.
492	*
493	* @return IPRT status code.
494	* @param hPAM PAM handle.
495	* @param uClientID Guest property service client ID.
496	* @param pszKey Key (name) of guest property to wait for.
497	* @param uTimeoutMS Timeout (in ms) to wait for the change. Specify
498	* RT_INDEFINITE_WAIT to wait indefinitly.
499	*/
500	static int pam_vbox_wait_prop(pam_handle_t *hPAM, uint32_t uClientID,
501	const char *pszKey, uint32_t uTimeoutMS)
502	{
503	AssertPtrReturn(hPAM, VERR_INVALID_POINTER);
504	AssertReturn(uClientID, VERR_INVALID_PARAMETER);
505	AssertPtrReturn(pszKey, VERR_INVALID_POINTER);
506
507	int rc;
508
509	/* The buffer for storing the data and its initial size. We leave a bit
510	* of space here in case the maximum values are raised. */
511	void *pvBuf = NULL;
512	uint32_t cbBuf = GUEST_PROP_MAX_NAME_LEN + GUEST_PROP_MAX_VALUE_LEN + GUEST_PROP_MAX_FLAGS_LEN + _1K;
513
514	for (int i = 0; ; i++)
515	{
516	void *pvTmpBuf = RTMemRealloc(pvBuf, cbBuf);
517	if (pvTmpBuf)
518	{
519	char *pszName = NULL;
520	char *pszValue = NULL;
521	uint64_t u64TimestampOut = 0;
522	char *pszFlags = NULL;
523
524	pvBuf = pvTmpBuf;
525	rc = VbglR3GuestPropWait(uClientID, pszKey, pvBuf, cbBuf,
526	0 /* Last timestamp; just wait for next event */, uTimeoutMS,
527	&pszName, &pszValue, &u64TimestampOut,
528	&pszFlags, &cbBuf, NULL /* pfWasDeleted */);
529	if (rc == VERR_BUFFER_OVERFLOW && i < 10)
530	{
531	cbBuf += _1K; /* Buffer too small, try it with a bigger one more time. */
532	continue;
533	}
534	}
535	else
536	rc = VERR_NO_MEMORY;
537	break;
538	}
539
540	RTMemFree(pvBuf);
541	return rc;
542	}
543
544	/**
545	* Thread function waiting for credentials to arrive.
546	*
547	* @return IPRT status code.
548	* @param hThreadSelf Thread handle.
549	* @param pvUser Pointer to a PAMVBOXTHREAD structure providing
550	* required data used / set by the thread.
551	*/
552	static DECLCALLBACK(int) pam_vbox_wait_thread(RTTHREAD hThreadSelf, void *pvUser)
553	{
554	RT_NOREF1(hThreadSelf);
555	PPAMVBOXTHREAD pUserData = (PPAMVBOXTHREAD)pvUser;
556	AssertPtr(pUserData);
557
558	int rc = VINF_SUCCESS;
559	/* Get current time stamp to later calculate rest of timeout left. */
560	uint64_t u64StartMS = RTTimeMilliTS();
561
562	uint32_t uClientID = 0;
563	rc = VbglR3GuestPropConnect(&uClientID);
564	if (RT_FAILURE(rc))
565	{
566	pam_vbox_error(pUserData->hPAM, "pam_vbox_wait_thread: Unable to connect to guest property service, rc=%Rrc\n", rc);
567	}
568	else
569	{
570	pam_vbox_log(pUserData->hPAM, "pam_vbox_wait_thread: clientID=%u\n", uClientID);
571
572	for (;;)
573	{
574
575	if (uClientID)
576	{
577	rc = pam_vbox_wait_prop(pUserData->hPAM, uClientID,
578	"/VirtualBox/GuestAdd/PAM/CredsWaitAbort",
579	500 /* Wait 500ms, same as VBoxGINA/VBoxCredProv. */);
580	switch (rc)
581	{
582	case VINF_SUCCESS:
583	/* Somebody (guest/host) wants to abort waiting for credentials. */
584	break;
585
586	case VERR_INTERRUPTED:
587	pam_vbox_error(pUserData->hPAM, "pam_vbox_wait_thread: The abort notification request timed out or was interrupted\n");
588	break;
589
590	case VERR_TIMEOUT:
591	/* We did not receive an abort message within time. */
592	break;
593
594	case VERR_TOO_MUCH_DATA:
595	pam_vbox_error(pUserData->hPAM, "pam_vbox_wait_thread: Temporarily unable to get abort notification\n");
596	break;
597
598	default:
599	pam_vbox_error(pUserData->hPAM, "pam_vbox_wait_thread: The abort notification request failed with rc=%Rrc\n", rc);
600	break;
601	}
602
603	if (RT_SUCCESS(rc)) /* Abort waiting. */
604	{
605	pam_vbox_log(pUserData->hPAM, "pam_vbox_wait_thread: Got notification to abort waiting\n");
606	rc = VERR_CANCELLED;
607	break;
608	}
609	}
610
611	if ( RT_SUCCESS(rc)
612	\|\| rc == VERR_TIMEOUT)
613	{
614	rc = pam_vbox_check_creds(pUserData->hPAM);
615	if (RT_SUCCESS(rc))
616	{
617	/* Credentials retrieved. */
618	break; /* Thread no longer is required, bail out. */
619	}
620	else if (rc == VERR_NOT_FOUND)
621	{
622	/* No credentials found, but try next round (if there's
623	* time left for) ... */
624	RTThreadSleep(500); /* Wait 500 ms. */
625	}
626	else
627	break; /* Something bad happend ... */
628	}
629	else
630	break;
631
632	/* Calculate timeout value left after process has been started. */
633	uint64_t u64Elapsed = RTTimeMilliTS() - u64StartMS;
634	/* Is it time to bail out? */
635	if (pUserData->uTimeoutMS < u64Elapsed)
636	{
637	pam_vbox_log(pUserData->hPAM, "pam_vbox_wait_thread: Waiting thread has reached timeout (%dms), exiting ...\n",
638	pUserData->uTimeoutMS);
639	rc = VERR_TIMEOUT;
640	break;
641	}
642	}
643	}
644	VbglR3GuestPropDisconnect(uClientID);
645
646	/* Save result. */
647	pUserData->rc = rc; /** @todo Use ASMAtomicXXX? */
648
649	int rc2 = RTThreadUserSignal(RTThreadSelf());
650	AssertRC(rc2);
651
652	pam_vbox_log(pUserData->hPAM, "pam_vbox_wait_thread: Waiting thread returned with rc=%Rrc\n", rc);
653	return rc;
654	}
655
656	/**
657	* Waits for credentials to arrive by creating and waiting for a thread.
658	*
659	* @return IPRT status code.
660	* @param hPAM PAM handle.
661	* @param uClientID Guest property service client ID.
662	* @param uTimeoutMS Timeout (in ms) to wait for the change. Specify
663	* RT_INDEFINITE_WAIT to wait indefinitly.
664	*/
665	static int pam_vbox_wait_for_creds(pam_handle_t *hPAM, uint32_t uClientID, uint32_t uTimeoutMS)
666	{
667	RT_NOREF1(uClientID);
668	PAMVBOXTHREAD threadData;
669	threadData.hPAM = hPAM;
670	threadData.uTimeoutMS = uTimeoutMS;
671
672	RTTHREAD threadWait;
673	int rc = RTThreadCreate(&threadWait, pam_vbox_wait_thread,
674	(void *)&threadData, 0,
675	RTTHREADTYPE_DEFAULT, 0 /* Flags */, "pam_vbox");
676	if (RT_SUCCESS(rc))
677	{
678	pam_vbox_log(hPAM, "pam_vbox_wait_for_creds: Waiting for credentials (%dms) ...\n", uTimeoutMS);
679	/* Wait for thread to initialize. */
680	/** @todo We can do something else here in the meantime later. */
681	rc = RTThreadUserWait(threadWait, RT_INDEFINITE_WAIT);
682	if (RT_SUCCESS(rc))
683	rc = threadData.rc; /* Get back thread result to take further actions. */
684	}
685	else
686	pam_vbox_error(hPAM, "pam_vbox_wait_for_creds: Creating thread failed with rc=%Rrc\n", rc);
687
688	pam_vbox_log(hPAM, "pam_vbox_wait_for_creds: Waiting for credentials returned with rc=%Rrc\n", rc);
689	return rc;
690	}
691
692	DECLEXPORT(int) pam_sm_authenticate(pam_handle_t hPAM, int iFlags, int argc, const char *argv)
693	{
694	RT_NOREF1(iFlags);
695
696	/* Parse arguments. */
697	for (int i = 0; i < argc; i++)
698	{
699	if (!RTStrICmp(argv[i], "debug"))
700	g_verbosity = 1;
701	else
702	pam_vbox_error(hPAM, "pam_vbox_authenticate: unknown command line argument \"%s\"\n", argv[i]);
703	}
704	pam_vbox_log(hPAM, "pam_vbox_authenticate called\n");
705
706	int rc = pam_vbox_init(hPAM);
707	if (RT_FAILURE(rc))
708	return PAM_SUCCESS; /* Jump out as early as we can to not mess around. */
709
710	bool fFallback = true;
711
712	uint32_t uClientId;
713	rc = VbglR3GuestPropConnect(&uClientId);
714	if (RT_SUCCESS(rc))
715	{
716	char szVal[256];
717	rc = pam_vbox_read_prop(hPAM, uClientId,
718	"/VirtualBox/GuestAdd/PAM/CredsWait",
719	true /* Read-only on guest */,
720	szVal, sizeof(szVal));
721	if (RT_SUCCESS(rc))
722	{
723	/* All calls which are checked against rc2 are not critical, e.g. it does
724	* not matter if they succeed or not. */
725	uint32_t uTimeoutMS = RT_INDEFINITE_WAIT; /* Wait infinite by default. */
726	int rc2 = pam_vbox_read_prop(hPAM, uClientId,
727	"/VirtualBox/GuestAdd/PAM/CredsWaitTimeout",
728	true /* Read-only on guest */,
729	szVal, sizeof(szVal));
730	if (RT_SUCCESS(rc2))
731	{
732	uTimeoutMS = RTStrToUInt32(szVal);
733	if (!uTimeoutMS)
734	{
735	pam_vbox_error(hPAM, "pam_vbox_authenticate: invalid waiting timeout value specified, defaulting to infinite timeout\n");
736	uTimeoutMS = RT_INDEFINITE_WAIT;
737	}
738	else
739	uTimeoutMS = uTimeoutMS * 1000; /* Make ms out of s. */
740	}
741
742	rc2 = pam_vbox_read_prop(hPAM, uClientId,
743	"/VirtualBox/GuestAdd/PAM/CredsMsgWaiting",
744	true /* Read-only on guest */,
745	szVal, sizeof(szVal));
746	const char *pszWaitMsg = NULL;
747	if (RT_SUCCESS(rc2))
748	pszWaitMsg = szVal;
749
750	rc2 = vbox_set_msg(hPAM, 0 /* Info message */,
751	pszWaitMsg ? pszWaitMsg : "Waiting for credentials ...");
752	if (RT_FAILURE(rc2)) /* Not critical. */
753	pam_vbox_error(hPAM, "pam_vbox_authenticate: error setting waiting information message, rc=%Rrc\n", rc2);
754
755	if (RT_SUCCESS(rc))
756	{
757	/* Before we actuall wait for credentials just make sure we didn't already get credentials
758	* set so that we can skip waiting for them ... */
759	rc = pam_vbox_check_creds(hPAM);
760	if (rc == VERR_NOT_FOUND)
761	{
762	rc = pam_vbox_wait_for_creds(hPAM, uClientId, uTimeoutMS);
763	if (rc == VERR_TIMEOUT)
764	{
765	pam_vbox_log(hPAM, "pam_vbox_authenticate: no credentials given within time\n");
766
767	rc2 = pam_vbox_read_prop(hPAM, uClientId,
768	"/VirtualBox/GuestAdd/PAM/CredsMsgWaitTimeout",
769	true /* Read-only on guest */,
770	szVal, sizeof(szVal));
771	if (RT_SUCCESS(rc2))
772	{
773	rc2 = vbox_set_msg(hPAM, 0 /* Info message */, szVal);
774	AssertRC(rc2);
775	}
776	}
777	else if (rc == VERR_CANCELLED)
778	{
779	pam_vbox_log(hPAM, "pam_vbox_authenticate: waiting aborted\n");
780
781	rc2 = pam_vbox_read_prop(hPAM, uClientId,
782	"/VirtualBox/GuestAdd/PAM/CredsMsgWaitAbort",
783	true /* Read-only on guest */,
784	szVal, sizeof(szVal));
785	if (RT_SUCCESS(rc2))
786	{
787	rc2 = vbox_set_msg(hPAM, 0 /* Info message */, szVal);
788	AssertRC(rc2);
789	}
790	}
791	}
792
793	/* If we got here we don't need the fallback, so just deactivate it. */
794	fFallback = false;
795	}
796	}
797
798	VbglR3GuestPropDisconnect(uClientId);
799	}
800
801	if (fFallback)
802	{
803	pam_vbox_log(hPAM, "pam_vbox_authenticate: falling back to old method\n");
804
805	/* If anything went wrong in the code above we just do a credentials
806	* check like it was before: Try retrieving the stuff and authenticating. */
807	int rc2 = pam_vbox_check_creds(hPAM);
808	if (RT_SUCCESS(rc))
809	rc = rc2;
810	}
811
812	pam_vbox_shutdown(hPAM);
813
814	pam_vbox_log(hPAM, "pam_vbox_authenticate: overall result rc=%Rrc\n", rc);
815
816	/* Never report an error here because if no credentials from the host are available or something
817	* went wrong we then let do the authentication by the next module in the stack. */
818
819	/* We report success here because this is all we can do right now -- we passed the credentials
820	* to the next PAM module in the block above which then might do a shadow (like pam_unix/pam_unix2)
821	* password verification to "really" authenticate the user. */
822	return PAM_SUCCESS;
823	}
824
825
826	DECLEXPORT(int) pam_sm_setcred(pam_handle_t hPAM, int iFlags, int argc, const char *argv)
827	{
828	pam_vbox_log(hPAM, "pam_vbox_setcred called, iFlags=0x%x\n", iFlags);
829	for (int i = 0; i < argc; i++)
830	pam_vbox_log(hPAM, "pam_vbox_setcred: argv[%d] = %s\n", i, argv[i]);
831	return PAM_SUCCESS;
832	}
833
834
835	DECLEXPORT(int) pam_sm_acct_mgmt(pam_handle_t hPAM, int iFlags, int argc, const char *argv)
836	{
837	RT_NOREF3(iFlags, argc, argv);
838	pam_vbox_log(hPAM, "pam_vbox_acct_mgmt called\n");
839	return PAM_SUCCESS;
840	}
841
842
843	DECLEXPORT(int) pam_sm_open_session(pam_handle_t hPAM, int iFlags, int argc, const char *argv)
844	{
845	RT_NOREF3(iFlags, argc, argv);
846	pam_vbox_log(hPAM, "pam_vbox_open_session called\n");
847	RTPrintf("This session was provided by VirtualBox Guest Additions. Have a lot of fun!\n");
848	return PAM_SUCCESS;
849	}
850
851
852	DECLEXPORT(int) pam_sm_close_session(pam_handle_t hPAM, int iFlags, int argc, const char *argv)
853	{
854	RT_NOREF3(iFlags, argc, argv);
855	pam_vbox_log(hPAM, "pam_vbox_close_session called\n");
856	return PAM_SUCCESS;
857	}
858
859
860	DECLEXPORT(int) pam_sm_chauthtok(pam_handle_t hPAM, int iFlags, int argc, const char *argv)
861	{
862	RT_NOREF3(iFlags, argc, argv);
863	pam_vbox_log(hPAM, "pam_vbox_sm_chauthtok called\n");
864	return PAM_SUCCESS;
865	}
866
867
868	#ifdef DEBUG
869	RTDECL(void) RTAssertMsg1Weak(const char pszExpr, unsigned uLine, const char pszFile, const char *pszFunction)
870	{
871	pam_vbox_log(g_pam_handle,
872	"\n!!Assertion Failed!!\n"
873	"Expression: %s\n"
874	"Location : %s(%d) %s\n",
875	pszExpr, pszFile, uLine, pszFunction);
876	RTAssertMsg1(pszExpr, uLine, pszFile, pszFunction);
877	}
878	#endif
879

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Additions/common/pam/pam_vbox.cpp@ 106945

Download in other formats: