python添加水印 pdf python数字水印

概要

数字水印是一种将标识信息嵌入到载体当中，且不影响载体使用的一种技术，主要分为时域水印嵌入算法（将水印嵌入到时域采样数据中）和变换域水印嵌入算法（先对音频做变换，将水印嵌入到变换域系数中）。本文主要介绍的是时域水印嵌入算法—LSB算法。

LSB算法原理

基于不可感知的要求，即数据的变化几乎不会引起使用的者的察觉，将水印信息嵌入到数据的最低有效位（Least Significant Bit），也就是将图片的RGB数值转换为二进制数据，然后用水印替换掉最低位，这种变化对于人眼来说是不可察觉的。当然，水印的形式也是多种多样的，有图片，文字等，这里主要介绍如何把图片作为水印写入到另一张图片中。

注意事项

• LSB隐写（最低有效位的隐写），是指通过改变图片中像素的最低位来实现信息的隐藏的。这种隐写方式需要图片是无压缩的位图，因此一般用于bmp和png图片。
• 本文采用python代码实现，下面是需要预先安装的包
  from PIL import Image

加密过程

假设载体图片和水印图片分别是这样的：

• 获取图片

img1 = Image.open('1.bmp')
img2 = Image.open('2.bmp')
rgb_im1 = img1.convert('RGB')
rgb_im2 = img2.convert('RGB')

除了获取图片外，还要将图片变为RGB通道模式，否则后面是获取不到RGB值的，其中1.bmp是载体图片，2.bmp是水印图片。

• 获取水印图片每个像素的RGB值

for i in range(img.size[0]):
        for j in range(img.size[1]):

            # 获取水印的每个像素值
            rgb = img.getpixel((i, j))

采用循环遍历水印图片，获取每个像素的RGB值，可以将值输出来看一下

可以看到，获取到的RGB值是以元组的方式存储的。

• 将RGB值转为二进制形式

# 将像素值转为二进制后保存
str = str + plus(bin(rgb[0]).replace('0b', ''))
str = str + plus(bin(rgb[1]).replace('0b', ''))
str = str + plus(bin(rgb[2]).replace('0b', ''))

其中bin是python的进制转换函数，能将十进制转换为二进制，唯一不足的就是会自动在转换的数字前面加0b，因此以空字符串替换掉0b。
此外，十进制转换二进制的时候，如果转换的二进制是以0开头的，那么会自动省略前方的0，这不符合我们的要求。因此以255为标准，二进制为1111 1111，其余的不足8位的在最前方补0，如1就是0000 0001。plus函数如下：

def plus(str):
    # 返回指定长度的字符串，原字符串右对齐，前面填充0。
    return str.zfill(8)

这样一转换，水印图片的所有RGB值都被转换为二进制并当做字符串存储在str里了，如下图：

这里的每一位，都是要替换掉载体图片每一个像素点的R，G，B三个值的二进制形式的末尾数字，因此载体的图片像素点的RGB值会改变，但变化最大不会超过1，主观上无法察觉。

• 遍历载体图片

for i in range(img.size[0]):
        for j in range(img.size[1]):
            # 获取到图片的每个像素值
            data = img.getpixel((i, j))

很明显，每次循环，data就会获得一个RGB值，也可以分别保存。

r = data[0]
g = data[1]
b = data[2]

• 改变像素点的RGB值
  此时，需要两个信号，一个是上面str的长度，来判断此时替换的是str的哪一位，以及来判断何时替换完毕；另一个是计数器，因为载体图片也有RGB三个数值，每次都需要替换完整的R,G,B三个数值后，才能完成一个像素点的修改，也就是说，str里的3位数字分别替换载体图片一个像素点的R,G,B的最后一位，此时该像素点修改完毕。当计数器数值等于str的长度时，代表水印完全写入载体。

# 计数器
count = 0
# 二进制像素值的长度，可以认为要写入图像的文本长度，提取（解密）时也需要此变量
codeLen = len(code)
print(codeLen)
if count == codeLen:
	break
	
	"""
	下面的是像素值替换，通过取模2得到最后一位像素值（0或1），
	然后减去最后一位像素值，在将code的值添加过来
	"""

r = (r - r % 2) + int(code[count])
count += 1
if count == codeLen:
	img.putpixel((i, j), (r, g, b))
	break

g = (g - g % 2) + int(code[count])
count += 1
if count == codeLen:
	img.putpixel((i, j), (r, g, b))
	break

b = (b - b % 2) + int(code[count])
count += 1
if count == codeLen:
	img.putpixel((i, j), (r, g, b))
	break

# 每3次循环表示一组RGB值被替换完毕，可以进行写入
if count % 3 == 0:
	img.putpixel((i, j), (r, g, b))

• 保存图片

img.save('1_out.bmp')

输出的图片和原图片感官上没有什么区别，甚至放大后也看不出来，比如下面分别是两张图片的左上角：

像素点都清晰可见，但肉眼丝毫感觉不到差别，用专业工具（PS等）才能看出它们的RGB的值最多相差1。

至此，加密完成！

解密过程

解密过程稍显复杂，因为载体图片中不是所有像素点都被修改了的，而且就算将水印图片的像素点RGB值还原了，但不知道水印图片的宽和高是根本没办法还原水印的，一个像素的差别就可能导致整个图片错位。因此，解密的密钥很明显了，就是水印图片的宽和高。当然，上文str（code）的长度也算密钥，只是这个可以通过宽和高计算的，具体公式：宽×高×3×8。

• 获取载体图片

img1 = Image.open('1_out.bmp')
rgb_im1 = img1.convert('RGB')
length = 150144

length就是加密中str的长度，可以通过宽和高计算。水印图片的尺寸是92*68。

• 提取附加值
  遍历载体图片，提取附加值，直到计数器等于length时停止循环，代表提取完毕。

for i in range(width):
        for j in range(height):
            # 获取像素点的值
            rgb = img.getpixel((i, j))

            # 提取R通道的附加值
            if count % 3 == 0:
                count += 1
                wt = wt + str(rgb[0] % 2)
                if count == length:
                    break

            # 提取G通道的附加值
            if count % 3 == 1:
                count += 1
                wt = wt + str(rgb[1] % 2)
                if count == length:
                    break

            # 提取B通道的附加值
            if count % 3 == 2:
                count += 1
                wt = wt + str(rgb[2] % 2)
                if count == length:
                    break
        if count == length:
            break

width和height是图片的宽和高，就是img.size[0]和img.size[1]。
这里提取到的wt的值应该与加密中str（code）的值一样。

• 将wt的值还原为RGB数值

str1 = []
for i in range(0, len(wt), 8):
	# 以每8位为一组二进制，转换为十进制
	str1.append(int(wt[i:i + 8], 2))

采用数组存放还原后的RGB数值，很明显，每三个值对应一个RGB。

• 绘制和显示水印图片

img_out = Image.new("RGB", (94, 70))
flag = 0
for m in range(0, 92):
	for n in range(0, 68):
		img_out.putpixel((m, n), (str1[flag], str1[flag + 1], str1[flag + 2]))
		flag += 3
img_out.show()

这里初始化图片的时候我为了便于观看，宽和高多给了2像素，而循环时是按照原本水印的尺寸，因此呈现的图片右方和下方会有阴影。

最后还原的水印图片如下图所示：

至此，解密完成！

附录

• 加密

from PIL import Image


def plus(str):
    # 返回指定长度的字符串，原字符串右对齐，前面填充0。
    return str.zfill(8)


def getCode(img):
    str = ""
    # 获取到水印的宽和高进行遍历
    for i in range(img.size[0]):
        for j in range(img.size[1]):

            # 获取水印的每个像素值
            rgb = img.getpixel((i, j))
            # 将像素值转为二进制后保存
            str = str + plus(bin(rgb[0]).replace('0b', ''))
            str = str + plus(bin(rgb[1]).replace('0b', ''))
            str = str + plus(bin(rgb[2]).replace('0b', ''))
            # print(plus(bin(rgb[0]).replace('0b', ''))+"\n")
            # print(plus(bin(rgb[1]).replace('0b', '')) + "\n")
            # print(plus(bin(rgb[2]).replace('0b', '')) + "\n")
    # print(str)
    return str


def encry(img, code):
    # 计数器
    count = 0
    # 二进制像素值的长度，可以认为要写入图像的文本长度，提取（解密）时也需要此变量
    codeLen = len(code)
    print(codeLen)

    # 获取到图像的宽、高进行遍历
    for i in range(img.size[0]):
        for j in range(img.size[1]):
            # 获取到图片的每个像素值
            data = img.getpixel((i, j))

            # 如果计数器等于长度，代表水印写入完成
            if count == codeLen:
                break

            # 将获取到的RGB数值分别保存
            r = data[0]
            g = data[1]
            b = data[2]

            """
            下面的是像素值替换，通过取模2得到最后一位像素值（0或1），
            然后减去最后一位像素值，在将code的值添加过来
            """

            r = (r - r % 2) + int(code[count])
            count += 1
            if count == codeLen:
                img.putpixel((i, j), (r, g, b))
                break

            g = (g - g % 2) + int(code[count])
            count += 1
            if count == codeLen:
                img.putpixel((i, j), (r, g, b))
                break

            b = (b - b % 2) + int(code[count])
            count += 1
            if count == codeLen:
                img.putpixel((i, j), (r, g, b))
                break

            # 每3次循环表示一组RGB值被替换完毕，可以进行写入
            if count % 3 == 0:
                img.putpixel((i, j), (r, g, b))
    img.save('加密图片.bmp')


# 获取图像对象
img1 = Image.open('原始图片.bmp')
img2 = Image.open('水印图片.bmp')

# 将图像转换为RGB通道，才能分别获取R,G,B的值
rgb_im1 = img1.convert('RGB')
rgb_im2 = img2.convert('RGB')

# 将水印的像素值转为文本
code = getCode(rgb_im2)

# 将水印写入图像
encry(rgb_im1, code)

• 解密

from PIL import Image


def deEncry(img, length):
    # 获取图片的宽和高
    width = img.size[0]
    height = img.size[1]

    # 计数器
    count = 0
    # 结果文本，从图片中提取到的附加值（加密时附加在每个RGB通道后的二进制数值）
    wt = ""

    # 遍历图片
    for i in range(width):
        for j in range(height):
            # 获取像素点的值
            rgb = img.getpixel((i, j))

            # 提取R通道的附加值
            if count % 3 == 0:
                count += 1
                wt = wt + str(rgb[0] % 2)
                if count == length:
                    break

            # 提取G通道的附加值
            if count % 3 == 1:
                count += 1
                wt = wt + str(rgb[1] % 2)
                if count == length:
                    break

            # 提取B通道的附加值
            if count % 3 == 2:
                count += 1
                wt = wt + str(rgb[2] % 2)
                if count == length:
                    break
        if count == length:
            break
    return wt


def showImage(wt, img_width, img_height):
    str1 = []
    for i in range(0, len(wt), 8):
        # 以每8位为一组二进制，转换为十进制
        str1.append(int(wt[i:i + 8], 2))
    # 图片大于水印图片1个像素，便于对比
    img_out = Image.new("RGB", (img_width + 1, img_height + 1))
    flag = 0
    for m in range(0, img_width):
        for n in range(0, img_height):
            if flag == len(str1):
                break
            img_out.putpixel((m, n), (str1[flag], str1[flag + 1], str1[flag + 2]))
            flag += 3
        if flag == len(str1):
            break
    img_out.save("解密图片.bmp")
    img_out.show()


# 水印图片的尺寸作为解密的密钥
# image_width = 92
# image_height = 68
# length = image_width * image_height * 24

# 获取一下水印图片的宽和高，也就是解密的密钥
w_image = Image.open('水印图片.bmp')
image_width = w_image.size[0]
image_height = w_image.size[1]
length = image_width * image_height * 24

# 获取图片
img1 = Image.open('加密图片.bmp')
rgb_im1 = img1.convert('RGB')

wt = deEncry(rgb_im1, length)
showImage(wt, image_width, image_height)