touchpass 0.0.8.1

data/lib/touchpass/prp.rb

@@ -0,0 +1,256 @@
+# Use BigDecimal for accuracy
+require 'bigdecimal'
+require 'geocoder'
+
+begin
+  # TODO: use a disk cache?
+  Geocoder::Configuration.cache = {}
+end
+
+module Touchpass
+  module Proximity
+    # PRP - Privacy Respecting Proximity
+    # Provides mechanisms that allows locations to be compared
+    # for proximity without revealing the actual location of
+    # either party.
+    class PRP
+
+      class BBoxResolution
+        # Bounding box resolutions:
+        STREET   = 0.001  # 3 decimal places
+        LOCAL    = 0.01   # 2 decimal places
+        METRO    = 0.1    # 1 decimal place
+        REGIONAL = 1      # 0 decimal places
+      end
+
+      # Minumum and maximum value for latitude
+      MIN_LAT, MAX_LAT = BigDecimal.new("-90.0"), BigDecimal.new("90.0")
+      # Minumum and maximum value for longitude
+      MIN_LNG, MAX_LNG = BigDecimal.new("-180.0"), BigDecimal.new("180.0")
+
+      attr_reader :lat, :lng, :resolution
+      attr_reader :bounding_coordinates
+      attr :crypted_coordinates
+
+      # Given a coordinate (latitude and longitude) and an Bounding Box resolution, return a PRP geohash
+      def initialize(params={})
+        resolution = params[:resolution]
+        if resolution.nil? or resolution == ""
+          resolution = 'LOCAL'
+        end
+
+        if params.has_key? :lat and params.has_key? :lng
+          @lat, @lng = lat, lng
+        elsif params[:address]
+          addr = nil
+          if params[:address].is_a? String
+            addr = params[:address]
+          elsif params[:address].is_a? Hash
+            addr = build_address(params[:address])
+          end
+
+          coord = Geocoder.coordinates(addr) if addr
+          #puts "addr = #{addr}"
+          #puts "coord = #{coord.first}, #{coord.last}"
+          return false if coord.nil? # Should we raise exception here?
+          @lat, @lng = coord.first, coord.last
+        end
+
+        case resolution.upcase
+        when 'STREET'
+          @resolution = BBoxResolution::STREET
+        when 'LOCAL'
+          @resolution = BBoxResolution::LOCAL
+        when 'METRO'
+          @resolution = BBoxResolution::METRO
+        when 'REGIONAL'
+          @resolution = BBoxResolution::REGIONAL
+        else
+          raise Exception, "Unknown resolution '#{resolution}'."
+        end
+
+        # convert lat, lng to bigdecimal
+        @lat, @lng = BigDecimal.new(@lat.to_s), BigDecimal.new(@lng.to_s)
+
+        # calculate bounding coordinates
+        calculate_bounding_coordinates!(@resolution)
+      end
+
+      # Calculates four coordinates that represent an anonymised version of the location.
+      # Anonymised means that regardless of the absolute value of lat and lng, the four 
+      # coordinates will be a bounding box around the point.
+      # Returns an array of lat/lng coordinates that bound the coordinates.
+      # Notes: 
+      # Size of the bounding box is determined by the granularity parameter
+      def calculate_bounding_coordinates!(resolution)
+        return @bounding_coordinates unless @bounding_coordinates.nil?
+
+        trunc = Touchpass::Proximity::PRP.truncate_size(resolution)      
+        granularity = BigDecimal.new(resolution.to_s)
+
+        min_lat = @lat.truncate(trunc)
+        min_lng = @lng.truncate(trunc)
+
+        # Allow for different calcs depending on sign of lat and lng
+        if @lat > 0.0
+      		max_lat = min_lat + granularity
+      	else
+      		max_lat = min_lat
+      		min_lat = max_lat - granularity
+      	end
+      	if @lng > 0.0
+      		max_lng = min_lng + granularity
+      	else
+      		max_lng = min_lng
+      		min_lng = max_lng - granularity
+      	end
+
+        @bounding_coordinates = {
+          :top_left     => [max_lat, min_lng],
+          :top_right    => [max_lat, max_lng],
+          :bottom_right => [min_lat, max_lng],
+          :bottom_left  => [min_lat, min_lng]
+        }
+
+        # Calibrate lats and lngs
+        @bounding_coordinates.collect{|k, coords| coords[0] = Touchpass::Proximity::PRP.calibrate_lat(coords[0])}
+        @bounding_coordinates.collect{|k, coords| coords[1] = Touchpass::Proximity::PRP.calibrate_lng(coords[1])}
+
+        return @bounding_coordinates
+      end
+
+      # Returns the bounding coordinates
+      def bounding_box
+        return @bounding_coordinates
+      end
+
+      def calibrated?
+        return false if @bounding_coordinates.nil? or @bounding_coordinates.empty?
+        for key in [:top_left, :top_right, :bottom_right, :bottom_left]
+          return false if !@bounding_coordinates.has_key?(key)
+        end
+        return true
+      end
+
+      # Test to see if the specified location is near this one, where
+      # 'near' means at least one of its bounding coordinates is shared between the two points
+      def proximate?(other_prp)
+        return Touchpass::Proximity::PRP.proximate?(self, other_prp)
+      end
+
+      def common_bounding_coordinates(other_prp)
+        return Touchpass::Proximity::PRP.common_bounding_coordinates(self, other_prp)
+      end
+
+      # Returns the hashed representation of the bounding coordinates
+      def encrypt(salt=nil)
+        crypted_1 = encrypt_point(@bounding_coordinates[:top_left], salt)
+        crypted_2 = encrypt_point(@bounding_coordinates[:top_right], salt)
+        crypted_3 = encrypt_point(@bounding_coordinates[:bottom_right], salt)
+        crypted_4 = encrypt_point(@bounding_coordinates[:bottom_left], salt)
+        @crypted_coordinates = crypted_1 + crypted_2 + crypted_3 + crypted_4
+        return @crypted_coordinates
+      end
+
+      def encrypt_point(point=[], salt=nil)
+        return if point.size!=2
+
+        # Format lat, lng with correct decimal places
+        # STREET  : 3 decimal places (e.g. -33.860, 151.200)
+        # LOCAL   : 2 decimal places (e.g. -33.86, 151.20)
+        # METRO   : 1 decimal places (e.g. -33.8, 151.2)
+        # REGIONAL: 0 decimal places (e.g. -33, 151)
+        lat = Touchpass::Proximity::PRP.format_decimal(point.first, Touchpass::Proximity::PRP.truncate_size(@resolution))
+        lng = Touchpass::Proximity::PRP.format_decimal(point.last, Touchpass::Proximity::PRP.truncate_size(@resolution))
+
+        # MFS: 20100722
+        # Original approach hashed points in the corner independently. eg:
+        # return crypto_provider.hexdigest(lat.to_s) + crypto_provider.hexdigest(lng.to_s)
+        # Changed to string concat the points together *before* the hash so that we end up with hash values
+        # that are coming from 3,240,000 values (ie 1,800*1,800) as opposed to 2 hashes derived from a set of 1,800
+        # possible values.
+        str_to_encrypt = (lat.to_s) + "," + (lng.to_s) + salt.to_s
+        return Touchpass::Crypt.encrypt(str_to_encrypt)
+      end
+
+      def self.truncate_size(resolution)
+        split = resolution.to_s.split(".")
+        return split.size==1 ? 0 : split.last.size
+      end
+
+      # Truncate decimal (not round)
+      # E.g.
+      # format_decimal(-33.860987, 3) #=> -33.860
+      # format_decimal(-33.860987, 2) #=> -33.86
+      # format_decimal(-33.860987, 1) #=> -33.8
+      # format_decimal(-33.860987, 0) #=> -33
+      # format_decimal(151.200948, 3) #=> 151.200
+      # format_decimal(151.200948, 2) #=> 151.20
+      # format_decimal(151.200948, 1) #=> 151.2
+      # format_decimal(151.200948, 0) #=> 151
+      def self.format_decimal(decimal, decimal_places)
+        # KM: 20110927
+        # Original approach was to round decimal. eg:
+        # {}"%.#{decimal_places}f" % decimal
+        # Changed to truncate without rounding
+        t = 10.0 ** decimal_places
+        "%.#{decimal_places}f" % ((decimal * t).truncate / t)
+      end
+
+      def self.calibrate_lat(lat)
+        if lat == 0.0
+          # make sure -0.0 turned into 0.0
+          lat = BigDecimal("0.0")
+        elsif !(MIN_LAT..MAX_LAT).include?(lat)
+          # latitude must fall within its range
+          lat = (lat<MIN_LAT) ? MIN_LAT : MAX_LAT
+        end
+        return lat
+      end
+
+      def self.calibrate_lng(lng)
+        if lng == 0.0
+          # make sure -0.0 turned into 0.0
+          lng = BigDecimal("0.0")
+        elsif !(MIN_LNG..MAX_LNG).include?(lng)
+          # longitude must fall within its range
+          lng = (lng<MIN_LNG) ? MIN_LNG : MAX_LNG
+        end
+        return lng
+      end
+
+      def self.proximate?(prp, other_prp)
+        return !Touchpass::Proximity::PRP.common_bounding_coordinates(prp, other_prp).empty?
+      end
+
+      def self.common_bounding_coordinates(prp, other_prp)
+        return nil unless prp.bounding_coordinates
+        bounding_coords_1 = prp.bounding_coordinates.collect{|k, v| v}
+        bounding_coords_2 = other_prp.bounding_coordinates.collect{|k, v| v}
+        return bounding_coords_1 & bounding_coords_2
+      end
+
+      def print_bbox
+        for point in [:top_left, :top_right, :bottom_right, :bottom_left]
+          lat = Touchpass::Proximity::PRP.format_decimal(self.bounding_coordinates[point].first, Touchpass::Proximity::PRP.truncate_size(@resolution))
+          lng = Touchpass::Proximity::PRP.format_decimal(self.bounding_coordinates[point].last, Touchpass::Proximity::PRP.truncate_size(@resolution))
+          # lat = "%.#{Touchpass::Proximity::PRP.truncate_size(@resolution)}f" % self.bounding_coordinates[point].first
+          # lng = "%.#{Touchpass::Proximity::PRP.truncate_size(@resolution)}f" % self.bounding_coordinates[point].last
+          puts "#{point.to_s}: [#{lat.to_s}, #{lng.to_s}]"
+        end
+        return true
+      end
+
+      # Converts addresss Hash to String
+      # "120 Sussex Street, Sydney 2000, NSW Australia"
+      def build_address(attributes)
+        address = attributes[:address] + ","
+        address << " #{attributes[:city]}" if attributes[:city].present?
+        address << " #{attributes[:postcode]}" if attributes[:postcode].present?
+        address << ", #{attributes[:state]}" if attributes[:state].present?
+        address << " #{attributes[:country]}" if attributes[:country].present?
+        address
+      end
+    end
+  end
+end

data/lib/touchpass/verification.rb

@@ -0,0 +1,112 @@
+module Touchpass
+  module Rp
+    class Verification
+      include HTTParty
+      #debug_output
+
+      def initialize
+        self.class.base_uri Touchpass.base_uri
+      end
+
+      def create(to_party, options={})
+        http_options = { :body => {:to_party => to_party}, :headers => api_key_header }
+
+        # Get the verifying party devices so we can encrypt message/prp using the devices public key
+        device = Touchpass::Rp::Device.new
+        vp_devices = device.get_all(to_party)
+
+        # Generate token
+        token = Touchpass::Crypt.salt
+        hashed_token = Touchpass::Crypt.encrypt(token)
+        http_options[:body][:claimed_token] = hashed_token
+
+        # Encrypt token using verifying_party (to_party) devices
+        create_crypted_tokens(token, vp_devices, http_options)
+
+        # Generate Claimed PRP (for Location Verification)
+        create_prp(options[:address], vp_devices, http_options)
+
+        # Generate Claimed PRP (for Location Verification)
+        create_crypted_messages(options[:message], vp_devices, http_options)
+
+        response = self.class.post("/verifications.json", http_options)
+        return response.parsed_response
+      end
+
+      def cancel(id)
+        http_options = { :body => {}, :headers => api_key_header }
+        response = self.class.put("/verifications/#{id}/cancel.json", http_options)
+        return response.parsed_response
+      end
+
+      def show(id)
+        http_options = { :body => {}, :headers => api_key_header }
+        response = self.class.get("/verifications/#{id}.json", http_options)
+        return response.parsed_response
+      end
+
+      private
+      def create_crypted_tokens(token, devices, http_options)
+        return if devices.nil? or (devices.is_a? Array and devices.empty?)
+        devices.each_with_index do |device, index|
+          device_id = device["id"]
+          pub_key = device["pub_key"]
+          public_key = Touchpass::Crypt.read_key(pub_key)
+          crypted_token = Base64.encode64(public_key.public_encrypt(token))
+          http_options[:body]["crypted_tokens[#{index}][device_id]"] = device_id
+          http_options[:body]["crypted_tokens[#{index}][value]"] = crypted_token
+        end
+      end
+
+      def create_prp(address, devices, http_options)
+        return unless address.present?
+
+        http_options[:body][:location_verification] = true
+
+        # Convert address to PRP      
+        http_options[:body][:resolution] = Touchpass.resolution # Resolution used to calculate PRP
+        prp = Touchpass::Proximity::PRP.new(:address => address, :resolution => Touchpass.resolution)
+
+        # Generate random salt
+        salt = Touchpass::Crypt.salt
+
+        # Encrypt PRP using salt
+        claimed_prp = prp.encrypt(salt)
+        http_options[:body][:claimed_prp] = claimed_prp
+
+        # Encrypt salt using verifiying_party (to_party) devices
+        if !devices.nil? and (devices.is_a? Array and !devices.empty?)
+          devices.each_with_index do |device, index|
+            device_id = device["id"]
+            pub_key = device["pub_key"]
+            public_key = Touchpass::Crypt.read_key(pub_key)
+            crypted_salt = Base64.encode64(public_key.public_encrypt(salt))
+            http_options[:body]["crypted_salts[#{index}][device_id]"] = device_id
+            http_options[:body]["crypted_salts[#{index}][value]"] = crypted_salt
+          end
+        end
+      end
+
+      def create_crypted_messages(message, devices, http_options)
+        return if message.blank?
+        return if devices.nil? or (devices.is_a? Array and devices.empty?)
+
+        # Encrypt message using verifying party devices public key
+        devices.each_with_index do |device, index|
+          device_id = device["id"]
+          pub_key = device["pub_key"]
+          public_key = Touchpass::Crypt.read_key(pub_key)
+          crypted_message = Base64.encode64(public_key.public_encrypt(message))
+          http_options[:body]["crypted_messages[#{index}][device_id]"] = device_id
+          http_options[:body]["crypted_messages[#{index}][value]"] = crypted_message
+        end
+      end
+      
+      private
+      def api_key_header
+        { Touchpass::Client::API_KEY_HEADER => Touchpass.api_key }
+      end
+
+    end
+  end
+end

data/lib/touchpass/version.rb

@@ -0,0 +1,3 @@
+module Touchpass
+  VERSION = "0.0.8.1"
+end

data/lib/touchpass.rb

@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*-
+require "touchpass/version"
+require 'touchpass/prp'
+require 'touchpass/client'
+require 'touchpass/crypt'
+require 'touchpass/key_file_creator'
+require 'touchpass/verification'
+require 'touchpass/device'
+
+module Touchpass
+  require 'engine' if defined?(Rails) && Rails::VERSION::MAJOR == 3
+
+  config = [:username, :api_key, :use_https, :host, :port, :resolution, :location_verification, :verified_message, :unverified_message]
+
+  # define getter and setter methods for each config
+  # normally we can use mattr_accessor :key for shortcut, but this only available in Rails environment
+  config.each do |symbol|
+    eval("@@#{symbol.to_s} = nil")
+    module_eval( "def self.#{symbol.to_s}() @@#{symbol.to_s}; end" )
+    module_eval( "def self.#{symbol.to_s}=(val) @@#{symbol.to_s} = val; end" )
+  end
+
+  # Default way to setup Touchpass. Run rails generate touchpass_install to create
+  # a fresh initializer with all configuration values.
+  def self.setup
+    yield self
+  end
+  
+  def self.base_uri
+    tp_base_uri = Touchpass.host
+    if Touchpass.port.present?
+      tp_base_uri += ":#{Touchpass.port}"
+    end
+    protocol = Touchpass.use_https ? "https://" : "http://"
+    tp_base_uri = protocol + tp_base_uri
+  end  
+  
+  module Role
+    RELYING_PARTY   = "relying_party"
+    VERIFYING_PARTY = "verifying_party"
+  end
+
+  module MessagingType
+    APN     = "apn"
+    APN_DEV = "apn-development"
+    #SMS     = "sms" # not supported yet
+
+    def self.all
+      [APN, APN_DEV]
+    end
+  end
+  
+end

data/spec/bounding_box_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe "Bounding Box" do
+
+  context "using north of equator" do
+    it "should have 4 points (top_left, top_right, bottom_right, bottom_left)" do
+      prp = Touchpass::Proximity::PRP.new(north_of_equator)
+      prp.bounding_box.size.should eql(4)
+      for point in [:top_left, :top_right, :bottom_right, :bottom_left]
+        prp.bounding_box[point].should be
+      end
+    end
+  end
+
+  context "using orbitec office in sydney" do
+    it "should have 4 points (top_left, top_right, bottom_right, bottom_left)" do
+      Geocoder.should_receive(:coordinates).and_return([1, 2])  # dummy values
+
+      prp = Touchpass::Proximity::PRP.new(:address => orbitec_office)
+      prp.bounding_box.size.should eql(4)
+      for point in [:top_left, :top_right, :bottom_right, :bottom_left]
+        prp.bounding_box[point].should be
+      end
+    end
+  end
+end

data/spec/geocode_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe "Geocode" do
+
+  for address in addresses
+
+    it "should find geographic coordinates for address '#{address}'" do
+      dummy_lat = 10
+      dummy_lon = 11
+
+      # avoid hammering the geocode server
+      # (we just want to test Touchpass::Proximity::PRP, rather than Geocoder)
+      Geocoder.should_receive(:coordinates).and_return([dummy_lat, dummy_lon])
+
+      prp = Touchpass::Proximity::PRP.new(:address => address)
+      prp.lat.should == dummy_lat
+      prp.lng.should == dummy_lon
+    end
+
+  end
+
+end

data/spec/helpers/client_spec_helper.rb

@@ -0,0 +1 @@
+require 'touchpass'

data/spec/helpers/gtp_spec_helper.rb

@@ -0,0 +1,98 @@
+require 'touchpass'
+
+def orbitec_office
+  '120 Sussex St Sydney NSW 2000 Australia'
+end
+
+def apple_store_sydney
+  '367 George Street Sydney 2000 NSW Australia'
+end
+
+def mecca_espresso_king_st
+  '67 King Street Sydney 2000 NSW Australia'
+end
+
+def talga_rd_rothbury
+  '127 Talga Rd Rothbury NSW 2320 Australia'
+end
+
+def cessnock_post_office
+  '16/205 Wollombi Rd Cessnock NSW 2325 Australia'
+end
+
+def holdsworth_st_neutralbay
+  '2/10 Holdsworth St Neutral Bay New South Wales 2089'
+end
+
+def north_sydney_post_office
+  '92 Pacific Highway North Sydney NSW 2060 Australia'
+end
+
+def empire_state_building
+  '350 5th Avenue New York, NY 10118-3304, United States'
+end
+
+def chrysler_building
+  'Chrysler Building, New York, NY, United States'
+end
+
+def themet
+  'Metropolitan Museum of Art 5th Avenue New York NY United States'
+end
+
+def addresses
+  [orbitec_office, apple_store_sydney, mecca_espresso_king_st, talga_rd_rothbury, cessnock_post_office, holdsworth_st_neutralbay, north_sydney_post_office,
+    empire_state_building, chrysler_building, themet]
+end
+
+def resolutions
+  ['street', 'local', 'metro', 'regional']
+end
+
+def north_of_equator
+  { :lat => 0.0525, :lng => 151.2348 }
+end
+
+def south_of_equator
+  { :lat => -0.0525, :lng => 151.2348 }
+end
+
+def east_of_gmt
+  { :lat => 33.8, :lng => 0.0525 }
+end
+
+def west_of_gmt
+  { :lat => 33.8, :lng => -0.0525 }
+end
+
+def north_west_of_equator_and_gmt
+  { :lat => 0.0525, :lng => -0.0525 }
+end
+
+def north_east_of_equator_and_gmt
+  { :lat => 0.0525, :lng => 0.0525 }
+end
+
+def south_east_of_equator_and_gmt
+  { :lat => -0.0525, :lng => 0.0525 }
+end
+
+def south_west_of_equator_and_gmt
+  { :lat => -0.0525, :lng => -0.0525 }
+end
+
+def cornercase1
+  { :lat => -0.15, :lng => -0.15 }
+end
+
+def cornercase2
+  { :lat =>  0.15, :lng =>  0.15 }
+end
+
+def cornercase3
+  { :lat =>  0.15, :lng => -0.15 }
+end
+
+def cornercase4
+  { :lat => -0.15, :lng =>  0.15 }
+end

data/spec/key_file_creator_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe "Key File Creator" do
+
+  context "create public / private keys" do
+    
+    before do
+      @device_id       = "1"
+      @device_udid     = "747c37dc35b66830e921148398e77f3b3f5e2c3b"
+      @key_file_helper = Touchpass::KeyFileCreator.new(@device_id)
+    end
+    
+    it "should initialise" do
+      @key_file_helper.should be
+    end
+    
+    it "should create public and private key files" do
+      @key_file_helper.generate_keys
+      
+      # Read in the public and private keys from the generated files
+      expected_public_key  = OpenSSL::PKey::RSA.new(File.read(File.join(Touchpass::KeyFileCreator.keys_path, @device_id, Touchpass::KeyFileCreator::PUBLIC_KEY))).to_s
+      expected_private_key = OpenSSL::PKey::RSA.new(File.read(File.join(Touchpass::KeyFileCreator.keys_path, @device_id, Touchpass::KeyFileCreator::PRIVATE_KEY))).to_s
+      
+      @key_file_helper.public_key.to_s.should  == expected_public_key
+      @key_file_helper.private_key.to_s.should == expected_private_key
+    end
+    
+  end
+  
+end