saslprep.c File Reference

#include "postgres.h"
#include "utils/memutils.h"
#include "common/saslprep.h"
#include "common/string.h"
#include "common/unicode_norm.h"
#include "mb/pg_wchar.h"

Include dependency graph for saslprep.c:

Go to the source code of this file.

Macros
#define	STRDUP(s)   pstrdup(s)
#define	ALLOC(size)   palloc(size)
#define	FREE(size)   pfree(size)
#define	IS_CODE_IN_TABLE(code, map)   is_code_in_table(code, map, lengthof(map))

Functions
static int	codepoint_range_cmp (const void *a, const void *b)
static bool	is_code_in_table (char32_t code, const char32_t *map, int mapsize)
static int	pg_utf8_string_len (const char *source)
pg_saslprep_rc	pg_saslprep (const char *input, char **output)

Variables
static const char32_t	non_ascii_space_ranges []
static const char32_t	commonly_mapped_to_nothing_ranges []
static const char32_t	prohibited_output_ranges []
static const char32_t	unassigned_codepoint_ranges []
static const char32_t	RandALCat_codepoint_ranges []
static const char32_t	LCat_codepoint_ranges []

Macro Definition Documentation

ALLOC

#define ALLOC

(

size

)

palloc(size)

Definition at line 40 of file saslprep.c.

FREE

#define FREE

(

size

)

pfree(size)

Definition at line 41 of file saslprep.c.

IS_CODE_IN_TABLE

#define IS_CODE_IN_TABLE	(		code,
			map
	)		is_code_in_table(code, map, lengthof(map))

Definition at line 966 of file saslprep.c.

STRDUP

#define STRDUP

(

s

)

pstrdup(s)

Definition at line 39 of file saslprep.c.

Function Documentation

codepoint_range_cmp()

static int codepoint_range_cmp ( const void *  a, const void *  b  )

static

Definition at line 969 of file saslprep.c.

{
    const char32_t *key = (const char32_t *) a;
    const char32_t *range = (const char32_t *) b;
 
    if (*key < range[0])
        return -1;              /* less than lower bound */
    if (*key > range[1])
        return 1;               /* greater than upper bound */
 
    return 0;                   /* within range */
}

References a, b, sort-test::key, and range().

Referenced by is_code_in_table().

is_code_in_table()

static bool is_code_in_table ( char32_t  code, const char32_t *  map, int  mapsize  )

static

Definition at line 983 of file saslprep.c.

{
    Assert(mapsize % 2 == 0);
 
    if (code < map[0] || code > map[mapsize - 1])
        return false;
 
    if (bsearch(&code, map, mapsize / 2, sizeof(char32_t) * 2,
                codepoint_range_cmp))
        return true;
    else
        return false;
}

References Assert(), and codepoint_range_cmp().

pg_saslprep()

pg_saslprep_rc pg_saslprep	(	const char *	input,
		char **	output
	)

Definition at line 1047 of file saslprep.c.

{
    char32_t   *input_chars = NULL;
    char32_t   *output_chars = NULL;
    int         input_size;
    char       *result;
    int         result_size;
    int         count;
    int         i;
    bool        contains_RandALCat;
    const unsigned char *p;
    unsigned char *outp;
    char32_t   *wp;
 
    /* Ensure we return *output as NULL on failure */
    *output = NULL;
 
    /*
     * Quick check if the input is pure ASCII.  An ASCII string requires no
     * further processing.
     */
    if (pg_is_ascii(input))
    {
        *output = STRDUP(input);
        if (!(*output))
            goto oom;
        return SASLPREP_SUCCESS;
    }
 
    /*
     * Convert the input from UTF-8 to an array of Unicode codepoints.
     *
     * This also checks that the input is a legal UTF-8 string.
     */
    input_size = pg_utf8_string_len(input);
    if (input_size < 0)
        return SASLPREP_INVALID_UTF8;
    if (input_size >= MaxAllocSize / sizeof(char32_t))
        goto oom;
 
    input_chars = ALLOC((input_size + 1) * sizeof(char32_t));
    if (!input_chars)
        goto oom;
 
    p = (const unsigned char *) input;
    for (i = 0; i < input_size; i++)
    {
        input_chars[i] = utf8_to_unicode(p);
        p += pg_utf_mblen(p);
    }
    input_chars[i] = (char32_t) '\0';
 
    /*
     * The steps below correspond to the steps listed in [RFC3454], Section
     * "2. Preparation Overview"
     */
 
    /*
     * 1) Map -- For each character in the input, check if it has a mapping
     * and, if so, replace it with its mapping.
     */
    count = 0;
    for (i = 0; i < input_size; i++)
    {
        char32_t    code = input_chars[i];
 
        if (IS_CODE_IN_TABLE(code, non_ascii_space_ranges))
            input_chars[count++] = 0x0020;
        else if (IS_CODE_IN_TABLE(code, commonly_mapped_to_nothing_ranges))
        {
            /* map to nothing */
        }
        else
            input_chars[count++] = code;
    }
    input_chars[count] = (char32_t) '\0';
    input_size = count;
 
    if (input_size == 0)
        goto prohibited;        /* don't allow empty password */
 
    /*
     * 2) Normalize -- Normalize the result of step 1 using Unicode
     * normalization.
     */
    output_chars = unicode_normalize(UNICODE_NFKC, input_chars);
    if (!output_chars)
        goto oom;
 
    /*
     * 3) Prohibit -- Check for any characters that are not allowed in the
     * output.  If any are found, return an error.
     */
    for (i = 0; i < input_size; i++)
    {
        char32_t    code = input_chars[i];
 
        if (IS_CODE_IN_TABLE(code, prohibited_output_ranges))
            goto prohibited;
        if (IS_CODE_IN_TABLE(code, unassigned_codepoint_ranges))
            goto prohibited;
    }
 
    /*
     * 4) Check bidi -- Possibly check for right-to-left characters, and if
     * any are found, make sure that the whole string satisfies the
     * requirements for bidirectional strings.  If the string does not satisfy
     * the requirements for bidirectional strings, return an error.
     *
     * [RFC3454], Section "6. Bidirectional Characters" explains in more
     * detail what that means:
     *
     * "In any profile that specifies bidirectional character handling, all
     * three of the following requirements MUST be met:
     *
     * 1) The characters in section 5.8 MUST be prohibited.
     *
     * 2) If a string contains any RandALCat character, the string MUST NOT
     * contain any LCat character.
     *
     * 3) If a string contains any RandALCat character, a RandALCat character
     * MUST be the first character of the string, and a RandALCat character
     * MUST be the last character of the string."
     */
    contains_RandALCat = false;
    for (i = 0; i < input_size; i++)
    {
        char32_t    code = input_chars[i];
 
        if (IS_CODE_IN_TABLE(code, RandALCat_codepoint_ranges))
        {
            contains_RandALCat = true;
            break;
        }
    }
 
    if (contains_RandALCat)
    {
        char32_t    first = input_chars[0];
        char32_t    last = input_chars[input_size - 1];
 
        for (i = 0; i < input_size; i++)
        {
            char32_t    code = input_chars[i];
 
            if (IS_CODE_IN_TABLE(code, LCat_codepoint_ranges))
                goto prohibited;
        }
 
        if (!IS_CODE_IN_TABLE(first, RandALCat_codepoint_ranges) ||
            !IS_CODE_IN_TABLE(last, RandALCat_codepoint_ranges))
            goto prohibited;
    }
 
    /*
     * Finally, convert the result back to UTF-8.
     */
    result_size = 0;
    for (wp = output_chars; *wp; wp++)
    {
        unsigned char buf[4];
 
        unicode_to_utf8(*wp, buf);
        result_size += pg_utf_mblen(buf);
    }
 
    result = ALLOC(result_size + 1);
    if (!result)
        goto oom;
 
    /*
     * There are no error exits below here, so the error exit paths don't need
     * to worry about possibly freeing "result".
     */
    outp = (unsigned char *) result;
    for (wp = output_chars; *wp; wp++)
    {
        unicode_to_utf8(*wp, outp);
        outp += pg_utf_mblen(outp);
    }
    Assert((char *) outp == result + result_size);
    *outp = '\0';
 
    FREE(input_chars);
    FREE(output_chars);
 
    *output = result;
    return SASLPREP_SUCCESS;
 
prohibited:
    if (input_chars)
        FREE(input_chars);
    if (output_chars)
        FREE(output_chars);
 
    return SASLPREP_PROHIBITED;
 
oom:
    if (input_chars)
        FREE(input_chars);
    if (output_chars)
        FREE(output_chars);
 
    return SASLPREP_OOM;
}

References ALLOC, Assert(), buf, commonly_mapped_to_nothing_ranges, FREE, i, input, IS_CODE_IN_TABLE, LCat_codepoint_ranges, MaxAllocSize, non_ascii_space_ranges, output, pg_is_ascii(), pg_utf8_string_len(), pg_utf_mblen, prohibited_output_ranges, RandALCat_codepoint_ranges, SASLPREP_INVALID_UTF8, SASLPREP_OOM, SASLPREP_PROHIBITED, SASLPREP_SUCCESS, STRDUP, unassigned_codepoint_ranges, UNICODE_NFKC, unicode_normalize(), unicode_to_utf8(), and utf8_to_unicode().

Referenced by pg_be_scram_build_secret(), pg_fe_scram_build_secret(), scram_init(), and scram_verify_plain_password().

pg_utf8_string_len()

static int pg_utf8_string_len ( const char *  source )

static

Definition at line 1003 of file saslprep.c.

{
    const unsigned char *p = (const unsigned char *) source;
    int         l;
    int         num_chars = 0;
    size_t      len = strlen(source);
 
    while (len)
    {
        l = pg_utf_mblen(p);
 
        if (len < l || !pg_utf8_islegal(p, l))
            return -1;
 
        p += l;
        len -= l;
        num_chars++;
    }
 
    return num_chars;
}

References len, pg_utf8_islegal(), pg_utf_mblen, and source.

Referenced by pg_saslprep().

Variable Documentation

commonly_mapped_to_nothing_ranges

const char32_t commonly_mapped_to_nothing_ranges[]

static

Initial value:

=
{
    0x00AD, 0x00AD,
    0x034F, 0x034F,
    0x1806, 0x1806,
    0x180B, 0x180D,
    0x200B, 0x200D,
    0x2060, 0x2060,
    0xFE00, 0xFE0F,
    0xFEFF, 0xFEFF
}

Definition at line 82 of file saslprep.c.

Referenced by pg_saslprep().

LCat_codepoint_ranges

const char32_t LCat_codepoint_ranges[]

static

Definition at line 598 of file saslprep.c.

Referenced by pg_saslprep().

non_ascii_space_ranges

const char32_t non_ascii_space_ranges[]

static

Initial value:

=
{
    0x00A0, 0x00A0,
    0x1680, 0x1680,
    0x2000, 0x200B,
    0x202F, 0x202F,
    0x205F, 0x205F,
    0x3000, 0x3000
}

Definition at line 67 of file saslprep.c.

Referenced by pg_saslprep().

prohibited_output_ranges

const char32_t prohibited_output_ranges[]

static

Definition at line 117 of file saslprep.c.

Referenced by pg_saslprep().

RandALCat_codepoint_ranges

const char32_t RandALCat_codepoint_ranges[]

static

Definition at line 559 of file saslprep.c.

Referenced by pg_saslprep().

unassigned_codepoint_ranges

const char32_t unassigned_codepoint_ranges[]

static

Definition at line 158 of file saslprep.c.

Referenced by pg_saslprep().