fastlane-plugin-cryptex 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6286c3236e933597fcaa231151783c966173268c
+  data.tar.gz: c2e7ecfbfbc3fc0fcec787d3197373b389ab4c92
+SHA512:
+  metadata.gz: b655c7072780622600f14be3cde5d3b5991999ab8d3616fc7ceef21d2b420ee3e23549fb0264ee11a8fdd4e45e7dd4040ed5b2a92dcf568fa7a383334b28941f
+  data.tar.gz: cde2607785293bb1c723d6d9af184424e65f124edb6df600f434fcd9dbf8dc74d1b03f0e06457c0179a7be5d0c04cdcd8b2b003bf0ed48412ecc4941365bbf0c

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Helmut Januschka <h.januschka@krone.at>
+
+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,138 @@
+# cryptex plugin
+
+[![fastlane Plugin Badge](https://rawcdn.githack.com/fastlane/fastlane/master/fastlane/assets/plugin-badge.svg)](https://rubygems.org/gems/fastlane-plugin-cryptex)
+
+## Getting Started
+
+This project is a [fastlane](https://github.com/fastlane/fastlane) plugin. To get started with `fastlane-plugin-cryptex`, add it to your project by running:
+
+```bash
+fastlane add_plugin cryptex
+```
+
+## About cryptex
+
+Android Key Store Git repo
+
+**Note to author:** Add a more detailed description about this plugin here. If your plugin contains multiple actions, make sure to mention them here.
+
+## Example
+
+```ruby
+
+lane :test do
+  # Generate a new Android Keystore
+  
+  cryptex_generate_keystore(
+    destination: "sample.keystore",
+    fullname: "Helmut Januschka",
+    city: "Vienna",
+    alias: "releaseKey"
+  )
+
+  # import/update this in cryptex
+  cryptex(
+    type: "import",
+    in: "sample.keystore",
+    key: "my_awesome_app_production"
+  )
+
+  # export a file from cryptex
+  cryptex(
+    type: "export",
+    out: "releaseKey.keystore",
+    key: "my_awesome_app_production"
+  )
+
+  file_output = File.read("../releaseKey.keystore")
+  puts "File Content: #{file_output.tr("\n", ' ')}"
+
+  # delete the file
+  cryptex(
+    type: "delete",
+    key: "my_awesome_app_production"
+  )
+
+  # Nuke's all files
+  cryptex(
+    type: "nuke"
+  )
+  
+  
+  #ENV SAMPLES
+  #import some env into the space of `my_group`
+  cryptex(
+    type: "import_env",
+    hash: {
+      "helmut" => "go",
+      "some_url" =>  "http://lets.do.it"
+    },
+    key: "my_group"
+  )
+  env_out = cryptex(
+    type: "export_env",
+    key: "my_group",
+    set_env: true #THIS one sets the values found directly into to ENV
+    #hash: {"my_key"=>true, "some_url"=>true} # only returned specific keys
+  )
+  
+  puts "IN ENV it is:"
+  puts ENV['some_url']
+  puts "returned: #{env_out.inspect}"
+  
+end
+
+
+```
+
+## Commandline Examples:
+
+```bash
+#init
+cryptex init
+
+# import file
+cryptex -s import -i file_to_hide.txt -k file_key
+
+# export file
+cryptex -s export -k file_key -o file_to_hide.txt
+
+#delete file
+cryptex -s delete -k file_key
+
+#nuke repo
+cryptex nuke
+
+
+```
+
+
+
+## Run tests for this plugin
+
+To run both the tests, and code style validation, run
+
+```
+rake
+```
+
+To automatically fix many of the styling issues, use 
+```
+rubocop -a
+```
+
+## Issues and Feedback
+
+For any other issues and feedback about this plugin, please submit it to this repository.
+
+## Troubleshooting
+
+If you have trouble using plugins, check out the [Plugins Troubleshooting](https://github.com/fastlane/fastlane/blob/master/fastlane/docs/PluginsTroubleshooting.md) doc in the main `fastlane` repo.
+
+## Using `fastlane` Plugins
+
+For more information about how the `fastlane` plugin system works, check out the [Plugins documentation](https://github.com/fastlane/fastlane/blob/master/fastlane/docs/Plugins.md).
+
+## About `fastlane`
+
+`fastlane` is the easiest way to automate building and releasing your iOS and Android apps. To learn more, check out [fastlane.tools](https://fastlane.tools).

data/bin/cryptex

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+$:.push File.expand_path("../../lib", __FILE__)
+
+require 'fastlane'
+require 'fastlane/plugin/cryptex'
+
+Fastlane::Cryptex::CommandsGenerator.start

data/lib/fastlane/plugin/cryptex.rb

@@ -0,0 +1,25 @@
+
+module Fastlane
+  module Cryptex
+    ROOT = Pathname.new(File.expand_path('lib/fastlane/plugin/cryptex'))
+    # Return all .rb files inside the "actions" and "helper" directory
+    def self.all_classes
+      Dir[File.expand_path('**/{actions,helper}/*.rb', File.dirname(__FILE__))]
+    end
+  end
+end
+
+require 'fastlane/plugin/cryptex/options'
+require 'fastlane/plugin/cryptex/change_password'
+require 'fastlane/plugin/cryptex/version'
+require 'fastlane/plugin/cryptex/setup'
+require 'fastlane/plugin/cryptex/git_helper'
+require 'fastlane/plugin/cryptex/encrypt'
+require 'fastlane/plugin/cryptex/runner'
+require 'fastlane/plugin/cryptex/commands_generator'
+
+# By default we want to import all available actions and helpers
+# A plugin can contain any number of actions and plugins
+Fastlane::Cryptex.all_classes.each do |current|
+  require current
+end

data/lib/fastlane/plugin/cryptex/actions/cryptex_action.rb

@@ -0,0 +1,29 @@
+module Fastlane
+  module Actions
+    class CryptexAction < Action
+      def self.run(params)
+        UI.message("The cryptex plugin is working!")
+
+        params.load_configuration_file("Cryptexfile")
+
+        Cryptex::Runner.new.run(params)
+      end
+
+      def self.description
+        "Secure Git-Backed Storage"
+      end
+
+      def self.authors
+        ["Helmut Januschka"]
+      end
+
+      def self.available_options
+        Cryptex::Options.available_options
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/cryptex/actions/cryptex_generate_keystore.rb

@@ -0,0 +1,62 @@
+module Fastlane
+  module Actions
+    class CryptexGenerateKeystoreAction < Action
+      def self.run(params)
+        require "fileutils"
+        cmd = "keytool -genkey -v -keystore #{File.expand_path(params[:destination])} -storepass #{params[:password]} -keypass #{params[:password]} -alias #{params[:alias]} -dname 'CN=#{params[:fullname]},L=#{params[:city]}' -validity 1000"
+        FastlaneCore::CommandExecutor.execute(command: cmd,
+                                            print_all: true,
+                                        print_command: true)
+
+        params[:destination]
+      end
+
+      def self.description
+        "Generate a new Android Keystore"
+      end
+
+      def self.authors
+        ["Helmut Januschka"]
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :password,
+                                       env_name: "MATCH_KEYSTORE_PASSWORD",
+                                       description: "Password for the Keystore",
+                                       optional: true,
+                                       is_string: true,
+                                       default_value: ""),
+          FastlaneCore::ConfigItem.new(key: :alias,
+                                       env_name: "MATCH_KEYSTORE_ALIAS",
+                                       description: "ALIAS for the Keystore",
+                                       optional: true,
+                                       is_string: true,
+                                       default_value: ""),
+          FastlaneCore::ConfigItem.new(key: :destination,
+                                       env_name: "MATCH_KEYSTORE_DESTINATION",
+                                       description: "Where to put decrypted keystore",
+                                       optional: true,
+                                       default_value: ""),
+          FastlaneCore::ConfigItem.new(key: :fullname,
+                                       env_name: "MATCH_KEYSTORE_FULLNAME",
+                                       description: "Fullname of keystore owner",
+                                       optional: true,
+                                       is_string: true,
+                                       default_value: ""),
+          FastlaneCore::ConfigItem.new(key: :city,
+                                       env_name: "MATCH_KEYSTORE_CITY",
+                                       description: "City of keystore owner",
+                                       optional: true,
+                                       is_string: true,
+                                       default_value: "")
+
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/cryptex/assets/CryptexfileTemplate

@@ -0,0 +1 @@
+git_url "[[GIT_URL]]"

data/lib/fastlane/plugin/cryptex/assets/READMETemplate.md

@@ -0,0 +1,2 @@
+# cryptex
+

data/lib/fastlane/plugin/cryptex/change_password.rb

@@ -0,0 +1,32 @@
+module Fastlane
+  module Cryptex
+    class ChangePassword
+      def self.update(params: nil, from: nil, to: nil)
+        to ||= ChangePassword.ask_password(message: "New passphrase for Git Repo: ", confirm: false)
+        from ||= ChangePassword.ask_password(message: "Old passphrase for Git Repo: ", confirm: true)
+        GitHelper.clear_changes
+        workspace = GitHelper.clone(params[:git_url], params[:shallow_clone], manual_password: from, skip_docs: params[:skip_docs], branch: params[:git_branch])
+        Encrypt.new.clear_password(params[:git_url])
+        Encrypt.new.store_password(params[:git_url], to)
+
+        message = "[fastlane] Changed passphrase"
+        GitHelper.commit_changes(workspace, message, params[:git_url], params[:git_branch])
+      end
+
+      def self.ask_password(message: "Passphrase for Git Repo: ", confirm: true)
+        loop do
+          password = UI.password(message)
+          if confirm
+            password2 = UI.password("Type passphrase again: ")
+            if password == password2
+              return password
+            end
+          else
+            return password
+          end
+          UI.error("Passhprases differ. Try again")
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/cryptex/commands_generator.rb

@@ -0,0 +1,92 @@
+require 'commander'
+
+HighLine.track_eof = false
+module Fastlane
+  module Cryptex
+    class CommandsGenerator
+      include Commander::Methods
+      UI = FastlaneCore::UI
+
+      def self.start
+        FastlaneCore::UpdateChecker.start_looking_for_update('cryptex')
+        self.new.run
+      ensure
+
+        FastlaneCore::UpdateChecker.show_update_status('cryptex', Cryptex::VERSION)
+      end
+
+      def run
+        program :version, Cryptex::VERSION
+        program :description, "Cryptex"
+        program :help, 'Author', 'Helmut Januschka <helmut@januschka.com>'
+        program :help, 'Website', 'https://fastlane.tools'
+        program :help, 'GitHub', 'https://github.com/hjanuschka/fastlane-plugin-cryptex'
+        program :help_formatter, :compact
+
+        global_option('--verbose') { $verbose = true }
+
+        FastlaneCore::CommanderGenerator.new.generate(Cryptex::Options.available_options)
+
+        command :run do |c|
+          c.syntax = 'cryptex'
+          c.description = Cryptex::DESCRIPTION
+          c.action do |args, options|
+            params = FastlaneCore::Configuration.create(Cryptex::Options.available_options, options.__hash__)
+            params.load_configuration_file("Cryptexfile")
+            Cryptex::Runner.new.run(params)
+          end
+        end
+
+        command :init do |c|
+          c.syntax = 'cryptex init'
+          c.description = 'Create the Cryptexfile for you'
+          c.action do |args, options|
+            containing = (File.directory?("fastlane") ? 'fastlane' : '.')
+            path = File.join(containing, "Cryptexfile")
+
+            if File.exist?(path)
+              FastlaneCore::UI.user_error!("You already got a Cryptexfile in this directory")
+              return 0
+            end
+
+            Cryptex::Setup.new.run(path)
+          end
+        end
+
+        command :change_password do |c|
+          c.syntax = 'cryptex change_password'
+          c.description = 'Re-encrypt all files with a different password'
+          c.action do |args, options|
+            puts "CHANGE PASSWORD"
+          end
+        end
+
+        command :decrypt do |c|
+          c.syntax = "cryptex decrypt"
+          c.description = "Decrypts the repository and keeps it on the filesystem"
+          c.action do |args, options|
+            params = FastlaneCore::Configuration.create(Match::Options.available_options, options.__hash__)
+            params.load_configuration_file("Cryptexfile")
+            decrypted_repo = Cryptex::GitHelper.clone(params[:git_url], params[:shallow_clone], branch: params[:git_branch])
+            UI.success "Repo is at: '#{decrypted_repo}'"
+          end
+        end
+        command "nuke" do |c|
+          # We have this empty command here, since otherwise the normal `match` command will be executed
+          c.syntax = "cryptex nuke"
+          c.description = "Delete all Crypted Files in the repository"
+          c.action do |args, options|
+            params = FastlaneCore::Configuration.create(Cryptex::Options.available_options, options.__hash__)
+            params.load_configuration_file("Cryptexfile")
+            params[:type] = "nuke"
+            Cryptex::Runner.new.run(params)
+          end
+        end
+
+        default_command :run
+
+        run!
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/cryptex/encrypt.rb

@@ -0,0 +1,95 @@
+module Fastlane
+  module Cryptex
+    class Encrypt
+      require 'security'
+      require 'shellwords'
+
+      def server_name(git_url)
+        ["cryptex", git_url].join("_")
+      end
+
+      def password(git_url)
+        password = ENV["CRYPTEX_PASSWORD"]
+        unless password
+          item = Security::InternetPassword.find(server: server_name(git_url))
+          password = item.password if item
+        end
+
+        unless password
+          UI.important "Enter the passphrase that should be used to encrypt/decrypt your repository"
+          UI.important "This passphrase is specific per repository and will be stored in your local keychain"
+          UI.important "Make sure to remember the password, as you'll need it when you run cryptex on a different machine"
+          password = ChangePassword.ask_password(confirm: true)
+          store_password(git_url, password)
+        end
+
+        return password
+      end
+
+      def store_password(git_url, password)
+        Security::InternetPassword.add(server_name(git_url), "", password)
+      end
+
+      # removes the password from the keychain again
+      def clear_password(git_url)
+        Security::InternetPassword.delete(server: server_name(git_url))
+      end
+
+      def encrypt_repo(path: nil, git_url: nil)
+        iterate(path) do |current|
+          crypt(path: current,
+            password: password(git_url),
+             encrypt: true)
+          UI.success "🔒  Encrypted '#{File.basename(current)}'" if $verbose
+        end
+        UI.success "🔒  Successfully encrypted certificates repo"
+      end
+
+      def decrypt_repo(path: nil, git_url: nil, manual_password: nil)
+        iterate(path) do |current|
+          begin
+            crypt(path: current,
+              password: manual_password || password(git_url),
+               encrypt: false)
+          rescue
+            UI.error "Couldn't decrypt the repo, please make sure you enter the right password!"
+            UI.user_error!("Invalid password passed via 'CRYPTEX_PASSWORD'") if ENV["CRYPTEX_PASSWORD"]
+            clear_password(git_url)
+            decrypt_repo(path: path, git_url: git_url)
+            return
+          end
+          UI.success "🔓  Decrypted '#{File.basename(current)}'" if $verbose
+        end
+        UI.success "🔓  Successfully decrypted certificates repo"
+      end
+
+      def iterate(source_path)
+        Dir[File.join(source_path, "**", "*.{crypt}")].each do |path|
+          next if File.directory?(path)
+          yield(path)
+        end
+      end
+
+      private
+
+      def crypt(path: nil, password: nil, encrypt: true)
+        if password.to_s.strip.length.zero? && encrypt
+          UI.user_error!("No password supplied")
+        end
+
+        tmpfile = File.join(Dir.mktmpdir, "temporary")
+        command = ["openssl aes-256-cbc"]
+        command << "-k #{password.shellescape}"
+        command << "-in #{path.shellescape}"
+        command << "-out #{tmpfile.shellescape}"
+        command << "-a"
+        command << "-d" unless encrypt
+        command << "&> /dev/null" unless $verbose # to show show an error message is something goes wrong
+        success = system(command.join(' '))
+
+        UI.crash!("Error decrypting '#{path}'") unless success
+        FileUtils.mv(tmpfile, path)
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/cryptex/git_helper.rb

@@ -0,0 +1,129 @@
+module Fastlane
+  module Cryptex
+    class GitHelper
+      def self.clone(git_url, shallow_clone, manual_password: nil, skip_docs: false, branch: "master")
+        return @dir if @dir
+
+        @dir = Dir.mktmpdir
+
+        command = "git clone '#{git_url}' '#{@dir}'"
+        command << " --depth 1" if shallow_clone
+
+        UI.message "Cloning remote git repo..."
+        begin
+          FastlaneCore::CommandExecutor.execute(command: "GIT_TERMINAL_PROMPT=0 #{command}",
+                                              print_all: $verbose,
+                                          print_command: $verbose)
+        rescue
+          UI.error("Error cloning Repo")
+          UI.error("Run the following command manually to make sure you're properly authenticated:")
+          UI.command(command)
+          UI.user_error!("Error cloning cryptex git repo, please make sure you have access to the repository - see instructions above")
+        end
+
+        UI.user_error!("Error cloning repo, make sure you have access to it '#{git_url}'") unless File.directory?(@dir)
+
+        checkout_branch(branch) unless branch == "master"
+
+        copy_readme(@dir) unless skip_docs
+        Cryptex::Encrypt.new.decrypt_repo(path: @dir, git_url: git_url, manual_password: manual_password)
+
+        return @dir
+      end
+
+      def self.generate_commit_message(params)
+        # 'Automatic commit via fastlane'
+        [
+          "[fastlane]",
+          "Updated"
+        ].join(" ")
+      end
+
+      def self.cryptex_version(workspace)
+        path = File.join(workspace, "cryptex_version.txt")
+        if File.exist?(path)
+          Gem::Version.new(File.read(path))
+        end
+      end
+
+      def self.commit_changes(path, message, git_url, branch = "master")
+        Dir.chdir(path) do
+          return if `git status`.include?("nothing to commit")
+
+          Cryptex::Encrypt.new.encrypt_repo(path: path, git_url: git_url)
+          File.write("cryptex_version.txt", Cryptex::VERSION) # unencrypted
+
+          commands = []
+          commands << "git add -A"
+          commands << "git commit -m #{message.shellescape}"
+          commands << "GIT_TERMINAL_PROMPT=0 git push origin #{branch.shellescape}"
+
+          UI.message "Pushing changes to remote git repo..."
+
+          commands.each do |command|
+            FastlaneCore::CommandExecutor.execute(command: command,
+                                                print_all: $verbose,
+                                            print_command: $verbose)
+          end
+        end
+        FileUtils.rm_rf(path)
+        @dir = nil
+      rescue => ex
+        UI.error("Couldn't commit or push changes back to git...")
+        UI.error(ex)
+      end
+
+      def self.clear_changes
+        return unless @dir
+
+        FileUtils.rm_rf(@dir)
+        UI.success "🔒  Successfully encrypted certificates repo" # so the user is happy
+        @dir = nil
+      end
+
+      # Create and checkout an specific branch in the git repo
+      def self.checkout_branch(branch)
+        return unless @dir
+
+        commands = []
+        if branch_exists?(branch)
+          # Checkout the branch if it already exists
+          commands << "git checkout #{branch.shellescape}"
+        else
+          # If a new branch is being created, we create it as an 'orphan' to not inherit changes from the master branch.
+          commands << "git checkout --orphan #{branch.shellescape}"
+          # We also need to reset the working directory to not transfer any uncommitted changes to the new branch.
+          commands << "git reset --hard"
+        end
+
+        UI.message "Checking out branch #{branch}..."
+
+        Dir.chdir(@dir) do
+          commands.each do |command|
+            FastlaneCore::CommandExecutor.execute(command: command,
+                                                  print_all: $verbose,
+                                                  print_command: $verbose)
+          end
+        end
+      end
+
+      # Checks if a specific branch exists in the git repo
+      def self.branch_exists?(branch)
+        return unless @dir
+
+        result = Dir.chdir(@dir) do
+          FastlaneCore::CommandExecutor.execute(command: "git branch --list origin/#{branch.shellescape} --no-color -r",
+                                                print_all: $verbose,
+                                                print_command: $verbose)
+        end
+        return !result.empty?
+      end
+
+      # Copies the README.md into the git repo
+      def self.copy_readme(directory)
+        template = File.read("#{Cryptex::ROOT}/assets/READMETemplate.md")
+        File.write(File.join(directory, "README.md"), template)
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/cryptex/helper/cryptex_helper.rb

@@ -0,0 +1,12 @@
+module Fastlane
+  module Helper
+    class CryptexHelper
+      # class methods that you define here become available in your action
+      # as `Helper::CryptexHelper.your_method`
+      #
+      def self.show_message
+        UI.message("Hello from the cryptex plugin helper!")
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/cryptex/options.rb

@@ -0,0 +1,85 @@
+require 'fastlane_core'
+require 'credentials_manager'
+
+module Fastlane
+  module Cryptex
+    class Options
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :git_url,
+                                       env_name: "CRYPTEX_GIT_URL",
+                                       description: "URL to the git repo containing all the certificates",
+                                       optional: false,
+                                       short_option: "-r"),
+          FastlaneCore::ConfigItem.new(key: :workspace,
+                                                                    description: nil,
+                                                                    verify_block: proc do |value|
+                                                                      unless Helper.test?
+                                                                        if value.start_with?("/var/folders") or value.include?("tmp/") or value.include?("temp/")
+                                                                          # that's fine
+                                                                        else
+                                                                          UI.user_error!("Specify the `git_url` instead of the `path`")
+                                                                        end
+                                                                      end
+                                                                    end,
+                                                                    optional: true),
+          FastlaneCore::ConfigItem.new(key: :git_branch,
+                                       env_name: "CRYPTEX_GIT_BRANCH",
+                                       description: "Specific git branch to use",
+                                       default_value: 'master'),
+          FastlaneCore::ConfigItem.new(key: :key,
+                                       short_option: "-k",
+                                       env_name: "CRYPTEX_FILE_KEY",
+                                       description: "The File KEY",
+                                       default_value: ""),
+          FastlaneCore::ConfigItem.new(key: :in,
+                                       short_option: "-i",
+                                       env_name: "CRYPTEX_IN",
+                                       description: "The File KEY",
+                                       default_value: ""),
+
+          FastlaneCore::ConfigItem.new(key: :hash,
+                                       short_option: "-H",
+                                       env_name: "CRYPTEX_HASH",
+                                       description: "Hash",
+                                       optional: true,
+                                       is_string: false),
+          FastlaneCore::ConfigItem.new(key: :set_env,
+                                       short_option: "-e",
+                                       env_name: "CRYPTEX_SET_ENV",
+                                       description: "set found variables as ENV",
+                                       default_value: false,
+                                       is_string: false),
+          FastlaneCore::ConfigItem.new(key: :out,
+                                       short_option: "-o",
+                                       env_name: "CRYPTEX_OUT",
+                                       description: "The File KEY",
+                                       default_value: ""),
+          FastlaneCore::ConfigItem.new(key: :type,
+                                       short_option: "-s",
+                                       env_name: "CRYPTEX_TYPE",
+                                       description: "Sub-Action Type (export, import, decrypt)",
+                                      default_value: "export"),
+          FastlaneCore::ConfigItem.new(key: :verbose,
+                                       env_name: "CRYPTEX_VERBOSE",
+                                       description: "Print out extra information and all commands",
+                                       is_string: false,
+                                       default_value: false,
+                                       verify_block: proc do |value|
+                                         $verbose = true if value
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :shallow_clone,
+                                       env_name: "CRYPTEX_SHALLOW_CLONE",
+                                       description: "Make a shallow clone of the repository (truncate the history to 1 revision)",
+                                       is_string: false,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :skip_docs,
+                                       env_name: "CRYPTEX_SKIP_DOCS",
+                                       description: "Skip generation of a README.md for the created git repository",
+                                       is_string: false,
+                                       default_value: false)
+        ]
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/cryptex/runner.rb

@@ -0,0 +1,88 @@
+module Fastlane
+  module Cryptex
+    class Runner
+      attr_accessor :git_changed
+
+      def import_env(params)
+        env_world_file = "#{params[:workspace]}/#{params[:key]}_env_world.crypt"
+        File.write(env_world_file, params[:hash].to_json)
+        @git_changed = true
+      end
+
+      def export_env(params)
+        env_world_file = "#{params[:workspace]}/#{params[:key]}_env_world.crypt"
+        world_data = File.read(env_world_file)
+        world_data_parsed = JSON.parse(world_data)
+        ret_json = {}
+
+        world_data_parsed.keys.each do |el|
+          next unless !params[:hash] || (params[:hash] && params[:hash].keys.include?(el))
+          ret_json[el] = world_data_parsed[el]
+          if params[:set_env]
+            ENV[el] = world_data_parsed[el]
+          end
+        end
+        return world_data_parsed
+      end
+
+      def import_file(params)
+        File.write("#{params[:workspace]}/#{params[:key]}.crypt", File.read(File.expand_path(params[:in])))
+        @git_changed = true
+      end
+
+      def delete_file(params)
+        FileUtils.rm_f "#{params[:workspace]}/#{params[:key]}.crypt"
+        @git_changed = true
+      end
+
+      def export_file(params)
+        File.write(File.expand_path(params[:out]), File.read("#{params[:workspace]}/#{params[:key]}.crypt"))
+        @git_changed = true
+      end
+
+      def nuke_all(params)
+        Encrypt.new.iterate(params[:workspace]) do |item|
+          FileUtils.rm_f item
+        end
+        @git_changed = true
+      end
+
+      def run(params)
+        FastlaneCore::PrintTable.print_values(config: params,
+                                           hide_keys: [],
+                                               title: "Summary for cryptex #{Cryptex::VERSION}")
+        @git_changed = false
+        params[:workspace] = GitHelper.clone(params[:git_url], params[:shallow_clone], skip_docs: params[:skip_docs], branch: params[:git_branch])
+        @params = params
+        if params[:type] == "import_env"
+          return import_env(params)
+        end
+        if params[:type] == "export_env"
+          return export_env(params)
+        end
+        if params[:type] == "import"
+          import_file(params)
+          return
+        end
+        if params[:type] == "delete"
+          delete_file(params)
+          return
+        end
+        if params[:type] == "export"
+          export_file(params)
+          return
+        end
+        if params[:type] == "nuke"
+          nuke_all(params)
+          return
+        end
+      ensure
+        if git_changed
+          message = GitHelper.generate_commit_message(params)
+          GitHelper.commit_changes(params[:workspace], message, params[:git_url], params[:git_branch])
+        end
+        GitHelper.clear_changes
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/cryptex/setup.rb

@@ -0,0 +1,17 @@
+module Fastlane
+  module Cryptex
+    class Setup
+      def run(path)
+        template = File.read("#{Cryptex::ROOT}/assets/CryptexfileTemplate")
+
+        UI.important "Please create a new, private git repository"
+        UI.important "to store the certificates and profiles there"
+        url = UI.input("URL of the Git Repo: ")
+
+        template.gsub!("[[GIT_URL]]", url)
+        File.write(path, template)
+        UI.success "Successfully created '#{path}'. You can open the file using a code editor."
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/cryptex/version.rb

@@ -0,0 +1,6 @@
+module Fastlane
+  module Cryptex
+    VERSION = "0.1.0"
+    DESCRIPTION = "cryptex"
+  end
+end

metadata

@@ -0,0 +1,173 @@
+--- !ruby/object:Gem::Specification
+name: fastlane-plugin-cryptex
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Helmut Januschka
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-11-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: commander
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.3.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.3.5
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fastlane
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.105.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.105.2
+- !ruby/object:Gem::Dependency
+  name: match
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+description: 
+email: h.januschka@krone.at
+executables:
+- cryptex
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/cryptex
+- lib/fastlane/plugin/cryptex.rb
+- lib/fastlane/plugin/cryptex/actions/cryptex_action.rb
+- lib/fastlane/plugin/cryptex/actions/cryptex_generate_keystore.rb
+- lib/fastlane/plugin/cryptex/assets/CryptexfileTemplate
+- lib/fastlane/plugin/cryptex/assets/READMETemplate.md
+- lib/fastlane/plugin/cryptex/change_password.rb
+- lib/fastlane/plugin/cryptex/commands_generator.rb
+- lib/fastlane/plugin/cryptex/encrypt.rb
+- lib/fastlane/plugin/cryptex/git_helper.rb
+- lib/fastlane/plugin/cryptex/helper/cryptex_helper.rb
+- lib/fastlane/plugin/cryptex/options.rb
+- lib/fastlane/plugin/cryptex/runner.rb
+- lib/fastlane/plugin/cryptex/setup.rb
+- lib/fastlane/plugin/cryptex/version.rb
+homepage: 
+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.4.8
+signing_key: 
+specification_version: 4
+summary: fastlane Crypt Store Git repo
+test_files: []