google_anymote 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.3@google_anymote

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in google_anymote.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Richard Hurt
+
+MIT License
+
+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,66 @@
+# Ruby Gem for the Google TV Pairing and Anymote Protocols
+
+This gem implements the Google Anymote Protocol which is used to send events to Google TVs.
+The protocol is based on a client-server model, with communications based on protocol buffers. 
+Clients search for a server on the local network. When a client wants to connect to a server 
+it has discovered, it does pairing authentication. After a successful pairing, both the client 
+and the server have certificates specific to the client app, and can communicate in the future 
+without the need to authenticate again. The transport layer uses TSL/SSL to protect messages 
+against sniffing.
+
+Note: I couldn't have made this without [Steven Le's Python client](https://github.com/stevenle/googletv-anymote).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'google_anymote'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install google_anymote
+
+## Prerequisites
+
+In order to send commands to a Google TV you must have an OpenSSL certificate.  This certificate
+can be self-signed and is pretty easy to generate.  Just follow these steps 
+(taken from http://www.akadia.com/services/ssh_test_certificate.html):
+
+    $ openssl genrsa -des3 -out server.key 1024
+    $ openssl req -new -key server.key -out server.csr
+    $ openssl rsa -in server.key -out server.key
+    $ openssl x509 -req -days 365 -in server.csr -signkey server.key -out server.crt
+    $ cat server.key server.crt > cert.pem
+
+Use the `cert.pem` as your certificate when you pair with the Google TV.
+
+## Usage
+
+### Command Line Utilities
+
+This gem includes several command line utilities to get you up and running.
+
+* <del>discover - searches your network for compatible Google TVs</del> - coming soon
+* pair - helps you pair your computer to a particular Google TV
+
+### As a gem
+
+1. Create a GoogleAnymote::TV object
+    
+     gtv = GoogleAnymote::TV.new(my_cert, hostname)
+
+2. Fling URIs to that TV 
+
+    gtv.fling_uri('http://github.com')
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch ('git checkout -b my-new-feature')
+3. Commit your changes ('git commit -am 'Added some feature')
+4. Push to the branch ('git push origin my-new-feature')
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,18 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+desc "Generate documentation"
+task :doc => :yard
+
+desc "Generated YARD documentation"
+task :yard do
+  require "yard"
+
+  opts = []
+  opts.push("--protected")
+  opts.push("--no-private")
+  opts.push("--private")
+  opts.push("--title", "GoogleAnymote")
+
+  YARD::CLI::Yardoc.run(*opts)
+end

data/bin/pair

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+require 'google_anymote'
+
+unless ARGV.count == 3 
+  abort "Usage: pair name host_name certificate\n\n"
+end
+
+# Collect arguments
+name  = ARGV.shift
+host  = ARGV.shift
+cert  = File.read ARGV.shift
+port  = 9551 + 1
+
+# Make a connection to the TV
+pair = GoogleAnymote::Pair.new(cert, host, name)
+
+# Ask the TV to pair
+pair.start_pairing
+
+# Collect pairing code
+print 'Enter the code from the TV: '
+code = gets.chomp
+
+# Complete the pairing process
+begin
+  pair.complete_pairing(code)
+rescue Exception => e
+  abort e
+end

data/google_anymote.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/google_anymote/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Richard Hurt"]
+  gem.email         = ["rnhurt@gmail.com"]
+  gem.description   = %q{Ruby implementation of the Google Anymote Protocol.}
+  gem.summary       = %q{This library uses the Google Anymote protocol to send events to Google TV servers.}
+  gem.homepage      = "https://github.com/rnhurt/google_anymote"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "google_anymote"
+  gem.require_paths = ["lib"]
+  gem.version       = GoogleAnymote::VERSION
+
+  gem.add_development_dependency  'yard'
+  gem.add_development_dependency  'redcarpet'
+  gem.add_dependency              'ruby_protobuf', '~> 0.4.11'
+end

data/lib/google_anymote/exceptions.rb

@@ -0,0 +1,7 @@
+module GoogleAnymote
+  # A general purpose error
+  class Error < StandardError; end
+
+  # Raised when a pairing operation fails for some reason
+  class PairingFailed < Error; end
+end

data/lib/google_anymote/pair.rb

@@ -0,0 +1,150 @@
+require "google_anymote/version"
+require 'socket'
+require 'openssl'
+
+##
+# Module that understands the Google Anymote protocol.
+module GoogleAnymote
+  ##
+  # Class to send events to a connected GoogleTV
+  class Pair
+    attr_reader :pair, :cert, :host, :gtv
+
+    ##
+    # Initializes the Pair class
+    #
+    # @param [Object] cert SSL certificate for this client
+    # @param [String] host hostname or IP address of the Google TV
+    # @param [String] client_name name of the client your connecting from
+    # @param [String] service_name name of the service (generally 'AnyMote')
+    # @return an instance of Pair
+    def initialize(cert, host, client_name = '', service_name = 'AnyMote')
+      @pair = PairingRequest.new
+      @cert = cert
+      @host = host
+      @pair.client_name  = client_name
+      @pair.service_name = service_name
+    end
+
+
+    ##
+    # Start the pairing process
+    #
+    # Once the TV recieves the pairing request it will display a 4 digit number.
+    # This number needs to be feed into the next step in the process, complete_pairing().
+    #
+    def start_pairing
+      @gtv = GoogleAnymote::TV.new(@cert, host, 9551 + 1)
+
+      # Let the TV know that we want to pair with it
+      send_message(pair, OuterMessage::MessageType::MESSAGE_TYPE_PAIRING_REQUEST)
+
+      # Build the options and send them to the TV
+      options       = Options.new
+      encoding      = Options::Encoding.new
+      encoding.type = Options::Encoding::EncodingType::ENCODING_TYPE_HEXADECIMAL
+      encoding.symbol_length = 4
+      options.input_encodings   << encoding
+      options.output_encodings  << encoding
+      send_message(options, OuterMessage::MessageType::MESSAGE_TYPE_OPTIONS)
+
+      # Build configuration and send it to the TV
+      config        = Configuration.new
+      encoding      = Options::Encoding.new
+      encoding.type = Options::Encoding::EncodingType::ENCODING_TYPE_HEXADECIMAL
+      config.encoding               = encoding
+      config.encoding.symbol_length = 4
+      config.client_role            = Options::RoleType::ROLE_TYPE_INPUT
+      outer = send_message(config, OuterMessage::MessageType::MESSAGE_TYPE_CONFIGURATION)
+      
+      raise PairingFailed, outer.status unless OuterMessage::Status::STATUS_OK == outer.status
+    end
+
+    ##
+    # Complete the pairing process
+    # @param [String] code The code displayed on the Google TV we are trying to pair with.
+    #
+    def complete_pairing(code)
+      # Send secret code to the TV to compete the pairing process
+      secret = Secret.new
+      secret.secret = encode_hex_secret(code)
+      outer = send_message(secret, OuterMessage::MessageType::MESSAGE_TYPE_SECRET)
+
+      # Clean up
+      @gtv.ssl_client.close
+
+      raise PairingFailed, outer.status unless OuterMessage::Status::STATUS_OK == outer.status
+    end
+
+
+
+    private
+
+    ##
+    # Format and send the message to the GoogleTV
+    #
+    # @param [String] msg message to send
+    # @param [Object] type type of message to send
+    # @return [Object] the OuterMessage response from the TV
+    def send_message(msg, type)
+      # Build the message and get it's size
+      message = wrap_message(msg, type).serialize_to_string
+      message_size = [message.length].pack('N')
+
+      # Write the message to the SSL client and get the response
+      @gtv.ssl_client.write(message_size + message)
+      data = ""
+      @gtv.ssl_client.readpartial(1000,data)
+      @gtv.ssl_client.readpartial(1000,data)
+
+      # Extract the response from the Google TV
+      outer = OuterMessage.new
+      outer.parse_from_string(data)
+
+      return outer
+    end
+
+    ##
+    # Wrap the message in an OuterMessage
+    #
+    # @param [String] msg message to send
+    # @param [Object] type type of message to send
+    # @return [Object] a properly formatted OuterMessage
+    def wrap_message(msg, type)
+      # Wrap it in an envelope
+      outer = OuterMessage.new
+      outer.protocol_version = 1
+      outer.status  = OuterMessage::Status::STATUS_OK
+      outer.type    = type
+      outer.payload = msg.serialize_to_string
+
+      return outer
+    end
+
+    ##
+    # Encode the secret from the TV into an OpenSSL Digest
+    #
+    # @param [String] secret pairing code from the TV's screen
+    # @return [Digest] OpenSSL Digest containing the encoded secret
+    def encode_hex_secret secret
+      # TODO(stevenle): Something further encodes the secret to a 64-char hex
+      # string. For now, use adb logcat to figure out what the expected challenge
+      # is. Eventually, make sure the encoding matches the server reference
+      # implementation:
+      #   http://code.google.com/p/google-tv-pairing-protocol/source/browse/src/com/google/polo/pairing/PoloChallengeResponse.java
+
+      encoded_secret = [secret.to_i(16)].pack("N").unpack("cccc")[2..3].pack("c*")
+
+      # Per "Polo Implementation Overview", section 6.1, client key material is
+      # hashed first, followed by the server key material, followed by the nonce.
+      digest = OpenSSL::Digest::Digest.new('sha256')
+      digest << @gtv.ssl_client.cert.public_key.n.to_s(2)       # client modulus
+      digest << @gtv.ssl_client.cert.public_key.e.to_s(2)       # client exponent
+      digest << @gtv.ssl_client.peer_cert.public_key.n.to_s(2)  # server modulus
+      digest << @gtv.ssl_client.peer_cert.public_key.e.to_s(2)  # server exponent
+
+      digest << encoded_secret[encoded_secret.size / 2]
+      return digest.digest
+    end
+  end
+end

data/lib/google_anymote/tv.rb

@@ -0,0 +1,96 @@
+require "google_anymote/version"
+require 'socket'
+require 'openssl'
+
+##
+# Module that understands the Google Anymote protocol.
+module GoogleAnymote
+  ##
+  # Class to send events to a connected GoogleTV
+  class TV
+    attr_reader :host, :port, :cert, :cotext, :ssl_client, :remote, :request, :fling
+
+    ##
+    # Initializes the TV class.
+    #
+    # @param [Object] cert SSL certificate for this client
+    # @param [String] host hostname or IP address of the Google TV
+    # @param [Number] port port number of the Google TV
+    # @return an instance of TV
+    def initialize(cert, host, port = 9551)
+      @host = host
+      @port = port
+      @cert = cert
+      @remote  = RemoteMessage.new
+      @request = RequestMessage.new
+      @fling   = Fling.new
+
+      # Build the SSL stuff
+      @context       = OpenSSL::SSL::SSLContext.new
+      @context.key   = OpenSSL::PKey::RSA.new @cert
+      @context.cert  = OpenSSL::X509::Certificate.new @cert
+
+      connect_to_unit
+    end
+
+    ##
+    # Connect this object to a Google TV
+    def connect_to_unit
+      puts "Connecting to '#{@host}..."
+      begin
+        tcp_client  = TCPSocket.new @host, @port
+        @ssl_client = OpenSSL::SSL::SSLSocket.new tcp_client, @context
+        @ssl_client.connect
+      rescue Exception => e
+        puts "Could not connect to '#{@host}: #{e}"
+      end
+    end
+
+    ##
+    # Clean up any sockets or other garbage.
+    def finalize()
+      @ssl_client.close
+    end
+
+    ##
+    # Fling a URI to the Google TV connected to this object
+    def fling_uri(uri)
+      @fling.uri = uri
+      @request.fling_message = fling
+      @remote.request_message = @request
+      send_message(@remote)
+    end
+
+    private
+    ##
+    # Send a message to the Google TV
+    # @param [String] msg message to send to the TV
+    # @return [String] raw data sent back from the TV
+    def send_message(msg)
+      # Build the message and get it's size
+      message = msg.serialize_to_string
+      message_size = [message.length].pack('N')
+
+      # Try to send the message
+      try_again = true
+      begin
+        data = ""
+        @ssl_client.write(message_size + message)
+        @ssl_client.readpartial(1000,data)
+      rescue
+        # Sometimes our connection might drop or something, so
+        # we'll reconnect to the unit and try to send the message again.
+        if try_again
+          try_again = false
+          connect_to_unit
+          retry
+        else
+          # Looks like we couldn't connect to the unit after all.
+          puts "message not sent"
+        end
+      end
+
+      return data
+    end
+  end
+end

data/lib/google_anymote/version.rb

@@ -0,0 +1,4 @@
+module GoogleAnymote
+  # Gem version
+  VERSION = "0.0.1"
+end

data/lib/google_anymote.rb

@@ -0,0 +1,7 @@
+require "google_anymote/version"
+require "google_anymote/tv"
+require "google_anymote/pair"
+require "google_anymote/exceptions"
+
+require "proto/remote.pb"
+require "proto/polo.pb"