embeddable;
public MyGIFShuffle(ImageFormat image) {
embeddable = new GIFShuffle((GIFImage) image, new GIFPointFilterNone());
}
@Override
public void embed(Payload payload, EmbeddingProgress progress, EmbeddingDoneListener listener)
throws SteganoEmbedException {
GIFImage embeddedImage = embeddable.embed(payload, progress);
listener.onEmbeddingDone(embeddable, embeddedImage);
}
@Override
public void extract(Payload payload, EmbeddingProgress progress, ExtractingDoneListener listener)
throws SteganoExtractException {
embeddable.extract(payload, progress);
listener.onExtractingDone(embeddable);
}
@Override
public int getCapacity() {
return embeddable.capacity();
}
@Override
public void setPointFilter(int a) {
// no point filter used
}
}
stegosuite/src/main/java/org/stegosuite/application/embedding/MyGIFShuffleFirst.java 0000664 0000000 0000000 00000006250 15260777315 0031233 0 ustar 00root root 0000000 0000000 package org.stegosuite.application.embedding;
import java.util.logging.Logger;
import org.stegosuite.image.embedding.EmbeddingProgress;
import org.stegosuite.image.format.ImageFormat;
import org.stegosuite.model.exception.SteganoEmbedException;
import org.stegosuite.model.exception.SteganoExtractException;
import org.stegosuite.model.payload.Payload;
/**
* GIF embedding that prefers GIFShuffle and falls back to the sorted color table method.
*
* GIFShuffle hides the payload in the order of the palette only, leaving all pixel data untouched,
* but its capacity is limited to log2(n!) bits for a palette of n distinct colors. Payloads that do
* not fit are embedded with {@link MyGIFSortedColorTable} instead, which alters pixel data and can
* carry far more.
*
* A steganogram does not record which method was used, so extraction tries both, starting with
* GIFShuffle. Trying the wrong method fails instead of returning garbage: the payload length header
* has to make sense, and the payload is compressed and encrypted, so it only decodes back into a
* readable payload when it was read from the steganogram that actually carries it.
*/
public class MyGIFShuffleFirst extends Embedding {
private static final Logger LOG = Logger.getLogger(
MyGIFShuffleFirst.class.getName()
);
private final Embedding shuffle;
private final Embedding sortedColorTable;
public MyGIFShuffleFirst(ImageFormat image) {
shuffle = new MyGIFShuffle(image);
sortedColorTable = new MyGIFSortedColorTable(image);
}
@Override
public void embed(
Payload payload,
EmbeddingProgress progress,
EmbeddingDoneListener listener
) throws SteganoEmbedException {
try {
shuffle.embed(payload, progress, listener);
} catch (SteganoEmbedException e) {
LOG.fine(
() ->
"GIFShuffle embedding failed (" +
e.getMessage() +
"), falling back to the sorted color table method"
);
sortedColorTable.embed(payload, progress, listener);
}
}
@Override
public void extract(
Payload payload,
EmbeddingProgress progress,
ExtractingDoneListener listener
) throws SteganoExtractException {
try {
shuffle.extract(payload, progress, listener);
} catch (SteganoExtractException e) {
LOG.fine(
() ->
"GIFShuffle extraction failed (" +
e.getMessage() +
"), trying the sorted color table method"
);
sortedColorTable.extract(payload, progress, listener);
}
}
/**
* Returns the capacity of the method that will actually be used, so every payload up to this
* size can be embedded: by GIFShuffle if it fits, otherwise by the sorted color table method.
*/
@Override
public int getCapacity() {
return Math.max(shuffle.getCapacity(), sortedColorTable.getCapacity());
}
@Override
public void setPointFilter(int a) {
shuffle.setPointFilter(a);
sortedColorTable.setPointFilter(a);
}
}
stegosuite/src/main/java/org/stegosuite/application/embedding/MyGIFSortedColorTable.java 0000664 0000000 0000000 00000003630 15260777315 0032035 0 ustar 00root root 0000000 0000000 package org.stegosuite.application.embedding;
import org.stegosuite.image.embedding.EmbeddingMethod;
import org.stegosuite.image.embedding.EmbeddingProgress;
import org.stegosuite.image.embedding.gif.GIFSortedColorTable;
import org.stegosuite.image.embedding.gif.filter.GIFPointFilterHomogeneous;
import org.stegosuite.image.embedding.gif.filter.GIFPointFilterNone;
import org.stegosuite.image.format.GIFImage;
import org.stegosuite.image.format.ImageFormat;
import org.stegosuite.model.exception.SteganoEmbedException;
import org.stegosuite.model.exception.SteganoExtractException;
import org.stegosuite.model.payload.Payload;
/**
* Abstraction layer between the GUI and the embed/extract functions.
*/
public class MyGIFSortedColorTable
extends Embedding {
private EmbeddingMethod embeddable;
private final EmbeddingMethod embeddablePoint;
private final EmbeddingMethod embeddableNoPoint;
public MyGIFSortedColorTable(ImageFormat image) {
embeddableNoPoint = new GIFSortedColorTable((GIFImage) image, new GIFPointFilterNone());
embeddablePoint = new GIFSortedColorTable((GIFImage) image, new GIFPointFilterHomogeneous());
embeddable = embeddableNoPoint;
}
@Override
public void embed(Payload payload, EmbeddingProgress progress, EmbeddingDoneListener listener)
throws SteganoEmbedException {
GIFImage embeddedImage = embeddable.embed(payload, progress);
listener.onEmbeddingDone(embeddable, embeddedImage);
}
@Override
public void extract(Payload payload, EmbeddingProgress progress, ExtractingDoneListener listener)
throws SteganoExtractException {
embeddable.extract(payload, progress);
listener.onExtractingDone(embeddable);
}
@Override
public int getCapacity() {
return embeddable.capacity();
}
@Override
public void setPointFilter(int a) {
if (a == 0) {
embeddable = embeddableNoPoint;
} else if (a == 1) {
embeddable = embeddablePoint;
}
}
}
stegosuite/src/main/java/org/stegosuite/application/embedding/MyJPGF5.java 0000664 0000000 0000000 00000002706 15260777315 0027116 0 ustar 00root root 0000000 0000000 package org.stegosuite.application.embedding;
import org.stegosuite.image.embedding.EmbeddingMethod;
import org.stegosuite.image.embedding.EmbeddingProgress;
import org.stegosuite.image.embedding.jpg.JPGF5;
import org.stegosuite.image.embedding.jpg.filter.JPGPointFilterNone;
import org.stegosuite.image.format.ImageFormat;
import org.stegosuite.image.format.JPGImage;
import org.stegosuite.model.exception.SteganoEmbedException;
import org.stegosuite.model.exception.SteganoExtractException;
import org.stegosuite.model.payload.Payload;
/**
* Abstraction layer between the GUI and the embed/extract functions.
*/
public class MyJPGF5
extends Embedding {
private final EmbeddingMethod embeddable;
public MyJPGF5(ImageFormat image) {
embeddable = new JPGF5((JPGImage) image, new JPGPointFilterNone());
}
@Override
public void embed(Payload payload, EmbeddingProgress progress, EmbeddingDoneListener listener)
throws SteganoEmbedException {
JPGImage embeddedImage = embeddable.embed(payload, progress);
listener.onEmbeddingDone(embeddable, embeddedImage);
}
@Override
public void extract(Payload payload, EmbeddingProgress progress, ExtractingDoneListener listener)
throws SteganoExtractException {
embeddable.extract(payload, progress);
listener.onExtractingDone(embeddable);
}
@Override
public int getCapacity() {
return embeddable.capacity();
}
@Override
public void setPointFilter(int a) {
// no point filter used
}
}
stegosuite/src/main/java/org/stegosuite/application/embedding/MyPNGLsbMultiColorChannel.java 0000664 0000000 0000000 00000003654 15260777315 0032676 0 ustar 00root root 0000000 0000000 package org.stegosuite.application.embedding;
import org.stegosuite.image.embedding.EmbeddingMethod;
import org.stegosuite.image.embedding.EmbeddingProgress;
import org.stegosuite.image.embedding.png.PNGLsbMultiColorChannel;
import org.stegosuite.image.embedding.png.filter.PNGPointFilterHomogeneous;
import org.stegosuite.image.embedding.png.filter.PNGPointFilterNone;
import org.stegosuite.image.format.ImageFormat;
import org.stegosuite.image.format.PNGImage;
import org.stegosuite.model.exception.SteganoEmbedException;
import org.stegosuite.model.exception.SteganoExtractException;
import org.stegosuite.model.payload.Payload;
/**
* Abstraction layer between the GUI and the embed/extract functions.
*/
public class MyPNGLsbMultiColorChannel
extends Embedding {
private EmbeddingMethod embeddable;
private final EmbeddingMethod embeddablePoint;
private final EmbeddingMethod embeddableNoPoint;
public MyPNGLsbMultiColorChannel(ImageFormat image) {
embeddableNoPoint = new PNGLsbMultiColorChannel((PNGImage) image, new PNGPointFilterNone());
embeddablePoint = new PNGLsbMultiColorChannel((PNGImage) image, new PNGPointFilterHomogeneous());
embeddable = embeddableNoPoint;
}
@Override
public void embed(Payload payload, EmbeddingProgress progress, EmbeddingDoneListener listener)
throws SteganoEmbedException {
PNGImage embeddedImage = embeddable.embed(payload, progress);
listener.onEmbeddingDone(embeddable, embeddedImage);
}
@Override
public void extract(Payload payload, EmbeddingProgress progress, ExtractingDoneListener listener)
throws SteganoExtractException {
embeddable.extract(payload, progress);
listener.onExtractingDone(embeddable);
}
@Override
public int getCapacity() {
return embeddable.capacity();
}
@Override
public void setPointFilter(int a) {
if (a == 0) {
embeddable = embeddableNoPoint;
} else if (a == 1) {
embeddable = embeddablePoint;
}
}
}
stegosuite/src/main/java/org/stegosuite/image/ 0000775 0000000 0000000 00000000000 15260777315 0021766 5 ustar 00root root 0000000 0000000 stegosuite/src/main/java/org/stegosuite/image/embedding/ 0000775 0000000 0000000 00000000000 15260777315 0023704 5 ustar 00root root 0000000 0000000 stegosuite/src/main/java/org/stegosuite/image/embedding/EmbeddingMethod.java 0000664 0000000 0000000 00000006773 15260777315 0027603 0 ustar 00root root 0000000 0000000 package org.stegosuite.image.embedding;
import org.stegosuite.image.embedding.point.PointFilter;
import org.stegosuite.image.format.ImageFormat;
import org.stegosuite.model.exception.SteganoEmbedException;
import org.stegosuite.model.exception.SteganoExtractException;
import org.stegosuite.model.payload.Payload;
/**
* Each embedding technique we support (SortedColorTable, Shuffle, LSB for bitmaps) needs to
* implement this interface
*
* @param The image format which the embedding method supports
*/
public abstract class EmbeddingMethod {
/**
* The image to embed to or extract from. The actual image to embed into or extract from is
* passed to the doEmbed() and doExtract() methods to make sure this image is not modified
*/
private final T image;
/**
* The filter to apply before embedding or extraction to skip certain points
*/
protected final PointFilter pointFilter;
/**
* Keeps track of the processed pixels in the image. Needs to be properly initialized in the
* implementing class and can then be used in the embed() and extract() methods.
*/
protected Visualizer visualizer = null;
/**
* Constructor
*
* @param image The image to embed to or extract from
* @param pointFilter The filter to apply before embedding or extraction to skip certain points
*/
public EmbeddingMethod(T image, PointFilter pointFilter) {
this.image = image;
this.pointFilter = pointFilter;
}
/**
* Returns the number of bytes that the current embedding technique is able to embed into the
* passed image
*
* @return
*/
public final int capacity() {
return this.doCapacity(this.image);
}
/**
* Internal capacity method implemented by subclasses
*
* @param image
* @return
*/
protected abstract int doCapacity(T image);
/**
* Embeds the payload into the carrier image
*
* @param payload
* @param progress
* @return
* @throws SteganoEmbedException
*/
public final T embed(Payload payload, EmbeddingProgress progress)
throws SteganoEmbedException {
@SuppressWarnings("unchecked")
T clonedImage = (T) this.image.clone();
this.visualizer = this.createVisualizer(clonedImage);
this.doEmbed(clonedImage, payload, progress);
return clonedImage;
}
/**
* Internal embedding method implemented by subclasses
*
* @param payload
* @param progress
* @throws SteganoEmbedException
*/
protected abstract void doEmbed(T image, Payload payload, EmbeddingProgress progress)
throws SteganoEmbedException;
/**
* Extracts the payload from the steganogram
*
* @param payload
* @param progress
* @throws SteganoExtractException
*/
public final void extract(Payload payload, EmbeddingProgress progress)
throws SteganoExtractException {
this.visualizer = this.createVisualizer(this.image);
this.doExtract(this.image, payload, progress);
}
/**
* Internal extraction method implemented by subclasses
*
* @param image
* @param payload
* @param progress
* @throws SteganoExtractException
*/
protected abstract void doExtract(T image, Payload payload, EmbeddingProgress progress)
throws SteganoExtractException;
/**
* Gets the current visualizer for this embedding method
*
* @return
*/
public Visualizer getVisualizer() {
return this.visualizer;
}
/**
* If the subclass supports visualizing the embedding/extraction process it needs to override
* this method and return a new Visualizer instance
*
* @return
*/
protected Visualizer createVisualizer(T image) {
return null;
}
}
stegosuite/src/main/java/org/stegosuite/image/embedding/EmbeddingProgress.java 0000664 0000000 0000000 00000002127 15260777315 0030154 0 ustar 00root root 0000000 0000000 package org.stegosuite.image.embedding;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
public class EmbeddingProgress {
private int currentPercentage = 0;
private final List listeners =
new CopyOnWriteArrayList<>();
public EmbeddingProgress() {}
/**
* Adds a progress listener.
*
* @param listener the listener to add
*/
public void addProgressListener(ProgressListener listener) {
listeners.add(listener);
}
/**
* Removes a progress listener.
*
* @param listener the listener to remove
*/
public void removeProgressListener(ProgressListener listener) {
listeners.remove(listener);
}
public void progressUpdate(int currentByte, int totalBytes) {
int newPercentage = (100 * currentByte) / totalBytes;
if (newPercentage > currentPercentage) {
currentPercentage = newPercentage;
for (ProgressListener listener : listeners) {
listener.onProgressUpdate(currentPercentage);
}
}
}
}
stegosuite/src/main/java/org/stegosuite/image/embedding/ProgressListener.java 0000664 0000000 0000000 00000000474 15260777315 0030066 0 ustar 00root root 0000000 0000000 package org.stegosuite.image.embedding;
/**
* Listener interface for receiving progress updates.
*/
@FunctionalInterface
public interface ProgressListener {
/**
* Called when progress is updated.
*
* @param percentage the current progress percentage (0-100)
*/
void onProgressUpdate(int percentage);
}
stegosuite/src/main/java/org/stegosuite/image/embedding/Visualizer.java 0000664 0000000 0000000 00000003405 15260777315 0026706 0 ustar 00root root 0000000 0000000 package org.stegosuite.image.embedding;
import org.eclipse.swt.graphics.ImageData;
import org.stegosuite.image.format.ImageFormat;
import org.stegosuite.util.ColorUtils;
import org.stegosuite.util.ImageSwtAwtConverter;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.util.Arrays;
import java.util.Map;
import static java.util.stream.Collectors.toMap;
public class Visualizer {
/**
* The different modes of visualization
*/
public enum VisualizationMode {
ALTERED, UNALTERED
}
/**
* Ties a mode to a specific color
*/
public static class Visualize {
private final VisualizationMode mode;
private final Color color;
public Visualize(VisualizationMode mode, Color color) {
this.mode = mode;
this.color = color;
}
public VisualizationMode getMode() {
return mode;
}
public Color getColor() {
return color;
}
}
private final Map visualizations;
private final BufferedImage visualizationBufferedImage;
public Visualizer(ImageFormat image, Visualize... visualizations) {
visualizationBufferedImage = ColorUtils.cloneBufferedImage(image.getBufferedImage());
this.visualizations = Arrays.stream(visualizations).collect(toMap(Visualize::getMode, Visualize::getColor));
}
/**
* Changes the color of the visualization image at the specified point according to the
* visualization mode
*
* @param point
* @param mode
*/
public void visualize(Point point, VisualizationMode mode) {
visualizationBufferedImage.setRGB(point.x, point.y, visualizations.get(mode).getRGB());
}
/**
* Returns a copy of the visualization image in ImageData format
*
* @return
*/
public ImageData getImageData() {
return ImageSwtAwtConverter.convertToSWT(visualizationBufferedImage);
}
}
stegosuite/src/main/java/org/stegosuite/image/embedding/bmp/ 0000775 0000000 0000000 00000000000 15260777315 0024462 5 ustar 00root root 0000000 0000000 stegosuite/src/main/java/org/stegosuite/image/embedding/bmp/BMPLsbMultiColorChannel.java 0000664 0000000 0000000 00000016457 15260777315 0031724 0 ustar 00root root 0000000 0000000 package org.stegosuite.image.embedding.bmp;
import java.awt.*;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.logging.Logger;
import org.stegosuite.image.embedding.EmbeddingMethod;
import org.stegosuite.image.embedding.EmbeddingProgress;
import org.stegosuite.image.embedding.Visualizer;
import org.stegosuite.image.embedding.Visualizer.VisualizationMode;
import org.stegosuite.image.embedding.Visualizer.Visualize;
import org.stegosuite.image.embedding.point.PointFilter;
import org.stegosuite.image.embedding.point.PointGenerator;
import org.stegosuite.image.format.BMPImage;
import org.stegosuite.model.exception.SteganoEmbedException;
import org.stegosuite.model.exception.SteganoExtractException;
import org.stegosuite.model.exception.SteganoKeyException;
import org.stegosuite.model.payload.Payload;
import org.stegosuite.model.payload.PayloadEmbedder;
import org.stegosuite.model.payload.PayloadExtractor;
import org.stegosuite.util.ByteUtils;
import org.stegosuite.util.RgbChannel;
/**
* Embed/Extract on BMP-images using data-spreading method. This method will utilise all {@code 3}
* color channels, sequentially, meaning the payload will first be embedded into the
* {@code red}-byte, then the {@code green} -byte, and finally the {@code blue}
* -byte.
*
* @author alwin
*/
public class BMPLsbMultiColorChannel extends EmbeddingMethod {
private static final Logger LOG = Logger.getLogger(
BMPLsbMultiColorChannel.class.getName()
);
/**
* Constructor
*
* @param image the {@link BMPImage} to be embedded/extracted
* @param pointFilter the {@link PointFilter} to filter out undesired areas of the given
* {@link BMPImage}
*/
public BMPLsbMultiColorChannel(
BMPImage image,
PointFilter pointFilter
) {
super(image, pointFilter);
}
@Override
public Visualizer createVisualizer(BMPImage image) {
return new Visualizer(
image,
new Visualize(VisualizationMode.ALTERED, Color.RED),
new Visualize(VisualizationMode.UNALTERED, Color.GREEN)
);
}
@Override
public int doCapacity(BMPImage image) {
LOG.fine(() -> "Embedding into " + pointFilter.maxLsbCount() + " LSBs");
// Embedding will be done on all 3 color channels
// Get the maximum number of LSBs from the point filter
int pixelCount = image.getWidth() * image.getHeight();
int filteredPixelCount = pointFilter.getFilteredPoints(image).size();
int embeddableBits =
(pixelCount - filteredPixelCount) * 3 * pointFilter.maxLsbCount();
return embeddableBits / 8;
}
@Override
protected void doEmbed(
BMPImage image,
Payload payload,
EmbeddingProgress progress
) throws SteganoEmbedException {
LOG.fine("Performing BMP LSB embedding");
PayloadEmbedder payloadEmbedder = new PayloadEmbedder(
payload,
this.capacity()
);
int numPayloadBytes = payloadEmbedder.getPayloadBytes().length;
// Initialize the data spreader
PointGenerator pointGenerator = new PointGenerator<>(
image,
payload.getSteganoPassword(),
pointFilter
);
int processedBits = 0;
Iterator payloadBits = payloadEmbedder
.iteratePayloadBits()
.iterator();
try {
while (payloadBits.hasNext()) {
// Get next point and its color
Point point = pointGenerator.nextPoint();
Color oldColor = new Color(
image.getBufferedImage().getRGB(point.x, point.y)
);
Color newColor = new Color(oldColor.getRGB());
// Embed into all 3 color channels
for (RgbChannel channel : RgbChannel.RGB()) {
byte bit = payloadBits.next();
int channelValue = channel.getValue(newColor);
channelValue = ByteUtils.setBitAt(
channelValue,
pointGenerator.getIterationCount() - 1,
bit
);
newColor = channel.setValue(newColor, channelValue);
processedBits++;
if (!payloadBits.hasNext()) {
break;
}
}
// Update visualization
visualizer.visualize(
point,
newColor.equals(oldColor)
? VisualizationMode.UNALTERED
: VisualizationMode.ALTERED
);
// Update pixel color
image
.getBufferedImage()
.setRGB(point.x, point.y, newColor.getRGB());
// Update progress
if (progress != null) {
progress.progressUpdate(processedBits / 8, numPayloadBytes);
}
}
} catch (NoSuchElementException e) {
throw new SteganoEmbedException(e.getMessage());
}
}
@Override
protected void doExtract(
BMPImage image,
Payload payload,
EmbeddingProgress progress
) throws SteganoExtractException {
LOG.fine("Performing BMP LSB extraction");
PayloadExtractor payloadExtractor = new PayloadExtractor(payload);
PointGenerator pointGenerator = new PointGenerator<>(
image,
payload.getSteganoPassword(),
pointFilter
);
try {
while (!payloadExtractor.finished()) {
// Get next point and its color
Point point = pointGenerator.nextPoint();
Color color = new Color(
image.getBufferedImage().getRGB(point.x, point.y)
);
// Extract from all 3 color channels
for (RgbChannel channel : RgbChannel.RGB()) {
int value = channel.getValue(color);
byte bit = ByteUtils.getBitAt(
value,
pointGenerator.getIterationCount() - 1
);
payloadExtractor.processBit(bit);
if (payloadExtractor.finished()) {
break;
}
}
// Update visualization
visualizer.visualize(point, VisualizationMode.ALTERED);
// Update progress
if (
progress != null &&
payloadExtractor.getPayloadLength() != null
) {
progress.progressUpdate(
payloadExtractor.getProcessedBytesCount(),
payloadExtractor.getPayloadLength()
);
}
}
} catch (NoSuchElementException e) {
LOG.fine(
() ->
"Error: The iteration count of PointGenerator exceeds its maximum iteration count (" +
pointFilter.maxLsbCount() +
")"
);
throw new SteganoKeyException();
}
}
}
stegosuite/src/main/java/org/stegosuite/image/embedding/bmp/filter/ 0000775 0000000 0000000 00000000000 15260777315 0025747 5 ustar 00root root 0000000 0000000 stegosuite/src/main/java/org/stegosuite/image/embedding/bmp/filter/BMPPointFilterHomogeneous.java 0000664 0000000 0000000 00000011535 15260777315 0033626 0 ustar 00root root 0000000 0000000 package org.stegosuite.image.embedding.bmp.filter;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.*;
import java.util.List;
import java.util.logging.Logger;
import org.stegosuite.image.embedding.point.PointFilter;
import org.stegosuite.image.format.BMPImage;
import org.stegosuite.model.exception.SteganoImageException;
/**
* Removes all points that are part of homogeneous areas of a BMP image
*/
public class BMPPointFilterHomogeneous extends PointFilter {
/**
* Sets the LSB of all 3 color channels of a 32bit RGB value to 0
*/
private static final int MASK_LSBS_TO_ZERO = ~0b10000000100000001;
private static final Logger LOG = Logger.getLogger(
BMPPointFilterHomogeneous.class.getName()
);
@Override
public int maxLsbCount() {
return 1;
}
/**
* Returns a list of all homogeneous areas
*/
@Override
protected Collection filter(BMPImage image) {
int[][] normalizedRgbValues = getNormalizedRgbValues(
image.getBufferedImage()
);
// long startTime = System.nanoTime();
Collection filteredPoints = new HashSet<>();
for (int x = 1; x < normalizedRgbValues.length - 1; x++) {
for (int y = 1; y < normalizedRgbValues[x].length - 1; y++) {
Collection homogenousPoints = getHomogeneousPoints(
normalizedRgbValues,
x,
y
);
filteredPoints.addAll(homogenousPoints);
}
}
// System.out.println("filter : " + (System.nanoTime() - startTime) / 1000000 + " ms");
return filteredPoints;
}
/**
* Returns a matrix of all RGB values that are present in the image with each value having set
* its LSBs for the 3 channels to zero.
*
* @param image
* @return
*/
private int[][] getNormalizedRgbValues(BufferedImage image) {
int width = image.getWidth();
int height = image.getHeight();
int[][] rgbValues = new int[width][];
for (int x = 0; x < width; x++) {
rgbValues[x] = new int[height];
for (int y = 0; y < height; y++) {
rgbValues[x][y] = image.getRGB(x, y) & MASK_LSBS_TO_ZERO;
}
}
return rgbValues;
}
/**
* Returns a list of points that are part of a homogeneous area around the x and y coordinate.
* Returns an empty list if the area is not homogeneous.
*
* @param normalizedRgbValues
* @param x
* @param y
* @return
*/
private Collection getHomogeneousPoints(
int[][] normalizedRgbValues,
int x,
int y
) {
Collection homogeneousPoints = new ArrayList<>();
int referenceRgbValue = normalizedRgbValues[x][y];
// System.out.println(Integer.toBinaryString(referenceRgbValue));
for (int dX = x - 1; dX <= x + 1; dX++) {
for (int dY = y - 1; dY <= y + 1; dY++) {
// As soon as 1 pixel in the area is different from the pixel in
// the center, the area is considered NOT to be homogeneous.
if (
dX != x &&
dY != y &&
normalizedRgbValues[dX][dY] != referenceRgbValue
) {
return Collections.emptyList();
}
homogeneousPoints.add(new Point(dX, dY));
}
}
return homogeneousPoints;
}
/**
* Debug only
*
* @param args
* @throws IOException
* @throws SteganoImageException
*/
public static void main(String[] args) throws SteganoImageException {
BMPImage bmpImage = new BMPImage();
bmpImage.load(new File("resources/Snow.bmp"));
LOG.fine(() -> "Width: " + bmpImage.getWidth());
LOG.fine(() -> "Height: " + bmpImage.getHeight());
LOG.fine(
() -> "Total pixel: " + (bmpImage.getWidth() * bmpImage.getHeight())
);
List allPoints = new ArrayList<>();
for (int x = 0; x < bmpImage.getWidth(); x++) {
for (int y = 0; y < bmpImage.getHeight(); y++) {
allPoints.add(new Point(x, y));
}
}
PointFilter filter = new BMPPointFilterHomogeneous();
Collection filteredPoints = filter.getFilteredPoints(bmpImage);
LOG.fine(() -> "Count of non-noise pixels: " + filteredPoints.size());
BufferedImage bufferedImage = bmpImage.getBufferedImage();
for (Point p : filteredPoints) {
bufferedImage.setRGB(p.x, p.y, Color.RED.getRGB());
}
bmpImage.setBufferedImage(bufferedImage);
bmpImage.save(new File("resources/sunflower_Noise2.bmp"));
}
}
stegosuite/src/main/java/org/stegosuite/image/embedding/bmp/filter/BMPPointFilterNone.java 0000664 0000000 0000000 00000001000 15260777315 0032217 0 ustar 00root root 0000000 0000000 package org.stegosuite.image.embedding.bmp.filter;
import org.stegosuite.image.embedding.point.PointFilter;
import org.stegosuite.image.format.BMPImage;
import java.awt.*;
import java.util.ArrayList;
import java.util.Collection;
/**
* Allows embedding into all points of a BMP image
*/
public class BMPPointFilterNone
extends PointFilter {
@Override
public int maxLsbCount() {
return 8;
}
@Override
protected Collection filter(BMPImage image) {
return new ArrayList<>();
}
}
stegosuite/src/main/java/org/stegosuite/image/embedding/gif/ 0000775 0000000 0000000 00000000000 15260777315 0024451 5 ustar 00root root 0000000 0000000 stegosuite/src/main/java/org/stegosuite/image/embedding/gif/GIFShuffle.java 0000664 0000000 0000000 00000015132 15260777315 0027240 0 ustar 00root root 0000000 0000000 package org.stegosuite.image.embedding.gif;
import java.awt.Color;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.logging.Logger;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import org.stegosuite.image.embedding.EmbeddingMethod;
import org.stegosuite.image.embedding.EmbeddingProgress;
import org.stegosuite.image.embedding.point.PointFilter;
import org.stegosuite.image.format.GIFImage;
import org.stegosuite.model.exception.SteganoEmbedException;
import org.stegosuite.model.exception.SteganoExtractException;
import org.stegosuite.model.exception.SteganoKeyException;
import org.stegosuite.model.payload.Payload;
import org.stegosuite.model.payload.PayloadEmbedder;
import org.stegosuite.model.payload.PayloadExtractor;
import org.stegosuite.util.ByteUtils;
import org.stegosuite.util.ColorDistance;
import org.stegosuite.util.ColorUtils;
import org.stegosuite.util.CryptoUtils;
/**
* GIFShuffle embedding and extracting procedures. Source: http://www.darkside.com.au/gifshuffle/
*
*/
public class GIFShuffle extends EmbeddingMethod {
private static final Logger LOG = Logger.getLogger(
GIFShuffle.class.getName()
);
public GIFShuffle(GIFImage image, PointFilter pointFilter) {
super(image, pointFilter);
}
private static final ColorDistance DISTANCE = ColorDistance.CIEDE_2000;
/**
* Returns the palette's distinct colors, in palette order.
*
* GIFShuffle hides the payload in the order of the palette, so it needs a table whose
* entries are all different. GIF color tables are usually padded with duplicate colors (the
* format only stores power-of-two sized tables), and a permutation of a multiset is not
* injective: two different payloads would produce the same image. Collapsing duplicates also
* makes the capacity formula (n! for n colors) correct. This is visually lossless because
* duplicate palette entries have identical RGB values.
*/
private static List distinctColors(GIFImage image) {
return image.getColorTable().stream().distinct().collect(
Collectors.toList()
);
}
/**
* Capacity in bits: sum(log2(n)) for n=2..number of distinct palette colors, i.e. log2(n!)
*/
@Override
protected int doCapacity(GIFImage image) {
int numColors = distinctColors(image).size();
double sum = IntStream.range(2, numColors + 1)
.mapToDouble(i -> Math.log(i) / Math.log(2))
.sum();
LOG.fine(() -> "Capacity: " + ((int) (sum / 8) - 1));
return (int) (sum / 8) - 1;
}
@Override
protected void doEmbed(
GIFImage image,
Payload payload,
EmbeddingProgress progress
) throws SteganoEmbedException {
List originalTable = image.getColorTable();
List randomTable = ColorUtils.sortColors(
distinctColors(image),
DISTANCE
);
Collections.shuffle(
randomTable,
CryptoUtils.seededRandom(payload.getSteganoPassword())
);
// The new color table is a permutation of the distinct palette colors
List newTable = new ArrayList<>(randomTable);
LOG.fine(() -> "origtable size: " + originalTable.size());
LOG.fine(() -> "randomtable size: " + randomTable.size());
// Prepend 1 to the payload so that leading 0 bytes are not cut off
PayloadEmbedder embedder = new PayloadEmbedder(
payload,
this.capacity()
);
BigInteger numPayload = new BigInteger(
ByteUtils.concat(new byte[] { 1 }, embedder.getPayloadBytes())
);
int numColors = randomTable.size();
for (int i = 0; i < numColors; i++) {
int pos = numPayload.mod(BigInteger.valueOf(i + 1)).intValue();
numPayload = numPayload.divide(BigInteger.valueOf(i + 1));
for (int j = i; j > pos; j--) {
newTable.set(j, newTable.get(j - 1));
}
newTable.set(pos, randomTable.get(numColors - i - 1));
progress.progressUpdate(i + 1, numColors);
}
// Update the color table and pixels according to the new color table
int[] newPixels = Arrays.stream(image.getPixels()) //
.map(pixel -> newTable.indexOf(originalTable.get(pixel)))
.toArray();
image.setPixels(newPixels);
image.setColorTable(newTable);
}
@Override
protected void doExtract(
GIFImage image,
Payload payload,
EmbeddingProgress progress
) throws SteganoExtractException {
// The palette of a steganogram is the permutation written by doEmbed. distinctColors() also
// drops the duplicates a GIF writer adds when padding the color table to a power of two.
List table = distinctColors(image);
List randomTable = new ArrayList<>(
ColorUtils.sortColors(table, DISTANCE)
);
Collections.shuffle(
randomTable,
CryptoUtils.seededRandom(payload.getSteganoPassword())
);
Map positions = IntStream.range(0, table.size())
.boxed()
.collect(Collectors.toMap(i -> table.get(i), i -> i));
BigInteger numPayload = BigInteger.ZERO;
for (int i = 0; i < table.size() - 1; i++) {
int pos = positions.get(randomTable.get(i));
numPayload = numPayload.multiply(
BigInteger.valueOf(table.size() - i)
);
numPayload = numPayload.add(BigInteger.valueOf(pos));
for (int j = i + 1; j < table.size(); j++) {
Color color = randomTable.get(j);
if (positions.get(color) > pos) {
positions.put(color, positions.get(color) - 1);
}
}
progress.progressUpdate(i + 2, table.size());
}
// We skip the 1st byte because it's the 1 we prepended during embedding
int i = 1;
byte[] payloadBytes = numPayload.toByteArray();
PayloadExtractor extractor = new PayloadExtractor(payload);
while (!extractor.finished() && i < payloadBytes.length) {
extractor.processByte(payloadBytes[i++]);
}
// If the extractor still expects data at this point, we extracted
// the wrong payload size due to wrong stego password
if (!extractor.finished()) {
throw new SteganoKeyException();
}
}
}
stegosuite/src/main/java/org/stegosuite/image/embedding/gif/GIFSortedColorTable.java 0000664 0000000 0000000 00000033750 15260777315 0031061 0 ustar 00root root 0000000 0000000 package org.stegosuite.image.embedding.gif;
import static java.util.stream.Collectors.toList;
import java.awt.*;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.StandardOpenOption;
import java.util.*;
import java.util.AbstractMap.SimpleEntry;
import java.util.List;
import java.util.Map.Entry;
import java.util.logging.Logger;
import org.stegosuite.image.embedding.EmbeddingMethod;
import org.stegosuite.image.embedding.EmbeddingProgress;
import org.stegosuite.image.embedding.Visualizer;
import org.stegosuite.image.embedding.Visualizer.VisualizationMode;
import org.stegosuite.image.embedding.Visualizer.Visualize;
import org.stegosuite.image.embedding.gif.filter.GIFPointFilterHomogeneous;
import org.stegosuite.image.embedding.point.PointFilter;
import org.stegosuite.image.embedding.point.PointGenerator;
import org.stegosuite.image.format.GIFImage;
import org.stegosuite.model.exception.SteganoEmbedException;
import org.stegosuite.model.exception.SteganoExtractException;
import org.stegosuite.model.exception.SteganoImageException;
import org.stegosuite.model.exception.SteganoKeyException;
import org.stegosuite.model.payload.Payload;
import org.stegosuite.model.payload.PayloadEmbedder;
import org.stegosuite.model.payload.PayloadExtractor;
import org.stegosuite.model.payload.block.FileBlock;
import org.stegosuite.model.payload.block.MessageBlock;
import org.stegosuite.util.ColorDistance;
import org.stegosuite.util.ColorUtils;
/**
* "Normal" embedding and extracting procedures for GIF image, i.e. using a sorted color table.
*/
public class GIFSortedColorTable extends EmbeddingMethod {
private static final Logger LOG = Logger.getLogger(
GIFSortedColorTable.class.getName()
);
private static final ColorDistance DISTANCE = ColorDistance.CIEDE_2000;
/**
* Number of colors to skip when embedding / extracting to prevent replacing too distinct
* colors. The colors are trimmed from the end of the sorted color table as that's where the
* distance between successive colors is the largest.
*/
private static final int NUM_SKIP_TRAILING_COLORS = 6;
private SimpleEntry> skipColors = null;
public GIFSortedColorTable(
GIFImage image,
PointFilter pointFilter
) {
super(image, pointFilter);
}
@Override
protected Visualizer createVisualizer(GIFImage image) {
return new Visualizer(
image,
new Visualize(VisualizationMode.ALTERED, Color.RED),
new Visualize(VisualizationMode.UNALTERED, Color.GREEN)
);
}
/**
* The SortedColorTable method can embed 1 bit in each pixel. From the total number of pixels,
* we subtract 1) the number of pixels that have a color we need to skip, and 2) the number of
* pixels that the point filter doesn't allow us to embed into.
*/
@Override
protected int doCapacity(GIFImage image) {
Map histogram = image.getHistogram();
int skipPixelCount = getSkipColors(image)
.stream()
.mapToInt(c -> histogram.get(c))
.sum();
int filteredPixelCount = pointFilter.getFilteredPoints(image).size();
return (
(image.getHeight() * image.getWidth() -
filteredPixelCount -
skipPixelCount) /
8
);
}
@Override
protected void doEmbed(
GIFImage image,
Payload payload,
EmbeddingProgress progress
) throws SteganoEmbedException {
PointGenerator pointGenerator = new PointGenerator<>(
image,
payload.getSteganoPassword(),
pointFilter
);
PayloadEmbedder embedder = new PayloadEmbedder(
payload,
this.capacity()
);
int payloadNumBytes = embedder.getPayloadBytes().length;
int[] pixels = image.getPixels().clone();
List table = image.getColorTable();
List sortedTable = image.getSortedColorTable(DISTANCE);
LOG.fine(() -> "origtable size: " + table.size());
LOG.fine(() -> "sortedtable size: " + sortedTable.size());
Set unreferencedColorsBefore = ColorUtils.getUnreferencedColors(
table,
pixels
);
int currentBit = 0;
for (byte bit : embedder.iteratePayloadBits()) {
Point point;
int pixelIndex;
Color currentColor;
do {
point = pointGenerator.nextPoint();
pixelIndex = (point.y * image.getWidth()) + point.x;
currentColor = table.get(pixels[pixelIndex]);
} while (getSkipColors(image).contains(currentColor));
int sortedColorIndex = sortedTable.indexOf(currentColor);
boolean pixelMatchesPayloadBit = sortedColorIndex % 2 == bit;
// Write steganogram
if (!pixelMatchesPayloadBit) {
// Toggle LSB
int newSortedColorIndex = Math.min(
sortedColorIndex ^ 0b1,
sortedTable.size() - 1
);
pixels[pixelIndex] = table.indexOf(
sortedTable.get(newSortedColorIndex)
);
}
// Write visualization
visualizer.visualize(
point,
pixelMatchesPayloadBit
? VisualizationMode.UNALTERED
: VisualizationMode.ALTERED
);
// Update progress
if (progress != null) {
progress.progressUpdate(currentBit++ / 8, payloadNumBytes);
}
}
// Check for colors that were referenced before embedding but are now
// unreferenced
Set referencedColorsAfter = ColorUtils.getUnreferencedColors(
table,
pixels
);
referencedColorsAfter.removeAll(unreferencedColorsBefore);
if (!referencedColorsAfter.isEmpty()) {
LOG.fine(
() ->
"Reinserting " +
referencedColorsAfter.size() +
" unreferenced colors"
);
Map histogram = ColorUtils.getHistogram(
table,
pixels
);
for (Color unreferencedColor : referencedColorsAfter) {
// Sort table by similarity to unreferenced color
List similarColors = new ArrayList<>(table);
similarColors.remove(unreferencedColor);
similarColors.sort((c1, c2) ->
(int) Math.round(
DISTANCE.distance(unreferencedColor, c1) -
DISTANCE.distance(unreferencedColor, c2)
)
);
// Try to replace most similar color with unreferenced color
boolean isFixed = false;
for (int i = 0; i < similarColors.size() && !isFixed; i++) {
Color similarColor = similarColors.get(i);
// Only replace it if it's referenced at least twice, we
// don't want another unreferenced color
if (histogram.get(similarColor) > 1) {
int similarColorIndex = table.indexOf(similarColor);
// Find first pixel of that color
for (int j = 0; j < pixels.length && !isFixed; j++) {
if (pixels[j] == similarColorIndex) {
// Only modify the pixel if it doesn't carry our
// payload
Point point = new Point(
j % image.getWidth(),
j / image.getWidth()
);
if (!pointGenerator.wasGenerated(point)) {
pixels[j] = table.indexOf(
unreferencedColor
);
isFixed = true;
}
}
}
}
}
}
}
// Sort color table by new color frequencies
List colorsSortedByFrequency = image
.getHistogram()
.entrySet()
.stream()
.sorted(Collections.reverseOrder(Entry.comparingByValue()))
.map(Entry::getKey)
.collect(toList());
// Adjust pixels to new sorting of the palette
pixels = Arrays.stream(pixels)
.map(i -> colorsSortedByFrequency.indexOf(table.get(i)))
.toArray();
image.setColorTable(colorsSortedByFrequency);
image.setPixels(pixels);
}
@Override
protected void doExtract(
GIFImage image,
Payload payload,
EmbeddingProgress progress
) throws SteganoExtractException {
int[] pixels = image.getPixels();
List table = image.getColorTable();
List sortedTable = image.getSortedColorTable(DISTANCE);
PayloadExtractor extractor = new PayloadExtractor(payload);
PointGenerator pointGenerator = new PointGenerator<>(
image,
payload.getSteganoPassword(),
pointFilter
);
try {
while (!extractor.finished()) {
Point point = pointGenerator.nextPoint();
int pixelIndex = (point.y * image.getWidth()) + point.x;
Color color = table.get(pixels[pixelIndex]);
if (getSkipColors(image).contains(color)) {
continue;
}
int sortedColorIndex = sortedTable.indexOf(color);
byte bit = (byte) (sortedColorIndex % 2);
extractor.processBit(bit);
// Write visualization
visualizer.visualize(point, VisualizationMode.ALTERED);
// Update progress
if (progress != null && extractor.getPayloadLength() != null) {
progress.progressUpdate(
extractor.getProcessedBytesCount(),
extractor.getPayloadLength()
);
}
}
} catch (NoSuchElementException e) {
// The point generator hit its limit, corrupt payload size
throw new SteganoKeyException();
}
}
/**
* Returns the list of colors to skip when embedding and extracting
*
* @param image
* @return
*/
private Collection getSkipColors(GIFImage image) {
if (skipColors == null || !skipColors.getKey().equals(image)) {
skipColors = new SimpleEntry<>(image, new HashSet<>());
List sortedTable = image.getSortedColorTable(DISTANCE);
int sortedTableSize = sortedTable.size();
// In addition to skipping trailing colors, we skip one more color
// if the number of colors in the palette is uneven. Otherwise, we
// might switch the last color's LSB from 0 to 1 which increases the
// index and therefore causes an ArrayIndexOutOfBoundsException
for (
int i = 0;
i < NUM_SKIP_TRAILING_COLORS + (sortedTableSize % 2);
i++
) {
skipColors
.getValue()
.add(sortedTable.get(sortedTableSize - i - 1));
}
}
return skipColors.getValue();
}
// TODO: Move this into tests
public static void main(String[] args)
throws SteganoImageException, SteganoEmbedException, SteganoExtractException, IOException {
File carrierFile = new File("D:/test/fish.gif");
File secretFileIn = new File("D:/test/secret_in3");
File secretFileOut = new File("D:/test/secret_out");
File steganogramFile = new File(
"D:/test/steganogram_" + GIFSortedColorTable.DISTANCE + ".gif"
);
GIFImage gifImage = new GIFImage();
gifImage.load(carrierFile);
LOG.fine(
ColorUtils.getUnreferencedColors(gifImage.getHistogram()).size() +
" unreferenced colors"
);
EmbeddingMethod embeddingMethod = new GIFSortedColorTable(
gifImage,
new GIFPointFilterHomogeneous()
);
// Prepare payload to embed
Payload payloadToEmbed = new Payload();
payloadToEmbed.setSteganoPassword("123");
// Disable payload encryption
payloadToEmbed.setEncryptionPassword(null);
// Add file to payload
FileBlock fileBlock = new FileBlock(secretFileIn.getAbsolutePath());
payloadToEmbed.addBlock(fileBlock);
MessageBlock messageBlock = new MessageBlock("Some hidden message");
payloadToEmbed.addBlock(messageBlock);
// Embed
embeddingMethod.embed(payloadToEmbed, null);
gifImage.save(steganogramFile);
// Prepare payload to extract
Payload payloadExtracted = new Payload();
payloadExtracted.setSteganoPassword("123");
// Extract
gifImage = new GIFImage();
gifImage.load(steganogramFile);
LOG.fine(
ColorUtils.getUnreferencedColors(gifImage.getHistogram()).size() +
" unreferenced colors"
);
embeddingMethod.extract(payloadExtracted, null);
// Save extracted contents to file
fileBlock = (FileBlock) payloadExtracted.getBlock(0);
LOG.info("Original file name: " + fileBlock.getFileName());
Files.write(
secretFileOut.toPath(),
fileBlock.getFileContent(),
StandardOpenOption.CREATE
);
messageBlock = (MessageBlock) payloadExtracted.getBlock(1);
LOG.fine("Message: " + messageBlock.getMessage());
}
}
stegosuite/src/main/java/org/stegosuite/image/embedding/gif/filter/ 0000775 0000000 0000000 00000000000 15260777315 0025736 5 ustar 00root root 0000000 0000000 stegosuite/src/main/java/org/stegosuite/image/embedding/gif/filter/GIFPointFilterHomogeneous.java 0000664 0000000 0000000 00000020375 15260777315 0033606 0 ustar 00root root 0000000 0000000 package org.stegosuite.image.embedding.gif.filter;
import static java.util.function.Function.identity;
import static java.util.stream.Collectors.toMap;
import java.awt.*;
import java.io.File;
import java.util.*;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.logging.Logger;
import java.util.stream.IntStream;
import org.stegosuite.image.embedding.point.PointFilter;
import org.stegosuite.image.format.GIFImage;
import org.stegosuite.model.exception.SteganoImageException;
import org.stegosuite.util.ColorDistance;
/**
* Removes all points that are part of homogeneous areas of a GIF image
*/
public class GIFPointFilterHomogeneous extends PointFilter {
private static final Logger LOG = Logger.getLogger(
GIFPointFilterHomogeneous.class.getName()
);
private static final ColorDistance DISTANCE = ColorDistance.CIEDE_2000;
private Collection filteredPoints = null;
private int[] indices = null;
private Map indexToSortedIndex = null;
@Override
public int maxLsbCount() {
return 1;
}
@Override
protected Collection filter(GIFImage image) {
filteredPoints = Collections.newSetFromMap(new ConcurrentHashMap<>());
indices = image.getPixels();
// Compute a mapping from original color indices to the indices in the sorted table,
// such that for all colors: table(i) == sortedTable(indexToSortedIndex(i))
List colorTable = image.getColorTable();
List sortedTable = image.getSortedColorTable(DISTANCE);
indexToSortedIndex = IntStream.range(0, colorTable.size())
.boxed()
.collect(
toMap(identity(), i -> sortedTable.indexOf(colorTable.get(i)))
);
long startTime = System.nanoTime();
int width = image.getWidth();
int height = image.getHeight();
// Partition the image into as many slices as CPU cores we have available
int numSlices = Runtime.getRuntime().availableProcessors();
int rowsForEachSlice = height / numSlices;
IntStream.range(0, numSlices)
.boxed()
.parallel()
.forEach(numSlice -> {
long startTimeSlice = System.nanoTime();
// Calculate start & end row of current slice
int sliceStartRow = numSlice * rowsForEachSlice;
int sliceEndRow =
numSlice + 1 < numSlices
? sliceStartRow + rowsForEachSlice
: height - 2;
int[][] normalizedRows = getNormalizedRows(
width,
sliceStartRow,
sliceEndRow + 2
);
Collection homogeneousPoints =
collectHomogeneousPointsOfRows(
normalizedRows,
sliceStartRow,
sliceEndRow,
width
);
filteredPoints.addAll(homogeneousPoints);
LOG.fine(
() ->
"Filtered slice " +
numSlice +
" of " +
(sliceEndRow - sliceStartRow) +
" rows in " +
((System.nanoTime() - startTimeSlice) / 1000000) +
" ms"
);
});
LOG.fine(
() ->
"Filtered homogeneous points in " +
((System.nanoTime() - startTime) / 1000000) +
" ms"
);
return filteredPoints;
}
/**
* Returns a sub-matrix of all indices with each index having set its LSBs to zero
*
* @param width The width of the matrix
* @param sliceStartIncl The start row of the pixels, inclusive
* @param sliceEndExcl The end row of the pixels, exclusive
* @return
*/
private int[][] getNormalizedRows(
int width,
int sliceStartIncl,
int sliceEndExcl
) {
int height = sliceEndExcl - sliceStartIncl;
int[][] normalizedRows = new int[width][height];
for (int y = sliceStartIncl; y < sliceEndExcl; y++) {
for (int x = 0; x < width; x++) {
int index = indices[y * width + x];
int sortedIndex = indexToSortedIndex.get(index);
// Set last bit of the sorted index to 0 because it will be changed after embedding
normalizedRows[x][y - sliceStartIncl] = sortedIndex & ~0b1;
}
}
return normalizedRows;
}
/**
* Returns a list with points of homogeneous areas in the normalizedRows matrix. Each returned
* point has the row offset (sliceStartIncl) added, so it is an absolute position in the image.
*
* @param normalizedRows
* @param sliceStartIncl
* @param sliceEndExcl
* @param width
*/
private Collection collectHomogeneousPointsOfRows(
int[][] normalizedRows,
int sliceStartIncl,
int sliceEndExcl,
int width
) {
Collection filteredPoints = new ArrayList<>();
for (int y = 0; y < sliceEndExcl - sliceStartIncl; y++) {
// Indicates the left-most column of the current homogeneous area. -1 means we are not
// in a homogeneous area.
int homogeneousColumnStart = -1;
for (int x = 0; x < width; x++) {
int thisColumnColor = normalizedRows[x][y];
// True if all 3 pixels of the current column are the same
boolean isHomogeneousColumn =
normalizedRows[x][y + 1] == thisColumnColor &&
normalizedRows[x][y + 2] == thisColumnColor;
// True if current column is part of a previously started homogeneous area
if (
isHomogeneousColumn &&
homogeneousColumnStart != -1 &&
thisColumnColor == normalizedRows[homogeneousColumnStart][y]
) {
// Jump to next column if the current column belongs the current homogeneous
// field. In the last column we need to pretend we are 1 column ahead so that we
// can correctly collect all points.
if (x + 1 == width) {
x++;
} else {
continue;
}
}
// Collect all points of the homogeneous area if it's at 3 pixels wide
if (
homogeneousColumnStart != -1 &&
x - homogeneousColumnStart >= 3
) {
for (int dX = homogeneousColumnStart; dX < x; dX++) {
for (int dY = 0; dY < 3; dY++) {
filteredPoints.add(
new Point(dX, sliceStartIncl + y + dY)
);
}
}
}
// If this column is homogeneous we are at the beginning of a new homogeneous area
homogeneousColumnStart = isHomogeneousColumn ? x : -1;
}
}
return filteredPoints;
}
/**
* Debug only
*
* @param args
* @throws SteganoImageException
*/
public static void main(String[] args) throws SteganoImageException {
GIFImage image = new GIFImage();
image.load(new File("src/test/resources/sunflower.gif"));
PointFilter filter = new GIFPointFilterHomogeneous();
Collection filteredPoints = filter.getFilteredPoints(image);
LOG.fine(
() ->
"Total pixels: " +
image.getWidth() +
" * " +
image.getHeight() +
" = " +
(image.getWidth() * image.getHeight())
);
LOG.fine(() -> "Count of non-noise pixels: " + filteredPoints.size());
for (Point p : filteredPoints) {
image.getBufferedImage().setRGB(p.x, p.y, Color.RED.getRGB());
}
image.save(new File("src/test/resources/sunflower_noise.gif"));
}
}
stegosuite/src/main/java/org/stegosuite/image/embedding/gif/filter/GIFPointFilterNone.java 0000664 0000000 0000000 00000001000 15260777315 0032175 0 ustar 00root root 0000000 0000000 package org.stegosuite.image.embedding.gif.filter;
import org.stegosuite.image.embedding.point.PointFilter;
import org.stegosuite.image.format.GIFImage;
import java.awt.*;
import java.util.ArrayList;
import java.util.Collection;
/**
* Allows embedding into all points of a GIF image
*/
public class GIFPointFilterNone
extends PointFilter {
@Override
public int maxLsbCount() {
return 1;
}
@Override
protected Collection filter(GIFImage image) {
return new ArrayList<>();
}
}
stegosuite/src/main/java/org/stegosuite/image/embedding/jpg/ 0000775 0000000 0000000 00000000000 15260777315 0024464 5 ustar 00root root 0000000 0000000 stegosuite/src/main/java/org/stegosuite/image/embedding/jpg/JPGF5.java 0000664 0000000 0000000 00000014100 15260777315 0026136 0 ustar 00root root 0000000 0000000 package org.stegosuite.image.embedding.jpg;
import java.io.*;
import java.nio.file.Files;
import java.nio.file.StandardOpenOption;
import java.util.logging.Logger;
import org.stegosuite.image.embedding.EmbeddingMethod;
import org.stegosuite.image.embedding.EmbeddingProgress;
import org.stegosuite.image.embedding.point.PointFilter;
import org.stegosuite.image.format.JPGImage;
import org.stegosuite.image.jpgtemp.james.JpegEncoder;
import org.stegosuite.image.jpgtemp.net.f5.Extract;
import org.stegosuite.model.exception.SteganoEmbedException;
import org.stegosuite.model.exception.SteganoExtractException;
import org.stegosuite.model.exception.SteganoImageException;
import org.stegosuite.model.payload.Payload;
import org.stegosuite.model.payload.PayloadEmbedder;
import org.stegosuite.model.payload.PayloadExtractor;
import org.stegosuite.model.payload.block.FileBlock;
import org.stegosuite.model.payload.block.MessageBlock;
import org.stegosuite.util.FileUtils;
public class JPGF5 extends EmbeddingMethod {
private static final Logger LOG = Logger.getLogger(JPGF5.class.getName());
public JPGF5(JPGImage image, PointFilter pointFilter) {
super(image, pointFilter);
}
@Override
protected int doCapacity(JPGImage image) {
JpegEncoder jpg = new JpegEncoder(image.getBufferedImage(), 80, null);
return jpg.getCapacity();
}
@Override
protected void doEmbed(
JPGImage image,
Payload payload,
EmbeddingProgress progress
) throws SteganoEmbedException {
PayloadEmbedder embedder = new PayloadEmbedder(
payload,
this.capacity()
);
final int quality = 80; // 0 is worst, 100 is best
ByteArrayOutputStream dataOut = new ByteArrayOutputStream();
JpegEncoder jpg = new JpegEncoder(
image.getBufferedImage(),
quality,
dataOut
);
jpg.Compress(
new ByteArrayInputStream(embedder.getPayloadBytes()),
payload.getSteganoPassword()
);
String outputPath = FileUtils.addFileNameSuffix(
image.getFile().getAbsolutePath(),
"_embed"
);
FileOutputStream outputStream = null;
//TODO: Move this saving functionality to ImageFormat.save()
try {
LOG.info(() -> "Saving jpg image to " + outputPath);
outputStream = new FileOutputStream(outputPath);
} catch (FileNotFoundException e1) {
e1.printStackTrace();
}
try {
dataOut.writeTo(outputStream);
dataOut.close();
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
protected void doExtract(
JPGImage image,
Payload payload,
EmbeddingProgress progress
) throws SteganoExtractException {
FileInputStream fis = null;
ByteArrayOutputStream baos = null;
try {
fis = new FileInputStream(image.getFile());
baos = new ByteArrayOutputStream();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
try {
Extract.extract(
fis,
(int) image.getFile().length(),
baos,
payload.getSteganoPassword()
);
} catch (IOException e) {
e.printStackTrace();
}
byte[] payloadBytes = null;
try {
baos.flush();
payloadBytes = baos.toByteArray();
baos.close();
} catch (IOException e) {
e.printStackTrace();
}
PayloadExtractor extractor = new PayloadExtractor(payload);
int i = 0;
while (!extractor.finished() && i < payloadBytes.length) {
extractor.processByte(payloadBytes[i++]);
}
}
// TODO: Move this into tests
public static void main(String[] args)
throws SteganoImageException, SteganoEmbedException, SteganoExtractException, IOException {
File carrierFile = new File(
"/home/tobi/stego/f5-steganography/sample/enc.jpg"
);
File secretFileIn = new File(
"/home/tobi/stego/f5-steganography/sample/msg.txt"
);
File secretFileOut = new File(
"/home/tobi/stego/f5-steganography/sample/msg_out.txt"
);
File steganogramFile = new File(
"/home/tobi/stego/f5-steganography/sample/enc_embed.jpg"
);
JPGImage jpgImage = new JPGImage();
jpgImage.load(carrierFile);
// EmbeddingMethod embeddingMethod = new F5(jpgImage, null);
JPGF5 embeddingMethod = new JPGF5(jpgImage, null);
// Prepare payload to embed
Payload payloadToEmbed = new Payload();
payloadToEmbed.setSteganoPassword("123");
// Disable payload encryption
payloadToEmbed.setEncryptionPassword(null);
// Add file to payload
FileBlock fileBlock = new FileBlock(secretFileIn.getAbsolutePath());
payloadToEmbed.addBlock(fileBlock);
MessageBlock messageBlock = new MessageBlock("Some hidden message");
payloadToEmbed.addBlock(messageBlock);
// Embed
embeddingMethod.embed(payloadToEmbed, null);
// jpgImage.save(steganogramFile);
Payload payloadExtracted = new Payload();
payloadExtracted.setSteganoPassword("123");
payloadExtracted.setEncryptionPassword(null);
// Extract
jpgImage = new JPGImage();
jpgImage.load(steganogramFile);
embeddingMethod = new JPGF5(jpgImage, null);
embeddingMethod.extract(payloadExtracted, null);
// Save extracted contents to file
fileBlock = (FileBlock) payloadExtracted.getBlock(0);
LOG.info("Original file name: " + fileBlock.getFileName());
Files.write(
secretFileOut.toPath(),
fileBlock.getFileContent(),
StandardOpenOption.CREATE
);
messageBlock = (MessageBlock) payloadExtracted.getBlock(1);
LOG.info("Message: " + messageBlock.getMessage());
}
}
stegosuite/src/main/java/org/stegosuite/image/embedding/jpg/filter/ 0000775 0000000 0000000 00000000000 15260777315 0025751 5 ustar 00root root 0000000 0000000 stegosuite/src/main/java/org/stegosuite/image/embedding/jpg/filter/JPGPointFilterNone.java 0000664 0000000 0000000 00000000777 15260777315 0032247 0 ustar 00root root 0000000 0000000 package org.stegosuite.image.embedding.jpg.filter;
import org.stegosuite.image.embedding.point.PointFilter;
import org.stegosuite.image.format.JPGImage;
import java.awt.*;
import java.util.ArrayList;
import java.util.Collection;
/**
* Allows embedding into all points of a GIF image
*/
public class JPGPointFilterNone
extends PointFilter {
@Override
public int maxLsbCount() {
return 1;
}
@Override
protected Collection filter(JPGImage image) {
return new ArrayList<>();
}
}
stegosuite/src/main/java/org/stegosuite/image/embedding/png/ 0000775 0000000 0000000 00000000000 15260777315 0024470 5 ustar 00root root 0000000 0000000 stegosuite/src/main/java/org/stegosuite/image/embedding/png/PNGLsbMultiColorChannel.java 0000664 0000000 0000000 00000016576 15260777315 0031742 0 ustar 00root root 0000000 0000000 package org.stegosuite.image.embedding.png;
import java.awt.*;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.stegosuite.image.embedding.EmbeddingMethod;
import org.stegosuite.image.embedding.EmbeddingProgress;
import org.stegosuite.image.embedding.Visualizer;
import org.stegosuite.image.embedding.Visualizer.VisualizationMode;
import org.stegosuite.image.embedding.Visualizer.Visualize;
import org.stegosuite.image.embedding.point.PointFilter;
import org.stegosuite.image.embedding.point.PointGenerator;
import org.stegosuite.image.format.PNGImage;
import org.stegosuite.model.exception.SteganoEmbedException;
import org.stegosuite.model.exception.SteganoExtractException;
import org.stegosuite.model.exception.SteganoKeyException;
import org.stegosuite.model.payload.Payload;
import org.stegosuite.model.payload.PayloadEmbedder;
import org.stegosuite.model.payload.PayloadExtractor;
import org.stegosuite.util.ByteUtils;
import org.stegosuite.util.RgbChannel;
/**
* Embed/Extract on PNG-images using data-spreading method. This method will utilise all {@code 3}
* color channels, sequentially, meaning the payload will first be embedded into the
* {@code red}-byte, then the {@code green} -byte, and finally the {@code blue}
* -byte.
*
* @author alwin
*/
public class PNGLsbMultiColorChannel extends EmbeddingMethod {
private static final Logger LOG = Logger.getLogger(
PNGLsbMultiColorChannel.class.getName()
);
/**
* Constructor
*
* @param image the {@link PNGImage} to be embedded/extracted
* @param pointFilter the {@link PointFilter} to filter out undesired areas of the given
* {@link PNGImage}
*/
public PNGLsbMultiColorChannel(
PNGImage image,
PointFilter pointFilter
) {
super(image, pointFilter);
}
@Override
public Visualizer createVisualizer(PNGImage image) {
return new Visualizer(
image,
new Visualize(VisualizationMode.ALTERED, Color.RED),
new Visualize(VisualizationMode.UNALTERED, Color.GREEN)
);
}
@Override
public int doCapacity(PNGImage image) {
LOG.fine(() -> "Embedding into " + pointFilter.maxLsbCount() + " LSBs");
// Embedding will be done on all 3 color channels
// Get the maximum number of LSBs from the point filter
int pixelCount = image.getWidth() * image.getHeight();
int filteredPixelCount = pointFilter.getFilteredPoints(image).size();
int embeddableBits =
(pixelCount - filteredPixelCount) * 3 * pointFilter.maxLsbCount();
return embeddableBits / 8;
}
@Override
protected void doEmbed(
PNGImage image,
Payload payload,
EmbeddingProgress progress
) throws SteganoEmbedException {
LOG.fine("Performing PNG LSB embedding");
PayloadEmbedder payloadEmbedder = new PayloadEmbedder(
payload,
this.capacity()
);
int numPayloadBytes = payloadEmbedder.getPayloadBytes().length;
// Initialize the data spreader
PointGenerator pointGenerator = new PointGenerator<>(
image,
payload.getSteganoPassword(),
pointFilter
);
int processedBits = 0;
Iterator payloadBits = payloadEmbedder
.iteratePayloadBits()
.iterator();
try {
while (payloadBits.hasNext()) {
// Get next point and its color
Point point = pointGenerator.nextPoint();
Color oldColor = new Color(
image.getBufferedImage().getRGB(point.x, point.y)
);
Color newColor = new Color(oldColor.getRGB());
// Embed into all 3 color channels
for (RgbChannel channel : RgbChannel.RGB()) {
byte bit = payloadBits.next();
int channelValue = channel.getValue(newColor);
channelValue = ByteUtils.setBitAt(
channelValue,
pointGenerator.getIterationCount() - 1,
bit
);
newColor = channel.setValue(newColor, channelValue);
processedBits++;
if (!payloadBits.hasNext()) {
break;
}
}
// Update visualization
visualizer.visualize(
point,
newColor.equals(oldColor)
? VisualizationMode.UNALTERED
: VisualizationMode.ALTERED
);
// Update pixel color
image
.getBufferedImage()
.setRGB(point.x, point.y, newColor.getRGB());
// Update progress
if (progress != null) {
progress.progressUpdate(processedBits / 8, numPayloadBytes);
}
}
} catch (NoSuchElementException e) {
throw new SteganoEmbedException(e.getMessage());
}
}
@Override
protected void doExtract(
PNGImage image,
Payload payload,
EmbeddingProgress progress
) throws SteganoExtractException {
LOG.fine("Performing PNG LSB extraction");
PayloadExtractor payloadExtractor = new PayloadExtractor(payload);
PointGenerator pointGenerator = new PointGenerator<>(
image,
payload.getSteganoPassword(),
pointFilter
);
try {
while (!payloadExtractor.finished()) {
// Get next point and its color
Point point = pointGenerator.nextPoint();
Color color = new Color(
image.getBufferedImage().getRGB(point.x, point.y)
);
// Extract from all 3 color channels
for (RgbChannel channel : RgbChannel.RGB()) {
int value = channel.getValue(color);
byte bit = ByteUtils.getBitAt(
value,
pointGenerator.getIterationCount() - 1
);
payloadExtractor.processBit(bit);
if (payloadExtractor.finished()) {
break;
}
}
// Update visualization
visualizer.visualize(point, VisualizationMode.ALTERED);
// Update progress
if (
progress != null &&
payloadExtractor.getPayloadLength() != null
) {
progress.progressUpdate(
payloadExtractor.getProcessedBytesCount(),
payloadExtractor.getPayloadLength()
);
}
}
} catch (NoSuchElementException e) {
if (LOG.isLoggable(Level.FINE)) {
LOG.fine(
"The iteration count of PointGenerator exceeds its maximum iteration count (" +
pointFilter.maxLsbCount() +
")"
);
}
throw new SteganoKeyException();
}
}
}
stegosuite/src/main/java/org/stegosuite/image/embedding/png/filter/ 0000775 0000000 0000000 00000000000 15260777315 0025755 5 ustar 00root root 0000000 0000000 stegosuite/src/main/java/org/stegosuite/image/embedding/png/filter/PNGPointFilterHomogeneous.java 0000664 0000000 0000000 00000011535 15260777315 0033642 0 ustar 00root root 0000000 0000000 package org.stegosuite.image.embedding.png.filter;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.*;
import java.util.List;
import java.util.logging.Logger;
import org.stegosuite.image.embedding.point.PointFilter;
import org.stegosuite.image.format.PNGImage;
import org.stegosuite.model.exception.SteganoImageException;
/**
* Removes all points that are part of homogeneous areas of a PNG image
*/
public class PNGPointFilterHomogeneous extends PointFilter {
/**
* Sets the LSB of all 3 color channels of a 32bit RGB value to 0
*/
private static final int MASK_LSBS_TO_ZERO = ~0b10000000100000001;
private static final Logger LOG = Logger.getLogger(
PNGPointFilterHomogeneous.class.getName()
);
@Override
public int maxLsbCount() {
return 1;
}
/**
* Returns a list of all homogeneous areas
*/
@Override
protected Collection filter(PNGImage image) {
int[][] normalizedRgbValues = getNormalizedRgbValues(
image.getBufferedImage()
);
// long startTime = System.nanoTime();
Collection filteredPoints = new HashSet<>();
for (int x = 1; x < normalizedRgbValues.length - 1; x++) {
for (int y = 1; y < normalizedRgbValues[x].length - 1; y++) {
Collection homogenousPoints = getHomogeneousPoints(
normalizedRgbValues,
x,
y
);
filteredPoints.addAll(homogenousPoints);
}
}
// System.out.println("filter : " + (System.nanoTime() - startTime) / 1000000 + " ms");
return filteredPoints;
}
/**
* Returns a matrix of all RGB values that are present in the image with each value having set
* its LSBs for the 3 channels to zero.
*
* @param image
* @return
*/
private int[][] getNormalizedRgbValues(BufferedImage image) {
int width = image.getWidth();
int height = image.getHeight();
int[][] rgbValues = new int[width][];
for (int x = 0; x < width; x++) {
rgbValues[x] = new int[height];
for (int y = 0; y < height; y++) {
rgbValues[x][y] = image.getRGB(x, y) & MASK_LSBS_TO_ZERO;
}
}
return rgbValues;
}
/**
* Returns a list of points that are part of a homogeneous area around the x and y coordinate.
* Returns an empty list if the area is not homogeneous.
*
* @param normalizedRgbValues
* @param x
* @param y
* @return
*/
private Collection getHomogeneousPoints(
int[][] normalizedRgbValues,
int x,
int y
) {
Collection homogeneousPoints = new ArrayList<>();
int referenceRgbValue = normalizedRgbValues[x][y];
// System.out.println(Integer.toBinaryString(referenceRgbValue));
for (int dX = x - 1; dX <= x + 1; dX++) {
for (int dY = y - 1; dY <= y + 1; dY++) {
// As soon as 1 pixel in the area is different from the pixel in
// the center, the area is considered NOT to be homogeneous.
if (
dX != x &&
dY != y &&
normalizedRgbValues[dX][dY] != referenceRgbValue
) {
return Collections.emptyList();
}
homogeneousPoints.add(new Point(dX, dY));
}
}
return homogeneousPoints;
}
/**
* Debug only
*
* @param args
* @throws IOException
* @throws SteganoImageException
*/
public static void main(String[] args) throws SteganoImageException {
PNGImage pngImage = new PNGImage();
pngImage.load(new File("resources/Snow.png"));
LOG.fine(() -> "Width: " + pngImage.getWidth());
LOG.fine(() -> "Height: " + pngImage.getHeight());
LOG.fine(
() -> "Total pixel: " + (pngImage.getWidth() * pngImage.getHeight())
);
List allPoints = new ArrayList<>();
for (int x = 0; x < pngImage.getWidth(); x++) {
for (int y = 0; y < pngImage.getHeight(); y++) {
allPoints.add(new Point(x, y));
}
}
PointFilter filter = new PNGPointFilterHomogeneous();
Collection filteredPoints = filter.getFilteredPoints(pngImage);
LOG.fine(() -> "Count of non-noise pixels: " + filteredPoints.size());
BufferedImage bufferedImage = pngImage.getBufferedImage();
for (Point p : filteredPoints) {
bufferedImage.setRGB(p.x, p.y, Color.RED.getRGB());
}
pngImage.setBufferedImage(bufferedImage);
pngImage.save(new File("resources/sunflower_Noise2.png"));
}
}
stegosuite/src/main/java/org/stegosuite/image/embedding/png/filter/PNGPointFilterNone.java 0000664 0000000 0000000 00000001000 15260777315 0032233 0 ustar 00root root 0000000 0000000 package org.stegosuite.image.embedding.png.filter;
import org.stegosuite.image.embedding.point.PointFilter;
import org.stegosuite.image.format.PNGImage;
import java.awt.*;
import java.util.ArrayList;
import java.util.Collection;
/**
* Allows embedding into all points of a PNG image
*/
public class PNGPointFilterNone
extends PointFilter {
@Override
public int maxLsbCount() {
return 8;
}
@Override
protected Collection filter(PNGImage image) {
return new ArrayList<>();
}
}
stegosuite/src/main/java/org/stegosuite/image/embedding/point/ 0000775 0000000 0000000 00000000000 15260777315 0025035 5 ustar 00root root 0000000 0000000 stegosuite/src/main/java/org/stegosuite/image/embedding/point/PointFilter.java 0000664 0000000 0000000 00000002074 15260777315 0030142 0 ustar 00root root 0000000 0000000 package org.stegosuite.image.embedding.point;
import org.stegosuite.image.format.ImageFormat;
import java.awt.*;
import java.util.Collection;
/**
* A filter can be applied to prevent certain points from being generated by the PointGenerator
*/
public abstract class PointFilter {
/**
* Contains the list of points that should be skipped when embedding or extracting
*/
private Collection filteredPoints = null;
/**
* Returns the number of LSBs that the filter limits the embedding method to
*
* @return
*/
public abstract int maxLsbCount();
/**
* Generates a list of points that should NOT be used when embedding or extracting. Implemented
* by the subclasses.
*
* @param image
* @return
*/
protected abstract Collection filter(T image);
/**
* Returns the list of points that should NOT be used when embedding or extracting
*
* @return
*/
public Collection getFilteredPoints(T image) {
if (filteredPoints == null) {
filteredPoints = filter(image);
}
return filteredPoints;
}
}
stegosuite/src/main/java/org/stegosuite/image/embedding/point/PointGenerator.java 0000664 0000000 0000000 00000005743 15260777315 0030651 0 ustar 00root root 0000000 0000000 package org.stegosuite.image.embedding.point;
import org.stegosuite.image.format.ImageFormat;
import org.stegosuite.util.CryptoUtils;
import java.awt.*;
import java.util.*;
import java.util.List;
/**
* This class is used for data spreading. It generates random 2D points using a key as a seed. Use
* the same key to generate the same sequence of points. All generated points are limited to the
* given bounds (width and height)
*/
public class PointGenerator {
/**
* The image to generate points for
*/
private final T image;
/**
* The filter to apply to the list of all possible points in order to avoid embedding into
* certain pixels
*/
private final PointFilter pointFilter;
/**
* PRNG, initialized in constructor if seed is provided, otherwise null
*/
private final Random random;
/**
* Contains all points that haven't been visited
*/
private final List points = new LinkedList<>();
/**
* The maximum number of times the points list should be seeded
*/
private int maxIterations = 1;
/**
* The number of times the points list is seeded
*/
private int iterationCount = 0;
/**
* Constructor
*
* @param image The image to generate points for
* @param key The key to seed the PRNG with. If key is null, no PRNG is used
* @param pointFilter The filter to apply to the list of all possible points in order to skip
* certain pixels when embedding
*/
public PointGenerator(T image, String key, PointFilter pointFilter) {
this.image = image;
this.pointFilter = pointFilter;
this.random = key == null ? null : CryptoUtils.seededRandom(key);
this.maxIterations = pointFilter.maxLsbCount();
}
/**
* Generates all possible points and shuffles them
*/
private int seedPoints() {
if (iterationCount >= maxIterations) {
throw new NoSuchElementException("No more points to generate");
}
int width = image.getWidth();
int height = image.getHeight();
Collection filteredPoints = pointFilter.getFilteredPoints(image);
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
Point point = new Point(x, y);
if (!filteredPoints.contains(point)) {
points.add(point);
}
}
}
if (random != null) {
Collections.shuffle(points, random);
}
return ++iterationCount;
}
/**
* Returns the next random point
*
* @return
* @throws NoSuchElementException
*/
public Point nextPoint()
throws NoSuchElementException {
if (points.isEmpty()) {
seedPoints();
}
return points.remove(0);
}
/**
* Returns true if the passed point has been generated by nextPoint() in the current iteration
* phase, otherwise false
*
* @param point
* @return
*/
public boolean wasGenerated(Point point) {
return !points.contains(point);
}
public int getMaxIterations() {
return maxIterations;
}
/**
* Returns the number of times the points list has been seeded
*
* @return
*/
public int getIterationCount() {
return iterationCount;
}
}
stegosuite/src/main/java/org/stegosuite/image/format/ 0000775 0000000 0000000 00000000000 15260777315 0023256 5 ustar 00root root 0000000 0000000 stegosuite/src/main/java/org/stegosuite/image/format/BMPImage.java 0000664 0000000 0000000 00000002564 15260777315 0025511 0 ustar 00root root 0000000 0000000 package org.stegosuite.image.format;
import java.awt.image.BufferedImage;
import java.util.Arrays;
import java.util.List;
import java.util.logging.Logger;
import org.stegosuite.util.ColorUtils;
/**
* Represent BMP-images and provides methods to manipulate BMP pixels
*
* @author alwin
*/
public class BMPImage extends ImageFormat {
private static final Logger LOG = Logger.getLogger(
BMPImage.class.getName()
);
public static final String FILE_EXTENSION = "bmp";
private static final List SUPPORTED_BMP_TYPES = Arrays.asList(
BufferedImage.TYPE_3BYTE_BGR,
BufferedImage.TYPE_4BYTE_ABGR,
BufferedImage.TYPE_4BYTE_ABGR_PRE
);
@Override
public String getFileExtension() {
return FILE_EXTENSION;
}
@Override
public void setBufferedImage(BufferedImage image) {
if (!SUPPORTED_BMP_TYPES.contains(image.getType())) {
LOG.fine("Converting BMP image to 24 bit");
image = ColorUtils.cloneBufferedImage(
image,
BufferedImage.TYPE_3BYTE_BGR
);
}
super.setBufferedImage(image);
LOG.fine(
() ->
"Width, height, type: " +
getWidth() +
"*" +
getHeight() +
"*" +
this.image.getType()
);
}
}
stegosuite/src/main/java/org/stegosuite/image/format/GIFImage.java 0000664 0000000 0000000 00000020075 15260777315 0025475 0 ustar 00root root 0000000 0000000 package org.stegosuite.image.format;
import static java.util.stream.Collectors.toSet;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.awt.image.IndexColorModel;
import java.awt.image.WritableRaster;
import java.io.File;
import java.io.IOException;
import java.util.*;
import java.util.List;
import java.util.logging.Logger;
import javax.imageio.*;
import javax.imageio.stream.ImageOutputStream;
import org.stegosuite.model.exception.SteganoImageException;
import org.stegosuite.util.ColorDistance;
import org.stegosuite.util.ColorUtils;
public class GIFImage extends ImageFormat {
private static final Logger LOG = Logger.getLogger(
GIFImage.class.getName()
);
public static final String FILE_EXTENSION = "gif";
private int[] pixels = null;
private List colorTable = null;
private final Map> sortedColorTables =
new HashMap<>();
/**
* Custom parameters for encoding GIF images
*/
private static class GIFImageWriteParam extends ImageWriteParam {
GIFImageWriteParam() {
super(null);
canWriteCompressed = true;
canWriteProgressive = true;
compressionTypes = new String[] { "LZW", "lzw" };
compressionType = compressionTypes[0];
// Disable interlacing to decrease file size
progressiveMode = ImageWriteParam.MODE_DISABLED;
}
@Override
public void setCompressionMode(int mode) {
if (mode == MODE_DISABLED) {
throw new UnsupportedOperationException(
"MODE_DISABLED is not supported."
);
}
super.setCompressionMode(mode);
}
}
/**
* Saves the modified GIF to file
*/
@Override
public void save(File gifFile) throws SteganoImageException {
LOG.info(() -> "Saving GIF image to " + gifFile.getAbsolutePath());
ImageTypeSpecifier type = ImageTypeSpecifier.createFromRenderedImage(
image
);
ImageWriter writer = ImageIO.getImageWriters(
type,
FILE_EXTENSION
).next();
try (
ImageOutputStream stream = ImageIO.createImageOutputStream(gifFile)
) {
// gifFile.delete();
writer.setOutput(stream);
try {
writer.write(
null,
new IIOImage(image, null, null),
new GIFImageWriteParam()
);
} finally {
writer.dispose();
stream.flush();
}
} catch (IOException e) {
throw new SteganoImageException(e.getMessage());
}
}
/**
*
*/
@Override
public String getFileExtension() {
return FILE_EXTENSION;
}
/**
* Sets the internal BufferedImage instance
*/
@Override
public void setBufferedImage(BufferedImage image) {
super.setBufferedImage(image);
pixels = null;
colorTable = null;
sortedColorTables.clear();
}
/**
* Returns up to 256 colors from the GIF color table. The black padding colors at the end of the
* table are skipped.
*
* @return
*/
public List getColorTable() {
if (colorTable == null) {
long startTime = System.nanoTime();
IndexColorModel colorModel =
(IndexColorModel) image.getColorModel();
int colorCount = colorModel.getMapSize();
byte[] reds = new byte[colorCount];
byte[] greens = new byte[colorCount];
byte[] blues = new byte[colorCount];
colorModel.getReds(reds);
colorModel.getGreens(greens);
colorModel.getBlues(blues);
colorTable = new ArrayList<>(colorCount);
for (int i = 0; i < reds.length; i++) {
colorTable.add(
new Color(reds[i] & 0xFF, greens[i] & 0xFF, blues[i] & 0xFF)
);
}
// Remove trailing blacks if they are unreferenced
Set referencedColors = Arrays.stream(getPixels())
.boxed()
.collect(toSet());
while (
colorTable.size() > 1 &&
colorTable.get(colorTable.size() - 1).equals(Color.BLACK) &&
referencedColors.contains(colorTable.get(colorTable.size() - 1))
) {
colorTable.remove(colorTable.size() - 1);
}
LOG.fine(
() ->
colorTable.size() +
" colors extracted from GIF color table in " +
((System.nanoTime() - startTime) / 1000000) +
" ms"
);
}
return colorTable;
}
/**
* Returns the current color table sorted by the specified color distance
*
* @param colorDistance
* @return
*/
public List getSortedColorTable(ColorDistance colorDistance) {
if (!sortedColorTables.containsKey(colorDistance)) {
long startTime = System.nanoTime();
sortedColorTables.put(
colorDistance,
ColorUtils.sortColors(getColorTable(), colorDistance)
);
LOG.fine(
() ->
"Sorted color table in " +
((System.nanoTime() - startTime) / 1000000) +
" ms"
);
}
return new ArrayList<>(sortedColorTables.get(colorDistance));
}
/**
* Overwrites the existing color table with a new color table.
*
* @param table
*/
public void setColorTable(List table) {
LOG.fine(
() -> "Writing " + table.size() + " colors to GIF color table"
);
byte[] reds = new byte[table.size()];
byte[] greens = new byte[table.size()];
byte[] blues = new byte[table.size()];
for (int i = 0; i < table.size(); i++) {
Color color = table.get(i);
reds[i] = (byte) color.getRed();
greens[i] = (byte) color.getGreen();
blues[i] = (byte) color.getBlue();
}
IndexColorModel colorModel = new IndexColorModel(
8,
table.size(),
reds,
greens,
blues
);
WritableRaster raster = colorModel.createCompatibleWritableRaster(
getWidth(),
getHeight()
);
raster.setPixels(0, 0, getWidth(), getHeight(), getPixels());
image = new BufferedImage(
colorModel,
raster,
image.isAlphaPremultiplied(),
null
);
colorTable = null;
sortedColorTables.clear();
}
/**
* Returns an array of pixel references.
*
* @return
*/
public int[] getPixels() {
if (pixels == null) {
int w = getWidth();
int h = getHeight();
LOG.fine(
() ->
"Reading " +
(w * h) +
" pixels from GIF file (" +
w +
"x" +
h +
")"
);
pixels = image.getRaster().getPixels(0, 0, w, h, (int[]) null);
}
return pixels;
}
/**
* Overwrites the existing pixel references.
*
* @param newPixels
*/
public void setPixels(int[] newPixels) {
int w = getWidth();
int h = getHeight();
LOG.fine(
() ->
"Writing " +
(w * h) +
" pixels to GIF file (" +
w +
"x" +
h +
")"
);
image.getRaster().setPixels(0, 0, w, h, newPixels);
pixels = null;
}
/**
* Returns the histogram of the GIF image.
*
* @return
*/
public Map getHistogram() {
return ColorUtils.getHistogram(getColorTable(), getPixels());
}
}
stegosuite/src/main/java/org/stegosuite/image/format/ImageFormat.java 0000664 0000000 0000000 00000015443 15260777315 0026323 0 ustar 00root root 0000000 0000000 package org.stegosuite.image.format;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.logging.Logger;
import javax.imageio.ImageIO;
import org.eclipse.swt.graphics.ImageData;
import org.stegosuite.model.exception.SteganoImageException;
import org.stegosuite.util.ColorUtils;
import org.stegosuite.util.FileUtils;
import org.stegosuite.util.ImageSwtAwtConverter;
/**
* All supported image formats need to extend this class and implement its abstract methods
*/
public abstract class ImageFormat {
private static final Logger LOG = Logger.getLogger(
ImageFormat.class.getName()
);
private static final Map<
String,
Class
> registeredImageExtensions = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
static {
registeredImageExtensions.put(BMPImage.FILE_EXTENSION, BMPImage.class);
registeredImageExtensions.put(GIFImage.FILE_EXTENSION, GIFImage.class);
registeredImageExtensions.put(JPGImage.FILE_EXTENSION, JPGImage.class);
registeredImageExtensions.put(PNGImage.FILE_EXTENSION, PNGImage.class);
}
/**
* The file instance from which the image was loaded
*/
protected File file = null;
/**
* The image data in AWT format
*/
protected BufferedImage image = null;
/**
* The image data in SWT format
*/
protected ImageData imageData = null;
/**
* Loads an image from disk
*
* @param file
* @throws SteganoImageException
*/
public void load(File file) throws SteganoImageException {
LOG.info(
() ->
"Loading " +
getFileExtension() +
" image from " +
file.getAbsolutePath()
);
this.file = file;
try {
setBufferedImage(ImageIO.read(file));
} catch (IOException e) {
throw new SteganoImageException(e.getMessage());
}
}
/**
* Saves the image to disk
*
* @param file
* @throws SteganoImageException
*/
public void save(File file) throws SteganoImageException {
LOG.info(
() ->
"Saving " +
getFileExtension() +
" image to " +
file.getAbsolutePath()
);
try {
ImageIO.write(image, getFileExtension(), file);
} catch (IOException e) {
throw new SteganoImageException(e.getMessage());
}
}
/**
* Returns the file extension of the image format
*
* @return
*/
public abstract String getFileExtension();
/**
* Returns the image's width
*
* @return
*/
public int getWidth() {
return image.getWidth();
}
/**
* Returns the image's height
*
* @return
*/
public int getHeight() {
return image.getHeight();
}
/**
* Returns the image in AWT's BufferedImage format
*
* @return
*/
public BufferedImage getBufferedImage() {
return image;
}
/**
* Sets an image.
*
* @param image AWT's BufferedImage format
*/
public void setBufferedImage(BufferedImage image) {
this.image = image;
imageData = null;
}
/**
* Returns the image in SWT's ImageData format
*
* @return
*/
public ImageData getImageData() {
if (imageData == null) {
imageData = ImageSwtAwtConverter.convertToSWT(image);
}
return imageData;
}
public File getFile() {
return file;
}
public ImageFormat clone(int imageType) {
ImageFormat clonedImage = newInstance(this.getClass());
clonedImage.setBufferedImage(
ColorUtils.cloneBufferedImage(image, imageType)
);
clonedImage.file = file;
return clonedImage;
}
@Override
public ImageFormat clone() {
return this.clone(image.getType());
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((file == null) ? 0 : file.hashCode());
result = prime * result + ((image == null) ? 0 : image.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
ImageFormat other = (ImageFormat) obj;
if (file == null) {
if (other.file != null) {
return false;
}
} else if (!file.equals(other.file)) {
return false;
}
if (image == null) {
return other.image == null;
} else return image.equals(other.image);
}
public static Set getSupportedFormats() {
return getRegisteredImageExtensions().keySet();
}
private static Map<
String,
Class
> getRegisteredImageExtensions() {
return registeredImageExtensions;
}
/**
* Returns a new instance of an ImageFormat depending on which class registered the filename
* extension
*
* @param fileNameExtension
* @return
*/
public static ImageFormat newInstance(String fileNameExtension) {
Class imageFormatClass =
getRegisteredImageExtensions().get(fileNameExtension);
return imageFormatClass == null ? null : newInstance(imageFormatClass);
}
/**
* Returns a new instance of the imageFormatClass
*
* @param imageFormatClass
* @return
*/
public static ImageFormat newInstance(
Class imageFormatClass
) {
try {
return imageFormatClass.getConstructor().newInstance();
} catch (Exception e) {
LOG.severe(e.getMessage());
}
return null;
}
/**
* Returns the ImageFormat object for a given image file path
*
* @param path absolute file-path of the image
* @return the image format for the image
* @throws SteganoImageException
*/
public static ImageFormat getImageFormat(String path)
throws SteganoImageException {
ImageFormat image = null;
if (path != null) {
String extension = FileUtils.getFileExtension(path);
if (getRegisteredImageExtensions().containsKey(extension)) {
image = newInstance(extension);
image.load(new File(path));
}
}
return image;
}
public String getFilePath() {
return file.getAbsolutePath();
}
}
stegosuite/src/main/java/org/stegosuite/image/format/JPGImage.java 0000664 0000000 0000000 00000000671 15260777315 0025510 0 ustar 00root root 0000000 0000000 package org.stegosuite.image.format;
import org.stegosuite.model.exception.SteganoImageException;
import java.io.File;
public class JPGImage
extends ImageFormat {
public static final String FILE_EXTENSION = "jpg";
@Override
public String getFileExtension() {
return FILE_EXTENSION;
}
@Override
public void save(File file)
throws SteganoImageException {
// temporally nothing because it's already done in embedding
}
}
stegosuite/src/main/java/org/stegosuite/image/format/PNGImage.java 0000664 0000000 0000000 00000001471 15260777315 0025513 0 ustar 00root root 0000000 0000000 package org.stegosuite.image.format;
import java.awt.image.BufferedImage;
import java.util.logging.Logger;
/**
* Represent PNG-images and provides methods to manipulate PNG pixels
*
*/
public class PNGImage extends ImageFormat {
private static final Logger LOG = Logger.getLogger(
PNGImage.class.getName()
);
public static final String FILE_EXTENSION = "png";
@Override
public String getFileExtension() {
return FILE_EXTENSION;
}
@Override
public void setBufferedImage(BufferedImage image) {
super.setBufferedImage(image);
LOG.fine(
() ->
"Width, height, type: " +
getWidth() +
"*" +
getHeight() +
"*" +
this.image.getType()
);
}
}
stegosuite/src/main/java/org/stegosuite/image/jpgtemp/ 0000775 0000000 0000000 00000000000 15260777315 0023434 5 ustar 00root root 0000000 0000000 stegosuite/src/main/java/org/stegosuite/image/jpgtemp/james/ 0000775 0000000 0000000 00000000000 15260777315 0024533 5 ustar 00root root 0000000 0000000 stegosuite/src/main/java/org/stegosuite/image/jpgtemp/james/DCT.java 0000664 0000000 0000000 00000033502 15260777315 0026013 0 ustar 00root root 0000000 0000000 // Version 1.0a
// Copyright (C) 1998, James R. Weeks and BioElectroMech.
// Visit BioElectroMech at www.obrador.com. Email James@obrador.com.
// See license.txt for details about the allowed used of this software.
// This software is based in part on the work of the Independent JPEG Group.
// See IJGreadme.txt for details about the Independent JPEG Group's license.
// This encoder is inspired by the Java Jpeg encoder by Florian Raemy,
// studwww.eurecom.fr/~raemy.
// It borrows a great deal of code and structure from the Independent
// Jpeg Group's Jpeg 6a library, Copyright Thomas G. Lane.
// See license.txt for details.
package org.stegosuite.image.jpgtemp.james;
/**
* DCT - A Java implementation of the Discreet Cosine Transform
*/
@SuppressWarnings("unused")
class DCT {
/**
* DCT Block Size - default 8
*/
public final int N = 8;
/**
* Image Quality (0-100) - default 80 (good image / good compression)
*/
public int QUALITY = 80;
public final Object[] quantum = new Object[2];
public final Object[] Divisors = new Object[2];
/**
* Quantization Matrix for luminance.
*/
public final int[] quantum_luminance = new int[this.N * this.N];
public final double[] DivisorsLuminance = new double[this.N * this.N];
/**
* Quantization Matrix for chrominance.
*/
public final int[] quantum_chrominance = new int[this.N * this.N];
public final double[] DivisorsChrominance = new double[this.N * this.N];
/**
* Constructs a new DCT object. Initializes the cosine transform matrix these are used when
* computing the DCT and its inverse. This also initializes the run length counters and the
* ZigZag sequence. Note that the image quality can be worse than 25 however the image will be
* extremely pixelated, usually to a block size of N.
*
* @param QUALITY The quality of the image (0 worst - 100 best)
*/
public DCT(final int QUALITY) {
initMatrix(QUALITY);
}
/*
* This method preforms a DCT on a block of image data using the AAN method as implemented in
* the IJG Jpeg-6a library.
*/
public double[][] forwardDCT(final float[][] input) {
final double[][] output = new double[this.N][this.N];
double tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
double tmp10, tmp11, tmp12, tmp13;
double z1, z2, z3, z4, z5, z11, z13;
int i;
int j;
// Subtracts 128 from the input values
for (i = 0; i < 8; i++) {
for (j = 0; j < 8; j++) {
output[i][j] = input[i][j] - 128.0;
// input[i][j] -= 128;
}
}
for (i = 0; i < 8; i++) {
tmp0 = output[i][0] + output[i][7];
tmp7 = output[i][0] - output[i][7];
tmp1 = output[i][1] + output[i][6];
tmp6 = output[i][1] - output[i][6];
tmp2 = output[i][2] + output[i][5];
tmp5 = output[i][2] - output[i][5];
tmp3 = output[i][3] + output[i][4];
tmp4 = output[i][3] - output[i][4];
tmp10 = tmp0 + tmp3;
tmp13 = tmp0 - tmp3;
tmp11 = tmp1 + tmp2;
tmp12 = tmp1 - tmp2;
output[i][0] = tmp10 + tmp11;
output[i][4] = tmp10 - tmp11;
z1 = (tmp12 + tmp13) * 0.707106781;
output[i][2] = tmp13 + z1;
output[i][6] = tmp13 - z1;
tmp10 = tmp4 + tmp5;
tmp11 = tmp5 + tmp6;
tmp12 = tmp6 + tmp7;
z5 = (tmp10 - tmp12) * 0.382683433;
z2 = 0.541196100 * tmp10 + z5;
z4 = 1.306562965 * tmp12 + z5;
z3 = tmp11 * 0.707106781;
z11 = tmp7 + z3;
z13 = tmp7 - z3;
output[i][5] = z13 + z2;
output[i][3] = z13 - z2;
output[i][1] = z11 + z4;
output[i][7] = z11 - z4;
}
for (i = 0; i < 8; i++) {
tmp0 = output[0][i] + output[7][i];
tmp7 = output[0][i] - output[7][i];
tmp1 = output[1][i] + output[6][i];
tmp6 = output[1][i] - output[6][i];
tmp2 = output[2][i] + output[5][i];
tmp5 = output[2][i] - output[5][i];
tmp3 = output[3][i] + output[4][i];
tmp4 = output[3][i] - output[4][i];
tmp10 = tmp0 + tmp3;
tmp13 = tmp0 - tmp3;
tmp11 = tmp1 + tmp2;
tmp12 = tmp1 - tmp2;
output[0][i] = tmp10 + tmp11;
output[4][i] = tmp10 - tmp11;
z1 = (tmp12 + tmp13) * 0.707106781;
output[2][i] = tmp13 + z1;
output[6][i] = tmp13 - z1;
tmp10 = tmp4 + tmp5;
tmp11 = tmp5 + tmp6;
tmp12 = tmp6 + tmp7;
z5 = (tmp10 - tmp12) * 0.382683433;
z2 = 0.541196100 * tmp10 + z5;
z4 = 1.306562965 * tmp12 + z5;
z3 = tmp11 * 0.707106781;
z11 = tmp7 + z3;
z13 = tmp7 - z3;
output[5][i] = z13 + z2;
output[3][i] = z13 - z2;
output[1][i] = z11 + z4;
output[7][i] = z11 - z4;
}
return output;
}
/*
* This method preforms forward DCT on a block of image data using the literal method specified
* for a 2-D Discrete Cosine Transform. It is included as a curiosity and can give you an idea
* of the difference in the compression result (the resulting image quality) by comparing its
* output to the output of the AAN method below. It is ridiculously inefficient.
*/
// For now the final output is unusable. The associated quantization step
// needs some tweaking. If you get this part working, please let me know.
public double[][] forwardDCTExtreme(final float[][] input) {
final double[][] output = new double[this.N][this.N];
final double tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
final double tmp10, tmp11, tmp12, tmp13;
final double z1, z2, z3, z4, z5, z11, z13;
final int i;
final int j;
int v, u, x, y;
for (v = 0; v < 8; v++) {
for (u = 0; u < 8; u++) {
for (x = 0; x < 8; x++) {
for (y = 0; y < 8; y++) {
output[v][u] += input[x][y] * Math.cos((double) (2 * x + 1) * (double) u * Math.PI / 16)
* Math.cos((double) (2 * y + 1) * (double) v * Math.PI / 16);
}
}
output[v][u] *= 0.25 * (u == 0 ? 1.0 / Math.sqrt(2) : (double) 1.0)
* (v == 0 ? 1.0 / Math.sqrt(2) : (double) 1.0);
}
}
return output;
}
/*
* This method sets up the quantization matrix for luminance and chrominance using the Quality
* parameter.
*/
private void initMatrix(final int quality) {
final double[] AANscaleFactor = { 1.0, 1.387039845, 1.306562965, 1.175875602, 1.0, 0.785694958, 0.541196100,
0.275899379 };
int i;
int j;
int index;
int Quality;
int temp;
// converting quality setting to that specified in the
// jpeg_quality_scaling
// method in the IJG Jpeg-6a C libraries
Quality = quality;
if (Quality <= 0) {
Quality = 1;
}
if (Quality > 100) {
Quality = 100;
}
if (Quality < 50) {
Quality = 5000 / Quality;
} else {
Quality = 200 - Quality * 2;
}
// Creating the luminance matrix
this.quantum_luminance[0] = 16;
this.quantum_luminance[1] = 11;
this.quantum_luminance[2] = 10;
this.quantum_luminance[3] = 16;
this.quantum_luminance[4] = 24;
this.quantum_luminance[5] = 40;
this.quantum_luminance[6] = 51;
this.quantum_luminance[7] = 61;
this.quantum_luminance[8] = 12;
this.quantum_luminance[9] = 12;
this.quantum_luminance[10] = 14;
this.quantum_luminance[11] = 19;
this.quantum_luminance[12] = 26;
this.quantum_luminance[13] = 58;
this.quantum_luminance[14] = 60;
this.quantum_luminance[15] = 55;
this.quantum_luminance[16] = 14;
this.quantum_luminance[17] = 13;
this.quantum_luminance[18] = 16;
this.quantum_luminance[19] = 24;
this.quantum_luminance[20] = 40;
this.quantum_luminance[21] = 57;
this.quantum_luminance[22] = 69;
this.quantum_luminance[23] = 56;
this.quantum_luminance[24] = 14;
this.quantum_luminance[25] = 17;
this.quantum_luminance[26] = 22;
this.quantum_luminance[27] = 29;
this.quantum_luminance[28] = 51;
this.quantum_luminance[29] = 87;
this.quantum_luminance[30] = 80;
this.quantum_luminance[31] = 62;
this.quantum_luminance[32] = 18;
this.quantum_luminance[33] = 22;
this.quantum_luminance[34] = 37;
this.quantum_luminance[35] = 56;
this.quantum_luminance[36] = 68;
this.quantum_luminance[37] = 109;
this.quantum_luminance[38] = 103;
this.quantum_luminance[39] = 77;
this.quantum_luminance[40] = 24;
this.quantum_luminance[41] = 35;
this.quantum_luminance[42] = 55;
this.quantum_luminance[43] = 64;
this.quantum_luminance[44] = 81;
this.quantum_luminance[45] = 104;
this.quantum_luminance[46] = 113;
this.quantum_luminance[47] = 92;
this.quantum_luminance[48] = 49;
this.quantum_luminance[49] = 64;
this.quantum_luminance[50] = 78;
this.quantum_luminance[51] = 87;
this.quantum_luminance[52] = 103;
this.quantum_luminance[53] = 121;
this.quantum_luminance[54] = 120;
this.quantum_luminance[55] = 101;
this.quantum_luminance[56] = 72;
this.quantum_luminance[57] = 92;
this.quantum_luminance[58] = 95;
this.quantum_luminance[59] = 98;
this.quantum_luminance[60] = 112;
this.quantum_luminance[61] = 100;
this.quantum_luminance[62] = 103;
this.quantum_luminance[63] = 99;
for (j = 0; j < 64; j++) {
temp = (this.quantum_luminance[j] * Quality + 50) / 100;
if (temp <= 0) {
temp = 1;
}
if (temp > 255) {
temp = 255;
}
this.quantum_luminance[j] = temp;
}
index = 0;
for (i = 0; i < 8; i++) {
for (j = 0; j < 8; j++) {
// The divisors for the LL&M method (the slow integer method
// used in
// jpeg 6a library). This method is currently (04/04/98)
// incompletely
// implemented.
// DivisorsLuminance[index] = ((double)
// quantum_luminance[index]) << 3;
// The divisors for the AAN method (the float method used in
// jpeg 6a library.)
this.DivisorsLuminance[index] = 1.0
/ (this.quantum_luminance[index] * AANscaleFactor[i] * AANscaleFactor[j] * 8.0);
index++;
}
}
// Creating the chrominance matrix
this.quantum_chrominance[0] = 17;
this.quantum_chrominance[1] = 18;
this.quantum_chrominance[2] = 24;
this.quantum_chrominance[3] = 47;
this.quantum_chrominance[4] = 99;
this.quantum_chrominance[5] = 99;
this.quantum_chrominance[6] = 99;
this.quantum_chrominance[7] = 99;
this.quantum_chrominance[8] = 18;
this.quantum_chrominance[9] = 21;
this.quantum_chrominance[10] = 26;
this.quantum_chrominance[11] = 66;
this.quantum_chrominance[12] = 99;
this.quantum_chrominance[13] = 99;
this.quantum_chrominance[14] = 99;
this.quantum_chrominance[15] = 99;
this.quantum_chrominance[16] = 24;
this.quantum_chrominance[17] = 26;
this.quantum_chrominance[18] = 56;
this.quantum_chrominance[19] = 99;
this.quantum_chrominance[20] = 99;
this.quantum_chrominance[21] = 99;
this.quantum_chrominance[22] = 99;
this.quantum_chrominance[23] = 99;
this.quantum_chrominance[24] = 47;
this.quantum_chrominance[25] = 66;
this.quantum_chrominance[26] = 99;
this.quantum_chrominance[27] = 99;
this.quantum_chrominance[28] = 99;
this.quantum_chrominance[29] = 99;
this.quantum_chrominance[30] = 99;
this.quantum_chrominance[31] = 99;
this.quantum_chrominance[32] = 99;
this.quantum_chrominance[33] = 99;
this.quantum_chrominance[34] = 99;
this.quantum_chrominance[35] = 99;
this.quantum_chrominance[36] = 99;
this.quantum_chrominance[37] = 99;
this.quantum_chrominance[38] = 99;
this.quantum_chrominance[39] = 99;
this.quantum_chrominance[40] = 99;
this.quantum_chrominance[41] = 99;
this.quantum_chrominance[42] = 99;
this.quantum_chrominance[43] = 99;
this.quantum_chrominance[44] = 99;
this.quantum_chrominance[45] = 99;
this.quantum_chrominance[46] = 99;
this.quantum_chrominance[47] = 99;
this.quantum_chrominance[48] = 99;
this.quantum_chrominance[49] = 99;
this.quantum_chrominance[50] = 99;
this.quantum_chrominance[51] = 99;
this.quantum_chrominance[52] = 99;
this.quantum_chrominance[53] = 99;
this.quantum_chrominance[54] = 99;
this.quantum_chrominance[55] = 99;
this.quantum_chrominance[56] = 99;
this.quantum_chrominance[57] = 99;
this.quantum_chrominance[58] = 99;
this.quantum_chrominance[59] = 99;
this.quantum_chrominance[60] = 99;
this.quantum_chrominance[61] = 99;
this.quantum_chrominance[62] = 99;
this.quantum_chrominance[63] = 99;
for (j = 0; j < 64; j++) {
temp = (this.quantum_chrominance[j] * Quality + 50) / 100;
if (temp <= 0) {
temp = 1;
}
if (temp >= 255) {
temp = 255;
}
this.quantum_chrominance[j] = temp;
}
index = 0;
for (i = 0; i < 8; i++) {
for (j = 0; j < 8; j++) {
// The divisors for the LL&M method (the slow integer method
// used in
// jpeg 6a library). This method is currently (04/04/98)
// incompletely
// implemented.
// DivisorsChrominance[index] = ((double)
// quantum_chrominance[index]) << 3;
// The divisors for the AAN method (the float method used in
// jpeg 6a library.)
this.DivisorsChrominance[index] = 1.0
/ (this.quantum_chrominance[index] * AANscaleFactor[i] * AANscaleFactor[j] * 8.0);
index++;
}
}
// quantum and Divisors are objects used to hold the appropriate matices
this.quantum[0] = this.quantum_luminance;
this.Divisors[0] = this.DivisorsLuminance;
this.quantum[1] = this.quantum_chrominance;
this.Divisors[1] = this.DivisorsChrominance;
}
/*
* This method quantitizes data and rounds it to the nearest integer.
*/
public int[] quantizeBlock(final double[][] inputData, final int code) {
final int[] outputData = new int[this.N * this.N];
int i, j;
int index;
index = 0;
for (i = 0; i < 8; i++) {
for (j = 0; j < 8; j++) {
// The second line results in significantly better compression.
outputData[index] = (int) Math.round(inputData[i][j] * ((double[]) this.Divisors[code])[index]);
// outputData[index] = (int)(((inputData[i][j] * (((double[])
// (Divisors[code]))[index])) + 16384.5) -16384);
index++;
}
}
return outputData;
}
/*
* This is the method for quantizing a block DCT'ed with forwardDCTExtreme This method
* quantitizes data and rounds it to the nearest integer.
*/
public int[] quantizeBlockExtreme(final double[][] inputData, final int code) {
final int[] outputData = new int[this.N * this.N];
int i, j;
int index;
index = 0;
for (i = 0; i < 8; i++) {
for (j = 0; j < 8; j++) {
outputData[index] = (int) Math.round(inputData[i][j] / ((int[]) this.quantum[code])[index]);
index++;
}
}
return outputData;
}
}
stegosuite/src/main/java/org/stegosuite/image/jpgtemp/james/Huffman.java 0000664 0000000 0000000 00000025514 15260777315 0026771 0 ustar 00root root 0000000 0000000 // Version 1.0a
// Copyright (C) 1998, James R. Weeks and BioElectroMech.
// Visit BioElectroMech at www.obrador.com. Email James@obrador.com.
// See license.txt for details about the allowed used of this software.
// This software is based in part on the work of the Independent JPEG Group.
// See IJGreadme.txt for details about the Independent JPEG Group's license.
// This encoder is inspired by the Java Jpeg encoder by Florian Raemy,
// studwww.eurecom.fr/~raemy.
// It borrows a great deal of code and structure from the Independent
// Jpeg Group's Jpeg 6a library, Copyright Thomas G. Lane.
// See license.txt for details.
package org.stegosuite.image.jpgtemp.james;
import java.io.BufferedOutputStream;
import java.io.IOException;
import java.util.Vector;
class Huffman {
int bufferPutBits, bufferPutBuffer;
public final int ImageHeight;
public final int ImageWidth;
public int[][] DC_matrix0;
public int[][] AC_matrix0;
public int[][] DC_matrix1;
public int[][] AC_matrix1;
public Object[] DC_matrix;
public Object[] AC_matrix;
public int code;
public int NumOfDCTables;
public int NumOfACTables;
public final int[] bitsDCluminance = { 0x00, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
public final int[] valDCluminance = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
public final int[] bitsDCchrominance = { 0x01, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
public final int[] valDCchrominance = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
public final int[] bitsACluminance = { 0x10, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
public final int[] valACluminance = { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06, 0x13, 0x51,
0x61, 0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08, 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x53, 0x54, 0x55,
0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77,
0x78, 0x79, 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8,
0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8,
0xd9, 0xda, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6,
0xf7, 0xf8, 0xf9, 0xfa };
public final int[] bitsACchrominance = { 0x11, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
public final int[] valACchrominance = { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51,
0x07, 0x61, 0x71, 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52,
0xf0, 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34, 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26, 0x27,
0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x53,
0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x73, 0x74, 0x75,
0x76, 0x77, 0x78, 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95,
0x96, 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5,
0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5,
0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf2, 0xf3, 0xf4, 0xf5,
0xf6, 0xf7, 0xf8, 0xf9, 0xfa };
public final Vector bits;
public final Vector val;
/*
* jpegNaturalOrder[i] is the natural-order position of the i'th element of zigzag order.
*/
public static final int[] jpegNaturalOrder = { 0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5, 12, 19, 26, 33, 40,
48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28, 35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51,
58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63, };
/*
* The Huffman class constructor
*/
public Huffman(final int Width, final int Height) {
this.bits = new Vector<>();
this.bits.addElement(this.bitsDCluminance);
this.bits.addElement(this.bitsACluminance);
this.bits.addElement(this.bitsDCchrominance);
this.bits.addElement(this.bitsACchrominance);
this.val = new Vector<>();
this.val.addElement(this.valDCluminance);
this.val.addElement(this.valACluminance);
this.val.addElement(this.valDCchrominance);
this.val.addElement(this.valACchrominance);
initHuf();
this.ImageWidth = Width;
this.ImageHeight = Height;
}
void bufferIt(final BufferedOutputStream outStream, final int code, final int size) {
int PutBuffer = code;
int PutBits = this.bufferPutBits;
PutBuffer &= (1 << size) - 1;
PutBits += size;
PutBuffer <<= 24 - PutBits;
PutBuffer |= this.bufferPutBuffer;
while (PutBits >= 8) {
final int c = PutBuffer >> 16 & 0xFF;
try {
outStream.write(c);
} catch (final IOException e) {
System.out.println("IO Error: " + e.getMessage());
}
if (c == 0xFF) {
try {
outStream.write(0);
} catch (final IOException e) {
System.out.println("IO Error: " + e.getMessage());
}
}
PutBuffer <<= 8;
PutBits -= 8;
}
this.bufferPutBuffer = PutBuffer;
this.bufferPutBits = PutBits;
}
// Uses an integer long (32 bits) buffer to store the Huffman encoded bits
// and sends them to outStream by the byte.
void flushBuffer(final BufferedOutputStream outStream) {
int PutBuffer = this.bufferPutBuffer;
int PutBits = this.bufferPutBits;
while (PutBits >= 8) {
final int c = PutBuffer >> 16 & 0xFF;
try {
outStream.write(c);
} catch (final IOException e) {
System.out.println("IO Error: " + e.getMessage());
}
if (c == 0xFF) {
try {
outStream.write(0);
} catch (final IOException e) {
System.out.println("IO Error: " + e.getMessage());
}
}
PutBuffer <<= 8;
PutBits -= 8;
}
if (PutBits > 0) {
final int c = PutBuffer >> 16 & 0xFF;
try {
outStream.write(c);
} catch (final IOException e) {
System.out.println("IO Error: " + e.getMessage());
}
}
}
/**
* HuffmanBlockEncoder run length encodes and Huffman encodes the quantized data.
**/
public void HuffmanBlockEncoder(final BufferedOutputStream outStream, final int[] zigzag, final int prec,
final int DCcode, final int ACcode) {
int temp, temp2, nbits, k, r, i;
this.NumOfDCTables = 2;
this.NumOfACTables = 2;
// The DC portion
temp = temp2 = zigzag[0] - prec;
if (temp < 0) {
temp = -temp;
temp2--;
}
nbits = 0;
while (temp != 0) {
nbits++;
temp >>= 1;
}
// if (nbits > 11) nbits = 11;
bufferIt(outStream, ((int[][]) this.DC_matrix[DCcode])[nbits][0], ((int[][]) this.DC_matrix[DCcode])[nbits][1]);
// The arguments in bufferIt are code and size.
if (nbits != 0) {
bufferIt(outStream, temp2, nbits);
}
// The AC portion
r = 0;
for (k = 1; k < 64; k++) {
if ((temp = zigzag[jpegNaturalOrder[k]]) == 0) {
r++;
} else {
while (r > 15) {
bufferIt(outStream, ((int[][]) this.AC_matrix[ACcode])[0xF0][0],
((int[][]) this.AC_matrix[ACcode])[0xF0][1]);
r -= 16;
}
temp2 = temp;
if (temp < 0) {
temp = -temp;
temp2--;
}
nbits = 1;
while ((temp >>= 1) != 0) {
nbits++;
}
i = (r << 4) + nbits;
bufferIt(outStream, ((int[][]) this.AC_matrix[ACcode])[i][0], ((int[][]) this.AC_matrix[ACcode])[i][1]);
bufferIt(outStream, temp2, nbits);
r = 0;
}
}
if (r > 0) {
bufferIt(outStream, ((int[][]) this.AC_matrix[ACcode])[0][0], ((int[][]) this.AC_matrix[ACcode])[0][1]);
}
}
/*
* Initialisation of the Huffman codes for Luminance and Chrominance. This code results in the
* same tables created in the IJG Jpeg-6a library.
*/
public void initHuf() {
this.DC_matrix0 = new int[12][2];
this.DC_matrix1 = new int[12][2];
this.AC_matrix0 = new int[255][2];
this.AC_matrix1 = new int[255][2];
this.DC_matrix = new Object[2];
this.AC_matrix = new Object[2];
int p, l, i, lastp, si, code;
final int[] huffsize = new int[257];
final int[] huffcode = new int[257];
/*
* init of the DC values for the chrominance [][0] is the code [][1] is the number of bit
*/
p = 0;
for (l = 1; l <= 16; l++) {
for (i = 1; i <= this.bitsDCchrominance[l]; i++) {
huffsize[p++] = l;
}
}
huffsize[p] = 0;
lastp = p;
code = 0;
si = huffsize[0];
p = 0;
while (huffsize[p] != 0) {
while (huffsize[p] == si) {
huffcode[p++] = code;
code++;
}
code <<= 1;
si++;
}
for (p = 0; p < lastp; p++) {
this.DC_matrix1[this.valDCchrominance[p]][0] = huffcode[p];
this.DC_matrix1[this.valDCchrominance[p]][1] = huffsize[p];
}
/*
* Init of the AC hufmann code for the chrominance matrix [][][0] is the code &
* matrix[][][1] is the number of bit needed
*/
p = 0;
for (l = 1; l <= 16; l++) {
for (i = 1; i <= this.bitsACchrominance[l]; i++) {
huffsize[p++] = l;
}
}
huffsize[p] = 0;
lastp = p;
code = 0;
si = huffsize[0];
p = 0;
while (huffsize[p] != 0) {
while (huffsize[p] == si) {
huffcode[p++] = code;
code++;
}
code <<= 1;
si++;
}
for (p = 0; p < lastp; p++) {
this.AC_matrix1[this.valACchrominance[p]][0] = huffcode[p];
this.AC_matrix1[this.valACchrominance[p]][1] = huffsize[p];
}
/*
* init of the DC values for the luminance [][0] is the code [][1] is the number of bit
*/
p = 0;
for (l = 1; l <= 16; l++) {
for (i = 1; i <= this.bitsDCluminance[l]; i++) {
huffsize[p++] = l;
}
}
huffsize[p] = 0;
lastp = p;
code = 0;
si = huffsize[0];
p = 0;
while (huffsize[p] != 0) {
while (huffsize[p] == si) {
huffcode[p++] = code;
code++;
}
code <<= 1;
si++;
}
for (p = 0; p < lastp; p++) {
this.DC_matrix0[this.valDCluminance[p]][0] = huffcode[p];
this.DC_matrix0[this.valDCluminance[p]][1] = huffsize[p];
}
/*
* Init of the AC hufmann code for luminance matrix [][][0] is the code & matrix[][][1] is
* the number of bit
*/
p = 0;
for (l = 1; l <= 16; l++) {
for (i = 1; i <= this.bitsACluminance[l]; i++) {
huffsize[p++] = l;
}
}
huffsize[p] = 0;
lastp = p;
code = 0;
si = huffsize[0];
p = 0;
while (huffsize[p] != 0) {
while (huffsize[p] == si) {
huffcode[p++] = code;
code++;
}
code <<= 1;
si++;
}
for (int q = 0; q < lastp; q++) {
this.AC_matrix0[this.valACluminance[q]][0] = huffcode[q];
this.AC_matrix0[this.valACluminance[q]][1] = huffsize[q];
}
this.DC_matrix[0] = this.DC_matrix0;
this.DC_matrix[1] = this.DC_matrix1;
this.AC_matrix[0] = this.AC_matrix0;
this.AC_matrix[1] = this.AC_matrix1;
}
}
stegosuite/src/main/java/org/stegosuite/image/jpgtemp/james/IJGreadme.txt 0000664 0000000 0000000 00000047442 15260777315 0027076 0 ustar 00root root 0000000 0000000 The Independent JPEG Group's JPEG software
==========================================
README for release 6a of 7-Feb-96
=================================
This distribution contains the sixth public release of the Independent JPEG
Group's free JPEG software. You are welcome to redistribute this software and
to use it for any purpose, subject to the conditions under LEGAL ISSUES, below.
Serious users of this software (particularly those incorporating it into
larger programs) should contact IJG at jpeg-info@uunet.uu.net to be added to
our electronic mailing list. Mailing list members are notified of updates
and have a chance to participate in technical discussions, etc.
This software is the work of Tom Lane, Philip Gladstone, Luis Ortiz, Jim
Boucher, Lee Crocker, Julian Minguillon, George Phillips, Davide Rossi,
Ge' Weijers, and other members of the Independent JPEG Group.
IJG is not affiliated with the official ISO JPEG standards committee.
DOCUMENTATION ROADMAP
=====================
This file contains the following sections:
OVERVIEW General description of JPEG and the IJG software.
LEGAL ISSUES Copyright, lack of warranty, terms of distribution.
REFERENCES Where to learn more about JPEG.
ARCHIVE LOCATIONS Where to find newer versions of this software.
RELATED SOFTWARE Other stuff you should get.
FILE FORMAT WARS Software *not* to get.
TO DO Plans for future IJG releases.
Other documentation files in the distribution are:
User documentation:
install.doc How to configure and install the IJG software.
usage.doc Usage instructions for cjpeg, djpeg, jpegtran,
rdjpgcom, and wrjpgcom.
*.1 Unix-style man pages for programs (same info as usage.doc).
wizard.doc Advanced usage instructions for JPEG wizards only.
change.log Version-to-version change highlights.
Programmer and internal documentation:
libjpeg.doc How to use the JPEG library in your own programs.
example.c Sample code for calling the JPEG library.
structure.doc Overview of the JPEG library's internal structure.
filelist.doc Road map of IJG files.
coderules.doc Coding style rules --- please read if you contribute code.
Please read at least the files install.doc and usage.doc. Useful information
can also be found in the JPEG FAQ (Frequently Asked Questions) article. See
ARCHIVE LOCATIONS below to find out where to obtain the FAQ article.
If you want to understand how the JPEG code works, we suggest reading one or
more of the REFERENCES, then looking at the documentation files (in roughly
the order listed) before diving into the code.
OVERVIEW
========
This package contains C software to implement JPEG image compression and
decompression. JPEG (pronounced "jay-peg") is a standardized compression
method for full-color and gray-scale images. JPEG is intended for compressing
"real-world" scenes; line drawings, cartoons and other non-realistic images
are not its strong suit. JPEG is lossy, meaning that the output image is not
exactly identical to the input image. Hence, you must not use JPEG if you
have to have identical output bits. However, on typical photographic images,
very good compression levels can be obtained with no visible change, and
remarkably high compression levels are possible if you can tolerate a
low-quality image. For more details, see the references, or just experiment
with various compression settings.
This software implements JPEG baseline, extended-sequential, and progressive
compression processes. Provision is made for supporting all variants of these
processes, although some uncommon parameter settings aren't implemented yet.
For legal reasons, we are not distributing code for the arithmetic-coding
variants of JPEG; see LEGAL ISSUES. We have made no provision for supporting
the hierarchical or lossless processes defined in the standard.
We provide a set of library routines for reading and writing JPEG image files,
plus two sample applications "cjpeg" and "djpeg", which use the library to
perform conversion between JPEG and some other popular image file formats.
The library is intended to be reused in other applications.
In order to support file conversion and viewing software, we have included
considerable functionality beyond the bare JPEG coding/decoding capability;
for example, the color quantization modules are not strictly part of JPEG
decoding, but they are essential for output to colormapped file formats or
colormapped displays. These extra functions can be compiled out of the
library if not required for a particular application. We have also included
"jpegtran", a utility for lossless transcoding between different JPEG
processes, and "rdjpgcom" and "wrjpgcom", two simple applications for
inserting and extracting textual comments in JFIF files.
The emphasis in designing this software has been on achieving portability and
flexibility, while also making it fast enough to be useful. In particular,
the software is not intended to be read as a tutorial on JPEG. (See the
REFERENCES section for introductory material.) Rather, it is intended to
be reliable, portable, industrial-strength code. We do not claim to have
achieved that goal in every aspect of the software, but we strive for it.
We welcome the use of this software as a component of commercial products.
No royalty is required, but we do ask for an acknowledgement in product
documentation, as described under LEGAL ISSUES.
LEGAL ISSUES
============
In plain English:
1. We don't promise that this software works. (But if you find any bugs,
please let us know!)
2. You can use this software for whatever you want. You don't have to pay us.
3. You may not pretend that you wrote this software. If you use it in a
program, you must acknowledge somewhere in your documentation that
you've used the IJG code.
In legalese:
The authors make NO WARRANTY or representation, either express or implied,
with respect to this software, its quality, accuracy, merchantability, or
fitness for a particular purpose. This software is provided "AS IS", and you,
its user, assume the entire risk as to its quality and accuracy.
This software is copyright (C) 1991-1996, Thomas G. Lane.
All Rights Reserved except as specified below.
Permission is hereby granted to use, copy, modify, and distribute this
software (or portions thereof) for any purpose, without fee, subject to these
conditions:
(1) If any part of the source code for this software is distributed, then this
README file must be included, with this copyright and no-warranty notice
unaltered; and any additions, deletions, or changes to the original files
must be clearly indicated in accompanying documentation.
(2) If only executable code is distributed, then the accompanying
documentation must state that "this software is based in part on the work of
the Independent JPEG Group".
(3) Permission for use of this software is granted only if the user accepts
full responsibility for any undesirable consequences; the authors accept
NO LIABILITY for damages of any kind.
These conditions apply to any software derived from or based on the IJG code,
not just to the unmodified library. If you use our work, you ought to
acknowledge us.
Permission is NOT granted for the use of any IJG author's name or company name
in advertising or publicity relating to this software or products derived from
it. This software may be referred to only as "the Independent JPEG Group's
software".
We specifically permit and encourage the use of this software as the basis of
commercial products, provided that all warranty or liability claims are
assumed by the product vendor.
ansi2knr.c is included in this distribution by permission of L. Peter Deutsch,
sole proprietor of its copyright holder, Aladdin Enterprises of Menlo Park, CA.
ansi2knr.c is NOT covered by the above copyright and conditions, but instead
by the usual distribution terms of the Free Software Foundation; principally,
that you must include source code if you redistribute it. (See the file
ansi2knr.c for full details.) However, since ansi2knr.c is not needed as part
of any program generated from the IJG code, this does not limit you more than
the foregoing paragraphs do.
The configuration script "configure" was produced with GNU Autoconf. It
is copyright by the Free Software Foundation but is freely distributable.
It appears that the arithmetic coding option of the JPEG spec is covered by
patents owned by IBM, AT&T, and Mitsubishi. Hence, arithmetic coding cannot
legally be used without obtaining one or more licenses. For this reason,
support for arithmetic coding has been removed from the free JPEG software.
(Since arithmetic coding provides only a marginal gain over the unpatented
Huffman mode, it is unlikely that very many implementations will support it.)
So far as we are aware, there are no patent restrictions on the remaining
code.
WARNING: Unisys has begun to enforce their patent on LZW compression against
GIF encoders and decoders. You will need a license from Unisys to use the
included rdgif.c or wrgif.c files in a commercial or shareware application.
At this time, Unisys is not enforcing their patent against freeware, so
distribution of this package remains legal. However, we intend to remove
GIF support from the IJG package as soon as a suitable replacement format
becomes reasonably popular.
We are required to state that
"The Graphics Interchange Format(c) is the Copyright property of
CompuServe Incorporated. GIF(sm) is a Service Mark property of
CompuServe Incorporated."
REFERENCES
==========
We highly recommend reading one or more of these references before trying to
understand the innards of the JPEG software.
The best short technical introduction to the JPEG compression algorithm is
Wallace, Gregory K. "The JPEG Still Picture Compression Standard",
Communications of the ACM, April 1991 (vol. 34 no. 4), pp. 30-44.
(Adjacent articles in that issue discuss MPEG motion picture compression,
applications of JPEG, and related topics.) If you don't have the CACM issue
handy, a PostScript file containing a revised version of Wallace's article
is available at ftp.uu.net, graphics/jpeg/wallace.ps.gz. The file (actually
a preprint for an article that appeared in IEEE Trans. Consumer Electronics)
omits the sample images that appeared in CACM, but it includes corrections
and some added material. Note: the Wallace article is copyright ACM and
IEEE, and it may not be used for commercial purposes.
A somewhat less technical, more leisurely introduction to JPEG can be found in
"The Data Compression Book" by Mark Nelson, published by M&T Books (Redwood
City, CA), 1991, ISBN 1-55851-216-0. This book provides good explanations and
example C code for a multitude of compression methods including JPEG. It is
an excellent source if you are comfortable reading C code but don't know much
about data compression in general. The book's JPEG sample code is far from
industrial-strength, but when you are ready to look at a full implementation,
you've got one here...
The best full description of JPEG is the textbook "JPEG Still Image Data
Compression Standard" by William B. Pennebaker and Joan L. Mitchell, published
by Van Nostrand Reinhold, 1993, ISBN 0-442-01272-1. Price US$59.95, 638 pp.
The book includes the complete text of the ISO JPEG standards (DIS 10918-1
and draft DIS 10918-2). This is by far the most complete exposition of JPEG
in existence, and we highly recommend it.
The JPEG standard itself is not available electronically; you must order a
paper copy through ISO or ITU. (Unless you feel a need to own a certified
official copy, we recommend buying the Pennebaker and Mitchell book instead;
it's much cheaper and includes a great deal of useful explanatory material.)
In the USA, copies of the standard may be ordered from ANSI Sales at (212)
642-4900, or from Global Engineering Documents at (800) 854-7179. (ANSI
doesn't take credit card orders, but Global does.) It's not cheap: as of
1992, ANSI was charging $95 for Part 1 and $47 for Part 2, plus 7%
shipping/handling. The standard is divided into two parts, Part 1 being the
actual specification, while Part 2 covers compliance testing methods. Part 1
is titled "Digital Compression and Coding of Continuous-tone Still Images,
Part 1: Requirements and guidelines" and has document numbers ISO/IEC IS
10918-1, ITU-T T.81. Part 2 is titled "Digital Compression and Coding of
Continuous-tone Still Images, Part 2: Compliance testing" and has document
numbers ISO/IEC IS 10918-2, ITU-T T.83.
Extensions to the original JPEG standard are defined in JPEG Part 3, a new ISO
document. Part 3 is undergoing ISO balloting and is expected to be approved
by the end of 1995; it will have document numbers ISO/IEC IS 10918-3, ITU-T
T.84. IJG currently does not support any Part 3 extensions.
The JPEG standard does not specify all details of an interchangeable file
format. For the omitted details we follow the "JFIF" conventions, revision
1.02. A copy of the JFIF spec is available from:
Literature Department
C-Cube Microsystems, Inc.
1778 McCarthy Blvd.
Milpitas, CA 95035
phone (408) 944-6300, fax (408) 944-6314
A PostScript version of this document is available at ftp.uu.net, file
graphics/jpeg/jfif.ps.gz. It can also be obtained by e-mail from the C-Cube
mail server, netlib@c3.pla.ca.us. Send the message "send jfif_ps from jpeg"
to the server to obtain the JFIF document; send the message "help" if you have
trouble.
The TIFF 6.0 file format specification can be obtained by FTP from sgi.com
(192.48.153.1), file graphics/tiff/TIFF6.ps.Z; or you can order a printed
copy from Aldus Corp. at (206) 628-6593. The JPEG incorporation scheme
found in the TIFF 6.0 spec of 3-June-92 has a number of serious problems.
IJG does not recommend use of the TIFF 6.0 design (TIFF Compression tag 6).
Instead, we recommend the JPEG design proposed by TIFF Technical Note #2
(Compression tag 7). Copies of this Note can be obtained from sgi.com or
from ftp.uu.net:/graphics/jpeg/. It is expected that the next revision of
the TIFF spec will replace the 6.0 JPEG design with the Note's design.
Although IJG's own code does not support TIFF/JPEG, the free libtiff library
uses our library to implement TIFF/JPEG per the Note. libtiff is available
from sgi.com:/graphics/tiff/.
ARCHIVE LOCATIONS
=================
The "official" archive site for this software is ftp.uu.net (Internet
address 192.48.96.9). The most recent released version can always be found
there in directory graphics/jpeg. This particular version will be archived
as graphics/jpeg/jpegsrc.v6a.tar.gz. If you are on the Internet, you
can retrieve files from ftp.uu.net by standard anonymous FTP. If you don't
have FTP access, UUNET's archives are also available via UUCP; contact
help@uunet.uu.net for information on retrieving files that way.
Numerous Internet sites maintain copies of the UUNET files. However, only
ftp.uu.net is guaranteed to have the latest official version.
You can also obtain this software in DOS-compatible "zip" archive format from
the SimTel archives (ftp.coast.net:/SimTel/msdos/graphics/), or on CompuServe
in the Graphics Support forum (GO CIS:GRAPHSUP), library 12 "JPEG Tools".
Again, these versions may sometimes lag behind the ftp.uu.net release.
The JPEG FAQ (Frequently Asked Questions) article is a useful source of
general information about JPEG. It is updated constantly and therefore is
not included in this distribution. The FAQ is posted every two weeks to
Usenet newsgroups comp.graphics.misc, news.answers, and other groups.
You can always obtain the latest version from the news.answers archive at
rtfm.mit.edu. By FTP, fetch /pub/usenet/news.answers/jpeg-faq/part1 and
.../part2. If you don't have FTP, send e-mail to mail-server@rtfm.mit.edu
with body
send usenet/news.answers/jpeg-faq/part1
send usenet/news.answers/jpeg-faq/part2
RELATED SOFTWARE
================
Numerous viewing and image manipulation programs now support JPEG. (Quite a
few of them use this library to do so.) The JPEG FAQ described above lists
some of the more popular free and shareware viewers, and tells where to
obtain them on Internet.
If you are on a Unix machine, we highly recommend Jef Poskanzer's free
PBMPLUS image software, which provides many useful operations on PPM-format
image files. In particular, it can convert PPM images to and from a wide
range of other formats. You can obtain this package by FTP from ftp.x.org
(contrib/pbmplus*.tar.Z) or ftp.ee.lbl.gov (pbmplus*.tar.Z). There is also
a newer update of this package called NETPBM, available from
wuarchive.wustl.edu under directory /graphics/graphics/packages/NetPBM/.
Unfortunately PBMPLUS/NETPBM is not nearly as portable as the IJG software
is; you are likely to have difficulty making it work on any non-Unix machine.
A different free JPEG implementation, written by the PVRG group at Stanford,
is available from havefun.stanford.edu in directory pub/jpeg. This program
is designed for research and experimentation rather than production use;
it is slower, harder to use, and less portable than the IJG code, but it
is easier to read and modify. Also, the PVRG code supports lossless JPEG,
which we do not.
FILE FORMAT WARS
================
Some JPEG programs produce files that are not compatible with our library.
The root of the problem is that the ISO JPEG committee failed to specify a
concrete file format. Some vendors "filled in the blanks" on their own,
creating proprietary formats that no one else could read. (For example, none
of the early commercial JPEG implementations for the Macintosh were able to
exchange compressed files.)
The file format we have adopted is called JFIF (see REFERENCES). This format
has been agreed to by a number of major commercial JPEG vendors, and it has
become the de facto standard. JFIF is a minimal or "low end" representation.
We recommend the use of TIFF/JPEG (TIFF revision 6.0 as modified by TIFF
Technical Note #2) for "high end" applications that need to record a lot of
additional data about an image. TIFF/JPEG is fairly new and not yet widely
supported, unfortunately.
The upcoming JPEG Part 3 standard defines a file format called SPIFF.
SPIFF is interoperable with JFIF, in the sense that most JFIF decoders should
be able to read the most common variant of SPIFF. SPIFF has some technical
advantages over JFIF, but its major claim to fame is simply that it is an
official standard rather than an informal one. At this point it is unclear
whether SPIFF will supersede JFIF or whether JFIF will remain the de-facto
standard. IJG intends to support SPIFF once the standard is frozen, but we
have not decided whether it should become our default output format or not.
(In any case, our decoder will remain capable of reading JFIF indefinitely.)
Various proprietary file formats incorporating JPEG compression also exist.
We have little or no sympathy for the existence of these formats. Indeed,
one of the original reasons for developing this free software was to help
force convergence on common, open format standards for JPEG files. Don't
use a proprietary file format!
TO DO
=====
In future versions, we are considering supporting some of the upcoming JPEG
Part 3 extensions --- principally, variable quantization and the SPIFF file
format.
Tuning the software for better behavior at low quality/high compression
settings is also of interest. The current method for scaling the
quantization tables is known not to be very good at low Q values.
As always, speeding things up is high on our priority list.
Please send bug reports, offers of help, etc. to jpeg-info@uunet.uu.net.
stegosuite/src/main/java/org/stegosuite/image/jpgtemp/james/Jpeg.java 0000664 0000000 0000000 00000007134 15260777315 0026270 0 ustar 00root root 0000000 0000000 // Copyright (C) 1998, James R. Weeks and BioElectroMech.
// Visit BioElectroMech at www.obrador.com. Email James@obrador.com.
// This software is based in part on the work of the Independent JPEG Group.
// See license.txt for details about the allowed used of this software.
// See IJGreadme.txt for details about the Independent JPEG Group's license.
package org.stegosuite.image.jpgtemp.james; // westfeld
import java.awt.*;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
public class Jpeg {
public static void main(final String[] args) {
Image image = null;
FileOutputStream dataOut = null;
File file, outFile;
JpegEncoder jpg;
String string;
int i, Quality = 80;
if (args.length < 2) {
StandardUsage();
}
if (!args[0].endsWith(".jpg") && !args[0].endsWith(".tif") && !args[0].endsWith(".gif")) {
StandardUsage();
}
if (args.length < 3) {
string = args[0].substring(0, args[0].lastIndexOf(".")) + ".jpg";
} else {
string = args[2];
if (string.endsWith(".tif") || string.endsWith(".gif")) {
string = string.substring(0, string.lastIndexOf("."));
}
if (!string.endsWith(".jpg")) {
string = string.concat(".jpg");
}
}
outFile = new File(string);
i = 1;
while (outFile.exists()) {
outFile = new File(string.substring(0, string.lastIndexOf(".")) + i++ + ".jpg");
if (i > 100) {
System.exit(0);
}
}
file = new File(args[0]);
if (file.exists()) {
try {
dataOut = new FileOutputStream(outFile);
} catch (final IOException ignored) {}
try {
Quality = Integer.parseInt(args[1]);
} catch (final NumberFormatException e) {
StandardUsage();
}
image = Toolkit.getDefaultToolkit().getImage(args[0]);
jpg = new JpegEncoder(image, Quality, dataOut);
jpg.Compress();
try {
dataOut.close();
} catch (final IOException ignored) {}
} else {
System.out.println("I couldn't find " + args[0] + ". Is it in another directory?");
}
System.exit(0);
}
public static void StandardUsage() {
System.out.println("JpegEncoder for Java(tm) Version 0.9");
System.out.println("");
System.out.println("Program usage: java Jpeg \"InputImage\".\"ext\" Quality [\"OutputFile\"[.jpg]]");
System.out.println("");
System.out.println("Where \"InputImage\" is the name of an existing image in the current directory.");
System.out.println(" (\"InputImage may specify a directory, too.) \"ext\" must be .tif, .gif,");
System.out.println(" or .jpg.");
System.out.println("Quality is an integer (0 to 100) that specifies how similar the compressed");
System.out.println(" image is to \"InputImage.\" 100 is almost exactly like \"InputImage\" and 0 is");
System.out.println(" most dissimilar. In most cases, 70 - 80 gives very good results.");
System.out.println("\"OutputFile\" is an optional argument. If \"OutputFile\" isn't specified, then");
System.out.println(" the input file name is adopted. This program will NOT write over an existing");
System.out.println(" file. If a directory is specified for the input image, then \"OutputFile\"");
System.out.println(" will be written in that directory. The extension \".jpg\" may automatically be");
System.out.println(" added.");
System.out.println("");
System.out.println("Copyright 1998 BioElectroMech and James R. Weeks. Portions copyright IJG and");
System.out.println(" Florian Raemy, LCAV. See license.txt for details.");
System.out.println("Visit BioElectroMech at www.obrador.com. Email James@obrador.com.");
System.exit(0);
}
}
stegosuite/src/main/java/org/stegosuite/image/jpgtemp/james/JpegEncoder.java 0000664 0000000 0000000 00000116346 15260777315 0027576 0 ustar 00root root 0000000 0000000 // Version 1.0a
// Copyright (C) 1998, James R. Weeks and BioElectroMech.
// Visit BioElectroMech at www.obrador.com. Email James@obrador.com.
// See license.txt for details about the allowed used of this software.
// This software is based in part on the work of the Independent JPEG Group.
// See IJGreadme.txt for details about the Independent JPEG Group's license.
// This encoder is inspired by the Java Jpeg encoder by Florian Raemy,
// studwww.eurecom.fr/~raemy.
// It borrows a great deal of code and structure from the Independent
// Jpeg Group's Jpeg 6a library, Copyright Thomas G. Lane.
// See license.txt for details.
// westfeld
// todo:
// switch for multi-volume embedding
// indeterministic embedding
// password switch
package org.stegosuite.image.jpgtemp.james;
import java.awt.*;
import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.logging.Logger;
import org.stegosuite.image.jpgtemp.net.f5.crypt.F5Random;
import org.stegosuite.image.jpgtemp.net.f5.crypt.Permutation;
/**
* JpegEncoder - The JPEG main program which performs a jpeg compression of an image.
*/
@SuppressWarnings({ "unused" })
public class JpegEncoder extends Frame {
private static final Logger LOG = Logger.getLogger(
JpegEncoder.class.getName()
);
Thread runner;
final BufferedOutputStream outStream;
Image image;
final JpegInfo JpegObj;
final Huffman Huf;
DCT dct;
final int imageHeight;
final int imageWidth;
final int Quality;
int code;
public static final int[] jpegNaturalOrder = {
0,
1,
8,
16,
9,
2,
3,
10,
17,
24,
32,
25,
18,
11,
4,
5,
12,
19,
26,
33,
40,
48,
41,
34,
27,
20,
13,
6,
7,
14,
21,
28,
35,
42,
49,
56,
57,
50,
43,
36,
29,
22,
15,
23,
30,
37,
44,
51,
58,
59,
52,
45,
38,
31,
39,
46,
53,
60,
61,
54,
47,
55,
62,
63,
};
// westfeld
InputStream embeddedData = null;
String password = null;
int n = 0;
public JpegEncoder(
final Image image,
final int quality,
final OutputStream out
) {
final MediaTracker tracker = new MediaTracker(this);
tracker.addImage(image, 0);
try {
tracker.waitForID(0);
} catch (final InterruptedException e) {
// Got to do something?
}
/*
* Quality of the image. 0 to 100 and from bad image quality, high compression to good image
* quality low compression
*/
this.Quality = quality;
/*
* Getting picture information It takes the Width, Height and RGB scans of the image.
*/
this.JpegObj = new JpegInfo(image);
this.imageHeight = this.JpegObj.imageHeight;
this.imageWidth = this.JpegObj.imageWidth;
this.outStream = new BufferedOutputStream(out);
this.dct = new DCT(this.Quality);
this.Huf = new Huffman(this.imageWidth, this.imageHeight);
}
public void Compress() {
WriteHeaders(this.outStream);
WriteCompressedData(this.outStream);
WriteEOI(this.outStream);
try {
this.outStream.flush();
} catch (final IOException e) {
System.out.println("IO Error: " + e.getMessage());
}
}
public void Compress(
final InputStream embeddedData,
final String password
) {
this.embeddedData = embeddedData;
this.password = password;
Compress();
}
public int getQuality() {
return this.Quality;
}
public void setQuality(final int quality) {
this.dct = new DCT(quality);
}
void WriteArray(final byte[] data, final BufferedOutputStream out) {
final int i;
int length;
try {
length = ((data[2] & 0xFF) << 8) + (data[3] & 0xFF) + 2;
out.write(data, 0, length);
} catch (final IOException e) {
System.out.println("IO Error: " + e.getMessage());
}
}
public void WriteCompressedData(final BufferedOutputStream outStream) {
final int offset;
int i, j, r, c, a, b;
final int temp = 0;
int comp, xpos, ypos, xblockoffset, yblockoffset;
float[][] inputArray;
final float[][] dctArray1 = new float[8][8];
double[][] dctArray2 = new double[8][8];
int[] dctArray3 = new int[8 * 8];
/*
* This method controls the compression of the image. Starting at the upper left of the
* image, it compresses 8x8 blocks of data until the entire image has been compressed.
*/
final int[] lastDCvalue = new int[this.JpegObj.NumberOfComponents];
final int[] zeroArray = new int[64]; // initialized to hold all zeros
int Width = 0,
Height = 0;
final int nothing = 0,
not;
int MinBlockWidth, MinBlockHeight;
// This initial setting of MinBlockWidth and MinBlockHeight is done to
// ensure they start with values larger than will actually be the case.
MinBlockWidth =
this.imageWidth % 8 != 0
? (int) (Math.floor(this.imageWidth / 8.0) + 1) * 8
: this.imageWidth;
MinBlockHeight =
this.imageHeight % 8 != 0
? (int) (Math.floor(this.imageHeight / 8.0) + 1) * 8
: this.imageHeight;
for (comp = 0; comp < this.JpegObj.NumberOfComponents; comp++) {
MinBlockWidth = Math.min(
MinBlockWidth,
this.JpegObj.BlockWidth[comp]
);
MinBlockHeight = Math.min(
MinBlockHeight,
this.JpegObj.BlockHeight[comp]
);
}
xpos = 0;
// westfeld
// Before we enter these loops, we initialise the
// coeff for steganography here:
int shuffledIndex = 0;
int coeffCount = 0;
for (r = 0; r < MinBlockHeight; r++) {
for (c = 0; c < MinBlockWidth; c++) {
for (comp = 0; comp < this.JpegObj.NumberOfComponents; comp++) {
for (i = 0; i < this.JpegObj.VsampFactor[comp]; i++) {
for (j = 0; j < this.JpegObj.HsampFactor[comp]; j++) {
coeffCount += 64;
}
}
}
}
}
final int[] coeff = new int[coeffCount];
//LOG.fine("DCT/quantisation starts");
LOG.fine(() -> this.imageWidth + " x " + this.imageHeight);
for (r = 0; r < MinBlockHeight; r++) {
for (c = 0; c < MinBlockWidth; c++) {
xpos = c * 8;
ypos = r * 8;
for (comp = 0; comp < this.JpegObj.NumberOfComponents; comp++) {
Width = this.JpegObj.BlockWidth[comp];
Height = this.JpegObj.BlockHeight[comp];
inputArray = (float[][]) this.JpegObj.Components[comp];
for (i = 0; i < this.JpegObj.VsampFactor[comp]; i++) {
for (j = 0; j < this.JpegObj.HsampFactor[comp]; j++) {
xblockoffset = j * 8;
yblockoffset = i * 8;
for (a = 0; a < 8; a++) {
for (b = 0; b < 8; b++) {
// I believe this is where the dirty line at
// the bottom of the image is
// coming from. I need to do a check here to
// make sure I'm not reading past
// image data.
// This seems to not be a big issue right
// now. (04/04/98)
// westfeld - dirty line fixed, Jun 6 2000
int ia =
ypos * this.JpegObj.VsampFactor[comp] +
yblockoffset +
a;
int ib =
xpos * this.JpegObj.HsampFactor[comp] +
xblockoffset +
b;
if (
(this.imageHeight / 2) *
this.JpegObj.VsampFactor[comp] <=
ia
) {
ia =
(this.imageHeight / 2) *
this.JpegObj.VsampFactor[comp] -
1;
}
if (
(this.imageWidth / 2) *
this.JpegObj.HsampFactor[comp] <=
ib
) {
ib =
(this.imageWidth / 2) *
this.JpegObj.HsampFactor[comp] -
1;
}
// dctArray1[a][b] = inputArray[ypos +
// yblockoffset + a][xpos + xblockoffset +
// b];
dctArray1[a][b] = inputArray[ia][ib];
}
}
// The following code commented out because on some
// images this technique
// results in poor right and bottom borders.
// if ((!JpegObj.lastColumnIsDummy[comp] || c <
// Width - 1) && (!JpegObj.lastRowIsDummy[comp] || r
// < Height - 1)) {
dctArray2 = this.dct.forwardDCT(dctArray1);
dctArray3 = this.dct.quantizeBlock(
dctArray2,
this.JpegObj.QtableNumber[comp]
);
// }
// else {
// zeroArray[0] = dctArray3[0];
// zeroArray[0] = lastDCvalue[comp];
// dctArray3 = zeroArray;
// }
// westfeld
// For steganography, all dct
// coefficients are collected in
// coeff[] first. We do not encode
// any Huffman Blocks here (we'll do
// this later).
System.arraycopy(
dctArray3,
0,
coeff,
shuffledIndex,
64
);
shuffledIndex += 64;
}
}
}
}
}
// LOG.fine("got " + coeffCount + " DCT AC/DC coefficients");
int _changed = 0;
int _embedded = 0;
int _examined = 0;
int _expected = 0;
int _one = 0;
int _large = 0;
int _thrown = 0;
int _zero = 0;
for (i = 0; i < coeffCount; i++) {
if (i % 64 == 0) {
continue;
}
if (coeff[i] == 1) {
_one++;
}
if (coeff[i] == -1) {
_one++;
}
if (coeff[i] == 0) {
_zero++;
}
}
_large = coeffCount - _zero - _one - coeffCount / 64;
_expected = _large + (int) (0.49 * _one);
//
// System.out.println("zero="+_zero);
// LOG.fine("one=" + _one);
// LOG.fine("large=" + _large);
//
LOG.fine("expected capacity: " + _expected + " bits");
// System.out.println("expected capacity with");
for (i = 1; i < 8; i++) {
int usable, changed, n;
n = (1 << i) - 1;
usable = (_expected * i) / n - (((_expected * i) / n) % n);
changed = coeffCount - _zero - coeffCount / 64;
changed = (changed * i) / n - (((changed * i) / n) % n);
changed = (n * changed) / (n + 1) / i;
//
changed = _large - (_large % (n + 1));
changed = (changed + _one + _one / 2 - _one / (n + 1)) / (n + 1);
usable /= 8;
if (usable == 0) {
break;
}
// if (i == 1) {
// LOG.debug("default");
// } else {
// LOG.debug("(1, " + n + ", " + i + ")");
// }
// LOG.debug(" code: " + usable + " bytes (efficiency: " + usable * 8 / changed + "."
// + usable * 80 / changed % 10 + " bits per change)");
}
// westfeld
if (this.embeddedData != null) {
// Now we embed the secret data in the permutated sequence.
// LOG.debug("Permutation starts");
// final F5Random random = new F5Random(this.password.getBytes());
final F5Random random = new F5Random(this.password);
final Permutation permutation = new Permutation(coeffCount, random);
int nextBitToEmbed = 0;
int byteToEmbed = 0;
int availableBitsToEmbed = 0;
// We start with the length information. Well,
// the length information it is more than one
// byte, so this first "byte" is 32 bits long.
try {
byteToEmbed = this.embeddedData.available();
} catch (final Exception e) {
e.printStackTrace();
}
// LOG.debug("Embedding of " + (byteToEmbed * 8 + 32) + " bits (" + byteToEmbed + "+4 bytes) ");
// We use the most significant byte for the 1 of n
// code, and reserve one extra bit for future use.
if (byteToEmbed > 0x007fffff) {
byteToEmbed = 0x007fffff;
}
// We calculate n now
for (i = 1; i < 8; i++) {
int usable;
final int changed;
this.n = (1 << i) - 1;
usable =
(_expected * i) / this.n -
(((_expected * i) / this.n) % this.n);
usable /= 8;
if (usable == 0) {
break;
}
if (usable < byteToEmbed + 4) {
break;
}
}
final int k = i - 1;
this.n = (1 << k) - 1;
switch (this.n) {
case 0:
System.out.println("using default code, file will not fit");
this.n++;
break;
case 1:
// LOG.debug("using default code");
break;
default:
// LOG.debug("using (1, " + this.n + ", " + k + ") code");
}
byteToEmbed |= k << 24; // store k in the status word
// Since shuffling cannot hide the distribution, the
// distribution of all bits to embed is unified by
// adding a pseudo random bit-string. We continue the random
// we used for Permutation, initially seeked with password.
byteToEmbed ^= random.getNextByte();
byteToEmbed ^= random.getNextByte() << 8;
byteToEmbed ^= random.getNextByte() << 16;
byteToEmbed ^= random.getNextByte() << 24;
nextBitToEmbed = byteToEmbed & 1;
byteToEmbed >>= 1;
availableBitsToEmbed = 31;
_embedded++;
if (this.n > 1) {
// use 1 of n code
int kBitsToEmbed;
int extractedBit;
final int[] codeWord = new int[this.n];
int hash;
int startOfN = 0;
int endOfN = 0;
boolean isLastByte = false;
// embed status word first
for (i = 0; i < coeffCount; i++) {
shuffledIndex = permutation.getShuffled(i);
if (shuffledIndex % 64 == 0) {
continue; // skip DC coefficients
}
if (coeff[shuffledIndex] == 0) {
continue; // skip zeroes
}
if (coeff[shuffledIndex] > 0) {
if ((coeff[shuffledIndex] & 1) != nextBitToEmbed) {
coeff[shuffledIndex]--; // decrease absolute value
_changed++;
}
} else {
if ((coeff[shuffledIndex] & 1) == nextBitToEmbed) {
coeff[shuffledIndex]++; // decrease absolute value
_changed++;
}
}
if (coeff[shuffledIndex] != 0) {
// The coefficient is still nonzero. We
// successfully embedded "nextBitToEmbed".
// We will read a new bit to embed now.
if (availableBitsToEmbed == 0) {
break; // statusword embedded.
}
nextBitToEmbed = byteToEmbed & 1;
byteToEmbed >>= 1;
availableBitsToEmbed--;
_embedded++;
} else {
_thrown++;
}
}
startOfN = i + 1;
// now embed the data using 1 of n code
embeddingLoop: do {
kBitsToEmbed = 0;
// get k bits to embed
for (i = 0; i < k; i++) {
if (availableBitsToEmbed == 0) {
// If the byte of embedded text is
// empty, we will get a new one.
try {
if (this.embeddedData.available() == 0) {
isLastByte = true;
break;
}
byteToEmbed = this.embeddedData.read();
byteToEmbed ^= random.getNextByte();
} catch (final Exception e) {
e.printStackTrace();
break;
}
availableBitsToEmbed = 8;
}
nextBitToEmbed = byteToEmbed & 1;
byteToEmbed >>= 1;
availableBitsToEmbed--;
kBitsToEmbed |= nextBitToEmbed << i;
_embedded++;
}
// embed k bits
do {
j = startOfN;
// fill codeWord[] with the indices of the
// next n non-zero coefficients in coeff[]
for (i = 0; i < this.n; j++) {
if (j >= coeffCount) {
// in rare cases the estimated capacity is too
// small
LOG.info("Capacity exhausted.");
break embeddingLoop;
}
shuffledIndex = permutation.getShuffled(j);
if (shuffledIndex % 64 == 0) {
continue; // skip DC coefficients
}
if (coeff[shuffledIndex] == 0) {
continue; // skip zeroes
}
codeWord[i++] = shuffledIndex;
}
endOfN = j;
hash = 0;
for (i = 0; i < this.n; i++) {
if (coeff[codeWord[i]] > 0) {
extractedBit = coeff[codeWord[i]] & 1;
} else {
extractedBit = 1 - (coeff[codeWord[i]] & 1);
}
if (extractedBit == 1) {
hash ^= i + 1;
}
}
i = hash ^ kBitsToEmbed;
if (i == 0) {
break; // embedded without change
}
i--;
if (coeff[codeWord[i]] > 0) {
coeff[codeWord[i]]--;
} else {
coeff[codeWord[i]]++;
}
_changed++;
if (coeff[codeWord[i]] == 0) {
_thrown++;
}
} while (coeff[codeWord[i]] == 0);
startOfN = endOfN;
} while (!isLastByte);
} else {
// default code
// The main embedding loop follows. It works on the
// shuffled stream of coefficients.
for (i = 0; i < coeffCount; i++) {
shuffledIndex = permutation.getShuffled(i);
if (shuffledIndex % 64 == 0) {
continue; // skip DC coefficients
}
if (coeff[shuffledIndex] == 0) {
continue; // skip zeroes
}
_examined++;
if (coeff[shuffledIndex] > 0) {
if ((coeff[shuffledIndex] & 1) != nextBitToEmbed) {
coeff[shuffledIndex]--; // decrease absolute value
_changed++;
}
} else {
if ((coeff[shuffledIndex] & 1) == nextBitToEmbed) {
coeff[shuffledIndex]++; // decrease absolute value
_changed++;
}
}
if (coeff[shuffledIndex] != 0) {
// The coefficient is still nonzero. We
// successfully embedded "nextBitToEmbed".
// We will read a new bit to embed now.
if (availableBitsToEmbed == 0) {
// If the byte of embedded text is
// empty, we will get a new one.
try {
if (this.embeddedData.available() == 0) {
break;
}
byteToEmbed = this.embeddedData.read();
byteToEmbed ^= random.getNextByte();
} catch (final Exception e) {
e.printStackTrace();
break;
}
availableBitsToEmbed = 8;
}
nextBitToEmbed = byteToEmbed & 1;
byteToEmbed >>= 1;
availableBitsToEmbed--;
_embedded++;
} else {
_thrown++;
}
}
}
// if (_examined > 0) {
// LOG.debug(_examined + " coefficients examined");
// }
// LOG.debug(_changed + " coefficients changed (efficiency: " + _embedded / _changed + "."
// + _embedded * 10 / _changed % 10 + " bits per change)");
// LOG.debug(_thrown + " coefficients thrown (zeroed)");
// LOG.debug(_embedded + " bits (" + _embedded / 8 + " bytes) embedded");
}
// LOG.debug("Starting Huffman Encoding.");
// Do the Huffman Encoding now.
shuffledIndex = 0;
for (r = 0; r < MinBlockHeight; r++) {
for (c = 0; c < MinBlockWidth; c++) {
for (comp = 0; comp < this.JpegObj.NumberOfComponents; comp++) {
for (i = 0; i < this.JpegObj.VsampFactor[comp]; i++) {
for (j = 0; j < this.JpegObj.HsampFactor[comp]; j++) {
System.arraycopy(
coeff,
shuffledIndex,
dctArray3,
0,
64
);
this.Huf.HuffmanBlockEncoder(
outStream,
dctArray3,
lastDCvalue[comp],
this.JpegObj.DCtableNumber[comp],
this.JpegObj.ACtableNumber[comp]
);
lastDCvalue[comp] = dctArray3[0];
shuffledIndex += 64;
}
}
}
}
}
this.Huf.flushBuffer(outStream);
}
public void WriteEOI(final BufferedOutputStream out) {
final byte[] EOI = { (byte) 0xFF, (byte) 0xD9 };
WriteMarker(EOI, out);
}
public void WriteHeaders(final BufferedOutputStream out) {
int i, j, index, offset, length;
int[] tempArray;
// the SOI marker
final byte[] SOI = { (byte) 0xFF, (byte) 0xD8 };
WriteMarker(SOI, out);
// The order of the following headers is quiet inconsequential.
// the JFIF header
final byte[] JFIF = new byte[18];
JFIF[0] = (byte) 0xff; // app0 marker
JFIF[1] = (byte) 0xe0;
JFIF[2] = (byte) 0x00; // length
JFIF[3] = (byte) 0x10;
JFIF[4] = (byte) 0x4a; // "JFIF"
JFIF[5] = (byte) 0x46;
JFIF[6] = (byte) 0x49;
JFIF[7] = (byte) 0x46;
JFIF[8] = (byte) 0x00;
JFIF[9] = (byte) 0x01; // 1.01
JFIF[10] = (byte) 0x01;
JFIF[11] = (byte) 0x00;
JFIF[12] = (byte) 0x00;
JFIF[13] = (byte) 0x01;
JFIF[14] = (byte) 0x00;
JFIF[15] = (byte) 0x01;
JFIF[16] = (byte) 0x00;
JFIF[17] = (byte) 0x00;
WriteArray(JFIF, out);
// The DQT header
// 0 is the luminance index and 1 is the chrominance index
final byte[] DQT = new byte[134];
DQT[0] = (byte) 0xFF;
DQT[1] = (byte) 0xDB;
DQT[2] = (byte) 0x00;
DQT[3] = (byte) 0x84;
offset = 4;
for (i = 0; i < 2; i++) {
DQT[offset++] = (byte) ((0) + i);
tempArray = (int[]) this.dct.quantum[i];
for (j = 0; j < 64; j++) {
DQT[offset++] = (byte) tempArray[jpegNaturalOrder[j]];
}
}
WriteArray(DQT, out);
// Start of Frame Header
final byte[] SOF = new byte[19];
SOF[0] = (byte) 0xFF;
SOF[1] = (byte) 0xC0;
SOF[2] = (byte) 0x00;
SOF[3] = (byte) 17;
SOF[4] = (byte) this.JpegObj.Precision;
SOF[5] = (byte) ((this.JpegObj.imageHeight >> 8) & 0xFF);
SOF[6] = (byte) (this.JpegObj.imageHeight & 0xFF);
SOF[7] = (byte) ((this.JpegObj.imageWidth >> 8) & 0xFF);
SOF[8] = (byte) (this.JpegObj.imageWidth & 0xFF);
SOF[9] = (byte) this.JpegObj.NumberOfComponents;
index = 10;
for (i = 0; i < SOF[9]; i++) {
SOF[index++] = (byte) this.JpegObj.CompID[i];
SOF[index++] = (byte) ((this.JpegObj.HsampFactor[i] << 4) +
this.JpegObj.VsampFactor[i]);
SOF[index++] = (byte) this.JpegObj.QtableNumber[i];
}
WriteArray(SOF, out);
// The DHT Header
byte[] DHT1, DHT2, DHT3, DHT4;
int bytes, temp, oldindex, intermediateindex;
length = 2;
index = 4;
oldindex = 4;
DHT1 = new byte[17];
DHT4 = new byte[4];
DHT4[0] = (byte) 0xFF;
DHT4[1] = (byte) 0xC4;
for (i = 0; i < 4; i++) {
bytes = 0;
DHT1[index++ - oldindex] = (byte) this.Huf.bits.elementAt(i)[0];
for (j = 1; j < 17; j++) {
temp = this.Huf.bits.elementAt(i)[j];
DHT1[index++ - oldindex] = (byte) temp;
bytes += temp;
}
intermediateindex = index;
DHT2 = new byte[bytes];
for (j = 0; j < bytes; j++) {
DHT2[index++ - intermediateindex] =
(byte) this.Huf.val.elementAt(i)[j];
}
DHT3 = new byte[index];
java.lang.System.arraycopy(DHT4, 0, DHT3, 0, oldindex);
java.lang.System.arraycopy(DHT1, 0, DHT3, oldindex, 17);
java.lang.System.arraycopy(DHT2, 0, DHT3, oldindex + 17, bytes);
DHT4 = DHT3;
oldindex = index;
}
DHT4[2] = (byte) (((index - 2) >> 8) & 0xFF);
DHT4[3] = (byte) ((index - 2) & 0xFF);
WriteArray(DHT4, out);
// Start of Scan Header
final byte[] SOS = new byte[14];
SOS[0] = (byte) 0xFF;
SOS[1] = (byte) 0xDA;
SOS[2] = (byte) 0x00;
SOS[3] = (byte) 12;
SOS[4] = (byte) this.JpegObj.NumberOfComponents;
index = 5;
for (i = 0; i < SOS[4]; i++) {
SOS[index++] = (byte) this.JpegObj.CompID[i];
SOS[index++] = (byte) ((this.JpegObj.DCtableNumber[i] << 4) +
this.JpegObj.ACtableNumber[i]);
}
SOS[index++] = (byte) this.JpegObj.Ss;
SOS[index++] = (byte) this.JpegObj.Se;
SOS[index++] = (byte) ((this.JpegObj.Ah << 4) + this.JpegObj.Al);
WriteArray(SOS, out);
}
void WriteMarker(final byte[] data, final BufferedOutputStream out) {
try {
out.write(data, 0, 2);
} catch (final IOException e) {
LOG.info("IO Error: " + e.getMessage());
}
}
/**
* returns capacity in bytes
*/
public int getCapacity() {
final int offset;
int i, j, r, c, a, b;
final int temp = 0;
int comp, xpos, ypos, xblockoffset, yblockoffset;
float[][] inputArray;
final float[][] dctArray1 = new float[8][8];
double[][] dctArray2 = new double[8][8];
int[] dctArray3 = new int[8 * 8];
/*
* This method controls the compression of the image. Starting at the upper left of the
* image, it compresses 8x8 blocks of data until the entire image has been compressed.
*/
final int[] lastDCvalue = new int[this.JpegObj.NumberOfComponents];
final int[] zeroArray = new int[64]; // initialized to hold all zeros
int Width = 0,
Height = 0;
final int nothing = 0,
not;
int MinBlockWidth, MinBlockHeight;
// This initial setting of MinBlockWidth and MinBlockHeight is done to
// ensure they start with values larger than will actually be the case.
MinBlockWidth =
this.imageWidth % 8 != 0
? (int) (Math.floor(this.imageWidth / 8.0) + 1) * 8
: this.imageWidth;
MinBlockHeight =
this.imageHeight % 8 != 0
? (int) (Math.floor(this.imageHeight / 8.0) + 1) * 8
: this.imageHeight;
for (comp = 0; comp < this.JpegObj.NumberOfComponents; comp++) {
MinBlockWidth = Math.min(
MinBlockWidth,
this.JpegObj.BlockWidth[comp]
);
MinBlockHeight = Math.min(
MinBlockHeight,
this.JpegObj.BlockHeight[comp]
);
}
xpos = 0;
// westfeld
// Before we enter these loops, we initialise the
// coeff for steganography here:
int shuffledIndex = 0;
int coeffCount = 0;
for (r = 0; r < MinBlockHeight; r++) {
for (c = 0; c < MinBlockWidth; c++) {
for (comp = 0; comp < this.JpegObj.NumberOfComponents; comp++) {
for (i = 0; i < this.JpegObj.VsampFactor[comp]; i++) {
for (j = 0; j < this.JpegObj.HsampFactor[comp]; j++) {
coeffCount += 64;
}
}
}
}
}
final int[] coeff = new int[coeffCount];
// LOG.debug("DCT/quantisation starts");
// LOG.debug(this.imageWidth + " x " + this.imageHeight);
for (r = 0; r < MinBlockHeight; r++) {
for (c = 0; c < MinBlockWidth; c++) {
xpos = c * 8;
ypos = r * 8;
for (comp = 0; comp < this.JpegObj.NumberOfComponents; comp++) {
Width = this.JpegObj.BlockWidth[comp];
Height = this.JpegObj.BlockHeight[comp];
inputArray = (float[][]) this.JpegObj.Components[comp];
for (i = 0; i < this.JpegObj.VsampFactor[comp]; i++) {
for (j = 0; j < this.JpegObj.HsampFactor[comp]; j++) {
xblockoffset = j * 8;
yblockoffset = i * 8;
for (a = 0; a < 8; a++) {
for (b = 0; b < 8; b++) {
// I believe this is where the dirty line at
// the bottom of the image is
// coming from. I need to do a check here to
// make sure I'm not reading past
// image data.
// This seems to not be a big issue right
// now. (04/04/98)
// westfeld - dirty line fixed, Jun 6 2000
int ia =
ypos * this.JpegObj.VsampFactor[comp] +
yblockoffset +
a;
int ib =
xpos * this.JpegObj.HsampFactor[comp] +
xblockoffset +
b;
if (
(this.imageHeight / 2) *
this.JpegObj.VsampFactor[comp] <=
ia
) {
ia =
(this.imageHeight / 2) *
this.JpegObj.VsampFactor[comp] -
1;
}
if (
(this.imageWidth / 2) *
this.JpegObj.HsampFactor[comp] <=
ib
) {
ib =
(this.imageWidth / 2) *
this.JpegObj.HsampFactor[comp] -
1;
}
// dctArray1[a][b] = inputArray[ypos +
// yblockoffset + a][xpos + xblockoffset +
// b];
dctArray1[a][b] = inputArray[ia][ib];
}
}
// The following code commented out because on some
// images this technique
// results in poor right and bottom borders.
// if ((!JpegObj.lastColumnIsDummy[comp] || c <
// Width - 1) && (!JpegObj.lastRowIsDummy[comp] || r
// < Height - 1)) {
dctArray2 = this.dct.forwardDCT(dctArray1);
dctArray3 = this.dct.quantizeBlock(
dctArray2,
this.JpegObj.QtableNumber[comp]
);
// }
// else {
// zeroArray[0] = dctArray3[0];
// zeroArray[0] = lastDCvalue[comp];
// dctArray3 = zeroArray;
// }
// westfeld
// For steganography, all dct
// coefficients are collected in
// coeff[] first. We do not encode
// any Huffman Blocks here (we'll do
// this later).
System.arraycopy(
dctArray3,
0,
coeff,
shuffledIndex,
64
);
shuffledIndex += 64;
}
}
}
}
}
// LOG.debug("got " + coeffCount + " DCT AC/DC coefficients");
int _changed = 0;
int _embedded = 0;
int _examined = 0;
int _expected = 0;
int _one = 0;
int _large = 0;
int _thrown = 0;
int _zero = 0;
for (i = 0; i < coeffCount; i++) {
if (i % 64 == 0) {
continue;
}
if (coeff[i] == 1) {
_one++;
}
if (coeff[i] == -1) {
_one++;
}
if (coeff[i] == 0) {
_zero++;
}
}
_large = coeffCount - _zero - _one - coeffCount / 64;
_expected = _large + (int) (0.49 * _one);
//
// System.out.println("zero="+_zero);
// LOG.debug("one=" + _one);
// LOG.debug("large=" + _large);
//
// LOG.debug("expected capacity: " + _expected + " bits");
return (_expected / 8);
}
}
stegosuite/src/main/java/org/stegosuite/image/jpgtemp/james/JpegInfo.java 0000664 0000000 0000000 00000015646 15260777315 0027113 0 ustar 00root root 0000000 0000000 // Version 1.0a
// Copyright (C) 1998, James R. Weeks and BioElectroMech.
// Visit BioElectroMech at www.obrador.com. Email James@obrador.com.
// See license.txt for details about the allowed used of this software.
// This software is based in part on the work of the Independent JPEG Group.
// See IJGreadme.txt for details about the Independent JPEG Group's license.
// This encoder is inspired by the Java Jpeg encoder by Florian Raemy,
// studwww.eurecom.fr/~raemy.
// It borrows a great deal of code and structure from the Independent
// Jpeg Group's Jpeg 6a library, Copyright Thomas G. Lane.
// See license.txt for details.
package org.stegosuite.image.jpgtemp.james;
import java.awt.*;
import java.awt.image.PixelGrabber;
/**
* JpegInfo - Given an image, sets default information about it and divides it into its constituant
* components, downsizing those that need to be.
*/
class JpegInfo {
public final Image imageobj;
public final int imageHeight;
public final int imageWidth;
public final int[] BlockWidth;
public final int[] BlockHeight;
// the following are set as the default
public final int Precision = 8;
public final int NumberOfComponents = 3;
public final Object[] Components;
public final int[] CompID = { 1, 2, 3 };
// public int[] HsampFactor = {1, 1, 1};
// public int[] VsampFactor = {1, 1, 1};
public final int[] HsampFactor = { 2, 1, 1 };
public final int[] VsampFactor = { 2, 1, 1 };
public final int[] QtableNumber = { 0, 1, 1 };
public final int[] DCtableNumber = { 0, 1, 1 };
public final int[] ACtableNumber = { 0, 1, 1 };
public final boolean[] lastColumnIsDummy = { false, false, false };
public final boolean[] lastRowIsDummy = { false, false, false };
public final int Ss = 0;
public final int Se = 63;
public final int Ah = 0;
public final int Al = 0;
public final int[] compWidth;
public final int[] compHeight;
public int MaxHsampFactor;
public int MaxVsampFactor;
public JpegInfo(final Image image) {
this.Components = new Object[this.NumberOfComponents];
this.compWidth = new int[this.NumberOfComponents];
this.compHeight = new int[this.NumberOfComponents];
this.BlockWidth = new int[this.NumberOfComponents];
this.BlockHeight = new int[this.NumberOfComponents];
this.imageobj = image;
this.imageWidth = image.getWidth(null);
this.imageHeight = image.getHeight(null);
getYCCArray();
}
float[][] DownSample(final float[][] C, final int comp) {
int inrow, incol;
int outrow, outcol;
float[][] output;
float temp;
int bias;
inrow = 0;
incol = 0;
output = new float[this.compHeight[comp]][this.compWidth[comp]];
for (outrow = 0; outrow < this.compHeight[comp]; outrow++) {
bias = 1;
for (outcol = 0; outcol < this.compWidth[comp]; outcol++) {
// System.out.println("outcol="+outcol);
temp = C[inrow][incol++]; // 00
temp += C[inrow++][incol--]; // 01
temp += C[inrow][incol++]; // 10
temp += C[inrow--][incol++] + bias; // 11 -> 02
output[outrow][outcol] = temp / (float) 4.0;
bias ^= 3;
}
inrow += 2;
incol = 0;
}
return output;
}
/*
* This method creates and fills three arrays, Y, Cb, and Cr using the input image.
*/
private void getYCCArray() {
final int[] values = new int[this.imageWidth * this.imageHeight];
int r, g, b, y, x;
// In order to minimize the chance that grabPixels will throw an
// exception
// it may be necessary to grab some pixels every few scanlines and
// process
// those before going for more. The time expense may be prohibitive.
// However, for a situation where memory overhead is a concern, this may
// be
// the only choice.
final PixelGrabber grabber = new PixelGrabber(this.imageobj.getSource(), 0, 0, this.imageWidth,
this.imageHeight, values, 0, this.imageWidth);
this.MaxHsampFactor = 1;
this.MaxVsampFactor = 1;
for (y = 0; y < this.NumberOfComponents; y++) {
this.MaxHsampFactor = Math.max(this.MaxHsampFactor, this.HsampFactor[y]);
this.MaxVsampFactor = Math.max(this.MaxVsampFactor, this.VsampFactor[y]);
}
for (y = 0; y < this.NumberOfComponents; y++) {
this.compWidth[y] = (this.imageWidth % 8 != 0 ? (int) Math.ceil(this.imageWidth / 8.0) * 8
: this.imageWidth) / this.MaxHsampFactor * this.HsampFactor[y];
if (this.compWidth[y] != this.imageWidth / this.MaxHsampFactor * this.HsampFactor[y]) {
this.lastColumnIsDummy[y] = true;
}
// results in a multiple of 8 for compWidth
// this will make the rest of the program fail for the unlikely
// event that someone tries to compress an 16 x 16 pixel image
// which would of course be worse than pointless
this.BlockWidth[y] = (int) Math.ceil(this.compWidth[y] / 8.0);
this.compHeight[y] = (this.imageHeight % 8 != 0 ? (int) Math.ceil(this.imageHeight / 8.0) * 8
: this.imageHeight) / this.MaxVsampFactor * this.VsampFactor[y];
if (this.compHeight[y] != this.imageHeight / this.MaxVsampFactor * this.VsampFactor[y]) {
this.lastRowIsDummy[y] = true;
}
this.BlockHeight[y] = (int) Math.ceil(this.compHeight[y] / 8.0);
}
try {
if (!grabber.grabPixels()) {
try {
throw new AWTException("Grabber returned false: " + grabber.getStatus());
} catch (final Exception ignored) {}
}
} catch (final InterruptedException ignored) {}
final float[][] Y = new float[this.compHeight[0]][this.compWidth[0]];
final float[][] Cr1 = new float[this.compHeight[0]][this.compWidth[0]];
final float[][] Cb1 = new float[this.compHeight[0]][this.compWidth[0]];
float[][] Cb2 = new float[this.compHeight[1]][this.compWidth[1]];
float[][] Cr2 = new float[this.compHeight[2]][this.compWidth[2]];
int index = 0;
for (y = 0; y < this.imageHeight; ++y) {
for (x = 0; x < this.imageWidth; ++x) {
r = values[index] >> 16 & 0xff;
g = values[index] >> 8 & 0xff;
b = values[index] & 0xff;
// The following three lines are a more correct color conversion
// but
// the current conversion technique is sufficient and results in
// a higher
// compression rate.
// Y[y][x] = 16 + (float)(0.8588*(0.299 * (float)r + 0.587 *
// (float)g + 0.114 * (float)b ));
// Cb1[y][x] = 128 + (float)(0.8784*(-0.16874 * (float)r -
// 0.33126 * (float)g + 0.5 * (float)b));
// Cr1[y][x] = 128 + (float)(0.8784*(0.5 * (float)r - 0.41869 *
// (float)g - 0.08131 * (float)b));
Y[y][x] = (float) (0.299 * r + 0.587 * g + 0.114 * b);
Cb1[y][x] = 128 + (float) (-0.16874 * r - 0.33126 * g + 0.5 * b);
Cr1[y][x] = 128 + (float) (0.5 * r - 0.41869 * g - 0.08131 * b);
index++;
}
}
// Need a way to set the H and V sample factors before allowing
// downsampling.
// For now (04/04/98) downsampling must be hard coded.
// Until a better downsampler is implemented, this will not be done.
// Downsampling is currently supported. The downsampling method here
// is a simple box filter.
this.Components[0] = Y;
Cb2 = DownSample(Cb1, 1);
this.Components[1] = Cb2;
Cr2 = DownSample(Cr1, 2);
this.Components[2] = Cr2;
}
}
stegosuite/src/main/java/org/stegosuite/image/jpgtemp/james/license.txt 0000664 0000000 0000000 00000002672 15260777315 0026725 0 ustar 00root root 0000000 0000000 The JpegEncoder and its associated classes are Copyright (c)
1998, James R. Weeks and BioElectroMech. This software is
based in part on the work of the Independent JPEG Group.
Redistribution and use in source and binary forms, with or
without modification, are permitted provided that the following
conditions are met:
1. Redistributions of source code must retain the above
copyright notice, this list of conditions, all files included
with the source code, and the following disclaimer. 2.
Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS
IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.
stegosuite/src/main/java/org/stegosuite/image/jpgtemp/james/version.txt 0000664 0000000 0000000 00000000577 15260777315 0026772 0 ustar 00root root 0000000 0000000 This is version 1.0a. This version corrected the dirty edges of images whose
dimensions were not mutliples of 8.
Version 1.0 was a fix of the below bug but still had dirty edges in
non-multiple-of-8 dimension images.
Version 0.9 didn't flush the entropy encoder's buffer and
resulted in files that some viewers were unable to read. This has been
fixed in version 1.0.
stegosuite/src/main/java/org/stegosuite/image/jpgtemp/net/ 0000775 0000000 0000000 00000000000 15260777315 0024222 5 ustar 00root root 0000000 0000000 stegosuite/src/main/java/org/stegosuite/image/jpgtemp/net/f5/ 0000775 0000000 0000000 00000000000 15260777315 0024534 5 ustar 00root root 0000000 0000000 stegosuite/src/main/java/org/stegosuite/image/jpgtemp/net/f5/Embed.java 0000664 0000000 0000000 00000002637 15260777315 0026423 0 ustar 00root root 0000000 0000000 package org.stegosuite.image.jpgtemp.net.f5;
import org.stegosuite.image.jpgtemp.james.JpegEncoder;
import java.awt.*;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class Embed {
public static void main(final String[] args) {
Image image;
FileOutputStream dataOut = null;
File file, outFile;
JpegEncoder jpg;
int Quality = 80;
// Check to see if the input file name has one of the extensions:
// .tif, .gif, .jpg
// If not, print the standard use info.
String embFileName = null;
String comment = "JPEG Encoder Copyright 1998, James R. Weeks and BioElectroMech. ";
String password = "abc123";
String inFileName = null;
String outFileName = null;
outFile = new File(outFileName);
while (outFile.exists()) {
outFile = new File(outFileName);
}
file = new File(inFileName);
if (file.exists()) {
try {
dataOut = new FileOutputStream(outFile);
} catch (final IOException ignored) {}
image = Toolkit.getDefaultToolkit().getImage(inFileName);
jpg = new JpegEncoder(image, Quality, dataOut);
try {
jpg.Compress(new FileInputStream(embFileName), password);
} catch (final Exception e) {
e.printStackTrace();
}
try {
dataOut.close();
} catch (final IOException ignored) {}
} else {
System.out.println("I couldn't find " + inFileName + ". Is it in another directory?");
}
}
}
stegosuite/src/main/java/org/stegosuite/image/jpgtemp/net/f5/Extract.java 0000664 0000000 0000000 00000022253 15260777315 0027015 0 ustar 00root root 0000000 0000000 package org.stegosuite.image.jpgtemp.net.f5;
import java.io.*;
import java.util.logging.Logger;
import org.stegosuite.image.jpgtemp.net.f5.crypt.F5Random;
import org.stegosuite.image.jpgtemp.net.f5.crypt.Permutation;
import org.stegosuite.image.jpgtemp.net.f5.ortega.HuffmanDecode;
import org.stegosuite.model.exception.SteganoKeyException;
public class Extract {
private static final Logger LOG = Logger.getLogger(Extract.class.getName());
private static File f; // carrier file
private static final byte[] deZigZag = {
0,
1,
5,
6,
14,
15,
27,
28,
2,
4,
7,
13,
16,
26,
29,
42,
3,
8,
12,
17,
25,
30,
41,
43,
9,
11,
18,
24,
31,
40,
44,
53,
10,
19,
23,
32,
39,
45,
52,
54,
20,
22,
33,
38,
46,
51,
55,
60,
21,
34,
37,
47,
50,
56,
59,
61,
35,
36,
48,
49,
57,
58,
62,
63,
};
public static void extract(
final InputStream fis,
final int flength,
final OutputStream fos,
final String password
) throws IOException, SteganoKeyException {
// carrier data
byte[] carrier = new byte[flength];
fis.read(carrier);
final HuffmanDecode hd = new HuffmanDecode(carrier);
// LOG.debug("Huffman decoding starts");
// dct values
int[] coeff = hd.decode();
// LOG.debug("Permutation starts");
//final F5Random random = new F5Random(password.getBytes());
final F5Random random = new F5Random(password);
final Permutation permutation = new Permutation(coeff.length, random);
// LOG.debug(coeff.length + " indices shuffled");
int extractedByte = 0;
int availableExtractedBits = 0;
int extractedFileLength = 0;
int nBytesExtracted = 0;
int shuffledIndex;
int extractedBit;
int i;
// LOG.debug("Extraction starts");
// extract length information
for (i = 0; availableExtractedBits < 32; i++) {
shuffledIndex = permutation.getShuffled(i);
if (shuffledIndex % 64 == 0) {
continue; // skip DC coefficients
}
shuffledIndex =
shuffledIndex -
(shuffledIndex % 64) +
deZigZag[shuffledIndex % 64];
if (coeff[shuffledIndex] == 0) {
continue; // skip zeroes
}
if (coeff[shuffledIndex] > 0) {
extractedBit = coeff[shuffledIndex] & 1;
} else {
extractedBit = 1 - (coeff[shuffledIndex] & 1);
}
extractedFileLength |= extractedBit << availableExtractedBits++;
}
// remove pseudo random pad
extractedFileLength ^= random.getNextByte();
extractedFileLength ^= random.getNextByte() << 8;
extractedFileLength ^= random.getNextByte() << 16;
extractedFileLength ^= random.getNextByte() << 24;
int k = extractedFileLength >> 24;
k %= 32;
final int n = (1 << k) - 1;
extractedFileLength &= 0x007fffff;
// LOG.debug("Length of embedded file: " + extractedFileLength + " bytes");
availableExtractedBits = 0;
if (n > 0) {
int startOfN = i;
int hash;
// LOG.debug("(1, " + n + ", " + k + ") code used");
extractingLoop: do {
// 1. read n places, and calculate k bits
hash = 0;
int code = 1;
for (i = 0; code <= n; i++) {
// check for pending end of coeff
if (startOfN + i >= coeff.length) {
break extractingLoop;
}
shuffledIndex = permutation.getShuffled(startOfN + i);
if (shuffledIndex % 64 == 0) {
continue; // skip DC coefficients
}
shuffledIndex =
shuffledIndex -
(shuffledIndex % 64) +
deZigZag[shuffledIndex % 64];
if (coeff[shuffledIndex] == 0) {
continue; // skip zeroes
}
if (coeff[shuffledIndex] > 0) {
extractedBit = coeff[shuffledIndex] & 1;
} else {
extractedBit = 1 - (coeff[shuffledIndex] & 1);
}
if (extractedBit == 1) {
hash ^= code;
}
code++;
}
startOfN += i;
// 2. write k bits bytewise
for (i = 0; i < k; i++) {
extractedByte |=
((hash >> i) & 1) << availableExtractedBits++;
if (availableExtractedBits == 8) {
// remove pseudo random pad
extractedByte ^= random.getNextByte();
fos.write((byte) extractedByte);
extractedByte = 0;
availableExtractedBits = 0;
nBytesExtracted++;
// check for pending end of embedded data
if (nBytesExtracted == extractedFileLength) {
break extractingLoop;
}
}
}
} while (true);
} else {
// LOG.debug("Default code used");
for (; i < coeff.length; i++) {
shuffledIndex = permutation.getShuffled(i);
if (shuffledIndex % 64 == 0) {
continue; // skip DC coefficients
}
shuffledIndex =
shuffledIndex -
(shuffledIndex % 64) +
deZigZag[shuffledIndex % 64];
if (coeff[shuffledIndex] == 0) {
continue; // skip zeroes
}
if (coeff[shuffledIndex] > 0) {
extractedBit = coeff[shuffledIndex] & 1;
} else {
extractedBit = 1 - (coeff[shuffledIndex] & 1);
}
extractedByte |= extractedBit << availableExtractedBits++;
if (availableExtractedBits == 8) {
// remove pseudo random pad
extractedByte ^= random.getNextByte();
fos.write((byte) extractedByte);
extractedByte = 0;
availableExtractedBits = 0;
nBytesExtracted++;
if (nBytesExtracted == extractedFileLength) {
break;
}
}
}
}
if (nBytesExtracted < extractedFileLength) {
LOG.fine(
"Incomplete file: only " +
nBytesExtracted +
" of " +
extractedFileLength +
" bytes extracted"
);
throw new SteganoKeyException();
}
}
public static void main(final String[] args) {
// output file name
String embFileName = "output.txt";
String password = "abc123";
try {
if (args.length < 1) {
usage();
return;
}
for (int i = 0; i < args.length; i++) {
if (!args[i].startsWith("-")) {
if (!args[i].endsWith(".jpg")) {
usage();
return;
}
f = new File(args[i]);
continue;
}
if (args.length < i + 1) {
LOG.fine("Missing parameter for switch " + args[i]);
usage();
return;
}
if (args[i].equals("-e")) {
embFileName = args[i + 1];
} else if (args[i].equals("-p")) {
password = args[i + 1];
} else {
LOG.fine("Unknown switch " + args[i] + " ignored.");
}
i++;
}
final FileInputStream fis = new FileInputStream(f);
// embedded file (output file)
FileOutputStream fos = new FileOutputStream(embFileName);
extract(fis, (int) f.length(), fos, password);
} catch (final Exception e) {
e.printStackTrace();
}
}
static void usage() {
LOG.fine("java Extract [Options] \"image.jpg\"");
LOG.fine("Options:");
LOG.fine("\t-p password (default: abc123)");
LOG.fine("\t-e extractedFileName (default: output.txt)");
LOG.fine("\nAuthor: Andreas Westfeld, westfeld@inf.tu-dresden.de");
}
}
stegosuite/src/main/java/org/stegosuite/image/jpgtemp/net/f5/crypt/ 0000775 0000000 0000000 00000000000 15260777315 0025675 5 ustar 00root root 0000000 0000000 stegosuite/src/main/java/org/stegosuite/image/jpgtemp/net/f5/crypt/F5Random.java 0000664 0000000 0000000 00000002444 15260777315 0030157 0 ustar 00root root 0000000 0000000 package org.stegosuite.image.jpgtemp.net.f5.crypt;
import java.util.Random;
//import java.security.SecureRandom;
import java.util.logging.Logger;
public class F5Random {
private final Random random;
private static final Logger LOG = Logger.getLogger(
F5Random.class.getName()
);
private final byte[] b;
public F5Random(final String password) {
this.random = new Random();
long seed = stringToNumber(password);
LOG.fine(() -> "Seed: " + seed);
this.random.setSeed(seed);
this.b = new byte[1];
}
// get a random byte
public int getNextByte() {
this.random.nextBytes(this.b);
return this.b[0];
}
public static long stringToNumber(String s) {
long result = 0;
for (int i = 0; i < s.length(); i++) {
final char ch = s.charAt(i);
result += (int) ch;
}
return result;
}
// get a random integer 0 ... (maxValue-1)
public int getNextValue(final int maxValue) {
int retVal =
getNextByte() |
(getNextByte() << 8) |
(getNextByte() << 16) |
(getNextByte() << 24);
retVal %= maxValue;
if (retVal < 0) {
retVal += maxValue;
}
return retVal;
}
}
stegosuite/src/main/java/org/stegosuite/image/jpgtemp/net/f5/crypt/Permutation.java 0000664 0000000 0000000 00000001710 15260777315 0031046 0 ustar 00root root 0000000 0000000 package org.stegosuite.image.jpgtemp.net.f5.crypt;
public class Permutation {
final int[] shuffled; // shuffled sequence
// The constructor of class Permutation creates a shuffled
// sequence of the integers 0 ... (size-1).
public Permutation(final int size, final F5Random random) {
int i, randomIndex, tmp;
this.shuffled = new int[size];
// To create the shuffled sequence, we initialise an array
// with the integers 0 ... (size-1).
for (i = 0; i < size; i++) {
// initialise with �size� integers
this.shuffled[i] = i;
}
int maxRandom = size; // set number of entries to shuffle
for (i = 0; i < size; i++) { // shuffle entries
randomIndex = random.getNextValue(maxRandom--);
tmp = this.shuffled[randomIndex];
this.shuffled[randomIndex] = this.shuffled[maxRandom];
this.shuffled[maxRandom] = tmp;
}
}
// get value #i from the shuffled sequence
public int getShuffled(final int i) {
return this.shuffled[i];
}
}
stegosuite/src/main/java/org/stegosuite/image/jpgtemp/net/f5/image/ 0000775 0000000 0000000 00000000000 15260777315 0025616 5 ustar 00root root 0000000 0000000 stegosuite/src/main/java/org/stegosuite/image/jpgtemp/net/f5/image/Bmp.java 0000664 0000000 0000000 00000005476 15260777315 0027213 0 ustar 00root root 0000000 0000000 package org.stegosuite.image.jpgtemp.net.f5.image;
import java.awt.*;
import java.awt.image.MemoryImageSource;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class Bmp {
int iDataOffset;
int[] pixel = null;
BufferedInputStream imageFile;
int bfSize;
int bfOffBits;
int biSize;
int biWidth;
int biHeight;
int biPlanes;
int biBitCount;
int biCompression;
int biSizeImage;
int biXPelsPerMeter;
int biYPelsPerMeter;
int biClrUsed;
int biClrImportant;
public Bmp(final String fileName) {
try {
this.imageFile = new BufferedInputStream(new FileInputStream(fileName));
readBitmapFileHeader();
readBitmapInfoHeader();
this.pixel = new int[this.biWidth * this.biHeight];
int padding = 3 * this.biWidth % 4;
if (padding > 0) {
padding = 4 - padding;
}
int offset;
for (int y = 1; y <= this.biHeight; y++) {
offset = (this.biHeight - y) * this.biWidth;
for (int x = 0; x < this.biWidth; x++) {
this.pixel[offset + x] = readPixel();
}
for (int x = 0; x < padding; x++) {
this.imageFile.read();
}
}
} catch (final Exception e) {
System.out.println(fileName + " is not a true colour file.");
System.exit(1);
}
}
public Image getImage() {
MemoryImageSource mis;
mis = new MemoryImageSource(this.biWidth, this.biHeight, this.pixel, 0, this.biWidth);
return Toolkit.getDefaultToolkit().createImage(mis);
}
void readBitmapFileHeader()
throws Exception {
if (this.imageFile.read() != 'B') {
throw new Exception();
}
if (this.imageFile.read() != 'M') {
throw new Exception();
}
this.bfSize = readInt();
readInt(); // ignore 4 bytes reserved
this.bfOffBits = readInt();
}
void readBitmapInfoHeader()
throws Exception {
this.biSize = readInt();
this.biWidth = readInt();
this.biHeight = readInt();
this.biPlanes = readShort();
this.biBitCount = readShort();
if (this.biBitCount != 24) {
throw new Exception();
}
this.biCompression = readInt();
this.biSizeImage = readInt();
this.biXPelsPerMeter = readInt();
this.biYPelsPerMeter = readInt();
this.biClrUsed = readInt();
this.biClrImportant = readInt();
}
int readInt()
throws IOException {
int retVal = 0;
for (int i = 0; i < 4; i++) {
retVal += (this.imageFile.read() & 0xff) << 8 * i;
}
return retVal;
}
int readPixel()
throws IOException {
int retVal = 0;
for (int i = 0; i < 3; i++) {
retVal += (this.imageFile.read() & 0xff) << 8 * i;
}
return retVal | 0xff000000;
}
int readShort()
throws IOException {
int retVal;
retVal = this.imageFile.read() & 0xff;
retVal += (this.imageFile.read() & 0xff) << 8;
return retVal;
}
}
stegosuite/src/main/java/org/stegosuite/image/jpgtemp/net/f5/ortega/ 0000775 0000000 0000000 00000000000 15260777315 0026015 5 ustar 00root root 0000000 0000000 stegosuite/src/main/java/org/stegosuite/image/jpgtemp/net/f5/ortega/HuffTable.java 0000664 0000000 0000000 00000011740 15260777315 0030523 0 ustar 00root root 0000000 0000000 /* Version 0.1 of F5 Steganography Software by Andreas Westfeld 1999 */
/* JPEG Decoder */
/* Sean Breslin */
/* EE590 Directed Research */
/* Dr. Ortega */
/* Fall 1997 */
/* */
/* HuffTable.class: */
/* Extracts Huffman table from image header */
/* data. Instanciate one class for each table */
/* in the file the header. */
/* */
/* Methods: */
/* getHUFFVAL(), returns HUFFVAL array */
/* getVALPRT(), returns VALPTR array */
/* getMAXCODE(), returns MAXCODE array */
/* getMINCODE(), returns MINCODE array */
/* */
/*
* /////////////// DISCLAIMER///////////////////////////////// This software is provided by the
* author and contributors ``as is'' and any express or implied warranties, including, but not
* limited to, the implied warranties of merchantability and fitness for a particular purpose are
* disclaimed. In no event shall the author or contributors be liable for any direct, indirect,
* incidental, special, exemplary, or consequential damages (including, but not limited to,
* procurement of substitute goods or services; loss of use, data, or profits; or business
* interruption) however caused and on any theory of liability, whether in contract, strict
* liability, or tort (including negligence or otherwise) arising in any way out of the use of this
* software, even if advised of the possibility of such damage.
* //////////////////////////////////////////////////////
*/
// westfeld
package org.stegosuite.image.jpgtemp.net.f5.ortega;
import java.io.DataInputStream;
import java.io.IOException;
public class HuffTable {
// Instance variables
private final int[] BITS = new int[17];
private final int[] HUFFVAL = new int[256];
private final int[] HUFFCODE = new int[257];
private final int[] HUFFSIZE = new int[257];
private final int[] EHUFCO = new int[257];
private final int[] EHUFSI = new int[257];
private final int[] MINCODE = new int[17];
private final int[] MAXCODE = new int[18];
private final int[] VALPTR = new int[17];
private final int Ln;
private int SI, I, J, K, LASTK, CODE;
// Declare input steam
final DataInputStream dis;
// Constructor Method
public HuffTable(final DataInputStream d, final int l) {
this.dis = d;
// System.out.println("L�nge="+l);
// Get table data from input stream
this.Ln = 19 + getTableData();
// System.out.println(Ln);
Generate_size_table(); // Flow Chart C.1
Generate_code_table(); // Flow Chart C.2
Order_codes(); // Flow Chart C.3
Decoder_tables(); // Generate decoder tables Flow Chart F.15
}
private void Decoder_tables() {
// Decoder table generation Flow Chart F.15
this.I = 0;
this.J = 0;
while (true) {
if (++this.I > 16) {
return;
}
if (this.BITS[this.I] == 0) {
this.MAXCODE[this.I] = -1;
} else {
this.VALPTR[this.I] = this.J;
this.MINCODE[this.I] = this.HUFFCODE[this.J];
this.J = this.J + this.BITS[this.I] - 1;
this.MAXCODE[this.I] = this.HUFFCODE[this.J++];
}
}
}
private void Generate_code_table() {
// Generate Code table Flow Chart C.2
this.K = 0;
this.CODE = 0;
this.SI = this.HUFFSIZE[0];
while (true) {
this.HUFFCODE[this.K++] = this.CODE++;
if (this.HUFFSIZE[this.K] == this.SI) {
continue;
}
if (this.HUFFSIZE[this.K] == 0) {
break;
}
do {
this.CODE <<= 1;
this.SI++;
} while (this.HUFFSIZE[this.K] != this.SI);
}
}
private void Generate_size_table() {
// Generate HUFFSIZE table Flow Chart C.1
this.K = 0;
this.I = 1;
this.J = 1;
while (true) {
if (this.J > this.BITS[this.I]) {
this.J = 1;
this.I++;
if (this.I > 16) {
break;
}
} else {
this.HUFFSIZE[this.K++] = this.I;
this.J++;
}
}
this.HUFFSIZE[this.K] = 0;
this.LASTK = this.K;
}
private int getByte() {
try {
return this.dis.readUnsignedByte();
} catch (final IOException e) {
return -1;
}
}
// IO MethodS
public int[] getHUFFVAL() {
return this.HUFFVAL;
}
public int getLen() {
return this.Ln;
}
public int[] getMAXCODE() {
return this.MAXCODE;
}
public int[] getMINCODE() {
return this.MINCODE;
}
private int getTableData() {
// Get BITS list
int count = 0;
for (int x = 1; x < 17; x++) {
this.BITS[x] = getByte();
count += this.BITS[x];
}
// Read in HUFFVAL
for (int x = 0; x < count; x++) {
// System.out.println(Ln);
this.HUFFVAL[x] = getByte();
}
return count;
}
public int[] getVALPTR() {
return this.VALPTR;
}
private void Order_codes() {
// Order Codes Flow Chart C.3
this.K = 0;
do {
this.I = this.HUFFVAL[this.K];
this.EHUFCO[this.I] = this.HUFFCODE[this.K];
this.EHUFSI[this.I] = this.HUFFSIZE[this.K++];
} while (this.K < this.LASTK);
}
}
stegosuite/src/main/java/org/stegosuite/image/jpgtemp/net/f5/ortega/HuffmanDecode.java 0000664 0000000 0000000 00000050547 15260777315 0031363 0 ustar 00root root 0000000 0000000 /* Version 0.1 of F5 Steganography Software by Andreas Westfeld 1999 */
/* JPEG Decoder */
/* Sean Breslin */
/* EE590 Directed Research */
/* Dr. Ortega */
/* Fall 1997 */
/* */
/* HuffmanDecode.class: */
/* This object performs entopy decoding on */
/* a JPEG image file. This object instanciates */
/* HuffTable.class which extracts the Huffman */
/* Tables from the file header information. */
/* */
/* Methods: */
/* HuffDecode(), returns array of 8x8 */
/* blocks of image data */
/* getX(), returns horizontal image size */
/* getY(), returns vertical image size */
/* getPrec(), returns sample precision */
/* getComp(), returns number of components */
/* rawDecode(), returns quantized */
/* coefficients */
/* */
//
// changes by Andreas Westfeld
//
package org.stegosuite.image.jpgtemp.net.f5.ortega;
//
// Mar 15 1999
// constructor changed to byte array parameter
// added method rawDecode
//
import java.awt.*;
import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.IOException;
import java.util.Date;
@SuppressWarnings("unused")
public class HuffmanDecode {
private final static int APP0 = 0xE0;
private final static int APP1 = 0xE1;
private final static int APP2 = 0xE2;
private final static int APP3 = 0xE3;
private final static int APP4 = 0xE4;
private final static int APP5 = 0xE5;
private final static int APP6 = 0xE6;
private final static int APP7 = 0xE7;
private final static int APP8 = 0xE8;
private final static int APP9 = 0xE9;
private final static int APP10 = 0xEA;
private final static int APP11 = 0xEB;
private final static int APP12 = 0xEC;
private final static int APP13 = 0xED;
private final static int APP14 = 0xEE;
private final static int APP15 = 0xEF;
private final static int DRI = 0xDD;
private final static int DNL = 0xDC;
private final static int EOI = 0xD9;
// Instance variables
// Declare header variables
private int Lf, P, X, Y, Nf; // SOF0 parameters
private int[] C, H, V, T; // SOF0 parameters
private int Ls, Ns, Ss, Se, Ah, Al; // SOS parameters
private int[] Cs, Td, Ta; // SOS parameters
private int Lh, Tc, Th; // DHT parameters
private int Lq, Pq, Tq; // DQT parameters
private int Ld, Nl; // DNL parameters
private int Lr, Ri; // DRI parameters
// other variables
private int B, CNT, DIFF, PRED;
private final int size;
private int K, SSSS, RS, R, J, CODE;
private int lp, cnt, a, b, hftbl;
private int[][][] Cr, Cb;
private final int[][] HUFFVAL = new int[4][];
private final int[][] VALPTR = new int[4][];
private final int[][] MINCODE = new int[4][];
private final int[][] MAXCODE = new int[4][];
private final int[] ZZ = new int[64];
private final int[][] QNT = new int[4][64];
private int RI;
private static final byte[][] deZZ = { { 0, 0 }, { 0, 1 }, { 1, 0 }, { 2, 0 }, { 1, 1 }, { 0, 2 }, { 0, 3 }, { 1, 2 },
{ 2, 1 }, { 3, 0 }, { 4, 0 }, { 3, 1 }, { 2, 2 }, { 1, 3 }, { 0, 4 }, { 0, 5 }, { 1, 4 }, { 2, 3 },
{ 3, 2 }, { 4, 1 }, { 5, 0 }, { 6, 0 }, { 5, 1 }, { 4, 2 }, { 3, 3 }, { 2, 4 }, { 1, 5 }, { 0, 6 },
{ 0, 7 }, { 1, 6 }, { 2, 5 }, { 3, 4 }, { 4, 3 }, { 5, 2 }, { 6, 1 }, { 7, 0 }, { 7, 1 }, { 6, 2 },
{ 5, 3 }, { 4, 4 }, { 3, 5 }, { 2, 6 }, { 1, 7 }, { 2, 7 }, { 3, 6 }, { 4, 5 }, { 5, 4 }, { 6, 3 },
{ 7, 2 }, { 7, 3 }, { 6, 4 }, { 5, 5 }, { 4, 6 }, { 3, 7 }, { 4, 7 }, { 5, 6 }, { 6, 5 }, { 7, 4 },
{ 7, 5 }, { 6, 6 }, { 5, 7 }, { 6, 7 }, { 7, 6 }, { 7, 7 } };
// added for decode()
private static final byte[] deZigZag = { 0, 1, 5, 6, 14, 15, 27, 28, 2, 4, 7, 13, 16, 26, 29, 42, 3, 8, 12, 17, 25, 30,
41, 43, 9, 11, 18, 24, 31, 40, 44, 53, 10, 19, 23, 32, 39, 45, 52, 54, 20, 22, 33, 38, 46, 51, 55, 60, 21,
34, 37, 47, 50, 56, 59, 61, 35, 36, 48, 49, 57, 58, 62, 63 };
// {{ Control Objects
HuffTable htDC0, htDC1;
HuffTable htAC0, htAC1;
final DataInputStream dis;
TextArea ta;
Date dt;
// }}
// Constructor Method
public HuffmanDecode(final byte[] data) {
this.size = (short) data.length;
this.dis = new DataInputStream(new ByteArrayInputStream(data));
// Parse out markers and header info
boolean cont = true;
while (cont) {
if (255 == getByte()) {
switch (getByte()) {
case 192:
sof0();
break;
case 196:
dht();
break;
case 219:
dqt();
break;
case 217, 218:
cont = false;
break;
case APP0:
case APP1:
case APP2:
case APP3:
case APP4:
case APP5:
case APP6:
case APP7:
case APP8:
case APP9:
case APP10:
case APP11:
case APP12:
case APP13:
case APP14:
case APP15:
skipVariable();
break;
case DRI:
dri();
break;
}
}
}
}
private int available() {
try {
return this.dis.available();
} catch (final IOException e) {
e.printStackTrace();
}
return 0;
}
private void closeStream() {
// Close input stream
try {
this.dis.close(); // close io stream to file
} catch (final IOException ignored) {}
}
// Return image data
public int[] decode() {
final int x, y, a, b, line;// , sz = X * Y;
int /* col, */ tmp;
final int blocks, MCU;// , scan=0;
int[] Cs, Ta, Td;
final int[] PRED = new int[this.Nf];
for (int nComponent = 0; nComponent < this.Nf; nComponent++) {
PRED[nComponent] = 0;
}
final long t;
final double time;
this.CNT = 0;
// Read in Scan Header information
this.Ls = getInt();
this.Ns = getByte();
// System.out.println("SOS - Components: "+Integer.toString(Ns));
Cs = new int[this.Ns];
Td = new int[this.Ns];
Ta = new int[this.Ns];
// get table information
for (this.lp = 0; this.lp < this.Ns; this.lp++) {
Cs[this.lp] = getByte();
Td[this.lp] = getByte();
Ta[this.lp] = Td[this.lp] & 0x0f;
Td[this.lp] >>= 4;
// System.out.println("DC-Table: "+Integer.toString(Td[lp])+"AC-Table:
// "+Integer.toString(Ta[lp]));
}
this.Ss = getByte();
this.Se = getByte();
this.Ah = getByte();
this.Al = this.Ah & 0x0f;
this.Ah >>= 4;
// Calculate the Number of blocks encoded
// warum doppelt so viel?
final int[] buff = new int[2 * 8 * 8 * getBlockCount()];
int pos = 0;
int MCUCount = 0;
// System.out.println("BlockCount="+getBlockCount());
final boolean bDoIt = true;
while (true) {
// Get component 1 of MCU
for (int nComponent = 0; nComponent < this.Nf; nComponent++) {
for (this.cnt = 0; this.cnt < this.H[nComponent] * this.V[nComponent]; this.cnt++) {
// Get DC coefficient
this.hftbl = Td[nComponent] * 2;
tmp = DECODE();
this.DIFF = RECEIVE(tmp);
this.ZZ[0] = PRED[0] + EXTEND(this.DIFF, tmp);
PRED[nComponent] = this.ZZ[0];
// Get AC coefficients
this.hftbl = Ta[nComponent] * 2 + 1;
Decode_AC_coefficients();
for (this.lp = 0; this.lp < 64; this.lp++) {
// System.out.println("pos="+pos);
// Zickzack???
// buff[pos++]=ZZ[deZigZag[lp]];
buff[pos++] = this.ZZ[this.lp];
}
}
}
MCUCount++;
if (MCUCount == this.RI) {
MCUCount = 0;
this.CNT = 0;
for (int nComponent = 0; nComponent < this.Nf; nComponent++) {
PRED[nComponent] = 0;
}
// System.out.println("MCUCount");
getByte();
// System.out.println(Integer.toHexString(getByte()));
final int tmpB = getByte();
// System.out.println(Integer.toHexString(tmpB));
if (tmpB == EOI) {
break;
// System.out.println("MCUCount-Ende");
}
}
if (available() <= 2) {
// System.out.println("expecting end of image");
if (available() == 2) {
getByte();
if (getByte() != EOI) {
System.out.println("file does not end with EOI");
}
} else {
if (available() > 0) {
System.out.println(Integer.toHexString(getByte()));
}
System.out.println("file does not end with EOI");
}
break;
}
}
final int[] tmpBuff = new int[pos];
System.arraycopy(buff, 0, tmpBuff, 0, pos);
return tmpBuff;
}
private int DECODE() {
int I, CD, VALUE;
CD = NextBit();
I = 1;
while (true) {
// System.out.println(hftbl+" "+I);
if (CD > this.MAXCODE[this.hftbl][I]) {
CD = (CD << 1) + NextBit();
I++;
} else {
break;
}
}
this.J = this.VALPTR[this.hftbl][I];
this.J = this.J + CD - this.MINCODE[this.hftbl][I];
VALUE = this.HUFFVAL[this.hftbl][this.J];
return VALUE;
}
private void Decode_AC_coefficients() {
this.K = 1;
// Zero out array ZZ[]
for (this.lp = 1; this.lp < 64; this.lp++) {
this.ZZ[this.lp] = 0;
}
while (true) {
// System.out.println(hftbl);
this.RS = DECODE();
this.SSSS = this.RS % 16;
this.R = this.RS >> 4;
if (this.SSSS == 0) {
if (this.R == 15) {
this.K += 16;
} else {
return;
}
} else {
this.K = this.K + this.R;
Decode_ZZ(this.K);
if (this.K == 63) {
return;
} else {
this.K++;
}
}
}
}
private void Decode_ZZ(final int k) {
// Decoding a nonzero AC coefficient
this.ZZ[k] = RECEIVE(this.SSSS);
this.ZZ[k] = EXTEND(this.ZZ[k], this.SSSS);
}
private void dht() {
// Read in Huffman tables
// System.out.println("Read in Huffman tables");
// Lh length
// Th index
// Tc AC?
this.Lh = getInt();
while (this.Lh > 0) {
this.Tc = getByte();
this.Th = this.Tc & 0x0f;
this.Tc >>= 4;
// System.out.println("______Lh="+Lh);
if (this.Th == 0) {
if (this.Tc == 0) {
this.htDC0 = new HuffTable(this.dis, this.Lh);
this.Lh -= this.htDC0.getLen();
this.HUFFVAL[0] = this.htDC0.getHUFFVAL();
this.VALPTR[0] = this.htDC0.getVALPTR();
this.MAXCODE[0] = this.htDC0.getMAXCODE();
// System.out.println("MAXCODE[0]="+MAXCODE[0]);
this.MINCODE[0] = this.htDC0.getMINCODE();
this.htDC0 = null;
System.gc();
} else {
this.htAC0 = new HuffTable(this.dis, this.Lh);
this.Lh -= this.htAC0.getLen();
this.HUFFVAL[1] = this.htAC0.getHUFFVAL();
this.VALPTR[1] = this.htAC0.getVALPTR();
this.MAXCODE[1] = this.htAC0.getMAXCODE();
// System.out.println("MAXCODE[1]="+MAXCODE[1]);
this.MINCODE[1] = this.htAC0.getMINCODE();
this.htAC0 = null;
System.gc();
}
} else {
if (this.Tc == 0) {
this.htDC1 = new HuffTable(this.dis, this.Lh);
this.Lh -= this.htDC1.getLen();
this.HUFFVAL[2] = this.htDC1.getHUFFVAL();
this.VALPTR[2] = this.htDC1.getVALPTR();
this.MAXCODE[2] = this.htDC1.getMAXCODE();
// System.out.println("MAXCODE[2]="+MAXCODE[2]);
this.MINCODE[2] = this.htDC1.getMINCODE();
this.htDC1 = null;
System.gc();
} else {
this.htAC1 = new HuffTable(this.dis, this.Lh);
this.Lh -= this.htAC1.getLen();
this.HUFFVAL[3] = this.htAC1.getHUFFVAL();
this.VALPTR[3] = this.htAC1.getVALPTR();
this.MAXCODE[3] = this.htAC1.getMAXCODE();
// System.out.println("MAXCODE[3]="+MAXCODE[3]);
this.MINCODE[3] = this.htAC1.getMINCODE();
this.htAC1 = null;
System.gc();
}
}
}
}
private void dqt() {
// Read in quatization tables
this.Lq = getInt();
this.Pq = getByte();
this.Tq = this.Pq & 0x0f;
this.Pq >>= 4;
switch (this.Tq) {
case 0:
for (this.lp = 0; this.lp < 64; this.lp++) {
this.QNT[0][this.lp] = getByte();
}
break;
case 1:
for (this.lp = 0; this.lp < 64; this.lp++) {
this.QNT[1][this.lp] = getByte();
}
break;
case 2:
for (this.lp = 0; this.lp < 64; this.lp++) {
this.QNT[2][this.lp] = getByte();
}
break;
case 3:
for (this.lp = 0; this.lp < 64; this.lp++) {
this.QNT[3][this.lp] = getByte();
}
break;
}
}
private void dri() {
getInt();
this.RI = getInt();
}
private int EXTEND(int V, final int T) {
int Vt;
Vt = 0x01 << T - 1;
if (V < Vt) {
Vt = (-1 << T) + 1;
V += Vt;
}
return V;
}
// Calculate the Number of blocks encoded
public int getBlockCount() {
switch (this.Nf) {
case 1:
return (this.X + 7) / 8 * ((this.Y + 7) / 8);
case 3:
return 6 * ((this.X + 15) / 16) * ((this.Y + 15) / 16);
default:
System.out.println("Nf weder 1 noch 3");
}
return 0;
}
public int getByte() {
int b = 0;
// Read Byte from DataInputStream
try {
b = this.dis.readUnsignedByte();
} catch (final IOException e) {
e.printStackTrace();
}
return b;
}
public int getComp() {
return this.Nf;
}
public int getInt() {
int b = 0;
// Read Integer from DataInputStream
try {
b = this.dis.readUnsignedByte();
b <<= 8;
final int tmp = this.dis.readUnsignedByte();
b ^= tmp;
} catch (final IOException e) {
e.printStackTrace();
}
return b;
}
public int getPrec() {
return this.P;
}
// Public get methods
public int getX() {
return this.X;
}
public int getY() {
return this.Y;
}
// Return image data
public void HuffDecode(final int[][][] buffer) {
int x, y, tmp;
final int sz = this.X * this.Y, scan = 0;
final int[][] Block = new int[8][8];
int Cs, Ta, Td, blocks;
final long t;
final double time;
// Read in Scan Header information
this.Ls = getInt();
this.Ns = getByte();
Cs = getByte();
Td = getByte();
Ta = Td & 0x0f;
Td >>= 4;
this.Ss = getByte();
this.Se = getByte();
this.Ah = getByte();
this.Al = this.Ah & 0x0f;
this.Ah >>= 4;
// Calculate the Number of blocks encoded
// blocks = X * Y / 64;
blocks = getBlockCount() / 6;
// decode image data and return image data in array
for (this.cnt = 0; this.cnt < blocks; this.cnt++) {
// Get DC coefficient
if (Td == 0) {
this.hftbl = 0;
} else {
this.hftbl = 2;
}
tmp = DECODE();
this.DIFF = RECEIVE(tmp);
this.ZZ[0] = this.PRED + EXTEND(this.DIFF, tmp);
this.PRED = this.ZZ[0];
// Get AC coefficients
if (Ta == 0) {
this.hftbl = 1;
} else {
this.hftbl = 3;
}
Decode_AC_coefficients();
// dezigzag and dequantize block
for (this.lp = 0; this.lp < 64; this.lp++) {
Block[deZZ[this.lp][0]][deZZ[this.lp][1]] = this.ZZ[this.lp] * this.QNT[0][this.lp];
}
// store blocks in buffer
for (x = 0; x < 8; x++) {
for (y = 0; y < 8; y++) {
buffer[this.cnt][x][y] = Block[x][y];
}
}
}
closeStream();
}
private int NextBit() {
// Get one bit from entropy coded data stream
int b2;
final int lns;
int BIT;
if (this.CNT == 0) {
this.CNT = 8;
this.B = getByte();
if (255 == this.B) {
b2 = getByte();
}
}
BIT = this.B & 0X80; // get MSBit of B
BIT >>= 7; // move MSB to LSB
this.CNT--; // Decrement counter
this.B <<= 1; // Shift left one bit
return BIT;
}
// Return quantized coefficients
public void rawDecode(final int[][][] buffer) {
int x, y, tmp;
final int[][] Block = new int[8][8];
int Cs, Ta, Td, blocks;
final long t;
final double time;
// Read in Scan Header information
this.Ls = getInt();
this.Ns = getByte();
Cs = getByte();
Td = getByte();
Ta = Td & 0x0f;
Td >>= 4;
this.Ss = getByte();
this.Se = getByte();
this.Ah = getByte();
this.Al = this.Ah & 0x0f;
this.Ah >>= 4;
// Calculate the Number of blocks encoded
blocks = getBlockCount() / 6;
// decode image data and return image data in array
for (this.cnt = 0; this.cnt < blocks; this.cnt++) {
// Get DC coefficient
if (Td == 0) {
this.hftbl = 0;
} else {
this.hftbl = 2;
}
tmp = DECODE();
this.DIFF = RECEIVE(tmp);
this.ZZ[0] = this.PRED + EXTEND(this.DIFF, tmp);
this.PRED = this.ZZ[0];
// Get AC coefficients
if (Ta == 0) {
this.hftbl = 1;
} else {
this.hftbl = 3;
}
Decode_AC_coefficients();
// dezigzag
for (this.lp = 0; this.lp < 64; this.lp++) {
Block[deZZ[this.lp][0]][deZZ[this.lp][1]] = this.ZZ[this.lp];
}
// store blocks in buffer
System.out.print(this.cnt + " ");
for (x = 0; x < 8; x++) {
for (y = 0; y < 8; y++) {
buffer[this.cnt][x][y] = Block[x][y];
}
}
}
closeStream();
}
private int RECEIVE(final int SSS) {
int V = 0, I = 0;
while (true) {
if (I == SSS) {
return V;
}
I++;
V = (V << 1) + NextBit();
}
}
// Return image data for RGB images
public void RGBdecode(final int[][][] Lum) {
int x, y, a, b, line, col, tmp;
final int sz = this.X * this.Y;
int blocks;
final int MCU, scan = 0;
final int[][] Block = new int[8][8];
int[] Cs, Ta, Td;
final int[] PRED = { 0, 0, 0 };
final long t;
final double time;
// Read in Scan Header information
this.Ls = getInt();
this.Ns = getByte();
Cs = new int[this.Ns];
Td = new int[this.Ns];
Ta = new int[this.Ns];
// get table information
for (this.lp = 0; this.lp < this.Ns; this.lp++) {
Cs[this.lp] = getByte();
Td[this.lp] = getByte();
Ta[this.lp] = Td[this.lp] & 0x0f;
Td[this.lp] >>= 4;
}
this.Ss = getByte();
this.Se = getByte();
this.Ah = getByte();
this.Al = this.Ah & 0x0f;
this.Ah >>= 4;
// Calculate the Number of blocks encoded
// blocks = X * Y / 64;
blocks = getBlockCount() / 6;
col = 2;
// decode image data and return image data in array
for (a = 0; a < 32; a++) {
for (b = 0; b < 32; b++) {
// Get component 1 of MCU
for (this.cnt = 0; this.cnt < 4; this.cnt++) {
// Get DC coefficient
this.hftbl = 0;
tmp = DECODE();
this.DIFF = RECEIVE(tmp);
this.ZZ[0] = PRED[0] + EXTEND(this.DIFF, tmp);
PRED[0] = this.ZZ[0];
// Get AC coefficients
this.hftbl = 1;
Decode_AC_coefficients();
// dezigzag and dequantize block
for (this.lp = 0; this.lp < 64; this.lp++) {
Block[deZZ[this.lp][0]][deZZ[this.lp][1]] = this.ZZ[this.lp] * this.QNT[0][this.lp];
}
if (this.cnt < 2) {
line = 0;
} else {
line = 62;
}
// store blocks in buffer
for (x = 0; x < 8; x++) {
for (y = 0; y < 8; y++) {
Lum[b * 2 + this.cnt + line + a * 128][x][y] = Block[x][y];
}
}
}
// getComponent 2 and 3 of image
for (this.cnt = 0; this.cnt < 2; this.cnt++) {
// Get DC coefficient
this.hftbl = 2;
tmp = DECODE();
this.DIFF = RECEIVE(tmp);
this.ZZ[0] = PRED[this.cnt + 1] + EXTEND(this.DIFF, tmp);
PRED[this.cnt + 1] = this.ZZ[0];
// Get AC coefficients
this.hftbl = 3;
Decode_AC_coefficients();
// dezigzag and dequantize block
for (this.lp = 0; this.lp < 64; this.lp++) {
Block[deZZ[this.lp][0]][deZZ[this.lp][1]] = this.ZZ[this.lp] * this.QNT[1][this.lp];
}
// store blocks in buffer
if (this.cnt == 0) {
for (x = 0; x < 8; x++) {
for (y = 0; y < 8; y++) {
this.Cb[a * 32 + b][x][y] = Block[x][y];
}
}
} else {
for (x = 0; x < 8; x++) {
for (y = 0; y < 8; y++) {
this.Cr[a * 32 + b][x][y] = Block[x][y];
}
}
}
}
}
}
closeStream();
}
public void setCb(final int[][][] chrome) {
this.Cb = chrome;
}
public void setCr(final int[][][] chrome) {
this.Cr = chrome;
}
private void skipVariable() {
try {
this.dis.skipBytes(getInt() - 2);
} catch (final IOException e) {
e.printStackTrace();
}
}
private void sof0() {
// Read in start of frame header data
this.Lf = getInt();
this.P = getByte();
this.Y = getInt();
this.X = getInt();
this.Nf = getByte();
this.C = new int[this.Nf];
this.H = new int[this.Nf];
this.V = new int[this.Nf];
this.T = new int[this.Nf];
// Read in quatization table identifiers
for (this.lp = 0; this.lp < this.Nf; this.lp++) {
this.C[this.lp] = getByte();
this.H[this.lp] = getByte();
this.V[this.lp] = this.H[this.lp] & 0x0f;
this.H[this.lp] >>= 4;
this.T[this.lp] = getByte();
}
}
}
stegosuite/src/main/java/org/stegosuite/logging/ 0000775 0000000 0000000 00000000000 15260777315 0022332 5 ustar 00root root 0000000 0000000 stegosuite/src/main/java/org/stegosuite/logging/DebugHandler.java 0000664 0000000 0000000 00000007273 15260777315 0025532 0 ustar 00root root 0000000 0000000 package org.stegosuite.logging;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.logging.Filter;
import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.StreamHandler;
/**
* Handler for DEBUG level messages only with detailed output (matches logback's STDOUT appender).
*/
public class DebugHandler extends StreamHandler {
public DebugHandler() {
super(System.out, new DetailedFormatter());
setFilter(new DebugLevelFilter());
}
@Override
public void publish(LogRecord record) {
super.publish(record);
flush();
}
private static class DebugLevelFilter implements Filter {
@Override
public boolean isLoggable(LogRecord record) {
// Accept FINE (DEBUG) and above, similar to logback's DEBUG appender
return record.getLevel().intValue() >= Level.FINE.intValue();
}
}
private static class DetailedFormatter extends java.util.logging.Formatter {
private static final DateTimeFormatter TIME_FORMATTER =
DateTimeFormatter.ofPattern("HH:mm:ss.SSS");
private static final StackWalker STACK_WALKER = StackWalker.getInstance();
@Override
public String format(LogRecord record) {
String time = LocalDateTime.now().format(TIME_FORMATTER);
Thread thread = Thread.currentThread();
String source = formatSource(record);
String message = formatMessage(record);
return String.format(
"%s @ %s (%s) %s%n",
time,
thread.getName(),
source,
message
);
}
/**
* Returns the source of the log call as {@code ClassName.java:line}. IDEs turn this into a
* link in the console, so a debug message can be jumped to with a single click.
*/
private String formatSource(LogRecord record) {
String fileName = extractClassName(record.getSourceClassName());
int line = findCallerLine(record);
if (line < 1) {
return fileName;
}
return fileName + ":" + line;
}
/**
* Returns the line number of the frame that issued the log call, or 0 if it cannot be
* determined. Logging is synchronous, so the caller is still on the stack while the record
* is formatted. The record's source class and method identify that frame, which also keeps
* the lookup correct for messages that are supplied lazily as a lambda.
*/
private int findCallerLine(LogRecord record) {
String className = record.getSourceClassName();
String methodName = record.getSourceMethodName();
if (className == null || methodName == null) {
return 0;
}
StackWalker.StackFrame caller = STACK_WALKER.walk(frames ->
frames
.filter(frame -> className.equals(frame.getClassName()))
.filter(frame -> methodName.equals(frame.getMethodName()))
.findFirst()
.orElse(null)
);
return caller == null ? 0 : caller.getLineNumber();
}
private String extractClassName(String fullClassName) {
if (fullClassName == null) {
return "unknown";
}
// Remove package prefix
int lastDot = fullClassName.lastIndexOf('.');
if (lastDot > 0) {
return fullClassName.substring(lastDot + 1) + ".java";
}
return fullClassName + ".java";
}
}
}
stegosuite/src/main/java/org/stegosuite/logging/InfoHandler.java 0000664 0000000 0000000 00000001737 15260777315 0025376 0 ustar 00root root 0000000 0000000 package org.stegosuite.logging;
import java.io.PrintStream;
import java.util.logging.Filter;
import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.StreamHandler;
/**
* Handler for INFO level messages only (matches logback's infoLog appender).
*/
public class InfoHandler extends StreamHandler {
public InfoHandler() {
super(System.out, new SimpleFormatter());
setFilter(new InfoLevelFilter());
}
@Override
public void publish(LogRecord record) {
super.publish(record);
flush();
}
private static class InfoLevelFilter implements Filter {
@Override
public boolean isLoggable(LogRecord record) {
return record.getLevel() == Level.INFO;
}
}
private static class SimpleFormatter extends java.util.logging.Formatter {
@Override
public String format(LogRecord record) {
return record.getMessage() + "\n";
}
}
}
stegosuite/src/main/java/org/stegosuite/logging/WarnHandler.java 0000664 0000000 0000000 00000002006 15260777315 0025400 0 ustar 00root root 0000000 0000000 package org.stegosuite.logging;
import java.io.PrintStream;
import java.util.logging.Filter;
import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.StreamHandler;
/**
* Handler for WARN and ERROR level messages to stderr (matches logback's STDERR appender).
*/
public class WarnHandler extends StreamHandler {
public WarnHandler() {
super(System.err, new SimpleFormatter());
setFilter(new WarnLevelFilter());
}
@Override
public void publish(LogRecord record) {
super.publish(record);
flush();
}
private static class WarnLevelFilter implements Filter {
@Override
public boolean isLoggable(LogRecord record) {
return record.getLevel().intValue() >= Level.WARNING.intValue();
}
}
private static class SimpleFormatter extends java.util.logging.Formatter {
@Override
public String format(LogRecord record) {
return record.getMessage() + "\n";
}
}
}
stegosuite/src/main/java/org/stegosuite/model/ 0000775 0000000 0000000 00000000000 15260777315 0022004 5 ustar 00root root 0000000 0000000 stegosuite/src/main/java/org/stegosuite/model/exception/ 0000775 0000000 0000000 00000000000 15260777315 0024002 5 ustar 00root root 0000000 0000000 stegosuite/src/main/java/org/stegosuite/model/exception/SteganoEmbedException.java 0000664 0000000 0000000 00000000416 15260777315 0031062 0 ustar 00root root 0000000 0000000 package org.stegosuite.model.exception;
import java.io.Serial;
public class SteganoEmbedException extends Exception {
@Serial
private static final long serialVersionUID = 1L;
public SteganoEmbedException(String message) {
super(message);
}
}
stegosuite/src/main/java/org/stegosuite/model/exception/SteganoEncryptionException.java 0000664 0000000 0000000 00000000432 15260777315 0032176 0 ustar 00root root 0000000 0000000 package org.stegosuite.model.exception;
import java.io.Serial;
public class SteganoEncryptionException
extends SteganoExtractException {
@Serial
private static final long serialVersionUID = 1L;
public SteganoEncryptionException(String message) {
super(message);
}
}
stegosuite/src/main/java/org/stegosuite/model/exception/SteganoExtractException.java 0000664 0000000 0000000 00000000567 15260777315 0031467 0 ustar 00root root 0000000 0000000 package org.stegosuite.model.exception;
import java.io.Serial;
public class SteganoExtractException extends Exception {
@Serial
private static final long serialVersionUID = 1L;
public SteganoExtractException(String message) {
super(message);
}
public SteganoExtractException() {
super("Error: Could not extract. Wrong key?");
}
}
stegosuite/src/main/java/org/stegosuite/model/exception/SteganoImageException.java 0000664 0000000 0000000 00000000401 15260777315 0031062 0 ustar 00root root 0000000 0000000 package org.stegosuite.model.exception;
import java.io.Serial;
public class SteganoImageException
extends Exception {
@Serial
private static final long serialVersionUID = 1L;
public SteganoImageException(String message) {
super(message);
}
}
stegosuite/src/main/java/org/stegosuite/model/exception/SteganoKeyException.java 0000664 0000000 0000000 00000000462 15260777315 0030577 0 ustar 00root root 0000000 0000000 package org.stegosuite.model.exception;
import java.io.Serial;
public class SteganoKeyException extends SteganoExtractException {
@Serial
private static final long serialVersionUID = 1L;
public SteganoKeyException() {
super("Error: Could not extract. Probably wrong key.");
}
}
stegosuite/src/main/java/org/stegosuite/model/payload/ 0000775 0000000 0000000 00000000000 15260777315 0023435 5 ustar 00root root 0000000 0000000 stegosuite/src/main/java/org/stegosuite/model/payload/Payload.java 0000664 0000000 0000000 00000010307 15260777315 0025672 0 ustar 00root root 0000000 0000000 package org.stegosuite.model.payload;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.logging.Logger;
import org.stegosuite.model.payload.block.Block;
import org.stegosuite.util.ByteUtils;
/**
* This class is the outermost wrapper of the data that the user wants to embed or extract.
*/
public class Payload {
private static final Logger LOG = Logger.getLogger(Payload.class.getName());
/**
* The way processed bits are embedded and extracted, should be either ByteOrder.LITTLE_ENDIAN
* if LSB is at index 0, or ByteOrder.BIG_ENDIAN if LSB is at index 7
*/
public static final ByteOrder BYTE_ORDER = ByteOrder.BIG_ENDIAN;
/**
* The number bytes that contain the payload size. Valid values: 1 = 256 bytes total payload
* length; 2 = 64 KB total payload length; 3 = 16MB total payload length; 4 = 4 GB total payload
* length;
*/
public static final int LENGTH_NUM_BYTES = 3;
/**
* Default value if no stegano key is provided by user
*/
private String steganoPassword = "";
/**
* List of all blocks that are embedded/extracted
*/
private final List blocks = new ArrayList<>();
/**
* User-provided password for encryption and decryption. If it's null at embedding time, the
* payload will not be encrypted. If it is null at extraction time, it signals that the payload
* is assumed to be not encrypted. If the payload turns out to be encrypted but no encryption
* password is set, an exception is thrown.
*/
private String encryptionPassword = null;
/**
* Packs all blocks into a continuous byte stream (as in serialize)
*
* @return
*/
public byte[] pack() {
byte[][] blocksData = new byte[blocks.size()][];
for (int i = 0; i < blocks.size(); i++) {
byte[] blockData = blocks.get(i).pack();
byte[] blockSize = ByteUtils.intToBytes(blockData.length);
byte[] blockTypeFlag = { blocks.get(i).getIdentifier() };
blocksData[i] = ByteUtils.concat(
blockTypeFlag,
blockSize,
blockData
);
}
return ByteUtils.concat(blocksData);
}
/**
* Parses the byte stream and creates the original block instances (as in unserialize)
* Requires the block classes to have an empty constructor
*
* @param blocksData
*/
public void unpack(byte[] blocksData) {
int i = 0;
while (i < blocksData.length) {
byte blockTypeFlag = blocksData[i];
int blockSize = ByteBuffer.wrap(blocksData, i + 1, 4).getInt();
byte[] blockData = Arrays.copyOfRange(
blocksData,
i + 5,
i + 5 + blockSize
);
Class blockClass = Block.getBlockClass(
blockTypeFlag
);
try {
Block block = blockClass.getConstructor().newInstance();
block.unpack(blockData);
blocks.add(block);
} catch (Exception e) {
LOG.severe("Error unpacking data.");
}
i += 5 + blockSize;
}
}
public String getSteganoPassword() {
return steganoPassword;
}
public void setSteganoPassword(String steganoPassword) {
this.steganoPassword = steganoPassword;
}
public List getBlocks() {
return blocks;
}
public String getEncryptionPassword() {
return encryptionPassword;
}
public void setEncryptionPassword(String encryptionPassword) {
this.encryptionPassword = encryptionPassword;
}
public void removeBlock(Block aBlock) {
blocks.remove(aBlock);
}
public void setPassword(String password) {
setSteganoPassword(password);
setEncryptionPassword(password);
}
public void addBlock(Block block) {
getBlocks().add(block);
}
public Block getBlock(int blockIndex) {
return getBlocks().get(blockIndex);
}
public boolean hasNoBlocks() {
return getBlocks().isEmpty();
}
}
stegosuite/src/main/java/org/stegosuite/model/payload/PayloadEmbedder.java 0000664 0000000 0000000 00000007353 15260777315 0027331 0 ustar 00root root 0000000 0000000 package org.stegosuite.model.payload;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.text.DecimalFormat;
import java.util.Arrays;
import java.util.logging.Logger;
import org.stegosuite.model.exception.SteganoEmbedException;
import org.stegosuite.util.ByteUtils;
import org.stegosuite.util.CompressionUtils;
import org.stegosuite.util.CryptoUtils;
public class PayloadEmbedder {
private static final Logger LOG = Logger.getLogger(
PayloadEmbedder.class.getName()
);
private static final DecimalFormat DECIMAL = new DecimalFormat("#0.000");
/**
* The raw data stream that should be embedded into the image
*/
private byte[] data = null;
/**
* Constructor
* @param payload The payload instance that hold the data to be embedded
* @param capacity capacity according to the embeddingMethod
* @throws SteganoEmbedException
*/
public PayloadEmbedder(Payload payload, int capacity)
throws SteganoEmbedException {
if (payload.hasNoBlocks()) {
throw new SteganoEmbedException("No data to embed");
}
byte[] packed = payload.pack();
LOG.fine("Packing " + packed.length + " bytes of payload");
try {
packed = CompressionUtils.compress(packed);
} catch (IOException e) {
throw new SteganoEmbedException("Error while compressing data");
}
if (payload.getEncryptionPassword() == null) {
payload.setEncryptionPassword("");
}
try {
packed = CryptoUtils.encrypt(
packed,
payload.getEncryptionPassword()
);
} catch (Exception e) {
throw new SteganoEmbedException(e.getMessage());
}
// Prepend header
data = ByteUtils.concat(new byte[Payload.LENGTH_NUM_BYTES], packed);
// Check if we crossed the maximum supported payload size
int maxPayloadLength = (int) Math.pow(2, Payload.LENGTH_NUM_BYTES * 8);
if (data.length > maxPayloadLength) {
throw new SteganoEmbedException(
String.format(
"Payload is too large. Limit is %d bytes but got %d bytes.",
maxPayloadLength,
data.length
)
);
}
if (data.length > capacity) {
throw new SteganoEmbedException(
String.format(
"Payload is too large. Maximum capacity for this carrier file is %d bytes but payload is %d bytes.",
capacity,
data.length
)
);
}
// Fill header with length and encryption flag
byte[] lengthBytes = Arrays.copyOfRange(
ByteUtils.intToBytes(data.length),
4 - Payload.LENGTH_NUM_BYTES,
4
);
data = ByteBuffer.wrap(data).put(lengthBytes).array();
LOG.fine(() -> "lengthBytes-Array: " + Arrays.toString(lengthBytes));
LOG.fine(() -> "data-Array: " + Arrays.toString(data));
Double percentage = (data.length * 100.0) / capacity;
LOG.fine(
() ->
"Packed payload to " +
data.length +
" bytes, " +
DECIMAL.format(percentage) +
"% of total capacity"
);
}
/**
* Returns in Iterable that yields all bits of the serialized payload
*
* @return
*/
public Iterable iteratePayloadBits() {
return ByteUtils.iterateBits(data, Payload.BYTE_ORDER);
}
/**
* Returns the compiled payload bytes that should be embedded
*
* @return
*/
public byte[] getPayloadBytes() {
return data;
}
}
stegosuite/src/main/java/org/stegosuite/model/payload/PayloadExtractor.java 0000664 0000000 0000000 00000013765 15260777315 0027601 0 ustar 00root root 0000000 0000000 package org.stegosuite.model.payload;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.Arrays;
import java.util.logging.Logger;
import org.stegosuite.model.exception.SteganoEncryptionException;
import org.stegosuite.model.exception.SteganoExtractException;
import org.stegosuite.model.exception.SteganoKeyException;
import org.stegosuite.util.ByteUtils;
import org.stegosuite.util.CompressionUtils;
import org.stegosuite.util.CryptoUtils;
public class PayloadExtractor {
private static final Logger LOG = Logger.getLogger(
PayloadExtractor.class.getName()
);
/**
* The payload instance that should be populated with the extracted data
*/
private final Payload payload;
/**
* Array of 4 bytes containing the total message length
*/
private byte[] dataSizeBytes = new byte[] { 0, 0, 0, 0 };
/**
*
*/
private Integer payloadLength = null;
/**
* Buffer that holds the bytes that are extracted after reading the message length
*/
private byte[] data = new byte[0];
/**
* Current position of the dataSize array
*/
private int dataSizePos = 4 - Payload.LENGTH_NUM_BYTES;
/**
* Buffer that holds the bits
*/
private final byte[] bits = new byte[8];
/**
* Current position of the bit
*/
private int dataSizeBitPos = 0;
/**
* Current position of the data array
*/
private int dataPos = 0;
/**
* Constructor
*
* @param payload The payload instance that should be populated with the extracted data
*/
public PayloadExtractor(Payload payload) {
this.payload = payload;
}
/**
* Signals whether the reader has processed all the data. If finished() returns true, (optional)
* decryption and decompression is applied and the payload instance is fed with the extracted
* data
*
* @return true if the payload instance is successfully populated with the extracted data
* @throws SteganoExtractException
*/
public boolean finished() throws SteganoExtractException {
boolean finished = dataPos > 0 && dataPos == data.length;
if (finished && dataSizeBytes != null) {
LOG.fine(
() ->
"Unpacking payload from " +
ByteBuffer.wrap(dataSizeBytes).getInt() +
" extracted bytes"
);
byte[] payloadBytes = Arrays.copyOfRange(data, 0, data.length);
if (payload.getEncryptionPassword() == null) {
payload.setEncryptionPassword("");
}
try {
payloadBytes = CryptoUtils.decrypt(
payloadBytes,
payload.getEncryptionPassword()
);
} catch (Exception e) {
LOG.fine(e.getMessage());
throw new SteganoEncryptionException(
"Wrong decryption password."
);
}
try {
payloadBytes = CompressionUtils.decompress(payloadBytes);
} catch (IOException e) {
throw new SteganoKeyException();
}
LOG.fine("Unpacked " + payloadBytes.length + " bytes of payload");
payload.unpack(payloadBytes);
dataSizeBytes = null;
}
return finished;
}
/**
* Processes the bytes extracted from a steganogram and stores them in the internal buffer
*
* @param b
* @throws SteganoExtractException
*/
public void processByte(byte b) throws SteganoExtractException {
if (finished()) {
return;
}
if (dataSizeBitPos != 0) {
throw new SteganoExtractException(
"Cannot process byte while processing bits"
);
}
if (dataSizePos < 4) {
dataSizeBytes[dataSizePos] = b;
if (dataSizePos == 3) {
// The bytes containing the payload length have been processed,
// initialize main buffer for the encryption flag and the whole
// payload.
payloadLength =
ByteBuffer.wrap(dataSizeBytes).getInt() -
Payload.LENGTH_NUM_BYTES;
// If (dataSize minus encryption flag byte) is negative it's a
// strong indicator that the stegano password was wrong
if (payloadLength - 1 < 0) {
throw new SteganoKeyException();
}
LOG.fine(
() ->
"Payload of " +
(payloadLength + Payload.LENGTH_NUM_BYTES) +
" bytes to be extracted"
);
LOG.fine(() -> "Array: " + Arrays.toString(dataSizeBytes));
data = new byte[payloadLength];
dataPos = 0;
}
dataSizePos++;
} else {
data[dataPos++] = b;
}
}
/**
* Processes the bits extracted from a steganogram and stores them in the internal buffer
*
* @param bit
* @throws SteganoExtractException
*/
public void processBit(byte bit) throws SteganoExtractException {
if (finished()) {
return;
}
bits[dataSizeBitPos] = bit;
if ((dataSizeBitPos = ++dataSizeBitPos % 8) == 0) {
processByte(ByteUtils.bitsToByte(bits, Payload.BYTE_ORDER));
}
}
/**
* Returns the total number of bytes that the extractor needs to process. Note that this method
* returns {@link null} if called until the extractor has processed at least
* Payload.LENGTH_NUM_BYTES bytes.
*
* @return
*/
public Integer getPayloadLength() {
return payloadLength;
}
/**
* Returns the number of currently processed bytes
*
* @return
*/
public int getProcessedBytesCount() {
return dataPos + dataSizePos - Payload.LENGTH_NUM_BYTES;
}
}
stegosuite/src/main/java/org/stegosuite/model/payload/block/ 0000775 0000000 0000000 00000000000 15260777315 0024527 5 ustar 00root root 0000000 0000000 stegosuite/src/main/java/org/stegosuite/model/payload/block/Block.java 0000664 0000000 0000000 00000002235 15260777315 0026426 0 ustar 00root root 0000000 0000000 package org.stegosuite.model.payload.block;
import java.util.HashMap;
import java.util.Map;
/**
* The payload is composed of blocks. It can contain an arbitrary number of blocks. Each concrete
* type of block must extend this class, and in addition must provide its own unique identifier.
*/
public abstract class Block {
/**
* This map keeps track of all available block types
*/
private static final Map> identifiers = new HashMap<>();
static {
identifiers.put(FileBlock.IDENTIFIER, FileBlock.class);
identifiers.put(MessageBlock.IDENTIFIER, MessageBlock.class);
}
public static Class getBlockClass(byte identifier) {
return identifiers.get(identifier);
}
/**
* Returns the individual identifier for the block type
*
*/
public abstract byte getIdentifier();
/**
* Packs the Block's data into a byte stream
*
*/
public abstract byte[] pack();
/**
* Unpacks a byte stream and populates the Block implementation's data fields
*
* @param data
*/
public abstract void unpack(byte[] data);
public boolean hasIdentifier(byte identifier) {
return getIdentifier() == identifier;
}
}
stegosuite/src/main/java/org/stegosuite/model/payload/block/FileBlock.java 0000664 0000000 0000000 00000004745 15260777315 0027236 0 ustar 00root root 0000000 0000000 package org.stegosuite.model.payload.block;
import org.stegosuite.util.ByteUtils;
import org.stegosuite.util.FileUtils;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;
import static java.nio.file.StandardOpenOption.CREATE;
/**
* This block contains the contents of a file as well as its file name
*/
public final class FileBlock
extends Block {
/**
* Mandatory empty constructor
* @see org.stegosuite.model.payload.Payload#unpack(byte[])
*/
@SuppressWarnings("unused")
public FileBlock() {}
/**
* Unique number among all Block implementations
*/
public static final byte IDENTIFIER = 1;
/**
* Contains the file name without path
*/
private String fileName = null;
/**
* Contains the bytes of the file
*/
private byte[] fileContent = null;
public FileBlock(String fileName) {
this.fileName = fileName;
try {
fileContent = Files.readAllBytes(new File(fileName).toPath());
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public byte getIdentifier() {
return IDENTIFIER;
}
@Override
public byte[] pack() {
byte[] fileNameWithoutPath = new File(fileName).getName().getBytes(StandardCharsets.UTF_8);
byte[] fileNameLength = ByteUtils.intToBytes(fileNameWithoutPath.length);
return ByteUtils.concat(fileNameLength, fileNameWithoutPath, fileContent);
}
@Override
public void unpack(byte[] data) {
int fileNameLength = ByteBuffer.wrap(data).getInt();
fileName = new String(Arrays.copyOfRange(data, 4, 4 + fileNameLength));
fileContent = Arrays.copyOfRange(data, 4 + fileNameLength, data.length);
}
public String getFileName() {
return fileName;
}
public byte[] getFileContent() {
return fileContent;
}
public long getSize() {
return FileUtils.getFileSize(fileName);
}
public boolean hasPath(String filename) {
String blockFilename = Paths.get(fileName).getFileName().toString();
return filename.equals(blockFilename);
}
public void saveFileTo(String extractionPath) {
try {
writeContentToFileIn(extractionPath);
// Update the filename, so that we can compute the file size later
fileName = extractionPath;
} catch (IOException e) {
e.printStackTrace();
}
}
private void writeContentToFileIn(String extractionPath) throws IOException {
Path path = Paths.get(extractionPath);
Files.write(path, fileContent, CREATE);
}
}
stegosuite/src/main/java/org/stegosuite/model/payload/block/MessageBlock.java 0000664 0000000 0000000 00000001517 15260777315 0027735 0 ustar 00root root 0000000 0000000 package org.stegosuite.model.payload.block;
import java.nio.charset.StandardCharsets;
/**
* This block contains a simple text message
*/
public final class MessageBlock
extends Block {
/**
* Unique number among all Block implementations
*/
public static final byte IDENTIFIER = 2;
private String message = null;
/**
* Mandatory empty constructor
* @see org.stegosuite.model.payload.Payload#unpack(byte[])
*/
@SuppressWarnings("unused")
public MessageBlock() {}
public MessageBlock(String message) {
this.message = message;
}
@Override
public byte getIdentifier() {
return IDENTIFIER;
}
@Override
public byte[] pack() {
return message.getBytes(StandardCharsets.UTF_8);
}
@Override
public void unpack(byte[] data) {
message = new String(data);
}
public String getMessage() {
return message;
}
}
stegosuite/src/main/java/org/stegosuite/ui/ 0000775 0000000 0000000 00000000000 15260777315 0021321 5 ustar 00root root 0000000 0000000 stegosuite/src/main/java/org/stegosuite/ui/cli/ 0000775 0000000 0000000 00000000000 15260777315 0022070 5 ustar 00root root 0000000 0000000 stegosuite/src/main/java/org/stegosuite/ui/cli/Cli.java 0000664 0000000 0000000 00000015143 15260777315 0023446 0 ustar 00root root 0000000 0000000 package org.stegosuite.ui.cli;
import java.io.File;
import java.util.List;
import java.util.logging.Logger;
import org.eclipse.swt.graphics.ImageData;
import org.stegosuite.application.StegosuitePresenter;
import org.stegosuite.application.StegosuiteUI;
import org.stegosuite.image.embedding.EmbeddingProgress;
import org.stegosuite.image.embedding.Visualizer;
import org.stegosuite.image.format.ImageFormat;
import org.stegosuite.model.exception.SteganoEmbedException;
import org.stegosuite.model.exception.SteganoExtractException;
import org.stegosuite.model.exception.SteganoImageException;
import org.stegosuite.ui.gui.ImageUtils;
import org.stegosuite.util.FileUtils;
public class Cli implements StegosuiteUI {
private static final Logger LOG = Logger.getLogger(Cli.class.getName());
private StegosuitePresenter presenter;
public int embed(
File steganogram,
String message,
List filesToBeEmbedded,
String key,
boolean noNoise,
File outputPath
) {
if (!steganogram.exists()) {
LOG.severe(
() -> "Error: Image does not exist: " + steganogram.getPath()
);
return 1;
}
if (!steganogram.canRead()) {
LOG.severe(
() -> "Error: Can't read image: " + steganogram.getPath()
);
return 1;
}
if (!validImageFormat(steganogram.getPath())) return 1;
if (message == null && filesToBeEmbedded == null) {
LOG.severe(
"Error: Nothing to embed. Use -m or -f to embed a message or files."
);
return 2;
}
pointFilter(noNoise);
if (message != null) {
presenter.addMessageToPayload(message);
}
if (filesToBeEmbedded != null) {
for (File f : filesToBeEmbedded) {
if (!f.exists()) {
LOG.severe(() -> "Error: Can't find file: " + f.getPath());
return 1;
}
if (!f.canRead()) {
LOG.severe(() -> "Error: Can't read file: " + f.getPath());
return 1;
}
presenter.addFileToPayload(f.getPath());
}
}
File my_outputPath;
if (outputPath == null) {
my_outputPath = new File(
FileUtils.addFileNameSuffix(steganogram.getPath(), "_embed")
);
} else {
my_outputPath = outputPath;
}
try {
embed(key, my_outputPath);
return 0;
} catch (SteganoEmbedException e) {
LOG.severe(e.getMessage());
return 1;
}
}
private void embed(String key, File outputPath)
throws SteganoEmbedException {
LOG.info("Embedding data...");
presenter.embedNotifying(new EmbeddingProgress(), key, outputPath);
}
public int extract(File steganogram, String key, boolean noNoise) {
if (!steganogram.exists()) {
LOG.severe(
() -> "Error: Image does not exist: " + steganogram.getPath()
);
return 1;
}
if (!steganogram.canRead()) {
LOG.severe(
() -> "Error: Can't read image: " + steganogram.getPath()
);
return 1;
}
if (!validImageFormat(steganogram.getPath())) return 1;
pointFilter(noNoise);
try {
extract(key);
return 0;
} catch (SteganoExtractException e) {
LOG.severe(e.getMessage());
return 1;
}
}
private void extract(String key) throws SteganoExtractException {
LOG.info("Extracting data...");
presenter.extractNotifying(new EmbeddingProgress(), key);
}
public int capacity(File steganogram, boolean noNoise) {
if (!steganogram.exists()) {
LOG.severe(
() -> "Error: Image does not exist: " + steganogram.getPath()
);
return 1;
}
if (!steganogram.canRead()) {
LOG.severe(
() -> "Error: Can't read image: " + steganogram.getPath()
);
return 1;
}
if (!validImageFormat(steganogram.getPath())) return 1;
pointFilter(noNoise);
int capacity = presenter.getEmbeddingCapacity();
LOG.info(() -> "Capacity: " + ImageUtils.formatSize(capacity));
return 0;
}
private void pointFilter(Boolean noNoise) {
if (noNoise) {
presenter.setPointFilter(0);
} else {
presenter.setPointFilter(1);
}
}
private boolean validImageFormat(String steganogramPath) {
ImageFormat image = getImageFormat(steganogramPath);
if (image == null) {
showFormatNotSupportedError();
return false;
}
presenter = new StegosuitePresenter(image, this);
return true;
}
private ImageFormat getImageFormat(String steganogramPath) {
try {
return ImageFormat.getImageFormat(steganogramPath);
} catch (SteganoImageException e) {
e.printStackTrace();
return null;
}
}
private void showFormatNotSupportedError() {
LOG.severe(
() ->
"Error: Currently only these file types are supported: " +
supportedFormats()
);
}
private String supportedFormats() {
return String.join(", ", ImageFormat.getSupportedFormats());
}
@Override
public void showEmbeddingError(SteganoEmbedException e) {
// Error will be logged by the catch block in embed()
}
@Override
public void showExtractingError(SteganoExtractException e) {
// Error will be logged by the catch block in extract()
}
@Override
public void extractingCompleted(
String extractedMessage,
List filePaths,
Visualizer visualizer,
ImageData imageData
) {
LOG.info("Extracting completed");
if (extractedMessage != null) {
LOG.info(() -> "Extracted message: " + extractedMessage);
}
if (!filePaths.isEmpty()) {
for (String string : filePaths) {
LOG.info(() -> "Extracted file saved to " + string);
}
}
}
@Override
public void embeddingCompleted(
ImageFormat embeddedImage,
String outputPath,
Visualizer visualizer
) {}
@Override
public void addPayloadFile(
String filename,
String extension,
long fileSize
) {}
}
stegosuite/src/main/java/org/stegosuite/ui/gui/ 0000775 0000000 0000000 00000000000 15260777315 0022105 5 ustar 00root root 0000000 0000000 stegosuite/src/main/java/org/stegosuite/ui/gui/EmbedUi.java 0000664 0000000 0000000 00000043456 15260777315 0024276 0 ustar 00root root 0000000 0000000 package org.stegosuite.ui.gui;
import java.util.List;
import java.util.Optional;
import java.util.ResourceBundle;
import java.util.logging.Logger;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.dnd.DND;
import org.eclipse.swt.dnd.DropTarget;
import org.eclipse.swt.dnd.DropTargetAdapter;
import org.eclipse.swt.dnd.DropTargetEvent;
import org.eclipse.swt.dnd.FileTransfer;
import org.eclipse.swt.events.KeyAdapter;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.graphics.Cursor;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.ImageData;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.program.Program;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.FileDialog;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.MenuItem;
import org.eclipse.swt.widgets.MessageBox;
import org.eclipse.swt.widgets.ProgressBar;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableColumn;
import org.eclipse.swt.widgets.TableItem;
import org.eclipse.swt.widgets.Text;
import org.stegosuite.application.EmbeddingProgressObserver;
import org.stegosuite.application.StegosuitePresenter;
import org.stegosuite.application.StegosuiteUI;
import org.stegosuite.image.embedding.EmbeddingProgress;
import org.stegosuite.image.embedding.Visualizer;
import org.stegosuite.image.format.ImageFormat;
import org.stegosuite.model.exception.SteganoEmbedException;
import org.stegosuite.model.exception.SteganoExtractException;
import org.stegosuite.model.payload.block.FileBlock;
import org.stegosuite.ui.gui.ImageContainer.ImageState;
/**
* Contains the GUI for embedding/extracting data.
*/
public class EmbedUi implements StegosuiteUI {
private Composite compositeImage;
private Text passwordField;
private Button checkBoxVisualize;
private ImageContainer imageContainer;
private Label imageLabel, payloadFileCounter, payloadFileSize;
private int fileSizeSum = 0;
private Button embedButton, extractButton;
private Cursor cursor;
private ProgressBar progressBar;
private Table fileTable;
private StyledText messageField;
private final Composite composite;
private static final Logger LOG = Logger.getLogger(EmbedUi.class.getName());
private final ResourceBundle L = ResourceBundle.getBundle("Messages");
private StegosuitePresenter presenter;
public EmbedUi(Composite composite, GuiComponents components) {
this.composite = composite;
initializeGui(components);
}
private void initializeGui(GuiComponents components) {
composite.setLayout(new FillLayout());
Composite compositeControls = components.createControlsComposite(
composite
);
Composite fileEmbedding = components.createFileEmbedding(
compositeControls
);
messageField = (StyledText) compositeControls.getChildren()[0];
fileTable = (Table) fileEmbedding.getChildren()[2];
payloadFileCounter = (Label) fileEmbedding.getChildren()[0];
payloadFileSize = (Label) fileEmbedding.getChildren()[1];
passwordField = components.createPasswordField(compositeControls);
embedButton = components.createMainButton(
compositeControls,
L.getString("embed_button")
);
extractButton = components.createMainButton(
compositeControls,
L.getString("extract_button")
);
((GridData) extractButton.getLayoutData()).horizontalAlignment =
SWT.END;
compositeImage = components.createImageComposite(composite);
imageLabel = new Label(compositeImage, SWT.NONE);
imageLabel.setLayoutData(
new GridData(SWT.BEGINNING, SWT.BEGINNING, false, false)
);
compositeImage.addListener(SWT.Resize, event -> {
if (imageLabel.getImage() != null) {
imageLabel.setImage(imageContainer.scaleImage());
compositeImage.layout(true, true);
}
});
final DropTarget dropTarget = new DropTarget(fileTable, DND.DROP_MOVE);
dropTarget.setTransfer(FileTransfer.getInstance());
dropTarget.addDropListener(
new DropTargetAdapter() {
@Override
public void drop(final DropTargetEvent event) {
final String[] filenames = (String[]) event.data;
String filename = filenames[0];
if (filename != null) {
presenter.addFileToPayload(filename);
}
}
}
);
Menu menu = new Menu(composite.getShell(), SWT.POP_UP);
fileTable.setMenu(menu);
MenuItem deleteFileMenu = new MenuItem(menu, SWT.PUSH);
deleteFileMenu.setText(L.getString("files_menu_delete"));
deleteFileMenu.addListener(SWT.Selection, event ->
removeSelectedPayloadFile()
);
MenuItem addFileMenu = new MenuItem(menu, SWT.PUSH);
addFileMenu.setText(L.getString("files_menu_add"));
addFileMenu.addListener(SWT.Selection, event -> {
final FileDialog dlg = new FileDialog(
composite.getShell(),
SWT.OPEN
);
final String filePath = dlg.open();
if (filePath != null) {
presenter.addFileToPayload(filePath);
}
});
fileTable.addKeyListener(
new KeyAdapter() {
@Override
public void keyReleased(final KeyEvent e) {
if (e.keyCode == SWT.DEL) {
removeSelectedPayloadFile();
}
}
}
);
embedButton.addListener(SWT.Selection, event -> {
startEmbedding(compositeControls);
});
extractButton.addListener(SWT.Selection, event -> {
startExtraction(compositeControls);
});
}
private void startEmbedding(Composite compositeControls) {
progressBar = new ProgressBar(compositeControls, SWT.SMOOTH);
progressBar.setSelection(0);
GridData data = new GridData(SWT.FILL, SWT.BEGINNING, true, false);
data.horizontalSpan = 2;
progressBar.setLayoutData(data);
compositeControls.layout(true, true);
adjustWindowSize();
Gui.setStatusBarMsg("Embedding data...");
embedButton.setEnabled(false);
cursor = new Cursor(Display.getDefault(), SWT.CURSOR_WAIT);
composite.getShell().setCursor(cursor);
EmbeddingProgress progress = new EmbeddingProgress();
new EmbeddingProgressObserver(progressBar, progress);
String message = messageField.getText();
String password = getEnteredPassword();
presenter.addMessageToPayload(message);
runInNewThread(() -> {
try {
presenter.embedNotifying(progress, password, null);
} catch (SteganoEmbedException e) {
// Error is already shown via ui.showEmbeddingError
}
});
}
private void startExtraction(Composite compositeControls) {
progressBar = new ProgressBar(compositeControls, SWT.SMOOTH);
progressBar.setSelection(0);
GridData data = new GridData(SWT.FILL, SWT.BEGINNING, true, false);
data.horizontalSpan = 2;
progressBar.setLayoutData(data);
compositeControls.layout(true, true);
adjustWindowSize();
EmbeddingProgress progress = new EmbeddingProgress();
new EmbeddingProgressObserver(progressBar, progress);
Gui.setStatusBarMsg("Extracting data...");
extractButton.setEnabled(false);
cursor = new Cursor(Display.getDefault(), SWT.CURSOR_WAIT);
composite.getShell().setCursor(cursor);
String password = getEnteredPassword();
runInNewThread(() -> {
try {
presenter.extractNotifying(progress, password);
} catch (SteganoExtractException e) {
// Error is already shown via ui.showExtractingError
}
});
}
private String getEnteredPassword() {
if (passwordField.getText().isEmpty()) {
return null;
} else {
return passwordField.getText();
}
}
private void runInNewThread(Runnable runnable) {
new Thread(runnable).start();
}
@Override
public void showEmbeddingError(SteganoEmbedException e) {
displayError("Embedding aborted.", embedButton, e.getMessage());
}
@Override
public void showExtractingError(SteganoExtractException e) {
displayError("Extracting aborted.", extractButton, e.getMessage());
}
@Override
public void extractingCompleted(
String extractedMessage,
List filePaths,
Visualizer visualizer,
ImageData imageData
) {
runInGuiThread(() -> {
messageField.setText(extractedMessage);
String status = "Extracting completed.";
if (!filePaths.isEmpty()) {
status +=
" Extracted file saved to " +
filePaths.get(filePaths.size() - 1);
}
Gui.setStatusBarMsg(status);
imageContainer.setImageData(ImageState.STEG, imageData);
if (visualizer != null) {
imageContainer.setImageData(
ImageState.STEG_VISUALIZED,
visualizer.getImageData()
);
}
extractButton.setEnabled(true);
updateVisualizationCheckbox();
cursor = new Cursor(Display.getDefault(), SWT.CURSOR_ARROW);
compositeImage.getShell().setCursor(cursor);
progressBar.dispose();
});
}
private void runInGuiThread(Runnable runnable) {
Display.getDefault().asyncExec(runnable);
}
@Override
public void embeddingCompleted(
ImageFormat embeddedImage,
String outputPath,
Visualizer visualizer
) {
runInGuiThread(() -> {
imageContainer.setImageData(
ImageState.STEG,
embeddedImage.getImageData()
);
if (visualizer != null) {
imageContainer.setImageData(
ImageState.STEG_VISUALIZED,
visualizer.getImageData()
);
}
Gui.setStatusBarMsg(
"Embedding completed. File saved to " + outputPath
);
embedButton.setEnabled(true);
imageLabel.setImage(imageContainer.scaleImage(ImageState.STEG));
updateVisualizationCheckbox();
compositeImage.layout(true, true);
presenter.clearPayload();
fileTable.clearAll();
fileTable.setItemCount(0);
fileSizeSum = 0;
payloadFileSize.setText("");
updateFilesCount();
cursor = new Cursor(Display.getDefault(), SWT.CURSOR_ARROW);
compositeImage.getShell().setCursor(cursor);
progressBar.dispose();
});
}
private void displayError(
String statusBarMessage,
Button actionButton,
String message
) {
runInGuiThread(() -> {
MessageBox dialog = new MessageBox(
composite.getShell(),
SWT.ICON_ERROR | SWT.OK
);
dialog.setText("Error");
dialog.setMessage(message);
dialog.open();
actionButton.setEnabled(true);
cursor = new Cursor(Display.getDefault(), SWT.CURSOR_ARROW);
compositeImage.getShell().setCursor(cursor);
progressBar.dispose();
Gui.setStatusBarMsg(statusBarMessage);
});
}
/**
* Loads an image from the given path, displays it and start capacity- and noise-calculations.
*
* @param image The image to load
*/
void loadImage(ImageFormat image) {
presenter = new StegosuitePresenter(image, this);
embedButton.setEnabled(false);
extractButton.setEnabled(false);
imageContainer = new ImageContainer(compositeImage);
Image img = imageContainer.loadImage(image.getImageData());
imageLabel.setImage(img);
imageLabel.setToolTipText(image.getFilePath());
messageField.setEnabled(true);
messageField.setText("");
passwordField.setText("");
fileTable.clearAll();
fileTable.setItemCount(0);
payloadFileSize.setText("");
fileSizeSum = 0;
updateFilesCount();
presenter.clearPayload();
updateVisualizationCheckbox();
compositeImage.layout(true, true);
Gui.setStatusBarMsg("Searching for homogeneous areas in the image...");
cursor = new Cursor(Display.getDefault(), SWT.CURSOR_WAIT);
passwordField.getParent().setCursor(cursor);
passwordField.getParent().layout(true, true);
runInNewThread(() -> {
int capacity = presenter.getEmbeddingCapacity();
runInGuiThread(() -> {
Gui.setStatusBarMsg(
L.getString("statusbar_capacity") +
": " +
ImageUtils.formatSize(capacity),
String.format("%d Bytes", capacity)
);
embedButton.setEnabled(true);
extractButton.setEnabled(true);
cursor = new Cursor(Display.getDefault(), SWT.CURSOR_ARROW);
passwordField.getParent().setCursor(cursor);
});
});
}
private void updateVisualizationCheckbox() {
if (imageContainer.getImageData(ImageState.STEG_VISUALIZED) != null) {
if (checkBoxVisualize == null || checkBoxVisualize.isDisposed()) {
checkBoxVisualize = new Button(compositeImage, SWT.CHECK);
checkBoxVisualize.setText(L.getString("visualize_checkbox"));
checkBoxVisualize.addListener(SWT.Selection, event2 -> {
ImageState state = checkBoxVisualize.getSelection()
? ImageState.STEG_VISUALIZED
: ImageState.STEG;
imageLabel.setImage(imageContainer.scaleImage(state));
});
} else {
checkBoxVisualize.setSelection(false);
}
} else {
if (checkBoxVisualize != null) {
checkBoxVisualize.dispose();
}
}
}
private void adjustWindowSize() {
final Point newSize = passwordField
.getShell()
.computeSize(
passwordField.getShell().getSize().x,
SWT.DEFAULT,
true
);
if (newSize.y > passwordField.getShell().getSize().y) {
passwordField.getShell().setSize(newSize);
}
}
@Override
public void addPayloadFile(
String filename,
String extension,
long fileSize
) {
runInGuiThread(() -> {
fileSizeSum += (int) fileSize;
addTableItemForFile(filename, fileSize, systemIconFor(extension));
updateFilesCount();
updateTotalFilesSize(fileSizeSum);
redrawFilesTable();
});
}
private void updateFilesCount() {
payloadFileCounter.setText(
fileTable.getItemCount() + " " + L.getString("files_text")
);
}
private void redrawFilesTable() {
for (TableColumn column : fileTable.getColumns()) {
column.pack();
}
payloadFileSize.getParent().layout(true, true);
}
private void updateTotalFilesSize(int fileSizeSum) {
payloadFileSize.setText(ImageUtils.formatSize(fileSizeSum));
}
private static Optional systemIconFor(String extension) {
return Optional.ofNullable(Program.findProgram(extension))
.map(program -> program.getImageData())
.map(data -> new Image(Display.getDefault(), data));
}
private void addTableItemForFile(
String filename,
long fileSize,
Optional icon
) {
TableItem item = new TableItem(fileTable, SWT.NONE);
item.setText(filename);
item.setText(1, ImageUtils.formatSize(fileSize));
item.setForeground(
1,
Display.getDefault().getSystemColor(SWT.COLOR_GRAY)
);
icon.ifPresent(image -> item.setImage(image));
}
private void removeSelectedPayloadFile() {
if (aFileIsSelected()) {
String selectedFilename = getSelectedFilename();
fileTable.remove(fileTable.getSelectionIndex());
// FIXME: If two files with the same name are added (being both the same file or not),
// all occurrences are deleted internally, but only one is deleted on the ui table
presenter
.payloadFileBlocksWithFilename(selectedFilename)
.forEach(this::removeFileBlock);
updateFilesCount();
payloadFileSize.getParent().layout(true, true);
}
}
private String getSelectedFilename() {
TableItem selectedItem = fileTable.getItem(
fileTable.getSelectionIndex()
);
return selectedItem.getText();
}
private boolean aFileIsSelected() {
return (
fileTable.getItemCount() > 0 && fileTable.getSelectionIndex() >= 0
);
}
private void removeFileBlock(FileBlock fileBlock) {
fileSizeSum -= (int) fileBlock.getSize();
updateTotalFilesSize(fileSizeSum);
presenter.removeBlock(fileBlock);
LOG.fine("File-block removed.");
}
}
stegosuite/src/main/java/org/stegosuite/ui/gui/Gui.java 0000664 0000000 0000000 00000014166 15260777315 0023504 0 ustar 00root root 0000000 0000000 package org.stegosuite.ui.gui;
import org.eclipse.swt.SWT;
import org.eclipse.swt.dnd.*;
import org.eclipse.swt.graphics.*;
import org.eclipse.swt.layout.FormAttachment;
import org.eclipse.swt.layout.FormData;
import org.eclipse.swt.layout.FormLayout;
import org.eclipse.swt.widgets.*;
import org.stegosuite.image.format.ImageFormat;
import org.stegosuite.model.exception.SteganoImageException;
import java.util.ResourceBundle;
/**
* Base class for the GUI. Contains global GUI-elements and global listeners.
*/
public class Gui {
private final Display display;
private final Shell shell;
private final GuiComponents guiComponents;
private Composite composite;
private static Label statusBar;
private final ResourceBundle L = ResourceBundle.getBundle("Messages");
private int borderAlpha = 50;
private String imagePath = null;
public Gui(String path) {
display = new Display();
guiComponents = new GuiComponents();
shell = guiComponents.createShell(display);
Menu menuBar = guiComponents.createMenuBar(shell);
if (path != null) {
imagePath = path;
} else {
shell.addListener(SWT.Paint, event -> drawBorder(event, borderAlpha));
showStartScreen();
}
// Drag and drop files into the window to load them
final DropTarget dropTarget = new DropTarget(shell, DND.DROP_MOVE);
dropTarget.setTransfer(FileTransfer.getInstance());
dropTarget.addDropListener(new DropTargetAdapter() {
@Override
public void drop(final DropTargetEvent event) {
final String[] filenames = (String[]) event.data;
loadImages(filenames[0]);
}
public void dragEnter(final DropTargetEvent event) {
borderAlpha = 250;
shell.redraw();
}
public void dragLeave(final DropTargetEvent event) {
borderAlpha = 50;
shell.redraw();
}
});
// when user clicks in menubar on "Load file", open a file dialog
menuBar.getItem(0).getMenu().getItem(0).addListener(SWT.Selection, event -> openFileDialog());
shell.setMenuBar(menuBar);
startEventLoop();
}
private void openFileDialog() {
final String[] FILTER_NAMES = { "All supported files (*.bmp/*.gif/*.jpg/*.png)", "BMP-Files (*.bmp)",
"GIF-Files (*.gif)", "JPG-Files (*.jpg)", "PNG-Files (*.png)" };
final String[] FILTER_EXTS = { "*.bmp;*.gif;*.jpg;*.png", "*.bmp", "*.gif", "*.jpg", "*.png" };
FileDialog dlg = new FileDialog(shell, SWT.OPEN);
dlg.setFilterNames(FILTER_NAMES);
dlg.setFilterExtensions(FILTER_EXTS);
loadImages(dlg.open());
}
private void startEventLoop() {
// Display Window in the middle of screen
final Rectangle bds = display.getBounds();
final Point p = shell.getSize();
final int nLeft = (bds.width - p.x) / 2;
final int nTop = (bds.height - p.y) / 2;
shell.setBounds(nLeft, nTop, p.x, p.y);
// ======================================
shell.open();
if (imagePath != null) {
loadImages(imagePath);
}
// main loop
while (!shell.isDisposed()) {
if (!display.readAndDispatch()) {
display.sleep();
}
}
display.dispose();
}
private void drawBorder(Event event, int alpha) {
GC gc = event.gc;
// gc.setForeground(event.display.getSystemColor(SWT.COLOR_GRAY));
gc.setAntialias(SWT.ON);
gc.setAlpha(alpha);
gc.setLineWidth(2);
gc.setLineStyle(SWT.LINE_CUSTOM);
gc.setLineDash(new int[] { 10, 5 });
gc.drawRoundRectangle(12, 12, shell.getClientArea().width - 24, shell.getClientArea().height - 24, 12, 12);
gc.dispose();
}
/**
* Loads a gif- or bmp-image and displays it.
*
* @param path absolute file-path of the image
*/
private void loadImages(String path) {
try {
ImageFormat image = ImageFormat.getImageFormat(path);
if (image != null) {
initializeEmbedUi();
guiComponents.embedUi.loadImage(image);
}
} catch (SteganoImageException e) {
e.printStackTrace();
}
}
private void initializeEmbedUi() {
if (composite == null) {
removeStartScreen();
startLayout();
}
}
private void removeStartScreen() {
if (shell.getChildren().length >= 1) {
shell.getChildren()[0].dispose();
shell.removeListener(SWT.Paint, shell.getListeners(SWT.Paint)[0]);
}
}
/**
* Sets the message of the global status bar.
*
* @param s String which gets displayed.
*/
static void setStatusBarMsg(final String s) {
statusBar.setText(s);
statusBar.setToolTipText("");
}
static void setStatusBarMsg(final String statusbarText, final String tooltip) {
statusBar.setText(statusbarText);
statusBar.setToolTipText(tooltip);
}
private void showStartScreen() {
final Composite composite = new Composite(shell, SWT.NONE);
composite.setLayout(new FormLayout());
final Label label = new Label(composite, SWT.SHADOW_NONE);
final Label label2 = new Label(composite, SWT.SHADOW_NONE);
final Button browseButton = new Button(composite, SWT.PUSH);
label.setText(L.getString("start_text"));
label2.setText(L.getString("or"));
browseButton.setText(L.getString("browse_files"));
// increase font size
final FontData[] fontData = label.getFont().getFontData();
for (FontData element : fontData) {
element.setHeight(18);
element.setStyle(SWT.BOLD);
}
label.setFont(new Font(display, fontData));
// place label in the middle of the window
shell.layout(true, true);
FormData formData = new FormData();
int offset = label2.getBounds().width / 2;
formData.left = new FormAttachment(50, -offset);
formData.top = new FormAttachment(label, 24);
label2.setLayoutData(formData);
formData = new FormData();
offset = browseButton.getBounds().width / 2;
formData.left = new FormAttachment(50, -offset);
formData.top = new FormAttachment(label2, 24);
browseButton.setLayoutData(formData);
browseButton.addListener(SWT.Selection, event -> openFileDialog());
shell.layout(true, true);
formData = new FormData();
offset = composite.getBounds().width / 2;
formData.left = new FormAttachment(50, -offset);
offset = composite.getBounds().height / 2;
formData.top = new FormAttachment(50, -offset);
composite.setLayoutData(formData);
shell.layout(true, true);
}
private void startLayout() {
statusBar = guiComponents.createStatusBar(shell);
composite = guiComponents.createLayout(shell, statusBar);
shell.layout(true, true);
}
}
stegosuite/src/main/java/org/stegosuite/ui/gui/GuiComponents.java 0000664 0000000 0000000 00000030713 15260777315 0025546 0 ustar 00root root 0000000 0000000 package org.stegosuite.ui.gui;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.graphics.*;
import org.eclipse.swt.layout.*;
import org.eclipse.swt.widgets.*;
import java.lang.reflect.Method;
import java.util.Objects;
import java.util.ResourceBundle;
/**
* Contains methods for creating the GUI-elements and setting their default parameters.
*/
public class GuiComponents {
final static byte LOAD_MENU_ITEM = 0;
EmbedUi embedUi;
private final ResourceBundle L = ResourceBundle.getBundle("Messages");
public static final int EMPTY = 1;
public static final int NOT_EMPTY = 0;
public static final int PROCESSING = 2;
Shell createShell(Display display) {
Shell shell = new Shell(display);
shell.setText("Stegosuite");
Image icon = new Image(display, this.getClass().getClassLoader().getResourceAsStream("icon.png"));
shell.setImage(icon);
// shell.setImage(new Image(display, "resources/images/man-hat.png"));
shell.setMinimumSize(350, 350);
shell.setSize(650, 400);
shell.setLayout(new FormLayout());
return shell;
}
Label createStatusBar(Shell shell) {
Label label = new Label(shell, SWT.SHADOW_NONE);
FormData labelData = new FormData();
labelData.left = new FormAttachment(0, 5);
labelData.right = new FormAttachment(100);
labelData.bottom = new FormAttachment(100, -1);
label.setLayoutData(labelData);
return label;
}
Menu createMenuBar(Shell shell) {
Menu menuBar = new Menu(shell, SWT.BAR);
MenuItem cascadeFileMenu = new MenuItem(menuBar, SWT.CASCADE);
cascadeFileMenu.setText(L.getString("file_menu"));
Menu fileMenu = new Menu(shell, SWT.DROP_DOWN);
cascadeFileMenu.setMenu(fileMenu);
MenuItem loadItem = new MenuItem(fileMenu, SWT.PUSH, LOAD_MENU_ITEM);
loadItem.setText(L.getString("load_image_menu"));
//
cascadeFileMenu = new MenuItem(menuBar, SWT.CASCADE);
cascadeFileMenu.setText("Help");
fileMenu = new Menu(shell, SWT.DROP_DOWN);
cascadeFileMenu.setMenu(fileMenu);
loadItem = new MenuItem(fileMenu, SWT.PUSH, LOAD_MENU_ITEM);
loadItem.setText("About");
loadItem.addListener(SWT.Selection, event -> {
int style = SWT.ICON_INFORMATION | SWT.OK;
MyDialog d = new MyDialog(shell, SWT.OK);
d.setText("About Stegosuite");
d.open();
});
shell.setMenuBar(menuBar);
return menuBar;
}
Composite createLayout(Shell parent, Control below) {
final Composite composite = new Composite(parent, SWT.NONE);
final FormData formData = new FormData();
formData.left = new FormAttachment(0);
formData.right = new FormAttachment(100);
formData.top = new FormAttachment(0);
formData.bottom = new FormAttachment(below);
composite.setLayoutData(formData);
embedUi = new EmbedUi(composite, this);
return composite;
}
Composite createControlsComposite(Composite parent) {
Composite compositeControls = new Composite(parent, SWT.NONE);
GridLayout mGridLayout = new GridLayout(2, true);
mGridLayout.verticalSpacing = 18;
mGridLayout.marginTop = 12;
mGridLayout.marginLeft = 12;
mGridLayout.makeColumnsEqualWidth = false;
compositeControls.setLayout(mGridLayout);
StyledText text = new StyledText(compositeControls, SWT.MULTI | SWT.V_SCROLL | SWT.WRAP | SWT.BORDER);
text.setAlwaysShowScrollBars(false);
text.setToolTipText(L.getString("message_text_tooltip"));
setPlaceholder(text, L.getString("message_text"));
/*
* text.addListener(SWT.MouseDown, event -> { text.setText(""); });
*/
GridData data = new GridData(SWT.FILL, SWT.CENTER, true, false, 2, 1);
data.heightHint = 70;
text.setLayoutData(data);
return compositeControls;
}
private void setPlaceholder(Scrollable text, String placeholder) {
text.setData(EMPTY);
Listener entryListener = event -> {
if (Objects.equals(text.getData(), EMPTY)) {
text.setData(PROCESSING);
setText(text, "");
text.setForeground(null);
text.setData(NOT_EMPTY);
}
};
Listener exitListener = event -> {
if (Objects.equals(text.getData(), NOT_EMPTY) && getText(text).isEmpty()) {
text.setData(PROCESSING);
setText(text, placeholder);
text.setForeground(Display.getDefault().getSystemColor(SWT.COLOR_DARK_GRAY));
text.setData(EMPTY);
}
};
text.addListener(SWT.FocusIn, entryListener);
text.addListener(SWT.Verify, entryListener);
text.addListener(SWT.Modify, exitListener);
text.addListener(SWT.FocusOut, exitListener);
entryListener.handleEvent(null);
exitListener.handleEvent(null);
}
private void setText(Scrollable textField, String value) {
// Reflection was needed to call the method on instances of Text and StyledText
// (whose common ancestor class is Scrollable)
try {
Method setText = textField.getClass().getMethod("setText", String.class);
setText.invoke(textField, value);
} catch (Exception e) {
e.printStackTrace();
}
}
private String getText(Scrollable textField) {
// Reflection was needed to call the method on instances of Text and StyledText
// (whose common ancestor class is Scrollable)
try {
Method getText = textField.getClass().getMethod("getText");
return getText.invoke(textField).toString();
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
Composite createFileEmbedding(Composite parent) {
Composite composite = new Composite(parent, SWT.NONE);
final GridData gridData2Columns = new GridData(SWT.FILL, SWT.CENTER, true, false, 2, 1);
// gridData2Columns.heightHint = 100;
composite.setLayoutData(gridData2Columns);
GridLayout mGridLayout = new GridLayout(2, true);
mGridLayout.verticalSpacing = 3;
mGridLayout.marginLeft = 0;
mGridLayout.marginRight = 0;
mGridLayout.marginTop = 0;
mGridLayout.horizontalSpacing = 0;
mGridLayout.marginWidth = 0;
mGridLayout.makeColumnsEqualWidth = false;
composite.setLayout(mGridLayout);
Label l = new Label(composite, SWT.NONE);
Label l2 = new Label(composite, SWT.NONE);
GridData gd = new GridData();
gd.horizontalAlignment = SWT.END;
l2.setLayoutData(gd);
l2.setForeground(Display.getDefault().getSystemColor(SWT.COLOR_DARK_GRAY));
final Table table = new Table(composite, SWT.SINGLE | SWT.BORDER);
final GridData gridData2Columns2 = new GridData(SWT.FILL, SWT.CENTER, true, false, 2, 1);
gridData2Columns2.heightHint = 50;
table.setLayoutData(gridData2Columns2);
TableColumn column1 = new TableColumn(table, SWT.LEFT);
TableColumn column2 = new TableColumn(table, SWT.RIGHT);
final TableColumn[] columns = table.getColumns();
// for (int i = 0; i < 1; i++) {
TableItem item = new TableItem(table, SWT.NONE);
item.setText(0, "Item");
item.setText(1, "123 KB");
item.setForeground(1, Display.getDefault().getSystemColor(SWT.COLOR_GRAY));
// }
for (TableColumn column : columns) {
column.pack();
}
table.remove(0);
l.setText(table.getItemCount() + " " + L.getString("files_text"));
return composite;
}
Text createPasswordField(Composite parent) {
GridData data = new GridData(SWT.FILL, SWT.BEGINNING, true, false, 2, 1);
// Label labelKey = new Label(g, SWT.LEFT);
// labelKey.setText("Secret key:");
// labelKey.setLayoutData(new GridData(SWT.BEGINNING, SWT.BEGINNING, true, false));
Text txtPassword = new Text(parent, SWT.SINGLE | SWT.BORDER);
txtPassword.setToolTipText(L.getString("key_text_tooltip"));
txtPassword.setLayoutData(data);
setPlaceholder(txtPassword, L.getString("key_text"));
// GridLayout mGridLayoutEncryption = new GridLayout(1, true);
// mGridLayoutEncryption.verticalSpacing = 6;
// mGridLayoutEncryption.marginWidth = 0;
// mGridLayoutEncryption.marginHeight = 0;
// Composite compositeEncryption = new Composite(g, SWT.NONE);
// compositeEncryption.setLayoutData(data);
// compositeEncryption.setLayout(mGridLayoutEncryption);
// Button checkBox1 = new Button(compositeEncryption, SWT.CHECK);
// checkBox1.setText("Encryption");
// checkBox1.setToolTipText("Encrypt the payload using AES with a secret key.");
//
// Text t3 = new Text(compositeEncryption, SWT.SINGLE | SWT.BORDER);
// t3.setEnabled(false);
// t3.setLayoutData(new GridData(SWT.FILL, SWT.BEGINNING, true, false));
// t3.addListener(SWT.MouseDown, event -> {
// t3.selectAll();
// });
//
// checkBox1.addListener(SWT.Selection, event -> {
// t3.setEnabled(checkBox1.getSelection());
// if (checkBox1.getSelection()) {
// t3.setText("secret-message-key");
// } else {
// t3.setText("");
// }
// });
return txtPassword;
}
Button createMainButton(Composite parent, String text) {
Button b = new Button(parent, SWT.PUSH);
b.setText(text);
GridData gd = new GridData();
gd.widthHint = (int) ((b.computeSize(SWT.DEFAULT, SWT.DEFAULT).x) * 1.6);
b.setLayoutData(gd);
return b;
}
Composite createImageComposite(Composite parent) {
Composite composite = new Composite(parent, SWT.NONE);
GridLayout gridLayout = new GridLayout(1, false);
gridLayout.marginRight = 18;
gridLayout.marginLeft = 12;
gridLayout.marginHeight = 17;
gridLayout.verticalSpacing = 6;
gridLayout.horizontalSpacing = 0;
composite.setLayout(gridLayout);
return composite;
}
}
class MyDialog
extends Dialog {
Object result;
public MyDialog(Shell parent, int style) {
super(parent, style);
}
public MyDialog(Shell parent) {
this(parent, 0);
}
private Image resize(Image image, int width, int height) {
Image scaled = new Image(Display.getDefault(), width, height);
GC gc = new GC(scaled);
gc.setAntialias(SWT.ON);
gc.setInterpolation(SWT.HIGH);
gc.drawImage(image, 0, 0, image.getBounds().width, image.getBounds().height, 0, 0, width, height);
gc.dispose();
image.dispose();
return scaled;
}
public Object open() {
Shell parent = getParent();
Shell shell = new Shell(parent, SWT.DIALOG_TRIM | SWT.APPLICATION_MODAL);
shell.setText(getText());
Image icon = new Image(shell.getDisplay(), this.getClass().getClassLoader().getResourceAsStream("icon.png"));
icon = resize(icon, 96, 96);
ImageData imageData = icon.getImageData();
imageData.transparentPixel = imageData.getPixel(0, 0);
icon.dispose();
final Image icon2 = new Image(null, imageData);
shell.setSize(400, 350);
shell.setLayout(new FormLayout());
Label lblIcon = null;
if (icon2 != null) {
lblIcon = new Label(shell, SWT.TRANSPARENT);
lblIcon.setImage(icon2);
lblIcon.setSize(new Point(96, 96));
FormData fd_lblIcon = new FormData();
int offsetX = -lblIcon.computeSize(SWT.DEFAULT, SWT.DEFAULT).x / 2;
fd_lblIcon.top = new FormAttachment(0, 20);
fd_lblIcon.left = new FormAttachment(50, offsetX);
lblIcon.setLayoutData(fd_lblIcon);
}
Label lblMessage = new Label(shell, SWT.WRAP);
FormData fd_lblMessage = new FormData();
lblMessage.setText("Stegosuite");
final FontData[] fontData = lblMessage.getFont().getFontData();
for (FontData element : fontData) {
element.setHeight(13);
}
Font font = new Font(shell.getDisplay(),
new FontData(fontData[0].getName(), fontData[0].getHeight(), SWT.BOLD));
lblMessage.setFont(font);
int offsetX = -lblMessage.computeSize(SWT.DEFAULT, SWT.DEFAULT).x / 2;
fd_lblMessage.top = new FormAttachment(lblIcon, 20);
fd_lblMessage.left = new FormAttachment(50, offsetX);
lblMessage.setLayoutData(fd_lblMessage);
Label lblMessage2 = new Label(shell, SWT.WRAP);
FormData fd_lblMessage2 = new FormData();
lblMessage2.setText("0.9");
offsetX = -lblMessage2.computeSize(SWT.DEFAULT, SWT.DEFAULT).x / 2;
fd_lblMessage2.top = new FormAttachment(lblMessage, 15);
fd_lblMessage2.left = new FormAttachment(50, offsetX);
lblMessage2.setLayoutData(fd_lblMessage2);
Label lblMessage3 = new Label(shell, SWT.WRAP | SWT.CENTER);
FormData fd_lblMessage3 = new FormData();
lblMessage3.setText("Stegosuite is a free steganography tool for hiding\n information in image files. "
+ "Written in Java using SWT");
offsetX = -lblMessage3.computeSize(SWT.DEFAULT, SWT.DEFAULT).x / 2;
fd_lblMessage3.top = new FormAttachment(lblMessage2, 15);
fd_lblMessage3.left = new FormAttachment(0, 15);
fd_lblMessage3.right = new FormAttachment(100, -15);
lblMessage3.setLayoutData(fd_lblMessage3);
Button btnOk = new Button(shell, SWT.NONE);
btnOk.addListener(SWT.Selection, event -> {
shell.dispose();
});
FormData fd_btnOk = new FormData();
fd_btnOk.bottom = new FormAttachment(100, -15);
fd_btnOk.left = new FormAttachment(100, -95);
fd_btnOk.right = new FormAttachment(100, -15);
btnOk.setLayoutData(fd_btnOk);
btnOk.setText("Close");
shell.open();
Display display = parent.getDisplay();
while (!shell.isDisposed()) {
if (!display.readAndDispatch())
display.sleep();
}
return result;
}
}
stegosuite/src/main/java/org/stegosuite/ui/gui/ImageContainer.java 0000664 0000000 0000000 00000003642 15260777315 0025642 0 ustar 00root root 0000000 0000000 package org.stegosuite.ui.gui;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.ImageData;
import org.eclipse.swt.widgets.Composite;
import java.util.HashMap;
import java.util.Map;
public class ImageContainer {
public enum ImageState {
CARRIER, CARRIER_SCALED, STEG, STEG_VISUALIZED, STEG_LSB, STEG_LSB2
}
private Image image = null;
private ImageState state = ImageState.CARRIER;
private final Map images = new HashMap<>();
private final Composite composite;
public ImageContainer(Composite composite) {
this.composite = composite;
}
public Image scaleImage() {
return scaleImage(state);
}
public Image scaleImage(ImageState state) {
this.state = state;
return loadImage(images.get(state));
}
public Image loadImage(ImageData imageData) {
if (composite.getChildren().length > 0) {
if (image != null) {
image.dispose();
image = null;
} else {
images.put(ImageState.CARRIER, imageData);
}
}
float ih = imageData.height;
float iw = imageData.width;
int iw_scaled = (int) iw;
int ih_scaled = (int) ih;
float scaleFactor = getImageScaleFactor(imageData);
if (scaleFactor < 1) {
iw_scaled = Math.round(iw * scaleFactor);
ih_scaled = Math.round(ih * scaleFactor);
}
ImageData imageDataScaled = imageData.scaledTo(iw_scaled, ih_scaled);
image = new Image(composite.getDisplay(), imageDataScaled);
return image;
}
private float getImageScaleFactor(ImageData imageData) {
float h = imageData.height;
float w = imageData.width;
float ch = composite.getBounds().height - 54;
float cw = composite.getBounds().width - 36;
float scaleHeight = ch / h;
float scaleWidth = cw / w;
return Math.min(scaleHeight, scaleWidth);
}
public void setImageData(ImageState state, ImageData imageData) {
images.put(state, imageData);
}
public ImageData getImageData(ImageState state) {
return images.get(state);
}
}
stegosuite/src/main/java/org/stegosuite/ui/gui/ImageUtils.java 0000664 0000000 0000000 00000000524 15260777315 0025014 0 ustar 00root root 0000000 0000000 package org.stegosuite.ui.gui;
public class ImageUtils {
// taken from http://stackoverflow.com/a/24805871
public static String formatSize(long v) {
if (v < 1024) {
return v + " B";
}
int z = (63 - Long.numberOfLeadingZeros(v)) / 10;
return String.format("%.1f %sB", (double) v / (1L << (z * 10)), " KMGTPE".charAt(z));
}
}
stegosuite/src/main/java/org/stegosuite/util/ 0000775 0000000 0000000 00000000000 15260777315 0021661 5 ustar 00root root 0000000 0000000 stegosuite/src/main/java/org/stegosuite/util/ByteUtils.java 0000664 0000000 0000000 00000011037 15260777315 0024452 0 ustar 00root root 0000000 0000000 package org.stegosuite.util;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Array;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.Arrays;
import java.util.Iterator;
import java.util.Random;
import java.util.function.Predicate;
public class ByteUtils {
/**
* Private constructor to hide the publicly implicit one
*/
private ByteUtils() {}
/**
* Generates a byte[] from a given integer
*
* @param i the integer
* @return the integer representation in byte[]
*/
public static byte[] intToBytes(int i) {
return ByteBuffer.allocate(4).putInt(i).array();
}
/**
* Creates a new array containing the concatenation of all passed arrays
*
* @param arrays
* @return
*/
public static byte[] concat(byte[]... arrays) {
if (arrays.length == 0) {
return new byte[0];
}
if (arrays.length == 1) {
return arrays[0];
}
int length = Arrays.stream(arrays).mapToInt(Array::getLength).sum();
ByteBuffer concatenation = ByteBuffer.allocate(length);
Arrays.stream(arrays).forEach(concatenation::put);
return concatenation.array();
}
/**
* Copies all content from the InputStream to the OutputStream
*
* @param in
* @param out
* @throws IOException
*/
public static void copy(InputStream in, OutputStream out)
throws IOException {
byte[] buffer = new byte[1024];
int len;
while ((len = in.read(buffer)) > 0) {
out.write(buffer, 0, len);
}
}
/**
* Returns one randomly generated byte based on a predicate
*
* @param predicate
*/
public static byte getRandomByte(Predicate predicate) {
Random random = new Random();
do {
byte[] b = new byte[1];
random.nextBytes(b);
if ((predicate == null) || predicate.test(b[0])) {
return b[0];
}
} while (true);
}
/**
* Converts an array of 8 bits to one byte. If you pass LITTLE_ENDIAN as byteOrder, index 0 is
* LSB, index 7 is MSB. If you pass BIG_ENDIAN as byteOrder, index 0 is MSB, index 7 is LSB.
*
* @param bits
* @param byteOrder
* @return
*/
public static byte bitsToByte(byte[] bits, ByteOrder byteOrder) {
byte b = 0;
for (int i = 0; i < 8; i++) {
int index = byteOrder.equals(ByteOrder.LITTLE_ENDIAN) ? i : 7 - i;
if (bits[index] != 0) {
b = (byte) (b | (1 << i));
}
}
return b;
}
/**
* Returns the bit at the specified index of b. Index 0 is LSB, index 7 is MSB
*
* @param b byte from which to read the bit
* @param index index to retrieve
* @return
*/
public static byte getBitAt(byte b, int index) {
return getBitAt((int) b, index);
}
/**
* Sets the bit in the passed byte at the specified index
*
* @param b byte to modify
* @param index index to modify
* @param bit new bit value to set, either 1 or 0
* @return
*/
public static byte setBitAt(byte b, int index, int bit) {
return (byte) setBitAt((int) b, index, bit);
}
/**
* Returns the bit at the specified index of i. Index 0 is LSB, index 31 is MSB
*
* @param i integer from which to read the bit
* @param index index to retrieve
* @return
*/
public static byte getBitAt(int i, int index) {
return (byte) ((i & (1 << index)) >> index);
}
/**
* Sets the bit in the passed integer at the specified index
*
* @param i integer to modify
* @param index index to modify
* @param bit new bit value to set, either 1 or 0
* @return
*/
public static int setBitAt(int i, int index, int bit) {
int mask = 1 << index;
return bit == 1 ? i | mask : i & ~mask;
}
/**
* Returns true if LSB is 0, otherwise false
*
* @param i
* @return
*/
public static boolean isEven(int i) {
return i % 2 == 0;
}
/**
* Returns true if LSB is 1, otherwise false
*
* @param i
* @return
*/
public static boolean isOdd(int i) {
return i % 2 != 0;
}
/**
* Returns an Iterable that yields bits for all bytes provided in the input byte array, going
* from LSB to MSB for each byte
*
* @param bytes
* @param byteOrder
* @return
*/
public static Iterable iterateBits(byte[] bytes, ByteOrder byteOrder) {
return () -> new Iterator<>() {
private int byteIndex = 0;
private int bitIndex = 0;
@Override
public boolean hasNext() {
return !((byteIndex == bytes.length) && (bitIndex == 0));
}
@Override
public Byte next() {
byte orderedBitIndex = (byte) (byteOrder == ByteOrder.LITTLE_ENDIAN ? bitIndex : 7 - bitIndex);
byte b = getBitAt(bytes[byteIndex], orderedBitIndex);
if ((bitIndex = ++bitIndex % 8) == 0) {
byteIndex++;
}
return b;
}
};
}
}
stegosuite/src/main/java/org/stegosuite/util/ColorDistance.java 0000664 0000000 0000000 00000014531 15260777315 0025261 0 ustar 00root root 0000000 0000000 package org.stegosuite.util;
import java.awt.*;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
*
*/
public enum ColorDistance {
/**
* Basic Euclidean distance
*/
RGB_EUCLID {
@Override
protected Double getDistance(Color rgb1, Color rgb2) {
return Math.sqrt(Math.pow(rgb1.getRed() - rgb2.getRed(), 2) + Math.pow(rgb1.getGreen() - rgb2.getGreen(), 2)
+ Math.pow(rgb1.getBlue() - rgb2.getBlue(), 2));
}
},
/**
* CIEDE2000 distance using the Lab color space
*/
CIEDE_2000 {
@Override
protected Double getDistance(Color rgb1, Color rgb2) {
double[] lab1 = rgb2lab(rgb1.getRed(), rgb1.getGreen(), rgb1.getBlue());
double[] lab2 = rgb2lab(rgb2.getRed(), rgb2.getGreen(), rgb2.getBlue());
return ciede2000(lab1, lab2);
}
};
protected abstract Double getDistance(Color rgb1, Color rgb2);
private static final Map, Double>> cache;
static {
cache = new HashMap<>(ColorDistance.values().length);
for (ColorDistance distance : ColorDistance.values()) {
cache.put(distance, new ConcurrentHashMap<>());
}
}
/**
* Compares two RGB colors according to the current distance algorithm.
*
* @param rgb1 First color for the comparison.
* @param rgb2 Second color for the comparison.
* @return The distance between the two colors according to the current distance algorithm.
*/
public Double distance(Color rgb1, Color rgb2) {
if (rgb1 == null || rgb2 == null) {
return null;
}
if (rgb1.equals(rgb2)) {
return 0.0;
}
InterchangeablePair pair = new InterchangeablePair<>(rgb1, rgb2);
return cache.get(this).computeIfAbsent(pair, k -> getDistance(rgb1, rgb2));
}
/**
* Converts a color from the RGB color space the L*a*b color space
*
* Taken from https://github.com/StanfordHCI/c3/blob/master/java/src/edu/stanford
* /vis/color/LAB.java
*
* Maps an RGB triple to binned LAB space (D65). Binning is done by flooring LAB values.
*
* @param ri Red component of the RGB color.
* @param gi Green component of the RGB color.
* @param bi Blue component of the RGB color.
* @return The color in the L*a*b color space
*/
private static double[] rgb2lab(int ri, int gi, int bi) {
// first, normalize RGB values
double r = ri / 255.0;
double g = gi / 255.0;
double b = bi / 255.0;
// D65 standard referent
double X = 0.950470, Y = 1.0, Z = 1.088830;
// second, map sRGB to CIE XYZ
r = r <= 0.04045 ? r / 12.92 : Math.pow((r + 0.055) / 1.055, 2.4);
g = g <= 0.04045 ? g / 12.92 : Math.pow((g + 0.055) / 1.055, 2.4);
b = b <= 0.04045 ? b / 12.92 : Math.pow((b + 0.055) / 1.055, 2.4);
double x = ((0.4124564 * r) + (0.3575761 * g) + (0.1804375 * b)) / X,
y = ((0.2126729 * r) + (0.7151522 * g) + (0.0721750 * b)) / Y,
z = ((0.0193339 * r) + (0.1191920 * g) + (0.9503041 * b)) / Z;
// third, map CIE XYZ to CIE L*a*b* and return
x = x > 0.008856 ? Math.pow(x, 1.0 / 3) : (7.787037 * x) + (4.0 / 29);
y = y > 0.008856 ? Math.pow(y, 1.0 / 3) : (7.787037 * y) + (4.0 / 29);
z = z > 0.008856 ? Math.pow(z, 1.0 / 3) : (7.787037 * z) + (4.0 / 29);
double L = (116 * y) - 16, A = 500 * (x - y), B = 200 * (y - z);
return new double[] { L, A, B };
}
/**
* Compares to L*a*b colors and returns the degree of their similarity. The lower the result the
* more similar are the colors.
*
* Taken from https://github.com/StanfordHCI/c3/blob/master/java/src/edu/stanford
* /vis/color/LAB.java
*
* @param lab1 First color represented in L*a*b color space.
* @param lab2 Second color represented in L*a*b color space.
* @return The degree of similarity between the two input colors according to the CIEDE2000
* color-difference formula.
*/
private static Double ciede2000(double[] lab1, double[] lab2) {
// adapted from Sharma et al's MATLAB implementation at
// http://www.ece.rochester.edu/~gsharma/ciede2000/
// parametric factors, use defaults
double kl = 1, kc = 1, kh = 1;
// compute terms
double pi = Math.PI, L1 = lab1[0], a1 = lab1[1], b1 = lab1[2], Cab1 = Math.sqrt((a1 * a1) + (b1 * b1)),
L2 = lab2[0], a2 = lab2[1], b2 = lab2[2], Cab2 = Math.sqrt((a2 * a2) + (b2 * b2)),
Cab = 0.5 * (Cab1 + Cab2),
G = 0.5 * (1 - Math.sqrt(Math.pow(Cab, 7) / (Math.pow(Cab, 7) + Math.pow(25, 7)))), ap1 = (1 + G) * a1,
ap2 = (1 + G) * a2, Cp1 = Math.sqrt((ap1 * ap1) + (b1 * b1)), Cp2 = Math.sqrt((ap2 * ap2) + (b2 * b2)),
Cpp = Cp1 * Cp2;
// ensure hue is between 0 and 2pi
double hp1 = Math.atan2(b1, ap1);
if (hp1 < 0) {
hp1 += 2 * pi;
}
double hp2 = Math.atan2(b2, ap2);
if (hp2 < 0) {
hp2 += 2 * pi;
}
double dL = L2 - L1, dC = Cp2 - Cp1, dhp = hp2 - hp1;
if (dhp > +pi) {
dhp -= 2 * pi;
}
if (dhp < -pi) {
dhp += 2 * pi;
}
if (Cpp == 0) {
dhp = 0;
}
// Note that the defining equations actually need signed Hue and chroma
// differences which is different from prior color difference formulae
double dH = 2 * Math.sqrt(Cpp) * Math.sin(dhp / 2);
// Weighting functions
double Lp = 0.5 * (L1 + L2), Cp = 0.5 * (Cp1 + Cp2);
// Average Hue Computation. This is equivalent to that in the paper but
// simpler programmatically. Average hue is computed in radians and
// converted to degrees where needed
double hp = 0.5 * (hp1 + hp2);
// Identify positions for which abs hue diff exceeds 180 degrees
if (Math.abs(hp1 - hp2) > pi) {
hp -= pi;
}
if (hp < 0) {
hp += 2 * pi;
}
// Check if one of the chroma values is zero, in which case set mean hue
// to the sum which is equivalent to other value
if (Cpp == 0) {
hp = hp1 + hp2;
}
double Lpm502 = (Lp - 50) * (Lp - 50), Sl = 1 + ((0.015 * Lpm502) / Math.sqrt(20 + Lpm502)),
Sc = 1 + (0.045 * Cp),
T = ((1 - (0.17 * Math.cos(hp - (pi / 6)))) + (0.24 * Math.cos(2 * hp))
+ (0.32 * Math.cos((3 * hp) + (pi / 30)))) - (0.20 * Math.cos((4 * hp) - ((63 * pi) / 180))),
Sh = 1 + (0.015 * Cp * T), ex = (((180 / pi) * hp) - 275) / 25,
delthetarad = ((30 * pi) / 180) * Math.exp(-1 * (ex * ex)),
Rc = 2 * Math.sqrt(Math.pow(Cp, 7) / (Math.pow(Cp, 7) + Math.pow(25, 7))),
RT = -1 * Math.sin(2 * delthetarad) * Rc;
dL = dL / (kl * Sl);
dC = dC / (kc * Sc);
dH = dH / (kh * Sh);
// The CIED200 color difference
return Math.sqrt((dL * dL) + (dC * dC) + (dH * dH) + (RT * dC * dH));
}
}
stegosuite/src/main/java/org/stegosuite/util/ColorUtils.java 0000664 0000000 0000000 00000011556 15260777315 0024633 0 ustar 00root root 0000000 0000000 package org.stegosuite.util;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.awt.image.WritableRaster;
import java.util.*;
import java.util.List;
import java.util.Map.Entry;
import java.util.concurrent.ConcurrentHashMap;
import static java.util.function.Function.identity;
import static java.util.stream.Collectors.*;
/**
* Utility class that provides various color-related methods such as color transformations, color
* comparisons, color sorting, etc.
*/
public class ColorUtils {
/**
* Sorts a list of RGB colors with a specific color distance algorithm
*
* Duplicate colors are collapsed, so the result contains every distinct input color exactly
* once. Colors are always looked up by value, so palette entries with identical RGB values are
* indistinguishable to callers.
*
* @param colors
* @param colorDistance
* @return
*/
public static List sortColors(List colors, ColorDistance colorDistance) {
if (colors.size() < 2) {
return colors;
}
Set unsortedBase = new HashSet<>(colors);
Map> sortedLists = new ConcurrentHashMap<>();
unsortedBase.parallelStream().forEach(base -> {
List unsorted = new ArrayList<>(unsortedBase);
unsorted.remove(base);
List sorted = new ArrayList<>(unsortedBase.size());
sorted.add(base);
Double sumDistance = 0.0;
while (!unsorted.isEmpty()) {
List distances = unsorted.stream()
.map(c -> colorDistance.distance(c, sorted.get(sorted.size() - 1))).collect(toList());
Double minDistance = Collections.min(distances);
sumDistance += minDistance;
sorted.add(unsorted.remove(distances.indexOf(minDistance)));
}
sortedLists.put(sumDistance, sorted);
});
return sortedLists.get(Collections.min(sortedLists.keySet()));
}
/**
* Returns a histogram (or frequency map) of all colors referenced in the pixels array
*
* @param colors
* @param pixels
* @return
*/
public static Map getHistogram(List colors, int[] pixels) {
Map histogram = new HashSet<>(colors).stream().collect(toMap(identity(), c -> 0));
Arrays.stream(pixels).mapToObj(colors::get).forEach(color -> histogram.put(color, histogram.get(color) + 1));
return histogram;
}
/**
* Returns the colors that are present in the color table but not referenced by any pixel
*
* @param colorTable
* @param pixels
* @return
*/
public static Set getUnreferencedColors(List colorTable, int[] pixels) {
return getUnreferencedColors(getHistogram(colorTable, pixels));
}
/**
* Returns the colors that are present in the histogram that have zero occurrences
*
* @param histogram
* @return
*/
public static Set getUnreferencedColors(Map histogram) {
return histogram.entrySet().stream().filter(e -> e.getValue() == 0).map(Entry::getKey).collect(toSet());
}
/**
* Writes a list of colors onto a BufferedImage for easy visualization
*
* @param colors
* @return
*/
public static BufferedImage colorsToImage(List colors) {
if (colors.isEmpty()) {
return null;
}
int width = 400;
int height = 40;
BufferedImage bufferedImage = new BufferedImage(width, height * colors.size(), BufferedImage.TYPE_INT_RGB);
Graphics graphics = bufferedImage.getGraphics();
graphics.setFont(new Font("Arial", Font.BOLD, 16));
for (int i = 0; i < colors.size(); i++) {
Color color = colors.get(i);
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
bufferedImage.setRGB(x, (i * height) + y, color.getRGB());
}
}
String rgb = String.format("[%d,%d,%d]", color.getRed(), color.getGreen(), color.getBlue());
graphics.setColor(Color.BLACK);
graphics.fillRect(0, i * height, 150, height);
graphics.setColor(Color.WHITE);
graphics.drawString(rgb, 25, (i * height) + 25);
}
return bufferedImage;
}
/**
* Creates an exact copy of the passed buffered image instance
*
* @param source
* @return
*/
public static BufferedImage cloneBufferedImage(BufferedImage source) {
return cloneBufferedImage(source, source.getType());
}
/**
* Creates a copy of the passed buffered image instance and optionally does type conversion
*
* @param source
* @param imageType
* @return
*/
public static BufferedImage cloneBufferedImage(BufferedImage source, int imageType) {
if (source.getType() == imageType) {
boolean isAlphaPremultiplied = source.getColorModel().isAlphaPremultiplied();
WritableRaster raster = source.copyData(source.getRaster().createCompatibleWritableRaster());
return new BufferedImage(source.getColorModel(), raster, isAlphaPremultiplied, null);
} else {
BufferedImage copy = new BufferedImage(source.getWidth(), source.getHeight(), imageType);
Graphics2D g2d = copy.createGraphics();
g2d.drawImage(source, 0, 0, null);
g2d.dispose();
return copy;
}
}
}
stegosuite/src/main/java/org/stegosuite/util/CompressionUtils.java 0000664 0000000 0000000 00000002362 15260777315 0026051 0 ustar 00root root 0000000 0000000 package org.stegosuite.util;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.zip.DeflaterOutputStream;
import java.util.zip.InflaterInputStream;
public class CompressionUtils {
/**
* Private constructor to hide the publicly implicit one
*/
private CompressionUtils() {}
/**
* Compresses a byte array using deflate
*
* @param data
* @return
* @throws IOException
*/
public static byte[] compress(byte[] data)
throws IOException {
ByteArrayOutputStream outBytes = new ByteArrayOutputStream();
try (ByteArrayInputStream in = new ByteArrayInputStream(data);
DeflaterOutputStream outDeflate = new DeflaterOutputStream(outBytes)) {
ByteUtils.copy(in, outDeflate);
outBytes.close();
}
return outBytes.toByteArray();
}
/**
* Decompresses a byte array using inflate
*
* @param data
* @return
* @throws IOException
*/
public static byte[] decompress(byte[] data)
throws IOException {
ByteArrayOutputStream outBytes = new ByteArrayOutputStream();
try (InflaterInputStream in = new InflaterInputStream(new ByteArrayInputStream(data))) {
ByteUtils.copy(in, outBytes);
outBytes.close();
}
return outBytes.toByteArray();
}
}
stegosuite/src/main/java/org/stegosuite/util/CryptoUtils.java 0000664 0000000 0000000 00000006344 15260777315 0025034 0 ustar 00root root 0000000 0000000 package org.stegosuite.util;
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.PBEKeySpec;
import javax.crypto.spec.SecretKeySpec;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.spec.KeySpec;
import java.util.Arrays;
import java.util.Random;
/**
*
* Some code in this class taken from: http://stackoverflow.com/a/992413/4862922
*
*/
public class CryptoUtils {
private static final int SALT_LENGTH = 16;
private static final String KEY_ALGORITHM = "PBKDF2WithHmacSHA1";
private static final int KEY_LENGTH = 256;
private static final String CIPHER_ALGORITHM = "AES";
private static final String CIPHER_MODE_PADDING_ALGORITHM = CIPHER_ALGORITHM + "/CTR/NoPadding";
/**
* Can be constant because we use CTR mode, and we salt the key
*/
private static final byte[] IV = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
private static final String RANDOM_MESSAGE_DIGEST_ALGORITHM = "MD5";
/**
* Encrypts a byte array
*
* @param dataToEncrypt
* @param password
* @return
* @throws Exception
*/
public static byte[] encrypt(final byte[] dataToEncrypt, final String password)
throws Exception {
final byte[] salt = SecureRandom.getSeed(SALT_LENGTH);
final Cipher cipher = Cipher.getInstance(CIPHER_MODE_PADDING_ALGORITHM);
cipher.init(Cipher.ENCRYPT_MODE, generateKey(password, salt), new IvParameterSpec(IV));
final byte[] cipherText = cipher.doFinal(dataToEncrypt);
return ByteUtils.concat(salt, cipherText);
}
/**
* Decrypts a byte array
*
* @param dataToDecrypt
* @param password
* @return
* @throws Exception
*/
public static byte[] decrypt(final byte[] dataToDecrypt, final String password)
throws Exception {
final byte[] salt = Arrays.copyOfRange(dataToDecrypt, 0, SALT_LENGTH);
final byte[] payload = Arrays.copyOfRange(dataToDecrypt, SALT_LENGTH, dataToDecrypt.length);
final Cipher cipher = Cipher.getInstance(CIPHER_MODE_PADDING_ALGORITHM);
cipher.init(Cipher.DECRYPT_MODE, generateKey(password, salt), new IvParameterSpec(IV));
return cipher.doFinal(payload);
}
/**
*
* @param password
* @param salt
* @return
* @throws Exception
*/
private static SecretKey generateKey(final String password, byte[] salt)
throws Exception {
final int iterationCount = 65536;
final SecretKeyFactory factory = SecretKeyFactory.getInstance(KEY_ALGORITHM);
final KeySpec spec = new PBEKeySpec(password.toCharArray(), salt, iterationCount, KEY_LENGTH);
return new SecretKeySpec(factory.generateSecret(spec).getEncoded(), CIPHER_ALGORITHM);
}
/**
* Creates a Random instance seeded with the specified key
*
* @param key
*/
public static Random seededRandom(String key) {
try {
MessageDigest digest = MessageDigest.getInstance(RANDOM_MESSAGE_DIGEST_ALGORITHM);
byte[] output = digest.digest(key.getBytes(StandardCharsets.UTF_8));
long rndSeed = ByteBuffer.wrap(output).getLong();
return new Random(rndSeed);
} catch (NoSuchAlgorithmException e) {
// Should never happen
}
return null;
}
}
stegosuite/src/main/java/org/stegosuite/util/FileUtils.java 0000664 0000000 0000000 00000003057 15260777315 0024431 0 ustar 00root root 0000000 0000000 package org.stegosuite.util;
import java.io.File;
import java.nio.file.Path;
import java.nio.file.Paths;
public class FileUtils {
/**
* Returns the substring after the last dot in fileName. If there is no dot in fileName, returns
* an empty {@link String}
*
* @param fileName foo.bar
* @return bar
*/
public static String getFileExtension(String fileName) {
int lastDotPos = fileName.lastIndexOf('.');
return lastDotPos > -1 ? fileName.substring(lastDotPos + 1) : "";
}
/**
* Appends a suffix to a filename
*
* @param fileName D:\folder\foo.bar
* @param suffix _horse
* @return D:\folder\foo_horse.bar
*/
public static String addFileNameSuffix(String fileName, String suffix) {
String fileExtension = getFileExtension(fileName);
if (fileExtension.isEmpty()) {
return fileName + suffix;
}
return fileName.substring(0, fileName.length() - fileExtension.length() - 1) + suffix + "." + fileExtension;
}
/**
* Changes the file name while leaving the path unmodified
*
* @param oldFileName D:\folder\foo.bar
* @param newFileName file.dat
* @return D:\folder\file.dat
*/
public static String changeFileName(String oldFileName, String newFileName) {
Path path = Paths.get(oldFileName);
return path.getParent() + File.separator + newFileName;
}
/**
* @param filePath D:\folder\foo.bar
* @return foo.bar
*/
public static String getFileName(String filePath) {
return Paths.get(filePath).getFileName().toString();
}
public static long getFileSize(String filePath) {
return new File(filePath).length();
}
}
stegosuite/src/main/java/org/stegosuite/util/ImageSwtAwtConverter.java 0000664 0000000 0000000 00000006422 15260777315 0026614 0 ustar 00root root 0000000 0000000 package org.stegosuite.util;
import org.eclipse.swt.graphics.ImageData;
import org.eclipse.swt.graphics.PaletteData;
import org.eclipse.swt.graphics.RGB;
import java.awt.image.*;
import java.util.stream.IntStream;
public class ImageSwtAwtConverter {
/** Private constructor to hide the implicit public one */
private ImageSwtAwtConverter() {}
/**
* Convert a given AWT's {@link BufferedImage} into SWT's {@link ImageData}
*
* @param bufferedImage the {@link BufferedImage} to be converted
*
* @return the associated {@link ImageData}
*/
public static ImageData convertToSWT(BufferedImage bufferedImage) {
int w = bufferedImage.getWidth();
int h = bufferedImage.getHeight();
if (bufferedImage.getColorModel() instanceof DirectColorModel) {
DirectColorModel cm = (DirectColorModel) bufferedImage.getColorModel();
PaletteData paletteData = new PaletteData(cm.getRedMask(), cm.getGreenMask(), cm.getBlueMask());
ImageData imageData = new ImageData(w, h, cm.getPixelSize(), paletteData);
WritableRaster raster = bufferedImage.getRaster();
int[] pixelArray = new int[bufferedImage.getColorModel().getComponentSize().length];
IntStream.range(0, h).forEach(y -> IntStream.range(0, w).forEach(x -> {
raster.getPixel(x, y, pixelArray);
int pixel = paletteData.getPixel(new RGB(pixelArray[0], pixelArray[1], pixelArray[2]));
imageData.setPixel(x, y, pixel);
if (cm.hasAlpha()) {
imageData.setAlpha(x, y, pixelArray[3]);
}
}));
return imageData;
} else if (bufferedImage.getColorModel() instanceof IndexColorModel) {
IndexColorModel cm = (IndexColorModel) bufferedImage.getColorModel();
int arrayLength = cm.getMapSize();
byte[] reds = new byte[arrayLength];
byte[] greens = new byte[arrayLength];
byte[] blues = new byte[arrayLength];
cm.getReds(reds);
cm.getGreens(greens);
cm.getBlues(blues);
RGB[] rgbs = new RGB[arrayLength];
IntStream.range(0, rgbs.length)
.forEach(i -> rgbs[i] = new RGB(reds[i] & 0xFF, greens[i] & 0xFF, blues[i] & 0xFF));
PaletteData paletteData = new PaletteData(rgbs);
ImageData imageData = new ImageData(w, h, cm.getPixelSize(), paletteData);
imageData.transparentPixel = cm.getTransparentPixel();
WritableRaster raster = bufferedImage.getRaster();
int[] pixelArray = new int[1];
IntStream.range(0, h).forEach(y -> IntStream.range(0, w).forEach(x -> {
raster.getPixel(x, y, pixelArray);
imageData.setPixel(x, y, pixelArray[0]);
}));
return imageData;
} else if (bufferedImage.getColorModel() instanceof ComponentColorModel) {
ComponentColorModel cm = (ComponentColorModel) bufferedImage.getColorModel();
PaletteData paletteData = new PaletteData(0x0000FF, 0x00FF00, 0xFF0000);
ImageData imageData = new ImageData(w, h, cm.getPixelSize(), paletteData);
WritableRaster raster = bufferedImage.getRaster();
int[] pixelArray = new int[bufferedImage.getColorModel().getComponentSize().length];
IntStream.range(0, h).forEach(y -> IntStream.range(0, w).forEach(x -> {
raster.getPixel(x, y, pixelArray);
int pixel = paletteData.getPixel(new RGB(pixelArray[0], pixelArray[1], pixelArray[2]));
imageData.setPixel(x, y, pixel);
if (cm.hasAlpha()) {
imageData.setAlpha(x, y, pixelArray[3]);
}
}));
return imageData;
}
return null;
}
}
stegosuite/src/main/java/org/stegosuite/util/InterchangeablePair.java 0000664 0000000 0000000 00000001166 15260777315 0026417 0 ustar 00root root 0000000 0000000 package org.stegosuite.util;
public class InterchangeablePair {
public final F first;
public final S second;
public InterchangeablePair(F first, S second) {
this.first = first;
this.second = second;
}
@Override
public boolean equals(Object o) {
if (o == null || !(o instanceof InterchangeablePair)) {
return false;
}
InterchangeablePair that = (InterchangeablePair) o;
return first.equals(that.first) && second.equals(that.second)
|| first.equals(that.second) && second.equals(that.first);
}
@Override
public int hashCode() {
return first.hashCode() ^ second.hashCode();
}
}
stegosuite/src/main/java/org/stegosuite/util/RgbChannel.java 0000664 0000000 0000000 00000002756 15260777315 0024541 0 ustar 00root root 0000000 0000000 package org.stegosuite.util;
import java.awt.*;
import java.util.Arrays;
import java.util.List;
public enum RgbChannel {
RED {
@Override
public int getValue(Color color) {
return color.getRed();
}
@Override
public Color setValue(Color color, int value) {
return new Color(value, color.getGreen(), color.getBlue(), color.getAlpha());
}
},
GREEN {
@Override
public int getValue(Color color) {
return color.getGreen();
}
@Override
public Color setValue(Color color, int value) {
return new Color(color.getRed(), value, color.getBlue(), color.getAlpha());
}
},
BLUE {
@Override
public int getValue(Color color) {
return color.getBlue();
}
@Override
public Color setValue(Color color, int value) {
return new Color(color.getRed(), color.getGreen(), value, color.getAlpha());
}
},
ALPHA {
@Override
public int getValue(Color color) {
return color.getAlpha();
}
@Override
public Color setValue(Color color, int value) {
return new Color(color.getRed(), color.getGreen(), color.getBlue(), value);
}
};
/**
* Gets the value (0..255) of the color for the current channel
*
* @param color
* @return
*/
public abstract int getValue(Color color);
/**
* Sets the value (0..255) of the color for the current channel
*
* @param color
* @param value
* @return
*/
public abstract Color setValue(Color color, int value);
public static List RGB() {
return Arrays.asList(RED, GREEN, BLUE);
}
}
stegosuite/src/main/resources/ 0000775 0000000 0000000 00000000000 15260777315 0017013 5 ustar 00root root 0000000 0000000 stegosuite/src/main/resources/i18n/ 0000775 0000000 0000000 00000000000 15260777315 0017572 5 ustar 00root root 0000000 0000000 stegosuite/src/main/resources/i18n/Messages.properties 0000664 0000000 0000000 00000001134 15260777315 0023456 0 ustar 00root root 0000000 0000000 start_text = Drag and drop image here
or = or
browse_files = Browse Files...
file_menu = &File
load_image_menu = &Open...
embed_button = Embed
extract_button = Extract
message_text = Enter secret message
message_text_tooltip = Secret message, which gets embedded into the image
message_text_tooltip_extract = Extracted text message
files_text = embedded files
files_menu_delete = Delete selection
files_menu_add = Add file...
key_text = Enter password
key_text_tooltip = Secret key used for hiding and encrypting the content
visualize_checkbox = Visualize embedding
statusbar_capacity = Capacity
stegosuite/src/main/resources/i18n/Messages_d_e.properties 0000664 0000000 0000000 00000001137 15260777315 0024270 0 ustar 00root root 0000000 0000000 start_text = Kein Bild geladen.
file_menu = &Datei
load_image_menu = &ffnen...
embed_button = Einbetten
extract_button = Extrahieren
message_text = Geheime Nachricht eingeben
message_text_tooltip = Geheime Nachricht, die in das Bild eingebettet wird
message_text_tooltip_extract = Extrahierte Nachricht
files_text = eingebettete Dateien
files_menu_delete = Auswahl lschen
files_menu_add = Datei hinzufgen...
key_text = Passwort eingeben
key_text_tooltip = Geheimer Schlssel, zum Verstecken und Verschlsseln des Inhalts
visualize_checkbox = Einbettung visualisieren
statusbar_capacity = Kapazitt stegosuite/src/main/resources/icon.png 0000664 0000000 0000000 00000011400 15260777315 0020445 0 ustar 00root root 0000000 0000000 PNG
IHDR \rf bKGD pHYs
B(x tIME,qH IDATx{Uu?p\0c*a l,`m
E Z;e-Bg:R:jh0>Fbʀ
mI;14B $BrssqؿsC:oA-2{//Vj2R-π@9&!D$
xK]$
Ŷ-Yȝr9g/Z!ˀJtvL/ 52á|~H_l?PW18n mEr98Au~ .aP
ѻZ_l/+dΟխ"^̜搄dZ!^$ծFGxcwb0{aڻ6r!&ARw),;4ŰV?o+.Z೬#q8;W7lf{JA`_454 bx՟ W$/=w
KQ&yi\?МK ݩ 4 QNڡ2ǜ Q
u^Kv!ۛ,(.m}wAIxq9s_^`" w}
/vʁ' sL<7h>Ӗֶ6܁{owIa
1T/f IN9$QL7 qEO! ,v^8 @
+TH$|G
\>;K.OR u3^H;JuI}n?uLBU P>vǁ@Js:&¤I(n? p~ַ[R}HM 1<'S$g3uwg^\$`ԁp7ȏ旔Nt:ټ t?M6
6,=@wh"I^Y Ԣ_Ο.X^L
sP!9? :cR є̰X@) %7r+ί 3t=nȡ.M A$qG0 ߐ.' B `ne2ii! P0?ہceR 6yL`kH|k D3; 4 BaB r vU&)B' 64ؚ Y 1IX"3hH4pq`aR
V*4D'E׀K&)\0DjXo]&Il@gL`$ItOf0!$ve@g8C!]* v 32yFRԢ3cm4J,JHR ~ NR>
~`Tf0n`]Fe ) 蕠]kKxX#Se$XG
`b+) °_I7"y ?wdӼ7DR ܫ)4 "e5( Bx^&0~& 9?@@942 6(*n732Ϥ S ?Dƿkf B@I7+3/@M M DHs
c7\fX0)rVr~1Kq$_;) Mr~ Q. -SX|O*":g&D%q8#)V?MROd :P$Ң/ u`[⏴}m VY%Ꞥ9@
Yª?Wk&:p"m[ ӞZXMJD:=IG}+ޕt^$ݮp0m}~ \EG:OKN|i3u_=r%凸
|}:"`ߒ9? mp2\UY\9 '>U^,D
}f}'frj 8;*6'h=9 ?o{
&= ,7c9]c//p#J`NyjqGn)]r}cҋ?Wq|pྊ[mC>xIYt{
/dmQTJq%gɜ=%gVJs_;R\IbbK?Br
{!`}gDq62η}@/wψ?q_
|PXf깾0dZlݖ3 '
fcjV~, nï-_n]ZSzm pV M ;c"%LS[5vdk@xޠq[s:g^'~3h.cGp' ɒ2r usF
Z-w*J`!8^֫8wXuY9d[oL
!QR-+܂^cV1%n a kBDl =n%oZ/ oU+3A N?Wi}*yi$ϴܐ_A7s ēV}wI/ yƱ{ bHkެ+ 9R!97gNו_b(!@{ߔp \U} `&]}~-
U1LK?Gkj3b9?ˤy
f`81gX`,.Lnviuԩ/8[S 3vjm]_eXUs r~1 gkbqxPE^HP]~fy8w|TtG Cy Uw34D
ԍ?1U\b1}!b>G
-s pET
gmb
VCLĔ}?+*fٸ[mB jD:#S 5Wv,C bp/ǁ5Dl!@
~I!<(iঀ?g_2M9'*n+PRAEIEu0K 8TCI ?¨f[_/ > mR&8l)
=(|ΞWo0p&XR%yϷs0ܕ:/L*P]q7_ G|EE.CzfGq봀r~!V 8Vu+]Yr~! ~ϓE]-D {
testExtractingWhenPasswordIsIncorrect("sunflower_embed_ok.gif");
});
}
@Test
public void testIncorrectPasswordFromBmpFile() throws Throwable {
assertThrows(SteganoExtractException.class, () -> {
testExtractingWhenPasswordIsIncorrect("snow_embed_ok.bmp");
});
}
@Test
public void testIncorrectPasswordFromJpgFile() throws Throwable {
assertThrows(SteganoExtractException.class, () -> {
testExtractingWhenPasswordIsIncorrect("landscape_embed_ok.jpg");
});
}
private void testEmbeddingAndThenExtractingOk(String imageName)
throws SteganoImageException, SteganoEmbedException, InterruptedException, java.util.concurrent.ExecutionException, SteganoExtractException {
testEmbeddingAndThenExtractingOk(imageName, THE_MESSAGE);
}
private void testEmbeddingAndThenExtractingOk(String imageName, String message)
throws SteganoImageException, SteganoEmbedException, InterruptedException, java.util.concurrent.ExecutionException, SteganoExtractException {
embedPayload(imageName, THE_PASSWORD, message);
assertTrue(new File(outputPath).exists());
extractPayload(outputPath, THE_PASSWORD);
assertEquals(message, extractedMessage);
}
/**
* Returns a message that compresses badly, so its embedded size exceeds GIFShuffle's
* palette-based capacity even though it is far smaller than the image's pixel capacity.
*/
private static String incompressibleMessage(int length) {
Random random = new Random(42);
StringBuilder message = new StringBuilder(length);
for (int i = 0; i < length; i++) {
message.append((char) ('a' + random.nextInt(26)));
}
return message.toString();
}
/**
* GIFShuffle only reorders the palette, leaving every pixel's color untouched, while the sorted
* color table method encodes into the pixel data. Comparing per-pixel colors therefore shows
* which of the two methods embedded a steganogram.
*/
private void assertPixelColorsUnchanged(String carrierName, String steganogram)
throws SteganoImageException {
assertTrue(
pixelColors(pathOf(carrierName)).equals(pixelColors(steganogram)),
"expected GIFShuffle to leave the pixel data untouched"
);
}
private void assertPixelColorsAltered(String carrierName, String steganogram)
throws SteganoImageException {
assertFalse(
pixelColors(pathOf(carrierName)).equals(pixelColors(steganogram)),
"expected the sorted color table fallback to alter the pixel data"
);
}
/** Returns the per-pixel colors, which stay the same when only the palette is reordered. */
private List pixelColors(String path) throws SteganoImageException {
GIFImage image = (GIFImage) ImageFormat.getImageFormat(path);
List table = image.getColorTable();
int[] pixels = image.getPixels();
List colors = new ArrayList<>(pixels.length);
for (int pixel : pixels) {
colors.add(table.get(pixel));
}
return colors;
}
private void testExtractingWhenPasswordIsIncorrect(String imageName)
throws Throwable {
try {
extractPayload(pathOf(imageName), INCORRECT_PASSWORD);
} catch (Exception e) {
throw e.getCause();
}
}
private void embedPayload(String imageName, String password, String message)
throws SteganoImageException, SteganoEmbedException {
String imagePath = pathOf(imageName);
StegosuitePresenter presenter = getPresenterFor(imagePath);
presenter.setEmbedding(embeddingAlgorithm);
presenter.addMessageToPayload(message);
presenter.embedNotifying(new EmbeddingProgress(), password, null);
}
private void extractPayload(String imagePath, String password)
throws SteganoImageException, SteganoExtractException {
StegosuitePresenter presenter = getPresenterFor(imagePath);
presenter.setEmbedding(embeddingAlgorithm);
presenter.extractNotifying(new EmbeddingProgress(), password);
}
private StegosuitePresenter getPresenterFor(String imagePath)
throws SteganoImageException {
ImageFormat image = ImageFormat.getImageFormat(imagePath);
return new StegosuitePresenter(image, ui);
}
private class UIStub implements StegosuiteUI {
@Override
public void showEmbeddingError(SteganoEmbedException e) {
throw new RuntimeException(e);
}
@Override
public void showExtractingError(SteganoExtractException e) {
throw new RuntimeException(e);
}
@Override
public void extractingCompleted(
String extractedMessage,
List filePaths,
Visualizer visualizer,
ImageData imageData
) {
EmbeddingAndExtractingTest.this.extractedMessage = extractedMessage;
}
@Override
public void embeddingCompleted(
ImageFormat embeddedImage,
String outputPath,
Visualizer visualizer
) {
EmbeddingAndExtractingTest.this.outputPath = outputPath;
}
@Override
public void addPayloadFile(
String filename,
String extension,
long fileSize
) {
}
}
}
stegosuite/src/test/java/org/stegosuite/MessagesBundleTest.java 0000664 0000000 0000000 00000001064 15260777315 0025344 0 ustar 00root root 0000000 0000000 package org.stegosuite;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.ResourceBundle;
import org.junit.jupiter.api.Test;
public class MessagesBundleTest {
@Test
public void testMessagesBundleIsOnTheClasspathRoot() {
// The UI resolves the bundle with ResourceBundle.getBundle("Messages"), which only finds
// Messages.properties at the classpath root. Guard the resource configuration that puts it there.
ResourceBundle bundle = ResourceBundle.getBundle("Messages");
assertTrue(bundle.containsKey("browse_files"));
}
}
stegosuite/src/test/java/org/stegosuite/PresenterTest.java 0000664 0000000 0000000 00000015451 15260777315 0024417 0 ustar 00root root 0000000 0000000 package org.stegosuite;
import static org.junit.jupiter.api.Assertions.*;
import static org.stegosuite.Resources.pathOf;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.List;
import org.eclipse.swt.graphics.ImageData;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.stegosuite.application.StegosuitePresenter;
import org.stegosuite.application.StegosuiteUI;
import org.stegosuite.image.embedding.EmbeddingProgress;
import org.stegosuite.image.embedding.ProgressListener;
import org.stegosuite.image.embedding.Visualizer;
import org.stegosuite.image.format.ImageFormat;
import org.stegosuite.model.exception.SteganoEmbedException;
import org.stegosuite.model.exception.SteganoExtractException;
import org.stegosuite.model.exception.SteganoImageException;
import org.stegosuite.model.payload.block.FileBlock;
public class PresenterTest implements StegosuiteUI, ProgressListener {
private static final String IMAGE_NAME = "snow.bmp";
private static final String EMBEDDED_IMAGE = "snow_embed.bmp";
private static final String FILE_CONTENT = "The content of the file";
private static final String FILE_EXTENSION = "txt";
private static final String FILE_NAME = "file.txt";
private final String message = "a message";
private final String password = "a password";
private int currentProgress;
private EmbeddingProgress progressListener;
private StegosuitePresenter presenter;
private String outputPath;
private ImageFormat embeddedImage;
private Visualizer outputVisualizer;
private String extractedMessage;
private String statusMessage;
private ImageData imageData;
private String addedFileName;
private String addedFileExtension;
private long addedFileSize;
@BeforeEach
public void setUp() throws Exception {
progressListener = new EmbeddingProgress();
progressListener.addProgressListener(this);
}
@AfterEach
public void tearDown() throws Exception {
Resources.delete(EMBEDDED_IMAGE);
}
@Test
public void embeddingTest() throws Exception {
presenter = presenterWithImage(IMAGE_NAME);
presenter.addMessageToPayload(message);
presenter.embedNotifying(progressListener, password, null);
assertEquals(100, currentProgress);
assertNotNull(outputVisualizer);
assertEquals(pathOf(IMAGE_NAME), embeddedImage.getFilePath());
assertEquals(pathOf(EMBEDDED_IMAGE), outputPath);
assertTrue(new File(outputPath).exists());
}
@Test
public void extractTest() throws Exception {
presenter = presenterWithImage(IMAGE_NAME);
presenter.addMessageToPayload(message);
presenter.embedNotifying(progressListener, password, null);
resetCurrentProgress();
presenter = presenterWithImage(EMBEDDED_IMAGE);
presenter.extractNotifying(progressListener, password);
assertEquals(message, extractedMessage);
//assertEquals("Extracting completed.", statusMessage); TODO: use filePaths instead
assertNotNull(outputVisualizer);
assertArrayEquals(imageDataOf(EMBEDDED_IMAGE).data, imageData.data);
}
@Test
public void extractFileTest() throws Exception {
presenter = presenterWithImage(IMAGE_NAME);
presenter.addFileToPayload(pathOf(FILE_NAME));
presenter.addMessageToPayload(message);
presenter.embedNotifying(progressListener, password, null);
resetCurrentProgress();
presenter = presenterWithImage(EMBEDDED_IMAGE);
presenter.extractNotifying(progressListener, password);
assertEquals(message, extractedMessage);
//assertEquals("Extracting completed. Extracted file saved to "
// + pathOf(FILE_NAME), statusMessage); TODO: use filePaths instead
assertNotNull(outputVisualizer);
assertArrayEquals(imageDataOf(EMBEDDED_IMAGE).data, imageData.data);
assertEquals(FILE_NAME, addedFileName);
assertEquals(FILE_EXTENSION, addedFileExtension);
assertEquals(FILE_CONTENT.length(), fileBlockSize());
assertEquals(FILE_CONTENT.length(), addedFileSize);
assertEquals(FILE_CONTENT, readContentFromFile(FILE_NAME));
}
private long fileBlockSize() {
return presenter
.payloadFileBlocksWithFilename(FILE_NAME)
.stream()
.findFirst()
.get()
.getSize();
}
private FileBlock getFileBlockFromPresenter() {
return presenter
.payloadFileBlocksWithFilename(FILE_NAME)
.stream()
.findAny()
.get();
}
private StegosuitePresenter presenterWithImage(String imageName)
throws SteganoImageException {
ImageFormat image = getImage(imageName);
return new StegosuitePresenter(image, this);
}
private ImageFormat getImage(String imageName)
throws SteganoImageException {
return ImageFormat.getImageFormat(pathOf(imageName));
}
private String readContentFromFile(String fileName) throws IOException {
return Files.readAllLines(Paths.get(pathOf(fileName)))
.stream()
.reduce(String::concat)
.get();
}
private void resetCurrentProgress() {
currentProgress = 0;
}
private ImageData imageDataOf(String image) throws SteganoImageException {
return getImage(image).getImageData();
}
@Override
public void showEmbeddingError(SteganoEmbedException e) {
throw new RuntimeException(e);
}
@Override
public void showExtractingError(SteganoExtractException e) {
throw new RuntimeException(e);
}
@Override
public void extractingCompleted(
String extractedMessage,
List filePaths,
Visualizer visualizer,
ImageData imageData
) {
this.extractedMessage = extractedMessage;
//this.statusMessage = statusMessage; //TODO: Use filePaths instead of statusMessage
this.outputVisualizer = visualizer;
this.imageData = imageData;
}
@Override
public void embeddingCompleted(
ImageFormat embeddedImage,
String outputPath,
Visualizer visualizer
) {
this.outputPath = outputPath;
this.embeddedImage = embeddedImage;
this.outputVisualizer = visualizer;
}
@Override
public void addPayloadFile(
String filename,
String extension,
long fileSize
) {
addedFileName = filename;
addedFileExtension = extension;
addedFileSize = fileSize;
}
@Override
public void onProgressUpdate(int percentage) {
assertTrue(percentage >= currentProgress);
currentProgress = percentage;
}
}
stegosuite/src/test/java/org/stegosuite/Resources.java 0000664 0000000 0000000 00000000745 15260777315 0023562 0 ustar 00root root 0000000 0000000 package org.stegosuite;
import java.io.File;
import java.net.URL;
public class Resources {
public static String pathOf(String fileName) {
URL resourceURL = Resources.class.getClassLoader().getResource(fileName);
if (resourceURL == null)
throw new RuntimeException("The resource " + fileName + " does not exist");
return resourceURL.getPath();
}
static void delete(String filename) {
try {
new File(pathOf(filename)).delete();
} catch (Exception ignored) {}
}
}
stegosuite/src/test/java/org/stegosuite/image/ 0000775 0000000 0000000 00000000000 15260777315 0022021 5 ustar 00root root 0000000 0000000 stegosuite/src/test/java/org/stegosuite/image/format/ 0000775 0000000 0000000 00000000000 15260777315 0023311 5 ustar 00root root 0000000 0000000 stegosuite/src/test/java/org/stegosuite/image/format/GIFImageTest.java 0000664 0000000 0000000 00000003211 15260777315 0026361 0 ustar 00root root 0000000 0000000 package org.stegosuite.image.format;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.io.File;
import java.util.Arrays;
import java.util.stream.IntStream;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.stegosuite.model.exception.SteganoImageException;
public class GIFImageTest {
private GIFImage image = null;
/**
* Using @BeforeEach here so that we work with a fresh copy of the image for each test
*
* @throws SteganoImageException
*/
@BeforeEach
public void beforeMethod() throws SteganoImageException {
image = new GIFImage();
image.load(
new File(
this.getClass()
.getClassLoader()
.getResource("sunflower.gif")
.getFile()
)
);
}
@Test
public void testWidth() {
assertEquals(1160, image.getWidth());
}
@Test
public void testHeight() {
assertEquals(1376, image.getHeight());
}
@Test
public void testGetPixels() {
Integer[] pixels = IntStream.of(image.getPixels())
.boxed()
.toArray(Integer[]::new);
assertEquals(pixels.length, image.getWidth() * image.getHeight());
assertEquals(-2099205017, Arrays.deepHashCode(pixels));
}
@Test
public void testSetPixels() {
int[] pixels = new int[image.getWidth() * image.getHeight()];
Arrays.fill(pixels, 0);
image.setPixels(pixels);
assertArrayEquals(image.getPixels(), pixels);
}
}
stegosuite/src/test/resources/ 0000775 0000000 0000000 00000000000 15260777315 0017046 5 ustar 00root root 0000000 0000000 stegosuite/src/test/resources/file.txt 0000664 0000000 0000000 00000000027 15260777315 0020525 0 ustar 00root root 0000000 0000000 The content of the file stegosuite/src/test/resources/landscape.jpg 0000664 0000000 0000000 00000170153 15260777315 0021511 0 ustar 00root root 0000000 0000000 JFIF C
C " E !1A"Qa2q#BR$3br4CS% C !1AQaq"2BR#$3C4Sbr ? JH@څxj$mK _զ:Єin*
p;b0leʈnvƝ܊C+ 1]B$f#aI ,~+Hϓ 9&0I Ph ֺ^i1zHͪ%5U9ޒЮH
}v,Ǔz2GI{qx8ځZFapcsxr*@( GV@p [wc3i(%xLqm^=;<Hv=t$wKh@nں }jv-28, d+V qon 7h:IJɒI}(=8 a9iLAv%
ۻ1
OyheF1 UqQ01Uf$c gzOr5T"iYܒ{3N7 D|S9 j]$R ['jIUl;bAY-qnO0W!FvƬoP4RI:{8J-rOB :Β` |v,QJޛf;!2}G)rK ɤX z07#j;}isDY4ڐҝy 9ںls/U;M u9H%.jKGZNI8lfRqN0dӒ852qګ15 Ɣ]l&Os:I+TH[ ^U;bRRa;`v R?ڬt
27c( !R`|ף ɣTn >P ϭ&coR#$xI#zT$i;zRNd0
@mϧza}M6>Җ9#MY\
YmQ -R61V9~jb¬( }{U*@9jᅑH99j^ۄ(&@9$ ^3VO~MX$k4& %st帑11!~
i!k39?&~<(D,E{c];cxu6"H%X _ڽrya9)
X\w8Ξ@,$SP\lˍ,d *@n cBZQbF? qjh6`Ҍn[zM lܜY8#=qk;B *)$sH A36
$}[L3!s5 l-1 {-+,7I$
b AH#PޅՕ#rsIHJ4NYl i x֛W8 Coڭ-VDN}MG"ifI$5$ i j-,rޅFr@V4LaJfZN6{R.4AJ-sD\ a_ޟbceXٶn+Dа9~4:K#8+m?CAlmZ #s{7 @@5l
PSji] cn;jQc oqvN 5
r@'~sڄ᳣Q' 23S eAqT_*H$2 LUlst0c@ =RlS ~h=c2@y&})Xj݈ {gV:qiN *2pN98 5kP_ 2q_ZF8 GzǠXT ,9#ޕGd̪< x)p3 St85վA]sp= Ψ`CVnw z£=묎:jIm;B T#|
}0B\m2xڨTkdI݁c}@"
{zUȡ=6+0egҺ~du0#9 J9N[ UR.I]9 s!+- HoOڹj1"-Utmff%pNG Rw 4~E
A9]Iinj$sFM1@sEMj"rA pH;6 6$ ('#wEF;LA#p}
.rQw4\tRM[j OGlJvت /nNB"_LzWJS~GI<#!ո ¸7nц ns5۹$Ql~vw uD[iLi2N \ '^~|9 [) ACm
{d LJgcV2 ON
<?$x? :7Pji*y$< {O 4.sI0ɀq}GN+;bg ;L-kb ~ ،m7P@s@BpH R;ӊm 4\iRO85; ֜T vYbpi
\@+e9 ڨǚ o`IP UYިaؒ=X)'g8Ѭ;d?G|{05͈#߰e w ǭ4]D ބۑ ; z _U
u!
#z
8ܒ1T7C0r2wڹv+Cj zP! n~SgjQ 7ޭJ:F|J j=0]V :C
v Ʊ ,Gm:H99ڹ25rԜ)PTp7H!N,0wږbJ [3q|r1 D j
QǚŏP$g3Q*%m 2+
\#8?T p6 o 4 0.2{B ERpkv})Pxlx\hY1E"J
N2wD_)'9#zjbnHj'9;jWRu @P 6ZAՌ23ގX^FqVʢ@#ZA%<O90NմL up64%rq[E7bی@ܟ#N}}+H˓\7ڨe -qZř̝HNp?jƮ?ZCsZ&r} )S9 -qk6NT$eqO8ڄ1~L̘=}h
'n=F{}Jgq4&+HI}PW;㍩l p}BAO밨ނV2 elA Թ^iHB6 Sa vތZdKc.#
p &sn6r ϵY#3NGnդO3'a ~Ԣ9N*OMP27;ɞynM@W n;U>;PhNnx\v9$frjLGaK(5mZڀ93<4 ;akA%sF?h=A8oڳSL/̟'慔 OdVxg9 &
obr `sKڹ9c vBN1E+U *Oa=5$85K(cE&r *fĘqweQ 5Bʐq6 ckJ 2NՄ`jIg IHbn>^W 02 C#7;oRX
o [DvNɃ|3 A`G?qNhq[=Bw 6B]8*j 1Q
VѓU}ʝ r*f=pkvD\g#?]#n >آ-QQW G<ג#
003]" 1I֩G; ͝,5]:I sKf$g#OvcOf{]Fsjh\`cizSnH"@>v:I# *NԹXښZ2m*9#͌R%
z9)mh&d I&(Nڦ}Oni$NiXQBحb &}K
r1j{g+[&fy"WR GI V<}dvYRD.78;.KjS)9艄1NN3@PpGlU,9Sj&d J
wH;RL
['lzҴ^'|VdFFqTɁ3T&e;` P2*CHڒa);ceTP jf)SqzB0B lTgssB˝'M0U:>вs=*; QF`hG %19Xls cɌcg,9# ({*FSR3h1-ЍqT#?JBi'#&T }x< c'hgSL
k>@cn
Sd3s_I04RfMVOx-;вj9Mz )I wqXStSRjO ~VI=4oj(`DHՃ愨 BǷ .3 T ( o;P=Ҩ`P p7E$T!;@cc m d ު*8B~ ڰ(;b3<njj< Z w% i = $j#li?~)&1} g 1\si) A>Sa:| COվ;Vy ۏZȞzX>GL@@$mڍ n'a; 0@\?9-YX/lzUL<ʸCoJq5*dΧHR ϿN$ }꧌`gp7j$gu|DB[ږѝY Suyp79 iq\~#3ZD·C{Sg} 2wj0Q;w8 j^=TЗ\g>S
Jq ibSmj)lֱ`h@ ̢ҵLALF)2d> -~ z^`hAMwK+5I_Q@ H Gq@S PJ ։J@8ǥ(s~PcM04JɁN@TSl
~Ԃ3&F,緮* 2zjAq%dPO
Lp1M05OMN TSpx sZ)2x}eǵT@
z8ӵ$D̘Sӂqz;vH&*HG#,ӟJ@PRA)A#dpsJ MH-C ֘N a sa6#|` 'AɲR` +
ĀFH 8`>]d?OJ Fh䁍 $r)Z3wbwp6+ްc, 'hCf`{ z 'p;gՌј®p c`j9#IYm}3IPO\SiڈE#rj
Pa
,l@g`@ 'E;mHo
Y0ufzm
ZNԶ\탚H
(7qK+I_A(J MJW} )2v*FF)
')%@1QԂP(4ahfm
cU,c SLLќccQAG`(vsIH-gz @z o}kE 5{y
8ުhp)e =9 {*B'j@kBfB6 z PoY} & N7 zNۏ%
c}l U cC*F8℮vI횶u&(!n6z(MD FǾjZ'X9 o{@;Oq03EPl3N}+
ٮ}1 })@U. v :+vk 7F$ý80 8"n8,G(Kn%vwN7e}PWjTDN)/5Kv_$3/@GPWn;RʌR3hJހ)R1%70v۵\g ֊@hP TyHqMH4NP m@˿l
|f'j@hИǵSzRN뜌VAh,}RG;(*;T2v"GZ)}(Jd?9Y3C 50U o U #JAq$d~ ܊cf&ڀw;څm5 )M88Y g 0qMH.$>E{
zm,ޚr.9n1BSڪ)4 x%#7|1߿(J "<`g|L |g|*$m}K?#TcNc5 5̗B'Adcj; b 1K0\I|>N1+t` Z:bktH㰤w sz K ܓEِޑ?Qe2$%"G9)ޚ("Ǿ1E';MH
?j^}8 ~Ō珿zDq#*NN
LgjǝP$֞`Q.V==T4{`Иw `Џ r+< vިyQ. i {W5DIF 2@9<
#q8nvEgm]3Հ+E3'\`o9^;ޜTv?-v Ӱjm"y' g4
\J vߚC
;x snQB; g#+Ac&{91|oBбa}gRRcC;Ul;1?W!T}+EN ~ӎFUQwl$\a.G }9 -pvR9㶆!# y#ׇ ݡ{$>~L}czIs/2^ud3N >%߿jJ60 hZc$>SΌ6Z܁ 7T 7 U'#<PmkHЀjB=8. BpwڣDs90#AOj
SR
dl~S.6@WzJdh(]1ک("# ~iD @W`qQQ R&RBNت1ބjfn4M;igN柣͵xޖr%ԟmƃFvU`ߵn?ʮz&Rbc%# iSJh@8xϦhBc ުtx RRsrO=p)qKyڨ] 3)eҴҴx4[| 1T ڀhfJv8BS )5QLP$Zj@q$1vW
e,I^"[ښ{o]h:# WF>g,yⰟtG OV>B@j.psm>T4*OBЏ
~sM^o 6[ RӶrOTRĖMad94qJRhsZ X %Iy& {Ԓܻ$j-)v$[F)r$NH1'w>Xud Pl@?kC {Ј\k 9"Ź$KN p }BW=WaƠdjgp|2;Wrw ߌ ƞvɕX+C~۟xIs ;WfT'! %ߚ0[獲7\IvƣG+ m]Pb A JNl3r
-9
UWН> 'HARKp3kJ=ꂔ7ڞWBP3YIw /PVS&Rv\)e2xJjjGe&+BWjN;PԃD3z[ fdl!撐h *LT愦9 S&RR JQAP4{ښ\IP2bd SS ;
TW~>G1Z)ހy@VZ%)hJ \)4,SSDv>%6Yht`b\IJ Jw+Z)Ę c@MTPqXSq6C:
S- h
$Hc5QM SRb74&.1(
g8P'ުh j zJaq&\`
Cc4:0?mf{Ka欎X.AT:N}ꩫtF\qsY^?j6ߊHɢfSoJmꢇ0jj}Ah<YH8aI9F 2}E»QZ@$_14 vЗkcEvpWN(\z,,Wd7`>mz Ė^ =u2Ü!drNJ28 AT<я且8 3^+.7W{Иɦɰ$u zKʉ>mj rƵRH|G5&o֫*~ޔ'|v9 (,wPm ns߭$ZHIW<$gz6H>Բ탃M6F!m 7'怄 5d*H
I\r} rqϥ5afIi.w##R#uvOps#@cU j5Ez& 1L cBPqWk,ĢdM'm+Xm7hxڒ#D}Lkm5!%TcnԲ{Us@S JAhw(j 14'l{UE891YÐEsU x순FdzS"3ٶ7D-v%(NÿzO8
qDbM E rpBDvqz#aȪ:#ud8>`KVDy4 6ޔx$x*Z #=(NJ*BvWs"-&JXPc]σ(N qqfABe "lctD0tNs+Y
-%aږ{0`^L|Ku
$BNBK1WG!P2A V8X
Z+ #>բFW[]p>bXTD!՜Ҹշ~7NmU=˜`cJ3v
>qf\kDSF 50NHجR7 I pas]l8a QǾ s)wy@l]|ȹ
g?G#4lsYE q3AW'ޏ!O$TJJl9QYx\{ЙH<|oZ vu̴@;c vqY.7GrKR mBі'zTcL}P =븭a'̍-]M[&;4>uA ,y]4^3cXQBMs$?|VjMssN? zych\}]ē^ W4b2JxacprOy F=l#`fZEJ-98Տ#mm͖E Zp62(-mޘ Vyd P- 9\LQxޅ# TX+b;v[SBO"^Z[4kV&{xƚN{V +2 .#LAr9
0(|1 T1ыU[ >Dc?
]/8 V %_LP~* W П7N8Ұ'v:bdM;)ӵ,ⴎ1 l(oL#ִX# Yf' Q Hjk *?' Y ]#4%s5V) +ޚCsMbP}E4BCzRXhKn(>%I; X$в 3xr z|tN dNqB`[}錌 'sKdQE)oZ1Ucy>zRk k<M
JK m#ҳNx
's@tXxDЕ߃T f#McЍ'^$;~g&g\ŴL r49hFϨX̬;i ֑+iq| {zq\BW)`1%G8ӎi{P% 愦iM{@4ȏ %27C#ۊ9"?\M{WwYl-֚PN Gpؒ2;ilUbC ?؏~j";Y[&N~Q% @L`ߜWq [Yɯ1
#+
]*`nއ)$;Ј~ֻ|@ ~ªÀiB9گ*lE)8`GވZ| {
ݘHޠ{~'QOi.}MhG?6l,pΣ5I xg( NQxqkZDyX۫y <_SE5 #l e?ni=Z[P
FjĮQ5 ^3]|1Jsg5 O?$ j)ǥU% } l~*S!ބ=,E9Xב Rw民Z,dea3p(5v5@Y8-l+,wPr),tN 0r°OڰcBHkЖlq[BOb)s7$ J3(r
53a) ek09#ք^!BTm{ ʽ JK߇od,۸,6Y"O]/%И;Pګ N%;G߄| `V n7XF?pElЂ ޚҐ6w& L-#>fߚ 7̜ P
K'}k/ry (4 89$X90徦jy?[Xsɥ9`hұ/moXLcE zx
?J! 흽&^Ԅy43xkz/(q"sF&Q(I8P{ VNQx˙p #|uo&y +lC%r<>8F̧I>p?49mGJskb$a%Xm2 ` P4B#|-XWK83`m7,x1 0k_c(2ڹ*BF ciEf&Z)3 G3 TSP['֮c4#zHi N?4 {UH Qx;ސY-,coZ "Ks@μ~+
/28>(2qxe~1qR%%PdP_Z-%?X9̞%{S7;zRO Lڧk