Hide Data into bitmap with ARGB8888 format

将保存重要信息，如银行卡密码的文本文件隐藏到ARGB8888的A通道。

bitmap.h

#ifndef BMP_H
#define BMP_H

#include <fstream>
#include <string>
#include <iostream>

#define DEBUG 0

#define LOG std::cout
#define HEX std::hex
#define DEC std::dec

#define FLAG_0 (0xFF)
#define FLAG_1 (0xEE)
#define FLAG_2 (0xDD)
#define FLAG_3 (0xCC)

#define DATA_CODE (0xCC)

#define BYTE_PER_PIXEL (4)

#pragma pack(push, 1)
typedef struct
{
    uint16_t bfType; // Type of bitmap, in windows, always 'BM'
    uint32_t bfSize; // Size of the bitmap file
    uint16_t bfReserved1; // reserved feild
    uint16_t bfReserved2; // reserved feild
    uint32_t bfOffBits; // the start address of the bitmap data
}BMP_FILE_HEADER;

typedef struct
{
    uint32_t biSize; // size of this struct
    uint32_t biWidth; // image width, unit is pixel
    uint32_t biHeight; // image height, unit is pixel
    uint16_t biPlanes; // alsways 1
    uint16_t biBitCount; // color depth of the image, 1, 4, 8, 16, 24 and 32
    uint32_t biCompression; // compression type, 0=no compress, 1=RLE8 compress
                            // 2=RLE4 compress, 3=pixel color mask
    uint32_t biSizeImage; // pixel data size of the image
    uint32_t biXPelsPerMeter; // H resolution, pixel per meter
    uint32_t biYPelsPerMeter; // V resolution, pixel per meter
    uint32_t biClrUsed; // color number that used, 0=all color
    uint32_t biClrImportant; // important color amount, 0=all color important
}BMP_INFO_HEADER;
#pragma pacn(pop)

class Bitmap
{
private:
    BMP_FILE_HEADER m_fileHeader;
    BMP_INFO_HEADER m_infoHeader;

    std::string m_bmpPath;
    bool m_parseFlag;
public:
    Bitmap(std::string path);
    ~Bitmap();
    bool bmpParse();
    uint32_t getBmpSize();
    uint32_t getBmpDataAddr();
    std::string getBmpPath();
    uint32_t getBmpPixelNum();
};

class DataHider
{
private:
    uint8_t m_flags[4];
    uint8_t m_length[4];
    Bitmap m_bitmapHeader;
    std::string m_dataFilePath;

    bool isAHider();
    uint32_t getFileSize(std::ifstream &in);
    bool readTransByte(std::fstream &file, uint8_t &val, int pos);
    bool writeTransByte(std::fstream &file, uint8_t val, int pos);
    void length2Byte(uint32_t length);
    uint32_t byte2Length();
public:
    DataHider(std::string dataPath, std::string bmpPath);
    ~DataHider();
    bool doEncode();
    bool doDecode();
};

#endif // BMP_H

　　bitmap.cpp

#include "bitmap.h"

Bitmap::Bitmap(std::string path)
: m_fileHeader(), m_infoHeader(), m_bmpPath(path), m_parseFlag(false)
{
}

Bitmap::~Bitmap()
{
}

bool Bitmap::bmpParse()
{
    std::ifstream in;
    in.open(m_bmpPath, std::ios::binary);

    in.read((char *)&m_fileHeader, sizeof(m_fileHeader));
    /*char * p = (char *)&m_fileHeader;
    for(uint32_t i=0; i<sizeof(m_fileHeader); ++i)
    {
        in.read(p, 1);
        LOG << HEX << (int)*p << " ";
        ++p;
    }*/
    if( !in.good() )
    {
        LOG << "read bitmap file head error!\n";
        in.close();
        return false;
    }

    in.read((char *)&m_infoHeader, sizeof(m_infoHeader));
    /*    LOG << "read bitmap information header!\n";
    p = (char *)&m_infoHeader;
    for(uint32_t i=0; i<sizeof(m_infoHeader); ++i)
    {
        in.read(p, 1);
        LOG << HEX << (int)*p << " ";
        ++p;
    }*/
    if( !in.good() )
    {
        LOG << "read bitmap information header error!\n";
        in.close();
        return false;
    }

    in.close();
    m_parseFlag = true;

    #if 1 == DEBUG
        LOG << "Bitmap file header:"
            << "\nbfType: " << HEX << (int)m_fileHeader.bfType
            << "\nbfSize: " << (int)m_fileHeader.bfSize
            << "\nbfReserved1: " << (int)m_fileHeader.bfReserved1
            << "\nbfReserved2: " << (int)m_fileHeader.bfReserved2
            << "\nbfOffBits: " << (int)m_fileHeader.bfOffBits
            << "\nBitmap information header:"
            << "\nbiSize: " << (int)m_infoHeader.biSize << DEC << "\n";
    #endif

    return true;
}

uint32_t Bitmap::getBmpSize()
{
    if(!m_parseFlag)
    {
        LOG << "please do bitmap parse first!\n";
    }
    return m_fileHeader.bfSize;
}

std::string Bitmap::getBmpPath()
{
    return m_bmpPath;
}

uint32_t Bitmap::getBmpDataAddr()
{
    if(!m_parseFlag)
    {
        LOG << "please do bitmap parse first!\n";
    }
    return m_fileHeader.bfOffBits;
}

uint32_t Bitmap::getBmpPixelNum()
{
    return m_infoHeader.biWidth * m_infoHeader.biHeight;
}

DataHider::DataHider(std::string dataPath, std::string bmpPath)
: m_bitmapHeader(bmpPath), m_dataFilePath(dataPath)
{
}

DataHider::~DataHider()
{
}

bool DataHider::isAHider()
{
    return (m_flags[0] == FLAG_0) & 
            (m_flags[1] == FLAG_1) &
            (m_flags[2] == FLAG_2) &
            (m_flags[3] == FLAG_3);
}

uint32_t DataHider::getFileSize(std::ifstream &in)
{
    if(!in.good())
    {
        LOG << "the data file has some error.\n";
        return false;
    }

    uint32_t pos =  in.tellg();
    in.seekg(0, std::ios_base::end);
    uint32_t size = in.tellg();
    in.seekg(pos, std::ios_base::beg);

    return size;
}

bool DataHider::readTransByte(std::fstream &file, uint8_t &val, int pos)
{
    file.seekg(m_bitmapHeader.getBmpDataAddr()+BYTE_PER_PIXEL*pos, std::ios_base::beg);
    #if DEBUG == 1
        LOG << "pos " << HEX << m_bitmapHeader.getBmpDataAddr()+BYTE_PER_PIXEL*pos << "\n";
    #endif
    file.read((char *)&val, 1);
    return file.good();
}

bool DataHider::writeTransByte(std::fstream &file, uint8_t val, int pos)
{
    file.seekp(m_bitmapHeader.getBmpDataAddr()+BYTE_PER_PIXEL*pos, std::ios_base::beg);
    file.write((char *)&val, 1);
    return file.good();    
}

void DataHider::length2Byte(uint32_t length)
{
    for(uint32_t i=0; i<4; ++i)
        m_length[i] = (uint8_t)(length >> (i*8)) & 0xFF;
    #if DEBUG == 1
        LOG << "length: " << length << "\n"
            << (int)m_length[0] << " "
            << (int)m_length[1] << " "
            << (int)m_length[2] << " "
            << (int)m_length[3] << "\n";
    #endif
}

uint32_t DataHider::byte2Length()
{
    uint32_t length = 0;
    uint32_t temp;
    for(uint32_t i=0; i<4; ++i)
    {
        temp = m_length[i];
    #if DEBUG == 1
        LOG << "temp: " << temp << "\n";
    #endif
        temp <<= (i*8);
    #if DEBUG == 1
        LOG << "temp: " << temp << "\n";
    #endif
        length += temp; 
    }

    #if DEBUG == 1
        LOG << "length: " << length << "\n";
    #endif

    return length;
}

bool DataHider::doEncode()
{
    m_bitmapHeader.bmpParse();
    
    std::ifstream dataFile;
    dataFile.open(m_dataFilePath, std::ios::binary);
    if(!dataFile.good())
    {
        LOG << "open " << m_dataFilePath << " failed!\n";
        return false;
    }
    uint32_t dataSize = getFileSize(dataFile);
    if(dataSize > m_bitmapHeader.getBmpPixelNum() + 8) // flag size add length size
    {
        LOG << "data is too big to save into the bitmap!\n";
        dataFile.close();
        return false;
    }

    std::fstream bmpFile;
    bmpFile.open(m_bitmapHeader.getBmpPath(), std::ios_base::binary|
                    std::ios_base::out|std::ios_base::in);
                    // |std::ios_base::ate|std::ios_base::app
    if(!bmpFile.good())
    {
        LOG << "open " << m_bitmapHeader.getBmpPath() << " failed!\n";
        dataFile.close();
        return false;
    }
    dataFile.seekg(0, std::ios_base::beg);

    // flags
    m_flags[0] = FLAG_0;
    m_flags[1] = FLAG_1;
    m_flags[2] = FLAG_2;
    m_flags[3] = FLAG_3;

    for(uint32_t i=0; i<4; ++i)
        writeTransByte(bmpFile, m_flags[i], i);

    // length
    length2Byte(dataSize);

    for(uint32_t i=0; i<4; ++i)
        writeTransByte(bmpFile, m_length[i], i+4);

    // pos start at the 8th pixel
    int pos = 0;
    uint8_t data;
    while(pos < dataSize)
    {
        dataFile.read((char *)&data, 1);
        #if DEBUG == 1
            LOG << HEX << (int)data << " ";
        #endif
        data ^= DATA_CODE;
        writeTransByte(bmpFile, data, pos+8);
        ++pos;
    }

    bmpFile.close();
    dataFile.close();
    return true;
}

bool DataHider::doDecode()
{
    m_bitmapHeader.bmpParse();
    
    std::fstream bmpFile;
    bmpFile.open(m_bitmapHeader.getBmpPath(), std::ios_base::binary|std::ios_base::in);
    if(!bmpFile.good())
    {
        LOG << "open " << m_bitmapHeader.getBmpPath() << " failed!\n";
        return false;
    }
    bmpFile.seekg(0, std::ios_base::beg);


    // flags
    for(uint32_t i=0; i<4; ++i)
    {
        readTransByte(bmpFile, m_flags[i], i);
        #if DEBUG
            LOG << HEX << (int)m_flags[i] << " ";
        #endif
    }

    if( !isAHider() )
    {
        LOG << "this bitmap is not a hider file!\n";
        bmpFile.close();
        return false;
    }

    // length
    for(uint32_t i=0; i<4; ++i)
        readTransByte(bmpFile, m_length[i], i+4);

    #if DEBUG == 1
        LOG << (int)m_length[0] << " "
            << (int)m_length[1] << " "
            << (int)m_length[2] << " "
            << (int)m_length[3] << "\n";
    #endif

    uint32_t dataSize = byte2Length();

    std::ofstream dataFile;
    dataFile.open(m_dataFilePath, std::ios::binary);
    if(!dataFile.good())
    {
        LOG << "open " << m_dataFilePath << " failed!\n";
        bmpFile.close();
        return false;
    }
    // pos start at the 8th pixel
    int pos = 0;
    uint8_t data;
    while(pos < dataSize)
    {
        readTransByte(bmpFile, data, pos+8);
        data ^= DATA_CODE;
        dataFile.write((char *)&data, 1);
        ++pos;
        
    }

    bmpFile.close();
    dataFile.close();
    return true;
}

　　main.cpp

#include <iostream>
#include "bitmap.h"
using namespace std;

int main(int argc, char **argv)
{
    cout << "Hello world!" << endl;

    if(argc < 4)
    {
        cout << "please type the right command!\n"
             << "DataHider encode ./data.txt ./ARGB8888.bmp\n"
             << "or DataHider decode ./data_out.txt ./ARGB8888.bmp\n";
        return -1;
    }

    string mode =  argv[1];
    string dataFile = argv[2];
    string bmpFile = argv[3];

    if(mode == "encode")
    {
        cout << "encoder\n";
        DataHider encoder(dataFile, bmpFile);
        encoder.doEncode();
    }
    else if(mode == "decode")
    {
        cout << "decoder\n";
        DataHider decoder(dataFile, bmpFile);
        decoder.doDecode();
    }

    return 0;
}