Review comments (208527a7) · Commits · CYBER - Cyber Security / TS 103 523 MSP / TLMSP / TLMSP OpenSSL

CHANGES

+3 −0

Original line number	Diff line number	Diff line
		@@ -4,6 +4,9 @@

		Changes between 1.0.2g and 1.1.0 [xx XXX xxxx]

		*) Add support for blake2b and blake2s
		[Bill Cox]

		*) Added support for "pipelining". Ciphers that have the
		EVP_CIPH_FLAG_PIPELINE flag set have a capability to process multiple
		encryptions/decryptions simultaneously. There are currently no built-in

apps/progs.h

+3 −5

Original line number	Diff line number	Diff line
		@@ -225,11 +225,9 @@ static FUNCTION functions[] = {
		#ifndef OPENSSL_NO_RMD160
		{ FT_md, "rmd160", dgst_main},
		#endif
		#ifndef OPENSSL_NO_BLAKE2B
		{ FT_md, "blake2b", dgst_main},
		#endif
		#ifndef OPENSSL_NO_BLAKE2S
		{ FT_md, "blake2s", dgst_main},
		#ifndef OPENSSL_NO_BLAKE2
		{ FT_md, "blake2b512", dgst_main},
		{ FT_md, "blake2s256", dgst_main},
		#endif
		#ifndef OPENSSL_NO_AES
		{ FT_cipher, "aes-128-cbc", enc_main, enc_options },

crypto/blake2/Makefile.in

+2 −6

Original line number	Diff line number	Diff line
		#
		# OpenSSL/crypto/blake2/Makefile
		#

		DIR= blake2
		TOP= ../..
		CC= cc
		@@ -17,8 +13,8 @@ AFLAGS= $(ASFLAGS)
		GENERAL=Makefile

		LIB=$(TOP)/libcrypto.a
		LIBSRC=blake2b.c blake2s.c
		LIBOBJ=blake2b.o blake2s.o
		LIBSRC=blake2b.c blake2s.c m_blake2b.c m_blake2s.c
		LIBOBJ=blake2b.o blake2s.o m_blake2b.o m_blake2s.o

		SRC= $(LIBSRC)

crypto/blake2/blake2_impl.h

+86 −91

Original line number	Diff line number	Diff line
		/*
		* 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:
		*
		* - OpenSSL license : https://www.openssl.org/source/license.html
		* - Apache 2.0 : http://www.apache.org/licenses/LICENSE-2.0
		* - CC0 1.0 Universal : http://creativecommons.org/publicdomain/zero/1.0
		* Copyright 2016 The OpenSSL Project Authors. All Rights Reserved.
		*
		* More information about the BLAKE2 hash function can be found at
		* https://blake2.net.
		* Licensed under the OpenSSL licenses, (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		* https://www.openssl.org/source/license.html
		* or in the file LICENSE in the source distribution.
		*/

		/* crypto/blake2/blake2_impl.h */
		/*
		* Derived from the BLAKE2 reference implementation written by Samuel Neves.
		* More information about the BLAKE2 hash function and its implementations
		* can be found at https://blake2.net.
		*/

		#include <stdint.h>
		#include <string.h>
		#include "e_os.h"

		static inline uint32_t load32(const void *src)
		static ossl_inline uint32_t load32(const void *src)
		{
		#if defined(L_ENDIAN)
		const union {
		long one;
		char little;
		} is_endian = { 1 };

		if (is_endian.little) {
		uint32_t w;
		memcpy(&w, src, sizeof(w));
		return w;
		#else
		} else {
		const uint8_t p = (const uint8_t )src;
		uint32_t w = *p++;
		w \|= (uint32_t)(*p++) << 8;
		w \|= (uint32_t)(*p++) << 16;
		w \|= (uint32_t)(*p++) << 24;
		return w;
		#endif
		}
		}

		static inline uint64_t load64(const void *src)
		static ossl_inline uint64_t load64(const void *src)
		{
		#if defined(L_ENDIAN)
		const union {
		long one;
		char little;
		} is_endian = { 1 };

		if (is_endian.little) {
		uint64_t w;
		memcpy(&w, src, sizeof(w));
		return w;
		#else
		} else {
		const uint8_t p = (const uint8_t )src;
		uint64_t w = *p++;
		w \|= (uint64_t)(*p++) << 8;
		@@ -52,50 +61,46 @@ static inline uint64_t load64(const void *src)
		w \|= (uint64_t)(*p++) << 48;
		w \|= (uint64_t)(*p++) << 56;
		return w;
		#endif
		}
		}

		static inline void store32(void *dst, uint32_t w)
		static ossl_inline void store32(void *dst, uint32_t w)
		{
		#if defined(L_ENDIAN)
		const union {
		long one;
		char little;
		} is_endian = { 1 };

		if (is_endian.little) {
		memcpy(dst, &w, sizeof(w));
		#else
		} else {
		uint8_t p = (uint8_t )dst;
		*p++ = (uint8_t)w;
		w >>= 8;
		*p++ = (uint8_t)w;
		w >>= 8;
		*p++ = (uint8_t)w;
		w >>= 8;
		*p++ = (uint8_t)w;
		#endif
		int i;

		for (i = 0; i < 4; i++)
		p[i] = (uint8_t)(w >> (8 * i));
		}
		}

		static inline void store64(void *dst, uint64_t w)
		static ossl_inline void store64(void *dst, uint64_t w)
		{
		#if defined(L_ENDIAN)
		const union {
		long one;
		char little;
		} is_endian = { 1 };

		if (is_endian.little) {
		memcpy(dst, &w, sizeof(w));
		#else
		} else {
		uint8_t p = (uint8_t )dst;
		*p++ = (uint8_t)w;
		w >>= 8;
		*p++ = (uint8_t)w;
		w >>= 8;
		*p++ = (uint8_t)w;
		w >>= 8;
		*p++ = (uint8_t)w;
		w >>= 8;
		*p++ = (uint8_t)w;
		w >>= 8;
		*p++ = (uint8_t)w;
		w >>= 8;
		*p++ = (uint8_t)w;
		w >>= 8;
		*p++ = (uint8_t)w;
		#endif
		int i;

		for (i = 0; i < 8; i++)
		p[i] = (uint8_t)(w >> (8 * i));
		}
		}

		static inline uint64_t load48(const void *src)
		static ossl_inline uint64_t load48(const void *src)
		{
		const uint8_t p = (const uint8_t )src;
		uint64_t w = *p++;
		@@ -107,7 +112,7 @@ static inline uint64_t load48(const void *src)
		return w;
		}

		static inline void store48(void *dst, uint64_t w)
		static ossl_inline void store48(void *dst, uint64_t w)
		{
		uint8_t p = (uint8_t )dst;
		*p++ = (uint8_t)w;
		@@ -123,22 +128,12 @@ static inline void store48(void *dst, uint64_t w)
		*p++ = (uint8_t)w;
		}

		static inline uint32_t rotl32(const uint32_t w, const unsigned c)
		{
		return (w << c) \| (w >> (32 - c));
		}

		static inline uint64_t rotl64(const uint64_t w, const unsigned c)
		{
		return (w << c) \| (w >> (64 - c));
		}

		static inline uint32_t rotr32(const uint32_t w, const unsigned c)
		static ossl_inline uint32_t rotr32(const uint32_t w, const unsigned c)
		{
		return (w >> c) \| (w << (32 - c));
		}

		static inline uint64_t rotr64(const uint64_t w, const unsigned c)
		static ossl_inline uint64_t rotr64(const uint64_t w, const unsigned c)
		{
		return (w >> c) \| (w << (64 - c));
		}

crypto/blake2/blake2b.c

+24 −26

Original line number	Diff line number	Diff line
		/*
		* 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:
		*
		* - OpenSSL license : https://www.openssl.org/source/license.html
		* - Apache 2.0 : http://www.apache.org/licenses/LICENSE-2.0
		* - CC0 1.0 Universal : http://creativecommons.org/publicdomain/zero/1.0
		* Copyright 2016 The OpenSSL Project Authors. All Rights Reserved.
		*
		* More information about the BLAKE2 hash function can be found at
		* https://blake2.net.
		* Licensed under the OpenSSL licenses, (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		* https://www.openssl.org/source/license.html
		* or in the file LICENSE in the source distribution.
		*/

		/* crypto/blake2/blake2b.c */
		/*
		* Derived from the BLAKE2 reference implementation written by Samuel Neves.
		* More information about the BLAKE2 hash function and its implementations
		* can be found at https://blake2.net.
		*/

		#include <stdint.h>
		#include <string.h>
		#include <stdio.h>
		#include <openssl/crypto.h>
		#include "e_os.h"

		#include "internal/blake2_locl.h"
		#include "blake2_impl.h"

		static const uint64_t blake2b_IV[8] =
		{
		0x6a09e667f3bcc908ULL, 0xbb67ae8584caa73bULL,
		0x3c6ef372fe94f82bULL, 0xa54ff53a5f1d36f1ULL,
		0x510e527fade682d1ULL, 0x9b05688c2b3e6c1fULL,
		0x1f83d9abfb41bd6bULL, 0x5be0cd19137e2179ULL
		0x6a09e667f3bcc908U, 0xbb67ae8584caa73bU,
		0x3c6ef372fe94f82bU, 0xa54ff53a5f1d36f1U,
		0x510e527fade682d1U, 0x9b05688c2b3e6c1fU,
		0x1f83d9abfb41bd6bU, 0x5be0cd19137e2179U
		};

		static const uint8_t blake2b_sigma[12][16] =
		@@ -48,14 +46,14 @@ static const uint8_t blake2b_sigma[12][16] =
		{ 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 }
		};

		/* Some helper functions, not necessarily useful */
		static inline void blake2b_set_lastblock(BLAKE2B_CTX *S)
		/* Set that it's the last block we'll compress */
		static ossl_inline void blake2b_set_lastblock(BLAKE2B_CTX *S)
		{
		S->f[0] = -1;
		}

		/* Increment the data hashed couter. */
		static inline void blake2b_increment_counter(BLAKE2B_CTX *S,
		/* Increment the data hashed counter. */
		static ossl_inline void blake2b_increment_counter(BLAKE2B_CTX *S,
		const uint64_t inc)
		{
		S->t[0] += inc;
		@@ -63,11 +61,11 @@ static inline void blake2b_increment_counter(BLAKE2B_CTX *S,
		}

		/* Initialize the hashing state. */
		static inline void blake2b_init0(BLAKE2B_CTX *S)
		static ossl_inline void blake2b_init0(BLAKE2B_CTX *S)
		{
		int i;
		memset(S, 0, sizeof(BLAKE2B_CTX));

		memset(S, 0, sizeof(BLAKE2B_CTX));
		for(i = 0; i < 8; ++i) {
		S->h[i] = blake2b_IV[i];
		}
		@@ -202,7 +200,7 @@ int BLAKE2b_Update(BLAKE2B_CTX c, const void data, size_t datalen)
		}

		/*
		* Finalize the hash state in a way that avoids length extension attacks.
		* Calculate the final hash and save it in md.
		* Always returns 1.
		*/
		int BLAKE2b_Final(unsigned char md, BLAKE2B_CTX c)