From: Michael Tremer Date: Fri, 26 Aug 2022 08:05:50 +0000 (+0000) Subject: digest: Rename SHA-512/256 to SHA-2-512/256 X-Git-Tag: 0.9.28~363 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=4500ed0a9c841a319dd910533d96c6945cd85026;p=pakfire.git digest: Rename SHA-512/256 to SHA-2-512/256 Signed-off-by: Michael Tremer --- diff --git a/src/_pakfire/_pakfiremodule.c b/src/_pakfire/_pakfiremodule.c index b00b000de..da78553e7 100644 --- a/src/_pakfire/_pakfiremodule.c +++ b/src/_pakfire/_pakfiremodule.c @@ -114,9 +114,9 @@ PyMODINIT_FUNC PyInit__pakfire(void) { } // Add digest constants - if (PyModule_AddIntMacro(module, PAKFIRE_DIGEST_SHA512)) + if (PyModule_AddIntMacro(module, PAKFIRE_DIGEST_SHA2_512)) return NULL; - if (PyModule_AddIntMacro(module, PAKFIRE_DIGEST_SHA256)) + if (PyModule_AddIntMacro(module, PAKFIRE_DIGEST_SHA2_256)) return NULL; // Pakfire diff --git a/src/_pakfire/package.c b/src/_pakfire/package.c index 45211a878..a9fbdbe8a 100644 --- a/src/_pakfire/package.c +++ b/src/_pakfire/package.c @@ -208,27 +208,27 @@ static PyObject* Package_get_hexdigest(PackageObject* self, enum pakfire_digest_ return PyUnicode_FromString(hexdigest); } -static PyObject* Package_get_hexdigest_sha256(PackageObject* self) { - return Package_get_hexdigest(self, PAKFIRE_DIGEST_SHA256); +static PyObject* Package_get_hexdigest_sha2_256(PackageObject* self) { + return Package_get_hexdigest(self, PAKFIRE_DIGEST_SHA2_256); } -static PyObject* Package_get_hexdigest_sha512(PackageObject* self) { - return Package_get_hexdigest(self, PAKFIRE_DIGEST_SHA512); +static PyObject* Package_get_hexdigest_sha2_512(PackageObject* self) { + return Package_get_hexdigest(self, PAKFIRE_DIGEST_SHA2_512); } static int Package_set_hexdigest(PackageObject* self, - enum pakfire_digest_types type, PyObject* value) { + const enum pakfire_digest_types type, PyObject* value) { const char* hexdigest = PyUnicode_FromValue(value); return pakfire_package_set_hexdigest(self->package, type, hexdigest); } -static int Package_set_hexdigest_sha256(PackageObject* self, PyObject* value) { - return Package_set_hexdigest(self, PAKFIRE_DIGEST_SHA256, value); +static int Package_set_hexdigest_sha2_256(PackageObject* self, PyObject* value) { + return Package_set_hexdigest(self, PAKFIRE_DIGEST_SHA2_256, value); } -static int Package_set_hexdigest_sha512(PackageObject* self, PyObject* value) { - return Package_set_hexdigest(self, PAKFIRE_DIGEST_SHA512, value); +static int Package_set_hexdigest_sha2_512(PackageObject* self, PyObject* value) { + return Package_set_hexdigest(self, PAKFIRE_DIGEST_SHA2_512, value); } static PyObject* Package_get_summary(PackageObject* self) { @@ -776,16 +776,16 @@ static struct PyGetSetDef Package_getsetters[] = { NULL }, { - "hexdigest_sha256", - (getter)Package_get_hexdigest_sha256, - (setter)Package_set_hexdigest_sha256, + "hexdigest_sha2_256", + (getter)Package_get_hexdigest_sha2_256, + (setter)Package_set_hexdigest_sha2_256, NULL, NULL }, { - "hexdigest_sha512", - (getter)Package_get_hexdigest_sha512, - (setter)Package_set_hexdigest_sha512, + "hexdigest_sha2_512", + (getter)Package_get_hexdigest_sha2_512, + (setter)Package_set_hexdigest_sha2_512, NULL, NULL }, diff --git a/src/libpakfire/archive.c b/src/libpakfire/archive.c index 192a56238..dd7d20dac 100644 --- a/src/libpakfire/archive.c +++ b/src/libpakfire/archive.c @@ -925,12 +925,12 @@ static int pakfire_archive_make_package_from_json(struct pakfire_archive* archiv // Set digest switch (PAKFIRE_ARCHIVE_CHECKSUM) { - case PAKFIRE_DIGEST_SHA512: - pakfire_package_set_digest(pkg, PAKFIRE_ARCHIVE_CHECKSUM, digests.sha512); + case PAKFIRE_DIGEST_SHA2_512: + pakfire_package_set_digest(pkg, PAKFIRE_ARCHIVE_CHECKSUM, digests.sha2_512); break; - case PAKFIRE_DIGEST_SHA256: - pakfire_package_set_digest(pkg, PAKFIRE_ARCHIVE_CHECKSUM, digests.sha256); + case PAKFIRE_DIGEST_SHA2_256: + pakfire_package_set_digest(pkg, PAKFIRE_ARCHIVE_CHECKSUM, digests.sha2_256); break; case PAKFIRE_DIGEST_UNDEFINED: @@ -1264,12 +1264,12 @@ static int pakfire_archive_make_legacy_package(struct pakfire_archive* archive, // Set digest switch (PAKFIRE_ARCHIVE_CHECKSUM) { - case PAKFIRE_DIGEST_SHA512: - pakfire_package_set_digest(pkg, PAKFIRE_ARCHIVE_CHECKSUM, digests.sha512); + case PAKFIRE_DIGEST_SHA2_512: + pakfire_package_set_digest(pkg, PAKFIRE_ARCHIVE_CHECKSUM, digests.sha2_512); break; - case PAKFIRE_DIGEST_SHA256: - pakfire_package_set_digest(pkg, PAKFIRE_ARCHIVE_CHECKSUM, digests.sha256); + case PAKFIRE_DIGEST_SHA2_256: + pakfire_package_set_digest(pkg, PAKFIRE_ARCHIVE_CHECKSUM, digests.sha2_256); break; case PAKFIRE_DIGEST_UNDEFINED: diff --git a/src/libpakfire/db.c b/src/libpakfire/db.c index 0596f9fa7..4635b6fa7 100644 --- a/src/libpakfire/db.c +++ b/src/libpakfire/db.c @@ -836,8 +836,8 @@ static const struct pakfire_digest { enum pakfire_digest_types type; const char* prefix; } pakfire_digests[] = { - { PAKFIRE_DIGEST_SHA512, "sha512:" }, - { PAKFIRE_DIGEST_SHA256, "sha256:" }, + { PAKFIRE_DIGEST_SHA2_512, "sha512:" }, + { PAKFIRE_DIGEST_SHA2_256, "sha256:" }, { 0, NULL }, }; @@ -1100,7 +1100,7 @@ static int pakfire_db_add_files(struct pakfire_db* db, unsigned long id, struct size_t sha512_length = 0; // SHA-512 Digest - sha512_digest = pakfire_file_get_digest(file, PAKFIRE_DIGEST_SHA512, &sha512_length); + sha512_digest = pakfire_file_get_digest(file, PAKFIRE_DIGEST_SHA2_512, &sha512_length); if (sha512_digest) { r = sqlite3_bind_blob(stmt, 12, sha512_digest, sha512_length, NULL); } else { @@ -1117,7 +1117,7 @@ static int pakfire_db_add_files(struct pakfire_db* db, unsigned long id, struct size_t sha256_length = 0; // SHA-256 Digest - sha256_digest = pakfire_file_get_digest(file, PAKFIRE_DIGEST_SHA256, &sha256_length); + sha256_digest = pakfire_file_get_digest(file, PAKFIRE_DIGEST_SHA2_256, &sha256_length); if (sha256_digest) { r = sqlite3_bind_blob(stmt, 13, sha256_digest, sha256_length, NULL); } else { @@ -2120,12 +2120,12 @@ static int pakfire_db_load_file(struct pakfire_db* db, struct pakfire_filelist* pakfire_file_set_mtime(file, mtime); // SHA-512 Digest - r = pakfire_db_load_file_digest(db, file, stmt, PAKFIRE_DIGEST_SHA512, 7); + r = pakfire_db_load_file_digest(db, file, stmt, PAKFIRE_DIGEST_SHA2_512, 7); if (r) goto ERROR; // SHA-256 Digest - r = pakfire_db_load_file_digest(db, file, stmt, PAKFIRE_DIGEST_SHA256, 8); + r = pakfire_db_load_file_digest(db, file, stmt, PAKFIRE_DIGEST_SHA2_256, 8); if (r) goto ERROR; diff --git a/src/libpakfire/digest.c b/src/libpakfire/digest.c index 362355f23..c35be92c6 100644 --- a/src/libpakfire/digest.c +++ b/src/libpakfire/digest.c @@ -39,10 +39,10 @@ size_t pakfire_digest_length(const enum pakfire_digest_types digest) { case PAKFIRE_DIGEST_BLAKE2S256: return BLAKE2S256_DIGEST_LENGTH; - case PAKFIRE_DIGEST_SHA512: + case PAKFIRE_DIGEST_SHA2_512: return SHA512_DIGEST_LENGTH; - case PAKFIRE_DIGEST_SHA256: + case PAKFIRE_DIGEST_SHA2_256: return SHA256_DIGEST_LENGTH; case PAKFIRE_DIGEST_UNDEFINED: @@ -68,13 +68,13 @@ void pakfire_digests_reset(struct pakfire_digests* digests, int types) { if (!types) types = ~types; - // Reset SHA-512 - if (types & PAKFIRE_DIGEST_SHA512) - memset(digests->sha512, 0, sizeof(digests->sha512)); + // Reset SHA-2-512 + if (types & PAKFIRE_DIGEST_SHA2_512) + memset(digests->sha2_512, 0, sizeof(digests->sha2_512)); - // Reset SHA-256 - if (types & PAKFIRE_DIGEST_SHA256) - memset(digests->sha256, 0, sizeof(digests->sha256)); + // Reset SHA-2-256 + if (types & PAKFIRE_DIGEST_SHA2_256) + memset(digests->sha2_256, 0, sizeof(digests->sha2_256)); } static int pakfire_digests_check_length(struct pakfire* pakfire, @@ -165,8 +165,8 @@ int pakfire_digests_compute_from_file(struct pakfire* pakfire, struct pakfire_digests* digests, const int types, FILE* f) { EVP_MD_CTX* blake2b512_ctx = NULL; EVP_MD_CTX* blake2s256_ctx = NULL; - EVP_MD_CTX* sha512_ctx = NULL; - EVP_MD_CTX* sha256_ctx = NULL; + EVP_MD_CTX* sha2_512_ctx = NULL; + EVP_MD_CTX* sha2_256_ctx = NULL; char buffer[PAKFIRE_BUFFER_SIZE]; int r = 1; @@ -185,16 +185,16 @@ int pakfire_digests_compute_from_file(struct pakfire* pakfire, } // Initialize context for SHA-512 - if (types & PAKFIRE_DIGEST_SHA512) { - sha512_ctx = __pakfire_digest_setup(pakfire, EVP_sha512()); - if (!sha512_ctx) + if (types & PAKFIRE_DIGEST_SHA2_512) { + sha2_512_ctx = __pakfire_digest_setup(pakfire, EVP_sha512()); + if (!sha2_512_ctx) goto ERROR; } // Initialize context for SHA-256 - if (types & PAKFIRE_DIGEST_SHA256) { - sha256_ctx = __pakfire_digest_setup(pakfire, EVP_sha256()); - if (!sha256_ctx) + if (types & PAKFIRE_DIGEST_SHA2_256) { + sha2_256_ctx = __pakfire_digest_setup(pakfire, EVP_sha256()); + if (!sha2_256_ctx) goto ERROR; } @@ -218,13 +218,13 @@ int pakfire_digests_compute_from_file(struct pakfire* pakfire, if (r) goto ERROR; - // SHA-512 - r = __pakfire_digest_update(pakfire, sha512_ctx, buffer, bytes_read); + // SHA-2-512 + r = __pakfire_digest_update(pakfire, sha2_512_ctx, buffer, bytes_read); if (r) goto ERROR; - // SHA-256 - r = __pakfire_digest_update(pakfire, sha256_ctx, buffer, bytes_read); + // SHA-2-256 + r = __pakfire_digest_update(pakfire, sha2_256_ctx, buffer, bytes_read); if (r) goto ERROR; } @@ -240,12 +240,12 @@ int pakfire_digests_compute_from_file(struct pakfire* pakfire, goto ERROR; // Finalize SHA-512 - r = __pakfire_digest_finalize(pakfire, sha512_ctx, digests->sha512); + r = __pakfire_digest_finalize(pakfire, sha2_512_ctx, digests->sha2_512); if (r) goto ERROR; // Finalize SHA-256 - r = __pakfire_digest_finalize(pakfire, sha256_ctx, digests->sha256); + r = __pakfire_digest_finalize(pakfire, sha2_256_ctx, digests->sha2_256); if (r) goto ERROR; @@ -257,10 +257,10 @@ ERROR: EVP_MD_CTX_free(blake2b512_ctx); if (blake2s256_ctx) EVP_MD_CTX_free(blake2s256_ctx); - if (sha512_ctx) - EVP_MD_CTX_free(sha512_ctx); - if (sha256_ctx) - EVP_MD_CTX_free(sha256_ctx); + if (sha2_512_ctx) + EVP_MD_CTX_free(sha2_512_ctx); + if (sha2_256_ctx) + EVP_MD_CTX_free(sha2_256_ctx); // Reset file offset to the beginning rewind(f); @@ -317,21 +317,21 @@ int pakfire_digests_compare(struct pakfire* pakfire, const struct pakfire_digest } // Check SHA-512 - if (types & PAKFIRE_DIGEST_SHA512) { - r = CRYPTO_memcmp(digests1->sha512, digests2->sha512, sizeof(digests1->sha512)); + if (types & PAKFIRE_DIGEST_SHA2_512) { + r = CRYPTO_memcmp(digests1->sha2_512, digests2->sha2_512, sizeof(digests1->sha2_512)); if (r) { - pakfire_digests_compare_mismatch(pakfire, "SHA-512", - digests1->sha512, digests2->sha512, sizeof(digests1->sha512)); + pakfire_digests_compare_mismatch(pakfire, "SHA-2-512", + digests1->sha2_512, digests2->sha2_512, sizeof(digests1->sha2_512)); return 1; } } // Check SHA-256 - if (types & PAKFIRE_DIGEST_SHA256) { - r = CRYPTO_memcmp(digests1->sha256, digests2->sha256, sizeof(digests1->sha256)); + if (types & PAKFIRE_DIGEST_SHA2_256) { + r = CRYPTO_memcmp(digests1->sha2_256, digests2->sha2_256, sizeof(digests1->sha2_256)); if (r) { - pakfire_digests_compare_mismatch(pakfire, "SHA-256", - digests1->sha256, digests2->sha256, sizeof(digests1->sha256)); + pakfire_digests_compare_mismatch(pakfire, "SHA-2-256", + digests1->sha2_256, digests2->sha2_256, sizeof(digests1->sha2_256)); return 1; } } @@ -359,12 +359,12 @@ int pakfire_digests_compare_one(struct pakfire* pakfire, struct pakfire_digests* memcpy(digests2.blake2s256, digest, sizeof(digests2.blake2s256)); break; - case PAKFIRE_DIGEST_SHA512: - memcpy(digests2.sha512, digest, sizeof(digests2.sha512)); + case PAKFIRE_DIGEST_SHA2_512: + memcpy(digests2.sha2_512, digest, sizeof(digests2.sha2_512)); break; - case PAKFIRE_DIGEST_SHA256: - memcpy(digests2.sha256, digest, sizeof(digests2.sha256)); + case PAKFIRE_DIGEST_SHA2_256: + memcpy(digests2.sha2_256, digest, sizeof(digests2.sha2_256)); break; case PAKFIRE_DIGEST_UNDEFINED: diff --git a/src/libpakfire/downloader.c b/src/libpakfire/downloader.c index 6a872c8ad..c5947d1ea 100644 --- a/src/libpakfire/downloader.c +++ b/src/libpakfire/downloader.c @@ -354,11 +354,11 @@ static struct pakfire_transfer* pakfire_downloader_create_transfer( transfer->md = EVP_blake2s256(); break; - case PAKFIRE_DIGEST_SHA512: + case PAKFIRE_DIGEST_SHA2_512: transfer->md = EVP_sha512(); break; - case PAKFIRE_DIGEST_SHA256: + case PAKFIRE_DIGEST_SHA2_256: transfer->md = EVP_sha256(); break; diff --git a/src/libpakfire/file.c b/src/libpakfire/file.c index cced21ea2..e42e8622c 100644 --- a/src/libpakfire/file.c +++ b/src/libpakfire/file.c @@ -151,15 +151,15 @@ static int pakfire_file_from_archive_entry(struct pakfire_file* file, struct arc if (r) goto ERROR; - // Digest: SHA-512 - } else if (strcmp(attr, "PAKFIRE.digests.sha512") == 0) { - r = pakfire_file_set_digest(file, PAKFIRE_DIGEST_SHA512, value, size); + // Digest: SHA-2-512 + } else if (strcmp(attr, "PAKFIRE.digests.sha2_512") == 0) { + r = pakfire_file_set_digest(file, PAKFIRE_DIGEST_SHA2_512, value, size); if (r) goto ERROR; - // Digest: SHA-256 - } else if (strcmp(attr, "PAKFIRE.digests.sha256") == 0) { - r = pakfire_file_set_digest(file, PAKFIRE_DIGEST_SHA256, value, size); + // Digest: SHA-2-256 + } else if (strcmp(attr, "PAKFIRE.digests.sha2_256") == 0) { + r = pakfire_file_set_digest(file, PAKFIRE_DIGEST_SHA2_256, value, size); if (r) goto ERROR; @@ -296,15 +296,15 @@ struct archive_entry* pakfire_file_archive_entry(struct pakfire_file* file) { archive_entry_xattr_add_entry(entry, "PAKFIRE.digests.blake2s256", file->digests.blake2s256, sizeof(file->digests.blake2s256)); - // SHA-512 - if (pakfire_digest_set(file->digests.sha512)) - archive_entry_xattr_add_entry(entry, "PAKFIRE.digests.sha512", - file->digests.sha512, sizeof(file->digests.sha512)); + // SHA-2-512 + if (pakfire_digest_set(file->digests.sha2_512)) + archive_entry_xattr_add_entry(entry, "PAKFIRE.digests.sha2_512", + file->digests.sha2_512, sizeof(file->digests.sha2_512)); - // SHA-256 - if (pakfire_digest_set(file->digests.sha256)) - archive_entry_xattr_add_entry(entry, "PAKFIRE.digests.sha256", - file->digests.sha256, sizeof(file->digests.sha256)); + // SHA-2-256 + if (pakfire_digest_set(file->digests.sha2_256)) + archive_entry_xattr_add_entry(entry, "PAKFIRE.digests.sha2_256", + file->digests.sha2_256, sizeof(file->digests.sha2_256)); return entry; } @@ -499,23 +499,23 @@ PAKFIRE_EXPORT const unsigned char* pakfire_file_get_digest( return file->digests.blake2s256; - case PAKFIRE_DIGEST_SHA512: - if (!pakfire_digest_set(file->digests.sha512)) + case PAKFIRE_DIGEST_SHA2_512: + if (!pakfire_digest_set(file->digests.sha2_512)) return NULL; if (length) - *length = sizeof(file->digests.sha512); + *length = sizeof(file->digests.sha2_512); - return file->digests.sha512; + return file->digests.sha2_512; - case PAKFIRE_DIGEST_SHA256: - if (!pakfire_digest_set(file->digests.sha256)) + case PAKFIRE_DIGEST_SHA2_256: + if (!pakfire_digest_set(file->digests.sha2_256)) return NULL; if (length) - *length = sizeof(file->digests.sha256); + *length = sizeof(file->digests.sha2_256); - return file->digests.sha256; + return file->digests.sha2_256; case PAKFIRE_DIGEST_UNDEFINED: break; @@ -548,12 +548,12 @@ PAKFIRE_EXPORT int pakfire_file_set_digest(struct pakfire_file* file, memcpy(file->digests.blake2s256, digest, sizeof(file->digests.blake2s256)); break; - case PAKFIRE_DIGEST_SHA512: - memcpy(file->digests.sha512, digest, sizeof(file->digests.sha512)); + case PAKFIRE_DIGEST_SHA2_512: + memcpy(file->digests.sha2_512, digest, sizeof(file->digests.sha2_512)); break; - case PAKFIRE_DIGEST_SHA256: - memcpy(file->digests.sha256, digest, sizeof(file->digests.sha256)); + case PAKFIRE_DIGEST_SHA2_256: + memcpy(file->digests.sha2_256, digest, sizeof(file->digests.sha2_256)); break; case PAKFIRE_DIGEST_UNDEFINED: @@ -830,11 +830,11 @@ static int pakfire_file_verify_payload(struct pakfire_file* file, const struct s } // Check if this file has any digests at all - if (pakfire_digest_set(file->digests.sha512)) - digest_types |= PAKFIRE_DIGEST_SHA512; + if (pakfire_digest_set(file->digests.sha2_512)) + digest_types |= PAKFIRE_DIGEST_SHA2_512; - if (pakfire_digest_set(file->digests.sha256)) - digest_types |= PAKFIRE_DIGEST_SHA256; + if (pakfire_digest_set(file->digests.sha2_256)) + digest_types |= PAKFIRE_DIGEST_SHA2_256; if (!digest_types) { ERROR(file->pakfire, "%s: No digests available\n", file->path); diff --git a/src/libpakfire/include/pakfire/digest.h b/src/libpakfire/include/pakfire/digest.h index f059c5ce4..6b6072907 100644 --- a/src/libpakfire/include/pakfire/digest.h +++ b/src/libpakfire/include/pakfire/digest.h @@ -24,8 +24,8 @@ // Pakfire knows these digests enum pakfire_digest_types { PAKFIRE_DIGEST_UNDEFINED = 0, - PAKFIRE_DIGEST_SHA256 = (1 << 0), - PAKFIRE_DIGEST_SHA512 = (1 << 1), + PAKFIRE_DIGEST_SHA2_256 = (1 << 0), + PAKFIRE_DIGEST_SHA2_512 = (1 << 1), PAKFIRE_DIGEST_BLAKE2S256 = (1 << 2), PAKFIRE_DIGEST_BLAKE2B512 = (1 << 3), }; @@ -41,7 +41,7 @@ enum pakfire_digest_types { #include // libsolv only supports storing one checksum which has to be of a supported type -#define PAKFIRE_ARCHIVE_CHECKSUM PAKFIRE_DIGEST_SHA512 +#define PAKFIRE_ARCHIVE_CHECKSUM PAKFIRE_DIGEST_SHA2_512 // Define BLAKE2's digest lengths #ifndef BLAKE2S256_DIGEST_LENGTH @@ -60,19 +60,19 @@ struct pakfire_digests { // BLAKE2s256 unsigned char blake2s256[BLAKE2S256_DIGEST_LENGTH]; - // SHA-512 - unsigned char sha512[SHA512_DIGEST_LENGTH]; + // SHA2-512 + unsigned char sha2_512[SHA512_DIGEST_LENGTH]; - // SHA-256 - unsigned char sha256[SHA256_DIGEST_LENGTH]; + // SHA2-256 + unsigned char sha2_256[SHA256_DIGEST_LENGTH]; }; #define PAKFIRE_DIGESTS_INIT \ { \ .blake2b512 = 0, \ .blake2s256 = 0, \ - .sha512 = 0, \ - .sha256 = 0, \ + .sha2_512 = 0, \ + .sha2_256 = 0, \ } size_t pakfire_digest_length(const enum pakfire_digest_types digest); diff --git a/src/libpakfire/package.c b/src/libpakfire/package.c index a9eb3b740..9f56e5656 100644 --- a/src/libpakfire/package.c +++ b/src/libpakfire/package.c @@ -399,10 +399,10 @@ PAKFIRE_EXPORT void pakfire_package_set_uuid(struct pakfire_package* pkg, const static enum pakfire_digest_types pakfire_package_id2digest(Id id) { switch (id) { case REPOKEY_TYPE_SHA512: - return PAKFIRE_DIGEST_SHA512; + return PAKFIRE_DIGEST_SHA2_512; case REPOKEY_TYPE_SHA256: - return PAKFIRE_DIGEST_SHA256; + return PAKFIRE_DIGEST_SHA2_256; } return 0; @@ -450,11 +450,11 @@ PAKFIRE_EXPORT int pakfire_package_set_digest(struct pakfire_package* pkg, int r = 1; switch (type) { - case PAKFIRE_DIGEST_SHA256: + case PAKFIRE_DIGEST_SHA2_256: id = REPOKEY_TYPE_SHA256; break; - case PAKFIRE_DIGEST_SHA512: + case PAKFIRE_DIGEST_SHA2_512: id = REPOKEY_TYPE_SHA512; break; @@ -1141,11 +1141,11 @@ PAKFIRE_EXPORT char* pakfire_package_dump(struct pakfire_package* pkg, int flags // Digest const char* hexdigest = pakfire_package_get_hexdigest(pkg, &digest); switch (digest) { - case PAKFIRE_DIGEST_SHA512: + case PAKFIRE_DIGEST_SHA2_512: pakfire_package_dump_add_line(&string, _("SHA512 Digest"), hexdigest); break; - case PAKFIRE_DIGEST_SHA256: + case PAKFIRE_DIGEST_SHA2_256: pakfire_package_dump_add_line(&string, _("SHA256 Digest"), hexdigest); break; diff --git a/src/pakfire/constants.py b/src/pakfire/constants.py index cbfcc1a85..b0c462cb3 100644 --- a/src/pakfire/constants.py +++ b/src/pakfire/constants.py @@ -27,8 +27,8 @@ from .__version__ import PAKFIRE_VERSION # Fetch digest constants from ._pakfire import ( - PAKFIRE_DIGEST_SHA512, - PAKFIRE_DIGEST_SHA256, + PAKFIRE_DIGEST_SHA2_512, + PAKFIRE_DIGEST_SHA2_256, ) # The default hub to connect to. diff --git a/tests/libpakfire/digest.c b/tests/libpakfire/digest.c index 1084eedfc..12b7c1759 100644 --- a/tests/libpakfire/digest.c +++ b/tests/libpakfire/digest.c @@ -27,7 +27,7 @@ const char* RANDOM_FILE = ABS_TOP_SRCDIR "/tests/data/digest/random"; static const struct pakfire_digests expected_digests = { - .sha512 = { + .sha2_512 = { 0xa1, 0x98, 0x97, 0x9b, 0x13, 0x44, 0xf3, 0x64, 0x48, 0x0e, 0x0f, 0xd1, 0xbc, 0xde, 0x8f, 0x50, 0xf3, 0x3c, 0x92, 0x8e, 0xf0, 0xe7, 0x5d, 0x6e, 0x1a, 0x28, 0x67, 0x1e, 0x16, 0x49, 0x7b, 0xc2, 0xd6, 0x64, 0xe5, 0x21, @@ -35,7 +35,7 @@ static const struct pakfire_digests expected_digests = { 0x16, 0xe7, 0xe7, 0x27, 0x33, 0xd9, 0x66, 0xb5, 0x0a, 0x39, 0x6d, 0xa8, 0xb2, 0xb4, 0xac, 0x05, }, - .sha256 = { + .sha2_256 = { 0x16, 0xf9, 0x01, 0xc1, 0x83, 0x31, 0x43, 0x88, 0x4f, 0x16, 0x6a, 0xe4, 0x81, 0x34, 0x51, 0x99, 0xcf, 0x91, 0x94, 0xa3, 0xb6, 0x01, 0x75, 0xd9, 0xb9, 0xca, 0x93, 0xd9, 0xd7, 0xa0, 0x4b, 0xa6, @@ -46,8 +46,8 @@ static int test_init(const struct test* t) { struct pakfire_digests digests = PAKFIRE_DIGESTS_INIT; // Check if everything is initialized correctly - ASSERT(pakfire_digest_set(digests.sha512) == 0); - ASSERT(pakfire_digest_set(digests.sha256) == 0); + ASSERT(pakfire_digest_set(digests.sha2_512) == 0); + ASSERT(pakfire_digest_set(digests.sha2_256) == 0); return EXIT_SUCCESS; @@ -68,13 +68,13 @@ static int test_random(const struct test* t) { // Compare the digests ASSERT_SUCCESS(pakfire_digests_compare(t->pakfire, - &digests, &expected_digests, PAKFIRE_DIGESTS_ALL)); + &digests, &expected_digests, PAKFIRE_DIGEST_SHA2_512|PAKFIRE_DIGEST_SHA2_256)); // Check if the individual digests match ASSERT_SUCCESS(pakfire_digests_compare_one(t->pakfire, &digests, - PAKFIRE_DIGEST_SHA512, expected_digests.sha512, sizeof(expected_digests.sha512))); + PAKFIRE_DIGEST_SHA2_512, expected_digests.sha2_512, sizeof(expected_digests.sha2_512))); ASSERT_SUCCESS(pakfire_digests_compare_one(t->pakfire, &digests, - PAKFIRE_DIGEST_SHA256, expected_digests.sha256, sizeof(expected_digests.sha256))); + PAKFIRE_DIGEST_SHA2_256, expected_digests.sha2_256, sizeof(expected_digests.sha2_256))); r = EXIT_SUCCESS;