Inspiration

Wanted to work on a very technical project to enhance out coding skills.

What it does

It is a downloadable program that when it runs it creates a folder where passwords are added, hashes the folder then encrypts it. The encrypts hash with a personal password. Users can go in and edit passwords whenever they want and view passwords.

How we built it

c++, openssl, and sha-256

Challenges we ran into

Figuring out a lot of the c++ program commands needed for this and integrating the system command line into the code.

Accomplishments that we're proud of

Finally getting this thing to work.

What we learned

How to work with encryption, hashing and more complicated c++ programming

What's next for Code For Project

To expand the security by making the file into a hash tree and then mixing the root hash with a generated key. And maybe making a UI.

Heres the code: main ()

include "Classes.cpp"

int main () { string mainhash; int choice; string passwordin; passwordVault PV;

    cout << "Enter 1 if no file is created yet, enter 2 to view/edit encrypted file" << endl;
    cin >> choice;
    system("clear");

    if (choice == 1)
    {
        PV.addFieldN();
        mainhash = PV.hashFile();
        cout << endl << endl << "***** Please write down this private key, this key acts as an extra security measure if you forget your password: *****" << endl;
        cout << "*****" << PV.hashFile() << "*****" << endl << endl;

        PV.createFile(mainhash);
        system("openssl aes-256-cbc -a -salt -in PassVault.txt -out PassVault.txt.enc -pass pass:file:/Library/Caches/KeyHolder.txt");
        //system(("openssl aes-256-cbc -a -salt -in PassVault.txt -out PassVault.txt.enc -pass pass:"+mainhash).c_str());
        system("rm -f PassVault.txt");
        PV.deleteFile();
        system("clear");
        passwordin = PV.mainPassIn();
        system("clear");
        PV.hashencrypt(passwordin, mainhash);




        cout << "File now encrypted" << endl;
    }

    if (choice == 2)
    {
        PV.reveiwFolderE();
    }

}

Classes.cpp

include

include "sha256.h"

using namespace std;

class passwordVault { private: string aType, userName, password, moreInfo, fstring; string keyin; string b;

void reviewFolderN ()
{
    cout << "Folder Contents Below:" << endl;

    ifstream reader;
    reader.open("PassVault.txt");

    while (!reader.eof())
    {

        getline(reader, aType,' ');
        getline(reader,userName,' ');
        getline(reader, password, ' ');
        getline(reader,moreInfo,'\n');


        cout << "Type: " << aType << "  " << "Username: " << userName << "  " << "Password: " << password << "  " << "More info: " << moreInfo << endl;

    }
    reader.close();
}

public:

void reveiwFolderE ()
{
    string key;
    string hash;
    string x;

    verification();

    key = verification();
    createFile(key);
    system("openssl aes-256-cbc -d -a -in PassVault.txt.enc -out PassVault.txt -pass pass:file:/Library/Caches/KeyHolder.txt");
    //system(("openssl aes-256-cbc -d -a -in PassVault.txt.enc -out PassVault.txt -pass pass:"+key).c_str());
    //system("openssl enc -d -aes-256-cbc -in ENCPassVault.txt -out PassVault.txt -pass pass:env:key");
    deleteFile();
    ifstream reader;
    reader.open("PassVault.txt");

    cout << "Current vault content below: " << endl << endl << endl;

    while (!reader.eof())
    {

        getline(reader, aType,' ');
        getline(reader,userName,' ');
        getline(reader, password, ' ');
        getline(reader,moreInfo,'\n');


        cout << "Type: " << aType << "   " << "Username: " << userName << "   " << "Password: " << password << "   " << " More info: " << moreInfo << endl;

    }

    reader.close();

    cout << endl << endl << "Would you like to add more information to the file? (Y/N)" << endl;
    cin >> x;

    if (x == "y" || x == "Y")
    {
        addFieldN();
        cout << "Your new private key is : " << hashFile() << endl;
    }

    if (x == "N" || x == "n")
    {
        cout << "No information added, file will encrypt" << endl;
    }


    hash = hashFile();
    createFile(hash);
    system("openssl aes-256-cbc -a -salt -in PassVault.txt -out PassVault.txt.enc -pass pass:file:/Library/Caches/KeyHolder.txt");
    //system(("openssl aes-256-cbc -a -salt -in PassVault.txt -out PassVault.txt.enc -pass pass:"+hash).c_str());
    //system("openssl enc -aes-256-cbc -in PassVault.txt -out ENCPassVault.txt -pass pass:env:hash");
    deleteFile();
    system("rm -f PassVault.txt");

}






void addFieldN ()
{
    ofstream adder;
    adder.open("PassVault.txt", ios::app);
    int x;
    string y;
    string h = "Y";



    cout << "File Password input, you will be asked to input 'Account Type' 'User Name' 'Password' 'More Info'" << endl;
    cout << "Input '1' to contine" << endl;
    cin >> x;
    system("clear");

    if (x==1)
    {
        while (h == "Y")
        {

            cout << "Enter Account Type/Name" << endl;
            getline (cin,aType);
            cout << "Enter Username" << endl;
            getline (cin,userName);
            cout << "Enter Password" << endl;
            getline (cin,password);
            cout << "Enter More Info:" << endl;
            getline (cin,moreInfo);

            adder << aType << " " << userName << " " << password << " " << moreInfo << endl;
            system("clear");
            cout << "Would you like to add another password 'Y' or 'N'" << endl;
            cin >> h;
            system("clear");
        }

        adder.close();
        cout << "Your passwords have been added to the file" << endl << endl;
        system("clear");
        cout << "Would you like to review all data being added to file before encryption? ('Y' or 'N')" << endl;
        cin >> b;
        system("clear");

        if (b == "Y" || b == "y")
        {
            reviewFolderN();
        }

        else
        {
            cout << "Time to proceed to encryption" << endl;
        }

        return;

    }

    else
    {
        cout << "Are you sure you would like to add no data to vault?" << endl;
        cout << "If you would like to go back and add data to your vault input 'YES' if not input 'NO'" << endl;
        cin >> y;
        system("clear");
        if (y == "YES" || y == "yes" || y == "Yes")
        {
            addFieldN();
        }

        else
        {
            cout << "Time to proceed to encryption" << endl;
            return;
        }
    }

    adder.close();
}





string makeFile ()
{
    ifstream reader;
    reader.open("PassVault.txt");

    while (!reader.eof())
    {

        getline(reader, aType,' ');
        getline(reader,userName,' ');
        getline(reader, password,' ');
        getline(reader,moreInfo,'\n');


        fstring = fstring + " **" + aType + "  " + userName + "   " + password + "   " + moreInfo;
    }
    reader.close();

    return fstring;
}





string hash(string input)
{
    string hashk = sha256(input);

    //cout << "sha256('"<< input << endl << "'):" << hashk << endl;
    return hashk;
}





string hashFile ()
{
    return hash(makeFile());
}




void hashencrypt (string passwordz, string hencrypt)
{
    string passe;
    passe = passwordz;
    ofstream writer;
    writer.open("hash.txt");
    writer << hencrypt << endl;
    writer.close();
    createFile(passe);
    system("openssl aes-256-cbc -a -salt -in hash.txt -out hash.txt.enc -pass pass:file:/Library/Caches/KeyHolder.txt");
    //system(("openssl aes-256-cbc -a -salt -in hash.txt -out hash.txt.enc -pass pass:"+passe).c_str());
    //system("openssl enc -aes-256-cbc -in hash.txt -out ENChash.txt -pass pass:env:passe");
    deleteFile();
    system("rm -f hash.txt");
}





string hashdecrypt (string passwordin)
{
    string hashtext, pass;
    pass = passwordin;
    createFile(pass);
    system("openssl aes-256-cbc -d -a -in hash.txt.enc -out hash.txt -pass pass:file:/Library/Caches/KeyHolder.txt");
    //system(("openssl aes-256-cbc -d -a -in hash.txt.enc -out hash.txt -pass pass:"+pass).c_str());
    //system("openssl enc -d -aes-256-cbc -in ENChash.txt -out hash.txt -pass pass:env:pass");
    deleteFile();
    ifstream reader;
    reader.open("hash.txt");
    getline(reader,hashtext,'\n');
    reader.close();
    hashencrypt(passwordin, hashtext);
    return hashtext;
}




string verification ()
{
    int choice;
    string attemptpass, hash1, in;
    cout << "Enter 1 to enter password or 2 to if you forgot your password." << endl;
    cin >> choice;

    if (choice == 1)
    {
        cout << "Please enter passcode: " << endl;
        cin >> attemptpass;
        system("clear");
        hash1 = hashdecrypt(attemptpass);
    }


    if (choice == 2)
    {
        cout << "Enter your recovery key" << endl;
        cin >> in;
        system("clear");
        hash1 = in;
    }

    return hash1;
}




void createFile(string key)
{
    string keys;
    keys = key;
    ofstream writer;
    writer.open("/Library/Caches/keyHolder.txt");
    writer << keys << endl;
    writer.close();
}




void deleteFile()
{
    system("rm -r /Library/Caches/keyHolder.txt");
}




//******
//******
//******
//BELOW IS PASSWORD CHECK FUNCTIONS


bool isShorter(const string pword)        // lower limit
{
    if (pword.size() > 10)
    {
        return false;
    }

    else
    {
        return true;
    }
}


bool isLonger(const string pword)         // upper limit
{
    if (pword.size() > 30)
    {
        return true;
    }

    else
    {
        return false;
    }
}

bool hasUpperCase(const string pword)      // checks uppercase
{
    for (auto &c : pword)
    {
        if (isupper(c))
            return true;
    }
    return false;
}

bool hasLowerCase(const string pword)    // checks lowercase
{
    for (auto &c : pword)
    {
        if (islower(c))
            return true;
    }
    return false;
}

bool hasNumber(const string pword)       // checks a number
{
    for (auto &c : pword)
    {
        if (isdigit(c))
            return true;
    }
    return false;
}

bool hasSpecialCharacters(const string pword) // checks special characters
{
    for (auto &c : pword)
    {
        if (isalnum(c))
            return false;
    }
    return true;
}

bool passwordCheck (const string password)
{
    bool isGood = true;

    if (!isLonger(password) && !isShorter(password) && hasUpperCase(password)
        && hasLowerCase(password) && hasNumber(password) && !hasSpecialCharacters(password))
    {
        cout << endl << "Proper password." << endl << endl;
        isGood = true;
    }

    else
    {
        cout << endl << "Improper password! Reason..." << endl;

        if (isShorter(password))
            cout << "Your password is shorter than 10 characters." << endl;
        if (isLonger(password))
            cout << "Your password can not be longer than 30 characters." << endl;
        if (!hasUpperCase(password))
            cout << "Your password must have at least one upper case letter." << endl;
        if (!hasLowerCase(password))
            cout << "Your password must have at least one lower case letter." << endl;
        if (!hasNumber(password))
            cout << "Your password must have at least one number." << endl;
        if (!hasSpecialCharacters(password))
            cout << "At least one special character is required." << endl;
        isGood = false;
    }
    return isGood;
}


string mainPassIn()
{
    string Password;
    cout << "Time to create your passcode, enter your password below. Your vault is as secure as your passcode." << endl;
    cout << "Your password must contain an uppercase letter, lowercase letter, special character, must be at least 10 characters, no more than 30 characters, and contain a number" << endl;
    cin >> Password;
    system("clear");
    while (!passwordCheck(Password))
    {
        cout << endl << "Try another password: ";
        cin >> Password;
    }

    return password;

}

};

sha256.cpp

include

include "sha256.h"

const unsigned int SHA256::sha256_k[64] = //UL = uint32 {0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2};

void SHA256::transform(const unsigned char *message, unsigned int block_nb) { uint32 w[64]; uint32 wv[8]; uint32 t1, t2; const unsigned char *sub_block; int i; int j; for (i = 0; i < (int) block_nb; i++) { sub_block = message + (i << 6); for (j = 0; j < 16; j++) { SHA2_PACK32(&sub_block[j << 2], &w[j]); } for (j = 16; j < 64; j++) { w[j] = SHA256_F4(w[j - 2]) + w[j - 7] + SHA256_F3(w[j - 15]) + w[j - 16]; } for (j = 0; j < 8; j++) { wv[j] = m_h[j]; } for (j = 0; j < 64; j++) { t1 = wv[7] + SHA256_F2(wv[4]) + SHA2_CH(wv[4], wv[5], wv[6]) + sha256_k[j] + w[j]; t2 = SHA256_F1(wv[0]) + SHA2_MAJ(wv[0], wv[1], wv[2]); wv[7] = wv[6]; wv[6] = wv[5]; wv[5] = wv[4]; wv[4] = wv[3] + t1; wv[3] = wv[2]; wv[2] = wv[1]; wv[1] = wv[0]; wv[0] = t1 + t2; } for (j = 0; j < 8; j++) { m_h[j] += wv[j]; } } }

void SHA256::init() { m_h[0] = 0x6a09e667; m_h[1] = 0xbb67ae85; m_h[2] = 0x3c6ef372; m_h[3] = 0xa54ff53a; m_h[4] = 0x510e527f; m_h[5] = 0x9b05688c; m_h[6] = 0x1f83d9ab; m_h[7] = 0x5be0cd19; m_len = 0; m_tot_len = 0; }

void SHA256::update(const unsigned char *message, unsigned int len) { unsigned int block_nb; unsigned int new_len, rem_len, tmp_len; const unsigned char *shifted_message; tmp_len = SHA224_256_BLOCK_SIZE - m_len; rem_len = len < tmp_len ? len : tmp_len; memcpy(&m_block[m_len], message, rem_len); if (m_len + len < SHA224_256_BLOCK_SIZE) { m_len += len; return; } new_len = len - rem_len; block_nb = new_len / SHA224_256_BLOCK_SIZE; shifted_message = message + rem_len; transform(m_block, 1); transform(shifted_message, block_nb); rem_len = new_len % SHA224_256_BLOCK_SIZE; memcpy(m_block, &shifted_message[block_nb << 6], rem_len); m_len = rem_len; m_tot_len += (block_nb + 1) << 6; }

void SHA256::final(unsigned char *digest) { unsigned int block_nb; unsigned int pm_len; unsigned int len_b; int i; block_nb = (1 + ((SHA224_256_BLOCK_SIZE - 9) < (m_len % SHA224_256_BLOCK_SIZE))); len_b = (m_tot_len + m_len) << 3; pm_len = block_nb << 6; memset(m_block + m_len, 0, pm_len - m_len); m_block[m_len] = 0x80; SHA2_UNPACK32(len_b, m_block + pm_len - 4); transform(m_block, block_nb); for (i = 0 ; i < 8; i++) { SHA2_UNPACK32(m_h[i], &digest[i << 2]); } }

std::string sha256(std::string input) { unsigned char digest[SHA256::DIGEST_SIZE]; memset(digest,0,SHA256::DIGEST_SIZE);

SHA256 ctx = SHA256();
ctx.init();
ctx.update( (unsigned char*)input.c_str(), input.length());
ctx.final(digest);

char buf[2*SHA256::DIGEST_SIZE+1];
buf[2*SHA256::DIGEST_SIZE] = 0;
for (int i = 0; i < SHA256::DIGEST_SIZE; i++)
    sprintf(buf+i*2, "%02x", digest[i]);
return std::string(buf);

}

sha256.h

ifndef SHA256_H

define SHA256_H

include

class SHA256 { protected: typedef unsigned char uint8; typedef unsigned int uint32; typedef unsigned long long uint64;

const static uint32 sha256_k[];
static const unsigned int SHA224_256_BLOCK_SIZE = (512/8);

public: void init(); void update(const unsigned char *message, unsigned int len); void final(unsigned char *digest); static const unsigned int DIGEST_SIZE = ( 256 / 8);

protected: void transform(const unsigned char *message, unsigned int block_nb); unsigned int m_tot_len; unsigned int m_len; unsigned char m_block[2*SHA224_256_BLOCK_SIZE]; uint32 m_h[8]; };

std::string sha256(std::string input);

define SHA2_SHFR(x, n) (x >> n)

define SHA2_ROTR(x, n) ((x >> n) | (x << ((sizeof(x) << 3) - n)))

define SHA2_ROTL(x, n) ((x << n) | (x >> ((sizeof(x) << 3) - n)))

define SHA2_CH(x, y, z) ((x & y) ^ (~x & z))

define SHA2_MAJ(x, y, z) ((x & y) ^ (x & z) ^ (y & z))

define SHA256_F1(x) (SHA2_ROTR(x, 2) ^ SHA2_ROTR(x, 13) ^ SHA2_ROTR(x, 22))

define SHA256_F2(x) (SHA2_ROTR(x, 6) ^ SHA2_ROTR(x, 11) ^ SHA2_ROTR(x, 25))

define SHA256_F3(x) (SHA2_ROTR(x, 7) ^ SHA2_ROTR(x, 18) ^ SHA2_SHFR(x, 3))

define SHA256_F4(x) (SHA2_ROTR(x, 17) ^ SHA2_ROTR(x, 19) ^ SHA2_SHFR(x, 10))

define SHA2_UNPACK32(x, str) \

{ \ *((str) + 3) = (uint8) ((x) ); \ *((str) + 2) = (uint8) ((x) >> 8); \ *((str) + 1) = (uint8) ((x) >> 16); \ *((str) + 0) = (uint8) ((x) >> 24); \ }