HGKeeper

* purple

* Purple is the legal property of its developers, whose names are too numerous

* to list here. Please refer to the COPYRIGHT file distributed with this

* source distribution.

* 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

* (at your option) any later version.

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA

#include <cipher.h>

#include "glibcompat.h"

#include <util.h>

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 (purple_strequal(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 (purple_strequal(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_memdup2(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 */

};

PurpleCipherOps *

purple_hmac_cipher_get_ops(void) {

return &HMACOps;

}

pidgin/pidgin