auth-scram.c File Reference

#include "postgres.h"
#include <unistd.h>
#include "access/xlog.h"
#include "catalog/pg_authid.h"
#include "catalog/pg_control.h"
#include "common/base64.h"
#include "common/saslprep.h"
#include "common/scram-common.h"
#include "common/sha2.h"
#include "libpq/auth.h"
#include "libpq/crypt.h"
#include "libpq/scram.h"
#include "miscadmin.h"
#include "utils/builtins.h"
#include "utils/timestamp.h"

Include dependency graph for auth-scram.c:

Go to the source code of this file.

Data Structures
struct	scram_state

Enumerations
enum	scram_state_enum { SCRAM_AUTH_INIT, SCRAM_AUTH_SALT_SENT, SCRAM_AUTH_FINISHED }

Functions
static void	read_client_first_message (scram_state *state, const char *input)
static void	read_client_final_message (scram_state *state, const char *input)
static char *	build_server_first_message (scram_state *state)
static char *	build_server_final_message (scram_state *state)
static bool	verify_client_proof (scram_state *state)
static bool	verify_final_nonce (scram_state *state)
static void	mock_scram_secret (const char *username, int *iterations, char **salt, uint8 *stored_key, uint8 *server_key)
static bool	is_scram_printable (char *p)
static char *	sanitize_char (char c)
static char *	sanitize_str (const char *s)
static char *	scram_mock_salt (const char *username)
void	pg_be_scram_get_mechanisms (Port *port, StringInfo buf)
void *	pg_be_scram_init (Port *port, const char *selected_mech, const char *shadow_pass)
int	pg_be_scram_exchange (void *opaq, const char *input, int inputlen, char **output, int *outputlen, char **logdetail)
char *	pg_be_scram_build_secret (const char *password)
bool	scram_verify_plain_password (const char *username, const char *password, const char *secret)
bool	parse_scram_secret (const char *secret, int *iterations, char **salt, uint8 *stored_key, uint8 *server_key)
static char *	read_attr_value (char **input, char attr)
static char *	read_any_attr (char **input, char *attr_p)

Enumeration Type Documentation

scram_state_enum

enum scram_state_enum

Enumerator
SCRAM_AUTH_INIT
SCRAM_AUTH_SALT_SENT
SCRAM_AUTH_FINISHED

Definition at line 112 of file auth-scram.c.

{
    SCRAM_AUTH_INIT,
    SCRAM_AUTH_SALT_SENT,
    SCRAM_AUTH_FINISHED
} scram_state_enum;

Function Documentation

build_server_final_message()

static char * build_server_final_message ( scram_state *  state )

static

Definition at line 1341 of file auth-scram.c.

References scram_state::client_final_message_without_proof, scram_state::client_first_message_bare, elog, ERROR, palloc(), pg_b64_enc_len(), pg_b64_encode(), psprintf(), scram_HMAC_final(), scram_HMAC_init(), scram_HMAC_update(), SCRAM_KEY_LEN, scram_state::server_first_message, and scram_state::ServerKey.

Referenced by pg_be_scram_exchange().

{
    uint8       ServerSignature[SCRAM_KEY_LEN];
    char       *server_signature_base64;
    int         siglen;
    scram_HMAC_ctx ctx;

    /* calculate ServerSignature */
    scram_HMAC_init(&ctx, state->ServerKey, SCRAM_KEY_LEN);
    scram_HMAC_update(&ctx,
                      state->client_first_message_bare,
                      strlen(state->client_first_message_bare));
    scram_HMAC_update(&ctx, ",", 1);
    scram_HMAC_update(&ctx,
                      state->server_first_message,
                      strlen(state->server_first_message));
    scram_HMAC_update(&ctx, ",", 1);
    scram_HMAC_update(&ctx,
                      state->client_final_message_without_proof,
                      strlen(state->client_final_message_without_proof));
    scram_HMAC_final(ServerSignature, &ctx);

    siglen = pg_b64_enc_len(SCRAM_KEY_LEN);
    /* don't forget the zero-terminator */
    server_signature_base64 = palloc(siglen + 1);
    siglen = pg_b64_encode((const char *) ServerSignature,
                           SCRAM_KEY_LEN, server_signature_base64,
                           siglen);
    if (siglen < 0)
        elog(ERROR, "could not encode server signature");
    server_signature_base64[siglen] = '\0';

    /*------
     * The syntax for the server-final-message is: (RFC 5802)
     *
     * verifier        = "v=" base64
     *                   ;; base-64 encoded ServerSignature.
     *
     * server-final-message = (server-error / verifier)
     *                   ["," extensions]
     *
     *------
     */
    return psprintf("v=%s", server_signature_base64);
}

build_server_first_message()

static char * build_server_first_message ( scram_state *  state )

static

Definition at line 1131 of file auth-scram.c.

References scram_state::client_nonce, ereport, errcode(), errmsg(), ERROR, scram_state::iterations, palloc(), pg_b64_enc_len(), pg_b64_encode(), pg_strong_random(), psprintf(), pstrdup(), scram_state::salt, SCRAM_RAW_NONCE_LEN, scram_state::server_first_message, and scram_state::server_nonce.

Referenced by pg_be_scram_exchange().

{
    /*------
     * The syntax for the server-first-message is: (RFC 5802)
     *
     * server-first-message =
     *                   [reserved-mext ","] nonce "," salt ","
     *                   iteration-count ["," extensions]
     *
     * nonce           = "r=" c-nonce [s-nonce]
     *                   ;; Second part provided by server.
     *
     * c-nonce         = printable
     *
     * s-nonce         = printable
     *
     * salt            = "s=" base64
     *
     * iteration-count = "i=" posit-number
     *                   ;; A positive number.
     *
     * Example:
     *
     * r=fyko+d2lbbFgONRv9qkxdawL3rfcNHYJY1ZVvWVs7j,s=QSXCR+Q6sek8bf92,i=4096
     *------
     */

    /*
     * Per the spec, the nonce may consist of any printable ASCII characters.
     * For convenience, however, we don't use the whole range available,
     * rather, we generate some random bytes, and base64 encode them.
     */
    char        raw_nonce[SCRAM_RAW_NONCE_LEN];
    int         encoded_len;

    if (!pg_strong_random(raw_nonce, SCRAM_RAW_NONCE_LEN))
        ereport(ERROR,
                (errcode(ERRCODE_INTERNAL_ERROR),
                 errmsg("could not generate random nonce")));

    encoded_len = pg_b64_enc_len(SCRAM_RAW_NONCE_LEN);
    /* don't forget the zero-terminator */
    state->server_nonce = palloc(encoded_len + 1);
    encoded_len = pg_b64_encode(raw_nonce, SCRAM_RAW_NONCE_LEN,
                                state->server_nonce, encoded_len);
    if (encoded_len < 0)
        ereport(ERROR,
                (errcode(ERRCODE_INTERNAL_ERROR),
                 errmsg("could not encode random nonce")));
    state->server_nonce[encoded_len] = '\0';

    state->server_first_message =
        psprintf("r=%s%s,s=%s,i=%u",
                 state->client_nonce, state->server_nonce,
                 state->salt, state->iterations);

    return pstrdup(state->server_first_message);
}

is_scram_printable()

static bool is_scram_printable ( char *  p )

static

Definition at line 721 of file auth-scram.c.

Referenced by read_client_first_message().

{
    /*------
     * Printable characters, as defined by SCRAM spec: (RFC 5802)
     *
     *  printable       = %x21-2B / %x2D-7E
     *                    ;; Printable ASCII except ",".
     *                    ;; Note that any "printable" is also
     *                    ;; a valid "value".
     *------
     */
    for (; *p; p++)
    {
        if (*p < 0x21 || *p > 0x7E || *p == 0x2C /* comma */ )
            return false;
    }
    return true;
}

mock_scram_secret()

static void mock_scram_secret ( const char *  username, int *  iterations, char **  salt, uint8 *  stored_key, uint8 *  server_key  )

static

Definition at line 647 of file auth-scram.c.

References elog, ERROR, palloc(), pg_b64_enc_len(), pg_b64_encode(), SCRAM_DEFAULT_ITERATIONS, SCRAM_DEFAULT_SALT_LEN, SCRAM_KEY_LEN, and scram_mock_salt().

Referenced by pg_be_scram_init().

{
    char       *raw_salt;
    char       *encoded_salt;
    int         encoded_len;

    /* Generate deterministic salt */
    raw_salt = scram_mock_salt(username);

    encoded_len = pg_b64_enc_len(SCRAM_DEFAULT_SALT_LEN);
    /* don't forget the zero-terminator */
    encoded_salt = (char *) palloc(encoded_len + 1);
    encoded_len = pg_b64_encode(raw_salt, SCRAM_DEFAULT_SALT_LEN, encoded_salt,
                                encoded_len);

    /*
     * Note that we cannot reveal any information to an attacker here so the
     * error message needs to remain generic.  This should never fail anyway
     * as the salt generated for mock authentication uses the cluster's nonce
     * value.
     */
    if (encoded_len < 0)
        elog(ERROR, "could not encode salt");
    encoded_salt[encoded_len] = '\0';

    *salt = encoded_salt;
    *iterations = SCRAM_DEFAULT_ITERATIONS;

    /* StoredKey and ServerKey are not used in a doomed authentication */
    memset(stored_key, 0, SCRAM_KEY_LEN);
    memset(server_key, 0, SCRAM_KEY_LEN);
}

parse_scram_secret()

bool parse_scram_secret	(	const char *	secret,
		int *	iterations,
		char **	salt,
		uint8 *	stored_key,
		uint8 *	server_key
	)

Definition at line 556 of file auth-scram.c.

References palloc(), pg_b64_dec_len(), pg_b64_decode(), pstrdup(), and SCRAM_KEY_LEN.

Referenced by get_password_type(), pg_be_scram_init(), and scram_verify_plain_password().

{
    char       *v;
    char       *p;
    char       *scheme_str;
    char       *salt_str;
    char       *iterations_str;
    char       *storedkey_str;
    char       *serverkey_str;
    int         decoded_len;
    char       *decoded_salt_buf;
    char       *decoded_stored_buf;
    char       *decoded_server_buf;

    /*
     * The secret is of form:
     *
     * SCRAM-SHA-256$<iterations>:<salt>$<storedkey>:<serverkey>
     */
    v = pstrdup(secret);
    if ((scheme_str = strtok(v, "$")) == NULL)
        goto invalid_secret;
    if ((iterations_str = strtok(NULL, ":")) == NULL)
        goto invalid_secret;
    if ((salt_str = strtok(NULL, "$")) == NULL)
        goto invalid_secret;
    if ((storedkey_str = strtok(NULL, ":")) == NULL)
        goto invalid_secret;
    if ((serverkey_str = strtok(NULL, "")) == NULL)
        goto invalid_secret;

    /* Parse the fields */
    if (strcmp(scheme_str, "SCRAM-SHA-256") != 0)
        goto invalid_secret;

    errno = 0;
    *iterations = strtol(iterations_str, &p, 10);
    if (*p || errno != 0)
        goto invalid_secret;

    /*
     * Verify that the salt is in Base64-encoded format, by decoding it,
     * although we return the encoded version to the caller.
     */
    decoded_len = pg_b64_dec_len(strlen(salt_str));
    decoded_salt_buf = palloc(decoded_len);
    decoded_len = pg_b64_decode(salt_str, strlen(salt_str),
                                decoded_salt_buf, decoded_len);
    if (decoded_len < 0)
        goto invalid_secret;
    *salt = pstrdup(salt_str);

    /*
     * Decode StoredKey and ServerKey.
     */
    decoded_len = pg_b64_dec_len(strlen(storedkey_str));
    decoded_stored_buf = palloc(decoded_len);
    decoded_len = pg_b64_decode(storedkey_str, strlen(storedkey_str),
                                decoded_stored_buf, decoded_len);
    if (decoded_len != SCRAM_KEY_LEN)
        goto invalid_secret;
    memcpy(stored_key, decoded_stored_buf, SCRAM_KEY_LEN);

    decoded_len = pg_b64_dec_len(strlen(serverkey_str));
    decoded_server_buf = palloc(decoded_len);
    decoded_len = pg_b64_decode(serverkey_str, strlen(serverkey_str),
                                decoded_server_buf, decoded_len);
    if (decoded_len != SCRAM_KEY_LEN)
        goto invalid_secret;
    memcpy(server_key, decoded_server_buf, SCRAM_KEY_LEN);

    return true;

invalid_secret:
    *salt = NULL;
    return false;
}

pg_be_scram_build_secret()

char* pg_be_scram_build_secret

(

const char *

password

)

Definition at line 451 of file auth-scram.c.

References ereport, errcode(), errmsg(), ERROR, pfree(), pg_saslprep(), pg_strong_random(), SASLPREP_SUCCESS, scram_build_secret(), SCRAM_DEFAULT_ITERATIONS, and SCRAM_DEFAULT_SALT_LEN.

Referenced by encrypt_password().

{
    char       *prep_password;
    pg_saslprep_rc rc;
    char        saltbuf[SCRAM_DEFAULT_SALT_LEN];
    char       *result;

    /*
     * Normalize the password with SASLprep.  If that doesn't work, because
     * the password isn't valid UTF-8 or contains prohibited characters, just
     * proceed with the original password.  (See comments at top of file.)
     */
    rc = pg_saslprep(password, &prep_password);
    if (rc == SASLPREP_SUCCESS)
        password = (const char *) prep_password;

    /* Generate random salt */
    if (!pg_strong_random(saltbuf, SCRAM_DEFAULT_SALT_LEN))
        ereport(ERROR,
                (errcode(ERRCODE_INTERNAL_ERROR),
                 errmsg("could not generate random salt")));

    result = scram_build_secret(saltbuf, SCRAM_DEFAULT_SALT_LEN,
                                SCRAM_DEFAULT_ITERATIONS, password);

    if (prep_password)
        pfree(prep_password);

    return result;
}

pg_be_scram_exchange()

int pg_be_scram_exchange	(	void *	opaq,
		const char *	input,
		int	inputlen,
		char **	output,
		int *	outputlen,
		char **	logdetail
	)

Definition at line 328 of file auth-scram.c.

References Assert, build_server_final_message(), build_server_first_message(), scram_state::doomed, elog, ereport, errcode(), errdetail(), errmsg(), ERROR, scram_state::logdetail, pstrdup(), read_client_final_message(), read_client_first_message(), SASL_EXCHANGE_CONTINUE, SASL_EXCHANGE_FAILURE, SASL_EXCHANGE_SUCCESS, SCRAM_AUTH_FINISHED, SCRAM_AUTH_INIT, SCRAM_AUTH_SALT_SENT, scram_state::state, verify_client_proof(), and verify_final_nonce().

Referenced by CheckSCRAMAuth().

{
    scram_state *state = (scram_state *) opaq;
    int         result;

    *output = NULL;

    /*
     * If the client didn't include an "Initial Client Response" in the
     * SASLInitialResponse message, send an empty challenge, to which the
     * client will respond with the same data that usually comes in the
     * Initial Client Response.
     */
    if (input == NULL)
    {
        Assert(state->state == SCRAM_AUTH_INIT);

        *output = pstrdup("");
        *outputlen = 0;
        return SASL_EXCHANGE_CONTINUE;
    }

    /*
     * Check that the input length agrees with the string length of the input.
     * We can ignore inputlen after this.
     */
    if (inputlen == 0)
        ereport(ERROR,
                (errcode(ERRCODE_PROTOCOL_VIOLATION),
                 errmsg("malformed SCRAM message"),
                 errdetail("The message is empty.")));
    if (inputlen != strlen(input))
        ereport(ERROR,
                (errcode(ERRCODE_PROTOCOL_VIOLATION),
                 errmsg("malformed SCRAM message"),
                 errdetail("Message length does not match input length.")));

    switch (state->state)
    {
        case SCRAM_AUTH_INIT:

            /*
             * Initialization phase.  Receive the first message from client
             * and be sure that it parsed correctly.  Then send the challenge
             * to the client.
             */
            read_client_first_message(state, input);

            /* prepare message to send challenge */
            *output = build_server_first_message(state);

            state->state = SCRAM_AUTH_SALT_SENT;
            result = SASL_EXCHANGE_CONTINUE;
            break;

        case SCRAM_AUTH_SALT_SENT:

            /*
             * Final phase for the server.  Receive the response to the
             * challenge previously sent, verify, and let the client know that
             * everything went well (or not).
             */
            read_client_final_message(state, input);

            if (!verify_final_nonce(state))
                ereport(ERROR,
                        (errcode(ERRCODE_PROTOCOL_VIOLATION),
                         errmsg("invalid SCRAM response"),
                         errdetail("Nonce does not match.")));

            /*
             * Now check the final nonce and the client proof.
             *
             * If we performed a "mock" authentication that we knew would fail
             * from the get go, this is where we fail.
             *
             * The SCRAM specification includes an error code,
             * "invalid-proof", for authentication failure, but it also allows
             * erroring out in an application-specific way.  We choose to do
             * the latter, so that the error message for invalid password is
             * the same for all authentication methods.  The caller will call
             * ereport(), when we return SASL_EXCHANGE_FAILURE with no output.
             *
             * NB: the order of these checks is intentional.  We calculate the
             * client proof even in a mock authentication, even though it's
             * bound to fail, to thwart timing attacks to determine if a role
             * with the given name exists or not.
             */
            if (!verify_client_proof(state) || state->doomed)
            {
                result = SASL_EXCHANGE_FAILURE;
                break;
            }

            /* Build final message for client */
            *output = build_server_final_message(state);

            /* Success! */
            result = SASL_EXCHANGE_SUCCESS;
            state->state = SCRAM_AUTH_FINISHED;
            break;

        default:
            elog(ERROR, "invalid SCRAM exchange state");
            result = SASL_EXCHANGE_FAILURE;
    }

    if (result == SASL_EXCHANGE_FAILURE && state->logdetail && logdetail)
        *logdetail = state->logdetail;

    if (*output)
        *outputlen = strlen(*output);

    return result;
}

pg_be_scram_get_mechanisms()

void pg_be_scram_get_mechanisms	(	Port *	port,
		StringInfo	buf
	)

Definition at line 181 of file auth-scram.c.

References appendStringInfoChar(), appendStringInfoString(), SCRAM_SHA_256_NAME, SCRAM_SHA_256_PLUS_NAME, and Port::ssl_in_use.

Referenced by CheckSCRAMAuth().

{
    /*
     * Advertise the mechanisms in decreasing order of importance.  So the
     * channel-binding variants go first, if they are supported.  Channel
     * binding is only supported with SSL, and only if the SSL implementation
     * has a function to get the certificate's hash.
     */
#ifdef HAVE_BE_TLS_GET_CERTIFICATE_HASH
    if (port->ssl_in_use)
    {
        appendStringInfoString(buf, SCRAM_SHA_256_PLUS_NAME);
        appendStringInfoChar(buf, '\0');
    }
#endif
    appendStringInfoString(buf, SCRAM_SHA_256_NAME);
    appendStringInfoChar(buf, '\0');
}

pg_be_scram_init()

void* pg_be_scram_init	(	Port *	port,
		const char *	selected_mech,
		const char *	shadow_pass
	)

Definition at line 218 of file auth-scram.c.

References _, scram_state::channel_binding_in_use, scram_state::doomed, ereport, errcode(), errmsg(), ERROR, get_password_type(), scram_state::iterations, LOG, scram_state::logdetail, mock_scram_secret(), palloc0(), parse_scram_secret(), PASSWORD_TYPE_SCRAM_SHA_256, port, scram_state::port, psprintf(), scram_state::salt, SCRAM_AUTH_INIT, SCRAM_SHA_256_NAME, SCRAM_SHA_256_PLUS_NAME, scram_state::ServerKey, Port::ssl_in_use, scram_state::state, scram_state::StoredKey, and Port::user_name.

Referenced by CheckSCRAMAuth().

{
    scram_state *state;
    bool        got_secret;

    state = (scram_state *) palloc0(sizeof(scram_state));
    state->port = port;
    state->state = SCRAM_AUTH_INIT;

    /*
     * Parse the selected mechanism.
     *
     * Note that if we don't support channel binding, either because the SSL
     * implementation doesn't support it or we're not using SSL at all, we
     * would not have advertised the PLUS variant in the first place.  If the
     * client nevertheless tries to select it, it's a protocol violation like
     * selecting any other SASL mechanism we don't support.
     */
#ifdef HAVE_BE_TLS_GET_CERTIFICATE_HASH
    if (strcmp(selected_mech, SCRAM_SHA_256_PLUS_NAME) == 0 && port->ssl_in_use)
        state->channel_binding_in_use = true;
    else
#endif
    if (strcmp(selected_mech, SCRAM_SHA_256_NAME) == 0)
        state->channel_binding_in_use = false;
    else
        ereport(ERROR,
                (errcode(ERRCODE_PROTOCOL_VIOLATION),
                 errmsg("client selected an invalid SASL authentication mechanism")));

    /*
     * Parse the stored secret.
     */
    if (shadow_pass)
    {
        int         password_type = get_password_type(shadow_pass);

        if (password_type == PASSWORD_TYPE_SCRAM_SHA_256)
        {
            if (parse_scram_secret(shadow_pass, &state->iterations, &state->salt,
                                   state->StoredKey, state->ServerKey))
                got_secret = true;
            else
            {
                /*
                 * The password looked like a SCRAM secret, but could not be
                 * parsed.
                 */
                ereport(LOG,
                        (errmsg("invalid SCRAM secret for user \"%s\"",
                                state->port->user_name)));
                got_secret = false;
            }
        }
        else
        {
            /*
             * The user doesn't have SCRAM secret. (You cannot do SCRAM
             * authentication with an MD5 hash.)
             */
            state->logdetail = psprintf(_("User \"%s\" does not have a valid SCRAM secret."),
                                        state->port->user_name);
            got_secret = false;
        }
    }
    else
    {
        /*
         * The caller requested us to perform a dummy authentication.  This is
         * considered normal, since the caller requested it, so don't set log
         * detail.
         */
        got_secret = false;
    }

    /*
     * If the user did not have a valid SCRAM secret, we still go through the
     * motions with a mock one, and fail as if the client supplied an
     * incorrect password.  This is to avoid revealing information to an
     * attacker.
     */
    if (!got_secret)
    {
        mock_scram_secret(state->port->user_name, &state->iterations,
                          &state->salt, state->StoredKey, state->ServerKey);
        state->doomed = true;
    }

    return state;
}

read_any_attr()

static char* read_any_attr ( char **  input, char *  attr_p  )

static

Definition at line 797 of file auth-scram.c.

References ereport, errcode(), errdetail(), errmsg(), ERROR, and sanitize_char().

Referenced by read_client_final_message(), and read_client_first_message().

{
    char       *begin = *input;
    char       *end;
    char        attr = *begin;

    if (attr == '\0')
        ereport(ERROR,
                (errcode(ERRCODE_PROTOCOL_VIOLATION),
                 errmsg("malformed SCRAM message"),
                 errdetail("Attribute expected, but found end of string.")));

    /*------
     * attr-val        = ALPHA "=" value
     *                   ;; Generic syntax of any attribute sent
     *                   ;; by server or client
     *------
     */
    if (!((attr >= 'A' && attr <= 'Z') ||
          (attr >= 'a' && attr <= 'z')))
        ereport(ERROR,
                (errcode(ERRCODE_PROTOCOL_VIOLATION),
                 errmsg("malformed SCRAM message"),
                 errdetail("Attribute expected, but found invalid character \"%s\".",
                           sanitize_char(attr))));
    if (attr_p)
        *attr_p = attr;
    begin++;

    if (*begin != '=')
        ereport(ERROR,
                (errcode(ERRCODE_PROTOCOL_VIOLATION),
                 errmsg("malformed SCRAM message"),
                 errdetail("Expected character \"=\" for attribute \"%c\".", attr)));
    begin++;

    end = begin;
    while (*end && *end != ',')
        end++;

    if (*end)
    {
        *end = '\0';
        *input = end + 1;
    }
    else
        *input = end;

    return begin;
}

read_attr_value()

static char* read_attr_value ( char **  input, char  attr  )

static

Definition at line 685 of file auth-scram.c.

References ereport, errcode(), errdetail(), errmsg(), ERROR, and sanitize_char().

Referenced by read_client_final_message(), and read_client_first_message().

{
    char       *begin = *input;
    char       *end;

    if (*begin != attr)
        ereport(ERROR,
                (errcode(ERRCODE_PROTOCOL_VIOLATION),
                 errmsg("malformed SCRAM message"),
                 errdetail("Expected attribute \"%c\" but found \"%s\".",
                           attr, sanitize_char(*begin))));
    begin++;

    if (*begin != '=')
        ereport(ERROR,
                (errcode(ERRCODE_PROTOCOL_VIOLATION),
                 errmsg("malformed SCRAM message"),
                 errdetail("Expected character \"=\" for attribute \"%c\".", attr)));
    begin++;

    end = begin;
    while (*end && *end != ',')
        end++;

    if (*end)
    {
        *end = '\0';
        *input = end + 1;
    }
    else
        *input = end;

    return begin;
}

read_client_final_message()

static void read_client_final_message ( scram_state *  state, const char *  input  )

static

Definition at line 1195 of file auth-scram.c.

References Assert, scram_state::cbind_flag, scram_state::channel_binding_in_use, scram_state::client_final_message_without_proof, scram_state::client_final_nonce, scram_state::ClientProof, elog, ereport, errcode(), errdetail(), errmsg(), ERROR, palloc(), pfree(), pg_b64_dec_len(), pg_b64_decode(), pg_b64_enc_len(), pg_b64_encode(), scram_state::port, pstrdup(), read_any_attr(), read_attr_value(), SCRAM_KEY_LEN, snprintf, and value.

Referenced by pg_be_scram_exchange().

{
    char        attr;
    char       *channel_binding;
    char       *value;
    char       *begin,
               *proof;
    char       *p;
    char       *client_proof;
    int         client_proof_len;

    begin = p = pstrdup(input);

    /*------
     * The syntax for the server-first-message is: (RFC 5802)
     *
     * gs2-header      = gs2-cbind-flag "," [ authzid ] ","
     *                   ;; GS2 header for SCRAM
     *                   ;; (the actual GS2 header includes an optional
     *                   ;; flag to indicate that the GSS mechanism is not
     *                   ;; "standard", but since SCRAM is "standard", we
     *                   ;; don't include that flag).
     *
     * cbind-input   = gs2-header [ cbind-data ]
     *                   ;; cbind-data MUST be present for
     *                   ;; gs2-cbind-flag of "p" and MUST be absent
     *                   ;; for "y" or "n".
     *
     * channel-binding = "c=" base64
     *                   ;; base64 encoding of cbind-input.
     *
     * proof           = "p=" base64
     *
     * client-final-message-without-proof =
     *                   channel-binding "," nonce [","
     *                   extensions]
     *
     * client-final-message =
     *                   client-final-message-without-proof "," proof
     *------
     */

    /*
     * Read channel binding.  This repeats the channel-binding flags and is
     * then followed by the actual binding data depending on the type.
     */
    channel_binding = read_attr_value(&p, 'c');
    if (state->channel_binding_in_use)
    {
#ifdef HAVE_BE_TLS_GET_CERTIFICATE_HASH
        const char *cbind_data = NULL;
        size_t      cbind_data_len = 0;
        size_t      cbind_header_len;
        char       *cbind_input;
        size_t      cbind_input_len;
        char       *b64_message;
        int         b64_message_len;

        Assert(state->cbind_flag == 'p');

        /* Fetch hash data of server's SSL certificate */
        cbind_data = be_tls_get_certificate_hash(state->port,
                                                 &cbind_data_len);

        /* should not happen */
        if (cbind_data == NULL || cbind_data_len == 0)
            elog(ERROR, "could not get server certificate hash");

        cbind_header_len = strlen("p=tls-server-end-point,,");  /* p=type,, */
        cbind_input_len = cbind_header_len + cbind_data_len;
        cbind_input = palloc(cbind_input_len);
        snprintf(cbind_input, cbind_input_len, "p=tls-server-end-point,,");
        memcpy(cbind_input + cbind_header_len, cbind_data, cbind_data_len);

        b64_message_len = pg_b64_enc_len(cbind_input_len);
        /* don't forget the zero-terminator */
        b64_message = palloc(b64_message_len + 1);
        b64_message_len = pg_b64_encode(cbind_input, cbind_input_len,
                                        b64_message, b64_message_len);
        if (b64_message_len < 0)
            elog(ERROR, "could not encode channel binding data");
        b64_message[b64_message_len] = '\0';

        /*
         * Compare the value sent by the client with the value expected by the
         * server.
         */
        if (strcmp(channel_binding, b64_message) != 0)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_AUTHORIZATION_SPECIFICATION),
                     errmsg("SCRAM channel binding check failed")));
#else
        /* shouldn't happen, because we checked this earlier already */
        elog(ERROR, "channel binding not supported by this build");
#endif
    }
    else
    {
        /*
         * If we are not using channel binding, the binding data is expected
         * to always be "biws", which is "n,," base64-encoded, or "eSws",
         * which is "y,,".  We also have to check whether the flag is the same
         * one that the client originally sent.
         */
        if (!(strcmp(channel_binding, "biws") == 0 && state->cbind_flag == 'n') &&
            !(strcmp(channel_binding, "eSws") == 0 && state->cbind_flag == 'y'))
            ereport(ERROR,
                    (errcode(ERRCODE_PROTOCOL_VIOLATION),
                     errmsg("unexpected SCRAM channel-binding attribute in client-final-message")));
    }

    state->client_final_nonce = read_attr_value(&p, 'r');

    /* ignore optional extensions, read until we find "p" attribute */
    do
    {
        proof = p - 1;
        value = read_any_attr(&p, &attr);
    } while (attr != 'p');

    client_proof_len = pg_b64_dec_len(strlen(value));
    client_proof = palloc(client_proof_len);
    if (pg_b64_decode(value, strlen(value), client_proof,
                      client_proof_len) != SCRAM_KEY_LEN)
        ereport(ERROR,
                (errcode(ERRCODE_PROTOCOL_VIOLATION),
                 errmsg("malformed SCRAM message"),
                 errdetail("Malformed proof in client-final-message.")));
    memcpy(state->ClientProof, client_proof, SCRAM_KEY_LEN);
    pfree(client_proof);

    if (*p != '\0')
        ereport(ERROR,
                (errcode(ERRCODE_PROTOCOL_VIOLATION),
                 errmsg("malformed SCRAM message"),
                 errdetail("Garbage found at the end of client-final-message.")));

    state->client_final_message_without_proof = palloc(proof - begin + 1);
    memcpy(state->client_final_message_without_proof, input, proof - begin);
    state->client_final_message_without_proof[proof - begin] = '\0';
}

read_client_first_message()

static void read_client_first_message ( scram_state *  state, const char *  input  )

static

Definition at line 855 of file auth-scram.c.

References scram_state::cbind_flag, scram_state::channel_binding_in_use, scram_state::client_first_message_bare, scram_state::client_nonce, scram_state::client_username, ereport, errcode(), errdetail(), errmsg(), ERROR, is_scram_printable(), scram_state::port, pstrdup(), read_any_attr(), read_attr_value(), sanitize_char(), sanitize_str(), and Port::ssl_in_use.

Referenced by pg_be_scram_exchange().

{
    char       *p = pstrdup(input);
    char       *channel_binding_type;


    /*------
     * The syntax for the client-first-message is: (RFC 5802)
     *
     * saslname        = 1*(value-safe-char / "=2C" / "=3D")
     *                   ;; Conforms to <value>.
     *
     * authzid         = "a=" saslname
     *                   ;; Protocol specific.
     *
     * cb-name         = 1*(ALPHA / DIGIT / "." / "-")
     *                    ;; See RFC 5056, Section 7.
     *                    ;; E.g., "tls-server-end-point" or
     *                    ;; "tls-unique".
     *
     * gs2-cbind-flag  = ("p=" cb-name) / "n" / "y"
     *                   ;; "n" -> client doesn't support channel binding.
     *                   ;; "y" -> client does support channel binding
     *                   ;;        but thinks the server does not.
     *                   ;; "p" -> client requires channel binding.
     *                   ;; The selected channel binding follows "p=".
     *
     * gs2-header      = gs2-cbind-flag "," [ authzid ] ","
     *                   ;; GS2 header for SCRAM
     *                   ;; (the actual GS2 header includes an optional
     *                   ;; flag to indicate that the GSS mechanism is not
     *                   ;; "standard", but since SCRAM is "standard", we
     *                   ;; don't include that flag).
     *
     * username        = "n=" saslname
     *                   ;; Usernames are prepared using SASLprep.
     *
     * reserved-mext  = "m=" 1*(value-char)
     *                   ;; Reserved for signaling mandatory extensions.
     *                   ;; The exact syntax will be defined in
     *                   ;; the future.
     *
     * nonce           = "r=" c-nonce [s-nonce]
     *                   ;; Second part provided by server.
     *
     * c-nonce         = printable
     *
     * client-first-message-bare =
     *                   [reserved-mext ","]
     *                   username "," nonce ["," extensions]
     *
     * client-first-message =
     *                   gs2-header client-first-message-bare
     *
     * For example:
     * n,,n=user,r=fyko+d2lbbFgONRv9qkxdawL
     *
     * The "n,," in the beginning means that the client doesn't support
     * channel binding, and no authzid is given.  "n=user" is the username.
     * However, in PostgreSQL the username is sent in the startup packet, and
     * the username in the SCRAM exchange is ignored.  libpq always sends it
     * as an empty string.  The last part, "r=fyko+d2lbbFgONRv9qkxdawL" is
     * the client nonce.
     *------
     */

    /*
     * Read gs2-cbind-flag.  (For details see also RFC 5802 Section 6 "Channel
     * Binding".)
     */
    state->cbind_flag = *p;
    switch (*p)
    {
        case 'n':

            /*
             * The client does not support channel binding or has simply
             * decided to not use it.  In that case just let it go.
             */
            if (state->channel_binding_in_use)
                ereport(ERROR,
                        (errcode(ERRCODE_PROTOCOL_VIOLATION),
                         errmsg("malformed SCRAM message"),
                         errdetail("The client selected SCRAM-SHA-256-PLUS, but the SCRAM message does not include channel binding data.")));

            p++;
            if (*p != ',')
                ereport(ERROR,
                        (errcode(ERRCODE_PROTOCOL_VIOLATION),
                         errmsg("malformed SCRAM message"),
                         errdetail("Comma expected, but found character \"%s\".",
                                   sanitize_char(*p))));
            p++;
            break;
        case 'y':

            /*
             * The client supports channel binding and thinks that the server
             * does not.  In this case, the server must fail authentication if
             * it supports channel binding.
             */
            if (state->channel_binding_in_use)
                ereport(ERROR,
                        (errcode(ERRCODE_PROTOCOL_VIOLATION),
                         errmsg("malformed SCRAM message"),
                         errdetail("The client selected SCRAM-SHA-256-PLUS, but the SCRAM message does not include channel binding data.")));

#ifdef HAVE_BE_TLS_GET_CERTIFICATE_HASH
            if (state->port->ssl_in_use)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_AUTHORIZATION_SPECIFICATION),
                         errmsg("SCRAM channel binding negotiation error"),
                         errdetail("The client supports SCRAM channel binding but thinks the server does not.  "
                                   "However, this server does support channel binding.")));
#endif
            p++;
            if (*p != ',')
                ereport(ERROR,
                        (errcode(ERRCODE_PROTOCOL_VIOLATION),
                         errmsg("malformed SCRAM message"),
                         errdetail("Comma expected, but found character \"%s\".",
                                   sanitize_char(*p))));
            p++;
            break;
        case 'p':

            /*
             * The client requires channel binding.  Channel binding type
             * follows, e.g., "p=tls-server-end-point".
             */
            if (!state->channel_binding_in_use)
                ereport(ERROR,
                        (errcode(ERRCODE_PROTOCOL_VIOLATION),
                         errmsg("malformed SCRAM message"),
                         errdetail("The client selected SCRAM-SHA-256 without channel binding, but the SCRAM message includes channel binding data.")));

            channel_binding_type = read_attr_value(&p, 'p');

            /*
             * The only channel binding type we support is
             * tls-server-end-point.
             */
            if (strcmp(channel_binding_type, "tls-server-end-point") != 0)
                ereport(ERROR,
                        (errcode(ERRCODE_PROTOCOL_VIOLATION),
                         errmsg("unsupported SCRAM channel-binding type \"%s\"",
                                sanitize_str(channel_binding_type))));
            break;
        default:
            ereport(ERROR,
                    (errcode(ERRCODE_PROTOCOL_VIOLATION),
                     errmsg("malformed SCRAM message"),
                     errdetail("Unexpected channel-binding flag \"%s\".",
                               sanitize_char(*p))));
    }

    /*
     * Forbid optional authzid (authorization identity).  We don't support it.
     */
    if (*p == 'a')
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("client uses authorization identity, but it is not supported")));
    if (*p != ',')
        ereport(ERROR,
                (errcode(ERRCODE_PROTOCOL_VIOLATION),
                 errmsg("malformed SCRAM message"),
                 errdetail("Unexpected attribute \"%s\" in client-first-message.",
                           sanitize_char(*p))));
    p++;

    state->client_first_message_bare = pstrdup(p);

    /*
     * Any mandatory extensions would go here.  We don't support any.
     *
     * RFC 5802 specifies error code "e=extensions-not-supported" for this,
     * but it can only be sent in the server-final message.  We prefer to fail
     * immediately (which the RFC also allows).
     */
    if (*p == 'm')
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("client requires an unsupported SCRAM extension")));

    /*
     * Read username.  Note: this is ignored.  We use the username from the
     * startup message instead, still it is kept around if provided as it
     * proves to be useful for debugging purposes.
     */
    state->client_username = read_attr_value(&p, 'n');

    /* read nonce and check that it is made of only printable characters */
    state->client_nonce = read_attr_value(&p, 'r');
    if (!is_scram_printable(state->client_nonce))
        ereport(ERROR,
                (errcode(ERRCODE_PROTOCOL_VIOLATION),
                 errmsg("non-printable characters in SCRAM nonce")));

    /*
     * There can be any number of optional extensions after this.  We don't
     * support any extensions, so ignore them.
     */
    while (*p != '\0')
        read_any_attr(&p, NULL);

    /* success! */
}

sanitize_char()

static char * sanitize_char ( char  c )

static

Definition at line 749 of file auth-scram.c.

References buf, and snprintf.

Referenced by read_any_attr(), read_attr_value(), and read_client_first_message().

{
    static char buf[5];

    if (c >= 0x21 && c <= 0x7E)
        snprintf(buf, sizeof(buf), "'%c'", c);
    else
        snprintf(buf, sizeof(buf), "0x%02x", (unsigned char) c);
    return buf;
}

sanitize_str()

static char * sanitize_str ( const char *  s )

static

Definition at line 769 of file auth-scram.c.

References buf, and i.

Referenced by read_client_first_message().

{
    static char buf[30 + 1];
    int         i;

    for (i = 0; i < sizeof(buf) - 1; i++)
    {
        char        c = s[i];

        if (c == '\0')
            break;

        if (c >= 0x21 && c <= 0x7E)
            buf[i] = c;
        else
            buf[i] = '?';
    }
    buf[i] = '\0';
    return buf;
}

scram_mock_salt()

static char * scram_mock_salt ( const char *  username )

static

Definition at line 1394 of file auth-scram.c.

References GetMockAuthenticationNonce(), MOCK_AUTH_NONCE_LEN, PG_SHA256_DIGEST_LENGTH, pg_sha256_final(), pg_sha256_init(), pg_sha256_update(), SCRAM_DEFAULT_SALT_LEN, and StaticAssertStmt.

Referenced by mock_scram_secret().

{
    pg_sha256_ctx ctx;
    static uint8 sha_digest[PG_SHA256_DIGEST_LENGTH];
    char       *mock_auth_nonce = GetMockAuthenticationNonce();

    /*
     * Generate salt using a SHA256 hash of the username and the cluster's
     * mock authentication nonce.  (This works as long as the salt length is
     * not larger than the SHA256 digest length.  If the salt is smaller, the
     * caller will just ignore the extra data.)
     */
    StaticAssertStmt(PG_SHA256_DIGEST_LENGTH >= SCRAM_DEFAULT_SALT_LEN,
                     "salt length greater than SHA256 digest length");

    pg_sha256_init(&ctx);
    pg_sha256_update(&ctx, (uint8 *) username, strlen(username));
    pg_sha256_update(&ctx, (uint8 *) mock_auth_nonce, MOCK_AUTH_NONCE_LEN);
    pg_sha256_final(&ctx, sha_digest);

    return (char *) sha_digest;
}

scram_verify_plain_password()

bool scram_verify_plain_password	(	const char *	username,
		const char *	password,
		const char *	secret
	)

Definition at line 488 of file auth-scram.c.

References ereport, errmsg(), LOG, palloc(), parse_scram_secret(), pfree(), pg_b64_dec_len(), pg_b64_decode(), pg_saslprep(), SASLPREP_SUCCESS, SCRAM_KEY_LEN, scram_SaltedPassword(), and scram_ServerKey().

Referenced by plain_crypt_verify().

{
    char       *encoded_salt;
    char       *salt;
    int         saltlen;
    int         iterations;
    uint8       salted_password[SCRAM_KEY_LEN];
    uint8       stored_key[SCRAM_KEY_LEN];
    uint8       server_key[SCRAM_KEY_LEN];
    uint8       computed_key[SCRAM_KEY_LEN];
    char       *prep_password;
    pg_saslprep_rc rc;

    if (!parse_scram_secret(secret, &iterations, &encoded_salt,
                            stored_key, server_key))
    {
        /*
         * The password looked like a SCRAM secret, but could not be parsed.
         */
        ereport(LOG,
                (errmsg("invalid SCRAM secret for user \"%s\"", username)));
        return false;
    }

    saltlen = pg_b64_dec_len(strlen(encoded_salt));
    salt = palloc(saltlen);
    saltlen = pg_b64_decode(encoded_salt, strlen(encoded_salt), salt,
                            saltlen);
    if (saltlen < 0)
    {
        ereport(LOG,
                (errmsg("invalid SCRAM secret for user \"%s\"", username)));
        return false;
    }

    /* Normalize the password */
    rc = pg_saslprep(password, &prep_password);
    if (rc == SASLPREP_SUCCESS)
        password = prep_password;

    /* Compute Server Key based on the user-supplied plaintext password */
    scram_SaltedPassword(password, salt, saltlen, iterations, salted_password);
    scram_ServerKey(salted_password, computed_key);

    if (prep_password)
        pfree(prep_password);

    /*
     * Compare the secret's Server Key with the one computed from the
     * user-supplied password.
     */
    return memcmp(computed_key, server_key, SCRAM_KEY_LEN) == 0;
}

verify_client_proof()

static bool verify_client_proof ( scram_state *  state )

static

Definition at line 1090 of file auth-scram.c.

References scram_state::client_final_message_without_proof, scram_state::client_first_message_bare, scram_state::ClientProof, i, scram_H(), scram_HMAC_final(), scram_HMAC_init(), scram_HMAC_update(), SCRAM_KEY_LEN, scram_state::server_first_message, and scram_state::StoredKey.

Referenced by pg_be_scram_exchange().

{
    uint8       ClientSignature[SCRAM_KEY_LEN];
    uint8       ClientKey[SCRAM_KEY_LEN];
    uint8       client_StoredKey[SCRAM_KEY_LEN];
    scram_HMAC_ctx ctx;
    int         i;

    /* calculate ClientSignature */
    scram_HMAC_init(&ctx, state->StoredKey, SCRAM_KEY_LEN);
    scram_HMAC_update(&ctx,
                      state->client_first_message_bare,
                      strlen(state->client_first_message_bare));
    scram_HMAC_update(&ctx, ",", 1);
    scram_HMAC_update(&ctx,
                      state->server_first_message,
                      strlen(state->server_first_message));
    scram_HMAC_update(&ctx, ",", 1);
    scram_HMAC_update(&ctx,
                      state->client_final_message_without_proof,
                      strlen(state->client_final_message_without_proof));
    scram_HMAC_final(ClientSignature, &ctx);

    /* Extract the ClientKey that the client calculated from the proof */
    for (i = 0; i < SCRAM_KEY_LEN; i++)
        ClientKey[i] = state->ClientProof[i] ^ ClientSignature[i];

    /* Hash it one more time, and compare with StoredKey */
    scram_H(ClientKey, SCRAM_KEY_LEN, client_StoredKey);

    if (memcmp(client_StoredKey, state->StoredKey, SCRAM_KEY_LEN) != 0)
        return false;

    return true;
}

verify_final_nonce()

static bool verify_final_nonce ( scram_state *  state )

static

Definition at line 1069 of file auth-scram.c.

References scram_state::client_final_nonce, scram_state::client_nonce, and scram_state::server_nonce.

Referenced by pg_be_scram_exchange().

{
    int         client_nonce_len = strlen(state->client_nonce);
    int         server_nonce_len = strlen(state->server_nonce);
    int         final_nonce_len = strlen(state->client_final_nonce);

    if (final_nonce_len != client_nonce_len + server_nonce_len)
        return false;
    if (memcmp(state->client_final_nonce, state->client_nonce, client_nonce_len) != 0)
        return false;
    if (memcmp(state->client_final_nonce + client_nonce_len, state->server_nonce, server_nonce_len) != 0)
        return false;

    return true;
}