obfusc 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a7fc494a9e84b4aaf03a3f8329f20ea56c75351f
+  data.tar.gz: a3b07cbc913a684a1fb3a03ef4c1a93bbad32768
+SHA512:
+  metadata.gz: da322a96246e4a6089df5015daa7573a9380e8676d3fd17f9c29876801f96ad1b1348b22648d7bfad095fb71ef0d408a1e3e556fde1ba9ef41cba67ccce6074b
+  data.tar.gz: f8d63efaab57384ff143e71f5c638c684c80b31836ad526d64aab2fe1d5ea5dae708407152384e819f340ef160b9692e63343cf93a04c1512e85d3d89439f09c

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+obfusc-*.gem

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.16.0

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+gem 'pry', '~> 0.11.3'
+
+# Specify your gem's dependencies in obfusc.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,41 @@
+PATH
+  remote: .
+  specs:
+    obfusc (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.1.2)
+    diff-lcs (1.3)
+    method_source (0.9.0)
+    pry (0.11.3)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    rake (10.5.0)
+    rspec (3.7.0)
+      rspec-core (~> 3.7.0)
+      rspec-expectations (~> 3.7.0)
+      rspec-mocks (~> 3.7.0)
+    rspec-core (3.7.1)
+      rspec-support (~> 3.7.0)
+    rspec-expectations (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-mocks (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-support (3.7.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.16)
+  obfusc!
+  pry (~> 0.11.3)
+  rake (~> 10.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   1.16.0

data/README.md

@@ -0,0 +1,101 @@
+[![Build Status](https://img.shields.io/travis/marcosgz/obfusc.svg?style=flat)](https://travis-ci.org/marcosgz/obfusc)
+
+# obfusc
+Simple command line tool to obfuscate a recursive tree of files. Basically just rename a list of files using a random and reversible name. Probably no one will use it. It's something that I'd be interested in when I was a teenager and tried to hide inappropriate files on my PC.
+
+*Always preferer "copy" command over "move". Unless you know exactly what are you doing.*
+
+## Installation
+Just install this gem by running
+
+```
+gem install obfusc
+```
+
+After successfully installed a new bin `obfusc` will be available.
+
+## Configuration
+First thing you will need to create a `$HOME/.obfusc.cnf` with with `secret` and `token` keys by executing the following command:
+
+```
+obfusct config generate
+```
+
+Here is an example of generated file:
+```
+$ cat ~/.obfusc.cnf
+---
+prefix: "obfusc"
+suffix: "obfusc"
+token: "@l(piZ3ynEz8tjs ,v7DUGP}SmrNMF:f=k4hbBc[dYWIo_uLJq|a9O]5gRK-T6AeXwQ);C{x1H02V"
+secret: "-A:z0rH2Zc4Gb6L@;Cwyd3g)l7JRIa[x]hWsoUD_Epe5O}jifu QqM{89FT=SvVBn1t,|P(NmXKkY"
+```
+
+It's recommended to make a backup of this file before start using this script. All obfuscated depends on token and secret from this config file. All the obfuscated files can no longer be recovered if you overwrite `.obfusc.cnf`.
+
+## Usage
+
+Use `obfusc --help` to show basic usage and all commands available.
+
+```
+obfusc <command> <arguments> <options>
+```
+
+#### Commands
+* setup
+* crypt
+* decrypt
+
+#### Options
+```
+-c, --config FILENAME            Using a different ".obfusc.cnf" filename (Default to $HOME/.obfusc.cnf)
+-e, --extension STRING           Specify a custom file extension. (Default to "obfc")
+-p, --prefix STRING              Specify a custom file prefix. (Default to "obfc")
+-v, --[no-]verbose               Run verbosely
+-s, --[no-]simulate              Do a simulate run without executing actions
+```
+
+### Crypt command
+
+`crypt` is the command used to obfuscated one or more files. Should always be followed by `<move OR copy>` and `<source>` and an optional `<target>`.
+
+Example:
+```
+# Simulate what will happen by executing this command
+$ obfusc crypt copy -v -s empty.gif
+DEBUG: cp empty.gif ./obfusc__6GP5D.nHv.obfusc
+
+# Obfuscate the "empty.gif" file with the `copy` mode.
+$ obfusc crypt copy empty.gif
+
+# Show obfuscated file
+$ obfusc show ./
+./obfusc__6GP5D.nHv.obfusc:
+---> empty.gif
+
+# `copy` always keep the original file
+$ ls empty.gif
+empty.gif
+```
+
+### Decrypt command
+`decrypt` is the command used to revert to original filename one or more obfuscated files. Should always be followed by `<move OR copy>` and `<source>` and an optional `<target>`.
+
+Example:
+```
+# Simulate what will happen by executing this command
+$ obfusc decrypt copy -s -v ./ /tmp/target
+DEBUG: mkdir -p /tmp/target
+DEBUG: cp ./obfusc__6GP5D.nHv.obfusc /tmp/target/empty.gif
+
+# Rename obfuscated file to the original name and copy to the target directory
+$ obfusc decrypt copy ./ /tmp/target
+
+# Show un-obfuscated file
+$ ls /tmp/target
+empty.gif
+
+# Original obfuscated file still existing with copy mode
+$ ls ./obfusc__6GP5D.nHv.obfusc
+./obfusc__6GP5D.nHv.obfusc
+```

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "obfusc"
+
+# 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/exe/obfusc

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'obfusc'
+
+cli = Obfusc::CLI.new ARGV
+cli.run

data/lib/obfusc/cli.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Obfusc
+  # This model receive and process ARGV from ./exe/obfusc script
+  class CLI
+    VALID_COMMANDS = %w[setup crypt decrypt show].freeze
+
+    attr_reader :argumetns, :options
+
+    def initialize(arguments)
+      @arguments = arguments
+      @options = {}
+    end
+
+    def run
+      configure
+      perform(@arguments.shift)
+    end
+
+    protected
+
+    def perform(command)
+      unless VALID_COMMANDS.include?(command)
+        puts parser.help
+        return
+      end
+      config = Obfusc::Config.new(@options)
+      class_name = "#{command[0].upcase}#{command[1..-1]}Command"
+      Obfusc.const_get(class_name).call(config, *@arguments)
+    end
+
+    def configure
+      parser.parse!(@arguments)
+    end
+
+    # rubocop:disable BlockLength,MethodLength,AbcSize
+    def parser
+      @parser = OptionParser.new do |opts|
+        opts.banner = 'Usage: obfusc <command> <arguments> <options>'
+        opts.separator ''
+        opts.separator 'Commands:'
+        VALID_COMMANDS.each do |command|
+          opts.separator "    * #{command}"
+        end
+
+        opts.separator ''
+        opts.separator 'Specific options:'
+
+        opts.on('-c', '--config FILENAME',
+                'Using a different ".obfusc.cnf" filename') do |filename|
+          @options[:config_path] = filename
+        end
+
+        opts.on(
+          '-e',
+          '--extension STRING',
+          'Specify a custom file extension. (Default to "obfc")'
+        ) do |extension|
+          @options[:extension] = extension
+        end
+
+        opts.on(
+          '-p',
+          '--prefix STRING',
+          'Specify a custom file prefix. (Default to "obfc")'
+        ) do |prefix|
+          @options[:prefix] = prefix
+        end
+
+        opts.on('-v', '--[no-]verbose', 'Run verbosely') do |v|
+          @options[:verbose] = v
+        end
+
+        opts.on(
+          '-s',
+          '--[no-]simulate',
+          'Do a simulate run without executing actions'
+        ) do |v|
+          @options[:simulate] = v
+        end
+
+        opts.separator ''
+        opts.separator 'Common options:'
+
+        opts.on_tail('-h', '--help', 'Show this message') do
+          puts opts
+          exit
+        end
+      end
+    end
+    # rubocop:enable BlockLength,MethodLength,AbcSize
+  end
+end

data/lib/obfusc/commands/concerns/config.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Obfusc
+  # Get/Set configurations with its default values.
+  class Config
+    attr_accessor :config_path, :extension, :verbose, :simulate
+
+    def initialize(options)
+      @config_path = options[:config_path]
+      @config_path ||= File.join(ENV['HOME'], '.obfusc.cnf')
+
+      @extension = options[:extension] || 'obfusc'
+      @verbose = options[:verbose] || false
+      @simulate = options[:simulate] || false
+    end
+
+    %i[simulate verbose].each do |method|
+      define_method "#{method}?" do
+        public_send("#{method}") == true
+      end
+    end
+
+    def encryptor
+      @encryptor ||= Obfusc::Encryptor.new(self)
+    end
+
+    def token
+      settings['token']
+    end
+
+    def secret
+      settings['secret']
+    end
+
+    def log(msg)
+      puts("DEBUG: #{msg}") if verbose?
+    end
+
+    def dry_run
+      return unless block_given?
+
+      yield unless simulate?
+    end
+
+    protected
+
+    def settings
+      @settings ||= YAML.load_file(config_path)
+    rescue Errno::ENOENT
+      puts "No such file #{config_path}."
+      puts "Use: `obfusc setup generate' to generate it"
+      {}
+    end
+  end
+end

data/lib/obfusc/commands/concerns/encryptor_command_base.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Obfusc
+  # Commom methods shared between CryptCommand and DecryptCommand models.
+  # Children models only overwrite `show_usage` and files.
+  class EncryptorCommandBase
+    COMMANDS = %w[move copy].freeze
+    CURRENT_DIR = './'.freeze
+
+    def initialize(config, from, to)
+      @config = config
+
+      @from = from || CURRENT_DIR
+      @to = to || CURRENT_DIR
+    end
+
+    def self.call(config, *args)
+      command, from, to = args
+      model = new(config, from, to)
+      command = 'show_usage' unless COMMANDS.include?(command)
+      model.public_send(command)
+    end
+
+    def show_usage
+      raise NotImplementedError
+    end
+
+    def files
+      raise NotImplementedError
+    end
+
+    def move
+      files.each_with_index do |(from, to), index|
+        create_target_base_directory if index.zero?
+        create_directory_from_file(to)
+        @config.log("mv #{from} #{to}")
+        @config.dry_run do
+          FileUtils.mv(from, to, verbose: @config.verbose?)
+        end
+      end.size
+    end
+
+    def copy
+      files.each_with_index do |(from, to), index|
+        create_target_base_directory if index.zero?
+        create_directory_from_file(to)
+        @config.log("cp #{from} #{to}")
+        @config.dry_run do
+          FileUtils.cp(from, to, verbose: @config.verbose?)
+        end
+      end.size
+    end
+
+    protected
+
+    def create_directory_from_file(path)
+      return if File.directory?(path)
+      dirname = File.dirname(path)
+      return if File.expand_path(dirname) == File.expand_path(@to)
+
+      @config.log("mkdir -p #{dirname}")
+      @config.dry_run { FileUtils.mkdir_p(dirname) }
+    end
+
+    def create_target_base_directory
+      return if @to == CURRENT_DIR
+      return if File.directory?(@to)
+
+      @config.log("mkdir -p #{@to}")
+      @config.dry_run { FileUtils.mkdir_p(@to) }
+    end
+  end
+end

data/lib/obfusc/commands/crypt_command.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'obfusc/commands/concerns/encryptor_command_base'
+
+module Obfusc
+  # Perform tasks related `crypt` command
+  class CryptCommand < Obfusc::EncryptorCommandBase
+    # rubocop:disable MethodLength
+    def show_usage
+      usage = <<-TEXT.gsub('      ', '')
+      Usage:
+      $ obfusc crypt <* #{COMMANDS.join('|')}> <* from> <to>
+        <* > Required arguments
+
+      Action:
+        move: Files will be moved to the target.
+        copy: Keep existing files and generate a copy.
+
+      Files:
+        from: Relative or absolute of obfuscated directory/file. You can also use wildcards like "*" or "**".
+        to: Relative or absolute directory where un-obfuscated files will be stored. (Default to current directory)
+      TEXT
+      puts usage
+    end
+    # rubocop:enable MethodLength
+
+    protected
+
+    def files
+      recursive_from = File.join(@from, '**/{.*,*}') if File.directory?(@from)
+      Dir.glob(recursive_from || @from).each_with_object({}) do |path, memo|
+        next if File.directory?(path)
+        next if File.symlink?(path)
+        memo[path] = File.join(@to, @config.encryptor.encrypt(path))
+      end
+    end
+  end
+end

data/lib/obfusc/commands/decrypt_command.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'obfusc/commands/concerns/encryptor_command_base'
+
+module Obfusc
+  # Perform tasks related `decrypt` command
+  class DecryptCommand < Obfusc::EncryptorCommandBase
+    # rubocop:disable MethodLength
+    def show_usage
+      usage = <<-TEXT.gsub('      ', '')
+      Usage:
+      $ obfusc decrypt <* #{COMMANDS.join('|')}> <* from> <to>
+        <* > Required arguments
+
+      Action:
+        move: Files will be moved to the target.
+        copy: Keep existing files and generate a copy.
+
+      Files:
+        from: Relative or absolute directory/file be obfuscated. You can also use wildcards like "*" or "**".
+        to: Relative or absolute directory where obfuscated files will be stored. (Default to current directory)
+      TEXT
+      puts usage
+    end
+    # rubocop:enable MethodLength
+
+    protected
+
+    def files
+      recursive_from = File.join(@from, '**/{.*,*}') if File.directory?(@from)
+      Dir.glob(recursive_from || @from).each_with_object({}) do |path, memo|
+        next if File.directory?(path)
+        next if File.symlink?(path)
+        basename = File.basename(path)
+        next unless @config.encryptor.obfuscated?(basename)
+        memo[path] = File.join(@to, @config.encryptor.decrypt(basename))
+      end
+    end
+  end
+end

data/lib/obfusc/commands/setup_command.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Obfusc
+  # Perform tasks related `setup` command
+  class SetupCommand
+    COMMANDS = %w[generate show].freeze
+
+    def initialize(config)
+      @config = config
+    end
+
+    def self.call(config, *args)
+      model = new(config)
+      command = args.first
+      command = 'show_usage' unless COMMANDS.include?(command)
+      model.public_send(command)
+    end
+
+    def show_usage
+      puts "Usage:\nobfusc setup <#{COMMANDS.join('|')}>"
+    end
+
+    def generate
+      File.open(config_file, 'w') do |f|
+        f.write tokenize(Obfusc::Random.generate!)
+      end
+    end
+
+    def show
+      unless File.exist?(config_file)
+        puts "#{config_file} does not exist.\nUse: `obfusc setup generate'"
+        return
+      end
+      YAML.load_file(config_file).each do |key, value|
+        puts "#{key}:"
+        puts "---> #{value.inspect}"
+      end
+    end
+
+    protected
+
+    def tokenize(characters_hash)
+      token = ''
+      secret = ''
+      characters_hash.sort_by { rand }.each do |key, value|
+        token += key
+        secret += value
+      end
+      YAML.dump(
+        'prefix' => @config.prefix,
+        'suffix' => @config.extension,
+        'token' => token,
+        'secret' => secret
+      )
+    end
+
+    def config_file
+      @config.config_path
+    end
+  end
+end

data/lib/obfusc/commands/show_command.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Obfusc
+  # Perform tasks related `show` command
+  class ShowCommand
+
+    def initialize(config, source)
+      @config = config
+      @source = source
+    end
+
+    def self.call(config, *args)
+      source = args.first
+      model = new(config, source)
+      model.public_send(File.exist?(source) ? :run : :show_usage)
+    end
+
+    def run
+      files.each do |from, to|
+        puts "#{from}:"
+        puts "---> #{to}"
+      end
+    end
+
+    def show_usage
+      usage = <<-TEXT.gsub('      ', '')
+      Usage:
+      $ obfusc show <source>
+
+      Files:
+        source: Relative or absolute directory where obfuscated files are stored. (Default to current directory)
+      TEXT
+      puts usage
+    end
+
+    protected
+
+    def files
+      recursive_from = File.join(@source, '**/{.*,*}') if File.directory?(@source)
+      Dir.glob(recursive_from || @source).each_with_object({}) do |path, memo|
+        next if File.directory?(path)
+        next if File.symlink?(path)
+        basename = File.basename(path)
+        next unless @config.encryptor.obfuscated?(basename)
+        memo[path] = @config.encryptor.decrypt(basename)
+      end
+    end
+  end
+end

data/lib/obfusc/config.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Obfusc
+  # Get/Set configurations with its default values.
+  class Config
+    attr_accessor :config_path, :extension, :verbose, :simulate, :prefix
+
+    def initialize(options)
+      @config_path = options[:config_path]
+      @config_path ||= File.join(ENV['HOME'], '.obfusc.cnf')
+
+      @extension = options[:extension] || 'obfusc'
+      @prefix = options[:prefix] || 'obfusc'
+      @verbose = options[:verbose] || false
+      @simulate = options[:simulate] || false
+    end
+
+    %i[simulate verbose].each do |method|
+      define_method "#{method}?" do
+        public_send("#{method}") == true
+      end
+    end
+
+    def encryptor
+      @encryptor ||= Obfusc::Encryptor.new(self)
+    end
+
+    def token
+      settings['token']
+    end
+
+    def secret
+      settings['secret']
+    end
+
+    def log(msg)
+      puts("DEBUG: #{msg}") if verbose?
+    end
+
+    def dry_run
+      return unless block_given?
+
+      yield unless simulate?
+    end
+
+    protected
+
+    def settings
+      @settings ||= YAML.load_file(config_path)
+    rescue Errno::ENOENT
+      puts "No such file #{config_path}."
+      puts "Use: `obfusc setup generate' to generate it"
+      {}
+    end
+  end
+end

data/lib/obfusc/encryptor.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Obfusc
+  # Recursive find files from origin or pattern
+  class Encryptor
+    SEP_FROM = '/'.freeze
+    SEP_TO = '___|___'.freeze
+
+    def initialize(config)
+      @config = config
+      @prefix = "#{config.prefix}__"
+      @suffix = ".#{config.extension}"
+    end
+
+    def encrypt(path)
+      crypted_filename = expand_path_for_encrypt(path).map do |step|
+        step.chars.map { |char| charlist[char] || char }.join
+      end.join(SEP_TO)
+
+      [@prefix, crypted_filename, @suffix].join
+    end
+
+    def decrypt(path)
+      expand_path_for_decrypt(path).join(SEP_FROM)
+    end
+
+    def obfuscated?(file)
+      !!(file =~ obfuscated_expression)
+    end
+
+    protected
+
+    def expand_path_for_encrypt(path)
+      parts = []
+      path.split(SEP_FROM).each do |part|
+        parts.push(*try_decrypt(part).split(SEP_FROM))
+      end
+      parts
+    end
+
+    def expand_path_for_decrypt(path, memo = [])
+      return memo if String(path).length.zero?
+
+      if path =~ obfuscated_expression
+        parts = normalize(path).split(SEP_TO)
+        return [*memo, *parts.map { |part| decrypt_segment(part) }]
+      end
+
+      dir, new_path = path.split(SEP_FROM, 2)
+      expand_path_for_decrypt(new_path, [*memo, dir])
+    end
+
+    def decrypt_segment(segment)
+      segment.chars.map { |char| charlist.key(char) || char }.join
+    end
+
+    def try_decrypt(step)
+      return step unless step =~ obfuscated_expression
+      decrypt(step)
+    end
+
+    def obfuscated_expression
+      /^(#{Regexp.escape(@prefix)}).*(#{Regexp.escape(@suffix)})$/
+    end
+
+    def charlist
+      @charlist ||= begin
+        keys = @config.token.split('')
+        values = @config.secret.split('')
+        Hash[keys.zip(values)]
+      end
+    end
+
+    def normalize(path)
+      path.sub!(/^(#{Regexp.escape(@prefix)})/, '')
+      path.sub!(/(#{Regexp.escape(@suffix)})$/, '')
+      path
+    end
+  end
+end

data/lib/obfusc/random.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Obfusc
+  # Grab most comon characters and generate a random list of key and value
+  class Random
+    DIGIT = (0x30..0x39).map(&:chr)
+    ALPHA = (0x41..0x5a).map(&:chr) + (0x61..0x7a).map(&:chr)
+    SPECIAL = [
+      ' ', '-', '_', ',', ':', ';', '=', '@', '[', ']', '(', ')', '{', '}', '|'
+    ].freeze
+
+    def self.generate!
+      hash = {}
+      randonize!(hash, DIGIT + ALPHA)
+      randonize!(hash, SPECIAL)
+      hash
+    end
+
+    private_class_method def self.randonize!(memo, source)
+      source.sort_by { rand }.each do |char|
+        list = source - (memo.values & source)
+        loop do
+          memo[char] = list.sample
+          break if list.size <= 1
+          break if memo[char] != char
+        end
+      end
+      memo
+    end
+  end
+end

data/lib/obfusc/version.rb

@@ -0,0 +1,3 @@
+module Obfusc
+  VERSION = '1.0.0'.freeze
+end

data/lib/obfusc.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'optparse'
+require 'yaml'
+require 'fileutils'
+
+require 'obfusc/cli'
+require 'obfusc/config'
+require 'obfusc/encryptor'
+require 'obfusc/random'
+require 'obfusc/version'
+
+Dir["#{File.dirname(__FILE__)}/obfusc/commands/*_command.rb"].each do |file|
+  require file
+end
+
+# Script to obfuscate directories or files using a unique token/secret key.
+module Obfusc
+end

data/obfusc.gemspec

@@ -0,0 +1,28 @@
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'obfusc/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'obfusc'
+  spec.version       = Obfusc::VERSION
+  spec.authors       = ['Marcos G. Zimmermann']
+  spec.email         = ['mgzmaster@gmail.com']
+  spec.license       = 'MIT'
+
+  spec.summary       = 'Command line tool to obfuscate files'
+  spec.description   = 'Simple script to obfuscate one or more files' \
+                       ' preserving the directory tree'
+  spec.homepage      = 'https://github.com/marcosgz/obfusc'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.16'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: obfusc
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Marcos G. Zimmermann
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-01-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Simple script to obfuscate one or more files preserving the directory
+  tree
+email:
+- mgzmaster@gmail.com
+executables:
+- obfusc
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/obfusc
+- lib/obfusc.rb
+- lib/obfusc/cli.rb
+- lib/obfusc/commands/concerns/config.rb
+- lib/obfusc/commands/concerns/encryptor_command_base.rb
+- lib/obfusc/commands/crypt_command.rb
+- lib/obfusc/commands/decrypt_command.rb
+- lib/obfusc/commands/setup_command.rb
+- lib/obfusc/commands/show_command.rb
+- lib/obfusc/config.rb
+- lib/obfusc/encryptor.rb
+- lib/obfusc/random.rb
+- lib/obfusc/version.rb
+- obfusc.gemspec
+homepage: https://github.com/marcosgz/obfusc
+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: Command line tool to obfuscate files
+test_files: []