ephemeral_calc 0.2.0

checksums.yaml

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

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+/spec/examples.txt

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.1.2
+before_install: gem install bundler -v 1.10.6

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

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

data/README.md

@@ -0,0 +1,60 @@
+# EphemeralCalc
+
+A Ruby gem that allows you to calculate ephemeral identifiers for Eddystone-EID beacons.
+
+# Example Usage
+
+```ruby
+# insert real resolver key here
+resolver_public_key = "61136adab1bf302f1c49e860196aeefd8fbaa41518b4c226372d6cc469c47278"
+# generate a new key pair for the beacon
+beacon_keys = EphemeralCalc::KeyPair.new
+# calculate the identity key
+identity_key = beacon_keys.identity_key(resolver_public_key: resolver_public_key)
+# set up the encryptor
+rotation_exponent = 10
+encryptor = EphemeralCalc::Encryptor.new identity_key, rotation_exponent
+# get the initial eid
+initial_eid = encryptor.get_identifier(0)
+
+# yield eid values as it rotates
+encryptor.each_identifier do |eid|
+  puts "Quantum: #{encryptor.quantum}, EID: #{eid}"
+end
+```
+
+# Command Line Usage
+The `ephemeral_calc` executable is included to allow you to generate keypairs, and do general eid calculation
+without having to write any code.
+
+```shell
+# display CLI help
+ephemeral_calc
+
+# set up EphemeralCalc for Google OAuth
+export GOOGLE_CLIENT_ID="xxxx"
+export GOOGLE_CLIENT_SECRET="yyyy"
+
+# get EID registration parameters from Google's API using OAuth
+ephemeral_calc eidparams
+
+# resolve an EID using a Google project's API key
+API_KEY=xxxx ephemeral_calc resolve 0123456789ABCDEF
+
+# resolve EID using OAuth
+ephemeral_calc resolve 0123456789ABCDEF
+
+# list first 5 EIDs given identity key, rotation scaler
+ephemeral_calc list 553C66DA1485E9F78849DE00F2CB178E 12 0 5
+```
+
+## 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/radiusnetworks/ephemeral_calc. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
+

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rake/extensiontask"
+
+Rake::ExtensionTask.new "curve25519" do |ext|
+  ext.lib_dir = "lib/ephemeral_calc"
+end
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "eid_utils"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/rspec

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by Bundler.
+#
+# The application 'rspec' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('rspec-core', 'rspec')

data/bin/setup

@@ -0,0 +1,12 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+echo
+echo "== Installing dependencies =="
+bundle install
+
+# Do any other automated setup that you need to do here
+echo
+echo "== Compiling Native Extensions =="
+bundle exec rake compile

data/ephemeral_calc.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ephemeral_calc/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ephemeral_calc"
+  spec.version       = EphemeralCalc::VERSION
+
+  spec.authors       = ["Radius Networks"]
+  spec.email         = ["support@radiusnetworks.com"]
+
+  spec.summary       = %q{Tools to calculate Eddystone ephemeral identifiers}
+  spec.description   = %q{Tools to calculate Eddystone ephemeral identifiers}
+  spec.homepage      = "https://github.com/RadiusNetworks/ephemeral_calc"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.extensions    = %w[ext/curve25519/extconf.rb]
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "webmock"
+  spec.add_development_dependency "rake-compiler"
+end

data/exe/ephemeral_calc

@@ -0,0 +1,227 @@
+#!/usr/bin/env ruby
+
+
+require 'ephemeral_calc'
+
+class App
+
+  def help
+    help_text = <<eos
+Usage:
+    ephemeral_calc <command> <arguments>
+
+Commands:
+
+  beacon:
+    ephemeral_calc beacon <ik> <scaler> <beacon_initial_time_seconds> <service_initial_time_seconds>
+
+    Given the identity key, the beacon rotation exponent, and the times of
+    registration for the beacon and the service, this computes the eid that the
+    beacon is currently broadcasting.
+
+  track:
+    ephemeral_calc track <ik> <scaler> <beacon_initial_time_seconds> <service_initial_time_seconds>
+
+    Given the identity key, the beacon rotation exponent, and the times of
+    registration for the beacon and the service, this displays the current eid and
+    outputs new eids as they are calculated, until the user presses <ctrl-c>.
+
+  eid:
+    ephemeral_calc eid <identity_key_hex> <rotation_scaler> <beacon_time_seconds>
+
+    Generates an EID from the given 16-bytes identity key, the scaler and the
+    beacon time in seconds.
+
+  list:
+    ephemeral_calc list <identity_key_hex> <rotation_scaler> <beacon_time_seconds> <count>
+
+    Lists <count> EIDs, starting at <beacon_time_seconds>
+
+  resolve:
+    ephemeral_calc resolve <eid_hex>
+
+    Resolves the given EID to a beacon contained in Google's Proximity Beacon API. If you supply an
+    api key (via the environment variable "GOOGLE_API_KEY") it will use that and call the
+    "getforobserved" API endpoint. Otherwise it will attempt to use OAuth for authentication and
+    use the admin api endpoint to get the beacon details.
+
+  eidparams:
+    ephemeral_calc eidparams
+
+    Gets the EID registration parameters from Google's Proximity Beacon API. Uses environment
+    variables "GOOGLE_CLIENT_ID" and "GOOGLE_CLIENT_SECRET" to do the necessary OAuth in order to
+    access the API.
+
+  register:
+    ephemeral_calc register <beacon_public_key> <rotation_scaler> <initial_eid> <initial_clock> <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.
+
+  keygen:
+    ephemeral_calc keygen
+
+    Generates a curve25519 keypair
+eos
+    puts help_text
+  end
+
+  COMMANDS = [:beacon, :track, :eid, :list, :resolve, :keygen, :eidparams, :register]
+
+  def beacon(track = false)
+    identity_key = ARGV.shift
+    rotation_scalar = ARGV.shift.to_i
+    beacon_initial_time = ARGV.shift.to_i
+    service_initial_time = ARGV.shift.to_i
+    beacon_time_zero = Time.at( service_initial_time - beacon_initial_time)
+    encryptor = EphemeralCalc::Encryptor.new identity_key, rotation_scalar, beacon_time_zero
+    beacon_time = encryptor.beacon_time
+    current_eid = encryptor.get_identifier
+    previous_eid = encryptor.get_identifier(beacon_time - 2**rotation_scalar)
+    next_eid = encryptor.get_identifier(beacon_time + 2**rotation_scalar)
+
+    if !track
+      puts "Previous EID: #{previous_eid}" if previous_eid
+      puts " Current EID: #{current_eid}"
+      puts "    Next EID: #{next_eid}"
+    else
+      puts "Press <ctrl-c> to stop"
+      begin
+        encryptor.each_identifier do |eid|
+          puts "Quantum: #{encryptor.quantum}, EID: #{eid}"
+        end
+      rescue SignalException => e
+        # ignore CTRL-C, just exit
+      end
+    end
+  end
+
+  def track
+    beacon(true)
+  end
+
+  def eid
+    identity_key = ARGV.shift
+    rotation_scalar = ARGV.shift.to_i
+    beacon_time = (ARGV.shift || 0).to_i
+    encryptor = EphemeralCalc::Encryptor.new identity_key, rotation_scalar
+    quantum = beacon_time / 2**rotation_scalar
+    eid = encryptor.get_identifier(beacon_time)
+    puts "Identity Key: #{identity_key}"
+    puts " Beacon Time: #{beacon_time}"
+    puts "     Quantum: #{quantum}"
+    puts "Ephemeral ID: #{eid}"
+  end
+
+  def list
+    identity_key = ARGV.shift
+    rotation_scalar = ARGV.shift.to_i
+    beacon_time = ARGV.shift.to_i
+    count = ARGV.shift.to_i
+    encryptor = EphemeralCalc::Encryptor.new identity_key, rotation_scalar
+    start_quantum = beacon_time / 2**rotation_scalar
+    end_quantum = start_quantum + count - 1
+    start_quantum.upto(end_quantum) do |quantum|
+      start_time = quantum * 2**rotation_scalar
+      end_time = start_time + 2**rotation_scalar
+      eid = encryptor.get_identifier(start_time)
+      puts "EID: #{eid}, Quantum: #{quantum} (#{seconds_display(start_time)} - #{seconds_display(end_time)})"
+    end
+  end
+
+  def resolve
+    require 'yaml'
+    eid_hex = ARGV.shift
+    api_key = ENV["GOOGLE_API_KEY"]
+
+    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
+        # if we get a 404, the EID doesn't resolve
+        raise e unless e.code == 404
+      end
+    end
+
+    if beacon == nil
+      puts "Does not resolve!"
+    else
+      puts beacon.to_yaml
+    end
+  end
+
+  def eidparams
+    require 'yaml'
+    eidparams = oauth_client.eidparams
+    key_hex = to_hex(Base64.decode64(eidparams["serviceEcdhPublicKey"]))
+    eidparams["serviceEcdhPublicKeyHex"] = key_hex
+    puts eidparams.to_yaml
+  end
+
+  def to_hex(bytes)
+    bytes.unpack("H*")[0].upcase
+  end
+
+  def from_hex(hex)
+    [hex].pack("H*")
+  end
+
+  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
+  end
+
+  def keygen
+    key_pair = EphemeralCalc::KeyPair.new
+    puts "Private Key: #{to_hex(key_pair.private_key)}"
+    puts " Public Key: #{to_hex(key_pair.public_key)}"
+  end
+
+  def seconds_display(seconds)
+    case
+    when seconds >= 86400
+      "#{seconds / 86400}d " + seconds_display(seconds % 86400)
+    when seconds >= 3600
+      "#{seconds / 3600}h " + seconds_display(seconds % 3600)
+    when seconds >= 60
+      "#{seconds / 60}m " + seconds_display(seconds % 60)
+    else
+      "#{seconds}s"
+    end
+  end
+
+  def oauth_client
+    @oauth_client ||=
+      begin
+        client = EphemeralCalc::GoogleAPI::Client.new
+        client.credentials.save
+        client
+      end
+  end
+end
+
+app = App.new
+command = ARGV.shift
+
+if command && App::COMMANDS.include?(command.to_sym)
+  app.send(command)
+else
+  app.help
+end