TagsManager.java

Go to the documentation of this file.

/*
 * Autopsy Forensic Browser
 *
 * Copyright 2013-2020 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.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.io.Closeable;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.logging.Level;
import org.openide.util.NbBundle;
import org.openide.util.WeakListeners;
import org.sleuthkit.autopsy.casemodule.Case;
import org.sleuthkit.autopsy.casemodule.NoCurrentCaseException;
import org.sleuthkit.autopsy.casemodule.events.TagNamesEvent;
import org.sleuthkit.autopsy.casemodule.events.TagNamesEvent.TagNamesDeletedEvent;
import org.sleuthkit.autopsy.casemodule.services.contentviewertags.ContentViewerTagManager;
import org.sleuthkit.autopsy.coreutils.Logger;
import org.sleuthkit.datamodel.BlackboardArtifact;
import org.sleuthkit.datamodel.BlackboardArtifactTag;
import org.sleuthkit.datamodel.CaseDbAccessManager;
import org.sleuthkit.datamodel.Content;
import org.sleuthkit.datamodel.ContentTag;
import org.sleuthkit.datamodel.SleuthkitCase;
import org.sleuthkit.datamodel.TagName;
import org.sleuthkit.datamodel.TagSet;
import org.sleuthkit.datamodel.TaggingManager;
import org.sleuthkit.datamodel.TskCoreException;
import org.sleuthkit.datamodel.TskData;
import org.sleuthkit.datamodel.TskData.DbType;

public class TagsManager implements Closeable {

    private static final Logger LOGGER = Logger.getLogger(TagsManager.class.getName());
    private final SleuthkitCase caseDb;

    // NOTE: This name is also hard coded in Image Gallery and Projet Vic module. 
    // They need to stay in sync
    private static String PROJECT_VIC_TAG_SET_NAME = "Project VIC";

    private static final Object lock = new Object();
    
    private final Map<String, TagName> allTagNameMap = Collections.synchronizedMap(new HashMap<>());
    
    private final PropertyChangeListener listener = new PropertyChangeListener() {
        @Override
        public void propertyChange(PropertyChangeEvent evt) {
            if (evt.getPropertyName().equals(Case.Events.TAG_NAMES_ADDED.name())
                    || evt.getPropertyName().equals(Case.Events.TAG_NAMES_UPDATED.name())) {
                TagNamesEvent tagEvent = (TagNamesEvent) evt;
                List<TagName> addTagNames = tagEvent.getTagNames();
                for (TagName tag : addTagNames) {
                    allTagNameMap.put(tag.getDisplayName(), tag);
                }
            } else if (evt.getPropertyName().equals(Case.Events.TAG_NAMES_DELETED.name())) {
                TagNamesDeletedEvent tagEvent = (TagNamesDeletedEvent) evt;
                List<Long> deletedIds = tagEvent.getTagNameIds();
                List<String> keysToRemove = new ArrayList<>();
                for (TagName tagName : getAllTagNames()) {
                    if (deletedIds.contains(tagName.getId())) {
                        keysToRemove.add(tagName.getDisplayName());
                    }
                }

                for (String key : keysToRemove) {
                    allTagNameMap.remove(key);
                }
            }
        }
    };
    
    private final PropertyChangeListener weakListener = WeakListeners.propertyChange(listener, null);

    static {

        //Create the contentviewer tags table if the current case does not 
        //have the table present
        Case.addEventTypeSubscriber(EnumSet.of(Case.Events.CURRENT_CASE), evt -> {
            if (evt.getNewValue() != null) {
                Case currentCase = (Case) evt.getNewValue();
                try {
                    CaseDbAccessManager caseDb = currentCase.getSleuthkitCase().getCaseDbAccessManager();
                    if (caseDb.tableExists(ContentViewerTagManager.TABLE_NAME)) {
                        return;
                    }

                    if (currentCase.getSleuthkitCase().getDatabaseType().equals(DbType.SQLITE)) {
                        caseDb.createTable(ContentViewerTagManager.TABLE_NAME, ContentViewerTagManager.TABLE_SCHEMA_SQLITE);
                    } else if (currentCase.getSleuthkitCase().getDatabaseType().equals(DbType.POSTGRESQL)) {
                        caseDb.createTable(ContentViewerTagManager.TABLE_NAME, ContentViewerTagManager.TABLE_SCHEMA_POSTGRESQL);
                    }
                } catch (TskCoreException ex) {
                    LOGGER.log(Level.SEVERE,
                            String.format("Unable to create the %s table for image tag storage.",
                                    ContentViewerTagManager.TABLE_NAME), ex);
                }
            }
        });
    }

    public static boolean containsIllegalCharacters(String tagDisplayName) {
        return (tagDisplayName.contains("\\")
                || tagDisplayName.contains(":")
                || tagDisplayName.contains("*")
                || tagDisplayName.contains("?")
                || tagDisplayName.contains("\"")
                || tagDisplayName.contains("<")
                || tagDisplayName.contains(">")
                || tagDisplayName.contains("|")
                || tagDisplayName.contains(",")
                || tagDisplayName.contains(";"));

    }

    @NbBundle.Messages({"TagsManager.notableTagEnding.text= (Notable)"})
    public static String getNotableTagLabel() {
        return Bundle.TagsManager_notableTagEnding_text();
    }

    public static Set<String> getTagDisplayNames() throws TskCoreException {
        Set<String> tagDisplayNames = new HashSet<>();
        Set<TagNameDefinition> customNames = TagNameDefinition.getTagNameDefinitions();
        customNames.forEach((tagType) -> {
            tagDisplayNames.add(tagType.getDisplayName());
        });
        try {
            TagsManager tagsManager = Case.getCurrentCaseThrows().getServices().getTagsManager();
            for (TagName tagName : tagsManager.getAllTagNames()) {
                tagDisplayNames.add(tagName.getDisplayName());
            }
        } catch (NoCurrentCaseException ignored) {
            /*
             * No current case, nothing more to add to the set.
             */
        }
        return tagDisplayNames;
    }

    public static List<String> getNotableTagDisplayNames() {
        List<String> tagDisplayNames = new ArrayList<>();
        for (TagNameDefinition tagDef : TagNameDefinition.getTagNameDefinitions()) {
            if (tagDef.getTagType() == TskData.TagType.BAD) {
                tagDisplayNames.add(tagDef.getDisplayName());
            }
        }

        try {
            TagsManager tagsManager = Case.getCurrentCaseThrows().getServices().getTagsManager();
            for (TagName tagName : tagsManager.getAllTagNames()) {
                if (tagName.getTagType() == TskData.TagType.BAD
                        && !tagDisplayNames.contains(tagName.getDisplayName())) {
                    tagDisplayNames.add(tagName.getDisplayName());
                }
            }
        } catch (NoCurrentCaseException ignored) {
            /*
             * No current case, nothing more to add to the set.
             */
        }
        return tagDisplayNames;
    }

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

        for (TagNameDefinition tagNameDef : TagNameDefinition.getStandardTagNameDefinitions()) {
            tagList.add(tagNameDef.getDisplayName());
        }

        try {
            List<TagSet> tagSetList = Case.getCurrentCaseThrows().getSleuthkitCase().getTaggingManager().getTagSets();
            for (TagSet tagSet : tagSetList) {
                if (tagSet.getName().equals(PROJECT_VIC_TAG_SET_NAME)) {
                    for (TagName tagName : tagSet.getTagNames()) {
                        tagList.add(tagName.getDisplayName());
                    }
                }
            }
        } catch (NoCurrentCaseException | TskCoreException ex) {
            LOGGER.log(Level.SEVERE, "Failed to get Project VIC tags from the database.", ex);
        }

        return tagList;
    }

    public static String getBookmarkTagDisplayName() {
        return TagNameDefinition.getBookmarkTagDisplayName();
    }

    public static String getFollowUpTagDisplayName() {
        return TagNameDefinition.getFollowUpTagDisplayName();
    }

    public static String getNotableTagDisplayName() {
        return TagNameDefinition.getNotableTagDisplayName();
    }

    public static void addTagSetDefinition(TagSetDefinition tagSetDef) throws IOException {
        synchronized (lock) {
            TagSetDefinition.writeTagSetDefinition(tagSetDef);
        }
    }

    TagsManager(SleuthkitCase caseDb) {
        this.caseDb = caseDb;

        // Add standard tags and any configured tag sets.
        TaggingManager taggingMgr = caseDb.getTaggingManager();
        try {
            List<TagSet> tagSetsInCase = taggingMgr.getTagSets();
            if (tagSetsInCase.isEmpty()) {
                
                // add the standard tag names
                for (TagNameDefinition def : TagNameDefinition.getStandardTagNameDefinitions()) {
                    taggingMgr.addOrUpdateTagName(def.getDisplayName(), def.getDescription(), def.getColor(), def.getTagType());
                }
                
                //Assume new case and add all tag sets
                for (TagSetDefinition setDef : TagSetDefinition.readTagSetDefinitions()) {
                    List<TagName> tagNamesInSet = new ArrayList<>();
                    for (TagNameDefinition tagNameDef : setDef.getTagNameDefinitions()) {
                        tagNamesInSet.add(taggingMgr.addOrUpdateTagName(tagNameDef.getDisplayName(), tagNameDef.getDescription(), tagNameDef.getColor(), tagNameDef.getTagType()));
                    }

                    if (!tagNamesInSet.isEmpty()) {
                        taggingMgr.addTagSet(setDef.getName(), tagNamesInSet);
                    }
                }
            }         

            for(TagName tagName: caseDb.getAllTagNames()) {
                allTagNameMap.put(tagName.getDisplayName(), tagName);
            }
            
        } catch (TskCoreException ex) {
            LOGGER.log(Level.SEVERE, "Error updating standard tag name and tag set definitions", ex);
        } catch (IOException ex) {
            LOGGER.log(Level.SEVERE, "Error loading tag set JSON files", ex);
        }

        for (TagNameDefinition tagName : TagNameDefinition.getTagNameDefinitions()) {
            tagName.saveToCase(caseDb);
        }
        
        Case.addEventTypeSubscriber(Collections.singleton(Case.Events.TAG_NAMES_UPDATED), weakListener);
        Case.addEventTypeSubscriber(Collections.singleton(Case.Events.TAG_NAMES_ADDED), weakListener);
        Case.addEventTypeSubscriber(Collections.singleton(Case.Events.TAG_NAMES_DELETED), weakListener);
    }

    public List<TagSet> getAllTagSets() throws TskCoreException {
        return caseDb.getTaggingManager().getTagSets();
    }

    public TagSet getTagSet(TagName tagName) throws TskCoreException {
        return caseDb.getTaggingManager().getTagSet(tagName);        
    }

    public TagSet addTagSet(String name, List<TagName> tagNameList) throws TskCoreException {
        return caseDb.getTaggingManager().addTagSet(name, tagNameList);
    }

    public synchronized List<TagName> getAllTagNames() {
        
        List<TagName> tagNames = new ArrayList<>();
        tagNames.addAll(allTagNameMap.values());
        return tagNames;
    }

    public List<TagName> getTagNamesInUse() throws TskCoreException {
        return caseDb.getTagNamesInUse();
    }

    public List<TagName> getTagNamesInUseForUser(String userName) throws TskCoreException {
        Set<TagName> tagNameSet = new HashSet<>();
        List<BlackboardArtifactTag> artifactTags = caseDb.getAllBlackboardArtifactTags();
        for (BlackboardArtifactTag tag : artifactTags) {
            if (tag.getUserName().equals(userName)) {
                tagNameSet.add(tag.getName());
            }
        }
        List<ContentTag> contentTags = caseDb.getAllContentTags();
        for (ContentTag tag : contentTags) {
            if (tag.getUserName().equals(userName)) {
                tagNameSet.add(tag.getName());
            }
        }
        return new ArrayList<>(tagNameSet);
    }

    public List<TagName> getTagNamesInUse(long dsObjId) throws TskCoreException {
        return caseDb.getTagNamesInUse(dsObjId);
    }

    public List<TagName> getTagNamesInUseForUser(long dsObjId, String userName) throws TskCoreException {
        Set<TagName> tagNameSet = new HashSet<>();
        List<BlackboardArtifactTag> artifactTags = caseDb.getAllBlackboardArtifactTags();
        for (BlackboardArtifactTag tag : artifactTags) {
            if (tag.getUserName().equals(userName) && tag.getArtifact().getDataSource().getId() == dsObjId) {
                tagNameSet.add(tag.getName());
            }
        }
        List<ContentTag> contentTags = caseDb.getAllContentTags();
        for (ContentTag tag : contentTags) {
            if (tag.getUserName().equals(userName) && tag.getContent().getDataSource().getId() == dsObjId) {
                tagNameSet.add(tag.getName());
            }
        }
        return new ArrayList<>(tagNameSet);
    }

    public Map<String, TagName> getDisplayNamesToTagNamesMap() throws TskCoreException {
        Map<String, TagName> tagNames = new HashMap<>();
        for (TagName tagName : getAllTagNames()) {
            tagNames.put(tagName.getDisplayName(), tagName);
        }
        return tagNames;
    }

    public TagName addTagName(String displayName) throws TagNameAlreadyExistsException, TskCoreException {
        return addTagName(displayName, "", TagName.HTML_COLOR.NONE, TskData.TagType.SUSPICIOUS);
    }

    public TagName addTagName(String displayName, String description) throws TagNameAlreadyExistsException, TskCoreException {
        return addTagName(displayName, description, TagName.HTML_COLOR.NONE, TskData.TagType.SUSPICIOUS);
    }

    public TagName addTagName(String displayName, String description, TagName.HTML_COLOR color) throws TagNameAlreadyExistsException, TskCoreException {
        return addTagName(displayName, description, color, TskData.TagType.SUSPICIOUS);
    }
    
    @Deprecated
    public TagName addTagName(String displayName, String description, TagName.HTML_COLOR color, TskData.FileKnown knownStatus) throws TagNameAlreadyExistsException, TskCoreException {
        return addTagName(displayName, description, color, TskData.TagType.convertFileKnownToTagType(knownStatus));
    }

    public TagName addTagName(String displayName, String description, TagName.HTML_COLOR color, TskData.TagType tagType) throws TagNameAlreadyExistsException, TskCoreException {
        synchronized (lock) {
            try {
                TagName tagName = caseDb.getTaggingManager().addOrUpdateTagName(displayName, description, color, tagType);
                Set<TagNameDefinition> customTypes = TagNameDefinition.getTagNameDefinitions();
                customTypes.add(new TagNameDefinition(displayName, description, color, tagType));
                TagNameDefinition.setTagNameDefinitions(customTypes);
                return tagName;
            } catch (TskCoreException ex) {
                List<TagName> existingTagNames = getAllTagNames();
                for (TagName tagName : existingTagNames) {
                    if (tagName.getDisplayName().equals(displayName)) {
                        throw new TagNameAlreadyExistsException();
                    }
                }
                throw ex;
            }
        }
    }

    public ContentTag addContentTag(Content content, TagName tagName) throws TskCoreException {
        return addContentTag(content, tagName, "", -1, -1);
    }

    public ContentTag addContentTag(Content content, TagName tagName, String comment) throws TskCoreException {
        return addContentTag(content, tagName, comment, -1, -1);
    }

    public ContentTag addContentTag(Content content, TagName tagName, String comment, long beginByteOffset, long endByteOffset) throws TskCoreException {
        TaggingManager.ContentTagChange tagChange = caseDb.getTaggingManager().addContentTag(content, tagName, comment, beginByteOffset, endByteOffset);
        try {
            Case currentCase = Case.getCurrentCaseThrows();

            currentCase.notifyContentTagAdded(tagChange.getAddedTag(), tagChange.getRemovedTags().isEmpty() ? null : tagChange.getRemovedTags());

        } catch (NoCurrentCaseException ex) {
            throw new TskCoreException("Added a tag to a closed case", ex);
        }
        return tagChange.getAddedTag();
    }

    public void deleteContentTag(ContentTag tag) throws TskCoreException {
        caseDb.deleteContentTag(tag);
        try {
            Case.getCurrentCaseThrows().notifyContentTagDeleted(tag);
        } catch (NoCurrentCaseException ex) {
            throw new TskCoreException("Deleted a tag from a closed case", ex);
        }
    }

    public List<ContentTag> getAllContentTags() throws TskCoreException {
        return caseDb.getAllContentTags();
    }

    public long getContentTagsCountByTagName(TagName tagName) throws TskCoreException {
        return caseDb.getContentTagsCountByTagName(tagName);
    }

    public long getContentTagsCountByTagNameForUser(TagName tagName, String userName) throws TskCoreException {
        long count = 0;
        List<ContentTag> contentTags = getContentTagsByTagName(tagName);
        for (ContentTag tag : contentTags) {
            if (userName.equals(tag.getUserName())) {
                count++;
            }
        }
        return count;
    }

    public long getContentTagsCountByTagName(TagName tagName, long dsObjId) throws TskCoreException {
        return caseDb.getContentTagsCountByTagName(tagName, dsObjId);
    }

    public long getContentTagsCountByTagNameForUser(TagName tagName, long dsObjId, String userName) throws TskCoreException {
        long count = 0;
        List<ContentTag> contentTags = getContentTagsByTagName(tagName, dsObjId);
        for (ContentTag tag : contentTags) {
            if (userName.equals(tag.getUserName())) {
                count++;
            }
        }
        return count;
    }

    public ContentTag getContentTagByTagID(long tagId) throws TskCoreException {
        return caseDb.getContentTagByID(tagId);
    }

    public List<ContentTag> getContentTagsByTagName(TagName tagName) throws TskCoreException {
        return caseDb.getContentTagsByTagName(tagName);
    }

    public List<ContentTag> getContentTagsByTagName(TagName tagName, long dsObjId) throws TskCoreException {
        return caseDb.getContentTagsByTagName(tagName, dsObjId);
    }

    public List<ContentTag> getContentTagsByContent(Content content) throws TskCoreException {
        return caseDb.getContentTagsByContent(content);
    }

    public BlackboardArtifactTag addBlackboardArtifactTag(BlackboardArtifact artifact, TagName tagName) throws TskCoreException {
        return addBlackboardArtifactTag(artifact, tagName, "");
    }

    public BlackboardArtifactTag addBlackboardArtifactTag(BlackboardArtifact artifact, TagName tagName, String comment) throws TskCoreException {
        TaggingManager.BlackboardArtifactTagChange tagChange = caseDb.getTaggingManager().addArtifactTag(artifact, tagName, comment);
        try {
            Case currentCase = Case.getCurrentCaseThrows();
            currentCase.notifyBlackBoardArtifactTagAdded(tagChange.getAddedTag(), tagChange.getRemovedTags().isEmpty() ? null : tagChange.getRemovedTags());
        } catch (NoCurrentCaseException ex) {
            throw new TskCoreException("Added a tag to a closed case", ex);
        }
        return tagChange.getAddedTag();
    }

    public void deleteBlackboardArtifactTag(BlackboardArtifactTag tag) throws TskCoreException {
        caseDb.deleteBlackboardArtifactTag(tag);
        try {
            Case.getCurrentCaseThrows().notifyBlackBoardArtifactTagDeleted(tag);
        } catch (NoCurrentCaseException ex) {
            throw new TskCoreException("Deleted a tag from a closed case", ex);
        }
    }

    public List<BlackboardArtifactTag> getAllBlackboardArtifactTags() throws TskCoreException {
        return caseDb.getAllBlackboardArtifactTags();
    }

    public long getBlackboardArtifactTagsCountByTagName(TagName tagName) throws TskCoreException {
        return caseDb.getBlackboardArtifactTagsCountByTagName(tagName);
    }

    public long getBlackboardArtifactTagsCountByTagNameForUser(TagName tagName, String userName) throws TskCoreException {
        long count = 0;
        List<BlackboardArtifactTag> artifactTags = getBlackboardArtifactTagsByTagName(tagName);
        for (BlackboardArtifactTag tag : artifactTags) {
            if (userName.equals(tag.getUserName())) {
                count++;
            }
        }
        return count;
    }

    public long getBlackboardArtifactTagsCountByTagName(TagName tagName, long dsObjId) throws TskCoreException {
        return caseDb.getBlackboardArtifactTagsCountByTagName(tagName, dsObjId);
    }

    public long getBlackboardArtifactTagsCountByTagNameForUser(TagName tagName, long dsObjId, String userName) throws TskCoreException {
        long count = 0;
        List<BlackboardArtifactTag> artifactTags = getBlackboardArtifactTagsByTagName(tagName, dsObjId);
        for (BlackboardArtifactTag tag : artifactTags) {
            if (userName.equals(tag.getUserName())) {
                count++;
            }
        }
        return count;
    }

    public BlackboardArtifactTag getBlackboardArtifactTagByTagID(long tagId) throws TskCoreException {
        return caseDb.getBlackboardArtifactTagByID(tagId);
    }

    public List<BlackboardArtifactTag> getBlackboardArtifactTagsByTagName(TagName tagName) throws TskCoreException {
        return caseDb.getBlackboardArtifactTagsByTagName(tagName);
    }

    public List<BlackboardArtifactTag> getBlackboardArtifactTagsByTagName(TagName tagName, long dsObjId) throws TskCoreException {
        return caseDb.getBlackboardArtifactTagsByTagName(tagName, dsObjId);
    }

    public List<BlackboardArtifactTag> getBlackboardArtifactTagsByArtifact(BlackboardArtifact artifact) throws TskCoreException {
        return caseDb.getBlackboardArtifactTagsByArtifact(artifact);
    }

    public static class TagNameAlreadyExistsException extends Exception {

        private static final long serialVersionUID = 1L;
    }

    @Deprecated
    public boolean tagNameExists(String tagDisplayName) {
        try {
            Map<String, TagName> tagNames = getDisplayNamesToTagNamesMap();
            return tagNames.containsKey(tagDisplayName) && (tagNames.get(tagDisplayName) != null);
        } catch (TskCoreException ex) {
            LOGGER.log(Level.SEVERE, "Error querying case database for tag names", ex);
            return false;
        }
    }

    @Deprecated
    @Override
    public void close() throws IOException {
    }
}