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.

JPBC 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 JPBC, 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 it.unisa.dia.gas.plaf.jpbc.mm.clt13.parameters.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 it.unisa.dia.gas.plaf.jpbc.mm.clt13.parameters.CTL13MMSystemParameters; CTL13MMSystemParameters toy = new CTL13MMSystemParameters( PairingFactory.getInstance().loadParameters("./params/mm/ctl13/toy.properties") );

JPBC 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.

JPBC 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 it.unisa.dia.gas.plaf.jpbc.mm.clt13.generators.CTL13MMMultiThreadPublicParameterGenerator; import it.unisa.dia.gas.plaf.jpbc.mm.clt13.generators.CTL13MMPublicParameterGenerator; import it.unisa.dia.gas.plaf.jpbc.mm.clt13.parameters.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.