crypto/blake2/blake2_impl.h

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