crypto/blake2/blake2_impl.h

   1 /*
   2  * Copyright 2016 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 /*
  11  * Derived from the BLAKE2 reference implementation written by Samuel Neves.
  12  * Copyright 2012, Samuel Neves <sneves@dei.uc.pt>
  13  * More information about the BLAKE2 hash function and its implementations
  14  * can be found at https://blake2.net.
  15  */
  16
  17 #include <string.h>
  18 #include "e_os.h"
  19
  20 static ossl_inline uint32_t load32(const uint8_t *src)
  21 {
  22     const union {
  23         long one;
  24         char little;
  25     } is_endian = { 1 };
  26
  27     if (is_endian.little) {
  28         uint32_t w;
  29         memcpy(&w, src, sizeof(w));
  30         return w;
  31     } else {
  32         uint32_t w = ((uint32_t)src[0])
  33                    | ((uint32_t)src[1] <<  8)
  34                    | ((uint32_t)src[2] << 16)
  35                    | ((uint32_t)src[3] << 24);
  36         return w;
  37     }
  38 }
  39
  40 static ossl_inline uint64_t load64(const uint8_t *src)
  41 {
  42     const union {
  43         long one;
  44         char little;
  45     } is_endian = { 1 };
  46
  47     if (is_endian.little) {
  48         uint64_t w;
  49         memcpy(&w, src, sizeof(w));
  50         return w;
  51     } else {
  52         uint64_t w = ((uint64_t)src[0])
  53                    | ((uint64_t)src[1] <<  8)
  54                    | ((uint64_t)src[2] << 16)
  55                    | ((uint64_t)src[3] << 24)
  56                    | ((uint64_t)src[4] << 32)
  57                    | ((uint64_t)src[5] << 40)
  58                    | ((uint64_t)src[6] << 48)
  59                    | ((uint64_t)src[7] << 56);
  60         return w;
  61     }
  62 }
  63
  64 static ossl_inline void store32(uint8_t *dst, uint32_t w)
  65 {
  66     const union {
  67         long one;
  68         char little;
  69     } is_endian = { 1 };
  70
  71     if (is_endian.little) {
  72         memcpy(dst, &w, sizeof(w));
  73     } else {
  74         uint8_t *p = (uint8_t *)dst;
  75         int i;
  76
  77         for (i = 0; i < 4; i++)
  78             p[i] = (uint8_t)(w >> (8 * i));
  79     }
  80 }
  81
  82 static ossl_inline void store64(uint8_t *dst, uint64_t w)
  83 {
  84     const union {
  85         long one;
  86         char little;
  87     } is_endian = { 1 };
  88
  89     if (is_endian.little) {
  90         memcpy(dst, &w, sizeof(w));
  91     } else {
  92         uint8_t *p = (uint8_t *)dst;
  93         int i;
  94
  95         for (i = 0; i < 8; i++)
  96             p[i] = (uint8_t)(w >> (8 * i));
  97     }
  98 }
  99
 100 static ossl_inline uint64_t load48(const uint8_t *src)
 101 {
 102     uint64_t w = ((uint64_t)src[0])
 103                | ((uint64_t)src[1] <<  8)
 104                | ((uint64_t)src[2] << 16)
 105                | ((uint64_t)src[3] << 24)
 106                | ((uint64_t)src[4] << 32)
 107                | ((uint64_t)src[5] << 40);
 108     return w;
 109 }
 110
 111 static ossl_inline void store48(uint8_t *dst, uint64_t w)
 112 {
 113     uint8_t *p = (uint8_t *)dst;
 114     p[0] = (uint8_t)w;
 115     p[1] = (uint8_t)(w>>8);
 116     p[2] = (uint8_t)(w>>16);
 117     p[3] = (uint8_t)(w>>24);
 118     p[4] = (uint8_t)(w>>32);
 119     p[5] = (uint8_t)(w>>40);
 120 }
 121
 122 static ossl_inline uint32_t rotr32(const uint32_t w, const unsigned int c)
 123 {
 124     return (w >> c) | (w << (32 - c));
 125 }
 126
 127 static ossl_inline uint64_t rotr64(const uint64_t w, const unsigned int c)
 128 {
 129     return (w >> c) | (w << (64 - c));
 130 }