machinator 0.1

data/README.rdoc

@@ -0,0 +1,101 @@
+Machinator can perform code obfuscation on file content and directory structures. 
+
+It can be paired up with high level language deployment and/or compression routines to keep even Big Brother guessing. Or can it?
+
+http://rubygems.org/gems/machinator
+
+== Terminal usage
+
+As a ruby gem
+
+    machinator -h
+  
+Or (with the source) you can just:
+
+    ruby bin/machinator -h
+
+== Obfuscating
+
+Machinator lets you define the schema for obfuscation.
+    
+A schema (in YAML) is defined in a .machinator file in the current directory, or a manually specified Hash resource.
+
+A schema has a words and a names hash collection, with each key/pair being a regular expression and strings to replace with any occurences, respectively.
+
+An example:
+
+    words: {      
+        namepsace\.Foo: nameSpace.bar            
+    }  
+        
+    names: {
+        SomeFile\.js$: ABC.js
+    }
+           
+Any words are matched against the entire file. File names are obfuscated afterwards (will only be matched once).
+ 
+== Using In Code 
+
+    require "machinator"
+    winston = Machinator::Obfuscator.new
+    winston.neverspeak(source, schema)
+
+The source can be an actual string to obfuscate, a File object, or a directory/file path to operate on.
+Keep in mind that the Obfuscator module will overwrite any files/directories that matches the schema. 
+
+Note: If you specify a string to obfusctate that is actually a valid file/directory path it will operate on that instead.
+
+== Manipulating Strings
+
+In the case of passing in a string an obfuscated copy will be returned.
+
+    new_string = winston.neverspeak("some string to obfuscate", { 
+      "words" => {
+        /^some\sstring/ => "something"
+      }
+    })
+
+== Operating on Files and Directories
+
+You can operate on a single file, where the first matched names key/pair is applied to the file name and any words are applied against the file content.
+
+    # renames to foo.foo
+    winston.neverspeak("foo.bar", {
+      "names" => {
+        /bar$/ => "foo" 
+      }
+    })
+
+If you specify a directory all files and directories inside will be operated on (recursively, bottom up), applying names/words matches to each file.
+
+    # let somedir have 'afile' in it
+    winston.neverspeak("somedir", {
+      "names" => {
+        /afile$/ => "thefile" 
+      }
+    })
+
+Note: This will recurse (fairly deep) so make sure the passed in directory is correct, or you could possibly bring on the apocalypse.
+
+== Filtering
+
+You can pass in a block to filer file operations (both words and names).
+
+    winston.neverspeak("somedir", schema) { |path| 
+      true
+    } # will operate on every file found
+
+== Dependencies
+
+None 
+        
+== Tests
+    
+rake test (need mocha, and rake... if you want)
+
+== Author
+    
+Copyright 2010 Brent Lintner
+
+The MIT License
+http://www.opensource.org/licenses/mit-license.php

data/bin/machinator

@@ -0,0 +1,2 @@
+require File.expand_path(File.dirname(__FILE__)) + "/../lib/machinator"
+Machinator::ConsoleInterface.new.interpret(ARGV)

data/lib/machinator/console_interface.rb

@@ -0,0 +1,58 @@
+module Machinator
+  class ConsoleInterface    
+    require 'ostruct'
+    require 'optparse'
+
+    VERSION_TEXT = '0.1'
+    HELP = <<TEXT
+
+== Machinator
+  obfuscate file content and directory structures
+
+== Usage
+  machinator [options]
+
+== Options
+  -h,   --help               Displays help message
+  -v,   --version            Displays the version
+
+TEXT
+    
+    def initialize
+      @options = OpenStruct.new      
+    end
+   
+    def interpret(argv)
+      @argv = argv
+      parsed_options?
+    end
+
+    def peace_out(msg)
+      puts(msg) ; exit!(0)
+    end
+
+    def parsed_options?
+      @options.verbose = false
+      
+      opts = OptionParser.new
+            
+      opts.on('-v', '--version')   { peace_out(VERSION_TEXT) }    
+      opts.on('-h', '--help')      { peace_out(HELP) }
+      opts.on('-o', '--obfuscate [path]') { |path| }
+
+      begin
+        opts.parse!(@argv)
+      rescue Exception => e
+        handle_exception(e) ; exit!(0)
+      end
+      
+      true
+    end
+    
+    def handle_exception(e)            
+      puts("\nshit pooped!\n\n")
+      puts "#{e.class.to_s} ==> #{e.message}\n\n"
+      puts e.backtrace.join("\n")
+    end
+  end
+end

data/lib/machinator/obfuscator.rb

@@ -0,0 +1,87 @@
+module Machinator
+  class Room101 < StandardError ; end
+  class Obfuscator  
+    require 'yaml'
+
+    def initialize
+      @block, @source, @schema = nil
+    end
+    
+    def neverspeak(source, schema=nil, &block)
+      @schema = schema
+      @source = source
+      @block = block
+
+      if @schema.nil?
+        config = File.join(@source, ".machinator")
+        if !File.exists?(config)
+          raise Room101, "no schema specified and no .machinator file was found."
+        end
+        @schema = YAML::load(File.open(config))
+      end
+ 
+      if @source.is_a?(File) || File.exist?(@source)
+        if !File.directory?(@source)
+          if !@block || @block.call(source)
+            obfuscate_file
+            obfuscate_file_name
+          end
+        else
+          obfuscate_dir
+        end
+      else
+        @source = String.new(@source)
+        obfuscate_string
+        return @source
+      end
+    end
+    
+    protected
+
+    def obfuscate_string(source=@source)
+      @schema["words"].each { |key, value|
+        source.gsub!(Regexp.new(key), value)
+      } if @schema["words"].is_a?(Hash)
+    end
+
+    def obfuscate_file(source=@source)
+      raise Room101, "could not find file to obfuscate (#{source})" if !File.exists?(@source)
+      file_buffer = ""
+      IO.foreach(source) { |line| file_buffer << line }
+      obfuscate_string(file_buffer)
+      File.open(source, "w") { |file| file.syswrite(file_buffer) }
+    end
+   
+    def obfuscate_file_name(source=@source)
+      @schema["names"].each { |key, value|
+        if (regex = Regexp.new(key)) =~ source
+          FileUtils.mv(source, source.gsub(regex, value)) ; break
+        end
+      } if @schema["names"].is_a?(Hash)
+    end
+
+    def obfuscate_dir(source=@source)
+      recurse(source) { |full_path|
+        if !@block || @block.call(full_path)
+          obfuscate_file(full_path) if !File.directory?(full_path)
+          obfuscate_file_name(full_path)
+        end
+      }
+    end
+    
+    def recurse(dir, limit=20, &block)
+      raise Room101, "recursive limit (20) reached" if limit <= 0
+      actual_path = dir.is_a?(File) ? dir.path : dir
+      Dir.foreach(actual_path) { |item|
+        full_path = File.join(actual_path, item)
+        if item !~ /^\.\.?$/
+          if File.directory?(full_path) 
+            recurse(full_path, limit - 1, &block)
+          end
+          yield(full_path) 
+        end
+      }
+      yield(actual_path)
+    end 
+  end
+end

data/lib/machinator.rb

@@ -0,0 +1,3 @@
+$LOAD_PATH << File.expand_path(File.dirname(__FILE__))
+require 'machinator/console_interface'
+require 'machinator/obfuscator'

data/machinator.gemspec

@@ -0,0 +1,22 @@
+Gem::Specification.new do |s|
+  s.platform = Gem::Platform::RUBY
+  s.name = 'machinator'
+  s.version = '0.1'
+  s.summary = 'obfuscate file content and directory structures.'
+  s.description = 'obfuscate file content and directory structures'
+
+  s.required_ruby_version = '>= 1.8.6'
+
+  s.author = 'Brent Lintner'
+  s.email = 'brent.lintner@gmail.com'
+  s.homepage = 'http://github.com/brentlintner/machinator'
+
+  s.files = Dir['bin/*', 'machinator.gemspec', 'README.rdoc', 'lib/**/*'].to_a
+
+  s.has_rdoc         = true
+  s.extra_rdoc_files = %w( README.rdoc )
+  s.rdoc_options.concat ['--main',  'README.rdoc']
+
+  s.executables = ["machinator"]
+  s.require_path = "lib"
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: machinator
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- Brent Lintner
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-03 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: obfuscate file content and directory structures
+email: brent.lintner@gmail.com
+executables: 
+- machinator
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- bin/machinator
+- machinator.gemspec
+- README.rdoc
+- lib/machinator/console_interface.rb
+- lib/machinator/obfuscator.rb
+- lib/machinator.rb
+has_rdoc: true
+homepage: http://github.com/brentlintner/machinator
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 8
+      - 6
+      version: 1.8.6
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: obfuscate file content and directory structures.
+test_files: []
+