88 changed files with 3528 additions and 2516 deletions
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@ -1,19 +0,0 @@
 version: 2.1
 jobs:
  ctest:
    docker:
      - image: git.wntrmute.dev/sc/dev:main
    steps:
      - checkout
      - run:
          name: Setup cmake build
          command: cmake-build-and-test.sh
      - run:
          name: Valgrind checks.
          command: cmake-run-valgrind.sh
 workflows:
  ctest:
    jobs:
      - ctest
--- a/.clang-format
+++ b/.clang-format
@ -1,67 +0,0 @@
 # Generated from CLion C/C++ Code Style settings
 BasedOnStyle: LLVM
 AccessModifierOffset: -8
 AlignAfterOpenBracket: Align
 AlignConsecutiveAssignments: Consecutive
 AlignOperands: Align
 AllowAllArgumentsOnNextLine: false
 AllowAllConstructorInitializersOnNextLine: false
 AllowAllParametersOfDeclarationOnNextLine: false
 AllowShortBlocksOnASingleLine: Always
 AllowShortCaseLabelsOnASingleLine: false
 AllowShortFunctionsOnASingleLine: All
 AllowShortIfStatementsOnASingleLine: Always
 AllowShortLambdasOnASingleLine: All
 AllowShortLoopsOnASingleLine: true
 AlwaysBreakAfterReturnType: TopLevel
 AlwaysBreakTemplateDeclarations: Yes
 BreakBeforeBraces: Custom
 BraceWrapping:
  AfterCaseLabel: false
  AfterClass: false
  AfterControlStatement: Never
  AfterEnum: false
  AfterFunction: true
  AfterNamespace: false
  AfterUnion: false
  BeforeCatch: false
  BeforeElse: false
  IndentBraces: false
  SplitEmptyFunction: false
  SplitEmptyRecord: true
 BreakBeforeBinaryOperators: None
 BreakBeforeTernaryOperators: true
 BreakConstructorInitializers: BeforeColon
 BreakInheritanceList: BeforeColon
 ColumnLimit: 0
 CompactNamespaces: false
 ContinuationIndentWidth: 4
 IndentCaseLabels: false
 IndentPPDirectives: None
 IndentWidth: 8
 KeepEmptyLinesAtTheStartOfBlocks: true
 MaxEmptyLinesToKeep: 2
 NamespaceIndentation: None
 ObjCSpaceAfterProperty: false
 ObjCSpaceBeforeProtocolList: true
 QualifierAlignment: Left
 PointerAlignment: Right
 ReflowComments: false
 SpaceAfterCStyleCast: true
 SpaceAfterLogicalNot: false
 SpaceAfterTemplateKeyword: false
 SpaceBeforeAssignmentOperators: true
 SpaceBeforeCpp11BracedList: false
 SpaceBeforeCtorInitializerColon: true
 SpaceBeforeInheritanceColon: true
 SpaceBeforeParens: ControlStatements
 SpaceBeforeRangeBasedForLoopColon: false
 SpaceInEmptyParentheses: false
 SpacesBeforeTrailingComments: 0
 SpacesInAngles: false
 SpacesInCStyleCastParentheses: false
 SpacesInContainerLiterals: false
 SpacesInParentheses: false
 SpacesInSquareBrackets: false
 TabWidth: 8
 UseTab: ForContinuationAndIndentation
--- a/.clang-tidy
+++ b/.clang-tidy
@ -1,36 +0,0 @@
 HeaderFilterRegex: \./.+
 Checks: >-
  bugprone-*,
  cppcoreguidelines-*,
  misc-*,
  modernize-*,
  performance-*,
  readability-*,
  -bugprone-lambda-function-name,
  -bugprone-reserved-identifier,
  -cppcoreguidelines-avoid-goto,
  -cppcoreguidelines-avoid-magic-numbers,
  -cppcoreguidelines-avoid-non-const-global-variables,
  -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
  -cppcoreguidelines-pro-type-vararg,
  -google-readability-braces-around-statements,
  -google-readability-function-size,
  -google-readability-namespace-comments,
  -misc-no-recursion,
  -modernize-return-braced-init-list,
  -modernize-use-nodiscard,
  -modernize-use-trailing-return-type,
  -performance-unnecessary-value-param,
  -readability-identifier-length,
  -readability-magic-numbers
 CheckOptions:
  - key: readability-function-cognitive-complexity.Threshold
    value: 100
  - key: readability-function-cognitive-complexity.IgnoreMacros
    value: true
  # Set naming conventions for your style below (there are dozens of naming settings possible):
  # See https://clang.llvm.org/extra/clang-tidy/checks/readability/identifier-naming.html
  - key: readability-identifier-naming.ClassCase
    value: CamelCase
--- a/.gitignore
+++ b/.gitignore
@ -1,8 +0,0 @@
 build
 cmake-build-*
 compile_commands.json
 TAGS
 tags
 core*
--- a/.idea/.gitignore
+++ b/.idea/.gitignore
@ -1,8 +0,0 @@
 # Default ignored files
 /shelf/
 /workspace.xml
 # Editor-based HTTP Client requests
 /httpRequests/
 # Datasource local storage ignored files
 /dataSources/
 /dataSources.local.xml
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@ -1,7 +0,0 @@
 <component name="ProjectCodeStyleConfiguration">
  <code_scheme name="Project" version="173">
    <clangFormatSettings>
      <option name="ENABLED" value="true" />
    </clangFormatSettings>
  </code_scheme>
 </component>
--- a/.idea/codeStyles/codeStyleConfig.xml
+++ b/.idea/codeStyles/codeStyleConfig.xml
@ -1,5 +0,0 @@
 <component name="ProjectCodeStyleConfiguration">
  <state>
    <option name="USE_PER_PROJECT_SETTINGS" value="true" />
  </state>
 </component>
--- a/.idea/emsha.iml
+++ b/.idea/emsha.iml
@ -1,2 +0,0 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <module classpath="CMake" type="CPP_MODULE" version="4" />
--- a/.idea/inspectionProfiles/Project_Default.xml
+++ b/.idea/inspectionProfiles/Project_Default.xml
@ -1,9 +0,0 @@
 <component name="InspectionProjectProfileManager">
  <profile version="1.0">
    <option name="myName" value="Project Default" />
    <inspection_tool class="ClangTidy" enabled="false" level="WARNING" enabled_by_default="false" />
    <inspection_tool class="Misra" enabled="true" level="WARNING" enabled_by_default="false">
      <scope name="ProjectSources" level="WARNING" enabled="true" />
    </inspection_tool>
  </profile>
 </component>
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@ -1,4 +0,0 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
  <component name="CMakeWorkspace" PROJECT_DIR="$PROJECT_DIR$" />
 </project>
--- a/.idea/modules.xml
+++ b/.idea/modules.xml
@ -1,8 +0,0 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
  <component name="ProjectModuleManager">
    <modules>
      <module fileurl="file://$PROJECT_DIR$/.idea/emsha.iml" filepath="$PROJECT_DIR$/.idea/emsha.iml" />
    </modules>
  </component>
 </project>
--- a/.idea/scopes/ProjectSources.xml
+++ b/.idea/scopes/ProjectSources.xml
@ -1,3 +0,0 @@
 <component name="DependencyValidationManager">
  <scope name="ProjectSources" pattern="file[emsha]:include/emsha/*||file:hmac.cc||file:emsha.cc||file:sha256.cc" />
 </component>
--- a/.idea/vcs.xml
+++ b/.idea/vcs.xml
@ -1,6 +0,0 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
  <component name="VcsDirectoryMappings">
    <mapping directory="" vcs="Git" />
  </component>
 </project>
--- a/.travis.yml
+++ b/.travis.yml
@ -0,0 +1,17 @@
 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
 install:
 - if [ "$CXX" = "g++" ]; then export CXX="g++-4.8" CC="gcc-4.8"; fi
 script: "./autobuild && ./do-release"
--- a/.trunk/.gitignore
+++ b/.trunk/.gitignore
@ -1,8 +0,0 @@
 *out
 *logs
 *actions
 *notifications
 *tools
 plugins
 user_trunk.yaml
 user.yaml
--- a/.trunk/configs/.clang-tidy
+++ b/.trunk/configs/.clang-tidy
@ -1,39 +0,0 @@
 Checks: >-
  bugprone-*,
  cppcoreguidelines-*,
  google-*,
  misc-*,
  modernize-*,
  performance-*,
  readability-*,
  -bugprone-lambda-function-name,
  -bugprone-reserved-identifier,
  -cppcoreguidelines-avoid-goto,
  -cppcoreguidelines-avoid-magic-numbers,
  -cppcoreguidelines-avoid-non-const-global-variables,
  -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
  -cppcoreguidelines-pro-type-vararg,
  -google-readability-braces-around-statements,
  -google-readability-function-size,
  -misc-no-recursion,
  -modernize-return-braced-init-list,
  -modernize-use-nodiscard,
  -modernize-use-trailing-return-type,
  -performance-unnecessary-value-param,
  -readability-magic-numbers,
 CheckOptions:
  - key: readability-function-cognitive-complexity.Threshold
    value: 100
  - key: readability-function-cognitive-complexity.IgnoreMacros
    value: true
  # Set naming conventions for your style below (there are dozens of naming settings possible):
  # See https://clang.llvm.org/extra/clang-tidy/checks/readability/identifier-naming.html
  # - key: readability-identifier-naming.ClassCase
  #   value: CamelCase
  # - key: readability-identifier-naming.NamespaceCase
  #   value: lower_case
  # - key: readability-identifier-naming.PrivateMemberSuffix
  #   value: _
  # - key: readability-identifier-naming.StructCase
  #   value: CamelCase
--- a/.trunk/configs/.isort.cfg
+++ b/.trunk/configs/.isort.cfg
@ -1,2 +0,0 @@
 [settings]
 profile=black
--- a/.trunk/configs/.markdownlint.yaml
+++ b/.trunk/configs/.markdownlint.yaml
@ -1,10 +0,0 @@
 # Autoformatter friendly markdownlint config (all formatting rules disabled)
 default: true
 blank_lines: false
 bullet: false
 html: false
 indentation: false
 line_length: false
 spaces: false
 url: false
 whitespace: false
--- a/.trunk/configs/.shellcheckrc
+++ b/.trunk/configs/.shellcheckrc
@ -1,7 +0,0 @@
 enable=all
 source-path=SCRIPTDIR
 disable=SC2154
 # If you're having issues with shellcheck following source, disable the errors via:
 # disable=SC1090
 # disable=SC1091
--- a/.trunk/configs/.yamllint.yaml
+++ b/.trunk/configs/.yamllint.yaml
@ -1,10 +0,0 @@
 rules:
  quoted-strings:
    required: only-when-needed
    extra-allowed: ["{|}"]
  empty-values:
    forbid-in-block-mappings: true
    forbid-in-flow-mappings: true
  key-duplicates: {}
  octal-values:
    forbid-implicit-octal: true
--- a/.trunk/configs/ruff.toml
+++ b/.trunk/configs/ruff.toml
@ -1,5 +0,0 @@
 # Generic, formatter-friendly config.
 select = ["B", "D3", "E", "F"]
 # Never enforce `E501` (line length violations). This should be handled by formatters.
 ignore = ["E501"]
--- a/.trunk/trunk.yaml
+++ b/.trunk/trunk.yaml
@ -1,39 +0,0 @@
 # This file controls the behavior of Trunk: https://docs.trunk.io/cli
 # To learn more about the format of this file, see https://docs.trunk.io/reference/trunk-yaml
 version: 0.1
 cli:
  version: 1.17.0
 plugins:
  sources:
    - id: trunk
      ref: v1.2.6
      uri: https://github.com/trunk-io/plugins
 runtimes:
  enabled:
    - go@1.21.0
    - node@18.12.1
    - python@3.10.8
 lint:
  enabled:
    - clang-tidy@16.0.3
    - bandit@1.7.5
    - black@23.9.1
    - checkov@2.5.9
    - git-diff-check
    - isort@5.12.0
    - markdownlint@0.37.0
    - osv-scanner@1.4.1
    - prettier@3.0.3
    - ruff@0.0.292
    - shellcheck@0.9.0
    - shfmt@3.6.0
    - trivy@0.46.0
    - trufflehog@3.60.0
    - yamllint@1.32.0
 actions:
  disabled:
    - trunk-announce
    - trunk-check-pre-push
    - trunk-fmt-pre-commit
  enabled:
    - trunk-upgrade-available
--- a/12
+++ b/12
@ -1,18 +1,6 @@
 LIBEMSHA CHANGELOG
 ==================
 1.0.3 (2023-10-17):
 Changed:
 	+ Switched from autotools to cmake.
 1.0.2 (2015-01-28):
 Added:
 	+ Build now includes pkg-config.
 	+ Debian packaging source files added.
 ------------------
 1.0.1 (2015-12-22):
 Fixed:
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -1,85 +0,0 @@
 cmake_minimum_required(VERSION 3.22)
 project(emsha
 	VERSION 1.1.1
 	LANGUAGES CXX 
 	DESCRIPTION "A compact HMAC-SHA-256 C++11 library.")
 set(CMAKE_CXX_STANDARD 11)
 set(CMAKE_VERBOSE_MAKEFILES ON)
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 set(SET_EMSHA_NO_HEXSTRING OFF CACHE BOOL
 	"Don't include support for hex strings.")
 if (SET_EMSHA_NO_HEXSTRING)
 	add_definitions(EMSHA_NO_HEXSTRING)
 endif ()
 set(SET_EMSHA_NO_HEXLUT OFF CACHE BOOL
 	"Don't use a LUT for hex strings (saves ~256B of memory).")
 if (SET_EMSHA_NO_HEXLUT)
 	add_definitions("-DEMSHA_NO_HEXLUT")
 endif ()
 set(SET_EMSHA_NO_SELFTEST OFF CACHE BOOL
 	"Disable the internal self-tests.")
 if (SET_EMSHA_NO_SELFTEST)
 	add_definitions("-DEMSHA_NO_SELFTEST")
 endif ()
 include(CTest)
 enable_testing()
 # compile options:                    
 #   -Wall                   Default to all errors.
 #   -Wextra                 And a few extra.
 #   -Werror                 And require them to be fixed to build.
 #   -Wno-unused-function    This is a library. Not every function is used here.
 #   -Wno-unused-parameter   Some functions have parameters defined for compatibility,
 #                           and aren't used in the implementation.
 add_compile_options(                   
        "-static"               
        "-Wall"
        "-Wextra"                  
        "-Werror"                   
        "-Wno-unused-function"
        "-Wno-unused-parameter"
        "-g"                                     
        "$<$<CONFIG:RELEASE>:-O2>"         
 )                                       
 if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
    add_compile_options("-stdlib=libc++")
 else ()                              
    # nothing special for gcc at the moment
 endif ()
 ### Set up the build ###
 set(HEADERS
        include/emsha/emsha.h
        include/emsha/sha256.h
        include/emsha/hmac.h
        include/emsha/internal.h)
 set(SOURCES src/emsha.cc src/sha256.cc src/hmac.cc)
 include_directories(include)
 ### Build products ###
 add_library(${PROJECT_NAME} STATIC ${SOURCES} ${HEADERS})
 ### TESTS ###
 set(TEST_SOURCES test/test_utils.cc)
 macro(generate_test name)
 	add_executable(${name} test/${name}.cc ${TEST_SOURCES} ${ARGN})
 	target_link_libraries(${name} ${PROJECT_NAME})
 	target_include_directories(${name} PRIVATE test)
 	add_test(${name} ${name})
 endmacro()
 generate_test(test_${PROJECT_NAME})
 generate_test(test_hmac)
 generate_test(test_mem)
 generate_test(test_sha256)
 include(cmake/docs.cmake)
 include(cmake/install.cmake)
 include(cmake/packaging.cmake)
--- a/Makefile.am
+++ b/Makefile.am
@ -0,0 +1,28 @@
 ACLOCAL_AMFLAGS =	-I m4
 SUBDIRS =		src
 TESTS = src/emsha_core_test		\
 	src/emsha_sha256_test		\
 	src/emsha_hmac_test
 dist_data_DATA =   LICENSE		\
 		   README.rst		\
 		   doc/libemsha.rst
 dist_noinst_DATA = autobuild		\
 		   doc/source		\
 		   doc/Makefile
 .PHONY: valgrind-check
 valgrind-check:
 	cd src && make $@
 .PHONY: cloc-report
 cloc-report:
 	cd src && make $@
 .PHONY: coverity-scan
 coverity-scan:
 	cd src && make $@
 epub:
 	cd doc && make $@
--- a/README.md
+++ b/README.md
@ -1,71 +0,0 @@
 # emsha: EMbedded Secure HAshing 
 [![CircleCI](https://dl.circleci.com/status-badge/img/gh/shimmering-clarity/emsha/tree/master.svg?style=svg)](https://dl.circleci.com/status-badge/redirect/gh/shimmering-clarity/emsha/tree/master)
 [![image](https://scan.coverity.com/projects/29250/badge.svg)](https://scan.coverity.com/projects/shimmering-clarity-emsha)
 This library is an MIT-licensed HMAC-SHA-256 C++11 library designed for
 embedded systems. It is built following the JPL [Power of  Ten](http://spinroot.com/gerard/pdf/P10.pdf)
 rules. It was written in response to a need for a standalone HMAC-SHA-256
 package that could run on several platforms, including several memory-
 constrained embedded platforms.
 ### Getting and Building the Source
 The source code is available via
 [Git](https://git.wntrmute.dev/sc/emsha/); each version should be git
 tagged. There is also a [mirror on Github](https://github.com/shimmering-clarity/emsha).
 ```
 git clone https://git.wntrmute.dev/sc/emsha
 ```
 The current release is
 [1.1.1](https://git.wntrmute.dev/sc/emsha/releases/tag/v1.1.0).
 The project is built using CMake. Packages are built using the `RelWithDebInfo`
 configuration; artifacts are built using the [sc3dev](https://git.wntrmute.dev/sc/sc3dev/)
 [build script](https://git.wntrmute.dev/sc/sc3dev/src/branch/master/cmake-build-and-test.sh).
 There are two cache variables that might be useful:
 - `SET EMSHA_NO_HEXSTRING` disables the provided `hexstring` function;
  while this might be useful in many cases, it also adds extra size to
  the code. For memory-constrained microcontrollers, this might be 
  desirable.
 - `SET_EMSHA_NO_HEXLUT` disables the larger lookup table used by
  `hexstring`, which can save around a kilobyte of program space. If
  the `hexstring` function is disabled, this option has no effect.
 - `SET_EMSHA_NO_SELFTEST` disables the internal self-tests, which can
  reclaim some additional program space.
 ### Synopsis
 The Hash pure virtual class defines a basic interface for programs:
 - Hash::Reset will clear an instance of a Hash class.
 - Hash::Update writes data into the Hash.
 - Hash::Finalize will finish the Hash function and write the results
  out.
 There are two implementations provided for Hash: SHA256 and HMAC.
 ### Documentation
 Documentation is currently done with Doxygen; documentation is
 available [online](https://docs.shimmering-clarity.net/emsha/).
 ### See also
 -   [FIPS 180-4, the Secure Hash Standard](http://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf)
 -   [FIPS 198-1, The Keyed-Hash Message Authentication Code (HMAC)](http://csrc.nist.gov/publications/fips/fips198-1/FIPS-198-1_final.pdf)
 -   [RFC 2014, HMAC: Keyed-Hashing for Message Authentication](https://tools.ietf.org/html/rfc2104)
 -   [RFC 6234, US Secure Hash Algorithms (SHA and SHA-based HMAC and HKDF)](https://tools.ietf.org/html/rfc6234)
 -   The behaviour of this package was cross-checked using the Go 1.5.1
    linux/amd64 standard library's [crypto/sha256](https://golang.org/src/crypto/sha256/) package.
 ### Acknowledgements
 This library came about after extracting the relevant C code from  RFC 
 6234, and needing a C++ version. It draws heavy inspiration from that
 code. I also pulled a lot of test vectors from Go's crypto/sha256.
--- a/README.rst
+++ b/README.rst
@ -0,0 +1,78 @@
 libemsha
 ========
 .. image:: https://travis-ci.org/kisom/libemsha.svg?branch=master
    :target: https://travis-ci.org/kisom/libemsha
 .. image:: https://scan.coverity.com/projects/7318/badge.svg
    :target: https://scan.coverity.com/projects/libemsha-52f2a5fd-e759-43c2-9073-cf6c2ed9abdb
 This library is an MIT-licensed HMAC-SHA-256 C++11 library designed
 for embedded systems. It is built following the JPL `Power of Ten
 <http://spinroot.com/gerard/pdf/P10.pdf>`_ rules. It was written in
 response to a need for a standalone HMAC-SHA-256 package that could run
 on several platforms.
 -------------------------------
 Getting and Building the Source
 -------------------------------
 The source code is available via `Github
 <https://github.com/kisom/libemsha/>`_; each version should be git tagged. ::
    git clone https://github.com/kisom/libemsha
    git clone git@github.com:kisom/libemsha
 The current release is `1.0.1 <https://github.com/kisom/libemsha/releases/tag/v1.0.1>`_.
 The project is built using Autotools and ``make``.
 When building from a git checkout, the `autobuild` script will bootstrap
 the project from the autotools sources (e.g. via ``autoreconf -i``),
 run ``configure`` (by default to use clang), and attempt to build the library
 and run the unit tests.
 Once the autotools infrastructure has been bootstrapped, the following
 should work: ::
    ./configure && make && make check && make install
 There are three flags to ``configure`` that might be useful:
 + ``--disable-hexstring`` disables the provided ``hexstring`` function;
  while this might be useful in many cases, it also adds extra size to
  the code.
 + ``--disable-hexlut`` disables the larger lookup table used by
  ``hexstring``, which can save around a kilobyte of program space. If
  the ``hexstring`` function is disabled, this option has no effect.
 + ``--disable-selftest`` disables the internal self-tests, which can
  reclaim some additional program space.
 -------------
 Documentation
 -------------
 Documentation is currently done with `Sphinx <http://sphinx-doc.org/>`_.
 See ``doc/``.
 See also
 --------
 * `FIPS 180-4, the Secure Hash Standard <http://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf>`_
 * `FIPS 198-1, The Keyed-Hash Message Authentication Code (HMAC) <http://csrc.nist.gov/publications/fips/fips198-1/FIPS-198-1_final.pdf>`_
 * `RFC 2014, HMAC: Keyed-Hashing for Message Authentication <https://tools.ietf.org/html/rfc2104>`_
 * `RFC 6234, US Secure Hash Algorithms (SHA and SHA-based HMAC and HKDF) <https://tools.ietf.org/html/rfc6234>`_\ [#f1]_
 * The behaviour of this package was cross-checked using the Go 1.5.1
  linux/amd64 standard library's `crypto/sha256 <https://golang.org/src/crypto/sha256/>`_
  package.
 .. rubric:: Footnotes
 .. [#f1] This library came about after extracting the relevant C code
         from RFC 6234, and needing a C++ version. It draws heavy
         inspiration from that code base.
--- a/TODO.rst
+++ b/TODO.rst
@ -2,12 +2,12 @@
 TODO
 ====
-[*] Documentation for ``HMAC``
+[ ] Documentation for ``HMAC``
-[*] Documentation for miscellaneous functions
+[ ] Documentation for miscellaneous functions
-[*] Travis with static analysers
+[ ] Travis with static analysers
-    [*] Coverity?
+    [ ] Coverity?
-    [*] cppcheck
+    [ ] cppcheck
--- a/7
+++ b/7
@ -0,0 +1,7 @@
 #!/bin/sh
 CXX=g++
 command -v clang 2>&1 > /dev/null && CXX=clang++
 [ -d m4 ] || mkdir m4
 autoreconf -i && ./configure --enable-silent-rules CXX=$CXX 	\
 	&& make && make check
--- a/37
+++ b/37
@ -0,0 +1,37 @@
 #!/bin/sh
 echo '  ____    _    _   _  ____ _____ ____  '
 echo ' |  _ \  / \  | \ | |/ ___| ____|  _ \ '
 echo ' | | | |/ _ \ |  \| | |  _|  _| | |_) |'
 echo ' | |_| / ___ \| |\  | |_| | |___|  _ < '
 echo ' |____/_/   \_\_| \_|\____|_____|_| \_\'
 echo ''
 echo "[!] This script will destroy anything not tracked by git."
 echo "[!] Waiting 5 seconds before running. Press ^C to abort."
 echo -n "5"
 sleep 1
 echo -n " 4"
 sleep 1
 echo -n " 3"
 sleep 1
 echo -n " 2"
 sleep 1
 echo -n " 1"
 sleep 1
 echo " nuking from orbit!" 
 sleep 1
 echo ""
 git clean -fxd
 echo ""
 echo "-------------------------------------------------------------"
 echo "If you wish to make an apple pie from scratch, you must first"
 echo "create the universe."
 echo "				-- Carl Fucking Sagan"
 echo "-------------------------------------------------------------"
 echo ""
 ./autobuild
--- a/cmake/docs.cmake
+++ b/cmake/docs.cmake
@ -1,29 +0,0 @@
 # Doxygen support for scsl.
 find_package(Doxygen)
 if (${DOXYGEN_FOUND})
 	# prefer scdocs for manpages.
 	set(DOXYGEN_GENERATE_MAN YES)
 	set(DOXYGEN_GENERATE_LATEX YES)
 	set(DOXYGEN_EXTRACT_ALL YES)
 	set(DOXYGEN_USE_MDFILE_AS_MAINPAGE "${CMAKE_CURRENT_SOURCE_DIR}/README.md")
 	set(DOXYGEN_EXCLUDE_PATTERNS "test_*" "*.cc" )
 	message(STATUS "Doxygen found, building docs.")
 	doxygen_add_docs(${PROJECT_NAME}_docs
 		${HEADER_FILES}
 		ALL
 		USE_STAMP_FILE)
 	add_custom_target(deploy-docs
 			COMMAND rsync --delete-after --progress -auvz ${CMAKE_CURRENT_BINARY_DIR}/html/* docs.shimmering-clarity.net:sites/cc/${PROJECT_NAME}/
 			DEPENDS emsha_docs
 	)
 	install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html
 		${CMAKE_CURRENT_BINARY_DIR}/latex
 		DESTINATION share/doc/${PROJECT_NAME}/doxygen)
 	install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/man
 		DESTINATION share)
 endif ()
--- a/cmake/emshaConfig.cmake
+++ b/cmake/emshaConfig.cmake
@ -1,3 +0,0 @@
 set(EMSHA_INCLUDE_DIRS include/@PROJECT_NAME@)
 set(EMSHA_LIBRARIES libemsha-@PROJECT_VERSION_MAJOR@.a)
--- a/cmake/install.cmake
+++ b/cmake/install.cmake
@ -1,27 +0,0 @@
 ### Install ###
 include(CMakePackageConfigHelpers)
 ### library packaging for CMake and pkgconfig to find built targets.
 write_basic_package_version_file(
 	${PROJECT_NAME}Config.cmake
 	VERSION ${PACKAGE_VERSION}
 	COMPATIBILITY SameMajorVersion
 )
 write_basic_package_version_file(
 	${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
 	VERSION ${PROJECT_VERSION}
 	COMPATIBILITY SameMajorVersion)
 configure_file(${PROJECT_NAME}.pc.in ${PROJECT_NAME}.pc @ONLY)
 ### set up installation targets.
 install(TARGETS ${PROJECT_NAME} LIBRARY DESTINATION lib)
 install(FILES ${HEADERS} DESTINATION include/${PROJECT_NAME})
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc
 	DESTINATION lib/pkgconfig)
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake
 	      ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
 	DESTINATION share/${PROJECT_CMAKE_CONFIG_NAME}/cmake)
--- a/cmake/packaging.cmake
+++ b/cmake/packaging.cmake
@ -1,41 +0,0 @@
 ### Packaging ###
 include(InstallRequiredSystemLibraries)
 set(CPACK_PACKAGE_VENDOR "K. Isom")
 set(CPACK_PACKAGE_DESCRIPTION_SUMMARY ${PROJECT_DESCRIPTION})
 set(CPACK_PACKAGE_VERSION_MAJOR ${PROJECT_VERSION_MAJOR})
 set(CPACK_PACKAGE_VERSION_MINOR ${PROJECT_VERSION_MINOR})
 set(CPACK_PACKAGE_VERSION_PATCH ${PROJECT_VERSION_PATCH})
 set(CPACK_PACKAGE_FILE_NAME
 	${PROJECT_NAME}-${PROJECT_VERSION}-${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_ARCH}${CMAKE_HOST_SYSTEM_PROCESSOR})
 # Debian settings
 set(CPACK_DEBIAN_PACKAGE_MAINTAINER ${CPACK_PACKAGE_VENDOR})
 set(CPACK_PACKAGE_DESCRIPTION_SUMMARY ${CPACK_PACKAGE_DESCRIPTION})
 set(CPACK_PACKAGE_DESCRIPTION ${CPACK_PACKAGE_DESCRIPTION})
 set(CPACK_PACKAGE_DEPENDS)
 set(CPACK_DEBIAN_PACKAGE_SECTION devel)
 set(CPACK_DEBIAN_PACKAGE_GENERATE_SHLIBS ON)
 set(CPACK_DEBIAN_FILE_NAME DEB-DEFAULT)
 if (LINUX)
 	set(CPACK_GENERATOR "DEB;STGZ;TGZ")
 elseif (APPLE)
 	set(CPACK_GENERATOR "STGZ;TGZ")
 elseif (MSVC OR MSYS OR MINGW)
 	set(CPACK_GENERATOR "NSIS;ZIP")
 else ()
 	set(CPACK_GENERATOR "ZIP")
 endif ()
 set(CPACK_SOURCE_GENERATOR "TGZ;ZIP")
 set(CPACK_SOURCE_IGNORE_FILES
 	/.git
 	/dist
 	/.*build.*)
 include (CPack)
 add_custom_target(package_docs DEPENDS emsha_docs package package_source)
--- a/configure.ac
+++ b/configure.ac
@ -0,0 +1,61 @@
 # autoconf version 2.68 and automake version 1.11 seem to be the latest
 # versions that can be used with Travis right now.
 AC_PREREQ([2.68])
 AC_INIT([libemsha],
 	[1.0.1],
 	[coder@kyleisom.net],
 	[libemsha],
 	[https://kyleisom.net/projects/libemsha/])
 AM_INIT_AUTOMAKE([1.11 foreign])
 AC_CONFIG_SRCDIR([src/emsha/sha256.hh])
 AC_CONFIG_FILES([Makefile src/Makefile doc/source/conf.py doc/source/header.rst])
 AC_CONFIG_FILES([do-release], [chmod +x do-release])
 AC_CONFIG_MACRO_DIR([m4])
 AC_CHECK_HEADERS
 LT_INIT
 AC_PROG_CXX
 AC_PROG_INSTALL
 AC_PROG_CC_C_O
 AC_CHECK_PROGS([SPHINX], [sphinx-build])
 if test -z "$SPHINX";
 then
       	AC_MSG_WARN([Sphinx not found - continuing without Sphinx support])
 fi
 AC_ARG_ENABLE([hexstring],
    AS_HELP_STRING([--disable-hexstring], [Don't build with support for hex string output (default enabled)]),
    [:], [enable_hexstring=check])
 AC_ARG_ENABLE([hexlut],
    AS_HELP_STRING([--disable-hexlut], [Don't build with the larger LUT for building hex strings (saves ~1KB of memory). This has no effect if hex strings are disabled.]),
    [:], [enable_hexlut=check])
 AC_ARG_ENABLE([selftest],
    AS_HELP_STRING([--disable-selftest], [Don't build with support for internal self-tests (saves some memory that is used by the test vectors.)]),
    [:], [enable_selftest=check])
 # The default for the ARG_ENABLE options is to have them enabled.
 AS_IF([test "x$enable_hexstring" == "xno"], [
 	AC_MSG_NOTICE([disabling hexstrings.])
 	AC_DEFINE(EMSHA_NO_HEXSTRING)
 ])
 AS_IF([test "x$enable_hexlut" == "xno"], [
 	AC_MSG_NOTICE([disabling the large hexstring LUT.])
 	AC_DEFINE(EMSHA_NO_HEXLUT)      
 ])
 AS_IF([test "x$enable_selftest" == "xno"], [
       AC_MSG_NOTICE([disabling the internal self tests.])
 	AC_DEFINE(EMSHA_NO_SELFTEST)
 ])
 AM_CONDITIONAL([HAVE_SPHINX], 
 	       [test -n "$SPHINX"])
 AC_OUTPUT
--- a/debian/changelog
+++ b/debian/changelog
@ -1,29 +0,0 @@
 libemsha (1.0.2-4) stable; urgency=medium
  * More Debian packaging cleanups.
 -- Kyle Isom <kyle@imap.cc>  Fri, 29 Jan 2016 16:29:33 -0800
 libemsha (1.0.2-3) main; urgency=medium
  * Clean up debian packaging files.
 -- Kyle Isom <kyle@imap.cc>  Fri, 29 Jan 2016 00:56:54 -0800
 libemsha (1.0.2-2) stable; urgency=medium
  * Package bump to fix dependency issues.
 -- Kyle Isom <kyle@imap.cc>  Thu, 28 Jan 2016 00:49:45 -0800
 libemsha (1.0.2-1) stable; urgency=medium
  * Add pkg-config to build.
 -- Kyle Isom <kyle@imap.cc>  Thu, 28 Jan 2016 00:27:31 -0800
 libemsha (1.0.1-1) unstable; urgency=low
  * Initial release for packaging.
 -- Kyle Isom <kyle@imap.cc>  Wed, 27 Jan 2016 21:19:12 -0800
--- a/debian/compat
+++ b/debian/compat
@ -1 +0,0 @@
 9
--- a/debian/control
+++ b/debian/control
@ -1,29 +0,0 @@
 Source: libemsha
 Priority: optional
 Section: libs
 Maintainer: Kyle Isom <kyle@imap.cc>
 Build-Depends: debhelper (>= 9), autotools-dev
 Standards-Version: 3.9.5
 Homepage: https://git.kyleisom.net/lib/libemsha
 Vcs-Git: https://git.kyleisom.net/lib/libemsha
 Vcs-Browser: https://git.kyleisom.net/lib/libemsha
 Package: libemsha-dev
 Section: libdevel
 Architecture: any
 Depends: libemsha-1 (= ${binary:Version}), ${misc:Depends}
 Description: HMAC-SHA-256 C++11 library - development files
 An MIT-licensed HMAC-SHA-256 C++11 library designed for embedded
 systems. It is built following the JPL Power of Ten rules. It was written
 in response to a need for a standalone HMAC-SHA-256 package that could
 run on several platforms.
 Package: libemsha-1
 Section: libs
 Architecture: any
 Depends: ${shlibs:Depends}, ${misc:Depends}
 Description: HMAC-SHA-256 C++11 library
 An MIT-licensed HMAC-SHA-256 C++11 library designed for embedded
 systems. It is built following the JPL Power of Ten rules. It was written
 in response to a need for a standalone HMAC-SHA-256 package that could
 run on several platforms.
--- a/debian/copyright
+++ b/debian/copyright
@ -1,24 +0,0 @@
 Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
 Upstream-Name: libemsha
 Source: https://git.kyleisom.net/lib/libemsha
 Files: *
 Copyright: 2015 K. Isom <coder@kyleisom.net>
 License: MIT
 Permission is hereby granted, free of charge, to any person obtaining a
 copy of this software and associated documentation files (the "Software"),
 to deal in the Software without restriction, including without limitation
 the rights to use, copy, modify, merge, publish, distribute, sublicense,
 and/or sell copies of the Software, and to permit persons to whom the
 Software is furnished to do so, subject to the following conditions:
 .
 The above copyright notice and this permission notice shall be included
 in all copies or substantial portions of the Software.
 .
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 OTHER DEALINGS IN THE SOFTWARE.
--- a/debian/libemsha-1.docs
+++ b/debian/libemsha-1.docs
@ -1,3 +0,0 @@
 README.rst
 TODO.rst
 doc/libemsha.rst
--- a/debian/libemsha-1.install
+++ b/debian/libemsha-1.install
@ -1,2 +0,0 @@
 usr/lib/*/lib*.so.*
 usr/lib/*/lib*.a
--- a/debian/libemsha-dev.dirs
+++ b/debian/libemsha-dev.dirs
@ -1 +0,0 @@
 usr/include
--- a/debian/libemsha-dev.install
+++ b/debian/libemsha-dev.install
@ -1,2 +0,0 @@
 usr/include/*
 usr/lib/*/pkgconfig/*
--- a/debian/patches/release-1.0.2-patch
+++ b/debian/patches/release-1.0.2-patch
@ -1,66 +0,0 @@
 Description: This adds the release files to the source tarball.
 The release files from the tagged release weren't added into
 the previous source file.
 .
 libemsha (1.0.2-3) main; urgency=medium
 .
   * Clean up debian packaging files.
 Author: Kyle Isom <kyle@imap.cc>
 ---
 The information above should follow the Patch Tagging Guidelines, please
 checkout http://dep.debian.net/deps/dep3/ to learn about the format. Here
 are templates for supplementary fields that you might want to add:
 --- libemsha-1.0.2.orig/CHANGELOG
 +++ libemsha-1.0.2/CHANGELOG
@@ -1,7 +1,7 @@
 LIBEMSHA CHANGELOG
 ==================
 -1.0.2 (2015-01-26):
 +1.0.2 (2015-01-28):
 Added:
 	+ Build now includes pkg-config.
 --- libemsha-1.0.2.orig/doc/libemsha.rst
 +++ libemsha-1.0.2/doc/libemsha.rst
@@ -2,9 +2,9 @@
 libemsha
 ========
 -Version: 1.0.1
 +Version: 1.0.2
 -Date:    2015-12-22
 +Date:    2016-01-28
 -----------------
 --- /dev/null
 +++ libemsha-1.0.2/doc/source/header.dated.rst
@@ -0,0 +1,24 @@
 +========
 +libemsha
 +========
 +
 +Version: 1.0.2
 +
 +Date:    2016-01-28
 +
 +
 +-----------------
 +Table of Contents
 +-----------------
 +
 ++ Introduction
 ++ Getting and Building the Source
 ++ Library Overview
 ++ The Hash interface
 ++ The SHA256 class
 ++ The HMAC class
 ++ Miscellaneous functions
 ++ Test Programs
 ++ References
 +
 +
--- a/debian/patches/series
+++ b/debian/patches/series
@ -1 +0,0 @@
 release-1.0.2-patch
--- a/debian/rules
+++ b/debian/rules
@ -1,32 +0,0 @@
 #!/usr/bin/make -f
 # See debhelper(7) (uncomment to enable)
 # output every command that modifies files on the build system.
 #DH_VERBOSE = 1
 # see EXAMPLES in dpkg-buildflags(1) and read /usr/share/dpkg/*
 DPKG_EXPORT_BUILDFLAGS = 1
 include /usr/share/dpkg/default.mk
 # see FEATURE AREAS in dpkg-buildflags(1)
 #export DEB_BUILD_MAINT_OPTIONS = hardening=+all
 # see ENVIRONMENT in dpkg-buildflags(1)
 # package maintainers to append CFLAGS
 #export DEB_CFLAGS_MAINT_APPEND  = -Wall -pedantic
 # package maintainers to append LDFLAGS
 #export DEB_LDFLAGS_MAINT_APPEND = -Wl,--as-needed
 # main packaging script based on dh7 syntax
 %:
 	dh $@  --with autotools-dev
 # debmake generated override targets
 # This is example for Cmake (See http://bugs.debian.org/641051 )
 #override_dh_auto_configure:
 #	dh_auto_configure -- \
 #	-DCMAKE_LIBRARY_PATH=$(DEB_HOST_MULTIARCH)
--- a/do-release.in
+++ b/do-release.in
@ -0,0 +1,43 @@
 #!/bin/sh
 set -e
 VERSION="@PACKAGE_VERSION@"
 TARBALL="@PACKAGE_NAME@-$VERSION"
 make clean
 echo "[+] rebuilding single ReST doc"
 cd doc && make clean singlerst clean && cd ..
 echo "[+] building release tarballs"
 make dist-gzip 
 if [ ! -e "$TARBALL.tar.gz" ]
 then
 	>&2 echo "[!] Expected to find ${TARBALL}.tar.gz, but it wasn't found."
 	>&2 echo "    Cannot proceed, aborting."
 	exit 1
 fi
 make dist-zip
 if [ ! -e "$TARBALL.zip" ]
 then
 	>&2 echo "[!] Expected to find ${TARBALL}.zip, but it wasn't found."
 	>&2 echo "    Cannot proceed, aborting."
 	exit 1
 fi
 mv "${TARBALL}.tar.gz" "@PACKAGE_NAME@-release.tar.gz"
 mv "${TARBALL}.zip" "@PACKAGE_NAME@-release.zip"
 echo "[+] building release notes"
 RELEASE_NOTES_AWK="/^[0-9]+\.[0-9]+\.[0-9]+(-[a-zA-Z0-9]+)? \([0-9]{4}-[0-9]{2}-[0-9]{2}\):/{
 	nmatch++;
 	if (nmatch>1) exit
 }
 {
 	if (nmatch>0)
 		print \$0;
 }"
 awk "$RELEASE_NOTES_AWK" CHANGELOG > RELEASE_NOTES
 echo "[+] release is ready"
--- a/doc/Makefile
+++ b/doc/Makefile
@ -0,0 +1,204 @@
 # Makefile for Sphinx documentation
 #
 # You can set these variables from the command line.
 SPHINXOPTS    =
 SPHINXBUILD   = sphinx-build
 PAPER         =
 BUILDDIR      = build
 # User-friendly check for sphinx-build
 ifeq ($(shell which $(SPHINXBUILD) >/dev/null 2>&1; echo $$?), 1)
 $(error The '$(SPHINXBUILD)' command was not found. Make sure you have Sphinx installed, then set the SPHINXBUILD environment variable to point to the full path of the '$(SPHINXBUILD)' executable. Alternatively you can add the directory with the executable to your PATH. If you don't have Sphinx installed, grab it from http://sphinx-doc.org/)
 endif
 # Internal variables.
 PAPEROPT_a4     = -D latex_paper_size=a4
 PAPEROPT_letter = -D latex_paper_size=letter
 ALLSPHINXOPTS   = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source
 # the i18n builder cannot share the environment and doctrees with the others
 I18NSPHINXOPTS  = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source
 .PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest gettext check
 help:
 	@echo "Please use \`make <target>' where <target> is one of"
 	@echo "  html       to make standalone HTML files"
 	@echo "  dirhtml    to make HTML files named index.html in directories"
 	@echo "  singlehtml to make a single large HTML file"
 	@echo "  pickle     to make pickle files"
 	@echo "  json       to make JSON files"
 	@echo "  htmlhelp   to make HTML files and a HTML help project"
 	@echo "  qthelp     to make HTML files and a qthelp project"
 	@echo "  devhelp    to make HTML files and a Devhelp project"
 	@echo "  epub       to make an epub"
 	@echo "  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
 	@echo "  latexpdf   to make LaTeX files and run them through pdflatex"
 	@echo "  latexpdfja to make LaTeX files and run them through platex/dvipdfmx"
 	@echo "  text       to make text files"
 	@echo "  man        to make manual pages"
 	@echo "  texinfo    to make Texinfo files"
 	@echo "  info       to make Texinfo files and run them through makeinfo"
 	@echo "  gettext    to make PO message catalogs"
 	@echo "  changes    to make an overview of all changed/added/deprecated items"
 	@echo "  xml        to make Docutils-native XML files"
 	@echo "  pseudoxml  to make pseudoxml-XML files for display purposes"
 	@echo "  linkcheck  to check all external links for integrity"
 	@echo "  doctest    to run all doctests embedded in the documentation (if enabled)"
 # The autotools Makefiles don't seem to do anything for docs in all or check.
 all:
 check:
 distclean: clean
 	rm -f source/header*.rst
 	rm -f source/conf.py
 clean:
 	rm -rf $(BUILDDIR)/*
 html:
 	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
 	@echo
 	@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
 dirhtml:
 	$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
 	@echo
 	@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
 singlehtml:
 	$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
 	@echo
 	@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
 pickle:
 	$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
 	@echo
 	@echo "Build finished; now you can process the pickle files."
 json:
 	$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
 	@echo
 	@echo "Build finished; now you can process the JSON files."
 htmlhelp:
 	$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
 	@echo
 	@echo "Build finished; now you can run HTML Help Workshop with the" \
 	      ".hhp project file in $(BUILDDIR)/htmlhelp."
 qthelp:
 	$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
 	@echo
 	@echo "Build finished; now you can run "qcollectiongenerator" with the" \
 	      ".qhcp project file in $(BUILDDIR)/qthelp, like this:"
 	@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/PACKAGE_NAME.qhcp"
 	@echo "To view the help file:"
 	@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/PACKAGE_NAME.qhc"
 devhelp:
 	$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
 	@echo
 	@echo "Build finished."
 	@echo "To view the help file:"
 	@echo "# mkdir -p $$HOME/.local/share/devhelp/PACKAGE_NAME"
 	@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/PACKAGE_NAME"
 	@echo "# devhelp"
 epub:
 	$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
 	@echo
 	@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
 latex:
 	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
 	@echo
 	@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
 	@echo "Run \`make' in that directory to run these through (pdf)latex" \
 	      "(use \`make latexpdf' here to do that automatically)."
 pdf: latexpdf
 latexpdf:
 	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
 	@echo "Running LaTeX files through pdflatex..."
 	$(MAKE) -C $(BUILDDIR)/latex all-pdf
 	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
 latexpdfja:
 	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
 	@echo "Running LaTeX files through platex and dvipdfmx..."
 	$(MAKE) -C $(BUILDDIR)/latex all-pdf-ja
 	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
 text:
 	$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
 	@echo
 	@echo "Build finished. The text files are in $(BUILDDIR)/text."
 man:
 	$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
 	@echo
 	@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
 texinfo:
 	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
 	@echo
 	@echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo."
 	@echo "Run \`make' in that directory to run these through makeinfo" \
 	      "(use \`make info' here to do that automatically)."
 info:
 	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
 	@echo "Running Texinfo files through makeinfo..."
 	make -C $(BUILDDIR)/texinfo info
 	@echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo."
 gettext:
 	$(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale
 	@echo
 	@echo "Build finished. The message catalogs are in $(BUILDDIR)/locale."
 changes:
 	$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
 	@echo
 	@echo "The overview file is in $(BUILDDIR)/changes."
 linkcheck:
 	$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
 	@echo
 	@echo "Link check complete; look for any errors in the above output " \
 	      "or in $(BUILDDIR)/linkcheck/output.txt."
 doctest:
 	$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
 	@echo "Testing of doctests in the sources finished, look at the " \
 	      "results in $(BUILDDIR)/doctest/output.txt."
 xml:
 	$(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml
 	@echo
 	@echo "Build finished. The XML files are in $(BUILDDIR)/xml."
 pseudoxml:
 	$(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml
 	@echo
 	@echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml."
 singlerst:
 	sed -e "s/@BUILD_DATE@/$$(date +'%Y-%m-%d')/" \
 		source/header.rst > source/header.dated.rst
 	cat 	source/header.dated.rst	\
 		source/intro.rst	\
 		source/building.rst	\
 		source/overview.rst	\
 		source/hash.rst		\
 		source/sha256.rst	\
 		source/hmac.rst		\
 		source/misc.rst		\
 		source/tests.rst	\
 		source/refs.rst		\
 		> libemsha.rst
--- a/doc/build/.gitkeep
+++ b/doc/build/.gitkeep
--- a/doc/libemsha.rst
+++ b/doc/libemsha.rst
@ -0,0 +1,601 @@
 ========
 libemsha
 ========
 Version: 1.0.1
 Date:    2015-12-22
 -----------------
 Table of Contents
 -----------------
 + Introduction
 + Getting and Building the Source
 + Library Overview
 + The Hash interface
 + The SHA256 class
 + The HMAC class
 + Miscellaneous functions
 + Test Programs
 + References
 -------------
 Introduction
 -------------
 This library is an MIT-licensed compact HMAC-SHA-256 C++11 library
 designed for embedded systems. It is built following the JPL `Power of
 Ten <http://spinroot.com/gerard/pdf/P10.pdf>`_ rules.
 This library came about as a result of a need for a standalone
 SHA-256 library for an embedded system. The original goal was
 to implement a wrapper around the code extracted from `RFC 6234
 <https://tools.ietf.org/html/rfc6234>`_; instead a standalone
 implementation was decided on.
 Additional resources:
 + `Github page <https://github.com/kisom/libemsha>`_
 + `Travis CI status <https://travis-ci.org/kisom/libemsha/>`_
 + `Coverity Scan page <https://scan.coverity.com/projects/libemsha-52f2a5fd-e759-43c2-9073-cf6c2ed9abdb>`_
 -------------------------------
 Getting and Building the Source
 -------------------------------
 The source code is available via `Github
 <https://github.com/kisom/libemsha/>`_; each version should be git tagged. ::
    git clone https://github.com/kisom/libemsha
    git clone git@github.com:kisom/libemsha
 The current release is `1.0.0 <https://github.com/kisom/libemsha/archive/1.0.0.zip>`_.
 The project is built using Autotools and ``make``.
 When building from a git checkout, the `autobuild` script will bootstrap
 the project from the autotools sources (e.g. via ``autoreconf -i``),
 run ``configurei`` (by default to use clang), and attempt to build the library
 and run the unit tests.
 Once the autotools infrastructure has been bootstrapped, the following
 should work: ::
    ./configure && make && make check && make install
 There are three flags to ``configure`` that might be useful:
 + ``--disable-hexstring`` disables the provided ``hexstring`` function;
  while this might be useful in many cases, it also adds extra size to
  the code.
 + ``--disable-hexlut`` disables the larger lookup table used by
  ``hexstring``, which can save around a kilobyte of program space. If
  the ``hexstring`` function is disabled, this option has no effect.
 + ``--disable-selftest`` disables the internal self-tests, which can
  reclaim some additional program space.
 ----------------
 Library Overview
 ----------------
 .. cpp:namespace:: emsha
 The package provides a pair of classes, :cpp:class:`SHA256` and
 :cpp:class:`HMAC`, that both satisfy a common interface :cpp:class:`Hash`. All
 functionality provided by this library is found under the ``emsha`` namespace.
 ``EMSHA_RESULT``
 ^^^^^^^^^^^^^^^^^
 The ``EMSHA_RESULT`` enum is used to convey the result of an
 operation. The possible values are:
 .. cpp:enum:: _EMSHA_RESULT_ : uint8_t
 ::
                // All operations have completed successfully so far.
                EMSHA_ROK = 0,
                // A self test or unit test failed.
                EMSHA_TEST_FAILURE = 1,
                // A null pointer was passed in as a buffer where it
                // shouldn't have been.
                EMSHA_NULLPTR = 2,
                // The Hash is in an invalid state.
                EMSHA_INVALID_STATE = 3,
                // The input to SHA256::update is too large.
                SHA256_INPUT_TOO_LONG = 4,
                // The self tests have been disabled, but a self test
                // function was called.
                EMSHA_SELFTEST_DISABLED = 5
 As a convenience, the following ``typedef`` is also provided.
 ``typedef enum _EMSHA_RESULT_`` :cpp:type:`EMSHA_RESULT`
 ------------------
 The Hash interface
 ------------------
 .. cpp:class:: emsha::Hash
   The ``Hash`` class contains a top-level interface for the objects in
   this library.
 In general, a `Hash` is used along the lines of: ::
        emsha::EMSHA_RESULT
        hash_single_pass(uint8_t *m, uint32_t ml, uint8_t *digest)
        {
                // Depending on the implementation, the constructor may need
                // arguments.
                emsha::Hash         h;
                emsha::EMSHA_RESULT res;
                res = h.write(m, ml);
                if (emsha::EMSHA_ROK != res) {
                        return res;        
                }
                // digest will contain the output of the Hash, and the
                // caller MUST ensure that there is enough space in
                // the buffer.
                return h.result(d);
        }
 Methods
 ^^^^^^^
 .. cpp:function:: emsha::EMSHA_RESULT reset(void)
   reset should bring the Hash back into its initial state. That is,
   the idea is that::
       hash->reset();
       hash->update(...); // possibly many of these...
       hash->result(...); // should always return the same hash.
   is idempotent, assuming the inputs to ``update`` and ``result``
   are constant. The implications of this for a given concrete class
   should be described in that class's documentation, but in general,
   it has the effect of preserving any initial state while removing any
   data written to the Hash via the update method.
 .. cpp:function:: emsha::EMSHA_RESULT update(const uint8_t *m, uint32_t ml)
   ``update`` is used to write message data into
   the Hash.
 .. cpp:function:: emsha::EMSHA_RESULT finalize(uint8_t *d)
   ``finalize`` should carry out any final operations on the `Hash`;
   after a call to finalize, no more data can be written.  Additionally,
   it transfers out the resulting hash into its argument.
   Note that this library does not allocate memory, and therefore the
   caller *must* ensure that ``d`` is a valid buffer containing at least
   ``this->size()`` bytes.
 .. cpp:function:: emsha::EMSHA_RESULT result(uint8_t *d)
   ``result`` is used to transfer out the hash to the argument. This implies
   that the `Hash` must keep enough state for repeated calls to ``result``
   to work.
 .. cpp:function:: uint32_t size(void)
   ``size`` should return the output size of the `Hash`; this is, how large
   the buffers written to by ``result`` should be.
 -----------------
 The SHA256 class
 -----------------
 .. cpp:class:: emsha::SHA256
   SHA256 is an implementation of the :cpp:class:`emsha::Hash` interface
   implementing the SHA-256 cryptographic hash algorithm
 .. cpp:function:: SHA256::SHA256()
   A SHA256 context does not need any special construction. It can be
   declared and immediately start being used.
 .. cpp:function:: SHA256::~SHA256()
   The SHA256 destructor will clear out its internal message buffer;
   all of the members are local and not resource handles, so cleanup
   is minimal.
 .. cpp:function:: emsha::EMSHA_RESULT SHA256::reset(void)
   reset clears the internal state of the `SHA256` context and returns
   it to its initial state.  It should always return ``EMSHA_ROK``.
 .. cpp:function:: emsha::EMSHA_RESULT SHA256::update(const uint8_t *m, uint32_t ml)
   update writes data into the context. While there is an upper limit
   on the size of data that SHA-256 can operate on, this package is
   designed for small systems that will not approach that level of
   data (which is on the order of 2 exabytes), so it is not thought to
   be a concern.
   **Inputs**:
   + ``m``: a byte array containing the message to be written. It must
     not be NULL (unless the message length is zero).
   + ``ml``: the message length, in bytes.
   **Return values**:
   * ``EMSHA_NULLPTR`` is returned if ``m`` is NULL and ``ml`` is nonzero.
   * ``EMSHA_INVALID_STATE`` is returned if the `update` is called 
     after a call to `finalize`.
   * ``SHA256_INPUT_TOO_LONG`` is returned if too much data has been
     written to the context.
   + ``EMSHA_ROK`` is returned if the data was successfully added to
     the SHA-256 context.
 .. cpp:function:: emsha::EMSHA_RESULT SHA256::finalize(uint8_t *d)
   ``finalize`` completes the digest. Once this method is called, the
   context cannot be updated unless the context is reset.
   **Inputs**:
   * d: a byte buffer that must be at least ``SHA256.size()`` in
     length.
   **Outputs**:
   * ``EMSHA_NULLPTR`` is returned if ``d`` is the null pointer.
   * ``EMSHA_INVALID_STATE`` is returned if the SHA-256 context is in
     an invalid state, such as if there were errors in previous
     updates.
   * ``EMSHA_ROK`` is returned if the context was successfully
     finalised and the digest copied to ``d``.
 .. cpp:function:: emsha::EMSHA_RESULT SHA256::result(uint8_t *d)
   ``result`` copies the result from the SHA-256 context into the
   buffer pointed to by ``d``, running finalize if needed. Once
   called, the context cannot be updated until the context is reset.
   **Inputs**:
   * ``d``: a byte buffer that must be at least ``SHA256.size()`` in
     length.
   **Outputs**:
   * ``EMSHA_NULLPTR`` is returned if ``d`` is the null pointer.
   * ``EMSHA_INVALID_STATE`` is returned if the SHA-256 context is in
     an invalid state, such as if there were errors in previous
     updates.
   * ``EMSHA_ROK`` is returned if the context was successfully
     finalised and the digest copied to ``d``.
 .. cpp:function:: uint32_t SHA256::size(void)
   ``size`` returns the output size of SHA256, e.g.
   the size that the buffers passed to ``finalize``
   and ``result`` should be.
   **Outputs**:
   * a ``uint32_t`` representing the expected size of buffers passed
     to ``result`` and ``finalize``.
 --------------
 The HMAC class
 --------------
 .. cpp:class:: emsha::HMAC
   HMAC is an implementation of the :cpp:class:`emsha::Hash` interface
   implementing the HMAC keyed-hash message authentication code as
   defined in FIPS 198-1, using SHA-256 internally.
 .. cpp:function:: HMAC::HMAC(const uint8_t *key, uint32_t keylen)
   An HMAC context must be initialised with a key.
 .. cpp:function:: HMAc::~HMAC()
   The HMAC destructor will attempt to wipe the key and reset the
   underlying SHA-256 context.
 .. cpp:function:: emsha::EMSHA_RESULT HMAC::reset(void)
   reset clears the internal state of the `HMAC` context and returns
   it to its initial state.  It should always return ``EMSHA_ROK``.
   This function will **not** wipe the key; an `HMAC` object that has
   `reset` called it can be used immediately after.
 .. cpp:function:: emsha::EMSHA_RESULT HMAC::update(const uint8_t *m, uint32_t ml)
   update writes data into the context. While there is an upper limit on
   the size of data that the underlying SHA-256 context can operate on,
   this package is designed for small systems that will not approach
   that level of data (which is on the order of 2 exabytes), so it is
   not thought to be a concern.
   **Inputs**:
   + ``m``: a byte array containing the message to be written. It must
     not be NULL (unless the message length is zero).
   + ``ml``: the message length, in bytes.
   **Return values**:
   * ``EMSHA_NULLPTR`` is returned if ``m`` is NULL and ``ml`` is nonzero.
   * ``EMSHA_INVALID_STATE`` is returned if the `update` is called 
     after a call to `finalize`.
   * ``SHA256_INPUT_TOO_LONG`` is returned if too much data has been
     written to the context.
   + ``EMSHA_ROK`` is returned if the data was successfully added to
     the HMAC context.
 .. cpp:function:: emsha::EMSHA_RESULT SHA256::finalize(uint8_t *d)
   ``finalize`` completes the digest. Once this method is called, the
   context cannot be updated unless the context is reset.
   **Inputs**:
   * d: a byte buffer that must be at least ``SHA256.size()`` in
     length.
   **Outputs**:
   * ``EMSHA_NULLPTR`` is returned if ``d`` is the null pointer.
   * ``EMSHA_INVALID_STATE`` is returned if the HMAC context is in
     an invalid state, such as if there were errors in previous
     updates.
   * ``EMSHA_ROK`` is returned if the context was successfully
     finalised and the digest copied to ``d``.
 .. cpp:function:: emsha::EMSHA_RESULT SHA256::result(uint8_t *d)
   ``result`` copies the result from the HMAC context into the
   buffer pointed to by ``d``, running finalize if needed. Once
   called, the context cannot be updated until the context is reset.
   **Inputs**:
   * ``d``: a byte buffer that must be at least ``HMAC.size()`` in
     length.
   **Outputs**:
   * ``EMSHA_NULLPTR`` is returned if ``d`` is the null pointer.
   * ``EMSHA_INVALID_STATE`` is returned if the HMAC context is in
     an invalid state, such as if there were errors in previous
     updates.
   * ``EMSHA_ROK`` is returned if the context was successfully
     finalised and the digest copied to ``d``.
 .. cpp:function:: uint32_t SHA256::size(void)
   ``size`` returns the output size of HMAC, e.g.  the size that the
   buffers passed to ``finalize`` and ``result`` should be.
   **Outputs**:
   * a ``uint32_t`` representing the expected size of buffers passed
     to ``result`` and ``finalize``.
 -----------------------
 Miscellaneous functions
 -----------------------
 .. cpp:function:: emsha::EMSHA_RESULT sha256_self_test(void)
   If the library was `compiled with support for self tests
   <./building.html>`_ (the default), this function will run a few self
   tests on the SHA-256 functions to validate that they are working
   correctly.
   **Outputs**:
   * ``EMSHA_ROK`` if the self-test completed successfully.
   * ``EMSHA_TEST_FAILURE`` if the SHA-256 functions did not produce
     the expected value.
   * ``EMSHA_SELFTEST_DISABLED`` if the library was built without
     support for the self test.
   * If an error occurs in the SHA-256 code, the resulting error code
     will be returned.
 .. cpp:function:: emsha::EMSHA_RESULT sha256_digest(const uint8_t *m, uint32_t ml, uint8_t *d)
   The ``sha256_digest`` function will compute the digest on the
   ``ml``-byte octet string stored in ``m``, returning the result
   in ``d``. This is a convenience function implemented as: ::
    EMSHA_RESULT
    sha256_digest(const uint8_t *m, uint32_t ml, uint8_t *d)
    {
            SHA256          h;
            EMSHA_RESULT    ret;
            if (EMSHA_ROK != (ret = h.update(m, ml))) {
                    return ret;
            }
            return h.finalize(d);
    }
 .. cpp:function:: emsha::EMSHA_RESULT compute_hmac(const uint8_t *k, uint32_t kl, const uint8_t *m, uint32_t ml, uint8_t *d)
   The ``compute_hmac`` function computes the MAC on the ``ml``-byte
   octet string stored in``m``, using the ``kl``-length key ``k``. The
   result is stored in ``d``. This is a convenience function implemented
   as: ::
    EMSHA_RESULT
    compute_hmac(const uint8_t *k, uint32_t kl, const uint8_t *m, uint32_t ml,
                 uint8_t *d)
    {
            EMSHA_RESULT    res;
            HMAC            h(k, kl);
            res = h.update(m, ml);
            if (EMSHA_ROK != res) {
                    return res;
            }
            res = h.result(d);
            if (EMSHA_ROK != res) {
                    return res;
            }
            return res;
    }
 .. cpp:function:: bool hash_equal(const uint8_t *a, const uint8_t *b)
   ``hash_equal`` performs a constant-time comparison of the first
   ``emsha::SHA256_HASH_SIZE`` bytes in the two byte array arguments.
   **Inputs**:
   * ``a``, ``b``: byte arrays at least ``emsha::SHA256_HASH_SIZE``
     bytes in length.
   ** Outputs**:
   * true *iff* the first ``emsha::SHA256_HASH_SIZE`` bytes match in
     both arrays.
   * false otherwise.
 .. cpp:function::  void hexstring(uint8_t *dest, uint8_t *src, uint32_t srclen)
   **Note**: this function is only present if the library was
   `built with support <./building.html>`_ for the hexstring functionality.
   **Inputs**:
   * dest:   a byte array that is 2 * ``srclen``.
   * src:    a byte array containing the data to process.
   * srclen: the size of ``src``.
   **Outputs**:
   When the function returns, the hex-encoded string will be placed in
   ``dest``.
 -------------
 Test Programs
 -------------
 Running ``make check`` builds and runs the test programs. These are:
 * ``emsha_core_test`` runs the core tests.
 * ``emsha_sha256_test`` runs test vectors on the SHA-256 code.
 * ``emsha_hmac_test`` runs test vectors on the HMAC code.
 Additionally, the following test programs are built but not run. These
 programs do not link with the library as the above programs do; instead,
 they compile the object files in to avoid the libtool dance before the
 library is installed.
 * ``emsha_mem_test`` and ``emsha_static_mem_test`` are for memory
  profiling (e.g., with `Valgrind <http://valgrind.org/>`_ during
  development.
 * ``emsha_static_sha256_test`` and ``emsha_static_hmac_test`` are used
  to facilitate testing and debugging the library. These programs run
  the same tests as the ``emsha_sha256_test`` and ``emsha_hmac_test``
  programs.
 Core Tests
 ^^^^^^^^^^
 There are three tests run in the core tests: a hexstring test (if
 `support is built in <./building.html>`_) and the constant time
 check. The constant time test does not validate that the function
 is constant time, only that it correctly verifies that two byte
 arrays are equal.
 SHA-256 Tests
 ^^^^^^^^^^^^^
 The SHA-256 checks take a number of test vectors from the Go standard
 library's SHA-256 library.
 HMAC Tests
 ^^^^^^^^^^
 The HMAC checks apply the `RFC 4231 <http://tools.ietf.org/html/rfc4231>`_
 test vectors to the HMAC code.
 ----------
 References
 ----------
 * `FIPS 180-4, the Secure Hash Standard <http://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf>`_
 * `FIPS 198-1, The Keyed-Hash Message Authentication Code (HMAC) <http://csrc.nist.gov/publications/fips/fips198-1/FIPS-198-1_final.pdf>`_
 * `RFC 2014, HMAC: Keyed-Hashing for Message Authentication <https://tools.ietf.org/html/rfc2104>`_
 * `RFC 6234, US Secure Hash Algorithms (SHA and SHA-based HMAC and HKDF) <https://tools.ietf.org/html/rfc6234>`_\ [#f1]_
 * The behaviour of this package was cross-checked using the Go 1.5.1
  linux/amd64 standard library's `crypto/sha256 <https://golang.org/src/crypto/sha256/>`_
  package.
 .. rubric:: Footnotes
 .. [#f1] This library came about after extracting the relevant C code
         from RFC 6234, and needing a C++ version. It draws heavy
         inspiration from that code base.
--- a/doc/source/_static/.gitkeep
+++ b/doc/source/_static/.gitkeep
--- a/doc/source/_templates/.gitkeep
+++ b/doc/source/_templates/.gitkeep
--- a/doc/source/building.rst
+++ b/doc/source/building.rst
@ -0,0 +1,37 @@
 -------------------------------
 Getting and Building the Source
 -------------------------------
 The source code is available via `Github
 <https://github.com/kisom/libemsha/>`_; each version should be git tagged. ::
    git clone https://github.com/kisom/libemsha
    git clone git@github.com:kisom/libemsha
 The current release is `1.0.0 <https://github.com/kisom/libemsha/archive/1.0.0.zip>`_.
 The project is built using Autotools and ``make``.
 When building from a git checkout, the `autobuild` script will bootstrap
 the project from the autotools sources (e.g. via ``autoreconf -i``),
 run ``configurei`` (by default to use clang), and attempt to build the library
 and run the unit tests.
 Once the autotools infrastructure has been bootstrapped, the following
 should work: ::
    ./configure && make && make check && make install
 There are three flags to ``configure`` that might be useful:
 + ``--disable-hexstring`` disables the provided ``hexstring`` function;
  while this might be useful in many cases, it also adds extra size to
  the code.
 + ``--disable-hexlut`` disables the larger lookup table used by
  ``hexstring``, which can save around a kilobyte of program space. If
  the ``hexstring`` function is disabled, this option has no effect.
 + ``--disable-selftest`` disables the internal self-tests, which can
  reclaim some additional program space.
--- a/doc/source/conf.py.in
+++ b/doc/source/conf.py.in
@ -0,0 +1,335 @@
 # -*- coding: utf-8 -*-
 #
 # @PACKAGE_NAME@ documentation build configuration file, created by
 # sphinx-quickstart on Tue Dec 15 23:35:10 2015.
 #
 # This file is execfile()d with the current directory set to its
 # containing dir.
 #
 # Note that not all possible configuration values are present in this
 # autogenerated file.
 #
 # All configuration values have a default; values that are commented out
 # serve to show the default.
 import sys
 import os
 import sphinx_rtd_theme
 # If extensions (or modules to document with autodoc) are in another directory,
 # add these directories to sys.path here. If the directory is relative to the
 # documentation root, use os.path.abspath to make it absolute, like shown here.
 #sys.path.insert(0, os.path.abspath('.'))
 # -- General configuration ------------------------------------------------
 # If your documentation needs a minimal Sphinx version, state it here.
 #needs_sphinx = '1.0'
 # Add any Sphinx extension module names here, as strings. They can be
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
 # ones.
 extensions = [
    'sphinx.ext.todo',
 ]
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['_templates']
 # The suffix of source filenames.
 source_suffix = '.rst'
 # The encoding of source files.
 #source_encoding = 'utf-8-sig'
 # The master toctree document.
 master_doc = 'index'
 # General information about the project.
 project = u'@PACKAGE_NAME@'
 copyright = u'2015, K. Isom <coder@kyleisom.net>'
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
 # built documents.
 #
 # The short X.Y version.
 version = '@PACKAGE_VERSION@'
 # The full version, including alpha/beta/rc tags.
 release = '@PACKAGE_VERSION@'
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
 #language = None
 # There are two options for replacing |today|: either, you set today to some
 # non-false value, then it is used:
 #today = ''
 # Else, today_fmt is used as the format for a strftime call.
 #today_fmt = '%B %d, %Y'
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
 exclude_patterns = []
 # The reST default role (used for this markup: `text`) to use for all
 # documents.
 #default_role = None
 # If true, '()' will be appended to :func: etc. cross-reference text.
 #add_function_parentheses = True
 # If true, the current module name will be prepended to all description
 # unit titles (such as .. function::).
 #add_module_names = True
 # If true, sectionauthor and moduleauthor directives will be shown in the
 # output. They are ignored by default.
 #show_authors = False
 # The name of the Pygments (syntax highlighting) style to use.
 pygments_style = 'sphinx'
 # A list of ignored prefixes for module index sorting.
 #modindex_common_prefix = []
 # If true, keep warnings as "system message" paragraphs in the built documents.
 #keep_warnings = False
 highlight_language = 'c++'
 # -- Options for HTML output ----------------------------------------------
 # The theme to use for HTML and HTML Help pages.  See the documentation for
 # a list of builtin themes.
 html_theme = 'sphinx_rtd_theme'
 # Theme options are theme-specific and customize the look and feel of a theme
 # further.  For a list of options available for each theme, see the
 # documentation.
 #html_theme_options = {}
 # Add any paths that contain custom themes here, relative to this directory.
 #html_theme_path = []
 html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]
 # The name for this set of Sphinx documents.  If None, it defaults to
 # "<project> v<release> documentation".
 #html_title = None
 # A shorter title for the navigation bar.  Default is the same as html_title.
 #html_short_title = None
 # The name of an image file (relative to this directory) to place at the top
 # of the sidebar.
 #html_logo = None
 # The name of an image file (within the static path) to use as favicon of the
 # docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
 # pixels large.
 #html_favicon = None
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".
 html_static_path = ['_static']
 # Add any extra paths that contain custom files (such as robots.txt or
 # .htaccess) here, relative to this directory. These files are copied
 # directly to the root of the documentation.
 #html_extra_path = []
 # If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
 # using the given strftime format.
 #html_last_updated_fmt = '%b %d, %Y'
 # If true, SmartyPants will be used to convert quotes and dashes to
 # typographically correct entities.
 #html_use_smartypants = True
 # Custom sidebar templates, maps document names to template names.
 #html_sidebars = {}
 # Additional templates that should be rendered to pages, maps page names to
 # template names.
 #html_additional_pages = {}
 # If false, no module index is generated.
 #html_domain_indices = True
 # If false, no index is generated.
 #html_use_index = True
 # If true, the index is split into individual pages for each letter.
 #html_split_index = False
 # If true, links to the reST sources are added to the pages.
 #html_show_sourcelink = True
 # If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
 #html_show_sphinx = True
 # If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
 #html_show_copyright = True
 # If true, an OpenSearch description file will be output, and all pages will
 # contain a <link> tag referring to it.  The value of this option must be the
 # base URL from which the finished HTML is served.
 #html_use_opensearch = ''
 # This is the file name suffix for HTML files (e.g. ".xhtml").
 #html_file_suffix = None
 # Output file base name for HTML help builder.
 htmlhelp_basename = '@PACKAGE_NAME@doc'
 # -- Options for LaTeX output ---------------------------------------------
 latex_elements = {
 # The paper size ('letterpaper' or 'a4paper').
 #'papersize': 'letterpaper',
 # The font size ('10pt', '11pt' or '12pt').
 #'pointsize': '10pt',
 # Additional stuff for the LaTeX preamble.
 #'preamble': '',
 }
 # Grouping the document tree into LaTeX files. List of tuples
 # (source start file, target name, title,
 #  author, documentclass [howto, manual, or own class]).
 latex_documents = [
  ('index', '@PACKAGE_NAME@.tex', u'@PACKAGE_NAME@ Documentation',
   u'K. Isom <coder@kyleisom.net>', 'manual'),
 ]
 # The name of an image file (relative to this directory) to place at the top of
 # the title page.
 #latex_logo = None
 # For "manual" documents, if this is true, then toplevel headings are parts,
 # not chapters.
 #latex_use_parts = False
 # If true, show page references after internal links.
 latex_show_pagerefs = True
 # If true, show URL addresses after external links.
 # latex_show_urls = True
 # Documents to append as an appendix to all manuals.
 #latex_appendices = []
 # If false, no module index is generated.
 #latex_domain_indices = True
 # -- Options for manual page output ---------------------------------------
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
 man_pages = [
    ('index', 'package_name', u'@PACKAGE_NAME@ Documentation',
     [u'K. Isom <coder@kyleisom.net>'], 1)
 ]
 # If true, show URL addresses after external links.
 man_show_urls = True
 # -- Options for Texinfo output -------------------------------------------
 # Grouping the document tree into Texinfo files. List of tuples
 # (source start file, target name, title, author,
 #  dir menu entry, description, category)
 texinfo_documents = [
  ('index', '@PACKAGE_NAME@', u'@PACKAGE_NAME@ Documentation',
   u'K. Isom <coder@kyleisom.net>', '@PACKAGE_NAME@', 'HMAC-SHA-256 C++11 library designed for embedded systems.',
   'Development'),
 ]
 # Documents to append as an appendix to all manuals.
 #texinfo_appendices = []
 # If false, no module index is generated.
 #texinfo_domain_indices = True
 # How to display URL addresses: 'footnote', 'no', or 'inline'.
 #texinfo_show_urls = 'footnote'
 # If true, do not generate a @detailmenu in the "Top" node's menu.
 #texinfo_no_detailmenu = False
 # -- Options for Epub output ----------------------------------------------
 # Bibliographic Dublin Core info.
 epub_title = u'@PACKAGE_NAME@'
 epub_author = u'K. Isom <coder@kyleisom.net>'
 epub_publisher = u'K. Isom <coder@kyleisom.net>'
 epub_copyright = u'2015, K. Isom <coder@kyleisom.net>'
 # The basename for the epub file. It defaults to the project name.
 #epub_basename = u'@PACKAGE_NAME@'
 # The HTML theme for the epub output. Since the default themes are not optimized
 # for small screen space, using the same theme for HTML and epub output is
 # usually not wise. This defaults to 'epub', a theme designed to save visual
 # space.
 #epub_theme = 'epub'
 # The language of the text. It defaults to the language option
 # or en if the language is not set.
 #epub_language = ''
 # The scheme of the identifier. Typical schemes are ISBN or URL.
 #epub_scheme = ''
 # The unique identifier of the text. This can be a ISBN number
 # or the project homepage.
 #epub_identifier = ''
 # A unique identification for the text.
 #epub_uid = ''
 # A tuple containing the cover image and cover page html template filenames.
 #epub_cover = ()
 # A sequence of (type, uri, title) tuples for the guide element of content.opf.
 #epub_guide = ()
 # HTML files that should be inserted before the pages created by sphinx.
 # The format is a list of tuples containing the path and title.
 #epub_pre_files = []
 # HTML files shat should be inserted after the pages created by sphinx.
 # The format is a list of tuples containing the path and title.
 #epub_post_files = []
 # A list of files that should not be packed into the epub file.
 epub_exclude_files = ['search.html']
 # The depth of the table of contents in toc.ncx.
 #epub_tocdepth = 3
 # Allow duplicate toc entries.
 #epub_tocdup = True
 # Choose between 'default' and 'includehidden'.
 #epub_tocscope = 'default'
 # Fix unsupported image types using the PIL.
 #epub_fix_images = False
 # Scale large images.
 #epub_max_image_width = 0
 # How to display URL addresses: 'footnote', 'no', or 'inline'.
 #epub_show_urls = 'inline'
 # If false, no index is generated.
 #epub_use_index = True
--- a/doc/source/hash.rst
+++ b/doc/source/hash.rst
@ -0,0 +1,74 @@
 ------------------
 The Hash interface
 ------------------
 .. cpp:class:: emsha::Hash
   The ``Hash`` class contains a top-level interface for the objects in
   this library.
 In general, a `Hash` is used along the lines of: ::
        emsha::EMSHA_RESULT
        hash_single_pass(uint8_t *m, uint32_t ml, uint8_t *digest)
        {
                // Depending on the implementation, the constructor may need
                // arguments.
                emsha::Hash         h;
                emsha::EMSHA_RESULT res;
                res = h.write(m, ml);
                if (emsha::EMSHA_ROK != res) {
                        return res;        
                }
                // digest will contain the output of the Hash, and the
                // caller MUST ensure that there is enough space in
                // the buffer.
                return h.result(d);
        }
 Methods
 ^^^^^^^
 .. cpp:function:: emsha::EMSHA_RESULT reset(void)
   reset should bring the Hash back into its initial state. That is,
   the idea is that::
       hash->reset();
       hash->update(...); // possibly many of these...
       hash->result(...); // should always return the same hash.
   is idempotent, assuming the inputs to ``update`` and ``result``
   are constant. The implications of this for a given concrete class
   should be described in that class's documentation, but in general,
   it has the effect of preserving any initial state while removing any
   data written to the Hash via the update method.
 .. cpp:function:: emsha::EMSHA_RESULT update(const uint8_t *m, uint32_t ml)
   ``update`` is used to write message data into
   the Hash.
 .. cpp:function:: emsha::EMSHA_RESULT finalize(uint8_t *d)
   ``finalize`` should carry out any final operations on the `Hash`;
   after a call to finalize, no more data can be written.  Additionally,
   it transfers out the resulting hash into its argument.
   Note that this library does not allocate memory, and therefore the
   caller *must* ensure that ``d`` is a valid buffer containing at least
   ``this->size()`` bytes.
 .. cpp:function:: emsha::EMSHA_RESULT result(uint8_t *d)
   ``result`` is used to transfer out the hash to the argument. This implies
   that the `Hash` must keep enough state for repeated calls to ``result``
   to work.
 .. cpp:function:: uint32_t size(void)
   ``size`` should return the output size of the `Hash`; this is, how large
   the buffers written to by ``result`` should be.
--- a/doc/source/header.rst.in
+++ b/doc/source/header.rst.in
@ -0,0 +1,24 @@
 ========
 libemsha
 ========
 Version: @PACKAGE_VERSION@
 Date:    @BUILD_DATE@
 -----------------
 Table of Contents
 -----------------
 + Introduction
 + Getting and Building the Source
 + Library Overview
 + The Hash interface
 + The SHA256 class
 + The HMAC class
 + Miscellaneous functions
 + Test Programs
 + References
--- a/doc/source/hmac.rst
+++ b/doc/source/hmac.rst
@ -0,0 +1,113 @@
 --------------
 The HMAC class
 --------------
 .. cpp:class:: emsha::HMAC
   HMAC is an implementation of the :cpp:class:`emsha::Hash` interface
   implementing the HMAC keyed-hash message authentication code as
   defined in FIPS 198-1, using SHA-256 internally.
 .. cpp:function:: HMAC::HMAC(const uint8_t *key, uint32_t keylen)
   An HMAC context must be initialised with a key.
 .. cpp:function:: HMAc::~HMAC()
   The HMAC destructor will attempt to wipe the key and reset the
   underlying SHA-256 context.
 .. cpp:function:: emsha::EMSHA_RESULT HMAC::reset(void)
   reset clears the internal state of the `HMAC` context and returns
   it to its initial state.  It should always return ``EMSHA_ROK``.
   This function will **not** wipe the key; an `HMAC` object that has
   `reset` called it can be used immediately after.
 .. cpp:function:: emsha::EMSHA_RESULT HMAC::update(const uint8_t *m, uint32_t ml)
   update writes data into the context. While there is an upper limit on
   the size of data that the underlying SHA-256 context can operate on,
   this package is designed for small systems that will not approach
   that level of data (which is on the order of 2 exabytes), so it is
   not thought to be a concern.
   **Inputs**:
   + ``m``: a byte array containing the message to be written. It must
     not be NULL (unless the message length is zero).
   + ``ml``: the message length, in bytes.
   **Return values**:
   * ``EMSHA_NULLPTR`` is returned if ``m`` is NULL and ``ml`` is nonzero.
   * ``EMSHA_INVALID_STATE`` is returned if the `update` is called 
     after a call to `finalize`.
   * ``SHA256_INPUT_TOO_LONG`` is returned if too much data has been
     written to the context.
   + ``EMSHA_ROK`` is returned if the data was successfully added to
     the HMAC context.
 .. cpp:function:: emsha::EMSHA_RESULT SHA256::finalize(uint8_t *d)
   ``finalize`` completes the digest. Once this method is called, the
   context cannot be updated unless the context is reset.
   **Inputs**:
   * d: a byte buffer that must be at least ``SHA256.size()`` in
     length.
   **Outputs**:
   * ``EMSHA_NULLPTR`` is returned if ``d`` is the null pointer.
   * ``EMSHA_INVALID_STATE`` is returned if the HMAC context is in
     an invalid state, such as if there were errors in previous
     updates.
   * ``EMSHA_ROK`` is returned if the context was successfully
     finalised and the digest copied to ``d``.
 .. cpp:function:: emsha::EMSHA_RESULT SHA256::result(uint8_t *d)
   ``result`` copies the result from the HMAC context into the
   buffer pointed to by ``d``, running finalize if needed. Once
   called, the context cannot be updated until the context is reset.
   **Inputs**:
   * ``d``: a byte buffer that must be at least ``HMAC.size()`` in
     length.
   **Outputs**:
   * ``EMSHA_NULLPTR`` is returned if ``d`` is the null pointer.
   * ``EMSHA_INVALID_STATE`` is returned if the HMAC context is in
     an invalid state, such as if there were errors in previous
     updates.
   * ``EMSHA_ROK`` is returned if the context was successfully
     finalised and the digest copied to ``d``.
 .. cpp:function:: uint32_t SHA256::size(void)
   ``size`` returns the output size of HMAC, e.g.  the size that the
   buffers passed to ``finalize`` and ``result`` should be.
   **Outputs**:
   * a ``uint32_t`` representing the expected size of buffers passed
     to ``result`` and ``finalize``.
--- a/doc/source/index.rst
+++ b/doc/source/index.rst
@ -0,0 +1,27 @@
 .. libemsha documentation master file, created by
   sphinx-quickstart on Tue Dec 15 23:35:10 2015.
   You can adapt this file completely to your liking, but it should at least
   contain the root `toctree` directive.
 libemsha
 ========
 .. toctree::
   :maxdepth: 2
   intro
   building
   overview
   hash
   sha256
   hmac
   misc
   tests
   refs
 Indices and tables
 ==================
 * :ref:`genindex`
--- a/doc/source/intro.rst
+++ b/doc/source/intro.rst
@ -0,0 +1,21 @@
 -------------
 Introduction
 -------------
 This library is an MIT-licensed compact HMAC-SHA-256 C++11 library
 designed for embedded systems. It is built following the JPL `Power of
 Ten <http://spinroot.com/gerard/pdf/P10.pdf>`_ rules.
 This library came about as a result of a need for a standalone
 SHA-256 library for an embedded system. The original goal was
 to implement a wrapper around the code extracted from `RFC 6234
 <https://tools.ietf.org/html/rfc6234>`_; instead a standalone
 implementation was decided on.
 Additional resources:
 + `Github page <https://github.com/kisom/libemsha>`_
 + `Travis CI status <https://travis-ci.org/kisom/libemsha/>`_
 + `Coverity Scan page <https://scan.coverity.com/projects/libemsha-52f2a5fd-e759-43c2-9073-cf6c2ed9abdb>`_
--- a/doc/source/misc.rst
+++ b/doc/source/misc.rst
@ -0,0 +1,107 @@
 -----------------------
 Miscellaneous functions
 -----------------------
 .. cpp:function:: emsha::EMSHA_RESULT sha256_self_test(void)
   If the library was `compiled with support for self tests
   <./building.html>`_ (the default), this function will run a few self
   tests on the SHA-256 functions to validate that they are working
   correctly.
   **Outputs**:
   * ``EMSHA_ROK`` if the self-test completed successfully.
   * ``EMSHA_TEST_FAILURE`` if the SHA-256 functions did not produce
     the expected value.
   * ``EMSHA_SELFTEST_DISABLED`` if the library was built without
     support for the self test.
   * If an error occurs in the SHA-256 code, the resulting error code
     will be returned.
 .. cpp:function:: emsha::EMSHA_RESULT sha256_digest(const uint8_t *m, uint32_t ml, uint8_t *d)
   The ``sha256_digest`` function will compute the digest on the
   ``ml``-byte octet string stored in ``m``, returning the result
   in ``d``. This is a convenience function implemented as: ::
    EMSHA_RESULT
    sha256_digest(const uint8_t *m, uint32_t ml, uint8_t *d)
    {
            SHA256          h;
            EMSHA_RESULT    ret;
            if (EMSHA_ROK != (ret = h.update(m, ml))) {
                    return ret;
            }
            return h.finalize(d);
    }
 .. cpp:function:: emsha::EMSHA_RESULT compute_hmac(const uint8_t *k, uint32_t kl, const uint8_t *m, uint32_t ml, uint8_t *d)
   The ``compute_hmac`` function computes the MAC on the ``ml``-byte
   octet string stored in``m``, using the ``kl``-length key ``k``. The
   result is stored in ``d``. This is a convenience function implemented
   as: ::
    EMSHA_RESULT
    compute_hmac(const uint8_t *k, uint32_t kl, const uint8_t *m, uint32_t ml,
                 uint8_t *d)
    {
            EMSHA_RESULT    res;
            HMAC            h(k, kl);
            res = h.update(m, ml);
            if (EMSHA_ROK != res) {
                    return res;
            }
            res = h.result(d);
            if (EMSHA_ROK != res) {
                    return res;
            }
            return res;
    }
 .. cpp:function:: bool hash_equal(const uint8_t *a, const uint8_t *b)
   ``hash_equal`` performs a constant-time comparison of the first
   ``emsha::SHA256_HASH_SIZE`` bytes in the two byte array arguments.
   **Inputs**:
   * ``a``, ``b``: byte arrays at least ``emsha::SHA256_HASH_SIZE``
     bytes in length.
   ** Outputs**:
   * true *iff* the first ``emsha::SHA256_HASH_SIZE`` bytes match in
     both arrays.
   * false otherwise.
 .. cpp:function::  void hexstring(uint8_t *dest, uint8_t *src, uint32_t srclen)
   **Note**: this function is only present if the library was
   `built with support <./building.html>`_ for the hexstring functionality.
   **Inputs**:
   * dest:   a byte array that is 2 * ``srclen``.
   * src:    a byte array containing the data to process.
   * srclen: the size of ``src``.
   **Outputs**:
   When the function returns, the hex-encoded string will be placed in
   ``dest``.
--- a/doc/source/overview.rst
+++ b/doc/source/overview.rst
@ -0,0 +1,46 @@
 ----------------
 Library Overview
 ----------------
 .. cpp:namespace:: emsha
 The package provides a pair of classes, :cpp:class:`SHA256` and
 :cpp:class:`HMAC`, that both satisfy a common interface :cpp:class:`Hash`. All
 functionality provided by this library is found under the ``emsha`` namespace.
 ``EMSHA_RESULT``
 ^^^^^^^^^^^^^^^^^
 The ``EMSHA_RESULT`` enum is used to convey the result of an
 operation. The possible values are:
 .. cpp:enum:: _EMSHA_RESULT_ : uint8_t
 ::
                // All operations have completed successfully so far.
                EMSHA_ROK = 0,
                // A self test or unit test failed.
                EMSHA_TEST_FAILURE = 1,
                // A null pointer was passed in as a buffer where it
                // shouldn't have been.
                EMSHA_NULLPTR = 2,
                // The Hash is in an invalid state.
                EMSHA_INVALID_STATE = 3,
                // The input to SHA256::update is too large.
                SHA256_INPUT_TOO_LONG = 4,
                // The self tests have been disabled, but a self test
                // function was called.
                EMSHA_SELFTEST_DISABLED = 5
 As a convenience, the following ``typedef`` is also provided.
 ``typedef enum _EMSHA_RESULT_`` :cpp:type:`EMSHA_RESULT`
--- a/doc/source/refs.rst
+++ b/doc/source/refs.rst
@ -0,0 +1,17 @@
 ----------
 References
 ----------
 * `FIPS 180-4, the Secure Hash Standard <http://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf>`_
 * `FIPS 198-1, The Keyed-Hash Message Authentication Code (HMAC) <http://csrc.nist.gov/publications/fips/fips198-1/FIPS-198-1_final.pdf>`_
 * `RFC 2014, HMAC: Keyed-Hashing for Message Authentication <https://tools.ietf.org/html/rfc2104>`_
 * `RFC 6234, US Secure Hash Algorithms (SHA and SHA-based HMAC and HKDF) <https://tools.ietf.org/html/rfc6234>`_\ [#f1]_
 * The behaviour of this package was cross-checked using the Go 1.5.1
  linux/amd64 standard library's `crypto/sha256 <https://golang.org/src/crypto/sha256/>`_
  package.
 .. rubric:: Footnotes
 .. [#f1] This library came about after extracting the relevant C code
         from RFC 6234, and needing a C++ version. It draws heavy
         inspiration from that code base.
--- a/doc/source/sha256.rst
+++ b/doc/source/sha256.rst
@ -0,0 +1,112 @@
 -----------------
 The SHA256 class
 -----------------
 .. cpp:class:: emsha::SHA256
   SHA256 is an implementation of the :cpp:class:`emsha::Hash` interface
   implementing the SHA-256 cryptographic hash algorithm
 .. cpp:function:: SHA256::SHA256()
   A SHA256 context does not need any special construction. It can be
   declared and immediately start being used.
 .. cpp:function:: SHA256::~SHA256()
   The SHA256 destructor will clear out its internal message buffer;
   all of the members are local and not resource handles, so cleanup
   is minimal.
 .. cpp:function:: emsha::EMSHA_RESULT SHA256::reset(void)
   reset clears the internal state of the `SHA256` context and returns
   it to its initial state.  It should always return ``EMSHA_ROK``.
 .. cpp:function:: emsha::EMSHA_RESULT SHA256::update(const uint8_t *m, uint32_t ml)
   update writes data into the context. While there is an upper limit
   on the size of data that SHA-256 can operate on, this package is
   designed for small systems that will not approach that level of
   data (which is on the order of 2 exabytes), so it is not thought to
   be a concern.
   **Inputs**:
   + ``m``: a byte array containing the message to be written. It must
     not be NULL (unless the message length is zero).
   + ``ml``: the message length, in bytes.
   **Return values**:
   * ``EMSHA_NULLPTR`` is returned if ``m`` is NULL and ``ml`` is nonzero.
   * ``EMSHA_INVALID_STATE`` is returned if the `update` is called 
     after a call to `finalize`.
   * ``SHA256_INPUT_TOO_LONG`` is returned if too much data has been
     written to the context.
   + ``EMSHA_ROK`` is returned if the data was successfully added to
     the SHA-256 context.
 .. cpp:function:: emsha::EMSHA_RESULT SHA256::finalize(uint8_t *d)
   ``finalize`` completes the digest. Once this method is called, the
   context cannot be updated unless the context is reset.
   **Inputs**:
   * d: a byte buffer that must be at least ``SHA256.size()`` in
     length.
   **Outputs**:
   * ``EMSHA_NULLPTR`` is returned if ``d`` is the null pointer.
   * ``EMSHA_INVALID_STATE`` is returned if the SHA-256 context is in
     an invalid state, such as if there were errors in previous
     updates.
   * ``EMSHA_ROK`` is returned if the context was successfully
     finalised and the digest copied to ``d``.
 .. cpp:function:: emsha::EMSHA_RESULT SHA256::result(uint8_t *d)
   ``result`` copies the result from the SHA-256 context into the
   buffer pointed to by ``d``, running finalize if needed. Once
   called, the context cannot be updated until the context is reset.
   **Inputs**:
   * ``d``: a byte buffer that must be at least ``SHA256.size()`` in
     length.
   **Outputs**:
   * ``EMSHA_NULLPTR`` is returned if ``d`` is the null pointer.
   * ``EMSHA_INVALID_STATE`` is returned if the SHA-256 context is in
     an invalid state, such as if there were errors in previous
     updates.
   * ``EMSHA_ROK`` is returned if the context was successfully
     finalised and the digest copied to ``d``.
 .. cpp:function:: uint32_t SHA256::size(void)
   ``size`` returns the output size of SHA256, e.g.
   the size that the buffers passed to ``finalize``
   and ``result`` should be.
   **Outputs**:
   * a ``uint32_t`` representing the expected size of buffers passed
     to ``result`` and ``finalize``.
--- a/doc/source/tests.rst
+++ b/doc/source/tests.rst
@ -0,0 +1,50 @@
 -------------
 Test Programs
 -------------
 Running ``make check`` builds and runs the test programs. These are:
 * ``emsha_core_test`` runs the core tests.
 * ``emsha_sha256_test`` runs test vectors on the SHA-256 code.
 * ``emsha_hmac_test`` runs test vectors on the HMAC code.
 Additionally, the following test programs are built but not run. These
 programs do not link with the library as the above programs do; instead,
 they compile the object files in to avoid the libtool dance before the
 library is installed.
 * ``emsha_mem_test`` and ``emsha_static_mem_test`` are for memory
  profiling (e.g., with `Valgrind <http://valgrind.org/>`_ during
  development.
 * ``emsha_static_sha256_test`` and ``emsha_static_hmac_test`` are used
  to facilitate testing and debugging the library. These programs run
  the same tests as the ``emsha_sha256_test`` and ``emsha_hmac_test``
  programs.
 Core Tests
 ^^^^^^^^^^
 There are three tests run in the core tests: a hexstring test (if
 `support is built in <./building.html>`_) and the constant time
 check. The constant time test does not validate that the function
 is constant time, only that it correctly verifies that two byte
 arrays are equal.
 SHA-256 Tests
 ^^^^^^^^^^^^^
 The SHA-256 checks take a number of test vectors from the Go standard
 library's SHA-256 library.
 HMAC Tests
 ^^^^^^^^^^
 The HMAC checks apply the `RFC 4231 <http://tools.ietf.org/html/rfc4231>`_
 test vectors to the HMAC code.
--- a/emsha.pc.in
+++ b/emsha.pc.in
@ -1,10 +0,0 @@
 prefix=@CMAKE_INSTALL_PREFIX@
 exec_prefix=${prefix}
 libdir=${prefix}/lib
 includedir=${prefix}/include
 Name: @PROJECT_NAME@
 Description: C++11 HMAC-SHA256 library
 URL: https://git.wntrmute.dev/kyle/emsha
 Version: @PROJECT_VERSION@
 Libs: -L${libdir} -lemsha
--- a/include/emsha/emsha.h
+++ b/include/emsha/emsha.h
@ -1,198 +0,0 @@
 ///
 /// \file emsha/emsha.h
 /// \author K. Isom <kyle@imap.cc>
 /// \date 2015-12-17
 /// \brief Declares an interface for an EMbedded Secure HAshing interface.
 /// 
 /// The MIT License (MIT)
 /// 
 /// Copyright (c) 2015 K. Isom <coder@kyleisom.net>
 /// 
 /// Permission is hereby granted, free of charge, to any person obtaining a copy
 /// copy of this  software and associated documentation  files (the "Software"),
 /// to deal  in the Software  without restriction, including  without limitation
 /// the rights  to use,  copy, modify,  merge, publish,  distribute, sublicense,
 /// and/or  sell copies  of the  Software,  and to  permit persons  to whom  the
 /// Software is furnished to do so, subject to the following conditions:
 /// 
 /// The above copyright notice and this permission notice shall be included in
 /// all copies or substantial portions of the Software.
 /// 
 /// THE SOFTWARE IS  PROVIDED "AS IS", WITHOUT WARRANTY OF  ANY KIND, EXPRESS OR
 /// IMPLIED, INCLUDING  BUT NOT  LIMITED TO  THE WARRANTIES  OF MERCHANTABILITY,
 /// FITNESS FOR A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT SHALL THE
 /// AUTHORS  OR COPYRIGHT  HOLDERS BE  LIABLE FOR  ANY CLAIM,  DAMAGES OR  OTHER
 /// LIABILITY,  WHETHER IN  AN ACTION  OF CONTRACT,  TORT OR  OTHERWISE, ARISING
 /// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 /// IN THE SOFTWARE.
 /// 
 #ifndef EMSHA_EMSHA_H
 #define EMSHA_EMSHA_H
 #include <cstdint>
 // emsha is an EMbedded Secure HAshing interface.
 namespace emsha {
 #ifdef NDEBUG
 /// EMSHA_CHECK is used for sanity checks in certain parts of
 /// the code. If asserts are turned off, expand the check to an
 /// if statement that will return with retval if the condition
 /// isn't met.
 #define EMSHA_CHECK(condition, retval) if (!(condition)) { return (retval); }
 #else
 /// EMSHA_CHECK is used for sanity checks in certain parts of
 /// the code. If asserts are turned on, the check is expanded to
 /// an assertion that the condition holds. In this case, retval
 /// is not used.
 #define        EMSHA_CHECK(condition, retval) (assert((condition)))
 #endif
 /// SHA256_HASH_SIZE is the output length of SHA-256 in bytes.
 const std::uint32_t SHA256_HASH_SIZE = 32U;
 /// \brief Describe the result of an EMSHA operation.
 ///
 /// The EMSHAResult type is used to indicate whether an operation
 /// succeeded, and if not, what the general fault type was.
 enum class EMSHAResult : std::uint8_t {
 	/// An unknown fault occurred. This is a serious bug in the
 	/// program.
 	Unknown = 0U,
 	/// All operations have completed successfully so far.
 	OK = 1U,
 	/// The self-test failed.
 	TestFailure = 2U,
 	/// A null pointer was passed in as a buffer where it shouldn't
 	/// have been.
 	NullPointer = 3U,
 	/// The Hash is in an invalid state.
 	InvalidState = 4U,
 	/// The input to SHA256::update is too large.
 	InputTooLong = 5U,
 	/// The self tests have been disabled, but a self-test function
 	/// was called.
 	SelfTestDisabled = 6U
 } ;
 /// A Hash is an abstract base class supporting concrete classes
 /// that produce digests of data.
 class Hash {
 public:
 	virtual ~Hash() = default;
 	/// \brief Bring the Hash back to its initial state.
 	///
 	/// That is, the idea is that
 	///
 	/// ```
 	///     hash->reset();
 	///	hash->update(...);
 	///     hash->result(...);
 	/// ```
 	///
 	/// is idempotent, assuming the inputs to update
 	/// and result are constant. The implications of
 	/// this for a given concrete class should be
 	/// described in that class's documentation, but
 	/// in general, it has the effect of preserving
 	/// any initial state while removing any data
 	/// written to the Hash via the update method.
 	///
 	/// \return An ::EMSHAResult describing the status of the
 	///         operation.
 	virtual EMSHAResult Reset() = 0;
 	/// \brief Write message data into the Hash.
 	///
 	/// \param message The message data to write into the Hash.
 	/// \param messageLength The length of the message data.
 	/// \return An ::EMSHAResult describing the status of the
 	///         operation.
 	virtual EMSHAResult Update(const std::uint8_t *message,
 				   std::uint32_t messageLength) = 0;
 	/// \brief Carry out any final operations on the Hash.
 	///
 	/// After a call to finalize, no more data can be written.
 	/// Additionally, it transfers out the resulting hash into its
 	/// argument.
 	///
 	/// \param digest The buffer to store the hash in.
 	/// \return An ::EMSHAResult describing the status of the
 	///         operation.
 	virtual EMSHAResult Finalise(std::uint8_t *digest) = 0;
 	/// \brief Result transfers out the hash to the argument.
 	///
 	/// The Hash must keep enough state for repeated calls to
 	/// result to work.
 	///
 	/// \param digest The buffer to store the hash in.
 	/// \return An ::EMSHAResult describing the status of the
 	///         operation.
 	virtual EMSHAResult Result(std::uint8_t *digest) = 0;
 	/// \brief Return the output size of the Hash.
 	///
 	/// This is how large the buffers written to by result should
 	/// be.
 	virtual std::uint32_t Size() = 0;
 };
 /// \brief Constant-time function for comparing two digests.
 ///
 /// HashEqual provides a constant time function for comparing two
 /// digests. The caller *must* ensure that both a and b are the same
 /// size. The recommended approach is to use fixed-size buffers of
 /// emsha::SHA256_HASH_SIZE length:
 ///
 /// ```c++
 /// uint8_t	expected[emsha::SHA256_HASH_SIZE];
 /// uint8_t	actual[emsha::SHA256_HASH_SIZE];
 ///
 /// // Fill in expected and actual using the Hash operations.
 ///
 /// if (hash_equal(expected, actual)) {
 ///         proceed();
 /// }
 /// ```
 ///
 /// \param a A byte buffer of size Hash::Size().
 /// \param b A byte buffer of size Hash::Size().
 /// \return True if both byte arrays match.
 bool		HashEqual(const std::uint8_t *a, const std::uint8_t *b);
 #ifndef EMSHA_NO_HEXSTRING
 /// \brief Write a hex-encoded version of a byte string.
 ///
 /// HexString writes a hex-encoded version of the src byte array into
 /// dest. The caller **must** ensure that dest is `srclen * 2` bytes
 /// or longer.
 ///
 /// \param dest The destination byte array at least (`2*srclen`)
 ///        bytes in length.
 /// \param src  A byte array containing the data to hexify.
 /// \param srclen The size in bytes of src.
 void HexString(std::uint8_t *dest, std::uint8_t *src, std::uint32_t srclen);
 #endif // EMSHA_NO_HEXSTRING
 } // end of namespace emsha
 #endif // EMSHA_EMSHA_H
--- a/include/emsha/hmac.h
+++ b/include/emsha/hmac.h
@ -1,180 +0,0 @@
 ///
 /// \file emsha/hmac.h
 /// \author K. Isom <kyle@imap.cc>
 /// \date 2015-12-17
 /// \brief Declares an interface for HMAC tagging.
 /// 
 /// The MIT License (MIT)
 /// 
 /// Copyright (c) 2015 K. Isom <coder@kyleisom.net>
 /// 
 /// Permission is hereby granted, free of charge, to any person obtaining a copy
 /// copy of this  software and associated documentation  files (the "Software"),
 /// to deal  in the Software  without restriction, including  without limitation
 /// the rights  to use,  copy, modify,  merge, publish,  distribute, sublicense,
 /// and/or  sell copies  of the  Software,  and to  permit persons  to whom  the
 /// Software is furnished to do so, subject to the following conditions:
 /// 
 /// The above copyright notice and this permission notice shall be included in
 /// all copies or substantial portions of the Software.
 /// 
 /// THE SOFTWARE IS  PROVIDED "AS IS", WITHOUT WARRANTY OF  ANY KIND, EXPRESS OR
 /// IMPLIED, INCLUDING  BUT NOT  LIMITED TO  THE WARRANTIES  OF MERCHANTABILITY,
 /// FITNESS FOR A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT SHALL THE
 /// AUTHORS  OR COPYRIGHT  HOLDERS BE  LIABLE FOR  ANY CLAIM,  DAMAGES OR  OTHER
 /// LIABILITY,  WHETHER IN  AN ACTION  OF CONTRACT,  TORT OR  OTHERWISE, ARISING
 /// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 /// IN THE SOFTWARE.
 /// 
 #ifndef EMSHA_HMAC_H
 #define EMSHA_HMAC_H
 #include <cstdint>
 #include "emsha.h"
 #include "sha256.h"
 namespace emsha {
 const uint32_t HMAC_KEY_LENGTH = SHA256_MB_SIZE;
 /// HMAC is a keyed hash that can be used to produce an
 /// authenticated hash of some data. The HMAC is built on
 /// (and uses internally) the SHA256 class; it's helpful to
 /// note that faults that occur in the SHA-256 code will be
 /// propagated up as the return value from many of the HMAC
 /// functions.
 class HMAC : Hash {
 public:
 	/// \brief Construct an HMAC with its initial key.
 	///
 	/// An HMAC is constructed with a key and the length of the
 	/// key. This key is stored in the HMAC context, and is wiped
 	/// by the HMAC destructor.
 	///
 	/// \param k The HMAC key.
 	/// \param kl THe length of the HMAC key.
 	HMAC(const uint8_t *k, uint32_t kl);
 	/// \brief Clear any data written to the HMAC.
 	///
 	/// This is equivalent to constructing a new HMAC, but it
 	/// preserves the keys.
 	///
 	/// \return EMSHAResult::OK is returned if the reset occurred
 	/// 	    without (detected) fault. If a fault occurs with
 	///	    the underlying SHA256 context, the error code is
 	///	    returned.
 	EMSHAResult Reset() override;
 	/// \brief Write data into the context.
 	///
 	/// While there is an upper limit on the size of data that the
 	/// underlying hash can operate on, this package is designed
 	/// for small systems that will not approach that level of data
 	/// (which is on the order of 2 exabytes), so it is not a
 	/// concern for this library.
 	///
 	/// \param message A byte array containing the message
 	///	     to be written.
 	/// \param messageLength The message length, in bytes.
 	/// \return An ::EMSHAResult describing the result of the
 	///         operation.
 	///
 	///        - EMSHAResult::NullPointer is returned if m is NULL
 	///          and ml is nonzero.
 	///        - EMSHAResult::InvalidState is returned if the
 	///          update is called after a call to finalize.
 	///        - EMSHAResult::InputTooLong is returned if too much
 	///          data has been written to the context.
 	///        - EMSHAResult::OK is returned if the data was
 	///          successfully written into the HMAC context.
 	EMSHAResult Update(const std::uint8_t *message, std::uint32_t messageLength) override;
 	/// \brief Complete the HMAC computation.
 	///
 	/// \note Once #Finalise is called, the context cannot be
 	///       updated unless the context is reset.
 	///
 	/// \param digest A byte buffer that must be at least
 	///        #Size() in length.
 	/// \return An EMSHAResult describing the result of this
 	///         method:
 	///
 	///         - EMSHAResult::NullPointer is returned if d is a
 	///           null pointer.
 	///         - EMSHAResult::InvalidState is returned if the HMAC
 	///           context is in an invalid state, such as if there
 	///           were errors in previous updates.
 	///         - EMSHAResult::OK is returned if the context was
 	///           successfully finalised and the digest copied to d.
 	///
 	EMSHAResult Finalise(std::uint8_t *digest) override;
 	/// \brief Copy the current digest into a destination buffer.
 	///
 	/// Copy the current digest from the HMAC context into
 	/// `digest`, running #Finalise if needed. Once called, the
 	/// context cannot be updated until the context is reset.
 	///
 	/// \param digest A byte buffer that must be at least
 	///        #Size() in length.
 	/// \return An ::EMSHAResult describing the result of this
 	///         method:
 	///
 	///         - EMSHAResult::NullPointer is returned if d is a
 	///           null pointer.
 	///         - EMSHAResult::InvalidState is returned if the HMAC
 	///           context is in an invalid state, such as if there
 	///           were errors in previous updates.
 	///         - EMSHAResult::OK is returned if the context was
 	///           successfully finalised and the digest copied to d.
 	EMSHAResult Result(std::uint8_t *digest) override;
 	/// \brief Returns the output size of HMAC-SHA-256.
 	///
 	/// The buffers passed to #Update and #Finalise should be at
 	/// least this size.
 	///
 	/// \return The expected size of buffers passed to result and
 	///         finalize.
 	std::uint32_t Size() override;
 	/// When an HMAC context is destroyed, it is reset and
 	/// the key material is zeroised using the STL `fill`
 	/// function.
 	~HMAC();
 private:
 	uint8_t hstate;
 	SHA256  ctx;
 	uint8_t k[HMAC_KEY_LENGTH];
 	uint8_t	buf[SHA256_HASH_SIZE];
 	EMSHAResult 		reset();
 	inline EMSHAResult	finalResult(uint8_t *d);
 };
 /// \brief Perform a single-pass HMAC computation over a message.
 ///
 /// \param k A byte buffer containing the HMAC key.
 /// \param kl The length of the HMAC key.
 /// \param m The message data over which the HMAC is to be computed.
 /// \param ml The length of the message.
 /// \param d Byte buffer that will be used to store the resulting
 ///          HMAC. It should be emsha::SHA256_HASH_SIZE bytes in size.
 /// \return An ::EMSHAResult describing the result of the HMAC operation.
 EMSHAResult
 ComputeHMAC(const uint8_t *k, const uint32_t kl,
 	    const uint8_t *m, const uint32_t ml,
 	    uint8_t *d);
 } // end of namespace emsha
 #endif // EMSHA_HMAC_H
--- a/include/emsha/internal.h
+++ b/include/emsha/internal.h
@ -1,96 +0,0 @@
 ///
 /// \file emsha/internal.h
 /// \author K. Isom <kyle@imap.cc>
 /// \date 2015-12-17
 /// \brief Declares internal interfaces for the emsha library.
 /// 
 /// The MIT License (MIT)
 /// 
 /// Copyright (c) 2015 K. Isom <coder@kyleisom.net>
 /// 
 /// Permission is hereby granted, free of charge, to any person obtaining a copy
 /// copy of this  software and associated documentation  files (the "Software"),
 /// to deal  in the Software  without restriction, including  without limitation
 /// the rights  to use,  copy, modify,  merge, publish,  distribute, sublicense,
 /// and/or  sell copies  of the  Software,  and to  permit persons  to whom  the
 /// Software is furnished to do so, subject to the following conditions:
 /// 
 /// The above copyright notice and this permission notice shall be included in
 /// all copies or substantial portions of the Software.
 /// 
 /// THE SOFTWARE IS  PROVIDED "AS IS", WITHOUT WARRANTY OF  ANY KIND, EXPRESS OR
 /// IMPLIED, INCLUDING  BUT NOT  LIMITED TO  THE WARRANTIES  OF MERCHANTABILITY,
 /// FITNESS FOR A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT SHALL THE
 /// AUTHORS  OR COPYRIGHT  HOLDERS BE  LIABLE FOR  ANY CLAIM,  DAMAGES OR  OTHER
 /// LIABILITY,  WHETHER IN  AN ACTION  OF CONTRACT,  TORT OR  OTHERWISE, ARISING
 /// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 /// IN THE SOFTWARE.
 /// 
 #ifndef EMSHA_INTERNAL_H
 #define EMSHA_INTERNAL_H
 #include <cstdint>
 using std::uint8_t;
 using std::uint32_t;
 namespace emsha {
 static inline uint32_t
 rotr32(uint32_t x, uint8_t n)
 {
 	return ((x >> n) | (x << (32 - n)));
 }
 static inline uint32_t
 sha_ch(uint32_t x, uint32_t y, uint32_t z)
 {
 	return ((x & y) ^ ((~x) & z));
 }
 static inline uint32_t
 sha_maj(uint32_t x, uint32_t y, uint32_t z)
 {
 	return (x & y) ^ (x & z) ^ (y & z);
 }
 static inline uint32_t
 sha_Sigma0(uint32_t x)
 {
 	return rotr32(x, 2) ^ rotr32(x, 13) ^ rotr32(x, 22);
 }
 static inline uint32_t
 sha_Sigma1(uint32_t x)
 {
 	return rotr32(x, 6) ^ rotr32(x, 11) ^ rotr32(x, 25);
 }
 static inline uint32_t
 sha_sigma0(uint32_t x)
 {
 	return rotr32(x, 7) ^ rotr32(x, 18) ^ (x >> 3);
 }
 static inline uint32_t
 sha_sigma1(uint32_t x)
 {
 	return rotr32(x, 17) ^ rotr32(x, 19) ^ (x >> 10);
 }
 } // end of namespace emsha
 #endif	// EMSHA_INTERNAL_H
--- a/include/emsha/sha256.h
+++ b/include/emsha/sha256.h
@ -1,194 +0,0 @@
 ///
 /// \file emsha/sha256.h
 /// \author K. Isom <kyle@imap.cc>
 /// \date 2015-12-17
 /// \brief Declares an interface for producing SHA-256 hashes.
 /// 
 /// The MIT License (MIT)
 /// 
 /// Copyright (c) 2015 K. Isom <coder@kyleisom.net>
 /// 
 /// Permission is hereby granted, free of charge, to any person obtaining a copy
 /// copy of this  software and associated documentation  files (the "Software"),
 /// to deal  in the Software  without restriction, including  without limitation
 /// the rights  to use,  copy, modify,  merge, publish,  distribute, sublicense,
 /// and/or  sell copies  of the  Software,  and to  permit persons  to whom  the
 /// Software is furnished to do so, subject to the following conditions:
 /// 
 /// The above copyright notice and this permission notice shall be included in
 /// all copies or substantial portions of the Software.
 /// 
 /// THE SOFTWARE IS  PROVIDED "AS IS", WITHOUT WARRANTY OF  ANY KIND, EXPRESS OR
 /// IMPLIED, INCLUDING  BUT NOT  LIMITED TO  THE WARRANTIES  OF MERCHANTABILITY,
 /// FITNESS FOR A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT SHALL THE
 /// AUTHORS  OR COPYRIGHT  HOLDERS BE  LIABLE FOR  ANY CLAIM,  DAMAGES OR  OTHER
 /// LIABILITY,  WHETHER IN  AN ACTION  OF CONTRACT,  TORT OR  OTHERWISE, ARISING
 /// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 /// IN THE SOFTWARE.
 /// 
 #ifndef EMSHA_SHA256_H
 #define EMSHA_SHA256_H
 #include <cstdint>
 #include <array>
 #include <emsha/emsha.h>
 namespace emsha {
 /// SHA256_MB_SIZE is the size of a message block.
 const uint32_t SHA256_MB_SIZE = 64;
 class SHA256 : Hash {
 public:
 	/// \brief A SHA256 context does not need any special
 	///        construction.
 	///
 	/// It can be declared and immediately start being used.
 	SHA256();
 	/// The SHA256 destructor will clear out its internal
 	/// message buffer; all the members are local and
 	/// not resource handles, so cleanup is minimal.
 	~SHA256();
 	/// \brief Clear the internal state of the SHA256 context,
 	///        returning it to its initial state.
 	///
 	/// \return This should always return EMSHAResult::OK.
 	EMSHAResult Reset() override;
 	/// \brief Writes data into the SHA256.
 	///
 	/// While there is an upper limit on the size of data that
 	/// SHA-256 can operate on, this package is designed for small
 	/// systems that will not approach that level of data (which is
 	/// on the order of 2 exabytes), so it is not thought to be a
 	/// concern.
 	///
 	/// \param message A byte array containing the message to be
 	///                written. It must not be NULL (unless the
 	///                message length is zero).
 	/// \param messageLength The message length, in bytes.
 	/// \return An ::EMSHAResult describing the result of the
 	///         operation.
 	///
 	///         - EMSHAResult::NullPointer is returned if m is a
 	///           nullptr and ml is nonzero.
 	///         - EMSHAResult::InvalidState is returned if the
 	///           update is called after a call to finalize.
 	///         - EMSHAResult::InputTooLong is returned if too much
 	///           data has been written to the context.
 	///         - EMSHAResult::OK is returned if the data was
 	///           successfully added to the SHA-256 context.
 	EMSHAResult Update(const std::uint8_t *message, std::uint32_t messageLength) override;
 	/// \brief Complete the digest.
 	///
 	/// Once this method is called, the context cannot be updated
 	/// unless the context is reset.
 	///
 	/// \param digest byte buffer that must be at least
 	///               SHA256.size() in length.
 	/// \return An ::EMSHAResult describing the result of the
 	///         operation.
 	///
 	///         - EMSHAResult::NullPointer is returned if a nullptr
 	///           is passed in.
 	///         - EMSHAResult::InvalidState is returned if the
 	///           SHA-256 context is in an invalid state, such as
 	///           if there were errors in previous updates.
 	///         - EMSHAResult::OK is returned if the context was
 	///           successfully finalised and the digest copied to
 	///           digest.
 	EMSHAResult Finalise(std::uint8_t *digest) override;
 	/// \brief Copy the result from the SHA-256
 	/// context into the buffer pointed to by d,
 	/// running #Finalise if needed. Once called,
 	/// the context cannot be updated until the
 	/// context is reset.
 	///
 	/// \param digest A byte buffer that must be at least
 	///               SHA256.size() in length.
 	/// \return An ::EMSHAResult describing the result of the
 	///         operation.
 	///
 	///         - EMSHAResult::NullPointer is returned if a nullptr
 	///           is passed in.
 	///         - EMSHAResult::InvalidState is returned if the
 	///           SHA-256 context is in an invalid state, such as
 	///           if there were errors in previous updates.
 	///         - EMSHAResult::OK is returned if the context was
 	///           successfully finalised and the digest copied to
 	///           digest.
 	EMSHAResult Result(std::uint8_t *digest) override;
 	/// \brief Returns the output size of SHA-256.
 	///
 	/// The buffers passed to #Update and #Finalise should be at
 	/// least this size.
 	///
 	/// \return The expected size of buffers passed to result and
 	///         finalize.
 	std::uint32_t Size() override;
 private:
 	uint64_t mlen; // Current message length.
 	uint32_t i_hash[8]; // The intermediate hash is 8x 32-bit blocks.
 	// hStatus is the hash status, and hComplete indicates
 	// whether the hash has been finalised.
 	EMSHAResult hStatus;
 	uint8_t     hComplete;
 	// mb is the message block, and mbi is the message
 	// block index.
 	uint8_t mbi;
 	std::array<uint8_t, SHA256_MB_SIZE> mb;
 	inline EMSHAResult	addLength(const uint32_t);
 	inline void  		updateMessageBlock(void);
 	inline void  		padMessage(uint8_t pc);
 	uint32_t     		chunkToUint32(uint32_t offset);
 	uint32_t     		uint32ToChunk(uint32_t offset);
 	EMSHAResult		reset();
 }; // end class SHA256
 /// \brief SHA256Digest performs a single pass hashing of the message
 ///        passed in.
 ///
 /// \param m Byte buffer containing the message to hash.
 /// \param ml The length of m.
 /// \param d Byte buffer that will be used to store the resulting hash;
 ///          it should have at least emsha::SHA256_HASH_SIZE bytes
 ///          available.
 /// \return An ::EMSHAResult describing the result of the operation.
 EMSHAResult SHA256Digest(const uint8_t *m, uint32_t ml, uint8_t *d);
 /// \brief SHA256SelfTest runs through two test cases to ensure that the
 ///        SHA-256 functions are working correctly.
 ///
 /// \return The result of the self-test.
 ///
 ///         - EMSHAResult::OK is returned if the self tests pass.
 ///         - EMSHAResult::SelfTestDisabled is returned if the self
 ///           tests have been disabled (e.g., libemsha was compiled
 ///           with the EMSHA_NO_SELFTEST #define).
 ///         - If a fault occurred inside the SHA-256 code, the error
 ///           code from one of the update, finalize, result, or reset
 ///           methods is returned.
 ///         - If the fault is that the output does not match the test
 ///           vector, EMSHAResult::TestFailure is returned.
 EMSHAResult SHA256SelfTest();
 } // end of namespace emsha
 #endif // EMSHA_SHA256_H
--- a/scripts/check-code.sh
+++ b/scripts/check-code.sh
@ -1,68 +0,0 @@
 #!/usr/bin/env sh
 ######################################################################
 # @author      : kyle (kyle@midgard)
 # @file        : check-code
 # @created     : Tuesday Oct 17, 2023 22:39:39 PDT
 #
 # @description : 
 ######################################################################
 run_clang_tidy () {
 	sources="${1:-*.cc}"
 	echo "[+] clang-tidy ${sources}"
 	if [ ! -e compile_commands.json ]
 	then
 		echo "[!] compile_commands.json not found" > /dev/stderr
 		candidate=$(find -name compile_commands.json | head)
 		if [ -z "${candidates}" ]
 		then
 			echo "[!] no suitable candidates found; can't proceed" > /dev/stderr
 			exit 1
 		fi
 		echo "[+] compile_commands.json candidate: $candidate"
 		ln -s ${candidate} .
 		echo "[+] if this isn't correct, you will need to manually link it"
 	fi
 	clang-tidy ${sources}
 }
 run_cppcheck () {
 	sources="${1:-*.cc}"
 	echo "[+] cppcheck ${sources}"
 	cppcheck  --enable=all --suppress=unusedFunction --suppress=missingIncludeSystem -I. ${sources}
 }
 run_trunk () {
 	sources="${1:-}"
 	echo "[+] trunk check ${sources}"
 	trunk check --filter clang-tidy ${sources}
 }
 main () {
 	command="${1:-usage}"
 	shift
 	case ${command} in
 		clang-tidy)	run_clang_tidy $@ ;;
 		cppcheck)	run_cppcheck $@ ;;
 		trunk)		run_trunk $@ ;;
 		*)
 			echo "[!] scanner ${command} isn't supported" > /dev/stderr
 			exit 1
 			;;
 	esac
 }
 main $@
--- a/scripts/install-cmake-debian.sh
+++ b/scripts/install-cmake-debian.sh
@ -1,50 +0,0 @@
 #!/usr/bin/env bash
 set -eu
 source /etc/lsb-release
 SUDO="sudo"
 USE_CMAKE_RC="${USE_CMAKE_RC:-}"
 preinstall () {
 	echo "[+] preparing to install"
  if [ "$(whoami)" == "root" ]
  then
    SUDO=
  fi
 	$SUDO apt-get -y update
 	$SUDO apt-get -y install ca-certificates gpg wget
 }
 do_install () {
 	if [ ! -f /etc/apt/sources.list.d/kitware.list ]
 	then
 		echo "[+] fetching initial keyring"
 		wget -O - https://apt.kitware.com/keys/kitware-archive-latest.asc 2>/dev/null | gpg --dearmor - | $SUDO tee /usr/share/keyrings/kitware-archive-keyring.gpg >/dev/null
 		echo "[+] adding repo to sources.list.d"
 		echo "deb [signed-by=/usr/share/keyrings/kitware-archive-keyring.gpg] https://apt.kitware.com/ubuntu/ ${DISTRIB_CODENAME} main" | \
 			$SUDO tee /etc/apt/sources.list.d/kitware.list >/dev/null
 					$SUDO apt-get -y update
 					echo "[+] installing kitware keyring"
 					if [ -f "/usr/share/keyrings/kitware-archive-keyring.gpg" ]
 					then
 						$SUDO rm /usr/share/keyrings/kitware-archive-keyring.gpg
 					fi
 					$SUDO apt-get -y install kitware-archive-keyring
 	fi
 	if [ "${USE_CMAKE_RC}" = "YES" ]
 	then
 		echo 'deb [signed-by=/usr/share/keyrings/kitware-archive-keyring.gpg] https://apt.kitware.com/ubuntu/ ${DISTRIB_RELEASE}-rc main' | \
 			$SUDO tee -a /etc/apt/sources.list.d/kitware.list >/dev/null
 					$SUDO apt-get update
 	fi
 }
 preinstall
 do_install
 $SUDO apt-get install -y cmake
--- a/scripts/install-depdendencies.sh
+++ b/scripts/install-depdendencies.sh
@ -1,91 +0,0 @@
 #!/usr/bin/env bash
 #####################################################################
 # This script attempts to install the appopriate build dependencies #
 # for the host system.                                              #
 #                                                                   #
 # This is primarily developed on the latest Ubuntu LTS release and  #
 # MacOS; other platforms are not supported.                         #
 #####################################################################
 set -eu
 AUTOMATED_MODE=${AUTOMATED_MODE:-}
 install_debianesque () {
 	APTARGS=""
 	SUDO="sudo"
 	if [ "$(whoami)" == "root" ]
 	then
 	  SUDO=
  fi
 	if [ ! -z "${AUTOMATED_MODE}" ]
 	then
 		APTARGS="-y"
 	fi
 	echo "[+] distribution is ${DISTRIB_ID}, choosing Debianesque install."
 	if [ -z "$(command -v cmake)" ]
 	then
 		./scripts/install-cmake-debian.sh
  fi
 	echo "[+] installing tools"
 	sudo $SUDO apt-get $APTARGS install git clang scdoc python3-pip doxygen graphviz
 }
 install_unsupported () {
 	echo "[+] distribution is ${DISTRIB_ID}, choosing Redhat install."
 	echo "[!] This distribution is unsupported." > /dev/stderr
 	exit 1;
 }
 install_macos () {
 	# TODO: consider supporting macports?
 	echo "[+] host system is MacOS"
 	echo "[+] installing tools"
 	brew install git cmake scdoc
 	echo "[+] installing libraries and development headers"
 	# TODO: look up proper package names in homebrew
 }
 install_linux () {
  DISTRIB_ID="${DISTRIB_ID:-}"
 	echo "[+] host system is Linux"
 	[[ -f "/etc/lsb-release" ]] && source /etc/lsb-release
 	[[ -f "/etc/rpi-issue" ]] && DISTRIB_ID=apt-based
 	if [ -z "${DISTRIB_ID}" ]
 	then
 		if [ -d /etc/apt ]
 		then
 			DISTRIB_ID="apt-based"
 		else
 			DISTRIB_ID="unsupported/unknown"
 		fi
 	fi
 	case ${DISTRIB_ID} in
 		Ubuntu)		install_debianesque ;;
 		Debian)		install_debianesque ;;
 		apt-based)	install_debianesque ;;
 		*)
 			echo "[!] distribution ${DISTRIB_ID} isn't supported in this script." > /dev/null
 			;;
 	esac
 }
 case "$(uname -s)" in
 	Linux)		install_linux ;;
 	Darwin)		install_macos ;;
 	*)
 		echo "[!] platform $(uname -s) isn't supported in this script." > /dev/null
 		;;
 esac
--- a/scripts/setup-cmake.sh
+++ b/scripts/setup-cmake.sh
@ -1,14 +0,0 @@
 #!/usr/bin/env bash
 ######################################################################
 # @author      : kyle (kyleimap.cc)
 # @file        : setup-cmake
 # @created     : Wednesday Oct 18, 2023 04:24:21 PDT
 #
 # @description : Prepare a CMake build environment, build, and test.
 ######################################################################
 set -eux
 mkdir -p build && cd build
 cmake -DCMAKE_BUILD_TYPE=RelWithDebInfo .. && make all test && ctest
--- a/src/Makefile.am
+++ b/src/Makefile.am
@ -0,0 +1,83 @@
 AM_CPPFLAGS  =	-Wall -Wextra -pedantic -Wshadow -Wpointer-arith -Wcast-align
 AM_CPPFLAGS +=	-Wwrite-strings -Wmissing-declarations -Wno-long-long -Werror
 AM_CPPFLAGS +=	-Wunused-variable -std=c++11 -D_XOPEN_SOURCE -Os -I.
 AM_CPPFLAGS +=	-fno-elide-constructors	 -Weffc++
 TEST_UTILS =	test_utils.hh test_utils.cc
 CLOC_PSOURCES =	emsha.cc sha256.cc hmac.cc internal.hh			\
 		emsha/emsha.hh emsha/hmac.hh emsha/sha256.hh
 CLOC_TSOURCES =	 test_emsha.cc test_hmac.cc test_mem.cc test_sha256.cc	\
 		 test_utils.cc test_utils.hh
 lib_LTLIBRARIES =		libemsha.la
 nobase_include_HEADERS =	emsha/sha256.hh emsha/hmac.hh emsha/emsha.hh
 libemsha_la_SOURCES =		emsha.cc sha256.cc hmac.cc internal.hh
 libemsha_li_CPPFLAGS =		$(AM_CPPFLAGS) -Winline 
 check_PROGRAMS =		emsha_sha256_test emsha_hmac_test	\
 				emsha_core_test emsha_mem_test		\
 				emsha_static_mem_test			\
 				emsha_static_sha_test			\
 				emsha_static_hmac_test
 check_CPPFLAGS =		$(AM_CPPFLAGS) -Wnoinline
 # emsha_sha256_test runs through some SHA-256 test vectors, ensuring
 # that the library's behaviour is correct.
 emsha_sha256_test_SOURCES =	test_sha256.cc $(TEST_UTILS)
 emsha_sha256_test_LDADD =	libemsha.la
 # emsha_hmac_test runs through a set of HMAC-SHA-256 test vectors,
 # ensuring that the library's behaviour is correct.
 emsha_hmac_test_SOURCES =	test_hmac.cc $(TEST_UTILS)
 emsha_hmac_test_LDADD =		libemsha.la
 # emsha_core_test validates some of the additional functions provided
 # by the emsha library.
 emsha_core_test_SOURCES =	test_emsha.cc $(TEST_UTILS)
 emsha_core_test_LDADD =		libemsha.la
 # emsha_mem_test is used for testing with valgrind; it aims to introduce
 # no heap allocations via the test harness so that memory usage inside
 # the library may be more accurately checked.
 emsha_mem_test_SOURCES =	test_mem.cc $(TEST_UTILS)
 emsha_mem_test_LDADD =		libemsha.la
 emsha_static_mem_test_SOURCES =	test_mem.cc emsha.cc sha256.cc hmac.cc $(TEST_UTILS)
 emsha_static_mem_test_CPPFLAGS = $(AM_CPPFLAGS) -static
 emsha_static_mem_test_LDFLAGS = $(AM_LDFLAGS) -static
 emsha_static_sha_test_SOURCES =	test_sha256.cc emsha.cc sha256.cc hmac.cc $(TEST_UTILS)
 emsha_static_sha_test_CPPFLAGS = $(AM_CPPFLAGS) -static
 emsha_static_sha_test_LDFLAGS = $(AM_LDFLAGS) -static
 emsha_static_hmac_test_SOURCES =	test_hmac.cc emsha.cc sha256.cc hmac.cc $(TEST_UTILS)
 emsha_static_hmac_test_CPPFLAGS =	$(AM_CPPFLAGS) -static
 emsha_static_hmac_test_LDFLAGS =	$(AM_LDFLAGS) -static
 .PHONY: valgrind-check
 valgrind-check: emsha_static_mem_test
 	valgrind --tool=massif -v emsha_static_mem_test ms_print
 .PHONY: cloc-report
 cloc-report:
 	@echo "=== Library Sources ==="
 	@cloc $(CLOC_PSOURCES)
 	@echo
 	@echo "=== Test Sources ==="
 	@cloc $(CLOC_TSOURCES)
 .PHONY:	coverity-scan
 coverity-scan: clean
 	cov-build --dir cov-int make all check
 	tar czf $(PACKAGE_NAME)-$(PACKAGE_VERSION)_coverity.tar.gz cov-int
 	rm -rf cov-int
 .PHONY: scanners clang-scanner cppcheck-scanner
 scanners: clang-scanner cppcheck-scanner
 clang-scanner:
 	clang++ $(AM_CPPFLAGS) --analyze $(CLOC_PSOURCES)
 cppcheck-scanner:
 	cppcheck --quiet --enable=all -I ./ $(CLOC_PSOURCES)
--- a/src/emsha.cc
+++ b/src/emsha.cc
@ -28,23 +28,31 @@
 #include <cstring>
 #include <iostream>
-#include "emsha/emsha.h"
+#include <emsha/emsha.hh>
 using std::uint8_t;
 using std::uint32_t;
 using std::cout;
 using std::endl;
 namespace emsha {
 Hash::~Hash()
 {
 	// Nothing to see here.
 }
 bool
-HashEqual(const uint8_t *a, const uint8_t *b)
+hash_equal(const uint8_t *a, const uint8_t *b)
 {
 	uint8_t	res = 0;
-	EMSHA_CHECK(a != nullptr, false);
+	EMSHA_CHECK(a != NULL, false);
-	EMSHA_CHECK(b != nullptr, false);
+	EMSHA_CHECK(b != NULL, false);
 	for (uint32_t i = 0; i < SHA256_HASH_SIZE; i++) {
 		res += a[i] ^ b[i];
@ -55,14 +63,11 @@ HashEqual(const uint8_t *a, const uint8_t *b)
 #ifndef EMSHA_NO_HEXSTRING
 namespace {
 #ifndef EMSHA_NO_HEXLUT
 // If using a lookup table is permitted, then the faster way to do this
 // is to use one.
-void
+static void
-writeHexChar(uint8_t *dest, uint8_t src)
+write_hex_char(uint8_t *dest, uint8_t src)
 {
 	static constexpr uint8_t lut[256][3] = {
 		"00", "01", "02", "03", "04", "05", "06", "07",
@ -103,14 +108,13 @@ writeHexChar(uint8_t *dest, uint8_t src)
 	*(dest + 1) = lut[src][1];
 }
 #else	// #ifndef EMSHA_NO_HEXLUT
 // If the full lookup table can't be used, e.g. because MSP430-level
 // memory constraints, we'll work around this using a small (16-byte)
 // lookup table and some bit shifting. On platforms where even this is
-// too much, the HexString functionality will just be disabled.
+// too much, the hexstring functionality will just be disabled.
-void
+static void
-writeHexChar(uint8_t *dest, uint8_t src)
+write_hex_char(uint8_t *dest, uint8_t src)
 {
 	static constexpr uint8_t	lut[] = {
 		'0', '1', '2', '3', '4', '5', '6', '7',
@ -120,22 +124,23 @@ writeHexChar(uint8_t *dest, uint8_t src)
 	*dest = lut[((src & 0xF0) >> 4)];
 	*(dest + 1) = lut[(src & 0xF)];
 }
 #endif // #ifndef EMSHA_NO_HEXLUT
 } // anonymous namespace for writeHexChar
 void
-HexString(uint8_t *dest, uint8_t *src, uint32_t srclen)
+hexstring(uint8_t *dest, uint8_t *src, uint32_t srclen)
 {
-	size_t	dp = 0;
+	uint8_t	*dp = dest;
 	for (uint32_t i = 0; i < srclen; i++) {
-		writeHexChar(&dest[dp], src[i]);
+		write_hex_char(dp, src[i]);
 		dp += 2;
 	}
 }
 #endif // #ifndef EMSHA_NO_HEXSTRING
 } // end of namespace emsha
--- a/src/emsha/emsha.hh
+++ b/src/emsha/emsha.hh
@ -0,0 +1,169 @@
 /*
 * The MIT License (MIT)
 *
 * Copyright (c) 2015 K. Isom <coder@kyleisom.net>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * copy of this  software and associated documentation  files (the "Software"),
 * to deal  in the Software  without restriction, including  without limitation
 * the rights  to use,  copy, modify,  merge, publish,  distribute, sublicense,
 * and/or  sell copies  of the  Software,  and to  permit persons  to whom  the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS  PROVIDED "AS IS", WITHOUT WARRANTY OF  ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING  BUT NOT  LIMITED TO  THE WARRANTIES  OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS  OR COPYRIGHT  HOLDERS BE  LIABLE FOR  ANY CLAIM,  DAMAGES OR  OTHER
 * LIABILITY,  WHETHER IN  AN ACTION  OF CONTRACT,  TORT OR  OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 */
 #ifndef __EMSHA_EMSHA_HH
 #define __EMSHA_EMSHA_HH
 #include <cstdint>
 namespace emsha {
 // EMSHA_CHECK is used for sanity checks in certain parts of the code.
 #ifdef NDEBUG
 	// If asserts are turned off, expand the check to an if
 	// statement that will return with retval if the condition
 	// isn't met.
 	#define EMSHA_CHECK(condition, retval) if (!(condition)) { return (retval); }
 #else
 	// If asserts are turned on, the check is expanded to an
 	// assertion that the condition holds. In this case, retval is
 	// not used.
 	#define	EMSHA_CHECK(condition, retval) (assert((condition)))
 #endif
 	// SHA256_HASH_SIZE is the output length of SHA-256 in bytes.
 	const std::uint32_t	SHA256_HASH_SIZE = 32;
 	// The EMSHA_RESULT type is used to indicate whether an
 	// operation succeeded, and if not, what the general fault type
 	// was.
 	typedef enum _EMSHA_RESULT_: std::uint8_t {
 		// All operations have completed successfully so far.
 		EMSHA_ROK = 0,
 		// A self test or unit test failed.
 		EMSHA_TEST_FAILURE = 1,
 		// A null pointer was passed in as a buffer where it shouldn't
                // have been.
 		EMSHA_NULLPTR = 2,
 		// The Hash is in an invalid state.
 		EMSHA_INVALID_STATE = 3,
                // The input to SHA256::update is too large.
                SHA256_INPUT_TOO_LONG = 4,
 		// The self tests have been disabled, but a self-test function
 		// was called.
 		EMSHA_SELFTEST_DISABLED = 5
 	} EMSHA_RESULT;
 	// A Hash is generalised superclass supporting concrete classes
 	// that produce digests of data.
 	class Hash {
 		public:
 			virtual ~Hash() =0;
 			// reset should bring the Hash back into its initial
 			// state. That is, the idea is that
 			//
 			//     hash->reset(); hash->update(...)...;
 			//     hash->result(...);
 			//
 			// is idempotent, assuming the inputs to update and
 			// result are constant. The implications of this for a
 			// given concrete class should be described in that
 			// class's documentation, but in general, it has the
 			// effect of preserving any initial state while removing
 			// any data written to the Hash via the update method.
 			virtual EMSHA_RESULT	reset(void) =0;
 			// update is used to write message data into the Hash.
 			virtual EMSHA_RESULT	update(const std::uint8_t *m,
 						       std::uint32_t ml) =0;
 			// finalize should carry out any final operations on the
 			// Hash; after a call to finalize, no more data can be
 			// written.  Additionally, it transfers out the
 			// resulting hash into its argument.
 			virtual EMSHA_RESULT	finalize(std::uint8_t *d) =0;
 			// result is used to transfer out the hash to the
 			// argument. This implies that the Hash must keep enough
 			// state for repeated calls to result to work.
                        virtual EMSHA_RESULT	result(std::uint8_t *d) =0;
 			// size should return the output size of the Hash; this
 			// is, how large the buffers written to by result should
 			// be.
 			virtual std::uint32_t	size(void) =0;
 	};
 	// hash_equal provides a constant time function for comparing two
 	// hashes. The caller *must* ensure that both a and b are the same
 	// size. The recommended approach is to use fixed-size buffers of
 	// emsha::SHA256_HASH_SIZE length:
 	//
 	// uint8_t	expected[emsha::SHA256_HASH_SIZE];
 	// uint8_t	actual[emsha::SHA256_HASH_SIZE];
 	//
 	// // Fill in expected and actual using the Hash operations.
 	//
 	// if (hash_equal(expected, actual)) {
 	//         proceed();
 	// }
 	//
 	// Inputs:
 	//     a, b: byte arrays that MUST contain at least
 	//     emsha::SHA256_HASH_SIZE bytes. Only the first
 	//     emsha::SHA256_HASH_SIZE bytes will be compared.
 	//
 	// Outputs:
 	//     true iff both byte arrays match
 	//
 	//     false if the arrays do not match
 	//
 	bool	hash_equal(const std::uint8_t *a, const std::uint8_t *b);
 #ifndef EMSHA_NO_HEXSTRING
 	// hexstring writes a hex-encoded version of the src byte
 	// array into dest. The caller *must* ensure that dest is
 	// srclen * 2 bytes or longer.
 	//
 	// Inputs:
 	//
 	//     dest:   a byte array that is 2 * srclen.
 	//
 	//     src:    a byte array containing the data to process.
 	//
 	//     srclen: the size of src.
 	//
 	// Outputs:
 	//     
 	//     The hex-encoded string will be placed into dest.
 	//
 	void	hexstring(std::uint8_t *dest, std::uint8_t *src, std::uint32_t srclen);
 #endif // EMSHA_NO_HEXSTRING
 } // end of namespace emsha
 #endif // __EMSHA_EMSHA_HH
--- a/src/emsha/hmac.hh
+++ b/src/emsha/hmac.hh
@ -0,0 +1,197 @@
 /*
 * The MIT License (MIT)
 *
 * Copyright (c) 2015 K. Isom <coder@kyleisom.net>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * copy of this  software and associated documentation  files (the "Software"),
 * to deal  in the Software  without restriction, including  without limitation
 * the rights  to use,  copy, modify,  merge, publish,  distribute, sublicense,
 * and/or  sell copies  of the  Software,  and to  permit persons  to whom  the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS  PROVIDED "AS IS", WITHOUT WARRANTY OF  ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING  BUT NOT  LIMITED TO  THE WARRANTIES  OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS  OR COPYRIGHT  HOLDERS BE  LIABLE FOR  ANY CLAIM,  DAMAGES OR  OTHER
 * LIABILITY,  WHETHER IN  AN ACTION  OF CONTRACT,  TORT OR  OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 */
 #ifndef __EMSHA_HMAC_HH
 #define __EMSHA_HMAC_HH
 #include <cstdint>
 #include <emsha/emsha.hh>
 #include <emsha/sha256.hh>
 namespace emsha {
 	const uint32_t	HMAC_KEY_LENGTH = SHA256_MB_SIZE;
 	// HMAC is a keyed hash that can be used to produce an
 	// authenticated hash of some data. The HMAC is built on (and
 	// uses internally) the SHA-256 class; it's helpful to note that
 	// faults that occur in the SHA-256 code will be propagated up
 	// as the return value from many of the HMAC functions.
        class HMAC : Hash {
                public:
 			// An HMAC is constructed with a key and the
 			// length of the key. This key is stored in
 			// the HMAC context, and is wiped by the HMAC
 			// destructor.
 			//
 			// Inputs:
 			//     k: the HMAC key.
 			//     kl: the length of the HMAC key.
 			//
                        HMAC(const uint8_t *k, uint32_t kl);
 			// reset clears any data written to the HMAC;
 			// this is equivalent to constructing a new HMAC,
 			// but it preserves the keys.
 			//
 			// Outputs:
 			//     EMSHA_ROK is returned if the reset occurred
 			//     without (detected) fault.
 			//
 			//     If a fault occurs with the underlying SHA-256
 			//     context, the error code is returned.
 			//
 			EMSHA_RESULT	reset(void);
 			// update writes data into the context. While there is
 			// an upper limit on the size of data that the
 			// underlying hash can operate on, this package is
 			// designed for small systems that will not approach
 			// that level of data (which is on the order of 2
 			// exabytes), so it is not thought to be a concern.
 			//
 			// Inputs:
 			//     m: a byte array containing the message to be
 			//     written. It must not be NULL (unless the message
 			//     length is zero).
 			//
 			//     ml: the message length, in bytes.
 			//
 			// Outputs:
 		        //     EMSHA_NULLPTR is returned if m is NULL and ml is
 			//     nonzero.
 			//
 			//     EMSHA_INVALID_STATE is returned if the update
 			//     is called after a call to finalize.
 			//
 			//     SHA256_INPUT_TOO_LONG is returned if too much
 			//     data has been written to the context.
 			//
 			//     EMSHA_ROK is returned if the data was
 			//     successfully written into the HMAC context.
 			//
 			EMSHA_RESULT	update(const uint8_t *, uint32_t);
 			// finalize completes the HMAC computation. Once this
 			// method is called, the context cannot be updated
 			// unless the context is reset.
 			//
 			// Inputs:
 			//     d: a byte buffer that must be at least
 			//     HMAC.size() in length.
 			//
 			// Outputs:
 			//     EMSHA_NULLPTR is returned if d is the null
 			//     pointer.
 			//
 			//     EMSHA_INVALID_STATE is returned if the HMAC
 			//     context is in an invalid state, such as if there
 			//     were errors in previous updates.
 			//
 			//     EMSHA_ROK is returned if the context was
 			//     successfully finalised and the digest copied to
 			//     d.
 			//
 			EMSHA_RESULT	finalize(uint8_t *);
 			// result copies the result from the HMAC context into
 			// the buffer pointed to by d, running finalize if
 			// needed. Once called, the context cannot be updated
 			// until the context is reset.
 			//
 			// Inputs:
 			//     d: a byte buffer that must be at least
 			//     HMAC.size() in length.
 			//
 			// Outputs:
 			//     EMSHA_NULLPTR is returned if d is the null
 			//     pointer.
 			//
 			//     EMSHA_INVALID_STATE is returned if the HMAC
 			//     context is in an invalid state, such as if there
 			//     were errors in previous updates.
 			//
 			//     EMSHA_ROK is returned if the context was
 			//     successfully finalised and the digest copied to
 			//     d.
 			//
 			EMSHA_RESULT	result(uint8_t *);
 			// size returns the output size of HMAC-SHA-256, e.g.
 			// the size that the buffers passed to finalize and
 			// result should be.
 			//
 			// Outputs:
 			//     A uint32_t representing the expected size
 			//     of buffers passed to result and finalize.
 			uint32_t	size(void) { return SHA256_HASH_SIZE; }
 			// When an HMAC context is destroyed, it is reset and
 			// the key material is zeroised using the STL fill
 			// function.
 			~HMAC(void);
                private:
 			uint8_t	hstate;
 			SHA256	ctx;
                        uint8_t	k[HMAC_KEY_LENGTH];
 			uint8_t	buf[SHA256_HASH_SIZE];
 			inline EMSHA_RESULT
 			    final_result(uint8_t *);
        };
 	// compute_hmac performs a single-pass HMAC computation over
 	// a message.
 	//
 	// Inputs:
 	//     k: a byte buffer containing the HMAC key.
 	//
 	//     kl: the length of the HMAC key.
 	//
 	//     m: the message data over which the HMAC is to be computed.
 	//
 	//     ml: the length of the message.
 	//
 	//     d: a byte buffer that will be used to store the resulting
 	//     HMAC. It should be SHA256_HASH_SIZE bytes in size.
 	//
 	// Outputs:
 	//     This function handles setting up the HMAC context with
 	//     the given key, calling update with the message data, and
 	//     then calling finalize to place the result in the output
 	//     buffer. Any of the faults that can occur in these functions
 	//     can be returned here, or EMSHA_ROK if the HMAC was
 	//     successfully computed.
 	EMSHA_RESULT	compute_hmac(const uint8_t *k, uint32_t kl,
 				     const uint8_t *m, uint32_t ml,
 				     uint8_t *d);
 } // end of namespace emsha
 #endif // __EMSHA_HMAC_HH
--- a/src/emsha/sha256.hh
+++ b/src/emsha/sha256.hh
@ -0,0 +1,211 @@
 /*
 * The MIT License (MIT)
 *
 * Copyright (c) 2015 K. Isom <coder@kyleisom.net>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * copy of this  software and associated documentation  files (the "Software"),
 * to deal  in the Software  without restriction, including  without limitation
 * the rights  to use,  copy, modify,  merge, publish,  distribute, sublicense,
 * and/or  sell copies  of the  Software,  and to  permit persons  to whom  the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS  PROVIDED "AS IS", WITHOUT WARRANTY OF  ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING  BUT NOT  LIMITED TO  THE WARRANTIES  OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS  OR COPYRIGHT  HOLDERS BE  LIABLE FOR  ANY CLAIM,  DAMAGES OR  OTHER
 * LIABILITY,  WHETHER IN  AN ACTION  OF CONTRACT,  TORT OR  OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 */
 #ifndef __EMSHA_SHA256_HH
 #define __EMSHA_SHA256_HH
 #include <cstdint>
 #include <emsha/emsha.hh>
 namespace emsha {
 	// SHA256_MB_SIZE is the size of a message block.
 	const uint32_t	SHA256_MB_SIZE = 64;
 	class SHA256 : Hash {
 		public:
 			// A SHA256 context does not need any special
 			// construction. It can be declared and
 			// immediately start being used.
 			SHA256();
 			// The SHA256 destructor will clear out its internal
 			// message buffer; all of the members are local
 			// and not resource handles, so cleanup is minimal.
 			~SHA256();
 			// reset clears the internal state of the SHA256
 			// context and returns it to its initial state.
 			// It should always return EMSHA_ROK.
 			EMSHA_RESULT		reset(void);
 			// update writes data into the context. While
 			// there is an upper limit on the size of data
 			// that SHA-256 can operate on, this package is
 			// designed for small systems that will not
 			// approach that level of data (which is on the
 			// order of 2 exabytes), so it is not thought
 			// to be a concern.
 			//
 			// Inputs:
 			//     m: a byte array containing the message to
 			//     be written. It must not be NULL (unless
 			//     the message length is zero).
 			//
 			//     ml: the message length, in bytes.
 			//
 			// Outputs:
 			//     EMSHA_NULLPTR is returned if m is NULL
 			//     and ml is nonzero.
 			//
 			//     EMSHA_INVALID_STATE is returned if the
 			//     update is called after a call to
 			//     finalize.
 			//
 			//     SHA256_INPUT_TOO_LONG is returned if too
 			//     much data has been written to the
 			//     context.
 			//
 			//     EMSHA_ROK is returned if the data was
 			//     successfully added to the SHA-256
 			//     context.
 			//
 			EMSHA_RESULT		update(const uint8_t *m, uint32_t ml);
 			// finalize completes the digest. Once this
 			// method is called, the context cannot be
 			// updated unless the context is reset.
 			//
 			// Inputs:
 			//     d: a byte buffer that must be at least
 			//     SHA256.size() in length.
 			//
 			// Outputs:
 			//     EMSHA_NULLPTR is returned if d is the
 			//     null pointer.
 			//
 			//     EMSHA_INVALID_STATE is returned if the
 			//     SHA-256 context is in an invalid state,
 			//     such as if there were errors in previous
 			//     updates.
 			//
 			//     EMSHA_ROK is returned if the context was
 			//     successfully finalised and the digest
 			//     copied to d.
 			//
 			EMSHA_RESULT		finalize(uint8_t *d);
 			// result copies the result from the SHA-256
 			// context into the buffer pointed to by d,
 			// running finalize if needed. Once called,
 			// the context cannot be updated until the
 			// context is reset.
 			//
 			// Inputs:
 			//     d: a byte buffer that must be at least
 			//     SHA256.size() in length.
 			//
 			// Outputs:
 			//     EMSHA_NULLPTR is returned if d is the
 			//     null pointer.
 			//
 			//     EMSHA_INVALID_STATE is returned if the
 			//     SHA-256 context is in an invalid state,
 			//     such as if there were errors in previous
 			//     updates.
 			//
 			//     EMSHA_ROK is returned if the context was
 			//     successfully finalised and the digest
 			//     copied to d.
 			//
                        EMSHA_RESULT		result(uint8_t *d);
 			// size returns the output size of SHA256, e.g.
 			// the size that the buffers passed to finalize
 			// and result should be.
 			//
 			// Outputs:
 			//     a uint32_t representing the expected size
 			//     of buffers passed to result and finalize.
 			uint32_t		size(void) { return SHA256_HASH_SIZE; }
 		private:
 			// mlen stores the current message length.
 			uint64_t	mlen;
 			// The intermediate hash is 8x 32-bit blocks.
 			uint32_t	i_hash[8];
 			// hstatus is the hash status, and hcomplete indicates
 			// whether the hash has been finalised.
 			EMSHA_RESULT	hstatus;
 			uint8_t		hcomplete;
 			// mb is the message block, and mbi is the message
 			// block index.
 			uint8_t		mbi;
 			uint8_t		mb[SHA256_MB_SIZE];
 			inline EMSHA_RESULT	add_length(uint32_t);
                        inline void             update_message_block(void);
                        inline void             pad_message(uint8_t);
 	}; // end class SHA256
 	// sha256_digest performs a single pass hashing of the message
 	// passed in.
 	//
 	// Inputs:
 	//     m: byte buffer containing the message to hash.
 	//
 	//     ml: the length of m.
 	//
 	//     d: byte buffer that will be used to store the resulting
 	//     hash; it should have at least emsha::SHA256_HASH_SIZE
 	//     bytes available.
 	//
 	// Outputs:
 	//     This function handles setting up a SHA256 context, calling
 	//     update using the message data, and then calling finalize. Any
 	//     of the errors that can occur in those functions can be
 	//     returned here, or EMSHA_ROK if the digest was computed
 	//     successfully.
 	//
 	EMSHA_RESULT	sha256_digest(const uint8_t *m, uint32_t ml, uint8_t *d);
 	// sha256_self_test runs through two test cases to ensure that the
 	// SHA-256 functions are working correctly.
 	//
 	// Outputs:
 	//     EMSHA_ROK is returned if the self tests pass.
 	//
 	//     EMSHA_SELFTEST_DISABLED is returned if the self tests
 	//     have been disabled (e.g., libemsha was compiled with the
 	//     EMSHA_NO_SELFTEST #define).
 	//
 	//     If a fault occurred inside the SHA-256 code, the error
 	//     code from one of the update, finalize, result, or reset
 	//     methods is returned.
 	//
 	//     If the fault is that the output does not match the test
 	//     vector, EMSHA_TEST_FAILURE is returned.
 	//
 	EMSHA_RESULT   sha256_self_test(void);
 } // end of namespace emsha
 #endif // __EMSHA_SHA256_HH
--- a/src/hmac.cc
+++ b/src/hmac.cc
@ -28,69 +28,57 @@
 #include <cstdint>
-#include "emsha/emsha.h"
+#include <emsha/emsha.hh>
-#include "emsha/hmac.h"
+#include <emsha/sha256.hh>
-#include "emsha/sha256.h"
+#include <emsha/hmac.hh>
 namespace emsha {
 // These constants are used to keep track of the state of the HMAC.
-// HMAC is in a clean-slate state following a call to Reset().
+// HMAC is in a clean-slate state following a call to reset().
-constexpr uint8_t HMAC_INIT = 0U;
+constexpr uint8_t	HMAC_INIT = 0;
 // The ipad constants have been XOR'd into the key and written to the
 // SHA-256 context.
-constexpr uint8_t HMAC_IPAD = 1U;
+constexpr uint8_t	HMAC_IPAD = 1;
 // The opad constants have been XOR'd into the key and written to the
 // SHA-256 context.
-constexpr uint8_t HMAC_OPAD = 2U;
+constexpr uint8_t	HMAC_OPAD = 2;
 // HMAC has been finalised
-constexpr uint8_t HMAC_FIN = 3U;
+constexpr uint8_t	HMAC_FIN = 3;
 // HMAC is in an invalid state.
-constexpr uint8_t HMAC_INVALID = 4U;
+constexpr uint8_t	HMAC_INVALID = 4;
-static constexpr uint8_t ipad = 0x36U;
+static constexpr uint8_t ipad = 0x36;
-static constexpr uint8_t opad = 0x5cU;
+static constexpr uint8_t opad = 0x5c;
 HMAC::HMAC(const uint8_t *ik, uint32_t ikl)
-    : hstate(HMAC_INIT), k{0U}, buf{0U}
+    :hstate(), ctx()
 {
-	std::fill(this->k, this->k+HMAC_KEY_LENGTH, 0);
+	this->hstate = HMAC_INIT;
 	std::fill(this->k, this->k + emsha::HMAC_KEY_LENGTH, 0);
 	if (ikl < HMAC_KEY_LENGTH) {
-		for (uint32_t i = 0U; i < ikl; i++) {
+		std::copy(ik, ik + ikl, this->k);
 			this->k[i] = ik[i];
 		}
 		while (ikl < HMAC_KEY_LENGTH) {
-			this->k[ikl++] = 0U;
+			this->k[ikl++] = 0;
 		}
 	} else if (ikl > HMAC_KEY_LENGTH) {
-		if (this->ctx.Update(ik, ikl) != EMSHAResult::OK) {
+		this->ctx.update(ik, ikl);
-			this->hstate = HMAC_INVALID;
+		this->ctx.result(this->k);
-		} else if (this->ctx.Result(this->k) != EMSHAResult::OK) {
+		this->ctx.reset();
 			this->hstate = HMAC_INVALID;
 		} else if (this->ctx.Reset() != EMSHAResult::OK) {
 			this->hstate = HMAC_INVALID;
 		} else {
 			this->hstate = HMAC_INIT;
 		}
 	} else {
-		for (uint32_t i = 0U; i < ikl; i++) {
+		std::copy(ik, ik + ikl, this->k);
 			this->k[i] = ik[i];
 		}
 	}
-	if (this->reset() != EMSHAResult::OK) {
+	this->reset();
 		this->hstate = HMAC_INVALID;
 	}
 }
@ -99,38 +87,31 @@ HMAC::HMAC(const uint8_t *ik, uint32_t ikl)
 */
 HMAC::~HMAC()
 {
-	(void)this->reset();
+	this->reset();
 	std::fill(this->k, this->k + HMAC_KEY_LENGTH, 0);
 }
-EMSHAResult
+EMSHA_RESULT
 HMAC::Reset()
 {
 	return this->reset();
 }
 EMSHAResult
 HMAC::reset()
 {
-	EMSHAResult res;
+	EMSHA_RESULT	res;
 	// Following a reset, both SHA-256 contexts and result buffer should be
 	// zero'd out for a clean slate. The HMAC state should be reset
 	// accordingly.
-	this->ctx.Reset();
+	this->ctx.reset();
 	std::fill(this->buf, this->buf + SHA256_HASH_SIZE, 0);
 	// Set up the k0 ⊕ ipad construction, and write it into the
 	// SHA-256 context.
-	uint8_t       key[HMAC_KEY_LENGTH];
+	uint8_t	key[HMAC_KEY_LENGTH];
 	for (uint32_t i = 0; i < HMAC_KEY_LENGTH; i++) {
 		key[i] = this->k[i] ^ ipad;
 	}
-	res = this->ctx.Update(key, HMAC_KEY_LENGTH);
+	res = this->ctx.update(key, HMAC_KEY_LENGTH);
-	if (EMSHAResult::OK != res) {
+	if (EMSHA_ROK != res) {
 		this->hstate = HMAC_INVALID;
 		return res;
 	}
@ -139,72 +120,70 @@ HMAC::reset()
 	std::fill(key, key + HMAC_KEY_LENGTH, 0);
 	this->hstate = HMAC_IPAD;
-	return EMSHAResult::OK;
+	return EMSHA_ROK;
 }
-EMSHAResult
+EMSHA_RESULT
-HMAC::Update(const std::uint8_t *message, std::uint32_t messageLength)
+HMAC::update(const uint8_t *m, uint32_t ml)
 {
-	EMSHAResult res;
+	EMSHA_RESULT	res;
-	SHA256      &hctx = this->ctx;
+	SHA256&		hctx = this->ctx;
-	EMSHA_CHECK(message != nullptr, EMSHAResult::NullPointer);
+	EMSHA_CHECK(HMAC_IPAD == this->hstate, EMSHA_INVALID_STATE);
 	EMSHA_CHECK(HMAC_IPAD == this->hstate, EMSHAResult::InvalidState);
 	// Write the message to the SHA-256 context.
-	res = hctx.Update(message, messageLength);
+	res = hctx.update(m, ml);
-	if (EMSHAResult::OK != res) {
+	if (EMSHA_ROK != res) {
 		this->hstate = HMAC_INVALID;
 		return res;
 	}
 	assert(HMAC_IPAD == this->hstate);
-	return EMSHAResult::OK;
+	return EMSHA_ROK;
 }
-inline EMSHAResult
+inline EMSHA_RESULT
-HMAC::finalResult(uint8_t *d)
+HMAC::final_result(uint8_t *d)
 {
 	if (nullptr == d) {
-		return EMSHAResult::NullPointer;
+		return EMSHA_NULLPTR;
 	}
 	// If the HMAC has already been finalised, skip straight to
 	// copying the result.
-	if (this->hstate == HMAC_FIN) {
+	if (HMAC_FIN == this->hstate) {
-		std::copy(this->buf, this->buf+SHA256_HASH_SIZE, d);
+		std::copy(this->buf, this->buf + SHA256_HASH_SIZE, d);
-
+		return EMSHA_ROK;
 		return EMSHAResult::OK;
 	}
-	EMSHA_CHECK(HMAC_IPAD == this->hstate, EMSHAResult::InvalidState);
+	EMSHA_CHECK(HMAC_IPAD == this->hstate, EMSHA_INVALID_STATE);
-	EMSHAResult res;
+	EMSHA_RESULT	res;
 	// Use the result buffer as an intermediate buffer to store the result
 	// of the inner hash.
-	res = this->ctx.Result(this->buf);
+	res = this->ctx.result(this->buf);
-	if (EMSHAResult::OK != res) {
+	if (EMSHA_ROK != res) {
 		this->hstate = HMAC_INVALID;
-		return EMSHAResult::InvalidState;
+		return EMSHA_INVALID_STATE;
 	}
 	assert(HMAC_IPAD == this->hstate);
 	// The SHA-256 context needs to be reset so that it may be
 	// re-used for the outer digest.
-	this->ctx.Reset();
+	this->ctx.reset();
 	// Set up the k0 ⊕ opad construction, and write it into the
 	// SHA-256 context.
-	uint8_t       key[HMAC_KEY_LENGTH];
+	uint8_t	key[HMAC_KEY_LENGTH];
 	for (uint32_t i = 0; i < HMAC_KEY_LENGTH; i++) {
 		key[i] = this->k[i] ^ opad;
 	}
-	res          = this->ctx.Update(key, HMAC_KEY_LENGTH);
+	res = this->ctx.update(key, HMAC_KEY_LENGTH);
-	if (EMSHAResult::OK != res) {
+	if (EMSHA_ROK != res) {
 		this->hstate = HMAC_INVALID;
 		return res;
 	}
@ -214,15 +193,15 @@ HMAC::finalResult(uint8_t *d)
 	std::fill(key, key + HMAC_KEY_LENGTH, 0);
 	// Write the inner hash result into the outer hash.
-	res = this->ctx.Update(this->buf, SHA256_HASH_SIZE);
+	res = this->ctx.update(this->buf, SHA256_HASH_SIZE);
-	if (EMSHAResult::OK != res) {
+	if (EMSHA_ROK != res) {
 		this->hstate = HMAC_INVALID;
 		return res;
 	}
 	// Write the outer hash result into the working buffer.
-	res = this->ctx.Finalise(this->buf);
+	res = this->ctx.finalize(this->buf);
-	if (EMSHAResult::OK != res) {
+	if (EMSHA_ROK != res) {
 		this->hstate = HMAC_INVALID;
 		return res;
 	}
@ -230,42 +209,39 @@ HMAC::finalResult(uint8_t *d)
 	std::copy(this->buf, this->buf + SHA256_HASH_SIZE, d);
 	this->hstate = HMAC_FIN;
-	return EMSHAResult::OK;
+	return EMSHA_ROK;
 }
-EMSHAResult
+EMSHA_RESULT
-HMAC::Finalise(std::uint8_t *digest)
+HMAC::finalize(uint8_t *d)
 {
-	return this->finalResult(digest);
+	return this->final_result(d);
 }
-EMSHAResult
+EMSHA_RESULT
-HMAC::Result(std::uint8_t *digest)
+HMAC::result(uint8_t *d)
 {
-	return this->finalResult(digest);
+	return this->final_result(d);
 }
-std::uint32_t
+EMSHA_RESULT
-HMAC::Size()
+compute_hmac(const uint8_t *k, uint32_t kl, const uint8_t *m, uint32_t ml,
 	     uint8_t *d)
 {
-	return SHA256_HASH_SIZE;
+	EMSHA_RESULT	res;
-}
+	HMAC		h(k, kl);
 	res = h.update(m, ml);
 	if (EMSHA_ROK != res) {
 		return res;
 	}
-EMSHAResult
+	res = h.result(d);
-ComputeHMAC(const uint8_t *k, const uint32_t kl,
+	if (EMSHA_ROK != res) {
-	    const uint8_t *m, const uint32_t ml,
+		return res;
 	    uint8_t *d)
 {
 	EMSHAResult res;
 	HMAC        h(k, kl);
 	res = h.Update(m, ml);
 	if (res == EMSHAResult::OK) {
 		res = h.Result(d);
 	}
 	return res;
@ -273,4 +249,3 @@ ComputeHMAC(const uint8_t *k, const uint32_t kl,
 } // end of namespace emsha
--- a/src/internal.hh
+++ b/src/internal.hh
@ -0,0 +1,92 @@
 /*
 * The MIT License (MIT)
 *
 * Copyright (c) 2015 K. Isom <coder@kyleisom.net>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * copy of this  software and associated documentation  files (the "Software"),
 * to deal  in the Software  without restriction, including  without limitation
 * the rights  to use,  copy, modify,  merge, publish,  distribute, sublicense,
 * and/or  sell copies  of the  Software,  and to  permit persons  to whom  the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS  PROVIDED "AS IS", WITHOUT WARRANTY OF  ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING  BUT NOT  LIMITED TO  THE WARRANTIES  OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS  OR COPYRIGHT  HOLDERS BE  LIABLE FOR  ANY CLAIM,  DAMAGES OR  OTHER
 * LIABILITY,  WHETHER IN  AN ACTION  OF CONTRACT,  TORT OR  OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 */
 #ifndef __EMSHA_INTERNAL_HH
 #define __EMSHA_INTERNAL_HH
 #include <cstdint>
 using std::uint8_t;
 using std::uint32_t;
 namespace emsha {
 static inline uint32_t
 rotr32(uint32_t x, uint8_t n)
 {
 	return ((x >> n) | (x << (32 - n)));
 }
 static inline uint32_t
 sha_ch(uint32_t x, uint32_t y, uint32_t z)
 {
 	return ((x & y) ^ ((~x) & z));
 }
 static inline uint32_t
 sha_maj(uint32_t x, uint32_t y, uint32_t z)
 {
 	return (x & y) ^ (x & z) ^ (y & z);
 }
 static inline uint32_t
 sha_Sigma0(uint32_t x)
 {
 	return rotr32(x, 2) ^ rotr32(x, 13) ^ rotr32(x, 22);
 }
 static inline uint32_t
 sha_Sigma1(uint32_t x)
 {
 	return rotr32(x, 6) ^ rotr32(x, 11) ^ rotr32(x, 25);
 }
 static inline uint32_t
 sha_sigma0(uint32_t x)
 {
 	return rotr32(x, 7) ^ rotr32(x, 18) ^ (x >> 3);
 }
 static inline uint32_t
 sha_sigma1(uint32_t x)
 {
 	return rotr32(x, 17) ^ rotr32(x, 19) ^ (x >> 10);
 }
 } // end of namespace emsha
 #endif	// __EMSHA_INTERNAL_HH
--- a/src/sha256.cc
+++ b/src/sha256.cc
@ -27,11 +27,9 @@
 #include <cstdint>
 #include <cstring>
-#include "emsha/emsha.h"
+#include <emsha/emsha.hh>
-#include "emsha/internal.h"
+#include <emsha/sha256.hh>
-#include "emsha/sha256.h"
+#include "internal.hh"
 #include <algorithm>
 #include <iostream>
 namespace emsha {
@ -40,51 +38,51 @@ namespace emsha {
 /*
 * SHA-256 constants, from FIPS 180-4 page 11.
 */
-static constexpr uint32_t sha256K[64] = {
+static constexpr uint32_t SHA256_K[64] = {
-    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
+        0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
-    0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+	0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
-    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+	0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
-    0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+	0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
-    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
+	0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
-    0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+	0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
-    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
+	0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
-    0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+	0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
-    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+	0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
-    0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+	0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
-    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
+	0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
-    0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+	0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
-    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
+	0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
-    0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+	0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
-    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+	0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
-    0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+	0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
 };
 /*
 * SHA-256 initialisation vector, from FIPS 180-4 page 15.
 */
-static constexpr uint32_t emsha256H0[] = {
+static constexpr uint32_t EMSHA_256_H0[] = {
-    0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A,
+	0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A,
-    0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19
+	0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19
 };
-EMSHAResult
+EMSHA_RESULT
-SHA256Digest(const uint8_t *m, uint32_t ml, uint8_t *d)
+sha256_digest(const uint8_t *m, uint32_t ml, uint8_t *d)
 {
-	SHA256      h;
+	SHA256		h;
-	EMSHAResult ret = EMSHAResult::Unknown;
+	EMSHA_RESULT	ret;
-	if (EMSHAResult::OK != (ret = h.Update(m, ml))) {
+	if (EMSHA_ROK != (ret = h.update(m, ml))) {
 		return ret;
 	}
-	return h.Finalise(d);
+	return h.finalize(d);
 }
 SHA256::SHA256()
-    : mlen(), hStatus(), hComplete(), mbi()
+	:mlen(), hstatus(), hcomplete(), mbi()
 {
 	this->reset();
 }
@ -92,433 +90,366 @@ SHA256::SHA256()
 SHA256::~SHA256()
 {
-	for (auto i = static_cast<uint32_t>(0); i < SHA256_MB_SIZE; i++) {
+	memset(this->mb, 0, SHA256_MB_SIZE);
 		this->mb[i] = static_cast<uint8_t>(0);
 	}
 }
-EMSHAResult
+inline EMSHA_RESULT
-SHA256::addLength(const uint32_t l)
+SHA256::add_length(uint32_t l)
 {
-	EMSHAResult res = EMSHAResult::InputTooLong;;
+        uint32_t        tmp = this->mlen + l;
-	uint32_t const tmp = static_cast<uint32_t>(this->mlen) + l;
+        if (tmp < this->mlen) {
-	if (tmp >= this->mlen) {
+                return SHA256_INPUT_TOO_LONG;
-		this->mlen = tmp;
+        }
-		assert(this->mlen > 0);
+        this->mlen = tmp;
-		res = EMSHAResult::OK;
+	assert(this->mlen > 0);
 	}
-	return res;
+        return EMSHA_ROK;
 }
-EMSHAResult
+EMSHA_RESULT
 SHA256::Reset()
 {
 	return this->reset();
 }
 EMSHAResult
 SHA256::reset()
 {
 	// The message block is set to the initial hash vector.
-	this->i_hash[0] = emsha256H0[0];
+	this->i_hash[0] = EMSHA_256_H0[0];
-	this->i_hash[1] = emsha256H0[1];
+	this->i_hash[1] = EMSHA_256_H0[1];
-	this->i_hash[2] = emsha256H0[2];
+	this->i_hash[2] = EMSHA_256_H0[2];
-	this->i_hash[3] = emsha256H0[3];
+	this->i_hash[3] = EMSHA_256_H0[3];
-	this->i_hash[4] = emsha256H0[4];
+	this->i_hash[4] = EMSHA_256_H0[4];
-	this->i_hash[5] = emsha256H0[5];
+	this->i_hash[5] = EMSHA_256_H0[5];
-	this->i_hash[6] = emsha256H0[6];
+	this->i_hash[6] = EMSHA_256_H0[6];
-	this->i_hash[7] = emsha256H0[7];
+	this->i_hash[7] = EMSHA_256_H0[7];
-	this->mbi       = 0;
+	this->mbi = 0;
-	this->hStatus   = EMSHAResult::OK;
+	this->hstatus = EMSHA_ROK;
-	this->hComplete = 0;
+	this->hcomplete = 0;
-	this->mlen      = 0;
+	this->mlen = 0;
 	memset(this->mb, 0, SHA256_MB_SIZE);
-	std::fill(this->mb.begin(), this->mb.end(), 0);
+	return this->hstatus;
 	return this->hStatus;
 }
-uint32_t
+// Read 32 bits from the byte buffer chunk as an unsigned 32-bit integer.
-SHA256::chunkToUint32(uint32_t offset)
+static inline uint32_t
 chunk_to_uint32(uint8_t *chunk)
 {
-	uint32_t chunk = 0U;
+        return ((*chunk) << 24)         |
-
+               ((*(chunk + 1)) << 16)   |
-	for (uint32_t i = offset; i < offset+4U; i++) {
+               ((*(chunk + 2)) << 8)    |
-		chunk <<= 8;
+               (*(chunk + 3));
 		chunk += static_cast<uint32_t>(this->mb[i]);
 	}
 	return chunk;
 }
-uint32_t
+// Copy an unsigned 32-bit integer into the start of the byte buffer chunk.
-SHA256::uint32ToChunk(uint32_t offset)
+static inline void
 uint32_to_chunk(uint32_t x, uint8_t *chunk)
 {
-	uint32_t chunk = 0U;
+        chunk[0] = (x & 0xff000000) >> 24;
-
+        chunk[1] = (x & 0x00ff0000) >> 16;
-	for (uint32_t i = offset; i < offset+4U; i++) {
+        chunk[2] = (x & 0x0000ff00) >> 8;
-		chunk <<= 8;
+        chunk[3] = (x & 0x000000ff);
 		chunk += static_cast<uint32_t>(this->mb[i]);
 	}
 	return chunk;
 }
 static void
 uint32ToChunkInPlace(uint32_t x, uint8_t *chunk)
 {
 	chunk[0] = static_cast<uint8_t>((x & 0xff000000u) >> 24);
 	chunk[1] = static_cast<uint8_t>((x & 0x00ff0000u) >> 16);
 	chunk[2] = static_cast<uint8_t>((x & 0x0000ff00U) >> 8);
 	chunk[3] = static_cast<uint8_t>(x & 0x000000ffU);
 }
 // FIPS 180-4, page 22.
 void
-SHA256::updateMessageBlock()
+SHA256::update_message_block()
 {
-	uint32_t w[64];
+        uint32_t	w[64];
-	uint32_t i     = 0U;
+        uint32_t        i = 0;
-	uint32_t chunk = 0U;
+        uint32_t        chunk = 0;
-	uint32_t a     = 0U;
+        uint32_t        a, b, c, d, e, f, g, h;
 	uint32_t b     = 0U;
 	uint32_t c     = 0U;
 	uint32_t d     = 0U;
 	uint32_t e     = 0U;
 	uint32_t f     = 0U;
 	uint32_t g     = 0U;
 	uint32_t h     = 0U;
-	while (i < 16U) {
+        while (i < 16) {
-		w[i++] = this->chunkToUint32(chunk);
+                w[i++] = chunk_to_uint32(this->mb + chunk);
-		chunk += 4U;
+                chunk += 4;
-	}
+        }
-	this->mbi = 0U;
+        this->mbi = 0;
-	for (i = 16U; i < 64U; i++) {
+        for (i = 16; i < 64; i++) {
-		w[i] = sha_sigma1(w[i - 2U]) + w[i - 7U] +
+                w[i] = sha_sigma1(w[i - 2]) + w[i - 7] +
-		       sha_sigma0(w[i - 15U]) + w[i - 16U];
+                    sha_sigma0(w[i - 15]) + w[i - 16];
-	}
+        }
-	a = this->i_hash[0];
+        a = this->i_hash[0];
-	b = this->i_hash[1];
+        b = this->i_hash[1];
-	c = this->i_hash[2];
+        c = this->i_hash[2];
-	d = this->i_hash[3];
+        d = this->i_hash[3];
-	e = this->i_hash[4];
+        e = this->i_hash[4];
-	f = this->i_hash[5];
+        f = this->i_hash[5];
-	g = this->i_hash[6];
+        g = this->i_hash[6];
-	h = this->i_hash[7];
+        h = this->i_hash[7];
-	for (i = 0U; i < 64U; i++) {
+        for (i = 0; i < 64; i++) {
-		uint32_t t1 = 0U;
+		uint32_t        t1, t2;
-		uint32_t t2 = 0U;
+                t1 = h + sha_Sigma1(e) + sha_ch(e, f, g) + SHA256_K[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;
+                g = f;
-		g  = f;
+                f = e;
-		f  = e;
+                e = d + t1;
-		e  = d + t1;
+                d = c;
-		d  = c;
+                c = b;
-		c  = b;
+                b = a;
-		b  = a;
+                a = t1 + t2;
-		a  = t1 + t2;
+        }
 	}
-	this->i_hash[0] += a;
+        this->i_hash[0] += a;
-	this->i_hash[1] += b;
+        this->i_hash[1] += b;
-	this->i_hash[2] += c;
+        this->i_hash[2] += c;
-	this->i_hash[3] += d;
+        this->i_hash[3] += d;
-	this->i_hash[4] += e;
+        this->i_hash[4] += e;
-	this->i_hash[5] += f;
+        this->i_hash[5] += f;
-	this->i_hash[6] += g;
+        this->i_hash[6] += g;
-	this->i_hash[7] += h;
+        this->i_hash[7] += h;
 }
-EMSHAResult
+EMSHA_RESULT
-SHA256::Update(const std::uint8_t *message, std::uint32_t messageLength)
+SHA256::update(const uint8_t *m, uint32_t ml)
 {
-	EMSHAResult res;
+        // Checking invariants:
 	// Checking invariants:
 	// If the message length is zero, there's nothing to be done.
-	if (messageLength == 0U) { res = EMSHAResult::OK; }
+	if (0 == ml)				return EMSHA_ROK;
 	// The message passed in cannot be the null pointer if the
 	// message length is greater than 0.
-	else if (message == nullptr) { res = EMSHAResult::NullPointer; }
+	if (nullptr == m)			return EMSHA_NULLPTR;
 	// If the SHA256 object is in a bad state, don't proceed.
-	else if (this->hStatus != EMSHAResult::OK) { res = this->hStatus; }
+	if (EMSHA_ROK != this->hstatus)		return this->hstatus;
 	// If the hash has been finalised, don't proceed.
-	else if (this->hComplete != 0U) { res = EMSHAResult::InvalidState; }
+	if (0 != this->hcomplete)		return EMSHA_INVALID_STATE;
        // Invariants satisfied by here.
-	// Invariants satisfied by here.
+        for (uint32_t i = 0; i < ml; i++) {
-	else {
+                this->mb[this->mbi] = *(m + i);
-		for (uint32_t i = 0U; i < messageLength; i++) {
+                mbi++;
 			this->mb[this->mbi] = *(message + i);
 			mbi++;
-			if (EMSHAResult::OK == this->addLength(8U)) {
+		if (EMSHA_ROK == this->add_length(8)) {
-				if (SHA256_MB_SIZE == this->mbi) {
+			if (SHA256_MB_SIZE == this->mbi) {
-					this->updateMessageBlock();
+				this->update_message_block();
-					// Assumption: following the message block
+				// Assumption: following the message block
-					// write, the context should still be in a good
+				// write, the context should still be in a good
-					// state.
+				// state.
-					assert(EMSHAResult::OK == this->hStatus);
+				assert(EMSHA_ROK == this->hstatus);
 				}
 			}
 		}
        }
-		res = this->hStatus;
+	return this->hstatus;
 	}
 	return res;
 }
 inline void
-SHA256::padMessage(uint8_t pc)
+SHA256::pad_message(uint8_t pc)
 {
 	// Assumption: the context is not in a corrupted state.
-	assert(EMSHAResult::OK == this->hStatus);
+	assert(EMSHA_ROK == this->hstatus);
-	if (this->mbi < (SHA256_MB_SIZE - 8U)) {
+        if (this->mbi < (SHA256_MB_SIZE - 8)) {
-		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 - 1U) {
+                if (this->mbi < SHA256_MB_SIZE - 1) {
-			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++] = 0U;
+                        this->mb[this->mbi++] = 0;
-		}
+                }
-		this->updateMessageBlock();
+                this->update_message_block();
-		if (!pc_add) {
+                if (!pc_add) {
-			this->mb[this->mbi++] = pc;
+                        this->mb[this->mbi++] = pc;
-		}
+                }
 		// Assumption: updating the message block has not left the
 		// context in a corrupted state.
-		assert(EMSHAResult::OK == this->hStatus);
+		assert(EMSHA_ROK == this->hstatus);
-	}
+        }
-	while (this->mbi < (SHA256_MB_SIZE - 8U)) {
+        while (this->mbi < (SHA256_MB_SIZE - 8)) {
-		this->mb[this->mbi++] = 0U;
+                this->mb[this->mbi++] = 0;
-	}
+        }
-	// 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 - 8U;
+        uint32_t        lstart = SHA256_MB_SIZE - 8;
-	this->mb[lstart] = static_cast<uint8_t>(this->mlen >> 56);
+        this->mb[lstart] = (uint8_t)(this->mlen >> 56);
-	this->mb[lstart + 1U] =
+        this->mb[lstart+1] =
-	    static_cast<uint8_t>((this->mlen & 0x00ff000000000000U) >> 48);
+            (uint8_t)((this->mlen & 0x00ff000000000000L) >> 48);
-	this->mb[lstart + 2U] =
+        this->mb[lstart+2] =
-	    static_cast<uint8_t>((this->mlen & 0x0000ff0000000000U) >> 40);
+            (uint8_t)((this->mlen & 0x0000ff0000000000L) >> 40);
-	this->mb[lstart + 3U] =
+        this->mb[lstart+3] =
-	    static_cast<uint8_t>((this->mlen & 0x000000ff00000000U) >> 32);
+            (uint8_t)((this->mlen & 0x000000ff00000000L) >> 32);
-	this->mb[lstart + 4U] =
+        this->mb[lstart+4] =
-	    static_cast<uint8_t>((this->mlen & 0x00000000ff000000U) >> 24);
+            (uint8_t)((this->mlen & 0x00000000ff000000L) >> 24);
-	this->mb[lstart + 5U] =
+        this->mb[lstart+5] =
-	    static_cast<uint8_t>((this->mlen & 0x0000000000ff0000U) >> 16);
+            (uint8_t)((this->mlen & 0x0000000000ff0000L) >> 16);
-	this->mb[lstart + 6U] =
+        this->mb[lstart+6] =
-	    static_cast<uint8_t>((this->mlen & 0x000000000000ff00U) >> 8);
+            (uint8_t)((this->mlen & 0x000000000000ff00L) >> 8);
-	this->mb[lstart + 7U] =
+        this->mb[lstart+7] =
-	    static_cast<uint8_t>(this->mlen & 0x00000000000000ffUL);
+            (uint8_t)(this->mlen & 0x00000000000000ffL);
-	this->updateMessageBlock();
+        this->update_message_block();
 	// Assumption: updating the message block has not left the context in a
 	// corrupted state.
-	assert(EMSHAResult::OK == this->hStatus);
+	assert(EMSHA_ROK == this->hstatus);
 }
-EMSHAResult
+EMSHA_RESULT
-SHA256::Finalise(std::uint8_t *digest)
+SHA256::finalize(uint8_t *d)
 {
-	EMSHAResult	res;
+        // Check invariants.
-
+        // The digest cannot be a null pointer; this library allocates
-	// Check invariants.
+        // no memory of its own.
-	// The digest cannot be a null pointer; this library allocates
+	if (nullptr == d)			return EMSHA_NULLPTR;
 	// no memory of its own.
 	if (digest == nullptr) { res = EMSHAResult::NullPointer; }
 	// If the SHA256 object is in a bad state, don't proceed.
-	else if (this->hStatus != EMSHAResult::OK) { res = this->hStatus; }
+	if (EMSHA_ROK != this->hstatus)	return this->hstatus;
 	// If the hash has been finalised, don't proceed.
-	else if (this->hComplete != 0U) { res = EMSHAResult::InvalidState; }
+	if (0 != this->hcomplete)		return EMSHA_INVALID_STATE;
        // Invariants satisfied by here.
-	// Invariants satisfied by here.
+        this->pad_message(0x80);
-	else {
+	
-		this->padMessage(0x80U);
+	// Assumption: padding the message block has not left the context in a
 	// corrupted state.
 	assert(EMSHA_ROK == this->hstatus);
        for (uint8_t i = 0; i < SHA256_MB_SIZE; i++) {
                this->mb[i] = 0;
        }
-		// Assumption: padding the message block has not left the context in a
+        this->hcomplete = 1;
-		// corrupted state.
+        this->mlen = 0;
 		assert(EMSHAResult::OK == this->hStatus);
 		std::fill(this->mb.begin(), this->mb.end(), 0);
-		this->hComplete = 1U;
+        uint32_to_chunk(this->i_hash[0], d);
-		this->mlen      = 0U;
+        uint32_to_chunk(this->i_hash[1], d+4);
        uint32_to_chunk(this->i_hash[2], d+8);
        uint32_to_chunk(this->i_hash[3], d+12);
        uint32_to_chunk(this->i_hash[4], d+16);
        uint32_to_chunk(this->i_hash[5], d+20);
        uint32_to_chunk(this->i_hash[6], d+24);
        uint32_to_chunk(this->i_hash[7], d+28);
-		uint32ToChunkInPlace(this->i_hash[0], digest);
+        return EMSHA_ROK;
 		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);
 		res = EMSHAResult::OK;
 	}
 	return res;
 }
-EMSHAResult
+EMSHA_RESULT
-SHA256::Result(std::uint8_t *digest)
+SHA256::result(uint8_t *d)
 {
-	EMSHAResult res;
+        // Check invariants.
-	// Check invariants.
+        // The digest cannot be a null pointer; this library allocates
-
+        // no memory of its own.
-	// The digest cannot be a null pointer; this library allocates
+	if (nullptr == d)			return EMSHA_NULLPTR;
 	// no memory of its own.
 	if (nullptr == digest) { res = EMSHAResult::NullPointer; }
 	// If the SHA256 object is in a bad state, don't proceed.
-	else if (this->hStatus != EMSHAResult::OK) { res = this->hStatus; }
+	if (EMSHA_ROK != this->hstatus)	return this->hstatus;
        // Invariants satisfied by here.
-	// Invariants satisfied by here.
+        if (!this->hcomplete) {
-	else if (this->hComplete == 0U) {
+                return this->finalize(d);
-		res = this->Finalise(digest);
+        }
 	}
-	else {
+        uint32_to_chunk(this->i_hash[0], d);
-		uint32ToChunkInPlace(this->i_hash[0], digest);
+        uint32_to_chunk(this->i_hash[1], d+4);
-		uint32ToChunkInPlace(this->i_hash[1], digest + 4);
+        uint32_to_chunk(this->i_hash[2], d+8);
-		uint32ToChunkInPlace(this->i_hash[2], digest + 8);
+        uint32_to_chunk(this->i_hash[3], d+12);
-		uint32ToChunkInPlace(this->i_hash[3], digest + 12);
+        uint32_to_chunk(this->i_hash[4], d+16);
-		uint32ToChunkInPlace(this->i_hash[4], digest + 16);
+        uint32_to_chunk(this->i_hash[5], d+20);
-		uint32ToChunkInPlace(this->i_hash[5], digest + 20);
+        uint32_to_chunk(this->i_hash[6], d+24);
-		uint32ToChunkInPlace(this->i_hash[6], digest + 24);
+        uint32_to_chunk(this->i_hash[7], d+28);
 		uint32ToChunkInPlace(this->i_hash[7], digest + 28);
 		res = EMSHAResult::OK;
 	}
-	return res;
+        return EMSHA_ROK;
 }
 std::uint32_t
 SHA256::Size()
 {
 	return SHA256_HASH_SIZE;
 }
 #ifndef EMSHA_NO_SELFTEST
-static const uint8_t emptyVector[] = {
+static const uint8_t empty_vector[] = {
-    0xe3, 0xb0, 0xc4, 0x42,
+        0xe3, 0xb0, 0xc4, 0x42,
-    0x98, 0xfc, 0x1c, 0x14,
+        0x98, 0xfc, 0x1c, 0x14,
-    0x9a, 0xfb, 0xf4, 0xc8,
+        0x9a, 0xfb, 0xf4, 0xc8,
-    0x99, 0x6f, 0xb9, 0x24,
+        0x99, 0x6f, 0xb9, 0x24,
-    0x27, 0xae, 0x41, 0xe4,
+        0x27, 0xae, 0x41, 0xe4,
-    0x64, 0x9b, 0x93, 0x4c,
+        0x64, 0x9b, 0x93, 0x4c,
-    0xa4, 0x95, 0x99, 0x1b,
+        0xa4, 0x95, 0x99, 0x1b,
-    0x78, 0x52, 0xb8, 0x55
+        0x78, 0x52, 0xb8, 0x55
 };
-static const uint8_t helloWorld[] = {
+static const uint8_t hello_world[] = {
-    0x09, 0xca, 0x7e, 0x4e,
+        0x09, 0xca, 0x7e, 0x4e,
-    0xaa, 0x6e, 0x8a, 0xe9,
+        0xaa, 0x6e, 0x8a, 0xe9,
-    0xc7, 0xd2, 0x61, 0x16,
+        0xc7, 0xd2, 0x61, 0x16,
-    0x71, 0x29, 0x18, 0x48,
+        0x71, 0x29, 0x18, 0x48,
-    0x83, 0x64, 0x4d, 0x07,
+        0x83, 0x64, 0x4d, 0x07,
-    0xdf, 0xba, 0x7c, 0xbf,
+        0xdf, 0xba, 0x7c, 0xbf,
-    0xbc, 0x4c, 0x8a, 0x2e,
+        0xbc, 0x4c, 0x8a, 0x2e,
-    0x08, 0x36, 0x0d, 0x5b,
+        0x08, 0x36, 0x0d, 0x5b,
 };
-constexpr uint32_t EMSHA_SELF_TEST_ITERS = 4;
+constexpr uint32_t	EMSHA_SELF_TEST_ITERS = 4;
-static EMSHAResult
+static EMSHA_RESULT
-runTest(const uint8_t *input, uint32_t input_len, const uint8_t *expected)
+run_test(const uint8_t *input, uint32_t input_len, const uint8_t *expected)
 {
-	uint8_t            hexString[65]{0};
+        uint8_t                 d[SHA256_HASH_SIZE];
-	uint8_t            d[SHA256_HASH_SIZE]{0};
+        emsha::SHA256           ctx;
-	emsha::SHA256      ctx;
+        emsha::EMSHA_RESULT    res;
 	emsha::EMSHAResult res;
-	res = ctx.Update(input, input_len);
+        res = ctx.update(input, input_len);
-	if (EMSHAResult::OK != res) {
+        if (EMSHA_ROK != res) {
-		return res;
+                return res;
-	}
+        }
 	for (uint32_t n = 0; n < EMSHA_SELF_TEST_ITERS; n++) {
-		res = ctx.Result(d);
+		res = ctx.result(d);
-		if (EMSHAResult::OK != res) {
+		if (EMSHA_ROK != res) {
 			return res;
 		}
 		for (uint32_t i = 0; i < SHA256_HASH_SIZE; i++) {
 			if (expected[i] != d[i]) {
-				HexString(hexString, const_cast<uint8_t *>(d), 32);
+				return EMSHA_TEST_FAILURE;
 				std::cerr << "[!] have: " << hexString << "\n";
 				HexString(hexString, const_cast<uint8_t *>(helloWorld), 32);
 				std::cerr << "[!] want: " << hexString << "\n";
 				return EMSHAResult::TestFailure;
 			}
 		}
 	}
-	return EMSHAResult::OK;
+        return EMSHA_ROK;
 }
-EMSHAResult
+EMSHA_RESULT
-SHA256SelfTest()
+sha256_self_test()
 {
-	EMSHAResult res;
+        EMSHA_RESULT   res;
-	res = runTest(reinterpret_cast<const uint8_t *>(""), 0, emptyVector);
+        res = run_test((const uint8_t *)"", 0, empty_vector);
-	if (EMSHAResult::OK == res) {
+        if (EMSHA_ROK == res) {
-		res = runTest(reinterpret_cast<const uint8_t *>("hello, world"), 12, helloWorld);
+                res = run_test((const uint8_t *)"hello, world", 12, hello_world);
-		if (res != EMSHAResult::OK) {
+        }
 			std::cerr << "[!] failed on hello, world.\n";
 		}
 	} else {
 		std::cerr << "[!] failed on empty vector\n";
 	}
-	return res;
+        return res;
 }
 #else // #ifdef EMSHA_NO_SELFTEST
-EMSHAResult
+EMSHA_RESULT
 sha256_self_test()
 {
-	return EMSHAResult::SelfTestDisabled;
+	return EMSHA_SELFTEST_DISABLED;
 }
--- a/test/test_emsha.cc
+++ b/test/test_emsha.cc
@ -23,41 +23,45 @@
 */
 #include "emsha/emsha.h"
 #include <chrono>
 #include <iostream>
-#include "test_utils.h"
+#include <emsha/emsha.hh>
 #include "test_utils.hh"
 using namespace std;
 // how many test runs to benchmark hex strings?
 static constexpr auto testIterations = 32768;
 #ifndef EMSHA_NO_HEXSTRING
 static void
-hexStringTest()
+hexstring_test(void)
 {
-	uint8_t buf[32];
+	uint8_t	buf[32];
-	uint8_t out[65];
+	uint8_t	out[65];
-	string  const expected = "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f";
+	string	expected = "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f";
 	out[64] = 0;
 	for (uint32_t i = 0; i < 32; i++) {
-		buf[i] = static_cast<uint8_t>(i);
+		buf[i] = (uint8_t)i;
 	}
-	emsha::HexString(out, buf, emsha::SHA256_HASH_SIZE);
+	emsha::hexstring(out, buf, emsha::SHA256_HASH_SIZE);
-	string const outs(reinterpret_cast<const char *>(out));
+	string	outs(reinterpret_cast<const char *>(out));
 	if (outs != expected) {
-		cerr << "FAILED: HexString\n";
+		cerr << "FAILED: hexstring" << endl;
-		cerr << "\twanted: " << expected << "\n";
+		cerr << "\twanted: " << expected << endl;
-		cerr << "\thave:   " << out << "\n";
+		cerr << "\thave:   " << out << endl;
 		exit(1);
 	}
 	cout << "PASSED: hexstring ";
 #ifdef EMSHA_NO_HEXLUT
 	cout << "(small LUT)";
 #else // #ifdef EMSHA_NO_HEXLUT
 	cout << "(large LUT)";
 #endif // #ifdef EMSHA_NO_HEXLUT
 	cout << endl;
 }
 #endif // #ifndef EMSHA_NO_HEXSTRING
@ -65,24 +69,24 @@ hexStringTest()
 // TODO(kyle): build a test harness around this to verify times between
 // runs.
 static void
-hashEqualTest()
+hash_equal_test(void)
 {
-	uint8_t a[emsha::SHA256_HASH_SIZE];
+	uint8_t		a[emsha::SHA256_HASH_SIZE];
-	uint8_t b[emsha::SHA256_HASH_SIZE];
+	uint8_t		b[emsha::SHA256_HASH_SIZE];
 	for (uint32_t i = 0; i < emsha::SHA256_HASH_SIZE; i++) {
 		a[i] = static_cast<uint8_t>(i);
 		b[i] = static_cast<uint8_t>(i);
 	}
-	if (!(emsha::HashEqual(a, b))) {
+	if (!(emsha::hash_equal(a, b))) {
-		string s;
+		string	s;
-		cerr << "FAILED: HashEqual\n";
+		cerr << "FAILED: hash_equal\n";
-		cerr << "\tHashEqual should have succeeded comparing a and b.\n";
+		cerr << "\thash_equal should have succeeded comparing a and b.\n";
-		DumpHexString(s, a, emsha::SHA256_HASH_SIZE);
+		dump_hexstring(s, a, emsha::SHA256_HASH_SIZE);
-		cerr << "\ta <- " << s << "\n";
+		cerr << "\ta <- " << s << std::endl;
-		DumpHexString(s, b, emsha::SHA256_HASH_SIZE);
+		dump_hexstring(s, b, emsha::SHA256_HASH_SIZE);
-		cerr << "\tb <- " << s << "\n";
+		cerr << "\tb <- " << s << std::endl;
 		exit(1);
 	}
@ -91,14 +95,14 @@ hashEqualTest()
 		b[i] = static_cast<uint8_t>(emsha::SHA256_HASH_SIZE - i);
 	}
-	if (emsha::HashEqual(a, b)) {
+	if (emsha::hash_equal(a, b)) {
-		string s;
+		string	s;
-		cerr << "FAILED: HashEqual\n";
+		cerr << "FAILED: hash_equal\n";
-		cerr << "\tHashEqual should not have succeeded comparing a and b.\n";
+		cerr << "\thash_equal should not have succeeded comparing a and b.\n";
-		DumpHexString(s, a, emsha::SHA256_HASH_SIZE);
+		dump_hexstring(s, a, emsha::SHA256_HASH_SIZE);
-		cerr << "\ta <- " << s << "\n";
+		cerr << "\ta <- " << s << std::endl;
-		DumpHexString(s, b, emsha::SHA256_HASH_SIZE);
+		dump_hexstring(s, b, emsha::SHA256_HASH_SIZE);
-		cerr << "\tb <- " << s << "\n";
+		cerr << "\tb <- " << s << std::endl;
 		exit(1);
 	}
@ -108,47 +112,32 @@ hashEqualTest()
 	//         res += a[i] ^ b[i];
 	for (uint32_t i = 0; i < emsha::SHA256_HASH_SIZE; i++) {
 		a[i] = static_cast<uint8_t>(i);
-		b[i] = static_cast<uint8_t>(i + 1);
+		b[i] = static_cast<uint8_t>(i+1);
 	}
 	b[emsha::SHA256_HASH_SIZE - 1]--;
-	if (emsha::HashEqual(a, b)) {
+	if (emsha::hash_equal(a, b)) {
-		string s;
+		string	s;
-		cerr << "FAILED: HashEqual\n";
+		cerr << "FAILED: hash_equal\n";
-		cerr << "\tREGRESSION: HashEqual should not have succeeded comparing a and b.\n";
+		cerr << "\tREGRESSION: hash_equal should not have succeeded comparing a and b.\n";
-		DumpHexString(s, a, emsha::SHA256_HASH_SIZE);
+		dump_hexstring(s, a, emsha::SHA256_HASH_SIZE);
 		cerr << "\ta <- " << s << std::endl;
-		DumpHexString(s, b, emsha::SHA256_HASH_SIZE);
+		dump_hexstring(s, b, emsha::SHA256_HASH_SIZE);
 		cerr << "\tb <- " << s << std::endl;
 		exit(1);
 	}
 	cout << "PASSED: hash_equal\n";
 }
 int
-main()
+main(void)
 {
 	auto start = std::chrono::steady_clock::now();
 	std::string testLabel;
 	for (auto i = 0; i < testIterations; i++) {
 #ifndef EMSHA_NO_HEXSTRING
-#ifndef EMSHA_NO_HEXLUT
+	hexstring_test();
 		testLabel = "(large LUT) ";
 #endif
-		hexStringTest();
+	hash_equal_test();
 #endif
 		hashEqualTest();
 	}
 	auto end   = std::chrono::steady_clock::now();
 	auto delta = (end - start);
 	std::cout << "Passed HexString " << testLabel << "tests.\n";
 	std::cout << "Total time: "
 		  << std::chrono::duration<double, std::milli>(delta).count()
 		  << " ms\n";
 	std::cout << "Average over " << testIterations << " tests: "
 		  << std::chrono::duration<double, std::nano>(delta).count() / testIterations
 		  << " ns\n";
 }
--- a/test/test_hmac.cc
+++ b/test/test_hmac.cc
@ -25,15 +25,15 @@
 #include <iostream>
-#include "emsha/emsha.h"
+#include <emsha/emsha.hh>
-#include "emsha/hmac.h"
+#include <emsha/hmac.hh>
-#include "test_utils.h"
+#include "test_utils.hh"
 using namespace std;
-const struct hmacTest rfc4231[] = {
+const struct hmac_test	rfc4231[] = {
 	{
 		{0x0b, 0x0b, 0x0b, 0x0b,
 		 0x0b, 0x0b, 0x0b, 0x0b,
@ -122,13 +122,13 @@ const struct hmacTest rfc4231[] = {
 int
-main()
+main(void)
 {
-	int	res = 0;
+	int	res;
-	res = runHMACTests((struct hmacTest *) rfc4231,
+	res = run_hmac_tests((struct hmac_test *)rfc4231, 
-			   sizeof rfc4231 / sizeof rfc4231[0],
+	    sizeof rfc4231 / sizeof rfc4231[0],
-			   "RFC 4231");
+	    "RFC 4231");
 	if (-1 == res) {
 		exit(1);
 	}
--- a/src/test_mem.cc
+++ b/src/test_mem.cc
@ -0,0 +1,214 @@
 /*
 * The MIT License (MIT)
 *
 * Copyright (c) 2015 K. Isom <coder@kyleisom.net>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * copy of this  software and associated documentation  files (the "Software"),
 * to deal  in the Software  without restriction, including  without limitation
 * the rights  to use,  copy, modify,  merge, publish,  distribute, sublicense,
 * and/or  sell copies  of the  Software,  and to  permit persons  to whom  the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS  PROVIDED "AS IS", WITHOUT WARRANTY OF  ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING  BUT NOT  LIMITED TO  THE WARRANTIES  OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS  OR COPYRIGHT  HOLDERS BE  LIABLE FOR  ANY CLAIM,  DAMAGES OR  OTHER
 * LIABILITY,  WHETHER IN  AN ACTION  OF CONTRACT,  TORT OR  OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 */
 #ifdef NDEBUG
 #undef NDEBUG
 #endif
 #include <cassert>
 #include <chrono>
 #include <cstring>
 #include <algorithm>
 #include <cstdio>
 #include <iostream>
 #include <emsha/emsha.hh>
 #include <emsha/sha256.hh>
 #include <emsha/hmac.hh>
 // Number of test iterations.
 static constexpr std::uint32_t	ITERS = 3000000;
 // The key used for HMAC.
 static constexpr std::uint8_t	k[] = {
 	0xc5, 0xb6, 0x80, 0xac, 0xdc, 0xf4, 0xff, 0xa1,
 	0x37, 0x05, 0xc0, 0x71, 0x11, 0x24, 0x31, 0x7c,
 	0xa5, 0xa2, 0xcf, 0x4d, 0x33, 0x00, 0x56, 0x4f,
 	0x69, 0x0f, 0x76, 0x70, 0x87, 0xd9, 0x35, 0xce,
 	0xa3, 0xad, 0xa3, 0x4f, 0x30, 0xe2, 0x7c, 0x58,
 	0x88, 0xd4, 0x89, 0x6a, 0xb5, 0xe0, 0x97, 0x1c,
 	0x7a, 0x69, 0x65, 0xc7, 0x61, 0x0d, 0x6d, 0xb6,
 	0x9b, 0x0e, 0x56, 0xd7, 0x0f, 0x5a, 0x01, 0x50,
 };
 static constexpr std::uint32_t	kl = sizeof(k) / sizeof(k[0]);
 // The message provided to both SHA-256 and HMAC-SHA-256; it is
 // "The fugacity of a constituent in a mixture of gases at a given
 // temperature is proportional to its mole fraction.  Lewis-Randall Rule",
 // chosen as one of the longer test vectors.
 static const std::uint8_t	m[] = {
 	0x54, 0x68, 0x65, 0x20, 0x66, 0x75, 0x67, 0x61,
 	0x63, 0x69, 0x74, 0x79, 0x20, 0x6f, 0x66, 0x20,
 	0x61, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x69,
 	0x74, 0x75, 0x65, 0x6e, 0x74, 0x20, 0x69, 0x6e,
 	0x20, 0x61, 0x20, 0x6d, 0x69, 0x78, 0x74, 0x75,
 	0x72, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x67, 0x61,
 	0x73, 0x65, 0x73, 0x20, 0x61, 0x74, 0x20, 0x61,
 	0x20, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x74,
 	0x65, 0x6d, 0x70, 0x65, 0x72, 0x61, 0x74, 0x75,
 	0x72, 0x65, 0x20, 0x69, 0x73, 0x20, 0x70, 0x72,
 	0x6f, 0x70, 0x6f, 0x72, 0x74, 0x69, 0x6f, 0x6e,
 	0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x74,
 	0x73, 0x20, 0x6d, 0x6f, 0x6c, 0x65, 0x20, 0x66,
 	0x72, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e,
 	0x20, 0x20, 0x4c, 0x65, 0x77, 0x69, 0x73, 0x2d,
 	0x52, 0x61, 0x6e, 0x64, 0x61, 0x6c, 0x6c, 0x20,
 	0x52, 0x75, 0x6c, 0x65
 };
 // d is the expected result of SHA256(m).
 static constexpr std::uint8_t	d[emsha::SHA256_HASH_SIZE] = {
 	0x39, 0x55, 0x85, 0xce, 0x30, 0x61, 0x7b, 0x62,
 	0xc8, 0x0b, 0x93, 0xe8, 0x20, 0x8c, 0xe8, 0x66,
 	0xd4, 0xed, 0xc8, 0x11, 0xa1, 0x77, 0xfd, 0xb4,
 	0xb8, 0x2d, 0x39, 0x11, 0xd8, 0x69, 0x64, 0x23
 };
 // t is the expected result of HMAC-SHA-256(k, m).
 static constexpr std::uint8_t	t[emsha::SHA256_HASH_SIZE] = {
 	0xbb, 0xc4, 0x7c, 0x35, 0x33, 0x4b, 0x9d, 0x90,
 	0xee, 0x20, 0x88, 0x30, 0xe1, 0x1a, 0x0f, 0xf3,
 	0xf4, 0x7d, 0xcc, 0xb0, 0xc5, 0xfb, 0x83, 0xe5,
 	0xc2, 0xf5, 0xa7, 0x94, 0x50, 0xb6, 0xe0, 0xe0,
 };
 // dig is used to store the output of SHA-256 and HMAC-SHA-256.
 static std::uint8_t		dig[emsha::SHA256_HASH_SIZE];
 static void
 init(void)
 {
 	std::fill(dig, dig+emsha::SHA256_HASH_SIZE, 0);
 }
 static void
 iterate_sha(void)
 {
 	emsha::SHA256		ctx;
 	int			cmp;
 	emsha::EMSHA_RESULT	res;
 	res = ctx.update(m, sizeof(m));
 	assert(emsha::EMSHA_ROK == res);
 	res = ctx.result(dig);
 	assert(emsha::EMSHA_ROK == res);
 	cmp = std::memcmp(dig, d, emsha::SHA256_HASH_SIZE);
 	assert(0 == cmp);
 }
 static void
 iterate_hmac(void)
 {
 	emsha::HMAC		ctx(k, kl);
 	int			cmp;
 	emsha::EMSHA_RESULT	res;
 	res = ctx.update(m, sizeof(m));
 	assert(emsha::EMSHA_ROK == res);
 	res = ctx.result(dig);
 	assert(emsha::EMSHA_ROK == res);
 	cmp = std::memcmp(dig, t, emsha::SHA256_HASH_SIZE);
 	assert(0 == cmp);
 }
 static void
 iterate_sha_sp(void)
 {
 	int		cmp;
 	assert(emsha::EMSHA_ROK == emsha::sha256_digest(m, sizeof(m), dig));
 	cmp = std::memcmp(dig, d, emsha::SHA256_HASH_SIZE);
 	assert(0 == cmp);
 }
 static void
 iterate_hmac_sp(void)
 {
 	int			cmp;
 	emsha::EMSHA_RESULT	res;
 	res = emsha::compute_hmac(k, kl, m, sizeof(m), dig);
 	assert(emsha::EMSHA_ROK == res);
 	cmp = std::memcmp(dig, t, emsha::SHA256_HASH_SIZE);
 	assert(0 == cmp);
 }
 static void
 iterate(std::string label, void(iteration)(void))
 {
 	std::cout << "=== " << label << " ===" << std::endl;
 	auto start = std::chrono::steady_clock::now();
 	for (std::uint32_t i = 0; i < ITERS; i++)
 		iteration();
 	auto end = std::chrono::steady_clock::now();
 	auto delta = (end - start );
 	std::cout << "Total time: "
 	    << std::chrono::duration <double, std::milli>(delta).count()
 	    << " ms" << std::endl;
 	std::cout << "Average over " << ITERS << " tests: "
 	    << std::chrono::duration <double, std::nano>(delta).count() / ITERS
 	    << " ns" << std::endl;
 }
 static void
 cold_start(void)
 {
 	std::cout << "=== SHA-256 cold start ===\n";
 	auto start = std::chrono::steady_clock::now();
 	iterate_sha();
 	auto end = std::chrono::steady_clock::now();
 	auto delta = (end - start );
 	std::cout << "Total time: "
 	    << std::chrono::duration <double, std::nano>(delta).count()
 	    << " ns" << std::endl;
 }
 int
 main(void)
 {
 	init();
 	cold_start();
 	iterate("SHA-256", iterate_sha);
 	iterate("SHA-256 single-pass", iterate_sha_sp);
 	iterate("HMAC-SHA-256", iterate_hmac);
 	iterate("HMAC-SHA-256 single-pass", iterate_hmac_sp);
 }
--- a/test/test_sha256.cc
+++ b/test/test_sha256.cc
@ -23,17 +23,19 @@
 */
-#include "emsha/sha256.h"
+#include <stdio.h>
-#include <cassert>
+#include <string.h>
 #include <iostream>
-#include "test_utils.h"
+#include <emsha/sha256.hh>
 #include "test_utils.hh"
 using namespace std;
 // Tests taken from the Go SHA-256 package.
-const struct hashTest goldenTests[] = {
+const struct hash_test	golden_tests[] = {
 	{"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", ""},
 	{"ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb", "a"},
 	{"fb8e20fc2e4c3f248c60c39bd652f3c1347298bb977b8b4d5903b85055620603", "ab"},
@ -67,49 +69,32 @@ const struct hashTest goldenTests[] = {
 	{"4f9b189a13d030838269dce846b16a1ce9ce81fe63e65de2f636863336a98fe6", "How can you write a big system without C++?  -Paul Glick"},
 };
 static constexpr auto numGoldenTests = sizeof goldenTests / sizeof goldenTests[0];
 static const std::string labelGoldenTests = "golden tests";
 int
-main()
+main(void)
 {
 	int	res;
 #ifdef EMSHA_NO_SELFTEST
 	cout << "[NOTICE] internal self-tests have been disabled.\n";
 #else
-	auto selfTestStatus = emsha::SHA256SelfTest();
+	res = emsha::sha256_self_test();
-	switch (selfTestStatus) {
+	switch (res) {
-	case emsha::EMSHAResult::OK:
+	case emsha::EMSHA_ROK:
-		cout << "PASSED: SHA-256 self test\n";
+		cout << "PASSED: SHA-256 self test" << endl;
 		break;
-	case emsha::EMSHAResult::TestFailure:
+	case emsha::EMSHA_TEST_FAILURE:
-		cout << "FAILED: SHA-256 self-test\n";
+		cout << "FAILED: SHA-256 self test (test failure)" << endl;
 		break;
 	case emsha::EMSHAResult::Unknown:
 		cout << "FAILED: SHA-256 self test (fault: Unknown)\n";
 		break;
 	case emsha::EMSHAResult::NullPointer:
 		cout << "FAILED: SHA-256 self test (fault: NullPointer)\n";
 		break;
 	case emsha::EMSHAResult::InvalidState:
 		cout << "FAILED: SHA-256 self test (fault: InvalidState)\n";
 		break;
 	case emsha::EMSHAResult::InputTooLong:
 		cout << "FAILED: SHA-256 self test (fault: InputTooLong)\n";
 		break;
 	case emsha::EMSHAResult::SelfTestDisabled:
 		cout << "FAILED: SHA-256 self test (fault: SelfTestDisabled)\n";
 		break;
 	default:
-		cout << "FAILED: SHA-256 self test (fault: internal system failure)\n";
+		cout << "FAILED: SHA-256 self test (fault " << res << ")"
-		abort();
+		     << endl;
 	}
 	assert(selfTestStatus == emsha::EMSHAResult::OK);
 #endif
-
+	res = run_hash_tests(const_cast<hash_test *>(golden_tests),
-
+	    sizeof golden_tests / sizeof golden_tests[0],
-	auto res = runHashTests(static_cast<const hashTest *>(goldenTests),
+	    "golden tests");
-				numGoldenTests, labelGoldenTests);
+	if (-1 == res) {
 	if (res == -1) {
 		exit(1);
 	}
--- a/test/test_utils.cc
+++ b/test/test_utils.cc
@ -28,7 +28,7 @@
 #include <iostream>
 #include <string>
-#include "test_utils.h"
+#include "test_utils.hh"
 using std::uint8_t;
 using std::uint32_t;
@ -39,90 +39,90 @@ using std::endl;
 void
-DumpHexString(std::string& hs, uint8_t *s, uint32_t sl)
+dump_hexstring(string& hs, uint8_t *s, uint32_t sl)
 {
-	uint32_t	 const bl = (2 * sl) + 1;
+	uint32_t	 bl = (2 * sl) + 1;
 	char		*buf = new char[bl];
 	string		 tmp;
 	memset(buf, 0, bl);
-	emsha::HexString(reinterpret_cast<uint8_t *>(buf), s, sl);
+	emsha::hexstring((uint8_t *)buf, s, sl);
 	tmp = string(buf);
 	hs.swap(tmp);
 	delete[] buf;
 }
-emsha::EMSHAResult
+emsha::EMSHA_RESULT
-runHMACTest(const struct hmacTest& test, const string& label)
+run_hmac_test(struct hmac_test test, string label)
 {
-	emsha::HMAC        h(test.key, test.keylen);
+	emsha::HMAC		h(test.key, test.keylen);
-	emsha::EMSHAResult res;
+	emsha::EMSHA_RESULT	res;
-	uint8_t            dig[emsha::SHA256_HASH_SIZE];
+	uint8_t			dig[emsha::SHA256_HASH_SIZE];
-	string			hs;
+	string			hs = "";
-	res = h.Update((uint8_t *)test.input.c_str(), test.input.size());
+	res = h.update((uint8_t *)test.input.c_str(), test.input.size());
-	if (emsha::EMSHAResult::OK != res) {
+	if (emsha::EMSHA_ROK != res) {
 		goto exit;
 	}
 	for (uint32_t n = 0; n < RESULT_ITERATIONS; n++) {
-		res = h.Result(dig);
+		res = h.result(dig);
-		if (emsha::EMSHAResult::OK != res) {
+		if (emsha::EMSHA_ROK != res) {
 			goto exit;
 		}
-		DumpHexString(hs, dig, emsha::SHA256_HASH_SIZE);
+		dump_hexstring(hs, dig, emsha::SHA256_HASH_SIZE);
 		if (hs != test.output) {
-			res = emsha::EMSHAResult::TestFailure;
+			res = emsha::EMSHA_TEST_FAILURE;
 			goto exit;
 		}
 		memset(dig, 0, emsha::SHA256_HASH_SIZE);
 	}
 	// Ensure that a reset and update gives the same results.
-	h.Reset();
+	h.reset();
-	res = h.Update((uint8_t *)test.input.c_str(), test.input.size());
+	res = h.update((uint8_t *)test.input.c_str(), test.input.size());
-	if (emsha::EMSHAResult::OK != res) {
+	if (emsha::EMSHA_ROK != res) {
 		goto exit;
 	}
 	for (uint32_t n = 0; n < RESULT_ITERATIONS; n++) {
-		res = h.Result(dig);
+		res = h.result(dig);
-		if (emsha::EMSHAResult::OK != res) {
+		if (emsha::EMSHA_ROK != res) {
 			goto exit;
 		}
-		DumpHexString(hs, dig, emsha::SHA256_HASH_SIZE);
+		dump_hexstring(hs, dig, emsha::SHA256_HASH_SIZE);
 		if (hs != test.output) {
-			res = emsha::EMSHAResult::TestFailure;
+			res = emsha::EMSHA_TEST_FAILURE;
 			goto exit;
 		}
 		memset(dig, 0, emsha::SHA256_HASH_SIZE);
 	}
 	// Test that the single-pass function works.
-	res = emsha::ComputeHMAC(test.key, test.keylen,
+	res = emsha::compute_hmac(test.key, test.keylen,
 	    (uint8_t *)test.input.c_str(), test.input.size(),
 	    dig);
-	if (emsha::EMSHAResult::OK != res) {
+	if (emsha::EMSHA_ROK != res) {
 		cerr << "(running single pass function test)\n";
 		goto exit;
 	}
-	DumpHexString(hs, dig, emsha::SHA256_HASH_SIZE);
+	dump_hexstring(hs, dig, emsha::SHA256_HASH_SIZE);
 	if (hs != test.output) {
 		cerr << "(comparing single pass function output)\n";
-		res = emsha::EMSHAResult::TestFailure;
+		res = emsha::EMSHA_TEST_FAILURE;
 		goto exit;
 	}
 	memset(dig, 0, emsha::SHA256_HASH_SIZE);
-	res = emsha::EMSHAResult::OK;
+	res = emsha::EMSHA_ROK;
 exit:
-	if (emsha::EMSHAResult::OK != res) {
+	if (emsha::EMSHA_ROK != res) {
 		cerr << "FAILED: " << label << endl;
 		cerr << "\tinput: " << test.input << endl;
 		cerr << "\twanted: " << test.output << endl;
@ -134,86 +134,86 @@ exit:
 int
-runHMACTests(const struct hmacTest *tests, size_t nTests, const string& label)
+run_hmac_tests(struct hmac_test *tests, uint32_t ntests, string label)
 {
-	for (uint32_t i = 0; i < nTests; i++) {
+	for (uint32_t i = 0; i < ntests; i++) {
-		if (emsha::EMSHAResult::OK != runHMACTest(*(tests + i), label)) {
+		if (emsha::EMSHA_ROK != run_hmac_test(*(tests + i), label)) {
 			return -1;
 		}
 	}
-	cout << "PASSED: " << label << " (" << nTests << ")" << endl;
+	cout << "PASSED: " << label << " (" << ntests << ")" << endl;
 	return 0;
 }
-emsha::EMSHAResult
+emsha::EMSHA_RESULT
-runHashTest(const struct hashTest& test, const string& label)
+run_hash_test(struct hash_test test, string label)
 {
-	emsha::SHA256      ctx;
+	emsha::SHA256		ctx;
-	emsha::EMSHAResult res;
+	emsha::EMSHA_RESULT	res;
-	uint8_t            dig[emsha::SHA256_HASH_SIZE];
+	uint8_t			dig[emsha::SHA256_HASH_SIZE];
 	string			hs;
-	res = ctx.Update((uint8_t *)test.input.c_str(), test.input.size());
+	res = ctx.update((uint8_t *)test.input.c_str(), test.input.size());
-	if (emsha::EMSHAResult::OK != res) {
+	if (emsha::EMSHA_ROK != res) {
 		goto exit;
 	}
 	for (uint32_t n = 0; n < RESULT_ITERATIONS; n++) {
-		res = ctx.Result(dig);
+		res = ctx.result(dig);
-		if (emsha::EMSHAResult::OK != res) {
+		if (emsha::EMSHA_ROK != res) {
 			goto exit;
 		}
-		DumpHexString(hs, dig, emsha::SHA256_HASH_SIZE);
+		dump_hexstring(hs, dig, emsha::SHA256_HASH_SIZE);
 		if (hs != test.output) {
-			res = emsha::EMSHAResult::TestFailure;
+			res = emsha::EMSHA_TEST_FAILURE;
 			goto exit;
 		}
 		memset(dig, 0, emsha::SHA256_HASH_SIZE);
 	}
 	// Ensure that a reset and update gives the same results.
-	ctx.Reset();
+	ctx.reset();
-	res = ctx.Update((uint8_t *)test.input.c_str(), test.input.size());
+	res = ctx.update((uint8_t *)test.input.c_str(), test.input.size());
-	if (emsha::EMSHAResult::OK != res) {
+	if (emsha::EMSHA_ROK != res) {
 		goto exit;
 	}
 	for (uint32_t n = 0; n < RESULT_ITERATIONS; n++) {
-		res = ctx.Result(dig);
+		res = ctx.result(dig);
-		if (emsha::EMSHAResult::OK != res) {
+		if (emsha::EMSHA_ROK != res) {
 			goto exit;
 		}
-		DumpHexString(hs, dig, emsha::SHA256_HASH_SIZE);
+		dump_hexstring(hs, dig, emsha::SHA256_HASH_SIZE);
 		if (hs != test.output) {
-			res = emsha::EMSHAResult::TestFailure;
+			res = emsha::EMSHA_TEST_FAILURE;
 			goto exit;
 		}
 		memset(dig, 0, emsha::SHA256_HASH_SIZE);
 	}
 	// Test that the single-pass function works.
-	res = emsha::SHA256Digest((uint8_t *) test.input.c_str(),
+	res = emsha::sha256_digest((uint8_t *)test.input.c_str(),
-				  test.input.size(), dig);
+	    test.input.size(), dig);
-	if (emsha::EMSHAResult::OK != res) {
+	if (emsha::EMSHA_ROK != res) {
 		cerr << "(running single pass function test)\n";
 		goto exit;
 	}
-	DumpHexString(hs, dig, emsha::SHA256_HASH_SIZE);
+	dump_hexstring(hs, dig, emsha::SHA256_HASH_SIZE);
 	if (hs != test.output) {
 		cerr << "(comparing single pass function output)\n";
-		res = emsha::EMSHAResult::TestFailure;
+		res = emsha::EMSHA_TEST_FAILURE;
 		goto exit;
 	}
 	memset(dig, 0, emsha::SHA256_HASH_SIZE);
-	res = emsha::EMSHAResult::OK;
+	res = emsha::EMSHA_ROK;
 exit:
-	if (emsha::EMSHAResult::OK != res) {
+	if (emsha::EMSHA_ROK != res) {
 		cerr << "FAILED: " << label << endl;
 		cerr << "\tinput: '" << test.input << "'" << endl;
 		cerr << "\twanted: " << test.output << endl;
@ -224,10 +224,10 @@ exit:
 int
-runHashTests(const struct hashTest *tests, const size_t ntests, const string& label)
+run_hash_tests(struct hash_test *tests, uint32_t ntests, string label)
 {
 	for (uint32_t i = 0; i < ntests; i++) {
-		if (emsha::EMSHAResult::OK != runHashTest(*(tests + i), label)) {
+		if (emsha::EMSHA_ROK != run_hash_test(*(tests + i), label)) {
 			return -1;
 		}
 	}
@ -284,7 +284,7 @@ write_hex_char(uint8_t *dest, uint8_t src)
 void
-HexString(uint8_t *dest, uint8_t *src, uint32_t srclen)
+hexstring(uint8_t *dest, uint8_t *src, uint32_t srclen)
 {
 	uint8_t	*dp = dest;
--- a/src/test_utils.hh
+++ b/src/test_utils.hh
@ -30,9 +30,9 @@
 #include <cstdint>
 #include <string>
-#include "emsha/emsha.h"
+#include <emsha/emsha.hh>
-#include "emsha/hmac.h"
+#include <emsha/sha256.hh>
-#include "emsha/sha256.h"
+#include <emsha/hmac.hh>
 // How many times should a test result be checked? The goal is to
@ -44,13 +44,13 @@ constexpr uint32_t	RESULT_ITERATIONS = 5;
 // Test data structures.
-struct hashTest {
+struct hash_test {
 	std::string	output;
 	std::string	input;
 };
-struct hmacTest {
+struct hmac_test {
 	std::uint8_t	key[256];
 	std::uint32_t	keylen;
 	std::string	input;
@ -59,20 +59,20 @@ struct hmacTest {
 // General-purpose debuggery.
-void	DumpHexString(std::string&, std::uint8_t *, std::uint32_t);
+void	dump_hexstring(std::string&, std::uint8_t *, std::uint32_t);
 void	dump_pair(std::uint8_t *, std::uint8_t *);
 // SHA-256 testing functions.
-emsha::EMSHAResult	runHashTest(const struct hashTest& test, const std::string& label);
+emsha::EMSHA_RESULT	run_hash_test(struct hash_test, std::string);
-int			runHashTests(const struct hashTest *tests, const std::size_t nTests,
+int			run_hash_tests(struct hash_test *, std::uint32_t,
-    				     const std::string& label);
+				      std::string);
 // HMAC-SHA-256 testery.
-emsha::EMSHAResult	runHMACTest(struct hmacTest& test, const std::string& label);
+emsha::EMSHA_RESULT	run_hmac_test(struct hmac_test, std::string);
-int			runHMACTests(const struct hmacTest *tests, std::size_t nTests,
+int			run_hmac_tests(struct hmac_test *, std::uint32_t,
-    				     const std::string& label);
+				       std::string);
 #ifdef EMSHA_NO_HEXSTRING
--- a/test/test_mem.cc
+++ b/test/test_mem.cc
@ -1,217 +0,0 @@
 /*
 * The MIT License (MIT)
 *
 * Copyright (c) 2015 K. Isom <coder@kyleisom.net>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * copy of this  software and associated documentation  files (the "Software"),
 * to deal  in the Software  without restriction, including  without limitation
 * the rights  to use,  copy, modify,  merge, publish,  distribute, sublicense,
 * and/or  sell copies  of the  Software,  and to  permit persons  to whom  the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS  PROVIDED "AS IS", WITHOUT WARRANTY OF  ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING  BUT NOT  LIMITED TO  THE WARRANTIES  OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS  OR COPYRIGHT  HOLDERS BE  LIABLE FOR  ANY CLAIM,  DAMAGES OR  OTHER
 * LIABILITY,  WHETHER IN  AN ACTION  OF CONTRACT,  TORT OR  OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 */
 #ifdef NDEBUG
 #undef NDEBUG
 #endif
 #include <cassert>
 #include <chrono>
 #include <cstring>
 #include <algorithm>
 #include <cstdio>
 #include <iostream>
 #include "emsha/emsha.h"
 #include "emsha/hmac.h"
 #include "emsha/sha256.h"
 // Number of test iterations.
 static constexpr std::uint32_t ITERS = 32768;
 // The key used for HMAC.
 static constexpr std::uint8_t  k[] = {
    0xc5, 0xb6, 0x80, 0xac, 0xdc, 0xf4, 0xff, 0xa1,
    0x37, 0x05, 0xc0, 0x71, 0x11, 0x24, 0x31, 0x7c,
    0xa5, 0xa2, 0xcf, 0x4d, 0x33, 0x00, 0x56, 0x4f,
    0x69, 0x0f, 0x76, 0x70, 0x87, 0xd9, 0x35, 0xce,
    0xa3, 0xad, 0xa3, 0x4f, 0x30, 0xe2, 0x7c, 0x58,
    0x88, 0xd4, 0x89, 0x6a, 0xb5, 0xe0, 0x97, 0x1c,
    0x7a, 0x69, 0x65, 0xc7, 0x61, 0x0d, 0x6d, 0xb6,
    0x9b, 0x0e, 0x56, 0xd7, 0x0f, 0x5a, 0x01, 0x50,
 };
 static constexpr std::uint32_t kl  = sizeof(k) / sizeof(k[0]);
 // The message provided to both SHA-256 and HMAC-SHA-256; it is
 // "The fugacity of a constituent in a mixture of gases at a given
 // temperature is proportional to its mole fraction.  Lewis-Randall Rule",
 // chosen as one of the longer test vectors.
 static const std::uint8_t m[] = {
    0x54, 0x68, 0x65, 0x20, 0x66, 0x75, 0x67, 0x61,
    0x63, 0x69, 0x74, 0x79, 0x20, 0x6f, 0x66, 0x20,
    0x61, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x69,
    0x74, 0x75, 0x65, 0x6e, 0x74, 0x20, 0x69, 0x6e,
    0x20, 0x61, 0x20, 0x6d, 0x69, 0x78, 0x74, 0x75,
    0x72, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x67, 0x61,
    0x73, 0x65, 0x73, 0x20, 0x61, 0x74, 0x20, 0x61,
    0x20, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x20, 0x74,
    0x65, 0x6d, 0x70, 0x65, 0x72, 0x61, 0x74, 0x75,
    0x72, 0x65, 0x20, 0x69, 0x73, 0x20, 0x70, 0x72,
    0x6f, 0x70, 0x6f, 0x72, 0x74, 0x69, 0x6f, 0x6e,
    0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x74,
    0x73, 0x20, 0x6d, 0x6f, 0x6c, 0x65, 0x20, 0x66,
    0x72, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e,
    0x20, 0x20, 0x4c, 0x65, 0x77, 0x69, 0x73, 0x2d,
    0x52, 0x61, 0x6e, 0x64, 0x61, 0x6c, 0x6c, 0x20,
    0x52, 0x75, 0x6c, 0x65
 };
 // d is the expected result of SHA256(m).
 static constexpr std::uint8_t d[emsha::SHA256_HASH_SIZE] = {
    0x39, 0x55, 0x85, 0xce, 0x30, 0x61, 0x7b, 0x62,
    0xc8, 0x0b, 0x93, 0xe8, 0x20, 0x8c, 0xe8, 0x66,
    0xd4, 0xed, 0xc8, 0x11, 0xa1, 0x77, 0xfd, 0xb4,
    0xb8, 0x2d, 0x39, 0x11, 0xd8, 0x69, 0x64, 0x23
 };
 // t is the expected result of HMAC-SHA-256(k, m).
 static constexpr std::uint8_t t[emsha::SHA256_HASH_SIZE] = {
    0xbb, 0xc4, 0x7c, 0x35, 0x33, 0x4b, 0x9d, 0x90,
    0xee, 0x20, 0x88, 0x30, 0xe1, 0x1a, 0x0f, 0xf3,
    0xf4, 0x7d, 0xcc, 0xb0, 0xc5, 0xfb, 0x83, 0xe5,
    0xc2, 0xf5, 0xa7, 0x94, 0x50, 0xb6, 0xe0, 0xe0,
 };
 // dig is used to store the output of SHA-256 and HMAC-SHA-256.
 static std::uint8_t dig[emsha::SHA256_HASH_SIZE];
 static void
 init()
 {
 	std::fill(dig, dig + emsha::SHA256_HASH_SIZE, 0);
 }
 static void
 iterateSHA()
 {
 	emsha::SHA256       ctx;
 	int                cmp = 0;
 	emsha::EMSHAResult res;
 	res = ctx.Update(m, sizeof(m));
 	assert(emsha::EMSHAResult::OK == res);
 	res = ctx.Result(dig);
 	assert(emsha::EMSHAResult::OK == res);
 	cmp = std::memcmp(dig, d, emsha::SHA256_HASH_SIZE);
 	assert(0 == cmp);
 }
 static void
 iterateHMAC()
 {
 	emsha::HMAC         ctx(k, kl);
 	int                cmp = 0;
 	emsha::EMSHAResult res;
 	res = ctx.Update(m, sizeof(m));
 	assert(emsha::EMSHAResult::OK == res);
 	res = ctx.Result(dig);
 	assert(emsha::EMSHAResult::OK == res);
 	cmp = std::memcmp(dig, t, emsha::SHA256_HASH_SIZE);
 	assert(0 == cmp);
 }
 static void
 iterateSHASP()
 {
 	int cmp = 0;
 	assert(emsha::EMSHAResult::OK == emsha::SHA256Digest(m, sizeof(m), dig));
 	cmp = std::memcmp(dig, d, emsha::SHA256_HASH_SIZE);
 	assert(0 == cmp);
 }
 static void
 iterateHMACSP()
 {
 	int                cmp = 0;
 	emsha::EMSHAResult res;
 	res = emsha::ComputeHMAC(k, kl, m, sizeof(m), dig);
 	assert(emsha::EMSHAResult::OK == res);
 	cmp = std::memcmp(dig, t, emsha::SHA256_HASH_SIZE);
 	assert(0 == cmp);
 }
 static void
 iterate(const std::string &label, void(iteration)(void))
 {
 	std::cout << "=== " << label << " ===" << std::endl;
 	auto start = std::chrono::steady_clock::now();
 	for (std::uint32_t i = 0; i < ITERS; i++) {
 		iteration();
 	}
 	auto end   = std::chrono::steady_clock::now();
 	auto delta = (end - start);
 	std::cout << "Total time: "
 		  << std::chrono::duration<double, std::milli>(delta).count()
 		  << " ms" << std::endl;
 	std::cout << "Average over " << ITERS << " tests: "
 		  << std::chrono::duration<double, std::nano>(delta).count() / ITERS
 		  << " ns" << std::endl;
 }
 static void
 coldStart()
 {
 	std::cout << "=== SHA-256 cold start ===\n";
 	auto start = std::chrono::steady_clock::now();
 	iterateSHA();
 	auto end   = std::chrono::steady_clock::now();
 	auto delta = (end - start);
 	std::cout << "Total time: "
 		  << std::chrono::duration<double, std::nano>(delta).count()
 		  << " ns" << std::endl;
 }
 int
 main()
 {
 	init();
 	coldStart();
 	iterate("SHA-256", iterateSHA);
 	iterate("SHA-256 single-pass", iterateSHASP);
 	iterate("HMAC-SHA-256", iterateHMAC);
 	iterate("HMAC-SHA-256 single-pass", iterateHMACSP);
 }
		`@ -1,2 +0,0 @@`
			`<?xml version="1.0" encoding="UTF-8"?>`
			`<module classpath="CMake" type="CPP_MODULE" version="4" />`
		`@ -1,3 +0,0 @@`
			`set(EMSHA_INCLUDE_DIRS include/@PROJECT_NAME@)`
			`set(EMSHA_LIBRARIES libemsha-@PROJECT_VERSION_MAJOR@.a)`