debug.cpp

信息隐藏里 large payload 源码

#include "header/ximage.h"
#pragma comment(lib, "cximaged.lib")
#include<stdio.h>
#include<math.h>
#include<iostream.h>
#include<conio.h>
#include <iomanip.h>
#include <sys/types.h>
#include <mmsystem.h>
#include <stdlib.h>

const imagewidth=512;
const imagehigth=512;
const code_length=28;
const rank_code=14;
const message_length=14;
const statisticalnum=15;
//const double relative_message=0.8;
int code_word[1<<rank_code][code_length]={0};
void  calSyn(int H[message_length][code_length], int *coverData, int *result);
void resolveFun(int H[message_length][code_length], int *messageData, int *result);
int findMin(int H[message_length][code_length], int *e);
//int SolvePCM(int input[message_length][code_length], int randm[message_length], int syn[message_length]);


int image[imagewidth][imagehigth];
//int pse_random_path[512][512];

void main()
{
int i;
int j;
int parity_check_matrix[message_length][code_length]={0};
int code_word[code_length]={0};
int countone=0;
int min_weight=0;
int flagsolve=0;
int solve[code_length]={0};
int syndrome[message_length]={0};
int message_stego_key=0;
int random_message[60000]={0};
int matrix_stego_key=0;
int solveword=0;
int current_message[message_length]={0};
int current_cover_data[code_length]={0};
int global_min_weight[100]={0};
double average_efficiency=0.0;
int totalnumber=0;

//.........读取灰度图象素值........

CxImage J;
J.Load("lena.Bmp");

memset(image, 0, sizeof(image));

for ( i=0; i<imagewidth; i++)
for (j=0; j<imagehigth; j++)
{
	image[i][j] = J.GetPixelGray(i, j);

}

//......随机生成奇偶校验矩阵......

printf("Enter matrix_stego_key ");
scanf("%d", &matrix_stego_key);
srand(matrix_stego_key);

for(i=0; i<message_length; i++)
	parity_check_matrix[i][i]=1;

for(i=0;i<message_length;i++)
{
	for(j=message_length;j<code_length;j++)
	{
		parity_check_matrix[i][j]=rand()%2;
	}
}



//..........随机生成一个消息序列...........

printf("Enter message_stego_key ");
scanf("%d", &message_stego_key);
srand(message_stego_key);

for(i=0; i<60000; i++)
{
	random_message[i]=rand()%2;

}


for(i=0; i<statisticalnum; i++)
{
	for(j=0; j<message_length; j++)
	{
		current_message[j]=random_message[i*message_length+j];//读取下一消息段 
	}

	for(j=0; j<message_length; j++)
	{
		current_cover_data[j]=image[(i*code_length+j)/imagewidth][(i*code_length+j)%imagewidth];//读取下一载体数据段 
	}

	 calSyn( parity_check_matrix , current_cover_data,  syndrome);

	 for(j=0; j<message_length; j++) 
		 syndrome[j]=current_message[j]^syndrome[j];

	 resolveFun( parity_check_matrix,  syndrome, solve);

	global_min_weight[i]= findMin(parity_check_matrix, solve);





}


/*//..........计算伴随式........

for(int t=0; t<statisticalnum; t++)//计算伴随式的次数1
{
	for(i=0; i<message_length; i++)
	{
		current_message[i]=random_message[t*message_length+i];//读取下一消息段 
	}
	
	for(i=0; i<message_length; i++)
	{
		for(j=0; j<code_length; j++)
		{
			syndrome[i]+=parity_check_matrix[i][j]&((image[(t*code_length)/imagewidth][(t*code_length+j)%imagewidth])&1);
		}
		syndrome[i]%=2;
	}

//..........求解线性方程组并找出最小重量.........
	
	global_min_weight[t]=SolvePCM(parity_check_matrix, current_message, syndrome);*/
	
//}//for(t)
for(i=0; i<statisticalnum; i++)
{
	average_efficiency+=(double)message_length/(double)global_min_weight[i];
}
printf("%.2f", average_efficiency/statisticalnum);

}


/*int SolvePCM(int input[message_length][code_length], int randm[message_length], int syn[message_length])
{
	int solve[code_length]={0};
	int temptrans[code_length]={0};
	int input_message[message_length][code_length+1]={0};
	int tempmessage=0;
	int tempsolveword=0;
	
	int min_weight=0;
	int countone=0;
	int i;
	int j;

	for(i=0; i<message_length; i++)
	{
		for(j=0; j<code_length; j++)
		{
			input_message[i][j]=input[i][j];
		}
		input_message[i][code_length]=randm[i]^syn[i];
	}

	for(i=0; i<message_length; i++)
	{
		if(input_message[i][i]==0)
		{
			for(j=i+1; j<message_length; j++)
			{
				if(input_message[j][i])
				{
					for(int t=0; t<code_length+1; t++)
					{
						temptrans[t]=input_message[i][t];
						input_message[i][t]=input_message[j][t];
						input_message[j][t]=temptrans[t];
					}
					break;
				}
			}
		}
		for(int t=i+1; t<message_length; t++)
		{
			if(input_message[t][i])
			{
				for(j=i; j<code_length+1; j++)
				{
					input_message[t][j]=(input_message[t][j]+input_message[i][j])%2;
				}
			}
		}
	}
	
/*	for(i=0; i<message_length; i++)
	{
		for(j=0; j<code_length; j++)
		{
			printf("%2d ", input_message[i][j]);
		}
		printf("\n");
	}*/

	/*for(i=message_length; i<code_length; i++)
		solve[i]=0;
	for(i=message_length-1; i>=0; i--)
	{
		solve[i]=input_message[i][code_length]&input_message[i][i];
		for(j=i-1; j>=0; j--)
		{
			input_message[j][code_length]^=(solve[i]&input_message[j][i]);
		}
	}

	
//.........求码字................

	for(i=0; i<message_length; i++)
		input_message[i][code_length]=0;
	
	for(i=0; i<(1<<rank_code); i++)
	{
		for(j=message_length; j<code_length; j++)
			code_word[i][j]=(i>>(j-message_length))&1;

		for(j=0; j<message_length; j++)
		{
			for(int r=message_length; r<code_length; r++)
			{
				input_message[j][code_length]^=(input_message[j][r]&code_word[i][r]);
			}
		}
		
		for(j=message_length-1; j>=0; j--)
		{
			code_word[i][j]=input_message[j][code_length]&input_message[j][j];
			for(int r=j-1; r>=0; r--)
			{
				input_message[r][code_length]^=(code_word[i][j]&input_message[r][j]);
			}	
		}	
	}
		
//.............求最小重量...............

	min_weight=0;

	for(j=0; j<code_length; j++)
		if(solve[j]) min_weight++;
	
	for(i=0; i<1<<rank_code; i++)
	{
		countone=0;

		for(j=0; j<code_length; j++)
		{
			if(code_word[i][j]!=solve[j]) countone++;
		}
		if(countone<min_weight) min_weight=countone;

	}
	
	return min_weight;
	
}

*/

void  calSyn(int H[message_length][code_length], int *coverData, int *result)
{
	int i,j;
	int tmp;
	for(i=0; i<message_length; i++)
	{
		for(j=tmp=0; j<code_length; j++) 
			tmp ^= coverData[j]&H[i][j];
		result[i] = tmp;
	}
}

void resolveFun(int H[message_length][code_length], int *messageData, int *result)
{
	int i;

	for(i=0; i<message_length; i++) result[i] = messageData[i];
	for(; i<code_length; i++)
			result[i] = 0;
}

int findMin(int H[message_length][code_length], int *e)
{
	int result[500];
	
	int i,j,l;
	int weight;
	int k= code_length - message_length;
	int minD = code_length;
	int nums = 1<<k;
	for(i=0; i<nums; i++)
	{
		for(j=0;j<k; j++)
		{
			result[j+message_length] = i>>(k-j-1)&1;
		}

		for(j=message_length-1; j>=0; j--)
		{
			result[j] = 0;
			for(l=j; l<code_length; l++)
				result[j] ^= H[j][l] * result[l];
		}

		for(j=weight=0; j<code_length; j++)
			weight += result[j] ^ e[j];

		if(weight < minD)
			minD = weight;
	}
	return minD;
}