pelock-stringencrypt 1.0.1

data/lib/stringencrypt/client.rb

@@ -0,0 +1,286 @@
+# frozen_string_literal: true
+
+require "base64"
+require "zlib"
+
+class StringEncrypt
+  DEFAULT_API_URL = "https://www.stringencrypt.com/api.php"
+  USER_AGENT = "pelock/stringencrypt (+https://www.stringencrypt.com)"
+
+  def initialize(api_key = "", prefer_curl = false)
+    @api_key = api_key.to_s
+    @prefer_curl = prefer_curl # ignored; Ruby client always uses Net::HTTP
+    @decompress_encrypt_source = true
+    reset_defaults(constructor: true)
+  end
+
+  def is_demo
+    previous = @command
+    self.command = Command::IS_DEMO
+    result = send
+    @command = previous
+    result
+  end
+
+  def encrypt_file_contents(file_path, label)
+    raw = File.binread(file_path)
+    return false if raw.nil? || raw.empty?
+
+    saved = snapshot_input
+    self.command = Command::ENCRYPT
+    set_bytes(raw)
+    self.label = label
+    result = send
+    restore_input(saved)
+    result
+  rescue StandardError
+    false
+  end
+
+  def encrypt_string(string, label)
+    saved = snapshot_input
+    self.command = Command::ENCRYPT
+    set_string(string)
+    self.label = label
+    result = send
+    restore_input(saved)
+    result
+  end
+
+  attr_accessor :prefer_curl, :decompress_encrypt_source, :command, :label,
+                :compression, :language, :highlight, :cmd_min, :cmd_max,
+                :local, :unicode, :lang_locale, :ansi_encoding, :new_lines,
+                :template, :return_template, :include_tags, :include_example,
+                :include_debug_comments
+
+  def set_command(command)
+    @command = command
+    self
+  end
+
+  def set_label(label)
+    @label = label
+    self
+  end
+
+  def set_string(string)
+    @input_string = string
+    @input_bytes = nil
+    self
+  end
+
+  def set_bytes(bytes)
+    @input_bytes = bytes
+    @input_string = nil
+    self
+  end
+
+  def set_compression(compression)
+    @compression = compression
+    self
+  end
+
+  def set_language(language)
+    @language = language
+    self
+  end
+
+  def set_highlight(highlight)
+    @highlight = highlight
+    self
+  end
+
+  def set_cmd_min(cmd_min)
+    @cmd_min = cmd_min
+    self
+  end
+
+  def set_cmd_max(cmd_max)
+    @cmd_max = cmd_max
+    self
+  end
+
+  def set_local(local)
+    @local = local
+    self
+  end
+
+  def set_unicode(unicode)
+    @unicode = unicode
+    self
+  end
+
+  def set_lang_locale(lang_locale)
+    @lang_locale = lang_locale
+    self
+  end
+
+  def set_ansi_encoding(ansi_encoding)
+    @ansi_encoding = ansi_encoding
+    self
+  end
+
+  def set_new_lines(new_lines)
+    @new_lines = new_lines
+    self
+  end
+
+  def set_template(template)
+    @template = template
+    self
+  end
+
+  def set_return_template(return_template)
+    @return_template = return_template
+    self
+  end
+
+  def set_include_tags(include_tags)
+    @include_tags = include_tags
+    self
+  end
+
+  def set_include_example(include_example)
+    @include_example = include_example
+    self
+  end
+
+  def set_include_debug_comments(include_debug_comments)
+    @include_debug_comments = include_debug_comments
+    self
+  end
+
+  def set_decompress_encrypt_source(decompress_encrypt_source)
+    @decompress_encrypt_source = decompress_encrypt_source
+    self
+  end
+
+  def reset
+    reset_defaults(constructor: false)
+    self
+  end
+
+  def to_request_array
+    raise ArgumentError, "Command must be set (use set_command)." if @command.nil?
+
+    case @command
+    when Command::INFO then build_info_params
+    when Command::IS_DEMO then build_is_demo_params
+    when Command::ENCRYPT then build_encrypt_params
+    else
+      raise ArgumentError, "Unknown command: #{@command}"
+    end
+  end
+
+  # PHP/JS `send()`. A Symbol first argument is forwarded to Object#send
+  # so metaprogramming still works.
+  def send(method_or_curl = :__http__, *args, &block)
+    unless method_or_curl == :__http__ || method_or_curl == true || method_or_curl == false || method_or_curl.nil?
+      return super(method_or_curl, *args, &block)
+    end
+
+    send_request
+  rescue ArgumentError
+    false
+  end
+
+  def send_request
+    params = to_request_array
+    raw = Http.post_urlencoded(DEFAULT_API_URL, params, user_agent: USER_AGENT)
+    return false if raw.nil? || raw.empty?
+
+    decoded = Http.parse_json(raw)
+    return false unless decoded.is_a?(Hash)
+
+    apply_decryptor_source_decompression(decoded)
+  end
+
+  private
+
+  def reset_defaults(constructor:)
+    @command = nil
+    @label = constructor ? "Label" : "$label"
+    @input_string = nil
+    @input_bytes = nil
+    @compression = false
+    @language = Language::PHP
+    @highlight = false
+    @cmd_min = 1
+    @cmd_max = 3
+    @local = false
+    @unicode = true
+    @lang_locale = "en_US.utf8"
+    @ansi_encoding = "WINDOWS-1250"
+    @new_lines = NewLine::LF
+    @template = nil
+    @return_template = false
+    @include_tags = false
+    @include_example = false
+    @include_debug_comments = false
+  end
+
+  def snapshot_input
+    {
+      command: @command,
+      input_string: @input_string,
+      input_bytes: @input_bytes,
+      label: @label
+    }
+  end
+
+  def restore_input(saved)
+    @command = saved[:command]
+    @input_string = saved[:input_string]
+    @input_bytes = saved[:input_bytes]
+    @label = saved[:label]
+  end
+
+  def build_info_params
+    { "command" => Command::INFO, "code" => @api_key }
+  end
+
+  def build_is_demo_params
+    { "command" => Command::IS_DEMO, "code" => @api_key }
+  end
+
+  def build_encrypt_params
+    params = {
+      "command" => Command::ENCRYPT,
+      "code" => @api_key,
+      "label" => @label,
+      "compression" => @compression,
+      "lang" => @language,
+      "cmd_min" => @cmd_min,
+      "cmd_max" => @cmd_max,
+      "local" => @local,
+      "unicode" => @unicode,
+      "lang_locale" => @lang_locale,
+      "ansi_encoding" => @ansi_encoding,
+      "new_lines" => @new_lines,
+      "return_template" => @return_template,
+      "include_tags" => @include_tags,
+      "include_example" => @include_example,
+      "include_debug_comments" => @include_debug_comments
+    }
+    if !@input_string.nil?
+      params["string"] = @input_string
+    elsif !@input_bytes.nil?
+      params["bytes"] = @input_bytes
+    end
+    params["highlight"] = @highlight unless @highlight == false
+    params["template"] = @template unless @template.nil?
+    params
+  end
+
+  def apply_decryptor_source_decompression(response)
+    return response unless @command == Command::ENCRYPT && @compression && @decompress_encrypt_source
+    return response unless response["error"] == ErrorCode::SUCCESS
+    return response unless response["source"].is_a?(String)
+
+    binary = Base64.decode64(response["source"])
+    response["source"] = Zlib::Inflate.inflate(binary)
+    response
+  rescue StandardError
+    response
+  end
+end

data/lib/stringencrypt/command.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class StringEncrypt
+  module Command
+    ENCRYPT = "encrypt"
+    IS_DEMO = "is_demo"
+    INFO = "info"
+  end
+end

data/lib/stringencrypt/error_code.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class StringEncrypt
+  module ErrorCode
+    SUCCESS = 0
+    EMPTY_LABEL = 1
+    LENGTH_LABEL = 2
+    EMPTY_STRING = 3
+    EMPTY_BYTES = 4
+    EMPTY_INPUT = 5
+    LENGTH_STRING = 6
+    INVALID_LANG = 7
+    INVALID_LOCALE = 8
+    CMD_MIN = 9
+    CMD_MAX = 10
+    LENGTH_BYTES = 11
+    DEMO = 100
+  end
+end

data/lib/stringencrypt/http.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "openssl"
+require "securerandom"
+require "uri"
+
+class StringEncrypt
+  # 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/stringencrypt/language.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class StringEncrypt
+  module Language
+    CPP = "cpp"
+    CSHARP = "csharp"
+    VBNET = "vbnet"
+    DELPHI = "delphi"
+    JAVA = "java"
+    JAVASCRIPT = "js"
+    PYTHON = "python"
+    RUBY = "ruby"
+    AUTOIT = "autoit"
+    POWERSHELL = "powershell"
+    HASKELL = "haskell"
+    MASM = "masm"
+    FASM = "fasm"
+    GO = "go"
+    RUST = "rust"
+    SWIFT = "swift"
+    KOTLIN = "kotlin"
+    LUA = "lua"
+    DART = "dart"
+    PHP = "php"
+    OBJC = "objc"
+    NASM = "nasm"
+  end
+end

data/lib/stringencrypt/new_line.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class StringEncrypt
+  module NewLine
+    LF = "lf"
+    CRLF = "crlf"
+    CR = "cr"
+  end
+end

data/lib/stringencrypt/version.rb

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

data/lib/stringencrypt.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "stringencrypt/version"
+require_relative "stringencrypt/http"
+require_relative "stringencrypt/command"
+require_relative "stringencrypt/error_code"
+require_relative "stringencrypt/language"
+require_relative "stringencrypt/new_line"
+require_relative "stringencrypt/client"

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: pelock-stringencrypt
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+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/stringencrypt.rb
+- lib/stringencrypt/client.rb
+- lib/stringencrypt/command.rb
+- lib/stringencrypt/error_code.rb
+- lib/stringencrypt/http.rb
+- lib/stringencrypt/language.rb
+- lib/stringencrypt/new_line.rb
+- lib/stringencrypt/version.rb
+homepage: https://www.stringencrypt.com
+licenses:
+- Apache-2.0
+metadata:
+  homepage_uri: https://www.stringencrypt.com
+  source_code_uri: https://github.com/PELock/StringEncrypt-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: StringEncrypt Web API Ruby SDK
+test_files: []