1 /*-
2 * Copyright (c) 2025 Nicholas Vinson
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer
9 * in this position and unchanged.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 */
25
26 #include "test.h"
27
28 #define __LIBARCHIVE_BUILD 1
29 #include "archive_digest_private.h"
30
31 struct expected_digests {
32 unsigned char md5[16];
33 unsigned char rmd160[20];
34 unsigned char sha1[20];
35 unsigned char sha256[32];
36 unsigned char sha384[48];
37 unsigned char sha512[64];
38 };
39
40 archive_md5_ctx expectedMd5Ctx;
41 archive_rmd160_ctx expectedRmd160Ctx;
42 archive_sha1_ctx expectedSha1Ctx;
43 archive_sha256_ctx expectedSha256Ctx;
44 archive_sha384_ctx expectedSha384Ctx;
45 archive_sha512_ctx expectedSha512Ctx;
46
DEFINE_TEST(test_write_format_mtree_digests_no_digests_set_no_data)47 DEFINE_TEST(test_write_format_mtree_digests_no_digests_set_no_data)
48 {
49 char buff[4096] = {0};
50 size_t used = 0;
51 struct archive *a;
52 struct archive_entry *entry;
53 struct expected_digests ed;
54
55 #ifdef ARCHIVE_HAS_MD5
56 assertEqualInt(ARCHIVE_OK, archive_md5_init(&expectedMd5Ctx));
57 assertEqualInt(ARCHIVE_OK, archive_md5_update(&expectedMd5Ctx, "", 0));
58 assertEqualInt(ARCHIVE_OK, archive_md5_final(&expectedMd5Ctx, ed.md5));
59 #endif
60
61 #ifdef ARCHIVE_HAS_RMD160
62 assertEqualInt(ARCHIVE_OK, archive_rmd160_init(&expectedRmd160Ctx));
63 assertEqualInt(ARCHIVE_OK, archive_rmd160_update(&expectedRmd160Ctx, "", 0));
64 assertEqualInt(ARCHIVE_OK, archive_rmd160_final(&expectedRmd160Ctx, ed.rmd160));
65 #endif
66
67 #ifdef ARCHIVE_HAS_SHA1
68 assertEqualInt(ARCHIVE_OK, archive_sha1_init(&expectedSha1Ctx));
69 assertEqualInt(ARCHIVE_OK, archive_sha1_update(&expectedSha1Ctx, "", 0));
70 assertEqualInt(ARCHIVE_OK, archive_sha1_final(&expectedSha1Ctx, ed.sha1));
71 #endif
72
73 #ifdef ARCHIVE_HAS_SHA256
74 assertEqualInt(ARCHIVE_OK, archive_sha256_init(&expectedSha256Ctx));
75 assertEqualInt(ARCHIVE_OK, archive_sha256_update(&expectedSha256Ctx, "", 0));
76 assertEqualInt(ARCHIVE_OK, archive_sha256_final(&expectedSha256Ctx, ed.sha256));
77 #endif
78
79 #ifdef ARCHIVE_HAS_SHA384
80 assertEqualInt(ARCHIVE_OK, archive_sha384_init(&expectedSha384Ctx));
81 assertEqualInt(ARCHIVE_OK, archive_sha384_update(&expectedSha384Ctx, "", 0));
82 assertEqualInt(ARCHIVE_OK, archive_sha384_final(&expectedSha384Ctx, ed.sha384));
83 #endif
84
85 #ifdef ARCHIVE_HAS_SHA512
86 assertEqualInt(ARCHIVE_OK, archive_sha512_init(&expectedSha512Ctx));
87 assertEqualInt(ARCHIVE_OK, archive_sha512_update(&expectedSha512Ctx, "", 0));
88 assertEqualInt(ARCHIVE_OK, archive_sha512_final(&expectedSha512Ctx, ed.sha512));
89 #endif
90
91 assert((a = archive_write_new()) != NULL);
92 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_mtree(a));
93 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_options(a, "all"));
94 assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, sizeof(buff) - 1, &used));
95 assert((entry = archive_entry_new()) != NULL);
96 archive_entry_set_pathname(entry, "test.data");
97 archive_entry_set_filetype(entry, AE_IFREG);
98 archive_entry_set_size(entry, 4);
99 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, entry));
100 archive_entry_free(entry);
101 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
102 assertEqualIntA(a, ARCHIVE_OK, archive_write_free(a));
103
104 assert((a = archive_read_new()) != NULL);
105 assert((entry = archive_entry_new()) != NULL);
106 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
107 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
108 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));
109 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &entry));
110
111 #ifdef ARCHIVE_HAS_MD5
112 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_MD5), ed.md5, sizeof(ed.md5)) == 0);
113 #endif
114
115 #ifdef ARCHIVE_HAS_RMD160
116 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_RMD160), ed.rmd160, sizeof(ed.rmd160)) == 0);
117 #endif
118
119 #ifdef ARCHIVE_HAS_SHA1
120 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA1), ed.sha1, sizeof(ed.sha1)) == 0);
121 #endif
122
123 #ifdef ARCHIVE_HAS_SHA256
124 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA256), ed.sha256, sizeof(ed.sha256)) == 0);
125 #endif
126
127 #ifdef ARCHIVE_HAS_SHA384
128 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA384), ed.sha384, sizeof(ed.sha384)) == 0);
129 #endif
130
131 #ifdef ARCHIVE_HAS_SHA512
132 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA512), ed.sha512, sizeof(ed.sha512)) == 0);
133 #endif
134 archive_entry_free(entry);
135 }
136
DEFINE_TEST(test_write_format_mtree_digests_no_digests_set_empty_data)137 DEFINE_TEST(test_write_format_mtree_digests_no_digests_set_empty_data)
138 {
139 char buff[4096] = {0};
140 size_t used = 0;
141 struct archive *a;
142 struct archive_entry *entry;
143 struct expected_digests ed;
144
145 #ifdef ARCHIVE_HAS_MD5
146 assertEqualInt(ARCHIVE_OK, archive_md5_init(&expectedMd5Ctx));
147 assertEqualInt(ARCHIVE_OK, archive_md5_update(&expectedMd5Ctx, "", 0));
148 assertEqualInt(ARCHIVE_OK, archive_md5_final(&expectedMd5Ctx, ed.md5));
149 #endif
150
151 #ifdef ARCHIVE_HAS_RMD160
152 assertEqualInt(ARCHIVE_OK, archive_rmd160_init(&expectedRmd160Ctx));
153 assertEqualInt(ARCHIVE_OK, archive_rmd160_update(&expectedRmd160Ctx, "", 0));
154 assertEqualInt(ARCHIVE_OK, archive_rmd160_final(&expectedRmd160Ctx, ed.rmd160));
155 #endif
156
157 #ifdef ARCHIVE_HAS_SHA1
158 assertEqualInt(ARCHIVE_OK, archive_sha1_init(&expectedSha1Ctx));
159 assertEqualInt(ARCHIVE_OK, archive_sha1_update(&expectedSha1Ctx, "", 0));
160 assertEqualInt(ARCHIVE_OK, archive_sha1_final(&expectedSha1Ctx, ed.sha1));
161 #endif
162
163 #ifdef ARCHIVE_HAS_SHA256
164 assertEqualInt(ARCHIVE_OK, archive_sha256_init(&expectedSha256Ctx));
165 assertEqualInt(ARCHIVE_OK, archive_sha256_update(&expectedSha256Ctx, "", 0));
166 assertEqualInt(ARCHIVE_OK, archive_sha256_final(&expectedSha256Ctx, ed.sha256));
167 #endif
168
169 #ifdef ARCHIVE_HAS_SHA384
170 assertEqualInt(ARCHIVE_OK, archive_sha384_init(&expectedSha384Ctx));
171 assertEqualInt(ARCHIVE_OK, archive_sha384_update(&expectedSha384Ctx, "", 0));
172 assertEqualInt(ARCHIVE_OK, archive_sha384_final(&expectedSha384Ctx, ed.sha384));
173 #endif
174
175 #ifdef ARCHIVE_HAS_SHA512
176 assertEqualInt(ARCHIVE_OK, archive_sha512_init(&expectedSha512Ctx));
177 assertEqualInt(ARCHIVE_OK, archive_sha512_update(&expectedSha512Ctx, "", 0));
178 assertEqualInt(ARCHIVE_OK, archive_sha512_final(&expectedSha512Ctx, ed.sha512));
179 #endif
180
181 assert((a = archive_write_new()) != NULL);
182 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_mtree(a));
183 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_options(a, "all"));
184 assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, sizeof(buff) - 1, &used));
185 assert((entry = archive_entry_new()) != NULL);
186 archive_entry_set_pathname(entry, "test.data");
187 archive_entry_set_filetype(entry, AE_IFREG);
188 archive_entry_set_size(entry, 4);
189 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, entry));
190 archive_write_data(a, "", 0);
191 archive_entry_free(entry);
192 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
193 assertEqualIntA(a, ARCHIVE_OK, archive_write_free(a));
194
195 assert((a = archive_read_new()) != NULL);
196 assert((entry = archive_entry_new()) != NULL);
197 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
198 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
199 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));
200 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &entry));
201
202 #ifdef ARCHIVE_HAS_MD5
203 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_MD5), ed.md5, sizeof(ed.md5)) == 0);
204 #endif
205
206 #ifdef ARCHIVE_HAS_RMD160
207 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_RMD160), ed.rmd160, sizeof(ed.rmd160)) == 0);
208 #endif
209
210 #ifdef ARCHIVE_HAS_SHA1
211 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA1), ed.sha1, sizeof(ed.sha1)) == 0);
212 #endif
213
214 #ifdef ARCHIVE_HAS_SHA256
215 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA256), ed.sha256, sizeof(ed.sha256)) == 0);
216 #endif
217
218 #ifdef ARCHIVE_HAS_SHA384
219 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA384), ed.sha384, sizeof(ed.sha384)) == 0);
220 #endif
221
222 #ifdef ARCHIVE_HAS_SHA512
223 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA512), ed.sha512, sizeof(ed.sha512)) == 0);
224 #endif
225 archive_entry_free(entry);
226 }
227
DEFINE_TEST(test_write_format_mtree_digests_no_digests_set_non_empty_data)228 DEFINE_TEST(test_write_format_mtree_digests_no_digests_set_non_empty_data)
229 {
230 char buff[4096] = {0};
231 size_t used = 0;
232 struct archive *a;
233 struct archive_entry *entry;
234 struct expected_digests ed;
235 char *data = "abcd";
236
237 #ifdef ARCHIVE_HAS_MD5
238 assertEqualInt(ARCHIVE_OK, archive_md5_init(&expectedMd5Ctx));
239 assertEqualInt(ARCHIVE_OK, archive_md5_update(&expectedMd5Ctx, data, 4));
240 assertEqualInt(ARCHIVE_OK, archive_md5_final(&expectedMd5Ctx, ed.md5));
241 #endif
242
243 #ifdef ARCHIVE_HAS_RMD160
244 assertEqualInt(ARCHIVE_OK, archive_rmd160_init(&expectedRmd160Ctx));
245 assertEqualInt(ARCHIVE_OK, archive_rmd160_update(&expectedRmd160Ctx, data, 4));
246 assertEqualInt(ARCHIVE_OK, archive_rmd160_final(&expectedRmd160Ctx, ed.rmd160));
247 #endif
248
249 #ifdef ARCHIVE_HAS_SHA1
250 assertEqualInt(ARCHIVE_OK, archive_sha1_init(&expectedSha1Ctx));
251 assertEqualInt(ARCHIVE_OK, archive_sha1_update(&expectedSha1Ctx, data, 4));
252 assertEqualInt(ARCHIVE_OK, archive_sha1_final(&expectedSha1Ctx, ed.sha1));
253 #endif
254
255 #ifdef ARCHIVE_HAS_SHA256
256 assertEqualInt(ARCHIVE_OK, archive_sha256_init(&expectedSha256Ctx));
257 assertEqualInt(ARCHIVE_OK, archive_sha256_update(&expectedSha256Ctx, data, 4));
258 assertEqualInt(ARCHIVE_OK, archive_sha256_final(&expectedSha256Ctx, ed.sha256));
259 #endif
260
261 #ifdef ARCHIVE_HAS_SHA384
262 assertEqualInt(ARCHIVE_OK, archive_sha384_init(&expectedSha384Ctx));
263 assertEqualInt(ARCHIVE_OK, archive_sha384_update(&expectedSha384Ctx, data, 4));
264 assertEqualInt(ARCHIVE_OK, archive_sha384_final(&expectedSha384Ctx, ed.sha384));
265 #endif
266
267 #ifdef ARCHIVE_HAS_SHA512
268 assertEqualInt(ARCHIVE_OK, archive_sha512_init(&expectedSha512Ctx));
269 assertEqualInt(ARCHIVE_OK, archive_sha512_update(&expectedSha512Ctx, data, 4));
270 assertEqualInt(ARCHIVE_OK, archive_sha512_final(&expectedSha512Ctx, ed.sha512));
271 #endif
272
273 assert((a = archive_write_new()) != NULL);
274 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_mtree(a));
275 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_options(a, "all"));
276 assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, sizeof(buff) - 1, &used));
277 assert((entry = archive_entry_new()) != NULL);
278 archive_entry_set_pathname(entry, "test.data");
279 archive_entry_set_filetype(entry, AE_IFREG);
280 archive_entry_set_size(entry, 4);
281 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, entry));
282 archive_write_data(a, data, 4);
283 archive_entry_free(entry);
284 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
285 assertEqualIntA(a, ARCHIVE_OK, archive_write_free(a));
286
287 assert((a = archive_read_new()) != NULL);
288 assert((entry = archive_entry_new()) != NULL);
289 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
290 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
291 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));
292 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &entry));
293
294 #ifdef ARCHIVE_HAS_MD5
295 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_MD5), ed.md5, sizeof(ed.md5)) == 0);
296 #endif
297
298 #ifdef ARCHIVE_HAS_RMD160
299 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_RMD160), ed.rmd160, sizeof(ed.rmd160)) == 0);
300 #endif
301
302 #ifdef ARCHIVE_HAS_SHA1
303 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA1), ed.sha1, sizeof(ed.sha1)) == 0);
304 #endif
305
306 #ifdef ARCHIVE_HAS_SHA256
307 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA256), ed.sha256, sizeof(ed.sha256)) == 0);
308 #endif
309
310 #ifdef ARCHIVE_HAS_SHA384
311 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA384), ed.sha384, sizeof(ed.sha384)) == 0);
312 #endif
313
314 #ifdef ARCHIVE_HAS_SHA512
315 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA512), ed.sha512, sizeof(ed.sha512)) == 0);
316 #endif
317 archive_entry_free(entry);
318 }
319
DEFINE_TEST(test_write_format_mtree_digests_md5_digest_set_no_data)320 DEFINE_TEST(test_write_format_mtree_digests_md5_digest_set_no_data)
321 {
322 #ifdef ARCHIVE_HAS_MD5
323 char buff[4096] = {0};
324 size_t used = 0;
325 struct archive *a;
326 struct archive_entry *entry;
327 struct expected_digests ed;
328
329 memcpy(ed.md5, ((unsigned char[]) {
330 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
331 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
332 }), sizeof(ed.md5));
333
334 #ifdef ARCHIVE_HAS_RMD160
335 assertEqualInt(ARCHIVE_OK, archive_rmd160_init(&expectedRmd160Ctx));
336 assertEqualInt(ARCHIVE_OK, archive_rmd160_update(&expectedRmd160Ctx, "", 0));
337 assertEqualInt(ARCHIVE_OK, archive_rmd160_final(&expectedRmd160Ctx, ed.rmd160));
338 #endif
339
340 #ifdef ARCHIVE_HAS_SHA1
341 assertEqualInt(ARCHIVE_OK, archive_sha1_init(&expectedSha1Ctx));
342 assertEqualInt(ARCHIVE_OK, archive_sha1_update(&expectedSha1Ctx, "", 0));
343 assertEqualInt(ARCHIVE_OK, archive_sha1_final(&expectedSha1Ctx, ed.sha1));
344 #endif
345
346 #ifdef ARCHIVE_HAS_SHA256
347 assertEqualInt(ARCHIVE_OK, archive_sha256_init(&expectedSha256Ctx));
348 assertEqualInt(ARCHIVE_OK, archive_sha256_update(&expectedSha256Ctx, "", 0));
349 assertEqualInt(ARCHIVE_OK, archive_sha256_final(&expectedSha256Ctx, ed.sha256));
350 #endif
351
352 #ifdef ARCHIVE_HAS_SHA384
353 assertEqualInt(ARCHIVE_OK, archive_sha384_init(&expectedSha384Ctx));
354 assertEqualInt(ARCHIVE_OK, archive_sha384_update(&expectedSha384Ctx, "", 0));
355 assertEqualInt(ARCHIVE_OK, archive_sha384_final(&expectedSha384Ctx, ed.sha384));
356 #endif
357
358 #ifdef ARCHIVE_HAS_SHA512
359 assertEqualInt(ARCHIVE_OK, archive_sha512_init(&expectedSha512Ctx));
360 assertEqualInt(ARCHIVE_OK, archive_sha512_update(&expectedSha512Ctx, "", 0));
361 assertEqualInt(ARCHIVE_OK, archive_sha512_final(&expectedSha512Ctx, ed.sha512));
362 #endif
363
364 assert((a = archive_write_new()) != NULL);
365 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_mtree(a));
366 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_options(a, "all"));
367 assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, sizeof(buff) - 1, &used));
368 assert((entry = archive_entry_new()) != NULL);
369 archive_entry_set_pathname(entry, "test.data");
370 archive_entry_set_filetype(entry, AE_IFREG);
371 archive_entry_set_size(entry, 4);
372 archive_entry_set_digest(entry, ARCHIVE_ENTRY_DIGEST_MD5, ed.md5);
373 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, entry));
374 archive_entry_free(entry);
375 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
376 assertEqualIntA(a, ARCHIVE_OK, archive_write_free(a));
377
378 assert((a = archive_read_new()) != NULL);
379 assert((entry = archive_entry_new()) != NULL);
380 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
381 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
382 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));
383 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &entry));
384
385 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_MD5), ed.md5, sizeof(ed.md5)) == 0);
386
387 #ifdef ARCHIVE_HAS_RMD160
388 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_RMD160), ed.rmd160, sizeof(ed.rmd160)) == 0);
389 #endif
390
391 #ifdef ARCHIVE_HAS_SHA1
392 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA1), ed.sha1, sizeof(ed.sha1)) == 0);
393 #endif
394
395 #ifdef ARCHIVE_HAS_SHA256
396 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA256), ed.sha256, sizeof(ed.sha256)) == 0);
397 #endif
398
399 #ifdef ARCHIVE_HAS_SHA384
400 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA384), ed.sha384, sizeof(ed.sha384)) == 0);
401 #endif
402
403 #ifdef ARCHIVE_HAS_SHA512
404 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA512), ed.sha512, sizeof(ed.sha512)) == 0);
405 #endif
406 archive_entry_free(entry);
407 #else
408 skipping("This platform does not support MD5");
409 return;
410 #endif
411 }
412
DEFINE_TEST(test_write_format_mtree_digests_md5_digest_set_empty_data)413 DEFINE_TEST(test_write_format_mtree_digests_md5_digest_set_empty_data)
414 {
415 #ifdef ARCHIVE_HAS_MD5
416 char buff[4096] = {0};
417 size_t used = 0;
418 struct archive *a;
419 struct archive_entry *entry;
420 struct expected_digests ed;
421
422 memcpy(ed.md5, ((unsigned char[]) {
423 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
424 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
425 }), sizeof(ed.md5));
426
427 #ifdef ARCHIVE_HAS_RMD160
428 assertEqualInt(ARCHIVE_OK, archive_rmd160_init(&expectedRmd160Ctx));
429 assertEqualInt(ARCHIVE_OK, archive_rmd160_update(&expectedRmd160Ctx, "", 0));
430 assertEqualInt(ARCHIVE_OK, archive_rmd160_final(&expectedRmd160Ctx, ed.rmd160));
431 #endif
432
433 #ifdef ARCHIVE_HAS_SHA1
434 assertEqualInt(ARCHIVE_OK, archive_sha1_init(&expectedSha1Ctx));
435 assertEqualInt(ARCHIVE_OK, archive_sha1_update(&expectedSha1Ctx, "", 0));
436 assertEqualInt(ARCHIVE_OK, archive_sha1_final(&expectedSha1Ctx, ed.sha1));
437 #endif
438
439 #ifdef ARCHIVE_HAS_SHA256
440 assertEqualInt(ARCHIVE_OK, archive_sha256_init(&expectedSha256Ctx));
441 assertEqualInt(ARCHIVE_OK, archive_sha256_update(&expectedSha256Ctx, "", 0));
442 assertEqualInt(ARCHIVE_OK, archive_sha256_final(&expectedSha256Ctx, ed.sha256));
443 #endif
444
445 #ifdef ARCHIVE_HAS_SHA384
446 assertEqualInt(ARCHIVE_OK, archive_sha384_init(&expectedSha384Ctx));
447 assertEqualInt(ARCHIVE_OK, archive_sha384_update(&expectedSha384Ctx, "", 0));
448 assertEqualInt(ARCHIVE_OK, archive_sha384_final(&expectedSha384Ctx, ed.sha384));
449 #endif
450
451 #ifdef ARCHIVE_HAS_SHA512
452 assertEqualInt(ARCHIVE_OK, archive_sha512_init(&expectedSha512Ctx));
453 assertEqualInt(ARCHIVE_OK, archive_sha512_update(&expectedSha512Ctx, "", 0));
454 assertEqualInt(ARCHIVE_OK, archive_sha512_final(&expectedSha512Ctx, ed.sha512));
455 #endif
456
457 assert((a = archive_write_new()) != NULL);
458 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_mtree(a));
459 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_options(a, "all"));
460 assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, sizeof(buff) - 1, &used));
461 assert((entry = archive_entry_new()) != NULL);
462 archive_entry_set_pathname(entry, "test.data");
463 archive_entry_set_filetype(entry, AE_IFREG);
464 archive_entry_set_size(entry, 4);
465 archive_entry_set_digest(entry, ARCHIVE_ENTRY_DIGEST_MD5, ed.md5);
466 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, entry));
467 archive_write_data(a, "", 0);
468 archive_entry_free(entry);
469 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
470 assertEqualIntA(a, ARCHIVE_OK, archive_write_free(a));
471
472 assert((a = archive_read_new()) != NULL);
473 assert((entry = archive_entry_new()) != NULL);
474 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
475 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
476 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));
477 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &entry));
478
479 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_MD5), ed.md5, sizeof(ed.md5)) != 0);
480
481 assertEqualInt(ARCHIVE_OK, archive_md5_init(&expectedMd5Ctx));
482 assertEqualInt(ARCHIVE_OK, archive_md5_update(&expectedMd5Ctx, "", 0));
483 assertEqualInt(ARCHIVE_OK, archive_md5_final(&expectedMd5Ctx, ed.md5));
484
485 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_MD5), ed.md5, sizeof(ed.md5)) == 0);
486
487 #ifdef ARCHIVE_HAS_RMD160
488 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_RMD160), ed.rmd160, sizeof(ed.rmd160)) == 0);
489 #endif
490
491 #ifdef ARCHIVE_HAS_SHA1
492 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA1), ed.sha1, sizeof(ed.sha1)) == 0);
493 #endif
494
495 #ifdef ARCHIVE_HAS_SHA256
496 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA256), ed.sha256, sizeof(ed.sha256)) == 0);
497 #endif
498
499 #ifdef ARCHIVE_HAS_SHA384
500 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA384), ed.sha384, sizeof(ed.sha384)) == 0);
501 #endif
502
503 #ifdef ARCHIVE_HAS_SHA512
504 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA512), ed.sha512, sizeof(ed.sha512)) == 0);
505 #endif
506 archive_entry_free(entry);
507 #else
508 skipping("This platform does not support MD5");
509 return;
510 #endif
511 }
512
DEFINE_TEST(test_write_format_mtree_digests_md5_digest_set_non_empty_data)513 DEFINE_TEST(test_write_format_mtree_digests_md5_digest_set_non_empty_data)
514 {
515 #ifdef ARCHIVE_HAS_MD5
516 char buff[4096] = {0};
517 size_t used = 0;
518 struct archive *a;
519 struct archive_entry *entry;
520 struct expected_digests ed;
521
522 memcpy(ed.md5, ((unsigned char[]) {
523 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
524 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
525 }), sizeof(ed.md5));
526
527 #ifdef ARCHIVE_HAS_RMD160
528 assertEqualInt(ARCHIVE_OK, archive_rmd160_init(&expectedRmd160Ctx));
529 assertEqualInt(ARCHIVE_OK, archive_rmd160_update(&expectedRmd160Ctx, "abcd", 4));
530 assertEqualInt(ARCHIVE_OK, archive_rmd160_final(&expectedRmd160Ctx, ed.rmd160));
531 #endif
532
533 #ifdef ARCHIVE_HAS_SHA1
534 assertEqualInt(ARCHIVE_OK, archive_sha1_init(&expectedSha1Ctx));
535 assertEqualInt(ARCHIVE_OK, archive_sha1_update(&expectedSha1Ctx, "abcd", 4));
536 assertEqualInt(ARCHIVE_OK, archive_sha1_final(&expectedSha1Ctx, ed.sha1));
537 #endif
538
539 #ifdef ARCHIVE_HAS_SHA256
540 assertEqualInt(ARCHIVE_OK, archive_sha256_init(&expectedSha256Ctx));
541 assertEqualInt(ARCHIVE_OK, archive_sha256_update(&expectedSha256Ctx, "abcd", 4));
542 assertEqualInt(ARCHIVE_OK, archive_sha256_final(&expectedSha256Ctx, ed.sha256));
543 #endif
544
545 #ifdef ARCHIVE_HAS_SHA384
546 assertEqualInt(ARCHIVE_OK, archive_sha384_init(&expectedSha384Ctx));
547 assertEqualInt(ARCHIVE_OK, archive_sha384_update(&expectedSha384Ctx, "abcd", 4));
548 assertEqualInt(ARCHIVE_OK, archive_sha384_final(&expectedSha384Ctx, ed.sha384));
549 #endif
550
551 #ifdef ARCHIVE_HAS_SHA512
552 assertEqualInt(ARCHIVE_OK, archive_sha512_init(&expectedSha512Ctx));
553 assertEqualInt(ARCHIVE_OK, archive_sha512_update(&expectedSha512Ctx, "abcd", 4));
554 assertEqualInt(ARCHIVE_OK, archive_sha512_final(&expectedSha512Ctx, ed.sha512));
555 #endif
556
557 assert((a = archive_write_new()) != NULL);
558 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_mtree(a));
559 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_options(a, "all"));
560 assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, sizeof(buff) - 1, &used));
561 assert((entry = archive_entry_new()) != NULL);
562 archive_entry_set_pathname(entry, "test.data");
563 archive_entry_set_filetype(entry, AE_IFREG);
564 archive_entry_set_size(entry, 4);
565 archive_entry_set_digest(entry, ARCHIVE_ENTRY_DIGEST_MD5, ed.md5);
566 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, entry));
567 archive_write_data(a, "abcd", 4);
568 archive_entry_free(entry);
569 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
570 assertEqualIntA(a, ARCHIVE_OK, archive_write_free(a));
571
572 assert((a = archive_read_new()) != NULL);
573 assert((entry = archive_entry_new()) != NULL);
574 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
575 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
576 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));
577 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &entry));
578
579 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_MD5), ed.md5, sizeof(ed.md5)) != 0);
580
581 assertEqualInt(ARCHIVE_OK, archive_md5_init(&expectedMd5Ctx));
582 assertEqualInt(ARCHIVE_OK, archive_md5_update(&expectedMd5Ctx, "abcd", 4));
583 assertEqualInt(ARCHIVE_OK, archive_md5_final(&expectedMd5Ctx, ed.md5));
584
585 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_MD5), ed.md5, sizeof(ed.md5)) == 0);
586
587 #ifdef ARCHIVE_HAS_RMD160
588 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_RMD160), ed.rmd160, sizeof(ed.rmd160)) == 0);
589 #endif
590
591 #ifdef ARCHIVE_HAS_SHA1
592 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA1), ed.sha1, sizeof(ed.sha1)) == 0);
593 #endif
594
595 #ifdef ARCHIVE_HAS_SHA256
596 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA256), ed.sha256, sizeof(ed.sha256)) == 0);
597 #endif
598
599 #ifdef ARCHIVE_HAS_SHA384
600 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA384), ed.sha384, sizeof(ed.sha384)) == 0);
601 #endif
602
603 #ifdef ARCHIVE_HAS_SHA512
604 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA512), ed.sha512, sizeof(ed.sha512)) == 0);
605 #endif
606 archive_entry_free(entry);
607 #else
608 skipping("This platform does not support MD5");
609 return;
610 #endif
611 }
612
DEFINE_TEST(test_write_format_mtree_digests_rmd160_digest_set_no_data)613 DEFINE_TEST(test_write_format_mtree_digests_rmd160_digest_set_no_data)
614 {
615 #ifdef ARCHIVE_HAS_RMD160
616 char buff[4096] = {0};
617 size_t used = 0;
618 struct archive *a;
619 struct archive_entry *entry;
620 struct expected_digests ed;
621
622 #ifdef ARCHIVE_HAS_MD5
623 assertEqualInt(ARCHIVE_OK, archive_md5_init(&expectedMd5Ctx));
624 assertEqualInt(ARCHIVE_OK, archive_md5_update(&expectedMd5Ctx, "", 0));
625 assertEqualInt(ARCHIVE_OK, archive_md5_final(&expectedMd5Ctx, ed.md5));
626 #endif
627
628 assertEqualInt(ARCHIVE_OK, archive_rmd160_init(&expectedRmd160Ctx));
629 assertEqualInt(ARCHIVE_OK, archive_rmd160_update(&expectedRmd160Ctx, "", 0));
630 assertEqualInt(ARCHIVE_OK, archive_rmd160_final(&expectedRmd160Ctx, ed.rmd160));
631
632 #ifdef ARCHIVE_HAS_SHA1
633 assertEqualInt(ARCHIVE_OK, archive_sha1_init(&expectedSha1Ctx));
634 assertEqualInt(ARCHIVE_OK, archive_sha1_update(&expectedSha1Ctx, "", 0));
635 assertEqualInt(ARCHIVE_OK, archive_sha1_final(&expectedSha1Ctx, ed.sha1));
636 #endif
637
638 #ifdef ARCHIVE_HAS_SHA256
639 assertEqualInt(ARCHIVE_OK, archive_sha256_init(&expectedSha256Ctx));
640 assertEqualInt(ARCHIVE_OK, archive_sha256_update(&expectedSha256Ctx, "", 0));
641 assertEqualInt(ARCHIVE_OK, archive_sha256_final(&expectedSha256Ctx, ed.sha256));
642 #endif
643
644 #ifdef ARCHIVE_HAS_SHA384
645 assertEqualInt(ARCHIVE_OK, archive_sha384_init(&expectedSha384Ctx));
646 assertEqualInt(ARCHIVE_OK, archive_sha384_update(&expectedSha384Ctx, "", 0));
647 assertEqualInt(ARCHIVE_OK, archive_sha384_final(&expectedSha384Ctx, ed.sha384));
648 #endif
649
650 #ifdef ARCHIVE_HAS_SHA512
651 assertEqualInt(ARCHIVE_OK, archive_sha512_init(&expectedSha512Ctx));
652 assertEqualInt(ARCHIVE_OK, archive_sha512_update(&expectedSha512Ctx, "", 0));
653 assertEqualInt(ARCHIVE_OK, archive_sha512_final(&expectedSha512Ctx, ed.sha512));
654 #endif
655
656 assert((a = archive_write_new()) != NULL);
657 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_mtree(a));
658 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_options(a, "all"));
659 assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, sizeof(buff) - 1, &used));
660 assert((entry = archive_entry_new()) != NULL);
661 archive_entry_set_pathname(entry, "test.data");
662 archive_entry_set_filetype(entry, AE_IFREG);
663 archive_entry_set_size(entry, 4);
664 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, entry));
665 archive_entry_free(entry);
666 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
667 assertEqualIntA(a, ARCHIVE_OK, archive_write_free(a));
668
669 assert((a = archive_read_new()) != NULL);
670 assert((entry = archive_entry_new()) != NULL);
671 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
672 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
673 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));
674 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &entry));
675
676 #ifdef ARCHIVE_HAS_MD5
677 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_MD5), ed.md5, sizeof(ed.md5)) == 0);
678 #endif
679
680 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_RMD160), ed.rmd160, sizeof(ed.rmd160)) == 0);
681
682 #ifdef ARCHIVE_HAS_SHA1
683 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA1), ed.sha1, sizeof(ed.sha1)) == 0);
684 #endif
685
686 #ifdef ARCHIVE_HAS_SHA256
687 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA256), ed.sha256, sizeof(ed.sha256)) == 0);
688 #endif
689
690 #ifdef ARCHIVE_HAS_SHA384
691 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA384), ed.sha384, sizeof(ed.sha384)) == 0);
692 #endif
693
694 #ifdef ARCHIVE_HAS_SHA512
695 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA512), ed.sha512, sizeof(ed.sha512)) == 0);
696 #endif
697 archive_entry_free(entry);
698 #else
699 skipping("This platform does not support RMD160");
700 return;
701 #endif
702 }
703
DEFINE_TEST(test_write_format_mtree_digests_rmd160_digest_set_empty_data)704 DEFINE_TEST(test_write_format_mtree_digests_rmd160_digest_set_empty_data)
705 {
706 #ifdef ARCHIVE_HAS_RMD160
707 char buff[4096] = {0};
708 size_t used = 0;
709 struct archive *a;
710 struct archive_entry *entry;
711 struct expected_digests ed;
712
713 memcpy(ed.rmd160, ((unsigned char[]) {
714 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
715 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed
716 }), sizeof(ed.rmd160));
717
718 #ifdef ARCHIVE_HAS_MD5
719 assertEqualInt(ARCHIVE_OK, archive_md5_init(&expectedMd5Ctx));
720 assertEqualInt(ARCHIVE_OK, archive_md5_update(&expectedMd5Ctx, "", 0));
721 assertEqualInt(ARCHIVE_OK, archive_md5_final(&expectedMd5Ctx, ed.md5));
722 #endif
723
724 #ifdef ARCHIVE_HAS_SHA1
725 assertEqualInt(ARCHIVE_OK, archive_sha1_init(&expectedSha1Ctx));
726 assertEqualInt(ARCHIVE_OK, archive_sha1_update(&expectedSha1Ctx, "", 0));
727 assertEqualInt(ARCHIVE_OK, archive_sha1_final(&expectedSha1Ctx, ed.sha1));
728 #endif
729
730 #ifdef ARCHIVE_HAS_SHA256
731 assertEqualInt(ARCHIVE_OK, archive_sha256_init(&expectedSha256Ctx));
732 assertEqualInt(ARCHIVE_OK, archive_sha256_update(&expectedSha256Ctx, "", 0));
733 assertEqualInt(ARCHIVE_OK, archive_sha256_final(&expectedSha256Ctx, ed.sha256));
734 #endif
735
736 #ifdef ARCHIVE_HAS_SHA384
737 assertEqualInt(ARCHIVE_OK, archive_sha384_init(&expectedSha384Ctx));
738 assertEqualInt(ARCHIVE_OK, archive_sha384_update(&expectedSha384Ctx, "", 0));
739 assertEqualInt(ARCHIVE_OK, archive_sha384_final(&expectedSha384Ctx, ed.sha384));
740 #endif
741
742 #ifdef ARCHIVE_HAS_SHA512
743 assertEqualInt(ARCHIVE_OK, archive_sha512_init(&expectedSha512Ctx));
744 assertEqualInt(ARCHIVE_OK, archive_sha512_update(&expectedSha512Ctx, "", 0));
745 assertEqualInt(ARCHIVE_OK, archive_sha512_final(&expectedSha512Ctx, ed.sha512));
746 #endif
747
748 assert((a = archive_write_new()) != NULL);
749 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_mtree(a));
750 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_options(a, "all"));
751 assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, sizeof(buff) - 1, &used));
752 assert((entry = archive_entry_new()) != NULL);
753 archive_entry_set_pathname(entry, "test.data");
754 archive_entry_set_filetype(entry, AE_IFREG);
755 archive_entry_set_size(entry, 4);
756 archive_entry_set_digest(entry, ARCHIVE_ENTRY_DIGEST_RMD160, ed.rmd160);
757 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, entry));
758 archive_write_data(a, "", 0);
759 archive_entry_free(entry);
760 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
761 assertEqualIntA(a, ARCHIVE_OK, archive_write_free(a));
762
763 assert((a = archive_read_new()) != NULL);
764 assert((entry = archive_entry_new()) != NULL);
765 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
766 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
767 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));
768 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &entry));
769
770 #ifdef ARCHIVE_HAS_MD5
771 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_MD5), ed.md5, sizeof(ed.md5)) == 0);
772 #endif
773
774 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_RMD160), ed.rmd160, sizeof(ed.rmd160)) != 0);
775
776 assertEqualInt(ARCHIVE_OK, archive_rmd160_init(&expectedRmd160Ctx));
777 assertEqualInt(ARCHIVE_OK, archive_rmd160_update(&expectedRmd160Ctx, "", 0));
778 assertEqualInt(ARCHIVE_OK, archive_rmd160_final(&expectedRmd160Ctx, ed.rmd160));
779
780 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_RMD160), ed.rmd160, sizeof(ed.rmd160)) == 0);
781
782 #ifdef ARCHIVE_HAS_SHA1
783 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA1), ed.sha1, sizeof(ed.sha1)) == 0);
784 #endif
785
786 #ifdef ARCHIVE_HAS_SHA256
787 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA256), ed.sha256, sizeof(ed.sha256)) == 0);
788 #endif
789
790 #ifdef ARCHIVE_HAS_SHA384
791 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA384), ed.sha384, sizeof(ed.sha384)) == 0);
792 #endif
793
794 #ifdef ARCHIVE_HAS_SHA512
795 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA512), ed.sha512, sizeof(ed.sha512)) == 0);
796 #endif
797 archive_entry_free(entry);
798 #else
799 skipping("This platform does not support RMD160");
800 return;
801 #endif
802 }
803
DEFINE_TEST(test_write_format_mtree_digests_rmd160_digest_set_non_empty_data)804 DEFINE_TEST(test_write_format_mtree_digests_rmd160_digest_set_non_empty_data)
805 {
806 #ifdef ARCHIVE_HAS_RMD160
807 char buff[4096] = {0};
808 size_t used = 0;
809 struct archive *a;
810 struct archive_entry *entry;
811 struct expected_digests ed;
812
813 memcpy(ed.rmd160, ((unsigned char[]) {
814 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
815 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed
816 }), sizeof(ed.rmd160));
817
818 #ifdef ARCHIVE_HAS_MD5
819 assertEqualInt(ARCHIVE_OK, archive_md5_init(&expectedMd5Ctx));
820 assertEqualInt(ARCHIVE_OK, archive_md5_update(&expectedMd5Ctx, "abcd", 4));
821 assertEqualInt(ARCHIVE_OK, archive_md5_final(&expectedMd5Ctx, ed.md5));
822 #endif
823
824 #ifdef ARCHIVE_HAS_SHA1
825 assertEqualInt(ARCHIVE_OK, archive_sha1_init(&expectedSha1Ctx));
826 assertEqualInt(ARCHIVE_OK, archive_sha1_update(&expectedSha1Ctx, "abcd", 4));
827 assertEqualInt(ARCHIVE_OK, archive_sha1_final(&expectedSha1Ctx, ed.sha1));
828 #endif
829
830 #ifdef ARCHIVE_HAS_SHA256
831 assertEqualInt(ARCHIVE_OK, archive_sha256_init(&expectedSha256Ctx));
832 assertEqualInt(ARCHIVE_OK, archive_sha256_update(&expectedSha256Ctx, "abcd", 4));
833 assertEqualInt(ARCHIVE_OK, archive_sha256_final(&expectedSha256Ctx, ed.sha256));
834 #endif
835
836 #ifdef ARCHIVE_HAS_SHA384
837 assertEqualInt(ARCHIVE_OK, archive_sha384_init(&expectedSha384Ctx));
838 assertEqualInt(ARCHIVE_OK, archive_sha384_update(&expectedSha384Ctx, "abcd", 4));
839 assertEqualInt(ARCHIVE_OK, archive_sha384_final(&expectedSha384Ctx, ed.sha384));
840 #endif
841
842 #ifdef ARCHIVE_HAS_SHA512
843 assertEqualInt(ARCHIVE_OK, archive_sha512_init(&expectedSha512Ctx));
844 assertEqualInt(ARCHIVE_OK, archive_sha512_update(&expectedSha512Ctx, "abcd", 4));
845 assertEqualInt(ARCHIVE_OK, archive_sha512_final(&expectedSha512Ctx, ed.sha512));
846 #endif
847
848 assert((a = archive_write_new()) != NULL);
849 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_mtree(a));
850 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_options(a, "all"));
851 assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, sizeof(buff) - 1, &used));
852 assert((entry = archive_entry_new()) != NULL);
853 archive_entry_set_pathname(entry, "test.data");
854 archive_entry_set_filetype(entry, AE_IFREG);
855 archive_entry_set_size(entry, 4);
856 archive_entry_set_digest(entry, ARCHIVE_ENTRY_DIGEST_RMD160, ed.rmd160);
857 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, entry));
858 archive_write_data(a, "abcd", 4);
859 archive_entry_free(entry);
860 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
861 assertEqualIntA(a, ARCHIVE_OK, archive_write_free(a));
862
863 assert((a = archive_read_new()) != NULL);
864 assert((entry = archive_entry_new()) != NULL);
865 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
866 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
867 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));
868 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &entry));
869
870 #ifdef ARCHIVE_HAS_MD5
871 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_MD5), ed.md5, sizeof(ed.md5)) == 0);
872 #endif
873
874 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_RMD160), ed.rmd160, sizeof(ed.rmd160)) != 0);
875
876 assertEqualInt(ARCHIVE_OK, archive_rmd160_init(&expectedRmd160Ctx));
877 assertEqualInt(ARCHIVE_OK, archive_rmd160_update(&expectedRmd160Ctx, "abcd", 4));
878 assertEqualInt(ARCHIVE_OK, archive_rmd160_final(&expectedRmd160Ctx, ed.rmd160));
879
880 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_RMD160), ed.rmd160, sizeof(ed.rmd160)) == 0);
881
882 #ifdef ARCHIVE_HAS_SHA1
883 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA1), ed.sha1, sizeof(ed.sha1)) == 0);
884 #endif
885
886 #ifdef ARCHIVE_HAS_SHA256
887 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA256), ed.sha256, sizeof(ed.sha256)) == 0);
888 #endif
889
890 #ifdef ARCHIVE_HAS_SHA384
891 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA384), ed.sha384, sizeof(ed.sha384)) == 0);
892 #endif
893
894 #ifdef ARCHIVE_HAS_SHA512
895 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA512), ed.sha512, sizeof(ed.sha512)) == 0);
896 #endif
897 archive_entry_free(entry);
898 #else
899 skipping("This platform does not support RMD160");
900 return;
901 #endif
902 }
903
DEFINE_TEST(test_write_format_mtree_digests_sha1_digest_set_no_data)904 DEFINE_TEST(test_write_format_mtree_digests_sha1_digest_set_no_data)
905 {
906 #ifdef ARCHIVE_HAS_SHA1
907 char buff[4096] = {0};
908 size_t used = 0;
909 struct archive *a;
910 struct archive_entry *entry;
911 struct expected_digests ed;
912
913 memcpy(ed.sha1, ((unsigned char[]) {
914 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
915 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed
916 }), sizeof(ed.sha1));
917
918 #ifdef ARCHIVE_HAS_MD5
919 assertEqualInt(ARCHIVE_OK, archive_md5_init(&expectedMd5Ctx));
920 assertEqualInt(ARCHIVE_OK, archive_md5_update(&expectedMd5Ctx, "", 0));
921 assertEqualInt(ARCHIVE_OK, archive_md5_final(&expectedMd5Ctx, ed.md5));
922 #endif
923
924 #ifdef ARCHIVE_HAS_RMD160
925 assertEqualInt(ARCHIVE_OK, archive_rmd160_init(&expectedRmd160Ctx));
926 assertEqualInt(ARCHIVE_OK, archive_rmd160_update(&expectedRmd160Ctx, "", 0));
927 assertEqualInt(ARCHIVE_OK, archive_rmd160_final(&expectedRmd160Ctx, ed.rmd160));
928 #endif
929
930 #ifdef ARCHIVE_HAS_SHA256
931 assertEqualInt(ARCHIVE_OK, archive_sha256_init(&expectedSha256Ctx));
932 assertEqualInt(ARCHIVE_OK, archive_sha256_update(&expectedSha256Ctx, "", 0));
933 assertEqualInt(ARCHIVE_OK, archive_sha256_final(&expectedSha256Ctx, ed.sha256));
934 #endif
935
936 #ifdef ARCHIVE_HAS_SHA384
937 assertEqualInt(ARCHIVE_OK, archive_sha384_init(&expectedSha384Ctx));
938 assertEqualInt(ARCHIVE_OK, archive_sha384_update(&expectedSha384Ctx, "", 0));
939 assertEqualInt(ARCHIVE_OK, archive_sha384_final(&expectedSha384Ctx, ed.sha384));
940 #endif
941
942 #ifdef ARCHIVE_HAS_SHA512
943 assertEqualInt(ARCHIVE_OK, archive_sha512_init(&expectedSha512Ctx));
944 assertEqualInt(ARCHIVE_OK, archive_sha512_update(&expectedSha512Ctx, "", 0));
945 assertEqualInt(ARCHIVE_OK, archive_sha512_final(&expectedSha512Ctx, ed.sha512));
946 #endif
947
948 assert((a = archive_write_new()) != NULL);
949 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_mtree(a));
950 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_options(a, "all"));
951 assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, sizeof(buff) - 1, &used));
952 assert((entry = archive_entry_new()) != NULL);
953 archive_entry_set_pathname(entry, "test.data");
954 archive_entry_set_filetype(entry, AE_IFREG);
955 archive_entry_set_size(entry, 4);
956 archive_entry_set_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA1, ed.sha1);
957 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, entry));
958 archive_entry_free(entry);
959 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
960 assertEqualIntA(a, ARCHIVE_OK, archive_write_free(a));
961
962 assert((a = archive_read_new()) != NULL);
963 assert((entry = archive_entry_new()) != NULL);
964 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
965 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
966 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));
967 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &entry));
968
969 #ifdef ARCHIVE_HAS_MD5
970 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_MD5), ed.md5, sizeof(ed.md5)) == 0);
971 #endif
972
973 #ifdef ARCHIVE_HAS_RMD160
974 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_RMD160), ed.rmd160, sizeof(ed.rmd160)) == 0);
975 #endif
976
977 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA1), ed.sha1, sizeof(ed.sha1)) == 0);
978
979 #ifdef ARCHIVE_HAS_SHA256
980 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA256), ed.sha256, sizeof(ed.sha256)) == 0);
981 #endif
982
983 #ifdef ARCHIVE_HAS_SHA384
984 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA384), ed.sha384, sizeof(ed.sha384)) == 0);
985 #endif
986
987 #ifdef ARCHIVE_HAS_SHA512
988 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA512), ed.sha512, sizeof(ed.sha512)) == 0);
989 #endif
990 archive_entry_free(entry);
991 #else
992 skipping("This platform does not support SHA1");
993 return;
994 #endif
995 }
996
DEFINE_TEST(test_write_format_mtree_digests_sha1_digest_set_empty_data)997 DEFINE_TEST(test_write_format_mtree_digests_sha1_digest_set_empty_data)
998 {
999 #ifdef ARCHIVE_HAS_SHA1
1000 char buff[4096] = {0};
1001 size_t used = 0;
1002 struct archive *a;
1003 struct archive_entry *entry;
1004 struct expected_digests ed;
1005
1006 memcpy(ed.sha1, ((unsigned char[]) {
1007 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
1008 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed
1009 }), sizeof(ed.sha1));
1010
1011 #ifdef ARCHIVE_HAS_MD5
1012 assertEqualInt(ARCHIVE_OK, archive_md5_init(&expectedMd5Ctx));
1013 assertEqualInt(ARCHIVE_OK, archive_md5_update(&expectedMd5Ctx, "", 0));
1014 assertEqualInt(ARCHIVE_OK, archive_md5_final(&expectedMd5Ctx, ed.md5));
1015 #endif
1016
1017 #ifdef ARCHIVE_HAS_RMD160
1018 assertEqualInt(ARCHIVE_OK, archive_rmd160_init(&expectedRmd160Ctx));
1019 assertEqualInt(ARCHIVE_OK, archive_rmd160_update(&expectedRmd160Ctx, "", 0));
1020 assertEqualInt(ARCHIVE_OK, archive_rmd160_final(&expectedRmd160Ctx, ed.rmd160));
1021 #endif
1022
1023 #ifdef ARCHIVE_HAS_SHA256
1024 assertEqualInt(ARCHIVE_OK, archive_sha256_init(&expectedSha256Ctx));
1025 assertEqualInt(ARCHIVE_OK, archive_sha256_update(&expectedSha256Ctx, "", 0));
1026 assertEqualInt(ARCHIVE_OK, archive_sha256_final(&expectedSha256Ctx, ed.sha256));
1027 #endif
1028
1029 #ifdef ARCHIVE_HAS_SHA384
1030 assertEqualInt(ARCHIVE_OK, archive_sha384_init(&expectedSha384Ctx));
1031 assertEqualInt(ARCHIVE_OK, archive_sha384_update(&expectedSha384Ctx, "", 0));
1032 assertEqualInt(ARCHIVE_OK, archive_sha384_final(&expectedSha384Ctx, ed.sha384));
1033 #endif
1034
1035 #ifdef ARCHIVE_HAS_SHA512
1036 assertEqualInt(ARCHIVE_OK, archive_sha512_init(&expectedSha512Ctx));
1037 assertEqualInt(ARCHIVE_OK, archive_sha512_update(&expectedSha512Ctx, "", 0));
1038 assertEqualInt(ARCHIVE_OK, archive_sha512_final(&expectedSha512Ctx, ed.sha512));
1039 #endif
1040
1041 assert((a = archive_write_new()) != NULL);
1042 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_mtree(a));
1043 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_options(a, "all"));
1044 assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, sizeof(buff) - 1, &used));
1045 assert((entry = archive_entry_new()) != NULL);
1046 archive_entry_set_pathname(entry, "test.data");
1047 archive_entry_set_filetype(entry, AE_IFREG);
1048 archive_entry_set_size(entry, 4);
1049 archive_entry_set_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA1, ed.sha1);
1050 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, entry));
1051 archive_write_data(a, "", 0);
1052 archive_entry_free(entry);
1053 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
1054 assertEqualIntA(a, ARCHIVE_OK, archive_write_free(a));
1055
1056 assert((a = archive_read_new()) != NULL);
1057 assert((entry = archive_entry_new()) != NULL);
1058 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
1059 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
1060 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));
1061 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &entry));
1062
1063 #ifdef ARCHIVE_HAS_MD5
1064 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_MD5), ed.md5, sizeof(ed.md5)) == 0);
1065 #endif
1066
1067 #ifdef ARCHIVE_HAS_RMD160
1068 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_RMD160), ed.rmd160, sizeof(ed.rmd160)) == 0);
1069 #endif
1070
1071 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA1), ed.sha1, sizeof(ed.sha1)) != 0);
1072
1073 assertEqualInt(ARCHIVE_OK, archive_sha1_init(&expectedSha1Ctx));
1074 assertEqualInt(ARCHIVE_OK, archive_sha1_update(&expectedSha1Ctx, "", 0));
1075 assertEqualInt(ARCHIVE_OK, archive_sha1_final(&expectedSha1Ctx, ed.sha1));
1076
1077 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA1), ed.sha1, sizeof(ed.sha1)) == 0);
1078
1079 #ifdef ARCHIVE_HAS_SHA256
1080 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA256), ed.sha256, sizeof(ed.sha256)) == 0);
1081 #endif
1082
1083 #ifdef ARCHIVE_HAS_SHA384
1084 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA384), ed.sha384, sizeof(ed.sha384)) == 0);
1085 #endif
1086
1087 #ifdef ARCHIVE_HAS_SHA512
1088 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA512), ed.sha512, sizeof(ed.sha512)) == 0);
1089 #endif
1090 archive_entry_free(entry);
1091 #else
1092 skipping("This platform does not support SHA1");
1093 return;
1094 #endif
1095 }
1096
DEFINE_TEST(test_write_format_mtree_digests_sha1_digest_set_non_empty_data)1097 DEFINE_TEST(test_write_format_mtree_digests_sha1_digest_set_non_empty_data)
1098 {
1099 #ifdef ARCHIVE_HAS_SHA1
1100 char buff[4096] = {0};
1101 size_t used = 0;
1102 struct archive *a;
1103 struct archive_entry *entry;
1104 struct expected_digests ed;
1105
1106 memcpy(ed.sha1, ((unsigned char[]) {
1107 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
1108 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed
1109 }), sizeof(ed.sha1));
1110
1111 #ifdef ARCHIVE_HAS_MD5
1112 assertEqualInt(ARCHIVE_OK, archive_md5_init(&expectedMd5Ctx));
1113 assertEqualInt(ARCHIVE_OK, archive_md5_update(&expectedMd5Ctx, "abcd", 4));
1114 assertEqualInt(ARCHIVE_OK, archive_md5_final(&expectedMd5Ctx, ed.md5));
1115 #endif
1116
1117 #ifdef ARCHIVE_HAS_RMD160
1118 assertEqualInt(ARCHIVE_OK, archive_rmd160_init(&expectedRmd160Ctx));
1119 assertEqualInt(ARCHIVE_OK, archive_rmd160_update(&expectedRmd160Ctx, "abcd", 4));
1120 assertEqualInt(ARCHIVE_OK, archive_rmd160_final(&expectedRmd160Ctx, ed.rmd160));
1121 #endif
1122
1123 #ifdef ARCHIVE_HAS_SHA256
1124 assertEqualInt(ARCHIVE_OK, archive_sha256_init(&expectedSha256Ctx));
1125 assertEqualInt(ARCHIVE_OK, archive_sha256_update(&expectedSha256Ctx, "abcd", 4));
1126 assertEqualInt(ARCHIVE_OK, archive_sha256_final(&expectedSha256Ctx, ed.sha256));
1127 #endif
1128
1129 #ifdef ARCHIVE_HAS_SHA384
1130 assertEqualInt(ARCHIVE_OK, archive_sha384_init(&expectedSha384Ctx));
1131 assertEqualInt(ARCHIVE_OK, archive_sha384_update(&expectedSha384Ctx, "abcd", 4));
1132 assertEqualInt(ARCHIVE_OK, archive_sha384_final(&expectedSha384Ctx, ed.sha384));
1133 #endif
1134
1135 #ifdef ARCHIVE_HAS_SHA512
1136 assertEqualInt(ARCHIVE_OK, archive_sha512_init(&expectedSha512Ctx));
1137 assertEqualInt(ARCHIVE_OK, archive_sha512_update(&expectedSha512Ctx, "abcd", 4));
1138 assertEqualInt(ARCHIVE_OK, archive_sha512_final(&expectedSha512Ctx, ed.sha512));
1139 #endif
1140
1141 assert((a = archive_write_new()) != NULL);
1142 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_mtree(a));
1143 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_options(a, "all"));
1144 assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, sizeof(buff) - 1, &used));
1145 assert((entry = archive_entry_new()) != NULL);
1146 archive_entry_set_pathname(entry, "test.data");
1147 archive_entry_set_filetype(entry, AE_IFREG);
1148 archive_entry_set_size(entry, 4);
1149 archive_entry_set_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA1, ed.sha1);
1150 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, entry));
1151 archive_write_data(a, "abcd", 4);
1152 archive_entry_free(entry);
1153 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
1154 assertEqualIntA(a, ARCHIVE_OK, archive_write_free(a));
1155
1156 assert((a = archive_read_new()) != NULL);
1157 assert((entry = archive_entry_new()) != NULL);
1158 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
1159 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
1160 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));
1161 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &entry));
1162
1163 #ifdef ARCHIVE_HAS_MD5
1164 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_MD5), ed.md5, sizeof(ed.md5)) == 0);
1165 #endif
1166
1167 #ifdef ARCHIVE_HAS_RMD160
1168 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_RMD160), ed.rmd160, sizeof(ed.rmd160)) == 0);
1169 #endif
1170
1171 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA1), ed.sha1, sizeof(ed.sha1)) != 0);
1172
1173 assertEqualInt(ARCHIVE_OK, archive_sha1_init(&expectedSha1Ctx));
1174 assertEqualInt(ARCHIVE_OK, archive_sha1_update(&expectedSha1Ctx, "abcd", 4));
1175 assertEqualInt(ARCHIVE_OK, archive_sha1_final(&expectedSha1Ctx, ed.sha1));
1176
1177 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA1), ed.sha1, sizeof(ed.sha1)) == 0);
1178
1179 #ifdef ARCHIVE_HAS_SHA256
1180 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA256), ed.sha256, sizeof(ed.sha256)) == 0);
1181 #endif
1182
1183 #ifdef ARCHIVE_HAS_SHA384
1184 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA384), ed.sha384, sizeof(ed.sha384)) == 0);
1185 #endif
1186
1187 #ifdef ARCHIVE_HAS_SHA512
1188 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA512), ed.sha512, sizeof(ed.sha512)) == 0);
1189 #endif
1190 archive_entry_free(entry);
1191 #else
1192 skipping("This platform does not support SHA1");
1193 return;
1194 #endif
1195 }
1196
DEFINE_TEST(test_write_format_mtree_digests_sha256_digest_set_no_data)1197 DEFINE_TEST(test_write_format_mtree_digests_sha256_digest_set_no_data)
1198 {
1199 #ifdef ARCHIVE_HAS_SHA256
1200 char buff[4096] = {0};
1201 size_t used = 0;
1202 struct archive *a;
1203 struct archive_entry *entry;
1204 struct expected_digests ed;
1205
1206 memcpy(ed.sha256, ((unsigned char[]) {
1207 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
1208 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
1209 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
1210 0xfe, 0xed
1211 }), sizeof(ed.sha256));
1212
1213 #ifdef ARCHIVE_HAS_MD5
1214 assertEqualInt(ARCHIVE_OK, archive_md5_init(&expectedMd5Ctx));
1215 assertEqualInt(ARCHIVE_OK, archive_md5_update(&expectedMd5Ctx, "", 0));
1216 assertEqualInt(ARCHIVE_OK, archive_md5_final(&expectedMd5Ctx, ed.md5));
1217 #endif
1218
1219 #ifdef ARCHIVE_HAS_RMD160
1220 assertEqualInt(ARCHIVE_OK, archive_rmd160_init(&expectedRmd160Ctx));
1221 assertEqualInt(ARCHIVE_OK, archive_rmd160_update(&expectedRmd160Ctx, "", 0));
1222 assertEqualInt(ARCHIVE_OK, archive_rmd160_final(&expectedRmd160Ctx, ed.rmd160));
1223 #endif
1224
1225 #ifdef ARCHIVE_HAS_SHA1
1226 assertEqualInt(ARCHIVE_OK, archive_sha1_init(&expectedSha1Ctx));
1227 assertEqualInt(ARCHIVE_OK, archive_sha1_update(&expectedSha1Ctx, "", 0));
1228 assertEqualInt(ARCHIVE_OK, archive_sha1_final(&expectedSha1Ctx, ed.sha1));
1229 #endif
1230
1231 #ifdef ARCHIVE_HAS_SHA384
1232 assertEqualInt(ARCHIVE_OK, archive_sha384_init(&expectedSha384Ctx));
1233 assertEqualInt(ARCHIVE_OK, archive_sha384_update(&expectedSha384Ctx, "", 0));
1234 assertEqualInt(ARCHIVE_OK, archive_sha384_final(&expectedSha384Ctx, ed.sha384));
1235 #endif
1236
1237 #ifdef ARCHIVE_HAS_SHA512
1238 assertEqualInt(ARCHIVE_OK, archive_sha512_init(&expectedSha512Ctx));
1239 assertEqualInt(ARCHIVE_OK, archive_sha512_update(&expectedSha512Ctx, "", 0));
1240 assertEqualInt(ARCHIVE_OK, archive_sha512_final(&expectedSha512Ctx, ed.sha512));
1241 #endif
1242
1243 assert((a = archive_write_new()) != NULL);
1244 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_mtree(a));
1245 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_options(a, "all"));
1246 assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, sizeof(buff) - 1, &used));
1247 assert((entry = archive_entry_new()) != NULL);
1248 archive_entry_set_pathname(entry, "test.data");
1249 archive_entry_set_filetype(entry, AE_IFREG);
1250 archive_entry_set_size(entry, 4);
1251 archive_entry_set_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA256, ed.sha256);
1252 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, entry));
1253 archive_entry_free(entry);
1254 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
1255 assertEqualIntA(a, ARCHIVE_OK, archive_write_free(a));
1256
1257 assert((a = archive_read_new()) != NULL);
1258 assert((entry = archive_entry_new()) != NULL);
1259 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
1260 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
1261 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));
1262 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &entry));
1263
1264 #ifdef ARCHIVE_HAS_MD5
1265 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_MD5), ed.md5, sizeof(ed.md5)) == 0);
1266 #endif
1267
1268 #ifdef ARCHIVE_HAS_RMD160
1269 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_RMD160), ed.rmd160, sizeof(ed.rmd160)) == 0);
1270 #endif
1271
1272 #ifdef ARCHIVE_HAS_SHA1
1273 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA1), ed.sha1, sizeof(ed.sha1)) == 0);
1274 #endif
1275
1276 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA256), ed.sha256, sizeof(ed.sha256)) == 0);
1277
1278 #ifdef ARCHIVE_HAS_SHA384
1279 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA384), ed.sha384, sizeof(ed.sha384)) == 0);
1280 #endif
1281
1282 #ifdef ARCHIVE_HAS_SHA512
1283 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA512), ed.sha512, sizeof(ed.sha512)) == 0);
1284 #endif
1285 archive_entry_free(entry);
1286 #else
1287 skipping("This platform does not support SHA256");
1288 return;
1289 #endif
1290 }
1291
DEFINE_TEST(test_write_format_mtree_digests_sha256_digest_set_empty_data)1292 DEFINE_TEST(test_write_format_mtree_digests_sha256_digest_set_empty_data)
1293 {
1294 #ifdef ARCHIVE_HAS_SHA256
1295 char buff[4096] = {0};
1296 size_t used = 0;
1297 struct archive *a;
1298 struct archive_entry *entry;
1299 struct expected_digests ed;
1300
1301 memcpy(ed.sha256, ((unsigned char[]) {
1302 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
1303 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
1304 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
1305 0xfe, 0xed
1306 }), sizeof(ed.sha256));
1307
1308 #ifdef ARCHIVE_HAS_MD5
1309 assertEqualInt(ARCHIVE_OK, archive_md5_init(&expectedMd5Ctx));
1310 assertEqualInt(ARCHIVE_OK, archive_md5_update(&expectedMd5Ctx, "", 0));
1311 assertEqualInt(ARCHIVE_OK, archive_md5_final(&expectedMd5Ctx, ed.md5));
1312 #endif
1313
1314 #ifdef ARCHIVE_HAS_RMD160
1315 assertEqualInt(ARCHIVE_OK, archive_rmd160_init(&expectedRmd160Ctx));
1316 assertEqualInt(ARCHIVE_OK, archive_rmd160_update(&expectedRmd160Ctx, "", 0));
1317 assertEqualInt(ARCHIVE_OK, archive_rmd160_final(&expectedRmd160Ctx, ed.rmd160));
1318 #endif
1319
1320 #ifdef ARCHIVE_HAS_SHA1
1321 assertEqualInt(ARCHIVE_OK, archive_sha1_init(&expectedSha1Ctx));
1322 assertEqualInt(ARCHIVE_OK, archive_sha1_update(&expectedSha1Ctx, "", 0));
1323 assertEqualInt(ARCHIVE_OK, archive_sha1_final(&expectedSha1Ctx, ed.sha1));
1324 #endif
1325
1326 #ifdef ARCHIVE_HAS_SHA384
1327 assertEqualInt(ARCHIVE_OK, archive_sha384_init(&expectedSha384Ctx));
1328 assertEqualInt(ARCHIVE_OK, archive_sha384_update(&expectedSha384Ctx, "", 0));
1329 assertEqualInt(ARCHIVE_OK, archive_sha384_final(&expectedSha384Ctx, ed.sha384));
1330 #endif
1331
1332 #ifdef ARCHIVE_HAS_SHA512
1333 assertEqualInt(ARCHIVE_OK, archive_sha512_init(&expectedSha512Ctx));
1334 assertEqualInt(ARCHIVE_OK, archive_sha512_update(&expectedSha512Ctx, "", 0));
1335 assertEqualInt(ARCHIVE_OK, archive_sha512_final(&expectedSha512Ctx, ed.sha512));
1336 #endif
1337
1338 assert((a = archive_write_new()) != NULL);
1339 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_mtree(a));
1340 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_options(a, "all"));
1341 assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, sizeof(buff) - 1, &used));
1342 assert((entry = archive_entry_new()) != NULL);
1343 archive_entry_set_pathname(entry, "test.data");
1344 archive_entry_set_filetype(entry, AE_IFREG);
1345 archive_entry_set_size(entry, 4);
1346 archive_entry_set_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA256, ed.sha256);
1347 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, entry));
1348 archive_write_data(a, "", 0);
1349 archive_entry_free(entry);
1350 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
1351 assertEqualIntA(a, ARCHIVE_OK, archive_write_free(a));
1352
1353 assert((a = archive_read_new()) != NULL);
1354 assert((entry = archive_entry_new()) != NULL);
1355 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
1356 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
1357 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));
1358 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &entry));
1359
1360 #ifdef ARCHIVE_HAS_MD5
1361 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_MD5), ed.md5, sizeof(ed.md5)) == 0);
1362 #endif
1363
1364 #ifdef ARCHIVE_HAS_RMD160
1365 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_RMD160), ed.rmd160, sizeof(ed.rmd160)) == 0);
1366 #endif
1367
1368 #ifdef ARCHIVE_HAS_SHA1
1369 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA1), ed.sha1, sizeof(ed.sha1)) == 0);
1370 #endif
1371
1372 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA256), ed.sha256, sizeof(ed.sha256)) != 0);
1373
1374 assertEqualInt(ARCHIVE_OK, archive_sha256_init(&expectedSha256Ctx));
1375 assertEqualInt(ARCHIVE_OK, archive_sha256_update(&expectedSha256Ctx, "", 0));
1376 assertEqualInt(ARCHIVE_OK, archive_sha256_final(&expectedSha256Ctx, ed.sha256));
1377
1378 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA256), ed.sha256, sizeof(ed.sha256)) == 0);
1379
1380 #ifdef ARCHIVE_HAS_SHA384
1381 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA384), ed.sha384, sizeof(ed.sha384)) == 0);
1382 #endif
1383
1384 #ifdef ARCHIVE_HAS_SHA512
1385 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA512), ed.sha512, sizeof(ed.sha512)) == 0);
1386 #endif
1387 archive_entry_free(entry);
1388 #else
1389 skipping("This platform does not support SHA256");
1390 return;
1391 #endif
1392 }
1393
DEFINE_TEST(test_write_format_mtree_digests_sha256_digest_set_non_empty_data)1394 DEFINE_TEST(test_write_format_mtree_digests_sha256_digest_set_non_empty_data)
1395 {
1396 #ifdef ARCHIVE_HAS_SHA256
1397 char buff[4096] = {0};
1398 size_t used = 0;
1399 struct archive *a;
1400 struct archive_entry *entry;
1401 struct expected_digests ed;
1402
1403 memcpy(ed.sha256, ((unsigned char[]) {
1404 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
1405 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
1406 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
1407 0xfe, 0xed
1408 }), sizeof(ed.sha256));
1409
1410 #ifdef ARCHIVE_HAS_MD5
1411 assertEqualInt(ARCHIVE_OK, archive_md5_init(&expectedMd5Ctx));
1412 assertEqualInt(ARCHIVE_OK, archive_md5_update(&expectedMd5Ctx, "abcd", 4));
1413 assertEqualInt(ARCHIVE_OK, archive_md5_final(&expectedMd5Ctx, ed.md5));
1414 #endif
1415
1416 #ifdef ARCHIVE_HAS_RMD160
1417 assertEqualInt(ARCHIVE_OK, archive_rmd160_init(&expectedRmd160Ctx));
1418 assertEqualInt(ARCHIVE_OK, archive_rmd160_update(&expectedRmd160Ctx, "abcd", 4));
1419 assertEqualInt(ARCHIVE_OK, archive_rmd160_final(&expectedRmd160Ctx, ed.rmd160));
1420 #endif
1421
1422 #ifdef ARCHIVE_HAS_SHA1
1423 assertEqualInt(ARCHIVE_OK, archive_sha1_init(&expectedSha1Ctx));
1424 assertEqualInt(ARCHIVE_OK, archive_sha1_update(&expectedSha1Ctx, "abcd", 4));
1425 assertEqualInt(ARCHIVE_OK, archive_sha1_final(&expectedSha1Ctx, ed.sha1));
1426 #endif
1427
1428 #ifdef ARCHIVE_HAS_SHA384
1429 assertEqualInt(ARCHIVE_OK, archive_sha384_init(&expectedSha384Ctx));
1430 assertEqualInt(ARCHIVE_OK, archive_sha384_update(&expectedSha384Ctx, "abcd", 4));
1431 assertEqualInt(ARCHIVE_OK, archive_sha384_final(&expectedSha384Ctx, ed.sha384));
1432 #endif
1433
1434 #ifdef ARCHIVE_HAS_SHA512
1435 assertEqualInt(ARCHIVE_OK, archive_sha512_init(&expectedSha512Ctx));
1436 assertEqualInt(ARCHIVE_OK, archive_sha512_update(&expectedSha512Ctx, "abcd", 4));
1437 assertEqualInt(ARCHIVE_OK, archive_sha512_final(&expectedSha512Ctx, ed.sha512));
1438 #endif
1439
1440 assert((a = archive_write_new()) != NULL);
1441 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_mtree(a));
1442 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_options(a, "all"));
1443 assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, sizeof(buff) - 1, &used));
1444 assert((entry = archive_entry_new()) != NULL);
1445 archive_entry_set_pathname(entry, "test.data");
1446 archive_entry_set_filetype(entry, AE_IFREG);
1447 archive_entry_set_size(entry, 4);
1448 archive_entry_set_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA256, ed.sha256);
1449 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, entry));
1450 archive_write_data(a, "abcd", 4);
1451 archive_entry_free(entry);
1452 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
1453 assertEqualIntA(a, ARCHIVE_OK, archive_write_free(a));
1454
1455 assert((a = archive_read_new()) != NULL);
1456 assert((entry = archive_entry_new()) != NULL);
1457 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
1458 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
1459 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));
1460 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &entry));
1461
1462 #ifdef ARCHIVE_HAS_MD5
1463 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_MD5), ed.md5, sizeof(ed.md5)) == 0);
1464 #endif
1465
1466 #ifdef ARCHIVE_HAS_RMD160
1467 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_RMD160), ed.rmd160, sizeof(ed.rmd160)) == 0);
1468 #endif
1469
1470 #ifdef ARCHIVE_HAS_SHA1
1471 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA1), ed.sha1, sizeof(ed.sha1)) == 0);
1472 #endif
1473
1474 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA256), ed.sha256, sizeof(ed.sha256)) != 0);
1475
1476 assertEqualInt(ARCHIVE_OK, archive_sha256_init(&expectedSha256Ctx));
1477 assertEqualInt(ARCHIVE_OK, archive_sha256_update(&expectedSha256Ctx, "abcd", 4));
1478 assertEqualInt(ARCHIVE_OK, archive_sha256_final(&expectedSha256Ctx, ed.sha256));
1479
1480 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA256), ed.sha256, sizeof(ed.sha256)) == 0);
1481
1482 #ifdef ARCHIVE_HAS_SHA384
1483 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA384), ed.sha384, sizeof(ed.sha384)) == 0);
1484 #endif
1485
1486 #ifdef ARCHIVE_HAS_SHA512
1487 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA512), ed.sha512, sizeof(ed.sha512)) == 0);
1488 #endif
1489 archive_entry_free(entry);
1490 #else
1491 skipping("This platform does not support SHA256");
1492 return;
1493 #endif
1494 }
1495
DEFINE_TEST(test_write_format_mtree_digests_sha384_digest_set_no_data)1496 DEFINE_TEST(test_write_format_mtree_digests_sha384_digest_set_no_data)
1497 {
1498 #ifdef ARCHIVE_HAS_SHA384
1499 char buff[4096] = {0};
1500 size_t used = 0;
1501 struct archive *a;
1502 struct archive_entry *entry;
1503 struct expected_digests ed;
1504
1505 memcpy(ed.sha384, ((unsigned char[]) {
1506 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
1507 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
1508 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
1509 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
1510 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed
1511 }), sizeof(ed.sha384));
1512
1513 #ifdef ARCHIVE_HAS_MD5
1514 assertEqualInt(ARCHIVE_OK, archive_md5_init(&expectedMd5Ctx));
1515 assertEqualInt(ARCHIVE_OK, archive_md5_update(&expectedMd5Ctx, "", 0));
1516 assertEqualInt(ARCHIVE_OK, archive_md5_final(&expectedMd5Ctx, ed.md5));
1517 #endif
1518
1519 #ifdef ARCHIVE_HAS_RMD160
1520 assertEqualInt(ARCHIVE_OK, archive_rmd160_init(&expectedRmd160Ctx));
1521 assertEqualInt(ARCHIVE_OK, archive_rmd160_update(&expectedRmd160Ctx, "", 0));
1522 assertEqualInt(ARCHIVE_OK, archive_rmd160_final(&expectedRmd160Ctx, ed.rmd160));
1523 #endif
1524
1525 #ifdef ARCHIVE_HAS_SHA1
1526 assertEqualInt(ARCHIVE_OK, archive_sha1_init(&expectedSha1Ctx));
1527 assertEqualInt(ARCHIVE_OK, archive_sha1_update(&expectedSha1Ctx, "", 0));
1528 assertEqualInt(ARCHIVE_OK, archive_sha1_final(&expectedSha1Ctx, ed.sha1));
1529 #endif
1530
1531 #ifdef ARCHIVE_HAS_SHA256
1532 assertEqualInt(ARCHIVE_OK, archive_sha256_init(&expectedSha256Ctx));
1533 assertEqualInt(ARCHIVE_OK, archive_sha256_update(&expectedSha256Ctx, "", 0));
1534 assertEqualInt(ARCHIVE_OK, archive_sha256_final(&expectedSha256Ctx, ed.sha256));
1535 #endif
1536
1537 #ifdef ARCHIVE_HAS_SHA512
1538 assertEqualInt(ARCHIVE_OK, archive_sha512_init(&expectedSha512Ctx));
1539 assertEqualInt(ARCHIVE_OK, archive_sha512_update(&expectedSha512Ctx, "", 0));
1540 assertEqualInt(ARCHIVE_OK, archive_sha512_final(&expectedSha512Ctx, ed.sha512));
1541 #endif
1542
1543 assert((a = archive_write_new()) != NULL);
1544 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_mtree(a));
1545 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_options(a, "all"));
1546 assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, sizeof(buff) - 1, &used));
1547 assert((entry = archive_entry_new()) != NULL);
1548 archive_entry_set_pathname(entry, "test.data");
1549 archive_entry_set_filetype(entry, AE_IFREG);
1550 archive_entry_set_size(entry, 4);
1551 archive_entry_set_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA384, ed.sha384);
1552 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, entry));
1553 archive_entry_free(entry);
1554 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
1555 assertEqualIntA(a, ARCHIVE_OK, archive_write_free(a));
1556
1557 assert((a = archive_read_new()) != NULL);
1558 assert((entry = archive_entry_new()) != NULL);
1559 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
1560 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
1561 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));
1562 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &entry));
1563
1564 #ifdef ARCHIVE_HAS_MD5
1565 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_MD5), ed.md5, sizeof(ed.md5)) == 0);
1566 #endif
1567
1568 #ifdef ARCHIVE_HAS_RMD160
1569 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_RMD160), ed.rmd160, sizeof(ed.rmd160)) == 0);
1570 #endif
1571
1572 #ifdef ARCHIVE_HAS_SHA1
1573 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA1), ed.sha1, sizeof(ed.sha1)) == 0);
1574 #endif
1575
1576 #ifdef ARCHIVE_HAS_SHA256
1577 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA256), ed.sha256, sizeof(ed.sha256)) == 0);
1578 #endif
1579
1580 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA384), ed.sha384, sizeof(ed.sha384)) == 0);
1581
1582 #ifdef ARCHIVE_HAS_SHA512
1583 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA512), ed.sha512, sizeof(ed.sha512)) == 0);
1584 #endif
1585 archive_entry_free(entry);
1586 #else
1587 skipping("This platform does not support SHA384");
1588 return;
1589 #endif
1590 }
1591
DEFINE_TEST(test_write_format_mtree_digests_sha384_digest_set_empty_data)1592 DEFINE_TEST(test_write_format_mtree_digests_sha384_digest_set_empty_data)
1593 {
1594 #ifdef ARCHIVE_HAS_SHA384
1595 char buff[4096] = {0};
1596 size_t used = 0;
1597 struct archive *a;
1598 struct archive_entry *entry;
1599 struct expected_digests ed;
1600
1601 memcpy(ed.sha384, ((unsigned char[]) {
1602 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
1603 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
1604 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
1605 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
1606 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed
1607 }), sizeof(ed.sha384));
1608
1609 #ifdef ARCHIVE_HAS_MD5
1610 assertEqualInt(ARCHIVE_OK, archive_md5_init(&expectedMd5Ctx));
1611 assertEqualInt(ARCHIVE_OK, archive_md5_update(&expectedMd5Ctx, "", 0));
1612 assertEqualInt(ARCHIVE_OK, archive_md5_final(&expectedMd5Ctx, ed.md5));
1613 #endif
1614
1615 #ifdef ARCHIVE_HAS_RMD160
1616 assertEqualInt(ARCHIVE_OK, archive_rmd160_init(&expectedRmd160Ctx));
1617 assertEqualInt(ARCHIVE_OK, archive_rmd160_update(&expectedRmd160Ctx, "", 0));
1618 assertEqualInt(ARCHIVE_OK, archive_rmd160_final(&expectedRmd160Ctx, ed.rmd160));
1619 #endif
1620
1621 #ifdef ARCHIVE_HAS_SHA1
1622 assertEqualInt(ARCHIVE_OK, archive_sha1_init(&expectedSha1Ctx));
1623 assertEqualInt(ARCHIVE_OK, archive_sha1_update(&expectedSha1Ctx, "", 0));
1624 assertEqualInt(ARCHIVE_OK, archive_sha1_final(&expectedSha1Ctx, ed.sha1));
1625 #endif
1626
1627 #ifdef ARCHIVE_HAS_SHA256
1628 assertEqualInt(ARCHIVE_OK, archive_sha256_init(&expectedSha256Ctx));
1629 assertEqualInt(ARCHIVE_OK, archive_sha256_update(&expectedSha256Ctx, "", 0));
1630 assertEqualInt(ARCHIVE_OK, archive_sha256_final(&expectedSha256Ctx, ed.sha256));
1631 #endif
1632
1633 #ifdef ARCHIVE_HAS_SHA512
1634 assertEqualInt(ARCHIVE_OK, archive_sha512_init(&expectedSha512Ctx));
1635 assertEqualInt(ARCHIVE_OK, archive_sha512_update(&expectedSha512Ctx, "", 0));
1636 assertEqualInt(ARCHIVE_OK, archive_sha512_final(&expectedSha512Ctx, ed.sha512));
1637 #endif
1638
1639 assert((a = archive_write_new()) != NULL);
1640 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_mtree(a));
1641 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_options(a, "all"));
1642 assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, sizeof(buff) - 1, &used));
1643 assert((entry = archive_entry_new()) != NULL);
1644 archive_entry_set_pathname(entry, "test.data");
1645 archive_entry_set_filetype(entry, AE_IFREG);
1646 archive_entry_set_size(entry, 4);
1647 archive_entry_set_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA384, ed.sha384);
1648 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, entry));
1649 archive_write_data(a, "", 0);
1650 archive_entry_free(entry);
1651 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
1652 assertEqualIntA(a, ARCHIVE_OK, archive_write_free(a));
1653
1654 assert((a = archive_read_new()) != NULL);
1655 assert((entry = archive_entry_new()) != NULL);
1656 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
1657 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
1658 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));
1659 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &entry));
1660
1661 #ifdef ARCHIVE_HAS_MD5
1662 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_MD5), ed.md5, sizeof(ed.md5)) == 0);
1663 #endif
1664
1665 #ifdef ARCHIVE_HAS_RMD160
1666 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_RMD160), ed.rmd160, sizeof(ed.rmd160)) == 0);
1667 #endif
1668
1669 #ifdef ARCHIVE_HAS_SHA1
1670 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA1), ed.sha1, sizeof(ed.sha1)) == 0);
1671 #endif
1672
1673 #ifdef ARCHIVE_HAS_SHA256
1674 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA256), ed.sha256, sizeof(ed.sha256)) == 0);
1675 #endif
1676
1677 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA384), ed.sha384, sizeof(ed.sha384)) != 0);
1678
1679 assertEqualInt(ARCHIVE_OK, archive_sha384_init(&expectedSha384Ctx));
1680 assertEqualInt(ARCHIVE_OK, archive_sha384_update(&expectedSha384Ctx, "", 0));
1681 assertEqualInt(ARCHIVE_OK, archive_sha384_final(&expectedSha384Ctx, ed.sha384));
1682
1683 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA384), ed.sha384, sizeof(ed.sha384)) == 0);
1684
1685 #ifdef ARCHIVE_HAS_SHA512
1686 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA512), ed.sha512, sizeof(ed.sha512)) == 0);
1687 #endif
1688 archive_entry_free(entry);
1689 #else
1690 skipping("This platform does not support SHA384");
1691 return;
1692 #endif
1693 }
1694
DEFINE_TEST(test_write_format_mtree_digests_sha384_digest_set_non_empty_data)1695 DEFINE_TEST(test_write_format_mtree_digests_sha384_digest_set_non_empty_data)
1696 {
1697 #ifdef ARCHIVE_HAS_SHA384
1698 char buff[4096] = {0};
1699 size_t used = 0;
1700 struct archive *a;
1701 struct archive_entry *entry;
1702 struct expected_digests ed;
1703
1704 memcpy(ed.sha384, ((unsigned char[]) {
1705 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
1706 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
1707 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
1708 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
1709 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed
1710 }), sizeof(ed.sha384));
1711
1712 #ifdef ARCHIVE_HAS_MD5
1713 assertEqualInt(ARCHIVE_OK, archive_md5_init(&expectedMd5Ctx));
1714 assertEqualInt(ARCHIVE_OK, archive_md5_update(&expectedMd5Ctx, "abcd", 4));
1715 assertEqualInt(ARCHIVE_OK, archive_md5_final(&expectedMd5Ctx, ed.md5));
1716 #endif
1717
1718 #ifdef ARCHIVE_HAS_RMD160
1719 assertEqualInt(ARCHIVE_OK, archive_rmd160_init(&expectedRmd160Ctx));
1720 assertEqualInt(ARCHIVE_OK, archive_rmd160_update(&expectedRmd160Ctx, "abcd", 4));
1721 assertEqualInt(ARCHIVE_OK, archive_rmd160_final(&expectedRmd160Ctx, ed.rmd160));
1722 #endif
1723
1724 #ifdef ARCHIVE_HAS_SHA1
1725 assertEqualInt(ARCHIVE_OK, archive_sha1_init(&expectedSha1Ctx));
1726 assertEqualInt(ARCHIVE_OK, archive_sha1_update(&expectedSha1Ctx, "abcd", 4));
1727 assertEqualInt(ARCHIVE_OK, archive_sha1_final(&expectedSha1Ctx, ed.sha1));
1728 #endif
1729
1730 #ifdef ARCHIVE_HAS_SHA256
1731 assertEqualInt(ARCHIVE_OK, archive_sha256_init(&expectedSha256Ctx));
1732 assertEqualInt(ARCHIVE_OK, archive_sha256_update(&expectedSha256Ctx, "abcd", 4));
1733 assertEqualInt(ARCHIVE_OK, archive_sha256_final(&expectedSha256Ctx, ed.sha256));
1734 #endif
1735
1736 #ifdef ARCHIVE_HAS_SHA512
1737 assertEqualInt(ARCHIVE_OK, archive_sha512_init(&expectedSha512Ctx));
1738 assertEqualInt(ARCHIVE_OK, archive_sha512_update(&expectedSha512Ctx, "abcd", 4));
1739 assertEqualInt(ARCHIVE_OK, archive_sha512_final(&expectedSha512Ctx, ed.sha512));
1740 #endif
1741
1742 assert((a = archive_write_new()) != NULL);
1743 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_mtree(a));
1744 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_options(a, "all"));
1745 assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, sizeof(buff) - 1, &used));
1746 assert((entry = archive_entry_new()) != NULL);
1747 archive_entry_set_pathname(entry, "test.data");
1748 archive_entry_set_filetype(entry, AE_IFREG);
1749 archive_entry_set_size(entry, 4);
1750 archive_entry_set_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA384, ed.sha384);
1751 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, entry));
1752 archive_write_data(a, "abcd", 4);
1753 archive_entry_free(entry);
1754 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
1755 assertEqualIntA(a, ARCHIVE_OK, archive_write_free(a));
1756
1757 assert((a = archive_read_new()) != NULL);
1758 assert((entry = archive_entry_new()) != NULL);
1759 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
1760 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
1761 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));
1762 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &entry));
1763
1764 #ifdef ARCHIVE_HAS_MD5
1765 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_MD5), ed.md5, sizeof(ed.md5)) == 0);
1766 #endif
1767
1768 #ifdef ARCHIVE_HAS_RMD160
1769 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_RMD160), ed.rmd160, sizeof(ed.rmd160)) == 0);
1770 #endif
1771
1772 #ifdef ARCHIVE_HAS_SHA1
1773 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA1), ed.sha1, sizeof(ed.sha1)) == 0);
1774 #endif
1775
1776 #ifdef ARCHIVE_HAS_SHA256
1777 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA256), ed.sha256, sizeof(ed.sha256)) == 0);
1778 #endif
1779
1780 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA384), ed.sha384, sizeof(ed.sha384)) != 0);
1781
1782 assertEqualInt(ARCHIVE_OK, archive_sha384_init(&expectedSha384Ctx));
1783 assertEqualInt(ARCHIVE_OK, archive_sha384_update(&expectedSha384Ctx, "abcd", 4));
1784 assertEqualInt(ARCHIVE_OK, archive_sha384_final(&expectedSha384Ctx, ed.sha384));
1785
1786 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA384), ed.sha384, sizeof(ed.sha384)) == 0);
1787
1788 #ifdef ARCHIVE_HAS_SHA512
1789 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA512), ed.sha512, sizeof(ed.sha512)) == 0);
1790 #endif
1791 archive_entry_free(entry);
1792 #else
1793 skipping("This platform does not support SHA384");
1794 return;
1795 #endif
1796 }
1797
DEFINE_TEST(test_write_format_mtree_digests_sha512_digest_set_no_data)1798 DEFINE_TEST(test_write_format_mtree_digests_sha512_digest_set_no_data)
1799 {
1800 #ifdef ARCHIVE_HAS_SHA512
1801 char buff[4096] = {0};
1802 size_t used = 0;
1803 struct archive *a;
1804 struct archive_entry *entry;
1805 struct expected_digests ed;
1806
1807 memcpy(ed.sha512, ((unsigned char[]) {
1808 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
1809 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
1810 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
1811 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
1812 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
1813 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
1814 0xfe, 0xed, 0xfe, 0xed
1815 }), sizeof(ed.sha512));
1816
1817 #ifdef ARCHIVE_HAS_MD5
1818 assertEqualInt(ARCHIVE_OK, archive_md5_init(&expectedMd5Ctx));
1819 assertEqualInt(ARCHIVE_OK, archive_md5_update(&expectedMd5Ctx, "", 0));
1820 assertEqualInt(ARCHIVE_OK, archive_md5_final(&expectedMd5Ctx, ed.md5));
1821 #endif
1822
1823 #ifdef ARCHIVE_HAS_RMD160
1824 assertEqualInt(ARCHIVE_OK, archive_rmd160_init(&expectedRmd160Ctx));
1825 assertEqualInt(ARCHIVE_OK, archive_rmd160_update(&expectedRmd160Ctx, "", 0));
1826 assertEqualInt(ARCHIVE_OK, archive_rmd160_final(&expectedRmd160Ctx, ed.rmd160));
1827 #endif
1828
1829 #ifdef ARCHIVE_HAS_SHA1
1830 assertEqualInt(ARCHIVE_OK, archive_sha1_init(&expectedSha1Ctx));
1831 assertEqualInt(ARCHIVE_OK, archive_sha1_update(&expectedSha1Ctx, "", 0));
1832 assertEqualInt(ARCHIVE_OK, archive_sha1_final(&expectedSha1Ctx, ed.sha1));
1833 #endif
1834
1835 #ifdef ARCHIVE_HAS_SHA256
1836 assertEqualInt(ARCHIVE_OK, archive_sha256_init(&expectedSha256Ctx));
1837 assertEqualInt(ARCHIVE_OK, archive_sha256_update(&expectedSha256Ctx, "", 0));
1838 assertEqualInt(ARCHIVE_OK, archive_sha256_final(&expectedSha256Ctx, ed.sha256));
1839 #endif
1840
1841 #ifdef ARCHIVE_HAS_SHA384
1842 assertEqualInt(ARCHIVE_OK, archive_sha384_init(&expectedSha384Ctx));
1843 assertEqualInt(ARCHIVE_OK, archive_sha384_update(&expectedSha384Ctx, "", 0));
1844 assertEqualInt(ARCHIVE_OK, archive_sha384_final(&expectedSha384Ctx, ed.sha384));
1845 #endif
1846
1847 assert((a = archive_write_new()) != NULL);
1848 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_mtree(a));
1849 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_options(a, "all"));
1850 assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, sizeof(buff) - 1, &used));
1851 assert((entry = archive_entry_new()) != NULL);
1852 archive_entry_set_pathname(entry, "test.data");
1853 archive_entry_set_filetype(entry, AE_IFREG);
1854 archive_entry_set_size(entry, 4);
1855 archive_entry_set_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA512, ed.sha512);
1856 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, entry));
1857 archive_entry_free(entry);
1858 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
1859 assertEqualIntA(a, ARCHIVE_OK, archive_write_free(a));
1860
1861 assert((a = archive_read_new()) != NULL);
1862 assert((entry = archive_entry_new()) != NULL);
1863 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
1864 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
1865 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));
1866 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &entry));
1867
1868 #ifdef ARCHIVE_HAS_MD5
1869 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_MD5), ed.md5, sizeof(ed.md5)) == 0);
1870 #endif
1871
1872 #ifdef ARCHIVE_HAS_RMD160
1873 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_RMD160), ed.rmd160, sizeof(ed.rmd160)) == 0);
1874 #endif
1875
1876 #ifdef ARCHIVE_HAS_SHA1
1877 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA1), ed.sha1, sizeof(ed.sha1)) == 0);
1878 #endif
1879
1880 #ifdef ARCHIVE_HAS_SHA256
1881 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA256), ed.sha256, sizeof(ed.sha256)) == 0);
1882 #endif
1883
1884 #ifdef ARCHIVE_HAS_SHA384
1885 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA384), ed.sha384, sizeof(ed.sha384)) == 0);
1886 #endif
1887
1888 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA512), ed.sha512, sizeof(ed.sha512)) == 0);
1889
1890 archive_entry_free(entry);
1891 #else
1892 skipping("This platform does not support SHA512");
1893 return;
1894 #endif
1895 }
1896
DEFINE_TEST(test_write_format_mtree_digests_sha512_digest_set_empty_data)1897 DEFINE_TEST(test_write_format_mtree_digests_sha512_digest_set_empty_data)
1898 {
1899 #ifdef ARCHIVE_HAS_SHA512
1900 char buff[4096] = {0};
1901 size_t used = 0;
1902 struct archive *a;
1903 struct archive_entry *entry;
1904 struct expected_digests ed;
1905
1906 memcpy(ed.sha512, ((unsigned char[]) {
1907 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
1908 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
1909 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
1910 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
1911 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
1912 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
1913 0xfe, 0xed, 0xfe, 0xed
1914 }), sizeof(ed.sha512));
1915
1916 #ifdef ARCHIVE_HAS_MD5
1917 assertEqualInt(ARCHIVE_OK, archive_md5_init(&expectedMd5Ctx));
1918 assertEqualInt(ARCHIVE_OK, archive_md5_update(&expectedMd5Ctx, "", 0));
1919 assertEqualInt(ARCHIVE_OK, archive_md5_final(&expectedMd5Ctx, ed.md5));
1920 #endif
1921
1922 #ifdef ARCHIVE_HAS_RMD160
1923 assertEqualInt(ARCHIVE_OK, archive_rmd160_init(&expectedRmd160Ctx));
1924 assertEqualInt(ARCHIVE_OK, archive_rmd160_update(&expectedRmd160Ctx, "", 0));
1925 assertEqualInt(ARCHIVE_OK, archive_rmd160_final(&expectedRmd160Ctx, ed.rmd160));
1926 #endif
1927
1928 #ifdef ARCHIVE_HAS_SHA1
1929 assertEqualInt(ARCHIVE_OK, archive_sha1_init(&expectedSha1Ctx));
1930 assertEqualInt(ARCHIVE_OK, archive_sha1_update(&expectedSha1Ctx, "", 0));
1931 assertEqualInt(ARCHIVE_OK, archive_sha1_final(&expectedSha1Ctx, ed.sha1));
1932 #endif
1933
1934 #ifdef ARCHIVE_HAS_SHA256
1935 assertEqualInt(ARCHIVE_OK, archive_sha256_init(&expectedSha256Ctx));
1936 assertEqualInt(ARCHIVE_OK, archive_sha256_update(&expectedSha256Ctx, "", 0));
1937 assertEqualInt(ARCHIVE_OK, archive_sha256_final(&expectedSha256Ctx, ed.sha256));
1938 #endif
1939
1940 #ifdef ARCHIVE_HAS_SHA384
1941 assertEqualInt(ARCHIVE_OK, archive_sha384_init(&expectedSha384Ctx));
1942 assertEqualInt(ARCHIVE_OK, archive_sha384_update(&expectedSha384Ctx, "", 0));
1943 assertEqualInt(ARCHIVE_OK, archive_sha384_final(&expectedSha384Ctx, ed.sha384));
1944 #endif
1945
1946 assert((a = archive_write_new()) != NULL);
1947 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_mtree(a));
1948 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_options(a, "all"));
1949 assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, sizeof(buff) - 1, &used));
1950 assert((entry = archive_entry_new()) != NULL);
1951 archive_entry_set_pathname(entry, "test.data");
1952 archive_entry_set_filetype(entry, AE_IFREG);
1953 archive_entry_set_size(entry, 4);
1954 archive_entry_set_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA512, ed.sha512);
1955 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, entry));
1956 archive_write_data(a, "", 0);
1957 archive_entry_free(entry);
1958 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
1959 assertEqualIntA(a, ARCHIVE_OK, archive_write_free(a));
1960
1961 assert((a = archive_read_new()) != NULL);
1962 assert((entry = archive_entry_new()) != NULL);
1963 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
1964 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
1965 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));
1966 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &entry));
1967
1968 #ifdef ARCHIVE_HAS_MD5
1969 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_MD5), ed.md5, sizeof(ed.md5)) == 0);
1970 #endif
1971
1972 #ifdef ARCHIVE_HAS_RMD160
1973 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_RMD160), ed.rmd160, sizeof(ed.rmd160)) == 0);
1974 #endif
1975
1976 #ifdef ARCHIVE_HAS_SHA1
1977 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA1), ed.sha1, sizeof(ed.sha1)) == 0);
1978 #endif
1979
1980 #ifdef ARCHIVE_HAS_SHA256
1981 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA256), ed.sha256, sizeof(ed.sha256)) == 0);
1982 #endif
1983
1984 #ifdef ARCHIVE_HAS_SHA384
1985 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA384), ed.sha384, sizeof(ed.sha384)) == 0);
1986 #endif
1987
1988 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA512), ed.sha512, sizeof(ed.sha512)) != 0);
1989
1990 assertEqualInt(ARCHIVE_OK, archive_sha512_init(&expectedSha512Ctx));
1991 assertEqualInt(ARCHIVE_OK, archive_sha512_update(&expectedSha512Ctx, "", 0));
1992 assertEqualInt(ARCHIVE_OK, archive_sha512_final(&expectedSha512Ctx, ed.sha512));
1993
1994 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA512), ed.sha512, sizeof(ed.sha512)) == 0);
1995
1996 archive_entry_free(entry);
1997 #else
1998 skipping("This platform does not support SHA512");
1999 return;
2000 #endif
2001 }
2002
DEFINE_TEST(test_write_format_mtree_digests_sha512_digest_set_non_empty_data)2003 DEFINE_TEST(test_write_format_mtree_digests_sha512_digest_set_non_empty_data)
2004 {
2005 #ifdef ARCHIVE_HAS_SHA512
2006 char buff[4096] = {0};
2007 size_t used = 0;
2008 struct archive *a;
2009 struct archive_entry *entry;
2010 struct expected_digests ed;
2011
2012 memcpy(ed.sha512, ((unsigned char[]) {
2013 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
2014 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
2015 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
2016 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
2017 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
2018 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed, 0xfe, 0xed,
2019 0xfe, 0xed, 0xfe, 0xed
2020 }), sizeof(ed.sha512));
2021
2022 #ifdef ARCHIVE_HAS_MD5
2023 assertEqualInt(ARCHIVE_OK, archive_md5_init(&expectedMd5Ctx));
2024 assertEqualInt(ARCHIVE_OK, archive_md5_update(&expectedMd5Ctx, "abcd", 4));
2025 assertEqualInt(ARCHIVE_OK, archive_md5_final(&expectedMd5Ctx, ed.md5));
2026 #endif
2027
2028 #ifdef ARCHIVE_HAS_RMD160
2029 assertEqualInt(ARCHIVE_OK, archive_rmd160_init(&expectedRmd160Ctx));
2030 assertEqualInt(ARCHIVE_OK, archive_rmd160_update(&expectedRmd160Ctx, "abcd", 4));
2031 assertEqualInt(ARCHIVE_OK, archive_rmd160_final(&expectedRmd160Ctx, ed.rmd160));
2032 #endif
2033
2034 #ifdef ARCHIVE_HAS_SHA1
2035 assertEqualInt(ARCHIVE_OK, archive_sha1_init(&expectedSha1Ctx));
2036 assertEqualInt(ARCHIVE_OK, archive_sha1_update(&expectedSha1Ctx, "abcd", 4));
2037 assertEqualInt(ARCHIVE_OK, archive_sha1_final(&expectedSha1Ctx, ed.sha1));
2038 #endif
2039
2040 #ifdef ARCHIVE_HAS_SHA256
2041 assertEqualInt(ARCHIVE_OK, archive_sha256_init(&expectedSha256Ctx));
2042 assertEqualInt(ARCHIVE_OK, archive_sha256_update(&expectedSha256Ctx, "abcd", 4));
2043 assertEqualInt(ARCHIVE_OK, archive_sha256_final(&expectedSha256Ctx, ed.sha256));
2044 #endif
2045
2046 #ifdef ARCHIVE_HAS_SHA384
2047 assertEqualInt(ARCHIVE_OK, archive_sha384_init(&expectedSha384Ctx));
2048 assertEqualInt(ARCHIVE_OK, archive_sha384_update(&expectedSha384Ctx, "abcd", 4));
2049 assertEqualInt(ARCHIVE_OK, archive_sha384_final(&expectedSha384Ctx, ed.sha384));
2050 #endif
2051
2052 assert((a = archive_write_new()) != NULL);
2053 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_mtree(a));
2054 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_options(a, "all"));
2055 assertEqualIntA(a, ARCHIVE_OK, archive_write_open_memory(a, buff, sizeof(buff) - 1, &used));
2056 assert((entry = archive_entry_new()) != NULL);
2057 archive_entry_set_pathname(entry, "test.data");
2058 archive_entry_set_filetype(entry, AE_IFREG);
2059 archive_entry_set_size(entry, 4);
2060 archive_entry_set_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA512, ed.sha512);
2061 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, entry));
2062 archive_write_data(a, "abcd", 4);
2063 archive_entry_free(entry);
2064 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
2065 assertEqualIntA(a, ARCHIVE_OK, archive_write_free(a));
2066
2067 assert((a = archive_read_new()) != NULL);
2068 assert((entry = archive_entry_new()) != NULL);
2069 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
2070 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
2071 assertEqualIntA(a, ARCHIVE_OK, archive_read_open_memory(a, buff, used));
2072 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &entry));
2073
2074 #ifdef ARCHIVE_HAS_MD5
2075 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_MD5), ed.md5, sizeof(ed.md5)) == 0);
2076 #endif
2077
2078 #ifdef ARCHIVE_HAS_RMD160
2079 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_RMD160), ed.rmd160, sizeof(ed.rmd160)) == 0);
2080 #endif
2081
2082 #ifdef ARCHIVE_HAS_SHA1
2083 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA1), ed.sha1, sizeof(ed.sha1)) == 0);
2084 #endif
2085
2086 #ifdef ARCHIVE_HAS_SHA256
2087 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA256), ed.sha256, sizeof(ed.sha256)) == 0);
2088 #endif
2089
2090 #ifdef ARCHIVE_HAS_SHA384
2091 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA384), ed.sha384, sizeof(ed.sha384)) == 0);
2092 #endif
2093
2094 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA512), ed.sha512, sizeof(ed.sha512)) != 0);
2095
2096 assertEqualInt(ARCHIVE_OK, archive_sha512_init(&expectedSha512Ctx));
2097 assertEqualInt(ARCHIVE_OK, archive_sha512_update(&expectedSha512Ctx, "abcd", 4));
2098 assertEqualInt(ARCHIVE_OK, archive_sha512_final(&expectedSha512Ctx, ed.sha512));
2099
2100 assert(memcmp(archive_entry_digest(entry, ARCHIVE_ENTRY_DIGEST_SHA512), ed.sha512, sizeof(ed.sha512)) == 0);
2101
2102 archive_entry_free(entry);
2103 #else
2104 skipping("This platform does not support SHA512");
2105 return;
2106 #endif
2107 }
2108