digests: Add a compute and comparison function

[people/stevee/pakfire.git] / src / libpakfire / digest.c

/*#############################################################################
#                                                                             #
# Pakfire - The IPFire package management system                              #
# Copyright (C) 2022 Pakfire development team                                 #
#                                                                             #
# This program is free software: you can redistribute it and/or modify        #
# it under the terms of the GNU General Public License as published by        #
# the Free Software Foundation, either version 3 of the License, or           #
# (at your option) any later version.                                         #
#                                                                             #
# This program 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 General Public License for more details.                                #
#                                                                             #
# You should have received a copy of the GNU General Public License           #
# along with this program.  If not, see <http://www.gnu.org/licenses/>.       #
#                                                                             #
#############################################################################*/

#include <stdio.h>

#include <openssl/crypto.h>
#include <openssl/err.h>
#include <openssl/evp.h>

#include <pakfire/digest.h>
#include <pakfire/logging.h>
#include <pakfire/pakfire.h>
#include <pakfire/private.h>

static EVP_MD_CTX* __pakfire_digest_setup(struct pakfire* pakfire, const EVP_MD* md) {
	EVP_MD_CTX* ctx = NULL;
	int r;

	// Setup a new context
	ctx = EVP_MD_CTX_new();
	if (!ctx) {
		ERROR(pakfire, "Could not initialize OpenSSL context: %s\n",
			ERR_error_string(ERR_get_error(), NULL));
		r = 1;
		goto ERROR;
	}

	// Setup digest
	r = EVP_DigestInit_ex(ctx, md, NULL);
	if (r != 1) {
		ERROR(pakfire, "Could not setup digest: %s\n",
			ERR_error_string(ERR_get_error(), NULL));
		r = 1;
		goto ERROR;
	}

	return ctx;

ERROR:
	if (ctx)
		EVP_MD_CTX_free(ctx);

	return NULL;
}

int pakfire_digests_compute_from_file(struct pakfire* pakfire,
		struct pakfire_digests* digests, const int types, FILE* f) {
	EVP_MD_CTX* sha512_ctx = NULL;
	EVP_MD_CTX* sha256_ctx = NULL;
	char buffer[PAKFIRE_BUFFER_SIZE];
	int r = 1;

	// Initialize context for SHA-512
	if (types & PAKFIRE_DIGEST_SHA512) {
		sha512_ctx = __pakfire_digest_setup(pakfire, EVP_sha512());
		if (!sha512_ctx)
			goto ERROR;
	}

	// Initialize context for SHA-256
	if (types & PAKFIRE_DIGEST_SHA256) {
		sha512_ctx = __pakfire_digest_setup(pakfire, EVP_sha256());
		if (!sha512_ctx)
			goto ERROR;
	}

	// Read the file into the hash functions
	while (!feof(f)) {
		size_t bytes_read = fread(buffer, 1, sizeof(buffer), f);

		// Raise any reading errors
		if (ferror(f)) {
			r = 1;
			goto ERROR;
		}

		// SHA-512
		r = EVP_DigestUpdate(sha512_ctx, buffer, bytes_read);
		if (r != 1) {
			ERROR(pakfire, "EVP_Digest_Update() failed: %s\n",
				ERR_error_string(ERR_get_error(), NULL));
			r = 1;
			goto ERROR;
		}

		// SHA-256
		r = EVP_DigestUpdate(sha256_ctx, buffer, bytes_read);
		if (r != 1) {
			ERROR(pakfire, "EVP_Digest_Update() failed: %s\n",
				ERR_error_string(ERR_get_error(), NULL));
			r = 1;
			goto ERROR;
		}
	}

	// Finalize SHA-512
	r = EVP_DigestFinal_ex(sha512_ctx, digests->sha512, NULL);
	if (r != 1) {
		ERROR(pakfire, "EVP_DigestFinal_ex() failed: %s\n",
			ERR_error_string(ERR_get_error(), NULL));
		r = 1;
		goto ERROR;
	}

	// Finalize SHA-256
	r = EVP_DigestFinal_ex(sha256_ctx, digests->sha256, NULL);
	if (r != 1) {
		ERROR(pakfire, "EVP_DigestFinal_ex() failed: %s\n",
			ERR_error_string(ERR_get_error(), NULL));
		r = 1;
		goto ERROR;
	}

ERROR:
	if (sha512_ctx)
		EVP_MD_CTX_free(sha512_ctx);
	if (sha256_ctx)
		EVP_MD_CTX_free(sha256_ctx);

	return r;
}

int pakfire_digests_compare(struct pakfire* pakfire, const struct pakfire_digests* digests1,
		const struct pakfire_digests* digests2, const int types) {
	int r;

	// Check if we are at least comparing one type
	if (!types) {
		errno = EINVAL;
		return 1;
	}

	// Check SHA-512
	if (types & PAKFIRE_DIGEST_SHA512) {
		r = CRYPTO_memcmp(digests1->sha512, digests2->sha512, sizeof(digests1->sha512));
		if (r) {
			DEBUG(pakfire, "SHA-512 digest does not match\n");
			return 1;
		}
	}

	// Check SHA-256
	if (types & PAKFIRE_DIGEST_SHA256) {
		r = CRYPTO_memcmp(digests1->sha256, digests2->sha256, sizeof(digests1->sha256));
		if (r) {
			DEBUG(pakfire, "SHA-256 digest does not match\n");
			return 1;
		}
	}

	// All digests match
	return 0;
}