|
|
tblake2-impl.h - dedup - deduplicating backup program |
|
|
 |
git clone git://bitreich.org/dedup/ git://hg6vgqziawt5s4dj.onion/dedup/ (git://bitreich.org) |
|
|
 |
Log |
|
|
|
Files |
|
|
|
Refs |
|
|
|
Tags |
|
|
|
README |
|
|
|
LICENSE |
|
|
|
--- |
|
|
|
tblake2-impl.h (4201B) |
|
|
|
--- |
|
|
|
1 /* |
|
|
|
2 BLAKE2 reference source code package - reference C implementations |
|
|
|
3 |
|
|
|
4 Copyright 2012, Samuel Neves <sneves@dei.uc.pt>. You may use this under the |
|
|
|
5 terms of the CC0, the OpenSSL Licence, or the Apache Public License 2.0, at |
|
|
|
6 your option. The terms of these licenses can be found at: |
|
|
|
7 |
|
|
|
8 - CC0 1.0 Universal : http://creativecommons.org/publicdomain/zero/1.0 |
|
|
|
9 - OpenSSL license : https://www.openssl.org/source/license.html |
|
|
|
10 - Apache 2.0 : http://www.apache.org/licenses/LICENSE-2.0 |
|
|
|
11 |
|
|
|
12 More information about the BLAKE2 hash function can be found at |
|
|
|
13 https://blake2.net. |
|
|
|
14 */ |
|
|
|
15 #ifndef BLAKE2_IMPL_H |
|
|
|
16 #define BLAKE2_IMPL_H |
|
|
|
17 |
|
|
|
18 #include <stdint.h> |
|
|
|
19 #include <string.h> |
|
|
|
20 |
|
|
|
21 #if !defined(__cplusplus) && (!defined(__STDC_VERSION__) || __STDC_VERSION__ < 199901L) |
|
|
|
22 #if defined(_MSC_VER) |
|
|
|
23 #define BLAKE2_INLINE __inline |
|
|
|
24 #elif defined(__GNUC__) |
|
|
|
25 #define BLAKE2_INLINE __inline__ |
|
|
|
26 #else |
|
|
|
27 #define BLAKE2_INLINE |
|
|
|
28 #endif |
|
|
|
29 #else |
|
|
|
30 #define BLAKE2_INLINE inline |
|
|
|
31 #endif |
|
|
|
32 |
|
|
|
33 static BLAKE2_INLINE uint32_t load32( const void *src ) |
|
|
|
34 { |
|
|
|
35 #if defined(NATIVE_LITTLE_ENDIAN) |
|
|
|
36 uint32_t w; |
|
|
|
37 memcpy(&w, src, sizeof w); |
|
|
|
38 return w; |
|
|
|
39 #else |
|
|
|
40 const uint8_t *p = ( const uint8_t * )src; |
|
|
|
41 return (( uint32_t )( p[0] ) << 0) | |
|
|
|
42 (( uint32_t )( p[1] ) << 8) | |
|
|
|
43 (( uint32_t )( p[2] ) << 16) | |
|
|
|
44 (( uint32_t )( p[3] ) << 24) ; |
|
|
|
45 #endif |
|
|
|
46 } |
|
|
|
47 |
|
|
|
48 static BLAKE2_INLINE uint64_t load64( const void *src ) |
|
|
|
49 { |
|
|
|
50 #if defined(NATIVE_LITTLE_ENDIAN) |
|
|
|
51 uint64_t w; |
|
|
|
52 memcpy(&w, src, sizeof w); |
|
|
|
53 return w; |
|
|
|
54 #else |
|
|
|
55 const uint8_t *p = ( const uint8_t * )src; |
|
|
|
56 return (( uint64_t )( p[0] ) << 0) | |
|
|
|
57 (( uint64_t )( p[1] ) << 8) | |
|
|
|
58 (( uint64_t )( p[2] ) << 16) | |
|
|
|
59 (( uint64_t )( p[3] ) << 24) | |
|
|
|
60 (( uint64_t )( p[4] ) << 32) | |
|
|
|
61 (( uint64_t )( p[5] ) << 40) | |
|
|
|
62 (( uint64_t )( p[6] ) << 48) | |
|
|
|
63 (( uint64_t )( p[7] ) << 56) ; |
|
|
|
64 #endif |
|
|
|
65 } |
|
|
|
66 |
|
|
|
67 static BLAKE2_INLINE uint16_t load16( const void *src ) |
|
|
|
68 { |
|
|
|
69 #if defined(NATIVE_LITTLE_ENDIAN) |
|
|
|
70 uint16_t w; |
|
|
|
71 memcpy(&w, src, sizeof w); |
|
|
|
72 return w; |
|
|
|
73 #else |
|
|
|
74 const uint8_t *p = ( const uint8_t * )src; |
|
|
|
75 return ( uint16_t )((( uint32_t )( p[0] ) << 0) | |
|
|
|
76 (( uint32_t )( p[1] ) << 8)); |
|
|
|
77 #endif |
|
|
|
78 } |
|
|
|
79 |
|
|
|
80 static BLAKE2_INLINE void store16( void *dst, uint16_t w ) |
|
|
|
81 { |
|
|
|
82 #if defined(NATIVE_LITTLE_ENDIAN) |
|
|
|
83 memcpy(dst, &w, sizeof w); |
|
|
|
84 #else |
|
|
|
85 uint8_t *p = ( uint8_t * )dst; |
|
|
|
86 *p++ = ( uint8_t )w; w >>= 8; |
|
|
|
87 *p++ = ( uint8_t )w; |
|
|
|
88 #endif |
|
|
|
89 } |
|
|
|
90 |
|
|
|
91 static BLAKE2_INLINE void store32( void *dst, uint32_t w ) |
|
|
|
92 { |
|
|
|
93 #if defined(NATIVE_LITTLE_ENDIAN) |
|
|
|
94 memcpy(dst, &w, sizeof w); |
|
|
|
95 #else |
|
|
|
96 uint8_t *p = ( uint8_t * )dst; |
|
|
|
97 p[0] = (uint8_t)(w >> 0); |
|
|
|
98 p[1] = (uint8_t)(w >> 8); |
|
|
|
99 p[2] = (uint8_t)(w >> 16); |
|
|
|
100 p[3] = (uint8_t)(w >> 24); |
|
|
|
101 #endif |
|
|
|
102 } |
|
|
|
103 |
|
|
|
104 static BLAKE2_INLINE void store64( void *dst, uint64_t w ) |
|
|
|
105 { |
|
|
|
106 #if defined(NATIVE_LITTLE_ENDIAN) |
|
|
|
107 memcpy(dst, &w, sizeof w); |
|
|
|
108 #else |
|
|
|
109 uint8_t *p = ( uint8_t * )dst; |
|
|
|
110 p[0] = (uint8_t)(w >> 0); |
|
|
|
111 p[1] = (uint8_t)(w >> 8); |
|
|
|
112 p[2] = (uint8_t)(w >> 16); |
|
|
|
113 p[3] = (uint8_t)(w >> 24); |
|
|
|
114 p[4] = (uint8_t)(w >> 32); |
|
|
|
115 p[5] = (uint8_t)(w >> 40); |
|
|
|
116 p[6] = (uint8_t)(w >> 48); |
|
|
|
117 p[7] = (uint8_t)(w >> 56); |
|
|
|
118 #endif |
|
|
|
119 } |
|
|
|
120 |
|
|
|
121 static BLAKE2_INLINE uint64_t load48( const void *src ) |
|
|
|
122 { |
|
|
|
123 const uint8_t *p = ( const uint8_t * )src; |
|
|
|
124 return (( uint64_t )( p[0] ) << 0) | |
|
|
|
125 (( uint64_t )( p[1] ) << 8) | |
|
|
|
126 (( uint64_t )( p[2] ) << 16) | |
|
|
|
127 (( uint64_t )( p[3] ) << 24) | |
|
|
|
128 (( uint64_t )( p[4] ) << 32) | |
|
|
|
129 (( uint64_t )( p[5] ) << 40) ; |
|
|
|
130 } |
|
|
|
131 |
|
|
|
132 static BLAKE2_INLINE void store48( void *dst, uint64_t w ) |
|
|
|
133 { |
|
|
|
134 uint8_t *p = ( uint8_t * )dst; |
|
|
|
135 p[0] = (uint8_t)(w >> 0); |
|
|
|
136 p[1] = (uint8_t)(w >> 8); |
|
|
|
137 p[2] = (uint8_t)(w >> 16); |
|
|
|
138 p[3] = (uint8_t)(w >> 24); |
|
|
|
139 p[4] = (uint8_t)(w >> 32); |
|
|
|
140 p[5] = (uint8_t)(w >> 40); |
|
|
|
141 } |
|
|
|
142 |
|
|
|
143 static BLAKE2_INLINE uint32_t rotr32( const uint32_t w, const unsigned c ) |
|
|
|
144 { |
|
|
|
145 return ( w >> c ) | ( w << ( 32 - c ) ); |
|
|
|
146 } |
|
|
|
147 |
|
|
|
148 static BLAKE2_INLINE uint64_t rotr64( const uint64_t w, const unsigned c ) |
|
|
|
149 { |
|
|
|
150 return ( w >> c ) | ( w << ( 64 - c ) ); |
|
|
|
151 } |
|
|
|
152 |
|
|
|
153 /* prevents compiler optimizing out memset() */ |
|
|
|
154 static BLAKE2_INLINE void secure_zero_memory(void *v, size_t n) |
|
|
|
155 { |
|
|
|
156 static void *(*const volatile memset_v)(void *, int, size_t) = &memset; |
|
|
|
157 memset_v(v, 0, n); |
|
|
|
158 } |
|
|
|
159 |
|
|
|
160 #endif |
|