/** \brief Checks if the given Pixel is empty (not used). It is empty, if least significant bits are all 0.
* \param pixel const Pixel& the pixel that should be checked
* \return bool true if pixel is not used until now, else false
*/
bool SteganoHide::isPixelEmpty(const Pixel &pixel) {
Magick::ColorRGB pixelColor = this->steganoImage.pixelColor(pixel.x, pixel.y);
const unsigned char redLeastSignificantBit = convert16BitTo8BitRGB(pixelColor.redQuantum()) % 10;
const unsigned char greenLeastSignificantBit = convert16BitTo8BitRGB(pixelColor.greenQuantum()) % 10;
const unsigned char blueLeastSignificantBit = convert16BitTo8BitRGB(pixelColor.blueQuantum()) % 10;
// std::cout << (int)redLeastSignificantBit << ":" << (int)greenLeastSignificantBit << ":" << (int)blueLeastSignificantBit << std::endl;
return (redLeastSignificantBit == 5 && greenLeastSignificantBit == 5 && blueLeastSignificantBit == 5);
}
/** \brief Draw a finish pixel at the specified position. The finishpixel has at the least-significant bit of their rgb-value r: 3, g: 0, b: 0
*
* \param &pixel const Pixel a pixel-struct describing the pixel-position where the finish-pixel should be set.
*/
void SteganoHide::drawFinishPixel(const Pixel &pixel) {
Magick::ColorRGB pixelColor = this->steganoImage.pixelColor(pixel.x, pixel.y);
RGB pixelRGB(convert16BitTo8BitRGB(pixelColor.redQuantum()),
convert16BitTo8BitRGB(pixelColor.greenQuantum()),
convert16BitTo8BitRGB(pixelColor.blueQuantum()));
pixelRGB.red = (pixelRGB.red - (pixelRGB.red % 10)) + 3;
pixelRGB.green = pixelRGB.green - (pixelRGB.green % 10);
pixelRGB.blue = pixelRGB.blue - (pixelRGB.blue % 10);
this->steganoImage.pixelColor(pixel.x, pixel.y, Magick::ColorRGB(pixelRGB.toString()));
}
/** \brief Normalize the loaded image.(set all least significant bits of all RGB-Values to 0).
* This change takes effect only while editing the picture. In the exported image, all pixel have their old value (except the edited ones).
* This is needed to differentiate between edited and not edited pixel.
*/
void SteganoHide::normalizeImage() {
for(unsigned int xValue = 0; xValue < this->xResolution; xValue++) {
for(unsigned int yValue = 0; yValue < this->yResolution; yValue++) {
Magick::ColorRGB curPixelColor = this->steganoImage.pixelColor(xValue, yValue);
RGB curPixelRGB(convert16BitTo8BitRGB(curPixelColor.redQuantum()),
convert16BitTo8BitRGB(curPixelColor.greenQuantum()),
convert16BitTo8BitRGB(curPixelColor.blueQuantum()));
RGB curPixelRoundedRGB(curPixelRGB.red - (curPixelRGB.red % 10) + 5,
curPixelRGB.green - (curPixelRGB.green % 10) + 5,
curPixelRGB.blue - (curPixelRGB.blue % 10) + 5);
this->steganoImage.pixelColor(xValue, yValue, Magick::ColorRGB(curPixelRoundedRGB.toString()));
}
this->doneBytes += this->yResolution;
}
}
// TODO: handle wrong input
bool SteganoHide::hideNumberInMagickColorRGB(const unsigned short &smallNumber, Magick::ColorRGB &color) {
RGB pixelRGB(convert16BitTo8BitRGB(color.redQuantum()),
convert16BitTo8BitRGB(color.greenQuantum()),
convert16BitTo8BitRGB(color.blueQuantum()));
RGB roundedRGB;
roundedRGB.red = pixelRGB.red - (pixelRGB.red % 10);
roundedRGB.green = pixelRGB.green - (pixelRGB.green % 10);
roundedRGB.blue = pixelRGB.blue - (pixelRGB.blue % 10);
unsigned char mostSignificantBit = std::floor(smallNumber / 100);
unsigned char middleSigificantBit = std::floor(smallNumber % 100 / 10);
unsigned char leastSignificantBit = smallNumber % 10;
/* if(mostSignificantBit > 5 || middleSigificantBit > 5 || leastSignificantBit > 5) {
throw hideNumber2Big;
}*/
// there was an overflow: eg. roundedRGB.blue = 250 and leastSignificantLetterBit = 8 => 258 => 2
// This way to check overflow is possible, because *SignificantLetterBit >= 0
if(roundedRGB.green + middleSigificantBit > 255) {
return false;
}
if(roundedRGB.blue + leastSignificantBit > 255) {
return false;
}
// std::cout << (int)roundedRGB.blue << "+" << (int)leastSignificantBit << "=";
roundedRGB.red += mostSignificantBit;
roundedRGB.green += middleSigificantBit;
roundedRGB.blue += leastSignificantBit;
//std::cout << (int)roundedRGB.blue << std::endl;
color = Magick::ColorRGB(roundedRGB.toString());
return true;
}
// TODO: shorten this method and outsource some inner methods and add header comment
std::stringstream SteganoExpose::unhidePhrase(const std::string &password)
{
if(!this->steganoImage.isValid())
{
throw SteganoException::UnhideFileNotSpecified();
}
this->exposeFinished = false;
Chunk hiddenChunk("vaPh");
std::cout << this->steganoImage.baseFilename() << std::endl;
PrivateChunk privChunk(this->steganoImage.baseFilename(), "./omg.png");
char *chunkData = new char[privChunk.getChunkSize(hiddenChunk)];
privChunk.readChunk(hiddenChunk, chunkData);
commentReaderStream.str(chunkData);
calculateNextShift();
Pixel curPixel(0, 0);
std::stringstream returnPhrase;
for(unsigned int runCounter = 0; ; runCounter++)
{
curPixel.x = 0;
curPixel.y = 0;
int_least64_t steps = quadraticSondation(runCounter, this->xResolution * this->yResolution);
// std::cout << "Push by" << steps << std::endl;
pushPixelBy(curPixel, steps);
// std::cout << curPixel.x << ":" << curPixel.y << std::endl;
if(runCounter == shiftIndex)
{
pushPixelBy(curPixel, shiftAmount);
calculateNextShift();
}
// std::cout << curPixel.x << "::" << curPixel.y << std::endl;
Magick::ColorRGB curPixelColor = this->steganoImage.pixelColor(curPixel.x, curPixel.y);
unsigned char redLeastSignificantBit = convert16BitTo8BitRGB(curPixelColor.redQuantum()) % 10;
unsigned char greenLeastSignificantBit = convert16BitTo8BitRGB(curPixelColor.greenQuantum()) % 10;
unsigned char blueLeastSignificantBit = convert16BitTo8BitRGB(curPixelColor.blueQuantum()) % 10;
// there was an overflow at the pixel color. we need to handle it special.
unsigned char decryptedChar = 0;
if(redLeastSignificantBit == 4)
{
decryptedChar += greenLeastSignificantBit * 10;
decryptedChar += blueLeastSignificantBit;
incrementPixel(curPixel);
curPixelColor = this->steganoImage.pixelColor(curPixel.x, curPixel.y);
redLeastSignificantBit = convert16BitTo8BitRGB(curPixelColor.redQuantum()) % 10;
greenLeastSignificantBit = convert16BitTo8BitRGB(curPixelColor.greenQuantum()) % 10;
blueLeastSignificantBit = convert16BitTo8BitRGB(curPixelColor.blueQuantum()) % 10;
decryptedChar += redLeastSignificantBit * 100;
decryptedChar += greenLeastSignificantBit * 10;
decryptedChar += blueLeastSignificantBit;
}
else
{
decryptedChar = redLeastSignificantBit * 100;
decryptedChar += greenLeastSignificantBit * 10;
decryptedChar += blueLeastSignificantBit;
}
if(isFinishPixel(curPixel))
{
break;
}
returnPhrase << decryptedChar;
}
this->exposeFinished = true;
return returnPhrase;
}
