obfuskit 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 64dba62899b6d17faac7cb64e3797074bf7d532bda2ed2541b7eaf0a7e831be4
+  data.tar.gz: eb181aeb2d05fffc68a2c7bc1229ed9524aa5bceebbf648e4ae80d342d8c3e52
+SHA512:
+  metadata.gz: 152431909ff9df68577645f73f68cb267662291b3e4ac8e13c95a34dd204718951a238f2d01c5d16d335a69083e79091e420b4103e0f6a35f151e0be8d09890d
+  data.tar.gz: 3167acf2e668dc3fd4b5eb0a6d1b2d31f6f1d0eeaa98316f8375212baae9b56e0254b22a8a610d77d0b0238d2a832323734381dba8352d9df92e117e063f35ae

data/bin/obfuskit

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require 'obfuskit'

data/lib/O.rb

@@ -0,0 +1,25 @@
+# A class representing an obfuscator.
+class O
+    # Initializes the obfuscator with a string.
+    # The string is converted to an array of bytes and stored in @c.
+    # The size of the array is stored in @l.
+    def initialize(s)
+      s = s.bytes if s.is_a? String
+      @c = s
+      @l = @c.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 o(v)
+      v.bytes.map.with_index { |b, i| b ^ @c[i % @l] }
+    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 r(value)
+      value.map.with_index { |b, i| b ^ @c[i % @l] }.pack('C*').force_encoding('utf-8')
+    end
+  end

data/lib/Omin.kt

@@ -0,0 +1 @@
+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)}}

data/lib/Omin.swift

@@ -0,0 +1 @@
+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) ?? "" } }

data/lib/obfuskit.rb

@@ -0,0 +1,107 @@
+#!/usr/bin/env ruby
+
+# Import the necessary modules and files
+require_relative 'O'
+require 'securerandom'
+require 'dotenv'
+
+# Define a module for language constants
+module Language
+    SWIFT = "Swift"
+    KOTLIN = "Kotlin"
+end
+
+# Function to generate Swift code
+def generate_swift(args)
+    # Get the source code for the obfuscator
+    obfuscator_source = obfuscator_source('Omin.swift')
+    # Generate a random UUID and remove the hyphens
+    obfuscation_salt = SecureRandom.uuid.to_s.gsub("-", "")
+    # Create a new instance of the O class with the obfuscation salt
+    o = O.new("_" + obfuscation_salt)
+
+    # Start building the Swift code
+    code = "import Foundation\n\n"
+    code += "enum ObfusKit {\n"
+    # For each argument, if it's in the environment variables, add it to the code
+    args.each_with_index do |arg, index|
+        if ENV[arg] != nil 
+            code += "\tstatic let #{arg}: String = _o.r(#{o.o(ENV[arg])})\n"
+        end
+    end
+    code += "\n"
+    # Add the obfuscation salt and the obfuscator to the code
+    code += <<-STRING
+\tprivate class _#{obfuscation_salt} { }
+\tprivate static let _o = O(String(describing: _#{obfuscation_salt}.self))
+}\n\n
+STRING
+
+    # Add the obfuscator source code to the code
+    code += obfuscator_source
+    # Return the generated code
+    return code
+end
+
+# Function to generate Kotlin code
+def generate_kotlin(args)
+    # Get the source code for the obfuscator
+    obfuscator_source = obfuscator_source('Omin.kt')
+    # Generate a random UUID and remove the hyphens
+    obfuscation_salt = SecureRandom.uuid.to_s.gsub("-", "")
+    # Create a new instance of the O class with the obfuscation salt
+    o = O.new("_" + obfuscation_salt)
+    
+    # Start building the Kotlin code
+    code = "object ObfusKit {\n"
+    # Add the obfuscation salt and the obfuscator to the code
+    code += <<-STRING
+\tprivate val _o = O(_#{obfuscation_salt}::class.java.simpleName)
+\tprivate class _#{obfuscation_salt}\n
+STRING
+
+    # For each argument, if it's in the environment variables, add it to the code
+    args.each_with_index do |arg, index|
+        if ENV[arg] != nil 
+            code += "\tval #{arg}: String = _o.r(byteArrayOf(#{o.o(ENV[arg]).map { |i| i.to_s }.join(', ')}))\n"
+        end
+    end
+    code += "}\n\n"
+
+    # Add the obfuscator source code to the code
+    code += obfuscator_source
+    # Return the generated code
+    return code
+end
+
+# Function to get the source code for the obfuscator
+def obfuscator_source(file_name)
+    # Get the full path to the file
+    source_file_path = File.expand_path(file_name, __dir__)
+    # If the file exists, read and return its contents
+    return File.read(source_file_path) if File.exist?(source_file_path)
+end
+
+# MAIN
+
+language_map = {
+    "swift" => Language::SWIFT,
+    "kotlin" => Language::KOTLIN,
+    "kt" => Language::KOTLIN
+}
+
+Dotenv.load
+
+args = ARGV
+first_arg = args.shift
+
+if first_arg != nil && language_map.key?(first_arg.downcase)    
+    case language_map[first_arg]
+    when Language::SWIFT
+        puts generate_swift(args)
+    when Language::KOTLIN
+        puts generate_kotlin(args)
+    end
+else
+    puts "First argument is not a valid language. Use `swift` or `kotlin`."
+end

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: obfuskit
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Martin Gratzer
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-01-16 00:00:00.000000000 Z
+dependencies: []
+description: Environment variable obfuscation for Swift and Kotlin
+email: mgratzer@gmail.com
+executables:
+- obfuskit
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/obfuskit
+- lib/O.rb
+- lib/Omin.kt
+- lib/Omin.swift
+- lib/obfuskit.rb
+homepage: https://github.com/mgratzer/obfuskit
+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: []
+rubygems_version: 3.3.3
+signing_key:
+specification_version: 4
+summary: Environment variable obfuscation for Swift and Kotlin
+test_files: []