#include "config.h"

#include <errno.h>

#include <fcntl.h>

#include <limits.h>

#include <pwd.h>

#include <stdarg.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <syslog.h>

#include <time.h>

#include <unistd.h>

#ifdef HAVE_SELINUX

#ifdef HAVE_SELINUX_SELINUX_H

#include <selinux/selinux.h>

#ifdef HAVE_SELINUX_CONTEXT_H

#include <selinux/context.h>

#ifdef HAVE_SYS_FSUID_H

#include <sys/fsuid.h>

#ifndef PAM_EXTERN

#define PAM_EXTERN

#if !defined(LOG_AUTHPRIV) && defined(LOG_AUTH)

#define LOG_AUTHPRIV LOG_AUTH

#define PAM_SM_AUTH

#include <security/pam_appl.h>

#include <security/pam_modules.h>

#include "base32.h"

#include "hmac.h"

#include "sha1.h"

#include "util.h"

#define MODULE_NAME "pam_google_auth"

#define SECRET "~/.google_authenticator"

#define SECRET_SELINUX_TYPE "auth_home_t"

#define CODE_PROMPT "Verification code: "

#define PWCODE_PROMPT "Password & verification code: "

typedef struct Params {

} Params;

static char oom;

static const char* nobody = "nobody";

#if defined(DEMO) || defined(TESTING)

static char* error_msg = NULL;

const char *get_error_msg(void) __attribute__((visibility("default")));

const char *get_error_msg(void) {

if (!error_msg) {

return "";

}

return error_msg;

}

static void log_message(int priority, pam_handle_t *pamh,

const char *format, ...) {

char *service = NULL;

if (pamh)

pam_get_item(pamh, PAM_SERVICE, (void *)&service);

if (!service)

service = "";

char logname[80];

snprintf(logname, sizeof(logname), "%s(" MODULE_NAME ")", service);

va_list args;

va_start(args, format);

#if !defined(DEMO) && !defined(TESTING)

openlog(logname, LOG_CONS | LOG_PID, LOG_AUTHPRIV);

vsyslog(priority, format, args);

closelog();

if (!error_msg) {

error_msg = strdup("");

}

{

char buf[1000];

vsnprintf(buf, sizeof buf, format, args);

const int newlen = strlen(error_msg) + 1 + strlen(buf) + 1;

char* n = malloc(newlen);

if (n) {

snprintf(n, newlen, "%s%s%s", error_msg, strlen(error_msg)?"\n":"",buf);

free(error_msg);

error_msg = n;

} else {

fprintf(stderr, "Failed to malloc %d bytes for log data.\n", newlen);

}

}

va_end(args);

if (priority == LOG_EMERG) {

// Something really bad happened. There is no way we can proceed safely.

_exit(1);

}

}

static int converse(pam_handle_t *pamh, int nargs,

PAM_CONST struct pam_message **message,

struct pam_response **response) {

struct pam_conv *conv;

int retval = pam_get_item(pamh, PAM_CONV, (void *)&conv);

if (retval != PAM_SUCCESS) {

return retval;

}

return conv->conv(nargs, message, response, conv->appdata_ptr);

}

static const char *get_user_name(pam_handle_t *pamh, const Params *params) {

// Obtain the user's name

const char *username;

if (pam_get_user(pamh, &username, NULL) != PAM_SUCCESS ||

!username || !*username) {

log_message(LOG_ERR, pamh,

"pam_get_user() failed to get a user name"

" when checking verification code");

return NULL;

}

if (params->debug) {

log_message(LOG_INFO, pamh, "debug: start of google_authenticator for \"%s\"", username);

}

return username;

}

static const char *

get_rhost(pam_handle_t *pamh, const Params *params) {

// Get the remote host

PAM_CONST void *rhost;

if (pam_get_item(pamh, PAM_RHOST, &rhost) != PAM_SUCCESS) {

log_message(LOG_ERR, pamh, "pam_get_rhost() failed to get the remote host");

return NULL;

}

if (params->debug) {

log_message(LOG_INFO, pamh, "debug: google_authenticator for host \"%s\"",

rhost);

}

return (const char *)rhost;

}

static size_t

getpwnam_buf_max_size()

{

#ifdef _SC_GETPW_R_SIZE_MAX

const ssize_t len = sysconf(_SC_GETPW_R_SIZE_MAX);

if (len <= 0) {

return 4096;

}

return len;

return 4096;

}

static char *get_secret_filename(pam_handle_t *pamh, const Params *params,

const char *username, uid_t *uid) {

if (!username) {

return NULL;

}

// Check whether the administrator decided to override the default location

// for the secret file.

const char *spec = params->secret_filename_spec

? params->secret_filename_spec : SECRET;

// Obtain the user's id and home directory

// NOTE: These variables need to be here because of their lifetimes.

struct passwd *pw = NULL; // Used

struct passwd pwbuf; // Here because `pw` points into it.

char *buf = NULL; // Here because `pw` members use it.

char *secret_filename = NULL; // Here because goto jumps.

if (!params->fixed_uid) {

const int len = getpwnam_buf_max_size();

buf = malloc(len);

*uid = -1;

if (buf == NULL) {

log_message(LOG_ERR, pamh, "Short (%d) mem allocation failed", len);

goto errout;

}

const int rc = getpwnam_r(username, &pwbuf, buf, len, &pw);

if (rc) {

log_message(LOG_ERR, pamh, "getpwnam_r(\"%s\")!=0: %d", username, rc);

goto errout;

}

if (!pw) {

log_message(LOG_ERR, pamh, "user(\"%s\") not found", username);

goto errout;

}

if (!pw->pw_dir) {

log_message(LOG_ERR, pamh, "user(\"%s\") has no home dir", username);

goto errout;

}

if (*pw->pw_dir != '/') {

log_message(LOG_ERR, pamh, "User \"%s\" home dir not absolute", username);

goto errout;

}

}

// Expand filename specification to an actual filename.

if ((secret_filename = strdup(spec)) == NULL) {

log_message(LOG_ERR, pamh, "Short (%d) mem allocation failed", strlen(spec));

goto errout;

}

int allow_tilde = 1;

for (int offset = 0; secret_filename[offset];) {

char *cur = secret_filename + offset;

char *var = NULL;

size_t var_len = 0;

const char *subst = NULL;

if (allow_tilde && *cur == '~') {

var_len = 1;

if (!pw) {

log_message(LOG_ERR, pamh,

"Home dir in 'secret' not implemented when 'user' set");

goto errout;

}

subst = pw->pw_dir;

var = cur;

} else if (secret_filename[offset] == '$') {

if (!memcmp(cur, "${HOME}", 7)) {

var_len = 7;

if (!pw) {

log_message(LOG_ERR, pamh,

"Home dir in 'secret' not implemented when 'user' set");

goto errout;

}

subst = pw->pw_dir;

var = cur;

} else if (!memcmp(cur, "${USER}", 7)) {

var_len = 7;

subst = username;

var = cur;

}

}

if (var) {

const size_t subst_len = strlen(subst);

if (subst_len > 1000000) {

log_message(LOG_ERR, pamh, "Unexpectedly large path name: %d", subst_len);

goto errout;

}

const int varidx = var - secret_filename;

char *resized = realloc(secret_filename,

strlen(secret_filename) + subst_len + 1);

if (!resized) {

log_message(LOG_ERR, pamh, "Short mem allocation failed");

goto errout;

}

var = resized + varidx;

secret_filename = resized;

memmove(var + subst_len, var + var_len, strlen(var + var_len) + 1);

memmove(var, subst, subst_len);

offset = var + subst_len - resized;

allow_tilde = 0;

} else {

allow_tilde = *cur == '/';

++offset;

}

}

*uid = params->fixed_uid ? params->uid : pw->pw_uid;

free(buf);

return secret_filename;

errout:

free(secret_filename);

free(buf);

return NULL;

}

static int setuser(int uid) {

#ifdef HAVE_SETFSUID

// The semantics for setfsuid() are a little unusual. On success, the

// previous user id is returned. On failure, the current user id is returned.

int old_uid = setfsuid(uid);

if (uid != setfsuid(uid)) {

setfsuid(old_uid);

return -1;

}

#ifdef linux

#error "Linux should have setfsuid(). Refusing to build."

int old_uid = geteuid();

if (old_uid != uid && seteuid(uid)) {

return -1;

}

return old_uid;

}

static int setgroup(int gid) {

#ifdef HAVE_SETFSGID

// The semantics of setfsgid() are a little unusual. On success, the

// previous group id is returned. On failure, the current groupd id is

// returned.

int old_gid = setfsgid(gid);

if (gid != setfsgid(gid)) {

setfsgid(old_gid);

return -1;

}

int old_gid = getegid();

if (old_gid != gid && setegid(gid)) {

return -1;

}

return old_gid;

}

static int drop_privileges(pam_handle_t *pamh, const char *username, int uid,

int *old_uid, int *old_gid) {

// Try to become the new user. This might be necessary for NFS mounted home

// directories.

// First, look up the user's default group

#ifdef _SC_GETPW_R_SIZE_MAX

int len = sysconf(_SC_GETPW_R_SIZE_MAX);

if (len <= 0) {

len = 4096;

}

#else

int len = 4096;

#endif

char *buf = malloc(len);

if (!buf) {

log_message(LOG_ERR, pamh, "Out of memory");

return -1;

}

struct passwd pwbuf, *pw;

if (getpwuid_r(uid, &pwbuf, buf, len, &pw) || !pw) {

log_message(LOG_ERR, pamh, "Cannot look up user id %d", uid);

free(buf);

return -1;

}

gid_t gid = pw->pw_gid;

free(buf);

int gid_o = setgroup(gid);

int uid_o = setuser(uid);

if (uid_o < 0) {

if (gid_o >= 0) {

if (setgroup(gid_o) < 0 || setgroup(gid_o) != gid_o) {

// Inform the caller that we were unsuccessful in resetting the group.

*old_gid = gid_o;

}

}

log_message(LOG_ERR, pamh, "Failed to change user id to \"%s\"",

username);

return -1;

}

if (gid_o < 0 && (gid_o = setgroup(gid)) < 0) {

// In most typical use cases, the PAM module will end up being called

// while uid=0. This allows the module to change to an arbitrary group

// prior to changing the uid. But there are many ways that PAM modules

// can be invoked and in some scenarios this might not work. So, we also

// try changing the group _after_ changing the uid. It might just work.

if (setuser(uid_o) < 0 || setuser(uid_o) != uid_o) {

// Inform the caller that we were unsuccessful in resetting the uid.

*old_uid = uid_o;

}

log_message(LOG_ERR, pamh,

"Failed to change group id for user \"%s\" to %d", username,

(int)gid);

return -1;

}

*old_uid = uid_o;

*old_gid = gid_o;

return 0;

}

static int open_secret_file(pam_handle_t *pamh, const char *secret_filename,

Params *params, const char *username,

int uid, struct stat *orig_stat) {

// Try to open "~/.google_authenticator"

const int fd = open(secret_filename, O_RDONLY);

if (fd < 0 ||

fstat(fd, orig_stat) < 0) {

if (params->nullok != NULLERR && errno == ENOENT) {

// The user doesn't have a state file, but the administrator said

// that this is OK. We still return an error from open_secret_file(),

// but we remember that this was the result of a missing state file.

params->nullok = SECRETNOTFOUND;

} else {

log_message(LOG_ERR, pamh, "Failed to read \"%s\" for \"%s\": %s",

secret_filename, username, strerror(errno));

}

error:

if (fd >= 0) {

close(fd);

}

return -1;

}

if (params->debug) {

log_message(LOG_INFO, pamh,

"debug: Secret file permissions are %04o."

" Allowed permissions are %04o",

orig_stat->st_mode & 03777, params->allowed_perm);

}

// Check permissions on "~/.google_authenticator".

if (!S_ISREG(orig_stat->st_mode)) {

log_message(LOG_ERR, pamh, "Secret file \"%s\" is not a regular file",

secret_filename);

goto error;

}

if (orig_stat->st_mode & 03777 & ~params->allowed_perm) {

log_message(LOG_ERR, pamh,

"Secret file \"%s\" permissions (%04o)"

" are more permissive than %04o", secret_filename,

orig_stat->st_mode & 03777, params->allowed_perm);

goto error;

}

if (!params->no_strict_owner && (orig_stat->st_uid != (uid_t)uid)) {

char buf[80];

if (params->fixed_uid) {

snprintf(buf, sizeof buf, "user id %d", params->uid);

username = buf;

}

log_message(LOG_ERR, pamh,

"Secret file \"%s\" must be owned by \"%s\"",

secret_filename, username);

goto error;

}

// Sanity check for file length

if (orig_stat->st_size < 1 || orig_stat->st_size > 64*1024) {

log_message(LOG_ERR, pamh,

"Invalid file size for \"%s\"", secret_filename);

goto error;

}

return fd;

}

static char *read_file_contents(pam_handle_t *pamh,

const Params *params,

const char *secret_filename, int *fd,

off_t filesize) {

// Arbitrary limit to prevent integer overflow.

if (filesize > 1000000) {

close(*fd);

errno = E2BIG;

return NULL;

}

// Read file contents

char *buf = malloc(filesize + 1);

if (!buf) {

log_message(LOG_ERR, pamh, "Failed to malloc %d+1", filesize);

goto out;

}

if (filesize != read(*fd, buf, filesize)) {

log_message(LOG_ERR, pamh, "Could not read \"%s\"", secret_filename);

goto out;

}

close(*fd);

*fd = -1;

// The rest of the code assumes that there are no NUL bytes in the file.

if (memchr(buf, 0, filesize)) {

log_message(LOG_ERR, pamh, "Invalid file contents in \"%s\"",

secret_filename);

goto out;

}

// Terminate the buffer with a NUL byte.

buf[filesize] = '\000';

if(params->debug) {

log_message(LOG_INFO, pamh, "debug: \"%s\" read", secret_filename);

}

return buf;

out:

// If we have any data, erase it.

if (buf) {

explicit_bzero(buf, filesize);

}

free(buf);

if (*fd >= 0) {

close(*fd);

*fd = -1;

}

return NULL;

}

static int is_totp(const char *buf) {

return !!strstr(buf, "\" TOTP_AUTH");

}

static int

full_write(int fd, const char* buf, size_t len) {

const char* p = buf;

int errors = 0;

for (;;) {

const ssize_t left = len - (p - buf);

const ssize_t rc = write(fd, p, left);

if (rc == left) {

return 0;

}

if (rc < 0) {

switch (errno) {

case EAGAIN:

case EINTR:

if (errors++ < 3) {

continue;

}

}

return errno;

}

p += rc;

}

}

static int set_selinux_context(int fd) {

int err = 0;

#ifdef HAVE_SELINUX

char *old_context = NULL;

const char *new_context = NULL;

// skip if SELinux is not enabled

if (!is_selinux_enabled()) {

return 1;

}

// Get the current context

if (fgetfilecon(fd, &old_context) < 0) {

return errno;

}

// Create a new context with the type changed

context_t ctx = context_new(old_context);

if (!ctx) {

err = errno;

goto cleanup;

}

if (context_type_set(ctx, SECRET_SELINUX_TYPE) < 0) {

err = errno;

goto cleanup;

}

// Get the SC as string

new_context = context_str(ctx);

if (!new_context) {

err = errno;

goto cleanup;

}

if (fsetfilecon(fd, new_context) < 0) {

err = errno;

goto cleanup;

}

cleanup:

if (ctx) {

context_free(ctx);

}

if (old_context) {

freecon(old_context);

}

return err;

}

static int write_file_contents(pam_handle_t *pamh,

const char *buf) {

int err = 0;

int fd = -1;

const size_t fnlength = strlen(secret_filename) + 1 + 6 + 1;

char *tmp_filename = malloc(fnlength);

if (tmp_filename == NULL) {

err = errno;

goto cleanup;

}

if (fnlength - 1 != snprintf(tmp_filename, fnlength,

"%s~XXXXXX", secret_filename)) {

err = ERANGE;

goto cleanup;

}

const mode_t old_mask = umask(077);

fd = mkstemp(tmp_filename);

umask(old_mask);

if (fd < 0) {

err = errno;

log_message(LOG_ERR, pamh, "Failed to create tempfile \"%s\": %s",

tmp_filename, strerror(err));

// Couldn't open file; don't try to delete it later.

free(tmp_filename);

tmp_filename = NULL;

goto cleanup;

}

if (fchmod(fd, 0400)) {

err = errno;

goto cleanup;

}

// Make sure the secret file is still the same. This prevents attackers

// from opening a lot of pending sessions and then reusing the same

// scratch code multiple times.

//

// (except for the brief race condition between this stat and the

// `rename` below)

{

struct stat sb;

if (stat(secret_filename, &sb) != 0) {

err = errno;

log_message(LOG_ERR, pamh, "stat(): %s", strerror(err));

goto cleanup;

}

if (sb.st_ino != orig_stat->st_ino ||

sb.st_size != orig_stat->st_size ||

sb.st_mtime != orig_stat->st_mtime) {

err = EAGAIN;

log_message(LOG_ERR, pamh,

"Secret file \"%s\" changed while trying to use "

"scratch code\n", secret_filename);

goto cleanup;

}

}

// Write the new file contents.

if ((err = full_write(fd, buf, strlen(buf)))) {

log_message(LOG_ERR, pamh, "write(): %s", strerror(err));

goto cleanup;

}

if (set_selinux_context(fd)) {

log_message(LOG_DEBUG, pamh, "setting SELinux type \"%s\" on file \"%s\" failed. Okay if SELinux is disabled", SECRET_SELINUX_TYPE, secret_filename);

}

if (fsync(fd)) {

err = errno;

log_message(LOG_ERR, pamh, "fsync(): %s", strerror(err));

goto cleanup;

}

if (close(fd)) {

err = errno;

log_message(LOG_ERR, pamh, "close(): %s", strerror(err));

goto cleanup;

}

fd = -1; // Prevent double-close.

// Double-check that the file size is correct.

{

struct stat st;

if (stat(tmp_filename, &st)) {

err = errno;

log_message(LOG_ERR, pamh, "stat(%s): %s", tmp_filename, strerror(err));

goto cleanup;

}

const off_t want = strlen(buf);

if (st.st_size == 0 || (want != st.st_size)) {

err = EAGAIN;

log_message(LOG_ERR, pamh, "temp file size %d. Should be non-zero and %d", st.st_size, want);

goto cleanup;

}

}

if (rename(tmp_filename, secret_filename) != 0) {

err = errno;

log_message(LOG_ERR, pamh, "rename(): %s", strerror(err));

goto cleanup;

}

free(tmp_filename);

tmp_filename = NULL; // Prevent unlink & double-free.

if (params->debug) {

log_message(LOG_INFO, pamh, "debug: \"%s\" written", secret_filename);

}

cleanup:

if (fd >= 0) {

close(fd);

}

if (tmp_filename) {

if (unlink(tmp_filename)) {

log_message(LOG_ERR, pamh, "Failed to delete tempfile \"%s\": %s",

tmp_filename, strerror(errno));

}

}

free(tmp_filename);

if (err) {

log_message(LOG_ERR, pamh, "Failed to update secret file \"%s\": %s",

secret_filename, strerror(err));

return err;

}

return 0;

}

static uint8_t *get_shared_secret(pam_handle_t *pamh,

const Params *params,

const char *secret_filename,

const char *buf, int *secretLen) {

if (!buf) {

return NULL;

}

// Decode secret key

const int base32Len = strcspn(buf, "\n");

// Arbitrary limit to prevent integer overflow.

if (base32Len > 100000) {

return NULL;

}

*secretLen = (base32Len*5 + 7)/8;

uint8_t *secret = malloc(base32Len + 1);

if (secret == NULL) {

*secretLen = 0;

return NULL;

}

memcpy(secret, buf, base32Len);

secret[base32Len] = '\000';

if ((*secretLen = base32_decode(secret, secret, base32Len)) < 1) {

log_message(LOG_ERR, pamh,

"Could not find a valid BASE32 encoded secret in \"%s\"",

secret_filename);

explicit_bzero(secret, base32Len);

free(secret);

return NULL;

}

memset(secret + *secretLen, 0, base32Len + 1 - *secretLen);

if(params->debug) {

log_message(LOG_INFO, pamh, "debug: shared secret in \"%s\" processed", secret_filename);

}

return secret;

}

#ifdef TESTING

static time_t current_time;

void set_time(time_t t) __attribute__((visibility("default")));

void set_time(time_t t) {

current_time = t;

}

static time_t get_time(void) {

return current_time;

}

static time_t get_time(void) {

return time(NULL);

}

static int comparator(const void *a, const void *b) {

return *(unsigned int *)a - *(unsigned int *)b;

}

static char *get_cfg_value(pam_handle_t *pamh, const char *key,

const char *buf) {

const size_t key_len = strlen(key);

for (const char *line = buf; *line; ) {

const char *ptr;

if (line[0] == '"' && line[1] == ' ' && !strncmp(line+2, key, key_len) &&

(!*(ptr = line+2+key_len) || *ptr == ' ' || *ptr == '\t' ||

*ptr == '\r' || *ptr == '\n')) {

ptr += strspn(ptr, " \t");

size_t val_len = strcspn(ptr, "\r\n");

char *val = malloc(val_len + 1);

if (!val) {

log_message(LOG_ERR, pamh, "Out of memory");

return &oom;

} else {

memcpy(val, ptr, val_len);

val[val_len] = '\000';

return val;

}

} else {

line += strcspn(line, "\r\n");

line += strspn(line, "\r\n");

}

}

return NULL;

}

static int set_cfg_value(pam_handle_t *pamh, const char *key, const char *val,

char **buf) {

const size_t key_len = strlen(key);

char *start = NULL;

char *stop = NULL;

// Find an existing line, if any.

for (char *line = *buf; *line; ) {

char *ptr;

if (line[0] == '"' && line[1] == ' ' && !strncmp(line+2, key, key_len) &&

(!*(ptr = line+2+key_len) || *ptr == ' ' || *ptr == '\t' ||

*ptr == '\r' || *ptr == '\n')) {

start = line;

stop = start + strcspn(start, "\r\n");

stop += strspn(stop, "\r\n");

break;

} else {

line += strcspn(line, "\r\n");

line += strspn(line, "\r\n");

}

}

// If no existing line, insert immediately after the first line.

if (!start) {

start = *buf + strcspn(*buf, "\r\n");

start += strspn(start, "\r\n");

stop = start;

}

// Replace [start..stop] with the new contents.

const size_t val_len = strlen(val);

const size_t total_len = key_len + val_len + 4;

if (total_len <= stop - start) {

// We are decreasing out space requirements. Shrink the buffer and pad with

// NUL characters.

const size_t tail_len = strlen(stop);

memmove(start + total_len, stop, tail_len + 1);

memset(start + total_len + tail_len, 0, stop - start - total_len + 1);

} else {

// Must resize existing buffer. We cannot call realloc(), as it could

// leave parts of the buffer content in unused parts of the heap.

const size_t buf_len = strlen(*buf);

const size_t tail_len = buf_len - (stop - *buf);

char *resized = malloc(buf_len - (stop - start) + total_len + 1);

if (!resized) {

log_message(LOG_ERR, pamh, "Out of memory");

return -1;

}

memcpy(resized, *buf, start - *buf);

memcpy(resized + (start - *buf) + total_len, stop, tail_len + 1);

memset(*buf, 0, buf_len);

free(*buf);

start = start - *buf + resized;

*buf = resized;

}

// Fill in new contents.

start[0] = '"';

start[1] = ' ';

memcpy(start + 2, key, key_len);

start[2+key_len] = ' ';

memcpy(start+3+key_len, val, val_len);

start[3+key_len+val_len] = '\n';

// Check if there are any other occurrences of "value". If so, delete them.

for (char *line = start + 4 + key_len + val_len; *line; ) {

char *ptr;

if (line[0] == '"' && line[1] == ' ' && !strncmp(line+2, key, key_len) &&

(!*(ptr = line+2+key_len) || *ptr == ' ' || *ptr == '\t' ||

*ptr == '\r' || *ptr == '\n')) {

start = line;

stop = start + strcspn(start, "\r\n");

stop += strspn(stop, "\r\n");

size_t tail_len = strlen(stop);

memmove(start, stop, tail_len + 1);

memset(start + tail_len, 0, stop - start);

line = start;

} else {

line += strcspn(line, "\r\n");

line += strspn(line, "\r\n");

}

}

return 0;

}

static int step_size(pam_handle_t *pamh, const char *secret_filename,

const char *buf) {

const char *value = get_cfg_value(pamh, "STEP_SIZE", buf);

if (!value) {

// Default step size is 30.

return 30;

} else if (value == &oom) {

// Out of memory. This is a fatal error.

return 0;

}

char *endptr;

errno = 0;

const int step = (int)strtoul(value, &endptr, 10);

if (errno || !*value || value == endptr ||

(*endptr && *endptr != ' ' && *endptr != '\t' &&

*endptr != '\n' && *endptr != '\r') ||

step < 1 || step > 60) {

free((void *)value);

log_message(LOG_ERR, pamh, "Invalid STEP_SIZE option in \"%s\"",

secret_filename);

return 0;

}

free((void *)value);

return step;

}

static int get_timestamp(pam_handle_t *pamh, const char *secret_filename,

const char **buf) {

const int step = step_size(pamh, secret_filename, *buf);

if (!step) {

return 0;

}

return get_time()/step;

}

static long get_hotp_counter(pam_handle_t *pamh, const char *buf) {

if (!buf) {

return -1;

}

const char *counter_str = get_cfg_value(pamh, "HOTP_COUNTER", buf);

if (counter_str == &oom) {

// Out of memory. This is a fatal error

return -1;

}

long counter = 0;

if (counter_str) {

counter = strtol(counter_str, NULL, 10);

}

free((void *)counter_str);

return counter;

}