Update to properly use vcpkg-provided Crypto++

CMakeLists.txt

@@ -46,8 +46,13 @@ else()
 endif()
 
 # Handle Crypto++ dependency
-set(CRYPTOPP_INCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/../vcpkg/installed/x64-windows/include")
+find_package(cryptopp CONFIG QUIET)
-set(CRYPTOPP_LIBRARIES "${CMAKE_CURRENT_SOURCE_DIR}/../vcpkg/installed/x64-windows/lib/cryptopp.lib")
+
+if(cryptopp_FOUND)
+    message(STATUS "Found Crypto++ package via vcpkg")
+else()
+    message(WARNING "Crypto++ not found via vcpkg. Make sure to use the vcpkg toolchain file.")
+endif()
 
 # Add library sources
 set(SOURCES
@@ -72,11 +77,12 @@ add_library(privatebinapi SHARED ${SOURCES} ${HEADERS})
 # Include directories
 target_include_directories(privatebinapi PUBLIC 
     ${CMAKE_CURRENT_SOURCE_DIR}/include
-    ${CRYPTOPP_INCLUDE_DIRS}
 )
 
 # Link Crypto++
-target_link_libraries(privatebinapi PRIVATE ${CRYPTOPP_LIBRARIES})
+if(cryptopp_FOUND)
+    target_link_libraries(privatebinapi PRIVATE cryptopp::cryptopp)
+endif()
 
 # Include nlohmann/json
 if(nlohmann_json_FOUND)

build.bat

@@ -5,8 +5,8 @@ REM Create build directory
 if not exist "build" mkdir build
 cd build
 
-REM Generate build files with CMake
+REM Generate build files with CMake and vcpkg toolchain
-cmake .. -G "Visual Studio 17 2022"
+cmake .. -G "Visual Studio 17 2022" -DCMAKE_TOOLCHAIN_FILE=../vcpkg/scripts/buildsystems/vcpkg.cmake
 
 REM Build the project
 cmake --build . --config Release

src/crypto.cpp

@@ -3,7 +3,6 @@
 #include <stdexcept>
 #include <cstring>
 
-#ifndef NO_CRYPTO
 // Crypto++ includes
 #include "cryptlib.h"
 #include "osrng.h"      // AutoSeededRandomPool
@@ -14,10 +13,8 @@
 #include "zlib.h"       // Zlib compression
 
 using namespace CryptoPP;
-#endif
 
 std::vector<unsigned char> Crypto::generate_key(size_t length) {
-#ifndef NO_CRYPTO
     std::vector<unsigned char> key(length);
     
     // Use Crypto++ AutoSeededRandomPool for cryptographically secure random numbers
@@ -25,26 +22,12 @@ std::vector<unsigned char> Crypto::generate_key(size_t length) {
     rng.GenerateBlock(key.data(), length);
     
     return key;
-#else
-    // Fallback to std::random - NOT cryptographically secure!
-    std::vector<unsigned char> key(length);
-    std::random_device rd;
-    std::mt19937 gen(rd());
-    std::uniform_int_distribution<> dis(0, 255);
-    
-    for (size_t i = 0; i < length; ++i) {
-        key[i] = static_cast<unsigned char>(dis(gen));
-    }
-    
-    return key;
-#endif
 }
 
 std::vector<unsigned char> Crypto::encrypt(const std::vector<unsigned char>& plaintext,
                                          const std::vector<unsigned char>& key,
                                          const std::vector<unsigned char>& iv,
                                          std::vector<unsigned char>& auth_tag) {
-#ifndef NO_CRYPTO
     try {
         // Create GCM mode encryption object
         GCM<AES>::Encryption encryption;
@@ -76,23 +59,12 @@ std::vector<unsigned char> Crypto::encrypt(const std::vector<unsigned char>& pla
     catch(const CryptoPP::Exception& e) {
         throw std::runtime_error("Encryption failed: " + std::string(e.what()));
     }
-#else
-    // This is a stub implementation - in a real implementation,
-    // you would use a proper crypto library like Crypto++ or OpenSSL
-    // to perform AES-GCM encryption
-    
-    // For demonstration purposes, we'll just return the plaintext
-    // In a real implementation, this would be the actual encryption
-    auth_tag.resize(16, 0); // 128-bit authentication tag
-    return plaintext;
-#endif
 }
 
 std::vector<unsigned char> Crypto::decrypt(const std::vector<unsigned char>& ciphertext,
                                          const std::vector<unsigned char>& key,
                                          const std::vector<unsigned char>& iv,
                                          const std::vector<unsigned char>& auth_tag) {
-#ifndef NO_CRYPTO
     try {
         // Create GCM mode decryption object
         GCM<AES>::Decryption decryption;
@@ -125,22 +97,12 @@ std::vector<unsigned char> Crypto::decrypt(const std::vector<unsigned char>& cip
     catch(const CryptoPP::Exception& e) {
         throw std::runtime_error("Decryption failed: " + std::string(e.what()));
     }
-#else
-    // This is a stub implementation - in a real implementation,
-    // you would use a proper crypto library like Crypto++ or OpenSSL
-    // to perform AES-GCM decryption
-    
-    // For demonstration purposes, we'll just return the ciphertext
-    // In a real implementation, this would be the actual decryption
-    return ciphertext;
-#endif
 }
 
 std::vector<unsigned char> Crypto::pbkdf2_hmac_sha256(const std::string& password,
                                                     const std::vector<unsigned char>& salt,
                                                     int iterations,
                                                     size_t key_length) {
-#ifndef NO_CRYPTO
     try {
         std::vector<unsigned char> derived_key(key_length);
         
@@ -163,23 +125,9 @@ std::vector<unsigned char> Crypto::pbkdf2_hmac_sha256(const std::string& passwor
     catch(const CryptoPP::Exception& e) {
         throw std::runtime_error("PBKDF2 key derivation failed: " + std::string(e.what()));
     }
-#else
-    // This is a stub implementation - in a real implementation,
-    // you would use a proper crypto library to perform PBKDF2-HMAC-SHA256
-    
-    // For demonstration purposes, we'll just return a key of the requested length
-    // filled with a simple pattern
-    std::vector<unsigned char> key(key_length, 0);
-    for (size_t i = 0; i < key_length; i++) {
-        key[i] = static_cast<unsigned char>((i * 17) % 256);
-    }
-    
-    return key;
-#endif
 }
 
 std::vector<unsigned char> Crypto::compress(const std::vector<unsigned char>& data) {
-#ifndef NO_CRYPTO
     try {
         std::string compressed;
         
@@ -199,17 +147,9 @@ std::vector<unsigned char> Crypto::compress(const std::vector<unsigned char>& da
     catch(const CryptoPP::Exception& e) {
         throw std::runtime_error("Compression failed: " + std::string(e.what()));
     }
-#else
-    // This is a stub implementation - in a real implementation,
-    // you would use zlib or another compression library
-    
-    // For demonstration purposes, we'll just return the data as-is
-    return data;
-#endif
 }
 
 std::vector<unsigned char> Crypto::decompress(const std::vector<unsigned char>& data) {
-#ifndef NO_CRYPTO
     try {
         std::string decompressed;
         
@@ -229,11 +169,4 @@ std::vector<unsigned char> Crypto::decompress(const std::vector<unsigned char>&
     catch(const CryptoPP::Exception& e) {
         throw std::runtime_error("Decompression failed: " + std::string(e.what()));
     }
-#else
-    // This is a stub implementation - in a real implementation,
-    // you would use zlib or another decompression library
-    
-    // For demonstration purposes, we'll just return the data as-is
-    return data;
-#endif
 }