crypt.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 2012 - 2013, Digium, Inc.
 *
 * David M. Lee, II <[email protected]>
 *
 * See http://www.asterisk.org for more information about
 * the Asterisk project. Please do not directly contact
 * any of the maintainers of this project for assistance;
 * the project provides a web site, mailing lists and IRC
 * channels for your use.
 *
 * This program is free software, distributed under the terms of
 * the GNU General Public License Version 2. See the LICENSE file
 * at the top of the source tree.
 */

/*! \file
 *
 * \brief Asterisk wrapper for crypt(3)
 * \author David M. Lee, II <[email protected]>
 */

/*** MODULEINFO
 <support_level>core</support_level>
 ***/

#include "asterisk.h"

#include <unistd.h>
#if defined(HAVE_CRYPT_R) && !defined(__FreeBSD__)
#include <crypt.h>
#endif

#include "asterisk/utils.h"

/*!
 * \brief Max length of a salt string.
 *
 * $[1,5,6]$[a–zA–Z0–9./]{1,16}$, plus null terminator
 */
#define MAX_SALT_LEN 21

static char salt_chars[] =
 "abcdefghijklmnopqrstuvwxyz"
 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 "0123456789"
 "./";

/*! Randomly select a character for a salt string */
static char gen_salt_char(void)
{
 int which = ast_random_double() * 64;
 return salt_chars[which];
}

/*!
 * \brief Generates a salt to try with crypt.
 *
 * If given an empty string, will generate a salt for the most secure algorithm
 * to try with crypt(). If given a previously generated salt, the algorithm will
 * be lowered by one level of security.
 *
 * \param[out] current_salt Output string in which to generate the salt.
 * This can be an empty string, or the results of a
 * prior gen_salt call.
 * \param max_len Length of \a current_salt.
 * \return 0 on success.
 * \return Non-zero on error.
 */
static int gen_salt(char *current_salt, size_t maxlen)
{
 int i;

 if (maxlen < MAX_SALT_LEN || current_salt == NULL) {
 return -1;
 }

 switch (current_salt[0]) {
 case '\0':
 /* Initial generation; $6$ = SHA-512 */
 *current_salt++ = '$';
 *current_salt++ = '6';
 *current_salt++ = '$';
 for (i = 0; i < 16; ++i) {
 *current_salt++ = gen_salt_char();
 }
 *current_salt++ = '$';
 *current_salt++ = '\0';
 return 0;
 case '$':
 switch (current_salt[1]) {
 case '6':
 /* Downgrade to SHA-256 */
 current_salt[1] = '5';
 return 0;
 case '5':
 /* Downgrade to MD5 */
 current_salt[1] = '1';
 return 0;
 case '1':
 /* Downgrade to traditional crypt */
 *current_salt++ = gen_salt_char();
 *current_salt++ = gen_salt_char();
 *current_salt++ = '\0';
 return 0;
 default:
 /* Unrecognized algorithm */
 return -1;
 }
 default:
 /* Was already as insecure as it gets */
 return -1;
 }

}

#if defined(HAVE_CRYPT_R)

char *ast_crypt(const char *key, const char *salt)
{
 struct crypt_data data = {};
 const char *crypted = crypt_r(key, salt, &data);

 /* Crypt may return success even if it doesn't recognize the salt. But
 * in those cases it always mangles the salt in some way.
 */
 if (!crypted || !ast_begins_with(crypted, salt)) {
 return NULL;
 }

 return ast_strdup(crypted);
}

int ast_crypt_validate(const char *key, const char *expected)
{
 struct crypt_data data = {};
 return strcmp(expected, crypt_r(key, expected, &data)) == 0;
}

#elif defined(HAVE_CRYPT)

/* crypt is not reentrant. A global mutex is neither ideal nor perfect, but good
 * enough if crypt_r support is unavailable
 */
AST_MUTEX_DEFINE_STATIC(crypt_mutex);

char *ast_crypt(const char *key, const char *salt)
{
 const char *crypted;
 SCOPED_MUTEX(lock, &crypt_mutex);

 crypted = crypt(key, salt);

 /* Crypt may return success even if it doesn't recognize the salt. But
 * in those cases it always mangles the salt in some way.
 */
 if (!crypted || !ast_begins_with(crypted, salt)) {
 return NULL;
 }

 return ast_strdup(crypted);
}

int ast_crypt_validate(const char *key, const char *expected)
{
 SCOPED_MUTEX(lock, &crypt_mutex);
 return strcmp(expected, crypt(key, expected)) == 0;
}

#else /* No crypt support */

char *ast_crypt(const char *key, const char *salt)
{
 ast_log(LOG_WARNING,
 "crypt() support not available; cannot encrypt password\n");
 return NULL;
}

int ast_crypt_validate(const char *key, const char *expected)
{
 ast_log(LOG_WARNING,
 "crypt() support not available; cannot validate password\n");
 return 0;
}

#endif /* No crypt support */

char *ast_crypt_encrypt(const char *key)
{
 char salt[MAX_SALT_LEN] = {};
 while (gen_salt(salt, sizeof(salt)) == 0) {
 char *crypted = ast_crypt(key, salt);
 if (crypted) {
 return crypted;
 }
 }
 return NULL;
}