crypto/nss/nss_sha512crypt.c

	nss_sha512crypt.c revision 2951a9a84bd85f384213a3e071ffc167907df2d7
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce/* This file is based on the work of Ulrich Drepper
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce * (http://people.redhat.com/drepper/SHA-crypt.txt). I have replaced the
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce * included SHA512 implementation by calls to NSS
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce * (http://www.mozilla.org/projects/security/pki/nss/).
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce *
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce *  Sumit Bose <sbose@redhat.com>
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce */
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce/* SHA512-based UNIX crypt implementation.
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce   Released into the Public Domain by Ulrich Drepper <drepper@redhat.com>.  */
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce#include "config.h"
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce#include <errno.h>
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce#include <limits.h>
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce#include <stdbool.h>
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce#include <stdint.h>
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce#include <stdio.h>
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce#include <stdlib.h>
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce#include <string.h>
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce#include <sys/param.h>
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce#include <sys/types.h>
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce#include "util/util.h"
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce#include "util/sss_endian.h"
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce#include "util/crypto/nss/nss_util.h"
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce
8f2a34cc6964a1f80a1434e05315a7ae0bb5774eSimo Sorce#include <prinit.h>
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce#include <nss.h>
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce#include <sechash.h>
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce#include <pk11func.h>
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce/* Define our magic string to mark salt for SHA512 "encryption" replacement. */
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorceconst char sha512_salt_prefix[] = "$6$";
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce#define SALT_PREF_SIZE (sizeof(sha512_salt_prefix) - 1)
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce/* Prefix for optional rounds specification. */
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorceconst char sha512_rounds_prefix[] = "rounds=";
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce#define ROUNDS_SIZE (sizeof(sha512_rounds_prefix) - 1)
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce#define SALT_LEN_MAX 16
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce#define ROUNDS_DEFAULT 5000
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce#define ROUNDS_MIN 1000
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce#define ROUNDS_MAX 999999999
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce/* Table with characters for base64 transformation.  */
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorceconst char b64t[64] =
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce    "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce/* base64 conversion function */
41cd6072648bb7a9e14e56ed38004a2947f67657Jakub Hrozekstatic inline void b64_from_24bit(char **dest, size_t *len, size_t n,
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce                                  uint8_t b2, uint8_t b1, uint8_t b0)
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce{
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce    uint32_t w;
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce    size_t i;
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce    if (*len < n) n = *len;
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce    w = (b2 << 16) | (b1 << 8) | b0;
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce    for (i = 0; i < n; i++) {
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce        (*dest)[i] = b64t[w & 0x3f];
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce        w >>= 6;
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce    }
8f2a34cc6964a1f80a1434e05315a7ae0bb5774eSimo Sorce
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce    *len -= i;
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce    *dest += i;
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce}
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce#define PTR_2_INT(x) ((x) - ((__typeof__ (x)) NULL))
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce#define ALIGN64 __alignof__(uint64_t)
8f2a34cc6964a1f80a1434e05315a7ae0bb5774eSimo Sorce
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorcestatic int sha512_crypt_r(const char *key,
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce                          const char *salt,
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce                          char *buffer, size_t buflen)
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce{
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce    unsigned char temp_result[64] __attribute__((__aligned__(ALIGN64)));
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce    unsigned char alt_result[64] __attribute__((__aligned__(ALIGN64)));
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce    size_t rounds = ROUNDS_DEFAULT;
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce    bool rounds_custom = false;
8f2a34cc6964a1f80a1434e05315a7ae0bb5774eSimo Sorce    HASHContext *alt_ctx = NULL;
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce    HASHContext *ctx = NULL;
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce    size_t salt_len;
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce    size_t key_len;
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce    size_t cnt;
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce    char *copied_salt = NULL;
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce    char *copied_key = NULL;
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce    char *p_bytes = NULL;
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce    char *s_bytes = NULL;
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce    int p1, p2, p3, pt, n;
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce    unsigned int part;
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce    char *cp, *tmp;
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce    int ret;
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce    /* Find beginning of salt string. The prefix should normally always be
8f2a34cc6964a1f80a1434e05315a7ae0bb5774eSimo Sorce     * present. Just in case it is not. */
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce    if (strncmp(salt, sha512_salt_prefix, SALT_PREF_SIZE) == 0) {
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce        /* Skip salt prefix.  */
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce        salt += SALT_PREF_SIZE;
8f2a34cc6964a1f80a1434e05315a7ae0bb5774eSimo Sorce    }
8f2a34cc6964a1f80a1434e05315a7ae0bb5774eSimo Sorce
8f2a34cc6964a1f80a1434e05315a7ae0bb5774eSimo Sorce    if (strncmp(salt, sha512_rounds_prefix, ROUNDS_SIZE) == 0) {
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce        unsigned long int srounds;
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce        const char *num;
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce        char *endp;
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce        num = salt + ROUNDS_SIZE;
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce        srounds = strtoul(num, &endp, 10);
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce        if (*endp == '$') {
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce            salt = endp + 1;
8f2a34cc6964a1f80a1434e05315a7ae0bb5774eSimo Sorce            if (srounds < ROUNDS_MIN) srounds = ROUNDS_MIN;
8f2a34cc6964a1f80a1434e05315a7ae0bb5774eSimo Sorce            if (srounds > ROUNDS_MAX) srounds = ROUNDS_MAX;
8f2a34cc6964a1f80a1434e05315a7ae0bb5774eSimo Sorce            rounds = srounds;
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce            rounds_custom = true;
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce        }
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce    }
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce    salt_len = MIN(strcspn(salt, "$"), SALT_LEN_MAX);
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce    key_len = strlen(key);
8f2a34cc6964a1f80a1434e05315a7ae0bb5774eSimo Sorce
8f2a34cc6964a1f80a1434e05315a7ae0bb5774eSimo Sorce    if ((PTR_2_INT(key) % ALIGN64) != 0) {
8f2a34cc6964a1f80a1434e05315a7ae0bb5774eSimo Sorce        tmp = (char *)alloca(key_len + ALIGN64);
8f2a34cc6964a1f80a1434e05315a7ae0bb5774eSimo Sorce        key = copied_key = memcpy(tmp + ALIGN64 - PTR_2_INT(tmp) % ALIGN64, key, key_len);
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce    }
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce    if (PTR_2_INT(salt) % ALIGN64 != 0) {
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce        tmp = (char *)alloca(salt_len + ALIGN64);
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce        salt = copied_salt = memcpy(tmp + ALIGN64 - PTR_2_INT(tmp) % ALIGN64, salt, salt_len);
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce    }
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce    ret = nspr_nss_init();
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce    if (ret != EOK) {
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce        ret = EIO;
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce        goto done;
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce    }
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce
e625eb47a3091d92eda2271b123f8aab06227b63Simo Sorce    ctx = HASH_Create(HASH_AlgSHA512);
e625eb47a3091d92eda2271b123f8aab06227b63Simo Sorce    if (!ctx) {
e625eb47a3091d92eda2271b123f8aab06227b63Simo Sorce        ret = EIO;
8f2a34cc6964a1f80a1434e05315a7ae0bb5774eSimo Sorce        goto done;
8f2a34cc6964a1f80a1434e05315a7ae0bb5774eSimo Sorce    }
8f2a34cc6964a1f80a1434e05315a7ae0bb5774eSimo Sorce
8f2a34cc6964a1f80a1434e05315a7ae0bb5774eSimo Sorce    alt_ctx = HASH_Create(HASH_AlgSHA512);
8f2a34cc6964a1f80a1434e05315a7ae0bb5774eSimo Sorce    if (!alt_ctx) {
8f2a34cc6964a1f80a1434e05315a7ae0bb5774eSimo Sorce        ret = EIO;
8f2a34cc6964a1f80a1434e05315a7ae0bb5774eSimo Sorce        goto done;
1dd679584241a0f9b29072c7eed1c5c5e4a577e4Simo Sorce    }

    /* Prepare for the real work.  */
    HASH_Begin(ctx);

    /* Add the key string.  */
    HASH_Update(ctx, (const unsigned char *)key, key_len);

    /* The last part is the salt string. This must be at most 16
     * characters and it ends at the first `$' character (for
     * compatibility with existing implementations). */
    HASH_Update(ctx, (const unsigned char *)salt, salt_len);


    /* Compute alternate SHA512 sum with input KEY, SALT, and KEY.
     * The final result will be added to the first context. */
    HASH_Begin(alt_ctx);

    /* Add key. */
    HASH_Update(alt_ctx, (const unsigned char *)key, key_len);

    /* Add salt. */
    HASH_Update(alt_ctx, (const unsigned char *)salt, salt_len);

    /* Add key again. */
    HASH_Update(alt_ctx, (const unsigned char *)key, key_len);

    /* Now get result of this (64 bytes) and add it to the other context. */
    HASH_End(alt_ctx, alt_result, &part, HASH_ResultLenContext(alt_ctx));

    /* Add for any character in the key one byte of the alternate sum. */
    for (cnt = key_len; cnt > 64; cnt -= 64) {
        HASH_Update(ctx, alt_result, 64);
    }
    HASH_Update(ctx, alt_result, cnt);

    /* Take the binary representation of the length of the key and for every
     * 1 add the alternate sum, for every 0 the key. */
    for (cnt = key_len; cnt > 0; cnt >>= 1) {
        if ((cnt & 1) != 0) {
            HASH_Update(ctx, alt_result, 64);
        } else {
            HASH_Update(ctx, (const unsigned char *)key, key_len);
        }
    }

    /* Create intermediate result. */
    HASH_End(ctx, alt_result, &part, HASH_ResultLenContext(ctx));

    /* Start computation of P byte sequence. */
    HASH_Begin(alt_ctx);

    /* For every character in the password add the entire password. */
    for (cnt = 0; cnt < key_len; cnt++) {
        HASH_Update(alt_ctx, (const unsigned char *)key, key_len);
    }

    /* Finish the digest. */
    HASH_End(alt_ctx, temp_result, &part, HASH_ResultLenContext(alt_ctx));

    /* Create byte sequence P. */
    cp = p_bytes = alloca(key_len);
    for (cnt = key_len; cnt >= 64; cnt -= 64) {
        cp = mempcpy(cp, temp_result, 64);
    }
    memcpy(cp, temp_result, cnt);

    /* Start computation of S byte sequence. */
    HASH_Begin(alt_ctx);

    /* For every character in the password add the entire salt. */
    for (cnt = 0; cnt < 16 + alt_result[0]; cnt++) {
        HASH_Update(alt_ctx, (const unsigned char *)salt, salt_len);
    }

    /* Finish the digest. */
    HASH_End(alt_ctx, temp_result, &part, HASH_ResultLenContext(alt_ctx));

    /* Create byte sequence S.  */
    cp = s_bytes = alloca(salt_len);
    for (cnt = salt_len; cnt >= 64; cnt -= 64) {
        cp = mempcpy(cp, temp_result, 64);
    }
    memcpy(cp, temp_result, cnt);

    /* Repeatedly run the collected hash value through SHA512 to burn CPU cycles. */
    for (cnt = 0; cnt < rounds; cnt++) {

        HASH_Begin(ctx);

        /* Add key or last result. */
        if ((cnt & 1) != 0) {
            HASH_Update(ctx, (const unsigned char *)p_bytes, key_len);
        } else {
            HASH_Update(ctx, alt_result, 64);
        }

        /* Add salt for numbers not divisible by 3. */
        if (cnt % 3 != 0) {
            HASH_Update(ctx, (const unsigned char *)s_bytes, salt_len);
        }

        /* Add key for numbers not divisible by 7. */
        if (cnt % 7 != 0) {
            HASH_Update(ctx, (const unsigned char *)p_bytes, key_len);
        }

        /* Add key or last result. */
        if ((cnt & 1) != 0) {
            HASH_Update(ctx, alt_result, 64);
        } else {
            HASH_Update(ctx, (const unsigned char *)p_bytes, key_len);
        }

        /* Create intermediate result. */
        HASH_End(ctx, alt_result, &part, HASH_ResultLenContext(ctx));
    }

    /* Now we can construct the result string.
     * It consists of three parts. */
    if (buflen <= SALT_PREF_SIZE) {
        ret = ERANGE;
        goto done;
    }

    cp = memcpy(buffer, sha512_salt_prefix, SALT_PREF_SIZE);
    buflen -= SALT_PREF_SIZE;

    if (rounds_custom) {
        n = snprintf(cp, buflen, "%s%zu$",
                     sha512_rounds_prefix, rounds);
        if (n < 0 || n >= buflen) {
            ret = ERANGE;
            goto done;
        }
        cp += n;
        buflen -= n;
    }

    if (buflen <= salt_len + 1) {
        ret = ERANGE;
        goto done;
    }
    cp = stpncpy(cp, salt, salt_len);
    *cp++ = '$';
    buflen -= salt_len + 1;

    /* fuzzyfill the base 64 string */
    p1 = 0;
    p2 = 21;
    p3 = 42;
    for (n = 0; n < 21; n++) {
        b64_from_24bit(&cp, &buflen, 4, alt_result[p1], alt_result[p2], alt_result[p3]);
        if (buflen == 0) {
            ret = ERANGE;
            goto done;
        }
        pt = p1;
        p1 = p2 + 1;
        p2 = p3 + 1;
        p3 = pt + 1;
    }
    /* 64th and last byte */
    b64_from_24bit(&cp, &buflen, 2, 0, 0, alt_result[p3]);
    if (buflen == 0) {
        ret = ERANGE;
        goto done;
    }

    *cp = '\0';
    ret = EOK;

done:
    /* Clear the buffer for the intermediate result so that people attaching
     * to processes or reading core dumps cannot get any information. We do it
     * in this way to clear correct_words[] inside the SHA512 implementation
     * as well.  */
    if (ctx) HASH_Destroy(ctx);
    if (alt_ctx) HASH_Destroy(alt_ctx);
    if (p_bytes) memset(p_bytes, '\0', key_len);
    if (s_bytes) memset(s_bytes, '\0', salt_len);
    if (copied_key) memset(copied_key, '\0', key_len);
    if (copied_salt) memset(copied_salt, '\0', salt_len);
    memset(temp_result, '\0', sizeof(temp_result));

    return ret;
}

int s3crypt_sha512(TALLOC_CTX *memctx,
                   const char *key, const char *salt, char **_hash)
{
    char *hash;
    int hlen = (sizeof (sha512_salt_prefix) - 1
                + sizeof (sha512_rounds_prefix) + 9 + 1
                + strlen (salt) + 1 + 86 + 1);
    int ret;

    hash = talloc_size(memctx, hlen);
    if (!hash) return ENOMEM;

    ret = sha512_crypt_r(key, salt, hash, hlen);
    if (ret) return ret;

    *_hash = hash;
    return ret;
}

#define SALT_RAND_LEN 12

int s3crypt_gen_salt(TALLOC_CTX *memctx, char **_salt)
{
    uint8_t rb[SALT_RAND_LEN];
    char *salt, *cp;
    size_t slen;
    int ret;

    ret = nspr_nss_init();
    if (ret != EOK) {
        return EIO;
    }

    salt = talloc_size(memctx, SALT_LEN_MAX + 1);
    if (!salt) {
        return ENOMEM;
    }

    ret = PK11_GenerateRandom(rb, SALT_RAND_LEN);
    if (ret != SECSuccess) {
        return EIO;
    }

    slen = SALT_LEN_MAX;
    cp = salt;
    b64_from_24bit(&cp, &slen, 4, rb[0], rb[1], rb[2]);
    b64_from_24bit(&cp, &slen, 4, rb[3], rb[4], rb[5]);
    b64_from_24bit(&cp, &slen, 4, rb[6], rb[7], rb[8]);
    b64_from_24bit(&cp, &slen, 4, rb[9], rb[10], rb[11]);
    *cp = '\0';

    *_salt = salt;

    return EOK;
}