#include <iostream>
    #include <string>
    
    using namespace std;
    
    // Funcție pentru criptare
    string encrypt(string text, int shift) {
        string result = "";
    
        // Parcugem fiecare caracter din text
        for (int i = 0; i < text.length(); i++) {
            // Criptăm doar literele mari și mici
            if (isupper(text[i])) {
                // Pentru litere mari (A-Z)
                result += char(int(text[i] + shift - 65) % 26 + 65);
            }
            else if (islower(text[i])) {
                // Pentru litere mici (a-z)
                result += char(int(text[i] + shift - 97) % 26 + 97);
            }
            else {
                // Orice alt caracter rămâne neschimbat
                result += text[i];
            }
        }
        return result;
    }
    
    // Funcție pentru decriptare (opusul criptării)
    string decrypt(string text, int shift) {
        return encrypt(text, 26 - shift);  // Deplasăm invers
    }
    
    int main() {
        string text = "Salut Lume!"; // Textul de criptat
        int shift = 4; // Cheia de criptare (deplasarea)
    
        string encrypted = encrypt(text, shift);
        string decrypted = decrypt(encrypted, shift);
    
        cout << "Text original: " << text << endl;
        cout << "Text criptat: " << encrypted << endl;
        cout << "Text decriptat: " << decrypted << endl;
    
        return 0;
    }
    

    def caesar_cipher(message, shift):
        # Funcția pentru criptarea mesajului folosind cifra lui Caesar
        encrypted_message = ""
        for char in message:
            if char.isalpha():
                shift_base = ord('a') if char.islower() else ord('A')
                encrypted_char = chr(ord(char) - shift_base + shift) % 26 + shift_base
                encrypted_message += encrypted_char
            else:
                encrypted_message += char
        return encrypted_message

    # Exemplu de utilizare
    message = "Mesaj de test."
    shift = 3
    encrypted = caesar_cipher(message, shift)
    print("Mesaj criptat:", encrypted)

    #include <iostream>
    #include <sstream>
    #include <iomanip>
    #include <string>
            
    using namespace std;
            
    // Funcție care convertește un șir de caractere într-o reprezentare hexazecimală
    std::string stringToHex(const std::string& input) {
    std::stringstream ss;
        ss << std::hex << std::setfill('0');
        for (const char& ch : input) {
            ss << std::setw(2) << static_cast<int>(static_cast<unsigned char>(ch));
        }
        return ss.str();
    }
            
    // Funcție care convertește un șir de caractere hexazecimal înapoi în reprezentarea sa originală
    std::string hexToString(const std::string& hexStr) {
        std::string output;
        for (size_t i = 0; i < hexStr.length(); i += 2) {
            std::string part = hexStr.substr(i, 2);
            char ch = static_cast<char>(std::stoi(part, nullptr, 16));
            output.push_back(ch);
        }
        return output;
    }
            
    // Funcție de criptare/decriptare folosind XOR
    std::string xorEncryptDecrypt(const std::string& input, char key) {
        std::string output = input;
        for (size_t i = 0; i < input.size(); ++i) {
            output[i] = input[i] ^ key; // Aplică operația XOR cu cheia
        }
        return output;
    }
            
    // Funcție de criptare
    std::string hexaEncrypt(const std::string& message, char key) {
        std::string xorEncrypted = xorEncryptDecrypt(message, key); // Pasul 1: Criptare XOR
        return stringToHex(xorEncrypted);  // Pasul 2: Convertire în hexazecimal
    }
            
    // Funcție de decriptare
    std::string hexaDecrypt(const std::string& hexMessage, char key) {
        std::string xorDecrypted = hexToString(hexMessage);  // Pasul 1: Convertire din hexazecimal în șir normal
        return xorEncryptDecrypt(xorDecrypted, key);         // Pasul 2: Decriptare XOR
    }
            
    int main() {
        std::string message;
        char key;
                    
        // Citim mesajul de criptat de la utilizator
        std::cout << "Introdu mesajul pentru criptare: ";
        std::getline(std::cin, message);
            
        // Citim cheia pentru criptare (un singur caracter)
        std::cout << "Introdu cheia (un singur caracter): ";
        std::cin >> key;
            
        // Criptăm mesajul
        std::string encrypted = hexaEncrypt(message, key);
        std::cout << "Mesaj criptat (Hexa Crypt): " << encrypted << std::endl;
            
        // Decriptăm mesajul
        std::string decrypted = hexaDecrypt(encrypted, key);
        std::cout << "Mesaj decriptat (Mesaj original): " << decrypted << std::endl;
            
        return 0;
    }
            

    def string_to_hex(input_string):
        # Funcție care convertește un șir de caractere în hexazecimal
        return ''.join(format(ord(c), '02x') for c in input_string)

    def hex_to_string(hex_string):
        # Funcție care convertește un șir hexazecimal înapoi în caractere
        return ''.join(chr(int(hex_string[i:i + 2], 16)) for i in range(0, len(hex_string), 2))

    # Exemplu de utilizare
    message = "Mesaj de test."
    hex_value = string_to_hex(message)
    print("Mesaj în hexazecimal:", hex_value)
    decrypted_message = hex_to_string(hex_value)
    print("Mesaj decriptat:", decrypted_message)

    #include <iostream>
    #include <cmath>
    #include <cstdlib>
    #include <ctime>

    using namespace std;

    // Funcție pentru a calcula cel mai mare divizor comun (GCD)
    int gcd(int a, int b) {
        while (b != 0) {
            int temp = b;
            b = a % b;
            a = temp;
        }
        return a;
    }

    // Funcție pentru a calcula (a^b) % c
    long long modExp(long long a, long long b, long long c) {
        long long result = 1;
        a = a % c;
        while (b > 0) {
            if (b % 2 == 1)
                result = (result * a) % c;
            b = b / 2;
            a = (a * a) % c;
        }
        return result;
    }

    // Funcție pentru a găsi inversul modular al lui e mod phi(n) folosind metoda extinsă Euclid
    int modInverse(int e, int phi) {
        int t = 0, newT = 1;
        int r = phi, newR = e;

        while (newR != 0) {
            int quotient = r / newR;
            int tempT = t;
            t = newT;
            newT = tempT - quotient * newT;

            int tempR = r;
            r = newR;
            newR = tempR - quotient * newR;
        }

        if (t < 0)
            t += phi;

        return t;
    }

    int main() {
        srand(time(0));

        // Alegerea a două numere prime (pentru simplificare, sunt numere mici)
        int p = 61;
        int q = 53;

        // Calcularea lui n = p * q
        int n = p * q;

        // Calcularea funcției Euler φ(n) = (p-1) * (q-1)
        int phi = (p - 1) * (q - 1);

        // Alegerea cheii publice e, unde 1 < e < φ(n) și gcd(e, φ(n)) = 1
        int e;
        do {
            e = rand() % (phi - 2) + 2; // e este ales aleator între 2 și phi - 1
        } while (gcd(e, phi) != 1);

        // Calcularea cheii private d, astfel încât (d * e) % φ(n) = 1
        int d = modInverse(e, phi);

        // Afișarea cheilor publice și private
        cout << "Cheia publică: (" << e << ", " << n << ")" << endl;
        cout << "Cheia privată: (" << d << ", " << n << ")" << endl;

        // Mesajul de criptat (un număr mai mic decât n)
        int mesaj;
        cout << "Introdu un mesaj numeric (mai mic decât " << n << "):";
        cin >> mesaj;

        // Criptarea mesajului: C = M^e % n
        int criptat = modExp(mesaj, e, n);
        cout << "Mesaj criptat: " << criptat << endl;

        // Decriptarea mesajului: M = C^d % n
        int decriptat = modExp(criptat, d, n);
        cout << "Mesaj decriptat: " << decriptat << endl;

        return 0;
    }
    

    def gcd(a, b):
        # Funcție pentru calculul celui mai mare divizor comun
        while b != 0:
            a, b = b, a % b
        return a

    def mod_inverse(a, m):
        # Funcție pentru calculul inversului modular
        m0, x0, x1 = m, 0, 1
        while a > 1:
            q = a // m
            m, a = a % m, m
            x0, x1 = x1 - q * x0, x0
        return x1 + m0 if x1 < 0 else x1

    def rsa_encrypt(plaintext, e, n):
        # Funcție pentru criptarea mesajului folosind RSA
        return pow(plaintext, e, n)

    def rsa_decrypt(ciphertext, d, n):
        # Funcție pentru decriptarea mesajului folosind RSA
        return pow(ciphertext, d, n)

    # Exemplu de utilizare
    p = 61
    q = 53
    n = p * q
    phi = (p - 1) * (q - 1)
    e = 17 # Cheia publică
    d = mod_inverse(e, phi)

    message = 65 # Mesaj de criptat
    encrypted_message = rsa_encrypt(message, e, n)
    print("Mesaj criptat:", encrypted_message)

    decrypted_message = rsa_decrypt(encrypted_message, d, n)
    print("Mesaj decriptat:", decrypted_message)

    #include <iostream>
    #include <vector>
    #include <cstring> // pentru memcpy
    
    using namespace std;
    
    // Dimensiunea unui bloc în Blowfish (în biți)
    const int BLOCK_SIZE = 8;
    
    // S-Box-uri pentru Blowfish (inițializate cu valori fictive, ar trebui inițializate corect conform specificației)
    unsigned long S[4][256] = {
        { /* S-Box 1 valori */ },
        { /* S-Box 2 valori */ },
        { /* S-Box 3 valori */ },
        { /* S-Box 4 valori */ }
    };
    
    // P-array pentru Blowfish (valori inițiale, acestea vor fi modificate de cheie)
    unsigned long P[18] = { 
        0x243F6A88, 0x85A308D3, 0x13198A2E, 0x03707344,
        0xA4093822, 0x299F31D0, 0x082EFA98, 0xEC4E6C89,
        0x452821E6, 0x38D01377, 0xBE5466CF, 0x34E90C6C,
        0xC0AC29B7, 0xC97C50DD, 0x3F84D5B5, 0xB5470917,
        0x9216D5D9, 0x8979FB1B
    };
    
    // Funcția F a algoritmului Blowfish
    unsigned long F(unsigned long x) {
        unsigned short a, b, c, d;
        a = (x >> 24) & 0xFF;
        b = (x >> 16) & 0xFF;
        c = (x >> 8) & 0xFF;
        d = x & 0xFF;
    
        return ((S[0][a] + S[1][b]) ^ S[2][c]) + S[3][d];
    }
    
    // Cifrul Blowfish - rotirea blocurilor de date
    void BlowfishEncrypt(unsigned long &left, unsigned long &right) {
        for (int i = 0; i < 16; i++) {
            left ^= P[i];
            right ^= F(left);
            swap(left, right);
        }
    
        swap(left, right); // Inversarea finală
        right ^= P[16];
        left ^= P[17];
    }
    
    // Decifrarea Blowfish - operația inversă cifrării
    void BlowfishDecrypt(unsigned long &left, unsigned long &right) {
        for (int i = 17; i > 1; i--) {
            left ^= P[i];
            right ^= F(left);
            swap(left, right);
        }
    
        swap(left, right); // Inversarea finală
        right ^= P[1];
        left ^= P[0];
    }
    
    // Inițializarea cheii în Blowfish
    void BlowfishKeyExpansion(const vector<unsigned char> &key) {
        int keyIndex = 0;
    
        // XOR fiecare valoare din P-array cu cheia
        for (int i = 0; i < 18; i++) {
            unsigned long data = 0x00000000;
            for (int j = 0; j < 4; j++) {
                data = (data << 8) | key[keyIndex];
                keyIndex = (keyIndex + 1) % key.size();
            }
            P[i] ^= data;
        }
    
        // Criptarea blocurilor nule pentru a finaliza inițializarea
        unsigned long left = 0x00000000;
        unsigned long right = 0x00000000;
        for (int i = 0; i < 18; i += 2) {
            BlowfishEncrypt(left, right);
            P[i] = left;
            P[i + 1] = right;
        }
    
        // Inițializarea S-box-urilor (aceeași tehnică folosită pentru P-array)
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 256; j += 2) {
                BlowfishEncrypt(left, right);
                S[i][j] = left;
                S[i][j + 1] = right;
            }
        }
    }
    
    // Funcție pentru a cripta un bloc de 64 de biți (8 octeți)
    void EncryptBlock(unsigned char *block) {
        unsigned long left, right;
        memcpy(&left, block, 4);        // Primele 4 octeți -> partea stângă
        memcpy(&right, block + 4, 4);   // Următorii 4 octeți -> partea dreaptă
    
        BlowfishEncrypt(left, right);
    
        memcpy(block, &left, 4);
        memcpy(block + 4, &right, 4);
    }
    
    // Funcție pentru a decripta un bloc de 64 de biți (8 octeți)
    void DecryptBlock(unsigned char *block) {
        unsigned long left, right;
        memcpy(&left, block, 4);        // Primele 4 octeți -> partea stângă
        memcpy(&right, block + 4, 4);   // Următorii 4 octeți -> partea dreaptă
    
        BlowfishDecrypt(left, right);
    
        memcpy(block, &left, 4);
        memcpy(block + 4, &right, 4);
    }
    
    int main() {
        // Cheia de criptare (exemplu)
        vector<unsigned char> key = { 'K', 'e', 'y', 'S', 'e', 'c', 'r', 'e', 't' };
    
        // Expansiunea cheii Blowfish
        BlowfishKeyExpansion(key);
    
        // Exemplu de bloc de 8 octeți (64 de biți) de criptat
        unsigned char block[BLOCK_SIZE] = { 'T', 'e', 's', 't', 'B', 'l', 'o', 'c' };
    
        // Afișarea blocului înainte de criptare
        cout << "Bloc înainte de criptare: ";
        for (int i = 0; i < BLOCK_SIZE; i++) {
            cout << block[i];
        }
        cout << endl;
    
        // Criptarea blocului
        EncryptBlock(block);
    
        // Afișarea blocului după criptare
        cout << "Bloc după criptare: ";
        for (int i = 0; i < BLOCK_SIZE; i++) {
            printf("%02X ", block[i]);
        }
        cout << endl;
    
        // Decriptarea blocului
        DecryptBlock(block);
    
        // Afișarea blocului după decriptare
        cout << "Bloc după decriptare: ";
        for (int i = 0; i < BLOCK_SIZE; i++) {
            cout << block[i];
        }
        cout << endl;
    
        return 0;
    }
    

    from Crypto.Cipher import Blowfish
    from Crypto.Util.Padding import pad, unpad

    def blowfish_encrypt(key, plaintext):
        # Funcție de criptare folosind Blowfish
        cipher = Blowfish.new(key, Blowfish.MODE_CBC)
        iv = cipher.iv
        ciphertext = cipher.encrypt(pad(plaintext.encode(), Blowfish.block_size))
        return iv + ciphertext

    def blowfish_decrypt(key, ciphertext):
        # Funcție de decriptare folosind Blowfish
        iv = ciphertext[:Blowfish.block_size]
        cipher = Blowfish.new(key, Blowfish.MODE_CBC, iv)
        decrypted = unpad(cipher.decrypt(ciphertext[Blowfish.block_size:]), Blowfish.block_size)
        return decrypted.decode()

    # Exemplu de utilizare
    key = b'SecretK'  # Cheie de criptare
    plaintext = "Mesaj de test."
    ciphertext = blowfish_encrypt(key, plaintext)
    print("Mesaj criptat:", ciphertext)

    decrypted_message = blowfish_decrypt(key, ciphertext)
    print("Mesaj decriptat:", decrypted_message)
    

    #include <iostream>
    #include <string>
    #include <openssl/aes.h>
    #include <openssl/rand.h>

    using namespace std;

    // Funcție pentru criptare AES
    void aesEncrypt(const unsigned char* input, unsigned char* output, const unsigned char* key) {
        AES_KEY encryptKey;
        AES_set_encrypt_key(key, 128, &encryptKey); // Setăm cheia AES
        AES_encrypt(input, output, &encryptKey); // Criptăm folosind AES
    }

    // Funcție pentru decriptare AES
    void aesDecrypt(const unsigned char* input, unsigned char* output, const unsigned char* key) {
        AES_KEY decryptKey;
        AES_set_decrypt_key(key, 128, &decryptKey); // Setăm cheia AES pentru decriptare
        AES_decrypt(input, output, &decryptKey); // Decriptăm folosind AES
    }

    int main() {
        // Cheia trebuie să fie de exact 16 octeți pentru AES-128
        unsigned char key[AES_BLOCK_SIZE] = {0x01, 0x02, 0x03, 0x04, 
                                               0x05, 0x06, 0x07, 0x08,
                                               0x09, 0x0A, 0x0B, 0x0C,
                                               0x0D, 0x0E, 0x0F, 0x10};

        unsigned char input[AES_BLOCK_SIZE] = {'T', 'e', 's', 't', 
                                              'I', 'n', 'p', 'u', 
                                              't', '1', '2', '3', 
                                              '4', '5', '6', '7'};

        unsigned char encryptedOutput[AES_BLOCK_SIZE];
        unsigned char decryptedOutput[AES_BLOCK_SIZE];

        // Criptare
        aesEncrypt(input, encryptedOutput, key);
        cout << "Mesaj criptat: ";
        for (int i = 0; i < AES_BLOCK_SIZE; i++) {
            printf("%02x ", encryptedOutput[i]);
        }
        cout << endl;

        // Decriptare
        aesDecrypt(encryptedOutput, decryptedOutput, key);
        cout << "Mesaj decriptat: ";
        for (int i = 0; i < AES_BLOCK_SIZE; i++) {
            cout << decryptedOutput[i];
        }
        cout << endl;

        return 0;
    }
    

    from Crypto.Cipher import AES
    from Crypto.Util.Padding import pad, unpad

    def aes_encrypt(key, plaintext):
        # Funcție de criptare folosind AES
        cipher = AES.new(key, AES.MODE_CBC)
        iv = cipher.iv
        ciphertext = cipher.encrypt(pad(plaintext.encode(), AES.block_size))
        return iv + ciphertext

    def aes_decrypt(key, ciphertext):
        # Funcție de decriptare folosind AES
        iv = ciphertext[:AES.block_size]
        cipher = AES.new(key, AES.MODE_CBC, iv)
        decrypted = unpad(cipher.decrypt(ciphertext[AES.block_size:]), AES.block_size)
        return decrypted.decode()

    # Exemplu de utilizare
    key = b'Sixteen byte key'  # Cheie de 16 bytes pentru AES
    plaintext = "Mesaj de test."
    ciphertext = aes_encrypt(key, plaintext)
    print("Mesaj criptat:", ciphertext)

    decrypted_message = aes_decrypt(key, ciphertext)
    print("Mesaj decriptat:", decrypted_message)
    

    #include <iostream>
    #include <utility> // pentru std::pair
    #include <cmath>   // pentru funcții matematice de bază

    using namespace std;

    // Structură pentru a reprezenta punctele pe curba eliptică
    struct Point {
        long long x, y;
    };

    // Parametrii curbei eliptice
    struct CurveParams {
        long long a, b, p; // a și b sunt coeficienții curbei y^2 = x^3 + ax + b, p este câmpul finit
    };

    // Funcție pentru a calcula inversul modular folosind Algoritmul Euclidian Extins
    long long modInverse(long long k, long long p) {
        long long t = 0, newT = 1;
        long long r = p, newR = k;

        while (newR != 0) {
            long long quotient = r / newR;

            // Actualizăm t și newT fără a folosi tie()
            long long tempT = newT;
            newT = t - quotient * newT;
            t = tempT;

            // Actualizăm r și newR fără tie()
            long long tempR = newR;
            newR = r - quotient * newR;
            r = tempR;
        }

        if (r > 1) return -1;  // Invers nu există
        if (t < 0) t += p;     // Ajustăm valoarea t dacă este negativă

        return t;
    }

    // Funcția pentru adunarea a două puncte pe o curbă eliptică
    Point addPoints(Point P, Point Q, CurveParams curve) {
        if (P.x == Q.x && P.y == Q.y) {
            long long s = (3 * P.x * P.x + curve.a) * modInverse(2 * P.y, curve.p) % curve.p;
            long long x_r = (s * s - 2 * P.x) % curve.p;
            long long y_r = (s * (P.x - x_r) - P.y) % curve.p;

            // Ajustăm dacă rezultatul este negativ
            if (x_r < 0) x_r += curve.p;
            if (y_r < 0) y_r += curve.p;

            return {x_r, y_r};
        } else {
            long long s = (Q.y - P.y) * modInverse(Q.x - P.x, curve.p) % curve.p;
            long long x_r = (s * s - P.x - Q.x) % curve.p;
            long long y_r = (s * (P.x - x_r) - P.y) % curve.p;

            // Ajustăm dacă rezultatul este negativ
            if (x_r < 0) x_r += curve.p;
            if (y_r < 0) y_r += curve.p;

            return {x_r, y_r};
        }
    }

    // Funcția pentru înmulțirea unui punct cu un scalar pe o curbă eliptică
    Point scalarMult(Point P, long long k, CurveParams curve) {
        Point result = P;
        k = k - 1; // Deja avem un punct, deci repetăm k-1 ori adunarea
        while (k > 0) {
            result = addPoints(result, P, curve);
            k--;
        }
        return result;
    }

    // Funcția principală
    int main() {
        // Definim o curbă eliptică simplă: y^2 = x^3 + ax + b (mod p)
        CurveParams curve = {2, 3, 97}; // Exemplu: y^2 = x^3 + 2x + 3 (mod 97)

        // Punctul generator G de pe curbă
        Point G = {3, 6}; // Exemplu de punct de pe curbă

        // Cheia privată a destinatarului
        long long privateKey = 7; // Exemplu de cheie privată

        // Cheia publică a destinatarului: PublicKey = privateKey * G
        Point publicKey = scalarMult(G, privateKey, curve);

        // Expeditorul alege o cheie aleatorie k pentru criptare
        long long k = 5; // Cheie aleatorie

        // Calcularea punctului R = k * G
        Point R = scalarMult(G, k, curve);

        // Mesajul de criptat (reprezentat ca punct pe curba eliptică)
        Point M = {10, 22}; // Exemplu de mesaj ca punct de pe curbă

        // Criptarea mesajului: C1 = R, C2 = M + k * publicKey
        Point C1 = R;
        Point C2 = addPoints(M, scalarMult(publicKey, k, curve), curve);

        // Afișăm rezultatele criptării
        cout << "Mesaj criptat:" << endl;
        cout << "C1: (" << C1.x << ", " << C1.y << ")" << endl;
        cout << "C2: (" << C2.x << ", " << C2.y << ")" << endl;

        // Decriptarea mesajului: M = C2 - privateKey * C1
        Point decryptedMessage = addPoints(C2, scalarMult(C1, privateKey, curve), curve);

        cout << "Mesaj decriptat: (" << decryptedMessage.x << ", " << decryptedMessage.y << ")" << endl;

        return 0;
    }

    # Definirea unei clase pentru a reprezenta punctele pe curba eliptică
    class Point:
        def __init__(self, x, y):
            self.x = x
            self.y = y

    # Parametrii curbei eliptice
    class CurveParams:
        def __init__(self, a, b, p):
            self.a = a  # Coeficientul 'a' al curbei
            self.b = b  # Coeficientul 'b' al curbei
            self.p = p  # Modulo p (câmp finit)

    # Funcție pentru a calcula inversul modular folosind Algoritmul Euclidian Extins
    def mod_inverse(k, p):
        t, new_t = 0, 1
        r, new_r = p, k

        while new_r != 0:
            quotient = r // new_r
            t, new_t = new_t, t - quotient * new_t
            r, new_r = new_r, r - quotient * new_r

        if r > 1:
            return -1  # Invers nu există
        if t < 0:
            t += p
        return t

    # Funcție pentru adunarea a două puncte pe o curbă eliptică
    def add_points(P, Q, curve):
        if P.x == Q.x and P.y == Q.y:
            s = (3 * P.x * P.x + curve.a) * mod_inverse(2 * P.y, curve.p) % curve.p
            x_r = (s * s - 2 * P.x) % curve.p
            y_r = (s * (P.x - x_r) - P.y) % curve.p
        else:
            s = (Q.y - P.y) * mod_inverse(Q.x - P.x, curve.p) % curve.p
            x_r = (s * s - P.x - Q.x) % curve.p
            y_r = (s * (P.x - x_r) - P.y) % curve.p

        if x_r < 0:
            x_r += curve.p
        if y_r < 0:
            y_r += curve.p

        return Point(x_r, y_r)

    # Funcție pentru înmulțirea unui punct cu un scalar pe o curbă eliptică
    def scalar_mult(P, k, curve):
        result = P
        k -= 1
        while k > 0:
            result = add_points(result, P, curve)
            k -= 1
        return result

    # Funcția principală
    if __name__ == "__main__":

        # Definim o curbă eliptică simplă: y^2 = x^3 + ax + b (mod p)
        curve = CurveParams(2, 3, 97) # Exemplu: y^2 = x^3 + 2x + 3 (mod 97)

        # Punctul generator G de pe curbă
        G = Point(3, 6)

        # Cheia privată a destinatarului
        private_key = 7 # Exemplu de cheie privată

        # Cheia publică a destinatarului: PublicKey = privateKey * G
        public_key = scalar_mult(G, private_key, curve)

        # Expeditorul alege o cheie aleatorie k pentru criptare
        k = 5

        # Calcularea punctului R = k * G
        R = scalar_mult(G, k, curve)

        # Mesajul de criptat (reprezentat ca punct pe curba eliptică)
        M = Point(10, 22)

        # Criptarea mesajului: C1 = R, C2 = M + k * publicKey
        C1 = R
        C2 = add_points(M, scalar_mult(public_key, k, curve), curve)

        # Afișăm rezultatele criptării
        print("Mesaj criptat:")
        print(f"C1: ({C1.x}, {C1.y})")
        print(f"C2: ({C2.x}, {C2.y})")

        # Decriptarea mesajului: M = C2 - privateKey * C1
        decrypted_message = add_points(C2, scalar_mult(C1, private_key, curve), curve)

        print(f"Mesaj decriptat: ({decrypted_message.x}, {decrypted_message.y})")

    #include <iostream>
    #include <string>
    #include <cryptlib.h>
    #include <twofish.h>
    #include <hex.h>
    #include <secblock.h>
    #include <osrng.h>

    using namespace CryptoPP;
    using namespace std;

    // Funcție pentru criptare Twofish
    string twofishEncrypt(const string& plainText, const SecByteBlock& key) {
        string cipherText;
        AutoSeededRandomPool prng;
        
        // Inițializare cu vector de inițializare
        byte iv[Twofish::BLOCKSIZE];
        prng.GenerateBlock(iv, sizeof(iv));

        CBC_Mode<Twofish>::Encryption encryption;
        encryption.SetKeyWithIV(key, key.size(), iv);

        StringSource ss1(plainText, true, 
            new StreamTransformationFilter(encryption, 
            new StringSink(cipherText), BlockPaddingSchemeDef::PKCS_PADDING));

        // Adăugăm IV-ul la începutul cifrului pentru a-l putea folosi la decriptare
        string cipherWithIV(reinterpret_cast<const char*>(iv), Twofish::BLOCKSIZE);
        cipherWithIV += cipherText;

        return cipherWithIV;
    }

    // Funcție pentru decriptare Twofish
    string twofishDecrypt(const string& cipherWithIV, const SecByteBlock& key) {
        string plainText;
        
        // Extragem IV-ul din începutul cifrului
        byte iv[Twofish::BLOCKSIZE];
        std::memcpy(iv, cipherWithIV.data(), Twofish::BLOCKSIZE);

        // Extragem restul textului criptat
        string cipherText = cipherWithIV.substr(Twofish::BLOCKSIZE);

        CBC_Mode<Twofish>::Decryption decryption;
        decryption.SetKeyWithIV(key, key.size(), iv);

        StringSource ss2(cipherText, true, 
            new StreamTransformationFilter(decryption, 
            new StringSink(plainText), BlockPaddingSchemeDef::PKCS_PADDING));

        return plainText;
    }

    int main() {
        AutoSeededRandomPool prng;

        // Definim cheia (16, 24 sau 32 octeți pentru Twofish)
        SecByteBlock key(Twofish::DEFAULT_KEYLENGTH);
        prng.GenerateBlock(key, key.size());

        // Mesajul pe care dorim să-l criptăm
        string plainText = "Mesajul secret pentru Twofish!";

        // Criptăm mesajul
        string cipherText = twofishEncrypt(plainText, key);
        cout << "Mesaj criptat (Twofish): " << cipherText << endl;

        // Decriptăm mesajul
        string decryptedText = twofishDecrypt(cipherText, key);
        cout << "Mesaj decriptat (Twofish): " << decryptedText << endl;

        return 0;
    }

    from Crypto.Cipher import Twofish
    from Crypto.Util.Padding import pad, unpad

    def twofish_encrypt(key, plaintext):
        # Funcție de criptare folosind TwoFish
        cipher = Twofish.new(key, Twofish.MODE_CBC)
        iv = cipher.iv
        ciphertext = cipher.encrypt(pad(plaintext.encode(), Twofish.block_size))
        return iv + ciphertext

    def twofish_decrypt(key, ciphertext):
        # Funcție de decriptare folosind TwoFish
        iv = ciphertext[:Twofish.block_size]
        cipher = Twofish.new(key, Twofish.MODE_CBC, iv)
        decrypted = unpad(cipher.decrypt(ciphertext[Twofish.block_size:]), Twofish.block_size)
        return decrypted.decode()

    # Exemplu de utilizare
    key = b'Sixteen byte key'  # Cheie de criptare
    plaintext = "Mesaj de test."
    ciphertext = twofish_encrypt(key, plaintext)
    print("Mesaj criptat:", ciphertext)

    decrypted_message = twofish_decrypt(key, ciphertext)
    print("Mesaj decriptat:", decrypted_message)
    

    #include <iostream>
    #include <string>
    #include <openssl/des.h>

    using namespace std;

    // Funcție pentru criptare DES
    void desEncrypt(const unsigned char* input, unsigned char* output, const_DES_cblock key) {
        DES_key_schedule schedule;
        DES_set_key_checked(&key, &schedule); // Setăm cheia DES
        DES_ecb_encrypt((const_DES_cblock*)input, (DES_cblock*)output, &schedule, DES_ENCRYPT); // Criptare DES
    }

    // Funcție pentru decriptare DES
    void desDecrypt(const unsigned char* input, unsigned char* output, const_DES_cblock key) {
        DES_key_schedule schedule;
        DES_set_key_checked(&key, &schedule); // Setăm cheia DES pentru decriptare
        DES_ecb_encrypt((const_DES_cblock*)input, (DES_cblock*)output, &schedule, DES_DECRYPT); // Decriptare DES
    }

    int main() {
        // Cheia trebuie să fie de exact 8 octeți pentru DES
        DES_cblock key = {0x01, 0x02, 0x03, 0x04, 
                                  0x05, 0x06, 0x07, 0x08};

        unsigned char input[8] = {'M', 'e', 's', 'a',
                                          'j', 'T', 'e', 's'};

        unsigned char encryptedOutput[8];
        unsigned char decryptedOutput[8];

        // Criptare
        desEncrypt(input, encryptedOutput, key);
        cout << "Mesaj criptat (DES): ";
        for (int i = 0; i < 8; i++) {
            printf("%02x ", encryptedOutput[i]);
        }
        cout << endl;

        // Decriptare
        desDecrypt(encryptedOutput, decryptedOutput, key);
        cout << "Mesaj decriptat (DES): ";
        for (int i = 0; i < 8; i++) {
            cout << decryptedOutput[i];
        }
        cout << endl;

        return 0;
    }

    from Crypto.Cipher import DES
    from Crypto.Util.Padding import pad, unpad

    def des_encrypt(key, plaintext):
        # Funcție de criptare folosind DES
        cipher = DES.new(key, DES.MODE_CBC)
        iv = cipher.iv
        ciphertext = cipher.encrypt(pad(plaintext.encode(), DES.block_size))
        return iv + ciphertext

    def des_decrypt(key, ciphertext):
        # Funcție de decriptare folosind DES
        iv = ciphertext[:DES.block_size]
        cipher = DES.new(key, DES.MODE_CBC, iv)
        decrypted = unpad(cipher.decrypt(ciphertext[DES.block_size:]), DES.block_size)
        return decrypted.decode()

    # Exemplu de utilizare
    key = b'8bytekey'  # Cheie de 8 bytes pentru DES
    plaintext = "Mesaj de test."
    ciphertext = des_encrypt(key, plaintext)
    print("Mesaj criptat:", ciphertext)

    decrypted_message = des_decrypt(key, ciphertext)
    print("Mesaj decriptat:", decrypted_message)

    #include <iostream>
    #include <dh.h>
    #include <osrng.h>
    #include <nbtheory.h>
    #include <hex.h>
    #include <secblock.h>

    using namespace CryptoPP;
    using namespace std;

    // Funcție pentru generarea perechii de chei (privată și publică) folosind Diffie-Hellman
    void generateKeys(DH& dh, SecByteBlock& privateKey, SecByteBlock& publicKey) {
        AutoSeededRandomPool prng;

        // Generăm cheia privată și cea publică
        privateKey = SecByteBlock(dh.PrivateKeyLength());
        publicKey = SecByteBlock(dh.PublicKeyLength());
        dh.GenerateKeyPair(prng, privateKey, publicKey);
    }

    // Funcție pentru calcularea cheii comune
    SecByteBlock computeSharedKey(DH& dh, const SecByteBlock& privateKey, const SecByteBlock& otherPublicKey) {
        AutoSeededRandomPool prng;
        SecByteBlock sharedKey(dh.AgreedValueLength());

        if (!dh.Agree(sharedKey, privateKey, otherPublicKey)) {
            cerr << "Eșec în calcularea cheii comune!" << endl;
            exit(1);
        }
        return sharedKey;
    }

    // Funcție pentru a converti o cheie în hexazecimal pentru a o putea vizualiza
    string keyToHex(const SecByteBlock& key) {
        string hexKey;
        HexEncoder encoder(new StringSink(hexKey));
        encoder.Put(key, key.size());
        encoder.MessageEnd();
        return hexKey;
    }

    int main() {
        // Setări pentru parametrul DH
        AutoSeededRandomPool prng;
        Integer p("0xFFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1"
                  "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
                  "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
                  "E485B576625E7EC6F44C42E9A63A36210000000000090563");
        Integer g("2");

        // Inițializăm obiectul Diffie-Hellman cu parametrul p și baza g
        DH dh(p, g);

        // Generăm chei pentru Alice
        SecByteBlock alicePrivateKey, alicePublicKey;
        generateKeys(dh, alicePrivateKey, alicePublicKey);
        
        // Generăm chei pentru Bob
        SecByteBlock bobPrivateKey, bobPublicKey;
        generateKeys(dh, bobPrivateKey, bobPublicKey);

        // Calculăm cheia comună pentru Alice
        SecByteBlock aliceSharedKey = computeSharedKey(dh, alicePrivateKey, bobPublicKey);
        
        // Calculăm cheia comună pentru Bob
        SecByteBlock bobSharedKey = computeSharedKey(dh, bobPrivateKey, alicePublicKey);

        // Conversia cheilor în hexazecimal pentru afișare
        cout << "Cheia privată Alice (hex): " << keyToHex(alicePrivateKey) << endl;
        cout << "Cheia publică Alice (hex): " << keyToHex(alicePublicKey) << endl;
        cout << "Cheia comună Alice (hex): " << keyToHex(aliceSharedKey) << endl;
        
        cout << "Cheia privată Bob (hex): " << keyToHex(bobPrivateKey) << endl;
        cout << "Cheia publică Bob (hex): " << keyToHex(bobPublicKey) << endl;
        cout << "Cheia comună Bob (hex): " << keyToHex(bobSharedKey) << endl;

        return 0;
    }

    from cryptography.hazmat.primitives.asymmetric import dh
    from cryptography.hazmat.primitives import serialization
    from cryptography.hazmat.backends import default_backend
    import binascii

    # Funcție pentru generarea cheilor (privată și publică) folosind parametrii DH
    def generate_keys(parameters):
        # Generăm cheia privată pentru utilizare în schimb
        private_key = parameters.generate_private_key()
        public_key = private_key.public_key()
        return private_key, public_key

    # Funcție pentru calcularea cheii comune
    def compute_shared_key(private_key, other_public_key):
        # Generăm cheia comună
        shared_key = private_key.exchange(other_public_key)
        return shared_key

    # Funcție pentru a converti o cheie în hexazecimal pentru a o putea vizualiza
    def key_to_hex(key):
        return binascii.hexlify(key).decode()

    # Funcția principală
    def main():
        # Definirea parametrilor pentru DH
        parameters = dh.generate_parameters(generator=2, key_size=2048, backend=default_backend())

        # Generăm chei pentru Alice
        alice_private_key, alice_public_key = generate_keys(parameters)

        # Generăm chei pentru Bob
        bob_private_key, bob_public_key = generate_keys(parameters)

        # Calculăm cheile comune
        alice_shared_key = compute_shared_key(alice_private_key, bob_public_key)
        bob_shared_key = compute_shared_key(bob_private_key, alice_public_key)

        # Conversia cheilor în hexazecimal pentru afișare
        print("Cheia privată Alice (hex): ", key_to_hex(alice_private_key.private_bytes(
            encoding=serialization.Encoding.DER,
            format=serialization.PrivateFormat.TraditionalOpenSSL)))
        
        print("Cheia publică Alice (hex): ", key_to_hex(alice_public_key.public_bytes(
            encoding=serialization.Encoding.DER,
            format=serialization.PublicFormat.SubjectPublicKeyInfo)))
        
        print("Cheia comună Alice (hex): ", key_to_hex(alice_shared_key))

        print("Cheia privată Bob (hex): ", key_to_hex(bob_private_key.private_bytes(
            encoding=serialization.Encoding.DER,
            format=serialization.PrivateFormat.TraditionalOpenSSL)))
        
        print("Cheia publică Bob (hex): ", key_to_hex(bob_public_key.public_bytes(
            encoding=serialization.Encoding.DER,
            format=serialization.PublicFormat.SubjectPublicKeyInfo)))
        
        print("Cheia comună Bob (hex): ", key_to_hex(bob_shared_key))

    if __name__ == "__main__":
        main()