checksum.h File Reference

Small dependency-free SHA-256 utility for persistent metadata identity. More...

#include <petscsys.h>
#include <stddef.h>
#include <stdint.h>

Include dependency graph for checksum.h:

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

Go to the source code of this file.

Data Structures
struct	PicurvSHA256Context
	Incremental SHA-256 state. More...

Functions
void	PicurvSHA256Init (PicurvSHA256Context *context)
	Initialize an incremental SHA-256 calculation.
void	PicurvSHA256Update (PicurvSHA256Context *context, const void *data, size_t length)
	Add bytes to an incremental SHA-256 calculation.
void	PicurvSHA256FinalHex (PicurvSHA256Context *context, char digest_hex[65])
	Finish a SHA-256 calculation and return a lowercase hexadecimal digest.
PetscErrorCode	PicurvSHA256File (const char *path, char digest_hex[65])
	Compute the lowercase SHA-256 digest of a file.

Detailed Description

Small dependency-free SHA-256 utility for persistent metadata identity.

Definition in file checksum.h.

---

Data Structure Documentation

PicurvSHA256Context

struct PicurvSHA256Context

Incremental SHA-256 state.

Definition at line 14 of file checksum.h.

Data Fields
uint32_t	state[8]
uint64_t	bit_count
unsigned char	buffer[64]
size_t	buffer_size

Function Documentation

PicurvSHA256Init()

void PicurvSHA256Init

(

PicurvSHA256Context *

context

)

Initialize an incremental SHA-256 calculation.

Parameters

[out]

context

Hash state to initialize.

Initialize an incremental SHA-256 calculation.

Definition at line 62 of file checksum.c.

{
    if (!context) return;
    context->state[0] = 0x6a09e667u; context->state[1] = 0xbb67ae85u;
    context->state[2] = 0x3c6ef372u; context->state[3] = 0xa54ff53au;
    context->state[4] = 0x510e527fu; context->state[5] = 0x9b05688cu;
    context->state[6] = 0x1f83d9abu; context->state[7] = 0x5be0cd19u;
    context->bit_count = 0;
    context->buffer_size = 0;
}

Here is the caller graph for this function:

PicurvSHA256Update()

void PicurvSHA256Update	(	PicurvSHA256Context *	context,
		const void *	data,
		size_t	length
	)

Add bytes to an incremental SHA-256 calculation.

Parameters

[in,out]	context	Active hash state.
[in]	data	Bytes to add.
[in]	length	Number of bytes to add.

Add bytes to an incremental SHA-256 calculation.

Definition at line 74 of file checksum.c.

{
    const unsigned char *bytes = (const unsigned char *)data;
 
    if (!context || (!bytes && length > 0)) return;
    context->bit_count += (uint64_t)length * 8u;
 
    while (length > 0) {
        const size_t room = 64 - context->buffer_size;
        const size_t take = length < room ? length : room;
        for (size_t index = 0; index < take; ++index) {
            context->buffer[context->buffer_size + index] = bytes[index];
        }
        context->buffer_size += take;
        bytes += take;
        length -= take;
        if (context->buffer_size == 64) {
            PicurvSHA256Transform(context, context->buffer);
            context->buffer_size = 0;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

PicurvSHA256FinalHex()

void PicurvSHA256FinalHex	(	PicurvSHA256Context *	context,
		char	digest_hex[65]
	)

Finish a SHA-256 calculation and return a lowercase hexadecimal digest.

Parameters

[in,out]	context	Active hash state.
[out]	digest_hex	Null-terminated 64-character lowercase digest.

Finish a SHA-256 calculation and return a lowercase hexadecimal digest.

Definition at line 98 of file checksum.c.

{
    static const char hex[] = "0123456789abcdef";
    unsigned char digest[32];
    const uint64_t message_bits = context ? context->bit_count : 0;
    unsigned char padding[128] = {0x80};
    size_t padding_length;
 
    if (!context || !digest_hex) return;
    padding_length = context->buffer_size < 56 ? 56 - context->buffer_size : 120 - context->buffer_size;
    PicurvSHA256Update(context, padding, padding_length);
    context->bit_count = message_bits;
 
    for (size_t index = 0; index < 8; ++index) {
        context->buffer[56 + index] = (unsigned char)(message_bits >> (56 - 8 * index));
    }
    PicurvSHA256Transform(context, context->buffer);
 
    for (size_t index = 0; index < 8; ++index) {
        digest[4 * index] = (unsigned char)(context->state[index] >> 24);
        digest[4 * index + 1] = (unsigned char)(context->state[index] >> 16);
        digest[4 * index + 2] = (unsigned char)(context->state[index] >> 8);
        digest[4 * index + 3] = (unsigned char)context->state[index];
    }
    for (size_t index = 0; index < sizeof(digest); ++index) {
        digest_hex[2 * index] = hex[digest[index] >> 4];
        digest_hex[2 * index + 1] = hex[digest[index] & 0x0f];
    }
    digest_hex[64] = '\0';
}

Here is the call graph for this function:

Here is the caller graph for this function:

PicurvSHA256File()

PetscErrorCode PicurvSHA256File	(	const char *	path,
		char	digest_hex[65]
	)

Compute the lowercase SHA-256 digest of a file.

Parameters

[in]	path	File to hash.
[out]	digest_hex	Null-terminated 64-character lowercase digest.

Returns

Zero on success or a PETSc filesystem error.

Compute the lowercase SHA-256 digest of a file.

Definition at line 130 of file checksum.c.

{
    FILE *file = NULL;
    unsigned char buffer[8192];
    PicurvSHA256Context context;
 
    PetscFunctionBeginUser;
    PetscCheck(path != NULL && digest_hex != NULL, PETSC_COMM_SELF, PETSC_ERR_ARG_NULL,
               "SHA-256 file path and digest output are required.");
    file = fopen(path, "rb");
    PetscCheck(file != NULL, PETSC_COMM_SELF, PETSC_ERR_FILE_OPEN,
               "Unable to open '%s' while computing SHA-256.", path);
 
    PicurvSHA256Init(&context);
    while (!feof(file)) {
        const size_t count = fread(buffer, 1, sizeof(buffer), file);
        if (count > 0) PicurvSHA256Update(&context, buffer, count);
        PetscCheck(!ferror(file), PETSC_COMM_SELF, PETSC_ERR_FILE_READ,
                   "Unable to read '%s' while computing SHA-256.", path);
    }
    PetscCheck(fclose(file) == 0, PETSC_COMM_SELF, PETSC_ERR_FILE_READ,
               "Unable to close '%s' after computing SHA-256.", path);
    PicurvSHA256FinalHex(&context, digest_hex);
    PetscFunctionReturn(0);
}

Here is the call graph for this function:

Here is the caller graph for this function: