1015 lines
20 KiB
C
1015 lines
20 KiB
C
/******************************************************************************
|
||
* @file evidence_record.c
|
||
* @brief Implémentation du modèle EvidenceRecord.
|
||
******************************************************************************/
|
||
|
||
#include "models/evidence_record.h"
|
||
|
||
#include <glib.h>
|
||
#include <string.h>
|
||
|
||
/**
|
||
* @brief Représentation privée d’une preuve numérique persistée.
|
||
*/
|
||
struct EvidenceRecord
|
||
{
|
||
char *identifier;
|
||
char *original_name;
|
||
char *internal_name;
|
||
char *relative_path;
|
||
char *type_identifier;
|
||
char *type_label;
|
||
char *mime_type;
|
||
|
||
guint64 size_bytes;
|
||
|
||
char *sha256;
|
||
char *imported_at;
|
||
char *collected_at;
|
||
char *source;
|
||
char *description;
|
||
|
||
EvidenceIntegrityStatus integrity_status;
|
||
};
|
||
|
||
EvidenceRecord *evidence_record_copy(const EvidenceRecord *evidence_record)
|
||
{
|
||
EvidenceRecord *copy;
|
||
if (evidence_record == NULL) return NULL;
|
||
copy = g_new0(EvidenceRecord, 1);
|
||
copy->identifier = g_strdup(evidence_record->identifier);
|
||
copy->original_name = g_strdup(evidence_record->original_name);
|
||
copy->internal_name = g_strdup(evidence_record->internal_name);
|
||
copy->relative_path = g_strdup(evidence_record->relative_path);
|
||
copy->type_identifier = g_strdup(evidence_record->type_identifier);
|
||
copy->type_label = g_strdup(evidence_record->type_label);
|
||
copy->mime_type = g_strdup(evidence_record->mime_type);
|
||
copy->size_bytes = evidence_record->size_bytes;
|
||
copy->sha256 = g_strdup(evidence_record->sha256);
|
||
copy->imported_at = g_strdup(evidence_record->imported_at);
|
||
copy->collected_at = g_strdup(evidence_record->collected_at);
|
||
copy->source = g_strdup(evidence_record->source);
|
||
copy->description = g_strdup(evidence_record->description);
|
||
copy->integrity_status = evidence_record->integrity_status;
|
||
return copy;
|
||
}
|
||
|
||
/**
|
||
* @brief Produit une erreur du domaine EvidenceRecord.
|
||
*/
|
||
static void evidence_record_set_error(
|
||
GError **error,
|
||
EvidenceRecordError error_code,
|
||
const char *message
|
||
)
|
||
{
|
||
if (error == NULL)
|
||
{
|
||
return;
|
||
}
|
||
|
||
g_set_error_literal(
|
||
error,
|
||
EVIDENCE_RECORD_ERROR,
|
||
error_code,
|
||
message
|
||
);
|
||
}
|
||
|
||
/**
|
||
* @brief Copie une chaîne et retire les espaces extérieurs.
|
||
*
|
||
* @return Nouvelle chaîne, ou NULL lorsque text vaut NULL.
|
||
*/
|
||
static char *evidence_record_duplicate_trimmed(
|
||
const char *text
|
||
)
|
||
{
|
||
char *text_copy = NULL;
|
||
|
||
if (text == NULL)
|
||
{
|
||
return NULL;
|
||
}
|
||
|
||
text_copy = g_strdup(
|
||
text
|
||
);
|
||
|
||
g_strstrip(
|
||
text_copy
|
||
);
|
||
|
||
return text_copy;
|
||
}
|
||
|
||
/**
|
||
* @brief Indique si une chaîne obligatoire contient du texte.
|
||
*/
|
||
static gboolean evidence_record_required_text_is_valid(
|
||
const char *text
|
||
)
|
||
{
|
||
return text != NULL &&
|
||
text[0] != '\0';
|
||
}
|
||
|
||
/**
|
||
* @brief Vérifie qu’un nom ne contient aucun composant de chemin.
|
||
*/
|
||
static gboolean evidence_record_filename_is_valid(
|
||
const char *filename
|
||
)
|
||
{
|
||
if (!evidence_record_required_text_is_valid(
|
||
filename
|
||
))
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
if (g_strcmp0(
|
||
filename,
|
||
"."
|
||
) == 0 ||
|
||
g_strcmp0(
|
||
filename,
|
||
".."
|
||
) == 0)
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
/*
|
||
* Les deux séparateurs sont refusés, même si l’application cible
|
||
* principalement les systèmes Unix.
|
||
*/
|
||
if (strchr(
|
||
filename,
|
||
'/'
|
||
) != NULL ||
|
||
strchr(
|
||
filename,
|
||
'\\'
|
||
) != NULL)
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief Vérifie qu’un chemin reste relatif à l’enquête.
|
||
*/
|
||
static gboolean evidence_record_relative_path_is_valid(
|
||
const char *relative_path
|
||
)
|
||
{
|
||
char **components = NULL;
|
||
gsize component_index = 0;
|
||
|
||
gboolean is_valid = TRUE;
|
||
|
||
if (!evidence_record_required_text_is_valid(
|
||
relative_path
|
||
))
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
if (g_path_is_absolute(
|
||
relative_path
|
||
))
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
if (g_strcmp0(
|
||
relative_path,
|
||
"."
|
||
) == 0 ||
|
||
g_strcmp0(
|
||
relative_path,
|
||
".."
|
||
) == 0)
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
if (relative_path[
|
||
strlen(relative_path) - 1
|
||
] == G_DIR_SEPARATOR)
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
components = g_strsplit(
|
||
relative_path,
|
||
G_DIR_SEPARATOR_S,
|
||
-1
|
||
);
|
||
|
||
if (components == NULL)
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
for (component_index = 0;
|
||
components[component_index] != NULL;
|
||
component_index++)
|
||
{
|
||
const char *component =
|
||
components[component_index];
|
||
|
||
if (component[0] == '\0' ||
|
||
g_strcmp0(
|
||
component,
|
||
"."
|
||
) == 0 ||
|
||
g_strcmp0(
|
||
component,
|
||
".."
|
||
) == 0)
|
||
{
|
||
is_valid = FALSE;
|
||
break;
|
||
}
|
||
}
|
||
|
||
g_strfreev(
|
||
components
|
||
);
|
||
|
||
return is_valid;
|
||
}
|
||
|
||
/**
|
||
* @brief Vérifie qu’une empreinte contient 64 caractères hexadécimaux.
|
||
*/
|
||
static gboolean evidence_record_sha256_is_valid(
|
||
const char *sha256
|
||
)
|
||
{
|
||
gsize character_index = 0;
|
||
|
||
if (sha256 == NULL ||
|
||
strlen(sha256) != 64)
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
for (character_index = 0;
|
||
character_index < 64;
|
||
character_index++)
|
||
{
|
||
if (!g_ascii_isxdigit(
|
||
sha256[character_index]
|
||
))
|
||
{
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief Convertit une empreinte hexadécimale en minuscules.
|
||
*/
|
||
static void evidence_record_sha256_to_lowercase(
|
||
char *sha256
|
||
)
|
||
{
|
||
gsize character_index = 0;
|
||
|
||
if (sha256 == NULL)
|
||
{
|
||
return;
|
||
}
|
||
|
||
for (character_index = 0;
|
||
sha256[character_index] != '\0';
|
||
character_index++)
|
||
{
|
||
sha256[character_index] =
|
||
g_ascii_tolower(
|
||
sha256[character_index]
|
||
);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief Lit un nombre décimal à une position déterminée.
|
||
*/
|
||
static gboolean evidence_record_parse_decimal(
|
||
const char *text,
|
||
gsize offset,
|
||
gsize length,
|
||
gint *out_value
|
||
)
|
||
{
|
||
gsize character_index = 0;
|
||
gint value = 0;
|
||
|
||
if (text == NULL ||
|
||
out_value == NULL ||
|
||
length == 0)
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
for (character_index = 0;
|
||
character_index < length;
|
||
character_index++)
|
||
{
|
||
char character =
|
||
text[offset + character_index];
|
||
|
||
if (!g_ascii_isdigit(
|
||
character
|
||
))
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
value =
|
||
(value * 10) +
|
||
(character - '0');
|
||
}
|
||
|
||
*out_value = value;
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief Vérifie une date UTC au format YYYY-MM-DDTHH:MM:SSZ.
|
||
*/
|
||
static gboolean evidence_record_utc_date_is_valid(
|
||
const char *date_text
|
||
)
|
||
{
|
||
GDateTime *date_time = NULL;
|
||
|
||
gint year = 0;
|
||
gint month = 0;
|
||
gint day = 0;
|
||
gint hour = 0;
|
||
gint minute = 0;
|
||
gint second = 0;
|
||
|
||
if (date_text == NULL ||
|
||
strlen(date_text) != 20)
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
if (date_text[4] != '-' ||
|
||
date_text[7] != '-' ||
|
||
date_text[10] != 'T' ||
|
||
date_text[13] != ':' ||
|
||
date_text[16] != ':' ||
|
||
date_text[19] != 'Z')
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
if (!evidence_record_parse_decimal(
|
||
date_text,
|
||
0,
|
||
4,
|
||
&year
|
||
) ||
|
||
!evidence_record_parse_decimal(
|
||
date_text,
|
||
5,
|
||
2,
|
||
&month
|
||
) ||
|
||
!evidence_record_parse_decimal(
|
||
date_text,
|
||
8,
|
||
2,
|
||
&day
|
||
) ||
|
||
!evidence_record_parse_decimal(
|
||
date_text,
|
||
11,
|
||
2,
|
||
&hour
|
||
) ||
|
||
!evidence_record_parse_decimal(
|
||
date_text,
|
||
14,
|
||
2,
|
||
&minute
|
||
) ||
|
||
!evidence_record_parse_decimal(
|
||
date_text,
|
||
17,
|
||
2,
|
||
&second
|
||
))
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
date_time = g_date_time_new_utc(
|
||
year,
|
||
month,
|
||
day,
|
||
hour,
|
||
minute,
|
||
second
|
||
);
|
||
|
||
if (date_time == NULL)
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
g_date_time_unref(
|
||
date_time
|
||
);
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief Vérifie que la valeur appartient à EvidenceIntegrityStatus.
|
||
*/
|
||
static gboolean evidence_record_integrity_status_is_valid(
|
||
EvidenceIntegrityStatus integrity_status
|
||
)
|
||
{
|
||
switch (integrity_status)
|
||
{
|
||
case EVIDENCE_INTEGRITY_STATUS_UNKNOWN:
|
||
case EVIDENCE_INTEGRITY_STATUS_VALID:
|
||
case EVIDENCE_INTEGRITY_STATUS_MISSING:
|
||
case EVIDENCE_INTEGRITY_STATUS_MODIFIED:
|
||
case EVIDENCE_INTEGRITY_STATUS_ERROR:
|
||
return TRUE;
|
||
|
||
default:
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
GQuark evidence_record_error_quark(void)
|
||
{
|
||
return g_quark_from_static_string(
|
||
"labfy-investigation-evidence-record-error"
|
||
);
|
||
}
|
||
|
||
EvidenceRecord *evidence_record_new(
|
||
const char *identifier,
|
||
const char *original_name,
|
||
const char *internal_name,
|
||
const char *relative_path,
|
||
const char *type_identifier,
|
||
guint64 size_bytes,
|
||
const char *sha256,
|
||
const char *imported_at,
|
||
const char *collected_at,
|
||
const char *source,
|
||
const char *description,
|
||
EvidenceIntegrityStatus integrity_status,
|
||
GError **error
|
||
)
|
||
{
|
||
EvidenceRecord *evidence_record = NULL;
|
||
|
||
char *identifier_copy = NULL;
|
||
char *original_name_copy = NULL;
|
||
char *internal_name_copy = NULL;
|
||
char *relative_path_copy = NULL;
|
||
char *type_identifier_copy = NULL;
|
||
char *sha256_copy = NULL;
|
||
char *imported_at_copy = NULL;
|
||
char *collected_at_copy = NULL;
|
||
char *source_copy = NULL;
|
||
char *description_copy = NULL;
|
||
|
||
g_return_val_if_fail(
|
||
error == NULL || *error == NULL,
|
||
NULL
|
||
);
|
||
|
||
identifier_copy =
|
||
evidence_record_duplicate_trimmed(
|
||
identifier
|
||
);
|
||
|
||
original_name_copy =
|
||
evidence_record_duplicate_trimmed(
|
||
original_name
|
||
);
|
||
|
||
internal_name_copy =
|
||
evidence_record_duplicate_trimmed(
|
||
internal_name
|
||
);
|
||
|
||
relative_path_copy =
|
||
evidence_record_duplicate_trimmed(
|
||
relative_path
|
||
);
|
||
|
||
type_identifier_copy =
|
||
evidence_record_duplicate_trimmed(
|
||
type_identifier
|
||
);
|
||
|
||
sha256_copy =
|
||
evidence_record_duplicate_trimmed(
|
||
sha256
|
||
);
|
||
|
||
imported_at_copy =
|
||
evidence_record_duplicate_trimmed(
|
||
imported_at
|
||
);
|
||
|
||
collected_at_copy =
|
||
evidence_record_duplicate_trimmed(
|
||
collected_at
|
||
);
|
||
|
||
source_copy =
|
||
evidence_record_duplicate_trimmed(
|
||
source
|
||
);
|
||
|
||
description_copy =
|
||
evidence_record_duplicate_trimmed(
|
||
description
|
||
);
|
||
|
||
if (!evidence_record_required_text_is_valid(
|
||
identifier_copy
|
||
))
|
||
{
|
||
evidence_record_set_error(
|
||
error,
|
||
EVIDENCE_RECORD_ERROR_INVALID_IDENTIFIER,
|
||
"L’identifiant de la preuve est obligatoire."
|
||
);
|
||
|
||
goto cleanup;
|
||
}
|
||
|
||
if (!g_uuid_string_is_valid(
|
||
identifier_copy
|
||
))
|
||
{
|
||
evidence_record_set_error(
|
||
error,
|
||
EVIDENCE_RECORD_ERROR_INVALID_IDENTIFIER,
|
||
"L’identifiant de la preuve n’est pas un UUID valide."
|
||
);
|
||
|
||
goto cleanup;
|
||
}
|
||
|
||
if (!evidence_record_filename_is_valid(
|
||
original_name_copy
|
||
))
|
||
{
|
||
evidence_record_set_error(
|
||
error,
|
||
EVIDENCE_RECORD_ERROR_INVALID_NAME,
|
||
"Le nom original de la preuve est invalide."
|
||
);
|
||
|
||
goto cleanup;
|
||
}
|
||
|
||
if (!evidence_record_filename_is_valid(
|
||
internal_name_copy
|
||
))
|
||
{
|
||
evidence_record_set_error(
|
||
error,
|
||
EVIDENCE_RECORD_ERROR_INVALID_NAME,
|
||
"Le nom interne de la preuve est invalide."
|
||
);
|
||
|
||
goto cleanup;
|
||
}
|
||
|
||
if (!evidence_record_relative_path_is_valid(
|
||
relative_path_copy
|
||
))
|
||
{
|
||
evidence_record_set_error(
|
||
error,
|
||
EVIDENCE_RECORD_ERROR_INVALID_PATH,
|
||
"Le chemin relatif de la preuve est invalide."
|
||
);
|
||
|
||
goto cleanup;
|
||
}
|
||
|
||
if (!evidence_record_required_text_is_valid(
|
||
type_identifier_copy
|
||
))
|
||
{
|
||
evidence_record_set_error(
|
||
error,
|
||
EVIDENCE_RECORD_ERROR_INVALID_TYPE,
|
||
"Le type de la preuve est obligatoire."
|
||
);
|
||
|
||
goto cleanup;
|
||
}
|
||
|
||
if (!evidence_record_sha256_is_valid(
|
||
sha256_copy
|
||
))
|
||
{
|
||
evidence_record_set_error(
|
||
error,
|
||
EVIDENCE_RECORD_ERROR_INVALID_SHA256,
|
||
"L’empreinte SHA-256 de la preuve est invalide."
|
||
);
|
||
|
||
goto cleanup;
|
||
}
|
||
|
||
if (!evidence_record_utc_date_is_valid(
|
||
imported_at_copy
|
||
))
|
||
{
|
||
evidence_record_set_error(
|
||
error,
|
||
EVIDENCE_RECORD_ERROR_INVALID_DATE,
|
||
"La date d’importation est invalide."
|
||
);
|
||
|
||
goto cleanup;
|
||
}
|
||
|
||
if (collected_at_copy != NULL &&
|
||
!evidence_record_utc_date_is_valid(
|
||
collected_at_copy
|
||
))
|
||
{
|
||
evidence_record_set_error(
|
||
error,
|
||
EVIDENCE_RECORD_ERROR_INVALID_DATE,
|
||
"La date de collecte est invalide."
|
||
);
|
||
|
||
goto cleanup;
|
||
}
|
||
|
||
if (!evidence_record_integrity_status_is_valid(
|
||
integrity_status
|
||
))
|
||
{
|
||
evidence_record_set_error(
|
||
error,
|
||
EVIDENCE_RECORD_ERROR_INVALID_STATUS,
|
||
"Le statut d’intégrité de la preuve est invalide."
|
||
);
|
||
|
||
goto cleanup;
|
||
}
|
||
|
||
/*
|
||
* Les champs facultatifs composés uniquement d’espaces deviennent
|
||
* NULL afin de ne pas conserver de chaînes vides.
|
||
*/
|
||
if (source_copy != NULL &&
|
||
source_copy[0] == '\0')
|
||
{
|
||
g_clear_pointer(
|
||
&source_copy,
|
||
g_free
|
||
);
|
||
}
|
||
|
||
if (description_copy != NULL &&
|
||
description_copy[0] == '\0')
|
||
{
|
||
g_clear_pointer(
|
||
&description_copy,
|
||
g_free
|
||
);
|
||
}
|
||
|
||
evidence_record_sha256_to_lowercase(
|
||
sha256_copy
|
||
);
|
||
|
||
evidence_record = g_new0(
|
||
EvidenceRecord,
|
||
1
|
||
);
|
||
|
||
evidence_record->identifier =
|
||
identifier_copy;
|
||
|
||
evidence_record->original_name =
|
||
original_name_copy;
|
||
|
||
evidence_record->internal_name =
|
||
internal_name_copy;
|
||
|
||
evidence_record->relative_path =
|
||
relative_path_copy;
|
||
|
||
evidence_record->type_identifier =
|
||
type_identifier_copy;
|
||
|
||
evidence_record->size_bytes =
|
||
size_bytes;
|
||
|
||
evidence_record->sha256 =
|
||
sha256_copy;
|
||
|
||
evidence_record->imported_at =
|
||
imported_at_copy;
|
||
|
||
evidence_record->collected_at =
|
||
collected_at_copy;
|
||
|
||
evidence_record->source =
|
||
source_copy;
|
||
|
||
evidence_record->description =
|
||
description_copy;
|
||
|
||
evidence_record->integrity_status =
|
||
integrity_status;
|
||
|
||
return evidence_record;
|
||
|
||
cleanup:
|
||
g_free(
|
||
description_copy
|
||
);
|
||
|
||
g_free(
|
||
source_copy
|
||
);
|
||
|
||
g_free(
|
||
collected_at_copy
|
||
);
|
||
|
||
g_free(
|
||
imported_at_copy
|
||
);
|
||
|
||
g_free(
|
||
sha256_copy
|
||
);
|
||
|
||
g_free(
|
||
type_identifier_copy
|
||
);
|
||
|
||
g_free(
|
||
relative_path_copy
|
||
);
|
||
|
||
g_free(
|
||
internal_name_copy
|
||
);
|
||
|
||
g_free(
|
||
original_name_copy
|
||
);
|
||
|
||
g_free(
|
||
identifier_copy
|
||
);
|
||
|
||
return NULL;
|
||
}
|
||
|
||
void evidence_record_free(
|
||
EvidenceRecord *evidence_record
|
||
)
|
||
{
|
||
if (evidence_record == NULL)
|
||
{
|
||
return;
|
||
}
|
||
|
||
g_free(
|
||
evidence_record->description
|
||
);
|
||
|
||
g_free(
|
||
evidence_record->source
|
||
);
|
||
|
||
g_free(
|
||
evidence_record->collected_at
|
||
);
|
||
|
||
g_free(
|
||
evidence_record->imported_at
|
||
);
|
||
|
||
g_free(
|
||
evidence_record->sha256
|
||
);
|
||
|
||
g_free(
|
||
evidence_record->type_identifier
|
||
);
|
||
g_free(evidence_record->type_label);
|
||
g_free(evidence_record->mime_type);
|
||
|
||
g_free(
|
||
evidence_record->relative_path
|
||
);
|
||
|
||
g_free(
|
||
evidence_record->internal_name
|
||
);
|
||
|
||
g_free(
|
||
evidence_record->original_name
|
||
);
|
||
|
||
g_free(
|
||
evidence_record->identifier
|
||
);
|
||
|
||
g_free(
|
||
evidence_record
|
||
);
|
||
}
|
||
|
||
const char *evidence_record_get_identifier(
|
||
const EvidenceRecord *evidence_record
|
||
)
|
||
{
|
||
if (evidence_record == NULL)
|
||
{
|
||
return NULL;
|
||
}
|
||
|
||
return evidence_record->identifier;
|
||
}
|
||
|
||
const char *evidence_record_get_original_name(
|
||
const EvidenceRecord *evidence_record
|
||
)
|
||
{
|
||
if (evidence_record == NULL)
|
||
{
|
||
return NULL;
|
||
}
|
||
|
||
return evidence_record->original_name;
|
||
}
|
||
|
||
const char *evidence_record_get_internal_name(
|
||
const EvidenceRecord *evidence_record
|
||
)
|
||
{
|
||
if (evidence_record == NULL)
|
||
{
|
||
return NULL;
|
||
}
|
||
|
||
return evidence_record->internal_name;
|
||
}
|
||
|
||
const char *evidence_record_get_relative_path(
|
||
const EvidenceRecord *evidence_record
|
||
)
|
||
{
|
||
if (evidence_record == NULL)
|
||
{
|
||
return NULL;
|
||
}
|
||
|
||
return evidence_record->relative_path;
|
||
}
|
||
|
||
const char *evidence_record_get_type_identifier(
|
||
const EvidenceRecord *evidence_record
|
||
)
|
||
{
|
||
if (evidence_record == NULL)
|
||
{
|
||
return NULL;
|
||
}
|
||
|
||
return evidence_record->type_identifier;
|
||
}
|
||
|
||
void evidence_record_set_display_metadata(EvidenceRecord *record,
|
||
const char *type_label, const char *mime_type)
|
||
{
|
||
if (record == NULL) return;
|
||
g_free(record->type_label);
|
||
g_free(record->mime_type);
|
||
record->type_label = g_strdup(type_label);
|
||
record->mime_type = g_strdup(mime_type);
|
||
}
|
||
|
||
const char *evidence_record_get_type_label(const EvidenceRecord *record)
|
||
{
|
||
if (record == NULL) return NULL;
|
||
return record->type_label != NULL
|
||
? record->type_label : record->type_identifier;
|
||
}
|
||
|
||
const char *evidence_record_get_mime_type(const EvidenceRecord *record)
|
||
{
|
||
return record != NULL ? record->mime_type : NULL;
|
||
}
|
||
|
||
guint64 evidence_record_get_size_bytes(
|
||
const EvidenceRecord *evidence_record
|
||
)
|
||
{
|
||
if (evidence_record == NULL)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
return evidence_record->size_bytes;
|
||
}
|
||
|
||
const char *evidence_record_get_sha256(
|
||
const EvidenceRecord *evidence_record
|
||
)
|
||
{
|
||
if (evidence_record == NULL)
|
||
{
|
||
return NULL;
|
||
}
|
||
|
||
return evidence_record->sha256;
|
||
}
|
||
|
||
const char *evidence_record_get_imported_at(
|
||
const EvidenceRecord *evidence_record
|
||
)
|
||
{
|
||
if (evidence_record == NULL)
|
||
{
|
||
return NULL;
|
||
}
|
||
|
||
return evidence_record->imported_at;
|
||
}
|
||
|
||
const char *evidence_record_get_collected_at(
|
||
const EvidenceRecord *evidence_record
|
||
)
|
||
{
|
||
if (evidence_record == NULL)
|
||
{
|
||
return NULL;
|
||
}
|
||
|
||
return evidence_record->collected_at;
|
||
}
|
||
|
||
const char *evidence_record_get_source(
|
||
const EvidenceRecord *evidence_record
|
||
)
|
||
{
|
||
if (evidence_record == NULL)
|
||
{
|
||
return NULL;
|
||
}
|
||
|
||
return evidence_record->source;
|
||
}
|
||
|
||
const char *evidence_record_get_description(
|
||
const EvidenceRecord *evidence_record
|
||
)
|
||
{
|
||
if (evidence_record == NULL)
|
||
{
|
||
return NULL;
|
||
}
|
||
|
||
return evidence_record->description;
|
||
}
|
||
|
||
EvidenceIntegrityStatus evidence_record_get_integrity_status(
|
||
const EvidenceRecord *evidence_record
|
||
)
|
||
{
|
||
if (evidence_record == NULL)
|
||
{
|
||
return EVIDENCE_INTEGRITY_STATUS_UNKNOWN;
|
||
}
|
||
|
||
return evidence_record->integrity_status;
|
||
}
|