idevice 1.1.5.0

data/lib/idevice/c.rb

@@ -0,0 +1,129 @@
+#
+# Copyright (c) 2013 Eric Monti - Bluebox Security
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+require "rubygems"
+require 'plist'
+require "ffi"
+
+module FFI
+  class MemoryPointer < Pointer
+    def self.from_bytes(data)
+      if block_given?
+        new(data.size) do |p|
+          p.write_bytes(data)
+          yield(p)
+        end
+      else
+        p = new(data.size)
+        p.write_bytes(data)
+        p
+      end
+    end
+
+    def self.null_terminated_array_of_strings(strs)
+      psize = FFI::MemoryPointer.size * (strs.count+1)
+      pstrs = strs.map{|str| FFI::MemoryPointer.from_string(str) }
+      if block_given?
+        new(psize) do |aryp|
+          aryp.write_array_of_pointer(pstrs)
+          yield(aryp)
+        end
+      else
+        aryp.instance_variable_set(:@_string_pointers, pstrs) # retain reference for garbage collection
+        aryp.write_array_of_pointer(pstrs)
+        return aryp
+      end
+    end
+  end
+end
+
+module Idevice
+  module LibHelpers
+    def self.included(base)
+      class << base
+      private
+        def _attach_helper(svcname, opts={})
+          idevice = opts[:idevice] || Idevice.attach(opts)
+          ldsvc = opts[:lockdown_service]
+          unless ldsvc
+            ldclient = opts[:lockdown_client] || LockdownClient.attach(opts.merge(idevice:idevice))
+            ldsvc = ldclient.start_service(svcname)
+          end
+
+          FFI::MemoryPointer.new(:pointer) do |p_client|
+            yield idevice, ldsvc, p_client
+          end
+        end
+      end
+    end
+
+  private
+
+    def _unbound_list_to_array(p_unbound_list)
+      ret = nil
+      base = list = p_unbound_list.read_pointer
+      unless list.null?
+        ret = []
+        until list.read_pointer.null?
+          ret << list.read_pointer.read_string
+          list += FFI::TypeDefs[:pointer].size
+        end
+        C.idevice_device_list_free(base)
+      end
+      return ret
+    end
+
+    def _infolist_to_hash(p_infolist)
+      infolist = _unbound_list_to_array(p_infolist)
+      if infolist
+        return Hash[ infolist.each_slice(2).to_a.map{|k,v| [k.to_sym, v]} ]
+      end
+    end
+
+  end
+
+  module C
+    extend FFI::Library
+
+    class ManagedOpaquePointer < FFI::AutoPointer
+      def initialize(pointer)
+        raise NoMethodError, "release() not implemented for class #{self}" unless self.class.respond_to? :release
+        raise ArgumentError, "Must supply a pointer to memory" unless pointer
+        super(pointer, self.class.method(:release))
+      end
+    end
+
+    #----------------------------------------------------------------------
+    ffi_lib FFI::Library::LIBC
+
+    # memory allocators
+    attach_function :malloc, [:size_t], :pointer
+    attach_function :calloc, [:size_t], :pointer
+    attach_function :valloc, [:size_t], :pointer
+    attach_function :realloc, [:pointer, :size_t], :pointer
+    attach_function :free, [:pointer], :void
+
+    # memory movers
+    attach_function :memcpy, [:pointer, :pointer, :size_t], :pointer
+    attach_function :bcopy, [:pointer, :pointer, :size_t], :void
+
+  end
+end
+

data/lib/idevice/diagnostics_relay.rb

@@ -0,0 +1,185 @@
+#
+# Copyright (c) 2013 Eric Monti - Bluebox Security
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+require 'idevice/c'
+require 'idevice/plist'
+require 'idevice/idevice'
+require 'idevice/lockdown'
+
+module Idevice
+  class DiagnosticsRelayError < IdeviceLibError
+  end
+
+  class DiagnosticsRelayClient < C::ManagedOpaquePointer
+    include LibHelpers
+
+    FLAG_WAIT_FOR_DISCONNECT = (1 << 1)
+    FLAG_DISPLAY_PASS        = (1 << 2)
+    FLAG_DISPLAY_FAIL        = (1 << 3)
+
+    REQUEST_TYPES = [
+      "All",
+      "HDMI",
+      "WiFi",
+      "GasGaugue",
+      "NAND",
+    ]
+
+    def self.release(ptr)
+      C.diagnostics_relay_client_free(ptr) unless ptr.null?
+    end
+
+
+    def self.attach(opts={})
+      # Note, we're not using LibHelpers#_attach_helper since we need to do the fallback to
+      # the old relay service name below
+
+      idevice = opts[:idevice] || Idevice.attach(opts)
+      ldsvc = opts[:lockdown_service]
+      unless ldsvc
+        ldclient = opts[:lockdown_client] || LockdownClient.attach(opts.merge(idevice:idevice))
+        ldsvc = begin
+                  ldclient.start_service("com.apple.mobile.diagnostics_relay")
+                rescue LockdownError
+                  # fall-back to old diagnostics relay service name
+                  ldclient.start_service("com.apple.iosdiagnostics.relay")
+                end
+      end
+
+      FFI::MemoryPointer.new(:pointer) do |p_drc|
+        err = C.diagnostics_relay_client_new(idevice, ldsvc, p_drc)
+        raise DiagnosticsRelayError, "Diagnostics Relay error: #{err}" if err != :SUCCESS
+        drc = p_drc.read_pointer
+        raise DiagnosticsRelayError, "diagnostics_relay_client_new returned a NULL diagnostics_relay_client_t pointer" if drc.null?
+        return new(drc)
+      end
+    end
+
+    def diagnostics(type="All")
+      FFI::MemoryPointer.new(:pointer) do |p_diags|
+        err = C.diagnostics_relay_request_diagnostics(self, type, p_diags)
+        raise DiagnosticsRelayError, "Diagnostics Relay error: #{err}" if err != :SUCCESS
+
+        diags = p_diags.read_pointer.read_plist_t
+        raise DiagnosticsRelayError, "diagnostics_relay_request_diagnostics returned null diagnostics" if diags.nil?
+        return diags
+      end
+    end
+
+    def mobilegestalt(*keys)
+      FFI::MemoryPointer.new(:pointer) do |p_result|
+        err = C.diagnostics_relay_query_mobilegestalt(self, Plist_t.from_ruby(keys), p_result)
+        raise DiagnosticsRelayError, "Diagnostics Relay error: #{err}" if err != :SUCCESS
+        result = p_result.read_pointer.read_plist_t
+        raise DiagnosticsRelayError, "diagnostics_relay_query_mobilegestalt returned a null result" if result.nil?
+        return result
+      end
+    end
+
+    def ioregistry_entry(name, klass)
+      FFI::MemoryPointer.new(:pointer) do |p_result|
+        err = C.diagnostics_relay_query_ioregistry_entry(self, name, klass, p_result)
+        raise DiagnosticsRelayError, "Diagnostics Relay error: #{err}" if err != :SUCCESS
+        result = p_result.read_pointer.read_plist_t
+        raise DiagnosticsRelayError, "diagnostics_relay_query_ioregistry_entry returned a null result" if result.nil?
+        return result
+      end
+    end
+
+    def ioregistry_plane(plane)
+      FFI::MemoryPointer.new(:pointer) do |p_result|
+        err = C.diagnostics_relay_query_ioregistry_plane(self, plane, p_result)
+        raise DiagnosticsRelayError, "Diagnostics Relay error: #{err}" if err != :SUCCESS
+        result = p_result.read_pointer.read_plist_t
+        raise DiagnosticsRelayError, "diagnostics_relay_query_ioregistry_plane returned a null result" if result.nil?
+        return result
+      end
+    end
+
+    def goodbye
+      err = C.diagnostics_relay_goodbye(self)
+      raise DiagnosticsRelayError, "Diagnostics Relay error: #{err}" if err != :SUCCESS
+      return true
+    end
+
+    def sleep
+      err = C.diagnostics_relay_sleep(self)
+      raise DiagnosticsRelayError, "Diagnostics Relay error: #{err}" if err != :SUCCESS
+      return true
+    end
+
+    def restart(flags=0)
+      err = C.diagnostics_relay_restart(self, flags)
+      raise DiagnosticsRelayError, "Diagnostics Relay error: #{err}" if err != :SUCCESS
+      return true
+    end
+
+    def shutdown(flags=0)
+      err = C.diagnostics_relay_shutdown(self, flags)
+      raise DiagnosticsRelayError, "Diagnostics Relay error: #{err}" if err != :SUCCESS
+      return true
+    end
+  end
+
+  module C
+    ffi_lib 'imobiledevice'
+
+    typedef enum(
+      :SUCCESS         ,     0,
+      :INVALID_ARG     ,    -1,
+      :PLIST_ERROR     ,    -2,
+      :MUX_ERROR       ,    -3,
+      :UNKNOWN_REQUEST ,    -4,
+      :UNKNOWN_ERROR   ,  -256,
+    ), :diagnostics_relay_error_t
+
+    #diagnostics_relay_error_t diagnostics_relay_client_new(idevice_t device, lockdownd_service_descriptor_t service, diagnostics_relay_client_t *client);
+    attach_function :diagnostics_relay_client_new, [Idevice, LockdownServiceDescriptor, :pointer], :diagnostics_relay_error_t
+
+    #diagnostics_relay_error_t diagnostics_relay_client_free(diagnostics_relay_client_t client);
+    attach_function :diagnostics_relay_client_free, [DiagnosticsRelayClient], :diagnostics_relay_error_t
+
+    #diagnostics_relay_error_t diagnostics_relay_goodbye(diagnostics_relay_client_t client);
+    attach_function :diagnostics_relay_goodbye, [DiagnosticsRelayClient], :diagnostics_relay_error_t
+
+    #diagnostics_relay_error_t diagnostics_relay_sleep(diagnostics_relay_client_t client);
+    attach_function :diagnostics_relay_sleep, [DiagnosticsRelayClient], :diagnostics_relay_error_t
+
+    #diagnostics_relay_error_t diagnostics_relay_restart(diagnostics_relay_client_t client, int flags);
+    attach_function :diagnostics_relay_restart, [DiagnosticsRelayClient, :int], :diagnostics_relay_error_t
+
+    #diagnostics_relay_error_t diagnostics_relay_shutdown(diagnostics_relay_client_t client, int flags);
+    attach_function :diagnostics_relay_shutdown, [DiagnosticsRelayClient, :int], :diagnostics_relay_error_t
+
+    #diagnostics_relay_error_t diagnostics_relay_request_diagnostics(diagnostics_relay_client_t client, const char* type, plist_t* diagnostics);
+    attach_function :diagnostics_relay_request_diagnostics, [DiagnosticsRelayClient, :string, :pointer], :diagnostics_relay_error_t
+
+    #diagnostics_relay_error_t diagnostics_relay_query_mobilegestalt(diagnostics_relay_client_t client, plist_t keys, plist_t* result);
+    attach_function :diagnostics_relay_query_mobilegestalt, [DiagnosticsRelayClient, Plist_t, :pointer], :diagnostics_relay_error_t
+
+    #diagnostics_relay_error_t diagnostics_relay_query_ioregistry_entry(diagnostics_relay_client_t client, const char* name, const char* class, plist_t* result);
+    attach_function :diagnostics_relay_query_ioregistry_entry, [DiagnosticsRelayClient, :string, :string, :pointer], :diagnostics_relay_error_t
+
+    #diagnostics_relay_error_t diagnostics_relay_query_ioregistry_plane(diagnostics_relay_client_t client, const char* plane, plist_t* result);
+    attach_function :diagnostics_relay_query_ioregistry_plane, [DiagnosticsRelayClient, :string, :pointer], :diagnostics_relay_error_t
+
+
+  end
+end

data/lib/idevice/file_relay.rb

@@ -0,0 +1,83 @@
+#
+# Copyright (c) 2013 Eric Monti - Bluebox Security
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+require 'idevice/c'
+require 'idevice/idevice'
+require 'idevice/lockdown'
+
+module Idevice
+  class FileRelayError < IdeviceLibError
+  end
+
+  class FileRelayClient < C::ManagedOpaquePointer
+    include LibHelpers
+    def self.release(ptr)
+      C.file_relay_client_free(ptr) unless ptr.null?
+    end
+
+    def self.attach(opts={})
+      _attach_helper("com.apple.mobile.file_relay", opts) do |idevice,ldsvc,p_frc|
+        err = C.file_relay_client_new(idevice, ldsvc, p_frc)
+        raise FileRelayError, "File Relay error: #{err}" if err != :SUCCESS
+        frc = p_frc.read_pointer
+        raise FileRelayError, "file_relay_client_new returned a NULL client" if frc.null?
+        return new(frc)
+      end
+    end
+
+    def request_sources(*sources, &block)
+      FFI::MemoryPointer.null_terminated_array_of_strings(sources) do |p_sources|
+        FFI::MemoryPointer.new(:pointer) do |p_conn|
+          err = C.file_relay_request_sources(self, p_sources, p_conn)
+          raise FileRelayError, "File Relay error: #{err}" if err != :SUCCESS
+          conn = p_conn.read_pointer
+          raise FileRelayError, "file_relay_request_sources returned a NULL connection" if conn.null?
+          iconn = IdeviceConnection.new(conn)
+          ret = iconn.receive_all(nil, &block)
+          return ret
+        end
+      end
+    end
+  end
+
+  module C
+    ffi_lib 'imobiledevice'
+
+    typedef enum(
+      :SUCCESS        ,       0,
+      :INVALID_ARG    ,      -1,
+      :PLIST_ERROR    ,      -2,
+      :MUX_ERROR      ,      -3,
+      :INVALID_SOURCE ,      -4,
+      :STAGING_EMPTY  ,      -5,
+      :UNKNOWN_ERROR  ,    -256,
+    ), :file_relay_error_t
+
+    #file_relay_error_t file_relay_client_new(idevice_t device, lockdownd_service_descriptor_t service, file_relay_client_t *client);
+    attach_function :file_relay_client_new, [Idevice, LockdownServiceDescriptor, :pointer], :file_relay_error_t
+
+    #file_relay_error_t file_relay_client_free(file_relay_client_t client);
+    attach_function :file_relay_client_free, [FileRelayClient], :file_relay_error_t
+
+    #file_relay_error_t file_relay_request_sources(file_relay_client_t client, const char **sources, idevice_connection_t *connection);
+    attach_function :file_relay_request_sources, [FileRelayClient, :pointer, :pointer], :file_relay_error_t
+
+  end
+end

data/lib/idevice/heartbeat.rb

@@ -0,0 +1,99 @@
+#
+# Copyright (c) 2013 Eric Monti - Bluebox Security
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+require 'idevice/c'
+require 'idevice/plist'
+require 'idevice/idevice'
+require 'idevice/lockdown'
+
+module Idevice
+  class HeartbeatError < IdeviceLibError
+  end
+
+  class HeartbeatClient < C::ManagedOpaquePointer
+    include LibHelpers
+
+    def self.release(ptr)
+      C.heartbeat_client_free(ptr) unless ptr.null?
+    end
+
+    def self.attach(opts={})
+      _attach_helper("com.apple.mobile.heartbeat", opts) do |idevice, ldsvc, p_hb|
+        err=C.heartbeat_client_new(idevice, ldsvc, p_hb)
+        raise HeartbeatError, "Heartbeat error: #{err}" if err != :SUCCESS
+        hb = p_hb.read_pointer
+        raise HeartbeatError, "hearbeat_client_new returned a NULL client" if hb.null?
+        return new(hb)
+      end
+    end
+
+    def send_plist(obj)
+      err = C.heartbeat_send(self, obj.to_plist_t)
+      raise HeartbeatError, "Heartbeat error: #{err}" if err != :SUCCESS
+      return true
+    end
+
+    def receive_plist(timeout=nil)
+      timeout ||= 1
+
+      FFI::MemoryPointer.new(:pointer) do |p_plist|
+        err = C.heartbeat_receive_with_timeout(self, p_plist, timeout)
+        raise HeartbeatError, "Heartbeat error: #{err}" if err != :SUCCESS
+        plist = p_plist.read_pointer
+        raise HeartbeatError, "hearbeat_receive returned a NULL plist" if plist.null?
+        return Plist.new(plist).to_ruby
+      end
+    end
+
+  end
+
+  module C
+    ffi_lib 'imobiledevice'
+
+    typedef enum(
+      :SUCCESS      ,         0,
+      :INVALID_ARG  ,        -1,
+      :PLIST_ERROR  ,        -2,
+      :MUX_ERROR    ,        -3,
+      :SSL_ERROR    ,        -4,
+      :UNKNOWN_ERROR,      -256,
+    ), :heartbeat_error_t
+
+
+    #heartbeat_error_t heartbeat_client_new(idevice_t device, lockdownd_service_descriptor_t service, heartbeat_client_t * client);
+    attach_function :heartbeat_client_new, [Idevice, LockdownServiceDescriptor, :pointer], :heartbeat_error_t
+
+    #heartbeat_error_t heartbeat_client_start_service(idevice_t device, heartbeat_client_t * client, const char* label);
+    attach_function :heartbeat_client_start_service, [Idevice, :pointer, :string], :heartbeat_error_t
+
+    #heartbeat_error_t heartbeat_client_free(heartbeat_client_t client);
+    attach_function :heartbeat_client_free, [HeartbeatClient], :heartbeat_error_t
+
+    #heartbeat_error_t heartbeat_send(heartbeat_client_t client, plist_t plist);
+    attach_function :heartbeat_send, [HeartbeatClient, Plist_t], :heartbeat_error_t
+
+    #heartbeat_error_t heartbeat_receive(heartbeat_client_t client, plist_t * plist);
+    attach_function :heartbeat_receive, [HeartbeatClient, :pointer], :heartbeat_error_t
+
+    #heartbeat_error_t heartbeat_receive_with_timeout(heartbeat_client_t client, plist_t * plist, uint32_t timeout_ms);
+    attach_function :heartbeat_receive_with_timeout, [HeartbeatClient, :pointer, :uint32], :heartbeat_error_t
+
+  end
+end