Java_最不重要位替换(LSB)基于24位BMP图片

隐写术的一个简单示例

向BMP图片中隐藏一段文字并保存,从保存的图片中提取文字.

原理:把需要隐藏的文本信息转换成二进制字符流,再将其拆分成一个个的0和1,隐藏在像素数据(RGB字节)中,因对RGB的改动很小,添加了隐藏信息的bmp图片和原始bmp图片看起来"一模一样";利用相反的手法可以将数据提取出来.

本程序只是隐写术的一个简单的具体实现.

bmp图片存储格式参考这一片文章: https://www.cnblogs.com/Matrix_Yao/archive/2009/12/02/1615295.html

注:保存后图片变形问题已解决   于2019/6/22 日

Java代码:

import javax.swing.*;
import javax.swing.filechooser.FileNameExtensionFilter;
import javax.swing.plaf.FontUIResource;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.*;
import java.time.LocalTime;
import java.util.Arrays;
import java.util.Enumeration;

/**
 * @author lw
 * @date 2019/6/20 20:43
 */
public class InfoHideToBmpImage extends JFrame {
    private int displayWidth, displayHeight;
    private JTextArea textArea;

    private InfoHideToBmpImage() {
        Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
        displayWidth = (int) (screenSize.getWidth() * 0.7);
        displayHeight = (int) (screenSize.getHeight() * 0.7);
        initFrame();
    }

    private void initFrame() {
        Util.setUIFont(new FontUIResource("微软雅黑", 0, 20));
        setLayout(new BorderLayout());
        setJMenuBar(initMenuBar());
        add(initTextAreaJScrollPane(), BorderLayout.SOUTH);
        setTitle("LSB隐藏器");
        setSize(displayWidth, displayHeight);
        //设置窗体出现在屏幕中间
        setLocationRelativeTo(null);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setVisible(true);
    }


    private final String FILE_MENU_NAME = "File";
    private final String OPEN_MENU_ITEM_NAME = "Open";
    private final String SAVE_MENU_ITEM_NAME = "Save";
    private final String LSB_MENU_NAME = "LSB";
    private final String HIDE_MENU_ITEM_NAME = "Hide";
    private final String SHOW_MENU_ITEM_NAME = "Show";
    private final String BMP = "bmp";

    private JMenuBar initMenuBar() {
        JMenuBar menuBar = new JMenuBar();
        MenuItemListener listener = new MenuItemListener();
        JMenu menu = new JMenu(FILE_MENU_NAME);
        JMenuItem openItem = new JMenuItem(OPEN_MENU_ITEM_NAME);
        openItem.addActionListener(listener);
        JMenuItem saveItem = new JMenuItem(SAVE_MENU_ITEM_NAME);
        saveItem.addActionListener(listener);
        menu.add(openItem);
        menu.add(saveItem);
        menuBar.add(menu);
        menu = new JMenu(LSB_MENU_NAME);
        JMenuItem hideItem = new JMenuItem(HIDE_MENU_ITEM_NAME);
        hideItem.addActionListener(listener);
        JMenuItem showItem = new JMenuItem(SHOW_MENU_ITEM_NAME);
        showItem.addActionListener(listener);
        menu.add(hideItem);
        menu.add(showItem);
        menuBar.add(menu);
        return menuBar;
    }

    class MenuItemListener implements ActionListener {
        private final String DEFAULT_CURRENT_DIRECTORY_PATH = "C:/Users/LW/Desktop";
        private JFileChooser fileChooser;
        private BmpImageInfo imageInfo;
        private static final byte OPEN_FILE = 1;
        private static final byte SAVE_FILE = 2;

        MenuItemListener() {
            fileChooser = new JFileChooser(DEFAULT_CURRENT_DIRECTORY_PATH);
            fileChooser.setFileFilter(new FileNameExtensionFilter("24位位图(*.bmp)", BMP));
            fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
        }

        @Override
        public void actionPerformed(ActionEvent e) {
            switch (e.getActionCommand()) {
                case OPEN_MENU_ITEM_NAME: {
                    openHandler();
                    break;
                }
                case SAVE_MENU_ITEM_NAME: {
                    saveHandler();
                    break;
                }
                case HIDE_MENU_ITEM_NAME: {
                    hideHandler();
                    break;
                }
                case SHOW_MENU_ITEM_NAME: {
                    showHandler();
                    break;
                }
                default: {
                    break;
                }
            }
        }

        private void showHandler() {
            if (null == imageInfo) {
                textArea.setText("请选择图片后重试");
                return;
            }

            String info = Util.analysisHideInfo(imageInfo);
            if ("".equals(info.trim())) {
                textArea.setText("提示信息: 解析出来的信息为空");
                return;
            }

            textArea.setText(info);
        }

        private void hideHandler() {
            if (imageInfo == null || imageInfo.blue == null) {
                textArea.setText("请打开bmp图片文件后重试!");
                return;
            }

            String text = textArea.getText();
            if (null == text || text.trim().length() <= 0) {
                textArea.setText("请在文本框中输入需要隐藏的文本信息后重试");
                return;
            }

            if (Util.hideInfoToBmp(imageInfo, textArea.getText())) {
                textArea.setText("隐藏文本信息成功");
                return;
            }

            textArea.setText("隐藏文本信息失败");

        }

        private void openHandler() {
            File file = selectFile(OPEN_FILE);
            if (null == file) {
                return;
            }

            imageInfo = Util.analysisBmpImage(file);
            showBmpImage(imageInfo);
            textArea.setText("打开图片文件成功!");
            if (imageInfo.getBfOffBits() > BmpImageInfo.DEFAULT_BF_OFF_BITS) {
                textArea.append("  图片文件有可能存在隐藏信息");
            }
        }


        private void saveHandler() {
            File file = new File(generateSaveFileName());
            fileChooser.setSelectedFile(file);
            file = selectFile(SAVE_FILE);
            Util.saveBmpImage(imageInfo, file);
            textArea.setText("保存图片文件成功");
        }

        private String generateSaveFileName() {
            File selectedFile = fileChooser.getSelectedFile();
            String name = selectedFile.getName();
            name = name.substring(name.lastIndexOf('_') + 1);
            String parent = selectedFile.getParent();
            String now = LocalTime.now().toString().replaceAll(":", "-");
            return String.join("", parent, "/", now, "_", name);
        }

        private File selectFile(byte type) {
            // 不是确认
            if (type == OPEN_FILE && JFileChooser.APPROVE_OPTION != fileChooser.showOpenDialog(null)) {
                return null;
            }

            if (type == SAVE_FILE && JFileChooser.APPROVE_OPTION != fileChooser.showSaveDialog(null)) {
                return null;
            }

            File selectedFile = fileChooser.getSelectedFile();
            String fileName = selectedFile.getName();
            String suffixName = fileName.substring(fileName.lastIndexOf(".") + 1);
            if (!BMP.equals(suffixName)) {
                System.out.println("非BMP类型文件");
                return null;
            }

            return selectedFile;
        }
    }

    private JScrollPane initTextAreaJScrollPane() {
        JTextArea textArea = new JTextArea();
        this.textArea = textArea;
        textArea.setLineWrap(true);
        textArea.setWrapStyleWord(true);
        JScrollPane scrollPane = new JScrollPane(textArea);
        scrollPane.setPreferredSize(new Dimension(displayWidth, 200));
        scrollPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
        return scrollPane;
    }

    private void showBmpImage(BmpImageInfo imageInfo) {
        DrawPanel drawPanel = new DrawPanel(imageInfo);
        JScrollPane scrollPane = new JScrollPane();
        scrollPane.setViewportView(drawPanel);
        scrollPane.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
        scrollPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
        add(scrollPane);
        // 刷新界面
        setVisible(true);
    }


    /**
     * 绘图面板
     */
    class DrawPanel extends JPanel {
        BmpImageInfo bmpImageInfo;

        DrawPanel(BmpImageInfo imageInfo) {
            bmpImageInfo = imageInfo;
            // 将画板撑大,这样当图片长宽过大时 jScrollPane 才会显示滚动条
            setPreferredSize(new Dimension(imageInfo.getImageWidth(), imageInfo.getImageHeight()));
        }

        @Override
        public void paint(Graphics g) {
            super.paint(g);
            if (null == bmpImageInfo) {
                return;
            }

            int height = bmpImageInfo.getImageHeight();
            int width = bmpImageInfo.getImageWidth();
            // 水平居中x 初始坐标
            int initX = 0;
            if (displayWidth > width) {
                Point location = getLocation();
                initX = (int) location.getX() + ((displayWidth - width) >> 1);
            }

            // 这里只考虑了 height 为正数的情况
            for (int h = 0; h < height; h++) {
                for (int w = 0; w < width; w++) {
                    g.setColor(new Color(bmpImageInfo.red[h][w], bmpImageInfo.green[h][w], bmpImageInfo.blue[h][w]));
                    g.fillRect(w + initX, h, 1, 1);
                }
            }
        }
    }

    public static void main(String[] args) {
        new InfoHideToBmpImage();
    }

}


class BmpImageInfo {
    /**
     * 默认偏移量
     */
    static final int DEFAULT_BF_OFF_BITS = 54;

    private int height = -1;
    private int width = -1;

    byte[] fileHeader = new byte[14];
    byte[] informationHeader = new byte[40];
    /**
     * 位图数据数组,即一个像素的三个分量的数据数组
     */
    int[][] red, green, blue;

    /**
     * 类型是否是位图
     *
     * @return true/false
     */
    boolean isBmpType() {
        return fileHeader[0] == 0X42 && fileHeader[1] == 0X4D;
    }

    /**
     * 是否是24位bmp
     *
     * @return true : 是;false: 否
     */
    boolean is24BitCount() {
        return informationHeader[15] == 0 && informationHeader[14] == 24;
    }

    /**
     * 初始化位图数据矩阵
     *
     * @return true:成功;false:失败
     */
    boolean initBitmapDataArr() {
        int imageWidth = getImageWidth();
        int imageHeight = getImageHeight();
        boolean flag = imageHeight != 0 && imageWidth != 0;
        if (flag) {
            red = new int[imageHeight][imageWidth];
            green = new int[imageHeight][imageWidth];
            blue = new int[imageHeight][imageWidth];
        }

        return flag;
    }

    /**
     * 获取偏移量
     *
     * @return 偏移量
     */
    int getBfOffBits() {
        return bytesToInt(Arrays.copyOfRange(fileHeader, 10, 14));
    }

    /**
     * 设置偏移量
     *
     * @param offset 偏移量
     */
    void setBfOffBits(int offset) {
        if (offset <= DEFAULT_BF_OFF_BITS) {
            return;
        }

        byte[] bs = intToBytes(offset);
        int index = 10, bi = 0;
        while (index < fileHeader.length) {
            fileHeader[index] = bs[bi++];
            index++;
        }
    }

    int getImageWidth() {
        if (width == -1) {
            width = bytesToInt(Arrays.copyOfRange(informationHeader, 4, 8));
        }

        return width;
    }

    int getImageHeight() {
        // 需要注意的是 height 有可能为负数
        if (height == -1) {
            height = bytesToInt(Arrays.copyOfRange(informationHeader, 8, 12));
        }

        return height;
    }

    private int bytesToInt(byte[] bytes) {
        if (null == bytes || bytes.length <= 0) {
            return 0;
        }

        return (bytes[3] & 0xff << 24) | (bytes[2] & 0xff) << 16 | (bytes[1] & 0xff) << 8 | bytes[0] & 0xff;
    }

    private byte[] intToBytes(int integer) {
        byte[] bytes = new byte[4];

        bytes[3] = (byte) (integer >> 24);
        bytes[2] = (byte) (integer >> 16);
        bytes[1] = (byte) (integer >> 8);
        bytes[0] = (byte) (integer);
        return bytes;
    }
}

class Util {
    private Util() {
    }

    /**
     * 设置全局页面字体大小
     *
     * @param f FontUIResource实例
     */
    static void setUIFont(FontUIResource f) {
        Enumeration<Object> keys = UIManager.getDefaults().keys();
        while (keys.hasMoreElements()) {
            Object key = keys.nextElement();
            if (UIManager.get(key) instanceof FontUIResource) {
                UIManager.put(key, f);
            }
        }
    }

    private static final String END_BINARY_STR = "0101010101010101";
    private static final char VALUE_0 = '0';

    static boolean hideInfoToBmp(BmpImageInfo imageInfo, String text) {
        imageInfo.setBfOffBits(imageInfo.getBfOffBits() + 1);
        String binary = toBinary(text).concat(END_BINARY_STR);
        char[] chars = binary.toCharArray();
        int i = 0, j = 0, cnt = 0, len = chars.length;
        for (; i < imageInfo.getImageHeight(); i++) {
            for (; j < imageInfo.getImageWidth(); j++) {
                imageInfo.blue[i][j] = getModifyBitData(imageInfo.blue[i][j], chars[cnt++]);
                if (cnt >= len) {
                    return true;
                }

                imageInfo.green[i][j] = getModifyBitData(imageInfo.green[i][j], chars[cnt++]);
                if (cnt >= len) {
                    return true;
                }

                imageInfo.red[i][j] = getModifyBitData(imageInfo.red[i][j], chars[cnt++]);
                if (cnt >= len) {
                    return true;
                }
            }
        }

        imageInfo.setBfOffBits(BmpImageInfo.DEFAULT_BF_OFF_BITS);
        return false;
    }

    private static int getModifyBitData(int oldValue, char c) {
        // 0 ASCLL 48
        if (c == VALUE_0) {
            return oldValue & 0XE;
        }

        return oldValue | 0X1;
    }

    static String analysisHideInfo(BmpImageInfo imageInfo) {
        if (imageInfo.getBfOffBits() == BmpImageInfo.DEFAULT_BF_OFF_BITS) {
            return "";
        }

        StringBuilder binStrBuilder = new StringBuilder(imageInfo.blue[0].length << 3);
        StringBuilder wordBin = new StringBuilder(16);
        int cnt = 0;
        flag:
        for (int i = 0; i < imageInfo.getImageHeight(); i++) {
            for (int j = 0; j < imageInfo.getImageWidth(); j++) {
                wordBin.append(imageInfo.blue[i][j] & 0X1);
                if (++cnt >= 16) {
                    if (isEndWithAppend(binStrBuilder, wordBin)) {
                        break flag;
                    }

                    cnt = 0;
                }

                wordBin.append(imageInfo.green[i][j] & 0X1);
                if (++cnt >= 16) {
                    if (isEndWithAppend(binStrBuilder, wordBin)) {
                        break flag;
                    }

                    cnt = 0;
                }

                wordBin.append(imageInfo.red[i][j] & 0X1);
                if (++cnt >= 16) {
                    if (isEndWithAppend(binStrBuilder, wordBin)) {
                        break flag;
                    }

                    cnt = 0;
                }
            }
        }

        return toString(binStrBuilder.toString());
    }

    /**
     * 添加内容,并判断是否结束
     *
     * @param binStrBuilder 二进制串
     * @param wordBin       一个字的二进制串
     * @return true:结束;false:否
     */
    private static boolean isEndWithAppend(StringBuilder binStrBuilder, StringBuilder wordBin) {
        if (END_BINARY_STR.equals(wordBin.toString())) {
            return true;
        }

        binStrBuilder.append(wordBin);
        wordBin.delete(0, 16);
        return false;
    }

    /**
     * 解析bmp图片
     */
    static BmpImageInfo analysisBmpImage(File file) {
        BmpImageInfo imageInfo = new BmpImageInfo();

        if (!isWindowOperatingSystem()) {
            System.out.println("非windows操作系统,终止");
            return imageInfo;
        }

        if (null == file) {
            return imageInfo;
        }

        try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file))) {
            bis.read(imageInfo.fileHeader);

            if (!imageInfo.isBmpType()) {
                System.out.println("非bmp类型文件");
                return imageInfo;
            }

            bis.read(imageInfo.informationHeader);
            if (!imageInfo.is24BitCount()) {
                System.out.println("非24位bmp类型文件");
                return imageInfo;
            }

            if (imageInfo.getBfOffBits() > BmpImageInfo.DEFAULT_BF_OFF_BITS) {
                System.out.println("bmp文件偏移超过默认偏移量,可能存在隐藏信息");
                bis.skip(imageInfo.getBfOffBits() - BmpImageInfo.DEFAULT_BF_OFF_BITS);
            }


            if (!imageInfo.initBitmapDataArr()) {
                System.out.println("初始化位图数据矩阵失败,可能未读取信息头数据");
                return imageInfo;
            }

            int imageWidth = imageInfo.getImageWidth();
            // 通过计算得到每行计算机需要填充的字符数。
            // 为什么要填充？这是因为windows系统在扫描数据的时候，每行都是按照4个字节的倍数来读取的。
            // 因为图片是由每个像素点组成。而每个像素点都是由3个颜色分量来构成的，而每个分量占据1个字节。
            // 因此在内存存储中实际图片数据每行的长度是width*3
            int skipCount = getSkipCount(imageWidth);

            int imageHeight = imageInfo.getImageHeight();
            // 这里需要注意，因为根据bmp的保存格式。
            // 位图数据中height的值如果是正数的话:
            // 那么数据就是按从下到上，从左到右的顺序来保存。这个称之为倒向位图。
            // 反之就是按从上到下，从左到右的顺序来保存。这个则称之为正向位图。
            if (imageHeight < 0) {
                // todo 大多数BMP位图是倒向的位图，imageHeight是正值,所以负值的情况暂未实现
                return null;
            }

            for (int i = imageHeight - 1; i >= 0; i--) {
                for (int j = 0; j < imageWidth; j++) {
                    // 这里遍历的时候，一定要注意本来像素是有RGB来表示，
                    // 但是在存储的时候由于windows是小段存储，所以在内存中是BGR顺序。
                    imageInfo.blue[i][j] = bis.read();
                    imageInfo.green[i][j] = bis.read();
                    imageInfo.red[i][j] = bis.read();
                }

                // 跳过每一行的补0项 ,网上有些是在j==0时进行跳过,表示傻傻不明白
                bis.skip(skipCount);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        return imageInfo;
    }

    /**
     * 获取填充的补0数
     *
     * @param width 图像像素宽度
     * @return 跳过数目
     */
    private static int getSkipCount(int width) {
        int skipCount = 0;
        int m = width * 3 % 4;
        if (m != 0) {
            skipCount = 4 - m;
        }

        return skipCount;
    }

    /**
     * 保存bmp图片
     *
     * @param imageInfo BmpImageInfo 实例
     * @param file      保存文件
     */
    static void saveBmpImage(BmpImageInfo imageInfo, File file) {
        if (null == imageInfo || null == file) {
            return;
        }

        try (BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(file))) {
            bos.write(imageInfo.fileHeader);
            bos.write(imageInfo.informationHeader);
            int bfOffBits = imageInfo.getBfOffBits();
            // 写入多余的偏移量
            if (bfOffBits > BmpImageInfo.DEFAULT_BF_OFF_BITS) {
                bos.write(new byte[bfOffBits - BmpImageInfo.DEFAULT_BF_OFF_BITS]);
            }

            int height = imageInfo.getImageHeight();
            int width = imageInfo.getImageWidth();
            int skipCount = getSkipCount(width);
            for (int h = height - 1; h >= 0; h--) {
                for (int w = 0; w < width; w++) {
                    int blue = imageInfo.blue[h][w];
                    int green = imageInfo.green[h][w];
                    int red = imageInfo.red[h][w];
                    bos.write(blue);
                    bos.write(green);
                    bos.write(red);
                }

                if (skipCount > 0) {
                    bos.write(new byte[skipCount]);
                }
            }

        } catch (IOException e) {
            e.printStackTrace();
        }

    }


    private static boolean isWindowOperatingSystem() {
        String osName = System.getProperty("os.name");
        return osName.startsWith("Window");
    }

    private static String[] PREFIX_POOL = {"0", "00", "000", "0000", "00000", "000000", "0000000", "00000000",
            "000000000", "0000000000", "00000000000", "000000000000",
            "0000000000000", "00000000000000", "000000000000000"
    };

    /**
     * 字符串转换成二进制流
     *
     * @param str 字符串
     * @return 二进制流
     */
    private static String toBinary(String str) {
        if (null == str || str.trim().length() == 0) {
            return null;
        }

        char[] strChar = str.toCharArray();
        StringBuilder result = new StringBuilder(strChar.length << 4);
        for (int i = 0; i < strChar.length; i++) {
            // 二进制ASCII码
            String s = Integer.toBinaryString(strChar[i]);
            // 补0
            if (s.length() < 16) {
                s = PREFIX_POOL[15 - s.length()].concat(s);
            }

            result.append(s);
        }

        return result.toString();
    }

    /**
     * 二进制流转换成字符串
     *
     * @param binaryString 二进制流
     * @return 字符串
     */
    private static String toString(String binaryString) {
        if (null == binaryString || binaryString.trim().length() == 0) {
            return null;
        }

        int len = binaryString.length();
        StringBuilder sb = new StringBuilder(len >> 4);
        int step = 16;
        for (int i = 0; i < len; i += step) {
            // 将ascll码强转成字符
            sb.append((char) (int) Integer.parseInt(binaryString.substring(i, i + step), 2));
        }

        return sb.toString();
    }
}

程序操作步骤:

file-->open,在文本域输入要保存的文本信息,LSB-->hide,file-->save,     file-->open(打开刚才保存的文件),LSB-->show.

效果图:

1.打开bmp文件

 

 

 

 

                                                     -----------------------------原始版本效果图--------------------------------