libfec/fec_open.cpp

   1 /*
   2  * Copyright (C) 2015 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <stdlib.h>
  18 #include <sys/ioctl.h>
  19 #include <sys/stat.h>
  20
  21 #include <ext4_utils/ext4_sb.h>
  22
  23 extern "C" {
  24     #include <squashfs_utils.h>
  25 }
  26
  27 #if defined(__linux__)
  28     #include <linux/fs.h>
  29 #elif defined(__APPLE__)
  30     #include <sys/disk.h>
  31     #define BLKGETSIZE64 DKIOCGETBLOCKCOUNT
  32     #define fdatasync(fd) fcntl((fd), F_FULLFSYNC)
  33 #endif
  34
  35 #include "fec_private.h"
  36
  37 /* used by `find_offset'; returns metadata size for a file size `size' and
  38    `roots' Reed-Solomon parity bytes */
  39 using size_func = uint64_t (*)(uint64_t size, int roots);
  40
  41 /* performs a binary search to find a metadata offset from a file so that
  42    the metadata size matches function `get_real_size(size, roots)', using
  43    the approximate size returned by `get_appr_size' as a starting point */
  44 static int find_offset(uint64_t file_size, int roots, uint64_t *offset,
  45         size_func get_appr_size, size_func get_real_size)
  46 {
  47     check(offset);
  48     check(get_appr_size);
  49     check(get_real_size);
  50
  51     if (file_size % FEC_BLOCKSIZE) {
  52         /* must be a multiple of block size */
  53         error("file size not multiple of " stringify(FEC_BLOCKSIZE));
  54         errno = EINVAL;
  55         return -1;
  56     }
  57
  58     uint64_t mi = get_appr_size(file_size, roots);
  59     uint64_t lo = file_size - mi * 2;
  60     uint64_t hi = file_size - mi / 2;
  61
  62     while (lo < hi) {
  63         mi = ((hi + lo) / (2 * FEC_BLOCKSIZE)) * FEC_BLOCKSIZE;
  64         uint64_t total = mi + get_real_size(mi, roots);
  65
  66         if (total < file_size) {
  67             lo = mi + FEC_BLOCKSIZE;
  68         } else if (total > file_size) {
  69             hi = mi;
  70         } else {
  71             *offset = mi;
  72             debug("file_size = %" PRIu64 " -> offset = %" PRIu64, file_size,
  73                 mi);
  74             return 0;
  75         }
  76     }
  77
  78     warn("could not determine offset");
  79     errno = ERANGE;
  80     return -1;
  81 }
  82
  83 /* returns verity metadata size for a `size' byte file */
  84 static uint64_t get_verity_size(uint64_t size, int)
  85 {
  86     return VERITY_METADATA_SIZE + verity_get_size(size, NULL, NULL);
  87 }
  88
  89 /* computes the verity metadata offset for a file with size `f->size' */
  90 static int find_verity_offset(fec_handle *f, uint64_t *offset)
  91 {
  92     check(f);
  93     check(offset);
  94
  95     return find_offset(f->data_size, 0, offset, get_verity_size,
  96                 get_verity_size);
  97 }
  98
  99 /* attempts to read and validate an ecc header from file position `offset' */
 100 static int parse_ecc_header(fec_handle *f, uint64_t offset)
 101 {
 102     check(f);
 103     check(f->ecc.rsn > 0 && f->ecc.rsn < FEC_RSM);
 104     check(f->size > sizeof(fec_header));
 105
 106     debug("offset = %" PRIu64, offset);
 107
 108     if (offset > f->size - sizeof(fec_header)) {
 109         return -1;
 110     }
 111
 112     fec_header header;
 113
 114     /* there's obviously no ecc data at this point, so there is no need to
 115        call fec_pread to access this data */
 116     if (!raw_pread(f, &header, sizeof(fec_header), offset)) {
 117         error("failed to read: %s", strerror(errno));
 118         return -1;
 119     }
 120
 121     /* move offset back to the beginning of the block for validating header */
 122     offset -= offset % FEC_BLOCKSIZE;
 123
 124     if (header.magic != FEC_MAGIC) {
 125         return -1;
 126     }
 127     if (header.version != FEC_VERSION) {
 128         error("unsupported ecc version: %u", header.version);
 129         return -1;
 130     }
 131     if (header.size != sizeof(fec_header)) {
 132         error("unexpected ecc header size: %u", header.size);
 133         return -1;
 134     }
 135     if (header.roots == 0 || header.roots >= FEC_RSM) {
 136         error("invalid ecc roots: %u", header.roots);
 137         return -1;
 138     }
 139     if (f->ecc.roots != (int)header.roots) {
 140         error("unexpected number of roots: %d vs %u", f->ecc.roots,
 141             header.roots);
 142         return -1;
 143     }
 144     if (header.fec_size % header.roots ||
 145             header.fec_size % FEC_BLOCKSIZE) {
 146         error("inconsistent ecc size %u", header.fec_size);
 147         return -1;
 148     }
 149
 150     f->data_size = header.inp_size;
 151     f->ecc.blocks = fec_div_round_up(f->data_size, FEC_BLOCKSIZE);
 152     f->ecc.rounds = fec_div_round_up(f->ecc.blocks, f->ecc.rsn);
 153
 154     if (header.fec_size !=
 155             (uint32_t)f->ecc.rounds * f->ecc.roots * FEC_BLOCKSIZE) {
 156         error("inconsistent ecc size %u", header.fec_size);
 157         return -1;
 158     }
 159
 160     f->ecc.size = header.fec_size;
 161     f->ecc.start = header.inp_size;
 162
 163     /* validate encoding data; caller may opt not to use it if invalid */
 164     SHA256_CTX ctx;
 165     SHA256_Init(&ctx);
 166
 167     uint8_t buf[FEC_BLOCKSIZE];
 168     uint32_t n = 0;
 169     uint32_t len = FEC_BLOCKSIZE;
 170
 171     while (n < f->ecc.size) {
 172         if (len > f->ecc.size - n) {
 173             len = f->ecc.size - n;
 174         }
 175
 176         if (!raw_pread(f, buf, len, f->ecc.start + n)) {
 177             error("failed to read ecc: %s", strerror(errno));
 178             return -1;
 179         }
 180
 181         SHA256_Update(&ctx, buf, len);
 182         n += len;
 183     }
 184
 185     uint8_t hash[SHA256_DIGEST_LENGTH];
 186     SHA256_Final(hash, &ctx);
 187
 188     f->ecc.valid = !memcmp(hash, header.hash, SHA256_DIGEST_LENGTH);
 189
 190     if (!f->ecc.valid) {
 191         warn("ecc data not valid");
 192     }
 193
 194     return 0;
 195 }
 196
 197 /* attempts to read an ecc header from `offset', and checks for a backup copy
 198    at the end of the block if the primary header is not valid */
 199 static int parse_ecc(fec_handle *f, uint64_t offset)
 200 {
 201     check(f);
 202     check(offset % FEC_BLOCKSIZE == 0);
 203     check(offset < UINT64_MAX - FEC_BLOCKSIZE);
 204
 205     /* check the primary header at the beginning of the block */
 206     if (parse_ecc_header(f, offset) == 0) {
 207         return 0;
 208     }
 209
 210     /* check the backup header at the end of the block */
 211     if (parse_ecc_header(f, offset + FEC_BLOCKSIZE - sizeof(fec_header)) == 0) {
 212         warn("using backup ecc header");
 213         return 0;
 214     }
 215
 216     return -1;
 217 }
 218
 219 /* reads the squashfs superblock and returns the size of the file system in
 220    `offset' */
 221 static int get_squashfs_size(fec_handle *f, uint64_t *offset)
 222 {
 223     check(f);
 224     check(offset);
 225
 226     size_t sb_size = squashfs_get_sb_size();
 227     check(sb_size <= SSIZE_MAX);
 228
 229     uint8_t buffer[sb_size];
 230
 231     if (fec_pread(f, buffer, sizeof(buffer), 0) != (ssize_t)sb_size) {
 232         error("failed to read superblock: %s", strerror(errno));
 233         return -1;
 234     }
 235
 236     squashfs_info sq;
 237
 238     if (squashfs_parse_sb_buffer(buffer, &sq) < 0) {
 239         error("failed to parse superblock: %s", strerror(errno));
 240         return -1;
 241     }
 242
 243     *offset = sq.bytes_used_4K_padded;
 244     return 0;
 245 }
 246
 247 /* reads the ext4 superblock and returns the size of the file system in
 248    `offset' */
 249 static int get_ext4_size(fec_handle *f, uint64_t *offset)
 250 {
 251     check(f);
 252     check(f->size > 1024 + sizeof(ext4_super_block));
 253     check(offset);
 254
 255     ext4_super_block sb;
 256
 257     if (fec_pread(f, &sb, sizeof(sb), 1024) != sizeof(sb)) {
 258         error("failed to read superblock: %s", strerror(errno));
 259         return -1;
 260     }
 261
 262     fs_info info;
 263     info.len = 0;  /* only len is set to 0 to ask the device for real size. */
 264
 265     if (ext4_parse_sb(&sb, &info) != 0) {
 266         errno = EINVAL;
 267         return -1;
 268     }
 269
 270     *offset = info.len;
 271     return 0;
 272 }
 273
 274 /* attempts to determine file system size, if no fs type is specified in
 275    `f->flags', tries all supported types, and returns the size in `offset' */
 276 static int get_fs_size(fec_handle *f, uint64_t *offset)
 277 {
 278     check(f);
 279     check(offset);
 280
 281     if (f->flags & FEC_FS_EXT4) {
 282         return get_ext4_size(f, offset);
 283     } else if (f->flags & FEC_FS_SQUASH) {
 284         return get_squashfs_size(f, offset);
 285     } else {
 286         /* try all alternatives */
 287         int rc = get_ext4_size(f, offset);
 288
 289         if (rc == 0) {
 290             debug("found ext4fs");
 291             return rc;
 292         }
 293
 294         rc = get_squashfs_size(f, offset);
 295
 296         if (rc == 0) {
 297             debug("found squashfs");
 298         }
 299
 300         return rc;
 301     }
 302 }
 303
 304 /* locates, validates, and loads verity metadata from `f->fd' */
 305 static int load_verity(fec_handle *f)
 306 {
 307     check(f);
 308     debug("size = %" PRIu64 ", flags = %d", f->data_size, f->flags);
 309
 310     uint64_t offset = f->data_size - VERITY_METADATA_SIZE;
 311
 312     /* verity header is at the end of the data area */
 313     if (verity_parse_header(f, offset) == 0) {
 314         debug("found at %" PRIu64 " (start %" PRIu64 ")", offset,
 315             f->verity.hash_start);
 316         return 0;
 317     }
 318
 319     debug("trying legacy formats");
 320
 321     /* legacy format at the end of the partition */
 322     if (find_verity_offset(f, &offset) == 0 &&
 323             verity_parse_header(f, offset) == 0) {
 324         debug("found at %" PRIu64 " (start %" PRIu64 ")", offset,
 325             f->verity.hash_start);
 326         return 0;
 327     }
 328
 329     /* legacy format after the file system, but not at the end */
 330     int rc = get_fs_size(f, &offset);
 331
 332     if (rc == 0) {
 333         debug("file system size = %" PRIu64, offset);
 334         rc = verity_parse_header(f, offset);
 335
 336         if (rc == 0) {
 337             debug("found at %" PRIu64 " (start %" PRIu64 ")", offset,
 338                 f->verity.hash_start);
 339         }
 340     }
 341
 342     return rc;
 343 }
 344
 345 /* locates, validates, and loads ecc data from `f->fd' */
 346 static int load_ecc(fec_handle *f)
 347 {
 348     check(f);
 349     debug("size = %" PRIu64, f->data_size);
 350
 351     uint64_t offset = f->data_size - FEC_BLOCKSIZE;
 352
 353     if (parse_ecc(f, offset) == 0) {
 354         debug("found at %" PRIu64 " (start %" PRIu64 ")", offset,
 355             f->ecc.start);
 356         return 0;
 357     }
 358
 359     return -1;
 360 }
 361
 362 /* sets `f->size' to the size of the file or block device */
 363 static int get_size(fec_handle *f)
 364 {
 365     check(f);
 366
 367     struct stat st;
 368
 369     if (fstat(f->fd, &st) == -1) {
 370         error("fstat failed: %s", strerror(errno));
 371         return -1;
 372     }
 373
 374     if (S_ISBLK(st.st_mode)) {
 375         debug("block device");
 376
 377         if (ioctl(f->fd, BLKGETSIZE64, &f->size) == -1) {
 378             error("ioctl failed: %s", strerror(errno));
 379             return -1;
 380         }
 381     } else if (S_ISREG(st.st_mode)) {
 382         debug("file");
 383         f->size = st.st_size;
 384     } else {
 385         error("unsupported type %d", (int)st.st_mode);
 386         errno = EACCES;
 387         return -1;
 388     }
 389
 390     return 0;
 391 }
 392
 393 /* clears fec_handle fiels to safe values */
 394 static void reset_handle(fec_handle *f)
 395 {
 396     f->fd = -1;
 397     f->flags = 0;
 398     f->mode = 0;
 399     f->errors = 0;
 400     f->data_size = 0;
 401     f->pos = 0;
 402     f->size = 0;
 403
 404     memset(&f->ecc, 0, sizeof(f->ecc));
 405     memset(&f->verity, 0, sizeof(f->verity));
 406 }
 407
 408 /* closes and flushes `f->fd' and releases any memory allocated for `f' */
 409 int fec_close(struct fec_handle *f)
 410 {
 411     check(f);
 412
 413     if (f->fd != -1) {
 414         if (f->mode & O_RDWR && fdatasync(f->fd) == -1) {
 415             warn("fdatasync failed: %s", strerror(errno));
 416         }
 417
 418         close(f->fd);
 419     }
 420
 421     if (f->verity.hash) {
 422         delete[] f->verity.hash;
 423     }
 424     if (f->verity.salt) {
 425         delete[] f->verity.salt;
 426     }
 427     if (f->verity.table) {
 428         delete[] f->verity.table;
 429     }
 430
 431     pthread_mutex_destroy(&f->mutex);
 432
 433     reset_handle(f);
 434     delete f;
 435
 436     return 0;
 437 }
 438
 439 /* populates `data' from the internal data in `f', returns a value <0 if verity
 440    metadata is not available in `f->fd' */
 441 int fec_verity_get_metadata(struct fec_handle *f, struct fec_verity_metadata *data)
 442 {
 443     check(f);
 444     check(data);
 445
 446     if (!f->verity.metadata_start) {
 447         return -1;
 448     }
 449
 450     check(f->data_size < f->size);
 451     check(f->data_size <= f->verity.hash_start);
 452     check(f->data_size <= f->verity.metadata_start);
 453     check(f->verity.table);
 454
 455     data->disabled = f->verity.disabled;
 456     data->data_size = f->data_size;
 457     memcpy(data->signature, f->verity.header.signature,
 458         sizeof(data->signature));
 459     memcpy(data->ecc_signature, f->verity.ecc_header.signature,
 460         sizeof(data->ecc_signature));
 461     data->table = f->verity.table;
 462     data->table_length = f->verity.header.length;
 463
 464     return 0;
 465 }
 466
 467 /* populates `data' from the internal data in `f', returns a value <0 if ecc
 468    metadata is not available in `f->fd' */
 469 int fec_ecc_get_metadata(struct fec_handle *f, struct fec_ecc_metadata *data)
 470 {
 471     check(f);
 472     check(data);
 473
 474     if (!f->ecc.start) {
 475         return -1;
 476     }
 477
 478     check(f->data_size < f->size);
 479     check(f->ecc.start >= f->data_size);
 480     check(f->ecc.start < f->size);
 481     check(f->ecc.start % FEC_BLOCKSIZE == 0)
 482
 483     data->valid = f->ecc.valid;
 484     data->roots = f->ecc.roots;
 485     data->blocks = f->ecc.blocks;
 486     data->rounds = f->ecc.rounds;
 487     data->start = f->ecc.start;
 488
 489     return 0;
 490 }
 491
 492 /* populates `data' from the internal status in `f' */
 493 int fec_get_status(struct fec_handle *f, struct fec_status *s)
 494 {
 495     check(f);
 496     check(s);
 497
 498     s->flags = f->flags;
 499     s->mode = f->mode;
 500     s->errors = f->errors;
 501     s->data_size = f->data_size;
 502     s->size = f->size;
 503
 504     return 0;
 505 }
 506
 507 /* opens `path' using given options and returns a fec_handle in `handle' if
 508    successful */
 509 int fec_open(struct fec_handle **handle, const char *path, int mode, int flags,
 510         int roots)
 511 {
 512     check(path);
 513     check(handle);
 514     check(roots > 0 && roots < FEC_RSM);
 515
 516     debug("path = %s, mode = %d, flags = %d, roots = %d", path, mode, flags,
 517         roots);
 518
 519     if (mode & (O_CREAT | O_TRUNC | O_EXCL | O_WRONLY)) {
 520         /* only reading and updating existing files is supported */
 521         error("failed to open '%s': (unsupported mode %d)", path, mode);
 522         errno = EACCES;
 523         return -1;
 524     }
 525
 526     fec::handle f(new (std::nothrow) fec_handle, fec_close);
 527
 528     if (unlikely(!f)) {
 529         error("failed to allocate file handle");
 530         errno = ENOMEM;
 531         return -1;
 532     }
 533
 534     reset_handle(f.get());
 535
 536     f->mode = mode;
 537     f->ecc.roots = roots;
 538     f->ecc.rsn = FEC_RSM - roots;
 539     f->flags = flags;
 540
 541     if (unlikely(pthread_mutex_init(&f->mutex, NULL) != 0)) {
 542         error("failed to create a mutex: %s", strerror(errno));
 543         return -1;
 544     }
 545
 546     f->fd = TEMP_FAILURE_RETRY(open(path, mode | O_CLOEXEC));
 547
 548     if (f->fd == -1) {
 549         error("failed to open '%s': %s", path, strerror(errno));
 550         return -1;
 551     }
 552
 553     if (get_size(f.get()) == -1) {
 554         error("failed to get size for '%s': %s", path, strerror(errno));
 555         return -1;
 556     }
 557
 558     f->data_size = f->size; /* until ecc and/or verity are loaded */
 559
 560     if (load_ecc(f.get()) == -1) {
 561         debug("error-correcting codes not found from '%s'", path);
 562     }
 563
 564     if (load_verity(f.get()) == -1) {
 565         debug("verity metadata not found from '%s'", path);
 566     }
 567
 568     *handle = f.release();
 569     return 0;
 570 }