idevice 1.1.5.0

data/lib/idevice/house_arrest.rb

@@ -0,0 +1,138 @@
+#
+# 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'
+require 'idevice/plist'
+
+module Idevice
+  class HouseArrestError < IdeviceLibError
+  end
+
+  class HouseArrestClient < C::ManagedOpaquePointer
+    include LibHelpers
+
+    def self.release(ptr)
+      C.house_arrest_client_free(ptr) unless ptr.null?
+    end
+
+    def self.attach(opts={})
+      _attach_helper("com.apple.mobile.house_arrest", opts) do |idevice, ldsvc, p_ha|
+        err = C.house_arrest_client_new(idevice, ldsvc, p_ha)
+        raise HouseArrestError, "house_arrest error: #{err}" if err != :SUCCESS
+        ha = p_ha.read_pointer
+        raise HouseArrestError, "house_arrest_client_new returned a NULL house_arrest_client_t pointer" if ha.null?
+        return new(ha)
+      end
+    end
+
+    def send_request(dict)
+      err = C.house_arrest_send_request(self, dict.to_plist_t)
+      raise HouseArrestError, "house_arrest error: #{err}" if err != :SUCCESS
+      return true
+    end
+
+    def send_command(command, appid)
+      err = C.house_arrest_send_command(self, command, appid)
+      raise HouseArrestError, "house_arrest error: #{err}" if err != :SUCCESS
+      return true
+    end
+
+    def get_result
+      FFI::MemoryPointer.new(:pointer) do |p_result|
+        err = C.house_arrest_get_result(self, p_result)
+        raise HouseArrestError, "house_arrest error: #{err}" if err != :SUCCESS
+        result = p_result.read_pointer.read_plist_t
+        raise HouseArrestError, "house_arrest_get_result returned a null plist_t" if result.nil?
+        return result
+      end
+    end
+
+    def vend_container(appid)
+      send_command("VendContainer", appid)
+      res = get_result
+      if res["Error"]
+        raise HouseArrestError, "Error vending container to appid: #{appid} - #{res.inspect}"
+      end
+    end
+
+    def vend_documents(appid)
+      send_command("VendDocuments", appid)
+      res = get_result
+      if res["Error"]
+        raise HouseArrestError, "Error vending documents to appid: #{appid} - #{res.inspect}"
+      end
+    end
+
+    def afc_client
+      FFI::MemoryPointer.new(:pointer) do |p_afc|
+        err = C.afc_client_new_from_house_arrest_client(self, p_afc)
+        raise AFCError, "AFC Error: #{err}" if err != :SUCCESS
+        afc = p_afc.read_pointer
+        raise AFCError, "afc_client_new_from_house_arrest_client returned a NULL afc_client_t pointer" if afc.null?
+        cli =  AFCClient.new(afc)
+
+        # save a reference to ourselves in the afc client to avoid premature garbage collection...
+        cli.instance_variable_set(:@house_arrest, self)
+        return cli
+      end
+    end
+
+    def afc_client_for_container(appid)
+      vend_container(appid)
+      return afc_client
+    end
+
+    def afc_client_for_documents(appid)
+      vend_documents(appid)
+      return afc_client
+    end
+  end
+
+  module C
+    ffi_lib 'imobiledevice'
+
+    typedef enum(
+      :SUCCESS          ,     0,
+      :INVALID_ARG      ,    -1,
+      :PLIST_ERROR      ,    -2,
+      :CONN_FAILED      ,    -3,
+      :INVALID_MODE     ,    -4,
+      :UNKNOWN_ERROR    ,  -256,
+    ), :house_arrest_error_t
+
+    #house_arrest_error_t house_arrest_client_new(idevice_t device, lockdownd_service_descriptor_t service, house_arrest_client_t *client);
+    attach_function :house_arrest_client_new, [Idevice, LockdownServiceDescriptor, :pointer], :house_arrest_error_t
+
+    #house_arrest_error_t house_arrest_client_free(house_arrest_client_t client);
+    attach_function :house_arrest_client_free, [HouseArrestClient], :house_arrest_error_t
+
+    #house_arrest_error_t house_arrest_send_request(house_arrest_client_t client, plist_t dict);
+    attach_function :house_arrest_send_request, [HouseArrestClient, Plist_t], :house_arrest_error_t
+
+    #house_arrest_error_t house_arrest_send_command(house_arrest_client_t client, const char *command, const char *appid);
+    attach_function :house_arrest_send_command, [HouseArrestClient, :string, :string], :house_arrest_error_t
+
+    #house_arrest_error_t house_arrest_get_result(house_arrest_client_t client, plist_t *dict);
+    attach_function :house_arrest_get_result, [HouseArrestClient, :pointer], :house_arrest_error_t
+
+  end
+end

data/lib/idevice/idevice.rb

@@ -0,0 +1,208 @@
+#
+# 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 'ffi'
+require 'idevice/c'
+require 'stringio'
+
+module Idevice
+  class IdeviceLibError < StandardError
+  end
+
+  class Idevice < C::ManagedOpaquePointer
+    def self.release(ptr)
+      C.idevice_free(ptr) unless ptr.null?
+    end
+
+    # Use this instead of 'new' to attach to an idevice using libimobiledevice
+    # and instantiate a new idevice_t handle
+    def self.attach(opts={})
+      @udid = opts[:udid]
+
+      FFI::MemoryPointer.new(:pointer) do |tmpptr|
+        err = C.idevice_new(tmpptr, @udid)
+        raise IdeviceLibError, "Idevice error: #{err}" if err != :SUCCESS
+
+        idevice_t = tmpptr.read_pointer
+        if idevice_t.null?
+          raise IdeviceLibError, "idevice_new created a null pointer"
+        else
+          return new(tmpptr.read_pointer)
+        end
+      end
+    end
+
+    def udid
+      return @udid if @udid
+
+      @udid = nil
+      FFI::MemoryPointer.new(:pointer) do |udid_ptr|
+        err = C.idevice_get_udid(self, udid_ptr)
+        raise IdeviceLibError, "Idevice error: #{err}" if err != :SUCCESS
+        unless udid_ptr.read_pointer.null?
+          @udid = udid_ptr.read_pointer.read_string
+          C.free(udid_ptr.read_pointer)
+        end
+      end
+      return @udid
+    end
+
+    def handle
+      @handle = nil
+      FFI::MemoryPointer.new(:uint32) do |tmpptr|
+        err = C.idevice_get_handle(self, tmpptr)
+        raise IdeviceLibError, "Idevice error: #{err}" if err != :SUCCESS
+        return tmpptr.read_uint32
+      end
+    end
+
+    def connect port
+      IdeviceConnection.connect(self, port)
+    end
+  end
+
+  class IdeviceConnection < C::ManagedOpaquePointer
+    def self.release(ptr)
+      C.idevice_disconnect(ptr) unless ptr.null? or ptr.disconnected?
+    end
+
+    def self.connect(idevice, port)
+      FFI::MemoryPointer.new(:pointer) do |tmpptr|
+        err = C.idevice_connect(idevice, port, tmpptr)
+        raise IdeviceLibError, "Idevice error: #{err}" if err != :SUCCESS
+        idev_connection = tmpptr.read_pointer
+        if idev_connection.null?
+          raise IdeviceLibError, "idevice_connect returned a null idevice_connection_t"
+        else
+          return new(idev_connection)
+        end
+      end
+    end
+
+    def disconnect
+      err = C.idevice_disconnect(self)
+      raise IdeviceLibError, "Idevice error: #{err}" if err != :SUCCESS
+      @_disconnected = true
+      nil
+    end
+
+    def connected?
+      not disconnected?
+    end
+
+    def disconnected?
+      @_disconnected == true
+    end
+
+    def send_data(data)
+      FFI::MemoryPointer.from_bytes(data) do |data_ptr|
+        FFI::MemoryPointer.new(:uint32) do |sent_bytes|
+          begin
+            err = C.idevice_connection_send(self, data_ptr, data_ptr.size, sent_bytes)
+            raise IdeviceLibError, "Idevice error: #{err}" if err != :SUCCESS
+            sent = sent_bytes.read_uint32
+            break if sent == 0
+            data_ptr += sent
+          end while data_ptr.size > 0
+        end
+      end
+      return
+    end
+
+    DEFAULT_RECV_TIMEOUT = 0
+    DEFAULT_RECV_CHUNKSZ = 8192
+    # blocking read - optionally yields to a block with each chunk read
+    def receive_all(timeout=nil, chunksz=nil)
+      timeout ||= DEFAULT_RECV_TIMEOUT
+      chunksz ||= DEFAULT_RECV_CHUNKSZ
+      recvdata = StringIO.new unless block_given?
+
+      FFI::MemoryPointer.new(chunksz) do |data_ptr|
+        FFI::MemoryPointer.new(:uint32) do |recv_bytes|
+          while (ierr=C.idevice_connection_receive_timeout(self, data_ptr, data_ptr.size, recv_bytes, timeout)) == :SUCCESS
+            chunk = data_ptr.read_bytes(recv_bytes.read_uint32) 
+            if block_given?
+              yield chunk
+            else
+              recvdata << chunk
+            end
+          end
+
+          # UNKNOWN_ERROR seems to indicate end of data/connection
+          raise IdeviceLibError, "Idevice error: #{ierr}" if ierr != :UNKNOWN_ERROR
+        end
+      end
+
+      return recvdata.string unless block_given?
+    end
+
+    # read up to maxlen bytes
+    def receive_data(maxlen, timeout=nil)
+      timeout ||= DEFAULT_RECV_TIMEOUT
+      recvdata = StringIO.new
+
+      FFI::MemoryPointer.new(maxlen) do |data_ptr|
+        FFI::MemoryPointer.new(:uint32) do |recv_bytes|
+          # one-shot, read up to max-len and we're done
+          err = C.idevice_connection_receive_timeout(self, data_ptr, data_ptr.size, recv_bytes, timeout)
+          raise IdeviceLibError, "Idevice error: #{err}" if err != :SUCCESS
+          recvdata << data_ptr.read_bytes(recv_bytes.read_uint32)
+        end
+      end
+      return recvdata.string
+    end
+  end
+
+  module C
+    ffi_lib 'imobiledevice'
+
+    typedef enum(
+      :SUCCESS,               0,
+      :INVALID_ARG,          -1,
+      :UNKNOWN_ERROR,        -2,
+      :NO_DEVICE,            -3,
+      :NOT_ENOUGH_DATA,      -4,
+      :BAD_HEADER,           -5,
+      :SSL_ERROR,            -6,
+    ), :idevice_error_t
+
+    # discovery (synchronous)
+    attach_function :idevice_set_debug_level, [:int], :void
+    attach_function :idevice_get_device_list, [:pointer, :pointer], :idevice_error_t
+    attach_function :idevice_device_list_free, [:pointer], :idevice_error_t
+
+    # device structure creation and destruction
+    attach_function :idevice_new, [:pointer, :string], :idevice_error_t
+    attach_function :idevice_free, [:pointer], :idevice_error_t
+
+    # connection/disconnection
+    attach_function :idevice_connect, [Idevice, :uint16, :pointer], :idevice_error_t
+    attach_function :idevice_disconnect, [IdeviceConnection], :idevice_error_t
+
+    # communication
+    attach_function :idevice_connection_send, [IdeviceConnection, :pointer, :uint32, :pointer], :idevice_error_t
+    attach_function :idevice_connection_receive_timeout, [IdeviceConnection, :pointer, :uint32, :pointer, :uint], :idevice_error_t
+    attach_function :idevice_connection_receive, [IdeviceConnection, :pointer, :uint32, :pointer], :idevice_error_t
+
+    # misc
+    attach_function :idevice_get_handle, [Idevice, :pointer], :idevice_error_t
+    attach_function :idevice_get_udid, [Idevice, :pointer], :idevice_error_t
+  end
+end

data/lib/idevice/image_mounter.rb

@@ -0,0 +1,117 @@
+#
+# 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 ImageMounterError < IdeviceLibError
+  end
+
+  # Used to mount developer/debug disk images on the device.
+  class ImageMounterClient < C::ManagedOpaquePointer
+    include LibHelpers
+
+    def self.release(ptr)
+      C.mobile_image_mounter_free(ptr) unless ptr.null?
+    end
+
+    def self.attach(opts={})
+      _attach_helper("com.apple.mobile.mobile_image_mounter", opts) do |idevice, ldsvc, p_mim|
+        err = C.mobile_image_mounter_new(idevice, ldsvc, p_mim)
+        raise ImageMounterError, "ImageMounter error: #{err}" if err != :SUCCESS
+
+        mim = p_mim.read_pointer
+        raise ImageMounterError, "mobile_image_mounter_new returned a NULL client" if mim.null?
+        return new(mim)
+      end
+    end
+
+    def is_mounted?(image_type="Developer")
+      ret = lookup_image(image_type)
+      return (ret["ImagePresent"] == true)
+    end
+
+    def lookup_image(image_type="Developer")
+      FFI::MemoryPointer.new(:pointer) do |p_result|
+        err = C.mobile_image_mounter_lookup_image(self, image_type, p_result)
+        raise ImageMounterError, "ImageMounter error: #{err}" if err != :SUCCESS
+
+        result = p_result.read_pointer.read_plist_t
+        raise ImageMounterError, "mobile_image_mounter_lookup_image returned a NULL result" if result.nil?
+
+        return result
+      end
+    end
+
+    def mount_image(path, signature, image_type="Developer")
+      signature = signature.dup.force_encoding('binary')
+      FFI::MemoryPointer.from_bytes(signature) do |p_signature|
+        FFI::MemoryPointer.new(:pointer) do |p_result|
+          err = C.mobile_image_mounter_mount_image(self, path, p_signature, p_signature.size, image_type, p_result)
+          raise ImageMounterError, "ImageMounter error: #{err}" if err != :SUCCESS
+
+          result = p_result.read_pointer.read_plist_t
+          raise ImageMounterError, "mobile_image_mounter_mount_image returned a NULL result" if result.nil?
+
+          return result
+        end
+      end
+    end
+
+    def hangup
+      err = C.mobile_image_mounter_hangup(self)
+      raise ImageMounterError, "ImageMounter error: #{err}" if err != :SUCCESS
+
+      return true
+    end
+  end
+
+  module C
+    ffi_lib 'imobiledevice'
+
+    typedef enum(
+      :SUCCESS      ,          0,
+      :INVALID_ARG  ,         -1,
+      :PLIST_ERROR  ,         -2,
+      :CONN_FAILED  ,         -3,
+      :UNKNOWN_ERROR,       -256,
+    ), :image_mounter_error_t
+
+    #mobile_image_mounter_error_t mobile_image_mounter_new(idevice_t device, lockdownd_service_descriptor_t service, mobile_image_mounter_client_t *client);
+    attach_function :mobile_image_mounter_new, [Idevice, LockdownServiceDescriptor, :pointer], :image_mounter_error_t
+
+    #mobile_image_mounter_error_t mobile_image_mounter_free(mobile_image_mounter_client_t client);
+    attach_function :mobile_image_mounter_free, [ImageMounterClient], :image_mounter_error_t
+
+    #mobile_image_mounter_error_t mobile_image_mounter_lookup_image(mobile_image_mounter_client_t client, const char *image_type, plist_t *result);
+    attach_function :mobile_image_mounter_lookup_image, [ImageMounterClient, :string, :pointer], :image_mounter_error_t
+
+    #mobile_image_mounter_error_t mobile_image_mounter_mount_image(mobile_image_mounter_client_t client, const char *image_path, const char *image_signature, uint16_t signature_length, const char *image_type, plist_t *result);
+    attach_function :mobile_image_mounter_mount_image, [ImageMounterClient, :string, :pointer, :uint16, :string, :pointer], :image_mounter_error_t
+
+    #mobile_image_mounter_error_t mobile_image_mounter_hangup(mobile_image_mounter_client_t client);
+    attach_function :mobile_image_mounter_hangup, [ImageMounterClient], :image_mounter_error_t
+
+  end
+end