obfuskit 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95df1da20d19fbbd42f0573e3373d1c08831f65f5a49365418fb98569a3d4c57
-  data.tar.gz: 43964e64f7175109de2e033f538a1a42632ff4be5330fa30513fb53651f45a17
+  metadata.gz: 1bf83c6351238774e0cd0f479d2aeb033d6e06bf61a0567f461951c76ea2f551
+  data.tar.gz: b1ef6d097ab410c3266ea9ef97b7ee04dd6e9cee053f85d0cd2f3085e7dc6db0
 SHA512:
-  metadata.gz: d2e3716d091ee82c00a397a2d17bd610220bef2678c0402e75582b81c8f5491915b0003196e4e72951aa29a3634eb30223b7c83463a31635f87a3e68c3f47600
-  data.tar.gz: 3086262688ba6c838a649a9bcbef677578a6001d5a716748ff0974046f511a58e4e556cd127bc316edfe5bf4e41f4cfde3e5791e9a9b475a2ca5f8fd545c562d
+  metadata.gz: cf47193804ca3fa28838b8d33d5f8e05965665c354b94a5651d8ca7e0ce0b9515758f84571664351efeae009116dc4fc9363bc28f1599ccdd3d1e1d0506c3e8f
+  data.tar.gz: 0a809262ff81d7c6df8656088867f575003ff519e521bdc3db38a775295a938d9ca05d4834c3bb6432151d1fc33d169d8810a51a8013a20b76f58c893490b804

data/README.md

@@ -1,22 +1,36 @@
 # ObfusKit
-
-ObfusKit is a ruby script to generate obfuscated secrets for `Swift` and `Kotlin`.
+ObfusKit is a ruby script that generates obfuscated secrets for `Swift` and `Kotlin`.
 
 ## Installation and usage
 
 Install the latest version of the gem using:
 
-```
+```sh
 gem install obfuskit
 ```
 
-To generate Swift code run the following command:
+Call `obfuskit -h` for help.
 
 ```sh
-obfuskit swift SECRET_1 SECRET_2 > generated.swift
+Usage: obfuskit [options]
+
+Specific options:
+    -l, --language [LANGUAGE]        Output language (swift, kotlin). Kotlin requires a package parameter.
+    -k SECRET_1,SECRET_2,SECRET_3,   List of environment variable keys
+        --keys
+    -p, --package [PACKAGE]          Package name for Kotlin
+    -t, --type [TYPE]                Output type name. Defaults to `ObfusKit`
+    -e, --env [PATH]                 Path to an alternative .env file
+
+Common options:
+    -h, --help                       Show this message
+    -v, --version                    Show version
 ```
 
-It will will create the file `generated.swift` containing an obfuscated version of the environment variables `SECRET_1` and `SECRET_2`. 
+### Swift
+
+To generate Swift code run the following command:
+It will create the file `generated.swift` containing an obfuscated version of the environment variables `SECRET_1` and `SECRET_2`. 
 This file should be excluded from the git repository and generated at build time. 
 The obfuscation salt is regenerated for each run.
 
@@ -30,14 +44,15 @@ enum ObfusKit {
 	private class _3f3eccd2e5ea46b39738e5502bda6bef { }
 	private static let _o = O(String(describing: _3f3eccd2e5ea46b39738e5502bda6bef.self))
 }
-
-struct O { private let c: [UInt8]; private let l: Int; init(_ s: String) { self.init([UInt8](s.utf8)) }; init(_ c: [UInt8]) { self.c = c; l = c.count }; @inline(__always) func o(_ v: String) -> [UInt8] { [UInt8](v.utf8).enumerated().map { $0.element ^ c[$0.offset % l] } }; @inline(__always) func r(_ value: [UInt8]) -> String { String(bytes: value.enumerated().map { $0.element ^ c[$0.offset % l] }, encoding: .utf8) ?? "" } }
+// ...
 ```
 
+### Kotlin 
+
 The same concept applies for the `kotlin` language using:
 
 ```sh
-obfuskit kotlin com.myapp.configuration.environment SECRET_1 SECRET_2 > generated.kt
+obfuskit -l kotlin -p com.myapp.configuration.environment -k SECRET_1,SECRET_2 > generated.kt
 ```
 It will create the Kotlin version `generated.kt`.
 
@@ -51,9 +66,29 @@ object ObfusKit {
         val SECRET_1: String = _o.r(byteArrayOf(30, 116, 118, 115, 119, 119, 116))
         val SECRET_2: String = _o.r(byteArrayOf(24, 112, 112, 115, 113, 115, 114))
 }
+// ...
+```
+
+## Customizations
 
-class O{private val a:ByteArray;private val b:Int;constructor(s:String){a=s.toByteArray(Charsets.UTF_8);b=a.size};fun o(v:String):ByteArray{val d=v.toByteArray(Charsets.UTF_8);return ByteArray(d.size){i->(d[i].toInt() xor a[i%b].toInt()).toByte()}};fun r(value:ByteArray):String{return String(ByteArray(value.size){i->(value[i].toInt() xor a[i%b].toInt()).toByte()},Charsets.UTF_8)}}
+### The output type name
 
+The default generated type name in the target language is `ObfusKit``. Customize this name with the `-t` option.
+Which will generate the Swift type `Secrets` instead of `ObfusKit`.
+
+```swift
+import Foundation
+
+enum Secrets {
+// ..
+```
+
+### Use a custom .env file location
+
+Use the `-e` option to define the path to a different `.env` file, e.g. if you want to reuse the `fastlane/.env` file.
+
+```sh
+obfuskit -l swift -k SECRET_3,SECRET_4 -e fastlane/.env > generated.swift
 ```
 
 ## Features

data/lib/obfuskit/generator.rb

@@ -1,79 +1,61 @@
 # frozen_string_literal: true
 require_relative 'obfuscator'
+require_relative 'options_parser'
 require 'securerandom'
 require 'dotenv'
 require 'erb'
-
-module Language
-  SWIFT = "Swift"
-  KOTLIN = "Kotlin"
-end
+require 'optparse'
 
 module Obfuskit
 
   class Generator
 
-    def generate()
+    def generate
 
-      Dotenv.load
-      args = ARGV
-      language_key = args.shift.downcase
+      parser = OptionsParser.new
+      options = parser.parse(ARGV)
 
-      language_map = {
-        "swift" => Language::SWIFT,
-        "kotlin" => Language::KOTLIN,
-        "kt" => Language::KOTLIN
-      }
+      Dotenv.load(options.dot_env_file_path)
 
-      if language_key != nil && language_map.key?(language_key)
+      if !options.output_language.nil? && options.env_var_keys.length.positive?
 
         salt = SecureRandom.uuid.to_s.gsub("-", "")
         obfuscator = Obfuscator.new("_" + salt)
 
-        case language_map[language_key]
-        when Language::SWIFT
-          puts generate_swift(args, obfuscator)
+        values = obfuscated_values_from_env(options.env_var_keys, obfuscator)
+
+        if options.output_language == :swift
+          puts generate_with_template("swift", values, nil, options.output_type_name, obfuscator)
+
+        elsif options.output_language == :kotlin && !options.package_name.nil?
+          puts generate_with_template("kotlin", values, options.package_name, options.output_type_name, obfuscator)
 
-        when Language::KOTLIN
-          puts generate_kotlin(args, obfuscator)
+        else
+        STDERR.puts parser.parse(%w[--help])
         end
 
       else
-        STDERR.puts "Please specify a valid language."
+        STDERR.puts parser.parse(%w[--help])
       end
     end
 
     private
 
-    def generate_swift(args, obfuscator)
-      values = obfuscated_values_from_env(args, obfuscator)
-      generate_with_template("swift", values, nil, obfuscator)
-    end
-
-    def generate_kotlin(args, obfuscator)
-      package = args.shift
-      if package == nil
-        STDERR.puts "No package name provided."
-      else
-        values = obfuscated_values_from_env(args, obfuscator)
-        generate_with_template("kotlin", values, package, obfuscator)
-      end
-    end
-
     def obfuscated_values_from_env(args, obfuscator)
-      args.map { |name|
-        ENV[name] != nil ? [name, obfuscator.obfuscate(ENV[name])] : nil
-      }.compact.to_h
+      args.map do |name|
+        !ENV[name].nil? ? [name, obfuscator.obfuscate(ENV[name])] : nil
+      end.compact.to_h
     end
 
-    def generate_with_template(template_name, values, package, obfuscator)
+    def generate_with_template(template_name, values, package, type_name, obfuscator)
       file = File.expand_path("templates/#{template_name}.erb", __dir__)
       template = ERB.new(File.read(file), trim_mode: "-")
       template.result_with_hash(
         values: values,
         package: package,
-        salt: obfuscator.salt
-      )
+        type_name: type_name,
+        salt: obfuscator.salt,
+        )
     end
 
   end

data/lib/obfuskit/obfuscator.rb

@@ -11,23 +11,23 @@ module Obfuskit
     # The string is converted to an array of bytes and stored in @c.
     # The size of the array is stored in @l.
     def initialize(salt)
-      salt = salt.bytes if salt.is_a? String
-      @salt = salt
-      @length = @salt.size
+      @salt = salt || ""
+      @salt_bytes = (salt.bytes || []) if salt.is_a? String
+      @salt_length = @salt_bytes.size
     end
 
     # Obfuscates a string.
     # The string is converted to an array of bytes and each element is XORed with an element from @c.
     # The index of the element from @c is the index of the element from the string modulo @l.
     def obfuscate(value)
-      value.bytes.map.with_index { |b, i| b ^ @salt[i % @length] }
+      value.bytes.map.with_index { |b, i| b ^ @salt_bytes[i % @salt_length] }
     end
 
     # Reverses the obfuscation of an array of bytes.
     # Each element is XORed with an element from @c and the result is converted back to a string.
     # The index of the element from @c is the index of the element from the array modulo @l.
     def reveal(value)
-      value.map.with_index { |b, i| b ^ @salt[i % @length] }.pack('C*').force_encoding('utf-8')
+      value.map.with_index { |b, i| b ^ @salt_bytes[i % @salt_length] }.pack('C*').force_encoding('utf-8')
     end
   end
 end

data/lib/obfuskit/options_parser.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+require 'optparse'
+
+class OptionsParser
+  class ScriptOptions
+
+    attr_accessor :output_language, :env_var_keys, :package_name, :output_type_name, :dot_env_file_path
+
+    def initialize
+      self.output_language = nil
+      self.env_var_keys = []
+      self.package_name = nil
+      self.output_type_name = "ObfusKit"
+      self.dot_env_file_path = ".env"
+    end
+
+    def define_options(parser)
+      parser.banner = "Usage: obfuskit [options]"
+      parser.separator ""
+      parser.separator "Specific options:"
+
+      # add additional options
+      output_language_option(parser)
+      env_var_keys_option(parser)
+      package_name_option(parser)
+      output_type_name_option(parser)
+      dot_env_file_path_options(parser)
+
+      parser.separator ""
+      parser.separator "Common options:"
+      # No argument, shows at tail.  This will print an options summary.
+      # Try it and see!
+      parser.on_tail("-h", "--help", "Show this message") do
+        puts parser
+        exit
+      end
+
+      # Another typical switch to print the version.
+      parser.on_tail("-v", "--version", "Show version") do
+        puts Obfuskit::VERSION
+        exit
+      end
+
+    end
+
+    private
+
+    def output_language_option(parser)
+      parser.on("-l", "--language [LANGUAGE]", [:swift, :kotlin],
+                "Output language (swift, kotlin). Kotlin requires a package parameter.") do |t|
+        self.output_language = t
+      end
+    end
+
+    def env_var_keys_option(parser)
+      parser.on("-k", "--keys SECRET_1,SECRET_2,SECRET_3", Array, "List of environment variable keys") do |list|
+        self.env_var_keys = list
+      end
+    end
+
+    def package_name_option(parser)
+      parser.on("-p", "--package [PACKAGE]", "Package name for Kotlin") do |value|
+        self.package_name = value
+      end
+    end
+
+    def output_type_name_option(parser)
+      parser.on("-t", "--type [TYPE]", "Output type name. Defaults to `ObfusKit`") do |value|
+        self.output_type_name = value
+      end
+    end
+
+    def dot_env_file_path_options(parser)
+      parser.on("-e", "--env [PATH]", "Path to an alternative .env file") do |value|
+        self.dot_env_file_path = value
+      end
+    end
+  end
+
+  #
+  # Return a structure describing the options.
+  #
+  def parse(args)
+    # The options specified on the command line will be collected in
+    # *options*.
+
+    @options = ScriptOptions.new
+    OptionParser.new do |parser|
+      @options.define_options(parser)
+      parser.parse!(args)
+    end
+    @options
+  end
+
+  attr_reader :parser, :options
+end  # class OptionsParser

data/lib/obfuskit/templates/kotlin.erb

@@ -1,8 +1,8 @@
 package <%= package %>
 
-public object ObfusKit {
-  private val _o = O(_6572131328ef462d9d4a05cf4b2a2516::class.java.simpleName)
-  private class _6572131328ef462d9d4a05cf4b2a2516
+public object <%= type_name %> {
+  private val _o = O(<%= salt %>::class.java.simpleName)
+  private class <%= salt %>
 
 <% values.each do |name, values| -%>
   public val <%= name %>: String = _o.r(byteArrayOf(<%= values.map { |i| i.to_s }.join(', ') %>))

data/lib/obfuskit/templates/swift.erb

@@ -1,6 +1,6 @@
 import Foundation
 
-public enum ObfusKit {
+public enum <%= type_name %> {
 <% values.each do |name, values| -%>
   public static let <%= name %>: String = _o.r([<%= values.map { |i| i.to_s }.join(', ') %>])
 <% end -%>

data/lib/obfuskit/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Obfuskit
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/sig/obfuskit/generator.rbs

@@ -3,9 +3,9 @@ module Obfuskit
     def generate: -> void
 
     private
-    def generate_kotlin: ([String], Obfuscator) -> String
-    def generate_swift: ([String], Obfuscator) -> String
+    def generate_kotlin: ([String], String, Obfuscator) -> String
+    def generate_swift: ([String], String, Obfuscator) -> String
     def obfuscated_values_from_env: ([String], Obfuscator) -> Hash[String, [Integer]]
-    def generate_with_template: (String, Hash[String, [Integer]], String, Obfuscator) -> String
+    def generate_with_template: (String, Hash[String, [Integer]], String?, String, Obfuscator) -> String
   end
 end

data/sig/obfuskit/obfuscator.rbs

@@ -1,10 +1,13 @@
 module Obfuskit
   class Obfuscator
-    @length: Integer
-    @salt: String
+    attr_reader salt: String
 
-    def salt: -> String
+    def initialize: (salt: String) -> void
     def obfuscate: (String) -> [Integer]
     def reveal: ([Integer]) -> String
+
+    private
+    attr_reader salt_length: Integer
+    attr_reader salt_bytes: [Integer]
   end
 end

data/sig/obfuskit/options_parser.rbs

@@ -0,0 +1,6 @@
+class OptionsParser
+  attr_reader options: ScriptOptions
+  attr_reader parser: OptionsParser
+
+  def parse: -> ScriptOptions
+end

data/sig/options_parser/script_options.rbs

@@ -0,0 +1,20 @@
+module OptionsParser
+  class ScriptOptions
+    attr_accessor dot_env_file_path: String
+    attr_accessor dot_env_file_paths: [String]
+    attr_accessor env_var_keys: [String]
+    attr_accessor output_language: String?
+    attr_accessor output_type_name: String
+    attr_accessor package_name: String?
+
+    def define_options: -> void
+
+    private
+
+    def dot_env_file_path_options: -> OptionParser
+    def env_var_keys_option: -> OptionParser
+    def output_language_option: -> OptionParser
+    def output_type_name_option: -> OptionParser
+    def package_name_option: -> OptionParser
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: obfuskit
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Martin Gratzer
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-01-19 00:00:00.000000000 Z
+date: 2024-04-02 00:00:00.000000000 Z
 dependencies: []
 description: Generate Swift and Kotlin files with obfuscated environment variables.
 email: mgratzer@gmail.com
@@ -23,18 +23,21 @@ files:
 - exe/obfuskit
 - lib/obfuskit/generator.rb
 - lib/obfuskit/obfuscator.rb
+- lib/obfuskit/options_parser.rb
 - lib/obfuskit/templates/kotlin.erb
 - lib/obfuskit/templates/swift.erb
 - lib/obfuskit/version.rb
 - sig/obfuskit.rbs
 - sig/obfuskit/generator.rbs
 - sig/obfuskit/obfuscator.rbs
+- sig/obfuskit/options_parser.rbs
+- sig/options_parser/script_options.rbs
 homepage: https://github.com/mgratzer/obfuskit
 licenses:
 - MIT
 metadata:
   homepage_uri: https://github.com/mgratzer/obfuskit
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -49,8 +52,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
-signing_key: 
+rubygems_version: 3.5.6
+signing_key:
 specification_version: 4
 summary: Environment variable obfuscation for Swift and Kotlin.
 test_files: []