Skip to content

Commit 46c7258

Browse files
SamuelMarksSamuelMarks
committed
[acquire/tests/test_*.h] Increase test coverage ; [acquire_*.h,acquire/cli/cli.c] Modify code fixing issues test failures found ; [reports/test_coverage.svg] Regenerate on latest ctest run
1 parent 4a3bd46 commit 46c7258

14 files changed

+329
-56
lines changed

‎acquire/acquire_checksums.h‎

Lines changed: 7 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -54,7 +54,7 @@ int acquire_verify_async_start(struct acquire_handle *handle,
5454
if (!handle || !filepath || !expected_hash) {
5555
if (handle)
5656
acquire_handle_set_error(handle, ACQUIRE_ERROR_INVALID_ARGUMENT,
57-
"Invalid arguments");
57+
"Invalid arguments provided for verification");
5858
return -1;
5959
}
6060
handle->active_backend = ACQUIRE_BACKEND_NONE;
@@ -99,8 +99,9 @@ int acquire_verify_async_start(struct acquire_handle *handle,
9999
if (handle->error.code != ACQUIRE_OK)
100100
return -1;
101101
#endif /* defined(LIBACQUIRE_USE_CRC32C) && LIBACQUIRE_USE_CRC32C */
102-
acquire_handle_set_error(handle, ACQUIRE_ERROR_UNSUPPORTED_CHECKSUM_FORMAT,
103-
"Unsupported checksum or no backend");
102+
acquire_handle_set_error(
103+
handle, ACQUIRE_ERROR_UNSUPPORTED_CHECKSUM_FORMAT,
104+
"Unsupported checksum algorithm or no backend available");
104105
return -1;
105106
}
106107

@@ -130,7 +131,7 @@ enum acquire_status acquire_verify_async_poll(struct acquire_handle *handle) {
130131
if (handle->status != ACQUIRE_IN_PROGRESS)
131132
return handle->status;
132133
acquire_handle_set_error(handle, ACQUIRE_ERROR_UNKNOWN,
133-
"No active backend");
134+
"No active backend for checksum operation");
134135
return ACQUIRE_ERROR;
135136
}
136137
}
@@ -149,9 +150,9 @@ int acquire_verify_sync(struct acquire_handle *handle, const char *filepath,
149150
do {
150151
status = acquire_verify_async_poll(handle);
151152
#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
152-
Sleep(100); /* 100ms */
153+
Sleep(10); /* 10ms poll interval */
153154
#else
154-
usleep(100000); /* 100ms */
155+
usleep(10000); /* 10ms poll interval */
155156
#endif
156157
} while (status == ACQUIRE_IN_PROGRESS);
157158
return (status == ACQUIRE_COMPLETE) ? 0 : -1;

‎acquire/acquire_common_defs.h‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -11,6 +11,7 @@ enum Checksum {
1111
LIBACQUIRE_CRC32C,
1212
LIBACQUIRE_SHA256,
1313
LIBACQUIRE_SHA512,
14+
LIBACQUIRE_INVALID_CHECKSUM,
1415
LIBACQUIRE_UNSUPPORTED_CHECKSUM
1516
};
1617

‎acquire/acquire_libcurl.h‎

Lines changed: 5 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -114,8 +114,12 @@ int acquire_download_sync(struct acquire_handle *handle, const char *url,
114114
int acquire_download_async_start(struct acquire_handle *handle, const char *url,
115115
const char *dest_path) {
116116
struct curl_backend *be;
117-
if (!handle)
117+
if (!handle || !url || !dest_path) {
118+
if (handle)
119+
acquire_handle_set_error(handle, ACQUIRE_ERROR_INVALID_ARGUMENT,
120+
"Invalid arguments");
118121
return -1;
122+
}
119123

120124
be = (struct curl_backend *)calloc(1, sizeof(struct curl_backend));
121125
if (!be) {

‎acquire/acquire_libfetch.h‎

Lines changed: 5 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -121,8 +121,12 @@ int acquire_download_sync(struct acquire_handle *handle, const char *url,
121121
*/
122122
int acquire_download_async_start(struct acquire_handle *handle, const char *url,
123123
const char *dest_path) {
124-
if (handle == NULL)
124+
if (!handle || !url || !dest_path) {
125+
if (handle)
126+
acquire_handle_set_error(handle, ACQUIRE_ERROR_INVALID_ARGUMENT,
127+
"Invalid arguments");
125128
return -1;
129+
}
126130
handle->status = ACQUIRE_IN_PROGRESS;
127131
/* This implementation is blocking, all work done here. */
128132
return acquire_download_sync(handle, url, dest_path);

‎acquire/acquire_librhash.h‎

Lines changed: 12 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -82,7 +82,8 @@ int _librhash_verify_async_start(struct acquire_handle *handle,
8282
default:
8383
return -1;
8484
}
85-
if (strlen(expected_hash) != expected_len) {
85+
if (strlen(expected_hash) != expected_len &&
86+
!(algorithm == LIBACQUIRE_SHA512 && strlen(expected_hash) == 128)) {
8687
acquire_handle_set_error(handle, ACQUIRE_ERROR_UNSUPPORTED_CHECKSUM_FORMAT,
8788
"Invalid hash length for selected algorithm");
8889
return -1;
@@ -93,7 +94,8 @@ int _librhash_verify_async_start(struct acquire_handle *handle,
9394
}
9495
be = (struct rhash_backend *)calloc(1, sizeof(struct rhash_backend));
9596
if (!be) {
96-
acquire_handle_set_error(handle, ACQUIRE_ERROR_OUT_OF_MEMORY, "rhash");
97+
acquire_handle_set_error(handle, ACQUIRE_ERROR_OUT_OF_MEMORY,
98+
"rhash backend allocation failed");
9799
return -1;
98100
}
99101
be->file = fopen(filepath, "rb");
@@ -106,7 +108,8 @@ int _librhash_verify_async_start(struct acquire_handle *handle,
106108
be->handle = rhash_init(rhash_algo_id);
107109
if (!be->handle) {
108110
cleanup_rhash_backend(handle);
109-
acquire_handle_set_error(handle, ACQUIRE_ERROR_UNKNOWN, "rhash_init");
111+
acquire_handle_set_error(handle, ACQUIRE_ERROR_UNKNOWN,
112+
"rhash_init failed");
110113
return -1;
111114
}
112115
be->algorithm_id = rhash_algo_id;
@@ -125,15 +128,17 @@ enum acquire_status _librhash_verify_async_poll(struct acquire_handle *handle) {
125128
if (handle->status != ACQUIRE_IN_PROGRESS)
126129
return handle->status;
127130
if (handle->cancel_flag) {
128-
acquire_handle_set_error(handle, ACQUIRE_ERROR_CANCELLED, "Cancelled");
131+
acquire_handle_set_error(handle, ACQUIRE_ERROR_CANCELLED,
132+
"Checksum cancelled");
129133
cleanup_rhash_backend(handle);
130134
return ACQUIRE_ERROR;
131135
}
132136
be = (struct rhash_backend *)handle->backend_handle;
133137
bytes_read = fread(buffer, 1, sizeof(buffer), be->file);
134138
if (bytes_read > 0) {
135139
if (rhash_update(be->handle, buffer, bytes_read) < 0) {
136-
acquire_handle_set_error(handle, ACQUIRE_ERROR_UNKNOWN, "rhash_update");
140+
acquire_handle_set_error(handle, ACQUIRE_ERROR_UNKNOWN,
141+
"rhash_update failed");
137142
} else {
138143
handle->bytes_processed += bytes_read;
139144
return ACQUIRE_IN_PROGRESS;
@@ -148,14 +153,13 @@ enum acquire_status _librhash_verify_async_poll(struct acquire_handle *handle) {
148153
int digest_size = 0;
149154
rhash_final(be->handle, hash);
150155
digest_size = rhash_get_digest_size(be->algorithm_id);
151-
/*rhash_print_hex(computed_hex, hash, digest_size, RHPR_DEFAULT);*/
152156
to_hex(computed_hex, hash, (size_t)digest_size);
153157
if (strncasecmp(computed_hex, be->expected_hash, digest_size * 2) == 0) {
154158
handle->status = ACQUIRE_COMPLETE;
155159
} else {
156160
acquire_handle_set_error(handle, ACQUIRE_ERROR_UNKNOWN,
157-
"Hash mismatch: %s != %s", be->expected_hash,
158-
computed_hex);
161+
"Hash mismatch: expected %s, got %s",
162+
be->expected_hash, computed_hex);
159163
}
160164
}
161165
cleanup_rhash_backend(handle);

‎acquire/acquire_openssl.h‎

Lines changed: 31 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -27,13 +27,15 @@ void _openssl_verify_async_cancel(struct acquire_handle *handle);
2727
#endif
2828

2929
#ifdef LIBACQUIRE_IMPLEMENTATION
30-
#ifndef ACQUIRE_OPENSSL_IMPL_
31-
#define ACQUIRE_OPENSSL_IMPL_
3230

3331
#if (defined(LIBACQUIRE_USE_COMMON_CRYPTO) && LIBACQUIRE_USE_COMMON_CRYPTO || \
3432
defined(LIBACQUIRE_USE_OPENSSL) && LIBACQUIRE_USE_OPENSSL || \
3533
defined(LIBACQUIRE_USE_LIBRESSL) && LIBACQUIRE_USE_LIBRESSL)
3634

35+
#ifndef EVP_MAX_MD_SIZE
36+
#define EVP_MAX_MD_SIZE 64
37+
#endif /* !EVP_MAX_MD_SIZE */
38+
3739
#include "acquire_handle.h"
3840
#include <errno.h>
3941
#include <stdlib.h>
@@ -97,7 +99,8 @@ int _openssl_verify_async_start(struct acquire_handle *handle,
9799
}
98100
be = (struct openssl_backend *)calloc(1, sizeof(struct openssl_backend));
99101
if (!be) {
100-
acquire_handle_set_error(handle, ACQUIRE_ERROR_OUT_OF_MEMORY, "openssl");
102+
acquire_handle_set_error(handle, ACQUIRE_ERROR_OUT_OF_MEMORY,
103+
"openssl backend memory allocation failed");
101104
return -1;
102105
}
103106
be->file = fopen(filepath, "rb");
@@ -108,7 +111,7 @@ int _openssl_verify_async_start(struct acquire_handle *handle,
108111
return -1;
109112
}
110113

111-
#if defined(LIBACQUIRE_USE_COMMON_CRYPTO) || !LIBACQUIRE_USE_COMMON_CRYPTO
114+
#if defined(LIBACQUIRE_USE_COMMON_CRYPTO) && LIBACQUIRE_USE_COMMON_CRYPTO
112115
be->algorithm = algorithm;
113116
switch (algorithm) {
114117
case LIBACQUIRE_SHA256:
@@ -118,15 +121,21 @@ int _openssl_verify_async_start(struct acquire_handle *handle,
118121
CC_SHA512_Init(&be->ctx.sha512);
119122
break;
120123
default:
121-
break;
124+
/* Should have been caught by the switch above, but for safety: */
125+
cleanup_openssl_backend(handle);
126+
acquire_handle_set_error(
127+
handle, ACQUIRE_ERROR_UNSUPPORTED_CHECKSUM_FORMAT,
128+
"Internal error: unsupported algorithm in CommonCrypto backend");
129+
return -1;
122130
}
123131
#else
124132
const EVP_MD *md =
125133
(algorithm == LIBACQUIRE_SHA256) ? EVP_sha256() : EVP_sha512();
126134
be->ctx = EVP_MD_CTX_new();
127135
if (!be->ctx || (1 != EVP_DigestInit_ex(be->ctx, md, NULL))) {
128136
cleanup_openssl_backend(handle);
129-
acquire_handle_set_error(handle, ACQUIRE_ERROR_UNKNOWN, "EVP init failed");
137+
acquire_handle_set_error(handle, ACQUIRE_ERROR_UNKNOWN,
138+
"EVP_DigestInit_ex failed");
130139
return -1;
131140
}
132141
#endif
@@ -146,7 +155,8 @@ enum acquire_status _openssl_verify_async_poll(struct acquire_handle *handle) {
146155
if (handle->status != ACQUIRE_IN_PROGRESS)
147156
return handle->status;
148157
if (handle->cancel_flag) {
149-
acquire_handle_set_error(handle, ACQUIRE_ERROR_CANCELLED, "Cancelled");
158+
acquire_handle_set_error(handle, ACQUIRE_ERROR_CANCELLED,
159+
"Checksum cancelled");
150160
cleanup_openssl_backend(handle);
151161
return ACQUIRE_ERROR;
152162
}
@@ -162,11 +172,14 @@ enum acquire_status _openssl_verify_async_poll(struct acquire_handle *handle) {
162172
CC_SHA512_Update(&be->ctx.sha512, buffer, (CC_LONG)bytes_read);
163173
break;
164174
default:
175+
acquire_handle_set_error(handle, ACQUIRE_ERROR_UNKNOWN,
176+
"Internal CC algorithm error");
165177
break;
166178
}
167179
#else
168180
if (1 != EVP_DigestUpdate(be->ctx, buffer, bytes_read))
169-
acquire_handle_set_error(handle, ACQUIRE_ERROR_UNKNOWN, "EVP_Update");
181+
acquire_handle_set_error(handle, ACQUIRE_ERROR_UNKNOWN,
182+
"EVP_DigestUpdate failed");
170183
#endif
171184
if (handle->error.code == ACQUIRE_OK) {
172185
handle->bytes_processed += bytes_read;
@@ -177,11 +190,11 @@ enum acquire_status _openssl_verify_async_poll(struct acquire_handle *handle) {
177190
acquire_handle_set_error(handle, ACQUIRE_ERROR_FILE_READ_FAILED, "%s",
178191
strerror(errno));
179192
} else {
180-
unsigned char hash[CC_SHA512_DIGEST_LENGTH];
181-
char computed_hex[130];
193+
unsigned char hash[EVP_MAX_MD_SIZE];
194+
char computed_hex[EVP_MAX_MD_SIZE * 2 + 1];
182195
unsigned int len = 0;
183196
int i;
184-
#ifdef LIBACQUIRE_USE_COMMON_CRYPTO
197+
#if defined(LIBACQUIRE_USE_COMMON_CRYPTO) && LIBACQUIRE_USE_COMMON_CRYPTO
185198
switch (be->algorithm) {
186199
case LIBACQUIRE_SHA256:
187200
len = CC_SHA256_DIGEST_LENGTH;
@@ -192,22 +205,25 @@ enum acquire_status _openssl_verify_async_poll(struct acquire_handle *handle) {
192205
CC_SHA512_Final(hash, &be->ctx.sha512);
193206
break;
194207
default:
208+
acquire_handle_set_error(handle, ACQUIRE_ERROR_UNKNOWN,
209+
"Internal CC algorithm error");
195210
break;
196211
}
197212
#else
198213
if (1 != EVP_DigestFinal_ex(be->ctx, hash, &len))
199-
acquire_handle_set_error(handle, ACQUIRE_ERROR_UNKNOWN, "EVP_Final");
214+
acquire_handle_set_error(handle, ACQUIRE_ERROR_UNKNOWN,
215+
"EVP_DigestFinal_ex failed");
200216
#endif
201217
if (handle->error.code == ACQUIRE_OK) {
202-
for (i = 0; i < len; i++)
218+
for (i = 0; (unsigned int)i < len; i++)
203219
sprintf(computed_hex + (i * 2), "%02x", hash[i]);
204220
computed_hex[len * 2] = '\0';
205221
if (strncasecmp(computed_hex, be->expected_hash, len * 2) == 0)
206222
handle->status = ACQUIRE_COMPLETE;
207223
else
208224
acquire_handle_set_error(handle, ACQUIRE_ERROR_UNKNOWN,
209-
"Hash mismatch: %s != %s", be->expected_hash,
210-
computed_hex);
225+
"Hash mismatch: expected %s, got %s",
226+
be->expected_hash, computed_hex);
211227
}
212228
}
213229
cleanup_openssl_backend(handle);
@@ -222,7 +238,6 @@ void _openssl_verify_async_cancel(struct acquire_handle *handle) {
222238
LIBACQUIRE_USE_COMMON_CRYPTO || defined(LIBACQUIRE_USE_OPENSSL) && \
223239
LIBACQUIRE_USE_OPENSSL || defined(LIBACQUIRE_USE_LIBRESSL) && \
224240
LIBACQUIRE_USE_LIBRESSL) */
225-
#endif /* ACQUIRE_OPENSSL_IMPL_ */
226241
#endif /* defined(LIBACQUIRE_IMPLEMENTATION) */
227242

228243
#ifdef __cplusplus

‎acquire/acquire_wininet.h‎

Lines changed: 5 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -114,8 +114,12 @@ int acquire_download_sync(struct acquire_handle *handle, const char *url,
114114
*/
115115
int acquire_download_async_start(struct acquire_handle *handle, const char *url,
116116
const char *dest_path) {
117-
if (handle == NULL)
117+
if (!handle || !url || !dest_path) {
118+
if (handle)
119+
acquire_handle_set_error(handle, ACQUIRE_ERROR_INVALID_ARGUMENT,
120+
"Invalid arguments");
118121
return -1;
122+
}
119123
handle->status = ACQUIRE_IN_PROGRESS;
120124
/* This implementation is blocking, so all work completes here. */
121125
return acquire_download_sync(handle, url, dest_path);

‎acquire/cli/cli.c‎

Lines changed: 0 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -80,7 +80,6 @@ int docopt(struct DocoptArgs *args, int argc, char *argv[], const bool help,
8080
continue;
8181
}
8282

83-
/* Options with arguments */
8483
if (strncmp(arg, "--directory=", 12) == 0) {
8584
args->directory = (char *)(arg + 12);
8685
} else if (strcmp(arg, "-d") == 0 || strcmp(arg, "--directory") == 0) {
@@ -121,12 +120,10 @@ int docopt(struct DocoptArgs *args, int argc, char *argv[], const bool help,
121120
fprintf(stderr, "Unknown option: %s\n", arg);
122121
return EXIT_FAILURE;
123122
} else {
124-
/* Positional argument */
125123
if (!url_is_set) {
126124
args->url = (char *)arg;
127125
url_is_set = 1;
128126
}
129-
/* Note: This simple parser only handles one URL. */
130127
}
131128
}
132129

‎acquire/tests/test_checksum.h‎

Lines changed: 37 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -170,6 +170,35 @@ TEST test_invalid_hash_length(void) {
170170
PASS();
171171
}
172172

173+
#if defined(LIBACQUIRE_USE_LIBRHASH) && LIBACQUIRE_USE_LIBRHASH
174+
TEST test_librhash_invalid_hash_length_sha512(void) {
175+
struct acquire_handle *h = acquire_handle_init();
176+
int result;
177+
/* SHA512 has special handling for 128 vs 129, test a different failure */
178+
result = acquire_verify_sync(h, GREATEST_FILE, LIBACQUIRE_SHA512, "short");
179+
ASSERT_EQ(-1, result);
180+
ASSERT_EQ(ACQUIRE_ERROR_UNSUPPORTED_CHECKSUM_FORMAT,
181+
acquire_handle_get_error_code(h));
182+
acquire_handle_free(h);
183+
PASS();
184+
}
185+
#endif
186+
187+
#if (defined(LIBACQUIRE_USE_OPENSSL) && LIBACQUIRE_USE_OPENSSL) || \
188+
(defined(LIBACQUIRE_USE_COMMON_CRYPTO) && LIBACQUIRE_USE_COMMON_CRYPTO)
189+
TEST test_openssl_unsupported_algorithm(void) {
190+
struct acquire_handle *h = acquire_handle_init();
191+
/* crc32c is unsupported by the openssl backend */
192+
const int result = acquire_verify_sync(
193+
h, GREATEST_FILE, LIBACQUIRE_INVALID_CHECKSUM, "12345678");
194+
ASSERT_EQ(-1, result);
195+
ASSERT_EQ(ACQUIRE_ERROR_UNSUPPORTED_CHECKSUM_FORMAT,
196+
acquire_handle_get_error_code(h));
197+
acquire_handle_free(h);
198+
PASS();
199+
}
200+
#endif
201+
173202
TEST test_verify_reusability(void) {
174203
struct acquire_handle *h = acquire_handle_init();
175204
int result;
@@ -198,8 +227,15 @@ TEST test_verify_reusability(void) {
198227
}
199228

200229
SUITE(checksums_suite) {
201-
RUN_TEST(test_invalid_hash_length);
202230
RUN_TEST(test_unsupported_algorithm);
231+
RUN_TEST(test_invalid_hash_length);
232+
#if defined(LIBACQUIRE_USE_LIBRHASH) && LIBACQUIRE_USE_LIBRHASH
233+
RUN_TEST(test_librhash_invalid_hash_length_sha512);
234+
#endif
235+
#if (defined(LIBACQUIRE_USE_OPENSSL) && LIBACQUIRE_USE_OPENSSL) || \
236+
(defined(LIBACQUIRE_USE_COMMON_CRYPTO) && LIBACQUIRE_USE_COMMON_CRYPTO)
237+
RUN_TEST(test_openssl_unsupported_algorithm);
238+
#endif
203239
RUN_TEST(test_verify_sync_success_sha256);
204240
RUN_TEST(test_verify_sync_success_sha512);
205241
#if defined(LIBACQUIRE_USE_LIBRHASH) && LIBACQUIRE_USE_LIBRHASH || \

0 commit comments

Comments
 (0)