/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (the "License").

 * You may not use this file except in compliance with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

#pragma	weak _crypt = crypt

#pragma weak _encrypt = encrypt

#pragma weak _setkey = setkey

#include "lint.h"

#include "mtlib.h"

#include <synch.h>

#include <thread.h>

#include <ctype.h>

#include <dlfcn.h>

#include <errno.h>

#include <stdio.h>

#include <strings.h>

#include <stdlib.h>

#include <sys/time.h>

#include <limits.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <syslog.h>

#include <unistd.h>

#include <atomic.h>

#include <crypt.h>

#include <libc.h>

#include "tsd.h"

#define	CRYPT_ALGORITHMS_ALLOW		"CRYPT_ALGORITHMS_ALLOW"

#define	CRYPT_ALGORITHMS_DEPRECATE	"CRYPT_ALGORITHMS_DEPRECATE"

#define	CRYPT_DEFAULT			"CRYPT_DEFAULT"

#define	CRYPT_UNIX			"__unix__"

#define	CRYPT_CONFFILE		"/etc/security/crypt.conf"

#define	POLICY_CONF_FILE	"/etc/security/policy.conf"

#define	CRYPT_CONFLINELENGTH	1024

#define	CRYPT_MODULE_ISA	"/$ISA/"

#ifdef	_LP64

#define	CRYPT_MODULE_DIR	"/usr/lib/security/64/"

#define	CRYPT_ISA_DIR		"/64/"

#else	/* !_LP64 */

#define	CRYPT_MODULE_DIR	"/usr/lib/security/"

#define	CRYPT_ISA_DIR		"/"

#endif	/* _LP64 */

/*

 * MAX_ALGNAME_LEN:

 *

 * In practical terms this is probably never any bigger than about 10, but...

 *

 * It has to fix the encrypted password filed of struct spwd it is

 * theoretically the maximum length of the cipher minus the magic $ sign.

 * Though that would be unexpected.

 * Since it also has to fit in crypt.conf it is CRYPT_CONFLINELENGTH

 * minus the path to the module and the minimum white space.

 *

 * CRYPT_MAXCIPHERTEXTLEN is defined in crypt.h and is smaller than

 * CRYPT_CONFLINELENGTH, and probably always will be.

 */

#define	MAX_ALGNAME_LEN	(CRYPT_MAXCIPHERTEXTLEN - 1)

struct crypt_alg_s {

	void	*a_libhandle;

	char	*(*a_genhash)(char *, const size_t, const char *,

		    const char *, const char **);

	char	*(*a_gensalt)(char *, const size_t,

		    const char *, const struct passwd *, const char **);

	char	**a_params;

	int	a_nparams;

};

struct crypt_policy_s {

	char	*cp_default;

	char	*cp_allow;

	char	*cp_deny;

};

enum crypt_policy_error_e {

	CPE_BOTH = 1,

	CPE_MULTI

};

static struct crypt_policy_s *getcryptpolicy(void);

static void free_crypt_policy(struct crypt_policy_s *policy);

static struct crypt_alg_s  *getalgbyname(const char *algname, boolean_t *found);

static void free_crypt_alg(struct crypt_alg_s *alg);

static char *getalgfromsalt(const char *salt);

static boolean_t alg_valid(const char *algname,

    const struct crypt_policy_s *policy);

static char *isa_path(const char *path);

static char *_unix_crypt(const char *pw, const char *salt, char *iobuf);

static char *_unix_crypt_gensalt(char *gsbuffer, size_t gsbufflen,

	    const char *oldpuresalt, const struct passwd *userinfo,

	    const char *params[]);

/*

 * crypt - string encoding function

 *

 * This function encodes strings in a suitable for for secure storage

 * as passwords.  It generates the password hash given the plaintext and salt.

 *

 * If the first character of salt is "$" then we use crypt.conf(4) to

 * determine which plugin to use and run the crypt_genhash_impl(3c) function

 * from it.

 * Otherwise we use the old unix algorithm.

 *

 * RETURN VALUES

 *	On Success we return a pointer to the encoded string.  The

 *	return value points to thread specific static data and should NOT

 *	be passed free(3c).

 *	On failure we return NULL and set errno to one of:

 *		EINVAL, ELIBACC, ENOMEM, ENOSYS.

 */

char *

crypt(const char *plaintext, const char *salt)

{

	struct crypt_alg_s *alg;

	char *ctbuffer;

	char *ciphertext;

	char *algname;

	boolean_t found;

	ctbuffer = tsdalloc(_T_CRYPT, CRYPT_MAXCIPHERTEXTLEN, NULL);

	if (ctbuffer == NULL)

		return (NULL);

	bzero(ctbuffer, CRYPT_MAXCIPHERTEXTLEN);

	/*

	 * '$' is never a possible salt char with the traditional unix

	 * algorithm.  If the salt passed in is NULL or the first char

	 * of the salt isn't a $ then do the traditional thing.

	 * We also do the traditional thing if the salt is only 1 char.

	 */

	if (salt == NULL || salt[0] != '$' || strlen(salt) == 1) {

		return (_unix_crypt(plaintext, salt, ctbuffer));

	}

	/*

	 * Find the algorithm name from the salt and look it up in

	 * crypt.conf(4) to find out what shared object to use.

	 * If we can't find it in crypt.conf then getalgbyname would

	 * have returned with found = B_FALSE so we use the unix algorithm.

	 * If alg is NULL but found = B_TRUE then there is a problem with

	 * the plugin so we fail leaving errno set to what getalgbyname()

	 * set it to or EINVAL it if wasn't set.

	 */

	if ((algname = getalgfromsalt(salt)) == NULL) {

		return (NULL);

	}

	errno = 0;

	alg = getalgbyname(algname, &found);

	if ((alg == NULL) || !found) {

		if (errno == 0)

			errno = EINVAL;

		ciphertext = NULL;

		goto cleanup;

	} else if (!found) {

		ciphertext = _unix_crypt(plaintext, salt, ctbuffer);

	} else {

		ciphertext = alg->a_genhash(ctbuffer, CRYPT_MAXCIPHERTEXTLEN,

		    plaintext, salt, (const char **)alg->a_params);

	}

cleanup:

	free_crypt_alg(alg);

	if (algname != NULL)

		free(algname);

	return (ciphertext);

}

/*

 * crypt_gensalt - generate salt string for string encoding

 *

 * This function generates the salt string pased to crypt(3c).

 * If oldsalt is NULL, the use the default algorithm.

 * Other wise check the policy in policy.conf to ensure that it is

 * either still allowed or not deprecated.

 *

 * RETURN VALUES

 * 	Return a pointer to the new salt, the caller is responsible

 * 	for using free(3c) on the return value.

 * 	Returns NULL on error and sets errno to one of:

 * 		EINVAL, ELIBACC, ENOMEM

 */

char *

crypt_gensalt(const char *oldsalt, const struct passwd *userinfo)

{

	struct crypt_alg_s *alg = NULL;

	struct crypt_policy_s *policy = NULL;

	char *newsalt = NULL;

	char *gsbuffer;

	char *algname = NULL;

	boolean_t found;

	gsbuffer = calloc(CRYPT_MAXCIPHERTEXTLEN, sizeof (char *));

	if (gsbuffer == NULL) {

		errno = ENOMEM;

		goto cleanup;

	}

	policy = getcryptpolicy();

	if (policy == NULL) {

		errno = EINVAL;

		goto cleanup;

	}

	algname = getalgfromsalt(oldsalt);

	if (!alg_valid(algname, policy)) {

		free(algname);

		algname = strdup(policy->cp_default);

	}

	if (strcmp(algname, CRYPT_UNIX) == 0) {

		newsalt = _unix_crypt_gensalt(gsbuffer, CRYPT_MAXCIPHERTEXTLEN,

		    oldsalt, userinfo, NULL);

	} else {

		errno = 0;

		alg = getalgbyname(algname, &found);

		if (alg == NULL || !found) {

			if (errno == 0)

				errno = EINVAL;

			goto cleanup;

		}

		newsalt = alg->a_gensalt(gsbuffer, CRYPT_MAXCIPHERTEXTLEN,

		    oldsalt, userinfo, (const char **)alg->a_params);

	}

cleanup:

	free_crypt_policy(policy);

	free_crypt_alg(alg);

	if (newsalt == NULL && gsbuffer != NULL)

		free(gsbuffer);

	if (algname != NULL)

		free(algname);

	return (newsalt);

}

/*

 * ===========================================================================

 * The remainder of this file contains internal interfaces for

 * the implementation of crypt(3c) and crypt_gensalt(3c)

 * ===========================================================================

 */

/*

 * getalgfromsalt - extract the algorithm name from the salt string

 */

static char *

getalgfromsalt(const char *salt)

{

	char algname[CRYPT_MAXCIPHERTEXTLEN];

	int i;

	int j;

	if (salt == NULL || strlen(salt) > CRYPT_MAXCIPHERTEXTLEN)

		return (NULL);

	/*

	 * Salts are in this format:

	 * $<algname>[,var=val,[var=val ...][$puresalt]$<ciphertext>

	 *

	 * The only bit we need to worry about here is extracting the

	 * name which is the string between the first "$" and the first

	 * of "," or second "$".

	 */

	if (salt[0] != '$') {

		return (strdup(CRYPT_UNIX));

	}

	i = 1;

	j = 0;

	while (salt[i] != '\0' && salt[i] != '$' && salt[i] != ',') {

		algname[j] = salt[i];

		i++;

		j++;

	}

	if (j == 0)

		return (NULL);

	algname[j] = '\0';

	return (strdup(algname));

}

/*

 * log_invalid_policy - syslog helper

 */

static void

log_invalid_policy(enum crypt_policy_error_e error, char *value)

{

	switch (error) {

	case CPE_BOTH:

		syslog(LOG_AUTH | LOG_ERR,

		    "crypt(3c): %s contains both %s and %s; only one may be "

		    "specified, using first entry in file.", POLICY_CONF_FILE,

		    CRYPT_ALGORITHMS_ALLOW, CRYPT_ALGORITHMS_DEPRECATE);

		break;

	case CPE_MULTI:

		syslog(LOG_AUTH | LOG_ERR,

		    "crypt(3c): %s contains multiple %s entries;"

		    "using first entry file.", POLICY_CONF_FILE, value);

		break;

	}

}

static char *

getval(const char *ival)

{

	char *tmp;

	char *oval;

	int off;

	if (ival == NULL)

		return (NULL);

	if ((tmp = strchr(ival, '=')) == NULL)

		return (NULL);

	oval = strdup(tmp + 1);	/* everything after the "=" */

	if (oval == NULL)

		return (NULL);

	off = strlen(oval) - 1;

	if (off < 0) {

		free(oval);

		return (NULL);

	}

	if (oval[off] == '\n')

		oval[off] = '\0';

	return (oval);

}

/*

 * getcryptpolicy - read /etc/security/policy.conf into a crypt_policy_s

 */

static struct crypt_policy_s *

getcryptpolicy(void)

{

	FILE	*pconf;

	char	line[BUFSIZ];

	struct crypt_policy_s *policy;

	if ((pconf = fopen(POLICY_CONF_FILE, "rF")) == NULL) {

		return (NULL);

	}

	policy = malloc(sizeof (struct crypt_policy_s));

	if (policy == NULL) {

		return (NULL);

	}

	policy->cp_default = NULL;

	policy->cp_allow = NULL;

	policy->cp_deny = NULL;

	while (!feof(pconf) &&

	    (fgets(line, sizeof (line), pconf) != NULL)) {

		if (strncasecmp(CRYPT_DEFAULT, line,

		    strlen(CRYPT_DEFAULT)) == 0) {

			if (policy->cp_default != NULL) {

				log_invalid_policy(CPE_MULTI, CRYPT_DEFAULT);

			} else {

				policy->cp_default = getval(line);

			}

		}

		if (strncasecmp(CRYPT_ALGORITHMS_ALLOW, line,

		    strlen(CRYPT_ALGORITHMS_ALLOW)) == 0) {

			if (policy->cp_deny != NULL) {

				log_invalid_policy(CPE_BOTH, NULL);

			} else if (policy->cp_allow != NULL) {

				log_invalid_policy(CPE_MULTI,

				    CRYPT_ALGORITHMS_ALLOW);

			} else {

				policy->cp_allow = getval(line);

			}

		}

		if (strncasecmp(CRYPT_ALGORITHMS_DEPRECATE, line,

		    strlen(CRYPT_ALGORITHMS_DEPRECATE)) == 0) {

			if (policy->cp_allow != NULL) {

				log_invalid_policy(CPE_BOTH, NULL);

			} else if (policy->cp_deny != NULL) {

				log_invalid_policy(CPE_MULTI,

				    CRYPT_ALGORITHMS_DEPRECATE);

			} else {

				policy->cp_deny = getval(line);

			}

		}

	}

	(void) fclose(pconf);

	if (policy->cp_default == NULL) {

		policy->cp_default = strdup(CRYPT_UNIX);

		if (policy->cp_default == NULL)

			free_crypt_policy(policy);

	}

	return (policy);

}

/*

 * alg_valid - is this algorithm valid given the policy ?

 */

static boolean_t

alg_valid(const char *algname, const struct crypt_policy_s *policy)

{

	char *lasts;

	char *list;

	char *entry;

	boolean_t allowed = B_FALSE;

	if ((algname == NULL) || (policy == NULL)) {

		return (B_FALSE);

	}

	if (strcmp(algname, policy->cp_default) == 0) {

		return (B_TRUE);

	}

	if (policy->cp_deny != NULL) {

		list = policy->cp_deny;

		allowed = B_FALSE;

	} else if (policy->cp_allow != NULL) {

		list = policy->cp_allow;

		allowed = B_TRUE;

	} else {

		/*

		 * Neither of allow or deny policies are set so anything goes.

		 */

		return (B_TRUE);

	}

	lasts = list;

	while ((entry = strtok_r(NULL, ",", &lasts)) != NULL) {

		if (strcmp(entry, algname) == 0) {

			return (allowed);

		}

	}

	return (!allowed);

}

/*

 * getalgbyname - read crypt.conf(4) looking for algname

 *

 * RETURN VALUES

 *	On error NULL and errno is set

 *	On success the alg details including an open handle to the lib

 *	If crypt.conf(4) is okay but algname doesn't exist in it then

 *	return NULL the caller should then use the default algorithm

 *	as per the policy.

 */

static struct crypt_alg_s *

getalgbyname(const char *algname, boolean_t *found)

{

	struct stat	stb;

	int		configfd;

	FILE		*fconf = NULL;

	struct crypt_alg_s *alg = NULL;

	char		line[CRYPT_CONFLINELENGTH];

	int		linelen = 0;

	int		lineno = 0;

	char		*pathname = NULL;

	char		*lasts = NULL;

	char		*token = NULL;

	*found = B_FALSE;

	if ((algname == NULL) || (strcmp(algname, CRYPT_UNIX) == 0)) {

		return (NULL);

	}

	if ((configfd = open(CRYPT_CONFFILE, O_RDONLY)) == -1) {

		syslog(LOG_ALERT, "crypt: open(%s) failed: %s",

		    CRYPT_CONFFILE, strerror(errno));

		return (NULL);

	}

	/*

	 * Stat the file so we can check modes and ownerships

	 */

	if (fstat(configfd, &stb) < 0) {

		syslog(LOG_ALERT, "crypt: stat(%s) failed: %s",

		    CRYPT_CONFFILE, strerror(errno));

		goto cleanup;

	}

	/*

	 * Check the ownership of the file

	 */

	if (stb.st_uid != (uid_t)0) {

		syslog(LOG_ALERT,

		    "crypt: Owner of %s is not root", CRYPT_CONFFILE);

		goto cleanup;

	}