im.pidgin.gobjectification: afd0de98d28b3483b0ba8d34d6d2e067074edd3d
sadrul at pidgin.im
sadrul at pidgin.im
Wed Feb 27 23:48:40 EST 2008
-----------------------------------------------------------------
Revision: afd0de98d28b3483b0ba8d34d6d2e067074edd3d
Ancestor: 8d63d102fe9727e30fc68d6f66eb801951c78ec1
Author: sadrul at pidgin.im
Date: 2008-02-28T04:47:26
Branch: im.pidgin.gobjectification
URL: http://d.pidgin.im/viewmtn/revision/info/afd0de98d28b3483b0ba8d34d6d2e067074edd3d
Modified files:
configure.ac libpurple/Makefile.am libpurple/cipher.c
libpurple/cipher.h libpurple/descipher.c
libpurple/descipher.h libpurple/plugins/ciphertest.c
libpurple/plugins/perl/common/Cipher.xs
libpurple/plugins/perl/common/Util.xs
libpurple/plugins/perl/common/module.h
libpurple/plugins/perl/common/typemap
libpurple/plugins/signals-test.c
libpurple/protocols/bonjour/bonjour_ft.c
libpurple/protocols/jabber/auth.c
libpurple/protocols/jabber/buddy.c
libpurple/protocols/jabber/si.c
libpurple/protocols/msn/msn.h
libpurple/protocols/msn/msnutils.c
libpurple/protocols/msnp9/msn.h
libpurple/protocols/msnp9/notification.c
libpurple/protocols/msnp9/user.c
libpurple/protocols/myspace/myspace.c
libpurple/protocols/myspace/myspace.h
libpurple/protocols/oscar/family_auth.c
libpurple/protocols/oscar/family_oservice.c
libpurple/protocols/oscar/oscar.c
libpurple/protocols/qq/file_trans.c
libpurple/protocols/qq/qq_proxy.c
libpurple/protocols/simple/simple.c
libpurple/protocols/yahoo/yahoo.c
libpurple/tests/check_libpurple.c
libpurple/tests/test_cipher.c libpurple/util.c
libpurple/util.h
ChangeLog:
A bunch of patches from xanderw to update the gobjectification branch with
the changes in i.p.p:
0001-Move-ciphers-around.patch
0002-New-cipher-API.patch
0003-All-cipher-subclasses.patch
0004-Update-libpurple-and-tests.patch
0005-Updates-plugins.patch
0006-Updates-protocols.patch
Things compile and run, apparently. References #35.
-------------- next part --------------
============================================================
--- configure.ac 06ce688082cea222c7ffd235469d75801518de11
+++ configure.ac 6aa15ba3f82ec84a4ed1eab67f4d0c31c94adb38
@@ -43,9 +43,9 @@ AC_PREREQ([2.50])
#
# Make sure to update finch/libgnt/configure.ac with libgnt version changes.
#
-m4_define([purple_lt_current], [4])
-m4_define([purple_major_version], [2])
-m4_define([purple_minor_version], [4])
+m4_define([purple_lt_current], [40])
+m4_define([purple_major_version], [3])
+m4_define([purple_minor_version], [0])
m4_define([purple_micro_version], [0])
m4_define([purple_version_suffix], [devel])
m4_define([purple_version],
============================================================
--- libpurple/Makefile.am 970eb388b52914c9e0287f4010996ba5ce7524c9
+++ libpurple/Makefile.am 2990b2ca47852a1c9b0f21a3ac0d31261d92af72
@@ -45,12 +45,17 @@ purple_coresources = \
conversation.c \
core.c \
debug.c \
+ descipher.c \
+ des3cipher.c \
desktopitem.c \
eventloop.c \
ft.c \
+ hmaccipher.c \
idle.c \
imgstore.c \
log.c \
+ md4cipher.c \
+ md5cipher.c \
mime.c \
nat-pmp.c \
network.c \
@@ -63,10 +68,12 @@ purple_coresources = \
privacy.c \
proxy.c \
prpl.c \
+ rc4cipher.c \
request.c \
roomlist.c \
savedstatuses.c \
server.c \
+ sha1cipher.c \
signals.c \
dnsquery.c \
dnssrv.c\
@@ -96,13 +103,18 @@ purple_coreheaders = \
core.h \
dbus-maybe.h \
debug.h \
+ descipher.h \
+ des3cipher.h \
desktopitem.h \
eventloop.h \
ft.h \
gaim-compat.h \
+ hmaccipher.h \
idle.h \
imgstore.h \
log.h \
+ md4cipher.h \
+ md5cipher.h \
mime.h \
nat-pmp.h \
network.h \
@@ -115,6 +127,7 @@ purple_coreheaders = \
privacy.h \
proxy.h \
prpl.h \
+ rc4cipher.h \
request.h \
roomlist.h \
savedstatuses.h \
@@ -122,6 +135,7 @@ purple_coreheaders = \
signals.h \
dnsquery.h \
dnssrv.h \
+ sha1cipher.h \
status.h \
stringref.h \
stun.h \
============================================================
--- libpurple/cipher.c 036f4dcc08b7253c49bf2025cd0c75f0ad0c03cc
+++ libpurple/cipher.c 6831530ce7ef83b5b4fcaea91772dfdee0f24e61
@@ -5,37 +5,6 @@
* to list here. Please refer to the COPYRIGHT file distributed with this
* source distribution.
*
- * Original md5
- * Copyright (C) 2001-2003 Christophe Devine <c.devine at cr0.net>
- *
- * Original md4 taken from linux kernel
- * MD4 Message Digest Algorithm (RFC1320).
- *
- * Implementation derived from Andrew Tridgell and Steve French's
- * CIFS MD4 implementation, and the cryptoapi implementation
- * originally based on the public domain implementation written
- * by Colin Plumb in 1993.
- *
- * Copyright (c) Andrew Tridgell 1997-1998.
- * Modified by Steve French (sfrench at us.ibm.com) 2002
- * Copyright (c) Cryptoapi developers.
- * Copyright (c) 2002 David S. Miller (davem at redhat.com)
- * Copyright (c) 2002 James Morris <jmorris at intercode.com.au>
- *
- * Original des taken from gpg
- *
- * des.c - DES and Triple-DES encryption/decryption Algorithm
- * Copyright (C) 1998 Free Software Foundation, Inc.
- *
- * Please see below for more legal information!
- *
- * According to the definition of DES in FIPS PUB 46-2 from December 1993.
- * For a description of triple encryption, see:
- * Bruce Schneier: Applied Cryptography. Second Edition.
- * John Wiley & Sons, 1996. ISBN 0-471-12845-7. Pages 358 ff.
- *
- * This file is part of GnuPG.
- *
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
@@ -50,2371 +19,130 @@
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
*/
-#include <glib.h>
-#include <string.h>
-#include <stdio.h>
-
#include "internal.h"
#include "cipher.h"
-#include "dbus-maybe.h"
-#include "debug.h"
-#include "signals.h"
-#include "value.h"
/*******************************************************************************
- * MD5
+ * Structs
******************************************************************************/
-#define MD5_HMAC_BLOCK_SIZE 64
-struct MD5Context {
- guint32 total[2];
- guint32 state[4];
- guchar buffer[64];
-};
-
-#define MD5_GET_GUINT32(n,b,i) { \
- (n) = ((guint32)(b) [(i) ] ) \
- | ((guint32)(b) [(i) + 1] << 8) \
- | ((guint32)(b) [(i) + 2] << 16) \
- | ((guint32)(b) [(i) + 3] << 24); \
-}
-#define MD5_PUT_GUINT32(n,b,i) { \
- (b)[(i) ] = (guchar)((n) ); \
- (b)[(i) + 1] = (guchar)((n) >> 8); \
- (b)[(i) + 2] = (guchar)((n) >> 16); \
- (b)[(i) + 3] = (guchar)((n) >> 24); \
-}
-
-static void
-md5_init(PurpleCipherContext *context, gpointer extra) {
- struct MD5Context *md5_context;
-
- md5_context = g_new0(struct MD5Context, 1);
-
- purple_cipher_context_set_data(context, md5_context);
-
- purple_cipher_context_reset(context, extra);
-}
-
-static void
-md5_reset(PurpleCipherContext *context, gpointer extra) {
- struct MD5Context *md5_context;
-
- md5_context = purple_cipher_context_get_data(context);
-
- md5_context->total[0] = 0;
- md5_context->total[1] = 0;
-
- md5_context->state[0] = 0x67452301;
- md5_context->state[1] = 0xEFCDAB89;
- md5_context->state[2] = 0x98BADCFE;
- md5_context->state[3] = 0x10325476;
-
- memset(md5_context->buffer, 0, sizeof(md5_context->buffer));
-}
-
-static void
-md5_uninit(PurpleCipherContext *context) {
- struct MD5Context *md5_context;
-
- purple_cipher_context_reset(context, NULL);
-
- md5_context = purple_cipher_context_get_data(context);
- memset(md5_context, 0, sizeof(md5_context));
-
- g_free(md5_context);
- md5_context = NULL;
-}
-
-static void
-md5_process(struct MD5Context *md5_context, const guchar data[64]) {
- guint32 X[16], A, B, C, D;
-
- A = md5_context->state[0];
- B = md5_context->state[1];
- C = md5_context->state[2];
- D = md5_context->state[3];
-
- MD5_GET_GUINT32(X[ 0], data, 0);
- MD5_GET_GUINT32(X[ 1], data, 4);
- MD5_GET_GUINT32(X[ 2], data, 8);
- MD5_GET_GUINT32(X[ 3], data, 12);
- MD5_GET_GUINT32(X[ 4], data, 16);
- MD5_GET_GUINT32(X[ 5], data, 20);
- MD5_GET_GUINT32(X[ 6], data, 24);
- MD5_GET_GUINT32(X[ 7], data, 28);
- MD5_GET_GUINT32(X[ 8], data, 32);
- MD5_GET_GUINT32(X[ 9], data, 36);
- MD5_GET_GUINT32(X[10], data, 40);
- MD5_GET_GUINT32(X[11], data, 44);
- MD5_GET_GUINT32(X[12], data, 48);
- MD5_GET_GUINT32(X[13], data, 52);
- MD5_GET_GUINT32(X[14], data, 56);
- MD5_GET_GUINT32(X[15], data, 60);
-
- #define S(x,n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n)))
- #define P(a,b,c,d,k,s,t) { \
- a += F(b,c,d) + X[k] + t; \
- a = S(a,s) + b; \
- }
-
- /* first pass */
- #define F(x,y,z) (z ^ (x & (y ^ z)))
- P(A, B, C, D, 0, 7, 0xD76AA478);
- P(D, A, B, C, 1, 12, 0xE8C7B756);
- P(C, D, A, B, 2, 17, 0x242070DB);
- P(B, C, D, A, 3, 22, 0xC1BDCEEE);
- P(A, B, C, D, 4, 7, 0xF57C0FAF);
- P(D, A, B, C, 5, 12, 0x4787C62A);
- P(C, D, A, B, 6, 17, 0xA8304613);
- P(B, C, D, A, 7, 22, 0xFD469501);
- P(A, B, C, D, 8, 7, 0x698098D8);
- P(D, A, B, C, 9, 12, 0x8B44F7AF);
- P(C, D, A, B, 10, 17, 0xFFFF5BB1);
- P(B, C, D, A, 11, 22, 0x895CD7BE);
- P(A, B, C, D, 12, 7, 0x6B901122);
- P(D, A, B, C, 13, 12, 0xFD987193);
- P(C, D, A, B, 14, 17, 0xA679438E);
- P(B, C, D, A, 15, 22, 0x49B40821);
- #undef F
-
- /* second pass */
- #define F(x,y,z) (y ^ (z & (x ^ y)))
- P(A, B, C, D, 1, 5, 0xF61E2562);
- P(D, A, B, C, 6, 9, 0xC040B340);
- P(C, D, A, B, 11, 14, 0x265E5A51);
- P(B, C, D, A, 0, 20, 0xE9B6C7AA);
- P(A, B, C, D, 5, 5, 0xD62F105D);
- P(D, A, B, C, 10, 9, 0x02441453);
- P(C, D, A, B, 15, 14, 0xD8A1E681);
- P(B, C, D, A, 4, 20, 0xE7D3FBC8);
- P(A, B, C, D, 9, 5, 0x21E1CDE6);
- P(D, A, B, C, 14, 9, 0xC33707D6);
- P(C, D, A, B, 3, 14, 0xF4D50D87);
- P(B, C, D, A, 8, 20, 0x455A14ED);
- P(A, B, C, D, 13, 5, 0xA9E3E905);
- P(D, A, B, C, 2, 9, 0xFCEFA3F8);
- P(C, D, A, B, 7, 14, 0x676F02D9);
- P(B, C, D, A, 12, 20, 0x8D2A4C8A);
- #undef F
-
- /* third pass */
- #define F(x,y,z) (x ^ y ^ z)
- P(A, B, C, D, 5, 4, 0xFFFA3942);
- P(D, A, B, C, 8, 11, 0x8771F681);
- P(C, D, A, B, 11, 16, 0x6D9D6122);
- P(B, C, D, A, 14, 23, 0xFDE5380C);
- P(A, B, C, D, 1, 4, 0xA4BEEA44);
- P(D, A, B, C, 4, 11, 0x4BDECFA9);
- P(C, D, A, B, 7, 16, 0xF6BB4B60);
- P(B, C, D, A, 10, 23, 0xBEBFBC70);
- P(A, B, C, D, 13, 4, 0x289B7EC6);
- P(D, A, B, C, 0, 11, 0xEAA127FA);
- P(C, D, A, B, 3, 16, 0xD4EF3085);
- P(B, C, D, A, 6, 23, 0x04881D05);
- P(A, B, C, D, 9, 4, 0xD9D4D039);
- P(D, A, B, C, 12, 11, 0xE6DB99E5);
- P(C, D, A, B, 15, 16, 0x1FA27CF8);
- P(B, C, D, A, 2, 23, 0xC4AC5665);
- #undef F
-
- /* forth pass */
- #define F(x,y,z) (y ^ (x | ~z))
- P(A, B, C, D, 0, 6, 0xF4292244);
- P(D, A, B, C, 7, 10, 0x432AFF97);
- P(C, D, A, B, 14, 15, 0xAB9423A7);
- P(B, C, D, A, 5, 21, 0xFC93A039);
- P(A, B, C, D, 12, 6, 0x655B59C3);
- P(D, A, B, C, 3, 10, 0x8F0CCC92);
- P(C, D, A, B, 10, 15, 0xFFEFF47D);
- P(B, C, D, A, 1, 21, 0x85845DD1);
- P(A, B, C, D, 8, 6, 0x6FA87E4F);
- P(D, A, B, C, 15, 10, 0xFE2CE6E0);
- P(C, D, A, B, 6, 15, 0xA3014314);
- P(B, C, D, A, 13, 21, 0x4E0811A1);
- P(A, B, C, D, 4, 6, 0xF7537E82);
- P(D, A, B, C, 11, 10, 0xBD3AF235);
- P(C, D, A, B, 2, 15, 0x2AD7D2BB);
- P(B, C, D, A, 9, 21, 0xEB86D391);
- #undef F
- #undef P
- #undef S
-
- md5_context->state[0] += A;
- md5_context->state[1] += B;
- md5_context->state[2] += C;
- md5_context->state[3] += D;
-}
-
-static void
-md5_append(PurpleCipherContext *context, const guchar *data, size_t len) {
- struct MD5Context *md5_context = NULL;
- guint32 left = 0, fill = 0;
-
- g_return_if_fail(context != NULL);
-
- md5_context = purple_cipher_context_get_data(context);
- g_return_if_fail(md5_context != NULL);
-
- left = md5_context->total[0] & 0x3F;
- fill = 64 - left;
-
- md5_context->total[0] += len;
- md5_context->total[0] &= 0xFFFFFFFF;
-
- if(md5_context->total[0] < len)
- md5_context->total[1]++;
-
- if(left && len >= fill) {
- memcpy((md5_context->buffer + left), data, fill);
- md5_process(md5_context, md5_context->buffer);
- len -= fill;
- data += fill;
- left = 0;
- }
-
- while(len >= 64) {
- md5_process(md5_context, data);
- len -= 64;
- data += 64;
- }
-
- if(len) {
- memcpy((md5_context->buffer + left), data, len);
- }
-}
-
-static gboolean
-md5_digest(PurpleCipherContext *context, size_t in_len, guchar digest[16],
- size_t *out_len)
-{
- struct MD5Context *md5_context = NULL;
- guint32 last, pad;
- guint32 high, low;
- guchar message[8];
- guchar padding[64] = {
- 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
- };
-
- g_return_val_if_fail(in_len >= 16, FALSE);
-
- md5_context = purple_cipher_context_get_data(context);
-
- high = (md5_context->total[0] >> 29)
- | (md5_context->total[1] << 3);
- low = (md5_context->total[0] << 3);
-
- MD5_PUT_GUINT32(low, message, 0);
- MD5_PUT_GUINT32(high, message, 4);
-
- last = md5_context->total[0] & 0x3F;
- pad = (last < 56) ? (56 - last) : (120 - last);
-
- md5_append(context, padding, pad);
- md5_append(context, message, 8);
-
- MD5_PUT_GUINT32(md5_context->state[0], digest, 0);
- MD5_PUT_GUINT32(md5_context->state[1], digest, 4);
- MD5_PUT_GUINT32(md5_context->state[2], digest, 8);
- MD5_PUT_GUINT32(md5_context->state[3], digest, 12);
-
- if(out_len)
- *out_len = 16;
-
- return TRUE;
-}
-
-static size_t
-md5_get_block_size(PurpleCipherContext *context)
-{
- /* This does not change (in this case) */
- return MD5_HMAC_BLOCK_SIZE;
-}
-
-static PurpleCipherOps MD5Ops = {
- NULL, /* Set option */
- NULL, /* Get option */
- md5_init, /* init */
- md5_reset, /* reset */
- md5_uninit, /* uninit */
- NULL, /* set iv */
- md5_append, /* append */
- md5_digest, /* digest */
- NULL, /* encrypt */
- NULL, /* decrypt */
- NULL, /* set salt */
- NULL, /* get salt size */
- NULL, /* set key */
- NULL, /* get key size */
- NULL, /* set batch mode */
- NULL, /* get batch mode */
- md5_get_block_size, /* get block size */
- NULL /* set key with len */
-};
-
-/*******************************************************************************
- * MD4
- ******************************************************************************/
-#define MD4_DIGEST_SIZE 16
-#define MD4_HMAC_BLOCK_SIZE 64
-#define MD4_BLOCK_WORDS 16
-#define MD4_HASH_WORDS 4
-
-
-
-struct MD4_Context {
- guint32 hash[MD4_HASH_WORDS];
- guint32 block[MD4_BLOCK_WORDS];
- guint64 byte_count;
-};
-
-static inline guint32 lshift(guint32 x, unsigned int s)
-{
- x &= 0xFFFFFFFF;
- return ((x << s) & 0xFFFFFFFF) | (x >> (32 - s));
-}
-
-static inline guint32 F(guint32 x, guint32 y, guint32 z)
-{
- return (x & y) | ((~x) & z);
-}
-
-static inline guint32 G(guint32 x, guint32 y, guint32 z)
-{
- return (x & y) | (x & z) | (y & z);
-}
-
-static inline guint32 H(guint32 x, guint32 y, guint32 z)
-{
- return x ^ y ^ z;
-}
-
-#define ROUND1(a,b,c,d,k,s) (a = lshift(a + F(b,c,d) + k, s))
-#define ROUND2(a,b,c,d,k,s) (a = lshift(a + G(b,c,d) + k + (guint32)0x5A827999,s))
-#define ROUND3(a,b,c,d,k,s) (a = lshift(a + H(b,c,d) + k + (guint32)0x6ED9EBA1,s))
-
-static inline void le32_to_cpu_array(guint32 *buf, unsigned int words)
-{
- while (words--) {
- *buf=GUINT_FROM_LE(*buf);
- buf++;
- }
-}
-
-static inline void cpu_to_le32_array(guint32 *buf, unsigned int words)
-{
- while (words--) {
- *buf=GUINT_TO_LE(*buf);
- buf++;
- }
-}
-
-static void md4_transform(guint32 *hash, guint32 const *in)
-{
- guint32 a, b, c, d;
-
- a = hash[0];
- b = hash[1];
- c = hash[2];
- d = hash[3];
-
- ROUND1(a, b, c, d, in[0], 3);
- ROUND1(d, a, b, c, in[1], 7);
- ROUND1(c, d, a, b, in[2], 11);
- ROUND1(b, c, d, a, in[3], 19);
- ROUND1(a, b, c, d, in[4], 3);
- ROUND1(d, a, b, c, in[5], 7);
- ROUND1(c, d, a, b, in[6], 11);
- ROUND1(b, c, d, a, in[7], 19);
- ROUND1(a, b, c, d, in[8], 3);
- ROUND1(d, a, b, c, in[9], 7);
- ROUND1(c, d, a, b, in[10], 11);
- ROUND1(b, c, d, a, in[11], 19);
- ROUND1(a, b, c, d, in[12], 3);
- ROUND1(d, a, b, c, in[13], 7);
- ROUND1(c, d, a, b, in[14], 11);
- ROUND1(b, c, d, a, in[15], 19);
-
- ROUND2(a, b, c, d,in[ 0], 3);
- ROUND2(d, a, b, c, in[4], 5);
- ROUND2(c, d, a, b, in[8], 9);
- ROUND2(b, c, d, a, in[12], 13);
- ROUND2(a, b, c, d, in[1], 3);
- ROUND2(d, a, b, c, in[5], 5);
- ROUND2(c, d, a, b, in[9], 9);
- ROUND2(b, c, d, a, in[13], 13);
- ROUND2(a, b, c, d, in[2], 3);
- ROUND2(d, a, b, c, in[6], 5);
- ROUND2(c, d, a, b, in[10], 9);
- ROUND2(b, c, d, a, in[14], 13);
- ROUND2(a, b, c, d, in[3], 3);
- ROUND2(d, a, b, c, in[7], 5);
- ROUND2(c, d, a, b, in[11], 9);
- ROUND2(b, c, d, a, in[15], 13);
-
- ROUND3(a, b, c, d,in[ 0], 3);
- ROUND3(d, a, b, c, in[8], 9);
- ROUND3(c, d, a, b, in[4], 11);
- ROUND3(b, c, d, a, in[12], 15);
- ROUND3(a, b, c, d, in[2], 3);
- ROUND3(d, a, b, c, in[10], 9);
- ROUND3(c, d, a, b, in[6], 11);
- ROUND3(b, c, d, a, in[14], 15);
- ROUND3(a, b, c, d, in[1], 3);
- ROUND3(d, a, b, c, in[9], 9);
- ROUND3(c, d, a, b, in[5], 11);
- ROUND3(b, c, d, a, in[13], 15);
- ROUND3(a, b, c, d, in[3], 3);
- ROUND3(d, a, b, c, in[11], 9);
- ROUND3(c, d, a, b, in[7], 11);
- ROUND3(b, c, d, a, in[15], 15);
-
- hash[0] += a;
- hash[1] += b;
- hash[2] += c;
- hash[3] += d;
-}
-
-static inline void md4_transform_helper(struct MD4_Context *ctx)
-{
- le32_to_cpu_array(ctx->block, sizeof(ctx->block) / sizeof(guint32));
- md4_transform(ctx->hash, ctx->block);
-}
-
-static void
-md4_init(PurpleCipherContext *context, gpointer extra) {
- struct MD4_Context *mctx;
- mctx = g_new0(struct MD4_Context, 1);
- purple_cipher_context_set_data(context, mctx);
- purple_cipher_context_reset(context, extra);
-
- mctx->hash[0] = 0x67452301;
- mctx->hash[1] = 0xefcdab89;
- mctx->hash[2] = 0x98badcfe;
- mctx->hash[3] = 0x10325476;
- mctx->byte_count = 0;
-}
-
-static void
-md4_reset(PurpleCipherContext *context, gpointer extra) {
- struct MD4_Context *mctx;
-
- mctx = purple_cipher_context_get_data(context);
-
- mctx->hash[0] = 0x67452301;
- mctx->hash[1] = 0xefcdab89;
- mctx->hash[2] = 0x98badcfe;
- mctx->hash[3] = 0x10325476;
- mctx->byte_count = 0;
-}
-
-static void
-md4_append(PurpleCipherContext *context, const guchar *data, size_t len)
-{
- struct MD4_Context *mctx = purple_cipher_context_get_data(context);
- const guint32 avail = sizeof(mctx->block) - (mctx->byte_count & 0x3f);
-
- mctx->byte_count += len;
-
- if (avail > len) {
- memcpy((char *)mctx->block + (sizeof(mctx->block) - avail),
- data, len);
- return;
- }
-
- memcpy((char *)mctx->block + (sizeof(mctx->block) - avail),
- data, avail);
-
- md4_transform_helper(mctx);
- data += avail;
- len -= avail;
-
- while (len >= sizeof(mctx->block)) {
- memcpy(mctx->block, data, sizeof(mctx->block));
- md4_transform_helper(mctx);
- data += sizeof(mctx->block);
- len -= sizeof(mctx->block);
- }
-
- memcpy(mctx->block, data, len);
-}
-
-static gboolean
-md4_digest(PurpleCipherContext *context, size_t in_len, guchar *out,
- size_t *out_len)
-{
- struct MD4_Context *mctx = purple_cipher_context_get_data(context);
- const unsigned int offset = mctx->byte_count & 0x3f;
- char *p = (char *)mctx->block + offset;
- int padding = 56 - (offset + 1);
-
-
- if(in_len<16) return FALSE;
- if(out_len) *out_len = 16;
- *p++ = 0x80;
- if (padding < 0) {
- memset(p, 0x00, padding + sizeof (guint64));
- md4_transform_helper(mctx);
- p = (char *)mctx->block;
- padding = 56;
- }
-
- memset(p, 0, padding);
- mctx->block[14] = mctx->byte_count << 3;
- mctx->block[15] = mctx->byte_count >> 29;
- le32_to_cpu_array(mctx->block, (sizeof(mctx->block) -
- sizeof(guint64)) / sizeof(guint32));
- md4_transform(mctx->hash, mctx->block);
- cpu_to_le32_array(mctx->hash, sizeof(mctx->hash) / sizeof(guint32));
- memcpy(out, mctx->hash, sizeof(mctx->hash));
- memset(mctx, 0, sizeof(*mctx));
- return TRUE;
-}
-
-static void
-md4_uninit(PurpleCipherContext *context) {
- struct MD4_Context *md4_context;
-
- purple_cipher_context_reset(context, NULL);
-
- md4_context = purple_cipher_context_get_data(context);
- memset(md4_context, 0, sizeof(md4_context));
-
- g_free(md4_context);
- md4_context = NULL;
-}
-
-static size_t
-md4_get_block_size(PurpleCipherContext *context)
-{
- /* This does not change (in this case) */
- return MD4_HMAC_BLOCK_SIZE;
-}
-
-static PurpleCipherOps MD4Ops = {
- NULL, /* Set option */
- NULL, /* Get option */
- md4_init, /* init */
- md4_reset, /* reset */
- md4_uninit, /* uninit */
- NULL, /* set iv */
- md4_append, /* append */
- md4_digest, /* digest */
- NULL, /* encrypt */
- NULL, /* decrypt */
- NULL, /* set salt */
- NULL, /* get salt size */
- NULL, /* set key */
- NULL, /* get key size */
- NULL, /* set batch mode */
- NULL, /* get batch mode */
- md4_get_block_size, /* get block size */
- NULL /* set key with len */
-};
-
-/*******************************************************************************
- * HMAC
- ******************************************************************************/
-
-struct HMAC_Context {
- PurpleCipherContext *hash;
- char *name;
- int blocksize;
- guchar *opad;
-};
-
-static void
-hmac_init(PurpleCipherContext *context, gpointer extra)
-{
- struct HMAC_Context *hctx;
- hctx = g_new0(struct HMAC_Context, 1);
- purple_cipher_context_set_data(context, hctx);
- purple_cipher_context_reset(context, extra);
-}
-
-static void
-hmac_reset(PurpleCipherContext *context, gpointer extra)
-{
- struct HMAC_Context *hctx;
-
- hctx = purple_cipher_context_get_data(context);
-
- g_free(hctx->name);
- hctx->name = NULL;
- if (hctx->hash)
- purple_cipher_context_destroy(hctx->hash);
- hctx->hash = NULL;
- hctx->blocksize = 0;
- g_free(hctx->opad);
- hctx->opad = NULL;
-}
-
-static void
-hmac_set_opt(PurpleCipherContext *context, const gchar *name, void *value)
-{
- struct HMAC_Context *hctx;
-
- hctx = purple_cipher_context_get_data(context);
-
- if (!strcmp(name, "hash")) {
- g_free(hctx->name);
- if (hctx->hash)
- purple_cipher_context_destroy(hctx->hash);
- hctx->name = g_strdup((char*)value);
- hctx->hash = purple_cipher_context_new_by_name((char *)value, NULL);
- hctx->blocksize = purple_cipher_context_get_block_size(hctx->hash);
- }
-}
-
-static void *
-hmac_get_opt(PurpleCipherContext *context, const gchar *name)
-{
- struct HMAC_Context *hctx;
-
- hctx = purple_cipher_context_get_data(context);
-
- if (!strcmp(name, "hash")) {
- return hctx->name;
- }
-
- return NULL;
-}
-
-static void
-hmac_append(PurpleCipherContext *context, const guchar *data, size_t len)
-{
- struct HMAC_Context *hctx = purple_cipher_context_get_data(context);
-
- g_return_if_fail(hctx->hash != NULL);
-
- purple_cipher_context_append(hctx->hash, data, len);
-}
-
-static gboolean
-hmac_digest(PurpleCipherContext *context, size_t in_len, guchar *out, size_t *out_len)
-{
- struct HMAC_Context *hctx = purple_cipher_context_get_data(context);
- PurpleCipherContext *hash = hctx->hash;
- guchar *inner_hash;
- size_t hash_len;
- gboolean result;
-
- g_return_val_if_fail(hash != NULL, FALSE);
-
- inner_hash = g_malloc(100); /* TODO: Should be enough for now... */
- result = purple_cipher_context_digest(hash, 100, inner_hash, &hash_len);
-
- purple_cipher_context_reset(hash, NULL);
-
- purple_cipher_context_append(hash, hctx->opad, hctx->blocksize);
- purple_cipher_context_append(hash, inner_hash, hash_len);
-
- g_free(inner_hash);
-
- result = result && purple_cipher_context_digest(hash, in_len, out, out_len);
-
- return result;
-}
-
-static void
-hmac_uninit(PurpleCipherContext *context)
-{
- struct HMAC_Context *hctx;
-
- purple_cipher_context_reset(context, NULL);
-
- hctx = purple_cipher_context_get_data(context);
-
- g_free(hctx);
-}
-
-static void
-hmac_set_key_with_len(PurpleCipherContext *context, const guchar * key, size_t key_len)
-{
- struct HMAC_Context *hctx = purple_cipher_context_get_data(context);
- int blocksize, i;
- guchar *ipad;
- guchar *full_key;
-
- g_return_if_fail(hctx->hash != NULL);
-
- g_free(hctx->opad);
-
- blocksize = hctx->blocksize;
- ipad = g_malloc(blocksize);
- hctx->opad = g_malloc(blocksize);
-
- if (key_len > blocksize) {
- purple_cipher_context_reset(hctx->hash, NULL);
- purple_cipher_context_append(hctx->hash, key, key_len);
- full_key = g_malloc(100); /* TODO: Should be enough for now... */
- purple_cipher_context_digest(hctx->hash, 100, full_key, &key_len);
- } else
- full_key = g_memdup(key, key_len);
-
- if (key_len < blocksize) {
- full_key = g_realloc(full_key, blocksize);
- memset(full_key + key_len, 0, blocksize - key_len);
- }
-
- for(i = 0; i < blocksize; i++) {
- ipad[i] = 0x36 ^ full_key[i];
- hctx->opad[i] = 0x5c ^ full_key[i];
- }
-
- g_free(full_key);
-
- purple_cipher_context_reset(hctx->hash, NULL);
- purple_cipher_context_append(hctx->hash, ipad, blocksize);
- g_free(ipad);
-}
-
-static void
-hmac_set_key(PurpleCipherContext *context, const guchar * key)
-{
- hmac_set_key_with_len(context, key, strlen((char *)key));
-}
-
-static size_t
-hmac_get_block_size(PurpleCipherContext *context)
-{
- struct HMAC_Context *hctx = purple_cipher_context_get_data(context);
-
- return hctx->blocksize;
-}
-
-static PurpleCipherOps HMACOps = {
- hmac_set_opt, /* Set option */
- hmac_get_opt, /* Get option */
- hmac_init, /* init */
- hmac_reset, /* reset */
- hmac_uninit, /* uninit */
- NULL, /* set iv */
- hmac_append, /* append */
- hmac_digest, /* digest */
- NULL, /* encrypt */
- NULL, /* decrypt */
- NULL, /* set salt */
- NULL, /* get salt size */
- hmac_set_key, /* set key */
- NULL, /* get key size */
- NULL, /* set batch mode */
- NULL, /* get batch mode */
- hmac_get_block_size, /* get block size */
- hmac_set_key_with_len /* set key with len */
-};
-
/******************************************************************************
- * DES
+ * Globals
*****************************************************************************/
+static GObjectClass *parent_class = NULL;
-typedef struct _des_ctx
-{
- guint32 encrypt_subkeys[32];
- guint32 decrypt_subkeys[32];
-} des_ctx[1];
-
-/*
- * The s-box values are permuted according to the 'primitive function P'
- */
-static const guint32 sbox1[64] =
-{
- 0x00808200, 0x00000000, 0x00008000, 0x00808202, 0x00808002, 0x00008202, 0x00000002, 0x00008000,
- 0x00000200, 0x00808200, 0x00808202, 0x00000200, 0x00800202, 0x00808002, 0x00800000, 0x00000002,
- 0x00000202, 0x00800200, 0x00800200, 0x00008200, 0x00008200, 0x00808000, 0x00808000, 0x00800202,
- 0x00008002, 0x00800002, 0x00800002, 0x00008002, 0x00000000, 0x00000202, 0x00008202, 0x00800000,
- 0x00008000, 0x00808202, 0x00000002, 0x00808000, 0x00808200, 0x00800000, 0x00800000, 0x00000200,
- 0x00808002, 0x00008000, 0x00008200, 0x00800002, 0x00000200, 0x00000002, 0x00800202, 0x00008202,
- 0x00808202, 0x00008002, 0x00808000, 0x00800202, 0x00800002, 0x00000202, 0x00008202, 0x00808200,
- 0x00000202, 0x00800200, 0x00800200, 0x00000000, 0x00008002, 0x00008200, 0x00000000, 0x00808002
-};
-
-static const guint32 sbox2[64] =
-{
- 0x40084010, 0x40004000, 0x00004000, 0x00084010, 0x00080000, 0x00000010, 0x40080010, 0x40004010,
- 0x40000010, 0x40084010, 0x40084000, 0x40000000, 0x40004000, 0x00080000, 0x00000010, 0x40080010,
- 0x00084000, 0x00080010, 0x40004010, 0x00000000, 0x40000000, 0x00004000, 0x00084010, 0x40080000,
- 0x00080010, 0x40000010, 0x00000000, 0x00084000, 0x00004010, 0x40084000, 0x40080000, 0x00004010,
- 0x00000000, 0x00084010, 0x40080010, 0x00080000, 0x40004010, 0x40080000, 0x40084000, 0x00004000,
- 0x40080000, 0x40004000, 0x00000010, 0x40084010, 0x00084010, 0x00000010, 0x00004000, 0x40000000,
- 0x00004010, 0x40084000, 0x00080000, 0x40000010, 0x00080010, 0x40004010, 0x40000010, 0x00080010,
- 0x00084000, 0x00000000, 0x40004000, 0x00004010, 0x40000000, 0x40080010, 0x40084010, 0x00084000
-};
-
-static const guint32 sbox3[64] =
-{
- 0x00000104, 0x04010100, 0x00000000, 0x04010004, 0x04000100, 0x00000000, 0x00010104, 0x04000100,
- 0x00010004, 0x04000004, 0x04000004, 0x00010000, 0x04010104, 0x00010004, 0x04010000, 0x00000104,
- 0x04000000, 0x00000004, 0x04010100, 0x00000100, 0x00010100, 0x04010000, 0x04010004, 0x00010104,
- 0x04000104, 0x00010100, 0x00010000, 0x04000104, 0x00000004, 0x04010104, 0x00000100, 0x04000000,
- 0x04010100, 0x04000000, 0x00010004, 0x00000104, 0x00010000, 0x04010100, 0x04000100, 0x00000000,
- 0x00000100, 0x00010004, 0x04010104, 0x04000100, 0x04000004, 0x00000100, 0x00000000, 0x04010004,
- 0x04000104, 0x00010000, 0x04000000, 0x04010104, 0x00000004, 0x00010104, 0x00010100, 0x04000004,
- 0x04010000, 0x04000104, 0x00000104, 0x04010000, 0x00010104, 0x00000004, 0x04010004, 0x00010100
-};
-
-static const guint32 sbox4[64] =
-{
- 0x80401000, 0x80001040, 0x80001040, 0x00000040, 0x00401040, 0x80400040, 0x80400000, 0x80001000,
- 0x00000000, 0x00401000, 0x00401000, 0x80401040, 0x80000040, 0x00000000, 0x00400040, 0x80400000,
- 0x80000000, 0x00001000, 0x00400000, 0x80401000, 0x00000040, 0x00400000, 0x80001000, 0x00001040,
- 0x80400040, 0x80000000, 0x00001040, 0x00400040, 0x00001000, 0x00401040, 0x80401040, 0x80000040,
- 0x00400040, 0x80400000, 0x00401000, 0x80401040, 0x80000040, 0x00000000, 0x00000000, 0x00401000,
- 0x00001040, 0x00400040, 0x80400040, 0x80000000, 0x80401000, 0x80001040, 0x80001040, 0x00000040,
- 0x80401040, 0x80000040, 0x80000000, 0x00001000, 0x80400000, 0x80001000, 0x00401040, 0x80400040,
- 0x80001000, 0x00001040, 0x00400000, 0x80401000, 0x00000040, 0x00400000, 0x00001000, 0x00401040
-};
-
-static const guint32 sbox5[64] =
-{
- 0x00000080, 0x01040080, 0x01040000, 0x21000080, 0x00040000, 0x00000080, 0x20000000, 0x01040000,
- 0x20040080, 0x00040000, 0x01000080, 0x20040080, 0x21000080, 0x21040000, 0x00040080, 0x20000000,
- 0x01000000, 0x20040000, 0x20040000, 0x00000000, 0x20000080, 0x21040080, 0x21040080, 0x01000080,
- 0x21040000, 0x20000080, 0x00000000, 0x21000000, 0x01040080, 0x01000000, 0x21000000, 0x00040080,
- 0x00040000, 0x21000080, 0x00000080, 0x01000000, 0x20000000, 0x01040000, 0x21000080, 0x20040080,
- 0x01000080, 0x20000000, 0x21040000, 0x01040080, 0x20040080, 0x00000080, 0x01000000, 0x21040000,
- 0x21040080, 0x00040080, 0x21000000, 0x21040080, 0x01040000, 0x00000000, 0x20040000, 0x21000000,
- 0x00040080, 0x01000080, 0x20000080, 0x00040000, 0x00000000, 0x20040000, 0x01040080, 0x20000080
-};
-
-static const guint32 sbox6[64] =
-{
- 0x10000008, 0x10200000, 0x00002000, 0x10202008, 0x10200000, 0x00000008, 0x10202008, 0x00200000,
- 0x10002000, 0x00202008, 0x00200000, 0x10000008, 0x00200008, 0x10002000, 0x10000000, 0x00002008,
- 0x00000000, 0x00200008, 0x10002008, 0x00002000, 0x00202000, 0x10002008, 0x00000008, 0x10200008,
- 0x10200008, 0x00000000, 0x00202008, 0x10202000, 0x00002008, 0x00202000, 0x10202000, 0x10000000,
- 0x10002000, 0x00000008, 0x10200008, 0x00202000, 0x10202008, 0x00200000, 0x00002008, 0x10000008,
- 0x00200000, 0x10002000, 0x10000000, 0x00002008, 0x10000008, 0x10202008, 0x00202000, 0x10200000,
- 0x00202008, 0x10202000, 0x00000000, 0x10200008, 0x00000008, 0x00002000, 0x10200000, 0x00202008,
- 0x00002000, 0x00200008, 0x10002008, 0x00000000, 0x10202000, 0x10000000, 0x00200008, 0x10002008
-};
-
-static const guint32 sbox7[64] =
-{
- 0x00100000, 0x02100001, 0x02000401, 0x00000000, 0x00000400, 0x02000401, 0x00100401, 0x02100400,
- 0x02100401, 0x00100000, 0x00000000, 0x02000001, 0x00000001, 0x02000000, 0x02100001, 0x00000401,
- 0x02000400, 0x00100401, 0x00100001, 0x02000400, 0x02000001, 0x02100000, 0x02100400, 0x00100001,
- 0x02100000, 0x00000400, 0x00000401, 0x02100401, 0x00100400, 0x00000001, 0x02000000, 0x00100400,
- 0x02000000, 0x00100400, 0x00100000, 0x02000401, 0x02000401, 0x02100001, 0x02100001, 0x00000001,
- 0x00100001, 0x02000000, 0x02000400, 0x00100000, 0x02100400, 0x00000401, 0x00100401, 0x02100400,
- 0x00000401, 0x02000001, 0x02100401, 0x02100000, 0x00100400, 0x00000000, 0x00000001, 0x02100401,
- 0x00000000, 0x00100401, 0x02100000, 0x00000400, 0x02000001, 0x02000400, 0x00000400, 0x00100001
-};
-
-static const guint32 sbox8[64] =
-{
- 0x08000820, 0x00000800, 0x00020000, 0x08020820, 0x08000000, 0x08000820, 0x00000020, 0x08000000,
- 0x00020020, 0x08020000, 0x08020820, 0x00020800, 0x08020800, 0x00020820, 0x00000800, 0x00000020,
- 0x08020000, 0x08000020, 0x08000800, 0x00000820, 0x00020800, 0x00020020, 0x08020020, 0x08020800,
- 0x00000820, 0x00000000, 0x00000000, 0x08020020, 0x08000020, 0x08000800, 0x00020820, 0x00020000,
- 0x00020820, 0x00020000, 0x08020800, 0x00000800, 0x00000020, 0x08020020, 0x00000800, 0x00020820,
- 0x08000800, 0x00000020, 0x08000020, 0x08020000, 0x08020020, 0x08000000, 0x00020000, 0x08000820,
- 0x00000000, 0x08020820, 0x00020020, 0x08000020, 0x08020000, 0x08000800, 0x08000820, 0x00000000,
- 0x08020820, 0x00020800, 0x00020800, 0x00000820, 0x00000820, 0x00020020, 0x08000000, 0x08020800
-};
-
-
-
-/*
- * * These two tables are part of the 'permuted choice 1' function.
- * * In this implementation several speed improvements are done.
- * */
-static const guint32 leftkey_swap[16] =
-{
- 0x00000000, 0x00000001, 0x00000100, 0x00000101,
- 0x00010000, 0x00010001, 0x00010100, 0x00010101,
- 0x01000000, 0x01000001, 0x01000100, 0x01000101,
- 0x01010000, 0x01010001, 0x01010100, 0x01010101
-};
-
-static const guint32 rightkey_swap[16] =
-{
- 0x00000000, 0x01000000, 0x00010000, 0x01010000,
- 0x00000100, 0x01000100, 0x00010100, 0x01010100,
- 0x00000001, 0x01000001, 0x00010001, 0x01010001,
- 0x00000101, 0x01000101, 0x00010101, 0x01010101,
-};
-
-
-
-/*
- * Numbers of left shifts per round for encryption subkey schedule
- * To calculate the decryption key scheduling we just reverse the
- * ordering of the subkeys so we can omit the table for decryption
- * subkey schedule.
- */
-static const guint8 encrypt_rotate_tab[16] =
-{
- 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1
-};
-
-/*
- * Macro to swap bits across two words
- **/
-#define DO_PERMUTATION(a, temp, b, offset, mask) \
- temp = ((a>>offset) ^ b) & mask; \
-b ^= temp; \
-a ^= temp<<offset;
-
-
-/*
- * This performs the 'initial permutation' for the data to be encrypted or decrypted
- **/
-#define INITIAL_PERMUTATION(left, temp, right) \
- DO_PERMUTATION(left, temp, right, 4, 0x0f0f0f0f) \
-DO_PERMUTATION(left, temp, right, 16, 0x0000ffff) \
-DO_PERMUTATION(right, temp, left, 2, 0x33333333) \
-DO_PERMUTATION(right, temp, left, 8, 0x00ff00ff) \
-DO_PERMUTATION(left, temp, right, 1, 0x55555555)
-
-
-/*
- * The 'inverse initial permutation'
- **/
-#define FINAL_PERMUTATION(left, temp, right) \
- DO_PERMUTATION(left, temp, right, 1, 0x55555555) \
-DO_PERMUTATION(right, temp, left, 8, 0x00ff00ff) \
-DO_PERMUTATION(right, temp, left, 2, 0x33333333) \
-DO_PERMUTATION(left, temp, right, 16, 0x0000ffff) \
-DO_PERMUTATION(left, temp, right, 4, 0x0f0f0f0f)
-
-
-/*
- * A full DES round including 'expansion function', 'sbox substitution'
- * and 'primitive function P' but without swapping the left and right word.
- **/
-#define DES_ROUND(from, to, work, subkey) \
- work = ((from<<1) | (from>>31)) ^ *subkey++; \
-to ^= sbox8[ work & 0x3f ]; \
-to ^= sbox6[ (work>>8) & 0x3f ]; \
-to ^= sbox4[ (work>>16) & 0x3f ]; \
-to ^= sbox2[ (work>>24) & 0x3f ]; \
-work = ((from>>3) | (from<<29)) ^ *subkey++; \
-to ^= sbox7[ work & 0x3f ]; \
-to ^= sbox5[ (work>>8) & 0x3f ]; \
-to ^= sbox3[ (work>>16) & 0x3f ]; \
-to ^= sbox1[ (work>>24) & 0x3f ];
-
-
-/*
- * Macros to convert 8 bytes from/to 32bit words
- **/
-#define READ_64BIT_DATA(data, left, right) \
- left = (data[0] << 24) | (data[1] << 16) | (data[2] << 8) | data[3]; \
-right = (data[4] << 24) | (data[5] << 16) | (data[6] << 8) | data[7];
-
-#define WRITE_64BIT_DATA(data, left, right) \
- data[0] = (left >> 24) &0xff; data[1] = (left >> 16) &0xff; \
-data[2] = (left >> 8) &0xff; data[3] = left &0xff; \
-data[4] = (right >> 24) &0xff; data[5] = (right >> 16) &0xff; \
-data[6] = (right >> 8) &0xff; data[7] = right &0xff;
-
-
-
-
-
-
-/*
- * des_key_schedule(): Calculate 16 subkeys pairs (even/odd) for
- * 16 encryption rounds.
- * To calculate subkeys for decryption the caller
- * have to reorder the generated subkeys.
- *
- * rawkey: 8 Bytes of key data
- * subkey: Array of at least 32 guint32s. Will be filled
- * with calculated subkeys.
- *
- **/
-static void
-des_key_schedule (const guint8 * rawkey, guint32 * subkey)
-{
- guint32 left, right, work;
- int round;
-
- READ_64BIT_DATA (rawkey, left, right)
-
- DO_PERMUTATION (right, work, left, 4, 0x0f0f0f0f)
- DO_PERMUTATION (right, work, left, 0, 0x10101010)
-
- left = (leftkey_swap[(left >> 0) & 0xf] << 3) | (leftkey_swap[(left >> 8) & 0xf] << 2)
- | (leftkey_swap[(left >> 16) & 0xf] << 1) | (leftkey_swap[(left >> 24) & 0xf])
- | (leftkey_swap[(left >> 5) & 0xf] << 7) | (leftkey_swap[(left >> 13) & 0xf] << 6)
- | (leftkey_swap[(left >> 21) & 0xf] << 5) | (leftkey_swap[(left >> 29) & 0xf] << 4);
-
- left &= 0x0fffffff;
-
- right = (rightkey_swap[(right >> 1) & 0xf] << 3) | (rightkey_swap[(right >> 9) & 0xf] << 2)
- | (rightkey_swap[(right >> 17) & 0xf] << 1) | (rightkey_swap[(right >> 25) & 0xf])
- | (rightkey_swap[(right >> 4) & 0xf] << 7) | (rightkey_swap[(right >> 12) & 0xf] << 6)
- | (rightkey_swap[(right >> 20) & 0xf] << 5) | (rightkey_swap[(right >> 28) & 0xf] << 4);
-
- right &= 0x0fffffff;
-
- for (round = 0; round < 16; ++round)
- {
- left = ((left << encrypt_rotate_tab[round]) | (left >> (28 - encrypt_rotate_tab[round]))) & 0x0fffffff;
- right = ((right << encrypt_rotate_tab[round]) | (right >> (28 - encrypt_rotate_tab[round]))) & 0x0fffffff;
-
- *subkey++ = ((left << 4) & 0x24000000)
- | ((left << 28) & 0x10000000)
- | ((left << 14) & 0x08000000)
- | ((left << 18) & 0x02080000)
- | ((left << 6) & 0x01000000)
- | ((left << 9) & 0x00200000)
- | ((left >> 1) & 0x00100000)
- | ((left << 10) & 0x00040000)
- | ((left << 2) & 0x00020000)
- | ((left >> 10) & 0x00010000)
- | ((right >> 13) & 0x00002000)
- | ((right >> 4) & 0x00001000)
- | ((right << 6) & 0x00000800)
- | ((right >> 1) & 0x00000400)
- | ((right >> 14) & 0x00000200)
- | (right & 0x00000100)
- | ((right >> 5) & 0x00000020)
- | ((right >> 10) & 0x00000010)
- | ((right >> 3) & 0x00000008)
- | ((right >> 18) & 0x00000004)
- | ((right >> 26) & 0x00000002)
- | ((right >> 24) & 0x00000001);
-
- *subkey++ = ((left << 15) & 0x20000000)
- | ((left << 17) & 0x10000000)
- | ((left << 10) & 0x08000000)
- | ((left << 22) & 0x04000000)
- | ((left >> 2) & 0x02000000)
- | ((left << 1) & 0x01000000)
- | ((left << 16) & 0x00200000)
- | ((left << 11) & 0x00100000)
- | ((left << 3) & 0x00080000)
- | ((left >> 6) & 0x00040000)
- | ((left << 15) & 0x00020000)
- | ((left >> 4) & 0x00010000)
- | ((right >> 2) & 0x00002000)
- | ((right << 8) & 0x00001000)
- | ((right >> 14) & 0x00000808)
- | ((right >> 9) & 0x00000400)
- | ((right) & 0x00000200)
- | ((right << 7) & 0x00000100)
- | ((right >> 7) & 0x00000020)
- | ((right >> 3) & 0x00000011)
- | ((right << 2) & 0x00000004)
- | ((right >> 21) & 0x00000002);
- }
-}
-
-
-
-/*
- * Fill a DES context with subkeys calculated from a 64bit key.
- * Does not check parity bits, but simply ignore them.
- * Does not check for weak keys.
- **/
-static void
-des_set_key (PurpleCipherContext *context, const guchar * key)
-{
- struct _des_ctx *ctx = purple_cipher_context_get_data(context);
- int i;
-
- des_key_schedule (key, ctx->encrypt_subkeys);
-
- for(i=0; i<32; i+=2)
- {
- ctx->decrypt_subkeys[i] = ctx->encrypt_subkeys[30-i];
- ctx->decrypt_subkeys[i+1] = ctx->encrypt_subkeys[31-i];
- }
-}
-
-
-
-/*
- * Electronic Codebook Mode DES encryption/decryption of data according
- * to 'mode'.
- **/
-static int
-des_ecb_crypt (struct _des_ctx *ctx, const guint8 * from, guint8 * to, int mode)
-{
- guint32 left, right, work;
- guint32 *keys;
-
- keys = mode ? ctx->decrypt_subkeys : ctx->encrypt_subkeys;
-
- READ_64BIT_DATA (from, left, right)
- INITIAL_PERMUTATION (left, work, right)
-
- DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
- DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
- DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
- DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
- DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
- DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
- DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
- DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
-
- FINAL_PERMUTATION (right, work, left)
- WRITE_64BIT_DATA (to, right, left)
-
- return 0;
-}
-
-static gint
-des_encrypt(PurpleCipherContext *context, const guchar data[],
- size_t len, guchar output[], size_t *outlen) {
- int offset = 0;
- int i = 0;
- int tmp;
- guint8 buf[8] = {0,0,0,0,0,0,0,0};
- while(offset+8<=len) {
- des_ecb_crypt(purple_cipher_context_get_data(context),
- data+offset,
- output+offset,
- 0);
- offset+=8;
- }
- *outlen = len;
- if(offset<len) {
- *outlen += len - offset;
- tmp = offset;
- while(tmp<len) {
- buf[i++] = data[tmp];
- tmp++;
- }
- des_ecb_crypt(purple_cipher_context_get_data(context),
- buf,
- output+offset,
- 0);
- }
- return 0;
-}
-
-static gint
-des_decrypt(PurpleCipherContext *context, const guchar data[],
- size_t len, guchar output[], size_t *outlen) {
- int offset = 0;
- int i = 0;
- int tmp;
- guint8 buf[8] = {0,0,0,0,0,0,0,0};
- while(offset+8<=len) {
- des_ecb_crypt(purple_cipher_context_get_data(context),
- data+offset,
- output+offset,
- 1);
- offset+=8;
- }
- *outlen = len;
- if(offset<len) {
- *outlen += len - offset;
- tmp = offset;
- while(tmp<len) {
- buf[i++] = data[tmp];
- tmp++;
- }
- des_ecb_crypt(purple_cipher_context_get_data(context),
- buf,
- output+offset,
- 1);
- }
- return 0;
-}
-
-static void
-des_init(PurpleCipherContext *context, gpointer extra) {
- struct _des_ctx *mctx;
- mctx = g_new0(struct _des_ctx, 1);
- purple_cipher_context_set_data(context, mctx);
-}
-
-static void
-des_uninit(PurpleCipherContext *context) {
- struct _des_ctx *des_context;
-
- des_context = purple_cipher_context_get_data(context);
- memset(des_context, 0, sizeof(des_context));
-
- g_free(des_context);
- des_context = NULL;
-}
-
-static PurpleCipherOps DESOps = {
- NULL, /* Set option */
- NULL, /* Get option */
- des_init, /* init */
- NULL, /* reset */
- des_uninit, /* uninit */
- NULL, /* set iv */
- NULL, /* append */
- NULL, /* digest */
- des_encrypt, /* encrypt */
- des_decrypt, /* decrypt */
- NULL, /* set salt */
- NULL, /* get salt size */
- des_set_key, /* set key */
- NULL, /* get key size */
- NULL, /* set batch mode */
- NULL, /* get batch mode */
- NULL, /* get block size */
- NULL /* set key with len */
-};
-
/******************************************************************************
- * Triple-DES
+ * Object Stuff
*****************************************************************************/
-
-typedef struct _des3_ctx
-{
- PurpleCipherBatchMode mode;
- guchar iv[8];
- /* First key for encryption */
- struct _des_ctx key1;
- /* Second key for decryption */
- struct _des_ctx key2;
- /* Third key for encryption */
- struct _des_ctx key3;
-} des3_ctx[1];
-
-/*
- * Fill a DES3 context with subkeys calculated from 3 64bit key.
- * Does not check parity bits, but simply ignore them.
- * Does not check for weak keys.
- **/
static void
-des3_set_key(PurpleCipherContext *context, const guchar * key)
-{
- struct _des3_ctx *ctx = purple_cipher_context_get_data(context);
- int i;
-
- des_key_schedule (key + 0, ctx->key1.encrypt_subkeys);
- des_key_schedule (key + 8, ctx->key2.encrypt_subkeys);
- des_key_schedule (key + 16, ctx->key3.encrypt_subkeys);
-
- for (i = 0; i < 32; i += 2)
- {
- ctx->key1.decrypt_subkeys[i] = ctx->key1.encrypt_subkeys[30-i];
- ctx->key1.decrypt_subkeys[i+1] = ctx->key1.encrypt_subkeys[31-i];
- ctx->key2.decrypt_subkeys[i] = ctx->key2.encrypt_subkeys[30-i];
- ctx->key2.decrypt_subkeys[i+1] = ctx->key2.encrypt_subkeys[31-i];
- ctx->key3.decrypt_subkeys[i] = ctx->key3.encrypt_subkeys[30-i];
- ctx->key3.decrypt_subkeys[i+1] = ctx->key3.encrypt_subkeys[31-i];
- }
+purple_cipher_class_init(PurpleCipherClass *klass) {
+ parent_class = g_type_class_peek_parent(klass);
}
-static gint
-des3_ecb_encrypt(struct _des3_ctx *ctx, const guchar data[],
- size_t len, guchar output[], size_t *outlen)
-{
- int offset = 0;
- int i = 0;
- int tmp;
- guint8 buf[8] = {0,0,0,0,0,0,0,0};
- while (offset + 8 <= len) {
- des_ecb_crypt(&ctx->key1,
- data+offset,
- output+offset,
- 0);
- des_ecb_crypt(&ctx->key2,
- output+offset,
- buf,
- 1);
- des_ecb_crypt(&ctx->key3,
- buf,
- output+offset,
- 0);
- offset += 8;
- }
- *outlen = len;
- if (offset < len) {
- *outlen += len - offset;
- tmp = offset;
- memset(buf, 0, 8);
- while (tmp < len) {
- buf[i++] = data[tmp];
- tmp++;
- }
- des_ecb_crypt(&ctx->key1,
- buf,
- output+offset,
- 0);
- des_ecb_crypt(&ctx->key2,
- output+offset,
- buf,
- 1);
- des_ecb_crypt(&ctx->key3,
- buf,
- output+offset,
- 0);
- }
- return 0;
-}
-
-static gint
-des3_cbc_encrypt(struct _des3_ctx *ctx, const guchar data[],
- size_t len, guchar output[], size_t *outlen)
-{
- int offset = 0;
- int i = 0;
- int tmp;
- guint8 buf[8];
- memcpy(buf, ctx->iv, 8);
- while (offset + 8 <= len) {
- for (i = 0; i < 8; i++)
- buf[i] ^= data[offset + i];
- des_ecb_crypt(&ctx->key1,
- buf,
- output+offset,
- 0);
- des_ecb_crypt(&ctx->key2,
- output+offset,
- buf,
- 1);
- des_ecb_crypt(&ctx->key3,
- buf,
- output+offset,
- 0);
- memcpy(buf, output+offset, 8);
- offset += 8;
- }
- *outlen = len;
- if (offset < len) {
- *outlen += len - offset;
- tmp = offset;
- i = 0;
- while (tmp < len) {
- buf[i++] ^= data[tmp];
- tmp++;
- }
- des_ecb_crypt(&ctx->key1,
- buf,
- output+offset,
- 0);
- des_ecb_crypt(&ctx->key2,
- output+offset,
- buf,
- 1);
- des_ecb_crypt(&ctx->key3,
- buf,
- output+offset,
- 0);
- }
- return 0;
-}
-
-static gint
-des3_encrypt(PurpleCipherContext *context, const guchar data[],
- size_t len, guchar output[], size_t *outlen)
-{
- struct _des3_ctx *ctx = purple_cipher_context_get_data(context);
-
- if (ctx->mode == PURPLE_CIPHER_BATCH_MODE_ECB) {
- return des3_ecb_encrypt(ctx, data, len, output, outlen);
- } else if (ctx->mode == PURPLE_CIPHER_BATCH_MODE_CBC) {
- return des3_cbc_encrypt(ctx, data, len, output, outlen);
- } else {
- g_return_val_if_reached(0);
- }
-
- return 0;
-}
-
-static gint
-des3_ecb_decrypt(struct _des3_ctx *ctx, const guchar data[],
- size_t len, guchar output[], size_t *outlen)
-{
- int offset = 0;
- int i = 0;
- int tmp;
- guint8 buf[8] = {0,0,0,0,0,0,0,0};
- while (offset + 8 <= len) {
- /* NOTE: Apply key in reverse */
- des_ecb_crypt(&ctx->key3,
- data+offset,
- output+offset,
- 1);
- des_ecb_crypt(&ctx->key2,
- output+offset,
- buf,
- 0);
- des_ecb_crypt(&ctx->key1,
- buf,
- output+offset,
- 1);
- offset+=8;
- }
- *outlen = len;
- if (offset < len) {
- *outlen += len - offset;
- tmp = offset;
- memset(buf, 0, 8);
- while (tmp < len) {
- buf[i++] = data[tmp];
- tmp++;
- }
- des_ecb_crypt(&ctx->key3,
- buf,
- output+offset,
- 1);
- des_ecb_crypt(&ctx->key2,
- output+offset,
- buf,
- 0);
- des_ecb_crypt(&ctx->key1,
- buf,
- output+offset,
- 1);
- }
- return 0;
-}
-
-static gint
-des3_cbc_decrypt(struct _des3_ctx *ctx, const guchar data[],
- size_t len, guchar output[], size_t *outlen)
-{
- int offset = 0;
- int i = 0;
- int tmp;
- guint8 buf[8] = {0,0,0,0,0,0,0,0};
- guint8 link[8];
- memcpy(link, ctx->iv, 8);
- while (offset + 8 <= len) {
- des_ecb_crypt(&ctx->key3,
- data+offset,
- output+offset,
- 1);
- des_ecb_crypt(&ctx->key2,
- output+offset,
- buf,
- 0);
- des_ecb_crypt(&ctx->key1,
- buf,
- output+offset,
- 1);
- for (i = 0; i < 8; i++)
- output[offset + i] ^= link[i];
- memcpy(link, data + offset, 8);
- offset+=8;
- }
- *outlen = len;
- if(offset<len) {
- *outlen += len - offset;
- tmp = offset;
- memset(buf, 0, 8);
- i = 0;
- while(tmp<len) {
- buf[i++] = data[tmp];
- tmp++;
- }
- des_ecb_crypt(&ctx->key3,
- buf,
- output+offset,
- 1);
- des_ecb_crypt(&ctx->key2,
- output+offset,
- buf,
- 0);
- des_ecb_crypt(&ctx->key1,
- buf,
- output+offset,
- 1);
- for (i = 0; i < 8; i++)
- output[offset + i] ^= link[i];
- }
- return 0;
-}
-
-static gint
-des3_decrypt(PurpleCipherContext *context, const guchar data[],
- size_t len, guchar output[], size_t *outlen)
-{
- struct _des3_ctx *ctx = purple_cipher_context_get_data(context);
-
- if (ctx->mode == PURPLE_CIPHER_BATCH_MODE_ECB) {
- return des3_ecb_decrypt(ctx, data, len, output, outlen);
- } else if (ctx->mode == PURPLE_CIPHER_BATCH_MODE_CBC) {
- return des3_cbc_decrypt(ctx, data, len, output, outlen);
- } else {
- g_return_val_if_reached(0);
- }
-
- return 0;
-}
-
-static void
-des3_set_batch(PurpleCipherContext *context, PurpleCipherBatchMode mode)
-{
- struct _des3_ctx *ctx = purple_cipher_context_get_data(context);
-
- ctx->mode = mode;
-}
-
-static PurpleCipherBatchMode
-des3_get_batch(PurpleCipherContext *context)
-{
- struct _des3_ctx *ctx = purple_cipher_context_get_data(context);
-
- return ctx->mode;
-}
-
-static void
-des3_set_iv(PurpleCipherContext *context, guchar *iv, size_t len)
-{
- struct _des3_ctx *ctx;
-
- g_return_if_fail(len == 8);
-
- ctx = purple_cipher_context_get_data(context);
-
- memcpy(ctx->iv, iv, len);
-}
-
-static void
-des3_init(PurpleCipherContext *context, gpointer extra)
-{
- struct _des3_ctx *mctx;
- mctx = g_new0(struct _des3_ctx, 1);
- purple_cipher_context_set_data(context, mctx);
-}
-
-static void
-des3_uninit(PurpleCipherContext *context)
-{
- struct _des3_ctx *des3_context;
-
- des3_context = purple_cipher_context_get_data(context);
- memset(des3_context, 0, sizeof(des3_context));
-
- g_free(des3_context);
- des3_context = NULL;
-}
-
-static PurpleCipherOps DES3Ops = {
- NULL, /* Set option */
- NULL, /* Get option */
- des3_init, /* init */
- NULL, /* reset */
- des3_uninit, /* uninit */
- des3_set_iv, /* set iv */
- NULL, /* append */
- NULL, /* digest */
- des3_encrypt, /* encrypt */
- des3_decrypt, /* decrypt */
- NULL, /* set salt */
- NULL, /* get salt size */
- des3_set_key, /* set key */
- NULL, /* get key size */
- des3_set_batch, /* set batch mode */
- des3_get_batch, /* get batch mode */
- NULL, /* get block size */
- NULL /* set key with len */
-};
-
-/*******************************************************************************
- * SHA-1
- ******************************************************************************/
-#define SHA1_HMAC_BLOCK_SIZE 64
-#define SHA1_ROTL(X,n) ((((X) << (n)) | ((X) >> (32-(n)))) & 0xFFFFFFFF)
-
-struct SHA1Context {
- guint32 H[5];
- guint32 W[80];
-
- gint lenW;
-
- guint32 sizeHi;
- guint32 sizeLo;
-};
-
-static void
-sha1_hash_block(struct SHA1Context *sha1_ctx) {
- gint i;
- guint32 A, B, C, D, E, T;
-
- for(i = 16; i < 80; i++) {
- sha1_ctx->W[i] = SHA1_ROTL(sha1_ctx->W[i - 3] ^
- sha1_ctx->W[i - 8] ^
- sha1_ctx->W[i - 14] ^
- sha1_ctx->W[i - 16], 1);
- }
-
- A = sha1_ctx->H[0];
- B = sha1_ctx->H[1];
- C = sha1_ctx->H[2];
- D = sha1_ctx->H[3];
- E = sha1_ctx->H[4];
-
- for(i = 0; i < 20; i++) {
- T = (SHA1_ROTL(A, 5) + (((C ^ D) & B) ^ D) + E + sha1_ctx->W[i] + 0x5A827999) & 0xFFFFFFFF;
- E = D;
- D = C;
- C = SHA1_ROTL(B, 30);
- B = A;
- A = T;
- }
-
- for(i = 20; i < 40; i++) {
- T = (SHA1_ROTL(A, 5) + (B ^ C ^ D) + E + sha1_ctx->W[i] + 0x6ED9EBA1) & 0xFFFFFFFF;
- E = D;
- D = C;
- C = SHA1_ROTL(B, 30);
- B = A;
- A = T;
- }
-
- for(i = 40; i < 60; i++) {
- T = (SHA1_ROTL(A, 5) + ((B & C) | (D & (B | C))) + E + sha1_ctx->W[i] + 0x8F1BBCDC) & 0xFFFFFFFF;
- E = D;
- D = C;
- C = SHA1_ROTL(B, 30);
- B = A;
- A = T;
- }
-
- for(i = 60; i < 80; i++) {
- T = (SHA1_ROTL(A, 5) + (B ^ C ^ D) + E + sha1_ctx->W[i] + 0xCA62C1D6) & 0xFFFFFFFF;
- E = D;
- D = C;
- C = SHA1_ROTL(B, 30);
- B = A;
- A = T;
- }
-
- sha1_ctx->H[0] += A;
- sha1_ctx->H[1] += B;
- sha1_ctx->H[2] += C;
- sha1_ctx->H[3] += D;
- sha1_ctx->H[4] += E;
-}
-
-static void
-sha1_set_opt(PurpleCipherContext *context, const gchar *name, void *value) {
- struct SHA1Context *ctx;
-
- ctx = purple_cipher_context_get_data(context);
-
- if(!strcmp(name, "sizeHi")) {
- ctx->sizeHi = GPOINTER_TO_INT(value);
- } else if(!strcmp(name, "sizeLo")) {
- ctx->sizeLo = GPOINTER_TO_INT(value);
- } else if(!strcmp(name, "lenW")) {
- ctx->lenW = GPOINTER_TO_INT(value);
- }
-}
-
-static void *
-sha1_get_opt(PurpleCipherContext *context, const gchar *name) {
- struct SHA1Context *ctx;
-
- ctx = purple_cipher_context_get_data(context);
-
- if(!strcmp(name, "sizeHi")) {
- return GINT_TO_POINTER(ctx->sizeHi);
- } else if(!strcmp(name, "sizeLo")) {
- return GINT_TO_POINTER(ctx->sizeLo);
- } else if(!strcmp(name, "lenW")) {
- return GINT_TO_POINTER(ctx->lenW);
- }
-
- return NULL;
-}
-
-static void
-sha1_init(PurpleCipherContext *context, void *extra) {
- struct SHA1Context *sha1_ctx;
-
- sha1_ctx = g_new0(struct SHA1Context, 1);
-
- purple_cipher_context_set_data(context, sha1_ctx);
-
- purple_cipher_context_reset(context, extra);
-}
-
-static void
-sha1_reset(PurpleCipherContext *context, void *extra) {
- struct SHA1Context *sha1_ctx;
- gint i;
-
- sha1_ctx = purple_cipher_context_get_data(context);
-
- g_return_if_fail(sha1_ctx);
-
- sha1_ctx->lenW = 0;
- sha1_ctx->sizeHi = 0;
- sha1_ctx->sizeLo = 0;
-
- sha1_ctx->H[0] = 0x67452301;
- sha1_ctx->H[1] = 0xEFCDAB89;
- sha1_ctx->H[2] = 0x98BADCFE;
- sha1_ctx->H[3] = 0x10325476;
- sha1_ctx->H[4] = 0xC3D2E1F0;
-
- for(i = 0; i < 80; i++)
- sha1_ctx->W[i] = 0;
-}
-
-static void
-sha1_uninit(PurpleCipherContext *context) {
- struct SHA1Context *sha1_ctx;
-
- purple_cipher_context_reset(context, NULL);
-
- sha1_ctx = purple_cipher_context_get_data(context);
-
- memset(sha1_ctx, 0, sizeof(struct SHA1Context));
-
- g_free(sha1_ctx);
- sha1_ctx = NULL;
-}
-
-
-static void
-sha1_append(PurpleCipherContext *context, const guchar *data, size_t len) {
- struct SHA1Context *sha1_ctx;
- gint i;
-
- sha1_ctx = purple_cipher_context_get_data(context);
-
- g_return_if_fail(sha1_ctx);
-
- for(i = 0; i < len; i++) {
- sha1_ctx->W[sha1_ctx->lenW / 4] <<= 8;
- sha1_ctx->W[sha1_ctx->lenW / 4] |= data[i];
-
- if((++sha1_ctx->lenW) % 64 == 0) {
- sha1_hash_block(sha1_ctx);
- sha1_ctx->lenW = 0;
- }
-
- sha1_ctx->sizeLo += 8;
- sha1_ctx->sizeHi += (sha1_ctx->sizeLo < 8);
- }
-}
-
-static gboolean
-sha1_digest(PurpleCipherContext *context, size_t in_len, guchar digest[20],
- size_t *out_len)
-{
- struct SHA1Context *sha1_ctx;
- guchar pad0x80 = 0x80, pad0x00 = 0x00;
- guchar padlen[8];
- gint i;
-
- g_return_val_if_fail(in_len >= 20, FALSE);
-
- sha1_ctx = purple_cipher_context_get_data(context);
-
- g_return_val_if_fail(sha1_ctx, FALSE);
-
- padlen[0] = (guchar)((sha1_ctx->sizeHi >> 24) & 255);
- padlen[1] = (guchar)((sha1_ctx->sizeHi >> 16) & 255);
- padlen[2] = (guchar)((sha1_ctx->sizeHi >> 8) & 255);
- padlen[3] = (guchar)((sha1_ctx->sizeHi >> 0) & 255);
- padlen[4] = (guchar)((sha1_ctx->sizeLo >> 24) & 255);
- padlen[5] = (guchar)((sha1_ctx->sizeLo >> 16) & 255);
- padlen[6] = (guchar)((sha1_ctx->sizeLo >> 8) & 255);
- padlen[7] = (guchar)((sha1_ctx->sizeLo >> 0) & 255);
-
- /* pad with a 1, then zeroes, then length */
- purple_cipher_context_append(context, &pad0x80, 1);
- while(sha1_ctx->lenW != 56)
- purple_cipher_context_append(context, &pad0x00, 1);
- purple_cipher_context_append(context, padlen, 8);
-
- for(i = 0; i < 20; i++) {
- digest[i] = (guchar)(sha1_ctx->H[i / 4] >> 24);
- sha1_ctx->H[i / 4] <<= 8;
- }
-
- purple_cipher_context_reset(context, NULL);
-
- if(out_len)
- *out_len = 20;
-
- return TRUE;
-}
-
-static size_t
-sha1_get_block_size(PurpleCipherContext *context)
-{
- /* This does not change (in this case) */
- return SHA1_HMAC_BLOCK_SIZE;
-}
-
-static PurpleCipherOps SHA1Ops = {
- sha1_set_opt, /* Set Option */
- sha1_get_opt, /* Get Option */
- sha1_init, /* init */
- sha1_reset, /* reset */
- sha1_uninit, /* uninit */
- NULL, /* set iv */
- sha1_append, /* append */
- sha1_digest, /* digest */
- NULL, /* encrypt */
- NULL, /* decrypt */
- NULL, /* set salt */
- NULL, /* get salt size */
- NULL, /* set key */
- NULL, /* get key size */
- NULL, /* set batch mode */
- NULL, /* get batch mode */
- sha1_get_block_size, /* get block size */
- NULL /* set key with len */
-};
-
-/*******************************************************************************
- * RC4
- ******************************************************************************/
-
-struct RC4Context {
- guchar state[256];
- guchar x;
- guchar y;
- gint key_len;
-};
-
-static void
-rc4_init(PurpleCipherContext *context, void *extra) {
- struct RC4Context *rc4_ctx;
- rc4_ctx = g_new0(struct RC4Context, 1);
- purple_cipher_context_set_data(context, rc4_ctx);
- purple_cipher_context_reset(context, extra);
-}
-
-
-static void
-rc4_reset(PurpleCipherContext *context, void *extra) {
- struct RC4Context *rc4_ctx;
- guint i;
-
- rc4_ctx = purple_cipher_context_get_data(context);
-
- g_return_if_fail(rc4_ctx);
-
- for(i = 0; i < 256; i++)
- rc4_ctx->state[i] = i;
- rc4_ctx->x = 0;
- rc4_ctx->y = 0;
-
- /* default is 5 bytes (40bit key) */
- rc4_ctx->key_len = 5;
-
-}
-
-static void
-rc4_uninit(PurpleCipherContext *context) {
- struct RC4Context *rc4_ctx;
-
- rc4_ctx = purple_cipher_context_get_data(context);
- memset(rc4_ctx, 0, sizeof(rc4_ctx));
-
- g_free(rc4_ctx);
- rc4_ctx = NULL;
-}
-
-
-
-static void
-rc4_set_key (PurpleCipherContext *context, const guchar * key) {
- struct RC4Context *ctx;
- guchar *state;
- guchar temp_swap;
- guchar x, y;
- guint i;
-
- ctx = purple_cipher_context_get_data(context);
-
- x = 0;
- y = 0;
- state = &ctx->state[0];
- for(i = 0; i < 256; i++)
- {
- y = (key[x] + state[i] + y) % 256;
- temp_swap = state[i];
- state[i] = state[y];
- state[y] = temp_swap;
- x = (x + 1) % ctx->key_len;
- }
-}
-
-static void
-rc4_set_opt(PurpleCipherContext *context, const gchar *name, void *value) {
- struct RC4Context *ctx;
-
- ctx = purple_cipher_context_get_data(context);
-
- if(!strcmp(name, "key_len")) {
- ctx->key_len = GPOINTER_TO_INT(value);
- }
-}
-
-static size_t
-rc4_get_key_size (PurpleCipherContext *context)
-{
- struct RC4Context *ctx;
-
- g_return_val_if_fail(context, -1);
-
- ctx = purple_cipher_context_get_data(context);
-
- g_return_val_if_fail(ctx, -1);
-
- return ctx->key_len;
-}
-
-static void *
-rc4_get_opt(PurpleCipherContext *context, const gchar *name) {
- struct RC4Context *ctx;
-
- ctx = purple_cipher_context_get_data(context);
-
- if(!strcmp(name, "key_len")) {
- return GINT_TO_POINTER(ctx->key_len);
- }
-
- return NULL;
-}
-
-static gint
-rc4_encrypt(PurpleCipherContext *context, const guchar data[],
- size_t len, guchar output[], size_t *outlen) {
- struct RC4Context *ctx;
- guchar temp_swap;
- guchar x, y, z;
- guchar *state;
- guint i;
-
- ctx = purple_cipher_context_get_data(context);
-
- x = ctx->x;
- y = ctx->y;
- state = &ctx->state[0];
-
- for(i = 0; i < len; i++)
- {
- x = (x + 1) % 256;
- y = (state[x] + y) % 256;
- temp_swap = state[x];
- state[x] = state[y];
- state[y] = temp_swap;
- z = state[x] + (state[y]) % 256;
- output[i] = data[i] ^ state[z];
- }
- ctx->x = x;
- ctx->y = y;
- if(outlen)
- *outlen = len;
-
- return 0;
-}
-
-static PurpleCipherOps RC4Ops = {
- rc4_set_opt, /* Set Option */
- rc4_get_opt, /* Get Option */
- rc4_init, /* init */
- rc4_reset, /* reset */
- rc4_uninit, /* uninit */
- NULL, /* set iv */
- NULL, /* append */
- NULL, /* digest */
- rc4_encrypt, /* encrypt */
- NULL, /* decrypt */
- NULL, /* set salt */
- NULL, /* get salt size */
- rc4_set_key, /* set key */
- rc4_get_key_size, /* get key size */
- NULL, /* set batch mode */
- NULL, /* get batch mode */
- NULL, /* get block size */
- NULL /* set key with len */
-};
-
-/*******************************************************************************
- * Structs
- ******************************************************************************/
-struct _PurpleCipher {
- gchar *name; /**< Internal name - used for searching */
- PurpleCipherOps *ops; /**< Operations supported by this cipher */
- guint ref; /**< Reference count */
-};
-
-struct _PurpleCipherContext {
- PurpleCipher *cipher; /**< Cipher this context is under */
- gpointer data; /**< Internal cipher state data */
-};
-
/******************************************************************************
- * Globals
- *****************************************************************************/
-static GList *ciphers = NULL;
-
-/******************************************************************************
* PurpleCipher API
*****************************************************************************/
-const gchar *
-purple_cipher_get_name(PurpleCipher *cipher) {
- g_return_val_if_fail(cipher, NULL);
+GType
+purple_cipher_get_gtype(void) {
+ static GType type = 0;
- return cipher->name;
-}
+ if(type == 0) {
+ static const GTypeInfo info = {
+ sizeof(PurpleCipherClass),
+ NULL,
+ NULL,
+ (GClassInitFunc)purple_cipher_class_init,
+ NULL,
+ NULL,
+ sizeof(PurpleCipher),
+ 0,
+ NULL,
+ NULL
+ };
-guint
-purple_cipher_get_capabilities(PurpleCipher *cipher) {
- PurpleCipherOps *ops = NULL;
- guint caps = 0;
-
- g_return_val_if_fail(cipher, 0);
-
- ops = cipher->ops;
- g_return_val_if_fail(ops, 0);
-
- if(ops->set_option)
- caps |= PURPLE_CIPHER_CAPS_SET_OPT;
- if(ops->get_option)
- caps |= PURPLE_CIPHER_CAPS_GET_OPT;
- if(ops->init)
- caps |= PURPLE_CIPHER_CAPS_INIT;
- if(ops->reset)
- caps |= PURPLE_CIPHER_CAPS_RESET;
- if(ops->uninit)
- caps |= PURPLE_CIPHER_CAPS_UNINIT;
- if(ops->set_iv)
- caps |= PURPLE_CIPHER_CAPS_SET_IV;
- if(ops->append)
- caps |= PURPLE_CIPHER_CAPS_APPEND;
- if(ops->digest)
- caps |= PURPLE_CIPHER_CAPS_DIGEST;
- if(ops->encrypt)
- caps |= PURPLE_CIPHER_CAPS_ENCRYPT;
- if(ops->decrypt)
- caps |= PURPLE_CIPHER_CAPS_DECRYPT;
- if(ops->set_salt)
- caps |= PURPLE_CIPHER_CAPS_SET_SALT;
- if(ops->get_salt_size)
- caps |= PURPLE_CIPHER_CAPS_GET_SALT_SIZE;
- if(ops->set_key)
- caps |= PURPLE_CIPHER_CAPS_SET_KEY;
- if(ops->get_key_size)
- caps |= PURPLE_CIPHER_CAPS_GET_KEY_SIZE;
- if(ops->set_batch_mode)
- caps |= PURPLE_CIPHER_CAPS_SET_BATCH_MODE;
- if(ops->get_batch_mode)
- caps |= PURPLE_CIPHER_CAPS_GET_BATCH_MODE;
- if(ops->get_block_size)
- caps |= PURPLE_CIPHER_CAPS_GET_BLOCK_SIZE;
- if(ops->set_key_with_len)
- caps |= PURPLE_CIPHER_CAPS_SET_KEY_WITH_LEN;
-
- return caps;
-}
-
-gboolean
-purple_cipher_digest_region(const gchar *name, const guchar *data,
- size_t data_len, size_t in_len,
- guchar digest[], size_t *out_len)
-{
- PurpleCipher *cipher;
- PurpleCipherContext *context;
- gboolean ret = FALSE;
-
- g_return_val_if_fail(name, FALSE);
- g_return_val_if_fail(data, FALSE);
-
- cipher = purple_ciphers_find_cipher(name);
-
- g_return_val_if_fail(cipher, FALSE);
-
- if(!cipher->ops->append || !cipher->ops->digest) {
- purple_debug_info("cipher", "purple_cipher_region failed: "
- "the %s cipher does not support appending and or "
- "digesting.", cipher->name);
- return FALSE;
+ type = g_type_register_static(G_TYPE_OBJECT,
+ "PurpleCipher",
+ &info, G_TYPE_FLAG_ABSTRACT);
}
- context = purple_cipher_context_new(cipher, NULL);
- purple_cipher_context_append(context, data, data_len);
- ret = purple_cipher_context_digest(context, in_len, digest, out_len);
- purple_cipher_context_destroy(context);
-
- return ret;
+ return type;
}
-/******************************************************************************
- * PurpleCiphers API
- *****************************************************************************/
-PurpleCipher *
-purple_ciphers_find_cipher(const gchar *name) {
- PurpleCipher *cipher;
- GList *l;
+GType
+purple_cipher_batch_mode_get_gtype(void) {
+ static GType type = 0;
- g_return_val_if_fail(name, NULL);
+ if(type == 0) {
+ static const GEnumValue values[] = {
+ { PURPLE_CIPHER_BATCH_MODE_ECB, "ECB", "ECB" },
+ { PURPLE_CIPHER_BATCH_MODE_CBC, "CBC", "CBC" },
+ { 0, NULL, NULL },
+ };
- for(l = ciphers; l; l = l->next) {
- cipher = PURPLE_CIPHER(l->data);
-
- if(!g_ascii_strcasecmp(cipher->name, name))
- return cipher;
+ type = g_enum_register_static("PurpleCipherBatchMode", values);
}
- return NULL;
+ return type;
}
-PurpleCipher *
-purple_ciphers_register_cipher(const gchar *name, PurpleCipherOps *ops) {
- PurpleCipher *cipher = NULL;
-
- g_return_val_if_fail(name, NULL);
- g_return_val_if_fail(ops, NULL);
- g_return_val_if_fail(!purple_ciphers_find_cipher(name), NULL);
-
- cipher = g_new0(PurpleCipher, 1);
- PURPLE_DBUS_REGISTER_POINTER(cipher, PurpleCipher);
-
- cipher->name = g_strdup(name);
- cipher->ops = ops;
-
- ciphers = g_list_append(ciphers, cipher);
-
- purple_signal_emit(purple_ciphers_get_handle(), "cipher-added", cipher);
-
- return cipher;
-}
-
-gboolean
-purple_ciphers_unregister_cipher(PurpleCipher *cipher) {
- g_return_val_if_fail(cipher, FALSE);
- g_return_val_if_fail(cipher->ref == 0, FALSE);
-
- purple_signal_emit(purple_ciphers_get_handle(), "cipher-removed", cipher);
-
- ciphers = g_list_remove(ciphers, cipher);
-
- g_free(cipher->name);
-
- PURPLE_DBUS_UNREGISTER_POINTER(cipher);
- g_free(cipher);
-
- return TRUE;
-}
-
-GList *
-purple_ciphers_get_ciphers() {
- return ciphers;
-}
-
-/******************************************************************************
- * PurpleCipher Subsystem API
- *****************************************************************************/
-gpointer
-purple_ciphers_get_handle() {
- static gint handle;
-
- return &handle;
-}
-
void
-purple_ciphers_init() {
- gpointer handle;
+purple_cipher_reset(PurpleCipher *cipher) {
+ PurpleCipherClass *klass = NULL;
- handle = purple_ciphers_get_handle();
+ g_return_if_fail(PURPLE_IS_CIPHER(cipher));
- purple_signal_register(handle, "cipher-added",
- purple_marshal_VOID__POINTER, NULL, 1,
- purple_value_new(PURPLE_TYPE_SUBTYPE,
- PURPLE_SUBTYPE_CIPHER));
- purple_signal_register(handle, "cipher-removed",
- purple_marshal_VOID__POINTER, NULL, 1,
- purple_value_new(PURPLE_TYPE_SUBTYPE,
- PURPLE_SUBTYPE_CIPHER));
+ klass = PURPLE_CIPHER_GET_CLASS(cipher);
- purple_ciphers_register_cipher("md5", &MD5Ops);
- purple_ciphers_register_cipher("sha1", &SHA1Ops);
- purple_ciphers_register_cipher("md4", &MD4Ops);
- purple_ciphers_register_cipher("hmac", &HMACOps);
- purple_ciphers_register_cipher("des", &DESOps);
- purple_ciphers_register_cipher("des3", &DES3Ops);
- purple_ciphers_register_cipher("rc4", &RC4Ops);
+ if(klass && klass->reset)
+ klass->reset(cipher);
}
void
-purple_ciphers_uninit() {
- PurpleCipher *cipher;
- GList *l, *ll;
-
- for(l = ciphers; l; l = ll) {
- ll = l->next;
-
- cipher = PURPLE_CIPHER(l->data);
- purple_ciphers_unregister_cipher(cipher);
-
- ciphers = g_list_remove(ciphers, cipher);
- }
-
- g_list_free(ciphers);
-
- purple_signals_unregister_by_instance(purple_ciphers_get_handle());
-}
-/******************************************************************************
- * PurpleCipherContext API
- *****************************************************************************/
-void
-purple_cipher_context_set_option(PurpleCipherContext *context, const gchar *name,
- gpointer value)
+purple_cipher_set_iv(PurpleCipher *cipher, guchar *iv, size_t len)
{
- PurpleCipher *cipher = NULL;
+ PurpleCipherClass *klass = NULL;
- g_return_if_fail(context);
- g_return_if_fail(name);
-
- cipher = context->cipher;
- g_return_if_fail(cipher);
-
- if(cipher->ops && cipher->ops->set_option)
- cipher->ops->set_option(context, name, value);
- else
- purple_debug_info("cipher", "the %s cipher does not support the "
- "set_option operation\n", cipher->name);
-}
-
-gpointer
-purple_cipher_context_get_option(PurpleCipherContext *context, const gchar *name) {
- PurpleCipher *cipher = NULL;
-
- g_return_val_if_fail(context, NULL);
- g_return_val_if_fail(name, NULL);
-
- cipher = context->cipher;
- g_return_val_if_fail(cipher, NULL);
-
- if(cipher->ops && cipher->ops->get_option)
- return cipher->ops->get_option(context, name);
- else {
- purple_debug_info("cipher", "the %s cipher does not support the "
- "get_option operation\n", cipher->name);
-
- return NULL;
- }
-}
-
-PurpleCipherContext *
-purple_cipher_context_new(PurpleCipher *cipher, void *extra) {
- PurpleCipherContext *context = NULL;
-
- g_return_val_if_fail(cipher, NULL);
-
- cipher->ref++;
-
- context = g_new0(PurpleCipherContext, 1);
- context->cipher = cipher;
-
- if(cipher->ops->init)
- cipher->ops->init(context, extra);
-
- return context;
-}
-
-PurpleCipherContext *
-purple_cipher_context_new_by_name(const gchar *name, void *extra) {
- PurpleCipher *cipher;
-
- g_return_val_if_fail(name, NULL);
-
- cipher = purple_ciphers_find_cipher(name);
-
- g_return_val_if_fail(cipher, NULL);
-
- return purple_cipher_context_new(cipher, extra);
-}
-
-void
-purple_cipher_context_reset(PurpleCipherContext *context, void *extra) {
- PurpleCipher *cipher = NULL;
-
- g_return_if_fail(context);
-
- cipher = context->cipher;
- g_return_if_fail(cipher);
-
- if(cipher->ops && cipher->ops->reset)
- context->cipher->ops->reset(context, extra);
-}
-
-void
-purple_cipher_context_destroy(PurpleCipherContext *context) {
- PurpleCipher *cipher = NULL;
-
- g_return_if_fail(context);
-
- cipher = context->cipher;
- g_return_if_fail(cipher);
-
- cipher->ref--;
-
- if(cipher->ops && cipher->ops->uninit)
- cipher->ops->uninit(context);
-
- memset(context, 0, sizeof(context));
- g_free(context);
- context = NULL;
-}
-
-void
-purple_cipher_context_set_iv(PurpleCipherContext *context, guchar *iv, size_t len)
-{
- PurpleCipher *cipher = NULL;
-
- g_return_if_fail(context);
+ g_return_if_fail(PURPLE_IS_CIPHER(cipher));
g_return_if_fail(iv);
- cipher = context->cipher;
- g_return_if_fail(cipher);
+ klass = PURPLE_CIPHER_GET_CLASS(cipher);
- if(cipher->ops && cipher->ops->set_iv)
- cipher->ops->set_iv(context, iv, len);
- else
- purple_debug_info("cipher", "the %s cipher does not support the set"
- "initialization vector operation\n", cipher->name);
+ if(klass && klass->set_iv)
+ klass->set_iv(cipher, iv, len);
}
void
-purple_cipher_context_append(PurpleCipherContext *context, const guchar *data,
+purple_cipher_append(PurpleCipher *cipher, const guchar *data,
size_t len)
{
- PurpleCipher *cipher = NULL;
+ PurpleCipherClass *klass = NULL;
- g_return_if_fail(context);
+ g_return_if_fail(PURPLE_IS_CIPHER(cipher));
- cipher = context->cipher;
- g_return_if_fail(cipher);
+ klass = PURPLE_CIPHER_GET_CLASS(cipher);
- if(cipher->ops && cipher->ops->append)
- cipher->ops->append(context, data, len);
- else
- purple_debug_info("cipher", "the %s cipher does not support the append "
- "operation\n", cipher->name);
+ if(klass && klass->append)
+ klass->append(cipher, data, len);
}
gboolean
-purple_cipher_context_digest(PurpleCipherContext *context, size_t in_len,
+purple_cipher_digest(PurpleCipher *cipher, size_t in_len,
guchar digest[], size_t *out_len)
{
- PurpleCipher *cipher = NULL;
+ PurpleCipherClass *klass = NULL;
- g_return_val_if_fail(context, FALSE);
+ g_return_val_if_fail(PURPLE_IS_CIPHER(cipher), FALSE);
- cipher = context->cipher;
- g_return_val_if_fail(context, FALSE);
+ klass = PURPLE_CIPHER_GET_CLASS(cipher);
- if(cipher->ops && cipher->ops->digest)
- return cipher->ops->digest(context, in_len, digest, out_len);
- else {
- purple_debug_info("cipher", "the %s cipher does not support the digest "
- "operation\n", cipher->name);
- return FALSE;
- }
+ if(klass && klass->digest)
+ return klass->digest(cipher, in_len, digest, out_len);
+
+ return FALSE;
}
gboolean
-purple_cipher_context_digest_to_str(PurpleCipherContext *context, size_t in_len,
+purple_cipher_digest_to_str(PurpleCipher *cipher, size_t in_len,
gchar digest_s[], size_t *out_len)
{
/* 8k is a bit excessive, will tweak later. */
@@ -2422,10 +150,10 @@ purple_cipher_context_digest_to_str(Purp
gint n = 0;
size_t dlen = 0;
- g_return_val_if_fail(context, FALSE);
+ g_return_val_if_fail(cipher, FALSE);
g_return_val_if_fail(digest_s, FALSE);
- if(!purple_cipher_context_digest(context, sizeof(digest), digest, &dlen))
+ if(!purple_cipher_digest(cipher, sizeof(digest), digest, &dlen))
return FALSE;
/* in_len must be greater than dlen * 2 so we have room for the NUL. */
@@ -2444,373 +172,180 @@ gint
}
gint
-purple_cipher_context_encrypt(PurpleCipherContext *context, const guchar data[],
+purple_cipher_encrypt(PurpleCipher *cipher, const guchar data[],
size_t len, guchar output[], size_t *outlen)
{
- PurpleCipher *cipher = NULL;
+ PurpleCipherClass *klass = NULL;
- g_return_val_if_fail(context, -1);
+ g_return_val_if_fail(PURPLE_IS_CIPHER(cipher), -1);
- cipher = context->cipher;
- g_return_val_if_fail(cipher, -1);
+ klass = PURPLE_CIPHER_GET_CLASS(cipher);
- if(cipher->ops && cipher->ops->encrypt)
- return cipher->ops->encrypt(context, data, len, output, outlen);
- else {
- purple_debug_info("cipher", "the %s cipher does not support the encrypt"
- "operation\n", cipher->name);
+ if(klass && klass->encrypt)
+ return klass->encrypt(cipher, data, len, output, outlen);
- if(outlen)
- *outlen = -1;
+ if(outlen)
+ *outlen = -1;
- return -1;
- }
+ return -1;
}
gint
-purple_cipher_context_decrypt(PurpleCipherContext *context, const guchar data[],
+purple_cipher_decrypt(PurpleCipher *cipher, const guchar data[],
size_t len, guchar output[], size_t *outlen)
{
- PurpleCipher *cipher = NULL;
+ PurpleCipherClass *klass = NULL;
- g_return_val_if_fail(context, -1);
+ g_return_val_if_fail(PURPLE_IS_CIPHER(cipher), -1);
- cipher = context->cipher;
- g_return_val_if_fail(cipher, -1);
+ klass = PURPLE_CIPHER_GET_CLASS(cipher);
- if(cipher->ops && cipher->ops->decrypt)
- return cipher->ops->decrypt(context, data, len, output, outlen);
- else {
- purple_debug_info("cipher", "the %s cipher does not support the decrypt"
- "operation\n", cipher->name);
+ if(klass && klass->decrypt)
+ return klass->decrypt(cipher, data, len, output, outlen);
- if(outlen)
- *outlen = -1;
+ if(outlen)
+ *outlen = -1;
- return -1;
- }
+ return -1;
}
void
-purple_cipher_context_set_salt(PurpleCipherContext *context, guchar *salt) {
- PurpleCipher *cipher = NULL;
+purple_cipher_set_salt(PurpleCipher *cipher, guchar *salt) {
+ PurpleCipherClass *klass = NULL;
- g_return_if_fail(context);
+ g_return_if_fail(PURPLE_IS_CIPHER(cipher));
- cipher = context->cipher;
- g_return_if_fail(cipher);
+ klass = PURPLE_CIPHER_GET_CLASS(cipher);
- if(cipher->ops && cipher->ops->set_salt)
- cipher->ops->set_salt(context, salt);
- else
- purple_debug_info("cipher", "the %s cipher does not support the "
- "set_salt operation\n", cipher->name);
+ if(klass && klass->set_salt)
+ klass->set_salt(cipher, salt);
}
size_t
-purple_cipher_context_get_salt_size(PurpleCipherContext *context) {
- PurpleCipher *cipher = NULL;
+purple_cipher_get_salt_size(PurpleCipher *cipher) {
+ PurpleCipherClass *klass = NULL;
- g_return_val_if_fail(context, -1);
+ g_return_val_if_fail(PURPLE_IS_CIPHER(cipher), -1);
- cipher = context->cipher;
- g_return_val_if_fail(cipher, -1);
+ klass = PURPLE_CIPHER_GET_CLASS(cipher);
- if(cipher->ops && cipher->ops->get_salt_size)
- return cipher->ops->get_salt_size(context);
- else {
- purple_debug_info("cipher", "the %s cipher does not support the "
- "get_salt_size operation\n", cipher->name);
+ if(klass && klass->get_salt_size)
+ return klass->get_salt_size(cipher);
- return -1;
- }
+ return -1;
}
void
-purple_cipher_context_set_key(PurpleCipherContext *context, const guchar *key) {
- PurpleCipher *cipher = NULL;
+purple_cipher_set_key(PurpleCipher *cipher, const guchar *key) {
+ PurpleCipherClass *klass = NULL;
- g_return_if_fail(context);
+ g_return_if_fail(PURPLE_IS_CIPHER(cipher));
- cipher = context->cipher;
- g_return_if_fail(cipher);
+ klass = PURPLE_CIPHER_GET_CLASS(cipher);
- if(cipher->ops && cipher->ops->set_key)
- cipher->ops->set_key(context, key);
- else
- purple_debug_info("cipher", "the %s cipher does not support the "
- "set_key operation\n", cipher->name);
+ if(klass && klass->set_key)
+ klass->set_key(cipher, key);
}
size_t
-purple_cipher_context_get_key_size(PurpleCipherContext *context) {
- PurpleCipher *cipher = NULL;
+purple_cipher_get_key_size(PurpleCipher *cipher) {
+ PurpleCipherClass *klass = NULL;
- g_return_val_if_fail(context, -1);
+ g_return_val_if_fail(PURPLE_IS_CIPHER(cipher), -1);
- cipher = context->cipher;
- g_return_val_if_fail(cipher, -1);
+ klass = PURPLE_CIPHER_GET_CLASS(cipher);
- if(cipher->ops && cipher->ops->get_key_size)
- return cipher->ops->get_key_size(context);
- else {
- purple_debug_info("cipher", "the %s cipher does not support the "
- "get_key_size operation\n", cipher->name);
+ if(klass && klass->get_key_size)
+ return klass->get_key_size(cipher);
- return -1;
- }
+ return -1;
}
void
-purple_cipher_context_set_batch_mode(PurpleCipherContext *context,
+purple_cipher_set_batch_mode(PurpleCipher *cipher,
PurpleCipherBatchMode mode)
{
- PurpleCipher *cipher = NULL;
+ PurpleCipherClass *klass = NULL;
- g_return_if_fail(context);
+ g_return_if_fail(PURPLE_IS_CIPHER(cipher));
- cipher = context->cipher;
- g_return_if_fail(cipher);
+ klass = PURPLE_CIPHER_GET_CLASS(cipher);
- if(cipher->ops && cipher->ops->set_batch_mode)
- cipher->ops->set_batch_mode(context, mode);
- else
- purple_debug_info("cipher", "The %s cipher does not support the "
- "set_batch_mode operation\n", cipher->name);
+ if(klass && klass->set_batch_mode)
+ klass->set_batch_mode(cipher, mode);
}
PurpleCipherBatchMode
-purple_cipher_context_get_batch_mode(PurpleCipherContext *context)
+purple_cipher_get_batch_mode(PurpleCipher *cipher)
{
- PurpleCipher *cipher = NULL;
+ PurpleCipherClass *klass = NULL;
- g_return_val_if_fail(context, -1);
+ g_return_val_if_fail(PURPLE_IS_CIPHER(cipher), -1);
- cipher = context->cipher;
- g_return_val_if_fail(cipher, -1);
+ klass = PURPLE_CIPHER_GET_CLASS(cipher);
- if(cipher->ops && cipher->ops->get_batch_mode)
- return cipher->ops->get_batch_mode(context);
- else {
- purple_debug_info("cipher", "The %s cipher does not support the "
- "get_batch_mode operation\n", cipher->name);
- return -1;
- }
+ if(klass && klass->get_batch_mode)
+ return klass->get_batch_mode(cipher);
+
+ return -1;
}
size_t
-purple_cipher_context_get_block_size(PurpleCipherContext *context)
+purple_cipher_get_block_size(PurpleCipher *cipher)
{
- PurpleCipher *cipher = NULL;
+ PurpleCipherClass *klass = NULL;
- g_return_val_if_fail(context, -1);
+ g_return_val_if_fail(PURPLE_IS_CIPHER(cipher), -1);
- cipher = context->cipher;
- g_return_val_if_fail(cipher, -1);
+ klass = PURPLE_CIPHER_GET_CLASS(cipher);
- if(cipher->ops && cipher->ops->get_block_size)
- return cipher->ops->get_block_size(context);
- else {
- purple_debug_info("cipher", "The %s cipher does not support the "
- "get_block_size operation\n", cipher->name);
- return -1;
- }
+ if(klass && klass->get_block_size)
+ return klass->get_block_size(cipher);
+
+ return -1;
}
void
-purple_cipher_context_set_key_with_len(PurpleCipherContext *context,
+purple_cipher_set_key_with_len(PurpleCipher *cipher,
const guchar *key, size_t len)
{
- PurpleCipher *cipher = NULL;
+ PurpleCipherClass *klass = NULL;
- g_return_if_fail(context);
+ g_return_if_fail(PURPLE_IS_CIPHER(cipher));
+ g_return_if_fail(key);
- cipher = context->cipher;
- g_return_if_fail(cipher);
+ klass = PURPLE_CIPHER_GET_CLASS(cipher);
- if(cipher->ops && cipher->ops->set_key_with_len)
- cipher->ops->set_key_with_len(context, key, len);
- else
- purple_debug_info("cipher", "The %s cipher does not support the "
- "set_key_with_len operation\n", cipher->name);
+ if(klass && klass->set_key_with_len)
+ klass->set_key_with_len(cipher, key, len);
}
void
-purple_cipher_context_set_data(PurpleCipherContext *context, gpointer data) {
- g_return_if_fail(context);
-
- context->data = data;
-}
-
-gpointer
-purple_cipher_context_get_data(PurpleCipherContext *context) {
- g_return_val_if_fail(context, NULL);
-
- return context->data;
-}
-
-gchar *purple_cipher_http_digest_calculate_session_key(
- const gchar *algorithm,
- const gchar *username,
- const gchar *realm,
- const gchar *password,
- const gchar *nonce,
- const gchar *client_nonce)
+purple_cipher_set_hash(PurpleCipher *cipher,
+ PurpleCipher *hash)
{
- PurpleCipher *cipher;
- PurpleCipherContext *context;
- gchar hash[33]; /* We only support MD5. */
+ PurpleCipherClass *klass = NULL;
- g_return_val_if_fail(username != NULL, NULL);
- g_return_val_if_fail(realm != NULL, NULL);
- g_return_val_if_fail(password != NULL, NULL);
- g_return_val_if_fail(nonce != NULL, NULL);
+ g_return_if_fail(PURPLE_IS_CIPHER(cipher));
+ g_return_if_fail(PURPLE_IS_CIPHER(hash));
- /* Check for a supported algorithm. */
- g_return_val_if_fail(algorithm == NULL ||
- *algorithm == '\0' ||
- g_ascii_strcasecmp(algorithm, "MD5") ||
- g_ascii_strcasecmp(algorithm, "MD5-sess"), NULL);
+ klass = PURPLE_CIPHER_GET_CLASS(cipher);
- cipher = purple_ciphers_find_cipher("md5");
- g_return_val_if_fail(cipher != NULL, NULL);
-
- context = purple_cipher_context_new(cipher, NULL);
-
- purple_cipher_context_append(context, (guchar *)username, strlen(username));
- purple_cipher_context_append(context, (guchar *)":", 1);
- purple_cipher_context_append(context, (guchar *)realm, strlen(realm));
- purple_cipher_context_append(context, (guchar *)":", 1);
- purple_cipher_context_append(context, (guchar *)password, strlen(password));
-
- if (algorithm != NULL && !g_ascii_strcasecmp(algorithm, "MD5-sess"))
- {
- guchar digest[16];
-
- if (client_nonce == NULL)
- {
- purple_cipher_context_destroy(context);
- purple_debug_error("cipher", "Required client_nonce missing for MD5-sess digest calculation.\n");
- return NULL;
- }
-
- purple_cipher_context_digest(context, sizeof(digest), digest, NULL);
- purple_cipher_context_destroy(context);
-
- context = purple_cipher_context_new(cipher, NULL);
- purple_cipher_context_append(context, digest, sizeof(digest));
- purple_cipher_context_append(context, (guchar *)":", 1);
- purple_cipher_context_append(context, (guchar *)nonce, strlen(nonce));
- purple_cipher_context_append(context, (guchar *)":", 1);
- purple_cipher_context_append(context, (guchar *)client_nonce, strlen(client_nonce));
- }
-
- purple_cipher_context_digest_to_str(context, sizeof(hash), hash, NULL);
- purple_cipher_context_destroy(context);
-
- return g_strdup(hash);
+ if(klass && klass->set_hash)
+ klass->set_hash(cipher, hash);
}
-gchar *purple_cipher_http_digest_calculate_response(
- const gchar *algorithm,
- const gchar *method,
- const gchar *digest_uri,
- const gchar *qop,
- const gchar *entity,
- const gchar *nonce,
- const gchar *nonce_count,
- const gchar *client_nonce,
- const gchar *session_key)
+PurpleCipher *
+purple_cipher_get_hash(PurpleCipher *cipher)
{
- PurpleCipher *cipher;
- PurpleCipherContext *context;
- static gchar hash2[33]; /* We only support MD5. */
+ PurpleCipherClass *klass = NULL;
- g_return_val_if_fail(method != NULL, NULL);
- g_return_val_if_fail(digest_uri != NULL, NULL);
- g_return_val_if_fail(nonce != NULL, NULL);
- g_return_val_if_fail(session_key != NULL, NULL);
+ g_return_val_if_fail(PURPLE_IS_CIPHER(cipher), NULL);
- /* Check for a supported algorithm. */
- g_return_val_if_fail(algorithm == NULL ||
- *algorithm == '\0' ||
- g_ascii_strcasecmp(algorithm, "MD5") ||
- g_ascii_strcasecmp(algorithm, "MD5-sess"), NULL);
+ klass = PURPLE_CIPHER_GET_CLASS(cipher);
- /* Check for a supported "quality of protection". */
- g_return_val_if_fail(qop == NULL ||
- *qop == '\0' ||
- g_ascii_strcasecmp(qop, "auth") ||
- g_ascii_strcasecmp(qop, "auth-int"), NULL);
+ if(klass && klass->get_hash)
+ return klass->get_hash(cipher);
- cipher = purple_ciphers_find_cipher("md5");
- g_return_val_if_fail(cipher != NULL, NULL);
-
- context = purple_cipher_context_new(cipher, NULL);
-
- purple_cipher_context_append(context, (guchar *)method, strlen(method));
- purple_cipher_context_append(context, (guchar *)":", 1);
- purple_cipher_context_append(context, (guchar *)digest_uri, strlen(digest_uri));
-
- if (qop != NULL && !g_ascii_strcasecmp(qop, "auth-int"))
- {
- PurpleCipherContext *context2;
- gchar entity_hash[33];
-
- if (entity == NULL)
- {
- purple_cipher_context_destroy(context);
- purple_debug_error("cipher", "Required entity missing for auth-int digest calculation.\n");
- return NULL;
- }
-
- context2 = purple_cipher_context_new(cipher, NULL);
- purple_cipher_context_append(context2, (guchar *)entity, strlen(entity));
- purple_cipher_context_digest_to_str(context2, sizeof(entity_hash), entity_hash, NULL);
- purple_cipher_context_destroy(context2);
-
- purple_cipher_context_append(context, (guchar *)":", 1);
- purple_cipher_context_append(context, (guchar *)entity_hash, strlen(entity_hash));
- }
-
- purple_cipher_context_digest_to_str(context, sizeof(hash2), hash2, NULL);
- purple_cipher_context_destroy(context);
-
- context = purple_cipher_context_new(cipher, NULL);
- purple_cipher_context_append(context, (guchar *)session_key, strlen(session_key));
- purple_cipher_context_append(context, (guchar *)":", 1);
- purple_cipher_context_append(context, (guchar *)nonce, strlen(nonce));
- purple_cipher_context_append(context, (guchar *)":", 1);
-
- if (qop != NULL && *qop != '\0')
- {
- if (nonce_count == NULL)
- {
- purple_cipher_context_destroy(context);
- purple_debug_error("cipher", "Required nonce_count missing for digest calculation.\n");
- return NULL;
- }
-
- if (client_nonce == NULL)
- {
- purple_cipher_context_destroy(context);
- purple_debug_error("cipher", "Required client_nonce missing for digest calculation.\n");
- return NULL;
- }
-
- purple_cipher_context_append(context, (guchar *)nonce_count, strlen(nonce_count));
- purple_cipher_context_append(context, (guchar *)":", 1);
- purple_cipher_context_append(context, (guchar *)client_nonce, strlen(client_nonce));
- purple_cipher_context_append(context, (guchar *)":", 1);
-
- purple_cipher_context_append(context, (guchar *)qop, strlen(qop));
-
- purple_cipher_context_append(context, (guchar *)":", 1);
- }
-
- purple_cipher_context_append(context, (guchar *)hash2, strlen(hash2));
- purple_cipher_context_digest_to_str(context, sizeof(hash2), hash2, NULL);
- purple_cipher_context_destroy(context);
-
- return g_strdup(hash2);
+ return NULL;
}
============================================================
--- libpurple/cipher.h 8188467edcae61f5f139accf56ff4dc63247b22e
+++ libpurple/cipher.h c5af633ae2092a04910887fe64aa2c4d2ced2318
@@ -1,7 +1,6 @@
/**
* @file cipher.h Purple Cipher API
* @ingroup core
- * @see @ref cipher-signals
*/
/* purple
@@ -29,315 +28,161 @@
#include <glib.h>
-#define PURPLE_CIPHER(obj) ((PurpleCipher *)(obj)) /**< PurpleCipher typecast helper */
-#define PURPLE_CIPHER_OPS(obj) ((PurpleCipherOps *)(obj)) /**< PurpleCipherInfo typecase helper */
-#define PURPLE_CIPHER_CONTEXT(obj) ((PurpleCipherContext *)(obj)) /**< PurpleCipherContext typecast helper */
+/*******************************************************************************
+ * New Cipher Header
+ ******************************************************************************/
+#include <glib-object.h>
-typedef struct _PurpleCipher PurpleCipher; /**< A handle to a PurpleCipher */
-typedef struct _PurpleCipherOps PurpleCipherOps; /**< Ops for a PurpleCipher */
-typedef struct _PurpleCipherContext PurpleCipherContext; /**< A context for a PurpleCipher */
+#define PURPLE_TYPE_CIPHER (purple_cipher_get_gtype())
+#define PURPLE_CIPHER(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), PURPLE_TYPE_CIPHER, PurpleCipher))
+#define PURPLE_CIPHER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), PURPLE_TYPE_CIPHER, PurpleCipherClass))
+#define PURPLE_IS_CIPHER(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), PURPLE_TYPE_CIPHER))
+#define PURPLE_IS_CIPHER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), PURPLE_TYPE_CIPHER))
+#define PURPLE_CIPHER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), PURPLE_TYPE_CIPHER, PurpleCipherClass))
+typedef struct _PurpleCipher PurpleCipher;
+typedef struct _PurpleCipherPriv PurpleCipherPriv;
+typedef struct _PurpleCipherClass PurpleCipherClass;
+
+#define PURPLE_TYPE_CIPHER_BATCH_MODE (purple_cipher_batch_mode_get_gtype())
+
/**
* Modes for batch encrypters
*/
-typedef enum _PurpleCipherBatchMode {
+typedef enum {
PURPLE_CIPHER_BATCH_MODE_ECB,
PURPLE_CIPHER_BATCH_MODE_CBC
} PurpleCipherBatchMode;
-/**
- * The operation flags for a cipher
- */
-typedef enum _PurpleCipherCaps {
- PURPLE_CIPHER_CAPS_SET_OPT = 1 << 1, /**< Set option flag */
- PURPLE_CIPHER_CAPS_GET_OPT = 1 << 2, /**< Get option flag */
- PURPLE_CIPHER_CAPS_INIT = 1 << 3, /**< Init flag */
- PURPLE_CIPHER_CAPS_RESET = 1 << 4, /**< Reset flag */
- PURPLE_CIPHER_CAPS_UNINIT = 1 << 5, /**< Uninit flag */
- PURPLE_CIPHER_CAPS_SET_IV = 1 << 6, /**< Set IV flag */
- PURPLE_CIPHER_CAPS_APPEND = 1 << 7, /**< Append flag */
- PURPLE_CIPHER_CAPS_DIGEST = 1 << 8, /**< Digest flag */
- PURPLE_CIPHER_CAPS_ENCRYPT = 1 << 9, /**< Encrypt flag */
- PURPLE_CIPHER_CAPS_DECRYPT = 1 << 10, /**< Decrypt flag */
- PURPLE_CIPHER_CAPS_SET_SALT = 1 << 11, /**< Set salt flag */
- PURPLE_CIPHER_CAPS_GET_SALT_SIZE = 1 << 12, /**< Get salt size flag */
- PURPLE_CIPHER_CAPS_SET_KEY = 1 << 13, /**< Set key flag */
- PURPLE_CIPHER_CAPS_GET_KEY_SIZE = 1 << 14, /**< Get key size flag */
- PURPLE_CIPHER_CAPS_SET_BATCH_MODE = 1 << 15, /**< Set batch mode flag */
- PURPLE_CIPHER_CAPS_GET_BATCH_MODE = 1 << 16, /**< Get batch mode flag */
- PURPLE_CIPHER_CAPS_GET_BLOCK_SIZE = 1 << 17, /**< The get block size flag */
- PURPLE_CIPHER_CAPS_SET_KEY_WITH_LEN = 1 << 18, /**< The set key with length flag */
- PURPLE_CIPHER_CAPS_UNKNOWN = 1 << 19 /**< Unknown */
-} PurpleCipherCaps;
+struct _PurpleCipher {
+ GObject gparent;
-/**
- * The operations of a cipher. Every cipher must implement one of these.
- */
-struct _PurpleCipherOps {
- /** The set option function */
- void (*set_option)(PurpleCipherContext *context, const gchar *name, void *value);
+ PurpleCipherPriv *priv;
- /** The get option function */
- void *(*get_option)(PurpleCipherContext *context, const gchar *name);
+ void (*_purple_reserved1)(void);
+ void (*_purple_reserved2)(void);
+ void (*_purple_reserved3)(void);
+ void (*_purple_reserved4)(void);
+};
- /** The init function */
- void (*init)(PurpleCipherContext *context, void *extra);
+struct _PurpleCipherClass {
+ GObjectClass gparent;
/** The reset function */
- void (*reset)(PurpleCipherContext *context, void *extra);
+ void (*reset)(PurpleCipher *cipher);
- /** The uninit function */
- void (*uninit)(PurpleCipherContext *context);
-
/** The set initialization vector function */
- void (*set_iv)(PurpleCipherContext *context, guchar *iv, size_t len);
+ void (*set_iv)(PurpleCipher *cipher, guchar *iv, size_t len);
/** The append data function */
- void (*append)(PurpleCipherContext *context, const guchar *data, size_t len);
+ void (*append)(PurpleCipher *cipher, const guchar *data, size_t len);
/** The digest function */
- gboolean (*digest)(PurpleCipherContext *context, size_t in_len, guchar digest[], size_t *out_len);
+ gboolean (*digest)(PurpleCipher *cipher, size_t in_len, guchar digest[], size_t *out_len);
/** The encrypt function */
- int (*encrypt)(PurpleCipherContext *context, const guchar data[], size_t len, guchar output[], size_t *outlen);
+ int (*encrypt)(PurpleCipher *cipher, const guchar data[], size_t len, guchar output[], size_t *outlen);
/** The decrypt function */
- int (*decrypt)(PurpleCipherContext *context, const guchar data[], size_t len, guchar output[], size_t *outlen);
+ int (*decrypt)(PurpleCipher *cipher, const guchar data[], size_t len, guchar output[], size_t *outlen);
/** The set salt function */
- void (*set_salt)(PurpleCipherContext *context, guchar *salt);
+ void (*set_salt)(PurpleCipher *cipher, guchar *salt);
/** The get salt size function */
- size_t (*get_salt_size)(PurpleCipherContext *context);
+ size_t (*get_salt_size)(PurpleCipher *cipher);
/** The set key function */
- void (*set_key)(PurpleCipherContext *context, const guchar *key);
+ void (*set_key)(PurpleCipher *cipher, const guchar *key);
/** The get key size function */
- size_t (*get_key_size)(PurpleCipherContext *context);
+ size_t (*get_key_size)(PurpleCipher *cipher);
/** The set batch mode function */
- void (*set_batch_mode)(PurpleCipherContext *context, PurpleCipherBatchMode mode);
+ void (*set_batch_mode)(PurpleCipher *cipher, PurpleCipherBatchMode mode);
/** The get batch mode function */
- PurpleCipherBatchMode (*get_batch_mode)(PurpleCipherContext *context);
+ PurpleCipherBatchMode (*get_batch_mode)(PurpleCipher *cipher);
/** The get block size function */
- size_t (*get_block_size)(PurpleCipherContext *context);
+ size_t (*get_block_size)(PurpleCipher *cipher);
/** The set key with length function */
- void (*set_key_with_len)(PurpleCipherContext *context, const guchar *key, size_t len);
+ void (*set_key_with_len)(PurpleCipher *cipher, const guchar *key, size_t len);
+
+ /** The get hash function */
+ PurpleCipher *(*get_hash)(PurpleCipher *cipher);
+
+ /** The set hash function */
+ void (*set_hash)(PurpleCipher *cipher, PurpleCipher *hash);
+
+ void (*_purple_reserved1)(void);
+ void (*_purple_reserved2)(void);
+ void (*_purple_reserved3)(void);
+ void (*_purple_reserved4)(void);
};
-#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
+G_BEGIN_DECLS
/*****************************************************************************/
/** @name PurpleCipher API */
/*****************************************************************************/
/*@{*/
-/**
- * Gets a cipher's name
- *
- * @param cipher The cipher handle
- *
- * @return The cipher's name
- */
-const gchar *purple_cipher_get_name(PurpleCipher *cipher);
+GType purple_cipher_get_gtype(void);
+GType purple_cipher_batch_mode_get_gtype(void);
/**
- * Gets a cipher's capabilities
- *
- * @param cipher The cipher handle
- *
- * @return The cipher's info
- */
-guint purple_cipher_get_capabilities(PurpleCipher *cipher);
-
-/**
- * Gets a digest from a cipher
- *
- * @param name The cipher's name
- * @param data The data to hash
- * @param data_len The length of the data
- * @param in_len The length of the buffer
- * @param digest The returned digest
- * @param out_len The length written
- *
- * @return @c TRUE if successful, @c FALSE otherwise
- */
-gboolean purple_cipher_digest_region(const gchar *name, const guchar *data, size_t data_len, size_t in_len, guchar digest[], size_t *out_len);
-
-/*@}*/
-/******************************************************************************/
-/** @name PurpleCiphers API */
-/******************************************************************************/
-/*@{*/
-
-/**
- * Finds a cipher by it's name
- *
- * @param name The name of the cipher to find
- *
- * @return The cipher handle or @c NULL
- */
-PurpleCipher *purple_ciphers_find_cipher(const gchar *name);
-
-/**
- * Registers a cipher as a usable cipher
- *
- * @param name The name of the new cipher
- * @param ops The cipher ops to register
- *
- * @return The handle to the new cipher or @c NULL if it failed
- */
-PurpleCipher *purple_ciphers_register_cipher(const gchar *name, PurpleCipherOps *ops);
-
-/**
- * Unregisters a cipher
- *
- * @param cipher The cipher handle to unregister
- *
- * @return Whether or not the cipher was successfully unloaded
- */
-gboolean purple_ciphers_unregister_cipher(PurpleCipher *cipher);
-
-/**
- * Gets the list of ciphers
- *
- * @return The list of available ciphers
- * @note This list should not be modified, it is owned by the cipher core
- */
-GList *purple_ciphers_get_ciphers(void);
-
-/*@}*/
-/******************************************************************************/
-/** @name PurpleCipher Subsystem API */
-/******************************************************************************/
-/*@{*/
-
-/**
- * Gets the handle to the cipher subsystem
- *
- * @return The handle to the cipher subsystem
- */
-gpointer purple_ciphers_get_handle(void);
-
-/**
- * Initializes the cipher core
- */
-void purple_ciphers_init(void);
-
-/**
- * Uninitializes the cipher core
- */
-void purple_ciphers_uninit(void);
-
-/*@}*/
-/******************************************************************************/
-/** @name PurpleCipherContext API */
-/******************************************************************************/
-/*@{*/
-
-/**
- * Sets the value an option on a cipher context
- *
- * @param context The cipher context
- * @param name The name of the option
- * @param value The value to set
- */
-void purple_cipher_context_set_option(PurpleCipherContext *context, const gchar *name, gpointer value);
-
-/**
- * Gets the vale of an option on a cipher context
- *
- * @param context The cipher context
- * @param name The name of the option
- * @return The value of the option
- */
-gpointer purple_cipher_context_get_option(PurpleCipherContext *context, const gchar *name);
-
-/**
- * Creates a new cipher context and initializes it
- *
- * @param cipher The cipher to use
- * @param extra Extra data for the specific cipher
- *
- * @return The new cipher context
- */
-PurpleCipherContext *purple_cipher_context_new(PurpleCipher *cipher, void *extra);
-
-/**
- * Creates a new cipher context by the cipher name and initializes it
- *
- * @param name The cipher's name
- * @param extra Extra data for the specific cipher
- *
- * @return The new cipher context
- */
-PurpleCipherContext *purple_cipher_context_new_by_name(const gchar *name, void *extra);
-
-/**
- * Resets a cipher context to it's default value
+ * Resets a cipher to it's default value
* @note If you have set an IV you will have to set it after resetting
*
- * @param context The context to reset
- * @param extra Extra data for the specific cipher
- */
-void purple_cipher_context_reset(PurpleCipherContext *context, gpointer extra);
+ * @param cipher The cipher to reset
+ */
+void purple_cipher_reset(PurpleCipher *cipher);
/**
- * Destorys a cipher context and deinitializes it
+ * Sets the initialization vector for a cipher
+ * @note This should only be called right after a cipher is created or reset
*
- * @param context The cipher context to destory
- */
-void purple_cipher_context_destroy(PurpleCipherContext *context);
-
-/**
- * Sets the initialization vector for a context
- * @note This should only be called right after a cipher context is created or reset
- *
- * @param context The context to set the IV to
+ * @param cipher The cipher to set the IV to
* @param iv The initialization vector to set
* @param len The len of the IV
*/
-void purple_cipher_context_set_iv(PurpleCipherContext *context, guchar *iv, size_t len);
+void purple_cipher_set_iv(PurpleCipher *cipher, guchar *iv, size_t len);
/**
- * Appends data to the context
+ * Appends data to the cipher
*
- * @param context The context to append data to
+ * @param cipher The cipher to append data to
* @param data The data to append
* @param len The length of the data
*/
-void purple_cipher_context_append(PurpleCipherContext *context, const guchar *data, size_t len);
+void purple_cipher_append(PurpleCipher *cipher, const guchar *data, size_t len);
/**
- * Digests a context
+ * Digests a cipher
*
- * @param context The context to digest
+ * @param cipher The cipher to digest
* @param in_len The length of the buffer
* @param digest The return buffer for the digest
* @param out_len The length of the returned value
*/
-gboolean purple_cipher_context_digest(PurpleCipherContext *context, size_t in_len, guchar digest[], size_t *out_len);
+gboolean purple_cipher_digest(PurpleCipher *cipher, size_t in_len, guchar digest[], size_t *out_len);
/**
* Converts a guchar digest into a hex string
*
- * @param context The context to get a digest from
+ * @param cipher The cipher to get a digest from
* @param in_len The length of the buffer
* @param digest_s The return buffer for the string digest
* @param out_len The length of the returned value
*/
-gboolean purple_cipher_context_digest_to_str(PurpleCipherContext *context, size_t in_len, gchar digest_s[], size_t *out_len);
+gboolean purple_cipher_digest_to_str(PurpleCipher *cipher, size_t in_len, gchar digest_s[], size_t *out_len);
/**
- * Encrypts data using the context
+ * Encrypts data using the cipher
*
- * @param context The context
+ * @param cipher The cipher
* @param data The data to encrypt
* @param len The length of the data
* @param output The output buffer
@@ -345,12 +190,12 @@ gboolean purple_cipher_context_digest_to
*
* @return A cipher specific status code
*/
-gint purple_cipher_context_encrypt(PurpleCipherContext *context, const guchar data[], size_t len, guchar output[], size_t *outlen);
+gint purple_cipher_encrypt(PurpleCipher *cipher, const guchar data[], size_t len, guchar output[], size_t *outlen);
/**
- * Decrypts data using the context
+ * Decrypts data using the cipher
*
- * @param context The context
+ * @param cipher The cipher
* @param data The data to encrypt
* @param len The length of the returned value
* @param output The output buffer
@@ -358,148 +203,99 @@ gint purple_cipher_context_encrypt(Purpl
*
* @return A cipher specific status code
*/
-gint purple_cipher_context_decrypt(PurpleCipherContext *context, const guchar data[], size_t len, guchar output[], size_t *outlen);
+gint purple_cipher_decrypt(PurpleCipher *cipher, const guchar data[], size_t len, guchar output[], size_t *outlen);
/**
- * Sets the salt on a context
+ * Sets the salt on a cipher
*
- * @param context The context whose salt to set
+ * @param cipher The cipher whose salt to set
* @param salt The salt
*/
-void purple_cipher_context_set_salt(PurpleCipherContext *context, guchar *salt);
+void purple_cipher_set_salt(PurpleCipher *cipher, guchar *salt);
/**
* Gets the size of the salt if the cipher supports it
*
- * @param context The context whose salt size to get
+ * @param cipher The cipher whose salt size to get
*
* @return The size of the salt
*/
-size_t purple_cipher_context_get_salt_size(PurpleCipherContext *context);
+size_t purple_cipher_get_salt_size(PurpleCipher *cipher);
/**
- * Sets the key on a context
+ * Sets the key on a cipher
*
- * @param context The context whose key to set
+ * @param cipher The cipher whose key to set
* @param key The key
*/
-void purple_cipher_context_set_key(PurpleCipherContext *context, const guchar *key);
+void purple_cipher_set_key(PurpleCipher *cipher, const guchar *key);
/**
- * Gets the key size for a context
+ * Gets the key size for a cipher
*
- * @param context The context whose key size to get
+ * @param cipher The cipher whose key size to get
*
* @return The size of the key
*/
-size_t purple_cipher_context_get_key_size(PurpleCipherContext *context);
+size_t purple_cipher_get_key_size(PurpleCipher *cipher);
/**
- * Sets the batch mode of a context
+ * Sets the batch mode of a cipher
*
- * @param context The context whose batch mode to set
+ * @param cipher The cipher whose batch mode to set
* @param mode The batch mode under which the cipher should operate
*
*/
-void purple_cipher_context_set_batch_mode(PurpleCipherContext *context, PurpleCipherBatchMode mode);
+void purple_cipher_set_batch_mode(PurpleCipher *cipher, PurpleCipherBatchMode mode);
/**
- * Gets the batch mode of a context
+ * Gets the batch mode of a cipher
*
- * @param context The context whose batch mode to get
+ * @param cipher The cipher whose batch mode to get
*
* @return The batch mode under which the cipher is operating
*/
-PurpleCipherBatchMode purple_cipher_context_get_batch_mode(PurpleCipherContext *context);
+PurpleCipherBatchMode purple_cipher_get_batch_mode(PurpleCipher *cipher);
/**
- * Gets the block size of a context
+ * Gets the block size of a cipher
*
- * @param context The context whose block size to get
+ * @param cipher The cipher whose block size to get
*
- * @return The block size of the context
+ * @return The block size of the cipher
*/
-size_t purple_cipher_context_get_block_size(PurpleCipherContext *context);
+size_t purple_cipher_get_block_size(PurpleCipher *cipher);
/**
- * Sets the key with a given length on a context
+ * Sets the key with a given length on a cipher
*
- * @param context The context whose key to set
+ * @param cipher The cipher whose key to set
* @param key The key
* @param len The length of the key
*
*/
-void purple_cipher_context_set_key_with_len(PurpleCipherContext *context, const guchar *key, size_t len);
+void purple_cipher_set_key_with_len(PurpleCipher *cipher, const guchar *key, size_t len);
/**
- * Sets the cipher data for a context
+ * Sets the internal hash of a cipher
*
- * @param context The context whose cipher data to set
- * @param data The cipher data to set
- */
-void purple_cipher_context_set_data(PurpleCipherContext *context, gpointer data);
-
-/**
- * Gets the cipher data for a context
+ * @param cipher The cipher whose hash to set
+ * @param hash The internal hash the cipher should use
*
- * @param context The context whose cipher data to get
- *
- * @return The cipher data
*/
-gpointer purple_cipher_context_get_data(PurpleCipherContext *context);
+void purple_cipher_set_hash(PurpleCipher *cipher, PurpleCipher *hash);
-/*@}*/
-/*****************************************************************************/
-/** @name Purple Cipher HTTP Digest Helper Functions */
-/*****************************************************************************/
-/*@{*/
-
/**
- * Calculates a session key for HTTP Digest authentation
+ * Gets the internal hash of a cipher
*
- * See RFC 2617 for more information.
+ * @param cipher The cipher whose hash to get
*
- * @param algorithm The hash algorithm to use
- * @param username The username provided by the user
- * @param realm The authentication realm provided by the server
- * @param password The password provided by the user
- * @param nonce The nonce provided by the server
- * @param client_nonce The nonce provided by the client
- *
- * @return The session key, or @c NULL if an error occurred.
+ * @return The internal hash the cipher is using.
*/
-gchar *purple_cipher_http_digest_calculate_session_key(
- const gchar *algorithm, const gchar *username,
- const gchar *realm, const gchar *password,
- const gchar *nonce, const gchar *client_nonce);
+PurpleCipher *purple_cipher_get_hash(PurpleCipher *cipher);
-/** Calculate a response for HTTP Digest authentication
- *
- * See RFC 2617 for more information.
- *
- * @param algorithm The hash algorithm to use
- * @param method The HTTP method in use
- * @param digest_uri The URI from the initial request
- * @param qop The "quality of protection"
- * @param entity The entity body
- * @param nonce The nonce provided by the server
- * @param nonce_count The nonce count
- * @param client_nonce The nonce provided by the client
- * @param session_key The session key from purple_cipher_http_digest_calculate_session_key()
- *
- * @return The hashed response, or @c NULL if an error occurred.
- */
-gchar *purple_cipher_http_digest_calculate_response(
- const gchar *algorithm, const gchar *method,
- const gchar *digest_uri, const gchar *qop,
- const gchar *entity, const gchar *nonce,
- const gchar *nonce_count, const gchar *client_nonce,
- const gchar *session_key);
-
/*@}*/
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
+G_END_DECLS
#endif /* PURPLE_CIPHER_H */
============================================================
--- libpurple/descipher.c 21233884ceb0619eea042a62dc7cb25065cc8217
+++ libpurple/descipher.c 4f5ec2afa830bf45ee9bbf9ba69f0c9560856d4e
@@ -20,12 +20,22 @@
/******************************************************************************
* Structs
*****************************************************************************/
-struct _PurpleDESCipherPriv {
+struct _PurpleDESCipherPriv
+{
guint32 encrypt_subkeys[32];
guint32 decrypt_subkeys[32];
};
/******************************************************************************
+ * Enums
+ *****************************************************************************/
+enum {
+ PROP_NONE,
+ PROP_KEY,
+ PROP_LAST,
+};
+
+/******************************************************************************
* Globals
*****************************************************************************/
static GObjectClass *parent_class = NULL;
@@ -358,8 +368,8 @@ purple_des_cipher_set_key(PurpleCipher *
* Electronic Codebook Mode DES encryption/decryption of data according to
* 'mode'.
*/
-static int
-des_ecb_crypt(PurpleDESCipher *des_cipher, const guint8 * from, guint8 * to,
+int
+purple_des_cipher_ecb_crypt(PurpleDESCipher *des_cipher, const guint8 * from, guint8 * to,
int mode)
{
guint32 left, right, work;
@@ -395,7 +405,7 @@ purple_des_cipher_encrypt(PurpleCipher *
guint8 buf[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
while(offset + 8 <= len) {
- des_ecb_crypt(des_cipher, data + offset, output + offset, 0);
+ purple_des_cipher_ecb_crypt(des_cipher, data + offset, output + offset, 0);
offset += 8;
}
@@ -410,17 +420,64 @@ purple_des_cipher_encrypt(PurpleCipher *
tmp++;
}
- des_ecb_crypt(des_cipher, buf, output + offset, 0);
+ purple_des_cipher_ecb_crypt(des_cipher, buf, output + offset, 0);
}
return 0;
}
+static int
+purple_des_cipher_decrypt(PurpleCipher *cipher, const guchar data[],
+ size_t len, guchar output[], size_t *outlen)
+{
+ PurpleDESCipher *des_cipher = PURPLE_DES_CIPHER(cipher);
+ int offset = 0, i = 0, tmp;
+ guint8 buf[8] = {0,0,0,0,0,0,0,0};
+
+ while(offset + 8 <= len) {
+ purple_des_cipher_ecb_crypt(des_cipher, data + offset, output + offset, 1);
+ offset += 8;
+ }
+
+ *outlen = len;
+
+ if(offset<len) {
+ *outlen += len - offset;
+ tmp = offset;
+
+ while(tmp<len) {
+ buf[i++] = data[tmp];
+ tmp++;
+ }
+
+ purple_des_cipher_ecb_crypt(des_cipher, buf, output + offset, 1);
+ }
+
+ return 0;
+}
+
/******************************************************************************
* Object Stuff
*****************************************************************************/
static void
-purple_des_cipher_finalize(GObject *obj) {
+purple_des_cipher_set_property(GObject *obj, guint param_id,
+ const GValue *value, GParamSpec *pspec)
+{
+ PurpleCipher *cipher = PURPLE_CIPHER(obj);
+
+ switch(param_id) {
+ case PROP_KEY:
+ purple_cipher_set_key(cipher, (guchar *)g_value_get_string(value));
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, param_id, pspec);
+ break;
+ }
+}
+
+static void
+purple_des_cipher_finalize(GObject *obj)
+{
PurpleDESCipher *des_cipher = PURPLE_DES_CIPHER(obj);
memset(des_cipher->priv, 0, sizeof(des_cipher->priv));
@@ -429,20 +486,29 @@ static void
}
static void
-purple_des_cipher_class_init(PurpleDESCipherClass *klass) {
+purple_des_cipher_class_init(PurpleDESCipherClass *klass)
+{
GObjectClass *obj_class = G_OBJECT_CLASS(klass);
PurpleCipherClass *cipher_class = PURPLE_CIPHER_CLASS(klass);
+ GParamSpec *pspec;
parent_class = g_type_class_peek_parent(klass);
obj_class->finalize = purple_des_cipher_finalize;
+ obj_class->set_property = purple_des_cipher_set_property;
cipher_class->encrypt = purple_des_cipher_encrypt;
+ cipher_class->decrypt = purple_des_cipher_decrypt;
cipher_class->set_key = purple_des_cipher_set_key;
+
+ pspec = g_param_spec_string("key", "key", "key", NULL,
+ G_PARAM_WRITABLE);
+ g_object_class_install_property(obj_class, PROP_KEY, pspec);
}
static void
-purple_des_cipher_init(PurpleCipher *cipher) {
+purple_des_cipher_init(PurpleCipher *cipher)
+{
PurpleDESCipher *des_cipher = PURPLE_DES_CIPHER(cipher);
des_cipher->priv = g_new0(PurpleDESCipherPriv, 1);
@@ -452,7 +518,8 @@ GType
* API
*****************************************************************************/
GType
-purple_des_cipher_get_gtype(void) {
+purple_des_cipher_get_gtype(void)
+{
static GType type = 0;
if(type == 0) {
@@ -478,7 +545,8 @@ PurpleCipher *
}
PurpleCipher *
-purple_des_cipher_new(void) {
+purple_des_cipher_new(void)
+{
return g_object_new(PURPLE_TYPE_DES_CIPHER, NULL);
}
============================================================
--- libpurple/descipher.h 1c2935bf43be9ca2d002addc6f9ae16ba71909ba
+++ libpurple/descipher.h e96a347c40f89b7ff6a006fc45a59ca19027a116
@@ -64,6 +64,8 @@ PurpleCipher *purple_des_cipher_new(void
PurpleCipher *purple_des_cipher_new(void);
+int purple_des_cipher_ecb_crypt(PurpleDESCipher *des_cipher, const guint8 * from, guint8 * to, int mode);
+
G_END_DECLS
#endif /* PURPLE_DES_CIPHER_H */
============================================================
--- libpurple/plugins/ciphertest.c f17b394053c74faa109c9f82b924e0063f72ba57
+++ libpurple/plugins/ciphertest.c 356a8b275398e7e9907d59105b681d70805da67a
@@ -34,7 +34,10 @@
#include "cipher.h"
#include "debug.h"
+#include "md5cipher.h"
#include "plugin.h"
+#include "sha1cipher.h"
+#include "util.h"
#include "version.h"
struct test {
@@ -63,30 +66,22 @@ cipher_test_md5(void) {
static void
cipher_test_md5(void) {
PurpleCipher *cipher;
- PurpleCipherContext *context;
gchar digest[33];
gboolean ret;
gint i = 0;
- cipher = purple_ciphers_find_cipher("md5");
- if(!cipher) {
- purple_debug_info("cipher-test",
- "could not find md5 cipher, not testing\n");
- return;
- }
+ cipher = purple_md5_cipher_new();
purple_debug_info("cipher-test", "Running md5 tests\n");
- context = purple_cipher_context_new(cipher, NULL);
-
while(md5_tests[i].answer) {
purple_debug_info("cipher-test", "Test %02d:\n", i);
purple_debug_info("cipher-test", "Testing '%s'\n", md5_tests[i].question);
- purple_cipher_context_append(context, (guchar *)md5_tests[i].question,
+ purple_cipher_append(cipher, (guchar *)md5_tests[i].question,
strlen(md5_tests[i].question));
- ret = purple_cipher_context_digest_to_str(context, sizeof(digest),
+ ret = purple_cipher_digest_to_str(cipher, sizeof(digest),
digest, NULL);
if(!ret) {
@@ -97,11 +92,11 @@ cipher_test_md5(void) {
md5_tests[i].answer);
}
- purple_cipher_context_reset(context, NULL);
+ purple_cipher_reset(cipher);
i++;
}
- purple_cipher_context_destroy(context);
+ g_object_unref(G_OBJECT(cipher));
purple_debug_info("cipher-test", "md5 tests completed\n\n");
}
@@ -120,22 +115,14 @@ cipher_test_sha1(void) {
static void
cipher_test_sha1(void) {
PurpleCipher *cipher;
- PurpleCipherContext *context;
gchar digest[41];
gint i = 0;
gboolean ret;
- cipher = purple_ciphers_find_cipher("sha1");
- if(!cipher) {
- purple_debug_info("cipher-test",
- "could not find sha1 cipher, not testing\n");
- return;
- }
+ cipher = purple_sha1_cipher_new();
purple_debug_info("cipher-test", "Running sha1 tests\n");
- context = purple_cipher_context_new(cipher, NULL);
-
while(sha1_tests[i].answer) {
purple_debug_info("cipher-test", "Test %02d:\n", i);
purple_debug_info("cipher-test", "Testing '%s'\n",
@@ -143,7 +130,7 @@ cipher_test_sha1(void) {
sha1_tests[i].question : "'a'x1000, 1000 times");
if(sha1_tests[i].question) {
- purple_cipher_context_append(context, (guchar *)sha1_tests[i].question,
+ purple_cipher_append(cipher, (guchar *)sha1_tests[i].question,
strlen(sha1_tests[i].question));
} else {
gint j;
@@ -152,10 +139,10 @@ cipher_test_sha1(void) {
memset(buff, 'a', 1000);
for(j = 0; j < 1000; j++)
- purple_cipher_context_append(context, buff, 1000);
+ purple_cipher_append(cipher, buff, 1000);
}
- ret = purple_cipher_context_digest_to_str(context, sizeof(digest),
+ ret = purple_cipher_digest_to_str(cipher, sizeof(digest),
digest, NULL);
if(!ret) {
@@ -166,11 +153,11 @@ cipher_test_sha1(void) {
sha1_tests[i].answer);
}
- purple_cipher_context_reset(context, NULL);
+ purple_cipher_reset(cipher);
i++;
}
- purple_cipher_context_destroy(context);
+ g_object_unref(G_OBJECT(cipher));
purple_debug_info("cipher-test", "sha1 tests completed\n\n");
}
@@ -194,7 +181,7 @@ cipher_test_digest(void)
purple_debug_info("cipher-test", "Running HTTP Digest tests\n");
- session_key = purple_cipher_http_digest_calculate_session_key(
+ session_key = purple_http_digest_calculate_session_key(
algorithm, username, realm, password,
nonce, client_nonce);
@@ -210,7 +197,7 @@ cipher_test_digest(void)
purple_debug_info("cipher-test", "\tsession_key: Got: %s\n", session_key);
purple_debug_info("cipher-test", "\tsession_key: Wanted: %s\n", "939e7578ed9e3c518a452acee763bce9");
- response = purple_cipher_http_digest_calculate_response(
+ response = purple_http_digest_calculate_response(
algorithm, method, digest_uri, qop, entity,
nonce, nonce_count, client_nonce, session_key);
============================================================
--- libpurple/plugins/perl/common/Cipher.xs 25ac2f8f320df5336ddd23aee2b69f103a46e513
+++ libpurple/plugins/perl/common/Cipher.xs babc8757929008c1f968b2600090415a7f89cfe6
@@ -1,157 +1,138 @@ PROTOTYPES: ENABLE
#include "module.h"
MODULE = Purple::Cipher PACKAGE = Purple::Cipher PREFIX = purple_cipher_
PROTOTYPES: ENABLE
-const gchar *
-purple_cipher_get_name(cipher)
+void
+purple_cipher_reset(cipher)
Purple::Cipher cipher
-guint
-purple_cipher_get_capabilities(cipher)
+void
+purple_cipher_set_iv(cipher, iv, len)
Purple::Cipher cipher
+ guchar * iv
+ size_t len
-gboolean
-purple_cipher_digest_region(name, data, data_len, in_len, digest, out_len)
- const gchar * name
+void
+purple_cipher_append(cipher, data, len)
+ Purple::Cipher cipher
const guchar * data
- size_t data_len
+ size_t len
+
+gboolean
+purple_cipher_digest(cipher, in_len, digest, out_len)
+ Purple::Cipher cipher
size_t in_len
guchar &digest
size_t * out_len
-MODULE = Purple::Cipher PACKAGE = Purple::Ciphers PREFIX = purple_ciphers_
-PROTOTYPES: ENABLE
-
-Purple::Cipher
-purple_ciphers_find_cipher(name)
- gchar * name
-
-Purple::Cipher
-purple_ciphers_register_cipher(name, ops)
- gchar * name
- Purple::Cipher::Ops ops
-
gboolean
-purple_ciphers_unregister_cipher(cipher)
+purple_cipher_digest_to_str(cipher, in_len, digest_s, out_len)
Purple::Cipher cipher
+ size_t in_len
+ gchar &digest_s
+ size_t * out_len
-void
-purple_ciphers_get_ciphers()
-PREINIT:
- GList *l;
-PPCODE:
- for (l = purple_ciphers_get_ciphers(); l != NULL; l = l->next) {
- XPUSHs(sv_2mortal(purple_perl_bless_object(l->data, "Purple::Cipher")));
- }
+gint
+purple_cipher_encrypt(cipher, data, len, output, outlen)
+ Purple::Cipher cipher
+ guchar &data
+ size_t len
+ guchar &output
+ size_t * outlen
-Purple::Handle
-purple_ciphers_get_handle()
+gint
+purple_cipher_decrypt(cipher, data, len, output, outlen)
+ Purple::Cipher cipher
+ guchar &data
+ size_t len
+ guchar &output
+ size_t * outlen
void
-purple_ciphers_init()
+purple_cipher_set_salt(cipher, salt)
+ Purple::Cipher cipher
+ guchar * salt
+size_t
+purple_cipher_get_salt_size(cipher);
+ Purple::Cipher cipher
+
void
-purple_ciphers_uninit()
+purple_cipher_set_key(cipher, key)
+ Purple::Cipher cipher
+ const guchar * key
-MODULE = Purple::Cipher PACKAGE = Purple::Cipher::Context PREFIX = purple_cipher_context_
-PROTOTYPES: ENABLE
+size_t
+purple_cipher_get_key_size(cipher)
+ Purple::Cipher cipher
void
-purple_cipher_context_set_option(context, name, value)
- Purple::Cipher::Context context
- gchar *name
- gpointer value
+purple_cipher_set_batch_mode(cipher, mode)
+ Purple::Cipher cipher
+ Purple::Cipher::BatchMode mode
-gpointer
-purple_cipher_context_get_option(context, name)
- Purple::Cipher::Context context
- gchar *name
-
-Purple::Cipher::Context
-purple_cipher_context_new(cipher, extra)
+Purple::Cipher::BatchMode
+purple_cipher_get_batch_mode(cipher)
Purple::Cipher cipher
- void *extra
-Purple::Cipher::Context
-purple_cipher_context_new_by_name(name, extra)
- gchar *name
- void *extra
+size_t
+purple_cipher_get_block_size(cipher)
+ Purple::Cipher cipher
void
-purple_cipher_context_reset(context, extra)
- Purple::Cipher::Context context
- gpointer extra
+purple_cipher_set_key_with_len(cipher, key, len)
+ Purple::Cipher cipher
+ const guchar * key
+ size_t len
void
-purple_cipher_context_destroy(context)
- Purple::Cipher::Context context
+purple_cipher_set_hash(cipher, hash);
+ Purple::Cipher cipher
+ Purple::Cipher hash
-void
-purple_cipher_context_set_iv(context, iv, len)
- Purple::Cipher::Context context
- guchar * iv
- size_t len
+Purple::Cipher
+purple_cipher_get_hash(cipher)
+ Purple::Cipher cipher
-void
-purple_cipher_context_append(context, data, len)
- Purple::Cipher::Context context
- guchar * data
- size_t len
+MODULE = Purple::Cipher PACKAGE = Purple::DESCipher PREFIX = purple_des_cipher_
+PROTOTYPES: ENABLE
-gboolean
-purple_cipher_context_digest(context, in_len, digest, out_len)
- Purple::Cipher::Context context
- size_t in_len
- guchar &digest
- size_t &out_len
+Purple::Cipher
+purple_des_cipher_new()
-gboolean
-purple_cipher_context_digest_to_str(context, in_len, digest_s, out_len)
- Purple::Cipher::Context context
- size_t in_len
- gchar &digest_s
- size_t &out_len
+MODULE = Purple::Cipher PACKAGE = Purple::MD4Cipher PREFIX = purple_md4_cipher_
+PROTOTYPES: ENABLE
-gint
-purple_cipher_context_encrypt(context, data, len, output, outlen)
- Purple::Cipher::Context context
- guchar &data
- size_t len
- guchar &output
- size_t &outlen
+Purple::Cipher
+purple_md4_cipher_new()
-gint
-purple_cipher_context_decrypt(context, data, len, output, outlen)
- Purple::Cipher::Context context
- guchar &data
- size_t len
- guchar &output
- size_t &outlen
+MODULE = Purple::Cipher PACKAGE = Purple::MD5Cipher PREFIX = purple_md5_cipher_
+PROTOTYPES: ENABLE
-void
-purple_cipher_context_set_salt(context, salt)
- Purple::Cipher::Context context
- guchar *salt
+Purple::Cipher
+purple_md5_cipher_new()
-size_t
-purple_cipher_context_get_salt_size(context)
- Purple::Cipher::Context context
+MODULE = Purple::Cipher PACKAGE = Purple::SHA1Cipher PREFIX = purple_sha1_cipher_
+PROTOTYPES: ENABLE
-void
-purple_cipher_context_set_key(context, key)
- Purple::Cipher::Context context
- guchar *key
+Purple::Cipher
+purple_sha1_cipher_new()
-size_t
-purple_cipher_context_get_key_size(context)
- Purple::Cipher::Context context
+MODULE = Purple::Cipher PACKAGE = Purple::HMACCipher PREFIX = purple_hmac_cipher_
+PROTOTYPES: ENABLE
-void
-purple_cipher_context_set_data(context, data)
- Purple::Cipher::Context context
- gpointer data
+Purple::Cipher
+purple_hmac_cipher_new()
+MODULE = Purple::Cipher PACKAGE = Purple::RC4Cipher PREFIX = purple_rc4_cipher_
+PROTOTYPES: ENABLE
+
+Purple::Cipher
+purple_rc4_cipher_new()
+
+MODULE = Purple::Cipher PACKAGE = Purple::DES3Cipher PREFIX = purple_des3_cipher_
+PROTOTYPES: ENABLE
+
+Purple::Cipher
+purple_des3_cipher_new()
-gpointer
-purple_cipher_context_get_data(context)
- Purple::Cipher::Context context
============================================================
--- libpurple/plugins/perl/common/Util.xs 5e95d737fbd5845bab75a4fd5a99772dfdab8285
+++ libpurple/plugins/perl/common/Util.xs 4ea85853e725e33319ad417cb6a52ef850cf6f35
@@ -277,3 +277,29 @@ purple_util_write_data_to_file(filename,
const char *filename
const char *data
size_t size
+
+
+MODULE = Purple::Util PACKAGE = Purple::Util::Http PREFIX = purple_http_
+PROTOTYPES: ENABLE
+
+gchar *
+purple_http_digest_calculate_session_key(algorithm, username, realm, password, nonce, client_nonce)
+ const gchar *algorithm
+ const gchar *username
+ const gchar *realm
+ const gchar *password
+ const gchar *nonce
+ const gchar *client_nonce
+
+gchar *
+purple_http_digest_calculate_response(algorithm, method, digest_uri, qop, entity, nonce, nonce_count, client_nonce, session_key)
+ const gchar *algorithm
+ const gchar *method
+ const gchar *digest_uri
+ const gchar *qop
+ const gchar *entity
+ const gchar *nonce
+ const gchar *nonce_count
+ const gchar *client_nonce
+ const gchar *session_key
+
============================================================
--- libpurple/plugins/perl/common/module.h e2f5c01868185ca35148d1c80cb90c4e9eaf59f0
+++ libpurple/plugins/perl/common/module.h 30c11dce79c5db32c72d6312589e98fe3742d3d2
@@ -20,12 +20,13 @@ typedef struct group *Purple__Group;
#include "accountopt.h"
#include "blist.h"
#include "buddyicon.h"
-#include "cipher.h"
#include "cmds.h"
#include "connection.h"
#include "conversation.h"
#include "core.h"
#include "debug.h"
+#include "des3cipher.h"
+#include "descipher.h"
#include "desktopitem.h"
#include "eventloop.h"
#include "ft.h"
@@ -36,7 +37,10 @@ typedef struct group *Purple__Group;
#include "gtkconv.h"
#include "gtkutils.h"
#endif
+#include "hmaccipher.h"
#include "imgstore.h"
+#include "md4cipher.h"
+#include "md5cipher.h"
#include "network.h"
#include "notify.h"
#include "plugin.h"
@@ -46,10 +50,12 @@ typedef struct group *Purple__Group;
#include "privacy.h"
#include "prpl.h"
#include "proxy.h"
+#include "rc4cipher.h"
#include "request.h"
#include "roomlist.h"
#include "savedstatuses.h"
#include "server.h"
+#include "sha1cipher.h"
#include "signals.h"
#include "sound.h"
#include "sslconn.h"
@@ -82,9 +88,7 @@ typedef PurpleCipher * Purple__Cipher;
/* cipher.h */
typedef PurpleCipher * Purple__Cipher;
-typedef PurpleCipherCaps Purple__CipherCaps;
-typedef PurpleCipherContext * Purple__Cipher__Context;
-typedef PurpleCipherOps * Purple__Cipher__Ops;
+typedef PurpleCipherBatchMode Purple__Cipher__BatchMode;
/* cmds.h */
typedef PurpleCmdFlag Purple__Cmd__Flag;
============================================================
--- libpurple/plugins/perl/common/typemap f86086abba79a48ffea4fe3f67b2fb13fd7d284b
+++ libpurple/plugins/perl/common/typemap 1ae3d825b0ad57b0c83d0fcc30599e703d7c44fd
@@ -56,9 +56,7 @@ Purple::Cipher T_PurpleObj
Purple::BuddyList::UiOps T_PurpleObj
Purple::Cipher T_PurpleObj
-Purple::CipherCaps T_IV
-Purple::Cipher::Ops T_PurpleObj
-Purple::Cipher::Context T_PurpleObj
+Purple::Cipher::BatchMode T_IV
Purple::Cmd::Flag T_IV
Purple::Cmd::Id T_IV
Purple::Cmd::Priority T_IV
============================================================
--- libpurple/plugins/signals-test.c 591850de877bfa00abd5ac7c6666a702e1e36bbc
+++ libpurple/plugins/signals-test.c ba95d635caefcaa947ae2035bee94c1054ea5825
@@ -23,7 +23,6 @@
#include <stdio.h>
#include "internal.h"
-#include "cipher.h"
#include "connection.h"
#include "conversation.h"
#include "core.h"
============================================================
--- libpurple/protocols/bonjour/bonjour_ft.c 43ebf9b9479e15c6a3c02aa75b469480ade7c899
+++ libpurple/protocols/bonjour/bonjour_ft.c 009fde2bf1549e8c868c6b98a1df68de568dab2e
@@ -28,7 +28,7 @@
#include "buddy.h"
#include "bonjour.h"
#include "bonjour_ft.h"
-#include "cipher.h"
+#include "sha1cipher.h"
static void
bonjour_bytestreams_init(PurpleXfer *xfer);
@@ -849,6 +849,7 @@ bonjour_bytestreams_connect(PurpleXfer *
static void
bonjour_bytestreams_connect(PurpleXfer *xfer, PurpleBuddy *pb)
{
+ PurpleCipher *cipher;
XepXfer *xf = NULL;
char dstaddr[41];
unsigned char hashval[20];
@@ -865,8 +866,12 @@ bonjour_bytestreams_connect(PurpleXfer *
return;
p = g_strdup_printf("%s%s%s", xf->sid, pb->name, purple_account_get_username(pb->account));
- purple_cipher_digest_region("sha1", (guchar *)p, strlen(p),
- sizeof(hashval), hashval, NULL);
+
+ cipher = purple_sha1_cipher_new();
+ purple_cipher_append(cipher, (guchar *)p, strlen(p));
+ purple_cipher_digest(cipher, sizeof(hashval), hashval, NULL);
+ g_object_unref(G_OBJECT(cipher));
+
g_free(p);
memset(dstaddr, 0, 41);
============================================================
--- libpurple/protocols/jabber/auth.c 8c4c2dab63b218c195650ffb587b1a18ab643a08
+++ libpurple/protocols/jabber/auth.c 33c6d085cc13ad727f9a48c0f8815f95239f19b5
@@ -581,23 +581,21 @@ auth_hmac_md5(const char *challenge, siz
auth_hmac_md5(const char *challenge, size_t challenge_len, const char *key, size_t key_len, guchar *digest)
{
PurpleCipher *cipher;
- PurpleCipherContext *context;
int i;
/* inner padding - key XORd with ipad */
unsigned char k_ipad[65];
/* outer padding - key XORd with opad */
unsigned char k_opad[65];
- cipher = purple_ciphers_find_cipher("md5");
+ cipher = purple_md5_cipher_new();
/* if key is longer than 64 bytes reset it to key=MD5(key) */
if (strlen(key) > 64) {
guchar keydigest[16];
- context = purple_cipher_context_new(cipher, NULL);
- purple_cipher_context_append(context, (const guchar *)key, strlen(key));
- purple_cipher_context_digest(context, 16, keydigest, NULL);
- purple_cipher_context_destroy(context);
+ purple_cipher_append(cipher, (const guchar *)key, strlen(key));
+ purple_cipher_digest(cipher, 16, keydigest, NULL);
+ purple_cipher_reset(cipher);
key = (char *)keydigest;
key_len = 16;
@@ -627,18 +625,16 @@ auth_hmac_md5(const char *challenge, siz
}
/* perform inner MD5 */
- context = purple_cipher_context_new(cipher, NULL);
- purple_cipher_context_append(context, k_ipad, 64); /* start with inner pad */
- purple_cipher_context_append(context, (const guchar *)challenge, challenge_len); /* then text of datagram */
- purple_cipher_context_digest(context, 16, digest, NULL); /* finish up 1st pass */
- purple_cipher_context_destroy(context);
+ purple_cipher_append(cipher, k_ipad, 64); /* start with inner pad */
+ purple_cipher_append(cipher, (const guchar *)challenge, challenge_len); /* then text of datagram */
+ purple_cipher_digest(cipher, 16, digest, NULL); /* finish up 1st pass */
+ purple_cipher_reset(cipher);
- /* perform outer MD5 */
- context = purple_cipher_context_new(cipher, NULL);
- purple_cipher_context_append(context, k_opad, 64); /* start with outer pad */
- purple_cipher_context_append(context, digest, 16); /* then results of 1st hash */
- purple_cipher_context_digest(context, 16, digest, NULL); /* finish up 2nd pass */
- purple_cipher_context_destroy(context);
+ /* perform outer MD5 */
+ purple_cipher_append(cipher, k_opad, 64); /* start with outer pad */
+ purple_cipher_append(cipher, digest, 16); /* then results of 1st hash */
+ purple_cipher_digest(cipher, 16, digest, NULL); /* finish up 2nd pass */
+ g_object_unref(G_OBJECT(cipher));
}
static void auth_old_cb(JabberStream *js, xmlnode *packet, gpointer data)
============================================================
--- libpurple/protocols/jabber/buddy.c 30ccef8ae960bfa7d6e2007eaa0e15f6d2a8dbf2
+++ libpurple/protocols/jabber/buddy.c c8e0eb60287ac34765a0701c1b2db09f12c817e9
@@ -19,11 +19,11 @@
*
*/
#include "internal.h"
-#include "cipher.h"
#include "debug.h"
#include "imgstore.h"
#include "prpl.h"
#include "notify.h"
+#include "sha1cipher.h"
#include "request.h"
#include "util.h"
#include "xmlnode.h"
@@ -425,6 +425,7 @@ void jabber_set_info(PurpleConnection *g
int i;
unsigned char hashval[20];
char *p, hash[41];
+ PurpleCipher *cipher;
if(!vc_node) {
vc_node = xmlnode_new("vCard");
@@ -444,9 +445,10 @@ void jabber_set_info(PurpleConnection *g
binval = xmlnode_new_child(photo, "BINVAL");
enc = purple_base64_encode(avatar_data, avatar_len);
- purple_cipher_digest_region("sha1", avatar_data,
- avatar_len, sizeof(hashval),
- hashval, NULL);
+ cipher = purple_sha1_cipher_new();
+ purple_cipher_append(cipher, (guchar*)avatar_data, avatar_len);
+ purple_cipher_digest(cipher, sizeof(hashval), hashval, NULL);
+ g_object_unref(G_OBJECT(cipher));
purple_imgstore_unref(img);
@@ -509,46 +511,47 @@ void jabber_set_buddy_icon(PurpleConnect
guint32 height = ntohl(png->ihdr.height);
xmlnode *publish, *item, *data, *metadata, *info;
char *lengthstring, *widthstring, *heightstring;
-
+
/* compute the sha1 hash */
- PurpleCipherContext *ctx;
+ PurpleCipher *cipher;
unsigned char digest[20];
char *hash;
char *base64avatar;
-
- ctx = purple_cipher_context_new_by_name("sha1", NULL);
- purple_cipher_context_append(ctx, purple_imgstore_get_data(img), purple_imgstore_get_size(img));
- purple_cipher_context_digest(ctx, sizeof(digest), digest, NULL);
-
+
+ cipher = purple_sha1_cipher_new();
+ purple_cipher_append(cipher, purple_imgstore_get_data(img), purple_imgstore_get_size(img));
+ purple_cipher_digest(cipher, sizeof(digest), digest, NULL);
+ g_object_unref(G_OBJECT(cipher));
+
/* convert digest to a string */
hash = g_strdup_printf("%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x",digest[0],digest[1],digest[2],digest[3],digest[4],digest[5],digest[6],digest[7],digest[8],digest[9],digest[10],digest[11],digest[12],digest[13],digest[14],digest[15],digest[16],digest[17],digest[18],digest[19]);
-
+
publish = xmlnode_new("publish");
xmlnode_set_attrib(publish,"node",AVATARNAMESPACEDATA);
-
+
item = xmlnode_new_child(publish, "item");
xmlnode_set_attrib(item, "id", hash);
-
+
data = xmlnode_new_child(item, "data");
xmlnode_set_namespace(data,AVATARNAMESPACEDATA);
-
+
base64avatar = purple_base64_encode(purple_imgstore_get_data(img), purple_imgstore_get_size(img));
xmlnode_insert_data(data,base64avatar,-1);
g_free(base64avatar);
-
+
/* publish the avatar itself */
jabber_pep_publish((JabberStream*)gc->proto_data, publish);
-
+
/* next step: publish the metadata */
publish = xmlnode_new("publish");
xmlnode_set_attrib(publish,"node",AVATARNAMESPACEMETA);
-
+
item = xmlnode_new_child(publish, "item");
xmlnode_set_attrib(item, "id", hash);
-
+
metadata = xmlnode_new_child(item, "metadata");
xmlnode_set_namespace(metadata,AVATARNAMESPACEMETA);
-
+
info = xmlnode_new_child(metadata, "info");
xmlnode_set_attrib(info, "id", hash);
xmlnode_set_attrib(info, "type", "image/png");
@@ -561,24 +564,24 @@ void jabber_set_buddy_icon(PurpleConnect
heightstring = g_strdup_printf("%u", height);
xmlnode_set_attrib(info, "height", heightstring);
g_free(heightstring);
-
+
/* publish the metadata */
jabber_pep_publish((JabberStream*)gc->proto_data, publish);
-
+
g_free(hash);
} else { /* if(img) */
/* remove the metadata */
xmlnode *metadata, *item;
xmlnode *publish = xmlnode_new("publish");
xmlnode_set_attrib(publish,"node",AVATARNAMESPACEMETA);
-
+
item = xmlnode_new_child(publish, "item");
-
+
metadata = xmlnode_new_child(item, "metadata");
xmlnode_set_namespace(metadata,AVATARNAMESPACEMETA);
-
+
xmlnode_new_child(metadata, "stop");
-
+
/* publish the metadata */
jabber_pep_publish((JabberStream*)gc->proto_data, publish);
}
@@ -1375,6 +1378,7 @@ static void jabber_vcard_parse(JabberStr
if( ((binval = xmlnode_get_child(child, "BINVAL")) &&
(bintext = xmlnode_get_data(binval))) ||
(bintext = xmlnode_get_data(child))) {
+ PurpleCipher *cipher;
gsize size;
guchar *data;
int i;
@@ -1389,9 +1393,12 @@ static void jabber_vcard_parse(JabberStr
"<b>%s:</b> <img id='%d'><br/>",
photo ? _("Photo") : _("Logo"),
GPOINTER_TO_INT(jbi->vcard_imgids->data));
-
- purple_cipher_digest_region("sha1", (guchar *)data, size,
- sizeof(hashval), hashval, NULL);
+
+ cipher = purple_sha1_cipher_new();
+ purple_cipher_append(cipher, (guchar *)data, size);
+ purple_cipher_digest(cipher, sizeof(hashval), hashval, NULL);
+ g_object_unref(G_OBJECT(cipher));
+
p = hash;
for(i=0; i<20; i++, p+=2)
snprintf(p, 3, "%02x", hashval[i]);
============================================================
--- libpurple/protocols/jabber/si.c 840b7c240f9c0f3c0bd1f0ffb2e8792f74d3f1f8
+++ libpurple/protocols/jabber/si.c 3f14aaa44a6d25661d49d5254e23d451da128673
@@ -23,12 +23,12 @@
#include "internal.h"
#include "blist.h"
-#include "cipher.h"
#include "debug.h"
#include "ft.h"
#include "request.h"
#include "network.h"
#include "notify.h"
+#include "sha1cipher.h"
#include "buddy.h"
#include "disco.h"
@@ -208,6 +208,8 @@ static void jabber_si_bytestreams_attemp
/* TODO: Deal with zeroconf */
if(dstjid != NULL && streamhost->host && streamhost->port > 0) {
+ PurpleCipher *cipher;
+
jsx->gpi = purple_proxy_info_new();
purple_proxy_info_set_type(jsx->gpi, PURPLE_PROXY_SOCKS5);
purple_proxy_info_set_host(jsx->gpi, streamhost->host);
@@ -221,8 +223,11 @@ static void jabber_si_bytestreams_attemp
dstaddr = g_strdup_printf("%s%s@%s/%s%s@%s/%s", jsx->stream_id, dstjid->node, dstjid->domain, dstjid->resource,
jsx->js->user->node, jsx->js->user->domain, jsx->js->user->resource);
- purple_cipher_digest_region("sha1", (guchar *)dstaddr, strlen(dstaddr),
- sizeof(hashval), hashval, NULL);
+ cipher = purple_sha1_cipher_new();
+ purple_cipher_append(cipher, (guchar *)dstaddr, strlen(dstaddr));
+ purple_cipher_digest(cipher, sizeof(hashval), hashval, NULL);
+ g_object_unref(G_OBJECT(cipher));
+
g_free(dstaddr);
dstaddr = g_malloc(41);
p = dstaddr;
@@ -344,6 +349,7 @@ jabber_si_xfer_bytestreams_send_read_aga
jabber_si_xfer_bytestreams_send_read_again_cb(gpointer data, gint source,
PurpleInputCondition cond)
{
+ PurpleCipher *cipher;
PurpleXfer *xfer = data;
JabberSIXfer *jsx = xfer->data;
int i;
@@ -406,8 +412,11 @@ jabber_si_xfer_bytestreams_send_read_aga
jsx->js->user->node, jsx->js->user->domain,
jsx->js->user->resource, xfer->who);
- purple_cipher_digest_region("sha1", (guchar *)dstaddr, strlen(dstaddr),
- sizeof(hashval), hashval, NULL);
+ cipher = purple_sha1_cipher_new();
+ purple_cipher_append(cipher, (guchar *)dstaddr, strlen(dstaddr));
+ purple_cipher_digest(cipher, sizeof(hashval), hashval, NULL);
+ g_object_unref(G_OBJECT(cipher));
+
g_free(dstaddr);
dstaddr = g_malloc(41);
p = dstaddr;
============================================================
--- libpurple/protocols/msn/msn.h dd2839c8e0ff2373f91d8757a85d934fda4d6b9f
+++ libpurple/protocols/msn/msn.h e072227c6b1493cd6631ad7d4997fdfc40a00092
@@ -43,13 +43,14 @@
#include "connection.h"
#include "conversation.h"
#include "debug.h"
-#include "cipher.h"
+#include "md5cipher.h"
#include "notify.h"
#include "privacy.h"
#include "proxy.h"
#include "prpl.h"
#include "request.h"
#include "servconn.h"
+#include "sha1cipher.h"
#include "sslconn.h"
#include "util.h"
============================================================
--- libpurple/protocols/msn/msnutils.c 10b96dd4da6fa65290b4ca3dcf04d4b8aed6c6fd
+++ libpurple/protocols/msn/msnutils.c 31d72a38c9a6c3116d221e569a1c579cf2d30989
@@ -512,7 +512,6 @@ msn_handle_chl(char *input, char *output
msn_handle_chl(char *input, char *output)
{
PurpleCipher *cipher;
- PurpleCipherContext *context;
char *productKey = MSNP13_WLM_PRODUCT_KEY,
*productID = MSNP13_WLM_PRODUCT_ID,
*hexChars = "0123456789abcdef",
@@ -525,16 +524,14 @@ msn_handle_chl(char *input, char *output
int i;
/* Create the MD5 hash by using Purple MD5 algorithm*/
- cipher = purple_ciphers_find_cipher("md5");
- context = purple_cipher_context_new(cipher, NULL);
+ cipher = purple_md5_cipher_new();
+ purple_cipher_append(cipher, (const guchar *)input,
+ strlen(input));
+ purple_cipher_append(cipher, (const guchar *)productKey,
+ strlen(productKey));
+ purple_cipher_digest(cipher, sizeof(md5Hash), md5Hash, NULL);
+ g_object_unref(G_OBJECT(cipher));
- purple_cipher_context_append(context, (const guchar *)input,
- strlen(input));
- purple_cipher_context_append(context, (const guchar *)productKey,
- strlen(productKey));
- purple_cipher_context_digest(context, sizeof(md5Hash), md5Hash, NULL);
- purple_cipher_context_destroy(context);
-
/* Split it into four integers */
md5Parts = (unsigned int *)md5Hash;
for(i=0; i<4; i++){
============================================================
--- libpurple/protocols/msnp9/msn.h b22e20e606eb32b0398e620861065293c19a5b1c
+++ libpurple/protocols/msnp9/msn.h 46510aa7b49f95efbe12f369236ca8256633a755
@@ -43,13 +43,14 @@
#include "connection.h"
#include "conversation.h"
#include "debug.h"
-#include "cipher.h"
+#include "md5cipher.h"
#include "notify.h"
#include "privacy.h"
#include "proxy.h"
#include "prpl.h"
#include "request.h"
#include "servconn.h"
+#include "sha1cipher.h"
#include "sslconn.h"
#include "util.h"
============================================================
--- libpurple/protocols/msnp9/notification.c c3dcbd019d45ecc26bdb68e5b8da748936ff9e98
+++ libpurple/protocols/msnp9/notification.c 0d38714b886b5d38659f34cb76fafb68cf40d6b6
@@ -408,22 +408,20 @@ chl_cmd(MsnCmdProc *cmdproc, MsnCommand
char buf[33];
const char *challenge_resp;
PurpleCipher *cipher;
- PurpleCipherContext *context;
guchar digest[16];
int i;
- cipher = purple_ciphers_find_cipher("md5");
- context = purple_cipher_context_new(cipher, NULL);
+ cipher = purple_md5_cipher_new();
- purple_cipher_context_append(context, (const guchar *)cmd->params[1],
- strlen(cmd->params[1]));
+ purple_cipher_append(cipher, (const guchar *)cmd->params[1],
+ strlen(cmd->params[1]));
challenge_resp = "VT6PX?UQTM4WM%YR";
- purple_cipher_context_append(context, (const guchar *)challenge_resp,
- strlen(challenge_resp));
- purple_cipher_context_digest(context, sizeof(digest), digest, NULL);
- purple_cipher_context_destroy(context);
+ purple_cipher_append(cipher, (const guchar *)challenge_resp,
+ strlen(challenge_resp));
+ purple_cipher_digest(cipher, sizeof(digest), digest, NULL);
+ g_object_unref(G_OBJECT(cipher));
for (i = 0; i < 16; i++)
g_snprintf(buf + (i*2), 3, "%02x", digest[i]);
@@ -998,7 +996,6 @@ url_cmd(MsnCmdProc *cmdproc, MsnCommand
const char *rru;
const char *url;
PurpleCipher *cipher;
- PurpleCipherContext *context;
guchar digest[16];
FILE *fd;
char *buf;
@@ -1017,13 +1014,11 @@ url_cmd(MsnCmdProc *cmdproc, MsnCommand
time(NULL) - session->passport_info.sl,
purple_connection_get_password(account->gc));
- cipher = purple_ciphers_find_cipher("md5");
- context = purple_cipher_context_new(cipher, NULL);
+ cipher = purple_md5_cipher_new();
+ purple_cipher_append(cipher, (const guchar *)buf, strlen(buf));
+ purple_cipher_digest(cipher, sizeof(digest), digest, NULL);
+ g_object_unref(G_OBJECT(cipher));
- purple_cipher_context_append(context, (const guchar *)buf, strlen(buf));
- purple_cipher_context_digest(context, sizeof(digest), digest, NULL);
- purple_cipher_context_destroy(context);
-
g_free(buf);
memset(sendbuf, 0, sizeof(sendbuf));
============================================================
--- libpurple/protocols/msnp9/user.c 58a59bd522734e7d219a276ce4ee6311a2982c42
+++ libpurple/protocols/msnp9/user.c 3f529cb37240ef84f4032a6c71910367c1d488f8
@@ -161,7 +161,7 @@ msn_user_set_buddy_icon(MsnUser *user, P
msn_user_set_object(user, NULL);
else
{
- PurpleCipherContext *ctx;
+ PurpleCipher *cipher;
char *buf;
gconstpointer data = purple_imgstore_get_data(img);
size_t size = purple_imgstore_get_size(img);
@@ -184,9 +184,9 @@ msn_user_set_buddy_icon(MsnUser *user, P
/* Compute the SHA1D field. */
memset(digest, 0, sizeof(digest));
- ctx = purple_cipher_context_new_by_name("sha1", NULL);
- purple_cipher_context_append(ctx, data, size);
- purple_cipher_context_digest(ctx, sizeof(digest), digest, NULL);
+ cipher = purple_sha1_cipher_new();
+ purple_cipher_append(cipher, data, size);
+ purple_cipher_digest(cipher, sizeof(digest), digest, NULL);
base64 = purple_base64_encode(digest, sizeof(digest));
msn_object_set_sha1d(msnobj, base64);
@@ -206,10 +206,11 @@ msn_user_set_buddy_icon(MsnUser *user, P
memset(digest, 0, sizeof(digest));
- purple_cipher_context_reset(ctx, NULL);
- purple_cipher_context_append(ctx, (const guchar *)buf, strlen(buf));
- purple_cipher_context_digest(ctx, sizeof(digest), digest, NULL);
- purple_cipher_context_destroy(ctx);
+ purple_cipher_reset(cipher);
+ purple_cipher_append(cipher, (const guchar *)buf, strlen(buf));
+ purple_cipher_digest(cipher, sizeof(digest), digest, NULL);
+ g_object_unref(G_OBJECT(cipher));
+
g_free(buf);
base64 = purple_base64_encode(digest, sizeof(digest));
============================================================
--- libpurple/protocols/myspace/myspace.c b8672d241bb608c52d3ce590017fef4d53863550
+++ libpurple/protocols/myspace/myspace.c 067d3a24c33f94098631120cce3aa602d9ccf804
@@ -105,16 +105,6 @@ msim_load(PurplePlugin *plugin)
gboolean
msim_load(PurplePlugin *plugin)
{
- /* If compiled to use RC4 from libpurple, check if it is really there. */
- if (!purple_ciphers_find_cipher("rc4")) {
- purple_debug_error("msim", "rc4 not in libpurple, but it is required - not loading MySpaceIM plugin!\n");
- purple_notify_error(plugin, _("Missing Cipher"),
- _("The RC4 cipher could not be found"),
- _("Upgrade "
- "to a libpurple with RC4 support (>= 2.0.1). MySpaceIM "
- "plugin will not be loaded."));
- return FALSE;
- }
return TRUE;
}
@@ -395,10 +385,7 @@ msim_compute_login_response(const gchar
msim_compute_login_response(const gchar nonce[2 * NONCE_SIZE],
const gchar *email, const gchar *password, guint *response_len)
{
- PurpleCipherContext *key_context;
- PurpleCipher *sha1;
- PurpleCipherContext *rc4;
-
+ PurpleCipher *cipher;
guchar hash_pw[HASH_SIZE];
guchar key[HASH_SIZE];
gchar *password_utf16le, *password_utf8_lc;
@@ -439,8 +426,12 @@ msim_compute_login_response(const gchar
}
/* Compute password hash */
- purple_cipher_digest_region("sha1", (guchar *)password_utf16le,
- conv_bytes_written, sizeof(hash_pw), hash_pw, NULL);
+ cipher = purple_sha1_cipher_new();
+ purple_cipher_append(cipher, (guchar *)password_utf16le,
+ conv_bytes_written);
+ purple_cipher_digest(cipher, sizeof(hash_pw), hash_pw, NULL);
+ purple_cipher_reset(cipher);
+
g_free(password_utf16le);
#ifdef MSIM_DEBUG_LOGIN_CHALLENGE
@@ -451,12 +442,10 @@ msim_compute_login_response(const gchar
#endif
/* key = sha1(sha1(pw) + nonce2) */
- sha1 = purple_ciphers_find_cipher("sha1");
- key_context = purple_cipher_context_new(sha1, NULL);
- purple_cipher_context_append(key_context, hash_pw, HASH_SIZE);
- purple_cipher_context_append(key_context, (guchar *)(nonce + NONCE_SIZE), NONCE_SIZE);
- purple_cipher_context_digest(key_context, sizeof(key), key, NULL);
- purple_cipher_context_destroy(key_context);
+ purple_cipher_append(cipher, hash_pw, HASH_SIZE);
+ purple_cipher_append(cipher, (guchar *)(nonce + NONCE_SIZE), NONCE_SIZE);
+ purple_cipher_digest(cipher, sizeof(key), key, NULL);
+ g_object_unref(G_OBJECT(cipher));
#ifdef MSIM_DEBUG_LOGIN_CHALLENGE
purple_debug_info("msim", "key = ");
@@ -466,12 +455,12 @@ msim_compute_login_response(const gchar
purple_debug_info("msim", "\n");
#endif
- rc4 = purple_cipher_context_new_by_name("rc4", NULL);
+ cipher = purple_rc4_cipher_new();
/* Note: 'key' variable is 0x14 bytes (from SHA-1 hash),
* but only first 0x10 used for the RC4 key. */
- purple_cipher_context_set_option(rc4, "key_len", (gpointer)0x10);
- purple_cipher_context_set_key(rc4, key);
+ purple_rc4_cipher_set_key_len(PURPLE_RC4_CIPHER(cipher), 0x10);
+ purple_cipher_set_key(cipher, key);
/* TODO: obtain IPs of network interfaces */
@@ -486,9 +475,10 @@ msim_compute_login_response(const gchar
data_out = g_new0(guchar, data_len);
- purple_cipher_context_encrypt(rc4, (const guchar *)data,
- data_len, data_out, &data_out_len);
- purple_cipher_context_destroy(rc4);
+ purple_cipher_encrypt(cipher, (const guchar *)data, data_len,
+ data_out, &data_out_len);
+ g_object_unref(G_OBJECT(cipher));
+
g_free(data);
if (data_out_len != data_len) {
============================================================
--- libpurple/protocols/myspace/myspace.h b562edaec50b976c20cdfe642b92f5560e438a96
+++ libpurple/protocols/myspace/myspace.h c171491f1dc21a9c48abcb910fae79aae33923a7
@@ -42,7 +42,8 @@
#include "plugin.h"
#include "accountopt.h"
#include "version.h"
-#include "cipher.h" /* for SHA-1 */
+#include "sha1cipher.h"
+#include "rc4cipher.h"
#include "util.h" /* for base64 */
#include "debug.h" /* for purple_debug_info */
#include "request.h" /* For dialogs used in setting the username */
============================================================
--- libpurple/protocols/oscar/family_auth.c fce284f373b96e23dd5d9a6e7445e4fb02d098af
+++ libpurple/protocols/oscar/family_auth.c cdbfd250aa495092440b3348c640abce3634b47a
@@ -82,17 +82,14 @@ aim_encode_password_md5(const char *pass
aim_encode_password_md5(const char *password, size_t password_len, const char *key, guint8 *digest)
{
PurpleCipher *cipher;
- PurpleCipherContext *context;
- cipher = purple_ciphers_find_cipher("md5");
+ cipher = purple_md5_cipher_new();
+ purple_cipher_append(cipher, (const guchar *)key, strlen(key));
+ purple_cipher_append(cipher, (const guchar *)password, password_len);
+ purple_cipher_append(cipher, (const guchar *)AIM_MD5_STRING, strlen(AIM_MD5_STRING));
+ purple_cipher_digest(cipher, 16, digest, NULL);
+ g_object_unref(G_OBJECT(cipher));
- context = purple_cipher_context_new(cipher, NULL);
- purple_cipher_context_append(context, (const guchar *)key, strlen(key));
- purple_cipher_context_append(context, (const guchar *)password, password_len);
- purple_cipher_context_append(context, (const guchar *)AIM_MD5_STRING, strlen(AIM_MD5_STRING));
- purple_cipher_context_digest(context, 16, digest, NULL);
- purple_cipher_context_destroy(context);
-
return 0;
}
#else
@@ -103,11 +100,10 @@ aim_encode_password_md5(const char *pass
guchar passdigest[16];
cipher = purple_md5_cipher_new();
- purple_cipher_append(cipher, (const guchar *)password, strlen(password));
+ purple_cipher_append(cipher, (const guchar *)password, password_len);
purple_cipher_digest(cipher, 16, passdigest, NULL);
- g_object_unref(G_OBJECT(cipher));
+ purple_cipher_reset(cipher);
- cipher = purple_md5_cipher_new();
purple_cipher_append(cipher, (const guchar *)key, strlen(key));
purple_cipher_append(cipher, passdigest, 16);
purple_cipher_append(cipher, (const guchar *)AIM_MD5_STRING, strlen(AIM_MD5_STRING));
============================================================
--- libpurple/protocols/oscar/family_oservice.c 7dd19dec0c78693a08241ac916bf63b7354920a8
+++ libpurple/protocols/oscar/family_oservice.c 842ae950d476ece654ea1264e6c19355d7743af9
@@ -960,7 +960,7 @@ aim_sendmemblock(OscarData *od, FlapConn
cipher = purple_md5_cipher_new();
purple_cipher_append(cipher, buf, len);
- purple_cipher_digest(cipher, 16, digest, NULL);
+ purple_cipher_digest(cipher, sizeof(digest), digest, NULL);
g_object_unref(G_OBJECT(cipher));
byte_stream_putraw(&frame->data, digest, 0x10);
@@ -976,7 +976,7 @@ aim_sendmemblock(OscarData *od, FlapConn
*/
cipher = purple_md5_cipher_new();
purple_cipher_append(cipher, &nil, 0);
- purple_cipher_digest(cipher, 16, digest, NULL);
+ purple_cipher_digest(cipher, sizeof(digest), digest, NULL);
g_object_unref(G_OBJECT(cipher));
byte_stream_putraw(&frame->data, digest, 0x10);
============================================================
--- libpurple/protocols/oscar/oscar.c 4e67797db258208c9e40fad59d82c76739f8f2a0
+++ libpurple/protocols/oscar/oscar.c 4b4a39ce2bbe0f8825bdf40c04f187abdf0a0f86
@@ -33,11 +33,11 @@
#include "account.h"
#include "accountopt.h"
#include "buddyicon.h"
-#include "md5cipher.h"
#include "conversation.h"
#include "core.h"
#include "debug.h"
#include "imgstore.h"
+#include "md5cipher.h"
#include "network.h"
#include "notify.h"
#include "privacy.h"
@@ -6387,10 +6387,9 @@ void oscar_set_icon(PurpleConnection *gc
gconstpointer data = purple_imgstore_get_data(img);
size_t len = purple_imgstore_get_size(img);
-
cipher = purple_md5_cipher_new();
purple_cipher_append(cipher, data, len);
- purple_cipher_digest(cipher, 16, md5, NULL);
+ purple_cipher_digest(cipher, sizeof(md5), md5, NULL);
g_object_unref(G_OBJECT(cipher));
aim_ssi_seticon(od, md5, 16);
============================================================
--- libpurple/protocols/qq/file_trans.c c07f767a88ac2ed8eba476e440885c922c8226e8
+++ libpurple/protocols/qq/file_trans.c 1d64f5a5b3e082e9f73a750cdbe4b94e5b08ae32
@@ -30,7 +30,7 @@
#include "debug.h"
#include "ft.h"
-#include "cipher.h"
+#include "md5cipher.h"
#include "crypt.h"
#include "file_trans.h"
@@ -80,15 +80,13 @@ static void _fill_filename_md5(const gch
static void _fill_filename_md5(const gchar *filename, guint8 *md5)
{
PurpleCipher *cipher;
- PurpleCipherContext *context;
g_return_if_fail(filename != NULL && md5 != NULL);
- cipher = purple_ciphers_find_cipher("md5");
- context = purple_cipher_context_new(cipher, NULL);
- purple_cipher_context_append(context, (guint8 *) filename, strlen(filename));
- purple_cipher_context_digest(context, 16, md5, NULL);
- purple_cipher_context_destroy(context);
+ cipher = purple_md5_cipher_new();
+ purple_cipher_append(cipher, (guint8 *) filename, strlen(filename));
+ purple_cipher_digest(cipher, sizeof(md5), md5, NULL);
+ g_object_unref(G_OBJECT(cipher));
}
static void _fill_file_md5(const gchar *filename, gint filelen, guint8 *md5)
@@ -96,7 +94,6 @@ static void _fill_file_md5(const gchar *
FILE *fp;
guint8 *buffer;
PurpleCipher *cipher;
- PurpleCipherContext *context;
size_t wc;
const gint QQ_MAX_FILE_MD5_LENGTH = 10002432;
@@ -119,11 +116,10 @@ static void _fill_file_md5(const gchar *
return;
}
- cipher = purple_ciphers_find_cipher("md5");
- context = purple_cipher_context_new(cipher, NULL);
- purple_cipher_context_append(context, buffer, filelen);
- purple_cipher_context_digest(context, 16, md5, NULL);
- purple_cipher_context_destroy(context);
+ cipher = purple_md5_cipher_new();
+ purple_cipher_append(cipher, buffer, filelen);
+ purple_cipher_digest(cipher, sizeof(md5), md5, NULL);
+ g_object_unref(G_OBJECT(cipher));
}
static void _qq_get_file_header(guint8 *buf, guint8 **cursor, gint buflen, qq_file_header *fh)
============================================================
--- libpurple/protocols/qq/qq_proxy.c 2b7c9840bf73eaaf32c89abf28d68c8e38a906be
+++ libpurple/protocols/qq/qq_proxy.c 585d9b3b6549c2deaad7660849a232e6eeff903b
@@ -78,9 +78,8 @@ static guint8 *_gen_pwkey(const gchar *p
cipher = purple_md5_cipher_new();
purple_cipher_append(cipher, (guchar *) pwd, strlen(pwd));
purple_cipher_digest(cipher, sizeof(pwkey_tmp), pwkey_tmp, NULL);
- g_object_unref(G_OBJECT(cipher));
+ purple_cipher_reset(cipher);
- cipher = purple_md5_cipher_new();
purple_cipher_append(cipher, pwkey_tmp, QQ_KEY_LENGTH);
purple_cipher_digest(cipher, sizeof(pwkey_tmp), pwkey_tmp, NULL);
g_object_unref(G_OBJECT(cipher));
============================================================
--- libpurple/protocols/simple/simple.c dedb5a17539196a0240a92ac86947dee2bc27768
+++ libpurple/protocols/simple/simple.c 892323a64f84f293e2ea3be5e33b86a0cb76ca8b
@@ -273,7 +273,7 @@ static gchar *auth_header(struct simple_
if(auth->type == 1) { /* Digest */
sprintf(noncecount, "%08d", auth->nc++);
- response = purple_cipher_http_digest_calculate_response(
+ response = purple_http_digest_calculate_response(
"md5", method, target, NULL, NULL,
auth->nonce, noncecount, NULL, auth->digest_session_key);
purple_debug(PURPLE_DEBUG_MISC, "simple", "response %s\n", response);
@@ -294,7 +294,7 @@ static gchar *auth_header(struct simple_
}
sprintf(noncecount, "%08d", auth->nc++);
- response = purple_cipher_http_digest_calculate_response(
+ response = purple_http_digest_calculate_response(
"md5", method, target, NULL, NULL,
auth->nonce, noncecount, NULL, auth->digest_session_key);
purple_debug(PURPLE_DEBUG_MISC, "simple", "response %s\n", response);
@@ -387,7 +387,7 @@ static void fill_auth(struct simple_acco
purple_debug(PURPLE_DEBUG_MISC, "simple", "nonce: %s realm: %s\n", auth->nonce ? auth->nonce : "(null)", auth->realm ? auth->realm : "(null)");
if(auth->realm) {
- auth->digest_session_key = purple_cipher_http_digest_calculate_session_key(
+ auth->digest_session_key = purple_http_digest_calculate_session_key(
"md5", authuser, auth->realm, sip->password, auth->nonce, NULL);
auth->nc = 1;
============================================================
--- libpurple/protocols/yahoo/yahoo.c aeef64612853baa5a062a60991d7179b070b574e
+++ libpurple/protocols/yahoo/yahoo.c d5343fa9e610d081bdea626f4199f0bff70ecdc6
@@ -26,16 +26,17 @@
#include "account.h"
#include "accountopt.h"
#include "blist.h"
-#include "cipher.h"
#include "cmds.h"
#include "core.h"
#include "debug.h"
+#include "md5cipher.h"
#include "notify.h"
#include "privacy.h"
#include "prpl.h"
#include "proxy.h"
#include "request.h"
#include "server.h"
+#include "sha1cipher.h"
#include "util.h"
#include "version.h"
@@ -1384,7 +1385,6 @@ static void yahoo_process_auth_old(Purpl
*/
PurpleCipher *cipher;
- PurpleCipherContext *context;
guchar digest[16];
char *crypt_result;
@@ -1403,19 +1403,16 @@ static void yahoo_process_auth_old(Purpl
sv = seed[15];
sv = sv % 8;
- cipher = purple_ciphers_find_cipher("md5");
- context = purple_cipher_context_new(cipher, NULL);
-
- purple_cipher_context_append(context, (const guchar *)pass, strlen(pass));
- purple_cipher_context_digest(context, sizeof(digest), digest, NULL);
-
+ cipher = purple_md5_cipher_new();
+ purple_cipher_append(cipher, (const guchar *)pass, strlen(pass));
+ purple_cipher_digest(cipher, sizeof(digest), digest, NULL);
to_y64(password_hash, digest, 16);
crypt_result = yahoo_crypt(pass, "$1$_2S43d5f$");
- purple_cipher_context_reset(context, NULL);
- purple_cipher_context_append(context, (const guchar *)crypt_result, strlen(crypt_result));
- purple_cipher_context_digest(context, sizeof(digest), digest, NULL);
+ purple_cipher_reset(cipher);
+ purple_cipher_append(cipher, (const guchar *)crypt_result, strlen(crypt_result));
+ purple_cipher_digest(cipher, sizeof(digest), digest, NULL);
to_y64(crypt_hash, digest, 16);
switch (sv) {
@@ -1459,15 +1456,15 @@ static void yahoo_process_auth_old(Purpl
break;
}
- purple_cipher_context_reset(context, NULL);
- purple_cipher_context_append(context, (const guchar *)hash_string_p, strlen(hash_string_p));
- purple_cipher_context_digest(context, sizeof(digest), digest, NULL);
+ purple_cipher_reset(cipher);
+ purple_cipher_append(cipher, (const guchar *)hash_string_p, strlen(hash_string_p));
+ purple_cipher_digest(cipher, sizeof(digest), digest, NULL);
to_y64(result6, digest, 16);
- purple_cipher_context_reset(context, NULL);
- purple_cipher_context_append(context, (const guchar *)hash_string_c, strlen(hash_string_c));
- purple_cipher_context_digest(context, sizeof(digest), digest, NULL);
- purple_cipher_context_destroy(context);
+ purple_cipher_reset(cipher);
+ purple_cipher_append(cipher, (const guchar *)hash_string_c, strlen(hash_string_c));
+ purple_cipher_digest(cipher, sizeof(digest), digest, NULL);
+ g_object_unref(G_OBJECT(cipher));
to_y64(result96, digest, 16);
pack = yahoo_packet_new(YAHOO_SERVICE_AUTHRESP, YAHOO_STATUS_AVAILABLE, 0);
@@ -1508,12 +1505,9 @@ static void yahoo_process_auth_new(Purpl
struct yahoo_data *yd = gc->proto_data;
PurpleCipher *md5_cipher;
- PurpleCipherContext *md5_ctx;
guchar md5_digest[16];
- PurpleCipher *sha1_cipher;
- PurpleCipherContext *sha1_ctx1;
- PurpleCipherContext *sha1_ctx2;
+ PurpleCipher *sha1_cipher1, *sha1_cipher2;
char *alphabet1 = "FBZDWAGHrJTLMNOPpRSKUVEXYChImkwQ";
char *alphabet2 = "F0E1D2C3B4A59687abcdefghijklmnop";
@@ -1563,12 +1557,10 @@ static void yahoo_process_auth_new(Purpl
memset(&magic_key_char, 0, 4);
memset(&comparison_src, 0, 20);
- md5_cipher = purple_ciphers_find_cipher("md5");
- md5_ctx = purple_cipher_context_new(md5_cipher, NULL);
+ md5_cipher = purple_md5_cipher_new();
- sha1_cipher = purple_ciphers_find_cipher("sha1");
- sha1_ctx1 = purple_cipher_context_new(sha1_cipher, NULL);
- sha1_ctx2 = purple_cipher_context_new(sha1_cipher, NULL);
+ sha1_cipher1 = purple_sha1_cipher_new();
+ sha1_cipher2 = purple_sha1_cipher_new();
/*
* Magic: Phase 1. Generate what seems to be a 30 byte value (could change if base64
@@ -1705,10 +1697,10 @@ static void yahoo_process_auth_new(Purpl
test[1] = x >> 8;
test[2] = y;
- purple_cipher_context_reset(md5_ctx, NULL);
- purple_cipher_context_append(md5_ctx, magic_key_char, 4);
- purple_cipher_context_append(md5_ctx, test, 3);
- purple_cipher_context_digest(md5_ctx, sizeof(md5_digest),
+ purple_cipher_reset(md5_cipher);
+ purple_cipher_append(md5_cipher, magic_key_char, 4);
+ purple_cipher_append(md5_cipher, test, 3);
+ purple_cipher_digest(md5_cipher, sizeof(md5_digest),
md5_digest, NULL);
if (!memcmp(md5_digest, comparison_src+4, 16)) {
@@ -1740,9 +1732,9 @@ static void yahoo_process_auth_new(Purpl
enc_pass = yahoo_string_encode(gc, pass, NULL);
/* Get password and crypt hashes as per usual. */
- purple_cipher_context_reset(md5_ctx, NULL);
- purple_cipher_context_append(md5_ctx, (const guchar *)enc_pass, strlen(enc_pass));
- purple_cipher_context_digest(md5_ctx, sizeof(md5_digest),
+ purple_cipher_reset(md5_cipher);
+ purple_cipher_append(md5_cipher, (const guchar *)enc_pass, strlen(enc_pass));
+ purple_cipher_digest(md5_cipher, sizeof(md5_digest),
md5_digest, NULL);
to_y64(password_hash, md5_digest, 16);
@@ -1751,9 +1743,9 @@ static void yahoo_process_auth_new(Purpl
g_free(enc_pass);
enc_pass = NULL;
- purple_cipher_context_reset(md5_ctx, NULL);
- purple_cipher_context_append(md5_ctx, (const guchar *)crypt_result, strlen(crypt_result));
- purple_cipher_context_digest(md5_ctx, sizeof(md5_digest),
+ purple_cipher_reset(md5_cipher);
+ purple_cipher_append(md5_cipher, (const guchar *)crypt_result, strlen(crypt_result));
+ purple_cipher_digest(md5_cipher, sizeof(md5_digest),
md5_digest, NULL);
to_y64(crypt_hash, md5_digest, 16);
@@ -1777,20 +1769,21 @@ static void yahoo_process_auth_new(Purpl
* which we previously extrapolated from our challenge.
*/
- purple_cipher_context_append(sha1_ctx1, pass_hash_xor1, 64);
+ purple_cipher_append(sha1_cipher1, pass_hash_xor1, 64);
if (y >= 3)
- purple_cipher_context_set_option(sha1_ctx1, "sizeLo", GINT_TO_POINTER(0x1ff));
- purple_cipher_context_append(sha1_ctx1, magic_key_char, 4);
- purple_cipher_context_digest(sha1_ctx1, sizeof(digest1), digest1, NULL);
+ purple_sha1_cipher_set_size_lo(PURPLE_SHA1_CIPHER(sha1_cipher1),
+ 0x1ff);
+ purple_cipher_append(sha1_cipher1, magic_key_char, 4);
+ purple_cipher_digest(sha1_cipher1, sizeof(digest1), digest1, NULL);
/*
* The second context gets the password hash XORed with 0x5c plus the SHA-1 digest
* of the first context.
*/
- purple_cipher_context_append(sha1_ctx2, pass_hash_xor2, 64);
- purple_cipher_context_append(sha1_ctx2, digest1, 20);
- purple_cipher_context_digest(sha1_ctx2, sizeof(digest2), digest2, NULL);
+ purple_cipher_append(sha1_cipher2, pass_hash_xor2, 64);
+ purple_cipher_append(sha1_cipher2, digest1, 20);
+ purple_cipher_digest(sha1_cipher2, sizeof(digest2), digest2, NULL);
/*
* Now that we have digest2, use it to fetch characters from an alphabet to construct
@@ -1860,30 +1853,30 @@ static void yahoo_process_auth_new(Purpl
if (cnt < 64)
memset(&(crypt_hash_xor2[cnt]), 0x5c, 64-cnt);
- purple_cipher_context_reset(sha1_ctx1, NULL);
- purple_cipher_context_reset(sha1_ctx2, NULL);
+ purple_cipher_reset(sha1_cipher1);
+ purple_cipher_reset(sha1_cipher2);
/*
* The first context gets the password hash XORed with 0x36 plus a magic value
* which we previously extrapolated from our challenge.
*/
- purple_cipher_context_append(sha1_ctx1, crypt_hash_xor1, 64);
+ purple_cipher_append(sha1_cipher1, crypt_hash_xor1, 64);
if (y >= 3) {
- purple_cipher_context_set_option(sha1_ctx1, "sizeLo",
- GINT_TO_POINTER(0x1ff));
+ purple_sha1_cipher_set_size_lo(PURPLE_SHA1_CIPHER(sha1_cipher1),
+ 0x1ff);
}
- purple_cipher_context_append(sha1_ctx1, magic_key_char, 4);
- purple_cipher_context_digest(sha1_ctx1, sizeof(digest1), digest1, NULL);
+ purple_cipher_append(sha1_cipher1, magic_key_char, 4);
+ purple_cipher_digest(sha1_cipher1, sizeof(digest1), digest1, NULL);
/*
* The second context gets the password hash XORed with 0x5c plus the SHA-1 digest
* of the first context.
*/
- purple_cipher_context_append(sha1_ctx2, crypt_hash_xor2, 64);
- purple_cipher_context_append(sha1_ctx2, digest1, 20);
- purple_cipher_context_digest(sha1_ctx2, sizeof(digest2), digest2, NULL);
+ purple_cipher_append(sha1_cipher2, crypt_hash_xor2, 64);
+ purple_cipher_append(sha1_cipher2, digest1, 20);
+ purple_cipher_digest(sha1_cipher2, sizeof(digest2), digest2, NULL);
/*
* Now that we have digest2, use it to fetch characters from an alphabet to construct
@@ -1957,9 +1950,9 @@ static void yahoo_process_auth_new(Purpl
yahoo_packet_send_and_free(pack, yd);
- purple_cipher_context_destroy(md5_ctx);
- purple_cipher_context_destroy(sha1_ctx1);
- purple_cipher_context_destroy(sha1_ctx2);
+ g_object_unref(G_OBJECT(md5_cipher));
+ g_object_unref(G_OBJECT(sha1_cipher1));
+ g_object_unref(G_OBJECT(sha1_cipher2));
g_free(password_hash);
g_free(crypt_hash);
============================================================
--- libpurple/tests/check_libpurple.c 99b69c13102682bc20ba388e508b3e7bcb99792d
+++ libpurple/tests/check_libpurple.c b1ecf63ea1acb62fac698dc01bb74ee09507a791
@@ -70,6 +70,8 @@ int main(void)
* by PURPLE_FATAL_ASSERTS. */
g_log_set_always_fatal(G_LOG_LEVEL_CRITICAL);
+ g_type_init();
+
sr = srunner_create (master_suite());
srunner_add_suite(sr, cipher_suite());
============================================================
--- libpurple/tests/test_cipher.c c0634d1d11fbcdf7a59d90298dfe37837333cbbb
+++ libpurple/tests/test_cipher.c d70f9403f314a3d513938a82a1d7582ed941a366
@@ -191,7 +191,6 @@ END_TEST
*****************************************************************************/
#define DES_TEST(in, keyz, out, len) { \
PurpleCipher *cipher = NULL; \
- PurpleCipherContext *context = NULL; \
guchar answer[len+1]; \
gint ret = 0; \
guchar decrypt[len+1] = in; \
@@ -199,21 +198,20 @@ END_TEST
guchar encrypt[len+1] = out;\
size_t outlen; \
\
- cipher = purple_ciphers_find_cipher("des"); \
- context = purple_cipher_context_new(cipher, NULL); \
- purple_cipher_context_set_key(context, key); \
+ cipher = purple_des_cipher_new(); \
+ purple_cipher_set_key(cipher, key); \
\
- ret = purple_cipher_context_encrypt(context, decrypt, len, answer, &outlen); \
+ ret = purple_cipher_encrypt(cipher, decrypt, len, answer, &outlen); \
fail_unless(ret == 0, NULL); \
fail_unless(outlen == (len), NULL); \
fail_unless(memcmp(encrypt, answer, len) == 0, NULL); \
\
- ret = purple_cipher_context_decrypt(context, encrypt, len, answer, &outlen); \
+ ret = purple_cipher_decrypt(cipher, encrypt, len, answer, &outlen); \
fail_unless(ret == 0, NULL); \
fail_unless(outlen == (len), NULL); \
fail_unless(memcmp(decrypt, answer, len) == 0, NULL); \
\
- purple_cipher_context_destroy(context); \
+ g_object_unref(G_OBJECT(cipher)); \
}
START_TEST(test_des_12345678) {
@@ -240,30 +238,28 @@ END_TEST
#define DES3_TEST(in, key, iv, out, len, mode) { \
PurpleCipher *cipher = NULL; \
- PurpleCipherContext *context = NULL; \
guchar answer[len+1]; \
guchar decrypt[len+1] = in; \
guchar encrypt[len+1] = out; \
size_t outlen; \
gint ret = 0; \
\
- cipher = purple_ciphers_find_cipher("des3"); \
- context = purple_cipher_context_new(cipher, NULL); \
- purple_cipher_context_set_key(context, (guchar *)key); \
- purple_cipher_context_set_batch_mode(context, (mode)); \
- purple_cipher_context_set_iv(context, (guchar *)iv, 8); \
+ cipher = purple_des3_cipher_new(); \
+ purple_cipher_set_key(cipher, (guchar *)key); \
+ purple_cipher_set_batch_mode(cipher, (mode)); \
+ purple_cipher_set_iv(cipher, (guchar *)iv, 8); \
\
- ret = purple_cipher_context_encrypt(context, decrypt, len, answer, &outlen); \
+ ret = purple_cipher_encrypt(cipher, decrypt, len, answer, &outlen); \
fail_unless(ret == 0, NULL); \
fail_unless(outlen == (len), NULL); \
fail_unless(memcmp(encrypt, answer, len) == 0, NULL); \
\
- ret = purple_cipher_context_decrypt(context, encrypt, len, answer, &outlen); \
+ ret = purple_cipher_decrypt(cipher, encrypt, len, answer, &outlen); \
fail_unless(ret == 0, NULL); \
fail_unless(outlen == (len), NULL); \
fail_unless(memcmp(decrypt, answer, len) == 0, NULL); \
\
- purple_cipher_context_destroy(context); \
+ g_object_unref(G_OBJECT(cipher)); \
}
START_TEST(test_des3_ecb_nist1) {
@@ -409,25 +405,23 @@ END_TEST
* See RFC2202 and some other NULL tests I made up
*****************************************************************************/
-#define HMAC_TEST(data, data_len, key, key_len, type, digest) { \
+#define HMAC_TEST(data, data_len, key, key_len, hash, digest) { \
PurpleCipher *cipher = NULL; \
- PurpleCipherContext *context = NULL; \
gchar cdigest[41]; \
gboolean ret = FALSE; \
\
- cipher = purple_ciphers_find_cipher("hmac"); \
- context = purple_cipher_context_new(cipher, NULL); \
- purple_cipher_context_set_option(context, "hash", type); \
- purple_cipher_context_set_key_with_len(context, (guchar *)key, (key_len)); \
+ cipher = purple_hmac_cipher_new(); \
+ purple_cipher_set_hash(cipher, (hash)); \
+ purple_cipher_set_key_with_len(cipher, (guchar *)(key), (key_len)); \
\
- purple_cipher_context_append(context, (guchar *)(data), (data_len)); \
- ret = purple_cipher_context_digest_to_str(context, sizeof(cdigest), cdigest, \
- NULL); \
+ purple_cipher_append(cipher, (guchar *)(data), (data_len)); \
+ ret = purple_cipher_digest_to_str(cipher, sizeof(cdigest), cdigest, \
+ NULL); \
\
fail_unless(ret == TRUE, NULL); \
fail_unless(strcmp((digest), cdigest) == 0, NULL); \
\
- purple_cipher_context_destroy(context); \
+ g_object_unref(G_OBJECT(cipher)); \
}
/* HMAC MD5 */
@@ -437,7 +431,7 @@ START_TEST(test_hmac_md5_Hi) {
8,
"\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b",
16,
- "md5",
+ purple_md5_cipher_new(),
"9294727a3638bb1c13f48ef8158bfc9d");
}
END_TEST
@@ -447,7 +441,7 @@ START_TEST(test_hmac_md5_what) {
28,
"Jefe",
4,
- "md5",
+ purple_md5_cipher_new(),
"750c783e6ab0b503eaa86e310a5db738");
}
END_TEST
@@ -461,7 +455,7 @@ START_TEST(test_hmac_md5_dd) {
50,
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa",
16,
- "md5",
+ purple_md5_cipher_new(),
"56be34521d144c88dbb8c733f0e8b3f6");
}
END_TEST
@@ -477,7 +471,7 @@ START_TEST(test_hmac_md5_cd) {
"\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14"
"\x15\x16\x17\x18\x19",
25,
- "md5",
+ purple_md5_cipher_new(),
"697eaf0aca3a3aea3a75164746ffaa79");
}
END_TEST
@@ -487,7 +481,7 @@ START_TEST(test_hmac_md5_truncation) {
20,
"\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c",
16,
- "md5",
+ purple_md5_cipher_new(),
"56461ef2342edc00f9bab995690efd4c");
}
END_TEST
@@ -504,7 +498,7 @@ START_TEST(test_hmac_md5_large_key) {
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa",
80,
- "md5",
+ purple_md5_cipher_new(),
"6b1ab7fe4bd7bf8f0b62e6ce61b9d0cd");
}
END_TEST
@@ -521,7 +515,7 @@ START_TEST(test_hmac_md5_large_key_and_d
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa",
80,
- "md5",
+ purple_md5_cipher_new(),
"6f630fad67cda0ee1fb1f562db3aa53e");
}
END_TEST
@@ -532,7 +526,7 @@ START_TEST(test_hmac_md5_null_key) {
"\x0a\x0b\x00\x0d\x0e\x0f\x1a\x2f\x0b\x0b"
"\x0b\x00\x00\x0b\x0b\x49\x5f\x6e\x0b\x0b",
20,
- "md5",
+ purple_md5_cipher_new(),
"597bfd644b797a985561eeb03a169e59");
}
END_TEST
@@ -543,7 +537,7 @@ START_TEST(test_hmac_md5_null_text) {
"\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
"\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b",
20,
- "md5",
+ purple_md5_cipher_new(),
"70be8e1b7b50dfcc335d6cd7992c564f");
}
END_TEST
@@ -554,7 +548,7 @@ START_TEST(test_hmac_md5_null_key_and_te
"\x0c\x0d\x00\x0f\x10\x1a\x3a\x3a\xe6\x34"
"\x0b\x00\x00\x0b\x0b\x49\x5f\x6e\x0b\x0b",
20,
- "md5",
+ purple_md5_cipher_new(),
"b31bcbba35a33a067cbba9131cba4889");
}
END_TEST
@@ -567,7 +561,7 @@ START_TEST(test_hmac_sha1_Hi) {
"\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
"\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b",
20,
- "sha1",
+ purple_sha1_cipher_new(),
"b617318655057264e28bc0b6fb378c8ef146be00");
}
END_TEST
@@ -577,7 +571,7 @@ START_TEST(test_hmac_sha1_what) {
28,
"Jefe",
4,
- "sha1",
+ purple_sha1_cipher_new(),
"effcdf6ae5eb2fa2d27416d5f184df9c259a7c79");
}
END_TEST
@@ -592,7 +586,7 @@ START_TEST(test_hmac_sha1_dd) {
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa",
20,
- "sha1",
+ purple_sha1_cipher_new(),
"125d7342b9ac11cd91a39af48aa17b4f63f175d3");
}
END_TEST
@@ -608,7 +602,7 @@ START_TEST(test_hmac_sha1_cd) {
"\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14"
"\x15\x16\x17\x18\x19",
25,
- "sha1",
+ purple_sha1_cipher_new(),
"4c9007f4026250c6bc8414f9bf50c86c2d7235da");
}
END_TEST
@@ -619,7 +613,7 @@ START_TEST(test_hmac_sha1_truncation) {
"\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c"
"\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c",
20,
- "sha1",
+ purple_sha1_cipher_new(),
"4c1a03424b55e07fe7f27be1d58bb9324a9a5a04");
}
END_TEST
@@ -636,7 +630,7 @@ START_TEST(test_hmac_sha1_large_key) {
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa",
80,
- "sha1",
+ purple_sha1_cipher_new(),
"aa4ae5e15272d00e95705637ce8a3b55ed402112");
}
END_TEST
@@ -653,7 +647,7 @@ START_TEST(test_hmac_sha1_large_key_and_
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa",
80,
- "sha1",
+ purple_sha1_cipher_new(),
"e8e99d0f45237d786d6bbaa7965c7808bbff1a91");
}
END_TEST
@@ -664,7 +658,7 @@ START_TEST(test_hmac_sha1_null_key) {
"\x0a\x0b\x00\x0d\x0e\x0f\x1a\x2f\x0b\x0b"
"\x0b\x00\x00\x0b\x0b\x49\x5f\x6e\x0b\x0b",
20,
- "sha1",
+ purple_sha1_cipher_new(),
"eb62a2e0e33d300be669c52aab3f591bc960aac5");
}
END_TEST
@@ -675,7 +669,7 @@ START_TEST(test_hmac_sha1_null_text) {
"\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
"\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b",
20,
- "sha1",
+ purple_sha1_cipher_new(),
"31ca58d849e971e418e3439de2c6f83144b6abb7");
}
END_TEST
@@ -686,7 +680,7 @@ START_TEST(test_hmac_sha1_null_key_and_t
"\x0c\x0d\x00\x0f\x10\x1a\x3a\x3a\xe6\x34"
"\x0b\x00\x00\x0b\x0b\x49\x5f\x6e\x0b\x0b",
20,
- "sha1",
+ purple_sha1_cipher_new(),
"e6b8e2fede87aa09dcb13e554df1435e056eae36");
}
END_TEST
@@ -743,6 +737,7 @@ cipher_suite(void) {
tcase_add_test(tc, test_des3_ecb_null_text);
tcase_add_test(tc, test_des3_ecb_null_key_and_text);
suite_add_tcase(s, tc);
+
/* des3 cbc tests */
tc = tcase_create("DES3 CBC");
tcase_add_test(tc, test_des3_cbc_nist1);
============================================================
--- libpurple/util.c 7dbe57fecdbb5f2c2e1b6552128a885bae9baf07
+++ libpurple/util.c a53ba14cd627d17159d10a80463ddd65abf3a52e
@@ -26,6 +26,7 @@
#include "conversation.h"
#include "core.h"
#include "debug.h"
+#include "md5cipher.h"
#include "notify.h"
#include "prpl.h"
#include "prefs.h"
@@ -4691,3 +4692,160 @@ char * purple_util_format_song_info(cons
return g_string_free(string, FALSE);
}
+/**************************************************************************
+ * HTTP Digest Functions
+ **************************************************************************/
+gchar *purple_http_digest_calculate_session_key(
+ const gchar *algorithm,
+ const gchar *username,
+ const gchar *realm,
+ const gchar *password,
+ const gchar *nonce,
+ const gchar *client_nonce)
+{
+ PurpleCipher *cipher;
+ gchar hash[33]; /* We only support MD5. */
+
+ g_return_val_if_fail(username != NULL, NULL);
+ g_return_val_if_fail(realm != NULL, NULL);
+ g_return_val_if_fail(password != NULL, NULL);
+ g_return_val_if_fail(nonce != NULL, NULL);
+
+ /* Check for a supported algorithm. */
+ g_return_val_if_fail(algorithm == NULL ||
+ *algorithm == '\0' ||
+ g_ascii_strcasecmp(algorithm, "MD5") ||
+ g_ascii_strcasecmp(algorithm, "MD5-sess"), NULL);
+
+ cipher = purple_md5_cipher_new();
+ purple_cipher_append(cipher, (guchar *)username, strlen(username));
+ purple_cipher_append(cipher, (guchar *)":", 1);
+ purple_cipher_append(cipher, (guchar *)realm, strlen(realm));
+ purple_cipher_append(cipher, (guchar *)":", 1);
+ purple_cipher_append(cipher, (guchar *)password, strlen(password));
+
+ if (algorithm != NULL && !g_ascii_strcasecmp(algorithm, "MD5-sess"))
+ {
+ guchar digest[16];
+
+ if (client_nonce == NULL)
+ {
+ g_object_unref(G_OBJECT(cipher));
+ purple_debug_error("cipher", "Required client_nonce missing for MD5-sess digest calculation.\n");
+ return NULL;
+ }
+
+ purple_cipher_digest(cipher, sizeof(digest), digest, NULL);
+ purple_cipher_reset(cipher);
+
+ purple_cipher_append(cipher, digest, sizeof(digest));
+ purple_cipher_append(cipher, (guchar *)":", 1);
+ purple_cipher_append(cipher, (guchar *)nonce, strlen(nonce));
+ purple_cipher_append(cipher, (guchar *)":", 1);
+ purple_cipher_append(cipher, (guchar *)client_nonce, strlen(client_nonce));
+ }
+
+ purple_cipher_digest_to_str(cipher, sizeof(hash), hash, NULL);
+ g_object_unref(G_OBJECT(cipher));
+
+ return g_strdup(hash);
+}
+
+gchar *purple_http_digest_calculate_response(
+ const gchar *algorithm,
+ const gchar *method,
+ const gchar *digest_uri,
+ const gchar *qop,
+ const gchar *entity,
+ const gchar *nonce,
+ const gchar *nonce_count,
+ const gchar *client_nonce,
+ const gchar *session_key)
+{
+ PurpleCipher *cipher;
+ static gchar hash2[33]; /* We only support MD5. */
+
+ g_return_val_if_fail(method != NULL, NULL);
+ g_return_val_if_fail(digest_uri != NULL, NULL);
+ g_return_val_if_fail(nonce != NULL, NULL);
+ g_return_val_if_fail(session_key != NULL, NULL);
+
+ /* Check for a supported algorithm. */
+ g_return_val_if_fail(algorithm == NULL ||
+ *algorithm == '\0' ||
+ g_ascii_strcasecmp(algorithm, "MD5") ||
+ g_ascii_strcasecmp(algorithm, "MD5-sess"), NULL);
+
+ /* Check for a supported "quality of protection". */
+ g_return_val_if_fail(qop == NULL ||
+ *qop == '\0' ||
+ g_ascii_strcasecmp(qop, "auth") ||
+ g_ascii_strcasecmp(qop, "auth-int"), NULL);
+
+ cipher = purple_md5_cipher_new();
+
+ purple_cipher_append(cipher, (guchar *)method, strlen(method));
+ purple_cipher_append(cipher, (guchar *)":", 1);
+ purple_cipher_append(cipher, (guchar *)digest_uri, strlen(digest_uri));
+
+ if (qop != NULL && !g_ascii_strcasecmp(qop, "auth-int"))
+ {
+ PurpleCipher *cipher2;
+ gchar entity_hash[33];
+
+ if (entity == NULL)
+ {
+ g_object_unref(G_OBJECT(cipher));
+ purple_debug_error("cipher", "Required entity missing for auth-int digest calculation.\n");
+ return NULL;
+ }
+
+ cipher2 = purple_md5_cipher_new();
+ purple_cipher_append(cipher2, (guchar *)entity, strlen(entity));
+ purple_cipher_digest_to_str(cipher2, sizeof(entity_hash), entity_hash, NULL);
+ g_object_unref(G_OBJECT(cipher2));
+
+ purple_cipher_append(cipher, (guchar *)":", 1);
+ purple_cipher_append(cipher, (guchar *)entity_hash, strlen(entity_hash));
+ }
+
+ purple_cipher_digest_to_str(cipher, sizeof(hash2), hash2, NULL);
+ purple_cipher_reset(cipher);
+
+ purple_cipher_append(cipher, (guchar *)session_key, strlen(session_key));
+ purple_cipher_append(cipher, (guchar *)":", 1);
+ purple_cipher_append(cipher, (guchar *)nonce, strlen(nonce));
+ purple_cipher_append(cipher, (guchar *)":", 1);
+
+ if (qop != NULL && *qop != '\0')
+ {
+ if (nonce_count == NULL)
+ {
+ g_object_unref(G_OBJECT(cipher));
+ purple_debug_error("cipher", "Required nonce_count missing for digest calculation.\n");
+ return NULL;
+ }
+
+ if (client_nonce == NULL)
+ {
+ g_object_unref(G_OBJECT(cipher));
+ purple_debug_error("cipher", "Required client_nonce missing for digest calculation.\n");
+ return NULL;
+ }
+
+ purple_cipher_append(cipher, (guchar *)nonce_count, strlen(nonce_count));
+ purple_cipher_append(cipher, (guchar *)":", 1);
+ purple_cipher_append(cipher, (guchar *)client_nonce, strlen(client_nonce));
+ purple_cipher_append(cipher, (guchar *)":", 1);
+
+ purple_cipher_append(cipher, (guchar *)qop, strlen(qop));
+
+ purple_cipher_append(cipher, (guchar *)":", 1);
+ }
+
+ purple_cipher_append(cipher, (guchar *)hash2, strlen(hash2));
+ purple_cipher_digest_to_str(cipher, sizeof(hash2), hash2, NULL);
+ g_object_unref(G_OBJECT(cipher));
+
+ return g_strdup(hash2);
+}
============================================================
--- libpurple/util.h 55564322be9c4ef39a3dce010516ee0bc1b3668c
+++ libpurple/util.h f83e421d631a94fee3e20a4e2a9c7fb5416bb68f
@@ -1250,6 +1250,48 @@ void purple_restore_default_signal_handl
*/
void purple_restore_default_signal_handlers(void);
+/**
+ * Calculates a session key for HTTP Digest authentation
+ *
+ * See RFC 2617 for more information.
+ *
+ * @param algorithm The hash algorithm to use
+ * @param username The username provided by the user
+ * @param realm The authentication realm provided by the server
+ * @param password The password provided by the user
+ * @param nonce The nonce provided by the server
+ * @param client_nonce The nonce provided by the client
+ *
+ * @return The session key, or @c NULL if an error occurred.
+ */
+gchar *purple_http_digest_calculate_session_key(
+ const gchar *algorithm, const gchar *username,
+ const gchar *realm, const gchar *password,
+ const gchar *nonce, const gchar *client_nonce);
+
+/** Calculate a response for HTTP Digest authentication
+ *
+ * See RFC 2617 for more information.
+ *
+ * @param algorithm The hash algorithm to use
+ * @param method The HTTP method in use
+ * @param digest_uri The URI from the initial request
+ * @param qop The "quality of protection"
+ * @param entity The entity body
+ * @param nonce The nonce provided by the server
+ * @param nonce_count The nonce count
+ * @param client_nonce The nonce provided by the client
+ * @param session_key The session key from purple_cipher_http_digest_calculate_session_key()
+ *
+ * @return The hashed response, or @c NULL if an error occurred.
+ */
+gchar *purple_http_digest_calculate_response(
+ const gchar *algorithm, const gchar *method,
+ const gchar *digest_uri, const gchar *qop,
+ const gchar *entity, const gchar *nonce,
+ const gchar *nonce_count, const gchar *client_nonce,
+ const gchar *session_key);
+
#ifdef __cplusplus
}
#endif
More information about the Commits
mailing list