Generate breached passwords script

.github/workflows/backend.yml

@@ -0,0 +1,41 @@
+name: Backend
+
+on: [pull_request, push]
+
+env:
+  # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
+  BUILD_TYPE: Release
+
+jobs:
+  test:
+    # The CMake configure and build commands are platform agnostic and should work equally
+    # well on Windows or Mac.  You can convert this to a matrix build if you need
+    # cross-platform coverage.
+    # See: https://docs.github.com/en/free-pro-team@latest/actions/learn-github-actions/managing-complex-workflows#using-a-build-matrix
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Get Conan
+      uses: turtlebrowser/get-conan@v1.0
+
+    - name: Create default profile
+      working-directory: ./backend
+      run: conan profile detect
+
+    - name: Install dependencies
+      working-directory: ${{github.workspace}}/backend
+      run: conan install . --output-folder=build --build=missing -s build_type=${{env.BUILD_TYPE}}
+
+    - name: Configure CMake
+      working-directory: ${{github.workspace}}/backend/build
+      run: cmake .. -DCMAKE_TOOLCHAIN_FILE=conan_toolchain.cmake -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}}
+
+    - name: Build
+      working-directory: ${{github.workspace}}/backend/build
+      run: cmake --build . --config ${{env.BUILD_TYPE}}
+
+    - name: Run tests
+      working-directory: ${{github.workspace}}/backend/build
+      run: ./test/pdl_test

.github/workflows/commits.yml

@@ -1,6 +1,6 @@
 name: Conventional Commits
 
-on: [pull_request, push]
+on: [push]
 
 jobs:
   build:

.gitignore

@@ -1 +1,2 @@
-.DS_Store
+.DS_Store
+.vscode

README.md

@@ -1,6 +1,7 @@
 # Private Data Lookup
 
 [![Conventional Commits](https://github.com/csirianni/private-data-lookup/actions/workflows/commits.yml/badge.svg)](https://github.com/csirianni/private-data-lookup/actions/workflows/commits.yml)
+[![Backend](https://github.com/csirianni/private-data-lookup/actions/workflows/backend.yml/badge.svg)](https://github.com/csirianni/private-data-lookup/actions/workflows/backend.yml)
 
 ## Overview
 

backend/CMakeLists.txt

@@ -1,18 +1,15 @@
 cmake_minimum_required(VERSION 3.27)
-project(backend)
 
-find_package(Crow REQUIRED)
-find_package(SQLite3 REQUIRED)
+project(pdl LANGUAGES CXX)
 
-set(SOURCES
-    src/main.cpp
-    src/database.cpp
-)
+add_subdirectory("src")
+add_subdirectory("test")
 
-set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
-
-add_executable(${PROJECT_NAME} ${SOURCES})
+if(NOT DEFINED CMAKE_CXX_STANDARD)
+    set(CMAKE_CXX_STANDARD_20)
+    set(CMAKE_CXX_STANDARD_REQUIRED True)
+endif()
 
-target_link_libraries(${PROJECT_NAME} Crow::Crow SQLite::SQLite3)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
-target_include_directories(${PROJECT_NAME} PRIVATE src)
+set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fsanitize=address,undefined,float-divide-by-zero,float-cast-overflow, -fno-sanitize=all,null,alignment")

backend/Makefile

@@ -0,0 +1,15 @@
+BUILD_DIR = build
+
+all: build
+
+build:
+	cd $(BUILD_DIR) && cmake .. -DCMAKE_TOOLCHAIN_FILE=conan_toolchain.cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
+	cd $(BUILD_DIR) && cmake --build .
+
+run: build
+	cd ${BUILD_DIR} && ./src/server
+
+check: build
+	cd $(BUILD_DIR) && ./test/pdl_test	
+
+.PHONY: all build run check

backend/README.md

@@ -30,3 +30,11 @@ 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/CMakeLists.txt

@@ -0,0 +1,10 @@
+find_package(Crow REQUIRED)
+find_package(SQLite3 REQUIRED)
+
+add_library(src database.cpp password.cpp)
+
+add_executable(server main.cpp)
+
+target_link_libraries(server Crow::Crow SQLite::SQLite3 src)
+
+target_include_directories(server PRIVATE src)

backend/src/database.cpp

@@ -18,56 +18,61 @@ namespace
 
 namespace database
 {
-    Database::Database(const std::string &file_path) : is_closed(false)
+    Database::Database(const std::string &file_path) : is_closed_(false)
     {
         if (std::filesystem::exists(file_path))
         {
             std::remove(file_path.c_str());
         }
 
-        int result = sqlite3_open_v2(file_path.c_str(), &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
+        int result = sqlite3_open_v2(file_path.c_str(), &db_, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
         if (result != SQLITE_OK)
         {
-            const char *error_msg = sqlite3_errmsg(db);
+            const char *error_msg = sqlite3_errmsg(db_);
             fprintf(stderr, "SQLite error: %s\n", error_msg);
         }
     }
 
     void Database::execute(const std::string &command)
     {
-        int result = sqlite3_exec(db, command.c_str(), NULL, NULL, NULL);
+        int result = sqlite3_exec(db_, command.c_str(), NULL, NULL, NULL);
         if (result != SQLITE_OK)
         {
-            const char *error_msg = sqlite3_errmsg(db);
+            const char *error_msg = sqlite3_errmsg(db_);
             fprintf(stderr, "SQLite error: %s\n", error_msg);
         }
     }
 
     void Database::printTable(const std::string &table)
     {
         const std::string query = "SELECT * FROM " + table + ";";
-        int result = sqlite3_exec(db, query.c_str(), printRow, NULL, NULL);
+        int result = sqlite3_exec(db_, query.c_str(), printRow, NULL, NULL);
         if (result != SQLITE_OK)
         {
-            const char *error_msg = sqlite3_errmsg(db);
+            const char *error_msg = sqlite3_errmsg(db_);
             fprintf(stderr, "SQLite error: %s\n", error_msg);
         }
     }
 
     void Database::close()
     {
-        sqlite3_close(db);
-        is_closed = true;
+        int result = sqlite3_close(db_);
+        if (result != SQLITE_OK)
+        {
+            const char *error_msg = sqlite3_errmsg(db_);
+            fprintf(stderr, "SQLite error: %s\n", error_msg);
+        }
+        is_closed_ = true;
     }
 
     Database::~Database()
     {
-        if (!is_closed)
+        if (!is_closed_)
         {
-            int result = sqlite3_close(db);
+            int result = sqlite3_close(db_);
             if (result != SQLITE_OK)
             {
-                const char *error_msg = sqlite3_errmsg(db);
+                const char *error_msg = sqlite3_errmsg(db_);
                 fprintf(stderr, "SQLite error: %s\n", error_msg);
             }
             std::abort();

backend/src/database.hpp

@@ -48,8 +48,8 @@ namespace database
         ~Database();
 
     private:
-        sqlite3 *db;
-        bool is_closed;
+        sqlite3 *db_;
+        bool is_closed_;
     };
 }
 #endif // DATABASE_H

backend/src/main.cpp

@@ -1,15 +1,21 @@
 #include <stdlib.h>
 #include <stdio.h>
 #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);");
+
+    // generate and insert the passwords into the database
+    std::unordered_set<std::string> password_set = password::generatePasswords(100, 20);
+    for (const auto &password : password_set)
+    {
+        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,80 @@
+#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
+        if (max_chars < min_chars)
+        {
+            throw std::invalid_argument("max_chars must be > " + std::to_string(min_chars));
+        }
+
+        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 min_chars and max_chars
+            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,20 @@
+#include <unordered_set>
+#include <string>
+
+#ifndef PASSWORDS_H
+#define PASSWORDS_H
+
+namespace password
+{
+    /**
+     * @brief Generate 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 num_passwords The number of passwords to generate.
+     * @param max_chars The maximum number of characters for a password.
+     * @return std::unordered_set<std::string> The passwords generated.
+     * @throws std::invalid_argument If max_chars is < min_chars (locally defined).
+     */
+    std::unordered_set<std::string> generatePasswords(int num_passwords, int max_chars);
+}
+#endif // PASSWORDS_H

backend/test/CMakeLists.txt

@@ -0,0 +1,11 @@
+find_package(Catch2 REQUIRED)
+
+set (TEST_SOURCE
+    password.cpp
+)
+
+add_executable(pdl_test ${TEST_SOURCE})
+
+target_link_libraries(pdl_test src Catch2::Catch2WithMain)
+
+target_include_directories(pdl_test PUBLIC ${CMAKE_SOURCE_DIR}/src)