unveiler 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: deb8e270b0525876f90650a279865f89b2fda044
+  data.tar.gz: 637a0e13085f4577cc8eb616bcf74899763d5b88
+SHA512:
+  metadata.gz: 46c3da0e933f6c31eee9cbe158dda816566a18cd4ff0c875de99b9f19d6163878b698e9275a1d13d6122623e287d8a517aa371dbd6c0f9c24fa537cd8bf3c4d3
+  data.tar.gz: 50ecc0fbfaa9db8f5e037a9ad09b81bbda9b63257bdcf77331d90cc67223ff5bffc43cc21ecf838504d219c2d1da459e0e73b6b55f1e831b334bdd42866e1b32

data/bin/unveiler

@@ -0,0 +1,67 @@
+#!/usr/bin/env ruby
+require 'unveiler'
+
+# Encodes the input file with the specified data, saving the manipulated data
+# to the output file.
+#
+# +input+::  File to be encoded
+# +output+:: File to write encoded data to
+# +data+::   Data to be encoded
+def encode(input, output, data)
+  begin
+    target = read_file(input)
+    data = Unveiler.encode(target, data)
+    write_file(output, data)
+  rescue
+    puts $!
+  end
+end
+
+# Decodes the provided input file and saves the decoded data to the output
+# file.
+#
+# +input+::  File to be decoded
+# +output+:: File to write decoded data to
+def decode(input, output)
+  begin
+    target = read_file(input)
+    data = Unveiler.decode(target)
+    write_file(output, data + "\n")
+  rescue
+    puts $!.message
+  end
+end
+
+# Reads data from the specified file.
+#
+# +input+:: File to read
+def read_file(input)
+  File.open(input, 'rb'){|file| return file.read}
+end
+
+# Writes data to the specified file.
+#
+# +output+:: File to write
+def write_file(output, data)
+  File.open(output, 'wb'){|file| file.write(data)}
+end
+
+# Prints unveiler usage examples.
+def usage
+  puts 'Usage:'
+  puts 'unveiler encode [input_file] [output_file] [data]'
+  puts 'unveiler decode [input_file] [output_file]'
+end
+
+# Parses ARGV to ensure the correct parameters are given.
+def parse_argv
+  if ARGV.first == 'encode'
+    ARGV.length == 4 ? encode(ARGV[1], ARGV[2], ARGV[3]) : usage
+  elsif ARGV.first == 'decode'
+    ARGV.length == 3 ? decode(ARGV[1], ARGV[2]) : usage
+  else
+    usage
+  end
+end
+
+ARGV.empty? ? usage : parse_argv

data/lib/unveiler.rb

@@ -0,0 +1,121 @@
+require 'base64'
+
+# Unveiler is a basic steganography tool that encodes data by manipulating
+# existing binary data and can decode previously encoded data.
+#
+# Author::      Brendan Goodenough
+# Copyright::   Copyright (c) 2016 Brendan Goodenough
+# License::     MIT
+#
+# The encoding of the data is achieved by manipulating the least significant
+# bits of each byte in the target data. These bits are replaced with the next
+# sequential bit of the data to be encoded, looping until the end of the data
+# is reached.
+#
+# Decoding is achieved by looping through each byte of the target data, and
+# stringing together the least significant bits of each byte. This is repeated
+# until the last 3 bytes in the string of bits forms the phrase 'EOF'.
+
+class Unveiler
+  # Encodes the specified string of data into the target data. Upon success,
+  # a UTF-8 string containing the manipulated data will be returned.
+  #
+  # +target+::  Target data to be manipulated
+  # +data+::    Data to encode
+  def self.encode(target, data)
+    raise ArgumentError, 'target must be a string' unless target.is_a? String
+    raise ArgumentError, 'data must be a string' unless data.is_a? String
+
+    # Convert target data into an array of bytes
+    bytes = target.unpack('B*')[0].scan(/.{8}/)
+
+    # Convert data to binary
+    data = Base64.encode64(data)
+    data += 'EOF'
+    data = data.unpack('B*').first
+
+    # Encode the data into the array of bytes
+    bytes = self.manipulate_bytes(bytes, data)
+
+    # Convert binary to UTF-8
+    bytes.map!{|byte| byte = byte.to_i(2)}
+    return bytes.pack('C*').force_encoding('utf-8')
+  end
+
+  # Decodes any data within the specified target data. Upon success, the decoded
+  # string will be returned.
+  #
+  # +target+::  Target data to be decoded
+  def self.decode(target)
+    raise ArgumentError, 'target must be a String' unless target.is_a? String
+
+    # Convert the target data into an array of bytes
+    bytes = target.unpack('B*')[0].scan(/.{8}/)
+
+    # Obtain string from the bytes
+    bytes = self.process_bytes(bytes)
+    return Base64.decode64(bytes)
+  end
+
+  # Manipulates an array of bytes by looping through and replacing the least
+  # significant bit of each byte with the next sequential bit in a string of
+  # binary data. The loop will break when the end of the data string is
+  # reached. Returns the manipulated array of bytes.
+  #
+  # +bytes+:: Array of bytes to manipulate
+  # +data+::  Binary data to insert
+  def self.manipulate_bytes(bytes, data)
+    count = 0
+
+    8.times do |index|
+      # Loop through each byte and replace the bit at the given index
+      bytes.reverse.each do |byte|
+        byte[7 - index] = data[count]
+        count += 1
+        return bytes if count == data.length
+      end
+    end
+
+    # Ran out of space to encode data
+    raise 'Input file is too small for the specified data'
+  end
+
+  # Processes the specified array of bytes by looping through each byte and
+  # appending the least significant bit onto a string of bits. At the end of
+  # every eighth bit, a check will be made to see if the last 3 bytes of the
+  # string contain the phrase 'EOF'. Only the bytes before EOF will be returned
+  # if the phrase is found. An error will be raised if no EOF is found.
+  #
+  # +bytes+:: Array of bytes to be processed
+  def self.process_bytes(bytes)
+    bits = ''
+
+    8.times do |index|
+      bytes.reverse.each do |byte|
+        # Least significant bit
+        bits += byte[7 - index]
+
+        # Check whether a full byte has been read
+        if bits.length % 8 == 0
+          # Convert bits to array of bytes
+          data = bits.scan(/.{8}/)
+
+          if data.length >= 3
+            # Convert bytes to a UTF-8 string
+            data.map!{|b| byte = b.to_i(2)}
+            data = data.pack('C*').force_encoding('utf-8')
+            len = data.length
+
+            if data[-3,3] == 'EOF'
+              # Return the UTF-8 string, excluding 'EOF'
+              return data[0..len - 3]
+            end
+          end
+        end
+      end
+    end
+
+    # No EOF was found, error
+    raise 'No phrase matching "EOF" was found'
+  end
+end

metadata

@@ -0,0 +1,47 @@
+--- !ruby/object:Gem::Specification
+name: unveiler
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Brendan Goodenough
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-05-22 00:00:00.000000000 Z
+dependencies: []
+description: Unveiler encodes hidden messages within files by manipulating their least
+  significant bits.
+email: brendan@goodenough.nz
+executables:
+- unveiler
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/unveiler
+- lib/unveiler.rb
+homepage: https://github.com/nerdenough/unveiler
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Encode hidden messages in files
+test_files: []