pindo 4.6.9

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 78cbf0c3494294a495f70d4d68732ab4d7fcb111efb47c13832bcc5570fdda49
+  data.tar.gz: 9b6072f6a35def3e42a09f36796bbe4a4999e2157d76225864ba3325a55d6d1c
+SHA512:
+  metadata.gz: cb6837bd54cd72e830010a5d263437913af930b6c3e9ce1c15ee9450a0699fa58e74b3cc14de69f6979efd147b051536d4698e36eebecfa47c6b6d6c97f5f731
+  data.tar.gz: 44b8eefc1b54857a60f20a72026f790bf134110976b97415dee6419086336cd7f30472cccdc37b7dda501a878609a279d55dbd5f8c9ca21eb99cf47dc773eb8e

data/bin/pindo

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+
+
+if Encoding.default_external != Encoding::UTF_8
+
+    if ARGV.include? '--no-ansi'
+      STDERR.puts <<-DOC
+      WARNING: pindo requires your terminal to be using UTF-8 encoding.
+      Consider adding the following to ~/.profile:
+      export LANG=en_US.UTF-8
+      DOC
+    else
+      STDERR.puts <<-DOC
+      \e[33mWARNING: pindo requires your terminal to be using UTF-8 encoding.
+      Consider adding the following to ~/.profile:
+      export LANG=en_US.UTF-8
+      \e[0m
+      DOC
+    end
+end
+
+if $PROGRAM_NAME == __FILE__ && !ENV['PINDO_NO_BUNDLER']
+  ENV['BUNDLE_GEMFILE'] = File.expand_path('../../Gemfile', __FILE__)
+  require 'rubygems'
+  require 'bundler/setup'
+  $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+elsif ENV['PINDO_NO_BUNDLER']
+  require 'rubygems'
+  gem 'pindo'
+end
+
+require 'pindo'
+
+Pindo::PindoApp.new.run(ARGV)

data/lib/pindo/base/aeshelper.rb

@@ -0,0 +1,31 @@
+module Pindo
+ 
+
+  module AESHelper
+
+
+
+
+    def self.aes_128_ecb_encrypt(key, encrypted_string)
+      cipher = OpenSSL::Cipher::Cipher.new('AES-128-ECB')
+      cipher.encrypt
+      cipher.key = key
+      txt = cipher.update(encrypted_string) << cipher.final
+      content =  Base64.strict_encode64(txt)
+      return content
+    end
+
+    def self.aes_128_ecb_decrypt(key, decrypted_string)
+      cipher = OpenSSL::Cipher.new("AES-128-ECB")
+      cipher.decrypt
+      cipher.key = key
+      text = cipher.update(Base64.strict_decode64(decrypted_string)) + cipher.final
+      return text
+    end
+
+
+
+  end
+
+
+end

data/lib/pindo/base/deviceinfo.rb

@@ -0,0 +1,90 @@
+
+module Pindo
+ 
+
+  class DeviceInfo 
+
+    attr_accessor :timezone
+    attr_accessor :xcdev
+    attr_accessor :region_code
+    attr_accessor :language_code
+    attr_accessor :system_version
+    attr_accessor :network_type
+    attr_accessor :name
+    attr_accessor :machine
+
+
+    attr_accessor :device_id
+    attr_accessor :idfa
+    attr_accessor :idfv
+    attr_accessor :tzlid
+    attr_accessor :sutid
+    attr_accessor :sbsid
+
+    attr_accessor :carriers
+
+
+    
+    def initialize(configfile:nil)
+
+        @timezone = 28800
+        @xcdev = false
+        @region_code = "US"
+        @language_code = "en"
+        @system_version = "16.4"
+        @network_type = "WIFI"
+        @name = "iPhone 14"
+        @machine = "x86_64"
+
+
+        @device_id = "PINDO000-0000-0000-0000-0000DEVICEID"
+        @idfa = "PINDO000-0000-0000-0000-00000000IDFA"
+        @sbsid = "PINDO000-0000-0000-0000-0000000SBSID"
+        @sutid = "PINDO000-0000-0000-0000-0000000SUTID"
+        @tzlid = "PINDO000-0000-0000-0000-0000000TZLID"
+        @idfv = "PINDO000-0000-0000-0000-00000000IDFV"
+
+        @carriers = []
+
+        if !configfile.nil? && File.exist?(configfile)
+
+            default_data = JSON.parse(File.read(configfile))
+            if !default_data.nil?
+
+                reset_with_config(device_config:default_data)
+                    
+            end
+
+        end
+
+
+    end
+
+    def reset_with_config(device_config:nil)
+
+
+        if !device_config.nil?
+            
+                @timezone = device_config["timezone"] || 28800
+                @xcdev = device_config["xcdev"] || false
+                @region_code = device_config["region_code"] || "US"
+                @language_code = device_config["language_code"] || "en"
+                @system_version = device_config["system_version"] || "16.4"
+                @network_type = device_config["network_type"] || "WIFI"
+                @name = device_config["name"] || "iPhone 14"
+                @machine = device_config["machine"] || "x86_64"
+
+                @device_id = device_config["device_id"] || "PINDO000-0000-0000-0000-0000DEVICEID"
+                @idfa = device_config["idfa"] || "PINDO000-0000-0000-0000-00000000IDFA"
+                @sbsid = device_config["sbsid"] || "PINDO000-0000-0000-0000-0000000SBSID"
+                @sutid = device_config["sutid"] || "PINDO000-0000-0000-0000-0000000SUTID"
+                @tzlid = device_config["tzlid"] || "PINDO000-0000-0000-0000-0000000TZLID"
+                @idfv = device_config["idfv"] || "PINDO000-0000-0000-0000-00000000IDFV"
+
+                @carriers = device_config["carriers"] || []
+
+        end
+    end
+
+  end
+end

data/lib/pindo/base/executable.rb

@@ -0,0 +1,224 @@
+module Pindo
+  # Module which provides support for running executables.
+  #
+  # In a class it can be used as:
+  #
+  #     extend Executable
+  #     executable :git
+  #
+  # This will create two methods `git` and `git!` both accept a command but
+  # the later will raise on non successful executions. The methods return the
+  # output of the command.
+  #
+  module Executable
+    # Creates the methods for the executable with the given name.
+    #
+    # @param  [Symbol] name
+    #         the name of the executable.
+    #
+    # @return [void]
+    #
+    def executable(name)
+      define_method(name) do |*command|
+        Executable.execute_command(name, Array(command).flatten, false)
+      end
+
+      define_method(name.to_s + '!') do |*command|
+        Executable.execute_command(name, Array(command).flatten, true)
+      end
+    end
+
+    # Executes the given command displaying it if in verbose mode.
+    #
+    # @param  [String] executable
+    #         The binary to use.
+    #
+    # @param  [Array<#to_s>] command
+    #         The command to send to the binary.
+    #
+    # @param  [Bool] raise_on_failure
+    #         Whether it should raise if the command fails.
+    #
+    # @raise  If the executable could not be located.
+    #
+    # @raise  If the command fails and the `raise_on_failure` is set to true.
+    #
+    # @return [String] the output of the command (STDOUT and STDERR).
+    #
+    def self.execute_command(executable, command, raise_on_failure = true)
+      bin = which!(executable)
+
+      command = command.map(&:to_s)
+      full_command = "#{bin} #{command.join(' ')}"
+
+      
+      # if Config.instance.verbose?
+        # puts "$ #{full_command}"
+        # stdout = Indenter.new(STDOUT)
+        # stderr = Indenter.new(STDERR)
+      # else
+        stdout = Indenter.new
+        stderr = Indenter.new
+      # end
+
+
+      status = popen3(bin, command, stdout, stderr)
+      stdout = stdout.join
+      stderr = stderr.join
+      output = stdout + stderr
+      unless status.success?
+        if raise_on_failure
+          raise  Informative, "#{full_command}\n\n#{output}"
+        else
+          puts "[!] Failed: #{full_command}"
+        end
+      end
+
+      output
+    end
+
+    # Returns the absolute path to the binary with the given name on the current
+    # `PATH`, or `nil` if none is found.
+    #
+    # @param  [String] program
+    #         The name of the program being searched for.
+    #
+    # @return [String,Nil] The absolute path to the given program, or `nil` if
+    #                      it wasn't found in the current `PATH`.
+    #
+    def self.which(program)
+      program = program.to_s
+      paths = ENV.fetch('PATH') { '' }.split(File::PATH_SEPARATOR)
+      paths.unshift('./')
+      paths.uniq!
+      paths.each do |path|
+        bin = File.expand_path(program, path)
+        if File.file?(bin) && File.executable?(bin)
+          return bin
+        end
+      end
+      nil
+    end
+
+    # Returns the absolute path to the binary with the given name on the current
+    # `PATH`, or raises if none is found.
+    #
+    # @param  [String] program
+    #         The name of the program being searched for.
+    #
+    # @return [String] The absolute path to the given program.
+    #
+    def self.which!(program)
+      which(program).tap do |bin|
+        raise Informative, "Unable to locate the executable `#{program}`" unless bin
+      end
+    end
+
+    # Runs the given command, capturing the desired output.
+    #
+    # @param  [String] bin
+    #         The binary to use.
+    #
+    # @param  [Array<#to_s>] command
+    #         The command to send to the binary.
+    #
+    # @param  [Symbol] capture
+    #         Whether it should raise if the command fails.
+    #
+    # @raise  If the executable could not be located.
+    #
+    # @return [(String, Process::Status)]
+    #         The desired captured output from the command, and the status from
+    #         running the command.
+    #
+    def self.capture_command(executable, command, capture: :merge)
+      bin = which!(executable)
+
+      require 'open3'
+      command = command.map(&:to_s)
+      case capture
+      when :merge then Open3.capture2e(bin, *command)
+      when :both then Open3.capture3(bin, *command)
+      when :out then Open3.capture3(bin, *command).values_at(0, -1)
+      when :err then Open3.capture3(bin, *command).drop(1)
+      when :none then Open3.capture3(bin, *command).last
+      end
+    end
+
+    private
+
+    def self.popen3(bin, command, stdout, stderr)
+      require 'open3'
+      Open3.popen3(bin, *command) do |i, o, e, t|
+        reader(o, stdout)
+        reader(e, stderr)
+        i.close
+
+        status = t.value
+
+        o.flush
+        e.flush
+        sleep(0.01)
+
+        status
+      end
+    end
+
+    def self.reader(input, output)
+      Thread.new do
+        buf = ''
+        begin
+          loop do
+            buf << input.readpartial(4096)
+            loop do
+              string, separator, buf = buf.partition(/[\r\n]/)
+              if separator.empty?
+                buf = string
+                break
+              end
+              output << (string << separator)
+            end
+          end
+        rescue EOFError
+          output << (buf << $/) unless buf.empty?
+        end
+      end
+    end
+
+    #-------------------------------------------------------------------------#
+
+    # Helper class that allows to write to an {IO} instance taking into account
+    # the UI indentation level.
+    #
+    class Indenter < ::Array
+      # @return [Fixnum] The indentation level of the UI.
+      #
+      attr_reader :indent
+
+      # @return [IO] the {IO} to which the output should be printed.
+      #
+      attr_reader :io
+
+      # Init a new Indenter
+      #
+      # @param [IO] io @see io
+      #
+      def initialize(io = nil)
+        @io = io
+        @indent = ' '
+      end
+
+      # Stores a portion of the output and prints it to the {IO} instance.
+      #
+      # @param  [String] value
+      #         the output to print.
+      #
+      # @return [void]
+      #
+      def <<(value)
+        super
+        io << "#{indent}#{value}" if io
+      end
+    end
+  end
+end