Generate breached passwords script

.vscode/settings.json

@@ -0,0 +1,61 @@
+{
+    "files.associations": {
+        "__bit_reference": "cpp",
+        "__config": "cpp",
+        "__debug": "cpp",
+        "__errc": "cpp",
+        "__hash_table": "cpp",
+        "__locale": "cpp",
+        "__mutex_base": "cpp",
+        "__node_handle": "cpp",
+        "__split_buffer": "cpp",
+        "__threading_support": "cpp",
+        "__verbose_abort": "cpp",
+        "array": "cpp",
+        "atomic": "cpp",
+        "bitset": "cpp",
+        "cctype": "cpp",
+        "charconv": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "complex": "cpp",
+        "cstdarg": "cpp",
+        "cstddef": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cstring": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "deque": "cpp",
+        "exception": "cpp",
+        "initializer_list": "cpp",
+        "iomanip": "cpp",
+        "ios": "cpp",
+        "iosfwd": "cpp",
+        "iostream": "cpp",
+        "istream": "cpp",
+        "limits": "cpp",
+        "locale": "cpp",
+        "mutex": "cpp",
+        "new": "cpp",
+        "optional": "cpp",
+        "ostream": "cpp",
+        "ratio": "cpp",
+        "regex": "cpp",
+        "sstream": "cpp",
+        "stdexcept": "cpp",
+        "streambuf": "cpp",
+        "string": "cpp",
+        "string_view": "cpp",
+        "system_error": "cpp",
+        "tuple": "cpp",
+        "typeinfo": "cpp",
+        "unordered_map": "cpp",
+        "unordered_set": "cpp",
+        "variant": "cpp",
+        "vector": "cpp",
+        "algorithm": "cpp"
+    }
+}

backend/CMakeLists.txt

@@ -1,4 +1,6 @@
 cmake_minimum_required(VERSION 3.27)
+
+## application
 project(backend)
 
 find_package(Crow REQUIRED)
@@ -7,6 +9,7 @@ find_package(SQLite3 REQUIRED)
 set(SOURCES
     src/main.cpp
     src/database.cpp
+    src/password.cpp
 )
 
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
@@ -16,3 +19,17 @@ add_executable(${PROJECT_NAME} ${SOURCES})
 target_link_libraries(${PROJECT_NAME} Crow::Crow SQLite::SQLite3)
 
 target_include_directories(${PROJECT_NAME} PRIVATE src)
+
+## tests
+project(tests)
+
+find_package(Catch2 REQUIRED)
+
+set (TEST_SOURCE
+    tests/testPasswordGenerator.cpp
+    src/password.cpp
+)
+
+add_executable(${PROJECT_NAME} ${TEST_SOURCE})
+
+target_link_libraries(${PROJECT_NAME} PRIVATE Catch2::Catch2WithMain)

backend/README.md

@@ -30,3 +30,9 @@ To fix VS Code import errors with Crow, try adding the following line to your `s
 ```
 
 [Source](https://stackoverflow.com/questions/58077908/linking-conan-include-to-vs-code)
+
+## Testing
+After building, you can run tests from `/backend`:
+```bash
+cd build && ./tests
+```

backend/conanfile.py

@@ -8,6 +8,7 @@ class BackendRecipe(ConanFile):
     def requirements(self):
         self.requires("crowcpp-crow/1.0+5")
         self.requires("sqlite3/3.42.0")
+        self.requires("catch2/3.4.0")
 
     def build_requirements(self):
         self.tool_requires("cmake/3.22.6")

backend/src/main.cpp

@@ -1,15 +1,23 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
+#include <iostream>
 
 #include "crow.h"
-#include <sqlite3.h>
 #include "database.hpp"
+#include "password.hpp"
 
 int main()
 {
     database::Database db = database::Database("passwords.db");
     db.execute("CREATE TABLE passwords (password TEXT);");
+
+    // generate and insert the passwords into the database
+    std::unordered_set<std::string> passwordSet = password::generatePasswords(10, 20);
+    for (const auto &password : passwordSet)
+    {
+        db.execute("INSERT INTO passwords (password) VALUES ('" + password + "');");
+    }
     db.execute("INSERT INTO passwords (password) VALUES ('chocolate1');");
     db.printTable("passwords");
 

backend/src/password.cpp

@@ -0,0 +1,86 @@
+#include <iostream>
+#include "password.hpp"
+
+namespace password
+{
+    std::unordered_set<std::string> generatePasswords(int num_passwords, int max_chars)
+    {
+        const int min_chars = 10;
+
+        // ensure max_chars is greater than min_chars
+        try {
+            if (max_chars < min_chars)
+            {
+                throw (max_chars);
+            }
+        }
+        catch (int max_chars) {
+            std::cout << "Password must have a minimum length of 10 characters\n";
+            std::cout << "You inputted a maximum length of " << max_chars << " characters \n";
+        }
+
+        std::unordered_set<std::string> passwords;
+        const std::string lowercase = "abcdefghijklmnopqrstuvwxyz";
+        const std::string uppercase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+        const std::string digits = "0123456789";
+        const std::string symbols = "!#$%&()*+,-./:;<=>?@[]^_`{|}~";
+
+        while (passwords.size() < num_passwords)
+        {
+            // randomize length between minChars and maxChars
+            const size_t length = min_chars + rand() % ((max_chars + 1) - min_chars);
+            std::string password = "";
+            bool has_lowercase = false;
+            bool has_uppercase = false;
+            bool has_digit = false;
+            bool has_symbol = false;
+
+            while (password.length() < length)
+            {
+                int char_type = rand() % 4;
+                int index;
+                switch (char_type)
+                {
+                case 0: // lowercase letter
+                    if (has_lowercase && !(has_uppercase && has_digit && has_symbol))
+                    {
+                        break;
+                    }
+                    index = rand() % lowercase.length();
+                    password = password + lowercase[index];
+                    has_lowercase = true;
+                    break;
+                case 1: // uppercase letter
+                    if (has_uppercase && !(has_lowercase && has_digit && has_symbol))
+                    {
+                        break;
+                    }
+                    index = rand() % uppercase.length();
+                    password = password + uppercase[index];
+                    has_uppercase = true;
+                    break;
+                case 2: // digit
+                    if (has_digit && !(has_lowercase && has_uppercase && has_symbol))
+                    {
+                        break;
+                    }
+                    index = rand() % digits.length();
+                    password = password + digits[index];
+                    has_digit = true;
+                    break;
+                case 3: // symbol
+                    if (has_symbol && !(has_lowercase && has_uppercase && has_digit))
+                    {
+                        break;
+                    }
+                    index = rand() % symbols.length();
+                    password = password + symbols[index];
+                    has_symbol = true;
+                    break;
+                };
+            };
+            passwords.insert(password);
+        };
+        return passwords;
+    };
+};

backend/src/password.hpp

@@ -0,0 +1,19 @@
+#include <unordered_set>
+#include <string>
+
+#ifndef PASSWORDS_H
+#define PASSWORDS_H
+
+namespace password
+{
+    /**
+     * @brief Returns a set of passwords, where each password contains at least one lowercase 
+     * letter, at least one uppercase letter, at least one digit, and at least special character.
+     * 
+     * @param numPasswords The number of passwords to generate.
+     * @param maxChars The maximum number of characters for a password.
+     * @return std::unordered_set<std::string> The passwords generated. 
+     */
+    std::unordered_set<std::string> generatePasswords(int num_passwords, int max_chars);
+}
+#endif // PASSWORDS_H

backend/tests/testPasswordGenerator.cpp

@@ -0,0 +1,29 @@
+#define CATCH_CONFIG_MAIN
+#include <regex>
+#include <catch2/catch_test_macros.hpp>
+#include "../src/password.hpp"
+
+bool hasLettersAndDigit(const std::string &password)
+{
+    const std::regex pattern("^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d).+$");
+    return regex_match(password, pattern);
+}
+
+bool hasSymbol(const std::string &password)
+{
+    return password.find_first_not_of("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890") != std::string::npos;
+}
+
+TEST_CASE("Test generatePassword creates valid passwords")
+{
+    std::unordered_set<std::string> passwordSet = password::generatePasswords(3, 12);
+    // function generated 3 passwords
+    CHECK(passwordSet.size() == 3);
+
+    for (const auto &password : passwordSet)
+    {   
+        CHECK(password.length() >= 10);
+        CHECK(hasLettersAndDigit(password));
+        CHECK(hasSymbol(password));
+    }
+}