zindosteg 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 01ac48210a386fca7fec50d18a609ced3f2122f0087f1fc6ead5a14970e89968
+  data.tar.gz: 4d11432c88bb155006a58f9f9dda92d292afb7dd5a4b671cf086b5a54467cc69
+SHA512:
+  metadata.gz: '06884588dc026719a0e8f86774075432e18a459f7aa586677499bfcce31d5664705e1d06eeab09f52ddf4f8126a50e15fc26acda500c852309d7532ae87285d9'
+  data.tar.gz: c860ce6d6f4c160fcf6d5b02066b661777fd41abde8189b5affc9a0b8eef3785e8a608f1a09079001ce3d94d2bb20d346ab92557d7836ca25cd3d66003b4ba24

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+
+Gemfile.lock

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,6 @@
+---
+language: ruby
+cache: bundler
+rvm:
+  - 2.5.1
+before_install: gem install bundler -v 2.1.0

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in zindosteg.gemspec
+gemspec
+
+gem "rake", "~> 12.0"
+gem "rspec", "~> 3.0"

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Nephi Allred
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,92 @@
+# Zindosteg
+
+Steganography is the art and science of hiding data inside another set of data. The hidden data is known as the "payload", and could be any kind of data. The data that holds the hidden data is called the "carrier" and is normally an image, sound, or video file. The goal is to modify the carrier file in such a way that to human eyes it appears the same as before, but the subtle differences actually encode bits (0s and 1s) that can be reassembled into the payload.
+
+This gem is a Ruby interface to the Zindosteg C++ library, which uses a variant of the F5 data hiding technique.
+
+## Features
+* Encryption: The payload is encrypted with AES-256-CTR using a key derived from the password using the carrier file as salt.
+* Data integrity: In order to protect against accidental corruption or intentional tampering, the payload is stored with an HMAC.
+* Scattering: Instead of placing the payload sequentially inside the carrier file, the order of the hidden bits is determined by a pseudo-random number generator seeded with the password.
+
+## Supported Carrier Types
+Zindosteg supports JPEG, PNG, and BMP carrier files. PNG files must have at least 8 bit depth, and not be "palette" type. BMP files must be 24-bit.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'zindosteg'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install zindosteg
+
+Note: To compile the native extensions, you may need to install JPEG, PNG, and OpenSSL development packages.
+
+## Usage
+Zindosteg is designed to mimic Ruby's `File` class as closely as possible. The basic idea is that you get a `Zindosteg` instance by "opening" the carrier file with a password. Then you can read and write to the `Zindosteg` object in the same way you normally would to a `File` object, using the same methods (e.g. `read`, `write`, `readlines`, `eof?`, `seek`, `tell`, etc.). You can even pass the `Zindosteg` instance to functions that expect `File` objects and everything should work.
+
+### Examples
+```
+# Open a new carrier for writing (overwriting any existing payload)
+file = ::Zindosteg::File.open("carrier.jpeg", "secretpassword", "w")
+
+# Write the payload to it
+file.write("This is my secret payload.")
+
+# Close to finalize
+file.close
+
+# Open an existing carrier file for reading
+file = ::Zindosteg::File.open("carrier.jpeg", "secretpassword", "r")
+
+# The mode parameter is "r" by default so this is equivalent to the above:
+file = ::Zindosteg::File.open("carrier.jpeg", "secretpassword")
+
+# Read the payload
+file.read
+
+# Or you could read it as an array of lines.
+file.readlines
+
+# Use all the regular File methods as you would normally
+file.seek(0)
+file.tell
+file.size
+file.eof?
+# etc
+
+# Use the `capacity` method to see the maximum number of bytes that the carrier file can hide.
+file.capacity
+
+# All the standard modes for opening files are supported:
+file = ::Zindosteg::File.open("carrier.jpeg", "secretpassword", "w+") # Opens for reading and writing, truncating any existing payload
+
+file = ::Zindosteg::File.open("carrier.jpeg", "secretpassword", "a") # Opens for appending
+
+# etc
+
+# If you open for reading (or appending) and either (1) an incorrect password is given, or (2) there is no existing payload, or (3) the carrier file has been corrupted or tampered with, then a exception will be thrown.
+
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/zindorsky/zindosteg-ruby.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rake/extensiontask"
+
+Rake::ExtensionTask.new "zindosteg" do |ext|
+  ext.lib_dir = "lib/zindosteg"
+end
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "zindosteg"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/ext/zindosteg/aes.cpp

@@ -0,0 +1,73 @@
+#include "./aes.h"
+#include <string.h>
+#include <algorithm>
+#include "steg_endian.h"
+
+namespace zindorsky {
+namespace crypto {
+
+aes::aes(byte const* key, int keysize) { rekey(key,keysize); }
+void aes::encrypt(byte const* in, byte * out) const { AES_encrypt(in,out,&ekey_); }
+void aes::decrypt(byte const* in, byte * out) const { AES_decrypt(in,out,&dkey_); }
+void aes::rekey(byte const* key, int keysize) { AES_set_encrypt_key(key,keysize*8,&ekey_); AES_set_decrypt_key(key,keysize*8,&dkey_); }
+
+namespace {
+
+void add128(byte * a, int p)
+{
+	std::int64_t a0,a1;
+	endian::read_be(a+8,a0);
+	a1 = a0+p;
+	endian::write_be(a1,a+8);
+	if( (p<0 && a1>a0) || (p>0 && a1<a0) ) {
+		endian::read_be(a,a0);
+		endian::write_be(a0+(p<0?-1:1),a);
+	}
+}
+
+}	//namespace
+
+aes_ctr_mode::aes_ctr_mode(byte const* key, int keysize, byte const* iv)
+	: key_(key,keysize)
+	, pos_(0)
+	, buffpos_(0)
+{
+	memcpy(iv_,iv,sizeof(iv_));
+	key_.encrypt(iv_,buff_);
+}
+
+void aes_ctr_mode::crypt(void const* inv, void * outv, size_t length)
+{
+    byte const* in = static_cast<byte const*>(inv);
+    byte * out = static_cast<byte *>(outv);
+	while(length > 0) {
+		size_t todo = std::min(length, 16-buffpos_);
+		for(size_t i=0; i<todo; ++i) {
+			*out++ = *in++ ^ buff_[buffpos_++];
+		}
+		length -= todo;
+		pos_ += todo;
+		if(buffpos_ >= 16) {
+			for(int i=15; i>=0; --i) {
+				if( ++iv_[i] != 0 ) {
+					break;
+				}
+			}
+			buffpos_ = 0;
+			key_.encrypt(iv_,buff_);
+		}
+	}
+}
+
+void aes_ctr_mode::seek(std::streampos pos)
+{
+	auto block = pos_/16, newblock = pos/16;
+	buffpos_ = static_cast<size_t>(pos)%16;
+	if(block != newblock) {
+		add128(iv_,static_cast<int>(newblock-block));
+		key_.encrypt(iv_,buff_);
+	}
+	pos_ = pos;
+}
+
+}}	//namespace zindorsky::crypto

data/ext/zindosteg/aes.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include "steg_defs.h"
+#include <openssl/aes.h>
+#include <ios>
+
+namespace zindorsky {
+namespace crypto {
+
+class aes {
+public:
+	aes(byte const* key, int keysize);
+	void encrypt(byte const* in, byte * out) const;
+	void decrypt(byte const* in, byte * out) const;
+	void rekey(byte const* key, int keysize);
+
+private:
+	AES_KEY ekey_;
+	AES_KEY dkey_;
+};
+
+class aes_ctr_mode {
+public:
+	aes_ctr_mode(byte const* key, int keysize, byte const* iv);
+	void crypt(void const* in, void * out, size_t length);
+	void seek(std::streampos pos);
+	std::streampos tell() const { return pos_; }
+
+private:
+	aes key_;
+	byte iv_[16], buff_[16];
+	std::streampos pos_;
+	size_t buffpos_;
+};
+
+}}	//namespace zindorsky::steganography

data/ext/zindosteg/bmp.cpp

@@ -0,0 +1,100 @@
+#include "bmp.h"
+#include "steg_endian.h"
+#include "file_utils.h"
+#include <cstdint>
+
+namespace zindorsky {
+namespace steganography {
+
+bmp_provider::bmp_provider( filesystem::path const& filename )
+	: bmp_provider( utils::load_from_file(filename) )
+{
+}
+
+bmp_provider::bmp_provider(byte const* data, size_t size)
+	: bmp_provider( byte_vector(data, data+size) )
+{
+}
+
+bmp_provider::bmp_provider(byte_vector const& data)
+	: bmp_provider(data.data(), data.size())
+{
+}
+
+bmp_provider::bmp_provider(byte_vector && data)
+	: file_(std::move(data))
+{
+	if (file_.size() < 54) {
+		throw invalid_carrier();
+	}
+
+	byte const* header = &file_[0];
+
+	int bits_per_pixel = (int(header[29])<<8) | header[28];
+	//only 24-bit BMPs for now (others use a palette, which makes steganography more difficult)
+	if( bits_per_pixel != 24 ) {
+		throw std::runtime_error("unsupported BMP format");
+	}
+
+	uint32_t data_offset, col_count, row_count;
+	endian::read_le(&header[10], data_offset);
+	endian::read_le(&header[18], col_count);
+	endian::read_le(&header[22], row_count);
+
+	row_sz_ = (col_count*bits_per_pixel + 7)/8;
+	row_count_ = row_count;
+	if( row_sz_ % 4 == 0 ) {
+		slack_sz_ = 0;
+	} else {
+		slack_sz_ = 4 - row_sz_%4;
+	}
+
+	data_ = file_.data() + data_offset;
+}
+
+provider_t::index_t bmp_provider::size() const
+{
+	return row_sz_ * row_count_;
+}
+
+byte & bmp_provider::access_indexed_data( index_t index )
+{
+	return *(data_ + logical_to_physical(index));
+}
+
+byte const& bmp_provider::access_indexed_data( index_t index ) const
+{
+	return *(data_ + logical_to_physical(index));
+}
+
+byte_vector bmp_provider::commit_to_memory()
+{
+	return file_;
+}
+
+void bmp_provider::commit_to_file(filesystem::path const& file)
+{
+	utils::save_to_file(file, file_);
+}
+
+byte_vector bmp_provider::salt() const
+{
+	byte salt[8]={0};
+	for(std::size_t i=0; i<row_count_; ++i) {
+		salt[ i%sizeof(salt) ] += access_indexed_data(i*row_sz_ + i%row_sz_)>>1;
+	}	
+
+	return byte_vector(salt,salt+sizeof(salt));
+}
+
+std::size_t bmp_provider::logical_to_physical( provider_t::index_t index ) const
+{
+	if( slack_sz_ == 0 ) {
+		return static_cast<std::size_t>(index);
+	}
+	std::size_t row = static_cast<std::size_t>(index / row_sz_), col = static_cast<std::size_t>(index % row_sz_);
+	return row*(row_sz_+slack_sz_) + col;
+}
+
+}}	//namespace zindorsky::steganography
+

data/ext/zindosteg/bmp.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include "provider.h"
+#include <vector>
+
+namespace zindorsky {
+namespace steganography {
+
+class bmp_provider : public provider_t {
+public:
+	explicit bmp_provider( filesystem::path const& filename );
+	bmp_provider(byte const* data, size_t size);
+	explicit bmp_provider(byte_vector const& data);
+	explicit bmp_provider(byte_vector && data);
+	//Copyable
+	bmp_provider(bmp_provider const&) = default;
+	bmp_provider & operator = (bmp_provider const&) = default;
+	//Movable
+	bmp_provider(bmp_provider &&) = default;
+	bmp_provider & operator = (bmp_provider &&) = default;
+
+	static std::string format() { return "BMP"; }
+
+	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:
+	byte_vector file_;
+	byte *data_;
+	std::size_t row_sz_, row_count_, slack_sz_; 
+
+	std::size_t logical_to_physical( index_t index ) const;
+};
+
+}}	//namespace zindorsky::steganography

data/ext/zindosteg/device.cpp

@@ -0,0 +1,244 @@
+#include "device.h"
+#include <cassert>
+#include "steg_endian.h"
+
+namespace zindorsky {
+namespace steganography {
+
+enum { max_length_sz = 9, nybble_span = 15, byte_span = nybble_span*2, };
+
+device_t::device_t( filesystem::path const& carrier_file, std::string const& password, bool open_existing_payload, bool throw_on_open_existing_fail )
+	: device_t( provider_t::load(carrier_file), password, open_existing_payload, throw_on_open_existing_fail )
+{
+	carrier_file_ = carrier_file;
+}
+
+device_t::device_t( std::unique_ptr<provider_t> provider, std::string const& password, bool open_existing_payload, bool throw_on_open_existing_fail )
+	: provider_( std::move(provider) )
+	, shuffler_(provider_->size() / nybble_span, crypto::key_generator(password,provider_->salt()))
+	, max_sz_( provider_->size() / byte_span - max_length_sz )
+	, payload_sz_( 0 )
+	, pos_(0)
+	, dirty_(false)
+{
+	if (!provider_) {
+		throw invalid_carrier();
+	}
+
+	if( max_sz_ <= 0 ) {
+		throw payload_extraction_error();
+	}
+	if( open_existing_payload ) {
+		payload_sz_ = read_payload_length(throw_on_open_existing_fail);
+	}
+	if( payload_sz_ > max_sz_ ) {
+		if (throw_on_open_existing_fail) {
+			throw payload_extraction_error();
+		} else {
+			payload_sz_ = 0;
+		}
+	}
+}
+
+std::streamsize device_t::read(char * s, std::streamsize n)
+{
+	if(!s || n<=0) {
+		return 0;
+	}
+	if( pos_ >= payload_sz_ ) {
+		return std::char_traits<char_type>::eof();
+	}
+	std::streamsize r=0;
+	while(n > 0 && pos_ < payload_sz_) {
+		*s = static_cast<char>(get_byte(pos_));
+		++s;
+		pos_ += 1;
+		++r;
+		--n;
+	}
+	return r;
+}
+
+std::streamsize device_t::write(char const* s, std::streamsize n)
+{
+	if(!s || n<=0) {
+		return 0;
+	}
+	if( pos_ >= max_sz_ ) {
+		return std::char_traits<char_type>::eof();
+	}
+	std::streamsize r=0;
+	while(n > 0 && pos_ < max_sz_) {
+		byte b = static_cast<byte>(*s);
+		put_byte(b,pos_);
+		++s;
+		pos_ += 1;
+		++r;
+		--n;
+	}
+	if( pos_ > payload_sz_ ) {
+		payload_sz_ = pos_;
+		dirty_ = true;
+	}
+	return r;
+}
+
+std::streampos device_t::seek(std::streamoff off, std::ios::seekdir way)
+{
+	std::streampos newpos;
+	switch(way) {
+	case std::ios::cur: newpos = pos_; break;
+	case std::ios::end: newpos = payload_sz_; break;
+	default: newpos = 0; break;
+	}
+	newpos += off;
+	if( newpos < 0 ) {
+		throw std::ios::failure("underseek");
+	}
+	if( newpos > max_sz_ ) {
+		newpos = max_sz_;
+	}
+	return pos_ = newpos;
+}
+
+void device_t::close()
+{
+	if (dirty_ && !carrier_file_.empty()) {
+		write_to_file(carrier_file_);
+		dirty_ = false;
+	}
+}
+
+void device_t::flush()
+{
+	if (dirty_ && !carrier_file_.empty()) {
+		write_to_file(carrier_file_);
+		dirty_ = false;
+	}
+}
+
+void device_t::write_to_file(filesystem::path const& outfile)
+{
+	if (dirty_) {
+		write_payload_length();
+	}
+	provider_->commit_to_file(outfile);
+	dirty_ = false;
+}
+
+byte_vector device_t::write_to_memory()
+{
+	if (dirty_) {
+		write_payload_length();
+	}
+	dirty_ = false;
+	return provider_->commit_to_memory();
+}
+
+byte device_t::get_byte(std::streampos const& pos, provider_t::index_t * lo_start, provider_t::index_t * hi_start) const
+{
+	assert( pos < max_sz_ + max_length_sz );
+
+	provider_t::index_t index = shuffler_[pos*2]*nybble_span;
+	if(lo_start) { *lo_start = index; }
+
+	byte cl=0;
+	for(byte i=1; i<=nybble_span; ++i) {
+		if( provider_->access_indexed_data( index++ ) & 1 ) {
+			cl ^= i;
+		}
+	}
+
+	index = shuffler_[pos*2+1]*nybble_span;
+	if(hi_start) { *hi_start = index; }
+
+	byte ch=0;
+	for(byte i=1; i<=nybble_span; ++i) {
+		if( provider_->access_indexed_data( index++ ) & 1 ) {
+			ch ^= i;
+		}
+	}
+	return (ch<<4)|cl;
+}
+
+void device_t::put_byte(byte b, std::streampos const& pos)
+{
+	assert( pos < max_sz_ + max_length_sz );
+
+	provider_t::index_t lo_start, hi_start;
+	byte c = get_byte(pos,&lo_start,&hi_start);
+	byte cl = c&15, ch = c>>4, bl = b&15, bh = b>>4;
+	if(bl != cl) {
+		provider_->access_indexed_data( lo_start + (bl^cl) - 1 ) ^= 1;
+		dirty_ = true;
+	}
+	if(bh != ch) {
+		provider_->access_indexed_data( hi_start + (bh^ch) - 1 ) ^= 1;
+		dirty_ = true;
+	}
+}
+
+std::streamsize device_t::truncate()
+{
+    if(payload_sz_ != pos_) {
+        dirty_ = true;
+    }
+	return payload_sz_ = pos_;
+}
+
+std::streamsize device_t::read_payload_length(bool throw_on_fail) const
+{
+	std::streampos pos = max_sz_+max_length_sz-1;
+	std::streamsize sz = 0;
+	unsigned int shift=0;
+	byte b;
+	do {
+		if(shift+7 > sizeof(std::streampos)*8) {
+			if (throw_on_fail) {
+				throw payload_extraction_error();
+			} else {
+				return 0;
+			}
+		}
+		b = get_byte(pos);
+		pos -= 1;
+		sz |= static_cast<std::streampos>(b&0x7f)<<shift;
+		shift += 7;
+	} while(b&0x80);
+
+	return sz;
+}
+
+void device_t::write_payload_length()
+{
+	if (payload_sz_ < 0) {
+		throw payload_extraction_error();
+	}
+	std::streampos pos = max_sz_+max_length_sz-1;
+	std::streamsize sz = payload_sz_;
+	do {
+		byte b = static_cast<byte>( sz&0x7f );
+		sz >>= 7;
+		if( sz > 0 ) {
+			b |= 0x80;
+		}
+		put_byte(b,pos);
+		pos -= 1;
+	} while( sz>0 );
+}
+
+byte_vector device_t::salt_for_encryption() const
+{
+	if (!provider_) {
+		return{};
+	}
+	byte_vector salt = provider_->salt();
+	//Though it's probably fine, for safety, make the salt different than the salt used by the shuffler.
+	if(!salt.empty()) {
+		salt.front() += 1;
+	}
+	return salt;
+}
+
+}}	//namespace zindorsky::steganography
+