zindosteg 1.0.0

data/ext/zindosteg/device.h

@@ -0,0 +1,69 @@
+#pragma once
+
+#include <ios>
+#include "provider.h"
+#include "permutator.h"
+#include <stdexcept>
+#include "steg_defs.h"
+
+namespace zindorsky {
+namespace steganography {
+
+class payload_extraction_error : public std::runtime_error {
+public:
+	payload_extraction_error() : std::runtime_error{"invalid payload data"} {}
+};
+
+class device_t {
+public:
+  using char_type = char;
+
+	//If "open_existing_payload" is true, a check will be made for a valid payload length (and possibly other parameters).
+	//If the check fails then if throw_on_open_existing_fail is true a payload_extraction_error exception will be thrown. If throw_on_open_existing_fail is false, the intitial size will be set to zero.
+	//If "open_existing_payload" is false, no check will be made and a new length will be written when the device is closed.
+	device_t(filesystem::path const& carrier_file, std::string const& password, bool open_existing_payload, bool throw_on_open_existing_fail = true);
+	//Takes ownership of provider:
+	device_t(std::unique_ptr<provider_t> provider, std::string const& password, bool open_existing_payload, bool throw_on_open_existing_fail = true);
+
+	//Non-copyable
+	device_t(device_t const&) = delete;
+	device_t & operator = (device_t const&) = delete;
+	//Movable
+	device_t( device_t && ) = default;
+	device_t & operator = (device_t &&) = default;
+
+	// I/O streams seekable, closable interface:
+	std::streamsize read(char * s, std::streamsize n);
+	std::streamsize write(char const* s, std::streamsize n);
+	std::streampos seek(std::streamoff off, std::ios::seekdir way);
+	void close();
+
+	//Not part of the I/O streams interface, but sometimes handy:
+	std::streamsize size() const { return payload_sz_; }
+	std::streamsize capacity() const { return max_sz_; }
+	std::streamsize truncate(); //sets eof to current position
+	void flush();
+
+	void write_to_file(filesystem::path const& outfile);
+	byte_vector write_to_memory();
+
+	//Returns salt derived from the carrier.
+	byte_vector salt_for_encryption() const;
+
+private:
+	std::unique_ptr<provider_t>  provider_;
+	filesystem::path carrier_file_;
+	permutator::context shuffler_;
+	std::streamsize max_sz_, payload_sz_;
+	std::streampos pos_;
+	bool dirty_;
+
+	byte get_byte(std::streampos const& pos, provider_t::index_t * lo_start = 0, provider_t::index_t * hi_start = 0) const;
+	void put_byte(byte b, std::streampos const& pos);
+
+	std::streamsize read_payload_length(bool throw_on_fail = true) const;
+	void write_payload_length();
+
+};
+
+}}	//namespace zindorsky::steganography

data/ext/zindosteg/extconf.rb

@@ -0,0 +1,10 @@
+require "mkmf-rice"
+
+sources = %w{aes key_generator permutator bmp jpeg_helpers jpeg png_provider loader device}
+$srcs = sources.map { |file| "#{file}.cpp" }
+$objs = sources.map { |file| "#{file}.o" } << "zindosteg.o"
+$CPPFLAGS << " -std=c++17 -O2"
+$LDFLAGS << " -lcrypto -ljpeg -lpng"
+$LDFLAGS << " -lstdc++fs" if have_macro("EXPERIMENTAL_FILESYSTEM", "steg_defs.h")
+
+create_makefile("zindosteg/zindosteg")

data/ext/zindosteg/file_utils.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <fstream>
+#include "steg_defs.h"
+#include <vector>
+
+namespace zindorsky {
+namespace steganography {
+namespace utils {
+
+inline byte_vector load_from_file( filesystem::path const& filename )
+{
+	std::ifstream f(filename.c_str(), std::ios::binary | std::ios_base::in);
+	std::streampos sz = f.seekg(0, std::ios::end).tellg();
+	f.seekg(0, std::ios::beg);
+
+	byte_vector buffer(static_cast<size_t>(sz));
+	char *d = reinterpret_cast<char*>(buffer.data());
+	size_t remaining = buffer.size();
+	while(remaining > 0) {
+		std::streamsize r = f.read(d, remaining).gcount();
+		if (r < 0) { break; }
+		d += static_cast<size_t>(r);
+		remaining -= static_cast<size_t>(r);
+	}
+	return buffer;
+}
+
+inline void save_to_file( filesystem::path const& filename, byte_vector const& data )
+{
+	std::ofstream f(filename.c_str(), std::ios::binary | std::ios::out);
+	f.write(reinterpret_cast<char const*>(data.data()), data.size());
+}
+
+}}}	//namespace zinodrsky::steganography::utils
+

data/ext/zindosteg/hmac.h

@@ -0,0 +1,82 @@
+#include <openssl/hmac.h>
+
+namespace zindorsky {
+namespace crypto {
+
+//RAII wrapper for OpenSSL HMAC API
+class hmac {
+public:
+	enum { digest_sz = 32 };
+
+	hmac(void const* key, int length) noexcept
+		: hmac_{HMAC_CTX_new()}
+	{
+		HMAC_Init_ex(hmac_, key, length, EVP_sha256(), nullptr);
+	}
+
+	hmac( hmac const& rhs ) noexcept
+		: hmac_{HMAC_CTX_new()}
+	{
+		HMAC_CTX_copy(hmac_, const_cast<hmac&>(rhs).hmac_);
+	}
+
+	hmac & operator = (hmac const& rhs) noexcept
+	{
+		if(this != &rhs) {
+			HMAC_CTX_copy(hmac_, const_cast<hmac&>(rhs).hmac_);
+		}
+		return *this;
+	}
+
+	hmac( hmac && rhs ) noexcept
+	{
+		hmac_ = rhs.hmac_;
+		rhs.hmac_ = nullptr;
+	}
+
+	hmac & operator = (hmac && rhs) noexcept
+	{
+		if(this != &rhs) {
+			if(hmac_) {
+				HMAC_CTX_free(hmac_);
+			}
+			hmac_ = rhs.hmac_;
+			rhs.hmac_ = nullptr;
+		}
+		return *this;
+	}
+
+	~hmac()
+	{
+		if(hmac_) {
+			HMAC_CTX_free(hmac_);
+		}
+	}
+
+	//HMAC operations:
+	void reset()
+	{
+		HMAC_Init_ex(hmac_, nullptr, 0, nullptr, nullptr);
+	}
+
+	void update( void const* data, std::size_t length )
+	{
+		HMAC_Update(hmac_, static_cast<byte const*>(data), length);
+	}
+
+	void final( byte * digest )
+	{
+		HMAC_Final(hmac_, digest, nullptr);
+	}
+
+private:
+	HMAC_CTX* hmac_;
+};
+
+class hmac_verification_failure : public std::runtime_error {
+public:
+	hmac_verification_failure() : std::runtime_error("HMAC verification failure.") {}
+};
+
+}} //namespace
+

data/ext/zindosteg/jpeg.cpp

@@ -0,0 +1,111 @@
+#include "jpeg.h"
+#include "steg_endian.h"
+#include "file_utils.h"
+#include <stdexcept>
+
+namespace zindorsky {
+namespace steganography {
+
+jpeg_provider::jpeg_provider( filesystem::path const& filename )
+	: jpeg_provider( utils::load_from_file(filename) )
+{
+}
+
+jpeg_provider::jpeg_provider(byte_vector const& data)
+	: jpeg_provider(data.data(), data.size())
+{
+}
+
+jpeg_provider::jpeg_provider(byte const* data, size_t size)
+	: jpeg_provider( byte_vector(data, data+size) )
+{
+}
+
+jpeg_provider::jpeg_provider(byte_vector && data)
+	: jinfo_(std::move(data))
+	, component_count_(0)
+	, sz_(0)
+{
+	component_count_ = static_cast<std::size_t>( jinfo_.object()->num_components );
+	wib_.resize(component_count_);
+	hib_.resize(component_count_);
+	comp_sz_.resize(component_count_);
+	for(std::size_t i=0; i<component_count_; ++i) {
+		wib_[i] = static_cast<std::size_t>( jinfo_.object()->comp_info[i].width_in_blocks );
+		hib_[i] = static_cast<std::size_t>( jinfo_.object()->comp_info[i].height_in_blocks );
+		comp_sz_[i] = wib_[i]*hib_[i]*DCTSIZE2;
+		sz_ += comp_sz_[i];
+	}
+}
+
+provider_t::index_t jpeg_provider::size() const
+{
+	return sz_;
+}
+
+#if LITTLE_ENDIAN
+# define INT16_LSB 0
+#else
+# define INT16_LSB 1
+#endif
+
+byte & jpeg_provider::access_indexed_data( provider_t::index_t index )
+{
+	std::size_t comp, row, col, block;
+	index_to_coordinates(index,comp,row,col,block);
+	JBLOCKARRAY rowblock = (*jinfo_.object()->mem->access_virt_barray)( (j_common_ptr)jinfo_.object(), jinfo_.coefficients()[comp], (JDIMENSION)row, 1, TRUE);
+	return reinterpret_cast<byte*>( &rowblock[0][col][block] )[ INT16_LSB ];
+}
+
+byte const& jpeg_provider::access_indexed_data( provider_t::index_t index ) const
+{
+	std::size_t comp, row, col, block;
+	index_to_coordinates(index,comp,row,col,block);
+	JBLOCKARRAY rowblock = (*jinfo_.object()->mem->access_virt_barray)( (j_common_ptr)jinfo_.object(), jinfo_.coefficients()[comp], (JDIMENSION)row, 1, FALSE);
+	return reinterpret_cast<byte const*>( &rowblock[0][col][block] )[ INT16_LSB ];
+}
+
+byte_vector jpeg_provider::commit_to_memory()
+{
+	return jinfo_.save_to_memory();
+}
+
+void jpeg_provider::commit_to_file(filesystem::path const& file)
+{
+	jinfo_.save_to_file(file);
+}
+
+byte_vector jpeg_provider::salt() const
+{
+	byte salt[8] = {0};
+	std::size_t salt_index=0;
+
+	for(std::size_t i=0; i<component_count_; ++i) {
+		for(std::size_t j=0; j<hib_[i]; ++j) {
+			JBLOCKARRAY rowblock = (*jinfo_.object()->mem->access_virt_barray)( (j_common_ptr)jinfo_.object(), jinfo_.coefficients()[i], (JDIMENSION)j, 1, FALSE);
+			salt[ salt_index++ % sizeof(salt) ] += static_cast<byte>( rowblock[0][j%wib_[i]][j%DCTSIZE2]>>1 );
+		}
+	}
+
+	return byte_vector(salt, salt+sizeof(salt));
+}
+
+void jpeg_provider::index_to_coordinates(provider_t::index_t index, std::size_t & comp, std::size_t & row, std::size_t & col, std::size_t & block) const
+{
+	if(index >= sz_) { throw std::out_of_range("index out of range"); }
+	for(comp=0; comp<component_count_; ++comp) {
+		if( index < comp_sz_[comp] ) {
+			break;
+		}
+		index -= comp_sz_[comp];
+	}
+	if(comp==component_count_) { throw std::logic_error("computed sizes incorrect"); }
+	
+	std::size_t rowsz = wib_[comp] * DCTSIZE2;
+	row = index / rowsz;
+	col = (index % rowsz) / DCTSIZE2;
+	block = index % DCTSIZE2;
+}
+
+}}	//namespace zindorsky::steganography 
+

data/ext/zindosteg/jpeg.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include "provider.h"
+#include <exception>
+#include "jpeg_helpers.h"
+
+namespace zindorsky {
+namespace steganography {
+
+class jpeg_provider : public provider_t {
+public:
+	explicit jpeg_provider( filesystem::path const& filename );
+    explicit jpeg_provider(byte_vector const& data);
+    explicit jpeg_provider(byte_vector && data);
+    jpeg_provider(byte const* data, size_t size);
+	//Movable:
+	jpeg_provider(jpeg_provider &&) = default;
+	jpeg_provider & operator = (jpeg_provider &&) = default;
+	
+	static std::string format() { return "JPG"; }
+
+	virtual index_t size() const override;
+	virtual byte & access_indexed_data( index_t index ) override;
+	virtual byte const& access_indexed_data( index_t index ) const override;
+	virtual byte_vector commit_to_memory() override;
+	virtual void commit_to_file(filesystem::path const& file) override;
+	virtual byte_vector salt() const override;
+
+private:
+	jpeg::decompress_ctx jinfo_;
+
+	std::size_t component_count_;
+	std::vector<std::size_t> wib_, hib_, comp_sz_;
+	index_t sz_;
+
+	void index_to_coordinates(index_t index, std::size_t & comp, std::size_t & row, std::size_t & col, std::size_t & block) const;
+};
+
+}}	//namespace zindorsky::steganography

data/ext/zindosteg/jpeg_helpers.cpp

@@ -0,0 +1,149 @@
+#include "jpeg_helpers.h"
+#include "file_utils.h"
+
+extern "C" void jpeglib_error_handler(j_common_ptr info)
+{
+	if(info) {
+		jpeg_abort(info);
+	}
+	//can't throw in extern "C" functions.
+//	throw steganography::jpeg::jpeg_exception(); 
+}
+
+namespace zindorsky {
+namespace steganography {
+namespace jpeg {
+
+decompress_ctx::decompress_ctx( filesystem::path const& filename )
+	: decompress_ctx( utils::load_from_file(filename) )
+{
+}
+
+decompress_ctx::decompress_ctx(byte const* data, size_t size)
+	: decompress_ctx( byte_vector(data, data+size) ) 
+{
+}
+
+decompress_ctx::decompress_ctx(byte_vector const& data)
+	: decompress_ctx(data.data(), data.size())
+{
+}
+
+decompress_ctx::decompress_ctx(byte_vector && data)
+	: data_(std::move(data))
+{
+	info_.err = jpeg_std_error(&err_mgr_);
+	err_mgr_.error_exit = jpeglib_error_handler;
+
+	jpeg_create_decompress(&info_);
+	//save markers for writing later
+	jpeg_save_markers(&info_,JPEG_COM,0xffff);
+	for(int i=1; i<=15; ++i) {
+		jpeg_save_markers(&info_,JPEG_APP0+i,0xffff);
+	}
+
+	try {
+		jpeg_mem_src(&info_, data_.data(), static_cast<unsigned long>(data_.size()));
+		jpeg_read_header(&info_,TRUE);
+		coeff_ = jpeg_read_coefficients(&info_);
+		if(!coeff_) {
+			throw jpeg_exception();
+		}
+	} catch(...) {
+		jpeg_destroy_decompress(&info_);
+		throw;
+	}
+}
+
+decompress_ctx::decompress_ctx(decompress_ctx && rhs)
+	: data_( std::move(rhs.data_) )
+	, err_mgr_( std::move(rhs.err_mgr_) )
+	, info_{0}
+	, coeff_( std::move(rhs.coeff_) )
+{
+	std::swap(info_, rhs.info_);
+}
+
+decompress_ctx & decompress_ctx::operator = (decompress_ctx && rhs)
+{
+	data_ = std::move(rhs.data_);
+	err_mgr_ = std::move(rhs.err_mgr_);
+	std::swap(info_, rhs.info_);
+	coeff_ = std::move(rhs.coeff_);
+	return *this;
+}
+
+decompress_ctx::~decompress_ctx()
+{
+	if (info_.src) {
+		jpeg_destroy_decompress(&info_);
+	}
+}
+
+void decompress_ctx::save_to_file( filesystem::path const& filename )
+{
+	FILE* file = ::fopen( filename.c_str(), "wb" );
+	if(!file) {
+		throw std::ios_base::failure("file open fail");
+	}
+
+	jpeg_error_mgr err_mgr;
+	jpeg_compress_struct info;
+
+	info.err = jpeg_std_error(&err_mgr);
+	err_mgr.error_exit = jpeglib_error_handler;
+
+	jpeg_create_compress(&info);
+	info.optimize_coding = TRUE;
+
+	jpeg_stdio_dest(&info, file);
+
+	jpeg_copy_critical_parameters(object(), &info);
+	jpeg_write_coefficients(&info, coefficients());
+	//copy markers and comments
+	for(jpeg_saved_marker_ptr curr=object()->marker_list; curr; curr=curr->next) {
+		if(curr->data && curr->data_length>0)
+			jpeg_write_marker(&info, curr->marker, curr->data, curr->data_length);
+	}
+	jpeg_finish_compress(&info);
+	jpeg_destroy_compress(&info);
+	::fclose(file);
+}
+
+byte_vector decompress_ctx::save_to_memory()
+{
+	byte *mem = nullptr;
+	unsigned long memsz = 0;
+
+	jpeg_error_mgr err_mgr;
+	jpeg_compress_struct info;
+
+	info.err = jpeg_std_error(&err_mgr);
+	err_mgr.error_exit = jpeglib_error_handler;
+
+	jpeg_create_compress(&info);
+	info.optimize_coding = TRUE;
+
+	jpeg_mem_dest(&info, &mem, &memsz);
+
+	jpeg_copy_critical_parameters(object(), &info);
+	jpeg_write_coefficients(&info, coefficients());
+	//copy markers and comments
+	for(jpeg_saved_marker_ptr curr=object()->marker_list; curr; curr=curr->next) {
+		if(curr->data && curr->data_length>0)
+			jpeg_write_marker(&info, curr->marker, curr->data, curr->data_length);
+	}
+	jpeg_finish_compress(&info);
+	jpeg_destroy_compress(&info);
+
+	if (mem && memsz) {
+		byte_vector result{ mem, mem + memsz };
+		::free(mem);
+		return result;
+	}
+
+	return{};
+}
+
+}}}	//namespace zindorsky::steganography::jpeg
+

data/ext/zindosteg/jpeg_helpers.h

@@ -0,0 +1,54 @@
+#ifndef steganography_jpeg_helpers_h_included
+#define steganography_jpeg_helpers_h_included
+
+#include "steg_defs.h"
+#include <cstdio>
+#include <jpeglib.h>
+#include <vector>
+
+//error handling callback for jpeg lib
+extern "C" void jpeglib_error_handler(j_common_ptr);
+
+namespace zindorsky {
+namespace steganography {
+namespace jpeg {
+
+class jpeg_exception : public std::runtime_error {
+public:
+	jpeg_exception() : std::runtime_error("JPEG file error") {}
+};
+
+class decompress_ctx {
+public:
+	explicit decompress_ctx( filesystem::path const& filename );
+	decompress_ctx(byte const* data, size_t size);
+	explicit decompress_ctx(byte_vector const& data);
+	explicit decompress_ctx(byte_vector && data);
+
+	//Non-copyable
+	decompress_ctx(decompress_ctx const&) = delete;
+	decompress_ctx & operator = (decompress_ctx const&) = delete;
+	//Movable
+	decompress_ctx(decompress_ctx &&);
+	decompress_ctx & operator = (decompress_ctx &&);
+	~decompress_ctx();
+	
+	jpeg_decompress_struct * object() { return &info_; }
+	jpeg_decompress_struct const* object() const { return &info_; }
+
+	jvirt_barray_ptr* coefficients() const { return coeff_; }
+
+	void save_to_file( filesystem::path const& filename );
+	byte_vector save_to_memory();
+
+private:
+	byte_vector data_;
+	jpeg_error_mgr err_mgr_;
+	jpeg_decompress_struct info_;
+	jvirt_barray_ptr *coeff_;
+};
+
+}}}	//namespace zindorsky::steganography::jpeg
+
+#endif //include guard
+

data/ext/zindosteg/key_generator.cpp

@@ -0,0 +1,36 @@
+#include "key_generator.h"
+#include <openssl/evp.h>
+
+namespace zindorsky {
+namespace crypto {
+
+key_generator::key_generator(std::string const& password, byte_vector const & salt, int iterations)
+	: password{password}
+	, salt{salt}
+	, iterations{iterations}
+{
+}
+
+key_generator::key_generator(std::string const& password, byte const* salt, std::size_t salt_sz, int iterations)
+	: password{password}
+	, salt{salt,salt+salt_sz}
+	, iterations{iterations}
+{
+}
+
+void key_generator::generate(byte * key, std::size_t length) const
+{
+	PKCS5_PBKDF2_HMAC_SHA1(password.c_str(), static_cast<int>(password.size()), salt.data(), static_cast<int>(salt.size()), iterations, static_cast<int>(length), key);
+}
+
+byte_vector key_generator::generate(std::size_t length) const
+{
+	byte_vector key(length);
+	if(!key.empty()) {
+		generate(&key[0],length);
+	}
+	return key;
+}
+
+}}	//namespace zindorsky::crypto
+

data/ext/zindosteg/key_generator.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "steg_defs.h"
+#include <string>
+
+namespace zindorsky {
+namespace crypto {
+
+class key_generator {
+public:
+	key_generator(std::string const& password, byte_vector const& salt, int iterations = 10000);
+	key_generator(std::string const& password, byte const* salt, std::size_t salt_sz, int iterations = 10000);
+
+	void generate(byte * key, std::size_t length) const;
+	byte_vector generate(std::size_t length) const;
+
+private:
+	std::string password;
+	byte_vector salt;
+	int iterations;
+};
+
+}}	//namespace zindorsky::crypto

data/ext/zindosteg/loader.cpp

@@ -0,0 +1,72 @@
+#include <fstream>
+#include "provider.h"
+//Currently implemented providers:
+#include "bmp.h"
+#include "jpeg.h"
+#include "png_provider.h"
+#include "string.h"
+
+namespace zindorsky {
+namespace steganography {
+
+namespace {
+	const size_t min_header_sz = 0x40;
+}
+
+std::unique_ptr<provider_t> provider_t::load(filesystem::path const& file)
+{
+	std::ifstream source(file.c_str());
+	//read first few bytes for header
+	byte header[min_header_sz];
+	source.read(reinterpret_cast<char*>(header),sizeof(header));
+	source.close();
+	
+	if( header[0]=='B' && header[1]=='M' ) {
+		return std::make_unique<bmp_provider>( file );
+	}
+	if( header[0]==0xff && header[1]==0xd8 && header[2]==0xff
+		&& (memcmp(&header[6],"JFIF",4)==0 || memcmp(&header[6],"Exif",4)==0) )
+	{
+		return std::make_unique<jpeg_provider>( file );
+	}
+    if( memcmp(header, png_provider::signature, sizeof(png_provider::signature)) == 0 ) {
+        return std::make_unique<png_provider>(file);
+    }
+
+	throw invalid_carrier{};
+}
+
+std::unique_ptr<provider_t> provider_t::load(void const* data, size_t size)
+{
+	byte const* d = static_cast<byte const*>(data);
+
+	if (!d || size < min_header_sz) {
+		throw invalid_carrier{};
+	}
+
+	if( d[0]=='B' && d[1]=='M' ) {
+		return std::make_unique<bmp_provider>( d, size );
+	}
+	if( d[0]==0xff && d[1]==0xd8 && d[2]==0xff
+		&& (memcmp(&d[6],"JFIF",4)==0 || memcmp(&d[6],"Exif",4)==0) )
+	{
+		return std::make_unique<jpeg_provider>( d, size );
+	}
+    if( memcmp(data, png_provider::signature, sizeof(png_provider::signature))==0 ) {
+        return std::make_unique<png_provider>(d, size);
+    }
+
+	throw invalid_carrier{};
+}
+
+std::vector<std::string> provider_t::supported_formats()
+{
+	return{ 
+		bmp_provider::format()
+		, jpeg_provider::format()
+		, png_provider::format()
+	};
+}
+
+}}	//namespace zindorsky::steganography
+