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

« back to all changes in this revision

Viewing changes to libclamav/others.c

• browse files at revision 130
• compare with another revision
• compare with revision 130
• download diff
• download tarball
• view history from revision 130

Show diffs side-by-side

added

removed

libclamav/others.c

52

52

#include <malloc.h>

53

53

#endif

54

54

 

 

55

#ifdef CL_THREAD_SAFE

 

56

#include <pthread.h>

 

57

#endif

 

58

 

55

59

#if defined(HAVE_READDIR_R_3) || defined(HAVE_READDIR_R_2)

56

60

#include <limits.h>

57

61

#include <stddef.h>

58

62

#endif

59

63

 

 

64

#ifdef HAVE_LIBXML2

 

65

#include <libxml/parser.h>

 

66

#endif

 

67

 

 

68

#include <openssl/ssl.h>

 

69

#include <openssl/err.h>

 

70

#include "libclamav/crypto.h"

 

71

 

60

72

#include "clamav.h"

61

73

#include "others.h"

62

 

#include "md5.h"

63

 

#include "sha1.h"

64

 

#include "sha256.h"

65

74

#include "cltypes.h"

66

75

#include "regex/regex.h"

67

76

#include "ltdl.h"

71

80

#include "bytecode.h"

72

81

#include "bytecode_api_impl.h"

73

82

#include "cache.h"

 

83

#include "stats.h"

74

84

 

75

85

int (*cli_unrar_open)(int fd, const char *dirname, unrar_state_t *state);

76

86

int (*cli_unrar_extract_next_prepare)(unrar_state_t *state, const char *dirname);

280

290

        struct timeval tv;

281

291

        unsigned int pid = (unsigned int) getpid();

282

292

 

 

293

    cl_initialize_crypto();

 

294

 

283

295

    {

284

296

        unrar_main_header_t x;

285

297

        if (((char*)&x.flags - (char*)&x) != 3) {

306

318

struct cl_engine *cl_engine_new(void)

307

319

{

308

320

        struct cl_engine *new;

309

 

 

 

321

    cli_intel_t *intel;

310

322

 

311

323

    new = (struct cl_engine *) cli_calloc(1, sizeof(struct cl_engine));

312

324

    if(!new) {

378

390

        return NULL;

379

391

    }

380

392

 

 

393

    /* Set up default stats/intel gathering callbacks */

 

394

    intel = cli_calloc(1, sizeof(cli_intel_t));

 

395

    if ((intel)) {

 

396

#ifdef CL_THREAD_SAFE

 

397

        if (pthread_mutex_init(&(intel->mutex), NULL)) {

 

398

            cli_errmsg("cli_engine_new: Cannot initialize stats gathering mutex\n");

 

399

            mpool_free(new->mempool, new->dconf);

 

400

            mpool_free(new->mempool, new->root);

 

401

#ifdef USE_MPOOL

 

402

            mpool_destroy(new->mempool);

 

403

#endif

 

404

            free(new);

 

405

            free(intel);

 

406

            return NULL;

 

407

        }

 

408

#endif

 

409

        intel->engine = new;

 

410

        intel->maxsamples = STATS_MAX_SAMPLES;

 

411

        intel->maxmem = STATS_MAX_MEM;

 

412

        intel->timeout = 10;

 

413

        new->stats_data = intel;

 

414

    } else {

 

415

        new->stats_data = NULL;

 

416

    }

 

417

 

 

418

    new->cb_stats_add_sample = NULL;

 

419

    new->cb_stats_submit = NULL;

 

420

    new->cb_stats_flush = clamav_stats_flush;

 

421

    new->cb_stats_remove_sample = clamav_stats_remove_sample;

 

422

    new->cb_stats_decrement_count = clamav_stats_decrement_count;

 

423

    new->cb_stats_get_num = clamav_stats_get_num;

 

424

    new->cb_stats_get_size = clamav_stats_get_size;

 

425

    new->cb_stats_get_hostid = clamav_stats_get_hostid;

 

426

 

 

427

    /* Setup raw disk image max settings */

 

428

    new->maxpartitions = CLI_DEFAULT_MAXPARTITIONS;

 

429

 

 

430

    /* Engine max settings */

 

431

    new->maxiconspe = CLI_DEFAULT_MAXICONSPE;

 

432

 

381

433

    cli_dbgmsg("Initialized %s engine\n", cl_retver());

382

434

    return new;

383

435

}

467

519

            break;

468

520

        case CL_ENGINE_FORCETODISK:

469

521

            if(num)

470

 

                engine->forcetodisk = 1;

 

522

                engine->engine_options |= ENGINE_OPTIONS_FORCE_TO_DISK;

471

523

            else

472

 

                engine->forcetodisk = 0;

 

524

                engine->engine_options &= ~(ENGINE_OPTIONS_FORCE_TO_DISK);

473

525

            break;

474

526

        case CL_ENGINE_BYTECODE_SECURITY:

475

527

            if (engine->dboptions & CL_DB_COMPILED) {

494

546

            if (num == CL_BYTECODE_MODE_TEST)

495

547

                cli_infomsg(NULL, "bytecode engine in test mode\n");

496

548

            break;

 

549

        case CL_ENGINE_DISABLE_CACHE:

 

550

            if (num) {

 

551

                engine->engine_options |= ENGINE_OPTIONS_DISABLE_CACHE;

 

552

            } else {

 

553

                engine->engine_options &= ~(ENGINE_OPTIONS_DISABLE_CACHE);

 

554

                if (!(engine->cache))

 

555

                    cli_cache_init(engine);

 

556

            }

 

557

            break;

 

558

        case CL_ENGINE_DISABLE_PE_STATS:

 

559

            if (num) {

 

560

                engine->engine_options |= ENGINE_OPTIONS_DISABLE_PE_STATS;

 

561

            } else {

 

562

                engine->engine_options &= ~(ENGINE_OPTIONS_DISABLE_PE_STATS);

 

563

            }

 

564

            break;

 

565

        case CL_ENGINE_STATS_TIMEOUT:

 

566

            if ((engine->stats_data)) {

 

567

                cli_intel_t *intel = (cli_intel_t *)(engine->stats_data);

 

568

 

 

569

                intel->timeout = (uint32_t)num;

 

570

            }

 

571

            break;

 

572

        case CL_ENGINE_MAX_PARTITIONS:

 

573

            engine->maxpartitions = (uint32_t)num;

 

574

            break;

 

575

        case CL_ENGINE_MAX_ICONSPE:

 

576

           engine->maxiconspe = (uint32_t)num;

 

577

           break;

497

578

        default:

498

579

            cli_errmsg("cl_engine_set_num: Incorrect field number\n");

499

580

            return CL_EARG;

552

633

        case CL_ENGINE_KEEPTMP:

553

634

            return engine->keeptmp;

554

635

        case CL_ENGINE_FORCETODISK:

555

 

            return engine->forcetodisk;

 

636

            return engine->engine_options & ENGINE_OPTIONS_FORCE_TO_DISK;

556

637

        case CL_ENGINE_BYTECODE_SECURITY:

557

638

            return engine->bytecode_security;

558

639

        case CL_ENGINE_BYTECODE_TIMEOUT:

559

640

            return engine->bytecode_timeout;

560

641

        case CL_ENGINE_BYTECODE_MODE:

561

642

            return engine->bytecode_mode;

 

643

        case CL_ENGINE_DISABLE_CACHE:

 

644

            return engine->engine_options & ENGINE_OPTIONS_DISABLE_CACHE;

 

645

        case CL_ENGINE_STATS_TIMEOUT:

 

646

            return ((cli_intel_t *)(engine->stats_data))->timeout;

 

647

        case CL_ENGINE_MAX_PARTITIONS:

 

648

            return engine->maxpartitions;

 

649

        case CL_ENGINE_MAX_ICONSPE:

 

650

            return engine->maxiconspe;

562

651

        default:

563

652

            cli_errmsg("cl_engine_get: Incorrect field number\n");

564

653

            if(err)

631

720

    settings->ac_maxdepth = engine->ac_maxdepth;

632

721

    settings->tmpdir = engine->tmpdir ? strdup(engine->tmpdir) : NULL;

633

722

    settings->keeptmp = engine->keeptmp;

634

 

    settings->forcetodisk = engine->forcetodisk;

635

723

    settings->maxscansize = engine->maxscansize;

636

724

    settings->maxfilesize = engine->maxfilesize;

637

725

    settings->maxreclevel = engine->maxreclevel;

655

743

    settings->cb_sigload_ctx = engine->cb_sigload_ctx;

656

744

    settings->cb_hash = engine->cb_hash;

657

745

    settings->cb_meta = engine->cb_meta;

 

746

    settings->engine_options = engine->engine_options;

 

747

 

 

748

    settings->cb_stats_add_sample = engine->cb_stats_add_sample;

 

749

    settings->cb_stats_remove_sample = engine->cb_stats_remove_sample;

 

750

    settings->cb_stats_decrement_count = engine->cb_stats_decrement_count;

 

751

    settings->cb_stats_submit = engine->cb_stats_submit;

 

752

    settings->cb_stats_flush = engine->cb_stats_flush;

 

753

    settings->cb_stats_get_num = engine->cb_stats_get_num;

 

754

    settings->cb_stats_get_size = engine->cb_stats_get_size;

 

755

    settings->cb_stats_get_hostid = engine->cb_stats_get_hostid;

 

756

 

 

757

    settings->maxpartitions = engine->maxpartitions;

 

758

 

 

759

    settings->maxiconspe = engine->maxiconspe;

658

760

 

659

761

    return settings;

660

762

}

661

763

 

662

764

int cl_engine_settings_apply(struct cl_engine *engine, const struct cl_settings *settings)

663

765

{

 

766

    cli_intel_t *intel;

 

767

 

664

768

    engine->ac_only = settings->ac_only;

665

769

    engine->ac_mindepth = settings->ac_mindepth;

666

770

    engine->ac_maxdepth = settings->ac_maxdepth;

667

771

    engine->keeptmp = settings->keeptmp;

668

 

    engine->forcetodisk = settings->forcetodisk;

669

772

    engine->maxscansize = settings->maxscansize;

670

773

    engine->maxfilesize = settings->maxfilesize;

671

774

    engine->maxreclevel = settings->maxreclevel;

680

783

    engine->bytecode_security = settings->bytecode_security;

681

784

    engine->bytecode_timeout = settings->bytecode_timeout;

682

785

    engine->bytecode_mode = settings->bytecode_mode;

 

786

    engine->engine_options = settings->engine_options;

683

787

 

684

788

    if(engine->tmpdir)

685

789

        mpool_free(engine->mempool, engine->tmpdir);

709

813

    engine->cb_hash = settings->cb_hash;

710

814

    engine->cb_meta = settings->cb_meta;

711

815

 

 

816

    engine->cb_stats_add_sample = settings->cb_stats_add_sample;

 

817

    engine->cb_stats_remove_sample = settings->cb_stats_remove_sample;

 

818

    engine->cb_stats_decrement_count = settings->cb_stats_decrement_count;

 

819

    engine->cb_stats_submit = settings->cb_stats_submit;

 

820

    engine->cb_stats_flush = settings->cb_stats_flush;

 

821

    engine->cb_stats_get_num = settings->cb_stats_get_num;

 

822

    engine->cb_stats_get_size = settings->cb_stats_get_size;

 

823

    engine->cb_stats_get_hostid = settings->cb_stats_get_hostid;

 

824

 

 

825

    engine->maxpartitions = settings->maxpartitions;

 

826

 

 

827

    engine->maxiconspe = settings->maxiconspe;

 

828

 

712

829

    return CL_SUCCESS;

713

830

}

714

831

 

773

890

 */

774

891

char *cli_hashstream(FILE *fs, unsigned char *digcpy, int type)

775

892

{

776

 

        unsigned char digest[32];

777

 

        char buff[FILEBUFF];

778

 

        cli_md5_ctx md5;

779

 

        SHA1Context sha1;

780

 

        SHA256_CTX sha256;

781

 

        char *hashstr, *pt;

782

 

        int i, bytes, size;

783

 

 

784

 

 

785

 

    if(type == 1)

786

 

        cli_md5_init(&md5);

787

 

    else if(type == 2)

788

 

        SHA1Init(&sha1);

789

 

    else

790

 

        sha256_init(&sha256);

791

 

 

792

 

    while((bytes = fread(buff, 1, FILEBUFF, fs))) {

793

 

        if(type == 1)

794

 

            cli_md5_update(&md5, buff, bytes);

795

 

        else if(type == 2)

796

 

            SHA1Update(&sha1, buff, bytes);

797

 

        else

798

 

            sha256_update(&sha256, buff, bytes);

799

 

    }

800

 

 

801

 

    if(type == 1) {

802

 

        cli_md5_final(digest, &md5);

803

 

        size = 16;

804

 

    } else if(type == 2) {

805

 

        SHA1Final(&sha1, digest);

806

 

        size = 20;

807

 

    } else {

808

 

        sha256_final(&sha256, digest);

809

 

        size = 32;

810

 

    }

 

893

    unsigned char digest[32];

 

894

    char buff[FILEBUFF];

 

895

    char *hashstr, *pt;

 

896

    const char *alg=NULL;

 

897

    int i, bytes, size;

 

898

    void *ctx;

 

899

 

 

900

    switch (type) {

 

901

        case 1:

 

902

            alg = "md5";

 

903

            size = 16;

 

904

            break;

 

905

        case 2:

 

906

            alg = "sha1";

 

907

            size = 20;

 

908

            break;

 

909

        default:

 

910

            alg = "sha256";

 

911

            size = 32;

 

912

            break;

 

913

    }

 

914

 

 

915

    ctx = cl_hash_init(alg);

 

916

    if (!(ctx))

 

917

        return NULL;

 

918

 

 

919

    while((bytes = fread(buff, 1, FILEBUFF, fs)))

 

920

        cl_update_hash(ctx, buff, bytes);

 

921

 

 

922

    cl_finish_hash(ctx, digest);

811

923

 

812

924

    if(!(hashstr = (char *) cli_calloc(size*2 + 1, sizeof(char))))

813

 

        return NULL;

 

925

        return NULL;

814

926

 

815

927

    pt = hashstr;

816

928

    for(i = 0; i < size; i++) {

817

 

        sprintf(pt, "%02x", digest[i]);

818

 

        pt += 2;

 

929

        sprintf(pt, "%02x", digest[i]);

 

930

        pt += 2;

819

931

    }

820

932

 

821

933

    if(digcpy)

822

 

        memcpy(digcpy, digest, size);

 

934

        memcpy(digcpy, digest, size);

823

935

 

824

936

    return hashstr;

825

937

}

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1