ssflib/dep/cryptocore/source/middle/cc_ecdh.c

   1 /**
   2  * \file        ecdh.c
   3  * @brief       implementation of EC Diffie-Hellman Key Exchange Protocol
   4  *
   5  * - Copyright : Samsung Electronics CO.LTD.,
   6  *
   7  * \internal
   8  * Author : Jisoon Park
   9  * Dept : DRM Lab, Digital Media Laboratory
  10  * Creation date : 2006/11/27
  11  */
  12
  13 ////////////////////////////////////////////////////////////////////////////
  14 // Include Header Files
  15 ////////////////////////////////////////////////////////////////////////////
  16 #include "cc_ecdh.h"
  17 #include "cc_ANSI_x931.h"
  18 #include "cc_ecc.h"
  19
  20 ////////////////////////////////////////////////////////////////////////////
  21 // Functions
  22 ////////////////////////////////////////////////////////////////////////////
  23 /*
  24  * @fn          SDRM_generateDH1stPhaseKey
  25  * @brief       generate Xk and its Xv
  26  *
  27  * @param       crt                                     [in]crypto context
  28  * @param       pchXk                           [out]Generated Random Number
  29  * @param       pchXv                           [out]DH 1st phase value
  30  *
  31  * @return      CRYPTO_SUCCESS          if no error is occured
  32  */
  33 int SDRM_generateDH1stPhaseKey(CryptoCoreContainer *crt, cc_u8 *pchXk, cc_u8 *pchXv)
  34 {
  35         cc_u8 Si_ANSI_X9_31[SDRM_X931_SEED_SIZ];
  36
  37         SDRM_BIG_NUM    *BN_Xk, *BN_Temp;
  38         SDRM_EC_POINT   *kP;
  39         SDRM_ECC_CTX    *ctx;
  40         int i;
  41
  42         if ((crt == NULL) || (crt->ctx == NULL) || (crt->ctx->ecdhctx == NULL) || (pchXk == NULL) || (pchXv == NULL))
  43         {
  44                 return CRYPTO_NULL_POINTER;
  45         }
  46
  47         ctx = crt->ctx->ecdhctx;
  48
  49         for (i = 0; i < SDRM_X931_SEED_SIZ; i++)
  50         {
  51                 Si_ANSI_X9_31[i] = ((rand() << 16) + rand()) & 0xff;
  52         }
  53
  54
  55         BN_Temp = SDRM_BN_Init(crt->ctx->ecdsactx->uDimension >> 3);
  56         if (BN_Temp == NULL)
  57         {
  58                 return CRYPTO_MEMORY_ALLOC_FAIL;
  59         }
  60
  61         BN_Xk = SDRM_BN_Init(crt->ctx->ecdsactx->uDimension >> 3);
  62         if (BN_Xk == NULL)
  63         {
  64                 free(BN_Temp);
  65                 return CRYPTO_MEMORY_ALLOC_FAIL;
  66         }
  67
  68         SDRM_BN_Sub(BN_Temp, ctx->ECC_n, BN_One);
  69         do {
  70                 SDRM_RNG_X931(Si_ANSI_X9_31, crt->ctx->ecdsactx->uDimension, pchXk);
  71                 SDRM_OS2BN(pchXk, crt->ctx->ecdsactx->uDimension >> 3,  BN_Xk);
  72         }
  73         while ((SDRM_BN_Cmp(BN_Xk, BN_One) < 0) || (SDRM_BN_Cmp(BN_Xk, BN_Temp) > 0));
  74
  75         kP = SDRM_ECC_Init();
  76         if (kP == NULL)
  77         {
  78                 free(BN_Temp);
  79                 free(BN_Xk);
  80
  81                 return CRYPTO_MEMORY_ALLOC_FAIL;
  82         }
  83
  84         if (SDRM_CTX_EC_kP(ctx, kP, ctx->ECC_G, BN_Xk) == CRYPTO_MEMORY_ALLOC_FAIL)
  85         {
  86                 free(BN_Temp);
  87                 free(BN_Xk);
  88                 free(kP);
  89
  90                 return CRYPTO_MEMORY_ALLOC_FAIL;
  91         }
  92
  93         SDRM_BN2OS(kP->x, crt->ctx->ecdsactx->uDimension >> 3, pchXv);
  94         SDRM_BN2OS(kP->y, crt->ctx->ecdsactx->uDimension >> 3, pchXv + (crt->ctx->ecdsactx->uDimension >> 3));
  95
  96         free(BN_Temp);
  97         free(BN_Xk);
  98         free(kP);
  99
 100         return CRYPTO_SUCCESS;
 101 }
 102
 103 /*
 104  * @fn          SDRM_generateDHKey
 105  * @brief       genenrate auth key with Xk and Yv
 106  *
 107  * @param       crt                                     [in]crypto context
 108  * @param       pchXk                           [in]Generated Random Number
 109  * @param       pchYv                           [in]DH 1st phase value
 110  * @param       pchKauth                        [out]authentication key
 111  *
 112  * @return      CRYPTO_SUCCESS          if no error is occured
 113  */
 114 int SDRM_generateDHKey(CryptoCoreContainer *crt, cc_u8* pchXk, cc_u8* pchYv, cc_u8* pchKauth)
 115 {
 116         SDRM_BIG_NUM    *BN_Xk;
 117         SDRM_EC_POINT   *kP, *EC_Yv;
 118         SDRM_ECC_CTX    *ctx;
 119         int retVal;
 120
 121         if ((crt == NULL) || (crt->ctx == NULL) || (crt->ctx->ecdhctx == NULL) || (pchXk == NULL) || (pchYv == NULL) || (pchKauth == NULL))
 122         {
 123                 return CRYPTO_NULL_POINTER;
 124         }
 125
 126         ctx = crt->ctx->ecdhctx;
 127
 128         BN_Xk = SDRM_BN_Init(crt->ctx->ecdsactx->uDimension >> 3);
 129         if (BN_Xk == NULL)
 130         {
 131                 return CRYPTO_MEMORY_ALLOC_FAIL;
 132         }
 133
 134         retVal = SDRM_OS2BN(pchXk, crt->ctx->ecdsactx->uDimension >> 3, BN_Xk);
 135         if (retVal != CRYPTO_SUCCESS)
 136         {
 137                 free(BN_Xk);
 138                 return retVal;
 139         }
 140
 141         kP = SDRM_ECC_Init();
 142         if (kP == NULL)
 143         {
 144                 free(BN_Xk);
 145                 return CRYPTO_MEMORY_ALLOC_FAIL;
 146         }
 147
 148         EC_Yv = SDRM_ECC_Init();
 149         if (EC_Yv == NULL)
 150         {
 151                 free(BN_Xk);
 152                 free(kP);
 153
 154                 return CRYPTO_MEMORY_ALLOC_FAIL;
 155         }
 156
 157         SDRM_EC_CLR(EC_Yv);
 158         retVal = SDRM_OS2BN(pchYv, crt->ctx->ecdsactx->uDimension >> 3, EC_Yv->x);
 159         if (retVal != CRYPTO_SUCCESS)
 160         {
 161                 free(BN_Xk);
 162                 free(kP);
 163                 free(EC_Yv);
 164
 165                 return CRYPTO_MEMORY_ALLOC_FAIL;
 166         }
 167
 168         retVal = SDRM_OS2BN(pchYv + (crt->ctx->ecdsactx->uDimension >> 3), crt->ctx->ecdsactx->uDimension >> 3, EC_Yv->y);
 169         if (retVal != CRYPTO_SUCCESS)
 170         {
 171                 free(BN_Xk);
 172                 free(kP);
 173                 free(EC_Yv);
 174
 175                 return CRYPTO_MEMORY_ALLOC_FAIL;
 176         }
 177
 178         if (SDRM_CTX_EC_kP(ctx, kP, EC_Yv, BN_Xk) == CRYPTO_MEMORY_ALLOC_FAIL)
 179         {
 180                 free(BN_Xk);
 181                 free(kP);
 182                 free(EC_Yv);
 183
 184                 return CRYPTO_MEMORY_ALLOC_FAIL;
 185         }
 186
 187         retVal = SDRM_BN2OS(kP->x, crt->ctx->ecdsactx->uDimension >> 3, pchKauth);
 188         if (retVal != CRYPTO_SUCCESS)
 189         {
 190                 free(BN_Xk);
 191                 free(kP);
 192                 free(EC_Yv);
 193
 194                 return retVal;
 195         }
 196
 197         free(BN_Xk);
 198         free(kP);
 199         free(EC_Yv);
 200
 201         return CRYPTO_SUCCESS;
 202 }
 203
 204 /***************************** End of File *****************************/