blob: 82cd69afaf9c61ac409cb942b9f3f5fdd993a4fd (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
|
/*************************************************
* Bit/Word Operations Header File *
* (C) 1999-2008 The Botan Project *
*************************************************/
#ifndef BOTAN_BIT_OPS_H__
#define BOTAN_BIT_OPS_H__
#include <botan/types.h>
namespace Botan {
/*************************************************
* Word Rotation Functions *
*************************************************/
template<typename T> inline T rotate_left(T input, u32bit rot)
{
return static_cast<T>((input << rot) | (input >> (8*sizeof(T)-rot)));;
}
template<typename T> inline T rotate_right(T input, u32bit rot)
{
return static_cast<T>((input >> rot) | (input << (8*sizeof(T)-rot)));
}
/*************************************************
* Byte Swapping Functions *
*************************************************/
inline u16bit reverse_bytes(u16bit input)
{
return rotate_left(input, 8);
}
inline u32bit reverse_bytes(u32bit input)
{
input = ((input & 0xFF00FF00) >> 8) | ((input & 0x00FF00FF) << 8);
return rotate_left(input, 16);
}
inline u64bit reverse_bytes(u64bit input)
{
u32bit hi = ((input >> 40) & 0x00FF00FF) | ((input >> 24) & 0xFF00FF00);
u32bit lo = ((input & 0xFF00FF00) >> 8) | ((input & 0x00FF00FF) << 8);
hi = (hi << 16) | (hi >> 16);
lo = (lo << 16) | (lo >> 16);
return (static_cast<u64bit>(lo) << 32) | hi;
}
/*************************************************
* XOR Arrays *
*************************************************/
inline void xor_buf(byte data[], const byte mask[], u32bit length)
{
while(length >= 8)
{
data[0] ^= mask[0]; data[1] ^= mask[1];
data[2] ^= mask[2]; data[3] ^= mask[3];
data[4] ^= mask[4]; data[5] ^= mask[5];
data[6] ^= mask[6]; data[7] ^= mask[7];
data += 8; mask += 8; length -= 8;
}
for(u32bit j = 0; j != length; ++j)
data[j] ^= mask[j];
}
/*************************************************
* XOR Arrays *
*************************************************/
inline void xor_buf(byte out[], const byte in[],
const byte mask[], u32bit length)
{
while(length >= 8)
{
out[0] = in[0] ^ mask[0]; out[1] = in[1] ^ mask[1];
out[2] = in[2] ^ mask[2]; out[3] = in[3] ^ mask[3];
out[4] = in[4] ^ mask[4]; out[5] = in[5] ^ mask[5];
out[6] = in[6] ^ mask[6]; out[7] = in[7] ^ mask[7];
in += 8; out += 8; mask += 8; length -= 8;
}
for(u32bit j = 0; j != length; ++j)
out[j] = in[j] ^ mask[j];
}
/*************************************************
* Simple Bit Manipulation *
*************************************************/
bool power_of_2(u64bit);
u32bit high_bit(u64bit);
u32bit low_bit(u64bit);
u32bit significant_bytes(u64bit);
u32bit hamming_weight(u64bit);
}
#endif
|
