code cleanups and CI updates.

This commit is contained in:
Kyle Isom 2023-10-19 10:41:59 -07:00
parent 146ccc71f3
commit fcf4bcd7b7
4 changed files with 113 additions and 134 deletions

View File

@ -9,14 +9,14 @@ jobs:
# Specify the execution environment. You can specify an image from Docker Hub or use one of our convenience images from CircleCI's Developer Hub. # Specify the execution environment. You can specify an image from Docker Hub or use one of our convenience images from CircleCI's Developer Hub.
# See: https://circleci.com/docs/configuration-reference/#executor-job # See: https://circleci.com/docs/configuration-reference/#executor-job
docker: docker:
- image: kisom/sc-dev:1.0.0 - image: git.wntrmute.dev/sc/dev:alpine
# Add steps to the job # Add steps to the job
# See: https://circleci.com/docs/configuration-reference/#steps # See: https://circleci.com/docs/configuration-reference/#steps
steps: steps:
- checkout - checkout
- run: - run:
name: Setup cmake build name: Setup cmake build
command: ./scripts/setup-cmake.sh command: setup-cmake.sh
# Orchestrate jobs using workflows # Orchestrate jobs using workflows
# See: https://circleci.com/docs/configuration-reference/#workflows # See: https://circleci.com/docs/configuration-reference/#workflows

View File

@ -1,18 +0,0 @@
language: cpp
compiler:
- clang
- gcc
addons:
apt:
sources:
- ubuntu-toolchain-r-test
packages:
- gcc-4.8
- g++-4.8
- clang
- python-sphinx
- python-sphinx-rtd-theme
- pkg-config
install:
- if [ "$CXX" = "g++" ]; then export CXX="g++-4.8" CC="gcc-4.8"; fi
script: "./autobuild && ./do-release"

View File

@ -1,18 +0,0 @@
FROM ubuntu:jammy
LABEL authors="kyle"
ARG DEBIAN_FRONTEND=noninteractive
ARG AUTOMATED_MODE=yes
WORKDIR /tmp
ENV TZ=America/Los_Angeles
RUN apt-get update -y && apt-get install -y gpg sudo ca-certificates apt-transport-https ssh tar gzip
RUN mkdir scripts
WORKDIR scripts
ADD scripts .
WORKDIR /tmp
RUN bash ./scripts/install-depdendencies.sh && rm -r *
RUN apt-get autoclean && \
apt-get autoremove && \
apt-get clean && \
rm -rf /var/lib/apt/lists/*

207
sha256.cc
View File

@ -147,9 +147,9 @@ SHA256::reset()
uint32_t uint32_t
SHA256::chunkToUint32(uint32_t offset) SHA256::chunkToUint32(uint32_t offset)
{ {
uint32_t chunk = 0; uint32_t chunk = 0U;
for (uint32_t i = offset; i < offset+4; i++) { for (uint32_t i = offset; i < offset+4U; i++) {
chunk <<= 8; chunk <<= 8;
chunk += static_cast<uint32_t>(this->mb[i]); chunk += static_cast<uint32_t>(this->mb[i]);
} }
@ -161,9 +161,9 @@ SHA256::chunkToUint32(uint32_t offset)
uint32_t uint32_t
SHA256::uint32ToChunk(uint32_t offset) SHA256::uint32ToChunk(uint32_t offset)
{ {
uint32_t chunk = 0; uint32_t chunk = 0U;
for (uint32_t i = offset; i < offset+4; i++) { for (uint32_t i = offset; i < offset+4U; i++) {
chunk <<= 8; chunk <<= 8;
chunk += static_cast<uint32_t>(this->mb[i]); chunk += static_cast<uint32_t>(this->mb[i]);
} }
@ -176,10 +176,10 @@ SHA256::uint32ToChunk(uint32_t offset)
static void static void
uint32ToChunkInPlace(uint32_t x, uint8_t *chunk) uint32ToChunkInPlace(uint32_t x, uint8_t *chunk)
{ {
chunk[0] = (x & 0xff000000) >> 24; chunk[0] = static_cast<uint8_t>((x & 0xff000000u) >> 24);
chunk[1] = (x & 0x00ff0000) >> 16; chunk[1] = static_cast<uint8_t>((x & 0x00ff0000u) >> 16);
chunk[2] = (x & 0x0000ff00) >> 8; chunk[2] = static_cast<uint8_t>((x & 0x0000ff00U) >> 8);
chunk[3] = (x & 0x000000ff); chunk[3] = static_cast<uint8_t>(x & 0x000000ffU);
} }
@ -188,26 +188,26 @@ void
SHA256::updateMessageBlock() SHA256::updateMessageBlock()
{ {
uint32_t w[64]; uint32_t w[64];
uint32_t i = 0; uint32_t i = 0U;
uint32_t chunk = 0; uint32_t chunk = 0U;
uint32_t a = 0; uint32_t a = 0U;
uint32_t b = 0; uint32_t b = 0U;
uint32_t c = 0; uint32_t c = 0U;
uint32_t d = 0; uint32_t d = 0U;
uint32_t e = 0; uint32_t e = 0U;
uint32_t f = 0; uint32_t f = 0U;
uint32_t g = 0; uint32_t g = 0U;
uint32_t h = 0; uint32_t h = 0U;
while (i < 16) { while (i < 16U) {
w[i++] = this->chunkToUint32(chunk); w[i++] = this->chunkToUint32(chunk);
chunk += 4; chunk += 4U;
} }
this->mbi = 0; this->mbi = 0U;
for (i = 16; i < 64; i++) { for (i = 16U; i < 64U; i++) {
w[i] = sha_sigma1(w[i - 2]) + w[i - 7] + w[i] = sha_sigma1(w[i - 2U]) + w[i - 7U] +
sha_sigma0(w[i - 15]) + w[i - 16]; sha_sigma0(w[i - 15U]) + w[i - 16U];
} }
a = this->i_hash[0]; a = this->i_hash[0];
@ -219,9 +219,9 @@ SHA256::updateMessageBlock()
g = this->i_hash[6]; g = this->i_hash[6];
h = this->i_hash[7]; h = this->i_hash[7];
for (i = 0; i < 64; i++) { for (i = 0U; i < 64U; i++) {
uint32_t t1 = 0; uint32_t t1 = 0U;
uint32_t t2 = 0; uint32_t t2 = 0U;
t1 = h + sha_Sigma1(e) + sha_ch(e, f, g) + sha256K[i] + w[i]; t1 = h + sha_Sigma1(e) + sha_ch(e, f, g) + sha256K[i] + w[i];
t2 = sha_Sigma0(a) + sha_maj(a, b, c); t2 = sha_Sigma0(a) + sha_maj(a, b, c);
h = g; h = g;
@ -248,38 +248,44 @@ SHA256::updateMessageBlock()
EMSHAResult EMSHAResult
SHA256::Update(const std::uint8_t *message, std::uint32_t messageLength) SHA256::Update(const std::uint8_t *message, std::uint32_t messageLength)
{ {
EMSHAResult res;
// Checking invariants: // Checking invariants:
// If the message length is zero, there's nothing to be done. // If the message length is zero, there's nothing to be done.
if (0 == messageLength) { return EMSHAResult::OK; } if (messageLength == 0U) { res = EMSHAResult::OK; }
// The message passed in cannot be the null pointer if the // The message passed in cannot be the null pointer if the
// message length is greater than 0. // message length is greater than 0.
if (message == nullptr) { return EMSHAResult::NullPointer; } else if (message == nullptr) { res = EMSHAResult::NullPointer; }
// If the SHA256 object is in a bad state, don't proceed. // If the SHA256 object is in a bad state, don't proceed.
if (this->hStatus != EMSHAResult::OK) { return this->hStatus; } else if (this->hStatus != EMSHAResult::OK) { res = this->hStatus; }
// If the hash has been finalised, don't proceed. // If the hash has been finalised, don't proceed.
if (this->hComplete != static_cast<uint8_t>(0)) { return EMSHAResult::InvalidState; } else if (this->hComplete != 0U) { res = EMSHAResult::InvalidState; }
// Invariants satisfied by here. // Invariants satisfied by here.
else {
for (uint32_t i = 0U; i < messageLength; i++) {
this->mb[this->mbi] = *(message + i);
mbi++;
for (uint32_t i = 0; i < messageLength; i++) { if (EMSHAResult::OK == this->addLength(8U)) {
this->mb[this->mbi] = *(message + i); if (SHA256_MB_SIZE == this->mbi) {
mbi++; this->updateMessageBlock();
if (EMSHAResult::OK == this->addLength(8)) { // Assumption: following the message block
if (SHA256_MB_SIZE == this->mbi) { // write, the context should still be in a good
this->updateMessageBlock(); // state.
assert(EMSHAResult::OK == this->hStatus);
// Assumption: following the message block }
// write, the context should still be in a good
// state.
assert(EMSHAResult::OK == this->hStatus);
} }
} }
res = this->hStatus;
} }
return this->hStatus; return res;
} }
@ -289,18 +295,18 @@ SHA256::padMessage(uint8_t pc)
// Assumption: the context is not in a corrupted state. // Assumption: the context is not in a corrupted state.
assert(EMSHAResult::OK == this->hStatus); assert(EMSHAResult::OK == this->hStatus);
if (this->mbi < (SHA256_MB_SIZE - 8)) { if (this->mbi < (SHA256_MB_SIZE - 8U)) {
this->mb[this->mbi++] = pc; this->mb[this->mbi++] = pc;
} else { } else {
bool pc_add = false; bool pc_add = false;
if (this->mbi < SHA256_MB_SIZE - 1) { if (this->mbi < SHA256_MB_SIZE - 1U) {
this->mb[this->mbi++] = pc; this->mb[this->mbi++] = pc;
pc_add = true; pc_add = true;
} }
while (this->mbi < SHA256_MB_SIZE) { while (this->mbi < SHA256_MB_SIZE) {
this->mb[this->mbi++] = 0; this->mb[this->mbi++] = 0U;
} }
this->updateMessageBlock(); this->updateMessageBlock();
@ -313,28 +319,28 @@ SHA256::padMessage(uint8_t pc)
assert(EMSHAResult::OK == this->hStatus); assert(EMSHAResult::OK == this->hStatus);
} }
while (this->mbi < (SHA256_MB_SIZE - 8)) { while (this->mbi < (SHA256_MB_SIZE - 8U)) {
this->mb[this->mbi++] = 0; this->mb[this->mbi++] = 0U;
} }
// lstart marks the starting point for the length packing. // lstart marks the starting point for the length packing.
uint32_t const lstart = SHA256_MB_SIZE - 8; uint32_t const lstart = SHA256_MB_SIZE - 8U;
this->mb[lstart] = static_cast<uint8_t>(this->mlen >> 56); this->mb[lstart] = static_cast<uint8_t>(this->mlen >> 56);
this->mb[lstart + 1] = this->mb[lstart + 1U] =
static_cast<uint8_t>((this->mlen & 0x00ff000000000000L) >> 48); static_cast<uint8_t>((this->mlen & 0x00ff000000000000U) >> 48);
this->mb[lstart + 2] = this->mb[lstart + 2U] =
static_cast<uint8_t>((this->mlen & 0x0000ff0000000000L) >> 40); static_cast<uint8_t>((this->mlen & 0x0000ff0000000000U) >> 40);
this->mb[lstart + 3] = this->mb[lstart + 3U] =
static_cast<uint8_t>((this->mlen & 0x000000ff00000000L) >> 32); static_cast<uint8_t>((this->mlen & 0x000000ff00000000U) >> 32);
this->mb[lstart + 4] = this->mb[lstart + 4U] =
static_cast<uint8_t>((this->mlen & 0x00000000ff000000L) >> 24); static_cast<uint8_t>((this->mlen & 0x00000000ff000000U) >> 24);
this->mb[lstart + 5] = this->mb[lstart + 5U] =
static_cast<uint8_t>((this->mlen & 0x0000000000ff0000L) >> 16); static_cast<uint8_t>((this->mlen & 0x0000000000ff0000U) >> 16);
this->mb[lstart + 6] = this->mb[lstart + 6U] =
static_cast<uint8_t>((this->mlen & 0x000000000000ff00L) >> 8); static_cast<uint8_t>((this->mlen & 0x000000000000ff00U) >> 8);
this->mb[lstart + 7] = this->mb[lstart + 7U] =
static_cast<uint8_t>(this->mlen & 0x00000000000000ffL); static_cast<uint8_t>(this->mlen & 0x00000000000000ffUL);
this->updateMessageBlock(); this->updateMessageBlock();
@ -347,69 +353,78 @@ SHA256::padMessage(uint8_t pc)
EMSHAResult EMSHAResult
SHA256::Finalise(std::uint8_t *digest) SHA256::Finalise(std::uint8_t *digest)
{ {
EMSHAResult res;
// Check invariants. // Check invariants.
// The digest cannot be a null pointer; this library allocates // The digest cannot be a null pointer; this library allocates
// no memory of its own. // no memory of its own.
if (nullptr == digest) { return EMSHAResult::NullPointer; } if (digest == nullptr) { res = EMSHAResult::NullPointer; }
// If the SHA256 object is in a bad state, don't proceed. // If the SHA256 object is in a bad state, don't proceed.
if (EMSHAResult::OK != this->hStatus) { return this->hStatus; } else if (this->hStatus != EMSHAResult::OK) { res = this->hStatus; }
// If the hash has been finalised, don't proceed. // If the hash has been finalised, don't proceed.
if (0 != this->hComplete) { return EMSHAResult::InvalidState; } else if (this->hComplete != 0U) { res = EMSHAResult::InvalidState; }
// Invariants satisfied by here. // Invariants satisfied by here.
else {
this->padMessage(0x80U);
this->padMessage(0x80); // Assumption: padding the message block has not left the context in a
// corrupted state.
assert(EMSHAResult::OK == this->hStatus);
std::fill(this->mb.begin(), this->mb.end(), 0);
// Assumption: padding the message block has not left the context in a this->hComplete = 1U;
// corrupted state. this->mlen = 0U;
assert(EMSHAResult::OK == this->hStatus);
std::fill(this->mb.begin(), this->mb.end(), 0);
this->hComplete = 1; uint32ToChunkInPlace(this->i_hash[0], digest);
this->mlen = 0; uint32ToChunkInPlace(this->i_hash[1], digest + 4);
uint32ToChunkInPlace(this->i_hash[2], digest + 8);
uint32ToChunkInPlace(this->i_hash[3], digest + 12);
uint32ToChunkInPlace(this->i_hash[4], digest + 16);
uint32ToChunkInPlace(this->i_hash[5], digest + 20);
uint32ToChunkInPlace(this->i_hash[6], digest + 24);
uint32ToChunkInPlace(this->i_hash[7], digest + 28);
uint32ToChunkInPlace(this->i_hash[0], digest); res = EMSHAResult::OK;
uint32ToChunkInPlace(this->i_hash[1], digest + 4); }
uint32ToChunkInPlace(this->i_hash[2], digest + 8);
uint32ToChunkInPlace(this->i_hash[3], digest + 12);
uint32ToChunkInPlace(this->i_hash[4], digest + 16);
uint32ToChunkInPlace(this->i_hash[5], digest + 20);
uint32ToChunkInPlace(this->i_hash[6], digest + 24);
uint32ToChunkInPlace(this->i_hash[7], digest + 28);
return EMSHAResult::OK; return res;
} }
EMSHAResult EMSHAResult
SHA256::Result(std::uint8_t *digest) SHA256::Result(std::uint8_t *digest)
{ {
EMSHAResult res;
// Check invariants. // Check invariants.
// The digest cannot be a null pointer; this library allocates // The digest cannot be a null pointer; this library allocates
// no memory of its own. // no memory of its own.
if (nullptr == digest) { return EMSHAResult::NullPointer; } if (nullptr == digest) { res = EMSHAResult::NullPointer; }
// If the SHA256 object is in a bad state, don't proceed. // If the SHA256 object is in a bad state, don't proceed.
if (EMSHAResult::OK != this->hStatus) { return this->hStatus; } else if (EMSHAResult::OK != this->hStatus) { res = this->hStatus; }
// Invariants satisfied by here. // Invariants satisfied by here.
else if (this->hComplete == 0U) {
if (this->hComplete == 0U) { res = this->Finalise(digest);
return this->Finalise(digest);
} }
uint32ToChunkInPlace(this->i_hash[0], digest); else {
uint32ToChunkInPlace(this->i_hash[1], digest + 4); uint32ToChunkInPlace(this->i_hash[0], digest);
uint32ToChunkInPlace(this->i_hash[2], digest + 8); uint32ToChunkInPlace(this->i_hash[1], digest + 4);
uint32ToChunkInPlace(this->i_hash[3], digest + 12); uint32ToChunkInPlace(this->i_hash[2], digest + 8);
uint32ToChunkInPlace(this->i_hash[4], digest + 16); uint32ToChunkInPlace(this->i_hash[3], digest + 12);
uint32ToChunkInPlace(this->i_hash[5], digest + 20); uint32ToChunkInPlace(this->i_hash[4], digest + 16);
uint32ToChunkInPlace(this->i_hash[6], digest + 24); uint32ToChunkInPlace(this->i_hash[5], digest + 20);
uint32ToChunkInPlace(this->i_hash[7], digest + 28); uint32ToChunkInPlace(this->i_hash[6], digest + 24);
uint32ToChunkInPlace(this->i_hash[7], digest + 28);
res = EMSHAResult::OK;
}
return EMSHAResult::OK; return res;
} }