/Users/maurits/Documents/studie/afstuderen/biosphere/modules/password/bsmod_password.c

Go to the documentation of this file.

/*
 * Author: MA Hartman
 * Date: may 10, 2007
 * 
 * Function:
 * A module which offers password services.
 * 
 * License information:
 * 
 * Copyright (c) 2006 Maurits Hartman
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following
 * conditions:
 * 
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 * 
 */

#include <biosphere_module.h>
#include <io.h>
#include <list.h>
#include <str.h>
#include <type.h>

#include <apr_strings.h>
#include <stdio.h>
#include <openssl/sha.h>


#define BSMOD_PASSWORD_FILE "passwd"

apr_pool_t *password_pool;
bs_list *password_list;


bs_module bsmod_symtable;


typedef struct password_entry {
        const char *username;   
        const char *hash;               
} password_entry;


static char *hash_string(const char *str)
{
        unsigned char md[SHA_DIGEST_LENGTH];
        char *ret = "";
        unsigned i;
        
        SHA1((unsigned char *) str, strlen(str), md);
        for (i = 0; i < SHA_DIGEST_LENGTH; i++) {
                char *d = apr_psprintf(password_pool, "%02x", md[i] & 0xff);
                ret = apr_pstrcat(password_pool, ret, d, NULL);
        }
        return ret;
}


static bs_status add_user(const char *name, const char *pass)
{
        char *hash;
        unsigned i;
        password_entry *entry;
        
        /* Check whether the user is not yet present: */
        for (i = 0; i < list_size(password_list); i++) {
                password_entry *e = (password_entry *) list_index(password_list, i);
                if (streq(e->username, name)) return BS_ERROR;
        }
        
        hash = hash_string(pass);
        entry = (password_entry *) apr_palloc(password_pool,
                        sizeof(password_entry));
        entry->username = apr_pstrdup(password_pool, name);
        entry->hash = hash;
        list_append(password_list, entry);
        return BS_OK;
}


static bs_status remove_user(const char *name)
{
        unsigned i;
        for (i = 0; i < list_size(password_list); i++) {
                password_entry *e = (password_entry *) list_index(password_list, i);
                if (streq(e->username, name)) {
                        list_remove(password_list, i);
                        return BS_OK;
                }
        }
        return BS_OK;
}


static bs_status bsmod_password_init(void)
{
        char *pfilename, *pfilecontents;
        bs_uint64 len;
        bs_status rv;
        bs_list *list;
        
        /* Create pool, mutexes and open password file: */
        apr_pool_create(&password_pool, NULL);
        pfilename = apr_pstrcat(password_pool,
                        "/usr/local/biosphere/modules/", BSMOD_PASSWORD_FILE, NULL);
        rv = read_file_into_buf(pfilename, &pfilecontents, &len, password_pool);
        if (rv != BS_OK || len == 0) {
                apr_pool_destroy(password_pool);
                return BS_ERROR;
        }
        
        /* Process the password file's contents: */
        list = new_list(password_pool);
        strtokenize(list, pfilecontents, NULL);
        if (list_size(list) % 2 == 1) {
                apr_pool_destroy(password_pool);
                return BS_ERROR;        
        }
        else {
                unsigned i;
                
                /* Make entries and add to password list: */
                password_list = new_list(password_pool);
                for (i = 0 ; i < list_size(list); i += 2) {
                        password_entry *entry;
                        
                        entry = (password_entry *) apr_palloc(password_pool,
                                        sizeof(password_entry));
                        entry->username = apr_pstrdup(password_pool,
                                        (char *) list_index(list, i));
                        entry->hash = apr_pstrdup(password_pool,
                                        (char *) list_index(list, i + 1));
                        list_append(password_list, entry);
                }
        }
        
        return BS_OK;
}


static bs_status bsmod_password_cleanup(void)
{
        char *passes = "", *pfilename;
        unsigned i;
        bs_status rv;
        
        /* Write the passwords to the password file: */
        for (i = 0; i < list_size(password_list); i++) {
                password_entry *e = (password_entry *) list_index(password_list, i);
                passes = apr_pstrcat(password_pool, passes,
                                e->username, " ", e->hash, "\n", NULL);
        }
        pfilename = apr_pstrcat(password_pool,
                        "/usr/local/biosphere/modules/", BSMOD_PASSWORD_FILE, NULL);
        rv = write_buf_into_file(pfilename, passes, password_pool);
        if (rv != BS_OK) return rv;
        
        apr_pool_destroy(password_pool);
        return BS_OK;   
}


static bs_service_response *create_status_response(
                const bs_service_request *request, bs_status status)
{
        bs_service_response *resp;
        bs_message_instance *output = NULL;
        bs_part_instance *part = NULL;
        bs_data_type *type = NULL;
        char *data;
        apr_pool_t *mp = password_pool;
        
        data = apr_psprintf(mp, "%u", status);
        type = new_bs_data_type(mp, "bs_uint32");
        if (!type) return NULL;
        part = new_bs_part_instance(mp, "status", type,
                        data, strlen(data));
        if (!part) return NULL;
        output = new_bs_message_instance(mp, "BSStatusMessage", 1);
        if (!output) return NULL;
        output->parts[0] = part;
        resp = new_bs_service_response(mp, request->uuid,
                        request->service, request->port, request->operation,
                        output, NULL);
        
        return resp;
}


static bs_status bsmod_password_handle_service(
                const bs_service_request *request,
                bs_service_response **response, void *extra)
{
        bs_status rv;
        
        /* Precondition checks: */
        if (!streq(request->service, "BSModPasswordServices"))
                return BS_NO_SERVICE;
        if (!streq(request->port, "Password"))
                return BS_NO_SERVICE;
        
        /* Handle the operation: */
        if (streq(request->operation, "verify_user")) {
                char *name, *pass;
                unsigned i;
                
                rv = 0;
                if (request->input->num_parts != 2) return BS_ERROR;
                name = request->input->parts[0]->data;
                pass = request->input->parts[1]->data;
                for (i = 0; i < list_size(password_list); i++) {
                        password_entry *e = (password_entry *) list_index(password_list, i);
                        if (streq(e->username, name) && streq(e->hash, hash_string(pass))) {
                                /* TODO: should improve: genuine is 1, imposter = 0 */
                                rv = 1;
                        }
                }
                *response = create_status_response(request, rv);
                return BS_OK;
        }
        else if (streq(request->operation, "add_user")) {
                if (request->input->num_parts != 2) return BS_ERROR;
                rv = add_user(request->input->parts[0]->data,
                                request->input->parts[1]->data);
                *response = create_status_response(request, rv);
                return BS_OK;   
        }
        else if (streq(request->operation, "remove_user")) {
                if (request->input->num_parts != 1) return BS_ERROR;
                rv = remove_user(request->input->parts[0]->data);
                *response = create_status_response(request, rv);
                return BS_OK;           
        }
        
        return BS_NO_SERVICE;                   
}


/* Final declaration of the bs_module struct: */
bs_module bsmod_symtable = {
        /* The major and minor version of the API used by this module: */
        0,
        0,
        
        /* The major and minor version of this module: */
        0,
        1,
        
        /* The name, author, date and copyright information: */
        "password module",
        "M.A.Hartman",
        "may 9, 2007",
        "(c) 2007, M.A.Hartman. See distributed LICENSE file for more information.",
        "A module which offers password functions. ",
        
        /* Init and cleanup routines: */
        bsmod_password_init,
        bsmod_password_cleanup,
        
        /* Service request handling function: */
        bsmod_password_handle_service,
        NULL,
        "bsmod_password.wsdl"
};

---