verify.c

Go to the documentation of this file.

/*
 * This file is part of the Aaru Data Preservation Suite.
 * Copyright (c) 2019-2025 Natalia Portillo.
 *
 * This library is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 of the
 * License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
 */
 
#include <aaruformat.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
 
#include "internal.h"
#include "log.h"
#include "utarray.h"
 
#define VERIFY_SIZE 1048576
 
static int32_t update_crc64_from_stream(FILE *stream, const uint64_t total_length, void *buffer, size_t buffer_size,
                                        crc64_ctx *crc_ctx, const char *label)
{
    uint64_t processed = 0;
 
    while(processed < total_length)
    {
        size_t   chunk     = buffer_size;
        uint64_t remaining = total_length - processed;
 
        if(remaining < chunk) chunk = (size_t)remaining;
 
        if(chunk == 0) break;
 
        size_t read_bytes = fread(buffer, 1, chunk, stream);
        if(read_bytes != chunk)
        {
            FATAL("Could not read %s chunk (expected %zu bytes, got %zu)", label, chunk, read_bytes);
            return AARUF_ERROR_CANNOT_READ_BLOCK;
        }
 
        aaruf_crc64_update(crc_ctx, buffer, read_bytes);
        processed += read_bytes;
    }
 
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_verify_image(void *context)
{
    TRACE("Entering aaruf_verify_image(%p)", context);
 
    aaruformat_context *ctx           = NULL;
    uint64_t            crc64         = 0;
    size_t              read_bytes    = 0;
    void               *buffer        = NULL;
    crc64_ctx          *crc64_context = NULL;
    BlockHeader         block_header;
    DdtHeader           ddt_header;
    DdtHeader2          ddt2_header;
    TracksHeader        tracks_header;
    uint32_t            signature     = 0;
    UT_array           *index_entries = NULL;
    int32_t             status        = AARUF_STATUS_OK;
 
    if(context == NULL)
    {
        FATAL("Invalid context");
        status = AARUF_ERROR_NOT_AARUFORMAT;
        goto cleanup;
    }
 
    ctx = context;
 
    if(ctx->magic != AARU_MAGIC)
    {
        FATAL("Invalid context");
        status = AARUF_ERROR_NOT_AARUFORMAT;
        goto cleanup;
    }
 
    if(ctx->imageStream == NULL)
    {
        FATAL("Image stream is not available");
        status = AARUF_ERROR_NOT_AARUFORMAT;
        goto cleanup;
    }
 
    if(fseek(ctx->imageStream, ctx->header.indexOffset, SEEK_SET) != 0)
    {
        FATAL("Could not seek to index offset %" PRIu64, ctx->header.indexOffset);
        status = AARUF_ERROR_CANNOT_READ_HEADER;
        goto cleanup;
    }
 
    TRACE("Reading index signature at position %" PRIu64, ctx->header.indexOffset);
    read_bytes = fread(&signature, 1, sizeof(signature), ctx->imageStream);
    if(read_bytes != sizeof(signature))
    {
        FATAL("Could not read index signature");
        status = AARUF_ERROR_CANNOT_READ_HEADER;
        goto cleanup;
    }
 
    if(signature != IndexBlock && signature != IndexBlock2 && signature != IndexBlock3)
    {
        FATAL("Incorrect index signature %4.4s", (char *)&signature);
        status = AARUF_ERROR_CANNOT_READ_INDEX;
        goto cleanup;
    }
 
    if(signature == IndexBlock)
        status = verify_index_v1(ctx);
    else if(signature == IndexBlock2)
        status = verify_index_v2(ctx);
    else
        status = verify_index_v3(ctx);
 
    if(status != AARUF_STATUS_OK)
    {
        FATAL("Index verification failed with error code %d", status);
        goto cleanup;
    }
 
    if(signature == IndexBlock)
        index_entries = process_index_v1(ctx);
    else if(signature == IndexBlock2)
        index_entries = process_index_v2(ctx);
    else
        index_entries = process_index_v3(ctx);
 
    if(index_entries == NULL)
    {
        FATAL("Could not process index");
        status = AARUF_ERROR_CANNOT_READ_INDEX;
        goto cleanup;
    }
 
    buffer = malloc(VERIFY_SIZE);
    if(buffer == NULL)
    {
        FATAL("Cannot allocate memory for verification buffer");
        status = AARUF_ERROR_NOT_ENOUGH_MEMORY;
        goto cleanup;
    }
 
    uint64_t crc_length;
    const unsigned int entry_count = utarray_len(index_entries);
 
    for(unsigned int i = 0; i < entry_count; i++)
    {
        IndexEntry *entry = utarray_eltptr(index_entries, i);
        TRACE("Checking block with type %4.4s at position %" PRIu64, (char *)&entry->blockType, entry->offset);
 
        if(fseek(ctx->imageStream, entry->offset, SEEK_SET) != 0)
        {
            FATAL("Could not seek to block at offset %" PRIu64, entry->offset);
            status = AARUF_ERROR_CANNOT_READ_BLOCK;
            goto cleanup;
        }
 
        switch(entry->blockType)
        {
            case DataBlock:
                read_bytes = fread(&block_header, 1, sizeof(BlockHeader), ctx->imageStream);
                if(read_bytes != sizeof(BlockHeader))
                {
                    FATAL("Could not read block header");
                    status = AARUF_ERROR_CANNOT_READ_BLOCK;
                    goto cleanup;
                }
 
                crc64_context = aaruf_crc64_init();
                if(crc64_context == NULL)
                {
                    FATAL("Could not initialize CRC64 context");
                    status = AARUF_ERROR_CANNOT_READ_BLOCK;
                    goto cleanup;
                }
 
                // For LZMA compression, skip the 5-byte properties header
                crc_length = block_header.cmpLength;
                if(block_header.compression == Lzma || block_header.compression == LzmaClauniaSubchannelTransform)
                {
                    // Skip LZMA properties
                    uint8_t props[LZMA_PROPERTIES_LENGTH];
                    size_t  read_props = fread(props, 1, LZMA_PROPERTIES_LENGTH, ctx->imageStream);
                    if(read_props != LZMA_PROPERTIES_LENGTH)
                    {
                        FATAL("Could not read LZMA properties");
                        status = AARUF_ERROR_CANNOT_READ_BLOCK;
                        goto cleanup;
                    }
                    crc_length -= LZMA_PROPERTIES_LENGTH;
                }
 
                status = update_crc64_from_stream(ctx->imageStream, crc_length, buffer, VERIFY_SIZE, crc64_context,
                                                  "data block");
                if(status != AARUF_STATUS_OK) goto cleanup;
 
                if(aaruf_crc64_final(crc64_context, &crc64) != 0)
                {
                    FATAL("Could not finalize CRC64 for data block");
                    status = AARUF_ERROR_CANNOT_READ_BLOCK;
                    goto cleanup;
                }
 
                if(ctx->header.imageMajorVersion <= AARUF_VERSION_V1) crc64 = bswap_64(crc64);
 
                if(crc64 != block_header.cmpCrc64)
                {
                    FATAL("Expected block CRC 0x%16llX but got 0x%16llX", block_header.cmpCrc64, crc64);
                    status = AARUF_ERROR_INVALID_BLOCK_CRC;
                    goto cleanup;
                }
 
                aaruf_crc64_free(crc64_context);
                crc64_context = NULL;
                break;
            case DeDuplicationTable:
                read_bytes = fread(&ddt_header, 1, sizeof(DdtHeader), ctx->imageStream);
                if(read_bytes != sizeof(DdtHeader))
                {
                    FATAL("Could not read DDT header");
                    status = AARUF_ERROR_CANNOT_READ_BLOCK;
                    goto cleanup;
                }
 
                crc64_context = aaruf_crc64_init();
                if(crc64_context == NULL)
                {
                    FATAL("Could not initialize CRC64 context");
                    status = AARUF_ERROR_CANNOT_READ_BLOCK;
                    goto cleanup;
                }
 
                // For LZMA compression, skip the 5-byte properties header
                crc_length = ddt_header.cmpLength;
                if(ddt_header.compression == Lzma || ddt_header.compression == LzmaClauniaSubchannelTransform)
                {
                    // Skip LZMA properties
                    uint8_t props[LZMA_PROPERTIES_LENGTH];
                    size_t  read_props = fread(props, 1, LZMA_PROPERTIES_LENGTH, ctx->imageStream);
                    if(read_props != LZMA_PROPERTIES_LENGTH)
                    {
                        FATAL("Could not read LZMA properties");
                        status = AARUF_ERROR_CANNOT_READ_BLOCK;
                        goto cleanup;
                    }
                    crc_length -= LZMA_PROPERTIES_LENGTH;
                }
 
                status = update_crc64_from_stream(ctx->imageStream, crc_length, buffer, VERIFY_SIZE, crc64_context,
                                                  "data block");
                if(status != AARUF_STATUS_OK) goto cleanup;
 
                if(aaruf_crc64_final(crc64_context, &crc64) != 0)
                {
                    FATAL("Could not finalize CRC64 for DDT block");
                    status = AARUF_ERROR_CANNOT_READ_BLOCK;
                    goto cleanup;
                }
 
                if(ctx->header.imageMajorVersion <= AARUF_VERSION_V1) crc64 = bswap_64(crc64);
 
                if(crc64 != ddt_header.cmpCrc64)
                {
                    FATAL("Expected DDT CRC 0x%16llX but got 0x%16llX", ddt_header.cmpCrc64, crc64);
                    status = AARUF_ERROR_INVALID_BLOCK_CRC;
                    goto cleanup;
                }
 
                aaruf_crc64_free(crc64_context);
                crc64_context = NULL;
                break;
            case DeDuplicationTable2:
                read_bytes = fread(&ddt2_header, 1, sizeof(DdtHeader2), ctx->imageStream);
                if(read_bytes != sizeof(DdtHeader2))
                {
                    FATAL("Could not read DDT2 header");
                    status = AARUF_ERROR_CANNOT_READ_BLOCK;
                    goto cleanup;
                }
 
                crc64_context = aaruf_crc64_init();
                if(crc64_context == NULL)
                {
                    FATAL("Could not initialize CRC64 context");
                    status = AARUF_ERROR_CANNOT_READ_BLOCK;
                    goto cleanup;
                }
 
                // For LZMA compression, skip the 5-byte properties header
                crc_length = ddt2_header.cmpLength;
                if(ddt2_header.compression == Lzma || ddt2_header.compression == LzmaClauniaSubchannelTransform)
                {
                    // Skip LZMA properties
                    uint8_t props[LZMA_PROPERTIES_LENGTH];
                    size_t  read_props = fread(props, 1, LZMA_PROPERTIES_LENGTH, ctx->imageStream);
                    if(read_props != LZMA_PROPERTIES_LENGTH)
                    {
                        FATAL("Could not read LZMA properties");
                        status = AARUF_ERROR_CANNOT_READ_BLOCK;
                        goto cleanup;
                    }
                    crc_length -= LZMA_PROPERTIES_LENGTH;
                }
 
                status = update_crc64_from_stream(ctx->imageStream, crc_length, buffer, VERIFY_SIZE, crc64_context,
                                                  "data block");
                if(status != AARUF_STATUS_OK) goto cleanup;
 
                if(aaruf_crc64_final(crc64_context, &crc64) != 0)
                {
                    FATAL("Could not finalize CRC64 for DDT2 block");
                    status = AARUF_ERROR_CANNOT_READ_BLOCK;
                    goto cleanup;
                }
 
                if(crc64 != ddt2_header.cmpCrc64)
                {
                    FATAL("Expected DDT2 CRC 0x%16llX but got 0x%16llX", ddt2_header.cmpCrc64, crc64);
                    status = AARUF_ERROR_INVALID_BLOCK_CRC;
                    goto cleanup;
                }
 
                aaruf_crc64_free(crc64_context);
                crc64_context = NULL;
                break;
            case TracksBlock:
            {
                read_bytes = fread(&tracks_header, 1, sizeof(TracksHeader), ctx->imageStream);
                if(read_bytes != sizeof(TracksHeader))
                {
                    FATAL("Could not read tracks header");
                    status = AARUF_ERROR_CANNOT_READ_BLOCK;
                    goto cleanup;
                }
 
                const uint64_t tracks_bytes = (uint64_t)tracks_header.entries * sizeof(TrackEntry);
                if(tracks_header.entries != 0 && tracks_bytes / sizeof(TrackEntry) != tracks_header.entries)
                {
                    FATAL("Tracks header length overflow (entries=%u)", tracks_header.entries);
                    status = AARUF_ERROR_CANNOT_READ_BLOCK;
                    goto cleanup;
                }
 
                crc64_context = aaruf_crc64_init();
                if(crc64_context == NULL)
                {
                    FATAL("Could not initialize CRC64 context");
                    status = AARUF_ERROR_CANNOT_READ_BLOCK;
                    goto cleanup;
                }
 
                status = update_crc64_from_stream(ctx->imageStream, tracks_bytes, buffer, VERIFY_SIZE, crc64_context,
                                                  "tracks block");
                if(status != AARUF_STATUS_OK) goto cleanup;
 
                if(aaruf_crc64_final(crc64_context, &crc64) != 0)
                {
                    FATAL("Could not finalize CRC64 for tracks block");
                    status = AARUF_ERROR_CANNOT_READ_BLOCK;
                    goto cleanup;
                }
 
                if(ctx->header.imageMajorVersion <= AARUF_VERSION_V1) crc64 = bswap_64(crc64);
 
                if(crc64 != tracks_header.crc64)
                {
                    FATAL("Expected tracks CRC 0x%16llX but got 0x%16llX", tracks_header.crc64, crc64);
                    status = AARUF_ERROR_INVALID_BLOCK_CRC;
                    goto cleanup;
                }
 
                aaruf_crc64_free(crc64_context);
                crc64_context = NULL;
                break;
            }
            default:
                TRACE("Ignoring block type %4.4s", (char *)&entry->blockType);
                break;
        }
    }
 
    status = AARUF_STATUS_OK;
 
cleanup:
    if(crc64_context != NULL)
    {
        aaruf_crc64_free(crc64_context);
        crc64_context = NULL;
    }
 
    if(buffer != NULL)
    {
        free(buffer);
        buffer = NULL;
    }
 
    if(index_entries != NULL)
    {
        utarray_free(index_entries);
        index_entries = NULL;
    }
 
    TRACE("Exiting aaruf_verify_image() = %d", status);
    return status;
}