src/libimaevm.c

   1 /*
   2  * ima-evm-utils - IMA/EVM support utilities
   3  *
   4  * Copyright (C) 2011 Nokia Corporation
   5  * Copyright (C) 2011,2012,2013 Intel Corporation
   6  * Copyright (C) 2013,2014 Samsung Electronics
   7  *
   8  * Authors:
   9  * Dmitry Kasatkin <dmitry.kasatkin@nokia.com>
  10  *                 <dmitry.kasatkin@intel.com>
  11  *                 <d.kasatkin@samsung.com>
  12  *
  13  * This program is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU General Public License
  15  * version 2 as published by the Free Software Foundation.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * File: libevm.c
  23  *       IMA/EVM library
  24  */
  25
  26 /* should we use logger instead for library? */
  27 #define USE_FPRINTF
  28
  29 #include "imaevm.h"
  30
  31 const char *const pkey_hash_algo[PKEY_HASH__LAST] = {
  32         [PKEY_HASH_MD4]         = "md4",
  33         [PKEY_HASH_MD5]         = "md5",
  34         [PKEY_HASH_SHA1]        = "sha1",
  35         [PKEY_HASH_RIPE_MD_160] = "rmd160",
  36         [PKEY_HASH_SHA256]      = "sha256",
  37         [PKEY_HASH_SHA384]      = "sha384",
  38         [PKEY_HASH_SHA512]      = "sha512",
  39         [PKEY_HASH_SHA224]      = "sha224",
  40 };
  41
  42 /*
  43  * Hash algorithm OIDs plus ASN.1 DER wrappings [RFC4880 sec 5.2.2].
  44  */
  45 static const uint8_t RSA_digest_info_MD5[] = {
  46         0x30, 0x20, 0x30, 0x0C, 0x06, 0x08,
  47         0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x02, 0x05, /* OID */
  48         0x05, 0x00, 0x04, 0x10
  49 };
  50
  51 static const uint8_t RSA_digest_info_SHA1[] = {
  52         0x30, 0x21, 0x30, 0x09, 0x06, 0x05,
  53         0x2B, 0x0E, 0x03, 0x02, 0x1A,
  54         0x05, 0x00, 0x04, 0x14
  55 };
  56
  57 static const uint8_t RSA_digest_info_RIPE_MD_160[] = {
  58         0x30, 0x21, 0x30, 0x09, 0x06, 0x05,
  59         0x2B, 0x24, 0x03, 0x02, 0x01,
  60         0x05, 0x00, 0x04, 0x14
  61 };
  62
  63 static const uint8_t RSA_digest_info_SHA224[] = {
  64         0x30, 0x2d, 0x30, 0x0d, 0x06, 0x09,
  65         0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x04,
  66         0x05, 0x00, 0x04, 0x1C
  67 };
  68
  69 static const uint8_t RSA_digest_info_SHA256[] = {
  70         0x30, 0x31, 0x30, 0x0d, 0x06, 0x09,
  71         0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01,
  72         0x05, 0x00, 0x04, 0x20
  73 };
  74
  75 static const uint8_t RSA_digest_info_SHA384[] = {
  76         0x30, 0x41, 0x30, 0x0d, 0x06, 0x09,
  77         0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x02,
  78         0x05, 0x00, 0x04, 0x30
  79 };
  80
  81 static const uint8_t RSA_digest_info_SHA512[] = {
  82         0x30, 0x51, 0x30, 0x0d, 0x06, 0x09,
  83         0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03,
  84         0x05, 0x00, 0x04, 0x40
  85 };
  86
  87 const struct RSA_ASN1_template RSA_ASN1_templates[PKEY_HASH__LAST] = {
  88 #define _(X) { RSA_digest_info_##X, sizeof(RSA_digest_info_##X) }
  89         [PKEY_HASH_MD5]         = _(MD5),
  90         [PKEY_HASH_SHA1]        = _(SHA1),
  91         [PKEY_HASH_RIPE_MD_160] = _(RIPE_MD_160),
  92         [PKEY_HASH_SHA256]      = _(SHA256),
  93         [PKEY_HASH_SHA384]      = _(SHA384),
  94         [PKEY_HASH_SHA512]      = _(SHA512),
  95         [PKEY_HASH_SHA224]      = _(SHA224),
  96 #undef _
  97 };
  98
  99 struct libevm_params params = {
 100         .verbose = LOG_INFO - 1,
 101         .hash_algo = "sha1",
 102 };
 103
 104 void do_dump(FILE *fp, const void *ptr, int len, bool cr)
 105 {
 106         int i;
 107         uint8_t *data = (uint8_t *) ptr;
 108
 109         for (i = 0; i < len; i++)
 110                 fprintf(fp, "%02x", data[i]);
 111         if (cr)
 112                 fprintf(fp, "\n");
 113 }
 114
 115 void dump(const void *ptr, int len)
 116 {
 117         do_dump(stdout, ptr, len, true);
 118 }
 119
 120 int get_filesize(const char *filename)
 121 {
 122         struct stat stats;
 123         /*  Need to know the file length */
 124         stat(filename, &stats);
 125         return (int)stats.st_size;
 126 }
 127
 128 static inline int get_fdsize(int fd)
 129 {
 130         struct stat stats;
 131         /*  Need to know the file length */
 132         fstat(fd, &stats);
 133         return (int)stats.st_size;
 134 }
 135
 136 static int add_file_hash(const char *file, EVP_MD_CTX *ctx)
 137 {
 138         uint8_t *data;
 139         int err, size, bs = DATA_SIZE;
 140         size_t len;
 141         FILE *fp;
 142
 143         data = malloc(bs);
 144         if (!data) {
 145                 log_err("malloc failed\n");
 146                 return -1;
 147         }
 148
 149         fp = fopen(file, "r");
 150         if (!fp) {
 151                 log_err("Unable to open %s\n", file);
 152                 return -1;
 153         }
 154
 155         for (size = get_fdsize(fileno(fp)); size; size -= len) {
 156                 len = MIN(size, bs);
 157                 err = fread(data, len, 1, fp);
 158                 if (!err) {
 159                         if (ferror(fp)) {
 160                                 log_err("fread() error\n\n");
 161                                 return -1;
 162                         }
 163                         break;
 164                 }
 165                 err = EVP_DigestUpdate(ctx, data, len);
 166                 if (!err) {
 167                         log_err("EVP_DigestUpdate() failed\n");
 168                         return 1;
 169                 }
 170         }
 171
 172         fclose(fp);
 173         free(data);
 174
 175         return 0;
 176 }
 177
 178 static int add_dir_hash(const char *file, EVP_MD_CTX *ctx)
 179 {
 180         int err;
 181         struct dirent *de;
 182         DIR *dir;
 183         unsigned long long ino, off;
 184         unsigned int type;
 185
 186         dir = opendir(file);
 187         if (!dir) {
 188                 log_err("Unable to open %s\n", file);
 189                 return -1;
 190         }
 191
 192         while ((de = readdir(dir))) {
 193                 ino = de->d_ino;
 194                 off = de->d_off;
 195                 type = de->d_type;
 196                 log_debug("entry: %s, ino: %llu, type: %u, off: %llu, reclen: %hu\n",
 197                           de->d_name, ino, type, off, de->d_reclen);
 198                 err = EVP_DigestUpdate(ctx, de->d_name, strlen(de->d_name));
 199                 /*err |= EVP_DigestUpdate(ctx, &off, sizeof(off));*/
 200                 err |= EVP_DigestUpdate(ctx, &ino, sizeof(ino));
 201                 err |= EVP_DigestUpdate(ctx, &type, sizeof(type));
 202                 if (!err) {
 203                         log_err("EVP_DigestUpdate() failed\n");
 204                         return 1;
 205                 }
 206         }
 207
 208         closedir(dir);
 209
 210         return 0;
 211 }
 212
 213 static int add_link_hash(const char *path, EVP_MD_CTX *ctx)
 214 {
 215         int err;
 216         char buf[1024];
 217
 218         err = readlink(path, buf, sizeof(buf));
 219         if (err <= 0)
 220                 return -1;
 221
 222         log_info("link: %s -> %.*s\n", path, err, buf);
 223         return !EVP_DigestUpdate(ctx, buf, err);
 224 }
 225
 226 static int add_dev_hash(struct stat *st, EVP_MD_CTX *ctx)
 227 {
 228         uint32_t dev = st->st_rdev;
 229         unsigned major = (dev & 0xfff00) >> 8;
 230         unsigned minor = (dev & 0xff) | ((dev >> 12) & 0xfff00);
 231         log_info("device: %u:%u\n", major, minor);
 232         return !EVP_DigestUpdate(ctx, &dev, sizeof(dev));
 233 }
 234
 235 int ima_calc_hash(const char *file, uint8_t *hash)
 236 {
 237         struct stat st;
 238         EVP_MD_CTX ctx;
 239         const EVP_MD *md;
 240         unsigned int mdlen;
 241         int err;
 242
 243         /*  Need to know the file length */
 244         err = lstat(file, &st);
 245         if (err < 0) {
 246                 log_err("stat() failed\n");
 247                 return err;
 248         }
 249
 250         md = EVP_get_digestbyname(params.hash_algo);
 251         if (!md) {
 252                 log_err("EVP_get_digestbyname() failed\n");
 253                 return 1;
 254         }
 255
 256         err = EVP_DigestInit(&ctx, md);
 257         if (!err) {
 258                 log_err("EVP_DigestInit() failed\n");
 259                 return 1;
 260         }
 261
 262         switch (st.st_mode & S_IFMT) {
 263         case S_IFREG:
 264                 err = add_file_hash(file, &ctx);
 265                 break;
 266         case S_IFDIR:
 267                 err = add_dir_hash(file, &ctx);
 268                 break;
 269         case S_IFLNK:
 270                 err = add_link_hash(file, &ctx);
 271                 break;
 272         case S_IFIFO: case S_IFSOCK:
 273         case S_IFCHR: case S_IFBLK:
 274                 err = add_dev_hash(&st, &ctx);
 275                 break;
 276         default:
 277                 log_errno("Unsupported file type");
 278                 return -1;
 279         }
 280
 281         if (err)
 282                 return err;
 283
 284         err = EVP_DigestFinal(&ctx, hash, &mdlen);
 285         if (!err) {
 286                 log_err("EVP_DigestFinal() failed\n");
 287                 return 1;
 288         }
 289
 290         return mdlen;
 291 }
 292
 293 RSA *read_pub_key(const char *keyfile, int x509)
 294 {
 295         FILE *fp;
 296         RSA *key = NULL;
 297         X509 *crt = NULL;
 298         EVP_PKEY *pkey = NULL;
 299
 300         fp = fopen(keyfile, "r");
 301         if (!fp) {
 302                 log_err("Unable to open keyfile %s\n", keyfile);
 303                 return NULL;
 304         }
 305
 306         if (x509) {
 307                 crt = d2i_X509_fp(fp, NULL);
 308                 if (!crt) {
 309                         log_err("d2i_X509_fp() failed\n");
 310                         goto out;
 311                 }
 312                 pkey = X509_extract_key(crt);
 313                 if (!pkey) {
 314                         log_err("X509_extract_key() failed\n");
 315                         goto out;
 316                 }
 317                 key = EVP_PKEY_get1_RSA(pkey);
 318         } else {
 319                 key = PEM_read_RSA_PUBKEY(fp, NULL, NULL, NULL);
 320         }
 321
 322         if (!key)
 323                 log_err("PEM_read_RSA_PUBKEY() failed\n");
 324
 325 out:
 326         if (pkey)
 327                 EVP_PKEY_free(pkey);
 328         if (crt)
 329                 X509_free(crt);
 330         fclose(fp);
 331         return key;
 332 }
 333
 334 int verify_hash_v1(const unsigned char *hash, int size, unsigned char *sig, int siglen, const char *keyfile)
 335 {
 336         int err, len;
 337         SHA_CTX ctx;
 338         unsigned char out[1024];
 339         RSA *key;
 340         unsigned char sighash[20];
 341         struct signature_hdr *hdr = (struct signature_hdr *)sig;
 342
 343         log_info("hash: ");
 344         log_dump(hash, size);
 345
 346         key = read_pub_key(keyfile, 0);
 347         if (!key)
 348                 return 1;
 349
 350         SHA1_Init(&ctx);
 351         SHA1_Update(&ctx, hash, size);
 352         SHA1_Update(&ctx, hdr, sizeof(*hdr));
 353         SHA1_Final(sighash, &ctx);
 354         log_info("sighash: ");
 355         log_dump(sighash, sizeof(sighash));
 356
 357         err = RSA_public_decrypt(siglen - sizeof(*hdr) - 2, sig + sizeof(*hdr) + 2, out, key, RSA_PKCS1_PADDING);
 358         RSA_free(key);
 359         if (err < 0) {
 360                 log_err("RSA_public_decrypt() failed: %d\n", err);
 361                 return 1;
 362         }
 363
 364         len = err;
 365
 366         if (len != sizeof(sighash) || memcmp(out, sighash, len) != 0) {
 367                 log_err("Verification failed: %d\n", err);
 368                 return -1;
 369         } else {
 370                 /*log_info("Verification is OK\n");*/
 371                 printf("Verification is OK\n");
 372         }
 373
 374         return 0;
 375 }
 376
 377 int verify_hash_v2(const unsigned char *hash, int size, unsigned char *sig, int siglen, const char *keyfile)
 378 {
 379         int err, len;
 380         unsigned char out[1024];
 381         RSA *key;
 382         struct signature_v2_hdr *hdr = (struct signature_v2_hdr *)sig;
 383         const struct RSA_ASN1_template *asn1;
 384
 385         log_info("hash: ");
 386         log_dump(hash, size);
 387
 388         key = read_pub_key(keyfile, 1);
 389         if (!key)
 390                 return 1;
 391
 392         err = RSA_public_decrypt(siglen - sizeof(*hdr), sig + sizeof(*hdr), out, key, RSA_PKCS1_PADDING);
 393         RSA_free(key);
 394         if (err < 0) {
 395                 log_err("RSA_public_decrypt() failed: %d\n", err);
 396                 return 1;
 397         }
 398
 399         len = err;
 400
 401         asn1 = &RSA_ASN1_templates[hdr->hash_algo];
 402
 403         if (len < asn1->size || memcmp(out, asn1->data, asn1->size)) {
 404                 log_err("Verification failed: %d\n", err);
 405                 return -1;
 406         }
 407
 408         len -= asn1->size;
 409
 410         if (len != size || memcmp(out + asn1->size, hash, len)) {
 411                 log_err("Verification failed: %d\n", err);
 412                 return -1;
 413         }
 414
 415         /*log_info("Verification is OK\n");*/
 416         printf("Verification is OK\n");
 417
 418         return 0;
 419 }
 420
 421 int get_hash_algo(const char *algo)
 422 {
 423         int i;
 424
 425         for (i = 0; i < PKEY_HASH__LAST; i++)
 426                 if (!strcmp(algo, pkey_hash_algo[i]))
 427                         return i;
 428
 429         return PKEY_HASH_SHA1;
 430 }
 431
 432 static int get_hash_algo_from_sig(unsigned char *sig)
 433 {
 434         uint8_t hashalgo;
 435
 436         if (sig[0] == 1) {
 437                 hashalgo = ((struct signature_hdr *)sig)->hash;
 438
 439                 if (hashalgo >= DIGEST_ALGO_MAX)
 440                         return -1;
 441
 442                 switch (hashalgo) {
 443                 case DIGEST_ALGO_SHA1:
 444                         return PKEY_HASH_SHA1;
 445                 case DIGEST_ALGO_SHA256:
 446                         return PKEY_HASH_SHA256;
 447                 default:
 448                         return -1;
 449                 }
 450         } else if (sig[0] == 2) {
 451                 hashalgo = ((struct signature_v2_hdr *)sig)->hash_algo;
 452                 if (hashalgo >= PKEY_HASH__LAST)
 453                         return -1;
 454                 return hashalgo;
 455         } else
 456                 return -1;
 457 }
 458
 459 int verify_hash(const unsigned char *hash, int size, unsigned char *sig, int siglen)
 460 {
 461         char *key;
 462         int x509;
 463         verify_hash_fn_t verify_hash;
 464
 465         /* Get signature type from sig header */
 466         if (sig[0] == DIGSIG_VERSION_1) {
 467                 verify_hash = verify_hash_v1;
 468                 /* Read pubkey from RSA key */
 469                 x509 = 0;
 470         } else if (sig[0] == DIGSIG_VERSION_2) {
 471                 verify_hash = verify_hash_v2;
 472                 /* Read pubkey from x509 cert */
 473                 x509 = 1;
 474         } else
 475                 return -1;
 476
 477         /* Determine what key to use for verification*/
 478         key = params.keyfile ? : x509 ?
 479                         "/etc/keys/x509_evm.der" :
 480                         "/etc/keys/pubkey_evm.pem";
 481
 482         return verify_hash(hash, size, sig, siglen, key);
 483 }
 484
 485 int ima_verify_signature(const char *file, unsigned char *sig, int siglen)
 486 {
 487         unsigned char hash[64];
 488         int hashlen, sig_hash_algo;
 489
 490         if (sig[0] != 0x03) {
 491                 log_err("security.ima has no signature\n");
 492                 return -1;
 493         }
 494
 495         sig_hash_algo = get_hash_algo_from_sig(sig + 1);
 496         if (sig_hash_algo < 0) {
 497                 log_err("Invalid signature\n");
 498                 return -1;
 499         }
 500         /* Use hash algorithm as retrieved from signature */
 501         params.hash_algo = pkey_hash_algo[sig_hash_algo];
 502
 503         hashlen = ima_calc_hash(file, hash);
 504         if (hashlen <= 1)
 505                 return hashlen;
 506
 507         return verify_hash(hash, hashlen, sig + 1, siglen - 1);
 508 }