UserDefinedFileTypesManager.java

Go to the documentation of this file.

/*
 * Autopsy Forensic Browser
 *
 * Copyright 2014 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.modules.filetypeid;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import javax.xml.bind.DatatypeConverter;
import javax.xml.transform.TransformerException;
import org.openide.util.NbBundle;
import org.sleuthkit.autopsy.coreutils.Logger;
import org.sleuthkit.autopsy.coreutils.PlatformUtil;
import org.sleuthkit.autopsy.coreutils.XMLUtil;
import org.sleuthkit.autopsy.modules.filetypeid.FileType.Signature;
import org.xml.sax.SAXException;

final class UserDefinedFileTypesManager {

    private static final Logger logger = Logger.getLogger(UserDefinedFileTypesManager.class.getName());
    private static final String FILE_TYPE_DEFINITIONS_SCHEMA_FILE = "FileTypes.xsd"; //NON-NLS
    private static final String USER_DEFINED_TYPE_DEFINITIONS_FILE = "UserFileTypeDefinitions.xml"; //NON-NLS
    private static final String FILE_TYPES_TAG_NAME = "FileTypes"; //NON-NLS
    private static final String FILE_TYPE_TAG_NAME = "FileType"; //NON-NLS
    private static final String MIME_TYPE_TAG_NAME = "MimeType"; //NON-NLS
    private static final String SIGNATURE_TAG_NAME = "Signature"; //NON-NLS
    private static final String SIGNATURE_TYPE_ATTRIBUTE = "type"; //NON-NLS
    private static final String BYTES_TAG_NAME = "Bytes"; //NON-NLS
    private static final String OFFSET_TAG_NAME = "Offset"; //NON-NLS
    private static final String INTERESTING_FILES_SET_TAG_NAME = "InterestingFileSset"; //NON-NLS
    private static final String ALERT_ATTRIBUTE = "alert"; //NON-NLS
    private static final String ENCODING_FOR_XML_FILE = "UTF-8"; //NON-NLS
    private static final String ASCII_ENCODING = "US-ASCII"; //NON-NLS
    private static UserDefinedFileTypesManager instance;

    private final Map<String, FileType> userDefinedFileTypes = new HashMap<>();

    private final Map<String, FileType> fileTypes = new HashMap<>();

    synchronized static UserDefinedFileTypesManager getInstance() {
        if (instance == null) {
            instance = new UserDefinedFileTypesManager();
        }
        return instance;
    }

    private UserDefinedFileTypesManager() {
    }

    synchronized Map<String, FileType> getFileTypes() throws UserDefinedFileTypesException {
        loadFileTypes();

        return new HashMap<>(fileTypes);
    }

    synchronized Map<String, FileType> getUserDefinedFileTypes() throws UserDefinedFileTypesException {
        loadFileTypes();

        return new HashMap<>(userDefinedFileTypes);
    }

    private void loadFileTypes() throws UserDefinedFileTypesException {
        fileTypes.clear();
        userDefinedFileTypes.clear();
        loadPredefinedFileTypes();
        loadUserDefinedFileTypes();
    }

    private void loadPredefinedFileTypes() throws UserDefinedFileTypesException {
        try {
            FileType fileType = new FileType("text/xml", new Signature("<?xml".getBytes(ASCII_ENCODING), 0L, FileType.Signature.Type.ASCII), "", false); //NON-NLS
            fileTypes.put(fileType.getMimeType(), fileType);

        } catch (UnsupportedEncodingException ex) {
            fileTypes.clear();
            throwUserDefinedFileTypesException(ex, "UserDefinedFileTypesManager.loadFileTypes.errorMessage");
        }
    }

    private void loadUserDefinedFileTypes() throws UserDefinedFileTypesException {
        try {
            String filePath = getFileTypeDefinitionsFilePath(USER_DEFINED_TYPE_DEFINITIONS_FILE);
            File file = new File(filePath);
            if (file.exists() && file.canRead()) {
                for (FileType fileType : XmlReader.readFileTypes(filePath)) {
                    addUserDefinedFileType(fileType);
                }
            }

        } catch (IOException | ParserConfigurationException | SAXException ex) {
            fileTypes.clear();
            userDefinedFileTypes.clear();
            throwUserDefinedFileTypesException(ex, "UserDefinedFileTypesManager.loadFileTypes.errorMessage");
        }
    }

    private void addUserDefinedFileType(FileType fileType) {
        userDefinedFileTypes.put(fileType.getMimeType(), fileType);
        fileTypes.put(fileType.getMimeType(), fileType);
    }

    synchronized void setUserDefinedFileTypes(Map<String, FileType> newFileTypes) throws UserDefinedFileTypesException {
        try {
            String filePath = getFileTypeDefinitionsFilePath(USER_DEFINED_TYPE_DEFINITIONS_FILE);
            XmlWriter.writeFileTypes(newFileTypes.values(), filePath);
        } catch (ParserConfigurationException | FileNotFoundException | UnsupportedEncodingException | TransformerException ex) {
            throwUserDefinedFileTypesException(ex, "UserDefinedFileTypesManager.saveFileTypes.errorMessage");
        } catch (IOException ex) {
            throwUserDefinedFileTypesException(ex, "UserDefinedFileTypesManager.saveFileTypes.errorMessage");
        }
    }

    private static String getFileTypeDefinitionsFilePath(String fileName) {
        Path filePath = Paths.get(PlatformUtil.getUserConfigDirectory(), fileName);
        return filePath.toAbsolutePath().toString();
    }

    private static class XmlWriter {

        private static void writeFileTypes(Collection<FileType> fileTypes, String filePath) throws ParserConfigurationException, IOException, FileNotFoundException, UnsupportedEncodingException, TransformerException {
            Document doc = XMLUtil.createDocument();
            Element fileTypesElem = doc.createElement(FILE_TYPES_TAG_NAME);
            doc.appendChild(fileTypesElem);
            for (FileType fileType : fileTypes) {
                Element fileTypeElem = XmlWriter.createFileTypeElement(fileType, doc);
                fileTypesElem.appendChild(fileTypeElem);
            }
            XMLUtil.saveDocument(doc, ENCODING_FOR_XML_FILE, filePath);
        }

        private static Element createFileTypeElement(FileType fileType, Document doc) {
            Element fileTypeElem = doc.createElement(FILE_TYPE_TAG_NAME);
            XmlWriter.addMimeTypeElement(fileType, fileTypeElem, doc);
            XmlWriter.addSignatureElement(fileType, fileTypeElem, doc);
            XmlWriter.addInterestingFilesSetElement(fileType, fileTypeElem, doc);
            XmlWriter.addAlertAttribute(fileType, fileTypeElem);
            return fileTypeElem;
        }

        private static void addMimeTypeElement(FileType fileType, Element fileTypeElem, Document doc) {
            Element typeNameElem = doc.createElement(MIME_TYPE_TAG_NAME);
            typeNameElem.setTextContent(fileType.getMimeType());
            fileTypeElem.appendChild(typeNameElem);
        }

        private static void addSignatureElement(FileType fileType, Element fileTypeElem, Document doc) {
            Signature signature = fileType.getSignature();
            Element signatureElem = doc.createElement(SIGNATURE_TAG_NAME);

            Element bytesElem = doc.createElement(BYTES_TAG_NAME);
            bytesElem.setTextContent(DatatypeConverter.printHexBinary(signature.getSignatureBytes()));
            signatureElem.appendChild(bytesElem);

            Element offsetElem = doc.createElement(OFFSET_TAG_NAME);
            offsetElem.setTextContent(DatatypeConverter.printLong(signature.getOffset()));
            signatureElem.appendChild(offsetElem);

            signatureElem.setAttribute(SIGNATURE_TYPE_ATTRIBUTE, signature.getType().toString());
            fileTypeElem.appendChild(signatureElem);
        }

        private static void addInterestingFilesSetElement(FileType fileType, Element fileTypeElem, Document doc) {
            if (!fileType.getFilesSetName().isEmpty()) {
                Element filesSetElem = doc.createElement(INTERESTING_FILES_SET_TAG_NAME);
                filesSetElem.setTextContent(fileType.getFilesSetName());
                fileTypeElem.appendChild(filesSetElem);
            }
        }

        private static void addAlertAttribute(FileType fileType, Element fileTypeElem) {
            fileTypeElem.setAttribute(ALERT_ATTRIBUTE, Boolean.toString(fileType.alertOnMatch()));
        }

    }

    private static class XmlReader {

        private static List<FileType> readFileTypes(String filePath) throws IOException, ParserConfigurationException, SAXException {
            List<FileType> fileTypes = new ArrayList<>();
            Document doc = XMLUtil.loadDocument(filePath, UserDefinedFileTypesManager.class, FILE_TYPE_DEFINITIONS_SCHEMA_FILE);
            if (doc != null) {
                Element fileTypesElem = doc.getDocumentElement();
                if (fileTypesElem != null && fileTypesElem.getNodeName().equals(FILE_TYPES_TAG_NAME)) {
                    NodeList fileTypeElems = fileTypesElem.getElementsByTagName(FILE_TYPE_TAG_NAME);
                    for (int i = 0; i < fileTypeElems.getLength(); ++i) {
                        Element fileTypeElem = (Element) fileTypeElems.item(i);
                        FileType fileType = XmlReader.parseFileType(fileTypeElem);
                        fileTypes.add(fileType);
                    }
                }
            }
            return fileTypes;
        }

        private static FileType parseFileType(Element fileTypeElem) throws IllegalArgumentException, NumberFormatException {
            String mimeType = XmlReader.parseMimeType(fileTypeElem);
            Signature signature = XmlReader.parseSignature(fileTypeElem);
            String filesSetName = XmlReader.parseInterestingFilesSet(fileTypeElem);
            boolean alert = XmlReader.parseAlert(fileTypeElem);
            return new FileType(mimeType, signature, filesSetName, alert);
        }

        private static String parseMimeType(Element fileTypeElem) {
            return getChildElementTextContent(fileTypeElem, MIME_TYPE_TAG_NAME);
        }

        private static Signature parseSignature(Element fileTypeElem) throws IllegalArgumentException, NumberFormatException {
            NodeList signatureElems = fileTypeElem.getElementsByTagName(SIGNATURE_TAG_NAME);
            Element signatureElem = (Element) signatureElems.item(0);

            String sigTypeAttribute = signatureElem.getAttribute(SIGNATURE_TYPE_ATTRIBUTE);
            Signature.Type signatureType = Signature.Type.valueOf(sigTypeAttribute);

            String sigBytesString = getChildElementTextContent(signatureElem, BYTES_TAG_NAME);
            byte[] signatureBytes = DatatypeConverter.parseHexBinary(sigBytesString);

            String offsetString = getChildElementTextContent(signatureElem, OFFSET_TAG_NAME);
            long offset = DatatypeConverter.parseLong(offsetString);

            return new Signature(signatureBytes, offset, signatureType);
        }

        private static String parseInterestingFilesSet(Element fileTypeElem) {
            String filesSetName = "";
            NodeList filesSetElems = fileTypeElem.getElementsByTagName(INTERESTING_FILES_SET_TAG_NAME);
            if (filesSetElems.getLength() > 0) {
                Element filesSetElem = (Element) filesSetElems.item(0);
                filesSetName = filesSetElem.getTextContent();
            }
            return filesSetName;
        }

        private static boolean parseAlert(Element fileTypeElem) {
            String alertAttribute = fileTypeElem.getAttribute(ALERT_ATTRIBUTE);
            return Boolean.parseBoolean(alertAttribute);
        }

        private static String getChildElementTextContent(Element elem, String tagName) {
            NodeList childElems = elem.getElementsByTagName(tagName);
            Element childElem = (Element) childElems.item(0);
            return childElem.getTextContent();
        }

    }

    private void throwUserDefinedFileTypesException(Exception ex, String messageKey) throws UserDefinedFileTypesException {
        String message = NbBundle.getMessage(UserDefinedFileTypesManager.class, messageKey);
        logger.log(Level.SEVERE, message, ex);
        throw new UserDefinedFileTypesException(message, ex);
    }

    static class UserDefinedFileTypesException extends Exception {

        UserDefinedFileTypesException(String message) {
            super(message);
        }

        UserDefinedFileTypesException(String message, Throwable throwable) {
            super(message, throwable);
        }
    }

}