diff --git a/clamd/clamd.c b/clamd/clamd.c index 1273f3a502..70bdf14fc3 100644 --- a/clamd/clamd.c +++ b/clamd/clamd.c @@ -160,6 +160,8 @@ int main(int argc, char **argv) pid_t mainpid = 0; mode_t old_umask = 0; const char *user_name = NULL; + char *cvdcertsdir = NULL; + STATBUF statbuf; if (check_flevel()) exit(1); @@ -577,20 +579,32 @@ int main(int argc, char **argv) } } - if ((opt = optget(opts, "certsdir"))->enabled) { - if ((ret = cl_engine_set_str(engine, CL_ENGINE_CERTSDIR, opt->strarg))) { - logg(LOGG_ERROR, "cli_engine_set_str(CL_ENGINE_CERTSDIR) failed: %s\n", cl_strerror(ret)); - ret = 1; - break; - } - } else { - if ((ret = cl_engine_set_str(engine, CL_ENGINE_CERTSDIR, CERTSDIR))) { - logg(LOGG_ERROR, "cli_engine_set_str(CL_ENGINE_CERTSDIR) failed: %s\n", cl_strerror(ret)); - ret = 1; - break; + cvdcertsdir = optget(opts, "cvdcertsdir")->strarg; + if (NULL == cvdcertsdir) { + // Check if the CVD_CERTS_DIR environment variable is set + cvdcertsdir = getenv("CVD_CERTS_DIR"); + + // If not, use the default value + if (NULL == cvdcertsdir) { + cvdcertsdir = CERTSDIR; } } + if (LSTAT(cvdcertsdir, &statbuf) == -1) { + logg(LOGG_ERROR, + "ClamAV CA certificates directory is missing: %s\n" + "It should have been provided as a part of installation.", + cvdcertsdir); + ret = 1; + break; + } + + if ((ret = cl_engine_set_str(engine, CL_ENGINE_CERTSDIR, cvdcertsdir))) { + logg(LOGG_ERROR, "cli_engine_set_str(CL_ENGINE_CERTSDIR) failed: %s\n", cl_strerror(ret)); + ret = 1; + break; + } + cl_engine_set_clcb_hash(engine, hash_callback); cl_engine_set_clcb_virus_found(engine, clamd_virus_found_cb); diff --git a/clamscan/clamscan.c b/clamscan/clamscan.c index f3e32f26fa..60987596cd 100644 --- a/clamscan/clamscan.c +++ b/clamscan/clamscan.c @@ -342,6 +342,10 @@ void help(void) mprintf(LOGG_INFO, " --pcre-recmatch-limit=#n Maximum recursive calls to the PCRE match function.\n"); mprintf(LOGG_INFO, " --pcre-max-filesize=#n Maximum size file to perform PCRE subsig matching.\n"); mprintf(LOGG_INFO, " --disable-cache Disable caching and cache checks for hash sums of scanned files.\n"); + mprintf(LOGG_INFO, " --cvdcertsdir=DIRECTORY Specify a directory containing the root\n"); + mprintf(LOGG_INFO, " CA cert needed to verify detached CVD digital signatures.\n"); + mprintf(LOGG_INFO, " If not provided, then clamscan will look in:\n"); + mprintf(LOGG_INFO, " " CERTSDIR "\n"); mprintf(LOGG_INFO, "\n"); mprintf(LOGG_INFO, "Pass in - as the filename for stdin.\n"); mprintf(LOGG_INFO, "\n"); diff --git a/clamscan/manager.c b/clamscan/manager.c index b4ec81d548..b0c1c749fa 100644 --- a/clamscan/manager.c +++ b/clamscan/manager.c @@ -1051,6 +1051,9 @@ int scanmanager(const struct optstruct *opts) struct engine_free_progress engine_free_progress_ctx = {0}; #endif + char *cvdcertsdir = NULL; + STATBUF statbuf; + /* Initialize scan options struct */ memset(&options, 0, sizeof(struct cl_scan_options)); @@ -1249,20 +1252,32 @@ int scanmanager(const struct optstruct *opts) } } - if ((opt = optget(opts, "certsdir"))->enabled) { - if ((ret = cl_engine_set_str(engine, CL_ENGINE_CERTSDIR, opt->strarg))) { - logg(LOGG_ERROR, "cli_engine_set_str(CL_ENGINE_CERTSDIR) failed: %s\n", cl_strerror(ret)); + cvdcertsdir = optget(opts, "cvdcertsdir")->strarg; + if (NULL == cvdcertsdir) { + // Check if the CVD_CERTS_DIR environment variable is set + cvdcertsdir = getenv("CVD_CERTS_DIR"); - ret = 2; - goto done; + // If not, use the default value + if (NULL == cvdcertsdir) { + cvdcertsdir = CERTSDIR; } - } else { - if ((ret = cl_engine_set_str(engine, CL_ENGINE_CERTSDIR, CERTSDIR))) { - logg(LOGG_ERROR, "cli_engine_set_str(CL_ENGINE_CERTSDIR) failed: %s\n", cl_strerror(ret)); + } - ret = 2; - goto done; - } + if (LSTAT(cvdcertsdir, &statbuf) == -1) { + logg(LOGG_ERROR, + "ClamAV CA certificates directory is missing: %s\n" + "It should have been provided as a part of installation.", + cvdcertsdir); + + ret = 2; + goto done; + } + + if ((ret = cl_engine_set_str(engine, CL_ENGINE_CERTSDIR, cvdcertsdir))) { + logg(LOGG_ERROR, "cli_engine_set_str(CL_ENGINE_CERTSDIR) failed: %s\n", cl_strerror(ret)); + + ret = 2; + goto done; } if ((opt = optget(opts, "database"))->active) { diff --git a/common/optparser.c b/common/optparser.c index 051463061e..fe379b4da5 100644 --- a/common/optparser.c +++ b/common/optparser.c @@ -286,7 +286,7 @@ const struct clam_option __clam_options[] = { {"DatabaseDirectory", "datadir", 0, CLOPT_TYPE_STRING, NULL, -1, CONST_DATADIR, 0, OPT_CLAMD | OPT_FRESHCLAM | OPT_SIGTOOL, "This option allows you to change the default database directory.\nIf you enable it, please make sure it points to the same directory in\nboth clamd and freshclam.", "/var/lib/clamav"}, - {"CVDCertsDirectory", "certsdir", 0, CLOPT_TYPE_STRING, NULL, -1, NULL, 0, OPT_CLAMD | OPT_FRESHCLAM | OPT_SIGTOOL, "This option allows you to change the default ClamAV CA certificates directory used to verify database external digital signatures.\nIf you enable it, please make sure it points to the same directory in\nboth clamd and freshclam.", "/etc/clamav/certs"}, + {"CVDCertsDirectory", "cvdcertsdir", 0, CLOPT_TYPE_STRING, NULL, -1, NULL, 0, OPT_CLAMD | OPT_CLAMSCAN | OPT_FRESHCLAM | OPT_SIGTOOL, "This option allows you to change the default ClamAV CA certificates directory used to verify database external digital signatures.\nIf you enable it, please make sure it points to the same directory in\nboth clamd and freshclam.", "/etc/clamav/certs"}, {"OfficialDatabaseOnly", "official-db-only", 0, CLOPT_TYPE_BOOL, MATCH_BOOL, 0, NULL, 0, OPT_CLAMD | OPT_CLAMSCAN, "Only load the official signatures published by the ClamAV project.", "no"}, diff --git a/etc/CMakeLists.txt b/etc/CMakeLists.txt index 826fff1d96..d9a27ec752 100644 --- a/etc/CMakeLists.txt +++ b/etc/CMakeLists.txt @@ -24,3 +24,17 @@ if(ENABLE_MILTER) ${APP_CONFIG_DIRECTORY} COMPONENT programs) endif() + +# +# clamav certs directory and root CA cert +# + +# Create the certs directory. This is where the root CA cert will be installed. +# Then copy the root CA cert to the certs directory. +install(DIRECTORY DESTINATION ${CERTS_DIRECTORY} COMPONENT programs) +install( + FILES + ${CMAKE_CURRENT_SOURCE_DIR}/certs/ca.crt + DESTINATION + ${CERTS_DIRECTORY} + COMPONENT programs) diff --git a/etc/certs/ca.crt b/etc/certs/ca.crt new file mode 100644 index 0000000000..931acf0ca6 --- /dev/null +++ b/etc/certs/ca.crt @@ -0,0 +1,31 @@ +-----BEGIN CERTIFICATE----- +MIIFTzCCAzcCFG9bzRiWhD7GrtKN5++v9AZJaJ0sMA0GCSqGSIb3DQEBCwUAMGQx +CzAJBgNVBAYTAlVTMQswCQYDVQQIDAJNRDEPMA0GA1UEBwwGTGF1cmVsMQ4wDAYD +VQQKDAVDaXNjbzEOMAwGA1UECwwFVGFsb3MxFzAVBgNVBAMMDkNsYW1BViBSb290 +IENBMB4XDTI0MTAyNDE3MjcyNVoXDTI2MTAyNDE3MjcyNVowZDELMAkGA1UEBhMC +VVMxCzAJBgNVBAgMAk1EMQ8wDQYDVQQHDAZMYXVyZWwxDjAMBgNVBAoMBUNpc2Nv +MQ4wDAYDVQQLDAVUYWxvczEXMBUGA1UEAwwOQ2xhbUFWIFJvb3QgQ0EwggIiMA0G +CSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDNp2WpxPv42Of3yiFUA8Bq6OiPDtjO +bBfPcffqcx1rtsjlgsyXPLr709+ktjdPOrlOAmkuZXUnWeQ6VMltxfUiz0uzMOpV +WR8tEQSaGLR4CBdEe8srnojB7Uwx0x8BEWzROUBBlXdDJjTteEomLduXYaRxoXc3 +S0qxIFx4jL4lfgj1uA8GCdT7oLdWK1gmmc6yijmZyLygh02b660vz8t8pTFp6dWC +zktl4IpnYenktF5mtldfORtdJsBK6dqFhDNTRDzM8VO0nqvVItPs/keCPVCx6+xe +9OI9pDx62NX3LZJX99CJR2Rt1IxIyo46SEBtUJudhMhDJm7xSis9Myu7almGBzpd +YbISdU+riMlgifKAEwWhOJ3eCCqycWA2uw3m0rOAMP775A2tc9FQ56ZhhJNQf5Pc +iZYE+Q2fjGiRDHqYzGF8Gr4YQIdDEkYLLVeq6Xkrb1QIgbzKn6PvrK1QrEgH1Ha+ +Qfpp6tkbu3CxfSnPJjTuL/cRw9jipnrcwesrMpeFS22htNgXm4wUAs8UHhnUNfry +QYan0ver6UDrhlmRn8QN4Wikhp1aZjKE7cAKztIVyZ2H1oWh7cuFCWMOBQ7BkI1a +UL6LYeI0VUrmDmAF7/tlIR62dDqPCJWfzHVfODAJR+I9NPxOSZmaJ5XVMbUh20vM +SsEOasY2nqLbKQIDAQABMA0GCSqGSIb3DQEBCwUAA4ICAQBkLEmFkTt+WX4nUIrY +9uu8vDt5fLC9G/LdNRkgOoeYhSBrktokjuH+Cj1RJ4LqkzXbfpcWkXFh+VidnDi7 +RpuH9I5bQscdxYgZbqHTIDD61uAqWWre/O5r3tqw8v5Lf/qPZ+8YfQSWHI0s11EF +qtNxMxYOshAna1nLHbqAyS8PpBw4Ia2EKjbf9uPch08jR5GS8CQ4FnTJvOysolZO +/YtRpD2ueu5hIarBT9mvlxX59fhSvxARJ7vaG0UrS6w1Ou7lUej5Ww/CKWWfGCAl +Yf2+BmQyM1ir6zXMuRbFwFzKSPxSMDtcTtmS+EugPtm6B0imz3OoDCm6GGNJ5LoE +xY07cbdDxcE8RSZeQhCQSzBUjgkO8nWiZ9okfP9lOiSCjzp25ymvvdqHHRjdjQZc +QafLdQjEWPGFV+XzHEjy5Tx5IWo8vu4G9Xp+x2jK5iR5dXwvuKV7r8jkc9WTDfgT +A0xd9GGK3/c2XQLTNGFaJhhbYfGs8Hptdt+69cABcMib0wHBQGKPjPJ7cCFssVmZ +FhuZRgsoqkCoDGTkcxkALlHEnjlJV58yHW71JA0XUX3sQOOHAefzTM+Zig0ip6yL +qEHRtMbqcYAb8QKzRh7OoVgENrZgtKPbM/RmmXyxCDaj4p8yGsT2wVgekTYgZgs/ +571h1ecLkL4h0vaq5BtDjW/Drg== +-----END CERTIFICATE----- diff --git a/freshclam/freshclam.c b/freshclam/freshclam.c index abd5f70bb8..db406ee87f 100644 --- a/freshclam/freshclam.c +++ b/freshclam/freshclam.c @@ -815,7 +815,16 @@ static fc_error_t initialize(struct optstruct *opts) * Verify that the clamav ca certificates directory exists. * Create certs directory if missing. */ - fcConfig.certsDirectory = optget(opts, "certsdir")->strarg; + fcConfig.certsDirectory = optget(opts, "cvdcertsdir")->strarg; + if (NULL == fcConfig.certsDirectory) { + // Check if the CVD_CERTS_DIR environment variable is set + fcConfig.certsDirectory = getenv("CVD_CERTS_DIR"); + + // If not, use the default value + if (NULL == fcConfig.certsDirectory) { + fcConfig.certsDirectory = CERTSDIR; + } + } if (LSTAT(fcConfig.certsDirectory, &statbuf) == -1) { logg(LOGG_ERROR, diff --git a/libclamav/cvd.c b/libclamav/cvd.c index 6af5f19576..af45402636 100644 --- a/libclamav/cvd.c +++ b/libclamav/cvd.c @@ -568,27 +568,34 @@ cl_error_t cli_cvdload(struct cl_engine *engine, unsigned int *signo, unsigned i cl_error_t ret; time_t s_time; struct cli_dbio dbio; - struct cli_dbinfo *dbinfo = NULL; - char *dupname = NULL; - cvd_t *cvd = NULL; - cvd_t *dupcvd = NULL; - FFIError *err = NULL; + struct cli_dbinfo *dbinfo = NULL; + char *dupname = NULL; + cvd_t *cvd = NULL; + cvd_t *dupcvd = NULL; + FFIError *cvd_open_error = NULL; + FFIError *cvd_verify_error = NULL; + char *signer_name = NULL; dbio.hashctx = NULL; cli_dbgmsg("in cli_cvdload()\n"); /* Open the cvd and read the header */ - cvd = cvd_open(filename, &err); + cvd = cvd_open(filename, &cvd_open_error); if (!cvd) { - cli_errmsg("cli_cvdload: Can't open CVD file %s: %s\n", filename, ffierror_fmt(err)); + cli_errmsg("cli_cvdload: Can't open CVD file %s: %s\n", filename, ffierror_fmt(cvd_open_error)); goto done; } /* For actual .cvd files, verify the digital signature. */ if (dbtype == CVD_TYPE_CVD) { - if (!cvd_verify(cvd, engine->certs_directory, false, &err)) { - cli_errmsg("cli_cvdload: Can't verify CVD file %s: %s\n", filename, ffierror_fmt(err)); + if (!cvd_verify( + cvd, + engine->certs_directory, + false, + &signer_name, + &cvd_verify_error)) { + cli_errmsg("cli_cvdload: Can't verify CVD file %s: %s\n", filename, ffierror_fmt(cvd_verify_error)); status = CL_EVERIFY; goto done; } @@ -607,7 +614,7 @@ cl_error_t cli_cvdload(struct cl_engine *engine, unsigned int *signo, unsigned i dupname[strlen(dupname) - 2] = (dbtype == CVD_TYPE_CLD ? 'v' : 'l'); - dupcvd = cvd_open(dupname, &err); + dupcvd = cvd_open(dupname, &cvd_open_error); if (dupcvd) { if (cvd_get_version(dupcvd) > cvd_get_version(cvd)) { cli_warnmsg("Detected duplicate databases %s and %s. The %s database is older and will not be loaded, you should manually remove it from the database directory.\n", filename, dupname, filename); @@ -619,6 +626,12 @@ cl_error_t cli_cvdload(struct cl_engine *engine, unsigned int *signo, unsigned i status = CL_SUCCESS; goto done; } + } else { + // If the .cld file doesn't exist, it's not an error. + if (NULL != cvd_open_error) { + ffierror_free(cvd_open_error); + cvd_open_error = NULL; + } } } @@ -699,6 +712,9 @@ cl_error_t cli_cvdload(struct cl_engine *engine, unsigned int *signo, unsigned i MPOOL_FREE(engine->mempool, dbinfo); } + if (NULL != signer_name) { + ffi_cstring_free(signer_name); + } free(dupname); if (NULL != cvd) { cvd_free(cvd); @@ -706,76 +722,112 @@ cl_error_t cli_cvdload(struct cl_engine *engine, unsigned int *signo, unsigned i if (NULL != dupcvd) { cvd_free(dupcvd); } + if (NULL != cvd_open_error) { + ffierror_free(cvd_open_error); + } + if (NULL != cvd_verify_error) { + ffierror_free(cvd_verify_error); + } return status; } cl_error_t cl_cvdunpack(const char *file, const char *dir, bool dont_verify) { - cl_error_t status = CL_SUCCESS; - cvd_t *cvd = NULL; - FFIError *err = NULL; - - cvd = cvd_open(file, &err); + cl_error_t status = CL_SUCCESS; + cvd_t *cvd = NULL; + FFIError *cvd_open_error = NULL; + FFIError *cvd_verify_error = NULL; + FFIError *cvd_unpack_error = NULL; + char *signer_name = NULL; + + cvd = cvd_open(file, &cvd_open_error); if (!cvd) { - cli_errmsg("Can't open CVD file %s: %s\n", file, ffierror_fmt(err)); + cli_errmsg("Can't open CVD file %s: %s\n", file, ffierror_fmt(cvd_open_error)); return CL_EOPEN; } if (!dont_verify) { - if (!cvd_verify(cvd, NULL, false, &err)) { - cli_errmsg("CVD verification failed: %s\n", ffierror_fmt(err)); + if (!cvd_verify(cvd, NULL, false, &signer_name, &cvd_verify_error)) { + cli_errmsg("CVD verification failed: %s\n", ffierror_fmt(cvd_verify_error)); status = CL_EVERIFY; goto done; } } - if (!cvd_unpack(cvd, dir, &err)) { - cli_errmsg("CVD unpacking failed: %s\n", ffierror_fmt(err)); + if (!cvd_unpack(cvd, dir, &cvd_unpack_error)) { + cli_errmsg("CVD unpacking failed: %s\n", ffierror_fmt(cvd_unpack_error)); status = CL_EUNPACK; goto done; } done: + if (NULL != signer_name) { + ffi_cstring_free(signer_name); + } if (NULL != cvd) { cvd_free(cvd); } + if (NULL != cvd_open_error) { + ffierror_free(cvd_open_error); + } + if (NULL != cvd_verify_error) { + ffierror_free(cvd_verify_error); + } + if (NULL != cvd_unpack_error) { + ffierror_free(cvd_unpack_error); + } return status; } cl_error_t cl_cvdunpack_ex(const char *file, const char *dir, bool dont_verify, const char *certs_directory) { - cl_error_t status = CL_SUCCESS; - cvd_t *cvd = NULL; - FFIError *err = NULL; - - cvd = cvd_open(file, &err); + cl_error_t status = CL_SUCCESS; + cvd_t *cvd = NULL; + FFIError *cvd_open_error = NULL; + FFIError *cvd_verify_error = NULL; + FFIError *cvd_unpack_error = NULL; + char *signer_name = NULL; + + cvd = cvd_open(file, &cvd_open_error); if (!cvd) { - cli_errmsg("Can't open CVD file %s: %s\n", file, ffierror_fmt(err)); + cli_errmsg("Can't open CVD file %s: %s\n", file, ffierror_fmt(cvd_open_error)); return CL_EOPEN; } if (!dont_verify) { - if (!cvd_verify(cvd, certs_directory, false, &err)) { - cli_errmsg("CVD verification failed: %s\n", ffierror_fmt(err)); + if (!cvd_verify(cvd, certs_directory, false, &signer_name, &cvd_verify_error)) { + cli_errmsg("CVD verification failed: %s\n", ffierror_fmt(cvd_verify_error)); status = CL_EVERIFY; goto done; } } - if (!cvd_unpack(cvd, dir, &err)) { - cli_errmsg("CVD unpacking failed: %s\n", ffierror_fmt(err)); + if (!cvd_unpack(cvd, dir, &cvd_unpack_error)) { + cli_errmsg("CVD unpacking failed: %s\n", ffierror_fmt(cvd_unpack_error)); status = CL_EUNPACK; goto done; } done: + if (NULL != signer_name) { + ffi_cstring_free(signer_name); + } if (NULL != cvd) { cvd_free(cvd); } + if (NULL != cvd_open_error) { + ffierror_free(cvd_open_error); + } + if (NULL != cvd_verify_error) { + ffierror_free(cvd_verify_error); + } + if (NULL != cvd_unpack_error) { + ffierror_free(cvd_unpack_error); + } return status; } @@ -783,13 +835,13 @@ cl_error_t cl_cvdunpack_ex(const char *file, const char *dir, bool dont_verify, static cl_error_t cvdgetfileage(const char *path, time_t *age_seconds) { time_t s_time; - cl_error_t status = CL_EOPEN; - cvd_t *cvd = NULL; - FFIError *err = NULL; + cl_error_t status = CL_EOPEN; + cvd_t *cvd = NULL; + FFIError *cvd_open_error = NULL; - cvd = cvd_open(path, &err); + cvd = cvd_open(path, &cvd_open_error); if (!cvd) { - cli_errmsg("Can't open CVD file %s: %s\n", path, ffierror_fmt(err)); + cli_errmsg("Can't open CVD file %s: %s\n", path, ffierror_fmt(cvd_open_error)); goto done; } @@ -807,6 +859,9 @@ static cl_error_t cvdgetfileage(const char *path, time_t *age_seconds) if (NULL != cvd) { cvd_free(cvd); } + if (NULL != cvd_open_error) { + ffierror_free(cvd_open_error); + } return status; } diff --git a/libclamav_rust/build.rs b/libclamav_rust/build.rs index eef75555c5..cecad154e0 100644 --- a/libclamav_rust/build.rs +++ b/libclamav_rust/build.rs @@ -60,7 +60,7 @@ const BINDGEN_FUNCTIONS: &[&str] = &[ ]; // Generate bindings for these types (structs, enums): -const BINDGEN_TYPES: &[&str] = &["cli_matcher", "cli_ac_data", "cli_ac_result", "onedump_t"]; +const BINDGEN_TYPES: &[&str] = &["cli_matcher", "cli_ac_data", "cli_ac_result", "onedump_t", "cvd_t"]; // Find the required functions and types in these headers: const BINDGEN_HEADERS: &[&str] = &[ diff --git a/libclamav_rust/src/cdiff.rs b/libclamav_rust/src/cdiff.rs index 9c4e460e5a..3e3bf87a35 100644 --- a/libclamav_rust/src/cdiff.rs +++ b/libclamav_rust/src/cdiff.rs @@ -187,9 +187,13 @@ pub enum InputError { LineNotUnicode(#[from] std::str::Utf8Error), /// Errors encountered while executing a command - #[error("processing: {0}")] + #[error("Processing: {0}")] Processing(#[from] ProcessingError), + /// Errors encountered while executing a command + #[error("Processing: {0}")] + ProcessingString(String), + #[error("no final newline")] MissingNL, @@ -781,17 +785,35 @@ fn cmd_move(ctx: &mut Context, move_op: MoveOp) -> Result<(), InputError> { let mut dst_file = OpenOptions::new() .append(true) .open(&move_op.dst) - .map_err(|e| InputError::Processing(e.into()))?; + .map_err(|e| { + InputError::ProcessingString(format!( + "Failed to open destination file {:?} for MOVE command: {}", + &move_op.dst, + e.to_string() + )) + })?; // Create tmp file and open for writing let tmp_named_file = tempfile::Builder::new() .prefix("_tmp_move_file") .tempfile_in("./") - .map_err(|e| InputError::Processing(e.into()))?; + .map_err(|e| { + InputError::ProcessingString(format!( + "Failed to create temp file in current directory {:?} for MOVE command: {}", + std::env::current_dir(), + e.to_string() + )) + })?; let mut tmp_file = tmp_named_file.as_file(); // Open src in read-only mode - let mut src_reader = BufReader::new(File::open(&move_op.src).map_err(ProcessingError::from)?); + let mut src_reader = BufReader::new(File::open(&move_op.src).map_err(|e| { + InputError::ProcessingString(format!( + "Failed to open source file {:?}: {} for MOVE command", + &move_op.src, + e.to_string() + )) + })?); let mut line = vec![]; let mut line_no = 0; @@ -799,9 +821,13 @@ fn cmd_move(ctx: &mut Context, move_op: MoveOp) -> Result<(), InputError> { // cdiff files start at line 1 line_no += 1; line.clear(); - let n_read = src_reader - .read_until(b'\n', &mut line) - .map_err(ProcessingError::from)?; + let n_read = src_reader.read_until(b'\n', &mut line).map_err(|e| { + InputError::ProcessingString(format!( + "Failed to read from source file {:?} for MOVE command: {}", + &move_op.src, + e.to_string() + )) + })?; if n_read == 0 { break; } @@ -830,7 +856,13 @@ fn cmd_move(ctx: &mut Context, move_op: MoveOp) -> Result<(), InputError> { } // Write everything outside of start and end to tmp else { - tmp_file.write_all(&line).map_err(ProcessingError::from)?; + tmp_file.write_all(&line).map_err(|e| { + InputError::ProcessingString(format!( + "Failed to write line to temp file {:?} for MOVE command: {}", + tmp_named_file.path(), + e.to_string() + )) + })?; } } @@ -845,8 +877,21 @@ fn cmd_move(ctx: &mut Context, move_op: MoveOp) -> Result<(), InputError> { // Delete src and replace it with tmp #[cfg(windows)] - fs::remove_file(&move_op.src).map_err(ProcessingError::from)?; - fs::rename(tmp_named_file.path(), &move_op.src).map_err(ProcessingError::from)?; + fs::remove_file(&move_op.src).map_err(|e| { + InputError::ProcessingString(format!( + "Failed to remove original source file {:?} for MOVE command: {}", + &move_op.src, + e.to_string() + )) + })?; + fs::rename(tmp_named_file.path(), &move_op.src).map_err(|e| { + InputError::ProcessingString(format!( + "Failed to rename temp file {:?} to {:?} for MOVE command: {}", + tmp_named_file.path(), + &move_op.src, + e.to_string() + )) + })?; Ok(()) } @@ -863,22 +908,38 @@ fn cmd_close(ctx: &mut Context) -> Result<(), InputError> { if next_edit.is_some() { // Open src in read-only mode - let mut src_reader = BufReader::new(File::open(&open_db).map_err(ProcessingError::from)?); + let mut src_reader = BufReader::new(File::open(&open_db).map_err(|e| { + InputError::ProcessingString(format!( + "Failed to open db file {:?} for CLOSE command: {}", + &open_db, + e.to_string() + )) + })?); // Create tmp file and open for writing let tmp_named_file = tempfile::Builder::new() .prefix("_tmp_move_file") .tempfile_in("./") - .map_err(ProcessingError::from)?; + .map_err(|e| { + InputError::ProcessingString(format!( + "Failed to create temp file in current directory {:?} for CLOSE command: {}", + std::env::current_dir(), + e.to_string() + )) + })?; let tmp_file = tmp_named_file.as_file(); let mut tmp_file = BufWriter::new(tmp_file); let mut linebuf = Vec::new(); for line_no in 1.. { linebuf.clear(); - let n_read = src_reader - .read_until(b'\n', &mut linebuf) - .map_err(ProcessingError::from)?; + let n_read = src_reader.read_until(b'\n', &mut linebuf).map_err(|e| { + InputError::ProcessingString(format!( + "Failed to read temp file {:?} for CLOSE command: {}", + tmp_named_file.path(), + e.to_string() + )) + })?; if n_read == 0 { // No more input break; @@ -924,10 +985,20 @@ fn cmd_close(ctx: &mut Context) -> Result<(), InputError> { // Anything to output? if let Some(new_line) = new_line { - tmp_file - .write_all(new_line) - .map_err(ProcessingError::from)?; - tmp_file.write_all(b"\n").map_err(ProcessingError::from)?; + tmp_file.write_all(new_line).map_err(|e| { + InputError::ProcessingString(format!( + "Failed to write line to temp file {:?} for CLOSE command: {}", + tmp_named_file.path(), + e.to_string() + )) + })?; + tmp_file.write_all(b"\n").map_err(|e| { + InputError::ProcessingString(format!( + "Failed to write new line to temp file {:?} for CLOSE command: {}", + tmp_named_file.path(), + e.to_string() + )) + })?; } } @@ -961,12 +1032,35 @@ fn cmd_close(ctx: &mut Context) -> Result<(), InputError> { #[cfg(windows)] if let Err(e) = fs::remove_file(&open_db) { // Try to remove the tempfile, since we failed to remove the original - fs::remove_file(tmpfile_path).map_err(ProcessingError::from)?; - return Err(ProcessingError::from(e).into()); + fs::remove_file(tmpfile_path).map_err(|e| { + InputError::ProcessingString(format!( + "Failed to remove the temp file file {:?} for CLOSE command: {}", + tmpfile_path, + e.to_string() + )) + })?; + return Err(InputError::ProcessingString(format!( + "Failed to remove open db file {:?} for CLOSE command: {}", + &open_db, + e.to_string() + )) + .into()); } if let Err(e) = fs::rename(&tmpfile_path, &open_db) { - fs::remove_file(&tmpfile_path).map_err(ProcessingError::from)?; - return Err(ProcessingError::from(e).into()); + fs::remove_file(&tmpfile_path).map_err(|e| { + InputError::ProcessingString(format!( + "Failed to remove temp file {:?}: {} for CLOSE command", + &tmpfile_path, + e.to_string() + )) + })?; + return Err(InputError::ProcessingString(format!( + "Failed to rename temp file {:?} to {:?} for CLOSE command: {}", + tmpfile_path, + &open_db, + e.to_string() + )) + .into()); } } @@ -976,10 +1070,20 @@ fn cmd_close(ctx: &mut Context) -> Result<(), InputError> { .create(true) .append(true) .open(&open_db) - .map_err(ProcessingError::from)?; - db_file - .write_all(&ctx.additions) - .map_err(ProcessingError::from)?; + .map_err(|e| { + InputError::ProcessingString(format!( + "Failed to open db file {:?} for CLOSE command: {}", + open_db, + e.to_string() + )) + })?; + db_file.write_all(&ctx.additions).map_err(|e| { + InputError::ProcessingString(format!( + "Failed to write add lines to db {:?} for CLOSE command: {}", + open_db, + e.to_string() + )) + })?; ctx.additions.clear(); } @@ -997,7 +1101,13 @@ fn cmd_unlink(ctx: &mut Context, unlink_op: UnlinkOp) -> Result<(), InputError> // We checked that the db_name doesn't have any '/' or '\\' in it before // adding to the UnlinkOp struct, so it's safe to say the path is just a local file and // won't accidentally delete something in a different directory. - fs::remove_file(unlink_op.db_name).map_err(ProcessingError::from)?; + fs::remove_file(unlink_op.db_name).map_err(|e| { + InputError::ProcessingString(format!( + "Failed to remove db file {:?} for UNLINK command: {}", + unlink_op.db_name, + e.to_string() + )) + })?; Ok(()) } diff --git a/libclamav_rust/src/codesign.rs b/libclamav_rust/src/codesign.rs index 1f599da95d..7fee32f423 100644 --- a/libclamav_rust/src/codesign.rs +++ b/libclamav_rust/src/codesign.rs @@ -2,6 +2,7 @@ use std::{ ffi::CStr, fs::File, io::{prelude::*, BufReader}, + os::raw::c_char, path::{Path, PathBuf}, }; @@ -60,11 +61,11 @@ pub enum Error { /// No parameters may be NULL. #[export_name = "codesign_sign_file"] pub unsafe extern "C" fn codesign_sign_file( - target_file_path_str: *const std::os::raw::c_char, - signature_file_path_str: *const std::os::raw::c_char, - signing_key_path_str: *const std::os::raw::c_char, - signing_cert_path_str: *const std::os::raw::c_char, - intermediate_cert_paths_str: *const *const std::os::raw::c_char, + target_file_path_str: *const c_char, + signature_file_path_str: *const c_char, + signing_key_path_str: *const c_char, + signing_cert_path_str: *const c_char, + intermediate_cert_paths_str: *const *const c_char, intermediate_cert_paths_len: usize, err: *mut *mut FFIError, ) -> bool { @@ -221,14 +222,18 @@ where /// C interface for verify_signed_file() which verifies a file's external digital signature. /// Handles all the unsafe ffi stuff. /// +/// The signer_name output parameter is a pointer to a pointer to a C string. +/// The caller is responsible for freeing the CString. See `ffi_cstring_free`. +/// /// # Safety /// /// No parameters may be NULL. #[export_name = "codesign_verify_file"] pub unsafe extern "C" fn codesign_verify_file( - signed_file_path_str: *const std::os::raw::c_char, - signature_file_path_str: *const std::os::raw::c_char, - certs_directory_str: *const std::os::raw::c_char, + signed_file_path_str: *const c_char, + signature_file_path_str: *const c_char, + certs_directory_str: *const c_char, + signer_name: *mut *mut c_char, err: *mut *mut FFIError, ) -> bool { let signed_file_path_str = validate_str_param!(signed_file_path_str); @@ -273,9 +278,21 @@ pub unsafe extern "C" fn codesign_verify_file( } }; + // verify that signer_name is not NULL + if signer_name.is_null() { + // invalid parameter + return ffi_error!( + err = err, + Error::CannotVerify("signer_name output parameter is NULL".to_string()) + ); + } + match verify_signed_file(&signed_file_path, &signature_file_path, &certs_directory) { - Ok(()) => { + Ok(signer) => { debug!("CVD verified successfully"); + // convert the signer_name to a CString and store it in the output parameter + let signer_cstr = std::ffi::CString::new(signer).unwrap(); + *signer_name = signer_cstr.into_raw(); true } Err(e) => { @@ -287,11 +304,12 @@ pub unsafe extern "C" fn codesign_verify_file( /// Verifies a signed file. /// The signature file is expected to be in the ClamAV '.sign' format. /// The certificates directory is expected to contain the public keys of the signers. +/// Returns the name of the signer. pub fn verify_signed_file( signed_file_path: &Path, signature_file_path: &Path, certs_directory: &Path, -) -> Result<(), Error> { +) -> Result { let signature_file: File = File::open(&signature_file_path)?; let mut signed_file: File = File::open(&signed_file_path)?; @@ -365,8 +383,8 @@ pub fn verify_signed_file( let verifier = Verifier::new(&cert_path)?; match verifier.verify(&file_data, &pkcs7) { - Ok(()) => { - return Ok(()); + Ok(signer) => { + return Ok(signer); } Err(Error::InvalidDigitalSignature(m)) => { warn!( @@ -461,17 +479,32 @@ impl Verifier { Ok(Verifier { root_ca }) } - pub fn verify(&self, data: &[u8], pkcs7: &Pkcs7) -> Result<(), Error> { + pub fn verify(&self, data: &[u8], pkcs7: &Pkcs7) -> Result { if let Some(signed) = pkcs7.signed() { if let Some(cert_stack) = signed.certificates() { let root_ca_serial = self.root_ca.serial_number().to_bn()?; debug!("Checking if the root CA's serial matches any in the signature's certificate stack..."); + let mut top_level_signer: Option = None; // Check each cert in the pkcs7 cert stack to see if it matches the root CA. // If we can't find a matching serial number, then we can't verify the pkcs7 signature. // That doesn't mean the signature is invalid, only that we don't have the required public key to verify it. for cert in cert_stack { let serial = cert.serial_number().to_bn()?; + if top_level_signer == None { + let signer = cert + .subject_name() + .entries() + .next() + .ok_or(Error::InvalidDigitalSignature( + "Certificate does not have any name entries".to_string(), + ))? + .data() + .as_utf8()? + .to_string(); + debug!("Top level signer serial: {}", signer); + top_level_signer = Some(signer); + } if root_ca_serial == serial { // found a matching serial number in the pkcs7 cert stack matching the provided root CA. @@ -494,7 +527,7 @@ impl Verifier { match result { Ok(()) => { debug!("Signature verified"); - return Ok(()); + return Ok(top_level_signer.unwrap()); } Err(e) => { eprintln!("Error verifying signature: {}", e); diff --git a/libclamav_rust/src/cvd.rs b/libclamav_rust/src/cvd.rs index 42af7f6b6b..c5df84ad5d 100644 --- a/libclamav_rust/src/cvd.rs +++ b/libclamav_rust/src/cvd.rs @@ -8,12 +8,14 @@ use std::{ raw::{c_char, c_void}, }, path::{Path, PathBuf}, + str::FromStr, time::{Duration, SystemTime}, }; use flate2::read::GzDecoder; use hex; use log::{debug, error, warn}; +use tar::Archive; use crate::{ codesign, ffi_error, ffi_error_null, ffi_util::FFIError, sys, validate_optional_str_param, @@ -52,6 +54,7 @@ pub struct CVD { pub builder: String, pub file: File, pub path: PathBuf, + pub is_compressed: bool, } impl CVD { @@ -65,6 +68,7 @@ impl CVD { md5: Option, builder: String, path: PathBuf, + is_compressed: bool, ) -> Self { let file = File::open(&path).unwrap(); Self { @@ -78,6 +82,7 @@ impl CVD { builder, file, path, + is_compressed, } } @@ -107,11 +112,24 @@ impl CVD { .to_string(); // read the 512 byte header - let mut header = [0; 512]; + let mut header: [u8; 512] = [0; 512]; reader .read_exact(&mut header) .map_err(|_| Error::Parse("File is smaller than 512-byte CVD header".to_string()))?; + let mut maybe_copying: [u8; 7] = [0; 7]; + reader + .read_exact(&mut maybe_copying) + .map_err(|_| Error::Parse("Can't read first 7 bytes of the tar file following the header.".to_string()))?; + + let is_compressed = if &maybe_copying == b"COPYING" { + // Able to read the contents of the first file, which must be COPYING. + // This means the CVD is not compressed. + false + } else { + true + }; + let mut fields = header.split(|&n| n == b':'); let magic = fields @@ -231,6 +249,7 @@ impl CVD { builder, file, path: file_path.to_path_buf(), + is_compressed, }) } @@ -250,7 +269,11 @@ impl CVD { debug!("Read {} bytes from CVD file", bytes_read); - let mut archive = tar::Archive::new(GzDecoder::new(file_bytes.as_slice())); + let mut archive: Archive> = if self.is_compressed { + tar::Archive::new(Box::new(GzDecoder::new(file_bytes.as_slice()))) + } else { + tar::Archive::new(Box::new(BufReader::new(file_bytes.as_slice()))) + }; archive .entries() @@ -260,8 +283,18 @@ impl CVD { e.to_string() )) })? - .filter_map(|e| e.ok()) - .for_each(|mut entry| -> () { + // .filter_map(|e| e.ok()) + .for_each(|entry| -> () { + let mut entry = match entry { + Ok(entry) => { + entry + } + Err(e) => { + error!("Failed to get entry in signature archive: {}", e); + return; + } + }; + let file_path = match entry.path() { Ok(file_path) => file_path, Err(e) => { @@ -360,7 +393,7 @@ impl CVD { Ok(()) } - pub fn verify_external_sign_file(&mut self, certs_directory: &Path) -> Result<(), Error> { + pub fn verify_external_sign_file(&mut self, certs_directory: &Path) -> Result { let database_directory = self.path.parent().ok_or_else(|| { Error::Parse("Failed to get database directory from CVD file path".to_string()) })?; @@ -384,9 +417,9 @@ impl CVD { let signature_file_path = database_directory.join(signature_file_name); match codesign::verify_signed_file(&self.path, &signature_file_path, certs_directory) { - Ok(()) => { - debug!("Detached CVD signature verification succeeded"); - return Ok(()); + Ok(signer) => { + debug!("Successfully verified {:?} signed by {}", self.path, signer); + return Ok(signer); } Err(codesign::Error::InvalidDigitalSignature(m)) => { warn!( @@ -409,14 +442,14 @@ impl CVD { &mut self, certs_directory: Option, disable_md5: bool, - ) -> Result<(), Error> { + ) -> Result { // First try to verify the CVD with the detached signature file. // If that fails, fall back to verifying with the MD5-based attached RSA digital signature. if let Some(certs_directory) = certs_directory { match self.verify_external_sign_file(&certs_directory) { - Ok(()) => { + Ok(signer) => { debug!("CVD verified successfully with detached signature file"); - return Ok(()); + return Ok(signer); } Err(Error::InvalidDigitalSignature(e)) => { warn!("Detached CVD signature is invalid: {}", e); @@ -427,6 +460,8 @@ impl CVD { "Failed to verify {:?} with detached signature file: {}", self.path, e ); + + // If the error because of an invalid signature, fall back to verifying with the MD5-based attached RSA digital signature } } } else { @@ -439,7 +474,19 @@ impl CVD { } // Fall back to verifying with the MD5-based attached RSA digital signature - self.verify_rsa_dsig() + match self.verify_rsa_dsig() { + Ok(()) => { + debug!("CVD verified successfully with Talos MD5-based RSA digital signature"); + Ok("Talos".to_string()) + } + Err(e) => { + warn!( + "Failed to verify CVD with MD5-based RSA digital signature: {}", + e + ); + Err(e) + } + } } } @@ -455,6 +502,7 @@ pub unsafe extern "C" fn cvd_check( certs_directory_str: *const c_char, skip_sign_verify: bool, disable_md5: bool, + signer_name: *mut *mut c_char, err: *mut *mut FFIError, ) -> bool { let cvd_file_path_str = validate_str_param!(cvd_file_path_str); @@ -469,7 +517,7 @@ pub unsafe extern "C" fn cvd_check( }; let certs_directory_str = validate_str_param!(certs_directory_str); - let certs_directory = match Path::new(certs_directory_str).canonicalize() { + let certs_directory = match PathBuf::from_str(certs_directory_str) { Ok(p) => p, Err(e) => { return ffi_error!( @@ -487,8 +535,9 @@ pub unsafe extern "C" fn cvd_check( } match cvd.verify(Some(certs_directory), disable_md5) { - Ok(()) => { - println!("CVD verified successfully"); + Ok(signer) => { + let signer_cstr = std::ffi::CString::new(signer).unwrap(); + *signer_name = signer_cstr.into_raw(); return true; } Err(e) => { @@ -593,18 +642,22 @@ pub unsafe extern "C" fn cvd_verify( cvd: *const c_void, certs_directory_str: *const c_char, disable_md5: bool, + signer_name: *mut *mut c_char, err: *mut *mut FFIError, ) -> bool { let mut cvd = ManuallyDrop::new(Box::from_raw(cvd as *mut CVD)); let certs_directory_str = validate_optional_str_param!(certs_directory_str); let certs_directory = match certs_directory_str { - Some(c) => match Path::new(c).canonicalize() { + Some(c) => match PathBuf::from_str(c) { Ok(p) => Some(p), Err(e) => { return ffi_error!( err = err, - Error::CannotVerify(format!("Invalid certs directory path: {}", e)) + Error::CannotVerify(format!( + "Invalid certs directory path {:?}: {}", + certs_directory_str, e + )) ); } }, @@ -612,13 +665,13 @@ pub unsafe extern "C" fn cvd_verify( }; match cvd.verify(certs_directory, disable_md5) { - Ok(()) => { - debug!("CVD verified successfully"); + Ok(signer) => { + let signer_cstr = std::ffi::CString::new(signer).unwrap(); + *signer_name = signer_cstr.into_raw(); true } Err(e) => { - ffi_error!(err = err, e); - false + return ffi_error!(err = err, e); } } } @@ -725,7 +778,7 @@ pub unsafe extern "C" fn cvd_get_min_flevel(cvd: *const c_void) -> u32 { /// No parameters may be NULL /// The CVD pointer must be valid #[export_name = "cvd_get_builder"] -pub unsafe extern "C" fn cvd_get_builder(cvd: *const c_void) -> *const c_char { +pub unsafe extern "C" fn cvd_get_builder(cvd: *const c_void) -> *mut c_char { let cvd = ManuallyDrop::new(Box::from_raw(cvd as *mut CVD)); CString::new(cvd.builder.clone()).unwrap().into_raw() } diff --git a/libclamav_rust/src/sys.rs b/libclamav_rust/src/sys.rs index 0a8044cf0f..5229f6df70 100644 --- a/libclamav_rust/src/sys.rs +++ b/libclamav_rust/src/sys.rs @@ -6,7 +6,6 @@ pub type __off_t = ::std::os::raw::c_long; pub type __time_t = ::std::os::raw::c_long; pub type __suseconds_t = ::std::os::raw::c_long; pub type off_t = __off_t; -pub type time_t = __time_t; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct timeval { @@ -251,6 +250,10 @@ pub struct cl_cvd { pub builder: *mut ::std::os::raw::c_char, pub stime: ::std::os::raw::c_uint, } +extern "C" { + #[doc = " @brief Get the Functionality Level (FLEVEL).\n\n @return unsigned int The FLEVEL."] + pub fn cl_retflevel() -> ::std::os::raw::c_uint; +} pub type cl_fmap_t = cl_fmap; #[doc = " @brief Read callback function type.\n\n A callback function pointer type for reading data from a cl_fmap_t that uses\n reads data from a handle interface.\n\n Read 'count' bytes starting at 'offset' into the buffer 'buf'\n\n Thread safety: It is guaranteed that only one callback is executing for a\n specific handle at any time, but there might be multiple callbacks executing\n for different handle at the same time.\n\n @param handle The handle passed to cl_fmap_open_handle, its meaning is up\n to the callback's implementation\n @param buf A buffer to read data into, must be at least offset + count\n bytes in size.\n @param count The number of bytes to read.\n @param offset The offset into buf to read the data to. If successful,\n the number of bytes actually read is returned. Upon reading\n end-of-file, zero is returned. Otherwise, a -1 is returned\n and the global variable errno is set to indicate the error."] pub type clcb_pread = ::std::option::Option< @@ -380,35 +383,37 @@ pub const cli_file_CL_TYPE_PS: cli_file = 552; pub const cli_file_CL_TYPE_EGG: cli_file = 553; pub const cli_file_CL_TYPE_ONENOTE: cli_file = 554; pub const cli_file_CL_TYPE_PYTHON_COMPILED: cli_file = 555; -pub const cli_file_CL_TYPE_PART_ANY: cli_file = 556; -pub const cli_file_CL_TYPE_PART_HFSPLUS: cli_file = 557; -pub const cli_file_CL_TYPE_MBR: cli_file = 558; -pub const cli_file_CL_TYPE_HTML: cli_file = 559; -pub const cli_file_CL_TYPE_MAIL: cli_file = 560; -pub const cli_file_CL_TYPE_SFX: cli_file = 561; -pub const cli_file_CL_TYPE_ZIPSFX: cli_file = 562; -pub const cli_file_CL_TYPE_RARSFX: cli_file = 563; -pub const cli_file_CL_TYPE_7ZSFX: cli_file = 564; -pub const cli_file_CL_TYPE_CABSFX: cli_file = 565; -pub const cli_file_CL_TYPE_ARJSFX: cli_file = 566; -pub const cli_file_CL_TYPE_EGGSFX: cli_file = 567; -pub const cli_file_CL_TYPE_NULSFT: cli_file = 568; -pub const cli_file_CL_TYPE_AUTOIT: cli_file = 569; -pub const cli_file_CL_TYPE_ISHIELD_MSI: cli_file = 570; -pub const cli_file_CL_TYPE_ISO9660: cli_file = 571; -pub const cli_file_CL_TYPE_DMG: cli_file = 572; -pub const cli_file_CL_TYPE_GPT: cli_file = 573; -pub const cli_file_CL_TYPE_APM: cli_file = 574; -pub const cli_file_CL_TYPE_XDP: cli_file = 575; -pub const cli_file_CL_TYPE_XML_WORD: cli_file = 576; -pub const cli_file_CL_TYPE_XML_XL: cli_file = 577; -pub const cli_file_CL_TYPE_XML_HWP: cli_file = 578; -pub const cli_file_CL_TYPE_HWPOLE2: cli_file = 579; -pub const cli_file_CL_TYPE_MHTML: cli_file = 580; -pub const cli_file_CL_TYPE_LNK: cli_file = 581; -pub const cli_file_CL_TYPE_UDF: cli_file = 582; -pub const cli_file_CL_TYPE_OTHER: cli_file = 583; -pub const cli_file_CL_TYPE_IGNORED: cli_file = 584; +pub const cli_file_CL_TYPE_LHA_LZH: cli_file = 556; +pub const cli_file_CL_TYPE_PART_ANY: cli_file = 557; +pub const cli_file_CL_TYPE_PART_HFSPLUS: cli_file = 558; +pub const cli_file_CL_TYPE_MBR: cli_file = 559; +pub const cli_file_CL_TYPE_HTML: cli_file = 560; +pub const cli_file_CL_TYPE_MAIL: cli_file = 561; +pub const cli_file_CL_TYPE_SFX: cli_file = 562; +pub const cli_file_CL_TYPE_ZIPSFX: cli_file = 563; +pub const cli_file_CL_TYPE_RARSFX: cli_file = 564; +pub const cli_file_CL_TYPE_7ZSFX: cli_file = 565; +pub const cli_file_CL_TYPE_CABSFX: cli_file = 566; +pub const cli_file_CL_TYPE_ARJSFX: cli_file = 567; +pub const cli_file_CL_TYPE_EGGSFX: cli_file = 568; +pub const cli_file_CL_TYPE_NULSFT: cli_file = 569; +pub const cli_file_CL_TYPE_AUTOIT: cli_file = 570; +pub const cli_file_CL_TYPE_ISHIELD_MSI: cli_file = 571; +pub const cli_file_CL_TYPE_ISO9660: cli_file = 572; +pub const cli_file_CL_TYPE_DMG: cli_file = 573; +pub const cli_file_CL_TYPE_GPT: cli_file = 574; +pub const cli_file_CL_TYPE_APM: cli_file = 575; +pub const cli_file_CL_TYPE_XDP: cli_file = 576; +pub const cli_file_CL_TYPE_XML_WORD: cli_file = 577; +pub const cli_file_CL_TYPE_XML_XL: cli_file = 578; +pub const cli_file_CL_TYPE_XML_HWP: cli_file = 579; +pub const cli_file_CL_TYPE_HWPOLE2: cli_file = 580; +pub const cli_file_CL_TYPE_MHTML: cli_file = 581; +pub const cli_file_CL_TYPE_LNK: cli_file = 582; +pub const cli_file_CL_TYPE_UDF: cli_file = 583; +pub const cli_file_CL_TYPE_ALZ: cli_file = 584; +pub const cli_file_CL_TYPE_OTHER: cli_file = 585; +pub const cli_file_CL_TYPE_IGNORED: cli_file = 586; pub type cli_file = ::std::os::raw::c_uint; pub use self::cli_file as cli_file_t; #[repr(C)] @@ -421,6 +426,13 @@ pub struct cli_ftype { pub next: *mut cli_ftype, pub length: u16, } +#[doc = " forward declaration of json-c's JSON value instance structure"] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct json_object { + _unused: [u8; 0], +} +pub type cvd_t = *mut ::std::os::raw::c_void; pub type mpool_t = ::std::os::raw::c_void; #[repr(C)] #[derive(Debug, Copy, Clone)] @@ -574,8 +586,8 @@ pub struct cli_crt_t { pub n: *mut BIGNUM, pub e: *mut BIGNUM, pub sig: *mut BIGNUM, - pub not_before: time_t, - pub not_after: time_t, + pub not_before: i64, + pub not_after: i64, pub hashtype: cli_crt_hashtype, pub certSign: ::std::os::raw::c_int, pub codeSign: ::std::os::raw::c_int, @@ -619,7 +631,6 @@ pub struct recursion_level_tag { pub type recursion_level_t = recursion_level_tag; pub type evidence_t = *mut ::std::os::raw::c_void; pub type onedump_t = *mut ::std::os::raw::c_void; -pub type cvd_t = *mut ::std::os::raw::c_void; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct cli_ctx_tag { @@ -643,6 +654,8 @@ pub struct cli_ctx_tag { pub hook_lsig_matches: *mut bitset_t, pub cb_ctx: *mut ::std::os::raw::c_void, pub perf: *mut cli_events_t, + pub properties: *mut json_object, + pub wrkproperty: *mut json_object, pub time_limit: timeval, pub limit_exceeded: bool, pub abort_scan: bool, @@ -712,6 +725,7 @@ pub struct cl_engine { pub ac_mindepth: u32, pub ac_maxdepth: u32, pub tmpdir: *mut ::std::os::raw::c_char, + pub certs_directory: *mut ::std::os::raw::c_char, pub keeptmp: u32, pub engine_options: u64, pub cache_size: u32, @@ -1179,14 +1193,11 @@ extern "C" { res1: ::std::os::raw::c_int, ) -> cl_error_t; } -extern "C" { - pub fn cl_retflevel() -> ::std::os::raw::c_uint; -} extern "C" { pub fn cli_versig( md5: *const ::std::os::raw::c_char, - dsig_str: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; + dsig: *const ::std::os::raw::c_char, + ) -> cl_error_t; } extern "C" { pub fn cli_versig2( @@ -1206,8 +1217,6 @@ extern "C" { mode: ::std::os::raw::c_ushort, ) -> *mut ::std::os::raw::c_char; } -pub type css_image_extractor_t = *mut ::std::os::raw::c_void; -pub type css_image_handle_t = *mut ::std::os::raw::c_void; extern "C" { #[doc = " @brief Convenience wrapper for cli_magic_scan_nested_fmap_type().\n\n Creates an fmap and calls cli_magic_scan_nested_fmap_type() for you, with type CL_TYPE_ANY.\n\n @param buffer Pointer to the buffer to be scanned.\n @param length Size in bytes of the buffer being scanned.\n @param ctx Scanning context structure.\n @param name (optional) Original name of the file (to set fmap name metadata)\n @param attributes Layer attributes of the file being scanned (is it normalized, decrypted, etc)\n @return int CL_SUCCESS, or an error code."] pub fn cli_magic_scan_buff( diff --git a/sigtool/sigtool.c b/sigtool/sigtool.c index 0140d135c1..6122febf01 100644 --- a/sigtool/sigtool.c +++ b/sigtool/sigtool.c @@ -875,13 +875,13 @@ void removeTempDir(const struct optstruct *opts, char *dir) */ static char *get_sign_file_name(char *target) { - char *sign_file_name = NULL; - char *dir = NULL; - FFIError *parse_error = NULL; - uint32_t cvd_version = 0; - char *cvd_name = NULL; - cvd_t *cvd = NULL; - char *target_dup = NULL; + char *sign_file_name = NULL; + char *dir = NULL; + FFIError *cvd_open_error = NULL; + uint32_t cvd_version = 0; + char *cvd_name = NULL; + cvd_t *cvd = NULL; + char *target_dup = NULL; cvd_type cvd_type = CVD_TYPE_UNKNOWN; const char *cvd_extension = NULL; @@ -901,9 +901,9 @@ static char *get_sign_file_name(char *target) if (cvd_type != CVD_TYPE_UNKNOWN) { // Signing a signature archive. We need to open the CVD file to get the version to use in the .sign file name. - cvd = cvd_open(target, &parse_error); + cvd = cvd_open(target, &cvd_open_error); if (NULL == cvd) { - mprintf(LOGG_ERROR, "get_sign_file_name: Failed to open CVD file '%s': %s\n", target, ffierror_fmt(parse_error)); + mprintf(LOGG_ERROR, "get_sign_file_name: Failed to open CVD file '%s': %s\n", target, ffierror_fmt(cvd_open_error)); goto done; } @@ -951,6 +951,9 @@ static char *get_sign_file_name(char *target) if (NULL != target_dup) { free(target_dup); } + if (NULL != cvd_open_error) { + ffierror_free(cvd_open_error); + } return sign_file_name; } @@ -969,8 +972,8 @@ static int sign(const struct optstruct *opts) char **intermediate_certs = NULL; size_t intermediate_certs_count = 0; - bool sign_result = false; - FFIError *sign_error = NULL; + bool sign_result = false; + FFIError *sign_file_error = NULL; target = optget(opts, "sign")->strarg; if (NULL == target) { @@ -1037,10 +1040,10 @@ static int sign(const struct optstruct *opts) signing_cert, (const char **)intermediate_certs, intermediate_certs_count, - &sign_error); + &sign_file_error); if (!sign_result) { - mprintf(LOGG_ERROR, "sign: Failed to sign file '%s': %s\n", target, ffierror_fmt(sign_error)); + mprintf(LOGG_ERROR, "sign: Failed to sign file '%s': %s\n", target, ffierror_fmt(sign_file_error)); goto done; } @@ -1055,6 +1058,9 @@ static int sign(const struct optstruct *opts) if (NULL != intermediate_certs) { free(intermediate_certs); } + if (NULL != sign_file_error) { + ffierror_free(sign_file_error); + } return ret; } @@ -1065,16 +1071,18 @@ static int verify(const struct optstruct *opts) char *target = NULL; char *sign_file_name = NULL; - char *certsdir = NULL; + char *cvdcertsdir = NULL; + STATBUF statbuf; - bool verify_result = false; - FFIError *verify_error = NULL; + char *signer_name = NULL; + bool verify_result = false; + FFIError *verify_file_error = NULL; target = optget(opts, "verify")->strarg; if (NULL == target) { mprintf(LOGG_ERROR, "verify: No target file specified.\n"); - mprintf(LOGG_ERROR, "To verify a file signed with sigtool, you must specify a target file. You may also override the default certificates directory using --certsdir.\n"); - mprintf(LOGG_ERROR, "For example: sigtool --verify myfile.cvd --certsdir /path/to/certs/\n"); + mprintf(LOGG_ERROR, "To verify a file signed with sigtool, you must specify a target file. You may also override the default certificates directory using --cvdcertsdir.\n"); + mprintf(LOGG_ERROR, "For example: sigtool --verify myfile.cvd --cvdcertsdir /path/to/certs/\n"); goto done; } @@ -1084,30 +1092,50 @@ static int verify(const struct optstruct *opts) goto done; } - certsdir = optget(opts, "certsdir")->strarg; - if (NULL == certsdir) { - certsdir = CERTSDIR; + cvdcertsdir = optget(opts, "cvdcertsdir")->strarg; + if (NULL == cvdcertsdir) { + // Check if the CVD_CERTS_DIR environment variable is set + cvdcertsdir = getenv("CVD_CERTS_DIR"); + + // If not, use the default value + if (NULL == cvdcertsdir) { + cvdcertsdir = CERTSDIR; + } + } + + if (LSTAT(cvdcertsdir, &statbuf) == -1) { + logg(LOGG_ERROR, + "ClamAV CA certificates directory is missing: %s\n" + "It should have been provided as a part of installation.", + cvdcertsdir); + goto done; } verify_result = codesign_verify_file( target, sign_file_name, - certsdir, - &verify_error); - + cvdcertsdir, + &signer_name, + &verify_file_error); if (!verify_result) { - mprintf(LOGG_ERROR, "verify: Failed to verify file '%s': %s\n", target, ffierror_fmt(verify_error)); + mprintf(LOGG_ERROR, "verify: Failed to verify file '%s': %s\n", target, ffierror_fmt(verify_file_error)); goto done; } - mprintf(LOGG_INFO, "verify: Successfully verified file '%s' with signature '%s'\n", target, sign_file_name); + mprintf(LOGG_INFO, "verify: Successfully verified file '%s' with signature '%s', signed by '%s'\n", target, sign_file_name, signer_name); ret = 0; done: + if (NULL != signer_name) { + ffi_cstring_free(signer_name); + } if (NULL != sign_file_name) { free(sign_file_name); } + if (NULL != verify_file_error) { + ffierror_free(verify_file_error); + } return ret; } @@ -1583,8 +1611,8 @@ static int unpack(const struct optstruct *opts) name[sizeof(name) - 1] = '\0'; } - if (optget(opts, "certsdir")->active) - certs_directory = optget(opts, "certsdir")->strarg; + if (optget(opts, "cvdcertsdir")->active) + certs_directory = optget(opts, "cvdcertsdir")->strarg; else certs_directory = CERTSDIR; @@ -3989,10 +4017,10 @@ static void help(void) mprintf(LOGG_INFO, "\n"); mprintf(LOGG_INFO, " Commands creating and verifying .sign detached digital signatures:\n"); mprintf(LOGG_INFO, "\n"); - mprintf(LOGG_INFO, " --sign /path/to/filename Sign a file.\n"); + mprintf(LOGG_INFO, " --sign FILE Sign a file.\n"); mprintf(LOGG_INFO, " The resulting .sign file name will\n"); - mprintf(LOGG_INFO, " be in the form: filename-version.cvd.sign\n"); - mprintf(LOGG_INFO, " or filename.sign for non-CVD targets.\n"); + mprintf(LOGG_INFO, " be in the form: dbname-version.cvd.sign\n"); + mprintf(LOGG_INFO, " or FILE.sign for non-CVD targets.\n"); mprintf(LOGG_INFO, " It will be created next to the target file.\n"); mprintf(LOGG_INFO, " If a .sign file already exists, then the\n"); mprintf(LOGG_INFO, " new signature will be appended to file.\n"); @@ -4001,13 +4029,13 @@ static void help(void) mprintf(LOGG_INFO, " May be used more than once to add\n"); mprintf(LOGG_INFO, " intermediate and root certificates.\n"); mprintf(LOGG_INFO, "\n"); - mprintf(LOGG_INFO, " --verify /path/to/filename Find and verify a detached digital\n"); + mprintf(LOGG_INFO, " --verify FILE Find and verify a detached digital\n"); mprintf(LOGG_INFO, " signature for the given file.\n"); mprintf(LOGG_INFO, " The digital signature file name must\n"); - mprintf(LOGG_INFO, " be in the form: filename-version.cvd.sign\n"); - mprintf(LOGG_INFO, " or filename.sign for non-CVD targets.\n"); + mprintf(LOGG_INFO, " be in the form: dbname-version.cvd.sign\n"); + mprintf(LOGG_INFO, " or FILE.sign for non-CVD targets.\n"); mprintf(LOGG_INFO, " It must be found next to the target file.\n"); - mprintf(LOGG_INFO, " --certsdir /path/to/certs/ Specify a directory containing the root\n"); + mprintf(LOGG_INFO, " --cvdcertsdir DIRECTORY Specify a directory containing the root\n"); mprintf(LOGG_INFO, " CA cert needed to verify the signature.\n"); mprintf(LOGG_INFO, " If not provided, then sigtool will look in:\n"); mprintf(LOGG_INFO, " " CERTSDIR "\n"); diff --git a/unit_tests/CMakeLists.txt b/unit_tests/CMakeLists.txt index e750e03932..fd5fb8f1e6 100644 --- a/unit_tests/CMakeLists.txt +++ b/unit_tests/CMakeLists.txt @@ -264,6 +264,7 @@ set(ENVIRONMENT CK_DEFAULT_TIMEOUT=300 LD_LIBRARY_PATH=${LD_LIBRARY_PATH} DYLD_LIBRARY_PATH=${LD_LIBRARY_PATH} + CVD_CERTS_DIR=${CMAKE_SOURCE_DIR}/etc/certs PATH=${NEW_PATH} LIBSSL=${LIBSSL} LIBCRYPTO=${LIBCRYPTO} diff --git a/unit_tests/check_clamav.c b/unit_tests/check_clamav.c index a8d0ed886c..15de986d49 100644 --- a/unit_tests/check_clamav.c +++ b/unit_tests/check_clamav.c @@ -451,7 +451,7 @@ START_TEST(test_cl_cvdverify) // Can't verify a cvd that doesn't exist testfile = SRCDIR "/input/freshclam_testfiles/test-na.cvd"; ret = cl_cvdverify(testfile); - ck_assert_msg(CL_EOPEN == ret, "cl_cvdverify should have failed for: %s -- %s", testfile, cl_strerror(ret)); + ck_assert_msg(CL_ECVD == ret, "cl_cvdverify should have failed for: %s -- %s", testfile, cl_strerror(ret)); // A cdiff is not a cvd. Cannot verify with cl_cvdverify! testfile = SRCDIR "/input/freshclam_testfiles/test-2.cdiff"; diff --git a/unit_tests/freshclam_test.py b/unit_tests/freshclam_test.py index 78de30c028..24ec6a7598 100644 --- a/unit_tests/freshclam_test.py +++ b/unit_tests/freshclam_test.py @@ -720,7 +720,7 @@ def test_freshclam_08_cdiff_update_twice(self): # # Now run the update for the first set up updates. # - command = '{valgrind} {valgrind_args} {freshclam} --no-dns --config-file={freshclam_config} --update-db=test'.format( + command = '{valgrind} {valgrind_args} {freshclam} --no-dns --debug --config-file={freshclam_config} --update-db=test'.format( valgrind=TC.valgrind, valgrind_args=TC.valgrind_args, freshclam=TC.freshclam, freshclam_config=TC.freshclam_config ) output = self.execute_command(command) @@ -751,7 +751,7 @@ def test_freshclam_08_cdiff_update_twice(self): # # Now re-run the update for more updates. # - command = '{valgrind} {valgrind_args} {freshclam} --no-dns --config-file={freshclam_config} --update-db=test'.format( + command = '{valgrind} {valgrind_args} {freshclam} --no-dns --debug --config-file={freshclam_config} --update-db=test'.format( valgrind=TC.valgrind, valgrind_args=TC.valgrind_args, freshclam=TC.freshclam, freshclam_config=TC.freshclam_config ) output = self.execute_command(command) diff --git a/unit_tests/input/freshclam_testfiles/test-1.cvd.sign b/unit_tests/input/freshclam_testfiles/test-1.cvd.sign new file mode 100644 index 0000000000..5a502c3f30 --- /dev/null +++ b/unit_tests/input/freshclam_testfiles/test-1.cvd.sign @@ -0,0 +1,2 @@ +#clamsign-1.0 +220::pkcs7-pem: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 diff --git a/unit_tests/input/freshclam_testfiles/test-2.cdiff.sign b/unit_tests/input/freshclam_testfiles/test-2.cdiff.sign new file mode 100644 index 0000000000..a459ccf5d7 --- /dev/null +++ b/unit_tests/input/freshclam_testfiles/test-2.cdiff.sign @@ -0,0 +1,2 @@ +#clamsign-1.0 +220::pkcs7-pem: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 diff --git a/unit_tests/input/freshclam_testfiles/test-2.cvd.sign b/unit_tests/input/freshclam_testfiles/test-2.cvd.sign new file mode 100644 index 0000000000..0423b71f54 --- /dev/null +++ b/unit_tests/input/freshclam_testfiles/test-2.cvd.sign @@ -0,0 +1,2 @@ +#clamsign-1.0 +220::pkcs7-pem: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 diff --git a/unit_tests/input/freshclam_testfiles/test-3.cdiff.sign b/unit_tests/input/freshclam_testfiles/test-3.cdiff.sign new file mode 100644 index 0000000000..e78a56f324 --- /dev/null +++ b/unit_tests/input/freshclam_testfiles/test-3.cdiff.sign @@ -0,0 +1,2 @@ +#clamsign-1.0 +220::pkcs7-pem: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 diff --git a/unit_tests/input/freshclam_testfiles/test-3.cvd.sign b/unit_tests/input/freshclam_testfiles/test-3.cvd.sign new file mode 100644 index 0000000000..a16bd1bd36 --- /dev/null +++ b/unit_tests/input/freshclam_testfiles/test-3.cvd.sign @@ -0,0 +1,2 @@ +#clamsign-1.0 +220::pkcs7-pem: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 diff --git a/unit_tests/input/freshclam_testfiles/test-4.cdiff.sign b/unit_tests/input/freshclam_testfiles/test-4.cdiff.sign new file mode 100644 index 0000000000..0dc8ed64c7 --- /dev/null +++ b/unit_tests/input/freshclam_testfiles/test-4.cdiff.sign @@ -0,0 +1,2 @@ +#clamsign-1.0 +220::pkcs7-pem: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 diff --git a/unit_tests/input/freshclam_testfiles/test-4.cvd.sign b/unit_tests/input/freshclam_testfiles/test-4.cvd.sign new file mode 100644 index 0000000000..cc4d82d9f1 --- /dev/null +++ b/unit_tests/input/freshclam_testfiles/test-4.cvd.sign @@ -0,0 +1,2 @@ +#clamsign-1.0 +220::pkcs7-pem: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 diff --git a/unit_tests/input/freshclam_testfiles/test-5.cdiff.sign b/unit_tests/input/freshclam_testfiles/test-5.cdiff.sign new file mode 100644 index 0000000000..9b660fff1a --- /dev/null +++ b/unit_tests/input/freshclam_testfiles/test-5.cdiff.sign @@ -0,0 +1,2 @@ +#clamsign-1.0 +220::pkcs7-pem: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 diff --git a/unit_tests/input/freshclam_testfiles/test-5.cvd.sign b/unit_tests/input/freshclam_testfiles/test-5.cvd.sign new file mode 100644 index 0000000000..624ec08097 --- /dev/null +++ b/unit_tests/input/freshclam_testfiles/test-5.cvd.sign @@ -0,0 +1,2 @@ +#clamsign-1.0 +220::pkcs7-pem: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 diff --git a/unit_tests/input/freshclam_testfiles/test-6.cdiff.sign b/unit_tests/input/freshclam_testfiles/test-6.cdiff.sign new file mode 100644 index 0000000000..c2ac60a69c --- /dev/null +++ b/unit_tests/input/freshclam_testfiles/test-6.cdiff.sign @@ -0,0 +1,2 @@ +#clamsign-1.0 +220::pkcs7-pem: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 diff --git a/unit_tests/input/freshclam_testfiles/test-6.cvd.sign b/unit_tests/input/freshclam_testfiles/test-6.cvd.sign new file mode 100644 index 0000000000..6e00f35aeb --- /dev/null +++ b/unit_tests/input/freshclam_testfiles/test-6.cvd.sign @@ -0,0 +1,2 @@ +#clamsign-1.0 +220::pkcs7-pem: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