simpleP.cpp

/*
 * simpleP — Simple Password Generator
 * A lightweight terminal password generator.
 * Licensed under GNU GPL v3.0 or later.
 */

#include <iostream>
#include <string>
#include <fstream>
#include <vector>
#include <cstdlib>

using namespace std;

// Word list for memorable passwords (common short words)
const vector<string> words = {
    "apple", "blue", "cat", "dog", "sun", "moon", "star", "fish",
    "bird", "tree", "book", "door", "fire", "gold", "hill", "ice",
    "jazz", "king", "lion", "milk", "nose", "owl", "pen", "queen",
    "rain", "snow", "top", "unit", "van", "wind", "yard", "zero"
};

/*
 * getRandomBytes — reads random bytes from /dev/urandom.
 * This is cryptographically secure and avoids the pwgen CVE-2013-4442 bug.
 */
void getRandomBytes(unsigned char *buf, size_t len) {
    ifstream urandom("/dev/urandom", ios::binary);
    urandom.read(reinterpret_cast<char *>(buf), len);
}

/*
 * getRandomInt — returns a random integer in [0, max).
 */
int getRandomInt(int max) {
    if (max <= 0) return 0;
    unsigned char buf[4];
    getRandomBytes(buf, 4);
    unsigned int val = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
    return val % max;
}

/*
 * getRandomChar — returns a random character from the given set.
 */
char getRandomChar(const string &charset) {
    return charset[getRandomInt(charset.length())];
}

/*
 * generateMemorable — generates a memorable password like "Blue-House-42-Pine".
 */
string generateMemorable(int wordCount) {
    string result;
    for (int i = 0; i < wordCount; i++) {
        string word = words[getRandomInt(words.size())];
        // Capitalize first letter
        word[0] = toupper(word[0]);
        result += word;
        if (i < wordCount - 1) result += "-";
    }
    // Add a random number at the end
    result += "-" + to_string(getRandomInt(90) + 10);
    return result;
}

/*
 * generateStrong — generates a strong password with mixed characters.
 */
string generateStrong(int length) {
    string upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    string lower = "abcdefghijklmnopqrstuvwxyz";
    string digits = "0123456789";
    string symbols = "!@#$%^&*()_+-=[]{}|;:,.<>?";
    string all = upper + lower + digits + symbols;
    
    string result;
    // Ensure at least one of each type
    result += getRandomChar(upper);
    result += getRandomChar(lower);
    result += getRandomChar(digits);
    result += getRandomChar(symbols);
    
    // Fill the rest randomly
    for (int i = 4; i < length; i++) {
        result += getRandomChar(all);
    }
    
    // Shuffle the result
    for (int i = result.length() - 1; i > 0; i--) {
        int j = getRandomInt(i + 1);
        swap(result[i], result[j]);
    }
    
    return result;
}

/*
 * generateAlphanum — generates an alphanumeric password (no symbols).
 */
string generateAlphanum(int length) {
    string chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
    string result;
    for (int i = 0; i < length; i++) {
        result += getRandomChar(chars);
    }
    return result;
}

/*
 * generatePin — generates a numeric PIN code.
 */
string generatePin(int length) {
    string digits = "0123456789";
    string result;
    for (int i = 0; i < length; i++) {
        result += getRandomChar(digits);
    }
    return result;
}

int main(int argc, char *argv[]) {
    int length = 16;           // default length for strong passwords
    string mode = "strong";    // strong by default
    
    // Parse arguments
    for (int i = 1; i < argc; i++) {
        string arg = argv[i];
        if (arg == "--memorable") {
            mode = "memorable";
            length = 12;
        } else if (arg == "--strong") {
            mode = "strong";
        } else if (arg == "--alphanum") {
            mode = "alphanum";
        } else if (arg == "--pin") {
            mode = "pin";
            length = 4;
        } else {
            try {
                length = stoi(arg);
                if (length < 4) length = 4;
                if (length > 128) length = 128;
            } catch (...) {
                cout << "Usage: simplep [--strong|--memorable|--alphanum|--pin] [length]" << endl;
                cout << "  simplep              strong password (16 chars)" << endl;
                cout << "  simplep 20           strong password (20 chars)" << endl;
                cout << "  simplep --memorable  memorable password (4 words)" << endl;
                cout << "  simplep --alphanum   alphanumeric only" << endl;
                cout << "  simplep --pin        numeric PIN (4 digits)" << endl;
                return 1;
            }
        }
    }
    
    string password;
    
    if (mode == "memorable") {
        int wordCount = max(3, length / 4);
        password = generateMemorable(wordCount);
    } else if (mode == "alphanum") {
        password = generateAlphanum(length);
    } else if (mode == "pin") {
        password = generatePin(length);
    } else {
        password = generateStrong(length);
    }
    
    cout << password << endl;
    return 0;
}