org.digidoc4j.DataFile - java examples

Here are the examples of the java api org.digidoc4j.DataFile taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

53 Examples 7

19 View Complete Implementation : TimeStampTokenValidator.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
private List<DigiDoc4JException> validateTimeStamp(DataFile dataFile, TimeStampToken token) {
    List<DigiDoc4JException> errors = new ArrayList<>();
    boolean isSignatureValid = this.isSignatureValid(token);
    if (!isSignatureValid) {
        errors.add(new DigiDoc4JException("Signature not intact"));
    }
    boolean isMessageImprintsValid = this.isMessageImprintsValid(dataFile.getBytes(), token);
    if (isSignatureValid && !isMessageImprintsValid) {
        errors.add(new DigiDoc4JException("Signature not intact"));
    }
    boolean isVersionValid = this.isVersionValid(token);
    if (!isVersionValid) {
        errors.add(new DigiDoc4JException("TST version not supported"));
    }
    return errors;
}

19 View Complete Implementation : CustomContainer.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
@Override
public void setTimeStampToken(DataFile timeStampToken) {
    throw new NotYetImplementedException();
}

19 View Complete Implementation : DDocContainer.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
@Override
public void addDataFile(DataFile dataFile) {
    throw new NotSupportedException("Adding new data files is not supported anymore for DDoc!");
}

19 View Complete Implementation : CustomContainer.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
@Override
public void addDataFile(DataFile dataFile) {
}

19 View Complete Implementation : DDocFacade.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
public List<DataFile> getDataFiles() {
    List<DataFile> dataFiles = new ArrayList<>();
    ArrayList ddocDataFiles = ddoc.getDataFiles();
    if (ddocDataFiles == null)
        return dataFiles;
    for (Object ddocDataFile : ddocDataFiles) {
        org.digidoc4j.ddoc.DataFile dataFile = (org.digidoc4j.ddoc.DataFile) ddocDataFile;
        String dataFileName = FilenameUtils.getName(dataFile.getFileName());
        try {
            if (isHashcodeForm(dataFile)) {
                DigestDataFile digestDataFile = new DigestDataFile(dataFileName, DigestAlgorithm.SHA1, dataFile.getDigestValueOfType("sha1"), dataFile.getMimeType());
                digestDataFile.setContentType(HASHCODE_CONTENT_TYPE);
                dataFiles.add(digestDataFile);
            } else {
                if (dataFile.getBody() == null) {
                    DataFile dataFile1 = new DataFile(dataFile.getFileName(), dataFile.getMimeType());
                    dataFile1.setId(dataFile.getId());
                    dataFiles.add(dataFile1);
                } else {
                    DataFile dataFile1 = new DataFile(dataFile.getBodyAsData(), dataFileName, dataFile.getMimeType());
                    dataFile1.setId(dataFile.getId());
                    dataFiles.add(dataFile1);
                }
            }
        } catch (DigiDocException e) {
            throw new DigiDoc4JException(e.getMessage(), e.getNestedException());
        }
    }
    return dataFiles;
}

19 View Complete Implementation : AsicParseResult.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
public void setTimeStampToken(DataFile timeStampToken) {
    this.timeStampToken = timeStampToken;
}

19 View Complete Implementation : AsicContainer.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
/**
 * Set timestamp token to container
 *
 * @param timeStampToken
 */
public void setTimeStampToken(DataFile timeStampToken) {
    this.timeStampToken = timeStampToken;
}

19 View Complete Implementation : CustomContainer.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
@Override
public void removeDataFile(DataFile file) {
}

19 View Complete Implementation : DDocContainer.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
@Override
public void removeDataFile(DataFile file) {
    throw new NotSupportedException("Removing data files is not supported anymore for DDoc!");
}

19 View Complete Implementation : DDocContainer.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
@Override
public void setTimeStampToken(DataFile timeStampToken) {
    throw new NotSupportedException("Not for DDOC container");
}

19 View Complete Implementation : AsicSContainer.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
/**
 * Replace Data File in AsicS container
 *
 * @param dataFile
 */
public void replaceDataFile(DataFile dataFile) {
    if (getDataFiles().size() > 0) {
        removeDataFile(getDataFiles().get(0));
    }
    addDataFile(dataFile);
}

18 View Complete Implementation : AsicContainerCreator.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
/**
 * @param dataFile data file
 */
public void writeTimestampToken(DataFile dataFile) {
    logger.debug("Adding signatures to the asic zip container");
    String signatureFileName = "META-INF/timestamp.tst";
    new BytesEntryCallback(new ZipEntry(signatureFileName), dataFile.getBytes()).write();
}

18 View Complete Implementation : PadesContainer.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
@Override
public void addDataFile(DataFile dataFile) {
    throw new NotYetImplementedException();
}

18 View Complete Implementation : PadesContainer.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
@Override
public void removeDataFile(DataFile file) {
    throw new NotYetImplementedException();
}

18 View Complete Implementation : TimestampToken.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
/**
 * generates timesstamp token for AsicS container
 *
 * @param digestAlgorithm
 * @param containerDataFile
 * @return DataFile timestamp token
 */
public static DataFile generateTimestampToken(DigestAlgorithm digestAlgorithm, DataFile containerDataFile) {
    OnlineTSPSource onlineTSPSource = defineOnlineTSPSource(null);
    byte[] dataFileDigest;
    dataFileDigest = containerDataFile.getBytes();
    byte[] digest = DSSUtils.digest(digestAlgorithm, dataFileDigest);
    DataFile timeStampToken = getTimestampToken(onlineTSPSource, digestAlgorithm, digest);
    return timeStampToken;
}

18 View Complete Implementation : TimestampToken.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
/**
 * generates timesstamp token for AsicS container
 *
 * @param digestAlgorithm
 * @param dataFiles
 * @return DataFile timestamp token
 */
public static DataFile generateTimestampToken(DigestAlgorithm digestAlgorithm, List<ContainerBuilder.ContainerDataFile> dataFiles, Configuration configuration) {
    if (dataFiles.isEmpty()) {
        throw new DigiDoc4JException("Add data file first");
    }
    if (dataFiles.size() > 1) {
        throw new DigiDoc4JException("Supports only asics with only one datafile");
    }
    ContainerBuilder.ContainerDataFile containerDataFile = dataFiles.get(0);
    OnlineTSPSource onlineTSPSource = defineOnlineTSPSource(configuration);
    byte[] dataFileDigest = getDigest(containerDataFile);
    byte[] digest = DSSUtils.digest(digestAlgorithm, dataFileDigest);
    DataFile timeStampToken = getTimestampToken(onlineTSPSource, digestAlgorithm, digest);
    return timeStampToken;
}

18 View Complete Implementation : TimestampToken.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
private static DataFile getTimestampToken(OnlineTSPSource onlineTSPSource, DigestAlgorithm digestAlgorithm, byte[] digest) {
    DataFile timeStampToken = new DataFile();
    TimeStampToken timeStampResponse = onlineTSPSource.getTimeStampResponse(digestAlgorithm, digest);
    String timestampFilename = "timestamp";
    timeStampToken.setDoreplacedent(new InMemoryDoreplacedent(DSSASN1Utils.getEncoded(timeStampResponse), timestampFilename, MimeType.TST));
    timeStampToken.setMediaType(MimeType.TST.getMimeTypeString());
    return timeStampToken;
}

18 View Complete Implementation : PadesContainer.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
@Override
public void setTimeStampToken(DataFile timeStampToken) {
    throw new NotSupportedException("Not for Pades container");
}

18 View Complete Implementation : AsicContainer.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
@Override
public DataFile addDataFile(File file, String mimeType) {
    DataFile dataFile = new DataFile(file.getPath(), mimeType);
    addDataFile(dataFile);
    return dataFile;
}

18 View Complete Implementation : AsicContainer.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
@Override
public DataFile addDataFile(String path, String mimeType) {
    DataFile dataFile = new DataFile(path, mimeType);
    addDataFile(dataFile);
    return dataFile;
}

18 View Complete Implementation : AsicContainer.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
private boolean removeDataFileFromContainer(DataFile dataFile) {
    if (!isNewContainer()) {
        removeExistingFileFromContainer(dataFile.getName());
        containerParseResult.getDataFiles().remove(dataFile);
        containerParseResult.getDetachedContents().remove(dataFile.getDoreplacedent());
    }
    newDataFiles.remove(dataFile);
    return dataFiles.remove(dataFile);
}

18 View Complete Implementation : AsicContainer.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
private void checkForDuplicateDataFile(String fileName) {
    for (DataFile dataFile : getDataFiles()) {
        String dataFileName = dataFile.getName();
        if (StringUtils.equals(dataFileName, fileName)) {
            String errorMessage = "Data file " + fileName + " already exists";
            LOGGER.error(errorMessage);
            throw new DuplicateDataFileException(errorMessage);
        }
    }
}

18 View Complete Implementation : AsicContainer.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
@Override
public DataFile addDataFile(InputStream inputStream, String fileName, String mimeType) {
    DataFile dataFile = new DataFile(inputStream, fileName, mimeType);
    addDataFile(dataFile);
    return dataFile;
}

17 View Complete Implementation : DataToSignSerializationTest.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
@Test
public void finalizeDetachedTimestampSignature_dataFileFromStream() throws FileNotFoundException {
    for (int fileSize : FILE_SIZES_IN_KILOBYTES) {
        String fileName = fileSize + "KB.txt";
        DataFile dataFile = new DataFile(new FileInputStream("src/test/resources/testFiles/helper-files/sized-files/" + fileName), fileName, "text/plain");
        Signature signature = finalizeAndValidateDetachedSignature(dataFile, SignatureProfile.LT, fileSize * 1000);
        replacedertTimestampSignature(signature);
    }
}

17 View Complete Implementation : DataToSignSerializationTest.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
@Test
public void finalizeDetachedTimemarkSignature_dataFileFromStream() throws FileNotFoundException {
    for (int fileSize : FILE_SIZES_IN_KILOBYTES) {
        String fileName = fileSize + "KB.txt";
        DataFile dataFile = new DataFile(new FileInputStream("src/test/resources/testFiles/helper-files/sized-files/" + fileName), fileName, "text/plain");
        Signature signature = finalizeAndValidateDetachedSignature(dataFile, SignatureProfile.LT_TM, fileSize * 1000);
        replacedertTimemarkSignature(signature);
    }
}

17 View Complete Implementation : DDocFacadeTest.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
@Test
public void testGetDataFileSize() {
    DDocFacade facade = openDDocFacade("src/test/resources/testFiles/valid-containers/ddoc_for_testing.ddoc");
    DataFile dataFile = facade.getDataFiles().get(0);
    replacedert.replacedertEquals(16, dataFile.getFileSize());
}

17 View Complete Implementation : StreamDocumentTest.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
@Test
public void createDoreplacedentFromStreamedDataFile() throws Exception {
    String file = this.getFileBy("txt");
    try (ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(new byte[] { 0x041 })) {
        DataFile dataFile = new DataFile(byteArrayInputStream, file, "text/plain");
        StreamDoreplacedent streamDoreplacedent = new StreamDoreplacedent(dataFile.getStream(), dataFile.getName(), MimeType.fromMimeTypeString(dataFile.getMediaType()));
        streamDoreplacedent.save(file);
    }
    try (FileInputStream fileInputStream = new FileInputStream(file)) {
        replacedert.replacedertArrayEquals(new byte[] { 0x041 }, IOUtils.toByteArray(fileInputStream));
    }
}

17 View Complete Implementation : AsicContainer.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
@Override
public void addDataFile(DataFile dataFile) {
    String fileName = dataFile.getName();
    verifyIfAllowedToAddDataFile(fileName);
    if (Constant.ASICS_CONTAINER_TYPE.equals(getType())) {
        if (dataFiles.size() > 1) {
            throw new DigiDoc4JException("DataFile is already exists");
        } else if (newDataFiles.size() > 1) {
            throw new DigiDoc4JException("Not possible to add more than one datafile");
        }
    }
    dataFiles.add(dataFile);
    newDataFiles.add(dataFile);
    dataFilesHaveChanged = true;
    if (!isNewContainer()) {
        removeExistingFileFromContainer(AsicManifest.XML_PATH);
    }
}

17 View Complete Implementation : AsicContainer.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
@Override
public void removeDataFile(DataFile file) {
    validateDataFilesRemoval();
    boolean wasRemovalSuccessful = removeDataFileFromContainer(file);
    if (!wasRemovalSuccessful) {
        throw new DataFileNotFoundException(file.getName());
    }
    LOGGER.info("Data file named '{}' has been removed", file.getName());
}

17 View Complete Implementation : AsicContainerCreator.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
/**
 * @param dataFiles list of data files
 */
public void writeDataFiles(Collection<DataFile> dataFiles) {
    logger.debug("Adding data files to the asic zip container");
    for (DataFile dataFile : dataFiles) {
        String name = dataFile.getName();
        logger.debug("Adding data file {}", name);
        zipOutputStream.setLevel(ZipEntry.DEFLATED);
        new StreamEntryCallback(new ZipEntry(name), dataFile.getStream()).write();
    }
}

17 View Complete Implementation : AsicParseResult.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
/**
 * ASIC parse result
 */
public clreplaced AsicParseResult implements Serializable {

    private List<XadesSignatureWrapper> signatures;

    private List<DataFile> dataFiles;

    private List<DSSDoreplacedent> detachedContents;

    private Integer currentUsedSignatureFileIndex;

    private String zipFileComment;

    private List<AsicEntry> asicEntries;

    private ManifestParser manifestParser;

    private DataFile timeStampToken;

    private String mimeType;

    /**
     * @return list of data files
     */
    public List<DataFile> getDataFiles() {
        return dataFiles;
    }

    /**
     * @param dataFiles list of data files
     */
    public void setDataFiles(List<DataFile> dataFiles) {
        this.dataFiles = dataFiles;
    }

    /**
     * @return list of signatures
     */
    public List<XadesSignatureWrapper> getSignatures() {
        return signatures;
    }

    /**
     * @param signatures list of signatures
     */
    public void setSignatures(List<XadesSignatureWrapper> signatures) {
        this.signatures = signatures;
    }

    public boolean removeSignature(String signatureName) {
        for (XadesSignatureWrapper signatureWrapper : signatures) {
            if (StringUtils.equalsIgnoreCase(signatureWrapper.getSignatureDoreplacedent().getName(), signatureName)) {
                return signatures.remove(signatureWrapper);
            }
        }
        return false;
    }

    /**
     * @return list of detached content
     */
    public List<DSSDoreplacedent> getDetachedContents() {
        return detachedContents;
    }

    public void setDetachedContents(List<DSSDoreplacedent> detachedContents) {
        this.detachedContents = detachedContents;
    }

    public Integer getCurrentUsedSignatureFileIndex() {
        return currentUsedSignatureFileIndex;
    }

    public void setCurrentUsedSignatureFileIndex(Integer currentUsedSignatureFileIndex) {
        this.currentUsedSignatureFileIndex = currentUsedSignatureFileIndex;
    }

    public String getZipFileComment() {
        return zipFileComment;
    }

    public void setZipFileComment(String zipFileComment) {
        this.zipFileComment = zipFileComment;
    }

    public List<AsicEntry> getAsicEntries() {
        return asicEntries;
    }

    public void setAsicEntries(List<AsicEntry> asicEntries) {
        this.asicEntries = asicEntries;
    }

    public boolean removeAsicEntry(String asicEntryName) {
        for (AsicEntry asicEntry : asicEntries) {
            if (StringUtils.equalsIgnoreCase(asicEntry.getZipEntry().getName(), asicEntryName)) {
                return asicEntries.remove(asicEntry);
            }
        }
        return false;
    }

    public ManifestParser getManifestParser() {
        return manifestParser;
    }

    public void setManifestParser(ManifestParser manifestParser) {
        this.manifestParser = manifestParser;
    }

    public void setTimeStampToken(DataFile timeStampToken) {
        this.timeStampToken = timeStampToken;
    }

    public DataFile getTimeStampToken() {
        return timeStampToken;
    }

    public void setMimeType(String mimeType) {
        this.mimeType = mimeType;
    }

    public String getMimeType() {
        return mimeType;
    }
}

17 View Complete Implementation : AsicStreamContainerParser.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
private void updateDataFilesMimeType() {
    for (DataFile dataFile : getDataFiles().values()) {
        String fileName = dataFile.getName();
        String mimeType = MimeTypeUtil.mimeTypeOf(getDataFileMimeType(fileName)).getMimeTypeString();
        dataFile.setMediaType(mimeType);
    }
}

17 View Complete Implementation : AsicManifest.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
/**
 * adds list of attachments to create manifest file
 *
 * @param dataFiles list of data files
 */
public void addFileEntry(Collection<DataFile> dataFiles) {
    for (DataFile dataFile : dataFiles) {
        logger.debug("Adding " + dataFile.getName() + " to manifest");
        Element childElement;
        childElement = dom.createElement("manifest:file-entry");
        childElement.setAttribute("manifest:media-type", dataFile.getMediaType());
        childElement.setAttribute("manifest:full-path", dataFile.getName());
        rootElement.appendChild(childElement);
    }
}

17 View Complete Implementation : AsicContainerParserTest.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
@Test
public void parseBdocFromStream() throws Exception {
    AsicParseResult result = getParseResultFromStream("src/test/resources/testFiles/valid-containers/23147_weak-warning-sha1.bdoc");
    for (DataFile dataFile : result.getDataFiles()) {
        replacedert.replacedertEquals(dataFile.getName(), "jdigidoc.cfg");
        replacedert.replacedertEquals(dataFile.getMediaType(), "text/html");
    }
}

17 View Complete Implementation : ManifestValidatorTest.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
private ManifestParser createManifest(DataFile... dataFile) {
    AsicManifest asicManifest = new AsicManifest();
    asicManifest.addFileEntry(Arrays.asList(dataFile));
    DSSDoreplacedent manifestFile = new InMemoryDoreplacedent(asicManifest.getBytes());
    return new ManifestParser(manifestFile);
}

16 View Complete Implementation : AsicContainer.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
@Override
public void removeDataFile(String fileName) {
    validateDataFilesRemoval();
    for (DataFile dataFile : dataFiles) {
        String name = dataFile.getName();
        if (StringUtils.equals(fileName, name)) {
            removeDataFileFromContainer(dataFile);
            LOGGER.info("Data file named '{}' has been removed", fileName);
            return;
        }
    }
    throw new DataFileNotFoundException(fileName);
}

16 View Complete Implementation : AsicContainer.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
/**
 * Created by Andrei on 7.11.2017.
 */
public abstract clreplaced AsicContainer implements Container {

    private static final Logger LOGGER = LoggerFactory.getLogger(AsicContainer.clreplaced);

    protected Configuration configuration;

    protected DataFile timeStampToken;

    private List<DataFile> dataFiles = new ArrayList<>();

    private List<Signature> newSignatures = new ArrayList<>();

    private List<Signature> signatures = new ArrayList<>();

    private List<DataFile> newDataFiles = new ArrayList<>();

    private AsicParseResult containerParseResult;

    private boolean dataFilesHaveChanged;

    private String containerType = "";

    protected abstract String createUserAgent();

    /**
     * ASicContainer constructor
     */
    public AsicContainer() {
        this.configuration = Configuration.getInstance();
    }

    /**
     * ASicContainer constructor
     *
     * @param configuration configuration
     */
    public AsicContainer(Configuration configuration) {
        this.configuration = configuration;
    }

    /**
     * ASicContainer constructor
     *
     * @param containerPath path
     * @param containerType type
     */
    public AsicContainer(String containerPath, String containerType) {
        this.configuration = Configuration.getInstance();
        this.containerType = containerType;
        this.openContainer(containerPath);
    }

    /**
     * ASicContainer constructor
     *
     * @param containerPath path
     * @param configuration configuration
     * @param containerType type
     */
    public AsicContainer(String containerPath, Configuration configuration, String containerType) {
        this.configuration = configuration;
        this.containerType = containerType;
        this.openContainer(containerPath);
    }

    /**
     * ASicContainer constructor
     *
     * @param stream        input stream
     * @param containerType type
     */
    public AsicContainer(InputStream stream, String containerType) {
        this.configuration = Configuration.getInstance();
        this.containerType = containerType;
        this.openContainer(stream);
    }

    /**
     * ASicContainer constructor
     *
     * @param stream        input stream
     * @param configuration configuration
     * @param containerType type
     */
    public AsicContainer(InputStream stream, Configuration configuration, String containerType) {
        this.configuration = configuration;
        this.containerType = containerType;
        this.openContainer(stream);
    }

    /**
     * ASicContainer constructor
     *
     * @param containerParseResult container parsed result
     * @param configuration configuration
     * @param containerType container type
     */
    public AsicContainer(AsicParseResult containerParseResult, Configuration configuration, String containerType) {
        this.configuration = configuration;
        this.containerType = containerType;
        this.populateContainerWithParseResult(containerParseResult);
    }

    @Override
    public ContainerValidationResult validate() {
        ContainerValidationResult validationResult = this.validateContainer();
        if (validationResult instanceof AbstractValidationResult) {
            ((AbstractValidationResult) validationResult).print(this.configuration);
        }
        return validationResult;
    }

    protected ContainerValidationResult validateContainer() {
        if (this.timeStampToken != null) {
            return this.validateTimestampToken();
        } else {
            if (!this.isNewContainer()) {
                if (DoreplacedentType.BDOC.name().equalsIgnoreCase(this.containerType)) {
                    return new BDocContainerValidator(this.containerParseResult, this.getConfiguration(), !this.dataFilesHaveChanged).validate(this.getSignatures());
                } else if (DoreplacedentType.ASICS.name().equalsIgnoreCase(this.containerType)) {
                    return new AsicSContainerValidator(this.containerParseResult, this.getConfiguration(), !this.dataFilesHaveChanged).validate(this.getSignatures());
                } else {
                    return new AsicEContainerValidator(this.containerParseResult, this.getConfiguration(), !this.dataFilesHaveChanged).validate(this.getSignatures());
                }
            } else {
                if (DoreplacedentType.BDOC.name().equalsIgnoreCase(this.containerType)) {
                    return new BDocContainerValidator(this.getConfiguration()).validate(this.getSignatures());
                } else if (DoreplacedentType.ASICS.name().equalsIgnoreCase(this.containerType)) {
                    return new AsicSContainerValidator(this.getConfiguration()).validate(this.getSignatures());
                } else {
                    return new AsicEContainerValidator(this.getConfiguration()).validate(this.getSignatures());
                }
            }
        }
    }

    private ContainerValidationResult validateTimestampToken() {
        if (this.containerParseResult == null) {
            this.containerParseResult = new AsicStreamContainerParser(this.savereplacedtream(), this.getConfiguration()).read();
        }
        return new TimeStampTokenValidator(this.containerParseResult).validate();
    }

    @Override
    public File saveAsFile(String filePath) {
        LOGGER.debug("Saving container to file: " + filePath);
        File file = new File(filePath);
        try (OutputStream stream = Helper.bufferedOutputStream(file)) {
            save(stream);
            LOGGER.info("Container was saved to file " + filePath);
            return file;
        } catch (IOException e) {
            LOGGER.error("Unable to close stream: " + e.getMessage());
            throw new TechnicalException("Unable to close stream", e);
        }
    }

    @Override
    public Configuration getConfiguration() {
        return configuration;
    }

    private List<Signature> openSignatures(List<XadesSignatureWrapper> signatureWrappers) {
        List<Signature> signatures = new ArrayList<>(signatureWrappers.size());
        for (XadesSignatureWrapper signatureWrapper : signatureWrappers) {
            signatures.add(getSignatureOpener().open(signatureWrapper));
        }
        return signatures;
    }

    protected abstract AsicSignatureOpener getSignatureOpener();

    @Override
    public InputStream savereplacedtream() {
        LOGGER.debug("Saving container as stream");
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        save(outputStream);
        InputStream inputStream = new ByteArrayInputStream(outputStream.toByteArray());
        LOGGER.info("Container was saved to stream");
        return inputStream;
    }

    protected void validateIncomingSignature(Signature signature) {
        if (signature == null) {
            throw new TechnicalException("ValidateIncomingSignature is null");
        }
        if (!((signature instanceof BDocSignature) || (signature instanceof AsicSSignature) || (signature instanceof AsicESignature) || (signature instanceof AsicSignature))) {
            throw new TechnicalException("BDoc signature must be an instance of AsicSignature");
        }
    }

    protected List<Signature> extendAllSignatureProfile(SignatureProfile profile, List<Signature> signatures, List<DataFile> dataFiles) {
        LOGGER.info("Extending all signatures' profile to " + profile.name());
        DetachedContentCreator detachedContentCreator = null;
        try {
            detachedContentCreator = new DetachedContentCreator().populate(dataFiles);
        } catch (Exception e) {
            LOGGER.error("Error in datafiles processing: " + e.getMessage());
            throw new DigiDoc4JException(e);
        }
        List<DSSDoreplacedent> detachedContentList = detachedContentCreator.getDetachedContentList();
        SignatureExtender signatureExtender = new SignatureExtender(getConfiguration(), detachedContentList);
        List<DSSDoreplacedent> extendedSignatureDoreplacedents = signatureExtender.extend(signatures, profile);
        List<XadesSignatureWrapper> parsedSignatures = parseSignaturesWrappers(extendedSignatureDoreplacedents, detachedContentList);
        List<Signature> extendedSignatures = openSignatures(parsedSignatures);
        LOGGER.debug("Finished extending all signatures");
        return extendedSignatures;
    }

    private List<XadesSignatureWrapper> parseSignaturesWrappers(List<DSSDoreplacedent> signatureDoreplacedents, List<DSSDoreplacedent> detachedContent) {
        AsicSignatureParser signatureParser = new AsicSignatureParser(detachedContent, configuration);
        List<XadesSignatureWrapper> parsedSignatures = new ArrayList<>();
        for (DSSDoreplacedent signatureDoreplacedent : signatureDoreplacedents) {
            XadesSignature signature = signatureParser.parse(signatureDoreplacedent);
            parsedSignatures.add(new XadesSignatureWrapper(signature, signatureDoreplacedent));
        }
        return parsedSignatures;
    }

    protected void validateDataFilesRemoval() {
        if (isContainerSigned()) {
            LOGGER.error("Datafiles cannot be removed from an already signed container");
            throw new RemovingDataFileException();
        }
    }

    protected void verifyIfAllowedToAddDataFile(String fileName) {
        if (isContainerSigned()) {
            String errorMessage = "Datafiles cannot be added to an already signed container";
            LOGGER.error(errorMessage);
            throw new DigiDoc4JException(errorMessage);
        }
        checkForDuplicateDataFile(fileName);
    }

    private boolean isContainerSigned() {
        return !getSignatures().isEmpty();
    }

    private void checkForDuplicateDataFile(String fileName) {
        for (DataFile dataFile : getDataFiles()) {
            String dataFileName = dataFile.getName();
            if (StringUtils.equals(dataFileName, fileName)) {
                String errorMessage = "Data file " + fileName + " already exists";
                LOGGER.error(errorMessage);
                throw new DuplicateDataFileException(errorMessage);
            }
        }
    }

    /**
     * @param containerType
     */
    public void setType(String containerType) {
        this.containerType = containerType;
    }

    @Override
    public String getType() {
        return containerType;
    }

    private void openContainer(String containerPath) {
        LOGGER.debug("Opening container from <{}>", containerPath);
        this.populateContainerWithParseResult(new AsicFileContainerParser(containerPath, this.getConfiguration()).read());
    }

    private void openContainer(InputStream inputStream) {
        LOGGER.debug("Opening container from stream");
        this.populateContainerWithParseResult(new AsicStreamContainerParser(inputStream, this.getConfiguration()).read());
    }

    private void populateContainerWithParseResult(AsicParseResult parseResult) {
        this.containerParseResult = parseResult;
        this.dataFiles.addAll(parseResult.getDataFiles());
        this.timeStampToken = parseResult.getTimeStampToken();
        this.signatures.addAll(this.openSignatures(parseResult.getSignatures()));
    }

    private void removeExistingSignature(AsicSignature signature) {
        DSSDoreplacedent signatureDoreplacedent = signature.getSignatureDoreplacedent();
        if (signatureDoreplacedent == null) {
            return;
        }
        String signatureFileName = signatureDoreplacedent.getName();
        removeExistingSignatureFromContainer(signatureFileName);
        removeExistingFileFromContainer(signatureFileName);
    }

    private void removeExistingSignatureFromContainer(String signatureName) {
        LOGGER.debug("Removing signature '{}' from the container", signatureName);
        if (containerParseResult.removeSignature(signatureName)) {
            LOGGER.debug("Signature '{}' successfully removed from container", signatureName);
        }
    }

    private void removeExistingFileFromContainer(String fileName) {
        LOGGER.debug("Removing file '{}' from the container" + fileName);
        if (containerParseResult.removeAsicEntry(fileName)) {
            LOGGER.debug("File '{}' successfully removed from container", fileName);
        }
    }

    private void removeAllExistingSignaturesFromContainer() {
        LOGGER.debug("Removing all existing signatures");
        for (Signature signature : signatures) {
            removeExistingSignature((AsicSignature) signature);
        }
    }

    private int determineNextSignatureFileIndex() {
        Integer currentUsedSignatureFileIndex = containerParseResult.getCurrentUsedSignatureFileIndex();
        if (currentUsedSignatureFileIndex == null) {
            return 0;
        }
        return currentUsedSignatureFileIndex + 1;
    }

    @Override
    public List<DataFile> getDataFiles() {
        return dataFiles;
    }

    @Override
    public DataFile addDataFile(String path, String mimeType) {
        DataFile dataFile = new DataFile(path, mimeType);
        addDataFile(dataFile);
        return dataFile;
    }

    @Override
    public DataFile addDataFile(InputStream inputStream, String fileName, String mimeType) {
        DataFile dataFile = new DataFile(inputStream, fileName, mimeType);
        addDataFile(dataFile);
        return dataFile;
    }

    @Override
    public DataFile addDataFile(File file, String mimeType) {
        DataFile dataFile = new DataFile(file.getPath(), mimeType);
        addDataFile(dataFile);
        return dataFile;
    }

    @Override
    public void addDataFile(DataFile dataFile) {
        String fileName = dataFile.getName();
        verifyIfAllowedToAddDataFile(fileName);
        if (Constant.ASICS_CONTAINER_TYPE.equals(getType())) {
            if (dataFiles.size() > 1) {
                throw new DigiDoc4JException("DataFile is already exists");
            } else if (newDataFiles.size() > 1) {
                throw new DigiDoc4JException("Not possible to add more than one datafile");
            }
        }
        dataFiles.add(dataFile);
        newDataFiles.add(dataFile);
        dataFilesHaveChanged = true;
        if (!isNewContainer()) {
            removeExistingFileFromContainer(AsicManifest.XML_PATH);
        }
    }

    @Override
    public void addSignature(Signature signature) {
        validateIncomingSignature(signature);
        validateSignatureId(signature);
        newSignatures.add(signature);
        signatures.add(signature);
    }

    /**
     * Set timestamp token to container
     *
     * @param timeStampToken
     */
    public void setTimeStampToken(DataFile timeStampToken) {
        this.timeStampToken = timeStampToken;
    }

    private void validateSignatureId(Signature signature) {
        for (Signature sig : signatures) {
            if (sig.getId() != null && sig.getId().equalsIgnoreCase(signature.getId())) {
                throw new TechnicalException("Signature with Id \"" + signature.getId() + "\" already exists");
            }
        }
    }

    /**
     * Controlls if timestamp token is defined
     *
     * @return true if timestemp token defined
     */
    public boolean isTimestampTokenDefined() {
        return timeStampToken != null;
    }

    // =======================================================
    @Override
    public void extendSignatureProfile(SignatureProfile profile) {
        if (!isNewContainer()) {
            removeAllExistingSignaturesFromContainer();
            List<Signature> signatures = extendAllSignaturesProfile(profile, this.signatures, dataFiles);
            this.signatures = signatures;
            newSignatures = new ArrayList<>(signatures);
        } else {
            signatures = extendAllSignaturesProfile(profile, signatures, dataFiles);
        }
    }

    private List<Signature> extendAllSignaturesProfile(SignatureProfile profile, List<Signature> signatures, List<DataFile> dataFiles) {
        List<Signature> extendedSignatures;
        if (Constant.ASICS_CONTAINER_TYPE.equals(getType())) {
            extendedSignatures = extendAllSignatureProfile(profile, signatures, Arrays.asList(dataFiles.get(0)));
        } else {
            extendedSignatures = extendAllSignatureProfile(profile, signatures, dataFiles);
        }
        return extendedSignatures;
    }

    @Override
    public void removeSignature(Signature signature) {
        if (signature == null) {
            LOGGER.warn("Cannot remove null signature");
            return;
        }
        LOGGER.info("Removing signature " + signature.getId());
        if (!isNewContainer()) {
            validateIncomingSignature(signature);
            boolean wasNewlyAddedSignature = newSignatures.remove(signature);
            boolean wasIncludedInContainer = signatures.remove(signature);
            if (wasIncludedInContainer && !wasNewlyAddedSignature) {
                LOGGER.debug("This signature was included in the container before the container was opened");
                removeExistingSignature((AsicSignature) signature);
            }
        } else {
            newSignatures.remove(signature);
            signatures.remove(signature);
        }
    }

    @Override
    @Deprecated
    public void removeSignature(int signatureId) {
        LOGGER.debug("Removing signature from index " + signatureId);
        Signature signature = signatures.get(signatureId);
        if (signature != null) {
            removeSignature(signature);
        }
    }

    @Override
    public void removeDataFile(String fileName) {
        validateDataFilesRemoval();
        for (DataFile dataFile : dataFiles) {
            String name = dataFile.getName();
            if (StringUtils.equals(fileName, name)) {
                removeDataFileFromContainer(dataFile);
                LOGGER.info("Data file named '{}' has been removed", fileName);
                return;
            }
        }
        throw new DataFileNotFoundException(fileName);
    }

    @Override
    public void removeDataFile(DataFile file) {
        validateDataFilesRemoval();
        boolean wasRemovalSuccessful = removeDataFileFromContainer(file);
        if (!wasRemovalSuccessful) {
            throw new DataFileNotFoundException(file.getName());
        }
        LOGGER.info("Data file named '{}' has been removed", file.getName());
    }

    private boolean removeDataFileFromContainer(DataFile dataFile) {
        if (!isNewContainer()) {
            removeExistingFileFromContainer(dataFile.getName());
            containerParseResult.getDataFiles().remove(dataFile);
            containerParseResult.getDetachedContents().remove(dataFile.getDoreplacedent());
        }
        newDataFiles.remove(dataFile);
        return dataFiles.remove(dataFile);
    }

    private boolean isNewContainer() {
        return containerParseResult == null;
    }

    @Override
    public List<Signature> getSignatures() {
        return signatures;
    }

    protected void writeAsicContainer(AsicContainerCreator zipCreator) {
        String userAgent = createUserAgent();
        zipCreator.setZipComment(userAgent);
        if (!isNewContainer()) {
            int nextSignatureFileIndex = determineNextSignatureFileIndex();
            zipCreator.writeExistingEntries(containerParseResult.getAsicEntries());
            if (dataFilesHaveChanged) {
                zipCreator.writeManifest(dataFiles, getType());
            }
            zipCreator.writeSignatures(newSignatures, nextSignatureFileIndex);
            zipCreator.writeDataFiles(newDataFiles);
            if (StringUtils.isNotBlank(containerParseResult.getZipFileComment())) {
                zipCreator.writeContainerComment(containerParseResult.getZipFileComment());
            }
        } else {
            int startingSignatureFileIndex = 0;
            zipCreator.writeAsiceMimeType(getType());
            zipCreator.writeManifest(dataFiles, getType());
            zipCreator.writeDataFiles(dataFiles);
            if (timeStampToken != null && Constant.ASICS_CONTAINER_TYPE.equals(getType())) {
                zipCreator.writeTimestampToken(timeStampToken);
            } else {
                zipCreator.writeSignatures(signatures, startingSignatureFileIndex);
            }
            zipCreator.writeContainerComment(userAgent);
        }
        zipCreator.finalizeZipFile();
    }

    // =============== Deprecated methods ====================
    @Override
    @Deprecated
    public void addRawSignature(byte[] signatureDoreplacedent) {
        LOGGER.info("Adding raw signature");
        Signature signature = SignatureBuilder.aSignature(this).openAdESSignature(signatureDoreplacedent);
        addSignature(signature);
    }

    @Override
    @Deprecated
    public void addRawSignature(InputStream signatureStream) {
        try {
            byte[] bytes = IOUtils.toByteArray(signatureStream);
            addRawSignature(bytes);
        } catch (IOException e) {
            LOGGER.error("Failed to read signature stream: " + e.getMessage());
            throw new InvalidSignatureException();
        }
    }

    @Override
    @Deprecated
    public int countDataFiles() {
        return getDataFiles().size();
    }

    @Override
    @Deprecated
    public int countSignatures() {
        return getSignatures().size();
    }

    @Override
    @Deprecated
    public DoreplacedentType getDoreplacedentType() {
        return Container.DoreplacedentType.BDOC;
    }

    @Override
    @Deprecated
    public String getVersion() {
        return "";
    }

    @Override
    @Deprecated
    public void extendTo(SignatureProfile profile) {
        extendSignatureProfile(profile);
    }

    @Override
    @Deprecated
    public void save(String path) {
        saveAsFile(path);
    }

    @Override
    @Deprecated
    public DataFile getDataFile(int index) {
        return getDataFiles().get(index);
    }

    @Override
    @Deprecated
    public Signature getSignature(int index) {
        return getSignatures().get(index);
    }

    /**
     * Prepare signing method is not supported by ASiC container.
     *
     * @param signerCert X509 Certificate to be used for preparing the signature
     * @return NotSupportedException
     */
    @Override
    @Deprecated
    public SignedInfo prepareSigning(X509Certificate signerCert) {
        throw new NotSupportedException("Prepare signing method is not supported by Asic container");
    }

    /**
     * Getting signature profile method is not supported by ASiC container.
     *
     * @return NotSupportedException
     */
    @Override
    @Deprecated
    public String getSignatureProfile() {
        throw new NotSupportedException("Getting signature profile method is not supported by Asic container");
    }

    /**
     * Setting signature parameters method is not supported by ASiC container
     *
     * @param signatureParameters Signature parameters. These are  related to the signing location and signer roles
     */
    @Override
    @Deprecated
    public void setSignatureParameters(SignatureParameters signatureParameters) {
        throw new NotSupportedException("Setting signature parameters method is not supported by Asic container");
    }

    /**
     * Getting digest algorithm method is not supported by ASiC container.
     *
     * @return NotSupportedException.
     */
    @Override
    @Deprecated
    public DigestAlgorithm getDigestAlgorithm() {
        throw new NotSupportedException("Getting digest algorithm method is not supported by Asic container");
    }

    /**
     * Sign method is not supported by ASiC container.
     *
     * @param signatureToken signatureToken implementation
     * @return NotSupportedException
     */
    @Override
    @Deprecated
    public Signature sign(SignatureToken signatureToken) {
        throw new NotSupportedException("Sign method is not supported by Asic container");
    }

    /**
     * Sign raw method is not supported by ASiC container.
     *
     * @param rawSignature raw signature
     * @return NotSupportedException
     */
    @Override
    @Deprecated
    public Signature signRaw(byte[] rawSignature) {
        throw new NotSupportedException("Sign raw method is not supported by Asic container");
    }

    /**
     * Setting signature profile method is not supported by ASiC container.
     *
     * @param profile signature profile
     */
    @Override
    @Deprecated
    public void setSignatureProfile(SignatureProfile profile) {
        throw new NotSupportedException("Setting signature profile method is not supported by Asic container");
    }

    public AsicParseResult getContainerParseResult() {
        return containerParseResult;
    }
}

16 View Complete Implementation : DetachedContentCreator.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
private void populateDetachedContent(Collection<DataFile> dataFiles) {
    Iterator<DataFile> dataFileIterator = dataFiles.iterator();
    firstDetachedContent = dataFileIterator.next().getDoreplacedent();
    detachedContentList.add(firstDetachedContent);
    while (dataFileIterator.hasNext()) {
        DataFile dataFile = dataFileIterator.next();
        DSSDoreplacedent doreplacedent = dataFile.getDoreplacedent();
        detachedContentList.add(doreplacedent);
    }
}

16 View Complete Implementation : AsicContainerParserTest.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
@Test
public void parseBDocFromFile() throws Exception {
    AsicParseResult result = this.getParseResultFromFile(Paths.get("src/test/resources/testFiles/valid-containers/23147_weak-warning-sha1.bdoc"));
    for (DataFile dataFile : result.getDataFiles()) {
        replacedert.replacedertEquals(dataFile.getName(), "jdigidoc.cfg");
        replacedert.replacedertEquals(dataFile.getMediaType(), "text/html");
    }
}

16 View Complete Implementation : ContainerParticlesRemovalTest.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
private void containerParseResultContainsDataFile(AsicParseResult containerParseResult, final String dataFileName) {
    boolean dataFileInAsicEntries = false;
    for (AsicEntry asicEntry : containerParseResult.getAsicEntries()) {
        dataFileInAsicEntries = dataFileName.equals(asicEntry.getContent().getName());
        if (dataFileInAsicEntries) {
            break;
        }
    }
    replacedertTrue(dataFileInAsicEntries);
    boolean dataFileInDataFiles = false;
    for (DataFile dataFile : containerParseResult.getDataFiles()) {
        dataFileInDataFiles = dataFile.getName().equals(dataFileName);
        if (dataFileInDataFiles) {
            break;
        }
    }
    replacedertTrue(dataFileInDataFiles);
    boolean dataFileInDetachedContents = false;
    for (DSSDoreplacedent detachedContent : containerParseResult.getDetachedContents()) {
        dataFileInDetachedContents = detachedContent.getName().equals(dataFileName);
        if (dataFileInDetachedContents) {
            break;
        }
    }
    replacedertTrue(dataFileInDetachedContents);
}

16 View Complete Implementation : ContainerParticlesRemovalTest.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
@Test
public void dataFileRemovalFromBDocContainerThroughoutContainerSavingAndOpening_shouldResultWithCompletelyRemovedData() {
    DataFile dataFile = mockDataFile();
    BDocContainer container = this.createEmptyContainerBy(BDOC);
    container.addDataFile(dataFile);
    replacedertTrue(container.getDataFiles().contains(dataFile));
    replacedertNull(container.getContainerParseResult());
    InputStream containerStream = container.savereplacedtream();
    container = (BDocContainer) ContainerBuilder.aContainer(BDOC).fromStream(containerStream).build();
    replacedertEquals(1, container.getDataFiles().size());
    replacedertEquals(dataFile.getName(), container.getDataFiles().get(0).getName());
    containerParseResultContainsDataFile(container.getContainerParseResult(), dataFile.getName());
    replacedertTrue(container.validate().isValid());
    container.removeDataFile(dataFile.getName());
    replacedertTrue(container.getDataFiles().isEmpty());
    containerParseResultDoesNotContainDataFile(container.getContainerParseResult(), dataFile.getName());
    replacedertTrue(container.validate().isValid());
    containerStream = container.savereplacedtream();
    container = (BDocContainer) ContainerBuilder.aContainer(BDOC).fromStream(containerStream).build();
    replacedertTrue(container.getDataFiles().isEmpty());
    containerParseResultDoesNotContainDataFile(container.getContainerParseResult(), dataFile.getName());
    replacedertTrue(container.validate().isValid());
}

16 View Complete Implementation : DataToSignSerializationTest.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
private Signature finalizeAndValidateDetachedSignature(DataFile dataFile, SignatureProfile signatureProfile, int dataToSignAdditionalWeightInBytes) {
    DataToSign dataToSign = DetachedXadesSignatureBuilder.withConfiguration(Configuration.of(Configuration.Mode.TEST)).withDataFile(dataFile).withSignatureProfile(signatureProfile).withSigningCertificate(pkcs12SignatureToken.getCertificate()).buildDataToSign();
    return finalizeAndValidateSignature(dataToSign, 1, dataToSignAdditionalWeightInBytes);
}

15 View Complete Implementation : Helper.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
/**
 * Saves all datafiles to specified folder
 *
 * @param container as Container object
 * @param path      as String
 */
public static void saveAllFilesFromContainerToFolder(Container container, String path) {
    for (DataFile dataFile : container.getDataFiles()) {
        File file = new File(path + File.separator + dataFile.getName());
        DSSUtils.saveToFile(dataFile.getBytes(), file);
    }
}

15 View Complete Implementation : ContainerParticlesRemovalTest.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
private void containerParseResultDoesNotContainDataFile(AsicParseResult containerParseResult, String dataFileName) {
    for (AsicEntry asicEntry : containerParseResult.getAsicEntries()) {
        replacedertNotEquals(dataFileName, asicEntry.getContent().getName());
    }
    for (DataFile dataFile : containerParseResult.getDataFiles()) {
        replacedertNotEquals(dataFile.getName(), dataFileName);
    }
    for (DSSDoreplacedent detachedContent : containerParseResult.getDetachedContents()) {
        replacedertNotEquals(detachedContent.getName(), dataFileName);
    }
}

14 View Complete Implementation : AsicContainerParser.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
private void extractDataFile(ZipEntry entry) {
    logger.debug("Extracting data file");
    String fileName = entry.getName();
    validateDataFile(fileName);
    DSSDoreplacedent doreplacedent = extractStreamDoreplacedent(entry);
    DataFile dataFile = new AsicDataFile(doreplacedent);
    dataFiles.put(fileName, dataFile);
    detachedContents.add(doreplacedent);
    extractAsicEntry(entry, doreplacedent);
}

14 View Complete Implementation : Helper.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
/**
 * gets all datafiles as List<byte[]> from Container
 *
 * @param container as Container object
 */
public static List<byte[]> getAllFilesFromContainerAsBytes(Container container) {
    List<byte[]> files = new ArrayList<>();
    for (DataFile dataFile : container.getDataFiles()) {
        files.add(dataFile.getBytes());
    }
    return files;
}

14 View Complete Implementation : Helper.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
/**
 * Saves all datafiles to specified folder
 *
 * @param pathFrom as String
 * @param pathTo   as String
 */
public static void saveAllFilesFromContainerPathToFolder(String pathFrom, String pathTo) {
    Container container = ContainerBuilder.aContainer().fromExistingFile(pathFrom).build();
    for (DataFile dataFile : container.getDataFiles()) {
        File file = new File(pathTo + File.separator + dataFile.getName());
        DSSUtils.saveToFile(dataFile.getBytes(), file);
    }
}

13 View Complete Implementation : AsicContainerParser.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
/**
 * Abstract clreplaced for parsing ASiC containers.
 */
public abstract clreplaced AsicContainerParser {

    public static final String MANIFEST = "META-INF/manifest.xml";

    public static final String TIMESTAMP_TOKEN = "META-INF/timestamp.tst";

    private static final Logger logger = LoggerFactory.getLogger(AsicContainerParser.clreplaced);

    // Matches META-INF/*signatures*.xml where the last * is a number
    private static final String SIGNATURES_FILE_REGEX = "META-INF/(.*)signatures(.*).xml";

    private static final Pattern SIGNATURE_FILE_ENDING_PATTERN = Pattern.compile("(\\d+).xml");

    private final Configuration configuration;

    private AsicParseResult parseResult = new AsicParseResult();

    private List<DSSDoreplacedent> signatures = new ArrayList<>();

    private LinkedHashMap<String, DataFile> dataFiles = new LinkedHashMap<>();

    private List<DSSDoreplacedent> detachedContents = new ArrayList<>();

    private Integer currentSignatureFileIndex;

    private String mimeType;

    private String zipFileComment;

    private List<AsicEntry> asicEntries = new ArrayList<>();

    private Map<String, ManifestEntry> manifestFileItems = Collections.emptyMap();

    private ManifestParser manifestParser;

    private boolean storeDataFilesOnlyInMemory;

    private boolean manifestFound = false;

    private long maxDataFileCachedInBytes;

    private DataFile timestampToken;

    protected AsicContainerParser(Configuration configuration) {
        this.configuration = configuration;
        storeDataFilesOnlyInMemory = configuration.storeDataFilesOnlyInMemory();
        maxDataFileCachedInBytes = configuration.getMaxDataFileCachedInBytes();
    }

    /**
     * Method for parsing and validating ASiC container.
     * @return parsing result
     */
    public AsicParseResult read() {
        parseContainer();
        validateParseResult();
        populateParseResult();
        return parseResult;
    }

    protected abstract void parseContainer();

    protected abstract void extractManifest(ZipEntry entry);

    protected abstract InputStream getZipEntryInputStream(ZipEntry entry);

    protected void parseManifestEntry(DSSDoreplacedent manifestFile) {
        logger.debug("Parsing manifest");
        manifestParser = new ManifestParser(manifestFile);
        manifestFileItems = manifestParser.getManifestFileItems();
    }

    protected void parseEntry(ZipEntry entry) {
        String entryName = entry.getName();
        logger.debug("Paring zip entry " + entryName + " with comment: " + entry.getComment());
        if (isMimeType(entryName)) {
            extractMimeType(entry);
        } else if (isManifest(entryName)) {
            if (this.manifestFound) {
                throw new DigiDoc4JException("Multiple manifest.xml files disallowed");
            }
            this.manifestFound = true;
            extractManifest(entry);
        } else if (isSignaturesFile(entryName)) {
            determineCurrentSignatureFileIndex(entryName);
            extractSignature(entry);
        } else if (isDataFile(entryName)) {
            extractDataFile(entry);
        } else if (isTimeStampToken(entryName)) {
            extractTimeStamp(entry);
        } else {
            extractAsicEntry(entry);
        }
    }

    private void extractMimeType(ZipEntry entry) {
        try {
            InputStream zipFileInputStream = getZipEntryInputStream(entry);
            BOMInputStream bomInputStream = new BOMInputStream(zipFileInputStream);
            DSSDoreplacedent doreplacedent = new InMemoryDoreplacedent(bomInputStream);
            mimeType = StringUtils.trim(IOUtils.toString(getDoreplacedentBytes(doreplacedent), "UTF-8"));
            extractAsicEntry(entry, doreplacedent);
        } catch (IOException e) {
            logger.error("Error parsing container mime type: " + e.getMessage());
            throw new TechnicalException("Error parsing container mime type: " + e.getMessage(), e);
        }
    }

    private void extractSignature(ZipEntry entry) {
        logger.debug("Extracting signature");
        InputStream zipFileInputStream = getZipEntryInputStream(entry);
        String fileName = entry.getName();
        InMemoryDoreplacedent doreplacedent = new InMemoryDoreplacedent(zipFileInputStream, fileName);
        signatures.add(doreplacedent);
        extractSignatureAsicEntry(entry, doreplacedent);
    }

    private void extractTimeStamp(ZipEntry entry) {
        logger.debug("Extracting timestamp file");
        InputStream zipFileInputStream = getZipEntryInputStream(entry);
        String fileName = entry.getName();
        timestampToken = new DataFile(zipFileInputStream, fileName, MimeType.TST.getMimeTypeString());
    }

    private void extractDataFile(ZipEntry entry) {
        logger.debug("Extracting data file");
        String fileName = entry.getName();
        validateDataFile(fileName);
        DSSDoreplacedent doreplacedent = extractStreamDoreplacedent(entry);
        DataFile dataFile = new AsicDataFile(doreplacedent);
        dataFiles.put(fileName, dataFile);
        detachedContents.add(doreplacedent);
        extractAsicEntry(entry, doreplacedent);
    }

    private DSSDoreplacedent extractStreamDoreplacedent(ZipEntry entry) {
        logger.debug("Zip entry size is <{}> bytes", entry.getSize());
        MimeType mimeTypeCode = MimeTypeUtil.mimeTypeOf(this.getDataFileMimeType(entry.getName()));
        if (this.storeDataFilesOnlyInMemory || entry.getSize() <= this.maxDataFileCachedInBytes) {
            return new InMemoryDoreplacedent(this.getZipEntryInputStream(entry), entry.getName(), mimeTypeCode);
        } else {
            return new StreamDoreplacedent(this.getZipEntryInputStream(entry), entry.getName(), mimeTypeCode);
        }
    }

    protected AsicEntry extractAsicEntry(ZipEntry entry) {
        logger.debug("Extracting asic entry");
        DSSDoreplacedent doreplacedent = extractStreamDoreplacedent(entry);
        return extractAsicEntry(entry, doreplacedent);
    }

    private AsicEntry extractAsicEntry(ZipEntry zipEntry, DSSDoreplacedent doreplacedent) {
        AsicEntry asicEntry = new AsicEntry(zipEntry);
        asicEntry.setContent(doreplacedent);
        asicEntries.add(asicEntry);
        return asicEntry;
    }

    private void extractSignatureAsicEntry(ZipEntry entry, DSSDoreplacedent doreplacedent) {
        AsicEntry asicEntry = extractAsicEntry(entry, doreplacedent);
        asicEntry.setSignature(true);
    }

    protected String getDataFileMimeType(String fileName) {
        if (manifestFileItems.containsKey(fileName)) {
            ManifestEntry manifestEntry = manifestFileItems.get(fileName);
            return manifestEntry.getMimeType();
        } else {
            MimeType mimetype = MimeType.fromFileName(fileName);
            return mimetype.getMimeTypeString();
        }
    }

    private void validateParseResult() {
        if (!StringUtils.equalsIgnoreCase(MimeType.ASICE.getMimeTypeString(), mimeType) && !StringUtils.equalsIgnoreCase(MimeType.ASICS.getMimeTypeString(), mimeType)) {
            logger.error("Container mime type is not " + MimeType.ASICE.getMimeTypeString() + " but is " + mimeType);
            throw new UnsupportedFormatException("Container mime type is not " + MimeType.ASICE.getMimeTypeString() + " OR " + MimeType.ASICS.getMimeTypeString() + " but is " + mimeType);
        }
        if (!this.signatures.isEmpty() && this.dataFiles.isEmpty()) {
            throw new ContainerWithoutFilesException("The reference data object(s) is not found!");
        }
    }

    private void validateDataFile(String fileName) {
        if (dataFiles.containsKey(fileName)) {
            logger.error("Container contains duplicate data file: " + fileName);
            throw new DuplicateDataFileException("Container contains duplicate data file: " + fileName);
        }
    }

    private void populateParseResult() {
        Collection<DataFile> files = dataFiles.values();
        parseResult.setDataFiles(new ArrayList<>(files));
        parseResult.setCurrentUsedSignatureFileIndex(currentSignatureFileIndex);
        parseResult.setDetachedContents(detachedContents);
        parseResult.setSignatures(parseSignatures());
        parseResult.setManifestParser(manifestParser);
        parseResult.setZipFileComment(zipFileComment);
        parseResult.setAsicEntries(asicEntries);
        parseResult.setTimeStampToken(timestampToken);
        parseResult.setMimeType(mimeType);
    }

    private List<XadesSignatureWrapper> parseSignatures() {
        AsicSignatureParser signatureParser = new AsicSignatureParser(parseResult.getDetachedContents(), configuration);
        List<XadesSignatureWrapper> parsedSignatures = new ArrayList<>();
        for (DSSDoreplacedent signatureDoreplacedent : signatures) {
            XadesSignature signature = signatureParser.parse(signatureDoreplacedent);
            parsedSignatures.add(new XadesSignatureWrapper(signature, signatureDoreplacedent));
        }
        return parsedSignatures;
    }

    private boolean isMimeType(String entryName) {
        return StringUtils.equalsIgnoreCase("mimetype", entryName);
    }

    private boolean isDataFile(String entryName) {
        return !entryName.startsWith("META-INF/") && !isMimeType(entryName);
    }

    private boolean isTimeStampToken(String entryName) {
        return StringUtils.equalsIgnoreCase(TIMESTAMP_TOKEN, entryName);
    }

    private boolean isManifest(String entryName) {
        return StringUtils.equalsIgnoreCase(MANIFEST, entryName);
    }

    private boolean isSignaturesFile(String entryName) {
        return entryName.matches(SIGNATURES_FILE_REGEX);
    }

    private void determineCurrentSignatureFileIndex(String entryName) {
        Matcher fileEndingMatcher = SIGNATURE_FILE_ENDING_PATTERN.matcher(entryName);
        boolean fileEndingFound = fileEndingMatcher.find();
        if (fileEndingFound) {
            String fileEnding = fileEndingMatcher.group();
            String indexNumber = fileEnding.replace(".xml", "");
            int fileIndex = Integer.parseInt(indexNumber);
            if (currentSignatureFileIndex == null || currentSignatureFileIndex <= fileIndex) {
                currentSignatureFileIndex = fileIndex;
            }
        }
    }

    private byte[] getDoreplacedentBytes(DSSDoreplacedent doreplacedent) {
        try {
            return IOUtils.toByteArray(doreplacedent.openStream());
        } catch (IOException e) {
            logger.error("Error getting doreplacedent content: " + e.getMessage());
            throw new TechnicalException("Error getting doreplacedent content: " + e.getMessage(), e);
        }
    }

    void setZipFileComment(String zipFileComment) {
        this.zipFileComment = zipFileComment;
    }

    LinkedHashMap<String, DataFile> getDataFiles() {
        return dataFiles;
    }
}

13 View Complete Implementation : CommandLineExecutor.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
private void signContainerWithTst(AsicContainer asicContainer) {
    if (this.context.getCommandLine().hasOption("tst") && !(this.context.getCommandLine().hasOption("pkcs12") || this.context.getCommandLine().hasOption("pkcs11"))) {
        DigestAlgorithm digestAlgorithm = DigestAlgorithm.SHA256;
        if (this.context.getCommandLine().hasOption("datst")) {
            String digestAlgorithmStr = this.context.getCommandLine().getOptionValue("datst");
            if (StringUtils.isNotBlank(digestAlgorithmStr)) {
                digestAlgorithm = DigestAlgorithm.forName(digestAlgorithmStr);
            }
        }
        LOGGER.info("Digest algorithm to calculate data file hash: " + digestAlgorithm.getName());
        if (this.context.getCommandLine().hasOption("add")) {
            if (asicContainer.getDataFiles().size() > 1) {
                throw new DigiDoc4JException("Data file in container already exists. Should be only one data file in case of ASiCS container.");
            }
            String[] optionValues = this.context.getCommandLine().getOptionValues("add");
            DataFile dataFile = new DataFile(optionValues[0], optionValues[1]);
            DataFile tst = TimestampToken.generateTimestampToken(digestAlgorithm, dataFile);
            asicContainer.setTimeStampToken(tst);
            this.fileHasChanged = true;
        }
    }
}

13 View Complete Implementation : Helper.java
Copyright GNU Lesser General Public License v2.1
Author : open-eid
/**
 * gets all datafiles as List<byte[]> from Container path
 *
 * @param pathFrom as String
 */
public static List<byte[]> getAllFilesFromContainerPathAsBytes(String pathFrom) {
    Container container = ContainerBuilder.aContainer().fromExistingFile(pathFrom).build();
    List<byte[]> files = new ArrayList<>();
    for (DataFile dataFile : container.getDataFiles()) {
        files.add(dataFile.getBytes());
    }
    return files;
}