From dba86cd11e70b8ce8651a2c14c5553d1024c1e55 Mon Sep 17 00:00:00 2001 From: Andrew Ziehl Date: Wed, 27 Jun 2018 12:01:30 -0700 Subject: [PATCH] added callback and wrapper to process single row of file instance table by id. --- .../datamodel/AbstractSqlEamDb.java | 40 ++++++++++ .../centralrepository/datamodel/EamDb.java | 12 ++- .../datamodel/SqliteEamDb.java | 19 +++++ .../EamDbAttributeInstancesAlgorithm.java | 75 ++++++++++++++++--- 4 files changed, 134 insertions(+), 12 deletions(-) diff --git a/Core/src/org/sleuthkit/autopsy/centralrepository/datamodel/AbstractSqlEamDb.java b/Core/src/org/sleuthkit/autopsy/centralrepository/datamodel/AbstractSqlEamDb.java index 898dd22d16..9a12af9666 100644 --- a/Core/src/org/sleuthkit/autopsy/centralrepository/datamodel/AbstractSqlEamDb.java +++ b/Core/src/org/sleuthkit/autopsy/centralrepository/datamodel/AbstractSqlEamDb.java @@ -1778,6 +1778,46 @@ abstract class AbstractSqlEamDb implements EamDb { } } + /** + * Process the Artifact instance in the EamDb + * + * @param type EamArtifact.Type to search for + * @param instanceTableCallback callback to process the instance + * @throws EamDbException + */ + @Override + public void processInstanceTableRow(CorrelationAttribute.Type type, int id, InstanceTableCallback instanceTableCallback) throws EamDbException { + if (type == null) { + throw new EamDbException("Correlation type is null"); + } + + if (instanceTableCallback == null) { + throw new EamDbException("Callback interface is null"); + } + + Connection conn = connect(); + PreparedStatement preparedStatement = null; + ResultSet resultSet = null; + String tableName = EamDbUtil.correlationTypeToInstanceTableName(type); + StringBuilder sql = new StringBuilder(); + sql.append("select * from "); + sql.append(tableName); + sql.append("WHERE id = ?"); + + try { + preparedStatement = conn.prepareStatement(sql.toString()); + preparedStatement.setInt(1, id); + resultSet = preparedStatement.executeQuery(); + instanceTableCallback.process(resultSet); + } catch (SQLException ex) { + throw new EamDbException("Error getting all artifact instances from instances table", ex); + } finally { + EamDbUtil.closeStatement(preparedStatement); + EamDbUtil.closeResultSet(resultSet); + EamDbUtil.closeConnection(conn); + } + } + /** * Process the Artifact instance in the EamDb * diff --git a/Core/src/org/sleuthkit/autopsy/centralrepository/datamodel/EamDb.java b/Core/src/org/sleuthkit/autopsy/centralrepository/datamodel/EamDb.java index 59e87ab023..287970d42f 100644 --- a/Core/src/org/sleuthkit/autopsy/centralrepository/datamodel/EamDb.java +++ b/Core/src/org/sleuthkit/autopsy/centralrepository/datamodel/EamDb.java @@ -686,6 +686,16 @@ public interface EamDb { */ void processInstanceTable(CorrelationAttribute.Type type, InstanceTableCallback instanceTableCallback) throws EamDbException; + /** + * Process a single Artifact instance in the EamDb + * + * @param type EamArtifact.Type to search for + * @param id the id of the row to return + * @param instanceTableCallback callback to process the instance + * @throws EamDbException + */ + void processInstanceTableRow(CorrelationAttribute.Type type, int id, InstanceTableCallback instanceTableCallback) throws EamDbException; + /** * Process the Artifact md5s in the EamDb for matches of case files which are not known * @param type EamArtifact.Type to search for @@ -693,5 +703,5 @@ public interface EamDb { * @param instanceTableCallback callback to process the instance * @throws EamDbException */ - public void processCaseInstancesTable(CorrelationAttribute.Type type, CorrelationCase correlationCase, InstanceTableCallback instanceTableCallback) throws EamDbException; + void processCaseInstancesTable(CorrelationAttribute.Type type, CorrelationCase correlationCase, InstanceTableCallback instanceTableCallback) throws EamDbException; } diff --git a/Core/src/org/sleuthkit/autopsy/centralrepository/datamodel/SqliteEamDb.java b/Core/src/org/sleuthkit/autopsy/centralrepository/datamodel/SqliteEamDb.java index e9852f2d34..3335d825f0 100644 --- a/Core/src/org/sleuthkit/autopsy/centralrepository/datamodel/SqliteEamDb.java +++ b/Core/src/org/sleuthkit/autopsy/centralrepository/datamodel/SqliteEamDb.java @@ -695,6 +695,25 @@ final class SqliteEamDb extends AbstractSqlEamDb { releaseSharedLock(); } } + + /** + * Process a single Artifact instance row in the EamDb + * + * @param type EamArtifact.Type to search for + * @param id the id of the row to return + * @param instanceTableCallback callback to process the instance + * @throws EamDbException + */ + @Override + public void processInstanceTableRow(CorrelationAttribute.Type type, int id, InstanceTableCallback instanceTableCallback) throws EamDbException { + try { + acquireSharedLock(); + super.processInstanceTableRow(type, id, instanceTableCallback); + } finally { + releaseSharedLock(); + } + } + /** * Process the Artifact md5s in the EamDb for matches of case files which are not known * @param type EamArtifact.Type to search for diff --git a/Core/src/org/sleuthkit/autopsy/commonfilesearch/EamDbAttributeInstancesAlgorithm.java b/Core/src/org/sleuthkit/autopsy/commonfilesearch/EamDbAttributeInstancesAlgorithm.java index 73759acff4..c492c43cfb 100644 --- a/Core/src/org/sleuthkit/autopsy/commonfilesearch/EamDbAttributeInstancesAlgorithm.java +++ b/Core/src/org/sleuthkit/autopsy/commonfilesearch/EamDbAttributeInstancesAlgorithm.java @@ -27,27 +27,46 @@ import java.util.logging.Level; import org.openide.util.Exceptions; import org.sleuthkit.autopsy.casemodule.Case; import org.sleuthkit.autopsy.centralrepository.datamodel.CorrelationAttribute; +import org.sleuthkit.autopsy.centralrepository.datamodel.CorrelationCase; import org.sleuthkit.autopsy.centralrepository.datamodel.EamDb; import org.sleuthkit.autopsy.centralrepository.datamodel.EamDbException; import org.sleuthkit.autopsy.centralrepository.datamodel.InstanceTableCallback; import org.sleuthkit.autopsy.coreutils.Logger; /** - * Used to process and return CorrelationCase md5s from the EamDB for CommonFilesSearch. + * Used to process and return CorrelationCase md5s from the EamDB for + * CommonFilesSearch. */ class EamDbAttributeInstancesAlgorithm { private static final Logger logger = Logger.getLogger(CommonFilesPanel.class.getName()); + + private final Map intercaseCommonValuesMap = new HashMap<>(); + private final Map intercaseCommonDatasourcesMap = new HashMap<>(); - private final Map intercaseCommonValuesMap = new HashMap<>(); - private final Map intercaseCommonDatasourcesMap = new HashMap<>(); - - void processCorrelationCaseAttributeValues(Case currentCase) { + CorrelationAttribute processCorrelationCaseSingleAttribute(int attrbuteId) { + try { + EamDbAttributeInstanceRowCallback instancetableCallback = new EamDbAttributeInstanceRowCallback(); + EamDb DbManager = EamDb.getInstance(); + CorrelationAttribute.Type fileType = DbManager.getCorrelationTypeById(CorrelationAttribute.FILES_TYPE_ID); + DbManager.processInstanceTableRow(fileType, attrbuteId, instancetableCallback); + + return instancetableCallback.getCorrelationAttribute(); + + } catch (EamDbException ex) { + logger.log(Level.SEVERE, "Error accessing EamDb processing InstanceTable row.", ex); + } + + return null; + } + + void processCorrelationCaseAttributeValues(Case currentCase) { + try { EamDbAttributeInstancesCallback instancetableCallback = new EamDbAttributeInstancesCallback(); EamDb DbManager = EamDb.getInstance(); - CorrelationAttribute.Type fileType = EamDb.getInstance().getCorrelationTypeById(CorrelationAttribute.FILES_TYPE_ID); + CorrelationAttribute.Type fileType = DbManager.getCorrelationTypeById(CorrelationAttribute.FILES_TYPE_ID); DbManager.processCaseInstancesTable(fileType, DbManager.getCase(currentCase), instancetableCallback); intercaseCommonValuesMap.putAll(instancetableCallback.getCorrelationIdValueMap()); @@ -55,14 +74,14 @@ class EamDbAttributeInstancesAlgorithm { } catch (EamDbException ex) { logger.log(Level.SEVERE, "Error accessing EamDb processing CaseInstancesTable.", ex); } - + } - + Map getIntercaseCommonValuesMap() { return Collections.unmodifiableMap(intercaseCommonValuesMap); } - - Map getIntercaseCommonDatasourcesMap() { + + Map getIntercaseCommonDatasourcesMap() { return Collections.unmodifiableMap(intercaseCommonDatasourcesMap); } @@ -91,10 +110,44 @@ class EamDbAttributeInstancesAlgorithm { Map getCorrelationIdValueMap() { return Collections.unmodifiableMap(correlationIdToValueMap); } - + Map getCorrelationIdDatasourceMap() { return Collections.unmodifiableMap(correlationIdToDatasourceMap); } } + + /** + * Callback to use with processCaseInstancesTable which generates a list of + * md5s for common files search + */ + private class EamDbAttributeInstanceRowCallback implements InstanceTableCallback { + + CorrelationAttribute correlationAttribute = null; + + @Override + public void process(ResultSet resultSet) { + try { + EamDb DbManager = EamDb.getInstance(); + CorrelationAttribute.Type fileType = DbManager.getCorrelationTypeById(CorrelationAttribute.FILES_TYPE_ID); + + while (resultSet.next()) { + CorrelationCase correlationCase = DbManager.getCaseByUUID(String.valueOf(InstanceTableCallback.getCaseId(resultSet))); + correlationAttribute = DbManager.getCorrelationAttribute(fileType, + correlationCase, + DbManager.getDataSource(correlationCase, String.valueOf(InstanceTableCallback.getDataSourceId(resultSet))), + InstanceTableCallback.getValue(resultSet), + InstanceTableCallback.getFilePath(resultSet)); + + } + } catch (SQLException | EamDbException ex) { + Exceptions.printStackTrace(ex); + } + } + + CorrelationAttribute getCorrelationAttribute() { + return correlationAttribute; + } + + } }