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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
//--------------------------------------------------------------------------------
//-- XorCompileTime.hpp
//
// Author: frk
// Date: 12.12.2015
//
//--------------------------------------------------------------------------------
#pragma once
#include <string>
#include <array>
#include <cstdarg>
#define BEGIN_NAMESPACE( x ) namespace x {
#define END_NAMESPACE }
BEGIN_NAMESPACE( strenc )
constexpr auto time = __TIME__;
constexpr auto seed = static_cast< int >( time[ 7 ] ) + static_cast< int >( time[ 6 ] ) * 10 + static_cast< int >( time[ 4 ] ) * 60 + static_cast< int >( time[ 3 ] ) * 600 + static_cast< int >( time[ 1 ] ) * 3600 + static_cast< int >( time[ 0 ] ) * 36000;
// 1988, Stephen Park and Keith Miller
// "Random Number Generators: Good Ones Are Hard To Find", considered as "minimal standard"
// Park-Miller 31 bit pseudo-random number generator, implemented with G. Carta's optimisation:
// with 32-bit math and without division
template < int N >
struct RandomGenerator {
private:
static constexpr unsigned a = 16807; // 7^5
static constexpr unsigned m = 2147483647; // 2^31 - 1
static constexpr unsigned s = RandomGenerator< N - 1 >::value;
static constexpr unsigned lo = a * ( s & 0xFFFF ); // Multiply lower 16 bits by 16807
static constexpr unsigned hi = a * ( s >> 16 ); // Multiply higher 16 bits by 16807
static constexpr unsigned lo2 = lo + ( ( hi & 0x7FFF ) << 16 ); // Combine lower 15 bits of hi with lo's upper bits
static constexpr unsigned hi2 = hi >> 15; // Discard lower 15 bits of hi
static constexpr unsigned lo3 = lo2 + hi;
public:
static constexpr unsigned max = m;
static constexpr unsigned value = lo3 > m ? lo3 - m : lo3;
};
template <>
struct RandomGenerator< 0 > {
static constexpr unsigned value = seed;
};
template < int N, int M >
struct RandomInt {
static constexpr auto value = RandomGenerator< N + 1 >::value % M;
};
template < int N >
struct RandomChar {
static const char value = static_cast< char >( 1 + RandomInt< N, 0x7F - 1 >::value );
};
template < size_t N, int K >
struct XorString {
private:
const char _key;
std::array< char, N + 1 > _encrypted;
bool decrypted = false;
constexpr char enc( char c ) const {
return c ^ _key;
}
char dec( char c ) const {
return c ^ _key;
}
public:
template < size_t... Is >
constexpr __forceinline XorString( const char* const str, std::index_sequence< Is... > ) : _key( RandomChar< K >::value ), _encrypted{ enc( str[ Is ] )... } {
}
__forceinline const char* decrypt( void ) {
if( !decrypted ) {
for( size_t i = 0; i < N; ++i ) {
_encrypted[ i ] = dec( _encrypted[ i ] );
}
_encrypted[ N ] = '\0';
decrypted = true;
}
printf( "N: %u K: %d str: %s address: %08x\n", N, K, _encrypted.data( ), _encrypted.data( ) );
return _encrypted.data( );
}
};
//--------------------------------------------------------------------------------
//-- Note: XorStr will __NOT__ work directly with functions like printf.
// To work with them you need a wrapper function that takes a const char*
// as parameter and passes it to printf and alike.
//
// The Microsoft Compiler/Linker is not working correctly with variadic
// templates!
//
// Use the functions below or use std::cout (and similar)!
//--------------------------------------------------------------------------------
static auto w_printf = [ ]( const char* fmt, ... ) {
va_list args;
va_start( args, fmt );
vprintf_s( fmt, args );
va_end( args );
};
static auto w_printf_s = [ ]( const char* fmt, ... ) {
va_list args;
va_start( args, fmt );
vprintf_s( fmt, args );
va_end( args );
};
static auto w_sprintf = [ ]( char* buf, const char* fmt, ... ) {
va_list args;
va_start( args, fmt );
vsprintf( buf, fmt, args );
va_end( args );
};
static auto w_sprintf_s = [ ]( char* buf, size_t buf_size, const char* fmt, ... ) {
va_list args;
va_start( args, fmt );
vsprintf_s( buf, buf_size, fmt, args );
va_end( args );
};
//for compatibility with debug mode
struct debug_ret {
private:
const char* ret;
public:
debug_ret( const char* str ) : ret( str ) { };
auto decrypt( ) {
return ret;
}
};
constexpr size_t strlen_ct( const char* const str ) {
size_t out = 1;
for( ; str[ out ] != '\0'; ++out );
return out;
}
#if 0
#define xors_raw( s ) ( strenc::XorString< strenc::strlen_ct( s ), __COUNTER__ >( s, std::make_index_sequence< sizeof( s ) - 1>() ) )
#define xors( s ) ( strenc::XorString< strenc::strlen_ct( s ), __COUNTER__ >( s, std::make_index_sequence< sizeof( s ) - 1>() ).decrypt() )
#else
#define xors_raw( s ) ( [ ]{ strenc::debug_ret ret{ s }; return ret; }( ) )
#define xors( s ) ( s )
#endif
END_NAMESPACE
|
