GGH-crypto 1.0.4__tar.gz

GGH_crypto-1.0.4/GGH_crypto/GGH/GGH.py

@@ -0,0 +1,294 @@
+import random
+import sympy as sp
+import math
+from flint import fmpz_mat, fmpz, fmpq, fmpq_mat
+from fractions import Fraction
+import time
+import logging
+
+logging.basicConfig(level=logging.INFO, format='%(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+
+from ..Utils.Utils import Utils
+
+class GGHCryptosystem:
+    """
+    Implementation of the GGH (Goldreich-Goldwasser-Halevi) cryptographic system.
+
+    This class provides methods for generating keys, encrypting, and decrypting messages
+    using the GGH lattice-based cryptographic system.
+
+    Attributes:
+        dimension (int): The dimension of the lattice.
+        integer_sigma (bool): If True, uses an integer value for sigma.
+        sigma (int or float): The sigma parameter for error generation.
+        message (fmpq_mat): The message to be encrypted.
+        ciphertext (fmpq_mat): The encrypted text.
+        error (fmpz_mat or fmpq_mat): The error vector.
+        private_basis (fmpz_mat): The private basis of the lattice.
+        public_basis (fmpz_mat): The public basis of the lattice.
+        unimodular (fmpz_mat): The unimodular matrix for public key generation.
+        debug (bool): If True, prints debug information.
+        private_key (fmpz_mat): The private key.
+        public_key (tuple): The public key (public basis, sigma).
+
+    Args:
+        dimension (int): The dimension of the lattice.
+        private_basis (fmpz_mat, optional): A predefined private basis.
+        public_basis (fmpz_mat, optional): A predefined public basis.
+        unimodular (fmpz_mat, optional): A predefined unimodular matrix.
+        message (fmpq_mat, optional): A predefined message.
+        error (fmpz_mat or fmpq_mat, optional): A predefined error vector.
+        sigma (int or float, optional): A predefined value for sigma.
+        integer_sigma (bool, optional): Whether to use an integer value for sigma. Default is True.
+        debug (bool, optional): Whether to enable debug prints. Default is False.
+
+    Raises:
+        ValueError: If the dimensions of the provided bases or vectors do not match.
+    """
+    def __init__(self, dimension, private_basis=None, public_basis=None, unimodular=None, message=None, 
+                 error=None, sigma = None, integer_sigma=True, debug=False):
+        self.dimension = dimension
+        self.integer_sigma = integer_sigma
+        self.sigma = sigma
+        
+        self.message = message
+        self.ciphertext = None
+        self.error = error
+
+        self.private_basis = private_basis
+        self.public_basis = public_basis
+        self.unimodular = unimodular
+        self.debug = debug
+
+        self.private_key = None
+        self.public_key = None
+
+        # Check dimensions of bases if provided
+        if private_basis is not None:
+            if private_basis.nrows() != dimension or private_basis.ncols() != dimension:
+                raise ValueError(f"[GGH] Private basis must be a {dimension}x{dimension} matrix, but got {private_basis.nrows()}x{private_basis.ncols()}")
+        
+        if public_basis is not None:
+            if public_basis.nrows() != dimension or public_basis.ncols() != dimension:
+                raise ValueError(f"[GGH] Public basis must be a {dimension}x{dimension} matrix, but got {public_basis.nrows()}x{public_basis.ncols()}")
+        
+        if unimodular is not None:
+            if unimodular.nrows() != dimension or unimodular.ncols() != dimension:
+                raise ValueError(f"[GGH] Unimodular matrix must be a {dimension}x{dimension} matrix, but got {unimodular.nrows()}x{unimodular.ncols()}")
+
+        # Check dimensions of vectors if provided
+        if message is not None:
+            if message.ncols() != dimension:
+                raise ValueError(f"[GGH] Message vector must have length {dimension}, but got length {message.ncols()}")
+        
+        if error is not None:
+            if error.ncols() != dimension:
+                raise ValueError(f"[GGH] Error vector must have length {dimension}, but got length {error.ncols()}")
+
+
+        if private_basis is not None:
+            self.generate_keys_from_R_or_B()
+        else:
+            self.generate_keys()
+
+    def random_unimodular(self, dim, mix):
+        """
+        Generates a random unimodular matrix.
+
+        Args:
+            dim (int): The dimension of the matrix.
+            mix (int): The number of mixing operations to perform.
+
+        Returns:
+            fmpz_mat: A random unimodular matrix.
+        """
+        T = sp.eye(dim)
+        x = sp.zeros(1, dim)
+        choices = [-1, 0, 1]
+        weights = [1, 5, 1]
+        
+        for _ in range(mix):
+            rows = list(range(dim))
+            random.shuffle(rows)
+            for i in rows:
+                x[0, i] = 1
+                for k in range(dim):
+                    if k != i:
+                        x[0, k] = random.choices(choices, weights=weights)[0]
+                
+                # Perform matrix multiplication more efficiently
+                new_row = x * T
+                for j in range(dim):
+                    T[i, j] = new_row[0, j]
+                
+                # Reset x for the next iteration
+                x[0, i] = 0
+
+        return Utils.npsp_to_fmpz_mat(T)
+
+    def generate_sigma(self, R):
+        """
+        Generates the sigma value based on the L1 norm of the inverse of R.
+
+        Args:
+            R (fmpz_mat): The R matrix to calculate the inverse from.
+
+        Returns:
+            int or float: The calculated sigma value.
+        """
+        rho = Utils.vector_l1_norm(R.inv())
+
+        sigma_max = 1 / (2 * rho)
+
+        if self.integer_sigma:
+            return int(math.floor(sigma_max)) if math.floor(sigma_max) < 3 else 3 #standard sigma is 3
+        else:
+            return sigma_max
+
+
+    def generate_error(self):
+        """
+        Generates a random error vector based on sigma.
+        """
+        sigma = self.public_key[1]
+
+        random_elements = [random.choice([-sigma, sigma]) for _ in range(self.dimension)]
+        
+        if isinstance(sigma, int):
+            self.error = fmpz_mat([random_elements])
+        else:
+            random_elements = [fmpq(Fraction(item).numerator, Fraction(item).denominator) for item in random_elements]
+            self.error = fmpq_mat([random_elements])
+
+    def generate_random_message(self):
+        """
+        Generates a random message.
+        """
+        random_elements = [random.randint(-128, 127) for _ in range(self.dimension)]
+        self.message = fmpq_mat([random_elements])
+
+    def generate_keys_from_R_or_B(self):
+        """
+        Generates keys from a provided private or public basis.
+        """
+        if self.debug:
+            logger.info("[GGH] Private basis given as input, inverting it..")
+
+        R_inv = self.private_basis.inv()
+
+        if not self.sigma:
+            self.sigma = self.generate_sigma(R_inv)
+
+        if self.public_basis is None:
+            if self.debug:
+                logger.info("[GGH] Generating public key...")
+
+            if not self.unimodular:
+                self.unimodular = self.random_unimodular(self.dimension, 2)
+            self.public_basis = self.unimodular * self.private_basis
+        else:
+            if self.debug:
+                logger.info("[GGH] Using the provided public basis as the public key")
+        
+        self.public_key = (self.public_basis, self.sigma)
+        self.private_key = self.private_basis
+
+    def generate_keys(self):
+        """
+        Generates the private and public keys of the cryptographic system.
+        """
+        tries = 0
+        l = 4
+        k = fmpz(l * math.ceil(math.sqrt(self.dimension) + 1))
+        if self.debug:
+            logger.info("[GGH] Generating private basis...")
+            time_start = time.time()
+        while True:
+            R = fmpz_mat([[random.randint(-l, l-1) for _ in range(self.dimension)] for _ in range(self.dimension)])
+            I = Utils.npsp_to_fmpz_mat(sp.eye(self.dimension))
+            KI = k * I
+            R += KI
+            
+            tries += 1
+
+            if R.det() != 0:
+                break
+
+        if self.debug:
+            priv_time = time.time() - time_start
+            logger.info(f"[GGH] Time taken: {priv_time} with {tries} tries")
+
+        self.private_basis = R
+
+        if not self.sigma:
+            if self.debug:
+                logger.info("[GGH] Generating sigma...")
+                time_start = time.time()
+            self.sigma = self.generate_sigma(R)
+            if self.debug:
+                sigma_time = time.time() - time_start
+                logger.info(f"Generated sigma is {self.sigma}, time taken: {sigma_time}")
+
+        if not self.unimodular:
+            if self.debug:
+                logger.info(f"Generating unimodular matrix...")
+                time_start = time.time()
+            self.unimodular = self.random_unimodular(self.dimension, 2)
+            if self.debug:
+                unim_time = time.time() - time_start
+                logger.info(f"[GGH] Time taken: {unim_time}")
+
+
+        if self.debug:
+            logger.info(f"[GGH] Generating public basis...")
+            time_start = time.time()
+        self.public_basis = self.unimodular * self.private_basis
+        if self.debug:
+            pub_time = time.time() - time_start
+            logger.info(f"[GGH] Time taken: {pub_time}")
+
+        self.public_key = (self.public_basis, self.sigma)
+        self.private_key = R
+
+    def encrypt(self):
+        """
+        Encrypts the message using the public key and an error vector.
+        """
+        if self.debug:
+            logger.info(f"[GGH] Encrypting...")
+            time_start = time.time()
+        if self.error is None:
+            self.generate_error()
+
+        if self.message is None:
+            self.generate_random_message()
+
+        B = self.public_key[0]
+
+        self.ciphertext = self.message * B + self.error
+        if self.debug:
+            enc_time = time.time() - time_start
+            logger.info(f"[GGH] Time taken: {enc_time}")
+
+    def decrypt(self):
+        """
+        Decrypts the ciphertext using the private key.
+
+        Returns:
+            fmpq_mat: The decrypted message.
+        """
+        if self.debug:
+            logger.info(f"[GGH] Decrypting...")
+            time_start = time.time()
+        
+        CVP = Utils.babai_rounding(self.private_basis, self.ciphertext)
+        
+        result = CVP * self.public_basis.inv()
+
+        if self.debug:
+            dec_time = time.time() - time_start
+            logger.info(f"[GGH] Time taken: {dec_time}")
+
+        return result

GGH_crypto-1.0.4/GGH_crypto/GGH/__init__.py

@@ -0,0 +1,3 @@
+from .GGH import GGHCryptosystem
+
+__all__ = ['GGHCryptosystem']

GGH_crypto-1.0.4/GGH_crypto/GGH_HNF/GGH_HNF.py

@@ -0,0 +1,291 @@
+import sympy as sp
+import random
+import math
+from flint import fmpz_mat, fmpq_mat, fmpq, fmpz
+from decimal import Decimal
+import time
+import numpy as np
+import logging
+
+logging.basicConfig(level=logging.INFO, format='%(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+from ..Utils.Utils import Utils
+
+class GGHHNFCryptosystem:
+    """
+    Implementation of the GGH (Goldreich-Goldwasser-Halevi) cryptographic system with Hermite Normal Form (HNF) modifications.
+
+    This class provides methods for generating keys, encrypting, and decrypting messages
+    using the GGH lattice-based cryptographic system with HNF optimizations.
+
+    Attributes:
+        dimension (int): The dimension of the lattice.
+        lattice_point (fmpz_mat): The lattice point to be encrypted.
+        ciphertext (fmpq_mat): The encrypted text.
+        error (fmpz_mat): The error vector.
+        alpha (float): The alpha parameter for error generation.
+        private_basis (fmpz_mat): The private basis of the lattice.
+        public_basis (fmpz_mat): The public basis of the lattice.
+        R_rho (Decimal): The rho parameter of the private basis.
+        GGH_private (bool): If True, uses GGH's matrix transformation technique for private basis generation.
+        debug (bool): If True, prints debug information.
+        private_key (tuple): The private key (R_inv, R).
+        public_key (tuple): The public key (H, R_rho).
+
+    Args:
+        dimension (int): The dimension of the lattice.
+        private_basis (fmpz_mat, optional): A predefined private basis.
+        public_basis (fmpz_mat, optional): A predefined public basis.
+        lattice_point (fmpz_mat, optional): A predefined lattice point.
+        error (fmpz_mat, optional): A predefined error vector.
+        alpha (float, optional): The alpha parameter for error generation. Default is 0.75.
+        GGH_private (bool, optional): Whether to use GGH's matrix transformation technique. Default is False.
+        debug (bool, optional): Whether to enable debug prints. Default is False.
+
+    Raises:
+        ValueError: If the dimensions of the provided bases or vectors do not match.
+    """
+    def __init__(self, dimension, private_basis=None, public_basis=None, lattice_point=None, error=None, alpha=0.75, GGH_private=False, debug=False):
+        self.dimension = dimension
+        
+        self.lattice_point = lattice_point
+        self.ciphertext = None
+        self.error = error
+        self.alpha = alpha
+
+        self.private_basis = private_basis
+        self.public_basis = public_basis
+        
+        self.R_rho = None
+        self.GGH_private = GGH_private
+        self.debug = debug
+
+        self.private_key = None
+        self.public_key = None
+
+        if private_basis is not None:
+            if private_basis.nrows() != dimension or private_basis.ncols() != dimension:
+                raise ValueError(f"[GGH-HNF] Private basis must be a {dimension}x{dimension} matrix, but got {private_basis.nrows()}x{private_basis.ncols()}")
+        
+        if public_basis is not None:
+            if public_basis.nrows() != dimension or public_basis.ncols() != dimension:
+                raise ValueError(f"[GGH-HNF] Public basis must be a {dimension}x{dimension} matrix, but got {public_basis.nrows()}x{public_basis.ncols()}")
+
+        if lattice_point is not None:
+            if lattice_point.ncols() != dimension:
+                raise ValueError(f"[GGH-HNF] Lattice point vector must have length {dimension}, but got length {lattice_point.ncols()}")
+        
+        if error is not None:
+            if error.ncols() != dimension:
+                raise ValueError(f"[GGH-HNF] Error vector must have length {dimension}, but got length {error.ncols()}")
+
+        if self.private_basis is not None:
+            self.generate_keys_from_R_or_B()
+        else:
+            self.generate_keys()
+            
+        if self.error is None:
+            self.generate_random_error()
+        else:
+            if self.debug:
+                logger.info(f"[GGH-HNF] Length of error vector is: {Utils.vector_l2_norm(self.error)}")
+
+    def generate_keys_from_R_or_B(self):
+        """
+        Generates keys from a provided private or public basis.
+        """
+        if self.debug:
+            logger.info("[GGH-HNF] Private basis given as input, inverting it..")
+    
+        R = self.private_basis
+        R_inv = R.inv()
+
+        if self.debug:
+            logger.info("[GGH-HNF] Calculating rho...")
+            self.R_rho = self.calculate_rho(self.private_basis)
+            
+
+        if self.public_basis is None:
+            if self.debug:
+                logger.info("[GGH-HNF] Generating public basis using HNF of the good basis...")
+            H = R.hnf()
+            self.public_basis = H
+        else:
+            if self.debug:
+                logger.info("[GGH-HNF] Using the provided public basis as the public key")
+            H = self.public_basis
+        
+        self.public_key = (H, self.R_rho)
+        self.private_key = (R_inv, R)
+
+    def min_norm_row(self, matrix):
+        """
+        Finds the minimum norm row in the given matrix.
+
+        Args:
+            matrix (fmpz_mat or fmpq_mat): The input matrix.
+
+        Returns:
+            float: The minimum norm among all rows.
+        """
+        norms = []
+        for j in range(matrix.nrows()):
+            row = [matrix[j, i] for i in range(matrix.ncols())]
+            norms.append(Utils.vector_l2_norm(row))
+        min_norm = min(norms)
+        return norms[norms.index(min_norm)]
+
+    def calculate_rho(self, basis):
+        """
+        Calculates the rho parameter for the given basis.
+
+        Args:
+            basis (fmpz_mat): The input basis.
+
+        Returns:
+            Decimal: The calculated rho value.
+        """
+        basis_orthogonalized = Utils.gram_schmidt(np.array(basis.tolist()).astype(int))
+        basis_orthogonalized = Utils.npsp_to_fmpq_mat(basis_orthogonalized)
+        min_norm = self.min_norm_row(basis_orthogonalized)
+        rho = Decimal(0.5) * min_norm
+
+        if self.debug:
+            logger.info(f'[GGH-HNF] Rho is: {rho:f}')
+        return rho
+    
+    def generate_random_error(self):
+        """
+        Generates a random error vector based on the alpha and R_rho parameters.
+        """
+        n = self.dimension
+        max_norm = Decimal(self.alpha) * self.R_rho
+
+        while True:
+            error = fmpz_mat([[random.randint(-n, n) for _ in range(self.dimension)]])
+      
+            error_norm = Utils.vector_l2_norm(error)
+            
+            if error_norm < max_norm:
+                break
+            n -= 1
+        
+        self.error = error
+
+        if self.debug:
+            logger.info(f"[GGH-HNF] Length of error vector is: {error_norm}")
+    
+    def reduce_mod_B(self):
+        """
+        Generates the private and public keys of the cryptographic system.
+        """
+        r = fmpq_mat(self.error)
+        H = self.public_basis
+        x = fmpz_mat(r.nrows(), r.ncols())
+   
+        # Iterate over each coordinate starting from the last one
+        for i in reversed(range(r.ncols())):
+            sum_j = sum(H[j, i] * x[0, j] for j in range(i + 1, self.dimension))
+            # Compute x[i] using the formula
+            x[0, i] = math.floor((r[0, i] - sum_j) / H[i, i])
+
+        return x
+
+    def generate_keys(self):
+        """
+        Encrypts the lattice point using the public key and an error vector.
+        """
+        n = self.dimension
+        tries = 0
+        if self.GGH_private:
+            if self.debug:
+                logger.info("[GGH-HNF] Generating private basis using GGH's matrix transformations technique...")
+                time_start = time.time()
+            l = n
+            k = fmpz(l * math.ceil(math.sqrt(self.dimension) + 1))
+            
+            while True:
+                R = fmpz_mat([[random.randint(-l, l-1) for _ in range(self.dimension)] for _ in range(self.dimension)])
+                I = Utils.npsp_to_fmpz_mat(sp.eye(self.dimension))
+                KI = k * I
+                R += KI
+                
+                tries += 1
+
+                if R.det() != 0:
+                    break
+        else:
+            if self.debug:
+                logger.info("[GGH-HNF] Generating private basis using Micciancio's random matrices tecnique...")
+                time_start = time.time()
+            while True:
+                R = fmpz_mat([[random.randint(-n, n - 1) for _ in range(n)] for _ in range(n)])
+                R = R.lll()
+                
+                tries += 1
+
+                if R.det() != 0:
+                    break
+               
+        
+        if self.debug:
+            priv_time = time.time() - time_start
+            logger.info(f"[GGH-HNF] Time taken: {priv_time} with {tries} tries")
+        self.private_basis = R
+
+        if self.debug:
+            time_start = time.time()
+            logger.info("[GGH-HNF] Calculating rho...")
+        self.R_rho = self.calculate_rho(self.private_basis)
+        if self.debug:
+            rho_time = time.time() - time_start
+            logger.info(f"[GGH-HNF] Time taken: {rho_time}")
+
+        if self.debug:
+            logger.info("[GGH-HNF] Generating public basis...")
+            time_start = time.time()
+        self.public_basis = H = R.hnf()
+        if self.debug:
+            pub_time = time.time() - time_start
+            logger.info(f"[GGH-HNF] Time taken: {pub_time}")
+
+        self.public_key = (H, self.R_rho)
+        self.private_key = R
+
+    def encrypt(self):
+        if self.debug:
+            logger.info(f"[GGH-HNF] Encrypting...")
+            time_start = time.time()
+        if self.lattice_point is None:
+            x = self.reduce_mod_B()
+        
+        H = self.public_basis
+        r = self.error
+
+        self.ciphertext = r - x * H
+        if self.debug:
+            enc_time = time.time() - time_start
+            logger.info(f"[GGH-HNF] Time taken: {enc_time}")
+
+    def decrypt(self):
+        """
+        Decrypts the ciphertext using the private key.
+
+        Returns:
+            fmpq_mat: The decrypted lattice point.
+        """
+        if self.debug:
+            logger.info(f"[GGH-HNF] Decrypting...")
+            time_start = time.time()
+        
+        CVP = Utils.babai_rounding(self.private_basis, self.ciphertext)
+
+        if self.debug:
+            dec_time = time.time() - time_start
+            logger.info(f"[GGH-HNF] Time taken: {dec_time}")
+
+
+        return fmpq_mat(self.ciphertext) - CVP
+    
+    

GGH_crypto-1.0.4/GGH_crypto/GGH_HNF/__init__.py

@@ -0,0 +1,3 @@
+from .GGH_HNF import GGHHNFCryptosystem
+
+__all__ = ['GGHHNFCryptosystem']

GGH_crypto-1.0.4/GGH_crypto/Utils/Utils.py

@@ -0,0 +1,513 @@
+from flint import fmpz_mat, fmpq_mat, fmpq, fmpz
+import matplotlib.pyplot as plt
+import numpy as np
+from decimal import Decimal, getcontext
+import os
+import subprocess
+import ast
+from fractions import Fraction
+import re
+import time
+import numpy as np
+import logging
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+class Utils:
+    """
+    A utility class providing various helper methods for lattice-based cryptography operations.
+
+    This class includes methods for linear algebra operations, lattice visualizations,
+    mathematical computations, and file I/O operations specific to lattice-based cryptography.
+
+    Class Methods:
+        gram_schmidt(basis): Performs Gram-Schmidt orthogonalization on a given basis.
+        visualize_lattice(basis_1, basis_1_cvp, point, basis_2=None, basis_2_cvp=None, title="Lattice Plot", limit=5):
+            Visualizes a 2D lattice with given bases and points.
+        embedding(basis, ciphertext, visualize=False, GGH=False, BKZ=False, block=20, pruned=False, precision=100, bkzautoabort=True, bkzmaxloops=None, nolll=False):
+            Performs lattice embedding for closest vector problem (CVP) solving.
+        npsp_to_fmpq_mat(basis): Converts a numpy array or sympy matrix to an fmpq_mat.
+        npsp_to_fmpz_mat(basis): Converts a numpy array or sympy matrix to an fmpz_mat.
+        vector_l1_norm(row): Calculates the L1 norm of a vector.
+        vector_l2_norm(row): Calculates the L2 norm of a vector.
+        get_hadamard_ratio(basis=None, precision=10): Calculates the Hadamard ratio of a basis.
+        write_matrix_to_file(matrix, filename): Writes a matrix to a file.
+        load_matrix_from_file(filename, matrix_type='fmpq'): Loads a matrix from a file.
+        BKZ_reduction(matrix, block=20, pruned=False, precision=90, bkzautoabort=True, bkzmaxloops=None, nolll=False):
+            Performs BKZ (Block Korkine-Zolotarev) lattice reduction.
+        babai_rounding(basis, point, visualize=False): Performs Babai's rounding algorithm for CVP.
+
+    Note:
+        This class assumes the availability of certain libraries like flint, matplotlib, and numpy.
+        It also interacts with system commands, particularly for BKZ reduction using fplll.
+    """
+    def gram_schmidt(basis):
+        """
+        Performs Gram-Schmidt orthogonalization on a given basis.
+
+        Args:
+            basis (numpy.ndarray): The input basis.
+
+        Returns:
+            numpy.ndarray: The orthogonalized basis.
+        """
+        ortho_basis = basis[0:1,:].copy()
+        for i in range(1, basis.shape[0]):
+            proj = np.diag((basis[i,:].dot(ortho_basis.T)/np.linalg.norm(ortho_basis,axis=1)**2).flat).dot(ortho_basis)
+            ortho_basis = np.vstack((ortho_basis, basis[i,:] - proj.sum(0)))
+        return ortho_basis
+    
+    def visualize_lattice(basis_1, basis_1_cvp, point, basis_2=None, basis_2_cvp=None, title="Lattice Plot", limit=5):
+        """
+        Visualizes a 2D lattice with given bases and points.
+
+        Args:
+            basis_1 (fmpz_mat): The first basis.
+            basis_1_cvp (fmpz_mat): The closest vector point for basis_1.
+            point (fmpz_mat): The target point.
+            basis_2 (fmpz_mat, optional): The second basis.
+            basis_2_cvp (fmpz_mat, optional): The closest vector point for basis_2.
+            title (str, optional): The title of the plot.
+            limit (int, optional): The limit for the lattice points to plot.
+        """
+        basis_1_np = np.array(basis_1.tolist()).astype(int)
+
+        plt.rcParams.update({'font.size': 14})
+
+        # Check if basis_2 is provided
+        if basis_2 is not None:
+            basis_2_np = np.array(basis_2.tolist()).astype(int)
+
+        point_np = np.array(point.tolist()).astype(int)
+
+        # Create a meshgrid of integer coordinates
+        x = np.arange(-limit, limit + 1)
+        y = np.arange(-limit, limit + 1)
+        coords = np.array(np.meshgrid(x, y)).T.reshape(-1, 2)
+
+        # Multiply the meshgrid by the basis matrix to get lattice points
+        lattice_points = np.dot(coords, basis_1_np)
+        
+        fig, ax = plt.subplots(figsize=(10, 10))
+        
+        ax.plot(lattice_points[:, 0], lattice_points[:, 1], 'o', color='black')
+        ax.grid(True, linestyle='--', alpha=0.7)
+        ax.set_xlabel('X-axis')
+        ax.set_ylabel('Y-axis')
+        ax.set_title(title)
+        
+        # Add Cartesian axes
+        ax.axhline(y=0, color='k', linewidth=0.5)
+        ax.axvline(x=0, color='k', linewidth=0.5)
+        
+        label_w = "w"
+        label_w_2 = "w_2"
+        label_t = "t"
+        
+        ax.scatter(point_np[0][0], point_np[0][1])
+        
+        if basis_2_cvp is not None:
+            ax.scatter(int(basis_2_cvp[0, 0]), int(basis_2_cvp[0, 1]), color='red', s=70)
+            
+        if basis_1_cvp is not None:
+            ax.scatter(int(basis_1_cvp[0, 0]), int(basis_1_cvp[0, 1]), color='blueviolet', s=70)
+            
+        ax.annotate(label_t, 
+                    (point_np[0][0], point_np[0][1]), 
+                    textcoords="offset points", 
+                    xytext=(10, -5), 
+                    ha='center')
+                    
+        if basis_1_cvp is not None:
+            ax.annotate(label_w, 
+                        (int(basis_1_cvp[0, 0]), int(basis_1_cvp[0, 1])), 
+                        textcoords="offset points",
+                        xytext=(0, 10), 
+                        ha='center')
+                        
+        if basis_2_cvp is not None:
+            ax.annotate(label_w_2, 
+                        (int(basis_2_cvp[0, 0]), int(basis_2_cvp[0, 1])), 
+                        textcoords="offset points", 
+                        xytext=(0, -12), 
+                        ha='center') 
+            
+        ax.arrow(0, 0, basis_1_np[0][0], basis_1_np[0][1], lw=2, head_width=0.1, head_length=0.1, fc='blueviolet', ec='blueviolet')
+        ax.arrow(0, 0, basis_1_np[1][0], basis_1_np[1][1], lw=2, head_width=0.1, head_length=0.1, fc='blueviolet', ec='blueviolet')
+        
+        if basis_2 is not None:
+            ax.arrow(0, 0, basis_2_np[0][0], basis_2_np[0][1], lw=2, head_width=0.1, head_length=0.1, fc='red', ec='red')
+            ax.arrow(0, 0, basis_2_np[1][0], basis_2_np[1][1], lw=2, head_width=0.1, head_length=0.1, fc='red', ec='red')  
+
+        # Set equal aspect ratio
+        ax.set_aspect('equal', adjustable='box')
+
+        # Calculate the limits based on lattice points and basis vectors
+        all_points = [lattice_points]
+        
+        # Ensure all arrays are 2D before appending
+        all_points.append(basis_1_np.reshape(-1, 2))
+        all_points.append(point_np.reshape(-1, 2))
+        
+        if basis_2 is not None:
+            all_points.append(basis_2_np.reshape(-1, 2))
+        if basis_1_cvp is not None:
+            all_points.append(np.array(basis_1_cvp.tolist()).astype(int).reshape(-1, 2))
+        if basis_2_cvp is not None:
+            all_points.append(np.array(basis_2_cvp.tolist()).astype(int).reshape(-1, 2))
+
+        all_points = np.vstack(all_points)
+
+        x_min, y_min = np.min(all_points, axis=0)
+        x_max, y_max = np.max(all_points, axis=0)
+
+        # Add some padding
+        padding = 0.5
+        ax.set_xlim(x_min - padding, x_max + padding)
+        ax.set_ylim(y_min - padding, y_max + padding)
+
+        plt.tight_layout()
+        plt.show()
+
+    def embedding(basis, ciphertext, visualize=False, GGH=False, BKZ=False, block=20, 
+                  pruned=False, precision=100, bkzautoabort=True, bkzmaxloops=None, nolll=False):
+        """
+        Performs lattice embedding for closest vector problem (CVP) solving.
+
+        Args:
+            basis (fmpz_mat): The lattice basis.
+            ciphertext (fmpz_mat): The ciphertext vector.
+            visualize (bool, optional): Whether to visualize the result.
+            GGH (bool, optional): Whether to use GGH-specific constraints.
+            BKZ (bool, optional): Whether to use BKZ reduction.
+            block (int, optional): The block size for BKZ reduction.
+            pruned (bool, optional): Whether to use pruning in BKZ.
+            precision (int, optional): The precision for BKZ calculations.
+            bkzautoabort (bool, optional): Whether to use auto-abort in BKZ.
+            bkzmaxloops (int, optional): The maximum number of loops for BKZ.
+            nolll (bool, optional): Whether to skip LLL in BKZ.
+
+        Returns:
+            fmpz_mat: The closest vector to the ciphertext in the lattice.
+        """
+        if basis.ncols() != ciphertext.ncols():
+                raise ValueError(f"[Utils] Point is a {1}x{ciphertext.ncols()} matrix, but basis is a {basis.nrows()}x{basis.ncols()} one")
+        
+        n = basis.nrows()
+
+        # Create the initial matrix with R and a column of zeros
+        matrix_emb = fmpz_mat([[int(basis[i,j]) if j < n else 0 for j in range(n+1)] for i in range(n)])
+
+        # Add t as the last row, with 1 as the last element
+        last_row = [int(ciphertext[0,i]) for i in range(n)] + [1]
+        matrix_emb = fmpz_mat(matrix_emb.tolist() + [last_row])
+        
+        if BKZ:
+            matrix_emb = Utils.BKZ_reduction(matrix_emb, block=block, pruned=pruned, precision=precision,
+                                   bkzautoabort=bkzautoabort, bkzmaxloops=bkzmaxloops, nolll=nolll)
+        else:
+            matrix_emb = matrix_emb.lll()
+
+        min_norm = float('inf')
+        shortest_vector = None
+
+        for i in range(n + 1):
+            i_th_row = fmpz_mat([[matrix_emb[i, j] for j in range(n + 1)]])
+
+            if GGH:
+                if matrix_emb[i, n] == 1:  # Se l'ultimo elemento è 1
+                    norm = Utils.vector_l2_norm(i_th_row)
+                    if norm < min_norm:
+                        min_norm = norm
+                        # Prendi i primi n valori della riga più corta
+                        shortest_vector = fmpz_mat([[matrix_emb[i, j] for j in range(n)]])
+            else:
+                # Se GGH non è vero, considera comunque la riga per trovare il vettore più corto
+                norm = Utils.vector_l2_norm(i_th_row)
+                if norm < min_norm:
+                    min_norm = norm
+                    # Prendi i primi n valori della riga più corta
+                    shortest_vector = fmpz_mat([[matrix_emb[i, j] for j in range(n)]])
+    
+        # Se GGH è vero e nessun vettore con 1 come ultimo elemento è stato trovato,
+        # ritorna comunque il vettore più corto trovato
+        if GGH and shortest_vector is None:
+            for i in range(n + 1):
+                i_th_row = fmpz_mat([[matrix_emb[i, j] for j in range(n + 1)]])
+                norm = Utils.vector_l2_norm(i_th_row)
+                if norm < min_norm:
+                    min_norm = norm
+                    # Prendi i primi n valori della riga più corta
+                    shortest_vector = fmpz_mat([[matrix_emb[i, j] for j in range(n)]])
+
+        closest_vector = ciphertext - shortest_vector
+
+        if visualize:
+            if basis.nrows() != 2:
+                raise ValueError(f"[Utils] Can't visualize. Basis must be a {2}x{2} matrix, but got a {basis.nrows()}x{basis.ncols()} one")
+            Utils.visualize_lattice(basis, closest_vector, ciphertext, title="Embedding method")
+            
+
+        return closest_vector
+    
+    def npsp_to_fmpq_mat(basis):
+        """
+        Converts a numpy array or sympy matrix to an fmpq_mat.
+
+        Args:
+            basis (numpy.ndarray or sympy.Matrix): The input matrix.
+
+        Returns:
+            fmpq_mat: The converted matrix.
+        """
+        fractions = [[Fraction(item) for item in row] for row in basis.tolist()]
+        return fmpq_mat([[fmpq(f.numerator, f.denominator) for f in row] for row in fractions])
+
+    def npsp_to_fmpz_mat(basis):
+        """
+        Converts a numpy array or sympy matrix to an fmpz_mat.
+
+        Args:
+            basis (numpy.ndarray or sympy.Matrix): The input matrix.
+
+        Returns:
+            fmpz_mat: The converted matrix.
+        """
+        return fmpz_mat([[int(item) for item in sublist] for sublist in basis.tolist()])
+        
+    def vector_l1_norm(row):
+        """
+        Calculates the L1 norm of a vector.
+
+        Args:
+            row (fmpz_mat or fmpq_mat): The input vector.
+
+        Returns:
+            Decimal: The L1 norm of the vector.
+        """
+        if isinstance(row, fmpz_mat):
+            row = fmpq_mat(row)
+        getcontext().prec = 50
+        return max(sum(abs(Decimal(int(x.numer())) / Decimal(int(x.denom()))) for x in row) for row in row.tolist())
+        
+    def vector_l2_norm(row):
+        """
+        Calculates the L2 norm of a vector.
+
+        Args:
+            row (fmpz_mat or fmpq_mat): The input vector.
+
+        Returns:
+            Decimal: The L2 norm of the vector.
+        """
+        if isinstance(row, fmpz_mat):
+            row = fmpq_mat(row)
+        getcontext().prec = 50
+        return Decimal(sum((Decimal(int(x.numer())) / Decimal(int(x.denom()))) ** 2 for x in row)).sqrt()
+
+    
+    def get_hadamard_ratio(basis=None, precision=10):
+        """
+        Calculates the Hadamard ratio of a basis.
+
+        Args:
+            basis (fmpz_mat or fmpq_mat, optional): The input basis.
+            precision (int, optional): The precision for calculations.
+
+        Returns:
+            tuple: (Decimal ratio, str formatted ratio)
+        """
+        norms = []
+        dimension = basis.nrows()
+        
+        # Set a high precision for Decimal calculations
+        getcontext().prec = precision
+        
+        for i in range(basis.nrows()):
+            row = fmpz_mat([[basis[i, j] for j in range(basis.ncols())]])
+            norm = Utils.vector_l2_norm(row)
+            norms.append(Decimal(str(norm)))
+        
+        # Use log sum instead of direct multiplication
+        log_denominator = sum(norm.ln() for norm in norms)
+        log_numerator = abs(Decimal(basis.det().str())).ln()
+        
+        # Calculate the ratio using logs
+        log_result = (log_numerator - log_denominator) / Decimal(dimension)
+        result = log_result.exp()
+        
+        return result, f"{result:.{precision}f}"
+    
+    def write_matrix_to_file(matrix, filename):
+        """
+        Writes a matrix to a file.
+
+        Args:
+            matrix (fmpz_mat or fmpq_mat): The matrix to write.
+            filename (str): The name of the file to write to.
+
+        Returns:
+            str: The full path of the written file.
+        """
+        filename = os.path.join(os.getcwd(), filename)
+
+        rows = matrix.nrows()
+        cols = matrix.ncols()
+
+        # Open the file for writing
+        with open(filename, "w") as file:
+            file.write("[")
+            # Iterate over each row of the matrix
+            for i in range(rows):
+                # Iterate over each column of the matrix
+                file.write("[")
+                for j in range(cols):
+                    # Write the element to the file
+                    file.write(matrix[i, j].str() + " ")
+                # Write a newline character after each row
+                file.write("]\n")
+            file.write("]")
+            
+        return filename
+    
+    def load_matrix_from_file(filename, matrix_type='fmpq'):
+        """
+        Loads a matrix from a file.
+
+        Args:
+            filename (str): The name of the file to read from.
+            matrix_type (str, optional): The type of matrix to load ('fmpz' or 'fmpq').
+
+        Returns:
+            fmpz_mat or fmpq_mat: The loaded matrix.
+
+        Raises:
+            ValueError: If an invalid matrix_type is provided.
+        """
+        with open(os.path.join(os.getcwd(), filename), 'r') as file:
+            content = file.read().replace(']', '],').replace(' ]', ']').replace(' ', ', ')[:-4] + ']'
+    
+        if matrix_type == 'fmpz':
+            return fmpz_mat(ast.literal_eval(content))
+        elif matrix_type == 'fmpq':
+            data = [[Fraction(*map(int, elem.split('/') if '/' in elem else (elem, 1)))
+                    for elem in re.findall(r'[-]?\d+(?:/\d+)?', row)]
+                    for row in re.findall(r'\[(.*?)\]', content)]
+            
+            matrix = fmpq_mat(len(data), len(data[0]) if data else 0)
+
+            for i, row in enumerate(data):
+                for j, frac in enumerate(row):
+                    matrix[i, j] = fmpq(frac.numerator, frac.denominator)
+            return matrix
+        else:
+            raise ValueError("Invalid matrix_type. Use 'fmpz' or 'fmpq'.")
+
+    def BKZ_reduction(matrix, block=20, pruned=False, precision=90, bkzautoabort=True, bkzmaxloops=None, nolll=False):
+        """
+        Performs BKZ (Block Korkine-Zolotarev) lattice reduction.
+
+        Args:
+            matrix (fmpz_mat): The input matrix to reduce.
+            block (int, optional): The block size for BKZ.
+            pruned (bool, optional): Whether to use pruning.
+            precision (int, optional): The precision for calculations.
+            bkzautoabort (bool, optional): Whether to use auto-abort.
+            bkzmaxloops (int, optional): The maximum number of loops.
+            nolll (bool, optional): Whether to skip LLL.
+
+        Returns:
+            tuple: (fmpz_mat reduced matrix, str error message or None)
+        """
+        input_path = Utils.write_matrix_to_file(matrix, f'input.txt')
+        output_path = Utils.write_matrix_to_file(matrix, f'output.txt')
+
+        if os.name == 'nt':
+            command = f"wsl fplll input.txt -a bkz -b {block} -p {precision} -m wrapper -f mpfr"
+            if pruned:
+                command += " -s default.json"
+            if bkzautoabort:
+                command += " -bkzautoabort"
+            if bkzmaxloops != None:
+                command += f" -bkzmaxloops {bkzmaxloops}"
+            if nolll:
+                command += " -nolll"
+            command += f" > output.txt"
+        else:
+            command = f"fplll input.txt -a bkz -b {block} -p {precision} -m wrapper -f mpfr"
+            if pruned:
+                command += " -s default.json"
+            if bkzautoabort:
+                command += " -bkzautoabort"
+            if bkzmaxloops != None:
+                command += f" -bkzmaxloops {bkzmaxloops}"
+            if nolll:
+                command += " -nolll"
+            command += f" > output.txt"
+        try:
+            # Run the command and capture its output
+            logger.info(f"Reduction started with the following parameters:\n"
+            f"  block: {block}\n"
+            f"  pruned: {pruned}\n"
+            f"  precision: {precision}\n"
+            f"  bkzautoabort: {bkzautoabort}\n"
+            f"  bkzmaxloops: {bkzmaxloops}\n"
+            f"  nolll: {nolll}")
+            logger.info("Final command:\n"
+                  f"{command}")
+           
+            time_now = time.time()
+            process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True, cwd=os.getcwd())
+            output, error = process.communicate()
+            output = output.decode('utf-8')
+            error = error.decode('utf-8')
+
+            if error:
+                if str(error).strip() != "Failure: loops limit exceeded in BKZ":
+                    logger.error("Error during reduction:", error)
+            else:
+                error = None
+
+            logger.info(f"Reduction completed, time taken: {time.time() - time_now}")
+
+            # Load the reduced matrix
+            reduced_matrix = Utils.load_matrix_from_file(f"output.txt", "fmpz")
+
+            os.remove(output_path)
+            os.remove(input_path)
+
+            return reduced_matrix, error
+
+        except Exception as e:
+            return None, str(e)
+        
+    def babai_rounding(basis, point, visualize=False):
+        """
+        Performs Babai's rounding algorithm for CVP.
+
+        Args:
+            basis (fmpz_mat): The lattice basis.
+            point (fmpz_mat): The target point.
+            visualize (bool, optional): Whether to visualize the result.
+
+        Returns:
+            fmpz_mat: The closest vector to the point in the lattice.
+
+        Raises:
+            ValueError: If visualization is requested for a non-2D lattice.
+        """
+        x = point * basis.inv()
+
+        for i in range(x.nrows()):
+            for j in range(x.ncols()):
+                x[i,j] = round(x[i,j])
+        
+        closest_vector = x * basis 
+
+        if visualize:
+            if basis.nrows() != 2:
+                raise ValueError(f"[Utils] Can't visualize. Basis must be a {2}x{2} matrix, but got a {basis.nrows()}x{basis.ncols()} one")
+            Utils.visualize_lattice(basis, closest_vector, point, title="Babai rounding technique")
+            
+        return closest_vector

GGH_crypto-1.0.4/GGH_crypto/Utils/__init__.py

@@ -0,0 +1,3 @@
+from .Utils import Utils
+
+__all__ = ['Utils']

GGH_crypto-1.0.4/GGH_crypto/__init__.py

@@ -0,0 +1,5 @@
+from .GGH.GGH import GGHCryptosystem
+from .GGH_HNF.GGH_HNF import GGHHNFCryptosystem
+from .Utils.Utils import Utils
+
+__all__ = ['GGHCryptosystem', 'GGHHNFCryptosystem', 'Utils']

GGH_crypto-1.0.4/GGH_crypto.egg-info/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.1
+Name: GGH-crypto
+Version: 1.0.4
+Summary: GGH_crypto is a Python package for lattice-based cryptography, focusing on GGH and GGH-HNF implementations.
+Home-page: https://github.com/TheGaBr0/GGH
+Download-URL: https://github.com/TheGaBr0/GGH/archive/refs/tags/v1.0.4.tar.gz
+Author: Gabriele Bottani
+Author-email: gbotani19@gmail.com
+License: MIT
+Keywords: GGH,GGH-HNF,GGH_CRYPTO,Lattice,LLL,BKZ,Lattice-based-cryptography
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+
+# GGH-crypto
+GGH-crypto is a Python package implementing the Goldreich-Goldwasser-Halevi (GGH) public key cryptosystem and its optimization, GGH-HNF by Micciancio. This package is designed for educational and research purposes, offering insights into lattice-based cryptography.
+This project was developed as part of a 3-year degree program at the Università degli Studi di Milano (University of Milan). It explores the resilience of lattice-based cryptography against quantum threats and introduces an hybrid variant.
+
+# Features
+
+- Implementation of the original GGH cryptosystem (1997)
+- Implementation of the GGH-HNF optimization (2002)
+- Utility functions for lattice-based cryptography
+- Algorithms for solving the Closest Vector Problem (CVP)
+- Lattice reduction algorithms
+
+# Usage and details
+For detailed installation, usage, examples and documentation, please visit the [GitHub repository](https://github.com/TheGaBr0/GGH).
+
+
+# Note
+Both the original GGH cryptosystem and its GGH-HNF optimization have known security vulnerabilities. This implementation is not intended for production use.    

GGH_crypto-1.0.4/GGH_crypto.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE.txt
+README.md
+setup.cfg
+setup.py
+GGH_crypto/__init__.py
+GGH_crypto.egg-info/PKG-INFO
+GGH_crypto.egg-info/SOURCES.txt
+GGH_crypto.egg-info/dependency_links.txt
+GGH_crypto.egg-info/requires.txt
+GGH_crypto.egg-info/top_level.txt
+GGH_crypto/GGH/GGH.py
+GGH_crypto/GGH/__init__.py
+GGH_crypto/GGH_HNF/GGH_HNF.py
+GGH_crypto/GGH_HNF/__init__.py
+GGH_crypto/Utils/Utils.py
+GGH_crypto/Utils/__init__.py

GGH_crypto-1.0.4/GGH_crypto.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

GGH_crypto-1.0.4/GGH_crypto.egg-info/requires.txt

@@ -0,0 +1,4 @@
+matplotlib
+numpy
+python_flint
+sympy

GGH_crypto-1.0.4/GGH_crypto.egg-info/top_level.txt

@@ -0,0 +1 @@
+GGH_crypto

GGH_crypto-1.0.4/LICENSE.txt

@@ -0,0 +1,17 @@
+MIT License
+Copyright (c) 2018 YOUR NAME
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

GGH_crypto-1.0.4/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.1
+Name: GGH_crypto
+Version: 1.0.4
+Summary: GGH_crypto is a Python package for lattice-based cryptography, focusing on GGH and GGH-HNF implementations.
+Home-page: https://github.com/TheGaBr0/GGH
+Download-URL: https://github.com/TheGaBr0/GGH/archive/refs/tags/v1.0.4.tar.gz
+Author: Gabriele Bottani
+Author-email: gbotani19@gmail.com
+License: MIT
+Keywords: GGH,GGH-HNF,GGH_CRYPTO,Lattice,LLL,BKZ,Lattice-based-cryptography
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+
+# GGH-crypto
+GGH-crypto is a Python package implementing the Goldreich-Goldwasser-Halevi (GGH) public key cryptosystem and its optimization, GGH-HNF by Micciancio. This package is designed for educational and research purposes, offering insights into lattice-based cryptography.
+This project was developed as part of a 3-year degree program at the Università degli Studi di Milano (University of Milan). It explores the resilience of lattice-based cryptography against quantum threats and introduces an hybrid variant.
+
+# Features
+
+- Implementation of the original GGH cryptosystem (1997)
+- Implementation of the GGH-HNF optimization (2002)
+- Utility functions for lattice-based cryptography
+- Algorithms for solving the Closest Vector Problem (CVP)
+- Lattice reduction algorithms
+
+# Usage and details
+For detailed installation, usage, examples and documentation, please visit the [GitHub repository](https://github.com/TheGaBr0/GGH).
+
+
+# Note
+Both the original GGH cryptosystem and its GGH-HNF optimization have known security vulnerabilities. This implementation is not intended for production use.    

GGH_crypto-1.0.4/README.md

@@ -0,0 +1,18 @@
+# GGH-crypto
+GGH-crypto is a Python package implementing the Goldreich-Goldwasser-Halevi (GGH) public key cryptosystem and its optimization, GGH-HNF by Micciancio. This package is designed for educational and research purposes, offering insights into lattice-based cryptography.
+This project was developed as part of a 3-year degree program at the Università degli Studi di Milano (University of Milan). It explores the resilience of lattice-based cryptography against quantum threats and introduces an hybrid variant.
+
+# Features
+
+- Implementation of the original GGH cryptosystem (1997)
+- Implementation of the GGH-HNF optimization (2002)
+- Utility functions for lattice-based cryptography
+- Algorithms for solving the Closest Vector Problem (CVP)
+- Lattice reduction algorithms
+
+# Usage and details
+For detailed installation, usage, examples and documentation, please visit the [GitHub repository](https://github.com/TheGaBr0/GGH).
+
+
+# Note
+Both the original GGH cryptosystem and its GGH-HNF optimization have known security vulnerabilities. This implementation is not intended for production use.    

GGH_crypto-1.0.4/setup.cfg

@@ -0,0 +1,7 @@
+[metadata]
+description-file = README.md
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

GGH_crypto-1.0.4/setup.py

@@ -0,0 +1,35 @@
+from setuptools import setup, find_packages
+
+from pathlib import Path
+this_directory = Path(__file__).parent
+long_description = (this_directory / "README.md").read_text()
+
+setup(
+  name = 'GGH_crypto',
+  packages = find_packages(),
+  version = '1.0.4',
+  license='MIT',
+  description = 'GGH_crypto is a Python package for lattice-based cryptography, focusing on GGH and GGH-HNF implementations.',
+  long_description=long_description,
+  long_description_content_type='text/markdown',
+  author = 'Gabriele Bottani',
+  author_email = 'gbotani19@gmail.com',
+  url = 'https://github.com/TheGaBr0/GGH',
+  download_url = 'https://github.com/TheGaBr0/GGH/archive/refs/tags/v1.0.4.tar.gz',
+  keywords = ['GGH', 'GGH-HNF', 'GGH_CRYPTO', 'Lattice', 'LLL', 'BKZ', 'Lattice-based-cryptography'],
+  install_requires=[
+      'matplotlib',
+      'numpy',
+      'python_flint',
+      'sympy',
+  ],
+  classifiers=[
+    'Development Status :: 5 - Production/Stable',
+    'Intended Audience :: Developers',
+    'Topic :: Software Development :: Build Tools',
+    'License :: OSI Approved :: MIT License',
+    'Programming Language :: Python :: 3.10',
+    'Programming Language :: Python :: 3.11',
+    'Programming Language :: Python :: 3.12'
+  ],
+)