user.hpp

// ---------------------------------------------------------------------
// pion:  a Boost C++ framework for building lightweight HTTP interfaces
// ---------------------------------------------------------------------
// Copyright (C) 2007-2014 Splunk Inc.  (https://github.com/splunk/pion)
//
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
//

#ifndef __PION_USER_HEADER__
#define __PION_USER_HEADER__

#include <map>
#include <string>
#include <cstdio>
#include <cstring>
#include <boost/shared_ptr.hpp>
#include <boost/noncopyable.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/numeric/conversion/cast.hpp>
#include <pion/config.hpp>
#include <pion/error.hpp>

#ifdef PION_HAVE_SSL
    #if defined(__APPLE__)
        // suppress warnings about OpenSSL being deprecated in OSX
        #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
    #endif
    #include <openssl/sha.h>
#endif


namespace pion {    // begin namespace pion


class user :
    private boost::noncopyable
{
public:

    user(std::string const &username) :
        m_username(username)
    {}

    user(std::string const &username, std::string const &password) :
        m_username(username)
    {
        set_password(password);
    }

    virtual ~user() {}

    std::string const & get_username() const { return m_username; }

    std::string const & get_password() const { return m_password; }

    virtual bool match_password(const std::string& password) const {
#ifdef PION_HAVE_SSL
        unsigned char sha1_hash[SHA_DIGEST_LENGTH];
        SHA1(reinterpret_cast<const unsigned char *>(password.data()), password.size(), sha1_hash);
        return (memcmp(sha1_hash, m_password_hash, SHA_DIGEST_LENGTH) == 0);
#else
        return m_password == password;
#endif
    }

    virtual void set_password(const std::string& password) { 
#ifdef PION_HAVE_SSL
        // store encrypted hash value
        SHA1((const unsigned char *)password.data(), password.size(), m_password_hash);

        // update password string (convert binary to hex)
        m_password.clear();
        char buf[3];
        for (unsigned int n = 0; n < SHA_DIGEST_LENGTH; ++n) {
            sprintf(buf, "%.2x", static_cast<unsigned int>(m_password_hash[n]));
            m_password += buf;
        }
#else
        m_password = password; 
#endif
    }

#ifdef PION_HAVE_SSL
    virtual void set_password_hash(const std::string& password_hash) {
        // update password string representation
        if (password_hash.size() != SHA_DIGEST_LENGTH*2)
            BOOST_THROW_EXCEPTION( error::bad_password_hash() );
        m_password = password_hash;

        // convert string from hex to binary value
        char buf[3];
        buf[2] = '\0';
        unsigned int hash_pos = 0;
        std::string::iterator str_it = m_password.begin();
        while (str_it != m_password.end()) {
            buf[0] = *str_it;
            ++str_it;
            buf[1] = *str_it;
            ++str_it;
            m_password_hash[hash_pos++] = boost::numeric_cast<unsigned char>(strtoul(buf, 0, 16));
        }
    }
#endif


protected:

    const std::string   m_username;

    std::string         m_password;

#ifdef PION_HAVE_SSL
    unsigned char       m_password_hash[SHA_DIGEST_LENGTH];
#endif
};

typedef boost::shared_ptr<user> user_ptr;


class user_manager :
    private boost::noncopyable
{
public:

    user_manager(void) {}

    virtual ~user_manager() {}

    inline bool empty(void) const {
        boost::mutex::scoped_lock lock(m_mutex);
        return m_users.empty();
    }

    virtual bool add_user(const std::string &username,
        const std::string &password)
    {
        boost::mutex::scoped_lock lock(m_mutex);
        user_map_t::iterator i = m_users.find(username);
        if (i!=m_users.end())
            return false;
        user_ptr user_ptr(new user(username, password));
        m_users.insert(std::make_pair(username, user_ptr));
        return true;
    }

    virtual bool update_user(const std::string &username,
        const std::string &password)
    {
        boost::mutex::scoped_lock lock(m_mutex);
        user_map_t::iterator i = m_users.find(username);
        if (i==m_users.end())
            return false;
        i->second->set_password(password);
        return true;
    }

#ifdef PION_HAVE_SSL

    virtual bool add_user_hash(const std::string &username,
        const std::string &password_hash)
    {
        boost::mutex::scoped_lock lock(m_mutex);
        user_map_t::iterator i = m_users.find(username);
        if (i!=m_users.end())
            return false;
        user_ptr user_ptr(new user(username));
        user_ptr->set_password_hash(password_hash);
        m_users.insert(std::make_pair(username, user_ptr));
        return true;
    }

    virtual bool update_user_hash(const std::string &username,
        const std::string &password_hash)
    {
        boost::mutex::scoped_lock lock(m_mutex);
        user_map_t::iterator i = m_users.find(username);
        if (i==m_users.end())
            return false;
        i->second->set_password_hash(password_hash);
        return true;
    }
#endif

    virtual bool remove_user(const std::string &username) {
        boost::mutex::scoped_lock lock(m_mutex);
        user_map_t::iterator i = m_users.find(username);
        if (i==m_users.end())
            return false;
        m_users.erase(i);
        return true;
    }

    virtual user_ptr get_user(const std::string &username) {
        boost::mutex::scoped_lock lock(m_mutex);
        user_map_t::const_iterator i = m_users.find(username);
        if (i==m_users.end())
            return user_ptr();
        else
            return i->second;
    }

    virtual user_ptr get_user(const std::string& username, const std::string& password) {
        boost::mutex::scoped_lock lock(m_mutex);
        user_map_t::const_iterator i = m_users.find(username);
        if (i==m_users.end() || !i->second->match_password(password))
            return user_ptr();
        else
            return i->second;
    }


protected:

    typedef std::map<std::string, user_ptr>  user_map_t;


    mutable boost::mutex    m_mutex;

    user_map_t              m_users;
};

typedef boost::shared_ptr<user_manager>  user_manager_ptr;


}   // end namespace pion

#endif