openssl.c

   1 /* Copyright (C) 2005 Andre Noll <maan@tuebingen.mpg.de>, see file COPYING. */
   2
   3 /** \file openssl.c Openssl-based encryption/decryption routines. */
   4
   5 #include <regex.h>
   6 #include <sys/types.h>
   7 #include <sys/socket.h>
   8 #include <openssl/rand.h>
   9 #include <openssl/err.h>
  10 #include <openssl/pem.h>
  11 #include <openssl/sha.h>
  12 #include <openssl/bn.h>
  13 #include <openssl/aes.h>
  14 #include <openssl/evp.h>
  15
  16 #include "para.h"
  17 #include "error.h"
  18 #include "string.h"
  19 #include "crypt.h"
  20 #include "crypt_backend.h"
  21 #include "portable_io.h"
  22
  23 struct asymmetric_key {
  24         RSA *rsa;
  25 };
  26
  27 void get_random_bytes_or_die(unsigned char *buf, int num)
  28 {
  29         unsigned long err;
  30
  31         /* RAND_bytes() returns 1 on success, 0 otherwise. */
  32         if (RAND_bytes(buf, num) == 1)
  33                 return;
  34         err = ERR_get_error();
  35         PARA_EMERG_LOG("%s\n", ERR_reason_error_string(err));
  36         exit(EXIT_FAILURE);
  37 }
  38
  39 /*
  40  * Read 64 bytes from /dev/urandom and add them to the SSL PRNG. Then seed the
  41  * PRNG used by random(3) with a random seed obtained from SSL.
  42  */
  43 void crypt_init(void)
  44 {
  45         int seed, ret = RAND_load_file("/dev/urandom", 64);
  46
  47         if (ret != 64) {
  48                 PARA_EMERG_LOG("could not seed PRNG (ret = %d)\n", ret);
  49                 exit(EXIT_FAILURE);
  50         }
  51         get_random_bytes_or_die((unsigned char *)&seed, sizeof(seed));
  52         srandom(seed);
  53 }
  54
  55 void crypt_shutdown(void)
  56 {
  57 #ifdef HAVE_CRYPTO_CLEANUP_ALL_EX_DATA
  58         CRYPTO_cleanup_all_ex_data();
  59 #endif
  60 #ifdef HAVE_OPENSSL_THREAD_STOP /* openssl-1.1 or later */
  61         OPENSSL_thread_stop();
  62 #else /* openssl-1.0 */
  63         ERR_remove_thread_state(NULL);
  64 #endif
  65         EVP_cleanup();
  66 }
  67
  68 /*
  69  * The public key loading functions below were inspired by corresponding code
  70  * of openssh-5.2p1, Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo,
  71  * Finland. However, not much of the original code remains.
  72  */
  73
  74 static int read_bignum(const unsigned char *buf, size_t len, BIGNUM **result)
  75 {
  76         const unsigned char *p = buf, *end = buf + len;
  77         uint32_t bnsize;
  78         BIGNUM *bn;
  79
  80         if (p + 4 < p)
  81                 return -E_BIGNUM;
  82         if (p + 4 > end)
  83                 return -E_BIGNUM;
  84         bnsize = read_u32_be(p);
  85         PARA_DEBUG_LOG("bnsize: %u\n", bnsize);
  86         p += 4;
  87         if (p + bnsize < p)
  88                 return -E_BIGNUM;
  89         if (p + bnsize > end)
  90                 return -E_BIGNUM;
  91         if (bnsize > 8192)
  92                 return -E_BIGNUM;
  93         bn = BN_bin2bn(p, bnsize, NULL);
  94         if (!bn)
  95                 return -E_BIGNUM;
  96         *result = bn;
  97         return bnsize + 4;
  98 }
  99
 100 static int read_public_key(const unsigned char *blob, int blen, RSA **result)
 101 {
 102         int ret;
 103         RSA *rsa;
 104         BIGNUM *n, *e;
 105         const unsigned char *p = blob, *end = blob + blen;
 106
 107         rsa = RSA_new();
 108         if (!rsa)
 109                 return -E_BIGNUM;
 110         ret = read_bignum(p, end - p, &e);
 111         if (ret < 0)
 112                 goto free_rsa;
 113         p += ret;
 114         ret = read_bignum(p, end - p, &n);
 115         if (ret < 0)
 116                 goto free_e;
 117 #ifdef HAVE_RSA_SET0_KEY
 118         RSA_set0_key(rsa, n, e, NULL);
 119 #else
 120         rsa->n = n;
 121         rsa->e = e;
 122 #endif
 123         *result = rsa;
 124         return 1;
 125 free_e:
 126         BN_free(e);
 127 free_rsa:
 128         RSA_free(rsa);
 129         return ret;
 130 }
 131
 132 static int read_pem_private_key(const char *path, RSA **rsa)
 133 {
 134         EVP_PKEY *pkey;
 135         BIO *bio = BIO_new(BIO_s_file());
 136
 137         *rsa = NULL;
 138         if (!bio)
 139                 return -E_PRIVATE_KEY;
 140         if (BIO_read_filename(bio, path) <= 0)
 141                 goto bio_free;
 142         pkey = PEM_read_bio_PrivateKey(bio, NULL, NULL, NULL);
 143         if (!pkey)
 144                 goto bio_free;
 145         *rsa = EVP_PKEY_get1_RSA(pkey);
 146         EVP_PKEY_free(pkey);
 147 bio_free:
 148         BIO_free(bio);
 149         return *rsa? RSA_size(*rsa) : -E_PRIVATE_KEY;
 150 }
 151
 152 static int read_openssh_private_key(const unsigned char *blob,
 153                 const unsigned char *end, RSA **result)
 154 {
 155         int ret;
 156         RSA *rsa;
 157         BN_CTX *ctx;
 158         BIGNUM *n, *e, *d, *iqmp, *p, *q; /* stored in the key file */
 159         BIGNUM *dmp1, *dmq1; /* these will be computed */
 160         BIGNUM *tmp;
 161         const unsigned char *cp = blob;
 162
 163         rsa = RSA_new();
 164         if (!rsa)
 165                 return -E_BIGNUM;
 166         ret = -E_BIGNUM;
 167         tmp = BN_new();
 168         if (!tmp)
 169                 goto free_rsa;
 170         ctx = BN_CTX_new();
 171         if (!ctx)
 172                 goto free_tmp;
 173         dmp1 = BN_new();
 174         if (!dmp1)
 175                 goto free_ctx;
 176         dmq1 = BN_new();
 177         if (!dmq1)
 178                 goto free_dmp1;
 179         ret = read_bignum(cp, end - cp, &n);
 180         if (ret < 0)
 181                 goto free_dmq1;
 182         cp += ret;
 183         ret = read_bignum(cp, end - cp, &e);
 184         if (ret < 0)
 185                 goto free_n;
 186         cp += ret;
 187         ret = read_bignum(cp, end - cp, &d);
 188         if (ret < 0)
 189                 goto free_e;
 190         cp += ret;
 191         ret = read_bignum(cp, end - cp, &iqmp);
 192         if (ret < 0)
 193                 goto free_d;
 194         cp += ret;
 195         ret = read_bignum(cp, end - cp, &p);
 196         if (ret < 0)
 197                 goto free_iqmp;
 198         cp += ret;
 199         ret = read_bignum(cp, end - cp, &q);
 200         if (ret < 0)
 201                 goto free_p;
 202         ret = -E_BIGNUM;
 203         if (!BN_sub(tmp, q, BN_value_one()))
 204                 goto free_q;
 205         if (!BN_mod(dmp1, d, tmp, ctx))
 206                 goto free_q;
 207         if (!BN_sub(tmp, q, BN_value_one()))
 208                 goto free_q;
 209         if (!BN_mod(dmq1, d, tmp, ctx))
 210                 goto free_q;
 211 #ifdef HAVE_RSA_SET0_KEY
 212         RSA_set0_key(rsa, n, e, d);
 213         RSA_set0_factors(rsa, p, q);
 214         RSA_set0_crt_params(rsa, dmp1, dmq1, iqmp);
 215 #else
 216         rsa->n = n;
 217         rsa->e = e;
 218         rsa->d = d;
 219         rsa->iqmp = iqmp;
 220         rsa->p = p;
 221         rsa->q = q;
 222         rsa->dmp1 = dmp1;
 223         rsa->dmq1 = dmq1;
 224 #endif
 225         *result = rsa;
 226         ret = 1;
 227         goto free_ctx;
 228 free_q:
 229         BN_clear_free(q);
 230 free_p:
 231         BN_clear_free(p);
 232 free_iqmp:
 233         BN_clear_free(iqmp);
 234 free_d:
 235         BN_clear_free(d);
 236 free_e:
 237         BN_free(e);
 238 free_n:
 239         BN_free(n);
 240 free_dmq1:
 241         BN_clear_free(dmq1);
 242 free_dmp1:
 243         BN_clear_free(dmp1);
 244 free_ctx:
 245         BN_CTX_free(ctx);
 246 free_tmp:
 247         BN_clear_free(tmp);
 248 free_rsa:
 249         if (ret < 0)
 250                 RSA_free(rsa);
 251         return ret;
 252 }
 253
 254 static int get_private_key(const char *path, RSA **rsa)
 255 {
 256         int ret;
 257         unsigned char *blob, *end;
 258         size_t blob_size;
 259
 260         *rsa = NULL;
 261         ret = decode_private_key(path, &blob, &blob_size);
 262         if (ret < 0)
 263                 return ret;
 264         end = blob + blob_size;
 265         if (ret == PKT_OPENSSH) {
 266                 ret = find_openssh_bignum_offset(blob, blob_size);
 267                 if (ret < 0)
 268                         goto free_blob;
 269                 PARA_INFO_LOG("reading RSA params at offset %d\n", ret);
 270                 ret = read_openssh_private_key(blob + ret, end, rsa);
 271         } else
 272                 ret = read_pem_private_key(path, rsa);
 273 free_blob:
 274         free(blob);
 275         return ret;
 276 }
 277
 278 int apc_get_pubkey(const char *key_file, struct asymmetric_key **result)
 279 {
 280         unsigned char *blob;
 281         size_t decoded_size;
 282         int ret;
 283         struct asymmetric_key *pub = alloc(sizeof(*pub));
 284
 285         ret = decode_public_key(key_file, &blob, &decoded_size);
 286         if (ret < 0)
 287                 goto out;
 288         ret = read_public_key(blob + ret, decoded_size - ret, &pub->rsa);
 289         if (ret < 0)
 290                 goto free_blob;
 291         ret = RSA_size(pub->rsa);
 292         assert(ret > 0);
 293         *result = pub;
 294 free_blob:
 295         free(blob);
 296 out:
 297         if (ret < 0) {
 298                 free(pub);
 299                 *result = NULL;
 300                 PARA_ERROR_LOG("can not load key %s\n", key_file);
 301         }
 302         return ret;
 303 }
 304
 305 void apc_free_pubkey(struct asymmetric_key *pub)
 306 {
 307         if (!pub)
 308                 return;
 309         RSA_free(pub->rsa);
 310         free(pub);
 311 }
 312
 313 int apc_priv_decrypt(const char *key_file, unsigned char *outbuf,
 314                 unsigned char *inbuf, int inlen)
 315 {
 316         struct asymmetric_key *priv;
 317         int ret;
 318
 319         ret = check_private_key_file(key_file);
 320         if (ret < 0)
 321                 return ret;
 322         if (inlen < 0)
 323                 return -E_RSA;
 324         priv = alloc(sizeof(*priv));
 325         ret = get_private_key(key_file, &priv->rsa);
 326         if (ret < 0) {
 327                 free(priv);
 328                 return ret;
 329         }
 330         /*
 331          * RSA is vulnerable to timing attacks. Generate a random blinding
 332          * factor to protect against this kind of attack.
 333          */
 334         ret = -E_BLINDING;
 335         if (RSA_blinding_on(priv->rsa, NULL) == 0)
 336                 goto out;
 337         ret = RSA_private_decrypt(inlen, inbuf, outbuf, priv->rsa,
 338                 RSA_PKCS1_OAEP_PADDING);
 339         RSA_blinding_off(priv->rsa);
 340         if (ret <= 0)
 341                 ret = -E_DECRYPT;
 342 out:
 343         RSA_free(priv->rsa);
 344         free(priv);
 345         return ret;
 346 }
 347
 348 int apc_pub_encrypt(struct asymmetric_key *pub, unsigned char *inbuf,
 349                 unsigned len, unsigned char *outbuf)
 350 {
 351         int ret, flen = len; /* RSA_public_encrypt expects a signed int */
 352
 353         if (flen < 0)
 354                 return -E_ENCRYPT;
 355         ret = RSA_public_encrypt(flen, inbuf, outbuf, pub->rsa,
 356                 RSA_PKCS1_OAEP_PADDING);
 357         return ret < 0? -E_ENCRYPT : ret;
 358 }
 359
 360 struct stream_cipher {
 361         EVP_CIPHER_CTX *aes;
 362 };
 363
 364 struct stream_cipher *sc_new(const unsigned char *data, int len)
 365 {
 366         struct stream_cipher *sc = alloc(sizeof(*sc));
 367
 368         assert(len >= 2 * AES_CRT128_BLOCK_SIZE);
 369         sc->aes = EVP_CIPHER_CTX_new();
 370         EVP_EncryptInit_ex(sc->aes, EVP_aes_128_ctr(), NULL, data,
 371                 data + AES_CRT128_BLOCK_SIZE);
 372         return sc;
 373 }
 374
 375 void sc_free(struct stream_cipher *sc)
 376 {
 377         if (!sc)
 378                 return;
 379         EVP_CIPHER_CTX_free(sc->aes);
 380         free(sc);
 381 }
 382
 383 static void aes_ctr128_crypt(EVP_CIPHER_CTX *ctx, struct iovec *src,
 384                 struct iovec *dst)
 385 {
 386         int ret, inlen = src->iov_len, outlen, tmplen;
 387
 388         *dst = (typeof(*dst)) {
 389                 /* Add one for the terminating zero byte. */
 390                 .iov_base = alloc(inlen + 1),
 391                 .iov_len = inlen
 392         };
 393         ret = EVP_EncryptUpdate(ctx, dst->iov_base, &outlen, src->iov_base, inlen);
 394         assert(ret != 0);
 395         ret = EVP_EncryptFinal_ex(ctx, dst->iov_base + outlen, &tmplen);
 396         assert(ret != 0);
 397         outlen += tmplen;
 398         ((char *)dst->iov_base)[outlen] = '\0';
 399         dst->iov_len = outlen;
 400 }
 401
 402 void sc_crypt(struct stream_cipher *sc, struct iovec *src, struct iovec *dst)
 403 {
 404         return aes_ctr128_crypt(sc->aes, src, dst);
 405 }
 406
 407 void hash_function(const char *data, unsigned long len, unsigned char *hash)
 408 {
 409         EVP_MD_CTX *c = EVP_MD_CTX_new();
 410         int ret = EVP_DigestInit_ex(c, EVP_sha1(), NULL);
 411         assert(ret != 0);
 412         ret = EVP_DigestUpdate(c, data, len);
 413         assert(ret != 0);
 414         ret = EVP_DigestFinal_ex(c, hash, NULL);
 415         assert(ret != 0);
 416         EVP_MD_CTX_free(c);
 417 }
 418
 419 void hash2_function(const char *data, unsigned long len, unsigned char *hash)
 420 {
 421         EVP_MD_CTX *c = EVP_MD_CTX_new();
 422         int ret = EVP_DigestInit_ex(c, EVP_sha256(), NULL);
 423         assert(ret != 0);
 424         ret = EVP_DigestUpdate(c, data, len);
 425         assert(ret != 0);
 426         ret = EVP_DigestFinal_ex(c, hash, NULL);
 427         assert(ret != 0);
 428         EVP_MD_CTX_free(c);
 429 }