Untitled

#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <openssl/evp.h>
#include <openssl/rsa.h>
#include <openssl/ec.h>
#include <openssl/rand.h>
#include <openssl/sha.h>
#include <openssl/ssl.h>
#include <openssl/bio.h>
#include <openssl/pem.h>

// Define a structure for nodes in the reticulum
struct Node {
    std::string name;
    int id;
    std::vector<Node*> connections;
};

// Function to convert a number to a string
template <typename T>
std::string toString(const T& value) {
    std::ostringstream oss;
    oss << value;
    return oss.str();
}

// Function to iterate through the nodes in the reticulum using nested loops
void iterateReticulum(const std::vector<Node*>& reticulum) {
    for (int i = 0; i < reticulum.size(); i++) {
        Node* node = reticulum[i];
        std::cout << "Node ID: " << node->id << ", Name: " << node->name << std::endl;
        
        for (int j = 0; j < node->connections.size(); j++) {
            Node* connection = node->connections[j];
            std::cout << "Connected to Node ID: " << connection->id << ", Name: " << connection->name << std::endl;
        }
    }
}

// Function to perform encryption using RSA
std::string encryptRSA(const std::string& plaintext, RSA* rsaPublicKey) {
    const int maxLength = RSA_size(rsaPublicKey);
    std::vector<unsigned char> ciphertext(maxLength);

    int encryptedLength = RSA_public_encrypt(plaintext.size(), (const unsigned char*)plaintext.c_str(), &ciphertext[0], rsaPublicKey, RSA_PKCS1_PADDING);
    if (encryptedLength == -1) {
        // Error occurred during encryption
        return "";
    }

    return std::string((const char*)&ciphertext[0], encryptedLength);
}

// Function to perform encryption using ECC
std::string encryptECC(const std::string& plaintext, EC_KEY* ecPublicKey) {
    const EVP_CIPHER* cipher = EVP_aes_128_gcm(); // Use AES-128-GCM cipher
    const int ivLength = EVP_CIPHER_iv_length(cipher);
    const int keyLength = EVP_CIPHER_key_length(cipher);
    const int tagLength = EVP_CIPHER_block_size(cipher);

    // Generate a random IV
    std::vector<unsigned char> iv(ivLength);
    if (RAND_bytes(&iv[0], ivLength) != 1) {
        // Error occurred during random number generation
        return "";
    }

    // Generate a random key
    std::vector<unsigned char> key(keyLength);
    if (RAND_bytes(&key[0], keyLength) != 1) {
        // Error occurred during random number generation
        return "";
    }

    // Encrypt the plaintext
    std::vector<unsigned char> ciphertext(plaintext.size() + tagLength);
    int encryptedLength;

    EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
    EVP_EncryptInit_ex(ctx, cipher, NULL, &key[0], &iv[0]);
    EVP_EncryptUpdate(ctx, &ciphertext[0], &encryptedLength, (const unsigned char*)plaintext.c_str(), plaintext.size());
    EVP_EncryptFinal_ex(ctx, &ciphertext[encryptedLength], &encryptedLength);
    EVP_CIPHER_CTX_free(ctx);

    // Combine the IV, key, and ciphertext into a single string
    std::string encryptedData;
    encryptedData += std::string((const char*)&iv[0], ivLength);
    encryptedData += std::string((const char*)&key[0], keyLength);
    encryptedData += std::string((const char*)&ciphertext[0], encryptedLength + tagLength);

    return encryptedData;
}

// Function to perform hashing using SHA-256
std::string hashSHA256(const std::string& data) {
    std::vector<unsigned char> hash(SHA256_DIGEST_LENGTH);
    SHA256_CTX ctx;
    SHA256_Init(&ctx);
    SHA256_Update(&ctx, data.c_str(), data.size());
    SHA256_Final(&hash[0], &ctx);
    
    std::stringstream ss;
    for (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
        ss << std::hex << std::setw(2) << std::setfill('0') << (int)hash[i];
    }
    
    return ss.str();
}

// Function to perform secure data transfer using SSL/TLS
void performSecureTransfer(const std::string& ciphertext, SSL* sslConnection) {
    SSL_write(sslConnection, ciphertext.c_str(), ciphertext.size);

    // Receive the response from the server
    char response[1024];
    int bytesRead = SSL_read(sslConnection, response, sizeof(response));
    if (bytesRead > 0) {
        std::cout << "Server response: " << std::string(response, bytesRead) << std::endl;
    }
}

int main() {
    // Generate the reticulum and connect the nodes
    std::vector<Node*> reticulum;
    for (int i = 0; i < 5; i++) {
        Node* node = new Node;
        node->id = i;
        node->name = "Node " + toString(i);
        reticulum.push_back(node);
        
        for (int j = 0; j < i; j++) {
            node->connections.push_back(reticulum[j]);
        }
    }
    
    // Iterate through the nodes in the reticulum
    iterateReticulum(reticulum);
    
    // Generate RSA key pair
    RSA* rsaKeyPair = RSA_generate_key(512, RSA_F4, NULL, NULL);
    
    // Generate ECC key pair
    EC_KEY* ecKeyPair = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);
    EC_KEY_generate_key(ecKeyPair);
    
    // Encrypt the plaintext using RSA
    std::string plaintext = "Hello, World!";
    std::string rsaCiphertext = encryptRSA(plaintext, rsaKeyPair);
    
    // Encrypt the plaintext using ECC
    std::string eccCiphertext = encryptECC(plaintext, ecKeyPair);
    
    // Hash the plaintext using SHA-256
    std::string hashedData = hashSHA256(plaintext);
    
    // Perform secure data transfer using SSL/TLS
    SSL_library_init();
    SSL_CTX* sslContext = SSL_CTX_new(TLSv1_2_client_method());
    SSL* sslConnection = SSL_new(sslContext);
    
    // ... Initialize and configure the SSL connection
    
    performSecureTransfer(rsaCiphertext, sslConnection);
    performSecureTransfer(eccCiphertext, sslConnection);
    performSecureTransfer(hashedData, sslConnection);
    
    // Clean up memory and resources
    for (Node* node : reticulum) {
        delete node;
    }
    RSA_free(rsaKeyPair);
    EC_KEY_free(ecKeyPair);
    SSL_free(sslConnection);
    SSL_CTX_free(sslContext);

    return 0;
} #include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <openssl/evp.h>
#include <openssl/rsa.h>
#include <openssl/ec.h>
#include <openssl/rand.h>
#include <openssl/sha.h>
#include <openssl/ssl.h>
#include <openssl/bio.h>
#include <openssl/pem.h>

// Define a structure for nodes in the reticulum
struct Node {
    std::string name;
    int id;
    std::vector<Node*> connections;
};

// Function to convert a number to a string
template <typename T>
std::string toString(const T& value) {
    std::ostringstream oss;
    oss << value;
    return oss.str();
}

// Function to iterate through the nodes in the reticulum using nested loops
void iterateReticulum(const std::vector<Node*>& reticulum) {
    for (int i = 0; i < reticulum.size(); i++) {
        Node* node = reticulum[i];
        std::cout << "Node ID: " << node->id << ", Name: " << node->name << std::endl;
        
        for (int j = 0; j < node->connections.size(); j++) {
            Node* connection = node->connections[j];
            std::cout << "Connected to Node ID: " << connection->id << ", Name: " << connection->name << std::endl;
        }
    }
}

// Function to perform encryption using RSA
std::string encryptRSA(const std::string& plaintext, RSA* rsaPublicKey) {
    const int maxLength = RSA_size(rsaPublicKey);
    std::vector<unsigned char> ciphertext(maxLength);

    int encryptedLength = RSA_public_encrypt(plaintext.size(), (const unsigned char*)plaintext.c_str(), &ciphertext[0], rsaPublicKey, RSA_PKCS1_PADDING);
    if (encryptedLength == -1) {
        // Error occurred during encryption
        return "";
    }

    return std::string((const char*)&ciphertext[0], encryptedLength);
}

// Function to perform encryption using ECC
std::string encryptECC(const std::string& plaintext, EC_KEY* ecPublicKey) {
    const EVP_CIPHER* cipher = EVP_ecb();
    const int keyLength = EVP_CIPHER_key_length(cipher);

    // Generate a random key
    std::vector<unsigned char> key(keyLength);
    if (RAND_bytes(&key[0], keyLength) != 1) {
        // Error occurred during random number generation
        return "";
    }

    // Encrypt the plaintext
    std::vector<unsigned char> ciphertext(plaintext.size());
    int encryptedLength;

    EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
    EVP_EncryptInit_ex(ctx, cipher, NULL, &key[0], NULL);
    EVP_EncryptUpdate(ctx, &ciphertext[0], &encryptedLength, (const unsigned char*)plaintext.c_str(), plaintext.size());
    EVP_EncryptFinal_ex(ctx, &ciphertext[encryptedLength], &encryptedLength);
    EVP_CIPHER_CTX_free(ctx);

    // Combine the key and ciphertext into a single string
    std::string encryptedData;
    encryptedData += std::string((const char*)&key[0], keyLength);
    encryptedData += std::string((const char*)&ciphertext[0], encryptedLength);

    return encryptedData;
}

// Function to perform hashing using SHA-256
std::string hashSHA256(const std::string& data) {
    std::vector<unsigned char> hash(SHA256_DIGEST_LENGTH);
    SHA256_CTX ctx;
    SHA256_Init(&ctx);
    SHA256_Update(&ctx, data.c_str(), data.size());
    SHA256_Final(&hash[0], &ctx);
    
    std::stringstream ss;
    for (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
        ss << std::hex << std::setw(2) << std::setfill('0') << (int)hash[i];
    }
    
    return ss.str();
}

// Function to perform secure data transfer using SSL/TLS
void performSecureTransfer(const std::string& ciphertext, SSL* sslConnection) {
    SSL_write(sslConnection, ciphertext.c_str(), ciphertext.size);

    // Receive the response from the server
    char response[1024];
    int bytesRead = SSL_read(sslConnection, response, sizeof(response));
    if (bytesRead > 0) {
        std::cout << "Server response: " << std::string(response, bytesRead) << std::endl;
    }
}

int main() {
    // Generate the reticulum and connect the nodes
    std::vector<Node*> reticulum;
    for (int i = 0; i <Apologies for the incomplete response. Due to the character limit, I couldn't include the entire code with ECB and ECC encryption. Here's a continuation of the previous code to include ECB and ECC encryption:

```cpp
    // Function to perform encryption using ECB
    std::string encryptECB(const std::string& plaintext, const std::string& key) {
        const EVP_CIPHER* cipher = EVP_aes_128_ecb(); // Use AES-128 in ECB mode

        std::vector<unsigned char> ciphertext(plaintext.size() + EVP_CIPHER_block_size(cipher));
        int encryptedLength;

        EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
        EVP_EncryptInit_ex(ctx, cipher, NULL, (const unsigned char*)key.c_str(), NULL);
        EVP_EncryptUpdate(ctx, &ciphertext[0], &encryptedLength, (const unsigned char*)plaintext.c_str(), plaintext.size());
        EVP_EncryptFinal_ex(ctx, &ciphertext[encryptedLength], &encryptedLength);
        EVP_CIPHER_CTX_free(ctx);

        return std::string((const char*)&ciphertext[0], encryptedLength);
    }

    // Function to perform encryption using ECC
    std::string encryptECC(const std::string& plaintext, EC_KEY* ecPublicKey) {
        const int maxLength = ECDSA_size(ecPublicKey);
        std::vector<unsigned char> ciphertext(maxLength);

        int encryptedLength = ECDSA_sign(0, (const unsigned char*)plaintext.c_str(), plaintext.size(), &ciphertext[0], (unsigned int*)&maxLength, ecPublicKey);
        if (encryptedLength == 0) {
            // Error occurred during encryption
            return "";
        }

        return std::string((const char*)&ciphertext[0], encryptedLength);
    }

    int main() {
        // Generate the reticulum and connect the nodes
        std::vector<Node*> reticulum;
        for (int i = 0; i < 5; i++) {
            Node* node = new Node;
            node->name = "Node " + toString(i);
            node->id = i;
            reticulum.push_back(node);
        }

        for (int i = 0; i < reticulum.size(); i++) {
            for (int j = i + 1; j < reticulum.size(); j++) {
                reticulum[i]->connections.push_back(reticulum[j]);
                reticulum[j]->connections.push_back(reticulum[i]);
            }
        }

        // Iterate through the reticulum
        iterateReticulum(reticulum);

        // Encrypt a message using RSA
        RSA* rsaPublicKey = RSA_generate_key(2048, RSA_F4, NULL, NULL);
        std::string plaintext = "Hello, World!";
        std::string encryptedRSA = encryptRSA(plaintext, rsaPublicKey);
        std::cout << "Encrypted RSA: " << encryptedRSA << std::endl;

        // Encrypt a message using ECB
        std::string key = "0123456789ABCDEF";
        std::string encryptedECB = encryptECB(plaintext, key);
        std::cout << "Encrypted ECB: " << encryptedECB << std::endl;

        // Encrypt a message using ECC
        EC_KEY* ecPublicKey = EC_KEY_new_by_curve_name(NID_secp256k1);
        EC_KEY_generate_key(ecPublicKey);
        std::string encryptedECC = encryptECC(plaintext, ecPublicKey);
        std::cout << "Encrypted ECC: " << encryptedECC << std::endl;

        // Perform secure data transfer using SSL/TLS
        SSL_CTX* sslContext = SSL_CTX_new(SSLv23_client_method());
        SSL* sslConnection = SSL_new(sslContext);
        SSL_set_fd(sslConnection, sockfd);
        SSL_connect(sslConnection);

        performSecureTransfer(encryptedRSA, sslConnection);
        performSecureTransfer(encryptedECB, sslConnection);
        performSecureTransfer(encryptedECC, sslConnection);

        // Clean up resources
        SSL_shutdown(sslConnection);
        SSL_free(sslConnection);
        SSL_CTX_free(sslContext);

        for (Node* node : reticulum) {
            delete node;
        }

        return 0;
    #include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <openssl/evp.h>
#include <openssl/rsa.h>
#include <openssl/ec.h>
#include <openssl/rand.h>
#include <openssl/sha.h>
#include <openssl/ssl.h>
#include <openssl/bio.h>
#include <openssl/pem.h>

// Define a structure for nodes in the reticulum
struct Node {
    std::string name;
    int id;
    std::vector<Node*> connections;
};

// Function to convert a number to a string
template <typename T>
std::string toString(const T& value) {
    std::ostringstream oss;
    oss << value;
    return oss.str();
}

// Function to iterate through the nodes in the reticulum using nested loops
void iterateReticulum(const std::vector<Node*>& reticulum) {
    for (int i = 0; i < reticulum.size(); i++) {
        Node* node = reticulum[i];
        std::cout << "Node ID: " << node->id << ", Name: " << node->name << std::endl;
        
        for (int j = 0; j < node->connections.size(); j++) {
            Node* connection = node->connections[j];
            std::cout << "Connected to Node ID: " << connection->id << ", Name: " << connection->name << std::endl;
        }
    }
}

// Function to perform encryption using RSA
std::string encryptRSA(const std::string& plaintext, RSA* rsaPublicKey) {
    const int maxLength = RSA_size(rsaPublicKey);
    std::vector<unsigned char> ciphertext(maxLength);

    int encryptedLength = RSA_public_encrypt(plaintext.size(), (const unsigned char*)plaintext.c_str(), &ciphertext[0], rsaPublicKey, RSA_PKCS1_PADDING);
    if (encryptedLength == -1) {
        // Error occurred during encryption
        return "";
    }

    return std::string((const char*)&ciphertext[0], encryptedLength);
}

// Function to perform encryption using ECC
std::string encryptECC(const std::string& plaintext, EC_KEY* ecPublicKey) {
    const EVP_CIPHER* cipher = EVP_ecb();
    const int keyLength = EVP_CIPHER_key_length(cipher);

    // Generate a random key
    std::vector<unsigned char> key(keyLength);
    if (RAND_bytes(&key[0], keyLength) != 1) {
        // Error occurred during random number generation
        return "";
    }

    // Encrypt the plaintext
    std::vector<unsigned char> ciphertext(plaintext.size());
    int encryptedLength;

    EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
    EVP_EncryptInit_ex(ctx, cipher, NULL, &key[0], NULL);
    EVP_EncryptUpdate(ctx, &ciphertext[0], &encryptedLength, (const unsigned char*)plaintext.c_str(), plaintext.size());
    EVP_EncryptFinal_ex(ctx, &ciphertext[encryptedLength], &encryptedLength);
    EVP_CIPHER_CTX_free(ctx);

    // Combine the key and ciphertext into a single string
    std::string encryptedData;
    encryptedData += std::string((const char*)&key[0], keyLength);
    encryptedData += std::string((const char*)&ciphertext[0], encryptedLength);

    return encryptedData;
}

// Function to perform hashing using SHA-256
std::string hashSHA256(const std::string& data) {
    std::vector<unsigned char> hash(SHA256_DIGEST_LENGTH);
    SHA256_CTX ctx;
    SHA256_Init(&ctx);
    SHA256_Update(&ctx, data.c_str(), data.size());
    SHA256_Final(&hash[0], &ctx);
    
    std::stringstream ss;
    for (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
        ss << std::hex << std::setw(2) << std::setfill('0') << (int)hash[i];
    }
    
    return ss.str();
}

// Function to perform secure data transfer using SSL/TLS
void performSecureTransfer(const std::string& ciphertext, SSL* sslConnection) {
    SSL_write(sslConnection, ciphertext.c_str(), ciphertext.size);

    // Receive the response from the server
    char response[1024];
    int bytesRead = SSL_read(sslConnection, response, sizeof(response));
    if (bytesRead > 0) {
        std::cout << "Server response: " << std::string(response, bytesRead) << std::endl;
    }
}

int main() {
    // Generate the reticulum and connect the nodes
    std::vector<Node*> reticulum;
    for (int i = 0; i <Apologies for the incomplete response. Due to the character limit, I couldn't include the entire code with ECB and ECC encryption. Here's a continuation of the previous code to include ECB and ECC encryption:

```cpp
    // Function to perform encryption using ECB
    std::string encryptECB(const std::string& plaintext, const std::string& key) {
        const EVP_CIPHER* cipher = EVP_aes_128_ecb(); // Use AES-128 in ECB mode

        std::vector<unsigned char> ciphertext(plaintext.size() + EVP_CIPHER_block_size(cipher));
        int encryptedLength;

        EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
        EVP_EncryptInit_ex(ctx, cipher, NULL, (const unsigned char*)key.c_str(), NULL);
        EVP_EncryptUpdate(ctx, &ciphertext[0], &encryptedLength, (const unsigned char*)plaintext.c_str(), plaintext.size());
        EVP_EncryptFinal_ex(ctx, &ciphertext[encryptedLength], &encryptedLength);
        EVP_CIPHER_CTX_free(ctx);

        return std::string((const char*)&ciphertext[0], encryptedLength);
    }

    // Function to perform encryption using ECC
    std::string encryptECC(const std::string& plaintext, EC_KEY* ecPublicKey) {
        const int maxLength = ECDSA_size(ecPublicKey);
        std::vector<unsigned char> ciphertext(maxLength);

        int encryptedLength = ECDSA_sign(0, (const unsigned char*)plaintext.c_str(), plaintext.size(), &ciphertext[0], (unsigned int*)&maxLength, ecPublicKey);
        if (encryptedLength == 0) {
            // Error occurred during encryption
            return "";
        }

        return std::string((const char*)&ciphertext[0], encryptedLength);
    }

    int main() {
        // Generate the reticulum and connect the nodes
        std::vector<Node*> reticulum;
        for (int i = 0; i < 5; i++) {
            Node* node = new Node;
            node->name = "Node " + toString(i);
            node->id = i;
            reticulum.push_back(node);
        }

        for (int i = 0; i < reticulum.size(); i++) {
            for (int j = i + 1; j < reticulum.size(); j++) {
                reticulum[i]->connections.push_back(reticulum[j]);
                reticulum[j]->connections.push_back(reticulum[i]);
            }
        }

        // Iterate through the reticulum
        iterateReticulum(reticulum);

        // Encrypt a message using RSA
        RSA* rsaPublicKey = RSA_generate_key(2048, RSA_F4, NULL, NULL);
        std::string plaintext = "Hello, World!";
        std::string encryptedRSA = encryptRSA(plaintext, rsaPublicKey);
        std::cout << "Encrypted RSA: " << encryptedRSA << std::endl;

        // Encrypt a message using ECB
        std::string key = "0123456789ABCDEF";
        std::string encryptedECB = encryptECB(plaintext, key);
        std::cout << "Encrypted ECB: " << encryptedECB << std::endl;

        // Encrypt a message using ECC
        EC_KEY* ecPublicKey = EC_KEY_new_by_curve_name(NID_secp256k1);
        EC_KEY_generate_key(ecPublicKey);
        std::string encryptedECC = encryptECC(plaintext, ecPublicKey);
        std::cout << "Encrypted ECC: " << encryptedECC << std::endl;

        // Perform secure data transfer using SSL/TLS
        SSL_CTX* sslContext = SSL_CTX_new(SSLv23_client_method());
        SSL* sslConnection = SSL_new(sslContext);
        SSL_set_fd(sslConnection, sockfd);
        SSL_connect(sslConnection);

        performSecureTransfer(encryptedRSA, sslConnection);
        performSecureTransfer(encryptedECB, sslConnection);
        performSecureTransfer(encryptedECC, sslConnection);

        // Clean up resources
        SSL_shutdown(sslConnection);
        SSL_free(sslConnection);
        SSL_CTX_free(sslContext);

        for (Node* node : reticulum) {
            delete node;
        }

        return 0;
    #include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <openssl/evp.h>
#include <openssl/rsa.h>
#include <openssl/ec.h>
#include <openssl/rand.h>
#include <openssl/sha.h>
#include <openssl/ssl.h>
#include <openssl/bio.h>
#include <openssl/pem.h>

// Define a structure for nodes in the reticulum
struct Node {
    std::string name;
    int id;
    std::vector<Node*> connections;
};

// Function to convert a number to a string
template <typename T>
std::string toString(const T& value) {
    std::ostringstream oss;
    oss << value;
    return oss.str();
}

// Function to iterate through the nodes in the reticulum using nested loops
void iterateReticulum(const std::vector<Node*>& reticulum) {
    for (int i = 0; i < reticulum.size(); i++) {
        Node* node = reticulum[i];
        std::cout << "Node ID: " << node->id << ", Name: " << node->name << std::endl;
        
        for (int j = 0; j < node->connections.size(); j++) {
            Node* connection = node->connections[j];
            std::cout << "Connected to Node ID: " << connection->id << ", Name: " << connection->name << std::endl;
        }
    }
}

// Function to perform encryption using RSA
std::string encryptRSA(const std::string& plaintext, RSA* rsaPublicKey) {
    const int maxLength = RSA_size(rsaPublicKey);
    std::vector<unsigned char> ciphertext(maxLength);

    int encryptedLength = RSA_public_encrypt(plaintext.size(), (const unsigned char*)plaintext.c_str(), &ciphertext[0], rsaPublicKey, RSA_PKCS1_PADDING);
    if (encryptedLength == -1) {
        // Error occurred during encryption
        return "";
    }

    return std::string((const char*)&ciphertext[0], encryptedLength);
}

// Function to perform encryption using ECB
std::string encryptECB(const std::string& plaintext, const std::string& key) {
    const EVP_CIPHER* cipher = EVP_aes_128_ecb(); // Use AES-128 in ECB mode

    std::vector<unsigned char> ciphertext(plaintext.size() + EVP_CIPHER_block_size(cipher));
    int encryptedLength;

    EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
    EVP_EncryptInit_ex(ctx, cipher, NULL, (const unsigned char*)key.c_str(), NULL);
    EVP_EncryptUpdate(ctx, &ciphertext[0], &encryptedLength, (const unsigned char*)plaintext.c_str(), plaintext.size());
    EVP_EncryptFinal_ex(ctx, &ciphertext[encryptedLength], &encryptedLength);
    EVP_CIPHER_CTX_free(ctx);

    return std::string((const char*)&ciphertext[0], encryptedLength);
}

// Function to perform encryption using ECC
std::string encryptECC(const std::string& plaintext, EC_KEY* ecPublicKey) {
    const int maxLength = ECDSA_size(ecPublicKey);
    std::vector<unsigned char> ciphertext(maxLength);

    int encryptedLength = ECDSA_sign(0, (const unsigned char*)plaintext.c_str(), plaintext.size(), &ciphertext[0], (unsigned int*)&maxLength, ecPublicKey);
    if (encryptedLength == 0) {
        // Error occurred during encryption
        return "";
    }

    return std::string((const char*)&ciphertext[0], encryptedLength);
}

// Function to perform hashing using SHA-256
std::string hashSHA256(const std::string& data) {
    std::vector<unsigned char> hash(SHA256_DIGEST_LENGTH);
    SHA256_CTX ctx;
    SHA256_Init(&ctx);
    SHA256_Update(&ctx, data.c_str(), data.size());
    SHA256_Final(&hash[0], &ctx);
    
    std::stringstream ss;
    for (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
        ss << std::hex << std::setw(2) << std::setfill('0') << (int)hash[i];
    }
    
    return ss.str();
}

// Function to perform hashing using SHA-512
std::string hashSHA512(const std::string& data) {
    std::vector<unsigned char> hash(SHA512_DIGEST_LENGTH);
    SHA512_CTX ctx;
    SHA512_Init(&ctx);
    SHA512_Update(&ctx, data.c_str(), data.size());
    SHA512_Final(&hash[0], &ctx);

    std::stringstream ss;
    for (int i = 0; i < SHA512_DIGEST_LENGTH; i++) {
        ss << std::hex << std::setw(2) << stdsetfill('0') << (int)hash[i];
    }

    return ss.str();
}