Starting to move stuff in to a lib

[mnenc] / mnencd.hpp

//      mnencd.hpp
//      
//      Copyright 2010 Micke Nordin <mickewiki@gmail.com>
//      
//      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 3 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 02110-1301, USA.
#ifndef _mnencd_h_included_
#define _mnencd_h_included_
#include <string>
#include <iostream>
#include <fstream>
#include "php.hpp"
#include <vector>
#include <csignal>

std::string masterpasswd = "";

std::string remove_char(std::string str, char c) {
        std::string::size_type k = 0;
        while((k=str.find(c,k))!=str.npos) {
                str.erase(k, 1);
        }
        return str;
}

std::string remove_chars(std::string str) {
        std::string chars = " \t\n\b\a-?+\\{[]}'*'";
        for(int i = 0; i < (signed) chars.size(); i++) {
                str = remove_char(str, chars[i]);
        }
        
        return str;     
}

std::string make_filename(std::string user, std::string app) {
        std::string name;
        name = getenv("USER");
        return "/home/" + name + "/.mnenc/" + remove_chars(app + user);
}
std::string get_password(std::string masterpasswd, std::string user, std::string app) {
        mnenc menc = mnenc();
        menc.genkey(masterpasswd);
        std::string key = menc.get_key();
        std::string enc, dec;
        password pw = password("", "", key);
        if(pw.from_file(make_filename(user, app))) {
                enc = pw.get_enc();
                dec = menc.decrypt(key, enc);
        } else {
                dec = "failure";
        }
        return dec;
}

void put_password(std::string masterpasswd, std::string passwd, std::string user, std::string app) {
        mnenc menc = mnenc();
        menc.genkey(masterpasswd);
        std::string key = menc.get_key();
        password pw = password(menc.encrypt(key, passwd ), "", key);
        pw.to_file(make_filename(user, app));
}
std::string do_something(std::string str) { //Handle requests for secure pipe
    pid_t proc = fork();
    std::string reply = "";
    if( proc == 0 ) { // child
        reply = open_connection( str );
    } else if( p > 0 ) { // parent
       // Store p somewhere
    } else { // fork failed
    }
    
    return reply;
}
std::string open_connection(std::string str) {

}
std::string do_something_else(std::string str) { //Handle requests

        std::vector<std::string> request; //Incomming message stored here
        request = explode(str, "|"); //explode request with function from php.hpp
        
        if(request[0] == "0_Unlock") { //Unlock keyring
                if(masterpasswd == "")  { //If master password is not yet set
                        masterpasswd = request[1]; //set password
                        return "201_Created\n";
                } else if(masterpasswd!= "") { //If master password is allready set
                        return "403_Forbidden\n";
                } else { //If something else is wrong
                        return "400_Bad_Request " + str + '\n';
                }
        } 
        
        else if(request[0] == "10_Encrypt") { //encrypt password
                if(masterpasswd == "") { //If master password is not yet set
                        return "412_Precondition_Failed\n";
                } else { //If we have a master password to encrypt with
                        put_password(masterpasswd, request[3], request[2], request[1]);
                        return "201_Created\n";
                }
                
        }else if(request[0] == "20_Decrypt") { //decrypt password
                if(masterpasswd == "") { //If master password is not yet set
                        return "412_Precondition_Failed\n";
                } else { //If we have a master password to encrypt with
                        std::string pw = get_password(masterpasswd, request[2], request[1]);
                        std::string message;
                        if(pw == "") {
                                message = "500_Internal_Server_Error\n";
                        } else {
                                message = "201_Created " + pw + "\n";
                        }
                        return message;
                } 
        }else if(request[0] == "30_Check") { //check if password file exists
                bool check = false;
                fstream file;
                file.open(make_filename(request[2], request[1]).c_str(), ios::in);
                if( file.is_open() ) {
                        check = true;
                }
                file.close();
                if(masterpasswd == "") { //If master password is not yet set
                        return "412_Precondition_Failed\n";
                } else {
                        if(check) {
                                return "201_Created\n";
                        } else {
                                return "404_Not_Found";
                        }
                }
        }
        else {
                return "400_Bad_Request " + str + '\n';
        }
}

std::string m_read() {
        std::string str;
        std::ifstream is("mnencdfifo");
        getline(is, str);
        is.close();
        return str;
}

void m_send(std::string message) {
        std::ofstream os("mnencdfifo");
        os << message;
        os.close();
}

void term(int sig)
{
        unlink("/tmp/mnencdfifo");
}

#endif