pairingfns.xml

这是一个C的源代码

<chapter>
<title>Pairing Functions</title>
<para>
An application will most likely need to instantiate a bilinear pairing
before performing any other operations.
The easiest way to do this is to initialize a pairing with
previously-generated pairing parameters.
</para>
<para>
Parameters for various pairings are included with
the PBC library distribution in the
<filename>param</filename> subdirectory and should
be suitable for cryptographic use. Some programs in
the <filename>gen</filename> subdirectory may be used to
generate parameters (see the chapter on bundled programs).
Also, on the PBC website an archive containing many pairing
parameters is available for download.
</para>
<para>
Particular instantiations of bilinear pairings are stored in the data
type <type>pairing_t</type>. Functions that operate on them
start with <function>pairing_</function>.
</para>
<para>
Pairings involve three groups of prime order. The PBC library labels them
G1, G2, and GT, and labels the order r. The pairing is
a bilinear map that takes two elements as input,
one from G1 and one from G2, and outputs an element of GT.
</para>
<para>
The elements of G2 are at least as long as G1; G1 is guaranteed to be the
shorter of the two. Sometimes G1 and G2 are the same group (i.e. the pairing
is symmetric) so their elements can be mixed freely. In this case the
<function>pairing_is_symmetric</function> function returns 1.
</para>
<para>
A <link linkend="chapter.param">later chapter</link> discusses the different
pairing types.
</para>
<section>
<title>Initializing Pairings</title>
<para>
The only way to initialize a pairing
is to provide pairing parameters to a <type>pairing_t</type>
variable using one of the functions
beginning with <function>pairing_init_inp_</function>. For example,
</para>
<programlisting>{
    pairing_t pairing;

    pairing_init_inp_str(pairing, stdin);
}
</programlisting>
<para>
will initialize <parameter>pairing</parameter> with
parameters are fed to the program on standard
input.
</para>
<para>
The format of the pairing parameters is a text format that
is output by the param functions.
</para>
<variablelist>
&pairing_init;
</variablelist>
</section>

<section>
<title>Applying Pairings</title>
<para>
The function <command>pairing_apply</command>
can be called to apply a bilinear map.
The order of the inputs is important. The first, which holds the output,
must be from the group GT. The second must be from G1, the third from G2,
and the fourth must be the <type>pairing_t</type> variable that relates them.
(One cannot mix and match G1, G2, and GT groups from different pairings.)
</para>
<para>
In some applications, the programmer may know that many pairings with the
same G1 input will be computed. In this case, preprocessing should be used
to avoid repeating many calculations saving time in the long run.
A variable of type <type>pairing_pp_t</type> should be declared,
initialized with the fixed G1 element, and then used to compute pairings:
</para>
<programlisting>
pairing_pp_t pp;

pairing_pp_init(pp, x, pairing); //x is some element of G1

pairing_pp_apply(r1, y1, pp); //r1 = e(x, y1)
pairing_pp_apply(r2, y2, pp); //r2 = e(x, y2)

pairing_pp_clear(pp); //don't need pp anymore
</programlisting>
<variablelist>
&pairing_apply;
</variablelist>
</section>

<section>
<title>Other Pairing Functions</title>
<variablelist>
&pairing_op;
</variablelist>
</section>
</chapter>