autoit-obfuscator 1.5.0

data/lib/autoit-obfuscator/client.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "base64"
+require "json"
+require "zlib"
+
+class AutoItObfuscator
+  API_URL = "https://www.pelock.com/api/autoit-obfuscator/v1"
+  ERROR_SUCCESS = 0
+  ERROR_INPUT_SIZE = 1
+  ERROR_INPUT = 2
+  ERROR_PARSING = 3
+  ERROR_OBFUSCATION = 4
+  ERROR_OUTPUT = 5
+  USER_AGENT = "PELock AutoIt Obfuscator"
+
+  # All strategy flags default to false (same as the JavaScript / PHP SDKs).
+  FLAG_PARAMS = {
+    anti_debug: "anti_debug",
+    anti_vm: "anti_vm",
+    anti_sandbox: "anti_sandbox",
+    anti_emulator: "anti_emulator",
+    random_integers: "random_bucket_integers",
+    random_characters: "random_bucket_characters",
+    random_anti_regex: "random_bucket_anti_regex",
+    random_arrays: "random_bucket_arrays",
+    random_arrays_multidimensional: "random_bucket_arrays_multidimensional",
+    random_functions: "random_bucket_functions",
+    random_autostarted: "random_bucket_autostart",
+    mix_code_flow: "mix_code_flow",
+    rename_variables: "rename_variables",
+    rename_functions: "rename_functions",
+    rename_function_calls: "rename_function_calls",
+    shuffle_functions: "shuffle_functions",
+    resolve_constants: "resolve_const",
+    crypt_numbers: "crypt_numbers",
+    split_strings: "split_strings",
+    modify_strings: "modify_strings",
+    crypt_strings: "crypt_strings",
+    insert_ternary_operators: "insert_ternary_operators"
+  }.freeze
+
+  attr_accessor :enable_compression, *FLAG_PARAMS.keys
+
+  def initialize(api_key = nil)
+    @api_key = api_key
+    @enable_compression = false
+    FLAG_PARAMS.each_key { |name| instance_variable_set("@#{name}", false) }
+  end
+
+  def login(return_as_object = true)
+    post_request({ "command" => "login" }, return_as_object)
+  end
+
+  def obfuscate_script_file(script_file_path, return_as_object = true)
+    source = File.read(script_file_path, encoding: "UTF-8")
+    return nil if source.nil? || source.empty?
+
+    obfuscate_script_source(source, return_as_object)
+  rescue StandardError
+    nil
+  end
+
+  def obfuscate_script_source(script_source, return_as_object = true)
+    post_request({ "command" => "obfuscate", "source" => script_source }, return_as_object)
+  end
+
+  private
+
+  def post_request(params_array, return_as_object)
+    params = params_array.dup
+    params["key"] = @api_key unless @api_key.nil? || @api_key.to_s.empty?
+
+    FLAG_PARAMS.each do |name, key|
+      params[key] = "1" if instance_variable_get("@#{name}")
+    end
+
+    if @enable_compression && params["source"]
+      params["source"] = Base64.strict_encode64(Zlib::Deflate.deflate(params["source"], 9))
+      params["compression"] = "1"
+    end
+
+    body = Http.post_multipart(API_URL, params, user_agent: USER_AGENT)
+    return nil if body.nil? || body.empty?
+
+    result = Http.parse_json(body)
+    return nil if result.nil?
+
+    depacked = false
+    if @enable_compression && result["error"] == ERROR_SUCCESS && result["output"]
+      begin
+        result["output"] = Zlib::Inflate.inflate(Base64.decode64(result["output"]))
+        depacked = true
+      rescue StandardError
+        return nil
+      end
+    end
+
+    return result if return_as_object
+    return JSON.generate(result) if depacked
+
+    body
+  end
+end

data/lib/autoit-obfuscator/http.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "openssl"
+require "securerandom"
+require "uri"
+
+class AutoItObfuscator
+  # Stdlib HTTP helper. Multipart for API form posts / file uploads; urlencoded when needed.
+  module Http
+    class << self
+      def post_multipart(url, fields, user_agent:, files: {})
+        boundary = "----PELock#{SecureRandom.hex(16)}"
+        body = build_multipart(fields, files, boundary)
+        request(url, body, user_agent, "multipart/form-data; boundary=#{boundary}")
+      end
+
+      def post_urlencoded(url, fields, user_agent:)
+        pairs = []
+        fields.each do |key, value|
+          next if value.nil?
+
+          pairs << [key.to_s, normalize_form_value(value)]
+        end
+        request(url, URI.encode_www_form(pairs), user_agent, "application/x-www-form-urlencoded")
+      end
+
+      def parse_json(body)
+        return nil if body.nil? || body.to_s.empty?
+
+        JSON.parse(body)
+      rescue JSON::ParserError
+        nil
+      end
+
+      def request(url, body, user_agent, content_type)
+        uri = URI.parse(url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        http.open_timeout = 30
+        http.read_timeout = 180
+        req = Net::HTTP::Post.new(uri.request_uri)
+        req["User-Agent"] = user_agent
+        req["Content-Type"] = content_type
+        req.body = body
+        http.request(req).body
+      rescue StandardError
+        nil
+      end
+
+      def build_multipart(fields, files, boundary)
+        body = String.new(encoding: Encoding::ASCII_8BIT)
+        fields.each do |name, value|
+          next if value.nil?
+
+          body << "--#{boundary}\r\n"
+          body << "Content-Disposition: form-data; name=\"#{name}\"\r\n\r\n"
+          body << value.to_s.dup.force_encoding(Encoding::UTF_8).b
+          body << "\r\n"
+        end
+        files.each do |name, file|
+          filename = file[:filename] || File.basename(file[:path].to_s)
+          content = file[:content] || File.binread(file[:path])
+          content_type = file[:content_type] || "application/octet-stream"
+          body << "--#{boundary}\r\n"
+          body << "Content-Disposition: form-data; name=\"#{name}\"; filename=\"#{filename}\"\r\n"
+          body << "Content-Type: #{content_type}\r\n\r\n"
+          body << content.b
+          body << "\r\n"
+        end
+        body << "--#{boundary}--\r\n"
+        body
+      end
+
+      def normalize_form_value(value)
+        case value
+        when true then "1"
+        when false then "0"
+        else value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/autoit-obfuscator/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class AutoItObfuscator
+  VERSION = "1.5.0"
+end

data/lib/autoit-obfuscator.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "autoit-obfuscator/version"
+require_relative "autoit-obfuscator/http"
+require_relative "autoit-obfuscator/client"

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: autoit-obfuscator
+version: !ruby/object:Gem::Version
+  version: 1.5.0
+platform: ruby
+authors:
+- Bartosz Wójcik
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+email:
+- support@pelock.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/autoit-obfuscator.rb
+- lib/autoit-obfuscator/client.rb
+- lib/autoit-obfuscator/http.rb
+- lib/autoit-obfuscator/version.rb
+homepage: https://www.pelock.com/products/autoit-obfuscator
+licenses:
+- Apache-2.0
+metadata:
+  homepage_uri: https://www.pelock.com/products/autoit-obfuscator
+  source_code_uri: https://github.com/PELock/AutoIt-Obfuscator-Ruby
+  bug_tracker_uri: https://www.pelock.com
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: AutoIt Obfuscator Web API Ruby SDK
+test_files: []