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.

* (http://toxygen.net/libgadu/) during Google Summer of Code 2012

* by Tomek Wasilczyk (http://www.wasilczyk.pl).

* 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 "oauth.h"

#include <time.h>

#include <glib.h>

char *gg_oauth_static_nonce; /* dla unit testów */

char *gg_oauth_static_timestamp; /* dla unit testów */

static char *gg_oauth_generate_request(gboolean header, ...) G_GNUC_NULL_TERMINATED;

static void gg_oauth_generate_nonce(char *buf, int len)

{

const char charset[] = "0123456789";

if (buf == NULL || len < 1)

return;

while (len > 1) {

*buf++ = charset[(unsigned) (((float) sizeof(charset) - 1.0) * g_random_int() / (RAND_MAX + 1.0))];

len--;

}

*buf = 0;

}

/* Returns a comma separated header value if header is true,

* or a url-encoded request otherwise

static char *

gg_oauth_generate_request(gboolean header, ...)

{

GString *res = g_string_new(NULL);

va_list params;

const gchar *key;

gboolean truncate = FALSE;

if(header) {

res = g_string_append(res, "OAuth ");

}

va_start(params, header);

while((key = va_arg(params, const gchar *))) {

const gchar *value = va_arg(params, const gchar *);

gchar *escaped = g_uri_escape_string(value, NULL, FALSE);

if(header) {

g_string_append_printf(res, "%s=\"%s\",", key, escaped);

} else {

g_string_append_printf(res, "%s=%s&", key, escaped);

}

g_free(escaped);

truncate = TRUE;

}

va_end(params);

if(truncate) {

/* remove trailing separator */

res = g_string_truncate(res, res->len - 1);

}

return g_string_free(res, FALSE);

}

static gchar *gg_hmac_sha1(const char *key, const char *message)

{

GHmac *hmac;

guchar digest[20];

gsize digest_len = 20;

hmac = g_hmac_new(G_CHECKSUM_SHA1, (guchar *)key, strlen(key));

g_hmac_update(hmac, (guchar *)message, -1);

g_hmac_get_digest(hmac, digest, &digest_len);

g_hmac_unref(hmac);

return g_base64_encode(digest, sizeof(digest));

}

static char *

gg_oauth_generate_signature(const char *method, const char *url,

const char *request, const char *consumer_secret,

const char *token_secret)

{

char *text, *key, *res;

gchar *url_e, *request_e, *consumer_secret_e, *token_secret_e;

url_e = g_uri_escape_string(url, "?", FALSE);

g_strdelimit(url_e, "?", '\0');

request_e = g_uri_escape_string(request, NULL, FALSE);

text = g_strdup_printf("%s&%s&%s", method, url_e, request_e);

g_free(url_e);

g_free(request_e);

consumer_secret_e = g_uri_escape_string(consumer_secret, NULL, FALSE);

token_secret_e = token_secret ? g_uri_escape_string(token_secret, NULL, FALSE) : NULL;

key = g_strdup_printf("%s&%s", consumer_secret_e, token_secret ? token_secret_e : "");

g_free(consumer_secret_e);

g_free(token_secret_e);

res = gg_hmac_sha1(key, text);

g_free(key);

g_free(text);

return res;

}

char *

gg_oauth_generate_header(const char *method, const char *url,

const char *consumer_key, const char *consumer_secret,

const char *token, const char *token_secret)

{

char *request, *signature, *res;

char nonce[80], timestamp[16];

if (gg_oauth_static_nonce == NULL)

gg_oauth_generate_nonce(nonce, sizeof(nonce));

else {

strncpy(nonce, gg_oauth_static_nonce, sizeof(nonce) - 1);

nonce[sizeof(nonce) - 1] = 0;

}

if (gg_oauth_static_timestamp == NULL) {

g_snprintf(timestamp, sizeof(timestamp), "%ld", time(NULL));

} else {

strncpy(timestamp, gg_oauth_static_timestamp, sizeof(timestamp) - 1);

timestamp[sizeof(timestamp) - 1] = 0;

}

request = gg_oauth_generate_request(FALSE,

"oauth_consumer_key", consumer_key,

"oauth_nonce", nonce,

"oauth_signature_method", "HMAC-SHA1",

"oauth_timestamp", timestamp,

"oauth_token", token,

"oauth_version", "1.0",

NULL);

signature = gg_oauth_generate_signature(method, url, request, consumer_secret, token_secret);

g_free(request);

if (signature == NULL)

return NULL;

res = gg_oauth_generate_request(TRUE,