7#ifndef BOTAN_BLS12_381_GROUP_H_
8#define BOTAN_BLS12_381_GROUP_H_
10#include <botan/bls12_381.h>
11#include <botan/mem_ops.h>
12#include <botan/internal/bls12_381_fields.h>
13#include <botan/internal/ct_utils.h>
26template <
typename Group>
29 using Affine =
typename Group::Affine;
31 using FE =
typename Group::FE;
33 static_assert(Affine::BYTES == FE::BYTES);
39 return Projective(Group::load(affine.m_x), Group::load(affine.m_y), z);
43 const auto z = Group::load(pt.m_z);
44 const auto zinv = z.invert();
45 const auto inf = z.is_zero();
50 auto y = Group::load(pt.m_y) * zinv;
51 y.conditional_assign(inf, FE::one());
53 return Affine(Group::load(pt.m_x) * zinv, y, inf.template into_bitmask<uint32_t>() & 1);
57 const size_t n = points.size();
59 std::vector<Affine> affine;
79 const auto masked_z = [](
const Projective& pt) {
80 auto z = Group::load(pt.m_z);
81 z.conditional_assign(z.is_zero(), FE::one());
85 const auto affine_from = [](
const Projective& pt,
const FE& z_inv) {
86 const auto inf = Group::load(pt.m_z).is_zero();
88 auto x = Group::load(pt.m_x) * z_inv;
89 auto y = Group::load(pt.m_y) * z_inv;
92 x.conditional_assign(inf, FE::zero());
93 y.conditional_assign(inf, FE::one());
95 return Affine(x, y, inf.template into_bitmask<uint32_t>() & 1);
98 std::vector<FE> prefix;
101 prefix.push_back(masked_z(points[0]));
102 for(
size_t i = 1; i != n; ++i) {
103 prefix.push_back(prefix[i - 1] * masked_z(points[i]));
106 auto inv = prefix[n - 1].invert();
108 for(
size_t i = n; i > 1; --i) {
109 const auto& pt = points[i - 1];
110 affine.push_back(affine_from(pt, inv * prefix[i - 2]));
111 inv = inv * masked_z(pt);
113 affine.push_back(affine_from(points[0], inv));
115 std::reverse(affine.begin(), affine.end());
121 return Projective(Group::load(pt.m_x), Group::load(pt.m_y).negate(), Group::load(pt.m_z));
125 auto y = Group::load(pt.m_y);
127 pt.m_y = Group::store(y);
133 const auto x = Group::load(pt.m_x);
134 const auto y = Group::load(pt.m_y);
135 const auto z = Group::load(pt.m_z);
137 auto t0 = y.square();
142 auto t2 = z.square();
143 t2 = Group::mul_by_3b(t2);
162 const auto x1 = Group::load(a.m_x);
163 const auto y1 = Group::load(a.m_y);
164 const auto z1 = Group::load(a.m_z);
165 const auto x2 = Group::load(b.m_x);
166 const auto y2 = Group::load(b.m_y);
167 const auto z2 = Group::load(b.m_z);
189 t2 = Group::mul_by_3b(t2);
192 y3 = Group::mul_by_3b(y3);
212 const auto x1 = Group::load(a.m_x);
213 const auto y1 = Group::load(a.m_y);
214 const auto z1 = Group::load(a.m_z);
215 const auto x2 = Group::load(other.m_x);
216 auto y2 = Group::load(other.m_y);
234 auto t2 = Group::mul_by_3b(z1);
237 y3 = Group::mul_by_3b(y3);
264 if(bytes.size() != Affine::BYTES) {
268 const uint8_t flags = bytes[0];
271 if((flags & 0x80) != 0x80) {
275 const bool is_infinity = (flags & 0x40) == 0x40;
276 const bool y_is_largest = (flags & 0x20) == 0x20;
278 std::array<uint8_t, Affine::BYTES> x_bytes{};
279 copy_mem(x_bytes.data(), bytes.data(), bytes.size());
284 if(y_is_largest || !
CT::all_zeros(x_bytes.data(), x_bytes.size()).as_bool()) {
287 return Affine::identity();
290 const auto x = FE::deserialize(x_bytes);
295 const auto y2 = x->square() * (*x) + Group::curve_b();
296 auto y = y2.sqrt().as_optional_vartime();
304 y->conditional_assign(flip, y->negate());
310 auto bytes = Group::load(pt.m_x).serialize();
318 bytes[0] |= (identity.template into_bitmask<uint8_t>() & 0x40);
321 const auto large_y = Group::load(pt.m_y)._is_lexicographically_largest();
322 bytes[0] |= ((!identity && large_y).template into_bitmask<uint8_t>() & 0x20);
typename Group::Projective Projective
static Projective from_affine(const Affine &affine)
static Projective add(const Projective &a, const Projective &b)
static Projective add_mixed(const Projective &a, const Affine &other, bool negate_other)
static std::optional< Affine > deserialize_unchecked(std::span< const uint8_t > bytes)
static Affine to_affine(const Projective &pt)
static std::vector< Affine > to_affine_batch(std::span< const Projective > points)
static Projective dbl(const Projective &pt)
static Projective negate(const Projective &pt)
static std::array< uint8_t, Affine::BYTES > serialize(const Affine &pt)
typename Group::Affine Affine
static void conditional_negate(Projective &pt, uint32_t negate)
static constexpr Choice from_int(T v)
constexpr CT::Mask< T > all_zeros(const T elem[], size_t len)
constexpr Mask< T > conditional_assign_mem(T cnd, T *dest, const T *src, size_t elems)
constexpr void copy_mem(T *out, const T *in, size_t n)
std::conditional_t< HasNative64BitRegisters, std::uint64_t, uint32_t > word
The native machine word, used as the limb type for multiprecision integers.