duckdb::MD5Context Class Reference

Public Member Functions
void	Add (const_data_ptr_t data, idx_t len)
void	Add (const char *data)
void	Add (string_t string)
void	Add (const string &data)
void	Finish (data_ptr_t out_digest)
	Write the 16-byte (binary) digest to the specified location.
void	FinishHex (char *out_digest)
	Write the 32-character digest (in hexadecimal format) to the specified location.
string	FinishHex ()
	Returns the 32-character digest (in hexadecimal format) as a string.

Static Public Attributes
static constexpr idx_t	MD5_HASH_LENGTH_BINARY = 16
static constexpr idx_t	MD5_HASH_LENGTH_TEXT = 32

Private Member Functions
void	MD5Update (const_data_ptr_t data, idx_t len)

Private Attributes
uint32_t	buf [4]
uint32_t	bits [2]
unsigned char	in [64]

Constructor & Destructor Documentation

MD5Context()

duckdb::MD5Context::MD5Context

(

)

                       {
    buf[0] = 0x67452301;
    buf[1] = 0xefcdab89;
    buf[2] = 0x98badcfe;
    buf[3] = 0x10325476;
    bits[0] = 0;
    bits[1] = 0;
}

Member Function Documentation

Add() [1/4]

void duckdb::MD5Context::Add ( const_data_ptr_t  data, idx_t  len  )

inline

                                               {
        MD5Update(data, len);
    }

Add() [2/4]

void duckdb::MD5Context::Add

(

const char *

data

)

                                     {
    MD5Update(const_data_ptr_cast(data), strlen(data));
}

Add() [3/4]

void duckdb::MD5Context::Add ( string_t  string )

inline

                              {
        MD5Update(const_data_ptr_cast(string.GetData()), string.GetSize());
    }

Add() [4/4]

void duckdb::MD5Context::Add ( const string &  data )

inline

                                 {
        MD5Update(const_data_ptr_cast(data.c_str()), data.size());
    }

Finish()

void duckdb::MD5Context::Finish

(

data_ptr_t

out_digest

)

Write the 16-byte (binary) digest to the specified location.

                                             {
    unsigned count;
    unsigned char *p;
 
    /* Compute number of bytes mod 64 */
    count = (bits[0] >> 3) & 0x3F;
 
    /* Set the first char of padding to 0x80.  This is safe since there is
       always at least one byte free */
    p = in + count;
    *p++ = 0x80;
 
    /* Bytes of padding needed to make 64 bytes */
    count = 64 - 1 - count;
 
    /* Pad out to 56 mod 64 */
    if (count < 8) {
        /* Two lots of padding:  Pad the first block to 64 bytes */
        memset(p, 0, count);
        ByteReverse(in, 16);
        MD5Transform(buf, reinterpret_cast<uint32_t *>(in));
 
        /* Now fill the next block with 56 bytes */
        memset(in, 0, 56);
    } else {
        /* Pad block to 56 bytes */
        memset(p, 0, count - 8);
    }
    ByteReverse(in, 14);
 
    /* Append length in bits and transform */
    (reinterpret_cast<uint32_t *>(in))[14] = bits[0];
    (reinterpret_cast<uint32_t *>(in))[15] = bits[1];
 
    MD5Transform(buf, reinterpret_cast<uint32_t *>(in));
    ByteReverse(reinterpret_cast<unsigned char *>(buf), 4);
    memcpy(out_digest, buf, 16);
}

Here is the caller graph for this function:

FinishHex() [1/2]

void duckdb::MD5Context::FinishHex

(

char *

out_digest

)

Write the 32-character digest (in hexadecimal format) to the specified location.

                                           {
    data_t digest[MD5_HASH_LENGTH_BINARY];
    Finish(digest);
    duckdb_mbedtls::MbedTlsWrapper::ToBase16(reinterpret_cast<char *>(digest), out_digest, MD5_HASH_LENGTH_BINARY);
}

Here is the call graph for this function:

FinishHex() [2/2]

string duckdb::MD5Context::FinishHex

(

)

Returns the 32-character digest (in hexadecimal format) as a string.

                             {
    char digest[MD5_HASH_LENGTH_TEXT];
    FinishHex(digest);
    return string(digest, MD5_HASH_LENGTH_TEXT);
}

Here is the call graph for this function:

Here is the caller graph for this function:

MD5Update()

void duckdb::MD5Context::MD5Update ( const_data_ptr_t  data, idx_t  len  )

private

                                                            {
    uint32_t t;
 
    /* Update bitcount */
 
    t = bits[0];
    bits[0] = t + ((uint32_t)len << 3);
    if (bits[0] < t) {
        bits[1]++; /* Carry from low to high */
    }
    bits[1] += len >> 29;
 
    t = (t >> 3) & 0x3f; /* Bytes already in shsInfo->data */
 
    /* Handle any leading odd-sized chunks */
 
    if (t) {
        unsigned char *p = (unsigned char *)in + t;
 
        t = 64 - t;
        if (len < t) {
            memcpy(p, input, len);
            return;
        }
        memcpy(p, input, t);
        ByteReverse(in, 16);
        MD5Transform(buf, reinterpret_cast<uint32_t *>(in));
        input += t;
        len -= t;
    }
 
    /* Process data in 64-byte chunks */
 
    while (len >= 64) {
        memcpy(in, input, 64);
        ByteReverse(in, 16);
        MD5Transform(buf, reinterpret_cast<uint32_t *>(in));
        input += 64;
        len -= 64;
    }
 
    /* Handle any remaining bytes of data. */
    memcpy(in, input, len);
}

---

The documentation for this class was generated from the following file:

• external/duckdb/duckdb.cpp