mphell-curve.h

Go to the documentation of this file.

/* 
  MPHELL-5.0 
  Author(s): The MPHELL team
 
 (C) Copyright 2015-2021 - Institut Fourier / Univ. Grenoble Alpes (France) 
 
 This file is part of the MPHELL Library.
 MPHELL is free software: you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation, version 3 of the License.
 
 MPHELL is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU Lesser General Public License for more details.
 
 You should have received a copy of the GNU Lesser General Public License
 along with MPHELL.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#ifndef MPHELL_CURVE_H
#define MPHELL_CURVE_H
 
#include "mphell-field.h"
 
 
/**************************************DATA STRUCTURE**********************************/
 
 
enum ec_type_enum 
{
    WEIERSTRASS,        
    EDWARDS,            
    JACOBI_QUARTIC      
};
 
typedef enum ec_type_enum ec_type;
 
enum ec_algo_enum
{
    PROJECTIVE,                         
    JACOBIAN,                           
    EXTENDED_HOMOGENEOUS_PROJECTIVE,    
    EXTENDED_EDWARDS                    
};
 
typedef enum ec_algo_enum ec_formula;
 
enum ec_known_curve_enum
{
    NIST_192,                           
    NIST_224,                           
    NIST_256,                           
    NIST_384,                           
    NIST_521,                           
    BRAINPOOL_160,                      
    BRAINPOOL_192,                      
    BRAINPOOL_224,                      
    BRAINPOOL_256,                      
    BRAINPOOL_320,                      
    BRAINPOOL_384,                      
    BRAINPOOL_512,                      
    FR_256,                             
    JQ_256_3,                           
    ED_25519,                            
    ED_448                              
};
 
typedef enum ec_known_curve_enum ec_known_curve;
 
struct ec_point 
{
    field_elt x; 
    field_elt y; 
    field_elt z; 
    field_elt t; 
};
 
typedef struct ec_point ec_point_t;
 
typedef ec_point_t ec_point[1];
 
typedef ec_point_t * ec_point_ptr;
 
typedef const ec_point_t * ec_point_srcptr;
 
struct ec_curve 
{
    char *id_curve;     
    field_ptr k;        
    number q;           
    field_elt a, b;     
    ec_type type;       
    ec_formula f;       
    ec_point G;         
    number n;           
    number h;           
    field_elt disc;     
    field_elt D;        
    bool ec_spec1;      
#if MPHELL_USE_AMNS == 1
    amns * AMNS;        
#endif
};
 
typedef struct ec_curve ec_curve_t;
 
typedef ec_curve_t ec_curve[1];
 
typedef ec_curve_t * ec_curve_ptr;
 
typedef const ec_curve_t * ec_curve_srcptr;
 
 
/**********************************WEIESTRASS*****************************/
 
#include "mphell-weierstrass.h"
 
/********************************JACOBI QUARTIC***************************/
 
#include "mphell-jacobi.h"
 
/***********************************EDWARDS*******************************/
 
#include "mphell-edwards.h"
 
/*************************************TMP*********************************/
 
static inline void
ec_point_get_pool_elt (ec_point_ptr P, field_ptr k, uint8_t stack)
{
    field_elt_get_pool_elt(&(P->x), k, stack);
    field_elt_get_pool_elt(&(P->y), k, stack);
    field_elt_get_pool_elt(&(P->z), k, stack);
    field_elt_get_pool_elt(&(P->t), k, stack);
}
 
static inline void
ec_point_relax_pool_elt (ec_point_ptr P, field_ptr k, uint8_t stack)
{
    field_elt_relax_pool_elt(&(P->x), k, stack);
    field_elt_relax_pool_elt(&(P->y), k, stack);
    field_elt_relax_pool_elt(&(P->z), k, stack);
    field_elt_relax_pool_elt(&(P->t), k, stack);
}
 
/************************************SETTERS**********************************/
 
 
void 
ec_alloc (ec_curve_ptr E, field_srcptr k);
 
void 
ec_init (ec_curve_ptr E, field_srcptr k);
 
void 
ec_create (ec_curve_ptr E, const char *id_curve, field_srcptr k, fe_srcptr a,
        fe_srcptr b, ec_point_srcptr G, number_srcptr h, number_srcptr n, 
        const ec_type type, const ec_formula f, uint8_t stack);
 
void 
ec_use_curve (ec_curve_ptr E, field_ptr k, const ec_known_curve id_curve, const ec_formula f, uint8_t stack);
 
void 
ec_random(ec_curve_ptr E, const char *id_curve, char * seed_res, field_srcptr k, const ec_type type, const ec_formula f, uint8_t stack);
 
bool 
ec_verify_random_generation(ec_curve_ptr E, const char * seed, uint8_t stack);
 
void 
ec_set_fast_unified_coordinates(ec_curve_ptr E);
 
void 
ec_set_fast_dedicated_coordinates(ec_curve_ptr E);
 
void
ec_compute_disc (ec_curve_ptr E, uint8_t stack);
 
void
ec_test_spec (ec_curve_ptr E, uint8_t stack);
 
void
ec_copy (ec_curve_ptr E_res, ec_curve_srcptr E);
 
void 
ec_clear (ec_curve_ptr E);
 
void 
ec_free (ec_curve_ptr E);
 
void 
ec_point_alloc (ec_point_ptr P, field_srcptr k);
 
void 
ec_point_init (ec_point_ptr P, field_srcptr k);
 
void 
ec_point_clear (ec_point_ptr P, field_srcptr k);
 
void 
ec_point_free (ec_point_ptr P, field_srcptr k);
 
void
ec_point_copy (ec_point_ptr P3, ec_point_srcptr P, field_srcptr k);
 
void 
ec_point_set (ec_point_ptr P, fe_srcptr x, fe_srcptr y, 
        fe_srcptr z, fe_srcptr t, field_srcptr k);
 
void 
ec_point_set_str (ec_point_ptr P, const char *str_x, const char *str_y, 
        const char *str_z, const char *str_t, const bool is_reduced, 
        const uint8_t base, field_srcptr k, uint8_t stack);
 
void 
ec_point_set_aff (ec_point_ptr P, fe_srcptr x, fe_srcptr y,
        const ec_type type, field_srcptr k, uint8_t stack);
 
void 
ec_point_set_aff_str (ec_point_ptr P, const char *str_x, const char *str_y,
        const bool is_reduced, const uint8_t base, const ec_type type,
        field_srcptr k, uint8_t stack);
 
void 
ec_point_set_neutral (ec_point_ptr dst, ec_curve_srcptr E, uint8_t stack);
 
void
ec_point_norm (ec_point_ptr P, ec_curve_srcptr E, uint8_t stack);
 
void
ec_point_get_x_affine (field_elt x, ec_point_ptr P, ec_curve_srcptr E, uint8_t stack);
 
void
ec_point_get_y_affine (field_elt y, ec_point_ptr P, ec_curve_srcptr E, uint8_t stack);
 
void
ec_point_lift (ec_point_ptr P, field_srcptr k, uint8_t stack);
 
bool
ec_belongs (ec_point_srcptr P, ec_curve_srcptr E, uint8_t stack);
 
void
ec_point_random (ec_point_ptr P, ec_curve_srcptr E, uint8_t stack);
 
void
ec_curve_str (char **str, ec_curve_srcptr E, const uint8_t base, uint8_t stack);
 
void
ec_curve_print (ec_curve_srcptr E, const uint8_t base, uint8_t stack);
 
void
ec_point_str (char **str, ec_point_srcptr P, const uint8_t base, 
        const bool lift, field_srcptr k, uint8_t stack);
 
void
ec_point_print (ec_point_srcptr P, const uint8_t base, const bool lift, field_srcptr k, uint8_t stack);
 
 
/*******************************COMPARISON************************************/
 
 
bool 
ec_point_is_neutral (ec_point_srcptr P, ec_curve_srcptr E, uint8_t stack);
 
bool
ec_point_are_equal (ec_point_srcptr P1, ec_point_srcptr P2, const ec_curve_srcptr E, uint8_t stack);
 
 
/*******************************OPERATIONS************************************/
 
void 
ec_point_neg (ec_point_ptr P3, ec_point_srcptr P1, ec_curve_srcptr E);
 
/* UNIFIED => Resistant to SPA */
 
void 
ec_point_add_unified (ec_point_ptr P3, ec_point_srcptr P1, ec_point_srcptr P2, 
        ec_curve_srcptr E, uint8_t stack);
 
void
ec_point_dbl_unified (ec_point_ptr P3, ec_point_srcptr P1, ec_curve_srcptr E, uint8_t stack);
 
void 
ec_point_sub_unified (ec_point_ptr P3, ec_point_srcptr P1, ec_point_srcptr P2, 
        ec_curve_srcptr E, uint8_t stack);
 
void
ec_point_mul_unified (ec_point_ptr P3, number_srcptr n, ec_point_srcptr P1, 
        ec_curve_srcptr E, uint8_t stack);
 
 
/* DEDICATED => Not resistant to SPA, but faster */
 
void 
ec_point_add (ec_point_ptr P3, ec_point_srcptr P1, ec_point_srcptr P2, 
        ec_curve_srcptr E, uint8_t stack);
 
void
ec_point_dbl (ec_point_ptr P3, ec_point_srcptr P1, ec_curve_srcptr E, uint8_t stack);
 
void 
ec_point_sub (ec_point_ptr P3, ec_point_srcptr P1, ec_point_srcptr P2, 
        ec_curve_srcptr E, uint8_t stack);
 
void
ec_point_mul (ec_point_ptr P3, number_srcptr n, ec_point_srcptr P1, 
        ec_curve_srcptr E, uint8_t stack);
 
void 
ec_point_mul_with_precomp (ec_point_ptr P3, number_srcptr n, ec_point * tab_P1, 
        int16_t window_size, ec_curve_srcptr E, uint8_t stack);
 
void 
ec_point_2mul_with_precomp (ec_point_ptr P3, number_srcptr n1, ec_point * tab_P1,
        number_srcptr n2, ec_point * tab_P2, 
        int16_t win_size, ec_curve_srcptr E, uint8_t stack);
 
/***********************************CONVERSION********************************/
 
void
jacobi_quartic_to_weierstrass (ec_curve_ptr E_res, ec_curve_srcptr E, uint8_t stack);
 
void
jacobi_quartic_point_to_weierstrass_point (ec_point_ptr dst, ec_point_srcptr P, 
        ec_curve_srcptr E, uint8_t stack);
 
void
weierstrass_to_jacobi_quartic (ec_curve_ptr E_res, ec_curve_srcptr E, const bool determined, fe_ptr teta, uint8_t stack);
 
void
weierstrass_point_to_jacobi_quartic_point (ec_point_ptr dst, ec_point_srcptr P, 
        ec_curve_srcptr E, uint8_t stack);
        
void
edwards_to_weierstrass (ec_curve_ptr E_res, ec_curve_srcptr E, uint8_t stack);
 
void
edwards_point_to_weierstrass_point (ec_point_ptr dst, ec_point_srcptr P, 
        ec_curve_srcptr E, uint8_t stack);
 
void
weierstrass_to_edwards (ec_curve_ptr E_res, ec_curve_srcptr E, const uint8_t n, 
        fe_ptr alpha, fe_ptr beta, uint8_t stack);
 
void
weierstrass_point_to_edwards_point (ec_point_ptr dst, ec_point_srcptr P, 
        ec_curve_srcptr E, const uint8_t n, fe_ptr alpha, fe_ptr beta, uint8_t stack);
 
 
#endif