path: root/src/libtidbit/tidbit-record.c

/* Tidbit
 * Copyright (C) 2010 Charlie Brej tidbit@brej.org
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 3.0 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#include <glib.h>
#include <openssl/objects.h>
#include <openssl/rsa.h>
#include <openssl/sha.h>
#include <string.h>

#include "tidbit.h"
#include "tidbit-record.h"
#include "tidbit-key.h"
#include "tidbit-guid.h"

#define SECONDS_PER_DAY 86400
#define SECONDS_PER_YEAR 31557600

#define TIDBIT_RECORD_ELEMENT_SEPARATOR_KEY    "=="
#define TIDBIT_RECORD_ELEMENT_SEPARATOR_VALUE  ":="

#define TIDBIT_RECORD_ELEMENT_KEY_CHAR_IS_VALID(_chr) (((_chr) >= 'a' && (_chr) <= 'z') || (_chr) == '_')
#define TIDBIT_RECORD_ELEMENT_VALUE_CHAR_IS_VALID(_chr) ((_chr) >= 0x20)

#define TIDBIT_RECORD_HEADER "TIDBIT/0.1; libtidbit/0.1"

static PtrTidbitRecord tidbit_record_new_raw (void)
{
 PtrTidbitRecord record = g_new(TidbitRecord, 1);
 record->ref_count = 1;
 record->start_time = 0;
 record->end_time = 0;
 record->elements = NULL;
 record->status = TIDBIT_RECORD_STATUS_ERROR;
 record->user_name = NULL;
 record->guid = NULL;
 record->raw = NULL;
 return record;
}

PtrTidbitRecord tidbit_record_new (char* table_name)
{
 PtrTidbitRecord record = tidbit_record_new_raw ();
 record->table_name = g_strdup(table_name);
 record->start_time = time(NULL);
 record->end_time = record->start_time + SECONDS_PER_YEAR;
 record->status = TIDBIT_RECORD_STATUS_NEW;
 return record;
}

static void tidbit_record_free (PtrTidbitRecord record)
{
 g_assert(!record->ref_count);
 g_free(record);
}

void tidbit_record_ref (PtrTidbitRecord record)
{
 record->ref_count++;
}

void tidbit_record_unref (PtrTidbitRecord record)
{
 record->ref_count--;
 if (!record->ref_count)
    tidbit_record_free (record);
}

void tidbit_record_set_ttl (PtrTidbitRecord record, int seconds, int days, int years)
{
 g_assert(record->status == TIDBIT_RECORD_STATUS_NEW);        //FIXME error, not assert
 unsigned long long ttl = seconds + (unsigned long long) days * SECONDS_PER_DAY + (unsigned long long) years * SECONDS_PER_YEAR;
 ttl = MIN(ttl, (unsigned long long) 100 * SECONDS_PER_YEAR);
 record->end_time = record->start_time + ttl;
}

void tidbit_record_add_element (PtrTidbitRecord record, char* key, char* value, TidbitRecordElementType type)
{
 g_assert(record->status != TIDBIT_RECORD_STATUS_SIGNED);        //FIXME error, not assert
 
 char* str_test = key;
 
 for (str_test = key; *str_test; str_test++){
    g_assert(TIDBIT_RECORD_ELEMENT_KEY_CHAR_IS_VALID(*str_test));  //FIXME error, not assert
    }
 for (str_test = value; *str_test; str_test++){
    g_assert(TIDBIT_RECORD_ELEMENT_VALUE_CHAR_IS_VALID(*str_test));  //FIXME error, not assert
    }
 g_assert(!g_str_has_prefix(key, TIDBIT_RECORD_ELEMENT_KEY_BASE));
 
 PtrTidbitRecordElement element = g_new(TidbitRecordElement, 1);
 element->key = g_strdup(key);
 element->value = g_strdup(value);
 element->type = type;
 record->elements = g_list_append(record->elements, element);
}

static PtrTidbitRecordElement tidbit_record_get_element_by_key (PtrTidbitRecord record, char* key)
{
 for (GList* elements = record->elements; elements; elements = g_list_next(elements)){
    PtrTidbitRecordElement element = elements->data;
    if (!strcmp(element->key, key))
        return element;
    }
 return NULL;
}

char* tidbit_record_get_element_value_by_key (PtrTidbitRecord record, char* key)
{
 PtrTidbitRecordElement element = tidbit_record_get_element_by_key (record, key);
 if (element)
    return element->value;
 return NULL;
}


void tidbit_record_sign (PtrTidbitRecord record, PtrTidbitKey key)
{
 g_assert(record->status == TIDBIT_RECORD_STATUS_NEW);
 record->user_name = g_strdup(key->public_key_string);  //FIXME use function
 GString* rec_str = g_string_sized_new (TIDBIT_RECORD_MAX_SIZE);
 g_string_append_printf (rec_str, TIDBIT_RECORD_HEADER"; %s\n", key->agent);
 
 g_string_append_printf (rec_str, TIDBIT_RECORD_ELEMENT_KEY_USERKEY TIDBIT_RECORD_ELEMENT_SEPARATOR_KEY "%s\n", record->user_name);
 g_string_append_printf (rec_str, TIDBIT_RECORD_ELEMENT_KEY_TABLE TIDBIT_RECORD_ELEMENT_SEPARATOR_KEY "%s\n", record->table_name);
 g_string_append_printf (rec_str, TIDBIT_RECORD_ELEMENT_KEY_CREATED TIDBIT_RECORD_ELEMENT_SEPARATOR_VALUE "%lld\n", (unsigned long long) record->start_time);
 g_string_append_printf (rec_str, TIDBIT_RECORD_ELEMENT_KEY_EXPIRES TIDBIT_RECORD_ELEMENT_SEPARATOR_VALUE "%lld\n", (unsigned long long) record->end_time);
 
 for (GList* element_itter = record->elements; element_itter; element_itter = g_list_next(element_itter)){
    PtrTidbitRecordElement element = element_itter->data;
    if (element->type == TIDBIT_RECORD_ELEMENT_TYPE_KEY)
        g_string_append_printf (rec_str, "%s" TIDBIT_RECORD_ELEMENT_SEPARATOR_KEY "%s\n", element->key, element->value);
    else if (element->type == TIDBIT_RECORD_ELEMENT_TYPE_VALUE)
        g_string_append_printf (rec_str, "%s" TIDBIT_RECORD_ELEMENT_SEPARATOR_VALUE "%s\n", element->key, element->value);
    else
        g_assert_not_reached();
    }
 char* signature = tidbit_key_sign_data (key, rec_str->str);
 g_string_append_printf (rec_str, TIDBIT_RECORD_ELEMENT_KEY_SIGNED TIDBIT_RECORD_ELEMENT_SEPARATOR_VALUE "%s\n", signature);
 record->guid = tidbit_guid_new (signature);
 g_free (signature);
 
 record->raw = g_string_free (rec_str, FALSE);
 record->status = TIDBIT_RECORD_STATUS_SIGNED;
}

char* tidbit_record_get_raw (PtrTidbitRecord record)
{
 g_assert(record->status == TIDBIT_RECORD_STATUS_SIGNED);
 return record->raw;
}

PtrTidbitGuid tidbit_record_get_guid (PtrTidbitRecord record)
{
 g_assert(record->status == TIDBIT_RECORD_STATUS_SIGNED);
 return record->guid;
}

static gboolean tidbit_record_extract_pair_from_raw (char* data, char** rest, char** key, char** value, TidbitRecordElementType* type)
{
 int i=0;
 for (i=0; TIDBIT_RECORD_ELEMENT_KEY_CHAR_IS_VALID (data[i]); i++){
    }
 
 if (data[i] == TIDBIT_RECORD_ELEMENT_SEPARATOR_KEY[0] && data[i + 1] == TIDBIT_RECORD_ELEMENT_SEPARATOR_KEY[0])
    *type = TIDBIT_RECORD_ELEMENT_TYPE_KEY;
 else if (data[i] == TIDBIT_RECORD_ELEMENT_SEPARATOR_VALUE[0] && data[i + 1] == TIDBIT_RECORD_ELEMENT_SEPARATOR_VALUE[0])
    *type = TIDBIT_RECORD_ELEMENT_TYPE_VALUE;
 else
    g_assert_not_reached();
 
 *key = g_strndup (data, i);
 i += 2;
 data = &data[i];
 for (i=0; data[i] != '\n'; i++){
    if (!TIDBIT_RECORD_ELEMENT_VALUE_CHAR_IS_VALID (data[i])){
        g_free(key);
        return FALSE;
        }
    }
 *value = g_strndup (data, i);
 i++;
 *rest = &data[i];
 return TRUE;
}

PtrTidbitRecord tidbit_record_from_raw (char* raw)
{
 char* key;
 char* value;
 char* rest;
 TidbitRecordElementType type;
 char* data = raw;
 gsize sig_length, user_key_length;
 int reply;
 PtrTidbitRecord record = tidbit_record_new_raw ();
 record->raw = g_strdup(raw);
 
 if (!g_str_has_prefix(data, "TIDBIT"))
    return record;
 data += strlen("TIDBIT");
 while (*data){
    if (*data == '\n'){
        data++;
        break;
        }
    data++;
    }

 if (!tidbit_record_extract_pair_from_raw (data, &data, &key, &value, &type))
    return record;
 if (!g_str_equal(key, TIDBIT_RECORD_ELEMENT_KEY_USERKEY))
    return record;
 g_free(key);
 record->user_name = value;
 
 if (!tidbit_record_extract_pair_from_raw (data, &data, &key, &value, &type))
    return record;
 if (!g_str_equal(key, TIDBIT_RECORD_ELEMENT_KEY_TABLE))
    return record;
 g_free(key);
 record->table_name = value;
 
 if (!tidbit_record_extract_pair_from_raw (data, &data, &key, &value, &type))
    return record;
 if (!g_str_equal(key, TIDBIT_RECORD_ELEMENT_KEY_CREATED))
    return record;
 g_free(key);
 record->start_time = g_ascii_strtoull(value, &rest, 0);
 if (*rest)
    return record;
 g_free(value);
 
 if (!tidbit_record_extract_pair_from_raw (data, &data, &key, &value, &type))
    return record;
 if (!g_str_equal(key, TIDBIT_RECORD_ELEMENT_KEY_EXPIRES))                  //FIXME leaks
    return record;
 g_free(key);
 record->end_time = g_ascii_strtoull(value, &rest, 0);
 if (*rest)
    return record;
 g_free(value);
 
 while (TRUE){
    if (!tidbit_record_extract_pair_from_raw (data, &rest, &key, &value, &type))
        return record;
    if (g_str_equal(key, TIDBIT_RECORD_ELEMENT_KEY_SIGNED))
        break;
    tidbit_record_add_element (record, key, value, type);
    g_free(key);
    g_free(value);
    data=rest;
    }
 
 record->guid = tidbit_guid_new (value);
 g_free(key);
 guchar *signature = g_base64_decode(value, &sig_length);
 guchar *user_key = g_base64_decode(record->user_name, &user_key_length);
 g_free(value);
 
 if (sig_length != user_key_length)
    return record;
 
 SHA512_CTX ctx;  
 guchar digest[SHA512_DIGEST_LENGTH];

 SHA512_Init(&ctx);
 SHA512_Update(&ctx, raw, data-raw);
 SHA512_Final(digest, &ctx);
 
 
 RSA *newkey = RSA_new();
 newkey->n = BN_bin2bn(user_key, user_key_length, NULL);
 newkey->e = BN_new();
 BN_hex2bn(&newkey->e, "10001");
 
 reply =  RSA_verify(NID_sha512, digest, SHA512_DIGEST_LENGTH, signature, sig_length, newkey);
 RSA_free(newkey);
 if (reply)
    record->status = TIDBIT_RECORD_STATUS_SIGNED;
 return record;
}