How to Compile Crypto++ Without RTTI (With Fake RTTI Using Templates)

I needed to compile Crypto++ (a very good cryptography library which uses RTTI) but my client requested that we leave out RTTI information to make reverse-engineering of the resulting product more difficult. Here’s how I managed to fake RTTI good enough to get Crypto++ to compile.

1. redefine typeid()

In cryptlib.h, I added directly after the initial

1
2

#include "config.h"
#include "stdcpp.h"

the following template and define to revert typeid() to my own implementation:

1
2

template<typename T> const std::type_info& HajoTypeID(void);
#define typeid(a) HajoTypeID<a>()

2. compile to get list of undefined symbols

I then compiled Crypto++ and was greeted with a huge list of undefined symbols, which were references to my HajoTypeID<>() template function. The errors looked like:

1
2
3

"__Z10HajoTypeIDIN8CryptoPP21InvertibleLUCFunctionEERKSt9type_infov", referenced from:
  __ZNK8CryptoPP14NameValuePairs13GetThisObjectINS_21InvertibleLUCFunctionEEEbRT_ in libCryptoPP.a(luc.o)
  __ZNK8CryptoPP14NameValuePairs8GetValueINS_21InvertibleLUCFunctionEEEbPKcRT_ in libCryptoPP.a(luc.o)

I copied all of those into undefined.txt and ran

1

cat undefined.txt | grep "\", referenced" | sed 's/"_//' | sed 's/",.*//' | mate

to get a list of the raw, mangled symbols that were missing. The output looked like this:

1
2
3

_Z10HajoTypeIDIPKhERKSt9type_infov
_Z10HajoTypeIDIPhERKSt9type_infov
_Z10HajoTypeIDIPSsERKSt9type_infov

3. demangle symbols to get needed template classes

I then piped the result through the Javascript from

1

http://slush.warosu.org/c++filtjs/

to get a list of the needed, unmangled symbols like this:

1
2
3

std::type_info const& HajoTypeID<int>()
std::type_info const& HajoTypeID<char const*>()
std::type_info const& HajoTypeID<std::ostream*>()

I stored this list into defineme.txt and ran

1

cat defineme.txt | sed 's/std::type_info const& HajoTypeID<//' | sed 's/>()//'  | sed 's/^.*$/template <> const std::type_info\& HajoTypeID< & >(void) { static HajoMkType type("&"); return type; }/' | mate

to get the needed C++ source to fake typeid(..) for those classes. The output looks like this:

1
2
3

template <> const std::type_info& HajoTypeID< int >(void) { static HajoMkType type("int"); return type; }
template <> const std::type_info& HajoTypeID< char const* >(void) { static HajoMkType type("char const*"); return type; }
template <> const std::type_info& HajoTypeID< std::ostream* >(void) { static HajoMkType type("std::ostream*"); return type; }

and together with this class:

1
2
3
4
5

class HajoMkType : public std::type_info {
public:
    inline HajoMkType(const char* name) : std::type_info(name) {}
    inline virtual ~HajoMkType() {}
};

can fake RTTI good enough such that the compiled Crypto++ library passes all validations with RTTI disabled.

My fake RTTI source

in cryptlib.h

1
2

template<typename T> const std::type_info& HajoTypeID(void);
#define typeid(a) HajoTypeID<a>()

in a C++ file of your choice

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

#include "eccrypto.h"
#include "ec2n.h"
#include "luc.h"
#include "esign.h"
#include "rabin.h"
#include "gfpcrypt.h"
#include "modexppc.h"
#include "xtrcrypt.h"

// fake RTTI data holder
class HajoMkType : public std::type_info {
public:
    inline HajoMkType(const char* name) : std::type_info(name) {}
    inline virtual ~HajoMkType() {}
};



template <> const std::type_info& HajoTypeID< int >(void) { static HajoMkType type("int"); return type; }
template <> const std::type_info& HajoTypeID< char const* >(void) { static HajoMkType type("char const*"); return type; }
template <> const std::type_info& HajoTypeID< std::ostream* >(void) { static HajoMkType type("std::ostream*"); return type; }
template <> const std::type_info& HajoTypeID< int const* >(void) { static HajoMkType type("int const*"); return type; }
template <> const std::type_info& HajoTypeID< unsigned char >(void) { static HajoMkType type("unsigned char"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::ConstByteArrayParameter >(void) { static HajoMkType type("CryptoPP::ConstByteArrayParameter"); return type; }
template <> const std::type_info& HajoTypeID< unsigned char const* >(void) { static HajoMkType type("unsigned char const*"); return type; }
template <> const std::type_info& HajoTypeID< unsigned char* >(void) { static HajoMkType type("unsigned char*"); return type; }
template <> const std::type_info& HajoTypeID< std::string* >(void) { static HajoMkType type("std::string*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_GroupParameters_IntegerBasedImpl<CryptoPP::ModExpPrecomputation, CryptoPP::DL_FixedBasePrecomputationImpl<CryptoPP::Integer> >  >(void) { static HajoMkType type("CryptoPP::DL_GroupParameters_IntegerBasedImpl<CryptoPP::ModExpPrecomputation, CryptoPP::DL_FixedBasePrecomputationImpl<CryptoPP::Integer> > "); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PublicKeyImpl<CryptoPP::DL_GroupParameters_DSA>  >(void) { static HajoMkType type("CryptoPP::DL_PublicKeyImpl<CryptoPP::DL_GroupParameters_DSA> "); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PrivateKey<CryptoPP::Integer>  >(void) { static HajoMkType type("CryptoPP::DL_PrivateKey<CryptoPP::Integer> "); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PrivateKey<CryptoPP::Integer>* >(void) { static HajoMkType type("CryptoPP::DL_PrivateKey<CryptoPP::Integer>*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PublicKey<CryptoPP::Integer>  >(void) { static HajoMkType type("CryptoPP::DL_PublicKey<CryptoPP::Integer> "); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::Integer >(void) { static HajoMkType type("CryptoPP::Integer"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PrivateKeyImpl<CryptoPP::DL_GroupParameters_DSA>  >(void) { static HajoMkType type("CryptoPP::DL_PrivateKeyImpl<CryptoPP::DL_GroupParameters_DSA> "); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_GroupParameters_DSA >(void) { static HajoMkType type("CryptoPP::DL_GroupParameters_DSA"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::OID >(void) { static HajoMkType type("CryptoPP::OID"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::ECP >(void) { static HajoMkType type("CryptoPP::ECP"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::ECPPoint >(void) { static HajoMkType type("CryptoPP::ECPPoint"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::EC2N >(void) { static HajoMkType type("CryptoPP::EC2N"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::EC2NPoint >(void) { static HajoMkType type("CryptoPP::EC2NPoint"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PublicKeyImpl<CryptoPP::DL_GroupParameters_EC<CryptoPP::ECP> >  >(void) { static HajoMkType type("CryptoPP::DL_PublicKeyImpl<CryptoPP::DL_GroupParameters_EC<CryptoPP::ECP> > "); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PrivateKey<CryptoPP::ECPPoint>  >(void) { static HajoMkType type("CryptoPP::DL_PrivateKey<CryptoPP::ECPPoint> "); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PrivateKey<CryptoPP::ECPPoint>* >(void) { static HajoMkType type("CryptoPP::DL_PrivateKey<CryptoPP::ECPPoint>*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PublicKey<CryptoPP::ECPPoint>  >(void) { static HajoMkType type("CryptoPP::DL_PublicKey<CryptoPP::ECPPoint> "); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PublicKeyImpl<CryptoPP::DL_GroupParameters_EC<CryptoPP::EC2N> >  >(void) { static HajoMkType type("CryptoPP::DL_PublicKeyImpl<CryptoPP::DL_GroupParameters_EC<CryptoPP::EC2N> > "); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PrivateKey<CryptoPP::EC2NPoint>  >(void) { static HajoMkType type("CryptoPP::DL_PrivateKey<CryptoPP::EC2NPoint> "); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PrivateKey<CryptoPP::EC2NPoint>* >(void) { static HajoMkType type("CryptoPP::DL_PrivateKey<CryptoPP::EC2NPoint>*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PublicKey<CryptoPP::EC2NPoint>  >(void) { static HajoMkType type("CryptoPP::DL_PublicKey<CryptoPP::EC2NPoint> "); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PrivateKeyImpl<CryptoPP::DL_GroupParameters_EC<CryptoPP::ECP> >  >(void) { static HajoMkType type("CryptoPP::DL_PrivateKeyImpl<CryptoPP::DL_GroupParameters_EC<CryptoPP::ECP> > "); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_GroupParameters_EC<CryptoPP::ECP>  >(void) { static HajoMkType type("CryptoPP::DL_GroupParameters_EC<CryptoPP::ECP> "); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PrivateKeyImpl<CryptoPP::DL_GroupParameters_EC<CryptoPP::EC2N> >  >(void) { static HajoMkType type("CryptoPP::DL_PrivateKeyImpl<CryptoPP::DL_GroupParameters_EC<CryptoPP::EC2N> > "); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_GroupParameters_EC<CryptoPP::EC2N>  >(void) { static HajoMkType type("CryptoPP::DL_GroupParameters_EC<CryptoPP::EC2N> "); return type; }
template <> const std::type_info& HajoTypeID< std::string >(void) { static HajoMkType type("std::string"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_GroupParameters_GFP >(void) { static HajoMkType type("CryptoPP::DL_GroupParameters_GFP"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_GroupParameters_IntegerBased >(void) { static HajoMkType type("CryptoPP::DL_GroupParameters_IntegerBased"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_GroupParameters_GFP* >(void) { static HajoMkType type("CryptoPP::DL_GroupParameters_GFP*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_GroupParameters<CryptoPP::Integer>  >(void) { static HajoMkType type("CryptoPP::DL_GroupParameters<CryptoPP::Integer> "); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_GroupParameters<CryptoPP::Integer>* >(void) { static HajoMkType type("CryptoPP::DL_GroupParameters<CryptoPP::Integer>*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_GroupParameters_IntegerBasedImpl<CryptoPP::ModExpPrecomputation, CryptoPP::DL_FixedBasePrecomputationImpl<CryptoPP::Integer> >* >(void) { static HajoMkType type("CryptoPP::DL_GroupParameters_IntegerBasedImpl<CryptoPP::ModExpPrecomputation, CryptoPP::DL_FixedBasePrecomputationImpl<CryptoPP::Integer> >*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PublicKeyImpl<CryptoPP::DL_GroupParameters_DSA>* >(void) { static HajoMkType type("CryptoPP::DL_PublicKeyImpl<CryptoPP::DL_GroupParameters_DSA>*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PublicKey<CryptoPP::Integer>* >(void) { static HajoMkType type("CryptoPP::DL_PublicKey<CryptoPP::Integer>*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PrivateKeyImpl<CryptoPP::DL_GroupParameters_DSA>* >(void) { static HajoMkType type("CryptoPP::DL_PrivateKeyImpl<CryptoPP::DL_GroupParameters_DSA>*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_GroupParameters<CryptoPP::ECPPoint>  >(void) { static HajoMkType type("CryptoPP::DL_GroupParameters<CryptoPP::ECPPoint> "); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_GroupParameters<CryptoPP::ECPPoint>* >(void) { static HajoMkType type("CryptoPP::DL_GroupParameters<CryptoPP::ECPPoint>*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_GroupParameters_EC<CryptoPP::ECP>* >(void) { static HajoMkType type("CryptoPP::DL_GroupParameters_EC<CryptoPP::ECP>*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_GroupParameters<CryptoPP::EC2NPoint>  >(void) { static HajoMkType type("CryptoPP::DL_GroupParameters<CryptoPP::EC2NPoint> "); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_GroupParameters<CryptoPP::EC2NPoint>* >(void) { static HajoMkType type("CryptoPP::DL_GroupParameters<CryptoPP::EC2NPoint>*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_GroupParameters_EC<CryptoPP::EC2N>* >(void) { static HajoMkType type("CryptoPP::DL_GroupParameters_EC<CryptoPP::EC2N>*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PublicKeyImpl<CryptoPP::DL_GroupParameters_EC<CryptoPP::ECP> >* >(void) { static HajoMkType type("CryptoPP::DL_PublicKeyImpl<CryptoPP::DL_GroupParameters_EC<CryptoPP::ECP> >*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PublicKey<CryptoPP::ECPPoint>* >(void) { static HajoMkType type("CryptoPP::DL_PublicKey<CryptoPP::ECPPoint>*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PublicKeyImpl<CryptoPP::DL_GroupParameters_EC<CryptoPP::EC2N> >* >(void) { static HajoMkType type("CryptoPP::DL_PublicKeyImpl<CryptoPP::DL_GroupParameters_EC<CryptoPP::EC2N> >*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PublicKey<CryptoPP::EC2NPoint>* >(void) { static HajoMkType type("CryptoPP::DL_PublicKey<CryptoPP::EC2NPoint>*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PrivateKeyImpl<CryptoPP::DL_GroupParameters_EC<CryptoPP::ECP> >* >(void) { static HajoMkType type("CryptoPP::DL_PrivateKeyImpl<CryptoPP::DL_GroupParameters_EC<CryptoPP::ECP> >*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PrivateKeyImpl<CryptoPP::DL_GroupParameters_EC<CryptoPP::EC2N> >* >(void) { static HajoMkType type("CryptoPP::DL_PrivateKeyImpl<CryptoPP::DL_GroupParameters_EC<CryptoPP::EC2N> >*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::ESIGNFunction >(void) { static HajoMkType type("CryptoPP::ESIGNFunction"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::InvertibleESIGNFunction >(void) { static HajoMkType type("CryptoPP::InvertibleESIGNFunction"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::ESIGNFunction* >(void) { static HajoMkType type("CryptoPP::ESIGNFunction*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::InvertibleESIGNFunction* >(void) { static HajoMkType type("CryptoPP::InvertibleESIGNFunction*"); return type; }
template <> const std::type_info& HajoTypeID< wchar_t const* >(void) { static HajoMkType type("wchar_t const*"); return type; }
template <> const std::type_info& HajoTypeID< std::istream* >(void) { static HajoMkType type("std::istream*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::ByteArrayParameter >(void) { static HajoMkType type("CryptoPP::ByteArrayParameter"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::BufferedTransformation* >(void) { static HajoMkType type("CryptoPP::BufferedTransformation*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::RandomNumberGenerator* >(void) { static HajoMkType type("CryptoPP::RandomNumberGenerator*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::BlockPaddingSchemeDef::BlockPaddingScheme >(void) { static HajoMkType type("CryptoPP::BlockPaddingSchemeDef::BlockPaddingScheme"); return type; }
template <> const std::type_info& HajoTypeID< bool >(void) { static HajoMkType type("bool"); return type; }
template <> const std::type_info& HajoTypeID< unsigned int >(void) { static HajoMkType type("unsigned int"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_GroupParameters_IntegerBased* >(void) { static HajoMkType type("CryptoPP::DL_GroupParameters_IntegerBased*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::Integer::RandomNumberType >(void) { static HajoMkType type("CryptoPP::Integer::RandomNumberType"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::PrimeSelector const* >(void) { static HajoMkType type("CryptoPP::PrimeSelector const*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::LUCFunction >(void) { static HajoMkType type("CryptoPP::LUCFunction"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::InvertibleLUCFunction >(void) { static HajoMkType type("CryptoPP::InvertibleLUCFunction"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::LUCFunction* >(void) { static HajoMkType type("CryptoPP::LUCFunction*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::InvertibleLUCFunction* >(void) { static HajoMkType type("CryptoPP::InvertibleLUCFunction*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::RabinFunction >(void) { static HajoMkType type("CryptoPP::RabinFunction"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::InvertibleRabinFunction >(void) { static HajoMkType type("CryptoPP::InvertibleRabinFunction"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::RabinFunction* >(void) { static HajoMkType type("CryptoPP::RabinFunction*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::InvertibleRabinFunction* >(void) { static HajoMkType type("CryptoPP::InvertibleRabinFunction*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PublicKeyImpl<CryptoPP::DL_GroupParameters_GFP_DefaultSafePrime>  >(void) { static HajoMkType type("CryptoPP::DL_PublicKeyImpl<CryptoPP::DL_GroupParameters_GFP_DefaultSafePrime> "); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PrivateKeyImpl<CryptoPP::DL_GroupParameters_GFP_DefaultSafePrime>  >(void) { static HajoMkType type("CryptoPP::DL_PrivateKeyImpl<CryptoPP::DL_GroupParameters_GFP_DefaultSafePrime> "); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_GroupParameters_GFP_DefaultSafePrime >(void) { static HajoMkType type("CryptoPP::DL_GroupParameters_GFP_DefaultSafePrime"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PrivateKeyImpl<CryptoPP::DL_GroupParameters_GFP>  >(void) { static HajoMkType type("CryptoPP::DL_PrivateKeyImpl<CryptoPP::DL_GroupParameters_GFP> "); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PublicKeyImpl<CryptoPP::DL_GroupParameters_GFP>  >(void) { static HajoMkType type("CryptoPP::DL_PublicKeyImpl<CryptoPP::DL_GroupParameters_GFP> "); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PublicKeyImpl<CryptoPP::DL_GroupParameters_GFP_DefaultSafePrime>* >(void) { static HajoMkType type("CryptoPP::DL_PublicKeyImpl<CryptoPP::DL_GroupParameters_GFP_DefaultSafePrime>*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PrivateKeyImpl<CryptoPP::DL_GroupParameters_GFP_DefaultSafePrime>* >(void) { static HajoMkType type("CryptoPP::DL_PrivateKeyImpl<CryptoPP::DL_GroupParameters_GFP_DefaultSafePrime>*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PrivateKeyImpl<CryptoPP::DL_GroupParameters_GFP>* >(void) { static HajoMkType type("CryptoPP::DL_PrivateKeyImpl<CryptoPP::DL_GroupParameters_GFP>*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PublicKeyImpl<CryptoPP::DL_GroupParameters_GFP>* >(void) { static HajoMkType type("CryptoPP::DL_PublicKeyImpl<CryptoPP::DL_GroupParameters_GFP>*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::RSAFunction >(void) { static HajoMkType type("CryptoPP::RSAFunction"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::InvertibleRSAFunction >(void) { static HajoMkType type("CryptoPP::InvertibleRSAFunction"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::RSAFunction* >(void) { static HajoMkType type("CryptoPP::RSAFunction*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::InvertibleRSAFunction* >(void) { static HajoMkType type("CryptoPP::InvertibleRSAFunction*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::RWFunction >(void) { static HajoMkType type("CryptoPP::RWFunction"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::InvertibleRWFunction >(void) { static HajoMkType type("CryptoPP::InvertibleRWFunction"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::RWFunction* >(void) { static HajoMkType type("CryptoPP::RWFunction*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::InvertibleRWFunction* >(void) { static HajoMkType type("CryptoPP::InvertibleRWFunction*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_GroupParameters_IntegerBasedImpl<CryptoPP::DL_GroupPrecomputation_LUC, CryptoPP::DL_BasePrecomputation_LUC>  >(void) { static HajoMkType type("CryptoPP::DL_GroupParameters_IntegerBasedImpl<CryptoPP::DL_GroupPrecomputation_LUC, CryptoPP::DL_BasePrecomputation_LUC> "); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PublicKeyImpl<CryptoPP::DL_GroupParameters_LUC>  >(void) { static HajoMkType type("CryptoPP::DL_PublicKeyImpl<CryptoPP::DL_GroupParameters_LUC> "); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PrivateKeyImpl<CryptoPP::DL_GroupParameters_LUC>  >(void) { static HajoMkType type("CryptoPP::DL_PrivateKeyImpl<CryptoPP::DL_GroupParameters_LUC> "); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_GroupParameters_LUC >(void) { static HajoMkType type("CryptoPP::DL_GroupParameters_LUC"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PublicKeyImpl<CryptoPP::DL_GroupParameters_LUC_DefaultSafePrime>  >(void) { static HajoMkType type("CryptoPP::DL_PublicKeyImpl<CryptoPP::DL_GroupParameters_LUC_DefaultSafePrime> "); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PrivateKeyImpl<CryptoPP::DL_GroupParameters_LUC_DefaultSafePrime>  >(void) { static HajoMkType type("CryptoPP::DL_PrivateKeyImpl<CryptoPP::DL_GroupParameters_LUC_DefaultSafePrime> "); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_GroupParameters_LUC_DefaultSafePrime >(void) { static HajoMkType type("CryptoPP::DL_GroupParameters_LUC_DefaultSafePrime"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_GroupParameters_LUC* >(void) { static HajoMkType type("CryptoPP::DL_GroupParameters_LUC*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_GroupParameters_IntegerBasedImpl<CryptoPP::DL_GroupPrecomputation_LUC, CryptoPP::DL_BasePrecomputation_LUC>* >(void) { static HajoMkType type("CryptoPP::DL_GroupParameters_IntegerBasedImpl<CryptoPP::DL_GroupPrecomputation_LUC, CryptoPP::DL_BasePrecomputation_LUC>*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PublicKeyImpl<CryptoPP::DL_GroupParameters_LUC>* >(void) { static HajoMkType type("CryptoPP::DL_PublicKeyImpl<CryptoPP::DL_GroupParameters_LUC>*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PrivateKeyImpl<CryptoPP::DL_GroupParameters_LUC>* >(void) { static HajoMkType type("CryptoPP::DL_PrivateKeyImpl<CryptoPP::DL_GroupParameters_LUC>*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PublicKeyImpl<CryptoPP::DL_GroupParameters_LUC_DefaultSafePrime>* >(void) { static HajoMkType type("CryptoPP::DL_PublicKeyImpl<CryptoPP::DL_GroupParameters_LUC_DefaultSafePrime>*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::DL_PrivateKeyImpl<CryptoPP::DL_GroupParameters_LUC_DefaultSafePrime>* >(void) { static HajoMkType type("CryptoPP::DL_PrivateKeyImpl<CryptoPP::DL_GroupParameters_LUC_DefaultSafePrime>*"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::XTR_DH >(void) { static HajoMkType type("CryptoPP::XTR_DH"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::GFP2Element >(void) { static HajoMkType type("CryptoPP::GFP2Element"); return type; }
template <> const std::type_info& HajoTypeID< CryptoPP::XTR_DH* >(void) { static HajoMkType type("CryptoPP::XTR_DH*"); return type; }