Crypto++  5.6.3
Free C++ class library of cryptographic schemes
misc.cpp
1 // misc.cpp - written and placed in the public domain by Wei Dai
2 
3 #include "pch.h"
4 #include "config.h"
5 
6 #if CRYPTOPP_MSC_VERSION
7 # pragma warning(disable: 4189)
8 # if (CRYPTOPP_MSC_VERSION >= 1400)
9 # pragma warning(disable: 6237)
10 # endif
11 #endif
12 
13 #ifndef CRYPTOPP_IMPORTS
14 
15 #include "misc.h"
16 #include "words.h"
17 #include "words.h"
18 #include "stdcpp.h"
19 #include "integer.h"
20 
21 // for memalign
22 #if defined(CRYPTOPP_MEMALIGN_AVAILABLE) || defined(CRYPTOPP_MM_MALLOC_AVAILABLE) || defined(QNX)
23 # include <malloc.h>
24 #endif
25 
26 NAMESPACE_BEGIN(CryptoPP)
27 
28 void xorbuf(byte *buf, const byte *mask, size_t count)
29 {
30  assert(buf != NULL);
31  assert(mask != NULL);
32  assert(count > 0);
33 
34  size_t i=0;
35  if (IsAligned<word32>(buf) && IsAligned<word32>(mask))
36  {
37  if (!CRYPTOPP_BOOL_SLOW_WORD64 && IsAligned<word64>(buf) && IsAligned<word64>(mask))
38  {
39  for (i=0; i<count/8; i++)
40  ((word64*)buf)[i] ^= ((word64*)mask)[i];
41  count -= 8*i;
42  if (!count)
43  return;
44  buf += 8*i;
45  mask += 8*i;
46  }
47 
48  for (i=0; i<count/4; i++)
49  ((word32*)buf)[i] ^= ((word32*)mask)[i];
50  count -= 4*i;
51  if (!count)
52  return;
53  buf += 4*i;
54  mask += 4*i;
55  }
56 
57  for (i=0; i<count; i++)
58  buf[i] ^= mask[i];
59 }
60 
61 void xorbuf(byte *output, const byte *input, const byte *mask, size_t count)
62 {
63  assert(output != NULL);
64  assert(input != NULL);
65  assert(count > 0);
66 
67  size_t i=0;
68  if (IsAligned<word32>(output) && IsAligned<word32>(input) && IsAligned<word32>(mask))
69  {
70  if (!CRYPTOPP_BOOL_SLOW_WORD64 && IsAligned<word64>(output) && IsAligned<word64>(input) && IsAligned<word64>(mask))
71  {
72  for (i=0; i<count/8; i++)
73  ((word64*)output)[i] = ((word64*)input)[i] ^ ((word64*)mask)[i];
74  count -= 8*i;
75  if (!count)
76  return;
77  output += 8*i;
78  input += 8*i;
79  mask += 8*i;
80  }
81 
82  for (i=0; i<count/4; i++)
83  ((word32*)output)[i] = ((word32*)input)[i] ^ ((word32*)mask)[i];
84  count -= 4*i;
85  if (!count)
86  return;
87  output += 4*i;
88  input += 4*i;
89  mask += 4*i;
90  }
91 
92  for (i=0; i<count; i++)
93  output[i] = input[i] ^ mask[i];
94 }
95 
96 bool VerifyBufsEqual(const byte *buf, const byte *mask, size_t count)
97 {
98  assert(buf != NULL);
99  assert(mask != NULL);
100  assert(count > 0);
101 
102  size_t i=0;
103  byte acc8 = 0;
104 
105  if (IsAligned<word32>(buf) && IsAligned<word32>(mask))
106  {
107  word32 acc32 = 0;
108  if (!CRYPTOPP_BOOL_SLOW_WORD64 && IsAligned<word64>(buf) && IsAligned<word64>(mask))
109  {
110  word64 acc64 = 0;
111  for (i=0; i<count/8; i++)
112  acc64 |= ((word64*)buf)[i] ^ ((word64*)mask)[i];
113  count -= 8*i;
114  if (!count)
115  return acc64 == 0;
116  buf += 8*i;
117  mask += 8*i;
118  acc32 = word32(acc64) | word32(acc64>>32);
119  }
120 
121  for (i=0; i<count/4; i++)
122  acc32 |= ((word32*)buf)[i] ^ ((word32*)mask)[i];
123  count -= 4*i;
124  if (!count)
125  return acc32 == 0;
126  buf += 4*i;
127  mask += 4*i;
128  acc8 = byte(acc32) | byte(acc32>>8) | byte(acc32>>16) | byte(acc32>>24);
129  }
130 
131  for (i=0; i<count; i++)
132  acc8 |= buf[i] ^ mask[i];
133  return acc8 == 0;
134 }
135 
136 #if !(defined(_MSC_VER) && (_MSC_VER < 1300))
137 using std::new_handler;
138 using std::set_new_handler;
139 #endif
140 
142 {
143  new_handler newHandler = set_new_handler(NULL);
144  if (newHandler)
145  set_new_handler(newHandler);
146 
147  if (newHandler)
148  newHandler();
149  else
150  throw std::bad_alloc();
151 }
152 
153 #if CRYPTOPP_BOOL_ALIGN16
154 
155 void * AlignedAllocate(size_t size)
156 {
157  byte *p;
158 #if defined(CRYPTOPP_APPLE_ALLOC_AVAILABLE)
159  while ((p = (byte *)calloc(1, size)) == NULL)
160 #elif defined(CRYPTOPP_MM_MALLOC_AVAILABLE)
161  while ((p = (byte *)_mm_malloc(size, 16)) == NULL)
162 #elif defined(CRYPTOPP_MEMALIGN_AVAILABLE)
163  while ((p = (byte *)memalign(16, size)) == NULL)
164 #elif defined(CRYPTOPP_MALLOC_ALIGNMENT_IS_16)
165  while ((p = (byte *)malloc(size)) == NULL)
166 #else
167  while ((p = (byte *)malloc(size + 16)) == NULL)
168 #endif
169  CallNewHandler();
170 
171 #ifdef CRYPTOPP_NO_ALIGNED_ALLOC
172  size_t adjustment = 16-((size_t)p%16);
173  p += adjustment;
174  p[-1] = (byte)adjustment;
175 #endif
176 
177  assert(IsAlignedOn(p, 16));
178  return p;
179 }
180 
181 void AlignedDeallocate(void *p)
182 {
183 #ifdef CRYPTOPP_MM_MALLOC_AVAILABLE
184  _mm_free(p);
185 #elif defined(CRYPTOPP_NO_ALIGNED_ALLOC)
186  p = (byte *)p - ((byte *)p)[-1];
187  free(p);
188 #else
189  free(p);
190 #endif
191 }
192 
193 #endif
194 
195 void * UnalignedAllocate(size_t size)
196 {
197  void *p;
198  while ((p = malloc(size)) == NULL)
199  CallNewHandler();
200  return p;
201 }
202 
203 void UnalignedDeallocate(void *p)
204 {
205  free(p);
206 }
207 
208 NAMESPACE_END
209 
210 #endif
Utility functions for the Crypto++ library.
void AlignedDeallocate(void *ptr)
Frees a buffer allocated with AlignedAllocate.
Library configuration file.
bool IsAlignedOn(const void *ptr, unsigned int alignment)
Determines whether ptr is aligned to a minimum value.
Definition: misc.h:810
void * UnalignedAllocate(size_t size)
Allocates a buffer.
Definition: misc.cpp:195
void CallNewHandler()
Attempts to reclaim unused memory.
Definition: misc.cpp:141
void xorbuf(byte *buf, const byte *mask, size_t count)
Performs an XOR of a buffer with a mask.
Definition: misc.cpp:28
bool VerifyBufsEqual(const byte *buf1, const byte *buf2, size_t count)
Performs a near constant-time comparison of two equally sized buffers.
Definition: misc.cpp:96
Crypto++ library namespace.
void UnalignedDeallocate(void *ptr)
Frees a buffer allocated with UnalignedAllocate.
Definition: misc.cpp:203
void * AlignedAllocate(size_t size)
Allocates a buffer on 16-byte boundary.