poly_pseudo 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fdab923c65e6f7879610f7942818cca80a8454eb
+  data.tar.gz: ef974d8386486a49767e202a1ded93a98fb67bbf
+SHA512:
+  metadata.gz: ca52fb9aeb48edcf19768067ad46d5b25f0e3091a3db70e3c62d67d6c89fb22b602b64a92f2be7599402b2bfca34089b65eb0a227cd0a0466b73708dd76368b2
+  data.tar.gz: 4512bb3314f9b1493ca06be4b2e18418c34042f8eb4f184ba1762808f56e8fbd8621248727c39b19eb950002aa9b009b5208f018439f2aabf978231adcf3b6bc

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.13.1

data/Gemfile

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

data/README.md

@@ -0,0 +1,79 @@
+# PolyPseudo
+
+## Installation
+
+Make sure you have installed OpenSSL 1.0.2+.
+
+    $ brew install openssl
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'poly_pseudo'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install poly_pseudo
+
+## Usage
+
+```ruby
+require 'poly_pseudo'
+
+encoded_asn1 = <<-BASE64
+MIIBVAYMYIQQAYdrg+MFAQIBAgEBAgEBFhQwMDAwMDAwNDAwMzIxNDM0NTAwMRYU
+MDAwMDAwMDMyNzMyMjYzMTAwMDACBAEzok4wgfkEUQQdTrTmvUoznOB+4bGfted+
+sc7mnN2M2k9T/c2ZXvOYf8CwniAsnxVgzTzsoEpg8NRJq6aBjFCyBz3NwOulwrNE
+4/Q+2v0eE6R9Cvd8ngeL7QRRBEybIwRxjf6/9xWlMSg3aINSJf2GQaJjkp+uQudg
+slmExVSUUidHeS4rRqh7MEiOulqAYF6UkvXFYCUGU7DRScIxGf8xPYmULaYnMSle
+cpeMBFEElI6gAq+crdUFVzkF7bNFX+tEUIiGvc7daUbYpoatwogyGveoPvgOt3MC
+t38iHgW3leqaRomZgNHbjQEgCCy/2VJgdwQYDSs/j++K1KtUMOgEEAAAAAAAAAAA
+AAAAAAAAAAA=
+BASE64
+
+identity_or_pseudonym = PolyPseudo::PseudoId.from_asn1(encoded_asn1)
+
+identity_key   = PolyPseudo::Util.read_key(File.read('EI_Decryption.pem'))
+decryption_key = PolyPseudo::Util.read_key(File.read('EP_Decryption.pem'))
+closing_key    = PolyPseudo::Util.read_key(File.read('EP_Closing.pem'))
+
+case identity_or_pseudonym
+when PolyPseudo::Identity
+    identity_or_pseudonym.decrypt(identity_key)
+when PolyPseudo::Pseudonym
+    identity_or_pseudonym.decrypt(decryption_key, closing_key)
+end
+
+puts identity_or_pseudonym.pseudo_id
+```
+
+## Caveats
+
+OpenSSL 1.0.2 is required.
+On OSX the default openssl is not capable of handling the Brainpool curves. 
+If you installed openssl via homebrew, chances are it's not correctly configured for FFI.
+You will probably get a segmentation fault if you don't have the correct version.
+
+You can configure the openssl library location using the config
+
+```ruby
+PolyPseudo.configure do |config|
+  config.ffi_lib = '/usr/local/opt/openssl/lib/libssl.dylib'
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` 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/digidentity/poly_pseudo.
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "poly_pseudo"
+
+# 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/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/ext/openssl_ec.rb

@@ -0,0 +1,78 @@
+module PolyPseudo
+  module OpenSSLPointExtension
+    extend FFI::Library
+    ffi_lib PolyPseudo.config.ffi_lib
+
+    NID_brainpoolP320r1 = 929
+
+    POINT_CONVERSION_COMPRESSED   = 2
+    POINT_CONVERSION_UNCOMPRESSED = 4
+
+    attach_function :EC_GROUP_new_by_curve_name, [:int], :pointer
+    attach_function :EC_POINT_free, [:pointer], :int
+    attach_function :EC_POINT_add, [:pointer, :pointer, :pointer, :pointer, :pointer], :int
+    attach_function :EC_POINT_point2hex, [:pointer, :pointer, :int, :pointer], :string
+    attach_function :EC_POINT_hex2point, [:pointer, :string, :pointer, :pointer], :pointer
+    attach_function :EC_POINT_new, [:pointer], :pointer
+    attach_function :BN_new, [], :pointer
+    attach_function :BN_free, [:pointer], :int
+    attach_function :BN_bn2hex, [:pointer], :string
+    attach_function :EC_POINT_get_affine_coordinates_GFp, [:pointer, :pointer, :pointer, :pointer, :pointer], :int
+
+    def self.add(point_0, point_1)
+      group       = EC_GROUP_new_by_curve_name(NID_brainpoolP320r1)
+      point_0_hex = point_0.to_bn.to_s(16)
+      point_0_pt  = EC_POINT_hex2point(group, point_0_hex, nil, nil)
+      point_1_hex = point_1.to_bn.to_s(16)
+      point_1_pt  = EC_POINT_hex2point(group, point_1_hex, nil, nil)
+      sum_point   = EC_POINT_new(group)
+      success     = EC_POINT_add(group, sum_point, point_0_pt, point_1_pt, nil)
+      if success
+        hex = EC_POINT_point2hex(group, sum_point, POINT_CONVERSION_COMPRESSED, nil)
+        OpenSSL::PKey::EC::Point.new(PolyPseudo.config.group, OpenSSL::BN.new(hex, 16))
+      end
+    ensure
+      EC_POINT_free(sum_point)
+    end
+
+    def self.x_y(point)
+      group     = EC_GROUP_new_by_curve_name(NID_brainpoolP320r1)
+      point_hex = point.to_bn.to_s(16)
+      point_pt  = EC_POINT_hex2point(group, point_hex, nil, nil)
+      x_coord   = BN_new()
+      y_coord   = BN_new()
+
+      EC_POINT_get_affine_coordinates_GFp(group, point_pt, x_coord, y_coord, nil)
+
+      [OpenSSL::BN.new(BN_bn2hex(x_coord), 16), OpenSSL::BN.new(BN_bn2hex(y_coord), 16)]
+    ensure
+      BN_free(x_coord)
+      BN_free(y_coord)
+    end
+
+    def self.point2hex(point, compressed)
+      group     = EC_GROUP_new_by_curve_name(NID_brainpoolP320r1)
+      point_hex = point.to_bn.to_s(16)
+      point_pt  = EC_POINT_hex2point(group, point_hex, nil, nil)
+      EC_POINT_point2hex(group, point_pt, compressed ? POINT_CONVERSION_COMPRESSED : POINT_CONVERSION_UNCOMPRESSED, nil)
+    end
+  end
+end
+
+class OpenSSL::PKey::EC::Point
+  def add(point)
+    PolyPseudo::OpenSSLPointExtension.add(self, point)
+  end
+
+  def x
+    PolyPseudo::OpenSSLPointExtension.x_y(self)[0]
+  end
+
+  def y
+    PolyPseudo::OpenSSLPointExtension.x_y(self)[1]
+  end
+
+  def to_hex(compressed = true)
+    PolyPseudo::OpenSSLPointExtension.point2hex(self, compressed)
+  end
+end

data/lib/poly_pseudo.rb

@@ -0,0 +1,31 @@
+require 'openssl'
+require 'base64'
+require 'digest'
+require 'ffi'
+
+require 'poly_pseudo/version'
+require 'poly_pseudo/util'
+require 'poly_pseudo/config'
+require 'poly_pseudo/key'
+require 'poly_pseudo/pseudo_id'
+require 'poly_pseudo/identity'
+require 'poly_pseudo/pseudonym'
+
+module PolyPseudo
+  @@loaded = false
+  def self.init!
+    unless @@loaded
+      require 'ext/openssl_ec'
+      @@loaded = true
+    end
+  end
+
+  def self.configure
+    yield config
+    PolyPseudo.init!
+  end
+
+  def self.config
+    @@config ||= Config.new
+  end
+end

data/lib/poly_pseudo/config.rb

@@ -0,0 +1,14 @@
+module PolyPseudo
+  class Config
+    attr_accessor :group_name, :ffi_lib
+
+    def initialize
+      @group_name = 'brainpoolP320r1'
+      @ffi_lib = 'ssl'
+    end
+
+    def group
+      OpenSSL::PKey::EC::Group.new(group_name)
+    end
+  end
+end

data/lib/poly_pseudo/identity.rb

@@ -0,0 +1,30 @@
+module PolyPseudo
+  class Identity
+    include PolyPseudo::PseudoId
+
+    # @param [PolyPseudo::Key] key
+    def decrypt(key)
+      PolyPseudo.init!
+
+      public_key = key.ec.public_key
+
+      raise "Invalid key for decryption" if point_3 != public_key
+
+      private_key = key.ec.private_key
+
+      identity_point = point_1.mul(private_key)
+          .invert!
+          .add(point_2)
+          .make_affine!
+
+      identity_point.x.to_s(16)
+      @identity = Util.oaep_decode(identity_point.x.to_s(2)).slice(3, 10)
+    end
+
+    def identity
+      @identity || raise('Identity not decrypted yet. call .decrypt first')
+    end
+
+    alias_method :pseudo_id, :identity
+  end
+end

data/lib/poly_pseudo/key.rb

@@ -0,0 +1,14 @@
+module PolyPseudo
+  class Key
+    attr_reader :scheme_version, :scheme_key_version, :type, :recipient, :recipient_key_set_version, :ec
+
+    def initialize(attributes)
+      @scheme_version            = attributes["SchemeVersion"]
+      @scheme_key_version        = attributes["SchemeKeyVersion"]
+      @type                      = attributes["Type"]
+      @recipient                 = attributes["Recipient"]
+      @recipient_key_set_version = attributes["RecipientKeySetVersion"]
+      @ec                        = attributes["PrivateKey"]
+    end
+  end
+end

data/lib/poly_pseudo/pseudo_id.rb

@@ -0,0 +1,43 @@
+module PolyPseudo
+  module PseudoId
+    def self.from_asn1(encoded)
+      attributes                           = {}
+      asn1                                 = OpenSSL::ASN1.decode(Base64.decode64(encoded))
+      attributes["Type"]                   = asn1.value[0].value.to_s
+      attributes["SchemaVersion"]          = asn1.value[1].value.to_i
+      attributes["SchemaKeyVersion"]       = asn1.value[2].value.to_i
+      attributes["Creator"]                = asn1.value[3].value.to_s
+      attributes["Recipient"]              = asn1.value[4].value.to_s
+      attributes["RecipientKeySetVersion"] = asn1.value[5].value.to_i
+      attributes["Point1"]                 = OpenSSL::PKey::EC::Point.new(PolyPseudo.config.group,
+                                                                          OpenSSL::BN.new(asn1.value[6].value[0].value, 2))
+      attributes["Point2"]                 = OpenSSL::PKey::EC::Point.new(PolyPseudo.config.group,
+                                                                          OpenSSL::BN.new(asn1.value[6].value[1].value, 2))
+      attributes["Point3"]                 = OpenSSL::PKey::EC::Point.new(PolyPseudo.config.group,
+                                                                          OpenSSL::BN.new(asn1.value[6].value[2].value, 2))
+
+      case attributes["Type"]
+      when /\A.*1\.2\.1\Z/
+        Identity.new(attributes)
+      when /\A.*1\.2\.1\Z/
+        Pseudonym.new(attributes)
+      else
+        raise "Invalid type"
+      end
+    end
+
+    attr_reader :type, :schema_version, :schema_key_version, :creator, :recipient, :recipient_key_set_version, :point_1, :point_2, :point_3
+
+    def initialize(attributes)
+      @type                      = attributes["Type"]
+      @schema_version            = attributes["SchemaVersion"]
+      @schema_key_version        = attributes["SchemaKeyVersion"]
+      @recipient                 = attributes["Creator"]
+      @recipient                 = attributes["Recipient"]
+      @recipient_key_set_version = attributes["RecipientKeySetVersion"]
+      @point_1                   = attributes["Point1"]
+      @point_2                   = attributes["Point2"]
+      @point_3                   = attributes["Point3"]
+    end
+  end
+end

data/lib/poly_pseudo/pseudonym.rb

@@ -0,0 +1,28 @@
+module PolyPseudo
+  class Pseudonym
+    include PolyPseudo::PseudoId
+
+    # @param [PolyPseudo::Key] closing_key
+    def decrypt(decryption_key, closing_key)
+      PolyPseudo.init!
+      decryption_private_key = decryption_key.ec.private_key
+      closing_private_key    = closing_key.ec.private_key
+
+      product            = decryption_private_key.mod_mul(closing_private_key, PolyPseudo.config.group.order)
+      point_2_multiplied = point_2.mul(closing_private_key)
+
+      pseudo_point        = point_1.mul(product)
+          .invert!
+          .add(point_2_multiplied)
+          .make_affine!
+
+      @pseudonym = closing_key.recipient_key_set_version.to_s + pseudo_point.to_hex
+    end
+
+    def pseudonym
+      @pseudonym || raise("Pseudonym not decrypted yet. call .decrypt first")
+    end
+
+    alias_method :pseudo_id, :pseudonym
+  end
+end

data/lib/poly_pseudo/util.rb

@@ -0,0 +1,83 @@
+module PolyPseudo
+  module Util
+    extend self
+
+    # @param [String] raw in pem format with metadata
+    def read_key(raw)
+      attributes               = {}
+      lines                    = raw.lines
+      meta_lines               = lines.slice!(1, 6)
+      attributes["PrivateKey"] = OpenSSL::PKey::EC.new(lines.join)
+
+      meta_lines.each do |line|
+        key, value      = line.split(":").map(&:strip)
+        attributes[key] = value
+      end
+
+      Key.new(attributes)
+    end
+
+    # @param [OpenSSL::BN] bn
+    def oaep_decode(em, p = '', hlen = 10)
+      raise 'message is too short!' if em.length < hlen * 2 + 1
+
+      maskedSeed = em[0...hlen]
+      maskedDB   = em[hlen..-1]
+
+      seedMask = mgf1 maskedDB, hlen
+      seed     = xor maskedSeed, seedMask
+      dbMask   = mgf1 seed, em.size - hlen
+      db       = xor maskedDB, dbMask
+      pHash    = Digest::SHA384.digest(p)[0...hlen]
+
+      ind = db.index("\x01", hlen)
+      raise 'message is invalid!' if ind.nil?
+
+      pHash2 = db[0...hlen]
+      ps     = db[hlen...ind]
+      m      = db[(ind + 1)..-1]
+
+      raise 'message is invalid!' unless ps.bytes.all?(&:zero?)
+      raise "specified p = #{p.inspect} is wrong!" unless pHash2 == pHash
+
+      m
+    end
+
+    def self.i2osp(x, len = nil)
+      raise ArgumentError, "integer too large" if len && x >= 256**len
+
+      StringIO.open do |buffer|
+        while x > 0
+          b = (x & 0xFF).chr
+          x >>= 8
+          buffer << b
+        end
+        s = buffer.string
+        s.force_encoding(Encoding::BINARY) if s.respond_to?(:force_encoding)
+        s.reverse!
+        s = len ? s.rjust(len, "\0") : s
+      end
+    end
+
+    def self.mgf1(z, l)
+      t = ''
+
+      (0..(l / 10)).each { |i|
+        t += Digest::SHA384.digest(z + i2osp(i, 4))
+      }
+
+      t[0...l]
+    end
+
+    def self.xor s1, s2
+      b1 = s1.unpack('c*')
+      b2 = s2.unpack('c*')
+
+      if b1.length != b2.length
+        raise DecodeError, 'cannot xor strings of different lengths!'
+      end
+
+      b1.zip(b2).map { |a, b| a ^ b }.pack('c*')
+    end
+  end
+end

data/lib/poly_pseudo/version.rb

@@ -0,0 +1,3 @@
+module PolyPseudo
+  VERSION = "0.1.0"
+end

data/poly_pseudo.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'poly_pseudo/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "poly_pseudo"
+  spec.version       = PolyPseudo::VERSION
+  spec.authors       = ["Benoist Claassen"]
+  spec.email         = ["bclaassen@digidentity.eu"]
+
+  spec.summary       = %q{Gem to decrypt polymorphic pseudonyms and identities}
+  spec.description   = %q{Gem to decrypt polymorphic pseudonyms and identities}
+  spec.homepage      = "https://www.digidentity.eu"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "minitest-reporters", "~> 1.1"
+
+  spec.add_dependency "ffi", "~> 1.9"
+end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: poly_pseudo
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Benoist Claassen
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-12-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+description: Gem to decrypt polymorphic pseudonyms and identities
+email:
+- bclaassen@digidentity.eu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/ext/openssl_ec.rb
+- lib/poly_pseudo.rb
+- lib/poly_pseudo/config.rb
+- lib/poly_pseudo/identity.rb
+- lib/poly_pseudo/key.rb
+- lib/poly_pseudo/pseudo_id.rb
+- lib/poly_pseudo/pseudonym.rb
+- lib/poly_pseudo/util.rb
+- lib/poly_pseudo/version.rb
+- poly_pseudo.gemspec
+homepage: https://www.digidentity.eu
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Gem to decrypt polymorphic pseudonyms and identities
+test_files: []