ruby_home 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ee1bab57c905588f1ea3b558c4a303a2935321cdb8e95e04416ff5812c40727
-  data.tar.gz: 8383552d3c59b1360ba854b5cada8159a98dac180fa137a4be907057ca2c84e6
+  metadata.gz: 6ccc3aa90b30716b6e6d39417f7c1bef28d9f46c9eede93dde811436d2ddfb8e
+  data.tar.gz: ad86b1dbbb0744be8eb76d82da287a9d2ee13d1e43d3bb5f137669fe3c865c82
 SHA512:
-  metadata.gz: 1a3be890c661e77d1c69348b04520b8426e6a7861d517880d99dd7d7619bf46eab47d433516139bb53af887c7429a007495e199877b0f58f3e4b0a5099ea1010
-  data.tar.gz: ef7aec5965acaf52f8da6084a63de3d0e51d1ef9df4e8049d7dc8940d497b926988296f6e9bf014e8e414a26716f926e227e704c0c38e4de1fa53166c20219be
+  metadata.gz: 03c859f3cd8129b26576402d2ecc8d3fff54adb7fcce812e36a910bec254d8c26e6f1192b570889ed6c7462f83f2a7a3a7e9f616e4941be0b82fb7af688e0ed0
+  data.tar.gz: ea4e4033a81221b8f798a8adb50a3e625b405d1136f43c690834f53af9a07cdf36eb8269241a1a69397b68fe3ca4f8dbf1673c3e0ffd750420686bdb61ace4dd

data/README.md

@@ -1,9 +1,9 @@
-[![Maintainability](https://api.codeclimate.com/v1/badges/a13f62c597b3746a7ef5/maintainability)](https://codeclimate.com/github/karlentwistle/ruby_home/maintainability)
+[![Maintainability](https://api.codeclimate.com/v1/badges/c81f4cfdf5c13d716487/maintainability)](https://codeclimate.com/github/karlentwistle/ruby_home/maintainability)
 [![Build Status](https://travis-ci.org/karlentwistle/ruby_home.svg?branch=master)](https://travis-ci.org/karlentwistle/ruby_home)
 
-# Ruby Home
+# ruby_home
 
-RubyHome is a lightweight service you can run on your home network that emulates the iOS HomeKit API. It supports community contributed plugins, which are modules that provide a bridge from HomeKit to various 3rd-party APIs provided by manufacturers of smart home devices.
+ruby_home is an implementation of the HomeKit Accessory Protocol (HAP) to create your own HomeKit accessory in Ruby. HomeKit is a set of protocols and libraries to access devices for home automation. A non-commercial version of the protocol documentation is available on the [HomeKit developer website](https://developer.apple.com/homekit/).
 
 ## Installation
 
@@ -23,14 +23,30 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+Create a fan with an on/off switch.
+
+```ruby
+require 'ruby_home'
+
+accessory_information = RubyHome::AccessoryFactory.create(:accessory_information)
+fan = RubyHome::AccessoryFactory.create(:fan)
+
+fan.characteristic(:on).on(:updated) do |new_value|
+  if new_value == 1
+    puts "Fan switched on"
+  else
+    puts "Fan switched off"
+  end
+end
+
+RubyHome::Broadcast.run
+```
 
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/ruby_home.
+Bug reports and pull requests are welcome on GitHub at https://github.com/karlentwistle/ruby_home.

data/lib/ruby_home.rb

@@ -2,5 +2,6 @@ require_relative 'ruby_home/version'
 require_relative 'ruby_home/broadcast'
 require_relative 'ruby_home/identifier_cache'
 Dir[File.dirname(__FILE__) + '/ruby_home/factories/*.rb'].each { |file| require file }
+Dir[File.dirname(__FILE__) + '/ruby_home/hap/crypto/*.rb'].each { |file| require file }
 
 module RubyHome; end

data/lib/ruby_home/hap/crypto/chacha20poly1305.rb

@@ -0,0 +1,31 @@
+require 'rbnacl/libsodium'
+
+module RubyHome
+  module HAP
+    module Crypto
+      class ChaCha20Poly1305
+        def initialize(key)
+          @key = key
+        end
+
+        def encrypt(nonce, message, additional_data=nil)
+          chacha20poly1305ietf.encrypt(nonce, message, additional_data)
+        end
+
+        def decrypt(nonce, ciphertext, additional_data=nil)
+          chacha20poly1305ietf.decrypt(nonce, ciphertext, additional_data)
+        end
+
+        private
+
+        attr_reader :key
+
+        def chacha20poly1305ietf
+          @_chacha20poly1305ietf ||= RbNaCl::AEAD::ChaCha20Poly1305IETF.new(key)
+        end
+      end
+    end
+  end
+end
+
+

data/lib/ruby_home/hap/crypto/hkdf.rb

@@ -0,0 +1,44 @@
+require 'rbnacl/libsodium'
+
+GEM_HKDF = HKDF
+
+module RubyHome
+  module HAP
+    module Crypto
+      class HKDF
+        def initialize(salt:, info: )
+          @salt = salt
+          @info = info
+        end
+
+        def encrypt(source)
+          byte_string = convert_string_to_byte_string(source)
+          GEM_HKDF.new(byte_string, hkdf_opts).next_bytes(BYTE_LENGTH)
+        end
+
+        private
+
+        ALGORITHM = 'SHA512'
+        BYTE_LENGTH = 32
+
+        attr_reader :info, :salt, :source
+
+        def hkdf_opts
+          {
+            algorithm: ALGORITHM,
+            info: info,
+            salt: salt
+          }
+        end
+
+        def convert_string_to_byte_string(string)
+          if string.encoding == Encoding::ASCII_8BIT
+            string
+          else
+            [string].pack('H*')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_home/hap/http_decryption.rb

@@ -51,7 +51,7 @@ module RubyHome
       end
 
       def chacha20poly1305ietf
-        RbNaCl::AEAD::ChaCha20Poly1305IETF.new(key)
+        HAP::Crypto::ChaCha20Poly1305.new(key)
       end
     end
   end

data/lib/ruby_home/hap/http_encryption.rb

@@ -34,7 +34,7 @@ module RubyHome
       end
 
       def chacha20poly1305ietf
-        RbNaCl::AEAD::ChaCha20Poly1305IETF.new(key)
+        HAP::Crypto::ChaCha20Poly1305.new(key)
       end
     end
   end

data/lib/ruby_home/hap/tlv.rb

@@ -0,0 +1,95 @@
+require 'bindata'
+
+module RubyHome
+  module HAP
+    module TLV
+      extend self
+
+      TYPE_NAMES = {
+        0 => 'kTLVType_Method',
+        1 => 'kTLVType_Identifier',
+        2 => 'kTLVType_Salt',
+        3 => 'kTLVType_PublicKey',
+        4 => 'kTLVType_Proof',
+        5 => 'kTLVType_EncryptedData',
+        6 => 'kTLVType_State',
+        7 => 'kTLVType_Error',
+        8 => 'kTLVType_RetryDelay',
+        9 => 'kTLVType_Certificate',
+       10 => 'kTLVType_Signature',
+       11 => 'kTLVType_Permissions',
+       12 => 'kTLVType_FragmentData',
+       13 => 'kTLVType_FragmentLast',
+      }.freeze
+      NAME_TYPES = TYPE_NAMES.invert.freeze
+
+      class Bytes < BinData::String; end
+
+      class UTF8String < BinData::String
+        def snapshot
+          super.force_encoding('UTF-8')
+        end
+      end
+
+      class Payload < BinData::Choice
+        bytes :default, read_length: :len
+
+        uint8       0,  read_length: :len
+        utf8_string 1,  read_length: :len
+        bytes       2,  read_length: :len
+        bytes       3,  read_length: :len
+        bytes       4,  read_length: :len
+        bytes       5,  read_length: :len
+        uint8       6,  read_length: :len
+        uint8       7,  read_length: :len
+        uint8       8,  read_length: :len
+        bytes       9,  read_length: :len
+        bytes      10,  read_length: :len
+        uint8      11,  read_length: :len
+        bytes      12,  read_length: :len
+        bytes      13,  read_length: :len
+      end
+
+      class TLV < BinData::Record
+        uint8 :type_id, read_length: 2
+        uint8 :len, read_length: 2
+        payload :val, selection: :type_id
+      end
+
+      READER = BinData::Array.new(type: :tlv, read_until: :eof)
+
+      def read(input)
+        READER.clear
+        READER.read(input)
+        READER.snapshot.each_with_object({}) do |(hash), memo|
+          type = TYPE_NAMES[hash[:type_id]]
+          next unless type
+
+          if memo[type]
+            memo[type] << hash[:val]
+          else
+            memo[type] = hash[:val]
+          end
+        end
+      end
+
+      def encode(hash)
+        hash.to_hash.each_with_object(String.new) do |(key, value), memo|
+          type_id = NAME_TYPES[key]
+          next unless type_id
+
+          if value.is_a?(String)
+            value.scan(/.{1,255}/m)
+          else
+            [value]
+          end.each do |frame_value|
+            tlv = TLV.new(type_id: type_id, val: frame_value).tap do |tlv|
+              tlv.len = tlv.val.to_binary_s.length
+            end
+            memo << tlv.to_binary_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_home/http/controllers/application_controller.rb

@@ -6,7 +6,7 @@ module RubyHome
       def unpack_request
         @_unpack_request ||= begin
           request.body.rewind
-          TLV.unpack(request.body.read)
+          HAP::TLV.read(request.body.read)
         end
       end
 

data/lib/ruby_home/http/controllers/pair_setups_controller.rb

@@ -3,7 +3,7 @@ require 'openssl'
 require 'rbnacl/libsodium'
 require 'ruby_home-srp'
 require_relative '../../hap/hex_pad'
-require_relative '../../tlv'
+require_relative '../../hap/tlv'
 require_relative 'application_controller'
 
 module RubyHome
@@ -36,82 +36,81 @@ module RubyHome
         challenge_and_proof = srp_verifier.get_challenge_and_proof(username, verifier, salt)
         store_proof(challenge_and_proof[:proof])
 
-        TLV.pack({
-          'kTLVType_Salt' => challenge_and_proof[:challenge][:salt],
-          'kTLVType_PublicKey' => challenge_and_proof[:challenge][:B],
+        HAP::TLV.encode({
+          'kTLVType_Salt' => [challenge_and_proof[:challenge][:salt]].pack('H*'),
+          'kTLVType_PublicKey' => [challenge_and_proof[:challenge][:B]].pack('H*'),
           'kTLVType_State' => 2
         })
       end
 
       def srp_verify_response
         proof = retrieve_proof.dup
-        proof[:A] = unpack_request['kTLVType_PublicKey']
+        proof[:A] = unpack_request['kTLVType_PublicKey'].unpack1('H*')
 
-        client_m1_proof = unpack_request['kTLVType_Proof']
-        server_m2_proof = srp_verifier.verify_session(proof, unpack_request['kTLVType_Proof'])
+        server_m2_proof = srp_verifier.verify_session(proof, unpack_request['kTLVType_Proof'].unpack1('H*'))
 
         store_session_key(srp_verifier.K)
         forget_proof!
 
-        TLV.pack({
+        HAP::TLV.encode({
           'kTLVType_State' => 4,
-          'kTLVType_Proof' => server_m2_proof
+          'kTLVType_Proof' => [server_m2_proof].pack('H*')
         })
       end
 
       def exchange_response
         encrypted_data = unpack_request['kTLVType_EncryptedData']
 
-        hkdf = HAP::HKDFEncryption.new(info: 'Pair-Setup-Encrypt-Info', salt: 'Pair-Setup-Encrypt-Salt')
-        key = hkdf.encrypt([session_key].pack('H*'))
+        hkdf = HAP::Crypto::HKDF.new(info: 'Pair-Setup-Encrypt-Info', salt: 'Pair-Setup-Encrypt-Salt')
+        key = hkdf.encrypt(session_key)
 
-        chacha20poly1305ietf = RbNaCl::AEAD::ChaCha20Poly1305IETF.new(key)
+        chacha20poly1305ietf = HAP::Crypto::ChaCha20Poly1305.new(key)
 
         nonce = HAP::HexPad.pad('PS-Msg05')
-        decrypted_data = chacha20poly1305ietf.decrypt(nonce, [encrypted_data].pack('H*'), nil)
-        unpacked_decrypted_data = TLV.unpack(decrypted_data)
+        decrypted_data = chacha20poly1305ietf.decrypt(nonce, encrypted_data)
+        unpacked_decrypted_data = HAP::TLV.read(decrypted_data)
 
         iosdevicepairingid = unpacked_decrypted_data['kTLVType_Identifier']
         iosdevicesignature = unpacked_decrypted_data['kTLVType_Signature']
         iosdeviceltpk = unpacked_decrypted_data['kTLVType_PublicKey']
 
-        hkdf = HAP::HKDFEncryption.new(info: 'Pair-Setup-Controller-Sign-Info', salt: 'Pair-Setup-Controller-Sign-Salt')
-        iosdevicex = hkdf.encrypt([session_key].pack('H*'))
+        hkdf = HAP::Crypto::HKDF.new(info: 'Pair-Setup-Controller-Sign-Info', salt: 'Pair-Setup-Controller-Sign-Salt')
+        iosdevicex = hkdf.encrypt(session_key)
 
         iosdeviceinfo = [
-          iosdevicex.unpack('H*'),
-          TLV::Utf8.pack(iosdevicepairingid),
-          iosdeviceltpk
+          iosdevicex.unpack1('H*'),
+          iosdevicepairingid.unpack1('H*'),
+          iosdeviceltpk.unpack1('H*')
         ].join
-        verify_key = RbNaCl::Signatures::Ed25519::VerifyKey.new([iosdeviceltpk].pack('H*'))
+        verify_key = RbNaCl::Signatures::Ed25519::VerifyKey.new(iosdeviceltpk)
 
-        if verify_key.verify([iosdevicesignature].pack('H*'), [iosdeviceinfo].pack('H*'))
-          hkdf = HAP::HKDFEncryption.new(info: 'Pair-Setup-Accessory-Sign-Info', salt: 'Pair-Setup-Accessory-Sign-Salt')
-          accessory_x = hkdf.encrypt([session_key].pack('H*'))
+        if verify_key.verify(iosdevicesignature, [iosdeviceinfo].pack('H*'))
+          hkdf = HAP::Crypto::HKDF.new(info: 'Pair-Setup-Accessory-Sign-Info', salt: 'Pair-Setup-Accessory-Sign-Salt')
+          accessory_x = hkdf.encrypt(session_key)
 
           signing_key = accessory_info.signing_key
-          accessoryltpk = signing_key.verify_key.to_bytes.unpack('H*')[0]
+          accessoryltpk = signing_key.verify_key.to_bytes
           accessoryinfo = [
-            accessory_x.unpack('H*'),
-            TLV::Utf8.pack(accessory_info.device_id),
-            accessoryltpk
+            accessory_x.unpack1('H*'),
+            accessory_info.device_id.unpack1('H*'),
+            accessoryltpk.unpack1('H*')
           ].join
 
-          accessorysignature = signing_key.sign([accessoryinfo].pack('H*')).unpack('H*')[0]
+          accessorysignature = signing_key.sign([accessoryinfo].pack('H*'))
 
-          subtlv = TLV.pack({
+          subtlv = HAP::TLV.encode({
             'kTLVType_Identifier' => accessory_info.device_id,
             'kTLVType_PublicKey' => accessoryltpk,
             'kTLVType_Signature' => accessorysignature
           })
 
           nonce = HAP::HexPad.pad('PS-Msg06')
-          encrypted_data = chacha20poly1305ietf.encrypt(nonce, subtlv, nil).unpack('H*')[0]
+          encrypted_data = chacha20poly1305ietf.encrypt(nonce, subtlv)
 
-          pairing_params = { admin: true, identifier: iosdevicepairingid, public_key: iosdeviceltpk }
+          pairing_params = { admin: true, identifier: iosdevicepairingid, public_key: iosdeviceltpk.unpack1('H*') }
           accessory_info.add_paired_client pairing_params
 
-          TLV.pack({
+          HAP::TLV.encode({
             'kTLVType_State' => 6,
             'kTLVType_EncryptedData' => encrypted_data
           })

data/lib/ruby_home/http/controllers/pair_verifies_controller.rb

@@ -1,7 +1,7 @@
 require 'x25519'
+require_relative '../../hap/crypto/hkdf'
 require_relative '../../hap/hex_pad'
-require_relative '../../hap/hkdf_encryption'
-require_relative '../../tlv'
+require_relative '../../hap/tlv'
 require_relative 'application_controller'
 
 module RubyHome
@@ -22,34 +22,34 @@ module RubyHome
 
       def verify_start_response
         secret_key = X25519::Scalar.generate
-        public_key = secret_key.public_key.to_bytes.unpack('H*')[0]
-        client_public_key = X25519::MontgomeryU.new([unpack_request['kTLVType_PublicKey']].pack('H*'))
+        public_key = secret_key.public_key.to_bytes
+        client_public_key = X25519::MontgomeryU.new(unpack_request['kTLVType_PublicKey'])
         shared_secret = secret_key.multiply(client_public_key).to_bytes
         cache[:shared_secret] = shared_secret
 
         accessoryinfo = [
-          public_key,
-          TLV::Utf8.pack(accessory_info.device_id),
-          client_public_key.to_bytes.unpack('H*')[0]
+          public_key.unpack1('H*'),
+          accessory_info.device_id.unpack1('H*'),
+          client_public_key.to_bytes.unpack1('H*')
         ].join
 
         signing_key = accessory_info.signing_key
-        accessorysignature = signing_key.sign([accessoryinfo].pack('H*')).unpack('H*')[0]
+        accessorysignature = signing_key.sign([accessoryinfo].pack('H*'))
 
-        subtlv = TLV.pack({
+        subtlv = HAP::TLV.encode({
           'kTLVType_Identifier' => accessory_info.device_id,
           'kTLVType_Signature' => accessorysignature
         })
 
-        hkdf = HAP::HKDFEncryption.new(info: 'Pair-Verify-Encrypt-Info', salt: 'Pair-Verify-Encrypt-Salt')
+        hkdf = HAP::Crypto::HKDF.new(info: 'Pair-Verify-Encrypt-Info', salt: 'Pair-Verify-Encrypt-Salt')
         session_key = hkdf.encrypt(shared_secret)
         cache[:session_key] = session_key
 
-        chacha20poly1305ietf = RbNaCl::AEAD::ChaCha20Poly1305IETF.new(session_key)
+        chacha20poly1305ietf = HAP::Crypto::ChaCha20Poly1305.new(session_key)
         nonce = HAP::HexPad.pad('PV-Msg02')
-        encrypted_data = chacha20poly1305ietf.encrypt(nonce, subtlv, nil).unpack('H*')[0]
+        encrypted_data = chacha20poly1305ietf.encrypt(nonce, subtlv)
 
-        TLV.pack({
+        HAP::TLV.encode({
           'kTLVType_State' => 2,
           'kTLVType_PublicKey' => public_key,
           'kTLVType_EncryptedData' => encrypted_data
@@ -59,21 +59,21 @@ module RubyHome
       def verify_finish_response
         encrypted_data = unpack_request['kTLVType_EncryptedData']
 
-        chacha20poly1305ietf = RbNaCl::AEAD::ChaCha20Poly1305IETF.new(cache[:session_key])
+        chacha20poly1305ietf = HAP::Crypto::ChaCha20Poly1305.new(cache[:session_key])
         nonce = HAP::HexPad.pad('PV-Msg03')
-        decrypted_data = chacha20poly1305ietf.decrypt(nonce, [encrypted_data].pack('H*'), nil)
-        unpacked_decrypted_data = TLV.unpack(decrypted_data)
+        decrypted_data = chacha20poly1305ietf.decrypt(nonce, encrypted_data)
+        unpacked_decrypted_data = HAP::TLV.read(decrypted_data)
 
         if accessory_info.paired_clients.any? {|h| h[:identifier] == unpacked_decrypted_data['kTLVType_Identifier']}
-          hkdf = HAP::HKDFEncryption.new(info: 'Control-Write-Encryption-Key', salt: 'Control-Salt')
+          hkdf = HAP::Crypto::HKDF.new(info: 'Control-Write-Encryption-Key', salt: 'Control-Salt')
           cache[:controller_to_accessory_key] = hkdf.encrypt(cache[:shared_secret])
 
-          hkdf = HAP::HKDFEncryption.new(info: 'Control-Read-Encryption-Key', salt: 'Control-Salt')
+          hkdf = HAP::Crypto::HKDF.new(info: 'Control-Read-Encryption-Key', salt: 'Control-Salt')
           cache[:accessory_to_controller_key] = hkdf.encrypt(cache[:shared_secret])
 
-          TLV.pack({'kTLVType_State' => 4})
+          HAP::TLV.encode({'kTLVType_State' => 4})
         else
-          TLV.pack({'kTLVType_State' => 4, 'kTLVType_Error' => 2})
+          HAP::TLV.encode({'kTLVType_State' => 4, 'kTLVType_Error' => 2})
         end
       end
     end

data/lib/ruby_home/http/controllers/pairings_controller.rb

@@ -20,18 +20,18 @@ module RubyHome
         pairing_params = {
           admin: !!unpack_request['kTLVType_Permissions'],
           identifier: unpack_request['kTLVType_Identifier'],
-          public_key: unpack_request['kTLVType_PublicKey']
+          public_key: unpack_request['kTLVType_PublicKey'].unpack1('H*')
         }
         accessory_info.add_paired_client pairing_params
 
-        TLV.pack({'kTLVType_State' => 2})
+        HAP::TLV.encode({'kTLVType_State' => 2})
       end
 
       def remove_pairing
         accessory_info.remove_paired_client(unpack_request['kTLVType_Identifier'])
 
         response['connection'] = 'close'
-        TLV.pack({'kTLVType_State' => 2})
+        HAP::TLV.encode({'kTLVType_State' => 2})
       end
     end
   end

data/lib/ruby_home/http/serializers/characteristic_serializer.rb

@@ -6,20 +6,27 @@ module RubyHome
       include ObjectSerializer
 
       def record_hash(characteristic)
-        record_hash = {}
+        {
+          'iid' => characteristic.instance_id,
+          'type' => characteristic.uuid,
+          'perms' => perms(characteristic),
+          'format' => characteristic.format,
+          'description' => characteristic.description,
+        }.merge(optional_hash(characteristic))
+      end
 
-        record_hash['iid'] = characteristic.instance_id
-        record_hash['type'] = characteristic.uuid
-        record_hash['perms'] = characteristic.properties.map do |property|
+      def perms(characteristic)
+        characteristic.properties.map do |property|
           RubyHome::Characteristic::PROPERTIES[property]
         end.compact
-        record_hash['format'] = characteristic.format
-        if characteristic.value != nil
-          record_hash['value'] = characteristic.value
-        end
-        record_hash['description'] = characteristic.description
+      end
 
-        record_hash
+      def optional_hash(characteristic)
+        Hash.new.tap do |optional_hash|
+          if characteristic.value != nil
+            optional_hash['value'] = characteristic.value
+          end
+        end
       end
     end
   end

data/lib/ruby_home/version.rb

@@ -1,3 +1,3 @@
 module RubyHome
-  VERSION = '0.1.0'
+  VERSION = '0.1.2'
 end

data/rubyhome.gemspec

@@ -24,14 +24,15 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
+  spec.add_dependency 'bindata', '~> 2.4', '>= 2.4.3'
   spec.add_dependency 'dnssd', '~> 3.0'
   spec.add_dependency 'ed25519', '~> 1.2', '>= 1.2.3'
   spec.add_dependency 'hkdf', '~> 0.3.0'
   spec.add_dependency 'oj', '~> 3.4'
   spec.add_dependency 'rbnacl', '~> 5.0'
   spec.add_dependency 'rbnacl-libsodium', '~> 1.0', '>= 1.0.16'
-  spec.add_dependency 'ruby_home-srp', '~> 1.1.1'
-  spec.add_dependency 'sinatra', '~> 2.0'
+  spec.add_dependency 'ruby_home-srp', '~> 1.2'
+  spec.add_dependency 'sinatra', '2.0.1'
   spec.add_dependency 'wisper', '~> 1.6', '>= 1.6.1'
   spec.add_dependency 'x25519', '~> 1.0', '>= 1.0.5'
   spec.add_development_dependency 'bundler', '~> 1.16'

metadata

@@ -1,15 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: ruby_home
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Karl Entwistle
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-03-31 00:00:00.000000000 Z
+date: 2018-06-26 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: bindata
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.4.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.4.3
 - !ruby/object:Gem::Dependency
   name: dnssd
   requirement: !ruby/object:Gem::Requirement
@@ -112,28 +132,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.1.1
+        version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.1.1
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: sinatra
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: 2.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: 2.0.1
 - !ruby/object:Gem::Dependency
   name: wisper
   requirement: !ruby/object:Gem::Requirement
@@ -295,11 +315,13 @@ files:
 - lib/ruby_home/factories/templates/service_template.rb
 - lib/ruby_home/hap/accessory.rb
 - lib/ruby_home/hap/characteristic.rb
+- lib/ruby_home/hap/crypto/chacha20poly1305.rb
+- lib/ruby_home/hap/crypto/hkdf.rb
 - lib/ruby_home/hap/hex_pad.rb
-- lib/ruby_home/hap/hkdf_encryption.rb
 - lib/ruby_home/hap/http_decryption.rb
 - lib/ruby_home/hap/http_encryption.rb
 - lib/ruby_home/hap/service.rb
+- lib/ruby_home/hap/tlv.rb
 - lib/ruby_home/http/application.rb
 - lib/ruby_home/http/cache.rb
 - lib/ruby_home/http/controllers/accessories_controller.rb
@@ -318,10 +340,6 @@ files:
 - lib/ruby_home/http/serializers/service_serializer.rb
 - lib/ruby_home/identifier_cache.rb
 - lib/ruby_home/rack/handler/hap_server.rb
-- lib/ruby_home/tlv.rb
-- lib/ruby_home/tlv/bytes.rb
-- lib/ruby_home/tlv/int.rb
-- lib/ruby_home/tlv/utf8.rb
 - lib/ruby_home/version.rb
 - rubyhome.gemspec
 - sbin/characteristic_generator.rb

data/lib/ruby_home/hap/hkdf_encryption.rb

@@ -1,34 +0,0 @@
-require 'rbnacl/libsodium'
-
-module RubyHome
-  module HAP
-    class HKDFEncryption
-      def initialize(salt:, info: )
-        @salt = salt
-        @info = info
-      end
-
-      def encrypt(source)
-        HKDF.new(source, hkdf_opts).next_bytes(BYTE_LENGTH)
-      end
-
-      private
-
-      BYTE_LENGTH = 32
-
-      attr_reader :info, :salt, :source
-
-      def hkdf_opts
-        {
-          algorithm: algorithm,
-          info: info,
-          salt: salt
-        }
-      end
-
-      def algorithm
-        'SHA512'
-      end
-    end
-  end
-end

data/lib/ruby_home/tlv.rb

@@ -1,83 +0,0 @@
-Dir[File.dirname(__FILE__) + '/tlv/*.rb'].each {|file| require file }
-
-module RubyHome
-  module TLV
-    extend self
-
-    TLV = Struct.new(:type, :name, :handler)
-    TLVs = [
-      TLV.new('00', 'kTLVType_Method', Int),
-      TLV.new('01', 'kTLVType_Identifier', Utf8),
-      TLV.new('02', 'kTLVType_Salt', Bytes),
-      TLV.new('03', 'kTLVType_PublicKey', Bytes),
-      TLV.new('04', 'kTLVType_Proof', Bytes),
-      TLV.new('05', 'kTLVType_EncryptedData', Bytes),
-      TLV.new('06', 'kTLVType_State', Int),
-      TLV.new('07', 'kTLVType_Error', Int),
-      TLV.new('08', 'kTLVType_RetryDelay', Int),
-      TLV.new('09', 'kTLVType_Certificate', Bytes),
-      TLV.new('0a', 'kTLVType_Signature', Bytes),
-      TLV.new('0b', 'kTLVType_Permissions', Int),
-      TLV.new('0c', 'kTLVType_FragmentData', Bytes),
-      TLV.new('0d', 'kTLVType_FragmentLast', Bytes),
-    ].freeze
-
-    def pack(hash)
-      data = ''
-
-      pack_objects(hash).each do |type, value|
-        value.chars.each_slice(510).map(&:join).each do |value_slice|
-          length = Int.pack([value_slice].pack('H*').length)
-
-          data << type
-          data << length
-          data << value_slice
-        end
-      end
-
-      [data].pack('H*')
-    end
-
-    def pack_objects(objects)
-      objects.each_with_object({}) do |(unpacked_key, unpacked_value), memo|
-        tlv_value = TLVs.find { |tlv| tlv.name == unpacked_key }
-        packed_key = tlv_value.type
-        packed_value = tlv_value.handler.pack(unpacked_value)
-        memo[packed_key] = packed_value
-      end
-    end
-
-    def unpack(input)
-      data = input.unpack('H*')[0]
-      objects = {}
-      scanner_index = 0
-
-      while scanner_index < data.length do
-        type = data[scanner_index, 2]
-        scanner_index += 2
-
-        byte_length = Int.unpack(data[scanner_index, 2]) * 2
-        scanner_index += 2
-
-        newData = data[scanner_index, byte_length]
-        if objects[type]
-          objects[type] << newData
-        else
-          objects[type] = newData
-        end
-        scanner_index += byte_length
-      end
-
-      unpack_objects(objects)
-    end
-
-    def unpack_objects(objects)
-      objects.each_with_object({}) do |(packed_key, packed_value), memo|
-        tlv_value = TLVs.find { |tlv| tlv.type == packed_key }
-        unpacked_key = tlv_value.name
-        unpacked_value = tlv_value.handler.unpack(packed_value)
-        memo[unpacked_key] = unpacked_value
-      end
-    end
-  end
-end

data/lib/ruby_home/tlv/bytes.rb

@@ -1,19 +0,0 @@
-module RubyHome
-  module TLV
-    module Bytes
-      extend self
-
-      def pack(input)
-        if input.length.odd?
-          input.insert(0, '0')
-        else
-          input
-        end
-      end
-
-      def unpack(input)
-        input
-      end
-    end
-  end
-end

data/lib/ruby_home/tlv/int.rb

@@ -1,15 +0,0 @@
-module RubyHome
-  module TLV
-    module Int
-      extend self
-
-      def pack(input)
-        [input].pack('C*').unpack1('H*')
-      end
-
-      def unpack(input)
-        [input].pack('H*').unpack1('C*')
-      end
-    end
-  end
-end

data/lib/ruby_home/tlv/utf8.rb

@@ -1,18 +0,0 @@
-module RubyHome
-  module TLV
-    module Utf8
-      extend self
-
-      def pack(input)
-        input.bytes.map { |b| b.to_s(16) }.join
-      end
-
-      def unpack(input)
-        [input]
-          .pack('H*')
-          .force_encoding('utf-8')
-          .encode('utf-8')
-      end
-    end
-  end
-end