char *ds_rds_session_get_html_report(struct ds_rds_session *rds_session)
{
const char *params[] = {
"show", "",
"verbosity", "",
"hide-profile-info", NULL,
"oscap-version", oscap_get_version(),
"pwd", NULL,
NULL
};
return oscap_source_apply_xslt_path_mem(rds_session->source, "xccdf-report.xsl", params, oscap_path_to_xslt());
}
oval_agent_session_t * oval_agent_new_session(struct oval_definition_model *model, const char * name) {
oval_agent_session_t *ag_sess;
struct oval_sysinfo *sysinfo;
struct oval_generator *generator;
int ret;
dI("Started new OVAL agent.", name);
/* Optimalization */
oval_definition_model_optimize_by_filter_propagation(model);
ag_sess = oscap_talloc(oval_agent_session_t);
ag_sess->filename = oscap_strdup(name);
ag_sess->def_model = model;
ag_sess->cur_var_model = NULL;
ag_sess->sys_model = oval_syschar_model_new(model);
#if defined(OVAL_PROBES_ENABLED)
ag_sess->psess = oval_probe_session_new(ag_sess->sys_model);
#endif
#if defined(OVAL_PROBES_ENABLED)
/* probe sysinfo */
ret = oval_probe_query_sysinfo(ag_sess->psess, &sysinfo);
if (ret != 0) {
oval_probe_session_destroy(ag_sess->psess);
oval_syschar_model_free(ag_sess->sys_model);
oscap_free(ag_sess);
return NULL;
}
#else
/* TODO */
sysinfo = oval_sysinfo_new(ag_sess->sys_model);
#endif /* OVAL_PROBES_ENABLED */
oval_syschar_model_set_sysinfo(ag_sess->sys_model, sysinfo);
oval_sysinfo_free(sysinfo);
/* one system only */
ag_sess->sys_models[0] = ag_sess->sys_model;
ag_sess->sys_models[1] = NULL;
#if defined(OVAL_PROBES_ENABLED)
ag_sess->res_model = oval_results_model_new_with_probe_session(
model, ag_sess->sys_models, ag_sess->psess);
generator = oval_results_model_get_generator(ag_sess->res_model);
oval_generator_set_product_version(generator, oscap_get_version());
#endif
ag_sess->product_name = NULL;
return ag_sess;
}
char *ds_sds_session_get_html_guide(struct ds_sds_session *session, const char *profile_id)
{
const char *params[] = {
"show", "",
"verbosity", "",
"hide-profile-info", NULL,
"oscap-version", oscap_get_version(),
"pwd", NULL,
"profile_id", profile_id,
NULL
};
struct oscap_source *xccdf = oscap_htable_get(session->component_sources, "xccdf.xml");
if (xccdf == NULL) {
oscap_seterr(OSCAP_EFAMILY_OSCAP, "Internal error: Could not acquire handle to xccdf.xml source.");
}
return oscap_source_apply_xslt_path_mem(xccdf, "xccdf-guide.xsl", params, oscap_path_to_xslt());
}
int app_xslt(const char *infile, const char *xsltfile, const char *outfile, const char **params)
{
char pwd[PATH_MAX];
if (getcwd(pwd, sizeof(pwd)) == NULL) {
fprintf(stderr, "ERROR: %s\n", strerror(errno));
return OSCAP_ERROR;
}
/* add params oscap-version & pwd */
const char *stdparams[] = { "oscap-version", oscap_get_version(), "pwd", pwd, NULL };
const char *par[paramlist_size(params) + paramlist_size(stdparams) + 1];
size_t s = paramlist_cpy(par , params);
paramlist_cpy(par + s, stdparams);
if (oscap_apply_xslt(infile, xsltfile, outfile, par)==-1) {
fprintf(stderr, "%s: %s\n", OSCAP_ERR_MSG, oscap_err_desc());
return OSCAP_ERROR;
}
return OSCAP_OK;
}
void DiagnosticsDialog::dumpVersionInfo()
{
// We display this in Help->About as well but let us dump it as info message
// in case workbench crashes before user can work with the GUI.
infoMessage(QString("SCAP Workbench %1, compiled with Qt %2, using OpenSCAP %3").arg(SCAP_WORKBENCH_VERSION, QT_VERSION_STR, oscap_get_version()));
}
static int app_analyse_oval(const struct oscap_action *action) {
struct oval_definition_model *def_model = NULL;
struct oval_syschar_model *sys_model = NULL;
struct oval_results_model *res_model = NULL;
struct oval_variable_model *var_model = NULL;
struct oval_directives_model *dir_model = NULL;
struct oval_syschar_model *sys_models[2];
struct oval_generator *generator = NULL;
int ret = OSCAP_ERROR;
/* Turn on verbosity */
if (!oscap_set_verbose(action->verbosity_level, action->f_verbose_log, false)) {
goto cleanup;
}
/* validate inputs */
if (action->validate) {
if (!valid_inputs(action)) {
goto cleanup;
}
}
/* load defnitions */
struct oscap_source *source = oscap_source_new_from_file(action->f_oval);
def_model = oval_definition_model_import_source(source);
oscap_source_free(source);
if (def_model == NULL) {
fprintf(stderr, "Failed to import the OVAL Definitions from '%s'.\n", action->f_oval);
goto cleanup;
}
/* bind external variables */
if(action->f_variables) {
struct oscap_source *var_source = oscap_source_new_from_file(action->f_variables);
var_model = oval_variable_model_import_source(var_source);
oscap_source_free(var_source);
if (var_model == NULL) {
fprintf(stderr, "Failed to import the OVAL Variables from '%s'.\n", action->f_variables);
goto cleanup;
}
if (oval_definition_model_bind_variable_model(def_model, var_model)) {
fprintf(stderr, "Failed to bind Variables to Definitions\n");
goto cleanup;
}
}
/* load system characteristics */
sys_model = oval_syschar_model_new(def_model);
source = oscap_source_new_from_file(action->f_syschar);
if (oval_syschar_model_import_source(sys_model, source) == -1 ) {
fprintf(stderr, "Failed to import the System Characteristics from '%s'.\n", action->f_syschar);
oscap_source_free(source);
goto cleanup;
}
oscap_source_free(source);
/* evaluate */
sys_models[0] = sys_model;
sys_models[1] = NULL;
res_model = oval_results_model_new(def_model, sys_models);
/* set product name */
generator = oval_results_model_get_generator(res_model);
oval_generator_set_product_name(generator, OSCAP_PRODUCTNAME);
oval_generator_set_product_version(generator, oscap_get_version());
oval_results_model_eval(res_model);
/* export results */
if (action->f_results != NULL) {
/* import directives */
if (action->f_directives != NULL) {
dir_model = oval_directives_model_new();
struct oscap_source *dir_source = oscap_source_new_from_file(action->f_directives);
oval_directives_model_import_source(dir_model, dir_source);
oscap_source_free(dir_source);
}
/* export result model to XML */
oval_results_model_export(res_model, dir_model, action->f_results);
const char* full_validation = getenv("OSCAP_FULL_VALIDATION");
/* validate OVAL Results */
if (action->validate && full_validation) {
struct oscap_source *result_source = oscap_source_new_from_file(action->f_results);
if (oscap_source_validate(result_source, reporter, (void *) action)) {
oscap_source_free(result_source);
goto cleanup;
}
fprintf(stdout, "OVAL Results are exported correctly.\n");
oscap_source_free(result_source);
}
}
ret = OSCAP_OK;
/* clean up */
cleanup:
if(oscap_err())
fprintf(stderr, "%s %s\n", OSCAP_ERR_MSG, oscap_err_desc());
if(res_model) oval_results_model_free(res_model);
if(sys_model) oval_syschar_model_free(sys_model);
if(def_model) oval_definition_model_free(def_model);
if(dir_model) oval_directives_model_free(dir_model);
return ret;
}
static int print_versions(const struct oscap_action *action)
{
printf("OpenSCAP command line tool (oscap) %s\n" "Copyright 2009--2016 Red Hat Inc., Durham, North Carolina.\n\n",
oscap_get_version());
printf("==== Supported specifications ====\n");
printf("XCCDF Version: %s\n", xccdf_benchmark_supported());
printf("OVAL Version: %s\n", oval_definition_model_supported());
printf("CPE Version: %s\n", cpe_dict_model_supported());
printf("CVSS Version: %s\n", cvss_model_supported());
printf("CVE Version: %s\n", cve_model_supported());
printf("Asset Identification Version: %s\n", "1.1");
printf("Asset Reporting Format Version: %s\n", "1.1");
printf("\n");
printf("==== Capabilities added by auto-loaded plugins ====\n");
const char * const *known_plugins = check_engine_plugin_get_known_plugins();
bool known_plugin_found = false;
while (*known_plugins) {
struct check_engine_plugin_def *plugin = check_engine_plugin_load(*known_plugins);
if (plugin) {
printf("%s (from %s)\n", check_engine_plugin_get_capabilities(plugin), *known_plugins);
check_engine_plugin_unload(plugin);
known_plugin_found = true;
}
known_plugins++;
}
if (!known_plugin_found)
printf("No plugins have been auto-loaded...\n");
// We do not report failure when a known plugin doesn't load properly, that's because they
// are optional and we don't know if it's not there or if it just failed to load.
oscap_clearerr();
printf("\n");
printf("==== Paths ====\n");
printf("Schema files: %s\n", oscap_path_to_schemas());
printf("Default CPE files: %s\n", oscap_path_to_cpe());
#if defined(OVAL_PROBES_ENABLED)
printf("Probes: %s\n", oval_probe_ext_getdir());
#endif
printf("\n");
printf("==== Inbuilt CPE names ====\n");
char default_cpe_path[PATH_MAX];
snprintf(default_cpe_path, PATH_MAX, "%s/openscap-cpe-dict.xml", oscap_path_to_cpe());
struct oscap_source *source = oscap_source_new_from_file(default_cpe_path);
struct cpe_dict_model* cpe_dict = cpe_dict_model_import_source(source);
oscap_source_free(source);
if (cpe_dict != NULL) {
struct cpe_item_iterator* cpe_items = cpe_dict_model_get_items(cpe_dict);
while (cpe_item_iterator_has_more(cpe_items))
{
struct cpe_item* cpe_item = cpe_item_iterator_next(cpe_items);
struct oscap_text_iterator* titles = cpe_item_get_titles(cpe_item);
char* str_title = oscap_textlist_get_preferred_plaintext(titles, NULL);
oscap_text_iterator_free(titles);
struct cpe_name* name = cpe_item_get_name(cpe_item);
char * str_name = cpe_name_get_as_format(name, CPE_FORMAT_URI);
printf("%s - %s\n", str_title, str_name);
free(str_name);
free(str_title);
}
cpe_item_iterator_free(cpe_items);
cpe_dict_model_free(cpe_dict);
}
printf("\n");
#if defined(OVAL_PROBES_ENABLED)
printf("==== Supported OVAL objects and associated OpenSCAP probes ====\n");
printf("%-14s%-28s %-28s\n", "OVAL family", "OVAL object", "OpenSCAP probe");
printf("%-14s%-28s %-28s\n", "----------", "----------", "----------");
oval_probe_meta_list(stdout, OVAL_PROBEMETA_LIST_DYNAMIC | OVAL_PROBEMETA_LIST_OTYPE);
#endif
return OSCAP_OK;
}
