Commit 208527a7 authored by Kurt Roeckx's avatar Kurt Roeckx Committed by Rich Salz
Browse files

Review comments 



Reviewed-by: default avatarAndy Polyakov <appro@openssl.org>
Reviewed-by: default avatarRich Salz <rsalz@openssl.org>
parent 2d0b4412

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)