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
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
|
#include "hybridcrypt.h"
HybridCrypt::HybridCrypt()
{
// Initialisiere Nutzerschlüssel mit NULL
userKeypair = NULL;
// Lade die menschenlesbaren Fehlerstrings für LibCrypto
ERR_load_crypto_strings();
// Lade alle Hash- und Verschlüsselungsalgorithmen
OpenSSL_add_all_algorithms();
// Lade Konfigurationsdatei und andere wichtige Initialisierungen
OPENSSL_config(NULL);
// Zeige ob der Zufallszahlengenerator initialisiert wurde
qDebug() << "Zufallszahlengenerator erfolgreich initialisiert: " <<
isCsprngSeeded();
}
HybridCrypt::~HybridCrypt()
{
// Räume Nutzerschlüssel auf
freeEvpKey(&userKeypair);
// Räume OpenSSL auf
// Entferne alle Hash- und Verschlüsselungsalgorithmen
EVP_cleanup();
// Falls das nächste Ausgelassen wird, könnte ein Speicherleck auftreten,
// wenn die BIO Api verwendet wurde (Base64 transformationen)
CRYPTO_cleanup_all_ex_data();
// Lösche den CSPRNG sicher
RAND_cleanup();
// Entferne Fehlerstrings
ERR_free_strings();
}
void HybridCrypt::encrypt(QString infileName, QString outfileName,
QVector<QString> recipientKeyfileNames)
{
}
void HybridCrypt::decrypt(QString infileName, QString outfileName)
{
}
void HybridCrypt::createKeypair()
{
if (isCsprngSeeded())
{
// Räume den alten Schlüssel vorher ab
freeEvpKey(&userKeypair);
// Lege Schlüsselkontextvariable an
EVP_PKEY_CTX *ctx = NULL;
// Erzeuge den Schlüsselkontext
if (!(ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, NULL)))
{
throwOpenSslException();
}
// Initialisiere den Schlüsselgenerator
if (EVP_PKEY_keygen_init(ctx) <= 0)
{
throwOpenSslException();
}
// Lege den Schlüssel mit 2048 Bit an
if (EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, 2048) <= 0)
{
throwOpenSslException();
}
// Erzeuge den Schlüssel
if (EVP_PKEY_keygen(ctx, &userKeypair) <= 0)
{
throwOpenSslException();
}
// Räume den Schlüsselkontext ab
EVP_PKEY_CTX_free(ctx);
}
}
void HybridCrypt::importUserKeypair(QString keyfileName, QString password)
{
// Räume den alten Schlüssel vorher ab
freeEvpKey(&userKeypair);
FILE *keyfile = fopen(keyfileName.toStdString().c_str(), "r");
// Datei existiert nicht
if (keyfile == NULL)
{
throw CryptException("Datei nicht gefunden: " + keyfileName.toStdString(), CryptException::FileNotFound);
}
// Ließ den Schlüssel des Nutzers ein
userKeypair = PEM_read_PrivateKey(keyfile, NULL, NULL,
(void *) password.toStdString().c_str());
// Räume die Ressourcen auf
fclose(keyfile);
// Wirf einen Fehler, falls OpenSSL ein Problem hatte
if (userKeypair == NULL)
{
throwOpenSslException();
}
// Wirf Exception, falls kein RSA Schlüssel importiert wurde
throwExceptionIfEvpKeyIsNotRsa(&userKeypair);
}
void HybridCrypt::exportUserKeypair(QString keyfileName, QString password)
{
if (userKeypair != NULL && isCsprngSeeded())
{
FILE *keyfile = fopen(keyfileName.toStdString().c_str(), "w+");
// Teste, ob die Datei zum Schreiben geöffnet werden konnte
if (keyfile == NULL)
{
throw CryptException("Konnte Datei nicht schreiben: " +
keyfileName.toStdString(), CryptException::FileNotWritable);
}
// Wenn password ein Leerstring ist, verschlüssele den privaten Schlüssel nicht
int opensslReturnError = PEM_write_PKCS8PrivateKey(keyfile, userKeypair,
(password.isEmpty()) ? NULL : EVP_aes_256_cbc(), NULL, 0, NULL,
(void *) password.toStdString().c_str());
// Räume die Ressourcen auf
fclose(keyfile);
// Wirf einen Fehler, falls OpenSSL ein Problem hatte
if (!opensslReturnError)
{
throwOpenSslException();
}
}
}
void HybridCrypt::exportPublicUserKey(QString keyfileName)
{
if (userKeypair != NULL)
{
FILE *keyfile = fopen(keyfileName.toStdString().c_str(), "w+");
// Teste, ob die Datei zum Schreiben geöffnet werden konnte
if (keyfile == NULL)
{
throw CryptException("Konnte Datei nicht schreiben: " +
keyfileName.toStdString(), CryptException::FileNotWritable);
}
int opensslReturnError = PEM_write_PUBKEY(keyfile, userKeypair);
// Räume die Ressourcen auf
fclose(keyfile);
// Wirft einen Fehler, falls OpenSSL ein Problem hatte
if (!opensslReturnError)
{
throwOpenSslException();
}
}
}
/*
* Private Funktionen
*/
bool HybridCrypt::isCsprngSeeded()
{
return RAND_status() == 1;
}
bool HybridCrypt::isKeyRsa(EVP_PKEY *key)
{
return EVP_PKEY_type(key->type) == EVP_PKEY_RSA;
}
void HybridCrypt::throwOpenSslException()
{
QString errorMsg("OpenSSL Fehler. Fehlermeldung: ");
errorMsg.append(ERR_error_string(ERR_get_error(), NULL));
throw CryptException(errorMsg.toStdString(), CryptException::OpenSslError);
}
void HybridCrypt::throwExceptionIfEvpKeyIsNotRsa(EVP_PKEY **key)
{
if (!isKeyRsa(*key))
{
freeEvpKey(key);
throw CryptException("Nur RSA Schlüssel werden unterstüzt.", CryptException::KeyNotRsa);
}
}
void HybridCrypt::freeEvpKey(EVP_PKEY **key)
{
EVP_PKEY_free(*key);
*key = NULL;
}
|
