TagNameDefinition.java

Go to the documentation of this file.

/*
 * Autopsy Forensic Browser
 *
 * Copyright 2011-2024 Basis Technology Corp.
 * Contact: carrier <at> sleuthkit <dot> org
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.sleuthkit.autopsy.casemodule.services;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.logging.Level;
import javax.annotation.concurrent.Immutable;
import org.openide.util.NbBundle.Messages;
import org.sleuthkit.autopsy.casemodule.Case;
import org.sleuthkit.autopsy.casemodule.NoCurrentCaseException;
import org.sleuthkit.autopsy.centralrepository.CentralRepoSettings;
import org.sleuthkit.autopsy.coreutils.Logger;
import org.sleuthkit.autopsy.coreutils.ModuleSettings;
import org.sleuthkit.datamodel.TagName;
import org.sleuthkit.datamodel.SleuthkitCase;
import org.sleuthkit.datamodel.TskCoreException;
import org.sleuthkit.datamodel.TskData;

@Immutable
final public class TagNameDefinition implements Comparable<TagNameDefinition> {

    private static final Logger LOGGER = Logger.getLogger(TagNameDefinition.class.getName());
    @Messages({
        "TagNameDefinition.predefTagNames.bookmark.text=Bookmark",
        "TagNameDefinition.predefTagNames.followUp.text=Follow Up",
        "TagNameDefinition.predefTagNames.notableItem.text=Notable Item",})

    private static final String TAGS_SETTINGS_NAME = "Tags"; //NON-NLS
    private static final String TAG_NAMES_SETTING_KEY = "TagNames"; //NON-NLS 
    private static final String TAG_SETTING_VERSION_KEY = "CustomTagNameVersion";
    private static final int TAG_SETTINGS_VERSION = 2; // Changed tag type from TskData.FileKnown to TskData.TagType

    private final String displayName;
    private final String description;
    private final TagName.HTML_COLOR color;
    private final TskData.TagType tagType;

    private static final List<TagNameDefinition> STANDARD_TAGS_DEFINITIONS = new ArrayList<>();
    private static final List<String> PROJECT_VIC_NAMES_NO_LONGER_USED = new ArrayList<>();

    static {
        STANDARD_TAGS_DEFINITIONS.add(new TagNameDefinition(Bundle.TagNameDefinition_predefTagNames_bookmark_text(), "", TagName.HTML_COLOR.NONE, TskData.TagType.SUSPICIOUS));
        STANDARD_TAGS_DEFINITIONS.add(new TagNameDefinition(Bundle.TagNameDefinition_predefTagNames_followUp_text(), "", TagName.HTML_COLOR.NONE, TskData.TagType.SUSPICIOUS));
        STANDARD_TAGS_DEFINITIONS.add(new TagNameDefinition(Bundle.TagNameDefinition_predefTagNames_notableItem_text(), "", TagName.HTML_COLOR.NONE, TskData.TagType.BAD));

        PROJECT_VIC_NAMES_NO_LONGER_USED.add("CAT-1: Child Exploitation (Illegal)");
        PROJECT_VIC_NAMES_NO_LONGER_USED.add("CAT-2: Child Exploitation (Non-Illegal/Age Difficult)");
        PROJECT_VIC_NAMES_NO_LONGER_USED.add("CAT-3: CGI/Animation (Child Exploitive)");
        PROJECT_VIC_NAMES_NO_LONGER_USED.add("CAT-4: Exemplar/Comparison (Internal Use Only)");
        PROJECT_VIC_NAMES_NO_LONGER_USED.add("CAT-5: Non-pertinent");
        PROJECT_VIC_NAMES_NO_LONGER_USED.add("CAT-0: Uncategorized");
    }

    @Deprecated
    public TagNameDefinition(String displayName, String description, TagName.HTML_COLOR color, TskData.FileKnown status) {
        this.displayName = displayName;
        this.description = description;
        this.color = color;
        this.tagType = TskData.TagType.convertFileKnownToTagType(status);
    }
    
    public TagNameDefinition(String displayName, String description, TagName.HTML_COLOR color, TskData.TagType status) {
        this.displayName = displayName;
        this.description = description;
        this.color = color;
        this.tagType = status;
    }

    static Collection<TagNameDefinition> getStandardTagNameDefinitions() {
        return Collections.unmodifiableCollection(STANDARD_TAGS_DEFINITIONS);
    }

    static List<String> getStandardTagNames() {
        List<String> strList = new ArrayList<>();

        for (TagNameDefinition def : STANDARD_TAGS_DEFINITIONS) {
            strList.add(def.getDisplayName());
        }

        return strList;
    }

    static String getBookmarkTagDisplayName() {
        return Bundle.TagNameDefinition_predefTagNames_bookmark_text();
    }

    static String getFollowUpTagDisplayName() {
        return Bundle.TagNameDefinition_predefTagNames_followUp_text();
    }

    static String getNotableTagDisplayName() {
        return Bundle.TagNameDefinition_predefTagNames_notableItem_text();
    }

    public String getDisplayName() {
        return displayName;
    }

    public String getDescription() {
        return description;
    }

    public TagName.HTML_COLOR getColor() {
        return color;
    }

    public TskData.TagType getTagType() {
        return tagType;
    }
    
    @Deprecated
    public TskData.FileKnown getKnownStatus() {
        return TskData.TagType.convertTagTypeToFileKnown(tagType);
    }

    @Override
    public int compareTo(TagNameDefinition other) {
        return this.getDisplayName().toLowerCase().compareTo(other.getDisplayName().toLowerCase());
    }

    @Override
    public int hashCode() {
        int hash = 7;
        hash = 83 * hash + Objects.hashCode(this.displayName);
        return hash;
    }

    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof TagNameDefinition)) {
            return false;
        }
        boolean sameName = this.getDisplayName().equals(((TagNameDefinition) obj).getDisplayName());
        boolean sameStatus = this.getTagType().equals(((TagNameDefinition) obj).getTagType());
        return sameName && sameStatus;
    }

    @Override
    public String toString() {
        return displayName;
    }

    private String toSettingsFormat() {
        return displayName + "," + description + "," + color.name() + "," + tagType.toString();
    }

    TagName saveToCase(SleuthkitCase caseDb) {
        TagName tagName = null;
        try {
            tagName = caseDb.getTaggingManager().addOrUpdateTagName(displayName, description, color, tagType);
        } catch (TskCoreException ex) {
            LOGGER.log(Level.SEVERE, "Error saving tag name definition", ex);
        }
        return tagName;
    }

    static synchronized Set<TagNameDefinition> getTagNameDefinitions() {
        if (needsVersionUpdate()) {
            updatePropertyFile();
        }

        String tagsProperty = ModuleSettings.getConfigSetting(TAGS_SETTINGS_NAME, TAG_NAMES_SETTING_KEY);
        if (tagsProperty == null || tagsProperty.isEmpty()) {
            return new HashSet<>();
        }

        List<String> individualTags = Arrays.asList(tagsProperty.split(";"));

        if (individualTags == null || individualTags.isEmpty()) {
            return new HashSet<>();
        }

        Set<TagNameDefinition> definitions = new HashSet<>();
        for (String tagProps : individualTags) {
            String[] attributes = tagProps.split(",");

            definitions.add(new TagNameDefinition(attributes[0], attributes[1],
                    TagName.HTML_COLOR.valueOf(attributes[2]), TskData.TagType.valueOf(attributes[3])));
        }

        return definitions;
    }

    static synchronized void setTagNameDefinitions(Set<TagNameDefinition> tagNames) {
        StringBuilder setting = new StringBuilder();
        for (TagNameDefinition tagName : tagNames) {
            if (setting.length() != 0) {
                setting.append(";");
            }
            setting.append(tagName.toSettingsFormat());
            try {
                SleuthkitCase caseDb = Case.getCurrentCaseThrows().getSleuthkitCase();
                tagName.saveToCase(caseDb);
            } catch (NoCurrentCaseException ex) {
                LOGGER.log(Level.SEVERE, "Exception while getting open case.", ex);
            }
        }

        ModuleSettings.setConfigSetting(TAGS_SETTINGS_NAME, TAG_SETTING_VERSION_KEY, Integer.toString(TAG_SETTINGS_VERSION));
        ModuleSettings.setConfigSetting(TAGS_SETTINGS_NAME, TAG_NAMES_SETTING_KEY, setting.toString());
    }

    private static void updatePropertyFile() {
        Integer version = getPropertyFileVersion();
        List<TagNameDefinition> definitions = new ArrayList<>();

        if (version == null || version == 1) {
            String tagsProperty = ModuleSettings.getConfigSetting(TAGS_SETTINGS_NAME, TAG_NAMES_SETTING_KEY);
            if (tagsProperty == null || tagsProperty.isEmpty()) {
                ModuleSettings.setConfigSetting(TAGS_SETTINGS_NAME, TAG_SETTING_VERSION_KEY, Integer.toString(TAG_SETTINGS_VERSION));
                return;
            }

            List<String> individualTags = Arrays.asList(tagsProperty.split(";"));

            if (individualTags == null || individualTags.isEmpty()) {
                return;
            }

            List<String> notableTagList = null;
            for (String tagProps : individualTags) {
                String[] attributes = tagProps.split(",");
                TskData.TagType tagType = TskData.TagType.SUSPICIOUS;
                if (attributes.length == 3) {
                    // If notableTagList is null load it from the CR.
                    if (notableTagList == null) {
                        notableTagList = getCRNotableList();
                    } else {
                        if (notableTagList.contains(attributes[0])) {
                            tagType = TskData.TagType.BAD;
                        }
                    }
                } else {
                    if (version == 1) {
                        // handle backwards compatibility
                        tagType = TskData.TagType.convertFileKnownToTagType(TskData.FileKnown.valueOf(attributes[3]));
                    } else {
                        tagType = TskData.TagType.valueOf(attributes[3]);
                    }
                }

                definitions.add(new TagNameDefinition(attributes[0], attributes[1],
                        TagName.HTML_COLOR.valueOf(attributes[2]), tagType));
            }
        }

        if (definitions.isEmpty()) {
            return;
        }

        // Remove the standard and Project VIC tags from the list
        List<String> tagStringsToKeep = new ArrayList<>();
        List<String> standardTags = getStandardTagNames();
        for (TagNameDefinition def : definitions) {
            if (!standardTags.contains(def.getDisplayName())
                    && !PROJECT_VIC_NAMES_NO_LONGER_USED.contains(def.getDisplayName())) {
                tagStringsToKeep.add(def.toSettingsFormat());
            }
        }

        // Write out the version and the new tag list.
        ModuleSettings.setConfigSetting(TAGS_SETTINGS_NAME, TAG_SETTING_VERSION_KEY, Integer.toString(TAG_SETTINGS_VERSION));
        ModuleSettings.setConfigSetting(TAGS_SETTINGS_NAME, TAG_NAMES_SETTING_KEY, String.join(";", tagStringsToKeep));
    }

    private static List<String> getCRNotableList() {
        String notableTagsProp = ModuleSettings.getConfigSetting(CentralRepoSettings.getInstance().getModuleSettingsKey(), "db.badTags"); // NON-NLS
        if (notableTagsProp != null && !notableTagsProp.isEmpty()) {
            return Arrays.asList(notableTagsProp.split(","));
        }

        return new ArrayList<>();
    }

    private static boolean needsVersionUpdate() {
        Integer version = getPropertyFileVersion();
        return version == null || version < TAG_SETTINGS_VERSION;
    }

    private static Integer getPropertyFileVersion() {
        String version = ModuleSettings.getConfigSetting(TAGS_SETTINGS_NAME, TAG_SETTING_VERSION_KEY);
        if (version == null || version.isEmpty()) {
            return null;
        }

        try {
            return Integer.parseInt(version);
        } catch (NumberFormatException ex) {
            // The version is not an integer
            return null;
        }
    }

}