Multilinear Pairing Parameters Generators

We currently do not have candidates for multilinear maps between groups with cryptographically hard problems. However, Garg, Gentry, and Halevi (henceforth GGH), in their paper Candidate Multilinear Maps from Ideal Lattices , suggest a concrete candidate for an approximation of multilinear maps, named graded encoding systems. With the GGH candidate, group elements have a randomized (and thus non-unique) representation dubbed encoding. While it is possible to extract a unique canonical bistring, it is not possible to perform further computations with this extracted bitstring. An encoding can be re-randomized (e.g., to hide the sequence of operations that were performed), but only at the cost of introducing an artificial noice term in the encoding. Further operation on this group element cause the noise to grow; once this noise grows beyond a certain bound, encodings can no longer be worked with.

CTL13

Arcanum provides an implementation of Multilinear Maps based on the paper Practical Multilinear Maps over the Integers by Coron, Lepoint, and Tibouchi (henceforth CTL). They describe a different construction from the GGH one that works over the integers instead of ideal lattices.

In the CTL construction there are two sets of parameters:

The System Parameters: They govern the security and the correctness of the multilinear map. They must be set carefully to satisfy the constraints described in the CTL paper, Section 3.1. In Arcanum, the class CTL13MMSystemParameters models the system parameters which can be set in two different ways. The first is by passing the parameters to one of the constructors of the class as follows: 

import CTL13MMSystemParameters;

                        CTL13MMSystemParameters toy = new CTL13MMSystemParameters(
                        757, // eta
                        165, // n
                        10, // alpha
                        160, // ell
                        27, //rho
                        12, // delta
                        5, // kappa
                        80, //beta
                        16, // theta
                        160 // bound
                        );

The system parameters can be also loaded from a file as follows: 

import CTL13MMSystemParameters;

                        CTL13MMSystemParameters toy = new CTL13MMSystemParameters(
                        PairingFactory.getInstance().loadParameters("./params/mm/ctl13/toy.properties")
                        );

Arcanum provides a set of predefined system parameters that can be found in the params/mm/ctl13 folder of the distro package.

The Public Parameters: They describe a specific instance of a multilinear map defined by the given system parameters.

Arcanum provides single and multithreaded generators that take in input the system parameters and generate the public parameters which are then saved in a file whose name is related to the system parameters used. For example, for CTL13MMSystemParameters.TOY the name used will be CTL13MM_eta_757_n_165_alpha_10_ell_160_rho_27_delta_12_kappa_5_beta_80_theta_16_bound_160.dat.
Here is an example on how to instantiate the generators. 

import
                    org.arcanum.dia.gas.plaf.arcanum.mm.clt13.generators.CTL13MMMultiThreadPublicParameterGenerator;
                    import CTL13MMPublicParameterGenerator;
                    import CTL13MMSystemParameters;

                    // Single thread public parameter generator ...
                    ParametersGenerator pg = new CTL13MMPublicParameterGenerator(CTL13MMSystemParameters.TOY);

                    // Multithreaded public parameter generator ...
                    ParametersGenerator mtPg = new
                    CTL13MMMultiThreadPublicParameterGenerator(CTL13MMSystemParameters.TOY);

Notice that, the multithreaded generator does not have any special memory requirements. In fact, the generator uses memory mapped files to store the public parameters. Of course, the less the memory the system has the slower the generation process is.

On the other hand, the single thread generator keeps all the public parameters in memory and only at the end of process the parameters are stored to a file. Thus, depending on the system parameters, huge quantity of memory could be required.

Once the public parameters are generated they can be loaded or used to instantiate the Pairing interface by using the PairingFactory in the usual way.