ssflib/dep/cryptocore/include/base/cc_ecc.h

   1 /**
   2  * \file        ecc.h
   3  * @brief       ecc library based on big number
   4  *
   5  * - Copyright : Samsung Electronics CO.LTD.,
   6  *
   7  * \internal
   8  * Author : Jiyoung Moon
   9  * Dept : DRM Lab, Digital Media Laboratory
  10  * Creation date : 2006/05/03
  11  * Note : optimized by Jiyoung Moon & Jisoon Park, August,2006.
  12  */
  13
  14
  15 #ifndef _CCECC_H
  16 #define _CCECC_H
  17
  18 ////////////////////////////////////////////////////////////////////////////
  19 // Include Header Files
  20 ////////////////////////////////////////////////////////////////////////////
  21 #include "CryptoCore.h"
  22 #include "cc_bignum.h"
  23 #include "cc_sha1.h"
  24
  25 ////////////////////////////////////////////////////////////////////////////
  26 // Constants
  27 ////////////////////////////////////////////////////////////////////////////
  28 #define SDRM_MAX_DIMENSION_ECC  256
  29 #define SDRM_SIZE_OF_ECC_KEY    (SDRM_SIZE_OF_DWORD * SDRM_ECC_BN_BUFSIZE)
  30
  31 ////////////////////////////////////////////////////////////////////////////
  32 // Macros for ECC
  33 ////////////////////////////////////////////////////////////////////////////
  34 #define SDRM_EC_FREE(X)                 if (X) {free(X);}
  35
  36 #define SDRM_EC_SET_ZERO(A)             do {                                                                                                                                                                            \
  37                                                                         memset((A), 0, sizeof(SDRM_EC_POINT) + SDRM_ECC_ALLOC_SIZE * 5);                                                \
  38                                                                         (A)->IsInfinity = 0;                                                                                                                                    \
  39                                                                         A->x  = SDRM_BN_Alloc((cc_u8*)A     + sizeof(SDRM_EC_POINT), SDRM_ECC_BN_BUFSIZE);              \
  40                                                                         A->y  = SDRM_BN_Alloc((cc_u8*)A->x  + SDRM_ECC_ALLOC_SIZE,   SDRM_ECC_BN_BUFSIZE);              \
  41                                                                         A->z  = SDRM_BN_Alloc((cc_u8*)A->y  + SDRM_ECC_ALLOC_SIZE,   SDRM_ECC_BN_BUFSIZE);              \
  42                                                                         A->z2 = SDRM_BN_Alloc((cc_u8*)A->z  + SDRM_ECC_ALLOC_SIZE,   SDRM_ECC_BN_BUFSIZE);              \
  43                                                                         A->z3 = SDRM_BN_Alloc((cc_u8*)A->z2 + SDRM_ECC_ALLOC_SIZE,   SDRM_ECC_BN_BUFSIZE);              \
  44                                                                 } while(0)
  45
  46 #define SDRM_EC_CLR(A)                  SDRM_EC_SET_ZERO(A)
  47
  48 #define SDRM_ECC_Clr(A)         do {                                                                                                    \
  49                                                                         SDRM_BN_Clr((A)->ECC_p);                                                \
  50                                                                         SDRM_BN_Clr((A)->ECC_A);                                                \
  51                                                                         SDRM_BN_Clr((A)->ECC_b);                                                \
  52                                                                         SDRM_BN_Clr((A)->ECC_n);                                                \
  53                                                                         SDRM_BN_Clr((A)->PRIV_KEY);                                             \
  54                                                                         EC_Clr((A)->ECC_G);                                                             \
  55                                                                         EC_Clr((A)->PUBLIC_KEY);                                                \
  56                                                                 } while(0)
  57
  58 #define SDRM_ECC_FREE(X)                do {                                                                                                                            \
  59                                                                         if ((X)) {                                                                                                              \
  60                                                                                 SDRM_BN_FREE(X->ECC_a);                                                                         \
  61                                                                                 SDRM_EC_FREE(X->ECC_G);                                                                         \
  62                                                                                 SDRM_EC_FREE(X->PUBLIC_KEY);                                                            \
  63                                                                                 SDRM_EC_FREE(X);                                                                                        \
  64                                                                         }                                                                                                                               \
  65                                                                 } while(0)
  66
  67 #define SDRM_EC_COPY(A, B)              do {                                                                                                                            \
  68                                                                         (A)->IsInfinity = (B)->IsInfinity;                                                              \
  69                                                                         SDRM_BN_Copy((A)->x, (B)->x);                                                                   \
  70                                                                         SDRM_BN_Copy((A)->y, (B)->y);                                                                   \
  71                                                                         SDRM_BN_Copy((A)->z, (B)->z);                                                                   \
  72                                                                         SDRM_BN_Copy((A)->z2, (B)->z2);                                                                 \
  73                                                                         SDRM_BN_Copy((A)->z3, (B)->z3);                                                                 \
  74                                                                 } while(0)
  75
  76
  77 ////////////////////////////////////////////////////////////////////////////
  78 // Function Prototypes
  79 ////////////////////////////////////////////////////////////////////////////
  80
  81 #ifdef __cplusplus
  82 extern "C" {
  83 #endif
  84
  85 ///// ECC º¸Á¶ÇÔ¼ö
  86 /*
  87  * @fn          SDRM_ECC_Init
  88  * @brief       return SDRM_EC_POINT structure
  89  *
  90  * @return      address of allocate structure
  91  * \n           NULL    if memory allocation is failed
  92  */
  93 SDRM_EC_POINT *SDRM_ECC_Init(void);
  94
  95 /*
  96  * @fn          SDRM_CURVE_Init
  97  * @brief       return SDRM_ECC_CTX structure
  98  *
  99  * @return      address of allocate structure
 100  * \n           NULL    if memory allocation is failed
 101  */
 102 SDRM_ECC_CTX *SDRM_CURVE_Init(void);
 103
 104 ///// ECC Point ¿¬»êÇÔ¼ö
 105 /*
 106  * @fn          SDRM_CTX_EC_Chain
 107  * @brief       Chain ÇÔ¼ö
 108  *
 109  * signed window method :       size of window = 4
 110  * chain for addition/subtraction of k Using sliding window method
 111  * @param       chain                                           [out]destination
 112  * @param       L_Src                                           [in]byte-length of chain
 113  * @param       Len_Src                                         [in]number of doubling in chain
 114  * @param       k                                                       [in]source
 115  * @param       window_size                                     [in]size of window
 116  *
 117  * @return      CRYPTO_SUCCESS                          if no error is occured
 118  * \n           CRYPTO_INVALID_ARGUMENT         if given value is incorrect
 119  */
 120 int SDRM_CTX_EC_Chain(signed char *chain, cc_u32 *L_Src, cc_u32 *Len_Src, SDRM_BIG_NUM *k, int window_size);
 121
 122 /*
 123  * @fn          SDRM_CTX_EC_kP
 124  * @brief       get EC_Dst = kP by Montgomery Method
 125  *
 126  * @param       ctx                                                     [in]ecc context
 127  * @param       EC_Dst                                          [out]destination
 128  * @param       EC_Src                                          [in]first element(P)
 129  * @param       k                                                       [in]second element(k)
 130  *
 131  * @return      CRYPTO_SUCCESS                          if no error is occured
 132  * \n           CRYPTO_INVALID_ARGUMENT         if the arguemnt represents a minus value
 133  * \n           CRYPTO_MEMORY_ALLOC_FAIL        if memory allocation is failed
 134  * \n           CRYPTO_INFINITY_INPUT           if the argument is a infinity value
 135  */
 136 int SDRM_CTX_EC_kP(SDRM_ECC_CTX *ctx, SDRM_EC_POINT* EC_Dst, SDRM_EC_POINT *EC_Src, SDRM_BIG_NUM *k);
 137
 138 /*
 139  * @fn          SDRM_CTX_EC_2kP
 140  * @brief       get EC_Dst = k1*C1 + k2*C2
 141  *
 142  * @param       ctx                                                     [in]ecc context
 143  * @param       EC_Dst                                          [out]destination
 144  * @param       k1                                                      [in]first element(k1)
 145  * @param       EC_Src1                                         [in]second element(C1)
 146  * @param       k2                                                      [in]third element(k2)
 147  * @param       EC_Src2                                         [in]fourth element(C2)
 148  *
 149  * @return      CRYPTO_SUCCESS                          if no error is occured
 150  * \n           CRYPTO_INVALID_ARGUMENT         if the arguemnt represents a minus value
 151  * \n           CRYPTO_MEMORY_ALLOC_FAIL        if memory allocation is failed
 152  * \n           CRYPTO_INFINITY_INPUT           if the argument is a infinity value
 153  */
 154 int SDRM_CTX_EC_2kP(SDRM_ECC_CTX *ctx, SDRM_EC_POINT *EC_Dst, SDRM_BIG_NUM *k1, SDRM_EC_POINT *EC_Src1, SDRM_BIG_NUM *k2, SDRM_EC_POINT *EC_Src2);
 155
 156 ///// Functions of Converting Coordingate
 157 /*
 158  * @fn          SDRM_Mont_Jm2Jc
 159  * @brief       ÁÂÇ¥º¯È¯ 1
 160  *                      Modified Jacobian  =>  Chundnovsky Jacobian
 161  *                      (A->y)  <= (A->y)/2
 162  *                      (A->z2) <= (A->z)^2
 163  *                      (A->z3) <= (A->z)^3
 164  *
 165  * @param       EC_Dst                  [out]destination
 166  * @param       new_a                   [in]first element
 167  * @param       new_b                   [in]second element
 168  * @param       Mont                    [in]montgomery context
 169  *
 170  * @return      CRYPTO_SUCCESS  if no error is occured
 171  * \n           CRYPTO_ERROR    if evaluation is failed
 172  */
 173 int SDRM_Mont_Jm2Jc(SDRM_EC_POINT *EC_Dst, SDRM_BIG_NUM *new_a, SDRM_BIG_NUM *new_b, SDRM_BIG_MONT *Mont);
 174
 175 /*
 176  * @fn          SDRM_Mont_Jc2Jm
 177  * @brief       ÁÂÇ¥º¯È¯ 2
 178  *                      Chundnovsky Jacobian  =>  Modified Jacobian
 179  *                      (A->y)  <= 2*(A->y)
 180  *                      (A->z2) <= new_a*(A->z)^4
 181  * @param       A                               [out]destination
 182  * @param       new_a                   [in]first element
 183  * @param       new_b                   [in]second element
 184  * @param       Mont                    [in]montgomery context
 185  *
 186  * @return      CRYPTO_SUCCESS  if no error is occured
 187  * \n           CRYPTO_ERROR    if evaluation is failed
 188  */
 189 int SDRM_Mont_Jc2Jm(SDRM_EC_POINT *A, SDRM_BIG_NUM *new_a, SDRM_BIG_NUM *new_b, SDRM_BIG_MONT *Mont);
 190
 191 /*
 192  * @fn          SDRM_CTX_EC_Add_Jc
 193  * @brief       Chundnovsky Jacobian coordinate
 194  *                      using montgomery (A = B + C)
 195  *
 196  * @param       EC_Dst                                          [out]destination(A)
 197  * @param       EC_Src1                                         [in]first element(B)
 198  * @param       EC_Src2                                         [in]second element(C)
 199  * @param       new_a                                           [in]ECC_A's montgomery value
 200  * @param       new_b                                           [in]ECC_B's montgomery value
 201  * @param       Mont                                            [in]montgomery context
 202  *
 203  * @return      CRYPTO_SUCCESS                          if no error is occured
 204  * \n           CRYPTO_ERROR                            if evaluation is failed
 205  * \n           CRYPTO_MEMORY_ALLOC_FAIL        if memory allocation is failed
 206  */
 207 int SDRM_CTX_EC_Add_Jc(SDRM_EC_POINT* EC_Dst, SDRM_EC_POINT *EC_Src1, SDRM_EC_POINT *EC_Src2, SDRM_BIG_NUM *new_a, SDRM_BIG_NUM *new_b, SDRM_BIG_MONT *Mont);
 208
 209 /*
 210  * @fn          SDRM_CTX_EC_Double_Jc
 211  * @brief       Chundnovsky Jacobian coordinate
 212  *                      montgomery (A = 2B)
 213  *
 214  * @param       EC_Dst                                          [out]destination(A)
 215  * @param       EC_Src1                                         [in]first element(B)
 216  * @param       new_a                                           [in]ECC_A's montgomery value
 217  * @param       new_b                                           [in]ECC_B's montgomery value
 218  * @param       Mont                                            [in]montgomery context
 219  *
 220  * @return      CRYPTO_SUCCESS                          if no error is occured
 221  * \n           CRYPTO_ERROR                            if evaluation is failed
 222  * \n           CRYPTO_MEMORY_ALLOC_FAIL        if memory allocation is failed
 223  */
 224 int SDRM_CTX_EC_Double_Jc(SDRM_EC_POINT *EC_Dst, SDRM_EC_POINT *EC_Src1, SDRM_BIG_NUM *new_a, SDRM_BIG_NUM *new_b, SDRM_BIG_MONT *Mont);
 225
 226 /*
 227  * @fn          SDRM_CTX_EC_Double_Jm
 228  * @brief       Modified Jacobian coordinate
 229  *                      montgomery (A = 2B)
 230  *
 231  * @param       EC_Dst                                          [out]destination(A)
 232  * @param       EC_Src1                                         [in]first element(B)
 233  * @param       new_a                                           [in]ECC_A's montgomery value
 234  * @param       new_b                                           [in]ECC_B's montgomery value
 235  * @param       Mont                                            [in]montgomery context
 236  *
 237  * @return      CRYPTO_SUCCESS                          if no error is occured
 238  * \n           CRYPTO_ERROR                            if evaluation is failed
 239  * \n           CRYPTO_MEMORY_ALLOC_FAIL        if memory allocation is failed
 240  */
 241 int SDRM_CTX_EC_Double_Jm(SDRM_EC_POINT *EC_Dst, SDRM_EC_POINT *EC_Src1, SDRM_BIG_NUM *new_a, SDRM_BIG_NUM *new_b, SDRM_BIG_MONT *Mont);
 242
 243 #ifdef __cplusplus
 244 }
 245 #endif
 246
 247 #endif // _ECC_H
 248
 249 /***************************** End of File *****************************/