Generate breached passwords script

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,21 @@ 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)
+
+target_include_directories(${PROJECT_NAME} PRIVATE tests)
+
+include(Catch)

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

@@ -3,11 +3,11 @@
 #include <string.h>
 
 #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);");
     db.execute("INSERT INTO passwords (password) VALUES ('chocolate1');");

backend/src/password.cpp

@@ -0,0 +1,75 @@
+#include <iostream>
+#include "password.hpp"
+
+namespace password
+{
+    std::unordered_set<std::string> generatePasswords(const int &numPasswords, const int &maxChars)
+    {
+        const int min_chars = 10;
+
+        if (maxChars < min_chars) {
+            std::cout << "Password must have a minimum length of 10 characters\n";
+            exit(0);
+        }
+
+        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() < numPasswords)
+        {
+            // randomize length between minChars and maxChars
+            const size_t length = min_chars + rand() % ((maxChars + 1) - min_chars);
+            std::string password = ""; 
+            bool hasLowercase = false;
+            bool hasUppercase = false;
+            bool hasDigit = false;
+            bool hasSymbol = false;
+
+            while (password.length() < length)
+            {
+                int charType = rand() % 4;
+                int index;
+                switch (charType)
+                {
+                case 0: // lowercase letter
+                    if (hasLowercase && !(hasUppercase && hasDigit && hasSymbol)){
+                        break;
+                    }
+                    index = rand() % lowercase.length();
+                    password = password + lowercase[index];
+                    hasLowercase = true;
+                    break;
+                case 1: // uppercase letter
+                    if (hasUppercase && !(hasLowercase && hasDigit && hasSymbol)) {
+                        break;
+                    }
+                    index = rand() % uppercase.length();
+                    password = password + uppercase[index];
+                    hasUppercase = true;
+                    break;
+                case 2: // digit
+                    if (hasDigit && !(hasLowercase && hasUppercase && hasSymbol)) {
+                        break;
+                    }
+                    index = rand() % digits.length();
+                    password = password + digits[index];
+                    hasDigit = true;
+                    break;
+                case 3: // symbol
+                    if (hasSymbol && !(hasLowercase && hasUppercase && hasDigit)) {
+                        break;
+                    }
+                    index = rand() % symbols.length();
+                    password = password + symbols[index];
+                    hasSymbol = 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> 
+     */
+    std::unordered_set<std::string> generatePasswords(const int &numPasswords, const int &maxChars);
+}
+#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));
+    }
+}