X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fintegrity.c;h=6d007fef93f825c6922b07b6d0ee0b18eaf37ba4;hp=67119211e8fdeffc29a5d4bd268b2165aa386091;hb=d265332581905dd769d5fcc93d18f753a6af9b1e;hpb=276f9f9f9658f4a8bafd6216db46760abe8c848d diff --git a/src/integrity.c b/src/integrity.c index 67119211..6d007fef 100644 --- a/src/integrity.c +++ b/src/integrity.c @@ -25,9 +25,18 @@ * along with wimlib; if not, see http://www.gnu.org/licenses/. */ -#include "wimlib_internal.h" -#include "buffer_io.h" -#include "sha1.h" +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "wimlib/assert.h" +#include "wimlib/endianness.h" +#include "wimlib/error.h" +#include "wimlib/file_io.h" +#include "wimlib/integrity.h" +#include "wimlib/resource.h" +#include "wimlib/sha1.h" +#include "wimlib/wim.h" /* Size, in bytes, of each SHA1-summed chunk, when wimlib writes integrity * information. */ @@ -42,43 +51,32 @@ struct integrity_table { u32 size; u32 num_entries; u32 chunk_size; - u8 sha1sums[0][20]; -}; + u8 sha1sums[][20]; +} _packed_attribute; -static int calculate_chunk_sha1(FILE *fp, size_t this_chunk_size, - off_t offset, u8 sha1_md[]) +static int +calculate_chunk_sha1(struct filedes *in_fd, size_t this_chunk_size, + off_t offset, u8 sha1_md[]) { - int ret; u8 buf[BUFFER_SIZE]; SHA_CTX ctx; size_t bytes_remaining; size_t bytes_to_read; - size_t bytes_read; + int ret; - ret = fseeko(fp, offset, SEEK_SET); - if (ret != 0) { - ERROR_WITH_ERRNO("Can't seek to offset " - "%"PRIu64" in WIM", offset); - return WIMLIB_ERR_READ; - } bytes_remaining = this_chunk_size; sha1_init(&ctx); do { bytes_to_read = min(bytes_remaining, sizeof(buf)); - bytes_read = fread(buf, 1, bytes_to_read, fp); - if (bytes_read != bytes_to_read) { - if (feof(fp)) { - ERROR("Unexpected EOF while calculating " - "integrity checksums"); - } else { - ERROR_WITH_ERRNO("File stream error while " - "calculating integrity " - "checksums"); - } - return WIMLIB_ERR_READ; + ret = full_pread(in_fd, buf, bytes_to_read, offset); + if (ret) { + ERROR_WITH_ERRNO("Read error while calculating " + "integrity checksums"); + return ret; } - sha1_update(&ctx, buf, bytes_read); - bytes_remaining -= bytes_read; + sha1_update(&ctx, buf, bytes_to_read); + bytes_remaining -= bytes_to_read; + offset += bytes_to_read; } while (bytes_remaining); sha1_final(sha1_md, &ctx); return 0; @@ -88,114 +86,69 @@ static int calculate_chunk_sha1(FILE *fp, size_t this_chunk_size, /* * read_integrity_table: - Reads the integrity table from a WIM file. * - * @res_entry: - * The resource entry that specifies the location of the integrity table. - * The integrity table must exist (i.e. res_entry->offset must not be 0). - * - * @fp: - * FILE * to the WIM file, opened for reading. + * @wim: + * WIMStruct for the WIM file; @wim->hdr.integrity specifies the location + * of the integrity table. The integrity table must exist (i.e. + * res_entry->offset must not be 0). @wim->in_fd is expected to be a + * seekable file descriptor to the WIM file opened for reading. * * @num_checked_bytes: - * Number of bytes of data that should be checked by the integrity table. - * - * @table ret: - * On success, a pointer to an in-memory structure containing the integrity - * information is written to this location. - * - * Returns 0 on success; nonzero on failure. The possible error codes are: - * - * * WIMLIB_ERR_INVALID_INTEGRITY_TABLE: The integrity table is invalid. - * * WIMLIB_ERR_NOMEM: Could not allocate memory to store the integrity - * data. - * * WIMLIB_ERR_READ: Could not read the integrity data from the WIM file. + * Number of bytes of data that should be checked by the integrity table. + * + * @table_ret: + * On success, a pointer to an in-memory structure containing the integrity + * information is written to this location. + * + * Return values: + * WIMLIB_ERR_SUCCESS (0) + * WIMLIB_ERR_INVALID_INTEGRITY_TABLE + * WIMLIB_ERR_NOMEM + * WIMLIB_ERR_READ + * WIMLIB_ERR_UNEXPECTED_END_OF_FILE */ -static int read_integrity_table(const struct resource_entry *res_entry, - FILE *fp, - u64 num_checked_bytes, - struct integrity_table **table_ret) +static int +read_integrity_table(WIMStruct *wim, u64 num_checked_bytes, + struct integrity_table **table_ret) { - struct integrity_table *table = NULL; - int ret = 0; - u64 expected_size; - u64 expected_num_entries; - - if (resource_is_compressed(res_entry)) { - ERROR("Didn't expect a compressed integrity table"); - return WIMLIB_ERR_INVALID_INTEGRITY_TABLE; - } - - if (res_entry->size < 8 || res_entry->size > 0xffffffff) { - ERROR("Integrity table resource header is invalid"); - return WIMLIB_ERR_INVALID_INTEGRITY_TABLE; - } + void *buf; + struct integrity_table *table; + int ret; - /* Read the integrity table into memory. */ - if ((table = MALLOC(res_entry->size)) == NULL) { - ERROR("Can't allocate %"PRIu64" bytes for integrity table", - (u64)res_entry->size); - return WIMLIB_ERR_NOMEM; - } + if (wim->hdr.integrity.size < 8) + goto invalid; - ret = read_uncompressed_resource(fp, res_entry->offset, - res_entry->size, (void*)table); + DEBUG("Reading integrity table (offset %"PRIu64", " + "original_size %"PRIu64")", + wim->hdr.integrity.offset, wim->hdr.integrity.original_size); - if (ret != 0) { - ERROR("Failed to read integrity table (size = %u, " - " offset = %"PRIu64")", - (unsigned)res_entry->size, res_entry->offset); - goto out; - } + ret = res_entry_to_data(&wim->hdr.integrity, wim, &buf); + if (ret) + return ret; + table = buf; table->size = le32_to_cpu(table->size); table->num_entries = le32_to_cpu(table->num_entries); table->chunk_size = le32_to_cpu(table->chunk_size); - if (table->size != res_entry->size) { - ERROR("Inconsistent integrity table sizes: Table header says " - "%u bytes but resource entry says %u bytes", - table->size, (unsigned)res_entry->size); - ret = WIMLIB_ERR_INVALID_INTEGRITY_TABLE; - goto out; - } - DEBUG("table->size = %u, table->num_entries = %u, " "table->chunk_size = %u", table->size, table->num_entries, table->chunk_size); - expected_size = (u64)table->num_entries * SHA1_HASH_SIZE + 12; - - if (table->size != expected_size) { - ERROR("Integrity table is %u bytes, but expected %"PRIu64" " - "bytes to hold %u entries", - table->size, expected_size, table->num_entries); - ret = WIMLIB_ERR_INVALID_INTEGRITY_TABLE; - goto out; + if (table->size != wim->hdr.integrity.original_size || + table->size != (u64)table->num_entries * SHA1_HASH_SIZE + 12 || + table->chunk_size == 0 || + table->num_entries != DIV_ROUND_UP(num_checked_bytes, table->chunk_size)) + { + FREE(table); + goto invalid; } - if (table->chunk_size == 0) { - ERROR("Cannot use integrity chunk size of 0"); - ret = WIMLIB_ERR_INVALID_INTEGRITY_TABLE; - goto out; - } + *table_ret = table; + return 0; - expected_num_entries = DIV_ROUND_UP(num_checked_bytes, table->chunk_size); - - if (table->num_entries != expected_num_entries) { - ERROR("%"PRIu64" integrity table entries would be required " - "to checksum the %"PRIu64" bytes from the end of the " - "header to the", - expected_num_entries, num_checked_bytes); - ERROR("end of the lookup table with a chunk size of %u, but " - "there were only %u entries", - table->chunk_size, table->num_entries); - ret = WIMLIB_ERR_INVALID_INTEGRITY_TABLE; - } -out: - if (ret == 0) - *table_ret = table; - else - FREE(table); - return ret; +invalid: + ERROR("Integrity table is invalid"); + return WIMLIB_ERR_INVALID_INTEGRITY_TABLE; } /* @@ -204,39 +157,44 @@ out: * Calculates an integrity table for the data in a file beginning at offset 208 * (WIM_HEADER_DISK_SIZE). * - * @fp: - * FILE * for the file to be checked, opened for reading. Does not need to - * be at any specific location in the file. + * @in_fd: + * File descriptor for the file to be checked, opened for reading. Does + * not need to be at any specific location in the file. * * @new_check_end: - * Offset of byte after the last byte to be checked. + * Offset of byte after the last byte to be checked. * * @old_table: - * If non-NULL, a pointer to the table containing the previously calculated - * integrity data for a prefix of this file. + * If non-NULL, a pointer to the table containing the previously calculated + * integrity data for a prefix of this file. * * @old_check_end: - * If @old_table is non-NULL, the byte after the last byte that was checked - * in the old table. Must be less than or equal to new_check_end. + * If @old_table is non-NULL, the byte after the last byte that was checked + * in the old table. Must be less than or equal to new_check_end. * * @progress_func: - * If non-NULL, a progress function that will be called after every - * calculated chunk. + * If non-NULL, a progress function that will be called after every + * calculated chunk. * * @integrity_table_ret: - * On success, a pointer to the calculated integrity table is written into - * this location. - * - * Returns 0 on success; nonzero on failure. + * On success, a pointer to the calculated integrity table is written into + * this location. + * + * Return values: + * WIMLIB_ERR_SUCCESS (0) + * WIMLIB_ERR_NOMEM + * WIMLIB_ERR_READ + * WIMLIB_ERR_UNEXPECTED_END_OF_FILE */ -static int calculate_integrity_table(FILE *fp, - off_t new_check_end, - const struct integrity_table *old_table, - off_t old_check_end, - wimlib_progress_func_t progress_func, - struct integrity_table **integrity_table_ret) +static int +calculate_integrity_table(struct filedes *in_fd, + off_t new_check_end, + const struct integrity_table *old_table, + off_t old_check_end, + wimlib_progress_func_t progress_func, + struct integrity_table **integrity_table_ret) { - int ret = 0; + int ret; size_t chunk_size = INTEGRITY_CHUNK_SIZE; /* If an old table is provided, set the chunk size to be compatible with @@ -298,10 +256,12 @@ static int calculate_integrity_table(FILE *fp, copy_hash(new_table->sha1sums[i], old_table->sha1sums[i]); } else { /* Calculate the SHA1 message digest of this chunk */ - ret = calculate_chunk_sha1(fp, this_chunk_size, + ret = calculate_chunk_sha1(in_fd, this_chunk_size, offset, new_table->sha1sums[i]); - if (ret != 0) - break; + if (ret) { + FREE(new_table); + return ret; + } } offset += this_chunk_size; if (progress_func) { @@ -311,11 +271,8 @@ static int calculate_integrity_table(FILE *fp, &progress); } } - if (ret == 0) - *integrity_table_ret = new_table; - else - FREE(new_table); - return ret; + *integrity_table_ret = new_table; + return 0; } /* @@ -332,56 +289,50 @@ static int calculate_integrity_table(FILE *fp, * cannot be read, a warning is printed and the integrity information is * re-calculated. * - * @fp: - * FILE * to the WIM file, opened read-write, positioned at the location at - * which the integrity table is to be written. - * - * @integrity_res_entry: - * Resource entry which will be set to point to the integrity table on - * success. In addition, if @old_lookup_table_end != 0, this initially - * must point to the resource entry for the old integrity table for the - * WIM. + * @wim: + * WIMStruct for the WIM file. @wim->out_fd must be a seekable descriptor + * to the new WIM file, opened read-write, positioned at the location at + * which the integrity table is to be written. Furthermore, + * @wim->hdr.integrity is expected to be a resource entry which will be set + * to the integrity table information on success. In addition, if + * @old_lookup_table_end != 0, @wim->hdr.integrity must initially contain + * information about the old integrity table, and @wim->in_fd must be a + * seekable descriptor to the original WIM file opened for reading. * * @new_lookup_table_end: - * The offset of the byte directly following the lookup table in the WIM - * being written. + * The offset of the byte directly following the lookup table in the WIM + * being written. * * @old_lookup_table_end: - * If nonzero, the offset of the byte directly following the old lookup - * table in the WIM. + * If nonzero, the offset of the byte directly following the old lookup + * table in the WIM. * * @progress_func - * If non-NULL, a progress function that will be called after every - * calculated chunk. - * - * Returns: - * 0 on success, nonzero on failure. The possible error codes are: - * * WIMLIB_ERR_WRITE: Could not write the integrity table. - * * WIMLIB_ERR_READ: Could not read a chunk of data that needed - * to be checked. + * If non-NULL, a progress function that will be called after every + * calculated chunk. + * + * Return values: + * WIMLIB_ERR_SUCCESS (0) + * WIMLIB_ERR_NOMEM + * WIMLIB_ERR_UNEXPECTED_END_OF_FILE + * WIMLIB_ERR_WRITE */ -int write_integrity_table(FILE *fp, - struct resource_entry *integrity_res_entry, - off_t new_lookup_table_end, - off_t old_lookup_table_end, - wimlib_progress_func_t progress_func) +int +write_integrity_table(WIMStruct *wim, + off_t new_lookup_table_end, + off_t old_lookup_table_end, + wimlib_progress_func_t progress_func) { struct integrity_table *old_table; struct integrity_table *new_table; int ret; - off_t cur_offset; u32 new_table_size; wimlib_assert(old_lookup_table_end <= new_lookup_table_end); - cur_offset = ftello(fp); - if (cur_offset == -1) - return WIMLIB_ERR_WRITE; - - if (integrity_res_entry->offset == 0 || old_lookup_table_end == 0) { - old_table = NULL; - } else { - ret = read_integrity_table(integrity_res_entry, fp, + old_table = NULL; + if (wim_has_integrity_table(wim) && old_lookup_table_end != 0) { + ret = read_integrity_table(wim, old_lookup_table_end - WIM_HEADER_DISK_SIZE, &old_table); if (ret == WIMLIB_ERR_INVALID_INTEGRITY_TABLE) { @@ -393,10 +344,10 @@ int write_integrity_table(FILE *fp, } } - ret = calculate_integrity_table(fp, new_lookup_table_end, + ret = calculate_integrity_table(&wim->out_fd, new_lookup_table_end, old_table, old_lookup_table_end, progress_func, &new_table); - if (ret != 0) + if (ret) goto out_free_old_table; new_table_size = new_table->size; @@ -405,24 +356,14 @@ int write_integrity_table(FILE *fp, new_table->num_entries = cpu_to_le32(new_table->num_entries); new_table->chunk_size = cpu_to_le32(new_table->chunk_size); - if (fseeko(fp, cur_offset, SEEK_SET) != 0) { - ERROR_WITH_ERRNO("Failed to seek to byte %"PRIu64" of WIM to " - "write integrity table", cur_offset); - ret = WIMLIB_ERR_WRITE; - goto out_free_new_table; - } - - if (fwrite(new_table, 1, new_table_size, fp) != new_table_size) { - ERROR_WITH_ERRNO("Failed to write WIM integrity table"); - ret = WIMLIB_ERR_WRITE; - } else { - integrity_res_entry->offset = cur_offset; - integrity_res_entry->size = new_table_size; - integrity_res_entry->original_size = new_table_size; - integrity_res_entry->flags = 0; - ret = 0; - } -out_free_new_table: + ret = write_wim_resource_from_buffer(new_table, + new_table_size, + 0, + &wim->out_fd, + WIMLIB_COMPRESSION_TYPE_NONE, + &wim->hdr.integrity, + NULL, + 0); FREE(new_table); out_free_old_table: FREE(old_table); @@ -434,30 +375,31 @@ out_free_old_table: * * Checks a WIM for consistency with the integrity table. * - * @fp: - * FILE * to the WIM file, opened for reading. + * @in_fd: + * File descriptor to the WIM file, opened for reading. * * @table: - * The integrity table for the WIM, read into memory. + * The integrity table for the WIM, read into memory. * * @bytes_to_check: - * Number of bytes in the WIM that need to be checked (offset of end of the - * lookup table minus offset of end of the header). + * Number of bytes in the WIM that need to be checked (offset of end of the + * lookup table minus offset of end of the header). * * @progress_func - * If non-NULL, a progress function that will be called after every - * verified chunk. + * If non-NULL, a progress function that will be called after every + * verified chunk. * * Returns: - * > 0 (WIMLIB_ERR_*) on error - * 0 (WIM_INTEGRITY_OK) if the integrity was checked successfully and there - * were no inconsistencies. - * -1 (WIM_INTEGRITY_NOT_OK) if the WIM failed the integrity check. + * > 0 (WIMLIB_ERR_READ, WIMLIB_ERR_UNEXPECTED_END_OF_FILE) on error + * 0 (WIM_INTEGRITY_OK) if the integrity was checked successfully and there + * were no inconsistencies. + * -1 (WIM_INTEGRITY_NOT_OK) if the WIM failed the integrity check. */ -static int verify_integrity(FILE *fp, const tchar *filename, - const struct integrity_table *table, - u64 bytes_to_check, - wimlib_progress_func_t progress_func) +static int +verify_integrity(struct filedes *in_fd, const tchar *filename, + const struct integrity_table *table, + u64 bytes_to_check, + wimlib_progress_func_t progress_func) { int ret; u64 offset = WIM_HEADER_DISK_SIZE; @@ -482,8 +424,8 @@ static int verify_integrity(FILE *fp, const tchar *filename, else this_chunk_size = table->chunk_size; - ret = calculate_chunk_sha1(fp, this_chunk_size, offset, sha1_md); - if (ret != 0) + ret = calculate_chunk_sha1(in_fd, this_chunk_size, offset, sha1_md); + if (ret) return ret; if (!hashes_equal(sha1_md, table->sha1sums[i])) @@ -508,35 +450,37 @@ static int verify_integrity(FILE *fp, const tchar *filename, * ~10 MiB chunks of the WIM match up with the values given in the integrity * table. * - * @w: - * The WIM, opened for reading, and with the header already read. + * @wim: + * The WIM, opened for reading. * * @progress_func - * If non-NULL, a progress function that will be called after every - * verified chunk. + * If non-NULL, a progress function that will be called after every + * verified chunk. * * Returns: - * > 0 (WIMLIB_ERR_*) on error - * 0 (WIM_INTEGRITY_OK) if the integrity was checked successfully and there - * were no inconsistencies. - * -1 (WIM_INTEGRITY_NOT_OK) if the WIM failed the integrity check. - * -2 (WIM_INTEGRITY_NONEXISTENT) if the WIM contains no integrity - * information. + * > 0 (WIMLIB_ERR_INVALID_INTEGRITY_TABLE, WIMLIB_ERR_READ, + * WIMLIB_ERR_UNEXPECTED_END_OF_FILE) on error + * 0 (WIM_INTEGRITY_OK) if the integrity was checked successfully and there + * were no inconsistencies. + * -1 (WIM_INTEGRITY_NOT_OK) if the WIM failed the integrity check. + * -2 (WIM_INTEGRITY_NONEXISTENT) if the WIM contains no integrity + * information. */ -int check_wim_integrity(WIMStruct *w, wimlib_progress_func_t progress_func) +int +check_wim_integrity(WIMStruct *wim, wimlib_progress_func_t progress_func) { int ret; u64 bytes_to_check; struct integrity_table *table; u64 end_lookup_table_offset; - if (w->hdr.integrity.offset == 0) { + if (!wim_has_integrity_table(wim)) { DEBUG("No integrity information."); return WIM_INTEGRITY_NONEXISTENT; } - end_lookup_table_offset = w->hdr.lookup_table_res_entry.offset + - w->hdr.lookup_table_res_entry.size; + end_lookup_table_offset = wim->hdr.lookup_table_res_entry.offset + + wim->hdr.lookup_table_res_entry.size; if (end_lookup_table_offset < WIM_HEADER_DISK_SIZE) { ERROR("WIM lookup table ends before WIM header ends!"); @@ -545,11 +489,10 @@ int check_wim_integrity(WIMStruct *w, wimlib_progress_func_t progress_func) bytes_to_check = end_lookup_table_offset - WIM_HEADER_DISK_SIZE; - ret = read_integrity_table(&w->hdr.integrity, w->fp, - bytes_to_check, &table); - if (ret != 0) + ret = read_integrity_table(wim, bytes_to_check, &table); + if (ret) return ret; - ret = verify_integrity(w->fp, w->filename, table, + ret = verify_integrity(&wim->in_fd, wim->filename, table, bytes_to_check, progress_func); FREE(table); return ret;