lsb算法 java,JAVA实现MD5算法

LSB算法

LSB（Least Significant Bit）算法是一种简单的隐写术，其核心思想是将要隐藏的信息嵌入到一张图片的RGB分量的最低位中，因为最低位对图片的影响相对较小，所以这种方法可以实现较高的隐蔽性。以下是一个简单的LSB算法的Java实现：

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;

public class LSB {
    
    public static void main(String[] args) throws IOException {
        BufferedImage img = ImageIO.read(new File("original.png")); // 读取原始图片
        BufferedImage stgImg = hideData(img, "Hello, world!"); // 嵌入数据
        ImageIO.write(stgImg, "png", new File("stego.png")); // 保存嵌入数据后的图片
        String data = extractData(stgImg); // 提取数据
        System.out.println(data); // 输出提取的数据
    }
    
    /**
     * 将字符串数据嵌入到图片中
     * @param img 原始图片
     * @param data 要嵌入的数据
     * @return 嵌入数据后的图片
     */
    public static BufferedImage hideData(BufferedImage img, String data) {
        int width = img.getWidth();
        int height = img.getHeight();
        int size = data.length();
        int dataIndex = 0;
        BufferedImage stgImg = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
        for (int y = 0; y < height; y++) {
            for (int x = 0; x < width; x++) {
                int pixel = img.getRGB(x, y);
                int r = (pixel >> 16) & 0xff;
                int g = (pixel >> 8) & 0xff;
                int b = pixel & 0xff;
                if (dataIndex < size) {
                    char c = data.charAt(dataIndex++);
                    int v = (int) c;
                    r = (r & 0xfe) | ((v >> 6) & 0x01);
                    g = (g & 0xfe) | ((v >> 5) & 0x01);
                    b = (b & 0xfe) | ((v >> 4) & 0x01);
                    stgImg.setRGB(x, y, (r << 16) | (g << 8) | b);
                } else {
                    stgImg.setRGB(x, y, pixel);
                }
            }
        }
        return stgImg;
    }
    
    /**
     * 从图片中提取嵌入的数据
     * @param stgImg 嵌入数据后的图片
     * @return 提取出的数据
     */
    public static String extractData(BufferedImage stgImg) {
        int width = stgImg.getWidth();
        int height = stgImg.getHeight();
        StringBuilder sb = new StringBuilder();
        for (int y = 0; y < height; y++) {
            for (int x = 0; x < width; x++) {
                int pixel = stgImg.getRGB(x, y);
                int r = (pixel >> 16) & 0xff;
                int g = (pixel >> 8) & 0xff;
                int b = pixel & 0xff;
                int v = ((r & 0x01) << 6) | ((g & 0x01) << 5) | ((b & 0x01) << 4);
                if (v != 0) {
                    sb.append((char) v);
                } else {
                    return sb.toString();
                }
            }
        }
        return sb.toString();
    }
}

以上是一个简单的LSB算法的Java实现，其原理就是将要隐藏的数据转换为字符形式，然后将其二进制表示的每一位嵌入到图片的RGB分量的最低位中。

JAVA实现MD5算法

MD5（Message-Digest Algorithm 5）算法是一种常用的哈希算法，用于对给定的信息生成一个128位的数字指纹，以保证数据的完整性和一致性。以下是一个简单的Java实现：

import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class MD5 {
    
    public static void main(String[] args) throws NoSuchAlgorithmException {
        String message = "Hello, world!";
        String md5 = getMD5(message);
        System.out.println(md5);
    }
    
    /**
     * 获取字符串的MD5值
     * @param message 要计算MD5值的字符串
     * @return 字符串的MD5值
     */
    public static String getMD5(String message) throws NoSuchAlgorithmException {
        MessageDigest md = MessageDigest.getInstance("MD5");
        byte[] digest = md.digest(message.getBytes());
        BigInteger bigInt = new BigInteger(1, digest);
        String md5 = bigInt.toString(16);
        while (md5.length() < 32) {
            md5 = "0" + md5;
        }
        return md5;
    }
}

以上是一个简单的Java实现MD5算法的代码，其原理就是利用Java内置的MessageDigest类计算字符串的MD5值。