msteinert-go-pam/transaction.h

#pragma once

#include <security/pam_appl.h>
#include <security/pam_modules.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>

#ifdef PAM_BINARY_PROMPT
#define BINARY_PROMPT_IS_SUPPORTED 1
#else
#include <limits.h>
#define PAM_BINARY_PROMPT INT_MAX
#define BINARY_PROMPT_IS_SUPPORTED 0
#endif

#ifdef __sun
#define PAM_CONST
#else
#define PAM_CONST const
#endif

extern int _go_pam_conv_handler(struct pam_message *, uintptr_t, char **reply);
extern void _go_pam_data_cleanup(pam_handle_t *, uintptr_t, int status);

static inline int cb_pam_conv(int num_msg, PAM_CONST struct pam_message **msg, struct pam_response **resp, void *appdata_ptr)
{
	if (num_msg <= 0 || num_msg > PAM_MAX_NUM_MSG)
		return PAM_CONV_ERR;

	*resp = calloc(num_msg, sizeof **resp);
	if (!*resp)
		return PAM_BUF_ERR;

	for (size_t i = 0; i < num_msg; ++i) {
		int result = _go_pam_conv_handler((struct pam_message *)msg[i], (uintptr_t)appdata_ptr, &(*resp)[i].resp);
		if (result != PAM_SUCCESS)
			goto error;
	}

	return PAM_SUCCESS;
error:
	for (size_t i = 0; i < num_msg; ++i) {
		if ((*resp)[i].resp) {
#ifdef PAM_BINARY_PROMPT
			if (msg[i]->msg_style != PAM_BINARY_PROMPT)
#endif
				memset((*resp)[i].resp, 0, strlen((*resp)[i].resp));
			free((*resp)[i].resp);
		}
	}

	memset(*resp, 0, num_msg * sizeof *resp);
	free(*resp);
	*resp = NULL;
	return PAM_CONV_ERR;
}

static inline void init_pam_conv(struct pam_conv *conv, uintptr_t appdata)
{
	conv->conv = cb_pam_conv;
	conv->appdata_ptr = (void *)appdata;
}

static inline int start_pam_conv(struct pam_conv *pc, int num_msgs, const struct pam_message **msgs, struct pam_response **out_resp)
{
	return pc->conv(num_msgs, msgs, out_resp, pc->appdata_ptr);
}

// pam_start_confdir is a recent PAM api to declare a confdir (mostly for
// tests) weaken the linking dependency to detect if it’s present.
int pam_start_confdir(const char *service_name, const char *user, const struct pam_conv *pam_conversation,
		      const char *confdir, pam_handle_t **pamh) __attribute__((weak));

static inline int check_pam_start_confdir(void)
{
	if (pam_start_confdir == NULL)
		return 1;

	return 0;
}

static inline void data_cleanup(pam_handle_t *pamh, void *data, int error_status)
{
	_go_pam_data_cleanup(pamh, (uintptr_t)data, error_status);
}

static inline int set_data(pam_handle_t *pamh, const char *name, uintptr_t handle)
{
	if (handle)
		return pam_set_data(pamh, name, (void *)handle, data_cleanup);

	return pam_set_data(pamh, name, NULL, NULL);
}

static inline int get_data(pam_handle_t *pamh, const char *name, uintptr_t *out_handle)
{
	return pam_get_data(pamh, name, (const void **)out_handle);
}
-												module-transaction: Add support for setting/getting module data

Module data is data associated with a module handle that is available
for the whole module loading time so it can be used also during
different operations.

We use cgo handles to preserve the life of the go objects so any value
can be associated with a pam transaction.

											
										
										
											2023-10-03 14:37:28 +02:00
+								#pragma once
-												Update interface

											
										
										
											2015-03-27 18:59:29 -05:00
+								#include <security/pam_appl.h>
-												module-transaction: Add support for setting/getting module data

Module data is data associated with a module handle that is available
for the whole module loading time so it can be used also during
different operations.

We use cgo handles to preserve the life of the go objects so any value
can be associated with a pam transaction.

											
										
										
											2023-10-03 14:37:28 +02:00
+								#include <security/pam_modules.h>
-												transaction: Use cgo.Handle to pass callback data to PAM

Go provides a nicer way to handle Go structs lifetime when they
are passed to C now, so use this instead of a custom
implementation that requires to store them in a map

											
										
										
											2023-09-19 20:04:06 +02:00
+								#include <stdint.h>
-												transaction: Define C functions as unexported static inlines

This will make it easier to avoid exporting unexpected symbols to the
generated PAM libraries.

Also it makes less messy handling C code inside go files.

											
										
										
											2023-11-20 21:06:58 +01:00
+								#include <stdlib.h>
-												Security fixes for conversation handler

											
										
										
											2015-03-31 12:19:55 -05:00
+								#include <string.h>
-												Update interface

											
										
										
											2015-03-27 18:59:29 -05:00
-												transaction: Define C functions as unexported static inlines

This will make it easier to avoid exporting unexpected symbols to the
generated PAM libraries.

Also it makes less messy handling C code inside go files.

											
										
										
											2023-11-20 21:06:58 +01:00
+								#ifdef PAM_BINARY_PROMPT
 								#define BINARY_PROMPT_IS_SUPPORTED 1
 								#else
 								#include <limits.h>
 								#define PAM_BINARY_PROMPT INT_MAX
 								#define BINARY_PROMPT_IS_SUPPORTED 0
 								#endif
-												Fix build on Solaris

											
										
										
											2020-08-07 17:34:46 +01:00
+								#ifdef __sun
 								#define PAM_CONST
 								#else
 								#define PAM_CONST const
 								#endif
-												transaction: Define C functions as unexported static inlines

This will make it easier to avoid exporting unexpected symbols to the
generated PAM libraries.

Also it makes less messy handling C code inside go files.

											
										
										
											2023-11-20 21:06:58 +01:00
+								extern int _go_pam_conv_handler(struct pam_message *, uintptr_t, char **reply);
-												module-transaction: Add support for setting/getting module data

Module data is data associated with a module handle that is available
for the whole module loading time so it can be used also during
different operations.

We use cgo handles to preserve the life of the go objects so any value
can be associated with a pam transaction.

											
										
										
											2023-10-03 14:37:28 +02:00
+								extern void _go_pam_data_cleanup(pam_handle_t *, uintptr_t, int status);
-												transaction: Define C functions as unexported static inlines

This will make it easier to avoid exporting unexpected symbols to the
generated PAM libraries.

Also it makes less messy handling C code inside go files.

											
										
										
											2023-11-20 21:06:58 +01:00
 								static inline int cb_pam_conv(int num_msg, PAM_CONST struct pam_message **msg, struct pam_response **resp, void *appdata_ptr)
-												Update interface

											
										
										
											2015-03-27 18:59:29 -05:00
+								{
-												Format transaction.c with clang-format

To improve readability and encourage consistency in PRs.

											
										
										
											2023-09-21 08:11:19 -05:00
+									if (num_msg <= 0 || num_msg > PAM_MAX_NUM_MSG)
-												Security fixes for conversation handler

											
										
										
											2015-03-31 12:19:55 -05:00
+										return PAM_CONV_ERR;
-												Format transaction.c with clang-format

To improve readability and encourage consistency in PRs.

											
										
										
											2023-09-21 08:11:19 -05:00
-												bugfix: Allocate after sanitizing inputs

											
										
										
											2023-09-21 08:12:18 -05:00
+									*resp = calloc(num_msg, sizeof **resp);
-												Format transaction.c with clang-format

To improve readability and encourage consistency in PRs.

											
										
										
											2023-09-21 08:11:19 -05:00
+									if (!*resp)
-												Update interface

											
										
										
											2015-03-27 18:59:29 -05:00
+										return PAM_BUF_ERR;
-												Format transaction.c with clang-format

To improve readability and encourage consistency in PRs.

											
										
										
											2023-09-21 08:11:19 -05:00
-												Update interface

											
										
										
											2015-03-27 18:59:29 -05:00
+									for (size_t i = 0; i < num_msg; ++i) {
-												transaction: Define C functions as unexported static inlines

This will make it easier to avoid exporting unexpected symbols to the
generated PAM libraries.

Also it makes less messy handling C code inside go files.

											
										
										
											2023-11-20 21:06:58 +01:00
+										int result = _go_pam_conv_handler((struct pam_message *)msg[i], (uintptr_t)appdata_ptr, &(*resp)[i].resp);
 										if (result != PAM_SUCCESS)
-												Update interface

											
										
										
											2015-03-27 18:59:29 -05:00
+											goto error;
 									}
-												Format transaction.c with clang-format

To improve readability and encourage consistency in PRs.

											
										
										
											2023-09-21 08:11:19 -05:00
-												Update interface

											
										
										
											2015-03-27 18:59:29 -05:00
+									return PAM_SUCCESS;
 								error:
 									for (size_t i = 0; i < num_msg; ++i) {
-												Security fixes for conversation handler

											
										
										
											2015-03-31 12:19:55 -05:00
+										if ((*resp)[i].resp) {
-												module-transaction: Add support for binary conversations

A module can now initiate a binary conversation decoding the native
pointer value as it wants.

Added tests to verify the main cases

											
										
										
											2023-10-05 05:49:22 +02:00
+								#ifdef PAM_BINARY_PROMPT
 											if (msg[i]->msg_style != PAM_BINARY_PROMPT)
 								#endif
 												memset((*resp)[i].resp, 0, strlen((*resp)[i].resp));
-												Security fixes for conversation handler

											
										
										
											2015-03-31 12:19:55 -05:00
+											free((*resp)[i].resp);
 										}
-												Update interface

											
										
										
											2015-03-27 18:59:29 -05:00
+									}
-												Format transaction.c with clang-format

To improve readability and encourage consistency in PRs.

											
										
										
											2023-09-21 08:11:19 -05:00
-												Security fixes for conversation handler

											
										
										
											2015-03-31 12:19:55 -05:00
+									memset(*resp, 0, num_msg * sizeof *resp);
-												Update interface

											
										
										
											2015-03-27 18:59:29 -05:00
+									free(*resp);
 									*resp = NULL;
 									return PAM_CONV_ERR;
 								}
-												transaction: Define C functions as unexported static inlines

This will make it easier to avoid exporting unexpected symbols to the
generated PAM libraries.

Also it makes less messy handling C code inside go files.

											
										
										
											2023-11-20 21:06:58 +01:00
+								static inline void init_pam_conv(struct pam_conv *conv, uintptr_t appdata)
-												Update interface

											
										
										
											2015-03-27 18:59:29 -05:00
+								{
 									conv->conv = cb_pam_conv;
-												transaction: Use cgo.Handle to pass callback data to PAM

Go provides a nicer way to handle Go structs lifetime when they
are passed to C now, so use this instead of a custom
implementation that requires to store them in a map

											
										
										
											2023-09-19 20:04:06 +02:00
+									conv->appdata_ptr = (void *)appdata;
-												Update interface

											
										
										
											2015-03-27 18:59:29 -05:00
+								}
-												Allow to define confdir

PAM has a pam_start_confdir() which allows to define the configuration
directory where all services are located.
This is useful to define your own service on tests in particular, so
that you can control your stack and be independant of the host when
running them.
Allow defining this configuration directory, with a new StartConfDir
function.
Also, allow pre-checking for the API availability with
CheckPamHasStartConfdir().

											
										
										
											2022-09-16 08:09:26 +02:00
-												module-transaction: Add support for initiating PAM Conversations

Modules have the ability to start PAM conversations, so while the
transaction code can handle them we did not have a way to init them.
Yet.

So add some APIs allowing this, making it easier from the go side to
handle the conversations.

In this commit we only support text-based conversations, but code is
designed with the idea of supporting binary cases too.

Added the integration tests using the module that is now able to both
start conversation and handle them using Go only.

											
										
										
											2023-10-04 23:34:20 +02:00
+								static inline int start_pam_conv(struct pam_conv *pc, int num_msgs, const struct pam_message **msgs, struct pam_response **out_resp)
 								{
 									return pc->conv(num_msgs, msgs, out_resp, pc->appdata_ptr);
 								}
-												Format transaction.c with clang-format

To improve readability and encourage consistency in PRs.

											
										
										
											2023-09-21 08:11:19 -05:00
+								// pam_start_confdir is a recent PAM api to declare a confdir (mostly for
 								// tests) weaken the linking dependency to detect if it’s present.
 								int pam_start_confdir(const char *service_name, const char *user, const struct pam_conv *pam_conversation,
 										      const char *confdir, pam_handle_t **pamh) __attribute__((weak));
-												transaction: Define C functions as unexported static inlines

This will make it easier to avoid exporting unexpected symbols to the
generated PAM libraries.

Also it makes less messy handling C code inside go files.

											
										
										
											2023-11-20 21:06:58 +01:00
+								static inline int check_pam_start_confdir(void)
-												Format transaction.c with clang-format

To improve readability and encourage consistency in PRs.

											
										
										
											2023-09-21 08:11:19 -05:00
+								{
-												Allow to define confdir

PAM has a pam_start_confdir() which allows to define the configuration
directory where all services are located.
This is useful to define your own service on tests in particular, so
that you can control your stack and be independant of the host when
running them.
Allow defining this configuration directory, with a new StartConfDir
function.
Also, allow pre-checking for the API availability with
CheckPamHasStartConfdir().

											
										
										
											2022-09-16 08:09:26 +02:00
+									if (pam_start_confdir == NULL)
 										return 1;
-												Format transaction.c with clang-format

To improve readability and encourage consistency in PRs.

											
										
										
											2023-09-21 08:11:19 -05:00
-												Allow to define confdir

PAM has a pam_start_confdir() which allows to define the configuration
directory where all services are located.
This is useful to define your own service on tests in particular, so
that you can control your stack and be independant of the host when
running them.
Allow defining this configuration directory, with a new StartConfDir
function.
Also, allow pre-checking for the API availability with
CheckPamHasStartConfdir().

											
										
										
											2022-09-16 08:09:26 +02:00
+									return 0;
 								}
-												module-transaction: Add support for setting/getting module data

Module data is data associated with a module handle that is available
for the whole module loading time so it can be used also during
different operations.

We use cgo handles to preserve the life of the go objects so any value
can be associated with a pam transaction.

											
										
										
											2023-10-03 14:37:28 +02:00
 								static inline void data_cleanup(pam_handle_t *pamh, void *data, int error_status)
 								{
 									_go_pam_data_cleanup(pamh, (uintptr_t)data, error_status);
 								}
 								static inline int set_data(pam_handle_t *pamh, const char *name, uintptr_t handle)
 								{
 									if (handle)
 										return pam_set_data(pamh, name, (void *)handle, data_cleanup);
 									return pam_set_data(pamh, name, NULL, NULL);
 								}
 								static inline int get_data(pam_handle_t *pamh, const char *name, uintptr_t *out_handle)
 								{
 									return pam_get_data(pamh, name, (const void **)out_handle);
 								}