prototok 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: aa2f4a8d086b1a650e523810806c1ab4bc415fa6fe1a24e862465cdbe2fab533
+  data.tar.gz: 8368dade9383592cc2188594cfc000791eca34c13ab759c812be087e74441a6d
+SHA512:
+  metadata.gz: e3638dd67c842af17c23225f74d023d572543e7fb39767a642e77c754cf49694422ddb33c96f417651f3c0b534b0b8e77ec4063346b330c039711c3d55770ead
+  data.tar.gz: 5825094f34c5bd8d9b0e2a7c0c6b872009416024724fb3269294d3023b31f684c7b39f7ccafbd08ee59aff437ef77d7da7cd4c1f42b7e62ef68a16c394afbdef

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/*.gem
+
+# rspec failure tracking
+.rspec_status
+.DS_Store
+.byebug_history

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.rubocop.yml

@@ -0,0 +1,14 @@
+require: rubocop-rspec
+AllCops:
+  RSpec:
+    Patterns:
+    - 'spec/meander/.+.rb$'
+    - 'spec/shared/.+.rb$'
+Metrics/MethodLength:
+  Max: 15
+Metrics/BlockLength:
+  Exclude:
+    - 'spec/**/*.rb'
+    - '*.gemspec'
+RSpec/ExampleLength:
+  Max: 10

data/.travis.yml

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

data/Gemfile

@@ -0,0 +1,11 @@
+source "https://rubygems.org"
+
+gem 'google-protobuf'
+gem 'grpc-tools'
+gem 'msgpack'
+gem 'oj'
+gem 'pry'
+gem 'byebug'
+gem 'stackprof'
+# Specify your gem's dependencies in prototok.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Kostrov Alexander
+
+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,7 @@
+# Prototok
+
+Token generation using RbNacl
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

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

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/prototok/attribute.rb

@@ -0,0 +1,21 @@
+module Prototok
+  module Serializers
+    class Attribute
+      attr_reader :options
+      attr_reader :serializer
+
+      def initialize(options)
+        @options = options || {}
+        @serializer = Serializers.find(@options[:serializer])
+      end
+
+      def serialize(value)
+        if @serializer
+          @serializer.new(value).encode
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/prototok/ciphers/V1/encrypted_mac.rb

@@ -0,0 +1,24 @@
+require 'rbnacl/secret_boxes/xsalsa20poly1305'
+
+module Prototok
+  module Ciphers
+    module V1
+      class EncryptedMac < Base
+        self.cipher_class = RbNaCl::SecretBoxes::XSalsa20Poly1305
+
+        def initialize(private_key)
+          @cipher = cipher_class.new(private_key)
+        end
+
+        def encode(blob)
+          nonce = RbNaCl::Random.random_bytes @cipher.nonce_bytes
+          [nonce, @cipher.box(nonce, blob)]
+        end
+
+        def decode(decoded_nonce, decoded_blob)
+          @cipher.open(decoded_nonce, decoded_blob)
+        end
+      end
+    end
+  end
+end

data/lib/prototok/ciphers/V1/encrypted_sign.rb

@@ -0,0 +1,34 @@
+require 'rbnacl/boxes/curve25519xsalsa20poly1305'
+
+module Prototok
+  module Ciphers
+    module V1
+      class EncryptedSign < Base
+        self.cipher_class = RbNaCl::Boxes::Curve25519XSalsa20Poly1305
+
+        def initialize(private_key, remote_public_key)
+          @private_key = private_key
+          @remote_public_key = remote_public_key
+          @cipher = cipher_class.new(@remote_public_key, @private_key)
+        end
+
+        def encode(blob)
+          nonce = RbNaCl::Random.random_bytes(cipher_class.nonce_bytes)
+          [nonce, @cipher.encrypt(nonce, blob)]
+        end
+
+        def decode(decoded_nonce, decoded_blob)
+          @cipher.decrypt(decoded_nonce, decoded_blob)
+        end
+
+        def self.key private_key=nil
+          if private_key.nil?
+            cipher_class::PrivateKey.generate.to_bytes
+          else
+            cipher_class::PrivateKey.new(private_key).public_key.to_bytes
+          end
+        end
+      end
+    end
+  end
+end

data/lib/prototok/ciphers/V1/mac.rb

@@ -0,0 +1,24 @@
+require 'rbnacl/hmac/sha512256'
+
+module Prototok
+  module Ciphers
+    module V1
+      class Mac < Base
+        self.cipher_class = RbNaCl::HMAC::SHA512256
+
+        def initialize(private_key)
+          @cipher = cipher_class.new(private_key)
+        end
+
+        def encode(blob)
+          [@cipher.auth(blob), blob]
+        end
+
+        def decode(decoded_auth, decoded_blob)
+          @cipher.verify(decoded_auth, decoded_blob)
+          decoded_blob
+        end
+      end
+    end
+  end
+end

data/lib/prototok/ciphers/V1/sign.rb

@@ -0,0 +1,34 @@
+require 'rbnacl/signatures/ed25519'
+
+module Prototok
+  module Ciphers
+    module V1
+      class Sign < Base
+        self.cipher_class = RbNaCl::Signatures::Ed25519
+
+        def initialize(private_or_public_key)
+          @key = private_or_public_key
+        end
+
+        def encode(blob)
+          cipher = cipher_class::SigningKey.new(@key)
+          [cipher.sign(blob), blob]
+        end
+
+        def decode(decoded_auth, decoded_blob)
+          cipher = cipher_class::VerifyKey.new(@key)
+          cipher.verify(decoded_auth, decoded_blob)
+          decoded_blob
+        end
+
+        def self.key(private_key = nil)
+          if private_key.nil?
+            cipher_class::SigningKey.generate.to_bytes
+          else
+            cipher_class::SigningKey.new(private_key).verify_key.to_bytes
+          end
+        end
+      end
+    end
+  end
+end

data/lib/prototok/ciphers/v1.rb

@@ -0,0 +1,7 @@
+module Prototok
+  module Ciphers
+    module V1
+      Autoloaded.class {}
+    end
+  end
+end

data/lib/prototok/ciphers.rb

@@ -0,0 +1,23 @@
+module Prototok
+  module Ciphers
+    Autoloaded.class {}
+    extend Utils::Listed
+    class Base
+      class << self
+        attr_writer :cipher_class
+        def cipher_class
+          @cipher_class ||
+            raise(Errors::CipherError, 'No cipher_class declared')
+        end
+
+        def key
+          RbNaCl::Random.random_bytes(cipher_class.key_bytes)
+        end
+      end
+
+      def cipher_class
+        self.class.cipher_class
+      end
+    end
+  end
+end

data/lib/prototok/config.rb

@@ -0,0 +1,25 @@
+module Prototok
+  CONFIG_DEFAULTS = {
+    formatter: :default,
+    version: 1,
+    op: :encrypted_mac,
+    encoder: :json,
+    token_delimiter: '.',
+    encoder_options: {
+      encoding_mode: :token
+    },
+    time_encoding_precision: 10
+  }.freeze
+
+  class << self
+    def configuration
+      @configutation ||= CONFIG_DEFAULTS.dup
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    alias_method :config, :configuration
+  end
+end

data/lib/prototok/encoders/json.rb

@@ -0,0 +1,23 @@
+require 'multi_json'
+
+module Prototok
+  module Encoders
+    class Json < Base
+      def encode_token payload, **header
+        MultiJson.encode serialize(payload, **header)
+      end
+
+      def decode_token str
+        deserialize(MultiJson.decode(str))
+      end
+
+      def encode_payload payload
+         MultiJson.encode payload.to_h
+      end
+
+      def decode_payload str
+        MultiJson.decode(str)
+      end
+    end
+  end
+end

data/lib/prototok/encoders/msgpack.rb

@@ -0,0 +1,23 @@
+require 'msgpack'
+
+module Prototok
+  module Encoders
+    class Msgpack < Base
+      def encode_token payload, **header
+        MessagePack.pack serialize(payload, **header)
+      end
+
+      def decode_token str
+        deserialize(MessagePack.unpack(str))
+      end
+
+      def encode_payload payload
+         MessagePack.pack payload.to_h
+      end
+
+      def decode_payload str
+        MessagePack.unpack(str)
+      end
+    end
+  end
+end

data/lib/prototok/encoders/protobuf/token.proto

@@ -0,0 +1,11 @@
+syntax = "proto3";
+import "google/protobuf/any.proto";
+package prototok.protobuf;
+
+message Token {
+  string exp = 1;
+  string nbf = 2;
+  string iat = 3;
+  string jti = 4;
+  google.protobuf.Any payload = 5;
+}

data/lib/prototok/encoders/protobuf.rb

@@ -0,0 +1,75 @@
+require 'google/protobuf'
+require 'google/protobuf/well_known_types'
+
+module Prototok
+  module Encoders
+    class Protobuf < Base
+      PROTOBUF_DEFAULTS = {
+        payload_class: '::Prototok::Protobuf::Payload'
+      }.freeze
+
+      def encode_token payload, **header
+        serialized = serialize(payload, **header)
+        prepared_token = prepare_token(serialized)
+        prepared_token.class.encode(prepared_token)
+      end
+
+      def decode_token str
+        decoded_token = Prototok::Protobuf::Token.decode(str)
+        payload = decoded_token.payload.unpack(payload_class)
+        token = deserialize(decoded_token.to_h)
+        token.payload = payload
+        token
+      end
+
+      def encode_payload payload
+        payload = payload_class.new(payload.to_h.reject { |_, v| v.nil? })
+        payload_class.encode(payload)
+      end
+
+      def decode_payload str
+        payload_class.decode(str)
+      end
+
+      def self.options
+        @options ||= super.merge!(PROTOBUF_DEFAULTS)
+      end
+
+      private
+
+      def prepare_token serialized_token
+        payload = payload_class.new(serialized_token[:payload] || {})
+        any = Google::Protobuf::Any.new
+        any.pack payload
+        serialized_token[:payload] = any
+        Prototok::Protobuf::Token.new(serialized_token)
+      end
+
+      def payload_class
+        self.class.payload_class(options)
+      end
+
+      def self.payload_class(opts)
+        @cache ||= {}
+        @cache[opts] ||= begin
+          existing = try_get_existed(opts[:payload_class])
+          return existing unless existing.nil?
+          unless opts[:payload_file]
+            Prototok.send :err, Errors::ConfigurationError, 'no_payload_proto_file'
+          end
+          Prototok::Utils::Protoc.process(opts[:payload_file])
+          Object.const_get opts[:payload_class], false
+        end
+      end
+
+      def self.try_get_existed(klass_name)
+        Object.const_get klass_name, false
+      rescue NameError
+        nil
+      end
+
+      base_token = File.join(__dir__, 'protobuf/token.proto')
+      Prototok::Utils::Protoc.process(base_token)
+    end
+  end
+end

data/lib/prototok/encoders.rb

@@ -0,0 +1,51 @@
+module Prototok
+  module Encoders
+    Autoloaded.class {}
+    extend Utils::Listed
+
+    class Base
+      def options
+        @options ||= self.class.options.dup
+      end
+
+      def self.options
+        @options ||= Prototok.config[:encoder_options].dup
+      end
+
+      def initialize(**encoder_options)
+        options.merge!(encoder_options)
+      end
+
+      def encode payload, **header
+        case options[:encoding_mode].to_s
+        when 'token'
+          encode_token payload, **header
+        when 'payload'
+          encode_payload payload
+        end
+      end
+
+      def decode str
+        case options[:encoding_mode].to_s
+        when 'token'
+          decode_token str
+        when 'payload'
+          decode_payload str
+        end
+      end
+
+      def serialize payload=nil, **header
+        if payload.is_a? Token
+          token = payload.dup.update!(header)
+        else
+          token = Token.new.update!(header.merge(:payload => payload))
+        end
+         Serializers.find(:token).new(token).encode
+      end
+
+      def deserialize data
+        Token.new(Serializers.find(:token).decode (data))
+      end
+    end
+  end
+end

data/lib/prototok/errors.rb

@@ -0,0 +1,25 @@
+module Prototok
+  module Errors
+    class FormatError < RuntimeError; end
+    class ConfigurationError < RuntimeError; end
+    class CipherError < RuntimeError; end
+    class TypeMismatch < RuntimeError; end
+    class ExternalError < RuntimeError; end
+    MESSAGES = {
+      encoder: 'No such encoder declared',
+      cipher: 'No such cipher declared',
+      formatter: 'No such formatter declared',
+      no_payload_proto_file: 'No payload .proto file path configured',
+      type_expected: '%s expects %s value, got %s',
+      external_command: 'have issues with system util "%s".
+      Try to run "%s" by hand. Maybe you have to install it'
+    }.freeze
+
+    def err(error_class, message_name, *args, **keywords)
+      message = (Errors::MESSAGES[message_name] || "")
+      message %= args unless args.empty?
+      message %= keywords unless keywords.empty?
+      raise(error_class, message)
+    end
+  end
+end

data/lib/prototok/formatters/default.rb

@@ -0,0 +1,17 @@
+module Prototok
+  module Formatters
+    class Default < Base
+      def encode(*args)
+        raise Errors::FormatError if args.size != 2
+        args.map { |part| RbNaCl::Util.bin2hex(part) }
+            .join(Prototok.config[:token_delimiter])
+      end
+
+      def decode(str)
+        parts = str.split(Prototok.config[:token_delimiter])
+        raise Errors::FormatError if parts.size != 2
+        parts.map { |part| RbNaCl::Util.hex2bin(part) }
+      end
+    end
+  end
+end

data/lib/prototok/formatters.rb

@@ -0,0 +1,7 @@
+module Prototok
+  module Formatters
+    Autoloaded.class {}
+    extend Utils::Listed
+    class Base; end
+  end
+end

data/lib/prototok/serializers/time.rb

@@ -0,0 +1,15 @@
+require 'time'
+
+module Prototok
+  module Serializers
+    class Time < Base
+      def encode
+        @object && @object.iso8601(Prototok.config[:time_encoding_precision])
+      end
+
+      def self.decode value
+        ::Time.iso8601(value)
+      end
+    end
+  end
+end

data/lib/prototok/serializers/token.rb

@@ -0,0 +1,8 @@
+module Prototok
+  module Serializers
+    class Token < Base
+      attributes :exp, :nbf, :iat, serializer: :time, nil: :delete, empty: :delete
+      attributes :payload, :jti, nil: :delete
+    end
+  end
+end

data/lib/prototok/serializers.rb

@@ -0,0 +1,146 @@
+module Prototok
+  module Serializers
+    Autoloaded.class {}
+    extend Utils::Listed
+
+    class Base
+      attr_reader :object
+
+      def initialize(object)
+        @object = object
+      end
+
+      KEY_OPERATIONS = %i[nil empty].freeze
+
+      def encode
+        if attribute_storage.empty?
+          @object.respond_to?(:to_h) ? @object.to_h : @object
+        else
+          Hash[map_attributes]
+        end
+      end
+
+      private
+
+      def attribute_storage
+        self.class.attribute_storage
+      end
+
+      def default_getter(name)
+        @object.respond_to?(name) ? @object.send(name) : @object[name]
+      end
+
+      def map_attributes
+        result = attribute_storage.keys.map {|name| [name, send(name)] }
+        self.class.apply_key_ops!(Hash[result])
+      end
+
+      class << self
+        def attribute(*names, **options)
+          names.uniq!
+          update_key_ops(*names, options)
+          names.each do |name|
+            attribute_storage[name] = Attribute.new(options)
+            define_attribute_method name
+          end
+        end
+
+        def decode(data)
+          apply_key_ops!(data)
+          result = attribute_storage.map do |name, attribute|
+            serializer = attribute.serializer
+            key = pick_key data, name
+            next unless key
+            value = data[key]
+            if serializer
+              [name, serializer.decode(value)]
+            else
+              [name, value]
+            end
+          end.compact
+          Hash[result]
+        end
+
+        def attribute_storage
+          @attribute_storage ||= {}
+        end
+
+        def key_ops
+          @key_ops ||= {}
+        end
+
+        def apply_op(result, key, op)
+          if op.is_a? Symbol
+            result.send op, key
+          else
+            op.call(result, key)
+          end
+        end
+
+        def apply_key_ops!(result)
+          key_ops.each do |key, ops|
+            ops.each do |check, op|
+              val = result[key]
+              apply_op(result, key, op) if check_value val, check
+            end
+          end
+          result
+        end
+
+        def check_value(val, check)
+          if check.is_a?(Symbol)
+            check_method = "#{check}?"
+            val.respond_to?(check_method) && val.send(check_method)
+          else
+            check.call(val)
+          end
+        end
+
+        alias_method :attributes, :attribute
+
+        private
+
+        def pick_key(data, key)
+          if data.key?(key)
+            key
+          elsif data.key?(stringified = key.to_s)
+            stringified
+          end
+        end
+
+        def define_attribute_method(name)
+          if attribute_storage[name].options.empty?
+            define_method(name) { default_getter(name) }
+          else
+            define_getter(name)
+          end
+        end
+
+        def define_getter(name)
+          attribute = attribute_storage[name]
+          define_method name do
+            attribute.serialize default_getter(name)
+          end
+        end
+
+        def update_key_ops(*names, **options)
+          current_key_ops = {}
+          options.each do |k, v|
+            external_option = false
+            raise ArgumentError if v.is_a?(Proc) && v.arity != 2
+            if k.is_a?(Proc)
+              raise ArgumentError if k.arity != 1
+              external_option = true
+            else
+              external_option = KEY_OPERATIONS.include?(k)
+            end
+            current_key_ops[k] = options.delete(k) if external_option
+          end
+          names.each do |name|
+            key_ops[name] = current_key_ops unless current_key_ops.empty?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/prototok/token.rb

@@ -0,0 +1,36 @@
+require 'time'
+
+module Prototok
+  CLAIM_ALIASES = [
+    [:exp, %i[expires_at use_before]],
+    [:nbf, %i[not_before use_after]],
+    [:iat, [:created_at]],
+    [:jti, %i[token_id id]],
+    [:payload, []]
+  ].freeze
+
+  class Token < Struct.new(*CLAIM_ALIASES.map(&:first))
+    extend Utils::TypeAttributes
+    type ::Time, :exp, :nbf, :iat
+
+    def initialize opts={}
+      super()
+      update!(opts)
+    end
+
+    CLAIM_ALIASES.each do |(original, aliases)|
+      aliases.each do |alias_name|
+        alias_method alias_name, original
+        alias_method "#{alias_name}=", "#{original}="
+      end
+    end
+
+    def update! opts={}
+      opts.each{|k,v| self.send "#{k}=", v}
+      self
+    end
+
+  end
+end
+
+

data/lib/prototok/utils/listed.rb

@@ -0,0 +1,19 @@
+module Prototok
+  module Utils
+    module Listed
+      def find(*attrs)
+        @cache ||= {}
+        @cache[attrs] ||= begin
+          const_name = attrs.map do |word|
+            word.to_s.split(/(?=[[:upper:]])|\_/).map(&:capitalize).join
+          end.join('::')
+          begin
+            const_get const_name, false
+          rescue NameError
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/prototok/utils/paths.rb

@@ -0,0 +1,11 @@
+module Prototok
+  module Utils
+    module Paths
+      class << self
+        def gem_root
+          Gem::Specification.find_by_name('prototok').gem_dir
+        end
+      end
+    end
+  end
+end

data/lib/prototok/utils/protoc.rb

@@ -0,0 +1,43 @@
+require 'digest/sha2'
+require 'tempfile'
+
+module Prototok
+  module Utils
+    module Protoc
+      class << self
+        def cache
+          @cache ||= Set.new
+        end
+
+        def process(path)
+          path = File.expand_path path
+          if !path || !File.exist?(path)
+            raise ArgumentError, 'protobuf proto file is missing'
+          end
+          input = File.read(path)
+          digest = Digest::SHA256.hexdigest(input)
+          if cache.include? digest
+            false
+          else
+            temp = ::Tempfile.new digest
+            temp.write input
+            temp.rewind
+            load_proto temp, digest
+          end
+        end
+
+        private
+
+        def load_proto(proto, digest)
+          dirname = File.dirname(proto.path)
+          output_rb = proto.path + '_pb.rb'
+          protoc_command = "protoc #{proto.path} --ruby_out=#{dirname} --proto_path=#{dirname}"
+          success = system(protoc_command)
+          Prototok.err(Errors::ExternalError, :external_command, 'protoc', protoc_command) unless success
+          load output_rb
+          cache.add digest
+        end
+      end
+    end
+  end
+end

data/lib/prototok/utils/test_helper.rb

@@ -0,0 +1,74 @@
+module Prototok
+  module Utils
+    module TestHelper
+      def option_combinations
+        combinations = (versions + [nil]).map do |v|
+          product_versions(v)
+        end.flatten.each_slice(5).entries
+        combinations.inject({}) do |aggr, options|
+          aggr.merge!(itemize_options(prepare_options(options)))
+        end
+      end
+
+      private
+
+      def prepare_options(o = {})
+        options = { version: o[0], op: o[1], encoder: o[2], formatter: o[3], encoder_options: o[4] }
+        if options[:encoder].to_s == 'protobuf'
+          options[:encoder_options] ||= {}
+          payload_proto_path = File.join(
+            Prototok::Utils::Paths.gem_root,
+            'spec/prototok/encoders/protobuf/test_payload.prot'
+          )
+          options[:encoder_options][:payload_file] = payload_proto_path
+        end
+        options
+      end
+
+      def product_versions(v)
+        [v]
+          .product(cipher_names(v))
+          .product(encoder_names)
+          .product(formatter_names)
+          .product(encoder_options)
+      end
+
+      def itemize_options(keyword_args = {})
+        defaulted = keyword_args.each_with_object({}) do |(key, val), obj|
+          obj[key] = (val.nil? ? 'default' : val)
+        end
+        name = defaulted.to_a.map { |i| i.join(' is ') }.join(', ')
+        { name => keyword_args.reject { |_k, v| v.nil? } }
+      end
+
+      def encoder_names
+        item_names('lib/prototok/encoders') + [nil]
+      end
+
+      def cipher_names(version = nil)
+        version ||= 1
+        item_names("lib/prototok/ciphers/V#{version}") + [nil]
+      end
+
+      def formatter_names
+        item_names('lib/prototok/formatters') + [nil]
+      end
+
+      def encoder_options
+        [:token, :payload].map do |mode|
+          {encoding_mode: mode}
+        end + [nil]
+      end
+
+      def item_names(subpath)
+        items_root = File.join(Paths.gem_root, subpath)
+        item_files = Dir.entries(items_root).select { |i| i =~ /.+\.rb/ } || []
+        item_files.map { |i| File.basename(i, '.rb') }
+      end
+
+      def versions
+        item_names('lib/prototok/ciphers').map { |i| i.sub(/^v/, '') }
+      end
+    end
+  end
+end

data/lib/prototok/utils/type_attributes.rb

@@ -0,0 +1,19 @@
+module Prototok
+  module Utils
+    module TypeAttributes
+      def type type, *attributes
+        unless type.is_a? Class
+          Prototok.err(Errors::TypeMismatch, :type_expected, :type, Class, type)
+        end
+        attributes.each do |attrib|
+          define_method "#{attrib}=" do |val|
+            unless val.is_a? type
+              Prototok.err(Errors::TypeMismatch, :type_expected, attrib, type, val)
+            end
+            super(val)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/prototok/utils.rb

@@ -0,0 +1,5 @@
+module Prototok
+  module Utils
+    Autoloaded.module {}
+  end
+end

data/lib/prototok/version.rb

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

data/lib/prototok.rb

@@ -0,0 +1,58 @@
+require 'autoloaded'
+require 'rbnacl'
+require 'prototok/version'
+require 'prototok/errors'
+require 'prototok/utils'
+require 'prototok/config'
+require 'prototok/attribute'
+require 'prototok/serializers'
+require 'prototok/token'
+require 'prototok/encoders'
+require 'prototok/ciphers'
+require 'prototok/formatters'
+
+module Prototok
+  class << self
+    def encode(payload=nil, *cipher_args, **opts)
+      raise ArgumentError if payload.nil?
+      header = opts[:header] || {}
+      encoded = encoder_instance(**opts).encode(payload, **header)
+      processed = cipher(**opts).new(*cipher_args).encode(encoded)
+      formatter(opts[:formatter]).new.encode(*processed)
+    end
+
+    def decode(encoded=nil, *cipher_args, **opts)
+      raise ArgumentError if encoded.nil?
+      unformatted = formatter(opts[:formatter]).new.decode(encoded)
+      unprocessed = cipher(**opts).new(*cipher_args).decode(*unformatted)
+      encoder_instance(**opts).decode(unprocessed)
+    end
+
+    def key(*args, **opts)
+      cipher(**opts).key(*args)
+    end
+
+    include Errors
+
+    private
+
+    def encoder_instance(encoder: nil, encoder_options: nil, **_)
+      encoder ||= config[:encoder]
+      klass = Prototok::Encoders.find(encoder) || err(ArgumentError, :encoder)
+      encoder_options ||= {}
+      klass.new(**encoder_options)
+    end
+
+    def cipher(op: nil, version: nil, **_)
+      op ||= config[:op]
+      version ||= config[:version]
+      ver_name = "V#{version}"
+      Prototok::Ciphers.find(ver_name, op) || err(ArgumentError, :cipher)
+    end
+
+    def formatter(frmter_name = nil)
+      frmter_name ||= config[:formatter]
+      Prototok::Formatters.find(frmter_name) || err(ArgumentError, :formatter)
+    end
+  end
+end

data/prototok.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'prototok/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'prototok'
+  spec.version       = Prototok::VERSION
+  spec.authors       = ['Kostrov Alexander']
+  spec.email         = ['bombazook@gmail.com']
+
+  spec.summary       = 'Tokens for sane auth'
+  spec.description   = 'Easy to use token generation using libsodium and
+                        json (using multi_json), message_pack or protobuf'
+  spec.homepage      = 'https://github.com/bombazook/prototok'
+  spec.license       = 'MIT'
+
+  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_dependency 'rbnacl'
+  spec.add_dependency 'multi_json'
+  spec.add_dependency 'autoloaded', '~> 2.0'
+
+  spec.add_development_dependency 'bundler', '~> 1.15'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'rubocop-rspec'
+end

metadata

@@ -0,0 +1,197 @@
+--- !ruby/object:Gem::Specification
+name: prototok
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kostrov Alexander
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-01-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rbnacl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: autoloaded
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |-
+  Easy to use token generation using libsodium and
+                          json (using multi_json), message_pack or protobuf
+email:
+- bombazook@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/prototok.rb
+- lib/prototok/attribute.rb
+- lib/prototok/ciphers.rb
+- lib/prototok/ciphers/V1/encrypted_mac.rb
+- lib/prototok/ciphers/V1/encrypted_sign.rb
+- lib/prototok/ciphers/V1/mac.rb
+- lib/prototok/ciphers/V1/sign.rb
+- lib/prototok/ciphers/v1.rb
+- lib/prototok/config.rb
+- lib/prototok/encoders.rb
+- lib/prototok/encoders/json.rb
+- lib/prototok/encoders/msgpack.rb
+- lib/prototok/encoders/protobuf.rb
+- lib/prototok/encoders/protobuf/token.proto
+- lib/prototok/errors.rb
+- lib/prototok/formatters.rb
+- lib/prototok/formatters/default.rb
+- lib/prototok/serializers.rb
+- lib/prototok/serializers/time.rb
+- lib/prototok/serializers/token.rb
+- lib/prototok/token.rb
+- lib/prototok/utils.rb
+- lib/prototok/utils/listed.rb
+- lib/prototok/utils/paths.rb
+- lib/prototok/utils/protoc.rb
+- lib/prototok/utils/test_helper.rb
+- lib/prototok/utils/type_attributes.rb
+- lib/prototok/version.rb
+- prototok.gemspec
+homepage: https://github.com/bombazook/prototok
+licenses:
+- MIT
+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.7.3
+signing_key: 
+specification_version: 4
+summary: Tokens for sane auth
+test_files: []