#include "postgres.h"
#include "common/base64.h"

Include dependency graph for base64.c:

Functions
int	pg_b64_encode (const char src, int len, char dst, int dstlen)

int	pg_b64_decode (const char src, int len, char dst, int dstlen)

int	pg_b64_enc_len (int srclen)

int	pg_b64_dec_len (int srclen)

Variables
static const char	_base64 []

static const int8	b64lookup [128]

Function Documentation

◆ pg_b64_dec_len()

int pg_b64_dec_len ( int srclen )

Definition at line 239 of file base64.c.

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

Referenced by parse_scram_secret(), read_client_final_message(), read_server_final_message(), read_server_first_message(), and scram_verify_plain_password().

◆ pg_b64_decode()

int pg_b64_decode	(	const char *	src,
		int	len,
		char *	dst,
		int	dstlen
	)

Definition at line 116 of file base64.c.

 {
     const char *srcend = src + len,
                *s = src;
     char       *p = dst;
     char        c;
     int         b = 0;
     uint32      buf = 0;
     int         pos = 0,
                 end = 0;
  
     while (s < srcend)
     {
         c = *s++;
  
         /* Leave if a whitespace is found */
         if (c == ' ' || c == '\t' || c == '\n' || c == '\r')
             goto error;
  
         if (c == '=')
         {
             /* end sequence */
             if (!end)
             {
                 if (pos == 2)
                     end = 1;
                 else if (pos == 3)
                     end = 2;
                 else
                 {
                     /*
                      * Unexpected "=" character found while decoding base64
                      * sequence.
                      */
                     goto error;
                 }
             }
             b = 0;
         }
         else
         {
             b = -1;
             if (c > 0 && c < 127)
                 b = b64lookup[(unsigned char) c];
             if (b < 0)
             {
                 /* invalid symbol found */
                 goto error;
             }
         }
         /* add it to buffer */
         buf = (buf << 6) + b;
         pos++;
         if (pos == 4)
         {
             /*
              * Leave if there is an overflow in the area allocated for the
              * decoded string.
              */
             if ((p - dst + 1) > dstlen)
                 goto error;
             *p++ = (buf >> 16) & 255;
  
             if (end == 0 || end > 1)
             {
                 /* overflow check */
                 if ((p - dst + 1) > dstlen)
                     goto error;
                 *p++ = (buf >> 8) & 255;
             }
             if (end == 0 || end > 2)
             {
                 /* overflow check */
                 if ((p - dst + 1) > dstlen)
                     goto error;
                 *p++ = buf & 255;
             }
             buf = 0;
             pos = 0;
         }
     }
  
     if (pos != 0)
     {
         /*
          * base64 end sequence is invalid.  Input data is missing padding, is
          * truncated or is otherwise corrupted.
          */
         goto error;
     }
  
     Assert((p - dst) <= dstlen);
     return p - dst;
  
 error:
     memset(dst, 0, dstlen);
     return -1;
 }

References Assert, b, b64lookup, buf, error(), and len.

Referenced by parse_scram_secret(), read_client_final_message(), read_server_final_message(), read_server_first_message(), and scram_verify_plain_password().

◆ pg_b64_enc_len()

int pg_b64_enc_len ( int srclen )

Definition at line 224 of file base64.c.

 {
     /* 3 bytes will be converted to 4 */
     return (srclen + 2) / 3 * 4;
 }

Referenced by build_client_final_message(), build_client_first_message(), build_server_final_message(), build_server_first_message(), mock_scram_secret(), read_client_final_message(), and scram_build_secret().

◆ pg_b64_encode()

int pg_b64_encode	(	const char *	src,
		int	len,
		char *	dst,
		int	dstlen
	)

Definition at line 49 of file base64.c.

 {
     char       *p;
     const char *s,
                *end = src + len;
     int         pos = 2;
     uint32      buf = 0;
  
     s = src;
     p = dst;
  
     while (s < end)
     {
         buf |= (unsigned char) *s << (pos << 3);
         pos--;
         s++;
  
         /* write it out */
         if (pos < 0)
         {
             /*
              * Leave if there is an overflow in the area allocated for the
              * encoded string.
              */
             if ((p - dst + 4) > dstlen)
                 goto error;
  
             *p++ = _base64[(buf >> 18) & 0x3f];
             *p++ = _base64[(buf >> 12) & 0x3f];
             *p++ = _base64[(buf >> 6) & 0x3f];
             *p++ = _base64[buf & 0x3f];
  
             pos = 2;
             buf = 0;
         }
     }
     if (pos != 2)
     {
         /*
          * Leave if there is an overflow in the area allocated for the encoded
          * string.
          */
         if ((p - dst + 4) > dstlen)
             goto error;
  
         *p++ = _base64[(buf >> 18) & 0x3f];
         *p++ = _base64[(buf >> 12) & 0x3f];
         *p++ = (pos == 0) ? _base64[(buf >> 6) & 0x3f] : '=';
         *p++ = '=';
     }
  
     Assert((p - dst) <= dstlen);
     return p - dst;
  
 error:
     memset(dst, 0, dstlen);
     return -1;
 }

References _base64, Assert, buf, error(), and len.

Referenced by build_client_final_message(), build_client_first_message(), build_server_final_message(), build_server_first_message(), mock_scram_secret(), read_client_final_message(), and scram_build_secret().

Variable Documentation

◆ _base64

const char _base64[]

static

Initial value:

=

"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

Definition at line 27 of file base64.c.

Referenced by pg_b64_encode().

◆ b64lookup

const int8 b64lookup[128]