hap_client 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1563b1509e5f1e6f88c06ecdf588fdd43c75dddb82e3b3dbeb1090d4bcc9146b
+  data.tar.gz: e6968e093e0b00a77e4c046783dfecaa86aeefe2f10a5ecd224000e99d48cb33
+SHA512:
+  metadata.gz: 017ca3ba5512e19e51ddc1031f5f478d1cf40bf564593a06ddc0dded6cc25156ab6c9c2e0d53a38a11956b47118c427c285669767467ee7617faaa6af613c7b5
+  data.tar.gz: 7ede4a9834f3d7e1fe4f66b2bd3ec9c83b4e9ff332a7fd82e415f3ee89a41e72e77fdb04efda19f73d52edb0b8415cac7c7b0129a85909d9eb93e08fdf3a06f1

data/.gitignore

@@ -0,0 +1,55 @@
+*.gem
+*.rbc
+Gemfile.lock
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+.ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+# Emacs
+*~
+.#*

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.5.1

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Seluxit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,2 @@
+# hap_client
+Ruby Gem for Apple Homekit Client

data/Rakefile

@@ -0,0 +1,11 @@
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+require "hap_client/version"
+
+task :build do
+  system "gem build hap_client.gemspec"
+end
+
+task :release => :build do
+  system "gem push hap_client-#{HapClient::VERSION}.gem"
+  system "rm hap_client-#{HapClient::VERSION}.gem"
+end

data/hap_client.gemspec

@@ -0,0 +1,29 @@
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'hap_client/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'hap_client'
+  s.version     = HapClient::VERSION
+  s.date        = '2018-06-15'
+  s.summary     = "HAP client"
+  s.description = "Ruby Gem for Apple Homekit Client"
+  s.authors     = ["Andreas Bomholtz"]
+  s.email       = 'andreas@seluxit.com'
+  s.files       = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  s.homepage    = 'http://github.com/Seluxit/hap_client'
+  s.license     = 'MIT'
+
+  s.add_dependency "eventmachine", '~> 1.2'
+  s.add_dependency "http_parser.rb", '~> 0.6'
+  s.add_dependency "json", '~> 2.1'
+  s.add_dependency 'ruby_home', '0.1.2'
+  s.add_dependency "ruby_home-srp", '1.2.0'
+
+  s.add_development_dependency 'bundler', '~> 1.16'
+  s.add_development_dependency 'rake', '~> 12.3'
+  s.add_development_dependency 'rspec', '~> 3.0'
+end

data/lib/hap_client/encryption_request.rb

@@ -0,0 +1,71 @@
+module HAP
+  module EncryptionRequest
+    AAD_LENGTH_BYTES = 2
+    AUTHENTICATE_TAG_LENGTH_BYTES = 16
+
+    attr_reader :encryption_count, :decryption_count
+
+    def encryption_ready?()
+      return !@controller_to_accessory_key.nil?
+    end
+
+    private
+
+    def encrypt(data)
+      @encryption_count ||= 0
+
+      data.chars.each_slice(1024).map(&:join).map do |message|
+        additional_data = [message.length].pack('v')
+
+        chacha20poly1305ietf = RubyHome::HAP::Crypto::ChaCha20Poly1305.new(@controller_to_accessory_key)
+        encrypted_data = chacha20poly1305ietf.encrypt(encryption_nonce, message, additional_data)
+        increment_encryption_count!
+
+        [additional_data, encrypted_data].join
+      end
+    end
+
+    def decrypt(data)
+      @decryption_count ||= 0
+      decrypted_data = []
+      read_pointer = 0
+
+      while read_pointer < data.length
+        little_endian_length_of_encrypted_data = data[read_pointer...read_pointer+AAD_LENGTH_BYTES]
+        length_of_encrypted_data = little_endian_length_of_encrypted_data.unpack('v').first
+        read_pointer += AAD_LENGTH_BYTES
+
+        message = data[read_pointer...read_pointer+length_of_encrypted_data]
+        read_pointer += length_of_encrypted_data
+
+        auth_tag = data[read_pointer...read_pointer+AUTHENTICATE_TAG_LENGTH_BYTES]
+        read_pointer += AUTHENTICATE_TAG_LENGTH_BYTES
+
+        ciphertext = message + auth_tag
+        additional_data = little_endian_length_of_encrypted_data
+        chacha20poly1305ietf = RubyHome::HAP::Crypto::ChaCha20Poly1305.new(@accessory_to_controller_key)
+        decrypted_data << chacha20poly1305ietf.decrypt(decryption_nonce, ciphertext, additional_data)
+
+        increment_decryption_count!
+      end
+
+      decrypted_data.join
+    end
+
+    def increment_encryption_count!
+      @encryption_count += 1
+    end
+
+    def encryption_nonce
+      RubyHome::HAP::HexPad.pad([encryption_count].pack('Q<'))
+    end
+
+    def increment_decryption_count!
+      @decryption_count += 1
+    end
+
+    def decryption_nonce
+      RubyHome::HAP::HexPad.pad([decryption_count].pack('Q<'))
+    end
+  end
+end

data/lib/hap_client/log.rb

@@ -0,0 +1,40 @@
+require 'logger'
+
+module HAP
+  module Log
+    LOG_LVL = ENV['DEBUG'] ? :debug : :info
+
+    def init_log()
+      @log = Logger.new(STDOUT,
+                        level: LOG_LVL,
+                        progname: self,
+                        formatter: proc {|severity, datetime, progname, msg|
+                          "[#{datetime}][#{progname}] #{severity}: #{msg}\n"
+                        })
+    end
+
+    def fatal(msg)
+      @log.fatal(msg)
+    end
+
+    def error(msg)
+      @log.error(msg)
+    end
+
+    def warn(msg)
+      @log.warn(msg)
+    end
+
+    def info(msg)
+      @log.info(msg)
+    end
+
+    def debug(msg)
+      @log.debug(msg)
+    end
+
+    def log_debug?
+      @log.debug?
+    end
+  end
+end

data/lib/hap_client/pairing.rb

@@ -0,0 +1,379 @@
+require 'ruby_home/device_id'
+require 'ruby_home/hap/tlv'
+require 'ruby_home/hap/hex_pad'
+require 'ruby_home/hap/crypto/chacha20poly1305'
+require 'hkdf'
+require 'ruby_home/hap/crypto/hkdf'
+require 'ruby_home-srp'
+require 'ed25519'
+require 'x25519'
+
+class PairingError < StandardError
+end
+
+module HAP
+  module Pairing
+    ERROR_NAMES = {
+      1 => 'kTLVError_Unknown',
+      2 => 'kTLVError_Authentication',
+      3 => 'kTLVError_Backoff',
+      4 => 'kTLVError_MaxPeers',
+      5 => 'kTLVError_MaxTries',
+      6 => 'kTLVError_Unavailable',
+      7 => 'kTLVError_Busy',
+    }.freeze
+    ERROR_TYPES = ERROR_NAMES.invert.freeze
+
+    def pair_setup(password, &block)
+      info("Pair Setup Step 1/3")
+      @mode = :pair_setup
+      @password = password
+      srp_start_request()
+
+      if block_given?
+        @pair_setup_callback = block
+      end
+    end
+
+    def pair_verify(&block)
+      info("Pair Verify 1/2")
+      @mode = :pair_verify
+      verify_start_request()
+
+      if block_given?
+        @pair_verify_callback = block
+      end
+    end
+
+    private
+
+    def pair_setup_parse(data)
+      begin
+        response = check_tlv_response(data)
+
+        case response['kTLVType_State']
+        when 2
+          info("Pair Setup Step 2/3")
+          srp_verify_request(response, @password)
+        when 4
+          srp_verify(response)
+
+          info("Pair Setup Step 3/3")
+          srp_exchange_request()
+        when 6
+          info("Verifying Server Exchange")
+          srp_exchange_verify(response)
+
+          call_pair_setup_callback(true)
+        else
+          error("Unknown Pair Setup State: #{response['kTLVType_State']}")
+        end
+      rescue PairingError => e
+        error("Pair Setup Error: #{e}")
+        call_pair_setup_callback(false, e.to_s)
+      end
+    end
+
+    def call_pair_setup_callback(status, data=nil)
+      if @pair_setup_callback
+        t = @pair_setup_callback
+        @pair_setup_callback = nil
+        t.call(status, data)
+      end
+    end
+
+    def srp_start_request()
+      debug("Pair Setup SRP Start Request")
+      data = RubyHome::HAP::TLV.encode({
+                                         'kTLVType_State' => 0x01,
+                                         'kTLVType_Method' => 0x00
+                                       })
+      post("/pair-setup", "application/pairing+tlv8", data)
+    end
+
+    def srp_verify_request(response, password)
+      debug("Pair Setup SRP Verify Request")
+
+      username = 'Pair-Setup'
+      debug("Using #{password} to pair with device")
+
+      # convert bin variables to hex strings
+      salt = bin_to_hex(response["kTLVType_Salt"])
+      serverPublicKey = bin_to_hex(response["kTLVType_PublicKey"])
+
+      debug("Generating Client Public/Private Keys")
+      @srp_client = RubyHome::SRP::Client.new(3072)
+      clientPublicKey = hex_to_bin(@srp_client.start_authentication())
+
+      debug("Process Challenge from Server")
+      client_M = hex_to_bin(@srp_client.process_challenge(username, password, salt, serverPublicKey))
+
+      debug("Send Client Proof to Server")
+      data = RubyHome::HAP::TLV.encode({
+                                         'kTLVType_Proof' => client_M,
+                                         'kTLVType_PublicKey' => clientPublicKey,
+                                         'kTLVType_State' => 3,
+                                         'kTLVType_Method' => 0
+                                       })
+
+      # Save session key
+      @srp_session_key = @srp_client.K
+
+      post("/pair-setup", "application/pairing+tlv8", data)
+    end
+
+    def srp_verify(response)
+      debug("Verifying Server Proof")
+      serverProof = bin_to_hex(response['kTLVType_Proof'])
+
+      unless @srp_client.verify(serverProof)
+        raise PairingError, "Failed to verify server proof"
+      end
+
+      @srp_client = nil
+    end
+
+    def srp_exchange_request()
+      debug("Pair Setup SRP Exchange Request")
+
+      debug("Generate Longterm key")
+      @signature_key = Ed25519::SigningKey.generate.to_bytes.unpack1('H*')
+      @signing_key = Ed25519::SigningKey.new([@signature_key].pack('H*'))
+
+      debug("Generating device id")
+      @client_id = RubyHome::DeviceID.generate()
+
+      debug("Generating Encryption key")
+      hkdf = RubyHome::HAP::Crypto::HKDF.new(info: 'Pair-Setup-Encrypt-Info', salt: 'Pair-Setup-Encrypt-Salt')
+      key = hkdf.encrypt(@srp_session_key)
+      @chacha20poly1305ietf = RubyHome::HAP::Crypto::ChaCha20Poly1305.new(key)
+
+      debug("Generating ClientX")
+      hkdf = RubyHome::HAP::Crypto::HKDF.new(info: 'Pair-Setup-Controller-Sign-Info', salt: 'Pair-Setup-Controller-Sign-Salt')
+      clientX = hkdf.encrypt(@srp_session_key)
+
+      debug("Generating ClientInfo")
+      clientLTPK = @signing_key.verify_key.to_bytes
+      clientInfo = [
+        clientX.unpack1('H*'),
+        @client_id.unpack1('H*'),
+        clientLTPK.unpack1('H*')
+      ].join
+
+      debug("Generating Client Signature")
+      clientSignature = @signing_key.sign([clientInfo].pack('H*'))
+
+      debug("Generating Encrypted Data")
+      subtlv = RubyHome::HAP::TLV.encode({
+                                           'kTLVType_Identifier' => @client_id,
+                                           'kTLVType_PublicKey' => clientLTPK,
+                                           'kTLVType_Signature' => clientSignature
+                                         })
+      nonce = RubyHome::HAP::HexPad.pad('PS-Msg05')
+      encrypted_data = @chacha20poly1305ietf.encrypt(nonce, subtlv)
+
+      debug("Sending Encrypted Request to Server")
+      data = RubyHome::HAP::TLV.encode({
+                                         'kTLVType_State' => 5,
+                                         'kTLVType_EncryptedData' => encrypted_data
+                                       })
+      post("/pair-setup", "application/pairing+tlv8", data)
+    end
+
+    def srp_exchange_verify(response)
+      debug("Decrypting Server Response")
+      encrypted_data = response['kTLVType_EncryptedData']
+      nonce = RubyHome::HAP::HexPad.pad('PS-Msg06')
+
+      decrypted_data = @chacha20poly1305ietf.decrypt(nonce, encrypted_data)
+      unpacked_decrypted_data = RubyHome::HAP::TLV.read(decrypted_data)
+      @chacha20poly1305ietf = nil
+
+      debug("Verifying Server Signature")
+      @serverPairingId = unpacked_decrypted_data['kTLVType_Identifier']
+      serverSignature = unpacked_decrypted_data['kTLVType_Signature']
+      @accessoryltpk = unpacked_decrypted_data['kTLVType_PublicKey']
+
+      hkdf = RubyHome::HAP::Crypto::HKDF.new(info: 'Pair-Setup-Accessory-Sign-Info', salt: 'Pair-Setup-Accessory-Sign-Salt')
+      accessoryx = hkdf.encrypt(@srp_session_key)
+
+      accessoryinfo = [
+        accessoryx.unpack1('H*'),
+        @serverPairingId.unpack1('H*'),
+        @accessoryltpk.unpack1('H*')
+      ].join
+      verify_key = RbNaCl::Signatures::Ed25519::VerifyKey.new(@accessoryltpk)
+
+      begin
+        if verify_key.verify(serverSignature, [accessoryinfo].pack('H*'))
+          info("Pairing Success! Server Pairing ID: #{@serverPairingId}")
+        else
+          error("Failed to verify Server Signature")
+          raise PairingError, "Failed to verify Server Signature"
+        end
+      rescue RbNaCl::BadSignatureError
+        error("Failed to verify Server Signature")
+        raise PairingError, "Failed to verify Server Signature"
+      end
+    end
+
+    def pair_verify_parse(data)
+      begin
+        response = check_tlv_response(data)
+
+        case response['kTLVType_State']
+        when 2
+          info("Pair Verify 2/2")
+          verify_finish_request(response)
+        when 4
+          verify_finish_verify()
+          @mode = :paired
+
+          call_pair_verify_callback(true)
+        else
+          error("Unknown Pair Verify State: #{response['kTLVType_State']}")
+        end
+      rescue PairingError => e
+        error("Pair Verify Error: #{e}")
+        call_pair_verify_callback(false, e.to_s)
+      end
+    end
+
+    def call_pair_verify_callback(status, data=nil)
+      if @pair_verify_callback
+        t = @pair_verify_callback
+        @pair_verify_callback = nil
+        t.call(status, data)
+      end
+    end
+
+    def verify_start_request()
+      debug("Generating new Session Public/Private Keys")
+      @client_secret_key = X25519::Scalar.generate
+      @client_public_key = @client_secret_key.public_key.to_bytes
+
+      debug("Sending verify Request to Server")
+      data = RubyHome::HAP::TLV.encode({
+                                         'kTLVType_State' => 1,
+                                         'kTLVType_PublicKey' => @client_public_key
+                                       })
+      post("/pair-verify", "application/pairing+tlv8", data)
+    end
+
+    def verify_finish_request(response)
+      debug("Generating shared secret")
+      server_public_key = X25519::MontgomeryU.new(response['kTLVType_PublicKey'])
+      @shared_secret = @client_secret_key.multiply(server_public_key).to_bytes
+
+      debug("Generating session key")
+      hkdf = RubyHome::HAP::Crypto::HKDF.new(info: 'Pair-Verify-Encrypt-Info', salt: 'Pair-Verify-Encrypt-Salt')
+      session_key = hkdf.encrypt(@shared_secret)
+
+      debug("Decrypting data")
+      subtlv = response['kTLVType_EncryptedData']
+      chacha20poly1305ietf = RubyHome::HAP::Crypto::ChaCha20Poly1305.new(session_key)
+      nonce = RubyHome::HAP::HexPad.pad('PV-Msg02')
+      decrypted_data = chacha20poly1305ietf.decrypt(nonce, subtlv)
+      decrypted_data = RubyHome::HAP::TLV.read(decrypted_data)
+
+      debug("Verifying Server Signature")
+      server_device_id = decrypted_data['kTLVType_Identifier']
+      serverSignature = decrypted_data['kTLVType_Signature']
+
+      accessoryinfo = [
+        server_public_key.to_bytes.unpack1('H*'),
+        server_device_id.unpack1('H*'),
+        @client_public_key.unpack1('H*')
+      ].join
+      verify_key = RbNaCl::Signatures::Ed25519::VerifyKey.new(@accessoryltpk)
+
+      begin
+        if !verify_key.verify(serverSignature, [accessoryinfo].pack('H*'))
+          error("Server signature INVALID!")
+          raise PairingError, "Server signature INVALID!"
+        end
+      rescue RbNaCl::BadSignatureError
+        error("Server signature INVALID!")
+        raise PairingError, "Server signature INVALID!"
+      end
+
+      debug("Generating Client Info")
+      clientInfo = [
+        @client_public_key.unpack1('H*'),
+        @client_id.unpack1('H*'),
+        server_public_key.to_bytes.unpack1('H*')
+      ].join
+
+      debug("Generating Client Signature")
+      clientSignature = @signing_key.sign([clientInfo].pack('H*'))
+
+      debug("Generating Encrypted Data")
+      subtlv = RubyHome::HAP::TLV.encode({
+                                           'kTLVType_Identifier' => @client_id,
+                                           'kTLVType_Signature' => clientSignature
+                                         })
+
+      chacha20poly1305ietf = RubyHome::HAP::Crypto::ChaCha20Poly1305.new(session_key)
+      nonce = RubyHome::HAP::HexPad.pad('PV-Msg03')
+      encrypted_data = chacha20poly1305ietf.encrypt(nonce, subtlv)
+
+      debug("Sending Encrypted Request to Server")
+      data = RubyHome::HAP::TLV.encode({
+                                         'kTLVType_State' => 3,
+                                         'kTLVType_EncryptedData' => encrypted_data
+                                       })
+
+      post("/pair-verify", "application/pairing+tlv8", data)
+    end
+
+    def verify_finish_verify()
+      hkdf = RubyHome::HAP::Crypto::HKDF.new(info: 'Control-Write-Encryption-Key', salt: 'Control-Salt')
+      @controller_to_accessory_key = hkdf.encrypt(@shared_secret)
+
+      hkdf = RubyHome::HAP::Crypto::HKDF.new(info: 'Control-Read-Encryption-Key', salt: 'Control-Salt')
+      @accessory_to_controller_key = hkdf.encrypt(@shared_secret)
+
+      @shared_secret = nil
+
+      info("Pair Verify Complete")
+    end
+
+    def get_pairing_context()
+      {
+        'client_id' => @client_id,
+        'signature_key' => @signature_key,
+        'accessoryltpk' => @accessoryltpk.unpack1('H*')
+      }
+    end
+
+    def set_pairing_context(context)
+      context = JSON.parse(context) if context.is_a?(String)
+      @client_id = context['client_id']
+      @signature_key = context['signature_key']
+      @accessoryltpk = hex_to_bin(context['accessoryltpk'])
+
+      @signing_key = Ed25519::SigningKey.new([@signature_key].pack('H*'))
+    end
+
+    def check_tlv_response(data)
+      data = RubyHome::HAP::TLV.read(data)
+
+      debug("Response: " + data.to_s)
+
+      if data['kTLVType_Error']
+        error("Failed to pair: #{data}")
+        raise PairingError, ERROR_NAMES[data['kTLVType_Error']]
+      end
+
+      return data
+    end
+
+    def bin_to_hex(s)
+      s.unpack('H*')[0]
+    end
+
+    def hex_to_bin(s)
+      s.scan(/../).map { |x| x.hex.chr }.join
+    end
+  end
+end

data/lib/hap_client/parser.rb

@@ -0,0 +1,35 @@
+require 'http/parser'
+
+module HAP
+  module Parser
+    def init_parser
+      @parser = Http::Parser.new(self)
+    end
+
+    def receive_data(data)
+      if encryption_ready?
+        data = decrypt(data)
+      end
+
+      @parser << data
+    end
+
+    def on_message_begin
+      @headers = nil
+      @body = ''
+    end
+
+    def on_headers_complete(headers)
+      @headers = headers
+    end
+
+    def on_body(chunk)
+      @body << chunk
+    end
+
+    def on_message_complete
+      parse_message(@body)
+    end
+
+  end
+end

data/lib/hap_client/request.rb

@@ -0,0 +1,68 @@
+require_relative 'encryption_request'
+
+module HAP
+  module Request
+    include EncryptionRequest
+
+    def get(url)
+      request("GET", url)
+    end
+
+    def post(url, type, data)
+      request("POST", url, type, data)
+    end
+
+    def put(url, type, data)
+      request("PUT", url, type, data)
+    end
+
+    private
+
+    def request(method, url, type=nil, data=nil)
+      req = method + " " + url + " HTTP/1.1\r\n"
+      req << "Host: homekit\r\n"
+
+      if type
+        req << "Content-Type: " + type + "\r\n"
+      end
+      if data
+        req << "Content-Length: " + data.length.to_s + "\r\n"
+      end
+      req << "\r\n"
+
+      if log_debug?
+        if data
+          if data[0] == '{'
+            debug(req + data.to_s)
+          else
+            debug(req + RubyHome::HAP::TLV.read(data).to_s)
+          end
+        else
+          debug(req)
+        end
+      end
+
+      if data
+        req << data.to_s
+      end
+
+      if encryption_ready?
+        encrypt(req).each do |r|
+          if @socket.nil?
+            send_data(r)
+          else
+            @socket.write(r)
+          end
+        end
+      else
+        if @socket.nil?
+          send_data(req)
+        else
+          @socket.write(req)
+        end
+      end
+
+      init_parser()
+    end
+  end
+end

data/lib/hap_client/version.rb

@@ -0,0 +1,3 @@
+module HapClient
+  VERSION = '0.0.2'
+end

data/lib/hap_client.rb

@@ -0,0 +1,134 @@
+require 'json'
+
+require_relative 'hap_client/log'
+require_relative 'hap_client/parser'
+require_relative 'hap_client/request'
+require_relative 'hap_client/pairing'
+
+module HAP
+  module Client
+    include Log
+    include Parser
+    include Request
+    include Pairing
+
+    def initialize
+      @name = "Unknown Client"
+      @mode = :init
+      @values = {}
+      init_log()
+    end
+
+    def set_value(aid, iid, value)
+      info("Set Value #{aid}:#{iid} to #{value}")
+      data = {
+        "characteristics" => [{
+                                "aid" => aid,
+                                "iid" => iid,
+                                "value" => value
+                              }]
+      }
+
+      put("/characteristics", "application/hap+json", JSON.generate(data))
+    end
+
+    def subscribe(aid, iid)
+      info("Subscribe to #{aid} #{iid}")
+      data = {
+        "characteristics" => [{
+                                "aid" => aid,
+                                "iid" => iid,
+                                "ev" => "true"
+                              }]
+      }
+
+      put("/characteristics", "application/hap+json", JSON.generate(data))
+    end
+
+    def subscribe_to_all()
+      @values.each do |service|
+        service.each do |val|
+          if val[:perms].include?("ev")
+            subscribe(val[:aid], val[:iid])
+          end
+        end
+      end
+    end
+
+    def get_accessories(&block)
+      info("Get Accessories")
+      get("/")
+
+      if block_given?
+        @callback = block
+      end
+    end
+
+    def to_s
+      @name
+    end
+
+    private
+
+    def parse_message(data)
+      case @mode
+      when :pair_setup
+        pair_setup_parse(data)
+      when :pair_verify
+        pair_verify_parse(data)
+      else
+        if !data.nil? and data != ""
+          data = parse_accessories(data)
+        end
+
+        if @callback
+          t = @callback
+          @callback = nil
+          t.call(data)
+        end
+      end
+    end
+
+    def parse_accessories(data)
+      data = JSON.parse(data, :symbolize_names=>true)
+
+      services = data[:accessories][0][:services]
+
+      services.each do |service|
+        @values[service[:type]] = {}
+
+        parse_characteristics(service)
+      end
+
+      return data
+    end
+
+    def parse_characteristics(service)
+      service[:characteristics].each do |char|
+        val = char[:value]
+
+        @values[service[:type]][char[:type]] = {
+          :aid => char[:aid],
+          :iid => char[:iid],
+          :perms => char[:perms},
+          :value => val
+        }
+
+        if service[:type] == "3E"
+          case char[:type]
+          when "20"
+            @manufacturer = val
+          when "21"
+            @model = val
+          when "23"
+            @name = val
+          when "30"
+            @serial = val
+          when "52"
+            @version = val
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,169 @@
+--- !ruby/object:Gem::Specification
+name: hap_client
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Andreas Bomholtz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-06-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: http_parser.rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: ruby_home
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+- !ruby/object:Gem::Dependency
+  name: ruby_home-srp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Ruby Gem for Apple Homekit Client
+email: andreas@seluxit.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-version"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- hap_client.gemspec
+- lib/hap_client.rb
+- lib/hap_client/encryption_request.rb
+- lib/hap_client/log.rb
+- lib/hap_client/pairing.rb
+- lib/hap_client/parser.rb
+- lib/hap_client/request.rb
+- lib/hap_client/version.rb
+homepage: http://github.com/Seluxit/hap_client
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: HAP client
+test_files: []