libff::ffi Namespace Reference

Functions
template<typename ppT >
bool	g1_add (const void *a_g1, size_t a_g1_size, const void *b_g1, size_t b_g1_size, void *out_g1, size_t out_g1_size)
template<typename ppT >
bool	g1_mul (const void *p_g1, size_t p_g1_size, const void *s_fr, size_t s_fr_size, void *out_g1, size_t out_g1_size)
template<typename ppT >
bool	pairing (const void *a_g1, size_t a_g1_size, const void *b_g2, size_t b_g2_size, const void *c_g1, size_t c_g1_size, const void *d_g2, size_t d_g2_size, const void *e_g1, size_t e_g1_size, const void *f_g2, size_t f_g2_size, const void *g_g1, size_t g_g1_size, const void *h_g2, size_t h_g2_size)
template<typename T >
bool	object_read_from_buffer (T &object, const void *buffer, size_t buffer_size)
template<typename T >
bool	object_write_to_buffer (const T &object, void *buffer, size_t buffer_size)
template<typename FieldT >
bool	field_element_read (FieldT &f, const void *buffer, size_t buffer_size)
template<typename FieldT >
bool	field_element_write (const FieldT &f, void *buffer, size_t buffer_size)
template<typename GroupT >
bool	group_element_read (GroupT &g, const void *buffer, size_t buffer_size)
template<typename GroupT >
bool	group_element_write (const GroupT &g, const void *buffer, size_t buffer_size)

Function Documentation

field_element_read()

template<typename FieldT >

bool libff::ffi::field_element_read	(	FieldT &	f,
		const void *	buffer,
		size_t	buffer_size
	)

Read a field element, checking that the buffer size is as expected. Returns true on success.

Here is the caller graph for this function:

field_element_write()

template<typename FieldT >

bool libff::ffi::field_element_write	(	const FieldT &	f,
		void *	buffer,
		size_t	buffer_size
	)

Write a field element to a buffer, checking that the size is as expected. Returns true on success.

g1_add()

template<typename ppT >

bool libff::ffi::g1_add	(	const void *	a_g1,
		size_t	a_g1_size,
		const void *	b_g1,
		size_t	b_g1_size,
		void *	out_g1,
		size_t	out_g1_size
	)

Definition at line 17 of file ffi.cpp.

{
    libff::G1<ppT> a;
    libff::G1<ppT> b;
    if (group_element_read(a, a_g1, a_g1_size) &&
        group_element_read(b, b_g1, b_g1_size)) {
        const libff::G1<ppT> output = a + b;
        return group_element_write(output, out_g1, out_g1_size);
    }
 
    return false;
}

Here is the call graph for this function:

g1_mul()

template<typename ppT >

bool libff::ffi::g1_mul	(	const void *	p_g1,
		size_t	p_g1_size,
		const void *	s_fr,
		size_t	s_fr_size,
		void *	out_g1,
		size_t	out_g1_size
	)

Definition at line 37 of file ffi.cpp.

{
    libff::G1<ppT> p;
    libff::Fr<ppT> s;
    if (group_element_read(p, p_g1, p_g1_size) &&
        field_element_read(s, s_fr, s_fr_size)) {
        const libff::G1<ppT> output = s * p;
        return group_element_write(output, out_g1, out_g1_size);
    }
 
    return false;
}

Here is the call graph for this function:

group_element_read()

template<typename GroupT >

bool libff::ffi::group_element_read	(	GroupT &	g,
		const void *	buffer,
		size_t	buffer_size
	)

Read a group element (in affine form), checking that the buffer size is as expected. Returns true on success.

Here is the caller graph for this function:

group_element_write()

template<typename GroupT >

bool libff::ffi::group_element_write	(	const GroupT &	g,
		const void *	buffer,
		size_t	buffer_size
	)

Write a group element to a buffer (in affine form), checking that the size is as expected. Returns true on success.

Here is the caller graph for this function:

object_read_from_buffer()

template<typename T >

bool libff::ffi::object_read_from_buffer	(	T &	object,
		const void *	buffer,
		size_t	buffer_size
	)

Check the buffer size and copy in reverse-byte order. Returns true on success.

object_write_to_buffer()

template<typename T >

bool libff::ffi::object_write_to_buffer	(	const T &	object,
		void *	buffer,
		size_t	buffer_size
	)

Check the buffer size and write in reverse-byte order. Returns true on success.

pairing()

template<typename ppT >

bool libff::ffi::pairing	(	const void *	a_g1,
		size_t	a_g1_size,
		const void *	b_g2,
		size_t	b_g2_size,
		const void *	c_g1,
		size_t	c_g1_size,
		const void *	d_g2,
		size_t	d_g2_size,
		const void *	e_g1,
		size_t	e_g1_size,
		const void *	f_g2,
		size_t	f_g2_size,
		const void *	g_g1,
		size_t	g_g1_size,
		const void *	h_g2,
		size_t	h_g2_size
	)

Definition at line 57 of file ffi.cpp.

{
    libff::G1<ppT> a;
    libff::G2<ppT> b;
    libff::G1<ppT> c;
    libff::G2<ppT> d;
    libff::G1<ppT> e;
    libff::G2<ppT> f;
    libff::G1<ppT> g;
    libff::G2<ppT> h;
 
    if (group_element_read(a, a_g1, a_g1_size) &&
        group_element_read(b, b_g2, b_g2_size) &&
        group_element_read(c, c_g1, c_g1_size) &&
        group_element_read(d, d_g2, d_g2_size) &&
        group_element_read(e, e_g1, e_g1_size) &&
        group_element_read(f, f_g2, f_g2_size) &&
        group_element_read(g, g_g1, g_g1_size) &&
        group_element_read(h, h_g2, h_g2_size)) {
        // Use the double miller loop, to compute the pairing for two
        // pairs at a time, and apply the final_exponentiation to the
        // product.
 
        // miller(a,b).miller(c,d)
        libff::GT<ppT> miller_abcd = ppT::double_miller_loop(
            ppT::precompute_G1(a),
            ppT::precompute_G2(b),
            ppT::precompute_G1(c),
            ppT::precompute_G2(d));
        // miller(e,f).miller(g,h)
        libff::GT<ppT> miller_efgh = ppT::double_miller_loop(
            ppT::precompute_G1(e),
            ppT::precompute_G2(f),
            ppT::precompute_G1(g),
            ppT::precompute_G2(h));
 
        // e(a,b).e(c,d).e(e,f).e(g,h)
        libff::GT<ppT> product =
            ppT::final_exponentiation(miller_abcd * miller_efgh);
        return libff::GT<ppT>::one() == product;
    }
 
    return false;
}

Here is the call graph for this function: