app-info 2.8.5 → 3.0.0.beta2

data/lib/app_info/certificate.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module AppInfo
+  # Certificate wrapper for
+  # {https://docs.ruby-lang.org/en/3.0/OpenSSL/X509/Certificate.html OpenSSL::X509::Certifiate}.
+  class Certificate
+    # Parse Raw data into X509 cerificate wrapper
+    # @param [String] certificate raw data
+    def self.parse(data)
+      cert = OpenSSL::X509::Certificate.new(data)
+      new(cert)
+    end
+
+    # @param [OpenSSL::X509::Certificate] certificate
+    def initialize(cert)
+      @cert = cert
+    end
+
+    # return version of certificate
+    # @param [String] prefix
+    # @param [Integer] base
+    # @return [String] version
+    def version(prefix: 'v', base: 1)
+      "#{prefix}#{raw.version + base}"
+    end
+
+    # return serial of certificate
+    # @param [Integer] base
+    # @param [Symbol] transform avaiables in :lower, :upper
+    # @param [String] prefix
+    # @return [String] serial
+    def serial(base = 10, transform: :lower, prefix: nil)
+      serial = raw.serial.to_s(base)
+      serial = transform == :lower ? serial.downcase : serial.upcase
+      return serial unless prefix
+
+      "#{prefix}#{serial}"
+    end
+
+    # return issuer from DN, similar to {#subject}.
+    #
+    # Example:
+    #
+    # @param [Symbol] format avaiables in `:to_a`, `:to_s` and `:raw`
+    # @return [Array, String, OpenSSL::X509::Name] the object converted into the expected format.
+    def issuer(format: :raw)
+      convert_cert_name(raw.issuer, format: format)
+    end
+
+    # return subject from DN, similar to {#issuer}.
+    # @param [Symbol] format avaiables in `:to_a`, `:to_s` and `:raw`
+    # @return [Array, String, OpenSSL::X509::Name] the object converted into the expected format.
+    def subject(format: :raw)
+      convert_cert_name(raw.subject, format: format)
+    end
+
+    # @return [Time]
+    def created_at
+      raw.not_before
+    end
+
+    # @return [Time]
+    def expired_at
+      raw.not_after
+    end
+
+    # @return [Boolean]
+    def expired?
+      expired_at < Time.now.utc
+    end
+
+    # @return [String] format always be :x509.
+    def format
+      :x509
+    end
+
+    # return algorithm digest
+    #
+    # OpenSSL supported digests:
+    #
+    # -blake2b512                -blake2s256                -md4
+    # -md5                       -md5-sha1                  -mdc2
+    # -ripemd                    -ripemd160                 -rmd160
+    # -sha1                      -sha224                    -sha256
+    # -sha3-224                  -sha3-256                  -sha3-384
+    # -sha3-512                  -sha384                    -sha512
+    # -sha512-224                -sha512-256                -shake128
+    # -shake256                  -sm3                       -ssl3-md5
+    # -ssl3-sha1                 -whirlpool
+    def digest
+      signature_algorithm = raw.signature_algorithm
+
+      case signature_algorithm
+      when /md5/
+        :md5
+      when /sha1/
+        :sha1
+      when /sha224/
+        :sha224
+      when /sha256/
+        :sha256
+      when /sha512/
+        :sha512
+      else
+        # Android signature no need the others
+        signature_algorithm.to_sym
+      end
+    end
+
+    # return algorithm name of public key
+    def algorithm
+      case public_key
+      when OpenSSL::PKey::RSA then :rsa
+      when OpenSSL::PKey::DSA then :dsa
+      when OpenSSL::PKey::DH  then :dh
+      when OpenSSL::PKey::EC  then :ec
+      end
+    end
+
+    # return size of public key
+    # @return [Integer]
+    def size
+      case public_key
+      when OpenSSL::PKey::RSA
+        public_key.n.num_bits
+      when OpenSSL::PKey::DSA, OpenSSL::PKey::DH
+        public_key.p.num_bits
+      when OpenSSL::PKey::EC
+        raise NotImplementedError, "key size for #{public_key.inspect} not implemented"
+      end
+    end
+
+    # return fingerprint of certificate
+    # @return [String]
+    def fingerprint(name = :sha256, transform: :lower, delimiter: nil)
+      digest = OpenSSL::Digest.new(name.to_s.upcase)
+      digest.update(raw.to_der)
+      fingerprint = digest.to_s
+      fingerprint = fingerprint.upcase if transform.to_sym == :upper
+      return fingerprint unless delimiter
+
+      fingerprint.scan(/../).join(delimiter)
+    end
+
+    # Orginal OpenSSL X509 certificate
+    # @return [OpenSSL::X509::Certificate]
+    def raw
+      @cert
+    end
+
+    private
+
+    def convert_cert_name(name, format:)
+      data = name.to_a
+      case format
+      when :to_a
+        data.map { |k, v, _| [k, v] }
+      when :to_s
+        data.map { |k, v, _| "#{k}=#{v}" }.join(' ')
+      else
+        name
+      end
+    end
+
+    def method_missing(method, *args, &block)
+      @cert.send(method.to_sym, *args, &block) || super
+    end
+
+    def respond_to_missing?(method_name, *args)
+      @cert.key?(method_name.to_sym) ||
+        @cert.respond_to?(method_name) ||
+        super
+    end
+  end
+end

data/lib/app_info/const.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module AppInfo
+  # Full Format
+  module Format
+    # Apple
+
+    INFOPLIST = :infoplist
+    MOBILEPROVISION = :mobileprovision
+    DSYM = :dsym
+
+    # macOS
+
+    MACOS = :macos
+
+    # iOS
+
+    IPA = :ipa
+
+    # Android
+
+    APK = :apk
+    AAB = :aab
+    PROGUARD = :proguard
+
+    # Windows
+
+    PE = :pe
+
+    UNKNOWN = :unknown
+  end
+
+  # Platform
+  module Platform
+    APPLE = :apple
+    GOOGLE = :google
+    WINDOWS = :windows
+  end
+
+  module OperaSystem
+    MACOS = :macos
+    IOS = :ios
+    ANDROID = :android
+    WINDOWS = :windows
+  end
+
+  # Apple Device Type
+  module Device
+    # macOS
+    MACOS = :macos
+
+    # Apple iPhone
+    IPHONE = :iphone
+    # Apple iPad
+    IPAD = :ipad
+    # Apple Watch
+    IWATCH = :iwatch # not implemented yet
+    # Apple Universal (iPhone and iPad)
+    UNIVERSAL = :universal
+
+    # Android Phone
+    PHONE = :phone
+    # Android Tablet (not implemented yet)
+    TABLET = :tablet
+    # Android Watch
+    WATCH = :watch
+    # Android TV
+    TELEVISION = :television
+    # Android Car Automotive
+    AUTOMOTIVE = :automotive
+
+    # Windows
+    WINDOWS = :windows
+  end
+end

data/lib/app_info/core_ext/object/try.rb

@@ -4,7 +4,8 @@
 # Copy from https://github.com/rails/rails/blob/master/activesupport/lib/active_support/core_ext/object/try.rb
 
 module AppInfo
-  module Tryable # :nodoc:
+  # @!visibility private
+  module Tryable
     ##
     # :method: try
     #
@@ -107,6 +108,7 @@ module AppInfo
   end
 end
 
+# @!visibility private
 class Object
   include AppInfo::Tryable
 end

data/lib/app_info/core_ext/string/inflector.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module AppInfo
+  # @!visibility private
   module Inflector
     def ai_snakecase
       gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
@@ -30,6 +31,7 @@ module AppInfo
   end
 end
 
+# @!visibility private
 class String
   include AppInfo::Inflector
 end

data/lib/app_info/dsym/debug_info.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'app_info/dsym/macho'
+
+module AppInfo
+  class DSYM < File
+    # DSYM Debug Information Format Struct
+    class DebugInfo
+      attr_reader :path
+
+      def initialize(path)
+        @path = path
+      end
+
+      def object
+        @object ||= ::File.basename(bin_path)
+      end
+
+      def macho_type
+        @macho_type ||= ::MachO.open(bin_path)
+      end
+
+      def machos
+        @machos ||= case macho_type
+                    when ::MachO::MachOFile
+                      [MachO.new(macho_type, ::File.size(bin_path))]
+                    else
+                      size = macho_type.fat_archs.each_with_object([]) do |arch, obj|
+                        obj << arch.size
+                      end
+
+                      machos = []
+                      macho_type.machos.each_with_index do |file, i|
+                        machos << MachO.new(file, size[i])
+                      end
+                      machos
+                    end
+      end
+
+      def release_version
+        info.try(:[], 'CFBundleShortVersionString')
+      end
+
+      def build_version
+        info.try(:[], 'CFBundleVersion')
+      end
+
+      def identifier
+        info.try(:[], 'CFBundleIdentifier').sub('com.apple.xcode.dsym.', '')
+      end
+      alias bundle_id identifier
+
+      def info
+        return nil unless ::File.exist?(info_path)
+
+        @info ||= CFPropertyList.native_types(CFPropertyList::List.new(file: info_path).value)
+      end
+
+      def info_path
+        @info_path ||= ::File.join(path, 'Contents', 'Info.plist')
+      end
+
+      def bin_path
+        @bin_path ||= lambda {
+          dwarf_path = ::File.join(path, 'Contents', 'Resources', 'DWARF')
+          name = Dir.children(dwarf_path)[0]
+          ::File.join(dwarf_path, name)
+        }.call
+      end
+    end
+  end
+end

data/lib/app_info/dsym/macho.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'macho'
+
+module AppInfo
+  class DSYM < File
+    # Mach-O Struct
+    class MachO
+      include Helper::HumanFileSize
+
+      def initialize(file, size = 0)
+        @file = file
+        @size = size
+      end
+
+      def cpu_name
+        @file.cpusubtype
+      end
+
+      def cpu_type
+        @file.cputype
+      end
+
+      def type
+        @file.filetype
+      end
+
+      def size(human_size: false)
+        return number_to_human_size(@size) if human_size
+
+        @size
+      end
+
+      def uuid
+        @file[:LC_UUID][0].uuid_string
+      end
+      alias debug_id uuid
+
+      def header
+        @header ||= @file.header
+      end
+
+      def to_h
+        {
+          uuid: uuid,
+          type: type,
+          cpu_name: cpu_name,
+          cpu_type: cpu_type,
+          size: size,
+          human_size: size(human_size: true)
+        }
+      end
+    end
+  end
+end

data/lib/app_info/dsym.rb

@@ -1,78 +1,26 @@
 # frozen_string_literal: true
 
-require 'macho'
+require 'app_info/dsym/debug_info'
 
 module AppInfo
   # DSYM parser
-  class DSYM
+  class DSYM < File
     include Helper::Archive
 
-    attr_reader :file
-
-    def initialize(file)
-      @file = file
-    end
-
-    def file_type
-      Platform::DSYM
-    end
-
-    def object
-      @object ||= File.basename(app_path)
-    end
-
-    def macho_type
-      @macho_type ||= ::MachO.open(app_path)
-    end
-
-    def machos
-      @machos ||= case macho_type
-                  when ::MachO::MachOFile
-                    [MachO.new(macho_type, File.size(app_path))]
-                  else
-                    size = macho_type.fat_archs.each_with_object([]) do |arch, obj|
-                      obj << arch.size
-                    end
-
-                    machos = []
-                    macho_type.machos.each_with_index do |file, i|
-                      machos << MachO.new(file, size[i])
-                    end
-                    machos
-                  end
-    end
-
-    def release_version
-      info.try(:[], 'CFBundleShortVersionString')
+    # @return [Symbol] {Platform}
+    def platform
+      Platform::APPLE
     end
 
-    def build_version
-      info.try(:[], 'CFBundleVersion')
+    def each_file(&block)
+      files.each { |file| block.call(file) }
     end
 
-    def identifier
-      info.try(:[], 'CFBundleIdentifier').sub('com.apple.xcode.dsym.', '')
-    end
-    alias bundle_id identifier
-
-    def info
-      return nil unless File.exist?(info_path)
-
-      @info ||= CFPropertyList.native_types(CFPropertyList::List.new(file: info_path).value)
-    end
-
-    def info_path
-      @info_path ||= File.join(contents, 'Contents', 'Info.plist')
-    end
-
-    def app_path
-      unless @app_path
-        path = File.join(contents, 'Contents', 'Resources', 'DWARF')
-        name = Dir.entries(path).reject { |f| ['.', '..'].include?(f) }.first
-        @app_path = File.join(path, name)
+    # @return [Array<DebugInfo>] dsym_files files by alphabetical order
+    def files
+      @files ||= Dir.children(contents).sort.each_with_object([]) do |file, obj|
+        obj << DebugInfo.new(::File.join(contents, file))
       end
-
-      @app_path
     end
 
     def clear!
@@ -81,85 +29,33 @@ module AppInfo
       FileUtils.rm_rf(@contents)
 
       @contents = nil
-      @app_path = nil
-      @info = nil
-      @object = nil
-      @macho_type = nil
+      @files = nil
     end
 
+    # @return [String] contents path of dsym
     def contents
-      unless @contents
-        if File.directory?(@file)
-          @contents = @file
-        else
-          dsym_dir = nil
-          @contents = unarchive(@file, path: 'dsym') do |path, zip_file|
-            zip_file.each do |f|
-              unless dsym_dir
-                dsym_dir = f.name
-                # fix filename is xxx.app.dSYM/Contents
-                dsym_dir = dsym_dir.split('/')[0] if dsym_dir.include?('/')
-              end
+      @contents ||= lambda {
+        return @file if ::File.directory?(@file)
 
-              f_path = File.join(path, f.name)
-              FileUtils.mkdir_p(File.dirname(f_path))
-              f.extract(f_path) unless File.exist?(f_path)
-            end
-          end
+        dsym_filenames = []
+        unarchive(@file, prefix: 'dsym') do |base_path, zip_file|
+          zip_file.each do |entry|
+            file_path = entry.name
+            next unless file_path.downcase.include?('.dsym/contents/')
+            next if ::File.basename(file_path).start_with?('.')
 
-          @contents = File.join(@contents, dsym_dir)
-        end
-      end
-
-      @contents
-    end
-
-    # DSYM Mach-O
-    class MachO
-      include Helper::HumanFileSize
-
-      def initialize(file, size = 0)
-        @file = file
-        @size = size
-      end
-
-      def cpu_name
-        @file.cpusubtype
-      end
-
-      def cpu_type
-        @file.cputype
-      end
-
-      def type
-        @file.filetype
-      end
-
-      def size(human_size: false)
-        return number_to_human_size(@size) if human_size
-
-        @size
-      end
-
-      def uuid
-        @file[:LC_UUID][0].uuid_string
-      end
-      alias debug_id uuid
+            dsym_filename = file_path.split('/').select { |f| f.downcase.end_with?('.dsym') }.last
+            dsym_filenames << dsym_filename unless dsym_filenames.include?(dsym_filename)
 
-      def header
-        @header ||= @file.header
-      end
+            unless file_path.start_with?(dsym_filename)
+              file_path = file_path.split('/')[1..-1].join('/')
+            end
 
-      def to_h
-        {
-          uuid: uuid,
-          type: type,
-          cpu_name: cpu_name,
-          cpu_type: cpu_type,
-          size: size,
-          human_size: size(human_size: true)
-        }
-      end
+            dest_path = ::File.join(base_path, file_path)
+            entry.extract(dest_path) unless ::File.exist?(dest_path)
+          end
+        end
+      }.call
     end
   end
 end

data/lib/app_info/error.rb

@@ -9,7 +9,7 @@ module AppInfo
 
   class NotFoundError < Error; end
 
-  class UnkownFileTypeError < Error; end
-
   class ProtobufParseError < Error; end
+
+  class UnknownFormatError < Error; end
 end

data/lib/app_info/file.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# AppInfo base file
+module AppInfo
+  class File
+    attr_reader :file, :logger
+
+    def initialize(file, logger: AppInfo.logger)
+      @file = file
+      @logger = logger
+    end
+
+    # @return [Symbol] {Format}
+    def format
+      @format ||= lambda {
+        if instance_of?(AppInfo::File) || instance_of?(AppInfo::Apple) ||
+           instance_of?(AppInfo::Android)
+          not_implemented_error!(__method__)
+        end
+
+        self.class.name.split('::')[-1].downcase.to_sym
+      }.call
+    end
+
+    # @abstract Subclass and override {#opera_system} to implement.
+    def opera_system
+      not_implemented_error!(__method__)
+    end
+
+    # @abstract Subclass and override {#platform} to implement.
+    def platform
+      not_implemented_error!(__method__)
+    end
+
+    # @abstract Subclass and override {#device} to implement.
+    def device
+      not_implemented_error!(__method__)
+    end
+
+    # @abstract Subclass and override {#size} to implement
+    def size(human_size: false)
+      not_implemented_error!(__method__)
+    end
+
+    def not_implemented_error!(method)
+      raise NotImplementedError, ".#{method} method implantation required in #{self.class}"
+    end
+  end
+end

data/lib/app_info/helper/archive.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'zip'
+require 'tmpdir'
+require 'fileutils'
+require 'securerandom'
+
+module AppInfo::Helper
+  module Archive
+    # Unarchive zip file
+    #
+    # source: https://github.com/soffes/lagunitas/blob/master/lib/lagunitas/ipa.rb
+    def unarchive(file, prefix:, dest_path: '/tmp')
+      base_path = Dir.mktmpdir("appinfo-#{prefix}", dest_path)
+      Zip::File.open(file) do |zip_file|
+        if block_given?
+          yield base_path, zip_file
+        else
+          zip_file.each do |f|
+            f_path = ::File.join(base_path, f.name)
+            FileUtils.mkdir_p(::File.dirname(f_path))
+            zip_file.extract(f, f_path) unless ::File.exist?(f_path)
+          end
+        end
+      end
+
+      base_path
+    end
+
+    def tempdir(file, prefix:, system: false)
+      base_path = system ? '/tmp' : ::File.dirname(file)
+      full_prefix = "appinfo-#{prefix}-#{::File.basename(file, '.*')}"
+      dest_path = Dir.mktmpdir(full_prefix, base_path)
+      ::File.join(dest_path, ::File.basename(file))
+    end
+  end
+end