pgp-armor.c File Reference

#include "postgres.h"
#include "pgp.h"
#include "px.h"

Include dependency graph for pgp-armor.c:

Go to the source code of this file.

Macros
#define	CRC24_INIT   0x00b704ceL
#define	CRC24_POLY   0x01864cfbL

Functions
static int	pg_base64_encode (const uint8 *src, unsigned len, uint8 *dst)
static int	pg_base64_decode (const uint8 *src, unsigned len, uint8 *dst)
static unsigned	pg_base64_enc_len (unsigned srclen)
static unsigned	pg_base64_dec_len (unsigned srclen)
static long	crc24 (const uint8 *data, unsigned len)
void	pgp_armor_encode (const uint8 *src, unsigned len, StringInfo dst, int num_headers, char **keys, char **values)
static const uint8 *	find_str (const uint8 *data, const uint8 *data_end, const char *str, int strlen)
static int	find_header (const uint8 *data, const uint8 *datend, const uint8 **start_p, int is_end)
int	pgp_armor_decode (const uint8 *src, int len, StringInfo dst)
int	pgp_extract_armor_headers (const uint8 *src, unsigned len, int *nheaders, char ***keys, char ***values)

Variables
static const unsigned char	_base64 []
static const char *const	armor_header = "-----BEGIN PGP MESSAGE-----\n"
static const char *const	armor_footer = "\n-----END PGP MESSAGE-----\n"

Macro Definition Documentation

CRC24_INIT

#define CRC24_INIT   0x00b704ceL

Definition at line 185 of file pgp-armor.c.

CRC24_POLY

#define CRC24_POLY   0x01864cfbL

Definition at line 186 of file pgp-armor.c.

Function Documentation

crc24()

static long crc24 ( const uint8 *  data, unsigned  len  )

static

Definition at line 188 of file pgp-armor.c.

{
    unsigned    crc = CRC24_INIT;
    int         i;
 
    while (len--)
    {
        crc ^= (*data++) << 16;
        for (i = 0; i < 8; i++)
        {
            crc <<= 1;
            if (crc & 0x1000000)
                crc ^= CRC24_POLY;
        }
    }
    return crc & 0xffffffL;
}

References crc, CRC24_INIT, CRC24_POLY, data, i, and len.

Referenced by pgp_armor_decode(), and pgp_armor_encode().

find_header()

static int find_header ( const uint8 *  data, const uint8 *  datend, const uint8 **  start_p, int  is_end  )

static

Definition at line 266 of file pgp-armor.c.

{
    const uint8 *p = data;
    static const char *start_sep = "-----BEGIN";
    static const char *end_sep = "-----END";
    const char *sep = is_end ? end_sep : start_sep;
 
    /* find header line */
    while (1)
    {
        p = find_str(p, datend, sep, strlen(sep));
        if (p == NULL)
            return PXE_PGP_CORRUPT_ARMOR;
        /* it must start at beginning of line */
        if (p == data || *(p - 1) == '\n')
            break;
        p += strlen(sep);
    }
    *start_p = p;
    p += strlen(sep);
 
    /* check if header text ok */
    for (; p < datend && *p != '-'; p++)
    {
        /* various junk can be there, but definitely not line-feed  */
        if (*p >= ' ')
            continue;
        return PXE_PGP_CORRUPT_ARMOR;
    }
    if (datend - p < 5 || memcmp(p, sep, 5) != 0)
        return PXE_PGP_CORRUPT_ARMOR;
    p += 5;
 
    /* check if at end of line */
    if (p < datend)
    {
        if (*p != '\n' && *p != '\r')
            return PXE_PGP_CORRUPT_ARMOR;
        if (*p == '\r')
            p++;
        if (p < datend && *p == '\n')
            p++;
    }
    return p - *start_p;
}

References data, find_str(), and PXE_PGP_CORRUPT_ARMOR.

Referenced by pgp_armor_decode(), and pgp_extract_armor_headers().

find_str()

static const uint8 * find_str ( const uint8 *  data, const uint8 *  data_end, const char *  str, int  strlen  )

static

Definition at line 243 of file pgp-armor.c.

{
    const uint8 *p = data;
 
    if (!strlen)
        return NULL;
    if (data_end - data < strlen)
        return NULL;
    while (p < data_end)
    {
        p = memchr(p, str[0], data_end - p);
        if (p == NULL)
            return NULL;
        if (p + strlen > data_end)
            return NULL;
        if (memcmp(p, str, strlen) == 0)
            return p;
        p++;
    }
    return NULL;
}

References data, and str.

Referenced by find_header().

pg_base64_dec_len()

static unsigned pg_base64_dec_len ( unsigned  srclen )

static

Definition at line 172 of file pgp-armor.c.

{
    return (srclen * 3) >> 2;
}

Referenced by pgp_armor_decode().

pg_base64_decode()

static int pg_base64_decode ( const uint8 *  src, unsigned  len, uint8 *  dst  )

static

Definition at line 95 of file pgp-armor.c.

{
    const uint8 *srcend = src + len,
               *s = src;
    uint8      *p = dst;
    char        c;
    unsigned    b = 0;
    unsigned long buf = 0;
    int         pos = 0,
                end = 0;
 
    while (s < srcend)
    {
        c = *s++;
        if (c >= 'A' && c <= 'Z')
            b = c - 'A';
        else if (c >= 'a' && c <= 'z')
            b = c - 'a' + 26;
        else if (c >= '0' && c <= '9')
            b = c - '0' + 52;
        else if (c == '+')
            b = 62;
        else if (c == '/')
            b = 63;
        else if (c == '=')
        {
            /*
             * end sequence
             */
            if (!end)
            {
                if (pos == 2)
                    end = 1;
                else if (pos == 3)
                    end = 2;
                else
                    return PXE_PGP_CORRUPT_ARMOR;
            }
            b = 0;
        }
        else if (c == ' ' || c == '\t' || c == '\n' || c == '\r')
            continue;
        else
            return PXE_PGP_CORRUPT_ARMOR;
 
        /*
         * add it to buffer
         */
        buf = (buf << 6) + b;
        pos++;
        if (pos == 4)
        {
            *p++ = (buf >> 16) & 255;
            if (end == 0 || end > 1)
                *p++ = (buf >> 8) & 255;
            if (end == 0 || end > 2)
                *p++ = buf & 255;
            buf = 0;
            pos = 0;
        }
    }
 
    if (pos != 0)
        return PXE_PGP_CORRUPT_ARMOR;
    return p - dst;
}

References b, buf, len, and PXE_PGP_CORRUPT_ARMOR.

Referenced by pgp_armor_decode().

pg_base64_enc_len()

static unsigned pg_base64_enc_len ( unsigned  srclen )

static

Definition at line 163 of file pgp-armor.c.

{
    /*
     * 3 bytes will be converted to 4, linefeed after 76 chars
     */
    return (srclen + 2) / 3 * 4 + srclen / (76 * 3 / 4);
}

Referenced by pgp_armor_encode().

pg_base64_encode()

static int pg_base64_encode ( const uint8 *  src, unsigned  len, uint8 *  dst  )

static

Definition at line 45 of file pgp-armor.c.

{
    uint8      *p,
               *lend = dst + 76;
    const uint8 *s,
               *end = src + len;
    int         pos = 2;
    unsigned long buf = 0;
 
    s = src;
    p = dst;
 
    while (s < end)
    {
        buf |= *s << (pos << 3);
        pos--;
        s++;
 
        /*
         * write it out
         */
        if (pos < 0)
        {
            *p++ = _base64[(buf >> 18) & 0x3f];
            *p++ = _base64[(buf >> 12) & 0x3f];
            *p++ = _base64[(buf >> 6) & 0x3f];
            *p++ = _base64[buf & 0x3f];
 
            pos = 2;
            buf = 0;
        }
        if (p >= lend)
        {
            *p++ = '\n';
            lend = p + 76;
        }
    }
    if (pos != 2)
    {
        *p++ = _base64[(buf >> 18) & 0x3f];
        *p++ = _base64[(buf >> 12) & 0x3f];
        *p++ = (pos == 0) ? _base64[(buf >> 6) & 0x3f] : '=';
        *p++ = '=';
    }
 
    return p - dst;
}

References _base64, buf, and len.

Referenced by pgp_armor_encode().

pgp_armor_decode()

int pgp_armor_decode	(	const uint8 *	src,
		int	len,
		StringInfo	dst
	)

Definition at line 314 of file pgp-armor.c.

{
    const uint8 *p = src;
    const uint8 *data_end = src + len;
    long        crc;
    const uint8 *base64_start,
               *armor_end;
    const uint8 *base64_end = NULL;
    uint8       buf[4];
    int         hlen;
    int         blen;
    int         res = PXE_PGP_CORRUPT_ARMOR;
 
    /* armor start */
    hlen = find_header(src, data_end, &p, 0);
    if (hlen <= 0)
        goto out;
    p += hlen;
 
    /* armor end */
    hlen = find_header(p, data_end, &armor_end, 1);
    if (hlen <= 0)
        goto out;
 
    /* skip comments - find empty line */
    while (p < armor_end && *p != '\n' && *p != '\r')
    {
        p = memchr(p, '\n', armor_end - p);
        if (!p)
            goto out;
 
        /* step to start of next line */
        p++;
    }
    base64_start = p;
 
    /* find crc pos */
    for (p = armor_end; p >= base64_start; p--)
        if (*p == '=')
        {
            base64_end = p - 1;
            break;
        }
    if (base64_end == NULL)
        goto out;
 
    /* decode crc */
    if (pg_base64_decode(p + 1, 4, buf) != 3)
        goto out;
    crc = (((long) buf[0]) << 16) + (((long) buf[1]) << 8) + (long) buf[2];
 
    /* decode data */
    blen = (int) pg_base64_dec_len(len);
    enlargeStringInfo(dst, blen);
    res = pg_base64_decode(base64_start, base64_end - base64_start, (uint8 *) dst->data);
    if (res > blen)
        elog(FATAL, "overflow - decode estimate too small");
    if (res >= 0)
    {
        if (crc24((uint8 *) dst->data, res) == crc)
            dst->len += res;
        else
            res = PXE_PGP_CORRUPT_ARMOR;
    }
out:
    return res;
}

References buf, crc, crc24(), StringInfoData::data, elog, enlargeStringInfo(), FATAL, find_header(), StringInfoData::len, len, pg_base64_dec_len(), pg_base64_decode(), and PXE_PGP_CORRUPT_ARMOR.

Referenced by pg_dearmor().

pgp_armor_encode()

void pgp_armor_encode	(	const uint8 *	src,
		unsigned	len,
		StringInfo	dst,
		int	num_headers,
		char **	keys,
		char **	values
	)

Definition at line 207 of file pgp-armor.c.

{
    int         n;
    int         res;
    unsigned    b64len;
    unsigned    crc = crc24(src, len);
 
    appendStringInfoString(dst, armor_header);
 
    for (n = 0; n < num_headers; n++)
        appendStringInfo(dst, "%s: %s\n", keys[n], values[n]);
    appendStringInfoChar(dst, '\n');
 
    /* make sure we have enough room to pg_base64_encode() */
    b64len = pg_base64_enc_len(len);
    enlargeStringInfo(dst, (int) b64len);
 
    res = pg_base64_encode(src, len, (uint8 *) dst->data + dst->len);
    if (res > b64len)
        elog(FATAL, "overflow - encode estimate too small");
    dst->len += res;
 
    if (*(dst->data + dst->len - 1) != '\n')
        appendStringInfoChar(dst, '\n');
 
    appendStringInfoChar(dst, '=');
    appendStringInfoChar(dst, _base64[(crc >> 18) & 0x3f]);
    appendStringInfoChar(dst, _base64[(crc >> 12) & 0x3f]);
    appendStringInfoChar(dst, _base64[(crc >> 6) & 0x3f]);
    appendStringInfoChar(dst, _base64[crc & 0x3f]);
 
    appendStringInfoString(dst, armor_footer);
}

References _base64, appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), armor_footer, armor_header, crc, crc24(), StringInfoData::data, elog, enlargeStringInfo(), FATAL, StringInfoData::len, len, pg_base64_enc_len(), pg_base64_encode(), and values.

Referenced by pg_armor().

pgp_extract_armor_headers()

int pgp_extract_armor_headers	(	const uint8 *	src,
		unsigned	len,
		int *	nheaders,
		char ***	keys,
		char ***	values
	)

Definition at line 390 of file pgp-armor.c.

{
    const uint8 *data_end = src + len;
    const uint8 *p;
    const uint8 *base64_start;
    const uint8 *armor_start;
    const uint8 *armor_end;
    Size        armor_len;
    char       *line;
    char       *nextline;
    char       *eol,
               *colon;
    int         hlen;
    char       *buf;
    int         hdrlines;
    int         n;
 
    /* armor start */
    hlen = find_header(src, data_end, &armor_start, 0);
    if (hlen <= 0)
        return PXE_PGP_CORRUPT_ARMOR;
    armor_start += hlen;
 
    /* armor end */
    hlen = find_header(armor_start, data_end, &armor_end, 1);
    if (hlen <= 0)
        return PXE_PGP_CORRUPT_ARMOR;
 
    /* Count the number of armor header lines. */
    hdrlines = 0;
    p = armor_start;
    while (p < armor_end && *p != '\n' && *p != '\r')
    {
        p = memchr(p, '\n', armor_end - p);
        if (!p)
            return PXE_PGP_CORRUPT_ARMOR;
 
        /* step to start of next line */
        p++;
        hdrlines++;
    }
    base64_start = p;
 
    /*
     * Make a modifiable copy of the part of the input that contains the
     * headers. The returned key/value pointers will point inside the buffer.
     */
    armor_len = base64_start - armor_start;
    buf = palloc(armor_len + 1);
    memcpy(buf, armor_start, armor_len);
    buf[armor_len] = '\0';
 
    /* Allocate return arrays */
    *keys = (char **) palloc(hdrlines * sizeof(char *));
    *values = (char **) palloc(hdrlines * sizeof(char *));
 
    /*
     * Split the header lines at newlines and ": " separators, and collect
     * pointers to the keys and values in the return arrays.
     */
    n = 0;
    line = buf;
    for (;;)
    {
        /* find end of line */
        eol = strchr(line, '\n');
        if (!eol)
            break;
        nextline = eol + 1;
        /* if the line ends in CR + LF, strip the CR */
        if (eol > line && *(eol - 1) == '\r')
            eol--;
        *eol = '\0';
 
        /* find colon+space separating the key and value */
        colon = strstr(line, ": ");
        if (!colon)
            return PXE_PGP_CORRUPT_ARMOR;
        *colon = '\0';
 
        /* shouldn't happen, we counted the number of lines beforehand */
        if (n >= hdrlines)
            elog(ERROR, "unexpected number of armor header lines");
 
        (*keys)[n] = line;
        (*values)[n] = colon + 2;
        n++;
 
        /* step to start of next line */
        line = nextline;
    }
 
    if (n != hdrlines)
        elog(ERROR, "unexpected number of armor header lines");
 
    *nheaders = n;
    return 0;
}

References buf, colon, elog, ERROR, find_header(), len, palloc(), PXE_PGP_CORRUPT_ARMOR, and values.

Referenced by pgp_armor_headers().

Variable Documentation

_base64

const unsigned char _base64[]

static

Initial value:

=
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

Definition at line 41 of file pgp-armor.c.

Referenced by pg_base64_encode(), and pgp_armor_encode().

armor_footer

const char* const armor_footer = "\n-----END PGP MESSAGE-----\n"

static

Definition at line 182 of file pgp-armor.c.

Referenced by pgp_armor_encode().

armor_header

const char* const armor_header = "-----BEGIN PGP MESSAGE-----\n"

static

Definition at line 181 of file pgp-armor.c.

Referenced by pgp_armor_encode().