userapps/opensource/sshd/libtomcrypt/rsa_sys.c

   1 /* these are smaller routines written by Clay Culver.  They do the same function as the rsa_encrypt/decrypt
   2  * except that they are used to RSA encrypt/decrypt a single value and not a packet.
   3  */
   4 int rsa_encrypt_key(const unsigned char *inkey, unsigned long inlen,
   5                     unsigned char *outkey, unsigned long *outlen,
   6                     prng_state *prng, int wprng, rsa_key *key)
   7 {
   8    unsigned char rsa_in[4096], rsa_out[4096];
   9    unsigned long x, y, rsa_size;
  10    int err;
  11
  12    _ARGCHK(inkey != NULL);
  13    _ARGCHK(outkey != NULL);
  14    _ARGCHK(outlen != NULL);
  15    _ARGCHK(key != NULL);
  16
  17    /* only allow keys from 64 to 256 bits */
  18    if (inlen < 8 || inlen > 32) {
  19       return CRYPT_INVALID_ARG;
  20    }
  21
  22    /* are the parameters valid? */
  23    if ((err = prng_is_valid(wprng)) != CRYPT_OK) {
  24       return err;
  25    }
  26
  27    /* rsa_pad the symmetric key */
  28    y = (unsigned long)sizeof(rsa_in);
  29    if ((err = rsa_pad(inkey, inlen, rsa_in, &y, wprng, prng)) != CRYPT_OK) {
  30       return CRYPT_ERROR;
  31    }
  32
  33    /* rsa encrypt it */
  34    rsa_size = (unsigned long)sizeof(rsa_out);
  35    if ((err = rsa_exptmod(rsa_in, y, rsa_out, &rsa_size, PK_PUBLIC, key)) != CRYPT_OK) {
  36       return CRYPT_ERROR;
  37    }
  38
  39    /* check size */
  40    if (*outlen < (PACKET_SIZE+4+rsa_size)) {
  41       return CRYPT_BUFFER_OVERFLOW;
  42    }
  43
  44    /* now lets make the header */
  45    y = PACKET_SIZE;
  46
  47    /* store the size of the RSA value */
  48    STORE32L(rsa_size, (outkey+y));
  49    y += 4;
  50
  51    /* store the rsa value */
  52    for (x = 0; x < rsa_size; x++, y++) {
  53        outkey[y] = rsa_out[x];
  54    }
  55
  56    /* store header */
  57    packet_store_header(outkey, PACKET_SECT_RSA, PACKET_SUB_ENC_KEY);
  58
  59 #ifdef CLEAN_STACK
  60    /* clean up */
  61    zeromem(rsa_in, sizeof(rsa_in));
  62    zeromem(rsa_out, sizeof(rsa_out));
  63 #endif
  64    *outlen = y;
  65    return CRYPT_OK;
  66 }
  67
  68 int rsa_decrypt_key(const unsigned char *in, unsigned long inlen,
  69                           unsigned char *outkey, unsigned long *keylen,
  70                           rsa_key *key)
  71 {
  72    unsigned char sym_key[MAXBLOCKSIZE], rsa_out[4096];
  73    unsigned long x, y, z, i, rsa_size;
  74    int err;
  75
  76    _ARGCHK(in != NULL);
  77    _ARGCHK(outkey != NULL);
  78    _ARGCHK(keylen != NULL);
  79    _ARGCHK(key != NULL);
  80
  81    /* right key type? */
  82    if (key->type != PK_PRIVATE && key->type != PK_PRIVATE_OPTIMIZED) {
  83       return CRYPT_PK_NOT_PRIVATE;
  84    }
  85
  86    if (inlen < PACKET_SIZE+4) {
  87       return CRYPT_INVALID_PACKET;
  88    } else {
  89       inlen -= PACKET_SIZE+4;
  90    }
  91
  92    /* check the header */
  93    if ((err = packet_valid_header((unsigned char *)in, PACKET_SECT_RSA, PACKET_SUB_ENC_KEY)) != CRYPT_OK) {
  94       return err;
  95    }
  96
  97    /* grab length of the rsa key */
  98    y = PACKET_SIZE;
  99    LOAD32L(rsa_size, (in+y));
 100    if (inlen < rsa_size) {
 101       return CRYPT_INVALID_PACKET;
 102    } else {
 103       inlen -= rsa_size;
 104    }
 105    y += 4;
 106
 107    /* decrypt it */
 108    x = (unsigned long)sizeof(rsa_out);
 109    if ((err = rsa_exptmod(in+y, rsa_size, rsa_out, &x, PK_PRIVATE, key)) != CRYPT_OK) {
 110       return err;
 111    }
 112    y += rsa_size;
 113
 114    /* depad it */
 115    z = (unsigned long)sizeof(sym_key);
 116    if ((err = rsa_depad(rsa_out, x, sym_key, &z)) != CRYPT_OK) {
 117       return err;
 118    }
 119
 120    /* check size */
 121    if (*keylen < z) {
 122       return CRYPT_BUFFER_OVERFLOW;
 123    }
 124
 125    for (i = 0; i < z; i++) {
 126      outkey[i] = sym_key[i];
 127    }
 128
 129 #ifdef CLEAN_STACK
 130    /* clean up */
 131    zeromem(sym_key, sizeof(sym_key));
 132    zeromem(rsa_out, sizeof(rsa_out));
 133 #endif
 134    *keylen = z;
 135    return CRYPT_OK;
 136 }
 137
 138 int rsa_sign_hash(const unsigned char *in,  unsigned long inlen,
 139                         unsigned char *out, unsigned long *outlen,
 140                         rsa_key *key)
 141 {
 142    unsigned long rsa_size, x, y;
 143    unsigned char rsa_in[4096], rsa_out[4096];
 144    int err;
 145
 146    _ARGCHK(in != NULL);
 147    _ARGCHK(out != NULL);
 148    _ARGCHK(outlen != NULL);
 149    _ARGCHK(key != NULL);
 150
 151    /* reject nonsense sizes */
 152    if (inlen > MAXBLOCKSIZE || inlen < 16) {
 153       return CRYPT_INVALID_ARG;
 154    }
 155
 156    /* type of key? */
 157    if (key->type != PK_PRIVATE && key->type != PK_PRIVATE_OPTIMIZED) {
 158       return CRYPT_PK_NOT_PRIVATE;
 159    }
 160
 161    /* pad it */
 162    x = (unsigned long)sizeof(rsa_out);
 163    if ((err = rsa_signpad(in, inlen, rsa_out, &x)) != CRYPT_OK) {
 164       return err;
 165    }
 166
 167    /* sign it */
 168    rsa_size = (unsigned long)sizeof(rsa_in);
 169    if ((err = rsa_exptmod(rsa_out, x, rsa_in, &rsa_size, PK_PRIVATE, key)) != CRYPT_OK) {
 170       return err;
 171    }
 172
 173    /* check size */
 174    if (*outlen < (PACKET_SIZE+4+rsa_size)) {
 175       return CRYPT_BUFFER_OVERFLOW;
 176    }
 177
 178    /* now lets output the message */
 179    y = PACKET_SIZE;
 180
 181    /* output the len */
 182    STORE32L(rsa_size, (out+y));
 183    y += 4;
 184
 185    /* store the signature */
 186    for (x = 0; x < rsa_size; x++, y++) {
 187        out[y] = rsa_in[x];
 188    }
 189
 190    /* store header */
 191    packet_store_header(out, PACKET_SECT_RSA, PACKET_SUB_SIGNED);
 192
 193 #ifdef CLEAN_STACK
 194    /* clean up */
 195    zeromem(rsa_in, sizeof(rsa_in));
 196    zeromem(rsa_out, sizeof(rsa_out));
 197 #endif
 198    *outlen = y;
 199    return CRYPT_OK;
 200 }
 201
 202 int rsa_verify_hash(const unsigned char *sig, unsigned long siglen,
 203                     const unsigned char *md, int *stat, rsa_key *key)
 204 {
 205    unsigned long rsa_size, x, y, z;
 206    unsigned char rsa_in[4096], rsa_out[4096];
 207    int err;
 208
 209    _ARGCHK(sig != NULL);
 210    _ARGCHK(md != NULL);
 211    _ARGCHK(stat != NULL);
 212    _ARGCHK(key != NULL);
 213
 214    /* always be incorrect by default */
 215    *stat = 0;
 216
 217    if (siglen < PACKET_SIZE+4) {
 218       return CRYPT_INVALID_PACKET;
 219    } else {
 220       siglen -= PACKET_SIZE+4;
 221    }
 222
 223    /* verify header */
 224    if ((err = packet_valid_header((unsigned char *)sig, PACKET_SECT_RSA, PACKET_SUB_SIGNED)) != CRYPT_OK) {
 225       return err;
 226    }
 227
 228    /* get the len */
 229    y = PACKET_SIZE;
 230    LOAD32L(rsa_size, (sig+y));
 231    if (siglen < rsa_size) {
 232       return CRYPT_INVALID_PACKET;
 233    } else {
 234       siglen -= rsa_size;
 235    }
 236    y += 4;
 237
 238    /* exptmod it */
 239    x = (unsigned long)sizeof(rsa_out);
 240    if ((err = rsa_exptmod(sig+y, rsa_size, rsa_out, &x, PK_PUBLIC, key)) != CRYPT_OK) {
 241       return err;
 242    }
 243    y += rsa_size;
 244
 245    /* depad it */
 246    z = (unsigned long)sizeof(rsa_in);
 247    if ((err = rsa_signdepad(rsa_out, x, rsa_in, &z)) != CRYPT_OK) {
 248       return err;
 249    }
 250
 251    /* check? */
 252    if (memcmp(rsa_in, md, (size_t)z) == 0) {
 253       *stat = 1;
 254    }
 255
 256 #ifdef CLEAN_STACK
 257    zeromem(rsa_in, sizeof(rsa_in));
 258    zeromem(rsa_out, sizeof(rsa_out));
 259 #endif
 260    return CRYPT_OK;
 261 }
 262