← Back to branch summary

~ubuntu-branches/ubuntu/saucy/clamav/saucy-backports

« back to all changes in this revision

Viewing changes to unit_tests/check_clamav.c

  • Committer: Package Import Robot
  • Author(s): Scott Kitterman
  • Date: 2014-07-15 01:08:10 UTC
  • mfrom: (0.35.47 sid)
  • Revision ID: package-import@ubuntu.com-20140715010810-ru66ek4fun2iseba
Tags: 0.98.4+dfsg-2~ubuntu13.10.1
https://launchpad.net/bugs/1341962
No-change backport to saucy (LP: #1341962)

Show diffs side-by-side

added added

removed removed

Lines of Context:
unit_tests/check_clamav.c
12
12
#include <sys/types.h>
13
13
#include <dirent.h>
14
14
#include <sys/mman.h>
 
15
 
 
16
#include <openssl/ssl.h>
 
17
#include <openssl/err.h>
 
18
#include "libclamav/crypto.h"
 
19
 
15
20
#include "../libclamav/clamav.h"
16
21
#include "../libclamav/others.h"
17
22
#include "../libclamav/matcher.h"
18
23
#include "../libclamav/version.h"
19
24
#include "../libclamav/dsig.h"
20
 
#include "../libclamav/sha256.h"
 
25
#include "../libclamav/fpu.h"
21
26
#include "checks.h"
22
27
 
 
28
static int fpu_words  = FPU_ENDIAN_INITME;
 
29
#define NO_FPU_ENDIAN (fpu_words == FPU_ENDIAN_UNKNOWN)
 
30
#define EA06_SCAN strstr(file, "clam.ea06.exe")
 
31
#define FALSE_NEGATIVE (EA06_SCAN && NO_FPU_ENDIAN)
 
32
 
23
33
/* extern void cl_free(struct cl_engine *engine); */
24
34
START_TEST (test_cl_free)
25
35
/*
164
174
    ret = cl_scandesc(fd, &virname, &scanned, g_engine, CL_SCAN_STDOPT);
165
175
    cli_dbgmsg("scan end (scandesc) %s\n", file);
166
176
 
167
 
    fail_unless_fmt(ret == CL_VIRUS, "cl_scandesc failed for %s: %s", file, cl_strerror(ret));
168
 
    fail_unless_fmt(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", virname);
 
177
    if (!FALSE_NEGATIVE) {
 
178
      fail_unless_fmt(ret == CL_VIRUS, "cl_scandesc failed for %s: %s", file, cl_strerror(ret));
 
179
      fail_unless_fmt(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", virname);
 
180
    }
169
181
    close(fd);
170
182
}
171
183
END_TEST
182
194
    int fd = get_test_file(_i, file, sizeof(file), &size);
183
195
    cli_dbgmsg("scanning (scandesc) %s\n", file);
184
196
    ret = cl_scandesc(fd, virpp, &scanned, g_engine, CL_SCAN_ALLMATCHES+CL_SCAN_STDOPT);
185
 
    virpp = (const char **)*virpp; /* allscan api hack */
 
197
 
186
198
    cli_dbgmsg("scan end (scandesc) %s\n", file);
187
199
 
188
 
    fail_unless_fmt(ret == CL_VIRUS, "cl_scandesc_allscan failed for %s: %s", file, cl_strerror(ret));
189
 
    fail_unless_fmt(*virpp && !strcmp(*virpp, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", *virpp);
190
 
    free((void *)virpp);
 
200
    if (!FALSE_NEGATIVE) {
 
201
      fail_unless_fmt(ret == CL_VIRUS, "cl_scandesc_allscan failed for %s: %s", file, cl_strerror(ret));
 
202
      virpp = (const char **)*virpp; /* allscan api hack */
 
203
      fail_unless_fmt(*virpp && !strcmp(*virpp, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", *virpp);
 
204
      free((void *)virpp);
 
205
    }
191
206
    close(fd);
192
207
}
193
208
END_TEST
208
223
    ret = cl_scanfile(file, &virname, &scanned, g_engine, CL_SCAN_STDOPT);
209
224
    cli_dbgmsg("scan end (scanfile) %s\n", file);
210
225
 
211
 
    fail_unless_fmt(ret == CL_VIRUS, "cl_scanfile failed for %s: %s", file, cl_strerror(ret));
212
 
    fail_unless_fmt(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", virname);
 
226
    if (!FALSE_NEGATIVE) {
 
227
      fail_unless_fmt(ret == CL_VIRUS , "cl_scanfile failed for %s: %s", file, cl_strerror(ret));
 
228
      fail_unless_fmt(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", virname);
 
229
    }
213
230
}
214
231
END_TEST
215
232
 
227
244
 
228
245
    cli_dbgmsg("scanning (scanfile_allscan) %s\n", file);
229
246
    ret = cl_scanfile(file, virpp, &scanned, g_engine, CL_SCAN_ALLMATCHES+CL_SCAN_STDOPT);
230
 
    virpp = (const char **)*virpp; /* allscan api hack */
231
247
    cli_dbgmsg("scan end (scanfile_allscan) %s\n", file);
232
248
 
233
 
    fail_unless_fmt(ret == CL_VIRUS, "cl_scanfile_allscan failed for %s: %s", file, cl_strerror(ret));
234
 
    fail_unless_fmt(*virpp && !strcmp(*virpp, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", *virpp);
235
 
    free((void *)virpp);
 
249
    if (!FALSE_NEGATIVE) {
 
250
      fail_unless_fmt(ret == CL_VIRUS, "cl_scanfile_allscan failed for %s: %s", file, cl_strerror(ret));
 
251
      virpp = (const char **)*virpp; /* allscan api hack */
 
252
      fail_unless_fmt(*virpp && !strcmp(*virpp, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", *virpp);
 
253
      free((void *)virpp);
 
254
    }
236
255
}
237
256
END_TEST
238
257
 
252
271
    ret = cl_scanfile_callback(file, &virname, &scanned, g_engine, CL_SCAN_STDOPT, NULL);
253
272
    cli_dbgmsg("scan end (scanfile_cb) %s\n", file);
254
273
 
255
 
    fail_unless_fmt(ret == CL_VIRUS, "cl_scanfile_cb failed for %s: %s", file, cl_strerror(ret));
256
 
    fail_unless_fmt(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", virname);
 
274
    if (!FALSE_NEGATIVE) {
 
275
      fail_unless_fmt(ret == CL_VIRUS, "cl_scanfile_cb failed for %s: %s", file, cl_strerror(ret));
 
276
      fail_unless_fmt(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", virname);
 
277
    }
257
278
}
258
279
END_TEST
259
280
 
272
293
    cli_dbgmsg("scanning (scanfile_cb_allscan) %s\n", file);
273
294
    /* TODO: test callbacks */
274
295
    ret = cl_scanfile_callback(file, virpp, &scanned, g_engine, CL_SCAN_ALLMATCHES+CL_SCAN_STDOPT, NULL);
275
 
    virpp = (const char **)*virpp; /* allscan api hack */
276
296
    cli_dbgmsg("scan end (scanfile_cb_allscan) %s\n", file);
277
297
 
278
 
    fail_unless_fmt(ret == CL_VIRUS, "cl_scanfile_cb_allscan failed for %s: %s", file, cl_strerror(ret));
279
 
    fail_unless_fmt(*virpp && !strcmp(*virpp, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", *virpp);
280
 
    free((void *)virpp);
 
298
    if (!FALSE_NEGATIVE) {
 
299
      fail_unless_fmt(ret == CL_VIRUS, "cl_scanfile_cb_allscan failed for %s: %s", file, cl_strerror(ret));
 
300
      virpp = (const char **)*virpp; /* allscan api hack */
 
301
      fail_unless_fmt(*virpp && !strcmp(*virpp, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", *virpp);
 
302
      free((void *)virpp);
 
303
    }
281
304
}
282
305
END_TEST
283
306
 
296
319
    ret = cl_scandesc_callback(fd, &virname, &scanned, g_engine, CL_SCAN_STDOPT, NULL);
297
320
    cli_dbgmsg("scan end (scandesc_cb) %s\n", file);
298
321
 
299
 
    fail_unless_fmt(ret == CL_VIRUS, "cl_scanfile failed for %s: %s", file, cl_strerror(ret));
300
 
    fail_unless_fmt(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", virname);
 
322
    if (!FALSE_NEGATIVE) {
 
323
      fail_unless_fmt(ret == CL_VIRUS, "cl_scanfile failed for %s: %s", file, cl_strerror(ret));
 
324
      fail_unless_fmt(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", virname);
 
325
    }
301
326
    close(fd);
302
327
}
303
328
END_TEST
316
341
    cli_dbgmsg("scanning (scandesc_cb_allscan) %s\n", file);
317
342
    /* TODO: test callbacks */
318
343
    ret = cl_scandesc_callback(fd, virpp, &scanned, g_engine, CL_SCAN_ALLMATCHES+CL_SCAN_STDOPT, NULL);
319
 
    virpp = (const char **)*virpp; /* allscan api hack */
320
344
    cli_dbgmsg("scan end (scandesc_cb_allscan) %s\n", file);
321
345
 
322
 
    fail_unless_fmt(ret == CL_VIRUS, "cl_scanfile_allscan failed for %s: %s", file, cl_strerror(ret));
323
 
    fail_unless_fmt(*virpp && !strcmp(*virpp, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", *virpp);
324
 
    free((void *)virpp);
 
346
    if (!FALSE_NEGATIVE) {
 
347
      fail_unless_fmt(ret == CL_VIRUS, "cl_scanfile_allscan failed for %s: %s", file, cl_strerror(ret));
 
348
      virpp = (const char **)*virpp; /* allscan api hack */
 
349
      fail_unless_fmt(*virpp && !strcmp(*virpp, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", *virpp);
 
350
      free((void *)virpp);
 
351
    }
325
352
    close(fd);
326
353
}
327
354
END_TEST
355
382
static char **testfiles = NULL;
356
383
static unsigned testfiles_n = 0;
357
384
 
 
385
static const int expected_testfiles = 48;
 
386
 
 
387
static unsigned skip_files(void)
 
388
{
 
389
    unsigned skipped = 0;
 
390
 
 
391
    /* skip .rar files if unrar is disabled */
 
392
    const char *s = getenv("unrar_disabled");
 
393
    if (s && !strcmp(s, "1")) {
 
394
        skipped += 2;
 
395
    }
 
396
 
 
397
    /* skip .bz2 files if bzip is disabled */
358
398
#if HAVE_BZLIB_H
359
 
static const int expected_testfiles = 48;
360
 
#else
361
 
static const int expected_testfiles = 46;
362
 
#endif
363
 
 
364
 
static unsigned skip_unrar_files(void)
365
 
{
366
 
        const char *s = getenv("unrar_disabled");
367
 
 
368
 
        if (!s)
369
 
                return 0;
370
 
 
371
 
        if (strcmp(s, "1"))
372
 
                return 0;
373
 
 
374
 
        /* number of .rar files we skipp */
375
 
        return 2;
 
399
#else
 
400
    skipped += 2;
 
401
#endif
 
402
 
 
403
    /* skip [placeholder] files if xml is disabled */
 
404
#if HAVE_LIBXML2
 
405
#else
 
406
    skipped += 0;
 
407
#endif
 
408
 
 
409
    return skipped;
376
410
}
377
411
 
378
412
static void init_testfiles(void)
379
413
{
380
414
    struct dirent *dirent;
381
 
    int expect = expected_testfiles;
382
415
    unsigned i = 0;
 
416
    int expect = expected_testfiles;
383
417
 
384
418
    DIR *d = opendir(OBJDIR"/../test");
385
419
    fail_unless(!!d, "opendir");
390
424
    while ((dirent = readdir(d))) {
391
425
        if (strncmp(dirent->d_name, "clam", 4))
392
426
            continue;
393
 
        if (strstr(dirent->d_name, ".rar") && skip_unrar_files()) {
394
 
                cli_dbgmsg("skipping (no unrar) %s\n", dirent->d_name);
395
 
                continue;
396
 
        }
397
 
        i++;
 
427
        i++;
398
428
        testfiles = cli_realloc(testfiles, i*sizeof(*testfiles));
399
429
        fail_unless(!!testfiles, "cli_realloc");
400
430
        testfiles[i-1] = strdup(dirent->d_name);
401
431
    }
402
432
    testfiles_n = i;
403
 
    expect -= skip_unrar_files();
 
433
    if (get_fpu_endian() == FPU_ENDIAN_UNKNOWN)
 
434
        expect--;
 
435
    expect -= skip_files();
404
436
    fail_unless_fmt(testfiles_n == expect, "testfiles: %d != %d", testfiles_n, expect);
405
437
 
406
438
    closedir(d);
446
478
    int fd;
447
479
    STATBUF st;
448
480
 
449
 
    fail_unless(i < testfiles_n);
 
481
    fail_unless(i < testfiles_n, "%i < %i %s", i, testfiles_n, file);
450
482
    snprintf(file, fsize, OBJDIR"/../test/%s", testfiles[i]);
451
483
 
452
484
    fd = open(file, O_RDONLY);
480
512
    ret = cl_scanmap_callback(map, &virname, &scanned, g_engine, CL_SCAN_STDOPT, NULL);
481
513
    cli_dbgmsg("scan end (handle) %s\n", file);
482
514
 
483
 
    fail_unless_fmt(ret == CL_VIRUS, "cl_scanmap_callback failed for %s: %s", file, cl_strerror(ret));
484
 
    fail_unless_fmt(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", virname);
 
515
    if (!FALSE_NEGATIVE) {
 
516
      fail_unless_fmt(ret == CL_VIRUS, "cl_scanmap_callback failed for %s: %s", file, cl_strerror(ret));
 
517
      fail_unless_fmt(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", virname);
 
518
    }
485
519
    close(fd);
486
520
}
487
521
END_TEST
499
533
    int fd = get_test_file(_i, file, sizeof(file), &size);
500
534
    /* intentionally use different way than scanners.c for testing */
501
535
    map = cl_fmap_open_handle(&fd, 0, size, pread_cb, 1);
502
 
    fail_unless(!!map, "cl_fmap_open_handle");
 
536
    fail_unless(!!map, "cl_fmap_open_handle %s");
503
537
 
504
538
    cli_dbgmsg("scanning (handle) allscan %s\n", file);
505
539
    ret = cl_scanmap_callback(map, virpp, &scanned, g_engine, CL_SCAN_ALLMATCHES+CL_SCAN_STDOPT, NULL);
506
 
    virpp = (const char **)*virpp; /* allscan api hack */
507
540
    cli_dbgmsg("scan end (handle) allscan %s\n", file);
508
541
 
509
 
    fail_unless_fmt(ret == CL_VIRUS, "cl_scanmap_callback_allscan failed for %s: %s", file, cl_strerror(ret));
510
 
    fail_unless_fmt(*virpp && !strcmp(*virpp, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", *virpp);
511
 
    free((void *)virpp);
 
542
    if (!FALSE_NEGATIVE) {
 
543
      fail_unless_fmt(ret == CL_VIRUS, "cl_scanmap_callback_allscan failed for %s: %s", file, cl_strerror(ret));
 
544
      virpp = (const char **)*virpp; /* allscan api hack */
 
545
      fail_unless_fmt(*virpp && !strcmp(*virpp, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", *virpp);
 
546
      free((void *)virpp);
 
547
    }
512
548
    close(fd);
513
549
}
514
550
END_TEST
535
571
    cli_dbgmsg("scanning (mem) %s\n", file);
536
572
    ret = cl_scanmap_callback(map, &virname, &scanned, g_engine, CL_SCAN_STDOPT, NULL);
537
573
    cli_dbgmsg("scan end (mem) %s\n", file);
538
 
    fail_unless_fmt(ret == CL_VIRUS, "cl_scanmap_callback failed for %s: %s", file, cl_strerror(ret));
539
 
    fail_unless_fmt(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s for %s", virname, file);
 
574
    if (!FALSE_NEGATIVE) {
 
575
      fail_unless_fmt(ret == CL_VIRUS, "cl_scanmap_callback failed for %s: %s", file, cl_strerror(ret));
 
576
      fail_unless_fmt(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s for %s", virname, file);
 
577
    }
540
578
    close(fd);
541
579
    cl_fmap_close(map);
542
580
 
562
600
 
563
601
    /* intentionally use different way than scanners.c for testing */
564
602
    map = cl_fmap_open_memory(mem, size);
565
 
    fail_unless(!!map, "cl_fmap_open_mem");
 
603
    fail_unless(!!map, "cl_fmap_open_mem %s");
566
604
 
567
605
    cli_dbgmsg("scanning (mem) allscan %s\n", file);
568
606
    ret = cl_scanmap_callback(map, virpp, &scanned, g_engine, CL_SCAN_ALLMATCHES+CL_SCAN_STDOPT, NULL);
569
 
    virpp = (const char **)*virpp; /* allscan api hack */
570
607
    cli_dbgmsg("scan end (mem) allscan %s\n", file);
571
 
    fail_unless_fmt(ret == CL_VIRUS, "cl_scanmap_callback failed for %s: %s", file, cl_strerror(ret));
572
 
    fail_unless_fmt(*virpp && !strcmp(*virpp, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s for %s", *virpp, file);
 
608
    if (!FALSE_NEGATIVE) {
 
609
      fail_unless_fmt(ret == CL_VIRUS, "cl_scanmap_callback failed for %s: %s", file, cl_strerror(ret));
 
610
      virpp = (const char **)*virpp; /* allscan api hack */
 
611
      fail_unless_fmt(*virpp && !strcmp(*virpp, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s for %s", *virpp, file);
 
612
      free((void *)virpp);
 
613
    }
573
614
    close(fd);
574
615
    cl_fmap_close(map);
575
 
    free((void *)virpp);
576
616
    munmap(mem, size);
577
617
}
578
618
END_TEST
580
620
 
581
621
static Suite *test_cl_suite(void)
582
622
{
583
 
    int expect = expected_testfiles;
584
 
 
585
623
    Suite *s = suite_create("cl_api");
586
624
    TCase *tc_cl = tcase_create("cl_dup");
587
625
    TCase *tc_cl_scan = tcase_create("cl_scan");
 
626
    int expect = expected_testfiles;
588
627
    suite_add_tcase (s, tc_cl);
589
628
    tcase_add_test(tc_cl, test_cl_free);
590
629
    tcase_add_test(tc_cl, test_cl_dup);
607
646
    suite_add_tcase(s, tc_cl_scan);
608
647
    tcase_add_checked_fixture (tc_cl_scan, engine_setup, engine_teardown);
609
648
#ifdef CHECK_HAVE_LOOPS
610
 
    expect -= skip_unrar_files();
611
 
 
 
649
    if (get_fpu_endian() == FPU_ENDIAN_UNKNOWN)
 
650
        expect--;
 
651
    expect -= skip_files();
612
652
    tcase_add_loop_test(tc_cl_scan, test_cl_scandesc, 0, expect);
613
653
    tcase_add_loop_test(tc_cl_scan, test_cl_scandesc_allscan, 0, expect);
614
654
    tcase_add_loop_test(tc_cl_scan, test_cl_scanfile, 0, expect);
777
817
 
778
818
START_TEST (test_sha256)
779
819
{
780
 
    SHA256_CTX sha256;
 
820
    void *sha256;
781
821
    uint8_t hsha256[SHA256_HASH_SIZE];
782
822
    uint8_t buf[1000];
783
823
    int i;
784
824
 
785
825
    memset (buf, 0x61, sizeof (buf));
786
826
 
787
 
    sha256_init (&sha256);
788
 
    sha256_update (&sha256, tv1, sizeof (tv1));
789
 
    sha256_final (&sha256, hsha256);
 
827
    cl_sha256(tv1, sizeof(tv1), hsha256, NULL);
790
828
    fail_unless(!memcmp (hsha256, res256[0], sizeof (hsha256)), "sha256 test vector #1 failed");
791
829
 
792
 
    sha256_init (&sha256);
793
 
    sha256_update (&sha256, tv2, sizeof (tv2));
794
 
    sha256_final (&sha256, hsha256);
 
830
    cl_sha256(tv2, sizeof(tv2), hsha256, NULL);
795
831
    fail_unless(!memcmp (hsha256, res256[1], sizeof (hsha256)), "sha256 test vector #2 failed");
796
832
 
797
 
    sha256_init (&sha256);
 
833
    sha256 = cl_hash_init("sha256");
 
834
    fail_unless(sha256 != NULL, "Could not create EVP_MD_CTX for sha256");
 
835
 
798
836
    for (i = 0; i < 1000; i++)
799
 
        sha256_update (&sha256, buf, sizeof (buf));
800
 
    sha256_final (&sha256, hsha256);
 
837
        cl_update_hash (sha256, buf, sizeof (buf));
 
838
    cl_finish_hash(sha256, hsha256);
801
839
    fail_unless(!memcmp (hsha256, res256[2], sizeof (hsha256)), "sha256 test vector #3 failed");
802
840
}
803
841
END_TEST
948
986
    Suite *s;
949
987
    SRunner *sr;
950
988
 
 
989
    cl_initialize_crypto();
 
990
 
 
991
    fpu_words  = get_fpu_endian();
 
992
  
951
993
    check_version_compatible();
952
994
    s = test_cl_suite();
953
995
    sr = srunner_create(s);
976
1018
    nf = srunner_ntests_failed(sr);
977
1019
    srunner_free(sr);
978
1020
 
 
1021
    cl_cleanup_crypto();
 
1022
 
979
1023
    return (nf == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
980
1024
}