rampart/src/util/rampart_util.c

/*
 *   Copyright 2003-2004 The Apache Software Foundation.
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 */

/* Rampart_crypto_util will contain crypto functionalities of the rampart model
 *
 */
#include <stdio.h>
#include <rampart_util.h>
#include <axis2_util.h>
#include <axis2_base64.h>
#include <time.h>
#include <oxs_buffer.h>
#include <openssl_util.h>
/*Calculate the hash of concatenated string of
 * nonce, created and the password.
 *
 */
#define SIZE 256
#define SIZE_HASH 32
#define SIZE_NONCE 24


/*#define PRINTINFO 1 */
AXIS2_EXTERN axis2_char_t* AXIS2_CALL rampart_generate_nonce(const axis2_env_t *env)
{
    oxs_buffer_t *buffer = NULL;
    axis2_status_t status = AXIS2_FAILURE;
    char *rand_str = NULL;
    axis2_char_t* encoded_str = NULL;

    buffer = oxs_buffer_create(env);
    status = generate_random_data(env, buffer, 16);
    rand_str = (char*)OXS_BUFFER_GET_DATA(buffer, env);
    encoded_str = AXIS2_MALLOC(env->allocator, sizeof(char) * SIZE_NONCE);
    axis2_base64_encode(encoded_str, rand_str, OXS_BUFFER_GET_SIZE(buffer, env));
    OXS_BUFFER_FREE(buffer, env);

    return encoded_str;
}


AXIS2_EXTERN axis2_char_t* AXIS2_CALL rampart_generate_time(const axis2_env_t *env, int ttl)
{
    axis2_date_time_t *dt = NULL;
    axis2_char_t *dt_str = NULL;

    dt = axis2_date_time_create_with_offset(env, ttl);
    dt_str = AXIS2_DATE_TIME_SERIALIZE_DATE_TIME(dt, env);
    return dt_str;
}

/**
    We expect dt1_str < dt2_str/ Otherwise FAILURE
*/
AXIS2_EXTERN axis2_status_t AXIS2_CALL
rampart_compare_date_time(const axis2_env_t *env, axis2_char_t *dt1_str, axis2_char_t *dt2_str)
{
    axis2_status_t status = AXIS2_FAILURE;
    axis2_date_time_t *dt1 = NULL;
    axis2_date_time_t *dt2 = NULL;
    int yyyy1, mm1, dd1, hh1, mi1, ss1;
    int yyyy2, mm2, dd2, hh2, mi2, ss2;


    dt1 = axis2_date_time_create(env);
    dt2 = axis2_date_time_create(env);

    status = AXIS2_DATE_TIME_DESERIALIZE_DATE_TIME(dt1, env, dt1_str);
    if (status == AXIS2_FAILURE)
    {
        return AXIS2_FAILURE;
    }

    /*printf("\n DT1 = %s",AXIS2_DATE_TIME_SERIALIZE_DATE_TIME(dt1, env)); */
    yyyy1 = AXIS2_DATE_TIME_GET_YEAR(dt1, env);
    mm1 = AXIS2_DATE_TIME_GET_MONTH(dt1, env);
    dd1 = AXIS2_DATE_TIME_GET_DATE(dt1, env);
    hh1 = AXIS2_DATE_TIME_GET_HOUR(dt1, env);
    mi1 = AXIS2_DATE_TIME_GET_MINUTE(dt1, env);
    ss1 = AXIS2_DATE_TIME_GET_SECOND(dt1, env);

    status = AXIS2_DATE_TIME_DESERIALIZE_DATE_TIME(dt2, env, dt2_str);
    if (status == AXIS2_FAILURE)
    {
        return AXIS2_FAILURE;
    }

    /*printf("\n DT2 = %s",AXIS2_DATE_TIME_SERIALIZE_DATE_TIME(dt2, env)); */

    yyyy2 = AXIS2_DATE_TIME_GET_YEAR(dt2, env);
    mm2 = AXIS2_DATE_TIME_GET_MONTH(dt2, env);
    dd2 = AXIS2_DATE_TIME_GET_DATE(dt2, env);
    hh2 = AXIS2_DATE_TIME_GET_HOUR(dt2, env);
    mi2 = AXIS2_DATE_TIME_GET_MINUTE(dt2, env);
    ss2 = AXIS2_DATE_TIME_GET_SECOND(dt2, env);

    /**
    Comparison. 
    We expect dt1_str < dt2_str/ Otherwise FAILURE
    */
    if (yyyy1 < yyyy2)
    {
        return AXIS2_SUCCESS;
    }
    else if (yyyy1 > yyyy2)
    {
        return AXIS2_FAILURE;
    }

    if (mm1 < mm2)
    {
        return AXIS2_SUCCESS;
    }
    else if (mm1 > mm2)
    {
        return AXIS2_FAILURE;
    }

    if (dd1 < dd2)
    {
        return AXIS2_SUCCESS;
    }
    else if (dd1 > dd2)
    {
        return AXIS2_FAILURE;
    }

    if (hh1 < hh2)
    {
        return AXIS2_SUCCESS;
    }
    else if (hh1 > hh2)
    {
        return AXIS2_FAILURE;
    }

    if (mi1 < mi2)
    {
        return AXIS2_SUCCESS;
    }
    else if (mi1 > mi2)
    {
        return AXIS2_FAILURE;
    }

    if (ss1 < ss2)
    {
        return AXIS2_SUCCESS;
    }
    else if (ss1 > ss2)
    {
        return AXIS2_FAILURE;
    }


    /*AXIS2_DATE_TIME_FREE(dt1, env);
    AXIS2_DATE_TIME_FREE(dt2, env);*/

    return AXIS2_SUCCESS;
}

AXIS2_EXTERN axis2_status_t AXIS2_CALL
rampart_print_info(const axis2_env_t *env, axis2_char_t* info)
{
#ifdef PRINTINFO
    printf("[rampart]: %s\n", info);
#endif
    return AXIS2_SUCCESS;
}