sha2_int.h File Reference

#include "common/sha2.h"

Include dependency graph for sha2_int.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	pg_sha256_ctx
struct	pg_sha512_ctx

Typedefs
typedef struct pg_sha256_ctx	pg_sha256_ctx
typedef struct pg_sha512_ctx	pg_sha512_ctx
typedef struct pg_sha256_ctx	pg_sha224_ctx
typedef struct pg_sha512_ctx	pg_sha384_ctx

Functions
void	pg_sha224_init (pg_sha224_ctx *ctx)
void	pg_sha224_update (pg_sha224_ctx *ctx, const uint8 *input0, size_t len)
void	pg_sha224_final (pg_sha224_ctx *ctx, uint8 *dest)
void	pg_sha256_init (pg_sha256_ctx *ctx)
void	pg_sha256_update (pg_sha256_ctx *ctx, const uint8 *input0, size_t len)
void	pg_sha256_final (pg_sha256_ctx *ctx, uint8 *dest)
void	pg_sha384_init (pg_sha384_ctx *ctx)
void	pg_sha384_update (pg_sha384_ctx *ctx, const uint8 *, size_t len)
void	pg_sha384_final (pg_sha384_ctx *ctx, uint8 *dest)
void	pg_sha512_init (pg_sha512_ctx *ctx)
void	pg_sha512_update (pg_sha512_ctx *ctx, const uint8 *input0, size_t len)
void	pg_sha512_final (pg_sha512_ctx *ctx, uint8 *dest)

Typedef Documentation

pg_sha224_ctx

typedef struct pg_sha256_ctx pg_sha224_ctx

Definition at line 67 of file sha2_int.h.

pg_sha256_ctx

typedef struct pg_sha256_ctx pg_sha256_ctx

pg_sha384_ctx

typedef struct pg_sha512_ctx pg_sha384_ctx

Definition at line 68 of file sha2_int.h.

pg_sha512_ctx

typedef struct pg_sha512_ctx pg_sha512_ctx

Function Documentation

pg_sha224_final()

void pg_sha224_final ( pg_sha224_ctx *  ctx, uint8 *  dest  )

extern

Definition at line 995 of file sha2.c.

{
    /* If no digest buffer is passed, we don't bother doing this: */
    if (digest != NULL)
    {
        SHA256_Last(context);
 
#ifndef WORDS_BIGENDIAN
        {
            /* Convert TO host byte order */
            int         j;
 
            for (j = 0; j < 8; j++)
            {
                REVERSE32(context->state[j], context->state[j]);
            }
        }
#endif
        memcpy(digest, context->state, PG_SHA224_DIGEST_LENGTH);
    }
 
    /* Clean up state data: */
    memset(context, 0, sizeof(pg_sha224_ctx));
}

References fb(), j, memcpy(), PG_SHA224_DIGEST_LENGTH, REVERSE32, SHA256_Last(), and pg_sha256_ctx::state.

Referenced by pg_cryptohash_final().

pg_sha224_init()

void pg_sha224_init ( pg_sha224_ctx *  ctx )

extern

Definition at line 979 of file sha2.c.

{
    if (context == NULL)
        return;
    memcpy(context->state, sha224_initial_hash_value, PG_SHA256_DIGEST_LENGTH);
    memset(context->buffer, 0, PG_SHA256_BLOCK_LENGTH);
    context->bitcount = 0;
}

References pg_sha256_ctx::bitcount, pg_sha256_ctx::buffer, fb(), memcpy(), PG_SHA256_BLOCK_LENGTH, PG_SHA256_DIGEST_LENGTH, sha224_initial_hash_value, and pg_sha256_ctx::state.

Referenced by pg_cryptohash_init().

pg_sha224_update()

void pg_sha224_update ( pg_sha224_ctx *  ctx, const uint8 *  input0, size_t  len  )

extern

Definition at line 989 of file sha2.c.

{
    pg_sha256_update((pg_sha256_ctx *) context, data, len);
}

References data, len, and pg_sha256_update().

Referenced by pg_cryptohash_update().

pg_sha256_final()

void pg_sha256_final ( pg_sha256_ctx *  ctx, uint8 *  dest  )

extern

Definition at line 578 of file sha2.c.

{
    /* If no digest buffer is passed, we don't bother doing this: */
    if (digest != NULL)
    {
        SHA256_Last(context);
 
#ifndef WORDS_BIGENDIAN
        {
            /* Convert TO host byte order */
            int         j;
 
            for (j = 0; j < 8; j++)
            {
                REVERSE32(context->state[j], context->state[j]);
            }
        }
#endif
        memcpy(digest, context->state, PG_SHA256_DIGEST_LENGTH);
    }
 
    /* Clean up state data: */
    memset(context, 0, sizeof(pg_sha256_ctx));
}

References fb(), j, memcpy(), PG_SHA256_DIGEST_LENGTH, REVERSE32, SHA256_Last(), and pg_sha256_ctx::state.

Referenced by pg_cryptohash_final().

pg_sha256_init()

void pg_sha256_init ( pg_sha256_ctx *  ctx )

extern

Definition at line 280 of file sha2.c.

{
    if (context == NULL)
        return;
    memcpy(context->state, sha256_initial_hash_value, PG_SHA256_DIGEST_LENGTH);
    memset(context->buffer, 0, PG_SHA256_BLOCK_LENGTH);
    context->bitcount = 0;
}

References pg_sha256_ctx::bitcount, pg_sha256_ctx::buffer, fb(), memcpy(), PG_SHA256_BLOCK_LENGTH, PG_SHA256_DIGEST_LENGTH, sha256_initial_hash_value, and pg_sha256_ctx::state.

Referenced by pg_cryptohash_init().

pg_sha256_update()

void pg_sha256_update ( pg_sha256_ctx *  ctx, const uint8 *  input0, size_t  len  )

extern

Definition at line 477 of file sha2.c.

{
    size_t      freespace,
                usedspace;
 
    /* Calling with no data is valid (we do nothing) */
    if (len == 0)
        return;
 
    usedspace = (context->bitcount >> 3) % PG_SHA256_BLOCK_LENGTH;
    if (usedspace > 0)
    {
        /* Calculate how much free space is available in the buffer */
        freespace = PG_SHA256_BLOCK_LENGTH - usedspace;
 
        if (len >= freespace)
        {
            /* Fill the buffer completely and process it */
            memcpy(&context->buffer[usedspace], data, freespace);
            context->bitcount += freespace << 3;
            len -= freespace;
            data += freespace;
            SHA256_Transform(context, context->buffer);
        }
        else
        {
            /* The buffer is not yet full */
            memcpy(&context->buffer[usedspace], data, len);
            context->bitcount += len << 3;
            /* Clean up: */
            usedspace = freespace = 0;
            return;
        }
    }
    while (len >= PG_SHA256_BLOCK_LENGTH)
    {
        /* Process as many complete blocks as we can */
        SHA256_Transform(context, data);
        context->bitcount += PG_SHA256_BLOCK_LENGTH << 3;
        len -= PG_SHA256_BLOCK_LENGTH;
        data += PG_SHA256_BLOCK_LENGTH;
    }
    if (len > 0)
    {
        /* There's left-overs, so save 'em */
        memcpy(context->buffer, data, len);
        context->bitcount += len << 3;
    }
    /* Clean up: */
    usedspace = freespace = 0;
}

References pg_sha256_ctx::bitcount, pg_sha256_ctx::buffer, data, fb(), len, memcpy(), PG_SHA256_BLOCK_LENGTH, and SHA256_Transform().

Referenced by pg_cryptohash_update(), and pg_sha224_update().

pg_sha384_final()

void pg_sha384_final ( pg_sha384_ctx *  ctx, uint8 *  dest  )

extern

Definition at line 951 of file sha2.c.

{
    /* If no digest buffer is passed, we don't bother doing this: */
    if (digest != NULL)
    {
        SHA512_Last((pg_sha512_ctx *) context);
 
        /* Save the hash data for output: */
#ifndef WORDS_BIGENDIAN
        {
            /* Convert TO host byte order */
            int         j;
 
            for (j = 0; j < 6; j++)
            {
                REVERSE64(context->state[j], context->state[j]);
            }
        }
#endif
        memcpy(digest, context->state, PG_SHA384_DIGEST_LENGTH);
    }
 
    /* Zero out state data */
    memset(context, 0, sizeof(pg_sha384_ctx));
}

References fb(), j, memcpy(), PG_SHA384_DIGEST_LENGTH, REVERSE64, SHA512_Last(), and pg_sha512_ctx::state.

Referenced by pg_cryptohash_final().

pg_sha384_init()

void pg_sha384_init ( pg_sha384_ctx *  ctx )

extern

Definition at line 935 of file sha2.c.

{
    if (context == NULL)
        return;
    memcpy(context->state, sha384_initial_hash_value, PG_SHA512_DIGEST_LENGTH);
    memset(context->buffer, 0, PG_SHA384_BLOCK_LENGTH);
    context->bitcount[0] = context->bitcount[1] = 0;
}

References pg_sha512_ctx::bitcount, pg_sha512_ctx::buffer, fb(), memcpy(), PG_SHA384_BLOCK_LENGTH, PG_SHA512_DIGEST_LENGTH, sha384_initial_hash_value, and pg_sha512_ctx::state.

Referenced by pg_cryptohash_init().

pg_sha384_update()

void pg_sha384_update ( pg_sha384_ctx *  ctx, const uint8 *  data, size_t  len  )

extern

Definition at line 945 of file sha2.c.

{
    pg_sha512_update((pg_sha512_ctx *) context, data, len);
}

References data, len, and pg_sha512_update().

Referenced by pg_cryptohash_update().

pg_sha512_final()

void pg_sha512_final ( pg_sha512_ctx *  ctx, uint8 *  dest  )

extern

Definition at line 906 of file sha2.c.

{
    /* If no digest buffer is passed, we don't bother doing this: */
    if (digest != NULL)
    {
        SHA512_Last(context);
 
        /* Save the hash data for output: */
#ifndef WORDS_BIGENDIAN
        {
            /* Convert TO host byte order */
            int         j;
 
            for (j = 0; j < 8; j++)
            {
                REVERSE64(context->state[j], context->state[j]);
            }
        }
#endif
        memcpy(digest, context->state, PG_SHA512_DIGEST_LENGTH);
    }
 
    /* Zero out state data */
    memset(context, 0, sizeof(pg_sha512_ctx));
}

References fb(), j, memcpy(), PG_SHA512_DIGEST_LENGTH, REVERSE64, SHA512_Last(), and pg_sha512_ctx::state.

Referenced by pg_cryptohash_final().

pg_sha512_init()

void pg_sha512_init ( pg_sha512_ctx *  ctx )

extern

Definition at line 606 of file sha2.c.

{
    if (context == NULL)
        return;
    memcpy(context->state, sha512_initial_hash_value, PG_SHA512_DIGEST_LENGTH);
    memset(context->buffer, 0, PG_SHA512_BLOCK_LENGTH);
    context->bitcount[0] = context->bitcount[1] = 0;
}

References pg_sha512_ctx::bitcount, pg_sha512_ctx::buffer, fb(), memcpy(), PG_SHA512_BLOCK_LENGTH, PG_SHA512_DIGEST_LENGTH, sha512_initial_hash_value, and pg_sha512_ctx::state.

Referenced by pg_cryptohash_init().

pg_sha512_update()

void pg_sha512_update ( pg_sha512_ctx *  ctx, const uint8 *  input0, size_t  len  )

extern

Definition at line 803 of file sha2.c.

{
    size_t      freespace,
                usedspace;
 
    /* Calling with no data is valid (we do nothing) */
    if (len == 0)
        return;
 
    usedspace = (context->bitcount[0] >> 3) % PG_SHA512_BLOCK_LENGTH;
    if (usedspace > 0)
    {
        /* Calculate how much free space is available in the buffer */
        freespace = PG_SHA512_BLOCK_LENGTH - usedspace;
 
        if (len >= freespace)
        {
            /* Fill the buffer completely and process it */
            memcpy(&context->buffer[usedspace], data, freespace);
            ADDINC128(context->bitcount, freespace << 3);
            len -= freespace;
            data += freespace;
            SHA512_Transform(context, context->buffer);
        }
        else
        {
            /* The buffer is not yet full */
            memcpy(&context->buffer[usedspace], data, len);
            ADDINC128(context->bitcount, len << 3);
            /* Clean up: */
            usedspace = freespace = 0;
            return;
        }
    }
    while (len >= PG_SHA512_BLOCK_LENGTH)
    {
        /* Process as many complete blocks as we can */
        SHA512_Transform(context, data);
        ADDINC128(context->bitcount, PG_SHA512_BLOCK_LENGTH << 3);
        len -= PG_SHA512_BLOCK_LENGTH;
        data += PG_SHA512_BLOCK_LENGTH;
    }
    if (len > 0)
    {
        /* There's left-overs, so save 'em */
        memcpy(context->buffer, data, len);
        ADDINC128(context->bitcount, len << 3);
    }
    /* Clean up: */
    usedspace = freespace = 0;
}

References ADDINC128, pg_sha512_ctx::bitcount, pg_sha512_ctx::buffer, data, fb(), len, memcpy(), PG_SHA512_BLOCK_LENGTH, and SHA512_Transform().

Referenced by pg_cryptohash_update(), and pg_sha384_update().