Mercurial > pidgin3 / file comparison

comparison: libpurple/cipher.c

libpurple/cipher.c

changeset 38413
e35c6b6ca094
parent 38412
e25c73450414
child 38414
3892b306732f
equal deleted inserted replaced
38412:e25c73450414 38413:e35c6b6ca094
1 /* purple
2 *
3 * Purple is the legal property of its developers, whose names are too numerous
4 * to list here. Please refer to the COPYRIGHT file distributed with this
5 * source distribution.
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
20 */
21 #include "internal.h"
22 #include "cipher.h"
23 #include "debug.h"
24
25 /******************************************************************************
26 * PurpleCipher API
27 *****************************************************************************/
28 GType
29 purple_cipher_get_type(void) {
30 static GType type = 0;
31
32 if(type == 0) {
33 static const GTypeInfo info = {
34 sizeof(PurpleCipherClass),
35 NULL,
36 NULL,
37 NULL,
38 NULL,
39 NULL,
40 sizeof(PurpleCipher),
41 0,
42 NULL,
43 NULL
44 };
45
46 type = g_type_register_static(G_TYPE_OBJECT,
47 "PurpleCipher",
48 &info, G_TYPE_FLAG_ABSTRACT);
49 }
50
51 return type;
52 }
53
54 static const gchar *
55 purple_cipher_get_name(PurpleCipher *cipher)
56 {
57 PurpleCipherClass *klass;
58 const gchar *name;
59
60 if (!PURPLE_IS_CIPHER(cipher))
61 return "(error: not a cipher)";
62
63 klass = PURPLE_CIPHER_GET_CLASS(cipher);
64 if (!klass)
65 return "(error: unknown cipher class)";
66
67 name = g_type_name(G_TYPE_FROM_CLASS(klass));
68 if (!name)
69 return "(error: unknown cipher name)";
70
71 return name;
72 }
73
74 static const gchar *
75 purple_hash_get_name(PurpleHash *hash)
76 {
77 PurpleHashClass *klass;
78 const gchar *name;
79
80 if (!PURPLE_IS_HASH(hash))
81 return "(error: not a hash)";
82
83 klass = PURPLE_HASH_GET_CLASS(hash);
84 if (!klass)
85 return "(error: unknown hash class)";
86
87 name = g_type_name(G_TYPE_FROM_CLASS(klass));
88 if (!name)
89 return "(error: unknown hash name)";
90
91 return name;
92 }
93
94 void
95 purple_cipher_reset(PurpleCipher *cipher) {
96 PurpleCipherClass *klass = NULL;
97
98 g_return_if_fail(PURPLE_IS_CIPHER(cipher));
99
100 klass = PURPLE_CIPHER_GET_CLASS(cipher);
101
102 if (klass && klass->reset)
103 klass->reset(cipher);
104 else {
105 purple_debug_warning("cipher", "the %s cipher does not "
106 "implement the reset method",
107 purple_cipher_get_name(cipher));
108 }
109 }
110
111 void
112 purple_cipher_reset_state(PurpleCipher *cipher) {
113 PurpleCipherClass *klass = NULL;
114
115 g_return_if_fail(PURPLE_IS_CIPHER(cipher));
116
117 klass = PURPLE_CIPHER_GET_CLASS(cipher);
118
119 if (klass && klass->reset_state)
120 klass->reset_state(cipher);
121 else {
122 purple_debug_warning("cipher", "the %s cipher does not "
123 "implement the reset_state method",
124 purple_cipher_get_name(cipher));
125 }
126 }
127
128 void
129 purple_cipher_set_iv(PurpleCipher *cipher, guchar *iv, size_t len)
130 {
131 PurpleCipherClass *klass = NULL;
132
133 g_return_if_fail(PURPLE_IS_CIPHER(cipher));
134 g_return_if_fail(iv);
135
136 klass = PURPLE_CIPHER_GET_CLASS(cipher);
137
138 if (klass && klass->set_iv)
139 klass->set_iv(cipher, iv, len);
140 else {
141 purple_debug_warning("cipher", "the %s cipher does not "
142 "implement the set_iv method",
143 purple_cipher_get_name(cipher));
144 }
145 }
146
147 void
148 purple_cipher_append(PurpleCipher *cipher, const guchar *data,
149 size_t len)
150 {
151 PurpleCipherClass *klass = NULL;
152
153 g_return_if_fail(PURPLE_IS_CIPHER(cipher));
154
155 klass = PURPLE_CIPHER_GET_CLASS(cipher);
156
157 if (klass && klass->append)
158 klass->append(cipher, data, len);
159 else {
160 purple_debug_warning("cipher", "the %s cipher does not "
161 "implement the append method",
162 purple_cipher_get_name(cipher));
163 }
164 }
165
166 gboolean
167 purple_cipher_digest(PurpleCipher *cipher, guchar digest[], size_t len)
168 {
169 PurpleCipherClass *klass = NULL;
170
171 g_return_val_if_fail(PURPLE_IS_CIPHER(cipher), FALSE);
172
173 klass = PURPLE_CIPHER_GET_CLASS(cipher);
174
175 if (klass && klass->digest)
176 return klass->digest(cipher, digest, len);
177 else {
178 purple_debug_warning("cipher", "the %s cipher does not "
179 "implement the digest method",
180 purple_cipher_get_name(cipher));
181 }
182
183 return FALSE;
184 }
185
186 gboolean
187 purple_cipher_digest_to_str(PurpleCipher *cipher, gchar digest_s[], size_t len)
188 {
189 /* 8k is a bit excessive, will tweak later. */
190 guchar digest[BUF_LEN * 4];
191 size_t digest_size, n;
192
193 g_return_val_if_fail(PURPLE_IS_CIPHER(cipher), FALSE);
194 g_return_val_if_fail(digest_s, FALSE);
195
196 digest_size = purple_cipher_get_digest_size(cipher);
197
198 g_return_val_if_fail(digest_size <= BUF_LEN * 4, FALSE);
199
200 if(!purple_cipher_digest(cipher, digest, sizeof(digest)))
201 return FALSE;
202
203 /* Every digest byte occupies 2 chars + the NUL at the end. */
204 g_return_val_if_fail(digest_size * 2 + 1 <= len, FALSE);
205
206 for(n = 0; n < digest_size; n++)
207 sprintf(digest_s + (n * 2), "%02x", digest[n]);
208
209 digest_s[n * 2] = '\0';
210
211 return TRUE;
212 }
213
214 size_t
215 purple_cipher_get_digest_size(PurpleCipher *cipher)
216 {
217 PurpleCipherClass *klass = NULL;
218
219 g_return_val_if_fail(PURPLE_IS_CIPHER(cipher), FALSE);
220
221 klass = PURPLE_CIPHER_GET_CLASS(cipher);
222
223 if (klass && klass->get_digest_size)
224 return klass->get_digest_size(cipher);
225 else {
226 purple_debug_warning("cipher", "the %s cipher does not "
227 "implement the get_digest_size method",
228 purple_cipher_get_name(cipher));
229 }
230
231 return FALSE;
232 }
233
234 ssize_t
235 purple_cipher_encrypt(PurpleCipher *cipher, const guchar input[],
236 size_t in_len, guchar output[], size_t out_size)
237 {
238 PurpleCipherClass *klass = NULL;
239
240 g_return_val_if_fail(PURPLE_IS_CIPHER(cipher), -1);
241 g_return_val_if_fail(input != NULL, -1);
242 g_return_val_if_fail(output != NULL, -1);
243 g_return_val_if_fail(out_size >= in_len, -1);
244
245 klass = PURPLE_CIPHER_GET_CLASS(cipher);
246
247 if (klass && klass->encrypt)
248 return klass->encrypt(cipher, input, in_len, output, out_size);
249 else {
250 purple_debug_warning("cipher", "the %s cipher does not "
251 "implement the encrypt method",
252 purple_cipher_get_name(cipher));
253 }
254
255 return -1;
256 }
257
258 ssize_t
259 purple_cipher_decrypt(PurpleCipher *cipher, const guchar input[],
260 size_t in_len, guchar output[], size_t out_size)
261 {
262 PurpleCipherClass *klass = NULL;
263
264 g_return_val_if_fail(PURPLE_IS_CIPHER(cipher), -1);
265 g_return_val_if_fail(input != NULL, -1);
266 g_return_val_if_fail(output != NULL, -1);
267
268 klass = PURPLE_CIPHER_GET_CLASS(cipher);
269
270 if (klass && klass->decrypt)
271 return klass->decrypt(cipher, input, in_len, output, out_size);
272 else {
273 purple_debug_warning("cipher", "the %s cipher does not "
274 "implement the decrypt method",
275 purple_cipher_get_name(cipher));
276 }
277
278 return -1;
279 }
280
281 void
282 purple_cipher_set_salt(PurpleCipher *cipher, const guchar *salt, size_t len) {
283 PurpleCipherClass *klass = NULL;
284
285 g_return_if_fail(PURPLE_IS_CIPHER(cipher));
286
287 klass = PURPLE_CIPHER_GET_CLASS(cipher);
288
289 if (klass && klass->set_salt)
290 klass->set_salt(cipher, salt, len);
291 else {
292 purple_debug_warning("cipher", "the %s cipher does not "
293 "implement the set_salt method",
294 purple_cipher_get_name(cipher));
295 }
296 }
297
298 void
299 purple_cipher_set_key(PurpleCipher *cipher, const guchar *key, size_t len) {
300 PurpleCipherClass *klass = NULL;
301
302 g_return_if_fail(PURPLE_IS_CIPHER(cipher));
303
304 klass = PURPLE_CIPHER_GET_CLASS(cipher);
305
306 if (klass && klass->set_key)
307 klass->set_key(cipher, key, len);
308 else {
309 purple_debug_warning("cipher", "the %s cipher does not "
310 "implement the set_key method",
311 purple_cipher_get_name(cipher));
312 }
313 }
314
315 size_t
316 purple_cipher_get_key_size(PurpleCipher *cipher) {
317 PurpleCipherClass *klass = NULL;
318
319 g_return_val_if_fail(PURPLE_IS_CIPHER(cipher), -1);
320
321 klass = PURPLE_CIPHER_GET_CLASS(cipher);
322
323 if (klass && klass->get_key_size)
324 return klass->get_key_size(cipher);
325 else {
326 purple_debug_warning("cipher", "the %s cipher does not "
327 "implement the get_key_size method",
328 purple_cipher_get_name(cipher));
329 }
330
331 return -1;
332 }
333
334 void
335 purple_cipher_set_batch_mode(PurpleCipher *cipher,
336 PurpleCipherBatchMode mode)
337 {
338 PurpleCipherClass *klass = NULL;
339
340 g_return_if_fail(PURPLE_IS_CIPHER(cipher));
341
342 klass = PURPLE_CIPHER_GET_CLASS(cipher);
343
344 if (klass && klass->set_batch_mode)
345 klass->set_batch_mode(cipher, mode);
346 else {
347 purple_debug_warning("cipher", "the %s cipher does not "
348 "implement the set_batch_mode method",
349 purple_cipher_get_name(cipher));
350 }
351 }
352
353 PurpleCipherBatchMode
354 purple_cipher_get_batch_mode(PurpleCipher *cipher)
355 {
356 PurpleCipherClass *klass = NULL;
357
358 g_return_val_if_fail(PURPLE_IS_CIPHER(cipher), -1);
359
360 klass = PURPLE_CIPHER_GET_CLASS(cipher);
361
362 if (klass && klass->get_batch_mode)
363 return klass->get_batch_mode(cipher);
364 else {
365 purple_debug_warning("cipher", "the %s cipher does not "
366 "implement the get_batch_mode method",
367 purple_cipher_get_name(cipher));
368 }
369
370 return -1;
371 }
372
373 size_t
374 purple_cipher_get_block_size(PurpleCipher *cipher)
375 {
376 PurpleCipherClass *klass = NULL;
377
378 g_return_val_if_fail(PURPLE_IS_CIPHER(cipher), -1);
379
380 klass = PURPLE_CIPHER_GET_CLASS(cipher);
381
382 if (klass && klass->get_block_size)
383 return klass->get_block_size(cipher);
384 else {
385 purple_debug_warning("cipher", "the %s cipher does not "
386 "implement the get_block_size method",
387 purple_cipher_get_name(cipher));
388 }
389
390 return -1;
391 }
392
393 /******************************************************************************
394 * PurpleHash API
395 *****************************************************************************/
396 GType
397 purple_hash_get_type(void) {
398 static GType type = 0;
399
400 if(type == 0) {
401 static const GTypeInfo info = {
402 sizeof(PurpleHashClass),
403 NULL,
404 NULL,
405 NULL,
406 NULL,
407 NULL,
408 sizeof(PurpleHash),
409 0,
410 NULL,
411 NULL
412 };
413
414 type = g_type_register_static(G_TYPE_OBJECT,
415 "PurpleHash",
416 &info, G_TYPE_FLAG_ABSTRACT);
417 }
418
419 return type;
420 }
421
422 void
423 purple_hash_reset(PurpleHash *hash) {
424 PurpleHashClass *klass = NULL;
425
426 g_return_if_fail(PURPLE_IS_HASH(hash));
427
428 klass = PURPLE_HASH_GET_CLASS(hash);
429
430 if (klass && klass->reset)
431 klass->reset(hash);
432 else {
433 purple_debug_warning("hash", "the %s hash does not implement "
434 "the reset method", purple_hash_get_name(hash));
435 }
436 }
437
438 void
439 purple_hash_reset_state(PurpleHash *hash) {
440 PurpleHashClass *klass = NULL;
441
442 g_return_if_fail(PURPLE_IS_HASH(hash));
443
444 klass = PURPLE_HASH_GET_CLASS(hash);
445
446 if (klass && klass->reset_state)
447 klass->reset_state(hash);
448 else {
449 purple_debug_warning("hash", "the %s hash does not implement "
450 "the reset_state method", purple_hash_get_name(hash));
451 }
452 }
453
454 void
455 purple_hash_append(PurpleHash *hash, const guchar *data,
456 size_t len)
457 {
458 PurpleHashClass *klass = NULL;
459
460 g_return_if_fail(PURPLE_IS_HASH(hash));
461
462 klass = PURPLE_HASH_GET_CLASS(hash);
463
464 if (klass && klass->append)
465 klass->append(hash, data, len);
466 else {
467 purple_debug_warning("hash", "the %s hash does not implement "
468 "the append method", purple_hash_get_name(hash));
469 }
470 }
471
472 gboolean
473 purple_hash_digest(PurpleHash *hash, guchar digest[], size_t len)
474 {
475 PurpleHashClass *klass = NULL;
476
477 g_return_val_if_fail(PURPLE_IS_HASH(hash), FALSE);
478
479 klass = PURPLE_HASH_GET_CLASS(hash);
480
481 if (klass && klass->digest)
482 return klass->digest(hash, digest, len);
483 else {
484 purple_debug_warning("hash", "the %s hash does not implement "
485 "the digest method", purple_hash_get_name(hash));
486 }
487
488 return FALSE;
489 }
490
491 gboolean
492 purple_hash_digest_to_str(PurpleHash *hash, gchar digest_s[], size_t len)
493 {
494 /* 8k is a bit excessive, will tweak later. */
495 guchar digest[BUF_LEN * 4];
496 size_t digest_size, n;
497
498 g_return_val_if_fail(PURPLE_IS_HASH(hash), FALSE);
499 g_return_val_if_fail(digest_s, FALSE);
500
501 digest_size = purple_hash_get_digest_size(hash);
502
503 g_return_val_if_fail(digest_size <= BUF_LEN * 4, FALSE);
504
505 if(!purple_hash_digest(hash, digest, sizeof(digest)))
506 return FALSE;
507
508 /* Every digest byte occupies 2 chars + the NUL at the end. */
509 g_return_val_if_fail(digest_size * 2 + 1 <= len, FALSE);
510
511 for(n = 0; n < digest_size; n++)
512 sprintf(digest_s + (n * 2), "%02x", digest[n]);
513
514 digest_s[n * 2] = '\0';
515
516 return TRUE;
517 }
518
519 size_t
520 purple_hash_get_digest_size(PurpleHash *hash)
521 {
522 PurpleHashClass *klass = NULL;
523
524 g_return_val_if_fail(PURPLE_IS_HASH(hash), FALSE);
525
526 klass = PURPLE_HASH_GET_CLASS(hash);
527
528 if (klass && klass->get_digest_size)
529 return klass->get_digest_size(hash);
530 else {
531 purple_debug_warning("hash", "the %s hash does not implement "
532 "the get_digest_size method", purple_hash_get_name(hash));
533 }
534
535 return FALSE;
536 }
537
538 size_t
539 purple_hash_get_block_size(PurpleHash *hash)
540 {
541 PurpleHashClass *klass = NULL;
542
543 g_return_val_if_fail(PURPLE_IS_HASH(hash), -1);
544
545 klass = PURPLE_HASH_GET_CLASS(hash);
546
547 if (klass && klass->get_block_size)
548 return klass->get_block_size(hash);
549 else {
550 purple_debug_warning("hash", "the %s hash does not implement "
551 "the get_block_size method", purple_hash_get_name(hash));
552 }
553
554 return -1;
555 }

Mercurial Repository: pidgin3

mercurial