iPXE
Functions
base64.h File Reference

Base64 encoding. More...

#include <stdint.h>
#include <string.h>

Go to the source code of this file.

Functions

 FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
static size_t base64_encoded_len (size_t raw_len)
 Calculate length of base64-encoded data.
static size_t base64_decoded_max_len (const char *encoded)
 Calculate maximum length of base64-decoded string.
size_t base64_encode (const void *raw, size_t raw_len, char *data, size_t len)
 Base64-encode data.
int base64_decode (const char *encoded, void *data, size_t len)
 Base64-decode string.

Detailed Description

Base64 encoding.

Definition in file base64.h.


Function Documentation

FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL  )
static size_t base64_encoded_len ( size_t  raw_len) [inline, static]

Calculate length of base64-encoded data.

Parameters:
raw_lenRaw data length
Return values:
encoded_lenEncoded string length (excluding NUL)

Definition at line 21 of file base64.h.

Referenced by base64_encode_okx(), http_format_ntlm_auth(), ocsp_uri_string(), and validator_start_download().

                                                           {
        return ( ( ( raw_len + 3 - 1 ) / 3 ) * 4 );
}
static size_t base64_decoded_max_len ( const char *  encoded) [inline, static]

Calculate maximum length of base64-decoded string.

Parameters:
encodedEncoded string
max_raw_lenMaximum length of raw data

Note that the exact length of the raw data cannot be known until the string is decoded.

Definition at line 34 of file base64.h.

References strlen().

Referenced by base64_decode_okx(), and pem_asn1().

                                                                    {
        return ( ( ( strlen ( encoded ) + 4 - 1 ) / 4 ) * 3 );
}
size_t base64_encode ( const void *  raw,
size_t  raw_len,
char *  data,
size_t  len 
)

Base64-encode data.

Parameters:
rawRaw data
raw_lenLength of raw data
dataBuffer
lenLength of buffer
Return values:
lenEncoded length

Definition at line 51 of file base64.c.

References base64, byte, and raw_len.

Referenced by base64_encode_okx(), format_base64_setting(), http_format_basic_auth(), http_format_ntlm_auth(), ocsp_uri_string(), and validator_start_download().

                                    {
        const uint8_t *raw_bytes = ( ( const uint8_t * ) raw );
        size_t raw_bit_len = ( 8 * raw_len );
        size_t used = 0;
        unsigned int bit;
        unsigned int byte;
        unsigned int shift;
        unsigned int tmp;

        for ( bit = 0 ; bit < raw_bit_len ; bit += 6, used++ ) {
                byte = ( bit / 8 );
                shift = ( bit % 8 );
                tmp = ( raw_bytes[byte] << shift );
                if ( ( byte + 1 ) < raw_len )
                        tmp |= ( raw_bytes[ byte + 1 ] >> ( 8 - shift ) );
                tmp = ( ( tmp >> 2 ) & 0x3f );
                if ( used < len )
                        data[used] = base64[tmp];
        }
        for ( ; ( bit % 8 ) != 0 ; bit += 6, used++ ) {
                if ( used < len )
                        data[used] = '=';
        }
        if ( used < len )
                data[used] = '\0';
        if ( len )
                data[ len - 1 ] = '\0'; /* Ensure terminator exists */

        return used;
}
int base64_decode ( const char *  encoded,
void *  data,
size_t  len 
)

Base64-decode string.

Parameters:
encodedEncoded string
dataBuffer
lenLength of buffer
Return values:
lenLength of data, or negative error

Definition at line 91 of file base64.c.

References base64, data, DBG, EINVAL, in, isspace(), memset(), offset, out, and strchr().

Referenced by base64_decode_okx(), http_parse_ntlm_auth(), iscsi_large_binary_decode(), parse_base64_setting(), and pem_asn1().

                                                                  {
        const char *in = encoded;
        uint8_t *out = data;
        uint8_t in_char;
        char *match;
        int in_bits;
        unsigned int bit = 0;
        unsigned int pad_count = 0;
        size_t offset;

        /* Zero the output buffer */
        memset ( data, 0, len );

        /* Decode string */
        while ( ( in_char = *(in++) ) ) {

                /* Ignore whitespace characters */
                if ( isspace ( in_char ) )
                        continue;

                /* Process pad characters */
                if ( in_char == '=' ) {
                        if ( pad_count >= 2 ) {
                                DBG ( "Base64-encoded string \"%s\" has too "
                                      "many pad characters\n", encoded );
                                return -EINVAL;
                        }
                        pad_count++;
                        bit -= 2; /* unused_bits = ( 2 * pad_count ) */
                        continue;
                }
                if ( pad_count ) {
                        DBG ( "Base64-encoded string \"%s\" has invalid pad "
                              "sequence\n", encoded );
                        return -EINVAL;
                }

                /* Process normal characters */
                match = strchr ( base64, in_char );
                if ( ! match ) {
                        DBG ( "Base64-encoded string \"%s\" contains invalid "
                              "character '%c'\n", encoded, in_char );
                        return -EINVAL;
                }
                in_bits = ( match - base64 );

                /* Add to raw data */
                in_bits <<= 2;
                offset = ( bit / 8 );
                if ( offset < len )
                        out[offset] |= ( in_bits >> ( bit % 8 ) );
                offset++;
                if ( offset < len )
                        out[offset] |= ( in_bits << ( 8 - ( bit % 8 ) ) );
                bit += 6;
        }

        /* Check that we decoded a whole number of bytes */
        if ( ( bit % 8 ) != 0 ) {
                DBG ( "Base64-encoded string \"%s\" has invalid bit length "
                      "%d\n", encoded, bit );
                return -EINVAL;
        }

        /* Return length in bytes */
        return ( bit / 8 );
}