LSB密写分析-RS分析

卡方分析及信息量估计法利用图像直方图特性分析，RS分析与GPC分析利用图像空间相关性进行分析。
RS分析，简单来说，将一幅图像分成很多个小图块，对每个图块分别进行非负及非正翻转，得到总的R(M),S(M),R(-M),S(-M)，由这四个值的关系判断是否经过密写；若经过密写，再对原始图像进行F1翻转，计算此时的新一组R(M),S(M),R(-M),S(-M)，由这两组值计算密写率。
实现如下：

1. RS分析主程序

image='ste_cover.bmp';
ste_cover=imread(image);
ste_cover=double(ste_cover);
[m,n]=size(ste_cover);

%RS分析
num=8;
[Rm,Sm,Rnem,Snem]=CalRS(ste_cover,num);

if (Rnem-Snem)>((Rm-Sm)*(1.05))
    fprintf('该图片经过密写\n');
else
    fprintf('该图片未经过密写\n');
end

%将待检测图像全部F1翻转
ste_overturn=AllF1(ste_cover);

[Rm2,Sm2,Rnem2,Snem2]=CalRS(ste_overturn,num);

%计算密写率
d1=Rm-Sm;
d2=Rm2-Sm2;
d3=Rnem-Snem;
d4=Rnem2-Snem2;

a=2*(d1+d2);
b=(d3-d4-d2-3*d1);
c=d1-d3;
r1=roots([a,b,c]);
if ((b^2)==4*a*c)||(a==0)
    alpha=r1/(r1-0.5);
else
    r2=abs(r1(1));
    r3=abs(r1(2));
    if (r2>=r3)
        alpha=r1(2)/(r1(2)-0.5);
    else
        alpha=r1(1)/(r1(1)-0.5);
    end
end
fprintf('密写率为：%f\n',alpha);

2. 将矩阵Zigzag化

function g=Zigzag(matrix)
    [m,n]=size(matrix);
    num=m*n;
    matrix = matrix';
    count = 1;    
    for dim_sum=2:(m + n)
        if mod(dim_sum, 2) == 0
            for i=1:m
                if dim_sum-i<=m&dim_sum-i>0
                    g(count)=matrix(i,dim_sum-i);
                    count=count+1;
                end
            end
        else
            for i=1:m
                if dim_sum-i<=m&dim_sum-i>0
                    g(count)=matrix(dim_sum-i,i);
                    count=count+1;
                end                   
            end   
        end
    end
    g=g(1:num);
    g=g';
end

3. 计算空间相关性f

%输出f，参数向量g
function s=f(g)
    n=length(g);
    sum=0;
    for i=1:n-1
        sum=sum+abs(g(i)-g(i+1));
        i=i+1;
    end
    s=sum;

4. 计算R(M),S(M),R(-M),S(-M)

%矩阵分割与计算R S
%ste_cover需计算的图像块，分割成numxnum块
function [Rm,Sm,Rnem,Snem]=CalRS(ste_cover,num)
    [m,n]=size(ste_cover);
    sep=mat2cell(ste_cover,(m/num)*ones(1,num),(n/num)*ones(1,num)); %将图像分成numxnum块
    b_NN_R=0; %非负翻转中起伏增加的图像块个数
    b_NN_S=0; %非负翻转中起伏减小的图像块个数
    b_NP_R=0; %非正翻转中起伏增加的图像块个数
    b_NP_S=0; %非正翻转中起伏减小的图像块个数
    for j=1:num
        for k=1:num
            block=cell2mat(sep(j,k));
            f1=f(Zigzag(block));
            f2=f(NoNeg(block));
            f3=f(NoPos(block));
            %fprintf('f1=%d,f2=%d,f3=%d\n',f1,f2,f3);
            if f2>f1
                b_NN_R=b_NN_R+1;
            elseif f2<f1
                b_NN_S=b_NN_S+1;
            end
            if f3>f1
                b_NP_R=b_NP_R+1;
            elseif f3<f1
                b_NP_S=b_NP_S+1;
            end
        end
    end

    Rm=b_NN_R/(num*num);
    Sm=b_NN_S/(num*num);
    Rnem=b_NP_R/(num*num);
    Snem=b_NP_S/(num*num);

5. F0翻转

function f=F0(x)
    f=x;

6. F1翻转

function f=F1(x)
    if mod(x,2)==0
        f=x+1;
    else
        f=x-1;
    end

7. F-1翻转

function f=Fne1(x)
    if mod(x,2)==0
        f=x-1;
    else
        f=x+1;
    end

8. 非正翻转

%非正翻转
%返回向量，参数为矩阵
function g=NoPos(matrix)
    [m,n]=size(matrix);
    M=randsrc(m,n,[0 1;0.5 0.5]); %生成随机翻转图谱矩阵
    M=Zigzag(M); %将翻转图谱排为向量，与矩阵同维
    G=Zigzag(matrix); %将矩阵按zigzag方式排为向量
    G_len=length(G);
    for i=1:G_len
        if M(i)==1
            G(i)=Fne1(G(i));
        else
            G(i)=F0(G(i));
        end
        i=i+1;
    end
    g=G;

9. 非负翻转

%非负翻转
%返回向量，参数为矩阵
function g=NoNeg(matrix)
    [m,n]=size(matrix);
    M=randsrc(m,n,[0 1;0.5 0.5]); %生成随机翻转图谱矩阵
    M=Zigzag(M); %将翻转图谱排为向量，与矩阵同维
    G=Zigzag(matrix); %将矩阵按zigzag方式排为向量
    G_len=length(G);
    for i=1:G_len
        if M(i)==1
            G(i)=F1(G(i));
        else
            G(i)=F0(G(i));
        end
        i=i+1;
    end
    g=G;

10. 对原图全F1翻转

%全F1翻转
function mat=AllF1(matrix)
    [m,n]=size(matrix);
    for j=1:m
        for k=1:n
            mat(j,k)=F1(matrix(j,k));
        end
    end