| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,4 @@ | ||
| FROM cirrusci/windowsservercore:2019 | ||
|
|
||
| RUN choco install -y --no-progress cygwin | ||
| RUN C:\tools\cygwin\cygwinsetup.exe -q -P make,autoconf,automake,cmake,gcc-core,binutils,libtool,pkg-config,bison,sharutils,zlib-devel,libbz2-devel,liblzma-devel,liblz4-devel,libiconv-devel,libxml2-devel,libzstd-devel,libssl-devel |
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,3 @@ | ||
| FROM fedora:29 | ||
|
|
||
| RUN dnf -y install make cmake gcc gcc-c++ kernel-devel automake libtool bison sharutils pkgconf libacl-devel libasan librichacl-devel bzip2-devel libzip-devel zlib-devel xz-devel lz4-devel libzstd-devel openssl-devel |
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,3 @@ | ||
| FROM fedora:29 | ||
|
|
||
| RUN dnf -y install make cmake gcc gcc-c++ kernel-devel automake libtool bison sharutils pkgconf libacl-devel libasan librichacl-devel bzip2-devel libzip-devel zlib-devel xz-devel lz4-devel libzstd-devel openssl-devel groff ghostscript |
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,8 @@ | ||
| FROM cirrusci/windowsservercore:2019 | ||
|
|
||
| RUN choco install -y --no-progress --installargs 'ADD_CMAKE_TO_PATH=User' cmake | ||
| RUN choco install -y --no-progress mingw | ||
| RUN curl -o zlib-1.2.11.tar.gz https://www.zlib.net/zlib-1.2.11.tar.gz | ||
| RUN tar -x -f zlib-1.2.11.tar.gz | ||
| RUN cd zlib-1.2.11 && cmake -G "MinGW Makefiles" -D CMAKE_BUILD_TYPE="Release" . && mingw32-make && mingw32-make install | ||
| RUN del /f /q /s zlib-1.2.11 zlib-1.2.11.tar.gz |
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,9 @@ | ||
| FROM cirrusci/windowsservercore:2019 | ||
|
|
||
| RUN choco install -y --no-progress --installargs 'ADD_CMAKE_TO_PATH=User' cmake | ||
| RUN choco install -y --no-progress visualstudio2017community | ||
| RUN choco install -y --no-progress visualstudio2017-workload-vctools | ||
| RUN curl -o zlib-1.2.11.tar.gz https://www.zlib.net/zlib-1.2.11.tar.gz | ||
| RUN tar -x -f zlib-1.2.11.tar.gz | ||
| RUN cd zlib-1.2.11 && cmake -G "Visual Studio 15 2017" . && cmake --build . --target ALL_BUILD --config Release && cmake --build . --target INSTALL --config Release | ||
| RUN del /f /q /s zlib-1.2.11 zlib-1.2.11.tar.gz |
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,12 @@ | ||
| FROM cirrusci/windowsservercore:2019 | ||
|
|
||
| RUN choco install -y --no-progress mingw | ||
| RUN choco install -y --no-progress --installargs 'ADD_CMAKE_TO_PATH=User' cmake | ||
| RUN choco install -y --no-progress visualstudio2017community | ||
| RUN choco install -y --no-progress visualstudio2017-workload-vctools | ||
| RUN curl -o zlib-1.2.11.tar.gz https://www.zlib.net/zlib-1.2.11.tar.gz | ||
| RUN tar -x -f zlib-1.2.11.tar.gz | ||
| RUN cd zlib-1.2.11 && cmake -G "Visual Studio 15 2017" . && cmake --build . --target ALL_BUILD --config Release && cmake --build . --target INSTALL --config Release | ||
| RUN del /f /q /s zlib-1.2.11 zlib-1.2.11.tar.gz | ||
| RUN choco install -y --no-progress cygwin | ||
| RUN C:\tools\cygwin\cygwinsetup.exe -q -P make,autoconf,automake,cmake,gcc-core,binutils,libtool,pkg-config,bison,sharutils,zlib-devel,libbz2-devel,liblzma-devel,liblz4-devel,libiconv-devel,libxml2-devel,libzstd-devel,libssl-devel |
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,122 @@ | ||
| @ECHO OFF | ||
| SET ZLIB_VERSION=1.2.11 | ||
| IF NOT "%BE%"=="cygwin-gcc" ( | ||
| IF NOT "%BE%"=="mingw-gcc" ( | ||
| IF NOT "%BE%"=="msvc" ( | ||
| ECHO Environment variable BE must be cygwin-gcc, mingw-gcc or msvc | ||
| EXIT /b 1 | ||
| ) | ||
| ) | ||
| ) | ||
|
|
||
| IF "%1%"=="prepare" ( | ||
| IF "%BE%"=="cygwin-gcc" ( | ||
| @ECHO ON | ||
| choco install -y --no-progress cygwin || EXIT /b 1 | ||
| C:\tools\cygwin\cygwinsetup.exe -q -P make,autoconf,automake,cmake,gcc-core,binutils,libtool,pkg-config,bison,sharutils,zlib-devel,libbz2-devel,liblzma-devel,liblz4-devel,libiconv-devel,libxml2-devel,libzstd-devel,libssl-devel || EXIT /b 1 | ||
| @EXIT /b 0 | ||
| ) ELSE IF "%BE%"=="mingw-gcc" ( | ||
| @ECHO ON | ||
| choco install -y --no-progress mingw || EXIT /b 1 | ||
| choco install -y --no-progress --installargs 'ADD_CMAKE_TO_PATH=System' cmake || EXIT /b 1 | ||
| @EXIT /b 0 | ||
| ) ELSE IF "%BE%"=="msvc" ( | ||
| @ECHO ON | ||
| choco install -y --no-progress visualstudio2017community || EXIT /b 1 | ||
| choco install -y --no-progress visualstudio2017-workload-vctools || EXIT /b 1 | ||
| choco install -y --no-progress --installargs 'ADD_CMAKE_TO_PATH=System' cmake || EXIT /b 1 | ||
| ) | ||
| ) ELSE IF "%1"=="deplibs" ( | ||
| IF "%BE%"=="cygwin-gcc" ( | ||
| ECHO Skipping on this platform | ||
| EXIT /b 0 | ||
| ) | ||
| IF NOT EXIST build_ci\libs ( | ||
| MKDIR build_ci\libs | ||
| ) | ||
| CD build_ci\libs | ||
| IF NOT EXIST zlib-%ZLIB_VERSION%.tar.gz ( | ||
| curl -o zlib-%ZLIB_VERSION%.tar.gz https://www.zlib.net/zlib-%ZLIB_VERSION%.tar.gz | ||
| ) | ||
| IF NOT EXIST zlib-%ZLIB_VERSION% ( | ||
| tar -x -z -f zlib-%ZLIB_VERSION%.tar.gz | ||
| ) | ||
| SET PATH=%PATH%;C:\Program Files\cmake\bin;C:\ProgramData\chocolatey\lib\mingw\tools\install\mingw64\bin | ||
| CD zlib-%ZLIB_VERSION% | ||
| IF "%BE%"=="mingw-gcc" ( | ||
| cmake -G "MinGW Makefiles" -D CMAKE_BUILD_TYPE="Release" . || EXIT /b 1 | ||
| mingw32-make || EXIT /b 1 | ||
| mingw32-make test || EXIT /b 1 | ||
| mingw32-make install || EXIT /b 1 | ||
| ) ELSE IF "%BE%"=="msvc" ( | ||
| cmake -G "Visual Studio 15 2017" . || EXIT /b 1 | ||
| cmake --build . --target ALL_BUILD --config Release || EXIT /b 1 | ||
| cmake --build . --target RUN_TESTS --config Release || EXIT /b 1 | ||
| cmake --build . --target INSTALL --config Release || EXIT /b 1 | ||
| ) | ||
| ) ELSE IF "%1%"=="configure" ( | ||
| IF "%BE%"=="cygwin-gcc" ( | ||
| SET BS=cmake | ||
| SET CONFIGURE_ARGS=-DENABLE_ACL=OFF | ||
| C:\tools\cygwin\bin\bash.exe --login -c "cd '%cd%'; ./build/ci/build.sh -a configure" || EXIT /b 1 | ||
| ) ELSE IF "%BE%"=="mingw-gcc" ( | ||
| SET PATH=%PATH%;C:\Program Files\cmake\bin;C:\ProgramData\chocolatey\lib\mingw\tools\install\mingw64\bin | ||
| MKDIR build_ci\cmake | ||
| CD build_ci\cmake | ||
| cmake -G "MinGW Makefiles" ..\.. || EXIT /b 1 | ||
| ) ELSE IF "%BE%"=="msvc" ( | ||
| SET PATH=%PATH%;C:\Program Files\cmake\bin;C:\ProgramData\chocolatey\lib\mingw\tools\install\mingw64\bin | ||
| MKDIR build_ci\cmake | ||
| CD build_ci\cmake | ||
| cmake -G "Visual Studio 15 2017" -D CMAKE_BUILD_TYPE="Release" ..\.. || EXIT /b 1 | ||
| ) | ||
| ) ELSE IF "%1%"=="build" ( | ||
| IF "%BE%"=="cygwin-gcc" ( | ||
| SET BS=cmake | ||
| C:\tools\cygwin\bin\bash.exe --login -c "cd '%cd%'; ./build/ci/build.sh -a build" | ||
| ) ELSE IF "%BE%"=="mingw-gcc" ( | ||
| SET PATH=%PATH%;C:\Program Files\cmake\bin;C:\ProgramData\chocolatey\lib\mingw\tools\install\mingw64\bin | ||
| CD build_ci\cmake | ||
| mingw32-make || EXIT /b 1 | ||
| ) ELSE IF "%BE%"=="msvc" ( | ||
| SET PATH=%PATH%;C:\Program Files\cmake\bin;C:\ProgramData\chocolatey\lib\mingw\tools\install\mingw64\bin | ||
| CD build_ci\cmake | ||
| cmake --build . --target ALL_BUILD --config Release | ||
| ) | ||
| ) ELSE IF "%1%"=="test" ( | ||
| IF "%BE%"=="cygwin-gcc" ( | ||
| ECHO "Skipping tests on this platform" | ||
| EXIT /b 0 | ||
| REM SET BS=cmake | ||
| REM SET SKIP_TEST_SPARSE=1 | ||
| REM C:\tools\cygwin\bin\bash.exe --login -c "cd '%cd%'; ./build/ci/build.sh -a test" | ||
| ) ELSE IF "%BE%"=="mingw-gcc" ( | ||
| SET PATH=%PATH%;C:\Program Files\cmake\bin;C:\ProgramData\chocolatey\lib\mingw\tools\install\mingw64\bin | ||
| COPY "C:\Program Files (x86)\zlib\bin\libzlib.dll" build_ci\cmake\bin\ | ||
| CD build_ci\cmake | ||
| SET SKIP_TEST_SPARSE=1 | ||
| mingw32-make test | ||
| ) ELSE IF "%BE%"=="msvc" ( | ||
| SET PATH=%PATH%;C:\Program Files\cmake\bin;C:\ProgramData\chocolatey\lib\mingw\tools\install\mingw64\bin | ||
| ECHO "Skipping tests on this platform" | ||
| EXIT /b 0 | ||
| REM CD build_ci\cmake | ||
| REM cmake --build . --target RUN_TESTS --config Release | ||
| ) | ||
| ) ELSE IF "%1%"=="install" ( | ||
| IF "%BE%"=="cygwin-gcc" ( | ||
| SET BS=cmake | ||
| C:\tools\cygwin\bin\bash.exe --login -c "cd '%cd%'; ./build/ci/build.sh -a install" | ||
| ) ELSE IF "%BE%"=="mingw-gcc" ( | ||
| SET PATH=%PATH%;C:\Program Files\cmake\bin;C:\ProgramData\chocolatey\lib\mingw\tools\install\mingw64\bin | ||
| CD build_ci\cmake | ||
| mingw32-make install DESTDIR=%cd%\destdir | ||
| ) ELSE IF "%BE%"=="msvc" ( | ||
| SET PATH=%PATH%;C:\Program Files\cmake\bin;C:\ProgramData\chocolatey\lib\mingw\tools\install\mingw64\bin | ||
| cmake --build . --target INSTALL --config Release | ||
| ) | ||
| ) ELSE ( | ||
| ECHO "Usage: %0% prepare|deplibs|configure|build|test|install" | ||
| @EXIT /b 0 | ||
| ) | ||
| @EXIT /b 0 |
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,56 @@ | ||
| #!/bin/sh | ||
| UNAME=`uname` | ||
| if [ "$1" = "prepare" ] | ||
| then | ||
| if [ "${UNAME}" = "FreeBSD" ] | ||
| then | ||
| set -x -e | ||
| sed -i.bak -e 's,pkg+http://pkg.FreeBSD.org/\${ABI}/quarterly,pkg+http://pkg.FreeBSD.org/\${ABI}/latest,' /etc/pkg/FreeBSD.conf | ||
| mount -u -o acls / | ||
| mkdir /tmp_acl_nfsv4 | ||
| MD=`mdconfig -a -t swap -s 128M` | ||
| newfs /dev/$MD | ||
| tunefs -N enable /dev/$MD | ||
| mount /dev/$MD /tmp_acl_nfsv4 | ||
| chmod 1777 /tmp_acl_nfsv4 | ||
| pkg install -y autoconf automake cmake libiconv libtool pkgconf expat libxml2 liblz4 zstd | ||
| elif [ "${UNAME}" = "Darwin" ] | ||
| then | ||
| set -x -e | ||
| brew update > /dev/null | ||
| for pkg in autoconf automake libtool pkg-config cmake xz lz4 zstd | ||
| do | ||
| brew list $pkg > /dev/null && brew upgrade $pkg || brew install $pkg | ||
| done | ||
| elif [ "${UNAME}" = "Linux" ] | ||
| then | ||
| if [ -f "/etc/debian_version" ] | ||
| then | ||
| apt-get -y update | ||
| apt-get -y install build-essential locales automake libtool bison sharutils pkgconf libacl1-dev libbz2-dev libzip-dev zlib1g-dev liblzma-dev liblz4-dev libzstd-dev libssl-dev lrzip cmake | ||
| elif [ -f "/etc/fedora-release" ] | ||
| then | ||
| dnf -y install make cmake gcc gcc-c++ kernel-devel automake libtool bison sharutils pkgconf libacl-devel librichacl-devel bzip2-devel libzip-devel zlib-devel xz-devel lz4-devel libzstd-devel openssl-devel | ||
| fi | ||
| fi | ||
| elif [ "$1" = "test" ] | ||
| then | ||
| if [ "${UNAME}" = "FreeBSD" ] | ||
| then | ||
| set -e | ||
| echo "Additional NFSv4 ACL tests" | ||
| CURDIR=`pwd` | ||
| if [ "${BS}" = "cmake" ] | ||
| then | ||
| BIN_SUBDIR="bin" | ||
| else | ||
| BIN_SUBDIR=. | ||
| fi | ||
| BUILDDIR="${CURDIR}/build_ci/${BS}" | ||
| cd "$BUILDDIR" | ||
| TMPDIR=/tmp_acl_nfsv4 ${BIN_SUBDIR}/libarchive_test -r "${CURDIR}/libarchive/test" -v test_acl_platform_nfs4 | ||
| fi | ||
| else | ||
| echo "Usage $0 prepare | test_nfsv4_acls" | ||
| exit 1 | ||
| fi |
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,33 @@ | ||
| #!/bin/sh | ||
| set -e | ||
| UNAME=`uname` | ||
| CURDIR=`pwd` | ||
| SRCDIR="${SRCDIR:-`pwd`}" | ||
| if [ -z "${BUILDDIR}" ]; then | ||
| BUILDDIR="${CURDIR}/build_ci/${BS}" | ||
| fi | ||
| mkdir -p "${BUILDDIR}" | ||
| cd "${BUILDDIR}" | ||
| case "$UNAME" in | ||
| MSYS*) | ||
| if [ "${BS}" = "msbuild" ]; then | ||
| set -x | ||
| cmake -G "Visual Studio 15 2017" -D CMAKE_BUILD_TYPE="Release" "${SRCDIR}" | ||
| cmake --build . --target ALL_BUILD | ||
| # Until fixed, we don't run tests on Windows (lots of fails + timeout) | ||
| #export SKIP_TEST_FUZZ=1 | ||
| #cmake --build . --target RUN_TESTS | ||
| set +x | ||
| elif [ "${BS}" = "mingw" ]; then | ||
| set -x | ||
| cmake -G "MSYS Makefiles" -D CMAKE_C_COMPILER="${CC}" -D CMAKE_MAKE_PROGRAM="mingw32-make" -D CMAKE_BUILD_TYPE="Release" "${SRCDIR}" | ||
| mingw32-make | ||
| #export SKIP_TEST_FUZZ=1 | ||
| #mingw32-make test | ||
| set +x | ||
| else | ||
| echo "Unknown or unspecified build type: ${BS}" | ||
| exit 1 | ||
| fi | ||
| ;; | ||
| esac |
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -1 +1 @@ | ||
| 3004000 |
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,218 @@ | ||
| /*- | ||
| * Copyright (c) 2019 Martin Matuska | ||
| * All rights reserved. | ||
| * | ||
| * Redistribution and use in source and binary forms, with or without | ||
| * modification, are permitted provided that the following conditions | ||
| * are met: | ||
| * 1. Redistributions of source code must retain the above copyright | ||
| * notice, this list of conditions and the following disclaimer. | ||
| * 2. Redistributions in binary form must reproduce the above copyright | ||
| * notice, this list of conditions and the following disclaimer in the | ||
| * documentation and/or other materials provided with the distribution. | ||
| * | ||
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR | ||
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES | ||
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. | ||
| * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, | ||
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | ||
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | ||
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | ||
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF | ||
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
| */ | ||
|
|
||
| /* | ||
| * Archivetest verifies reading archives with libarchive | ||
| * | ||
| * It may be used to reproduce failures in testcases discovered by OSS-Fuzz | ||
| * https://github.com/google/oss-fuzz/blob/master/projects/libarchive | ||
| */ | ||
|
|
||
| #include <stdio.h> | ||
| #include <stdlib.h> | ||
| #include <stdarg.h> | ||
| #include <ctype.h> | ||
| #include <archive.h> | ||
| #include <archive_entry.h> | ||
|
|
||
| const char *errnostr(int errno) | ||
| { | ||
| char *estr; | ||
| switch(errno) { | ||
| case ARCHIVE_EOF: | ||
| estr = "ARCHIVE_EOF"; | ||
| break; | ||
| case ARCHIVE_OK: | ||
| estr = "ARCHIVE_OK"; | ||
| break; | ||
| case ARCHIVE_WARN: | ||
| estr = "ARCHIVE_WARN"; | ||
| break; | ||
| case ARCHIVE_RETRY: | ||
| estr = "ARCHIVE_RETRY"; | ||
| break; | ||
| case ARCHIVE_FAILED: | ||
| estr = "ARCHIVE_FAILED"; | ||
| break; | ||
| case ARCHIVE_FATAL: | ||
| estr = "ARCHIVE_FATAL"; | ||
| break; | ||
| default: | ||
| estr = "Unknown"; | ||
| break; | ||
| } | ||
| return (estr); | ||
| } | ||
|
|
||
| void usage(const char *prog) | ||
| { | ||
| fprintf(stderr, "Usage: %s [-f filename] [-h] [-q] [-s]\n", prog); | ||
| } | ||
|
|
||
| void printhelp() | ||
| { | ||
| fprintf(stdout, "archivetest: verify reading archives with " | ||
| "libarchive\n\n" | ||
| "Options:\n" | ||
| " -f filename Filename to verify\n" | ||
| " -h Show this help\n" | ||
| " -q Quiet mode\n" | ||
| " -s Verify only headers (skip data)\n\n" | ||
| "If no filename is specified, data is read from standard input.\n" | ||
| "\n%s\n", archive_version_details()); | ||
| } | ||
|
|
||
| int v_print(int verbose, const char *format, ...) | ||
| { | ||
| int r = 0; | ||
|
|
||
| if (verbose) { | ||
| va_list args; | ||
|
|
||
| va_start(args, format); | ||
| r = vfprintf(stdout, format, args); | ||
| va_end(args); | ||
| } | ||
| return (r); | ||
| } | ||
|
|
||
| int main(int argc, char *argv[]) | ||
| { | ||
| struct archive *a; | ||
| struct archive_entry *entry; | ||
| char *filename; | ||
| const char *p; | ||
| char buffer[4096]; | ||
| int c; | ||
| int v, skip_data; | ||
| int r = ARCHIVE_OK; | ||
| int format_printed; | ||
|
|
||
| filename = NULL; | ||
| skip_data = 0; | ||
| v = 1; | ||
|
|
||
| while ((c = getopt (argc, argv, "f:hqs")) != -1) { | ||
| switch (c) { | ||
| case 'f': | ||
| filename = optarg; | ||
| break; | ||
| case 'h': | ||
| printhelp(); | ||
| exit(0); | ||
| case 'q': | ||
| v = 0; | ||
| break; | ||
| case 's': | ||
| skip_data = 1; | ||
| break; | ||
| case '?': | ||
| if (optopt == 'f') | ||
| fprintf(stderr, "Option -%c requires " | ||
| "an argument.\n", optopt); | ||
| else if (isprint(optopt)) | ||
| fprintf(stderr, "Unknown option '-%c'" | ||
| ".\n", optopt); | ||
| else | ||
| fprintf(stderr, "Unknown option " | ||
| "character '\\x%x'.\n", optopt); | ||
| usage(argv[0]); | ||
| default: | ||
| exit(1); | ||
| } | ||
| } | ||
|
|
||
| a = archive_read_new(); | ||
|
|
||
| archive_read_support_filter_all(a); | ||
| archive_read_support_format_all(a); | ||
|
|
||
| v_print(v, "Data source: "); | ||
|
|
||
| if (filename == NULL) { | ||
| v_print(v, "standard input\n"); | ||
| r = archive_read_open_fd(a, STDIN_FILENO, 4096); | ||
| } else { | ||
| v_print(v, "filename: %s\n", filename); | ||
| r = archive_read_open_filename(a, filename, 4096); | ||
| } | ||
|
|
||
| if (r != ARCHIVE_OK) { | ||
| archive_read_free(a); | ||
| fprintf(stderr, "Invalid or unsupported data source\n"); | ||
| exit(1); | ||
| } | ||
|
|
||
| format_printed = 0; | ||
| c = 1; | ||
|
|
||
| while (1) { | ||
| r = archive_read_next_header(a, &entry); | ||
| if (r == ARCHIVE_FATAL) { | ||
| v_print(v, "Entry %d: fatal error reading " | ||
| "header\n", c); | ||
| break; | ||
| } | ||
| if (!format_printed) { | ||
| v_print(v, "Filter: %s\nFormat: %s\n", | ||
| archive_filter_name(a, 0), archive_format_name(a)); | ||
| format_printed = 1; | ||
| } | ||
| if (r == ARCHIVE_RETRY) | ||
| continue; | ||
| if (r == ARCHIVE_EOF) | ||
| break; | ||
| p = archive_entry_pathname(entry); | ||
| v_print(v, "Entry %d: %s, pathname", c, errnostr(r)); | ||
| if (p == NULL || p[0] == '\0') | ||
| v_print(v, " unreadable"); | ||
| else | ||
| v_print(v, ": %s", p); | ||
| v_print(v, ", data: "); | ||
| if (skip_data) { | ||
| v_print(v, "skipping"); | ||
| } else { | ||
| while ((r = archive_read_data(a, buffer, 4096) > 0)) | ||
| ; | ||
| if (r == ARCHIVE_FATAL) { | ||
| v_print(v, "ERROR\nError string: %s\n", | ||
| archive_error_string(a)); | ||
| break; | ||
| } | ||
| v_print(v, "OK"); | ||
| } | ||
| v_print(v, "\n"); | ||
| c++; | ||
| } | ||
|
|
||
| v_print(v, "Last return code: %s (%d)\n", errnostr(r), r); | ||
| if (r == ARCHIVE_EOF || r == ARCHIVE_OK) { | ||
| archive_read_free(a); | ||
| exit(0); | ||
| } | ||
| v_print(v, "Error string: %s\n", archive_error_string(a)); | ||
| archive_read_free(a); | ||
| exit(2); | ||
| } |
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -1,105 +1,216 @@ | ||
| Name: {{{ git_name }}} | ||
| Version: {{{ git_version lead=3 follow=4 }}} | ||
| Release: 1%{?dist} | ||
| Summary: A library for handling streaming archive formats | ||
|
|
||
| License: BSD | ||
| URL: http://www.libarchive.org/ | ||
| Source: {{{ git_pack }}} | ||
|
|
||
| VCS: {{{ git_vcs }}} | ||
|
|
||
| BuildRequires: automake | ||
| BuildRequires: bison | ||
| BuildRequires: bzip2-devel | ||
| BuildRequires: e2fsprogs-devel | ||
| BuildRequires: gcc | ||
| BuildRequires: libacl-devel | ||
| BuildRequires: libattr-devel | ||
| BuildRequires: libtool | ||
| BuildRequires: libxml2-devel | ||
| BuildRequires: libzstd-devel | ||
| BuildRequires: lz4-devel | ||
| BuildRequires: lzo-devel | ||
| BuildRequires: openssl-devel | ||
| BuildRequires: sharutils | ||
| BuildRequires: xz-devel | ||
| BuildRequires: zlib-devel | ||
|
|
||
| %description | ||
| Libarchive is a programming library that can create and read several different | ||
| streaming archive formats, including most popular tar variants, several cpio | ||
| formats, and both BSD and GNU ar variants. It can also write shar archives and | ||
| read ISO9660 CDROM images and ZIP archives. | ||
|
|
||
|
|
||
| %package devel | ||
| Summary: Development files for %{name} | ||
| Requires: %{name}%{?_isa} = %{version}-%{release} | ||
|
|
||
| %description devel | ||
| The %{name}-devel package contains libraries and header files for | ||
| developing applications that use %{name}. | ||
|
|
||
|
|
||
| %package -n bsdtar | ||
| Summary: Manipulate tape archives | ||
| Requires: %{name}%{?_isa} = %{version}-%{release} | ||
|
|
||
| %description -n bsdtar | ||
| The bsdtar package contains standalone bsdtar utility split off regular | ||
| libarchive packages. | ||
|
|
||
|
|
||
| %package -n bsdcpio | ||
| Summary: Copy files to and from archives | ||
| Requires: %{name}%{?_isa} = %{version}-%{release} | ||
|
|
||
| %description -n bsdcpio | ||
| The bsdcpio package contains standalone bsdcpio utility split off regular | ||
| libarchive packages. | ||
|
|
||
|
|
||
| %package -n bsdcat | ||
| Summary: Expand files to standard output | ||
| Requires: %{name}%{?_isa} = %{version}-%{release} | ||
|
|
||
| %description -n bsdcat | ||
| The bsdcat program typically takes a filename as an argument or reads standard | ||
| input when used in a pipe. In both cases decompressed data it written to | ||
| standard output. | ||
|
|
||
|
|
||
| %prep | ||
| {{{ git_setup_macro }}} | ||
| %autosetup -p1 | ||
|
|
||
|
|
||
| %build | ||
| build/autogen.sh | ||
| %configure --disable-static --without-nettle LT_SYS_LIBRARY_PATH=%_libdir | ||
| %make_build | ||
|
|
||
|
|
||
| %install | ||
| make install DESTDIR=$RPM_BUILD_ROOT | ||
| find $RPM_BUILD_ROOT -name '*.la' -exec rm -f {} ';' | ||
|
|
||
| # rhbz#1294252 | ||
| replace () | ||
| { | ||
| filename=$1 | ||
| file=`basename "$filename"` | ||
| binary=${file%%.*} | ||
| pattern=${binary##bsd} | ||
|
|
||
| awk " | ||
| # replace the topic | ||
| /^.Dt ${pattern^^} 1/ { | ||
| print \".Dt ${binary^^} 1\"; | ||
| next; | ||
| } | ||
| # replace the first occurence of \"$pattern\" by \"$binary\" | ||
| !stop && /^.Nm $pattern/ { | ||
| print \".Nm $binary\" ; | ||
| stop = 1 ; | ||
| next; | ||
| } | ||
| # print remaining lines | ||
| 1; | ||
| " "$filename" > "$filename.new" | ||
| mv "$filename".new "$filename" | ||
| } | ||
|
|
||
| for manpage in bsdtar.1 bsdcpio.1 | ||
| do | ||
| installed_manpage=`find "$RPM_BUILD_ROOT" -name "$manpage"` | ||
| replace "$installed_manpage" | ||
| done | ||
|
|
||
|
|
||
| %check | ||
| %if %{with check} | ||
| logfiles () | ||
| { | ||
| find -name '*_test.log' -or -name test-suite.log | ||
| } | ||
|
|
||
| tempdirs () | ||
| { | ||
| cat `logfiles` \ | ||
| | awk "match(\$0, /[^[:space:]]*`date -I`[^[:space:]]*/) { print substr(\$0, RSTART, RLENGTH); }" \ | ||
| | sort | uniq | ||
| } | ||
|
|
||
| cat_logs () | ||
| { | ||
| for i in `logfiles` | ||
| do | ||
| echo "=== $i ===" | ||
| cat "$i" | ||
| done | ||
| } | ||
|
|
||
| run_testsuite () | ||
| { | ||
| rc=0 | ||
| %make_build check -j1 || { | ||
| # error happened - try to extract in koji as much info as possible | ||
| cat_logs | ||
|
|
||
| for i in `tempdirs`; do | ||
| if test -d "$i" ; then | ||
| find $i -printf "%p\n ~> a: %a\n ~> c: %c\n ~> t: %t\n ~> %s B\n" | ||
| cat $i/*.log | ||
| fi | ||
| done | ||
| return 1 | ||
| } | ||
| cat_logs | ||
| } | ||
|
|
||
| # On a ppc/ppc64 is some race condition causing 'make check' fail on ppc | ||
| # when both 32 and 64 builds are done in parallel on the same machine in | ||
| # koji. Try to run once again if failed. | ||
| %ifarch ppc | ||
| run_testsuite || run_testsuite | ||
| %else | ||
| run_testsuite | ||
| %endif | ||
| %endif | ||
|
|
||
|
|
||
| %files | ||
| %{!?_licensedir:%global license %%doc} | ||
| %license COPYING | ||
| %doc NEWS README.md | ||
| %{_libdir}/libarchive.so.13* | ||
| %{_mandir}/*/cpio.* | ||
| %{_mandir}/*/mtree.* | ||
| %{_mandir}/*/tar.* | ||
|
|
||
| %files devel | ||
| %{_includedir}/*.h | ||
| %{_mandir}/*/archive* | ||
| %{_mandir}/*/libarchive* | ||
| %{_libdir}/libarchive.so | ||
| %{_libdir}/pkgconfig/libarchive.pc | ||
|
|
||
| %files -n bsdtar | ||
| %{!?_licensedir:%global license %%doc} | ||
| %license COPYING | ||
| %doc NEWS README.md | ||
| %{_bindir}/bsdtar | ||
| %{_mandir}/*/bsdtar* | ||
|
|
||
| %files -n bsdcpio | ||
| %{!?_licensedir:%global license %%doc} | ||
| %license COPYING | ||
| %doc NEWS README.md | ||
| %{_bindir}/bsdcpio | ||
| %{_mandir}/*/bsdcpio* | ||
|
|
||
| %files -n bsdcat | ||
| %{!?_licensedir:%global license %%doc} | ||
| %license COPYING | ||
| %doc NEWS README.md | ||
| %{_bindir}/bsdcat | ||
| %{_mandir}/*/bsdcat* | ||
|
|
||
|
|
||
|
|
||
| %changelog | ||
| * Thu Mar 28 2019 Pavel Raiskup <praiskup@redhat.com> - 3.3.3-7 | ||
| - simplify libtool hacks | ||
|
|
||
| {{ git_changelog }} |
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,194 @@ | ||
| /* | ||
| BLAKE2 reference source code package - reference C implementations | ||
| Copyright 2012, Samuel Neves <sneves@dei.uc.pt>. You may use this under the | ||
| terms of the CC0, the OpenSSL Licence, or the Apache Public License 2.0, at | ||
| your option. The terms of these licenses can be found at: | ||
| - CC0 1.0 Universal : http://creativecommons.org/publicdomain/zero/1.0 | ||
| - OpenSSL license : https://www.openssl.org/source/license.html | ||
| - Apache 2.0 : http://www.apache.org/licenses/LICENSE-2.0 | ||
| More information about the BLAKE2 hash function can be found at | ||
| https://blake2.net. | ||
| */ | ||
| #ifndef BLAKE2_H | ||
| #define BLAKE2_H | ||
|
|
||
| #include <stddef.h> | ||
| #include <stdint.h> | ||
|
|
||
| #if defined(_MSC_VER) | ||
| #define BLAKE2_PACKED(x) __pragma(pack(push, 1)) x __pragma(pack(pop)) | ||
| #else | ||
| #define BLAKE2_PACKED(x) x __attribute__((packed)) | ||
| #endif | ||
|
|
||
| #if defined(__cplusplus) | ||
| extern "C" { | ||
| #endif | ||
|
|
||
| enum blake2s_constant | ||
| { | ||
| BLAKE2S_BLOCKBYTES = 64, | ||
| BLAKE2S_OUTBYTES = 32, | ||
| BLAKE2S_KEYBYTES = 32, | ||
| BLAKE2S_SALTBYTES = 8, | ||
| BLAKE2S_PERSONALBYTES = 8 | ||
| }; | ||
|
|
||
| enum blake2b_constant | ||
| { | ||
| BLAKE2B_BLOCKBYTES = 128, | ||
| BLAKE2B_OUTBYTES = 64, | ||
| BLAKE2B_KEYBYTES = 64, | ||
| BLAKE2B_SALTBYTES = 16, | ||
| BLAKE2B_PERSONALBYTES = 16 | ||
| }; | ||
|
|
||
| typedef struct blake2s_state__ | ||
| { | ||
| uint32_t h[8]; | ||
| uint32_t t[2]; | ||
| uint32_t f[2]; | ||
| uint8_t buf[BLAKE2S_BLOCKBYTES]; | ||
| size_t buflen; | ||
| size_t outlen; | ||
| uint8_t last_node; | ||
| } blake2s_state; | ||
|
|
||
| typedef struct blake2b_state__ | ||
| { | ||
| uint64_t h[8]; | ||
| uint64_t t[2]; | ||
| uint64_t f[2]; | ||
| uint8_t buf[BLAKE2B_BLOCKBYTES]; | ||
| size_t buflen; | ||
| size_t outlen; | ||
| uint8_t last_node; | ||
| } blake2b_state; | ||
|
|
||
| typedef struct blake2sp_state__ | ||
| { | ||
| blake2s_state S[8][1]; | ||
| blake2s_state R[1]; | ||
| uint8_t buf[8 * BLAKE2S_BLOCKBYTES]; | ||
| size_t buflen; | ||
| size_t outlen; | ||
| } blake2sp_state; | ||
|
|
||
| typedef struct blake2bp_state__ | ||
| { | ||
| blake2b_state S[4][1]; | ||
| blake2b_state R[1]; | ||
| uint8_t buf[4 * BLAKE2B_BLOCKBYTES]; | ||
| size_t buflen; | ||
| size_t outlen; | ||
| } blake2bp_state; | ||
|
|
||
| BLAKE2_PACKED(struct blake2s_param__ | ||
| { | ||
| uint8_t digest_length; /* 1 */ | ||
| uint8_t key_length; /* 2 */ | ||
| uint8_t fanout; /* 3 */ | ||
| uint8_t depth; /* 4 */ | ||
| uint32_t leaf_length; /* 8 */ | ||
| uint32_t node_offset; /* 12 */ | ||
| uint16_t xof_length; /* 14 */ | ||
| uint8_t node_depth; /* 15 */ | ||
| uint8_t inner_length; /* 16 */ | ||
| /* uint8_t reserved[0]; */ | ||
| uint8_t salt[BLAKE2S_SALTBYTES]; /* 24 */ | ||
| uint8_t personal[BLAKE2S_PERSONALBYTES]; /* 32 */ | ||
| }); | ||
|
|
||
| typedef struct blake2s_param__ blake2s_param; | ||
|
|
||
| BLAKE2_PACKED(struct blake2b_param__ | ||
| { | ||
| uint8_t digest_length; /* 1 */ | ||
| uint8_t key_length; /* 2 */ | ||
| uint8_t fanout; /* 3 */ | ||
| uint8_t depth; /* 4 */ | ||
| uint32_t leaf_length; /* 8 */ | ||
| uint32_t node_offset; /* 12 */ | ||
| uint32_t xof_length; /* 16 */ | ||
| uint8_t node_depth; /* 17 */ | ||
| uint8_t inner_length; /* 18 */ | ||
| uint8_t reserved[14]; /* 32 */ | ||
| uint8_t salt[BLAKE2B_SALTBYTES]; /* 48 */ | ||
| uint8_t personal[BLAKE2B_PERSONALBYTES]; /* 64 */ | ||
| }); | ||
|
|
||
| typedef struct blake2b_param__ blake2b_param; | ||
|
|
||
| typedef struct blake2xs_state__ | ||
| { | ||
| blake2s_state S[1]; | ||
| blake2s_param P[1]; | ||
| } blake2xs_state; | ||
|
|
||
| typedef struct blake2xb_state__ | ||
| { | ||
| blake2b_state S[1]; | ||
| blake2b_param P[1]; | ||
| } blake2xb_state; | ||
|
|
||
| /* Padded structs result in a compile-time error */ | ||
| enum { | ||
| BLAKE2_DUMMY_1 = 1/(sizeof(blake2s_param) == BLAKE2S_OUTBYTES), | ||
| BLAKE2_DUMMY_2 = 1/(sizeof(blake2b_param) == BLAKE2B_OUTBYTES) | ||
| }; | ||
|
|
||
| /* Streaming API */ | ||
| int blake2s_init( blake2s_state *S, size_t outlen ); | ||
| int blake2s_init_key( blake2s_state *S, size_t outlen, const void *key, size_t keylen ); | ||
| int blake2s_init_param( blake2s_state *S, const blake2s_param *P ); | ||
| int blake2s_update( blake2s_state *S, const void *in, size_t inlen ); | ||
| int blake2s_final( blake2s_state *S, void *out, size_t outlen ); | ||
|
|
||
| int blake2b_init( blake2b_state *S, size_t outlen ); | ||
| int blake2b_init_key( blake2b_state *S, size_t outlen, const void *key, size_t keylen ); | ||
| int blake2b_init_param( blake2b_state *S, const blake2b_param *P ); | ||
| int blake2b_update( blake2b_state *S, const void *in, size_t inlen ); | ||
| int blake2b_final( blake2b_state *S, void *out, size_t outlen ); | ||
|
|
||
| int blake2sp_init( blake2sp_state *S, size_t outlen ); | ||
| int blake2sp_init_key( blake2sp_state *S, size_t outlen, const void *key, size_t keylen ); | ||
| int blake2sp_update( blake2sp_state *S, const void *in, size_t inlen ); | ||
| int blake2sp_final( blake2sp_state *S, void *out, size_t outlen ); | ||
|
|
||
| int blake2bp_init( blake2bp_state *S, size_t outlen ); | ||
| int blake2bp_init_key( blake2bp_state *S, size_t outlen, const void *key, size_t keylen ); | ||
| int blake2bp_update( blake2bp_state *S, const void *in, size_t inlen ); | ||
| int blake2bp_final( blake2bp_state *S, void *out, size_t outlen ); | ||
|
|
||
| /* Variable output length API */ | ||
| int blake2xs_init( blake2xs_state *S, const size_t outlen ); | ||
| int blake2xs_init_key( blake2xs_state *S, const size_t outlen, const void *key, size_t keylen ); | ||
| int blake2xs_update( blake2xs_state *S, const void *in, size_t inlen ); | ||
| int blake2xs_final(blake2xs_state *S, void *out, size_t outlen); | ||
|
|
||
| int blake2xb_init( blake2xb_state *S, const size_t outlen ); | ||
| int blake2xb_init_key( blake2xb_state *S, const size_t outlen, const void *key, size_t keylen ); | ||
| int blake2xb_update( blake2xb_state *S, const void *in, size_t inlen ); | ||
| int blake2xb_final(blake2xb_state *S, void *out, size_t outlen); | ||
|
|
||
| /* Simple API */ | ||
| int blake2s( void *out, size_t outlen, const void *in, size_t inlen, const void *key, size_t keylen ); | ||
| int blake2b( void *out, size_t outlen, const void *in, size_t inlen, const void *key, size_t keylen ); | ||
|
|
||
| int blake2sp( void *out, size_t outlen, const void *in, size_t inlen, const void *key, size_t keylen ); | ||
| int blake2bp( void *out, size_t outlen, const void *in, size_t inlen, const void *key, size_t keylen ); | ||
|
|
||
| int blake2xs( void *out, size_t outlen, const void *in, size_t inlen, const void *key, size_t keylen ); | ||
| int blake2xb( void *out, size_t outlen, const void *in, size_t inlen, const void *key, size_t keylen ); | ||
|
|
||
| /* This is simply an alias for blake2b */ | ||
| int blake2( void *out, size_t outlen, const void *in, size_t inlen, const void *key, size_t keylen ); | ||
|
|
||
| #if defined(__cplusplus) | ||
| } | ||
| #endif | ||
|
|
||
| #endif |
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,160 @@ | ||
| /* | ||
| BLAKE2 reference source code package - reference C implementations | ||
| Copyright 2012, Samuel Neves <sneves@dei.uc.pt>. You may use this under the | ||
| terms of the CC0, the OpenSSL Licence, or the Apache Public License 2.0, at | ||
| your option. The terms of these licenses can be found at: | ||
| - CC0 1.0 Universal : http://creativecommons.org/publicdomain/zero/1.0 | ||
| - OpenSSL license : https://www.openssl.org/source/license.html | ||
| - Apache 2.0 : http://www.apache.org/licenses/LICENSE-2.0 | ||
| More information about the BLAKE2 hash function can be found at | ||
| https://blake2.net. | ||
| */ | ||
| #ifndef BLAKE2_IMPL_H | ||
| #define BLAKE2_IMPL_H | ||
|
|
||
| #include <stdint.h> | ||
| #include <string.h> | ||
|
|
||
| #if !defined(__cplusplus) && (!defined(__STDC_VERSION__) || __STDC_VERSION__ < 199901L) | ||
| #if defined(_MSC_VER) | ||
| #define BLAKE2_INLINE __inline | ||
| #elif defined(__GNUC__) | ||
| #define BLAKE2_INLINE __inline__ | ||
| #else | ||
| #define BLAKE2_INLINE | ||
| #endif | ||
| #else | ||
| #define BLAKE2_INLINE inline | ||
| #endif | ||
|
|
||
| static BLAKE2_INLINE uint32_t load32( const void *src ) | ||
| { | ||
| #if defined(NATIVE_LITTLE_ENDIAN) | ||
| uint32_t w; | ||
| memcpy(&w, src, sizeof w); | ||
| return w; | ||
| #else | ||
| const uint8_t *p = ( const uint8_t * )src; | ||
| return (( uint32_t )( p[0] ) << 0) | | ||
| (( uint32_t )( p[1] ) << 8) | | ||
| (( uint32_t )( p[2] ) << 16) | | ||
| (( uint32_t )( p[3] ) << 24) ; | ||
| #endif | ||
| } | ||
|
|
||
| static BLAKE2_INLINE uint64_t load64( const void *src ) | ||
| { | ||
| #if defined(NATIVE_LITTLE_ENDIAN) | ||
| uint64_t w; | ||
| memcpy(&w, src, sizeof w); | ||
| return w; | ||
| #else | ||
| const uint8_t *p = ( const uint8_t * )src; | ||
| return (( uint64_t )( p[0] ) << 0) | | ||
| (( uint64_t )( p[1] ) << 8) | | ||
| (( uint64_t )( p[2] ) << 16) | | ||
| (( uint64_t )( p[3] ) << 24) | | ||
| (( uint64_t )( p[4] ) << 32) | | ||
| (( uint64_t )( p[5] ) << 40) | | ||
| (( uint64_t )( p[6] ) << 48) | | ||
| (( uint64_t )( p[7] ) << 56) ; | ||
| #endif | ||
| } | ||
|
|
||
| static BLAKE2_INLINE uint16_t load16( const void *src ) | ||
| { | ||
| #if defined(NATIVE_LITTLE_ENDIAN) | ||
| uint16_t w; | ||
| memcpy(&w, src, sizeof w); | ||
| return w; | ||
| #else | ||
| const uint8_t *p = ( const uint8_t * )src; | ||
| return ( uint16_t )((( uint32_t )( p[0] ) << 0) | | ||
| (( uint32_t )( p[1] ) << 8)); | ||
| #endif | ||
| } | ||
|
|
||
| static BLAKE2_INLINE void store16( void *dst, uint16_t w ) | ||
| { | ||
| #if defined(NATIVE_LITTLE_ENDIAN) | ||
| memcpy(dst, &w, sizeof w); | ||
| #else | ||
| uint8_t *p = ( uint8_t * )dst; | ||
| *p++ = ( uint8_t )w; w >>= 8; | ||
| *p++ = ( uint8_t )w; | ||
| #endif | ||
| } | ||
|
|
||
| static BLAKE2_INLINE void store32( void *dst, uint32_t w ) | ||
| { | ||
| #if defined(NATIVE_LITTLE_ENDIAN) | ||
| memcpy(dst, &w, sizeof w); | ||
| #else | ||
| uint8_t *p = ( uint8_t * )dst; | ||
| p[0] = (uint8_t)(w >> 0); | ||
| p[1] = (uint8_t)(w >> 8); | ||
| p[2] = (uint8_t)(w >> 16); | ||
| p[3] = (uint8_t)(w >> 24); | ||
| #endif | ||
| } | ||
|
|
||
| static BLAKE2_INLINE void store64( void *dst, uint64_t w ) | ||
| { | ||
| #if defined(NATIVE_LITTLE_ENDIAN) | ||
| memcpy(dst, &w, sizeof w); | ||
| #else | ||
| uint8_t *p = ( uint8_t * )dst; | ||
| p[0] = (uint8_t)(w >> 0); | ||
| p[1] = (uint8_t)(w >> 8); | ||
| p[2] = (uint8_t)(w >> 16); | ||
| p[3] = (uint8_t)(w >> 24); | ||
| p[4] = (uint8_t)(w >> 32); | ||
| p[5] = (uint8_t)(w >> 40); | ||
| p[6] = (uint8_t)(w >> 48); | ||
| p[7] = (uint8_t)(w >> 56); | ||
| #endif | ||
| } | ||
|
|
||
| static BLAKE2_INLINE uint64_t load48( const void *src ) | ||
| { | ||
| const uint8_t *p = ( const uint8_t * )src; | ||
| return (( uint64_t )( p[0] ) << 0) | | ||
| (( uint64_t )( p[1] ) << 8) | | ||
| (( uint64_t )( p[2] ) << 16) | | ||
| (( uint64_t )( p[3] ) << 24) | | ||
| (( uint64_t )( p[4] ) << 32) | | ||
| (( uint64_t )( p[5] ) << 40) ; | ||
| } | ||
|
|
||
| static BLAKE2_INLINE void store48( void *dst, uint64_t w ) | ||
| { | ||
| uint8_t *p = ( uint8_t * )dst; | ||
| p[0] = (uint8_t)(w >> 0); | ||
| p[1] = (uint8_t)(w >> 8); | ||
| p[2] = (uint8_t)(w >> 16); | ||
| p[3] = (uint8_t)(w >> 24); | ||
| p[4] = (uint8_t)(w >> 32); | ||
| p[5] = (uint8_t)(w >> 40); | ||
| } | ||
|
|
||
| static BLAKE2_INLINE uint32_t rotr32( const uint32_t w, const unsigned c ) | ||
| { | ||
| return ( w >> c ) | ( w << ( 32 - c ) ); | ||
| } | ||
|
|
||
| static BLAKE2_INLINE uint64_t rotr64( const uint64_t w, const unsigned c ) | ||
| { | ||
| return ( w >> c ) | ( w << ( 64 - c ) ); | ||
| } | ||
|
|
||
| /* prevents compiler optimizing out memset() */ | ||
| static BLAKE2_INLINE void secure_zero_memory(void *v, size_t n) | ||
| { | ||
| static void *(*const volatile memset_v)(void *, int, size_t) = &memset; | ||
| memset_v(v, 0, n); | ||
| } | ||
|
|
||
| #endif |
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,367 @@ | ||
| /* | ||
| BLAKE2 reference source code package - reference C implementations | ||
| Copyright 2012, Samuel Neves <sneves@dei.uc.pt>. You may use this under the | ||
| terms of the CC0, the OpenSSL Licence, or the Apache Public License 2.0, at | ||
| your option. The terms of these licenses can be found at: | ||
| - CC0 1.0 Universal : http://creativecommons.org/publicdomain/zero/1.0 | ||
| - OpenSSL license : https://www.openssl.org/source/license.html | ||
| - Apache 2.0 : http://www.apache.org/licenses/LICENSE-2.0 | ||
| More information about the BLAKE2 hash function can be found at | ||
| https://blake2.net. | ||
| */ | ||
|
|
||
| #include <stdint.h> | ||
| #include <string.h> | ||
| #include <stdio.h> | ||
|
|
||
| #include "archive_blake2.h" | ||
| #include "archive_blake2_impl.h" | ||
|
|
||
| static const uint32_t blake2s_IV[8] = | ||
| { | ||
| 0x6A09E667UL, 0xBB67AE85UL, 0x3C6EF372UL, 0xA54FF53AUL, | ||
| 0x510E527FUL, 0x9B05688CUL, 0x1F83D9ABUL, 0x5BE0CD19UL | ||
| }; | ||
|
|
||
| static const uint8_t blake2s_sigma[10][16] = | ||
| { | ||
| { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 } , | ||
| { 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 } , | ||
| { 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 } , | ||
| { 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 } , | ||
| { 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 } , | ||
| { 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 } , | ||
| { 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11 } , | ||
| { 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10 } , | ||
| { 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5 } , | ||
| { 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13 , 0 } , | ||
| }; | ||
|
|
||
| static void blake2s_set_lastnode( blake2s_state *S ) | ||
| { | ||
| S->f[1] = (uint32_t)-1; | ||
| } | ||
|
|
||
| /* Some helper functions, not necessarily useful */ | ||
| static int blake2s_is_lastblock( const blake2s_state *S ) | ||
| { | ||
| return S->f[0] != 0; | ||
| } | ||
|
|
||
| static void blake2s_set_lastblock( blake2s_state *S ) | ||
| { | ||
| if( S->last_node ) blake2s_set_lastnode( S ); | ||
|
|
||
| S->f[0] = (uint32_t)-1; | ||
| } | ||
|
|
||
| static void blake2s_increment_counter( blake2s_state *S, const uint32_t inc ) | ||
| { | ||
| S->t[0] += inc; | ||
| S->t[1] += ( S->t[0] < inc ); | ||
| } | ||
|
|
||
| static void blake2s_init0( blake2s_state *S ) | ||
| { | ||
| size_t i; | ||
| memset( S, 0, sizeof( blake2s_state ) ); | ||
|
|
||
| for( i = 0; i < 8; ++i ) S->h[i] = blake2s_IV[i]; | ||
| } | ||
|
|
||
| /* init2 xors IV with input parameter block */ | ||
| int blake2s_init_param( blake2s_state *S, const blake2s_param *P ) | ||
| { | ||
| const unsigned char *p = ( const unsigned char * )( P ); | ||
| size_t i; | ||
|
|
||
| blake2s_init0( S ); | ||
|
|
||
| /* IV XOR ParamBlock */ | ||
| for( i = 0; i < 8; ++i ) | ||
| S->h[i] ^= load32( &p[i * 4] ); | ||
|
|
||
| S->outlen = P->digest_length; | ||
| return 0; | ||
| } | ||
|
|
||
|
|
||
| /* Sequential blake2s initialization */ | ||
| int blake2s_init( blake2s_state *S, size_t outlen ) | ||
| { | ||
| blake2s_param P[1]; | ||
|
|
||
| /* Move interval verification here? */ | ||
| if ( ( !outlen ) || ( outlen > BLAKE2S_OUTBYTES ) ) return -1; | ||
|
|
||
| P->digest_length = (uint8_t)outlen; | ||
| P->key_length = 0; | ||
| P->fanout = 1; | ||
| P->depth = 1; | ||
| store32( &P->leaf_length, 0 ); | ||
| store32( &P->node_offset, 0 ); | ||
| store16( &P->xof_length, 0 ); | ||
| P->node_depth = 0; | ||
| P->inner_length = 0; | ||
| /* memset(P->reserved, 0, sizeof(P->reserved) ); */ | ||
| memset( P->salt, 0, sizeof( P->salt ) ); | ||
| memset( P->personal, 0, sizeof( P->personal ) ); | ||
| return blake2s_init_param( S, P ); | ||
| } | ||
|
|
||
| int blake2s_init_key( blake2s_state *S, size_t outlen, const void *key, size_t keylen ) | ||
| { | ||
| blake2s_param P[1]; | ||
|
|
||
| if ( ( !outlen ) || ( outlen > BLAKE2S_OUTBYTES ) ) return -1; | ||
|
|
||
| if ( !key || !keylen || keylen > BLAKE2S_KEYBYTES ) return -1; | ||
|
|
||
| P->digest_length = (uint8_t)outlen; | ||
| P->key_length = (uint8_t)keylen; | ||
| P->fanout = 1; | ||
| P->depth = 1; | ||
| store32( &P->leaf_length, 0 ); | ||
| store32( &P->node_offset, 0 ); | ||
| store16( &P->xof_length, 0 ); | ||
| P->node_depth = 0; | ||
| P->inner_length = 0; | ||
| /* memset(P->reserved, 0, sizeof(P->reserved) ); */ | ||
| memset( P->salt, 0, sizeof( P->salt ) ); | ||
| memset( P->personal, 0, sizeof( P->personal ) ); | ||
|
|
||
| if( blake2s_init_param( S, P ) < 0 ) return -1; | ||
|
|
||
| { | ||
| uint8_t block[BLAKE2S_BLOCKBYTES]; | ||
| memset( block, 0, BLAKE2S_BLOCKBYTES ); | ||
| memcpy( block, key, keylen ); | ||
| blake2s_update( S, block, BLAKE2S_BLOCKBYTES ); | ||
| secure_zero_memory( block, BLAKE2S_BLOCKBYTES ); /* Burn the key from stack */ | ||
| } | ||
| return 0; | ||
| } | ||
|
|
||
| #define G(r,i,a,b,c,d) \ | ||
| do { \ | ||
| a = a + b + m[blake2s_sigma[r][2*i+0]]; \ | ||
| d = rotr32(d ^ a, 16); \ | ||
| c = c + d; \ | ||
| b = rotr32(b ^ c, 12); \ | ||
| a = a + b + m[blake2s_sigma[r][2*i+1]]; \ | ||
| d = rotr32(d ^ a, 8); \ | ||
| c = c + d; \ | ||
| b = rotr32(b ^ c, 7); \ | ||
| } while(0) | ||
|
|
||
| #define ROUND(r) \ | ||
| do { \ | ||
| G(r,0,v[ 0],v[ 4],v[ 8],v[12]); \ | ||
| G(r,1,v[ 1],v[ 5],v[ 9],v[13]); \ | ||
| G(r,2,v[ 2],v[ 6],v[10],v[14]); \ | ||
| G(r,3,v[ 3],v[ 7],v[11],v[15]); \ | ||
| G(r,4,v[ 0],v[ 5],v[10],v[15]); \ | ||
| G(r,5,v[ 1],v[ 6],v[11],v[12]); \ | ||
| G(r,6,v[ 2],v[ 7],v[ 8],v[13]); \ | ||
| G(r,7,v[ 3],v[ 4],v[ 9],v[14]); \ | ||
| } while(0) | ||
|
|
||
| static void blake2s_compress( blake2s_state *S, const uint8_t in[BLAKE2S_BLOCKBYTES] ) | ||
| { | ||
| uint32_t m[16]; | ||
| uint32_t v[16]; | ||
| size_t i; | ||
|
|
||
| for( i = 0; i < 16; ++i ) { | ||
| m[i] = load32( in + i * sizeof( m[i] ) ); | ||
| } | ||
|
|
||
| for( i = 0; i < 8; ++i ) { | ||
| v[i] = S->h[i]; | ||
| } | ||
|
|
||
| v[ 8] = blake2s_IV[0]; | ||
| v[ 9] = blake2s_IV[1]; | ||
| v[10] = blake2s_IV[2]; | ||
| v[11] = blake2s_IV[3]; | ||
| v[12] = S->t[0] ^ blake2s_IV[4]; | ||
| v[13] = S->t[1] ^ blake2s_IV[5]; | ||
| v[14] = S->f[0] ^ blake2s_IV[6]; | ||
| v[15] = S->f[1] ^ blake2s_IV[7]; | ||
|
|
||
| ROUND( 0 ); | ||
| ROUND( 1 ); | ||
| ROUND( 2 ); | ||
| ROUND( 3 ); | ||
| ROUND( 4 ); | ||
| ROUND( 5 ); | ||
| ROUND( 6 ); | ||
| ROUND( 7 ); | ||
| ROUND( 8 ); | ||
| ROUND( 9 ); | ||
|
|
||
| for( i = 0; i < 8; ++i ) { | ||
| S->h[i] = S->h[i] ^ v[i] ^ v[i + 8]; | ||
| } | ||
| } | ||
|
|
||
| #undef G | ||
| #undef ROUND | ||
|
|
||
| int blake2s_update( blake2s_state *S, const void *pin, size_t inlen ) | ||
| { | ||
| const unsigned char * in = (const unsigned char *)pin; | ||
| if( inlen > 0 ) | ||
| { | ||
| size_t left = S->buflen; | ||
| size_t fill = BLAKE2S_BLOCKBYTES - left; | ||
| if( inlen > fill ) | ||
| { | ||
| S->buflen = 0; | ||
| memcpy( S->buf + left, in, fill ); /* Fill buffer */ | ||
| blake2s_increment_counter( S, BLAKE2S_BLOCKBYTES ); | ||
| blake2s_compress( S, S->buf ); /* Compress */ | ||
| in += fill; inlen -= fill; | ||
| while(inlen > BLAKE2S_BLOCKBYTES) { | ||
| blake2s_increment_counter(S, BLAKE2S_BLOCKBYTES); | ||
| blake2s_compress( S, in ); | ||
| in += BLAKE2S_BLOCKBYTES; | ||
| inlen -= BLAKE2S_BLOCKBYTES; | ||
| } | ||
| } | ||
| memcpy( S->buf + S->buflen, in, inlen ); | ||
| S->buflen += inlen; | ||
| } | ||
| return 0; | ||
| } | ||
|
|
||
| int blake2s_final( blake2s_state *S, void *out, size_t outlen ) | ||
| { | ||
| uint8_t buffer[BLAKE2S_OUTBYTES] = {0}; | ||
| size_t i; | ||
|
|
||
| if( out == NULL || outlen < S->outlen ) | ||
| return -1; | ||
|
|
||
| if( blake2s_is_lastblock( S ) ) | ||
| return -1; | ||
|
|
||
| blake2s_increment_counter( S, ( uint32_t )S->buflen ); | ||
| blake2s_set_lastblock( S ); | ||
| memset( S->buf + S->buflen, 0, BLAKE2S_BLOCKBYTES - S->buflen ); /* Padding */ | ||
| blake2s_compress( S, S->buf ); | ||
|
|
||
| for( i = 0; i < 8; ++i ) /* Output full hash to temp buffer */ | ||
| store32( buffer + sizeof( S->h[i] ) * i, S->h[i] ); | ||
|
|
||
| memcpy( out, buffer, outlen ); | ||
| secure_zero_memory(buffer, sizeof(buffer)); | ||
| return 0; | ||
| } | ||
|
|
||
| int blake2s( void *out, size_t outlen, const void *in, size_t inlen, const void *key, size_t keylen ) | ||
| { | ||
| blake2s_state S[1]; | ||
|
|
||
| /* Verify parameters */ | ||
| if ( NULL == in && inlen > 0 ) return -1; | ||
|
|
||
| if ( NULL == out ) return -1; | ||
|
|
||
| if ( NULL == key && keylen > 0) return -1; | ||
|
|
||
| if( !outlen || outlen > BLAKE2S_OUTBYTES ) return -1; | ||
|
|
||
| if( keylen > BLAKE2S_KEYBYTES ) return -1; | ||
|
|
||
| if( keylen > 0 ) | ||
| { | ||
| if( blake2s_init_key( S, outlen, key, keylen ) < 0 ) return -1; | ||
| } | ||
| else | ||
| { | ||
| if( blake2s_init( S, outlen ) < 0 ) return -1; | ||
| } | ||
|
|
||
| blake2s_update( S, ( const uint8_t * )in, inlen ); | ||
| blake2s_final( S, out, outlen ); | ||
| return 0; | ||
| } | ||
|
|
||
| #if defined(SUPERCOP) | ||
| int crypto_hash( unsigned char *out, unsigned char *in, unsigned long long inlen ) | ||
| { | ||
| return blake2s( out, BLAKE2S_OUTBYTES, in, inlen, NULL, 0 ); | ||
| } | ||
| #endif | ||
|
|
||
| #if defined(BLAKE2S_SELFTEST) | ||
| #include <string.h> | ||
| #include "blake2-kat.h" | ||
| int main( void ) | ||
| { | ||
| uint8_t key[BLAKE2S_KEYBYTES]; | ||
| uint8_t buf[BLAKE2_KAT_LENGTH]; | ||
| size_t i, step; | ||
|
|
||
| for( i = 0; i < BLAKE2S_KEYBYTES; ++i ) | ||
| key[i] = ( uint8_t )i; | ||
|
|
||
| for( i = 0; i < BLAKE2_KAT_LENGTH; ++i ) | ||
| buf[i] = ( uint8_t )i; | ||
|
|
||
| /* Test simple API */ | ||
| for( i = 0; i < BLAKE2_KAT_LENGTH; ++i ) | ||
| { | ||
| uint8_t hash[BLAKE2S_OUTBYTES]; | ||
| blake2s( hash, BLAKE2S_OUTBYTES, buf, i, key, BLAKE2S_KEYBYTES ); | ||
|
|
||
| if( 0 != memcmp( hash, blake2s_keyed_kat[i], BLAKE2S_OUTBYTES ) ) | ||
| { | ||
| goto fail; | ||
| } | ||
| } | ||
|
|
||
| /* Test streaming API */ | ||
| for(step = 1; step < BLAKE2S_BLOCKBYTES; ++step) { | ||
| for (i = 0; i < BLAKE2_KAT_LENGTH; ++i) { | ||
| uint8_t hash[BLAKE2S_OUTBYTES]; | ||
| blake2s_state S; | ||
| uint8_t * p = buf; | ||
| size_t mlen = i; | ||
| int err = 0; | ||
|
|
||
| if( (err = blake2s_init_key(&S, BLAKE2S_OUTBYTES, key, BLAKE2S_KEYBYTES)) < 0 ) { | ||
| goto fail; | ||
| } | ||
|
|
||
| while (mlen >= step) { | ||
| if ( (err = blake2s_update(&S, p, step)) < 0 ) { | ||
| goto fail; | ||
| } | ||
| mlen -= step; | ||
| p += step; | ||
| } | ||
| if ( (err = blake2s_update(&S, p, mlen)) < 0) { | ||
| goto fail; | ||
| } | ||
| if ( (err = blake2s_final(&S, hash, BLAKE2S_OUTBYTES)) < 0) { | ||
| goto fail; | ||
| } | ||
|
|
||
| if (0 != memcmp(hash, blake2s_keyed_kat[i], BLAKE2S_OUTBYTES)) { | ||
| goto fail; | ||
| } | ||
| } | ||
| } | ||
|
|
||
| puts( "ok" ); | ||
| return 0; | ||
| fail: | ||
| puts("error"); | ||
| return -1; | ||
| } | ||
| #endif |
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,359 @@ | ||
| /* | ||
| BLAKE2 reference source code package - reference C implementations | ||
| Copyright 2012, Samuel Neves <sneves@dei.uc.pt>. You may use this under the | ||
| terms of the CC0, the OpenSSL Licence, or the Apache Public License 2.0, at | ||
| your option. The terms of these licenses can be found at: | ||
| - CC0 1.0 Universal : http://creativecommons.org/publicdomain/zero/1.0 | ||
| - OpenSSL license : https://www.openssl.org/source/license.html | ||
| - Apache 2.0 : http://www.apache.org/licenses/LICENSE-2.0 | ||
| More information about the BLAKE2 hash function can be found at | ||
| https://blake2.net. | ||
| */ | ||
|
|
||
| #include <stdlib.h> | ||
| #include <string.h> | ||
| #include <stdio.h> | ||
|
|
||
| #if defined(_OPENMP) | ||
| #include <omp.h> | ||
| #endif | ||
|
|
||
| #include "archive_blake2.h" | ||
| #include "archive_blake2_impl.h" | ||
|
|
||
| #define PARALLELISM_DEGREE 8 | ||
|
|
||
| /* | ||
| blake2sp_init_param defaults to setting the expecting output length | ||
| from the digest_length parameter block field. | ||
| In some cases, however, we do not want this, as the output length | ||
| of these instances is given by inner_length instead. | ||
| */ | ||
| static int blake2sp_init_leaf_param( blake2s_state *S, const blake2s_param *P ) | ||
| { | ||
| int err = blake2s_init_param(S, P); | ||
| S->outlen = P->inner_length; | ||
| return err; | ||
| } | ||
|
|
||
| static int blake2sp_init_leaf( blake2s_state *S, size_t outlen, size_t keylen, uint32_t offset ) | ||
| { | ||
| blake2s_param P[1]; | ||
| P->digest_length = (uint8_t)outlen; | ||
| P->key_length = (uint8_t)keylen; | ||
| P->fanout = PARALLELISM_DEGREE; | ||
| P->depth = 2; | ||
| store32( &P->leaf_length, 0 ); | ||
| store32( &P->node_offset, offset ); | ||
| store16( &P->xof_length, 0 ); | ||
| P->node_depth = 0; | ||
| P->inner_length = BLAKE2S_OUTBYTES; | ||
| memset( P->salt, 0, sizeof( P->salt ) ); | ||
| memset( P->personal, 0, sizeof( P->personal ) ); | ||
| return blake2sp_init_leaf_param( S, P ); | ||
| } | ||
|
|
||
| static int blake2sp_init_root( blake2s_state *S, size_t outlen, size_t keylen ) | ||
| { | ||
| blake2s_param P[1]; | ||
| P->digest_length = (uint8_t)outlen; | ||
| P->key_length = (uint8_t)keylen; | ||
| P->fanout = PARALLELISM_DEGREE; | ||
| P->depth = 2; | ||
| store32( &P->leaf_length, 0 ); | ||
| store32( &P->node_offset, 0 ); | ||
| store16( &P->xof_length, 0 ); | ||
| P->node_depth = 1; | ||
| P->inner_length = BLAKE2S_OUTBYTES; | ||
| memset( P->salt, 0, sizeof( P->salt ) ); | ||
| memset( P->personal, 0, sizeof( P->personal ) ); | ||
| return blake2s_init_param( S, P ); | ||
| } | ||
|
|
||
|
|
||
| int blake2sp_init( blake2sp_state *S, size_t outlen ) | ||
| { | ||
| size_t i; | ||
|
|
||
| if( !outlen || outlen > BLAKE2S_OUTBYTES ) return -1; | ||
|
|
||
| memset( S->buf, 0, sizeof( S->buf ) ); | ||
| S->buflen = 0; | ||
| S->outlen = outlen; | ||
|
|
||
| if( blake2sp_init_root( S->R, outlen, 0 ) < 0 ) | ||
| return -1; | ||
|
|
||
| for( i = 0; i < PARALLELISM_DEGREE; ++i ) | ||
| if( blake2sp_init_leaf( S->S[i], outlen, 0, (uint32_t)i ) < 0 ) return -1; | ||
|
|
||
| S->R->last_node = 1; | ||
| S->S[PARALLELISM_DEGREE - 1]->last_node = 1; | ||
| return 0; | ||
| } | ||
|
|
||
| int blake2sp_init_key( blake2sp_state *S, size_t outlen, const void *key, size_t keylen ) | ||
| { | ||
| size_t i; | ||
|
|
||
| if( !outlen || outlen > BLAKE2S_OUTBYTES ) return -1; | ||
|
|
||
| if( !key || !keylen || keylen > BLAKE2S_KEYBYTES ) return -1; | ||
|
|
||
| memset( S->buf, 0, sizeof( S->buf ) ); | ||
| S->buflen = 0; | ||
| S->outlen = outlen; | ||
|
|
||
| if( blake2sp_init_root( S->R, outlen, keylen ) < 0 ) | ||
| return -1; | ||
|
|
||
| for( i = 0; i < PARALLELISM_DEGREE; ++i ) | ||
| if( blake2sp_init_leaf( S->S[i], outlen, keylen, (uint32_t)i ) < 0 ) return -1; | ||
|
|
||
| S->R->last_node = 1; | ||
| S->S[PARALLELISM_DEGREE - 1]->last_node = 1; | ||
| { | ||
| uint8_t block[BLAKE2S_BLOCKBYTES]; | ||
| memset( block, 0, BLAKE2S_BLOCKBYTES ); | ||
| memcpy( block, key, keylen ); | ||
|
|
||
| for( i = 0; i < PARALLELISM_DEGREE; ++i ) | ||
| blake2s_update( S->S[i], block, BLAKE2S_BLOCKBYTES ); | ||
|
|
||
| secure_zero_memory( block, BLAKE2S_BLOCKBYTES ); /* Burn the key from stack */ | ||
| } | ||
| return 0; | ||
| } | ||
|
|
||
|
|
||
| int blake2sp_update( blake2sp_state *S, const void *pin, size_t inlen ) | ||
| { | ||
| const unsigned char * in = (const unsigned char *)pin; | ||
| size_t left = S->buflen; | ||
| size_t fill = sizeof( S->buf ) - left; | ||
| size_t i; | ||
|
|
||
| if( left && inlen >= fill ) | ||
| { | ||
| memcpy( S->buf + left, in, fill ); | ||
|
|
||
| for( i = 0; i < PARALLELISM_DEGREE; ++i ) | ||
| blake2s_update( S->S[i], S->buf + i * BLAKE2S_BLOCKBYTES, BLAKE2S_BLOCKBYTES ); | ||
|
|
||
| in += fill; | ||
| inlen -= fill; | ||
| left = 0; | ||
| } | ||
|
|
||
| #if defined(_OPENMP) | ||
| #pragma omp parallel shared(S), num_threads(PARALLELISM_DEGREE) | ||
| #else | ||
| for( i = 0; i < PARALLELISM_DEGREE; ++i ) | ||
| #endif | ||
| { | ||
| #if defined(_OPENMP) | ||
| size_t i = omp_get_thread_num(); | ||
| #endif | ||
| size_t inlen__ = inlen; | ||
| const unsigned char *in__ = ( const unsigned char * )in; | ||
| in__ += i * BLAKE2S_BLOCKBYTES; | ||
|
|
||
| while( inlen__ >= PARALLELISM_DEGREE * BLAKE2S_BLOCKBYTES ) | ||
| { | ||
| blake2s_update( S->S[i], in__, BLAKE2S_BLOCKBYTES ); | ||
| in__ += PARALLELISM_DEGREE * BLAKE2S_BLOCKBYTES; | ||
| inlen__ -= PARALLELISM_DEGREE * BLAKE2S_BLOCKBYTES; | ||
| } | ||
| } | ||
|
|
||
| in += inlen - inlen % ( PARALLELISM_DEGREE * BLAKE2S_BLOCKBYTES ); | ||
| inlen %= PARALLELISM_DEGREE * BLAKE2S_BLOCKBYTES; | ||
|
|
||
| if( inlen > 0 ) | ||
| memcpy( S->buf + left, in, inlen ); | ||
|
|
||
| S->buflen = left + inlen; | ||
| return 0; | ||
| } | ||
|
|
||
|
|
||
| int blake2sp_final( blake2sp_state *S, void *out, size_t outlen ) | ||
| { | ||
| uint8_t hash[PARALLELISM_DEGREE][BLAKE2S_OUTBYTES]; | ||
| size_t i; | ||
|
|
||
| if(out == NULL || outlen < S->outlen) { | ||
| return -1; | ||
| } | ||
|
|
||
| for( i = 0; i < PARALLELISM_DEGREE; ++i ) | ||
| { | ||
| if( S->buflen > i * BLAKE2S_BLOCKBYTES ) | ||
| { | ||
| size_t left = S->buflen - i * BLAKE2S_BLOCKBYTES; | ||
|
|
||
| if( left > BLAKE2S_BLOCKBYTES ) left = BLAKE2S_BLOCKBYTES; | ||
|
|
||
| blake2s_update( S->S[i], S->buf + i * BLAKE2S_BLOCKBYTES, left ); | ||
| } | ||
|
|
||
| blake2s_final( S->S[i], hash[i], BLAKE2S_OUTBYTES ); | ||
| } | ||
|
|
||
| for( i = 0; i < PARALLELISM_DEGREE; ++i ) | ||
| blake2s_update( S->R, hash[i], BLAKE2S_OUTBYTES ); | ||
|
|
||
| return blake2s_final( S->R, out, S->outlen ); | ||
| } | ||
|
|
||
|
|
||
| int blake2sp( void *out, size_t outlen, const void *in, size_t inlen, const void *key, size_t keylen ) | ||
| { | ||
| uint8_t hash[PARALLELISM_DEGREE][BLAKE2S_OUTBYTES]; | ||
| blake2s_state S[PARALLELISM_DEGREE][1]; | ||
| blake2s_state FS[1]; | ||
| size_t i; | ||
|
|
||
| /* Verify parameters */ | ||
| if ( NULL == in && inlen > 0 ) return -1; | ||
|
|
||
| if ( NULL == out ) return -1; | ||
|
|
||
| if ( NULL == key && keylen > 0) return -1; | ||
|
|
||
| if( !outlen || outlen > BLAKE2S_OUTBYTES ) return -1; | ||
|
|
||
| if( keylen > BLAKE2S_KEYBYTES ) return -1; | ||
|
|
||
| for( i = 0; i < PARALLELISM_DEGREE; ++i ) | ||
| if( blake2sp_init_leaf( S[i], outlen, keylen, (uint32_t)i ) < 0 ) return -1; | ||
|
|
||
| S[PARALLELISM_DEGREE - 1]->last_node = 1; /* mark last node */ | ||
|
|
||
| if( keylen > 0 ) | ||
| { | ||
| uint8_t block[BLAKE2S_BLOCKBYTES]; | ||
| memset( block, 0, BLAKE2S_BLOCKBYTES ); | ||
| memcpy( block, key, keylen ); | ||
|
|
||
| for( i = 0; i < PARALLELISM_DEGREE; ++i ) | ||
| blake2s_update( S[i], block, BLAKE2S_BLOCKBYTES ); | ||
|
|
||
| secure_zero_memory( block, BLAKE2S_BLOCKBYTES ); /* Burn the key from stack */ | ||
| } | ||
|
|
||
| #if defined(_OPENMP) | ||
| #pragma omp parallel shared(S,hash), num_threads(PARALLELISM_DEGREE) | ||
| #else | ||
|
|
||
| for( i = 0; i < PARALLELISM_DEGREE; ++i ) | ||
| #endif | ||
| { | ||
| #if defined(_OPENMP) | ||
| size_t i = omp_get_thread_num(); | ||
| #endif | ||
| size_t inlen__ = inlen; | ||
| const unsigned char *in__ = ( const unsigned char * )in; | ||
| in__ += i * BLAKE2S_BLOCKBYTES; | ||
|
|
||
| while( inlen__ >= PARALLELISM_DEGREE * BLAKE2S_BLOCKBYTES ) | ||
| { | ||
| blake2s_update( S[i], in__, BLAKE2S_BLOCKBYTES ); | ||
| in__ += PARALLELISM_DEGREE * BLAKE2S_BLOCKBYTES; | ||
| inlen__ -= PARALLELISM_DEGREE * BLAKE2S_BLOCKBYTES; | ||
| } | ||
|
|
||
| if( inlen__ > i * BLAKE2S_BLOCKBYTES ) | ||
| { | ||
| const size_t left = inlen__ - i * BLAKE2S_BLOCKBYTES; | ||
| const size_t len = left <= BLAKE2S_BLOCKBYTES ? left : BLAKE2S_BLOCKBYTES; | ||
| blake2s_update( S[i], in__, len ); | ||
| } | ||
|
|
||
| blake2s_final( S[i], hash[i], BLAKE2S_OUTBYTES ); | ||
| } | ||
|
|
||
| if( blake2sp_init_root( FS, outlen, keylen ) < 0 ) | ||
| return -1; | ||
|
|
||
| FS->last_node = 1; | ||
|
|
||
| for( i = 0; i < PARALLELISM_DEGREE; ++i ) | ||
| blake2s_update( FS, hash[i], BLAKE2S_OUTBYTES ); | ||
|
|
||
| return blake2s_final( FS, out, outlen ); | ||
| } | ||
|
|
||
|
|
||
|
|
||
| #if defined(BLAKE2SP_SELFTEST) | ||
| #include <string.h> | ||
| #include "blake2-kat.h" | ||
| int main( void ) | ||
| { | ||
| uint8_t key[BLAKE2S_KEYBYTES]; | ||
| uint8_t buf[BLAKE2_KAT_LENGTH]; | ||
| size_t i, step; | ||
|
|
||
| for( i = 0; i < BLAKE2S_KEYBYTES; ++i ) | ||
| key[i] = ( uint8_t )i; | ||
|
|
||
| for( i = 0; i < BLAKE2_KAT_LENGTH; ++i ) | ||
| buf[i] = ( uint8_t )i; | ||
|
|
||
| /* Test simple API */ | ||
| for( i = 0; i < BLAKE2_KAT_LENGTH; ++i ) | ||
| { | ||
| uint8_t hash[BLAKE2S_OUTBYTES]; | ||
| blake2sp( hash, BLAKE2S_OUTBYTES, buf, i, key, BLAKE2S_KEYBYTES ); | ||
|
|
||
| if( 0 != memcmp( hash, blake2sp_keyed_kat[i], BLAKE2S_OUTBYTES ) ) | ||
| { | ||
| goto fail; | ||
| } | ||
| } | ||
|
|
||
| /* Test streaming API */ | ||
| for(step = 1; step < BLAKE2S_BLOCKBYTES; ++step) { | ||
| for (i = 0; i < BLAKE2_KAT_LENGTH; ++i) { | ||
| uint8_t hash[BLAKE2S_OUTBYTES]; | ||
| blake2sp_state S; | ||
| uint8_t * p = buf; | ||
| size_t mlen = i; | ||
| int err = 0; | ||
|
|
||
| if( (err = blake2sp_init_key(&S, BLAKE2S_OUTBYTES, key, BLAKE2S_KEYBYTES)) < 0 ) { | ||
| goto fail; | ||
| } | ||
|
|
||
| while (mlen >= step) { | ||
| if ( (err = blake2sp_update(&S, p, step)) < 0 ) { | ||
| goto fail; | ||
| } | ||
| mlen -= step; | ||
| p += step; | ||
| } | ||
| if ( (err = blake2sp_update(&S, p, mlen)) < 0) { | ||
| goto fail; | ||
| } | ||
| if ( (err = blake2sp_final(&S, hash, BLAKE2S_OUTBYTES)) < 0) { | ||
| goto fail; | ||
| } | ||
|
|
||
| if (0 != memcmp(hash, blake2sp_keyed_kat[i], BLAKE2S_OUTBYTES)) { | ||
| goto fail; | ||
| } | ||
| } | ||
| } | ||
|
|
||
| puts( "ok" ); | ||
| return 0; | ||
| fail: | ||
| puts("error"); | ||
| return -1; | ||
| } | ||
| #endif |