lib/silccrypt/pkcs1.c

   1 /* $Id$ */
   2 /*
   3    PKCS #1 RSA wrapper.
   4
   5    Heavily modified to work under SILC, rewrote all interfaces, code that
   6    is not needed in SILC has been removed for good, and some code was fixed
   7    and changed.
   8
   9    For example, RSA_DecodeOneBlock was not used at all by Mozilla, however,
  10    I took this code in to use after doing some fixing (it had some bugs).
  11    Also, OAEP is removed totally for now.  I'm not sure whether OAEP could
  12    be used in the future with SILC but not for now.
  13
  14    This file also implements partial SILC PKCS API for RSA with PKCS #1.
  15    It is partial because all the other functions but encrypt, decrypt,
  16    sign and verify are common.
  17
  18    Note:
  19
  20    The mandatory PKCS #1 implementation in SILC must be compliant to either
  21    PKCS #1 version 1.5 or PKCS #1 version 2 with the following notes:
  22    The signature encoding is always in same format as the encryption
  23    encoding regardles of the PKCS #1 version.  The signature with
  24    appendix (with hash algorithm OID in the data) must not be used
  25    in the SILC.  Rationale for this is that there is no binding between
  26    the PKCS #1 OIDs and the hash algorithms used in the SILC protocol.
  27    Hence, the encoding is always in PKCS #1 version 1.5 format.
  28
  29    Any questions and comments regarding this modified version should be
  30    sent to priikone@poseidon.pspt.fi.
  31
  32    References: ftp://ftp.rsasecurity.com/pub/pkcs/ascii/pkcs-1v2.asc,
  33                ftp://ftp.rsasecurity.com/pub/pkcs/ascii/pkcs-1.asc,
  34                and RFC 2437.
  35
  36    Copyright notice: All code in this file, including the SILC PKCS API
  37    code that is not part of the Mozilla code, falls under the same license
  38    (MPL or GPL) found attached to this file, below.
  39 */
  40
  41 /*
  42  * PKCS#1 encoding and decoding functions.
  43  * This file is believed to contain no code licensed from other parties.
  44  *
  45  * The contents of this file are subject to the Mozilla Public
  46  * License Version 1.1 (the "License"); you may not use this file
  47  * except in compliance with the License. You may obtain a copy of
  48  * the License at http://www.mozilla.org/MPL/
  49  *
  50  * Software distributed under the License is distributed on an "AS
  51  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  52  * implied. See the License for the specific language governing
  53  * rights and limitations under the License.
  54  *
  55  * The Original Code is the Netscape security libraries.
  56  *
  57  * The Initial Developer of the Original Code is Netscape
  58  * Communications Corporation.  Portions created by Netscape are
  59  * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
  60  * Rights Reserved.
  61  *
  62  * Contributor(s):
  63  *
  64  * Alternatively, the contents of this file may be used under the
  65  * terms of the GNU General Public License Version 2 or later (the
  66  * "GPL"), in which case the provisions of the GPL are applicable
  67  * instead of those above.  If you wish to allow use of your
  68  * version of this file only under the terms of the GPL and not to
  69  * allow others to use your version of this file under the MPL,
  70  * indicate your decision by deleting the provisions above and
  71  * replace them with the notice and other provisions required by
  72  * the GPL.  If you do not delete the provisions above, a recipient
  73  * may use your version of this file under either the MPL or the
  74  * GPL.
  75  *
  76  * $Id$
  77  */
  78
  79 #include "silcincludes.h"
  80 #include "rsa.h"
  81
  82 #define RSA_BLOCK_MIN_PAD_LEN           8
  83 #define RSA_BLOCK_FIRST_OCTET           0x00
  84 #define RSA_BLOCK_PRIVATE0_PAD_OCTET    0x00
  85 #define RSA_BLOCK_PRIVATE_PAD_OCTET     0xff
  86 #define RSA_BLOCK_AFTER_PAD_OCTET       0x00
  87
  88 /*
  89  * RSA block types
  90  *
  91  * The actual values are important -- they are fixed, *not* arbitrary.
  92  * The explicit value assignments are not needed (because C would give
  93  * us those same values anyway) but are included as a reminder...
  94  */
  95 typedef enum {
  96     RSA_BlockPrivate0 = 0,      /* unused, really */
  97     RSA_BlockPrivate = 1,       /* pad for a private-key operation */
  98     RSA_BlockPublic = 2,        /* pad for a public-key operation */
  99     RSA_BlockTotal
 100 } RSA_BlockType;
 101
 102 /*
 103  * Format one block of data for public/private key encryption using
 104  * the rules defined in PKCS #1.
 105  */
 106 static unsigned char *
 107 RSA_FormatOneBlock(uint32 modulusLen, RSA_BlockType blockType,
 108                    unsigned char *data, uint32 data_len)
 109 {
 110     unsigned char *block;
 111     unsigned char *bp;
 112     int padLen;
 113     int i;
 114
 115     block = (unsigned char *) silc_malloc(modulusLen);
 116     if (block == NULL)
 117         return NULL;
 118
 119     bp = block;
 120
 121     /*
 122      * All RSA blocks start with two octets:
 123      *  0x00 || BlockType
 124      */
 125     *bp++ = RSA_BLOCK_FIRST_OCTET;
 126     *bp++ = (unsigned char) blockType;
 127
 128     switch (blockType) {
 129
 130       /*
 131        * Blocks intended for private-key operation.
 132        */
 133       case RSA_BlockPrivate0: /* essentially unused */
 134       case RSA_BlockPrivate:     /* preferred method */
 135         /*
 136          * 0x00 || BT || Pad || 0x00 || ActualData
 137          *   1      1   padLen    1      data_len
 138          * Pad is either all 0x00 or all 0xff bytes, depending on blockType.
 139          */
 140         padLen = modulusLen - data_len - 3;
 141         assert(padLen >= RSA_BLOCK_MIN_PAD_LEN);
 142         memset(bp,
 143                    blockType == RSA_BlockPrivate0
 144                         ? RSA_BLOCK_PRIVATE0_PAD_OCTET
 145                         : RSA_BLOCK_PRIVATE_PAD_OCTET,
 146                    padLen);
 147         bp += padLen;
 148         *bp++ = RSA_BLOCK_AFTER_PAD_OCTET;
 149         memcpy(bp, data, data_len);
 150         break;
 151
 152       /*
 153        * Blocks intended for public-key operation.
 154        */
 155       case RSA_BlockPublic:
 156         /*
 157          * 0x00 || BT || Pad || 0x00 || ActualData
 158          *   1      1   padLen    1      data_len
 159          * Pad is all non-zero random bytes.
 160          */
 161         padLen = modulusLen - data_len - 3;
 162         assert(padLen >= RSA_BLOCK_MIN_PAD_LEN);
 163         for (i = 0; i < padLen; i++) {
 164             /* Pad with non-zero random data. */
 165             do {
 166                 silc_rng_global_get_byte(bp + i);
 167             } while (bp[i] == RSA_BLOCK_AFTER_PAD_OCTET);
 168         }
 169         bp += padLen;
 170         *bp++ = RSA_BLOCK_AFTER_PAD_OCTET;
 171         memcpy(bp, data, data_len);
 172         break;
 173
 174       default:
 175         silc_free(block);
 176         return NULL;
 177     }
 178
 179     return block;
 180 }
 181
 182 static int
 183 RSA_FormatBlock(unsigned char **result, uint32 *result_len,
 184                 uint32 modulusLen,
 185                 RSA_BlockType blockType, unsigned char *data,
 186                 uint32 data_len)
 187 {
 188     /*
 189      * XXX For now assume that the data length fits in a single
 190      * XXX encryption block; the ASSERTs below force this.
 191      * XXX To fix it, each case will have to loop over chunks whose
 192      * XXX lengths satisfy the assertions, until all data is handled.
 193      * XXX (Unless RSA has more to say about how to handle data
 194      * XXX which does not fit in a single encryption block?)
 195      * XXX And I do not know what the result is supposed to be,
 196      * XXX so the interface to this function may need to change
 197      * XXX to allow for returning multiple blocks, if they are
 198      * XXX not wanted simply concatenated one after the other.
 199      */
 200
 201     switch (blockType) {
 202       case RSA_BlockPrivate0:
 203       case RSA_BlockPrivate:
 204       case RSA_BlockPublic:
 205         /*
 206          * 0x00 || BT || Pad || 0x00 || ActualData
 207          *
 208          * The "3" below is the first octet + the second octet + the 0x00
 209          * octet that always comes just before the ActualData.
 210          */
 211         assert(data_len <= (modulusLen - (3 + RSA_BLOCK_MIN_PAD_LEN)));
 212
 213         *result = RSA_FormatOneBlock(modulusLen, blockType, data, data_len);
 214         if (result == NULL) {
 215             *result_len = 0;
 216             return FALSE;
 217         }
 218         *result_len = modulusLen;
 219
 220         break;
 221
 222       default:
 223         *result = NULL;
 224         *result_len = 0;
 225         return FALSE;
 226     }
 227
 228     return TRUE;
 229 }
 230
 231 /*
 232  * Takes a formatted block and returns the data part.
 233  * (This is the inverse of RSA_FormatOneBlock().)
 234  * In some formats the start of the data is ambiguous;
 235  * if it is non-zero, expectedLen will disambiguate.
 236  *
 237  */
 238 unsigned char *
 239 RSA_DecodeOneBlock(unsigned char *data,
 240                    uint32 modulusLen,
 241                    uint32 expectedLen,
 242                    RSA_BlockType bt,
 243                    uint32 *pResultLen)
 244 {
 245     RSA_BlockType blockType;
 246     unsigned char *dp, *res;
 247     uint32 i, len = 0;
 248
 249     dp = data;
 250     if (dp[0] != RSA_BLOCK_FIRST_OCTET) {
 251         return NULL;
 252     }
 253
 254     blockType = (RSA_BlockType)dp[1];
 255     if (blockType != bt)
 256       return NULL;
 257
 258     dp += 2;
 259
 260     switch (blockType) {
 261       case RSA_BlockPrivate0:
 262         /* Ignored */
 263         res = (unsigned char *) silc_malloc(modulusLen);
 264         memcpy(res, data, modulusLen);
 265         break;
 266
 267       case RSA_BlockPrivate:
 268         for (i = 0; i < modulusLen; i++) {
 269             if (*dp++ != RSA_BLOCK_PRIVATE_PAD_OCTET)
 270                 break;
 271         }
 272         if (i == modulusLen)
 273             return NULL;
 274         len = modulusLen - (dp - data);
 275         res = (unsigned char *) silc_malloc(len);
 276         if (res == NULL) {
 277             return NULL;
 278         }
 279         memcpy(res, dp, len);
 280         break;
 281
 282       case RSA_BlockPublic:
 283         for (i = 0; i < modulusLen; i++) {
 284             if (*dp++ == RSA_BLOCK_AFTER_PAD_OCTET)
 285                 break;
 286         }
 287         if (i == modulusLen)
 288             return NULL;
 289         len = modulusLen - (dp - data);
 290         res = (unsigned char *) silc_malloc(len);
 291         if (res == NULL) {
 292             return NULL;
 293         }
 294         memcpy(res, dp, len);
 295         break;
 296
 297       default:
 298         return NULL;
 299     }
 300
 301     if (pResultLen)
 302       *pResultLen = len;
 303     return res;
 304 }
 305
 306 /*
 307  * SILC PKCS API for PKCS #1
 308  *
 309  * Note all the other PKCS API functions are used from the rsa.c.
 310  * See the definitions in rsa.c and in silcpkcs.c.
 311  */
 312
 313 SILC_PKCS_API_ENCRYPT(pkcs1)
 314 {
 315   RsaKey *key = (RsaKey *)context;
 316   SilcInt mp_tmp;
 317   SilcInt mp_dst;
 318   unsigned char *padded;
 319   uint32 padded_len, len = key->bits / 8;
 320
 321   /* Pad data */
 322   if (!RSA_FormatBlock(&padded, &padded_len, len,
 323                        RSA_BlockPublic, src, src_len))
 324     return FALSE;
 325
 326   silc_mp_init_set_ui(&mp_tmp, 0);
 327   silc_mp_init_set_ui(&mp_dst, 0);
 328
 329   /* Data to MP */
 330   silc_mp_bin2mp(padded, padded_len, &mp_tmp);
 331
 332   /* Encrypt */
 333   rsa_en_de_crypt(&mp_dst, &mp_tmp, &key->e, &key->n);
 334
 335   /* MP to data */
 336   silc_mp_mp2bin_noalloc(&mp_dst, dst, len);
 337   *dst_len = len;
 338
 339   memset(padded, 0, padded_len);
 340   silc_free(padded);
 341   silc_mp_clear(&mp_tmp);
 342   silc_mp_clear(&mp_dst);
 343
 344   return TRUE;
 345 }
 346
 347 SILC_PKCS_API_DECRYPT(pkcs1)
 348 {
 349   RsaKey *key = (RsaKey *)context;
 350   SilcInt mp_tmp;
 351   SilcInt mp_dst;
 352   unsigned char *padded, *unpadded;
 353   uint32 padded_len;
 354
 355   silc_mp_init_set_ui(&mp_tmp, 0);
 356   silc_mp_init_set_ui(&mp_dst, 0);
 357
 358   /* Data to MP */
 359   silc_mp_bin2mp(src, src_len, &mp_tmp);
 360
 361   /* Decrypt */
 362   rsa_en_de_crypt(&mp_dst, &mp_tmp, &key->d, &key->n);
 363
 364   /* MP to data */
 365   padded = silc_mp_mp2bin(&mp_dst, key->bits / 8, &padded_len);
 366
 367   /* Unpad data */
 368   unpadded = RSA_DecodeOneBlock(padded, padded_len, 0,
 369                                 RSA_BlockPublic, &padded_len);
 370   if (!unpadded) {
 371     memset(padded, 0, padded_len);
 372     silc_free(padded);
 373     silc_mp_clear(&mp_tmp);
 374     silc_mp_clear(&mp_dst);
 375     return FALSE;
 376   }
 377
 378   /* Copy to destination */
 379   memcpy(dst, unpadded, padded_len);
 380   *dst_len = padded_len;
 381
 382   memset(padded, 0, padded_len);
 383   memset(unpadded, 0, padded_len);
 384   silc_free(padded);
 385   silc_free(unpadded);
 386   silc_mp_clear(&mp_tmp);
 387   silc_mp_clear(&mp_dst);
 388
 389   return TRUE;
 390 }
 391
 392 SILC_PKCS_API_SIGN(pkcs1)
 393 {
 394   RsaKey *key = (RsaKey *)context;
 395   SilcInt mp_tmp;
 396   SilcInt mp_dst;
 397   unsigned char *padded;
 398   uint32 padded_len;
 399   uint32 len = key->bits / 8;
 400
 401   /* Pad data */
 402   if (!RSA_FormatBlock(&padded, &padded_len, len, RSA_BlockPrivate,
 403                        src, src_len))
 404     return FALSE;
 405
 406   silc_mp_init_set_ui(&mp_tmp, 0);
 407   silc_mp_init_set_ui(&mp_dst, 0);
 408
 409   /* Data to MP */
 410   silc_mp_bin2mp(padded, len, &mp_tmp);
 411
 412   /* Sign */
 413   rsa_en_de_crypt(&mp_dst, &mp_tmp, &key->d, &key->n);
 414
 415   /* MP to data */
 416   silc_mp_mp2bin_noalloc(&mp_dst, dst, len);
 417   *dst_len = len;
 418
 419   memset(padded, 0, padded_len);
 420   silc_free(padded);
 421   silc_mp_clear(&mp_tmp);
 422   silc_mp_clear(&mp_dst);
 423
 424   return TRUE;
 425 }
 426
 427 SILC_PKCS_API_VERIFY(pkcs1)
 428 {
 429   RsaKey *key = (RsaKey *)context;
 430   int ret = TRUE;
 431   SilcInt mp_tmp2;
 432   SilcInt mp_dst;
 433   unsigned char *verify, *unpadded;
 434   uint32 verify_len, len = key->bits / 8;
 435
 436   silc_mp_init_set_ui(&mp_tmp2, 0);
 437   silc_mp_init_set_ui(&mp_dst, 0);
 438
 439   /* Format the signature into MP int */
 440   silc_mp_bin2mp(signature, signature_len, &mp_tmp2);
 441
 442   /* Verify */
 443   rsa_en_de_crypt(&mp_dst, &mp_tmp2, &key->e, &key->n);
 444
 445   /* MP to data */
 446   verify = silc_mp_mp2bin(&mp_dst, len, &verify_len);
 447
 448   /* Unpad data */
 449   unpadded = RSA_DecodeOneBlock(verify, len, 0,
 450                                 RSA_BlockPrivate, &verify_len);
 451   if (!unpadded) {
 452     memset(verify, 0, verify_len);
 453     silc_free(verify);
 454     silc_mp_clear(&mp_tmp2);
 455     silc_mp_clear(&mp_dst);
 456     return FALSE;
 457   }
 458
 459   /* Compare */
 460   if (memcmp(data, unpadded, verify_len))
 461     ret = FALSE;
 462
 463   memset(verify, 0, verify_len);
 464   memset(unpadded, 0, verify_len);
 465   silc_free(verify);
 466   silc_free(unpadded);
 467   silc_mp_clear(&mp_tmp2);
 468   silc_mp_clear(&mp_dst);
 469
 470   return ret;
 471 }