pd.if.org Git - zpackage/blob - libtomcrypt/src/pk/pkcs1/pkcs_1_oaep_encode.c

   1 /* LibTomCrypt, modular cryptographic library -- Tom St Denis
   2  *
   3  * LibTomCrypt is a library that provides various cryptographic
   4  * algorithms in a highly modular and flexible manner.
   5  *
   6  * The library is free for all purposes without any express
   7  * guarantee it works.
   8  */
   9 #include "tomcrypt.h"
  10
  11 /**
  12   @file pkcs_1_oaep_encode.c
  13   OAEP Padding for PKCS #1, Tom St Denis
  14 */
  15
  16 #ifdef LTC_PKCS_1
  17
  18 /**
  19   PKCS #1 v2.00 OAEP encode
  20   @param msg             The data to encode
  21   @param msglen          The length of the data to encode (octets)
  22   @param lparam          A session or system parameter (can be NULL)
  23   @param lparamlen       The length of the lparam data
  24   @param modulus_bitlen  The bit length of the RSA modulus
  25   @param prng            An active PRNG state
  26   @param prng_idx        The index of the PRNG desired
  27   @param hash_idx        The index of the hash desired
  28   @param out             [out] The destination for the encoded data
  29   @param outlen          [in/out] The max size and resulting size of the encoded data
  30   @return CRYPT_OK if successful
  31 */
  32 int pkcs_1_oaep_encode(const unsigned char *msg,    unsigned long msglen,
  33                        const unsigned char *lparam, unsigned long lparamlen,
  34                              unsigned long modulus_bitlen, prng_state *prng,
  35                              int           prng_idx,         int  hash_idx,
  36                              unsigned char *out,    unsigned long *outlen)
  37 {
  38    unsigned char *DB, *seed, *mask;
  39    unsigned long hLen, x, y, modulus_len;
  40    int           err;
  41
  42    LTC_ARGCHK(msg    != NULL);
  43    LTC_ARGCHK(out    != NULL);
  44    LTC_ARGCHK(outlen != NULL);
  45
  46    /* test valid hash */
  47    if ((err = hash_is_valid(hash_idx)) != CRYPT_OK) {
  48       return err;
  49    }
  50
  51    /* valid prng */
  52    if ((err = prng_is_valid(prng_idx)) != CRYPT_OK) {
  53       return err;
  54    }
  55
  56    hLen        = hash_descriptor[hash_idx].hashsize;
  57    modulus_len = (modulus_bitlen >> 3) + (modulus_bitlen & 7 ? 1 : 0);
  58
  59    /* test message size */
  60    if ((2*hLen >= (modulus_len - 2)) || (msglen > (modulus_len - 2*hLen - 2))) {
  61       return CRYPT_PK_INVALID_SIZE;
  62    }
  63
  64    /* allocate ram for DB/mask/salt of size modulus_len */
  65    DB   = XMALLOC(modulus_len);
  66    mask = XMALLOC(modulus_len);
  67    seed = XMALLOC(hLen);
  68    if (DB == NULL || mask == NULL || seed == NULL) {
  69       if (DB != NULL) {
  70          XFREE(DB);
  71       }
  72       if (mask != NULL) {
  73          XFREE(mask);
  74       }
  75       if (seed != NULL) {
  76          XFREE(seed);
  77       }
  78       return CRYPT_MEM;
  79    }
  80
  81    /* get lhash */
  82    /* DB == lhash || PS || 0x01 || M, PS == k - mlen - 2hlen - 2 zeroes */
  83    x = modulus_len;
  84    if (lparam != NULL) {
  85       if ((err = hash_memory(hash_idx, lparam, lparamlen, DB, &x)) != CRYPT_OK) {
  86          goto LBL_ERR;
  87       }
  88    } else {
  89       /* can't pass hash_memory a NULL so use DB with zero length */
  90       if ((err = hash_memory(hash_idx, DB, 0, DB, &x)) != CRYPT_OK) {
  91          goto LBL_ERR;
  92       }
  93    }
  94
  95    /* append PS then 0x01 (to lhash)  */
  96    x = hLen;
  97    y = modulus_len - msglen - 2*hLen - 2;
  98    XMEMSET(DB+x, 0, y);
  99    x += y;
 100
 101    /* 0x01 byte */
 102    DB[x++] = 0x01;
 103
 104    /* message (length = msglen) */
 105    XMEMCPY(DB+x, msg, msglen);
 106    x += msglen;
 107
 108    /* now choose a random seed */
 109    if (prng_descriptor[prng_idx].read(seed, hLen, prng) != hLen) {
 110       err = CRYPT_ERROR_READPRNG;
 111       goto LBL_ERR;
 112    }
 113
 114    /* compute MGF1 of seed (k - hlen - 1) */
 115    if ((err = pkcs_1_mgf1(hash_idx, seed, hLen, mask, modulus_len - hLen - 1)) != CRYPT_OK) {
 116       goto LBL_ERR;
 117    }
 118
 119    /* xor against DB */
 120    for (y = 0; y < (modulus_len - hLen - 1); y++) {
 121        DB[y] ^= mask[y];
 122    }
 123
 124    /* compute MGF1 of maskedDB (hLen) */
 125    if ((err = pkcs_1_mgf1(hash_idx, DB, modulus_len - hLen - 1, mask, hLen)) != CRYPT_OK) {
 126       goto LBL_ERR;
 127    }
 128
 129    /* XOR against seed */
 130    for (y = 0; y < hLen; y++) {
 131       seed[y] ^= mask[y];
 132    }
 133
 134    /* create string of length modulus_len */
 135    if (*outlen < modulus_len) {
 136       *outlen = modulus_len;
 137       err = CRYPT_BUFFER_OVERFLOW;
 138       goto LBL_ERR;
 139    }
 140
 141    /* start output which is 0x00 || maskedSeed || maskedDB */
 142    x = 0;
 143    out[x++] = 0x00;
 144    XMEMCPY(out+x, seed, hLen);
 145    x += hLen;
 146    XMEMCPY(out+x, DB, modulus_len - hLen - 1);
 147    x += modulus_len - hLen - 1;
 148
 149    *outlen = x;
 150
 151    err = CRYPT_OK;
 152 LBL_ERR:
 153 #ifdef LTC_CLEAN_STACK
 154    zeromem(DB,   modulus_len);
 155    zeromem(seed, hLen);
 156    zeromem(mask, modulus_len);
 157 #endif
 158
 159    XFREE(seed);
 160    XFREE(mask);
 161    XFREE(DB);
 162
 163    return err;
 164 }
 165
 166 #endif /* LTC_PKCS_1 */
 167
 168
 169 /* ref:         $Format:%D$ */
 170 /* git commit:  $Format:%H$ */
 171 /* commit time: $Format:%ai$ */