ephemeral_calc 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d8cecf935ff387d53df0c4f3a5ab898810061627
-  data.tar.gz: 4a303fa845749f4c4f33c7df5e0616fd08e3d018
+  metadata.gz: d66ed2f2feb08b61474d5e99d9906de5702b409a
+  data.tar.gz: 448f9eb5dbad2eb1cc99e097f384d0041a60ebcc
 SHA512:
-  metadata.gz: 134e6ceb11fa9daeafb21b228e9a97289ed25eaa953a525a81d9058a0bf0d5a38f531ff5aedd578933018ebbba0ee0f1c5edcab4812340fc91a8764c3eb06c85
-  data.tar.gz: c03aaa19d4f06effd6fe854cd22d4ba7be0f75612a07f4ca256f90776f8209370017da3b1698e609f856929220a0dfeee3b519fa1ed88b7e154cdb177b233aa4
+  metadata.gz: 0f4e472ea04511a2406a17897c2571a4337dbffef92796661d8b66de8e5a26ce4a834859b0e6352cda6e26d147535cd27cf8ab55c994e533822e9b7979eb8914
+  data.tar.gz: f0a98210f4e975c70ef30de5beb8c2dc6af80b2837eb9d6969f7d5afec7e938883467b38c6907d3daa7ec44733d4057d4d6d8ab049e255b6ca1c2da05bceb686

data/ephemeral_calc.gemspec

@@ -20,6 +20,8 @@ Gem::Specification.new do |spec|
   spec.extensions    = %w[ext/curve25519/extconf.rb]
   spec.require_paths = ["lib"]
 
+  spec.add_runtime_dependency "proximity_beacon", "~> 0.1.3"
+
   spec.add_development_dependency "bundler", "~> 1.10"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec"

data/exe/ephemeral_calc

@@ -53,11 +53,13 @@ Commands:
     access the API.
 
   register:
-    ephemeral_calc register <beacon_public_key> <rotation_scaler> <initial_eid> <initial_clock> <namespace> <instance>
+    ephemeral_calc register <beacon_description> [<rotation_exp> [<namespace> [<instance]]]
 
-    Registers an EID beacon with Google's Proximity Beacon API. All keys and byte strings should be in hex.
-    Uses environment variables "GOOGLE_CLIENT_ID" and "GOOGLE_CLIENT_SECRET" to do the necessary OAuth in
-    order to access the API.
+    Registers an EID beacon with Google's Proximity Beacon API. All byte strings should be in hex. If you
+    do not supply a namespace it will use the following: 'e3dd811dd3bbe49e630a'. If you do not supply an
+    instance it will randomly generate one. Uses environment variables "GOOGLE_CLIENT_ID" and
+    "GOOGLE_CLIENT_SECRET" to do the neccessary OAuth in order to access the API. Outputs YAML which
+    contains all the information necessary to advertise as this registered beacon.
 
   keygen:
     ephemeral_calc keygen
@@ -135,18 +137,17 @@ eos
     eid_hex = ARGV.shift
     api_key = ENV["GOOGLE_API_KEY"]
 
+    client = ProximityBeacon::Client.new
     if api_key
-      client = EphemeralCalc::GoogleAPI::Client.new(nil) # don't try oauth
       response = client.getforobserved(eid_hex, api_key)
       beacons = response["beacons"]
       beacon = beacons[0] if beacons
     else
       beacon_name = "beacons/4!#{eid_hex.downcase}"
       begin
-        beacon = oauth_client.get_resource(beacon_name)
-        attachments = oauth_client.get_resource("#{beacon_name}/attachments")
-        beacon.merge!(attachments)
-      rescue EphemeralCalc::GoogleAPI::RequestError => e
+        beacon = client.beacons.get(beacon_name).as_json
+        beacon["attachments"] = client.attachments.list(beacon_name).map(&:as_json)
+      rescue ProximityBeacon::Client::RequestError => e
         # if we get a 404, the EID doesn't resolve
         raise e unless e.code == 404
       end
@@ -161,7 +162,7 @@ eos
 
   def eidparams
     require 'yaml'
-    eidparams = oauth_client.eidparams
+    eidparams = ProximityBeacon::Client.new.eidparams
     key_hex = to_hex(Base64.decode64(eidparams["serviceEcdhPublicKey"]))
     eidparams["serviceEcdhPublicKeyHex"] = key_hex
     puts eidparams.to_yaml
@@ -177,15 +178,18 @@ eos
 
   def register
     require 'yaml'
-    beacon_public_key = from_hex(ARGV.shift)
-    rotation_scaler = ARGV.shift
-    initial_eid = from_hex(ARGV.shift)
-    initial_clock = ARGV.shift
-    namespace = from_hex(ARGV.shift)
-    instance = from_hex(ARGV.shift)
-    uid_bytes = namespace + instance
-    response = oauth_client.register_eid(beacon_public_key, rotation_scaler, initial_eid, initial_clock, uid_bytes)
-    puts response.to_yaml
+    name = ARGV.shift
+    rotation_exp = ARGV.shift
+    namespace = ARGV.shift
+    instance = ARGV.shift
+    registration = EphemeralCalc::Registration.new(
+      name: name,
+      rotation_exp: rotation_exp,
+      namespace: namespace,
+      instance: instance
+    )
+    registration.register
+    puts registration.to_yaml
   end
 
   def keygen
@@ -207,14 +211,6 @@ eos
     end
   end
 
-  def oauth_client
-    @oauth_client ||=
-      begin
-        client = EphemeralCalc::GoogleAPI::Client.new
-        client.credentials.save
-        client
-      end
-  end
 end
 
 app = App.new

data/lib/ephemeral_calc/registration.rb

@@ -0,0 +1,89 @@
+module EphemeralCalc
+  class Registration
+
+    DEFAULT_NAMESPACE = "e3dd811dd3bbe49e630a"
+    DEFAULT_ROTATION_EXP = 12 # 2^12 = ~68 minutes
+
+    attr_reader :name,
+                :rotation_exp,
+                :namespace,
+                :instance,
+                :beacon_private_key,
+                :beacon_keypair,
+                :beacon_time_zero
+
+    def initialize(name:,
+                   rotation_exp: nil,
+                   namespace: nil,
+                   instance: nil,
+                   beacon_private_key: nil)
+      @name = name
+      @rotation_exp = (rotation_exp || DEFAULT_ROTATION_EXP).to_i
+      @namespace = namespace || DEFAULT_NAMESPACE
+      @instance = instance || random_instance
+      @beacon_private_key = beacon_private_key || EphemeralCalc::KeyPair.generate_private_key
+      @beacon_keypair = EphemeralCalc::KeyPair.new(@beacon_private_key)
+    end
+
+    def api_client
+      @api_client ||= ProximityBeacon::Client.new
+    end
+
+    def eid_params
+      @eid_params ||= api_client.eidparams
+    end
+
+    def resolver_public_key
+      Base64.decode64(eid_params["serviceEcdhPublicKey"])
+    end
+
+    def identity_key
+      beacon_keypair.identity_key(resolver_public_key: resolver_public_key)
+    end
+
+    def encryptor
+      @encryptor ||= EphemeralCalc::Encryptor.new(identity_key, rotation_exp)
+    end
+
+    def initial_eid
+      [encryptor.get_identifier(0)].pack("H*")
+    end
+
+    def register
+      beacon = ProximityBeacon::Beacon.new(
+        ephemeral_id_registration: {
+          beaconEcdhPublicKey: Base64.strict_encode64(beacon_keypair.public_key),
+          serviceEcdhPublicKey: eid_params["serviceEcdhPublicKey"],
+          rotationPeriodExponent: rotation_exp,
+          initialClockValue: encryptor.beacon_time,
+          initialEid: Base64.strict_encode64(initial_eid)
+        },
+        advertised_id: ProximityBeacon::AdvertisedId.new(
+          eddystone_ids: [namespace, instance]
+        ),
+        status: "ACTIVE",
+        description: self.name,
+      )
+      api_client.beacons.register(beacon)
+    end
+
+    def as_yaml
+      {
+        identity_key: identity_key,
+        rotation_exp: rotation_exp,
+        initial_time: encryptor.initial_time,
+      }
+    end
+
+    def to_yaml
+      as_yaml.to_yaml
+    end
+
+  private
+
+    def random_instance
+      SecureRandom.random_bytes(6).unpack("H*")[0]
+    end
+
+  end
+end

data/lib/ephemeral_calc/version.rb

@@ -1,3 +1,3 @@
 module EphemeralCalc
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/ephemeral_calc.rb

@@ -1,11 +1,10 @@
+require "proximity_beacon"
+
 require "ephemeral_calc/version"
 require "ephemeral_calc/curve25519"
 require "ephemeral_calc/encryptor"
 require "ephemeral_calc/key_pair"
-require "ephemeral_calc/google_api/oauth"
-require "ephemeral_calc/google_api/credentials"
-require "ephemeral_calc/google_api/request"
-require "ephemeral_calc/google_api/client"
+require "ephemeral_calc/registration"
 
 module EphemeralCalc
   # Your code goes here...

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: ephemeral_calc
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Radius Networks
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-08-12 00:00:00.000000000 Z
+date: 2016-08-15 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: proximity_beacon
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.3
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -106,11 +120,8 @@ files:
 - ext/curve25519/extconf.rb
 - lib/ephemeral_calc.rb
 - lib/ephemeral_calc/encryptor.rb
-- lib/ephemeral_calc/google_api/client.rb
-- lib/ephemeral_calc/google_api/credentials.rb
-- lib/ephemeral_calc/google_api/oauth.rb
-- lib/ephemeral_calc/google_api/request.rb
 - lib/ephemeral_calc/key_pair.rb
+- lib/ephemeral_calc/registration.rb
 - lib/ephemeral_calc/version.rb
 homepage: https://github.com/RadiusNetworks/ephemeral_calc
 licenses: []

data/lib/ephemeral_calc/google_api/client.rb

@@ -1,82 +0,0 @@
-require 'json'
-require 'uri'
-require 'net/http'
-require 'base64'
-
-module EphemeralCalc
-  module GoogleAPI
-    class Client
-
-      PROXIMITY_BEACON_ROOT = "https://proximitybeacon.googleapis.com/v1beta1/"
-      EIDPARAMS_URI = URI(PROXIMITY_BEACON_ROOT + "eidparams")
-      BEACON_REGISTER_URI = URI(PROXIMITY_BEACON_ROOT + "beacons:register")
-
-      attr_accessor :credentials
-
-      def initialize(credentials = OAuth.new.get_credentials)
-        self.credentials = credentials
-      end
-
-      def eidparams
-        response = Request.get(EIDPARAMS_URI, credentials)
-        # response = request(:get, EIDPARAMS_URI, credentials.access_token)
-        return JSON.parse(response.body)
-      end
-
-      def register_eid(beacon_public_key, rotation_exp, initial_eid, initial_clock, uid_bytes)
-        service_public_key_base64 = get_eidparams["serviceEcdhPublicKey"]
-        response = Request.post(BEACON_REGISTER_URI, credentials) {|request|
-          request.add_field "Content-Type", "application/json"
-          request.body = {
-            ephemeralIdRegistration: {
-              beaconEcdhPublicKey: Base64.strict_encode64(beacon_public_key),
-              serviceEcdhPublicKey: service_public_key_base64,
-              rotationPeriodExponent: rotation_exp,
-              initialClockValue: initial_clock,
-              initialEid: Base64.strict_encode64(initial_eid)
-            },
-            advertisedId: {
-              type: "EDDYSTONE",
-              id: Base64.strict_encode64(uid_bytes)
-            },
-            status: "ACTIVE",
-            description: "EphemeralCalc Registered EID"
-          }.to_json
-        }
-        JSON.parse(response.body)
-      end
-
-      def get_resource(resource_name)
-        uri = URI(PROXIMITY_BEACON_ROOT + resource_name)
-        response = Request.get(uri, credentials)
-        JSON.parse(response.body)
-      end
-
-      def getforobserved(eids, api_key = ENV["GOOGLE_API_KEY"])
-        uri = URI("#{PROXIMITY_BEACON_ROOT}beaconinfo:getforobserved?key=#{api_key}")
-        response = Request.post(uri) {|request|
-          observations = Array(eids).map {|eid|
-            {advertisedId: {type: "EDDYSTONE_EID", id: base64_eid(eid)}}
-          }
-          request.body = {
-            observations: observations,
-            namespacedTypes: "*",
-          }.to_json
-          request.add_field "Content-Type", "application/json"
-        }
-        JSON.parse(response.body)
-      end
-
-    private
-
-      def base64_eid(eid)
-        if eid.size == 16
-          Base64.strict_encode64([eid].pack("H*"))
-        else
-          Base64.strict_encode64(eid)
-        end
-      end
-
-    end
-  end
-end

data/lib/ephemeral_calc/google_api/credentials.rb

@@ -1,39 +0,0 @@
-require 'yaml'
-
-module EphemeralCalc
-  module GoogleAPI
-    class Credentials
-
-      DEFAULT_FILE_STORE = File.expand_path("~/.ephemeral_calc_google_credentials.yaml")
-      attr_accessor :access_token, :refresh_token, :expires_at
-
-      def self.from_file(file = DEFAULT_FILE_STORE)
-        return nil unless File.exist?(file)
-        self.new YAML.load_file(file)
-      end
-
-      def initialize(opts = {})
-        # convert string keys to symbols
-        opts = opts.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
-
-        self.access_token = opts[:access_token]
-        self.refresh_token = opts[:refresh_token]
-        self.expires_at = opts[:expires_at] || (Time.now + opts[:expires_in].to_i)
-      end
-
-      def save(file = DEFAULT_FILE_STORE)
-        data = {
-          access_token:  access_token,
-          refresh_token: refresh_token,
-          expires_at:    expires_at
-        }.to_yaml
-        File.open(file, 'w') {|f| f.write(data) }
-      end
-
-      def expired?
-        self.expires_at < Time.now
-      end
-
-    end
-  end
-end

data/lib/ephemeral_calc/google_api/oauth.rb

@@ -1,87 +0,0 @@
-require 'json'
-require 'uri'
-require 'net/http'
-
-module EphemeralCalc
-  module GoogleAPI
-    class OAuth
-
-      SCOPES = [
-        "https://www.googleapis.com/auth/userlocation.beacon.registry",
-        "https://www.googleapis.com/auth/cloud-platform",
-      ]
-
-      REDIRECT_URI = "urn:ietf:wg:oauth:2.0:oob"
-      TOKEN_URI = URI("https://www.googleapis.com/oauth2/v4/token")
-
-      attr_accessor :client_id, :secret
-
-      def initialize(client_id = ENV["GOOGLE_CLIENT_ID"], secret = ENV["GOOGLE_CLIENT_SECRET"])
-        if client_id.nil? || secret.nil?
-          raise ArgumentError, "No Google Client ID or Secret was set. These can set in the environment variables \"GOOGLE_CLIENT_ID\" and \"GOOGLE_CLIENT_SECRET\" respectively. Credentials must be created for your project at \"https://console.developers.google.com/apis/credentials\"."
-        end
-        self.client_id = client_id
-        self.secret = secret
-      end
-
-      def get_code
-        puts("Performing OAuth with Google...")
-        if RUBY_PLATFORM =~ /darwin/
-          system("open \"#{url}\"")
-        else
-          puts("Open this URL in your browser: \"#{url}\"\n\n")
-        end
-        printf "Copy and paste code from web browser here: "
-        _code = STDIN.gets.chomp
-      end
-
-      def get_credentials(old_credentials = Credentials.from_file)
-        return old_credentials if old_credentials && !old_credentials.expired?
-        response = Request.post(TOKEN_URI) {|request|
-          request.body = hash_to_params( token_request_params(old_credentials) )
-        }
-        json = JSON.parse(response.body)
-        credentials = Credentials.new(json)
-        if old_credentials
-          credentials.refresh_token = old_credentials.refresh_token
-        end
-        return credentials
-      end
-
-      def url
-        params = hash_to_params(
-          scope: SCOPES.join("%20"),
-          redirect_uri: REDIRECT_URI,
-          response_type: "code",
-          client_id: client_id,
-        )
-        "https://accounts.google.com/o/oauth2/v2/auth?#{params}"
-      end
-
-      def token_request_params(old_credentials)
-        if old_credentials == nil
-          {
-            code: get_code,
-            client_id: client_id,
-            client_secret: secret,
-            redirect_uri: REDIRECT_URI,
-            grant_type: "authorization_code",
-          }
-        else
-          # this is a refresh of the old credentials
-          {
-            refresh_token: old_credentials.refresh_token,
-            client_id: client_id,
-            client_secret: secret,
-            grant_type: "refresh_token",
-          }
-        end
-      end
-
-      def hash_to_params(hash)
-        hash.map {|k,v| "#{k}=#{v}"}.join("&")
-      end
-
-    end
-  end
-end

data/lib/ephemeral_calc/google_api/request.rb

@@ -1,69 +0,0 @@
-require 'forwardable'
-require 'uri'
-require 'net/http'
-require 'base64'
-
-module EphemeralCalc
-  module GoogleAPI
-    class Request
-      extend Forwardable
-
-      attr_accessor :method, :uri, :credentials
-      def_delegators :request, :add_field, :body=
-
-      def self.get(uri, credentials = nil)
-        result = self.new(:get, uri, credentials)
-        result.perform {|r| yield r if block_given? }
-      end
-
-      def self.post(uri, credentials = nil)
-        result = self.new(:post, uri, credentials)
-        result.perform {|r| yield r if block_given? }
-      end
-
-      def initialize(method, uri, credentials = nil)
-        self.method = method
-        self.uri = uri
-        self.credentials = credentials
-        yield self if block_given?
-      end
-
-      def perform
-        http_opts = {use_ssl: true}
-        response = Net::HTTP.start(uri.host, uri.port, http_opts) do |http|
-          add_field "Authorization", "Bearer #{credentials.access_token}" if credentials
-          add_field "Accept", "application/json"
-          yield self if block_given?
-          http.request request
-        end
-        if (200..299).include?(response.code.to_i)
-          return response
-        else
-          raise RequestError.new(response.code.to_i), "Error #{response.code} (#{response.msg}) - #{uri}\n#{response.body}"
-        end
-      end
-
-    private
-
-      def request
-        @request ||=
-          begin
-            case method
-            when :get
-              Net::HTTP::Get.new uri.request_uri
-            when :post
-              Net::HTTP::Post.new uri.request_uri
-            end
-          end
-      end
-    end
-
-    class RequestError < StandardError
-      attr_accessor :code
-      def initialize(code)
-        self.code = code
-      end
-    end
-
-  end
-end