jwt-blockstack 2.0.0.beta1

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler/gem_tasks'
+
+begin
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new(:test)
+
+  task default: :test
+rescue LoadError
+  puts 'RSpec rake tasks not available. Please run "bundle install" to install missing dependencies.'
+end

data/lib/jwt.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+require 'base64'
+require 'jwt/decode'
+require 'jwt/default_options'
+require 'jwt/encode'
+require 'jwt/error'
+require 'jwt/signature'
+require 'jwt/verify'
+
+# JSON Web Token implementation
+#
+# Should be up to date with the latest spec:
+# https://tools.ietf.org/html/rfc7519
+module JWT
+  include JWT::DefaultOptions
+
+  module_function
+
+  def decoded_segments(jwt, verify = true)
+    raise(JWT::DecodeError, 'Nil JSON web token') unless jwt
+
+    decoder = Decode.new jwt, verify
+    decoder.decode_segments
+  end
+
+  def encode(payload, key, algorithm = 'HS256', header_fields = {})
+    encoder = Encode.new payload, key, algorithm, header_fields
+    encoder.segments
+  end
+
+  def decode(jwt, key = nil, verify = true, custom_options = {}, &keyfinder)
+    raise(JWT::DecodeError, 'Nil JSON web token') unless jwt
+
+    merged_options = DEFAULT_OPTIONS.merge(custom_options)
+
+    decoder = Decode.new jwt, verify
+    header, payload, signature, signing_input = decoder.decode_segments
+    decode_verify_signature(key, header, payload, signature, signing_input, merged_options, &keyfinder) if verify
+
+    Verify.verify_claims(payload, merged_options)
+
+    raise(JWT::DecodeError, 'Not enough or too many segments') unless header && payload
+
+    [payload, header]
+  end
+
+  def decode_verify_signature(key, header, payload, signature, signing_input, options, &keyfinder)
+    algo, key = signature_algorithm_and_key(header, payload, key, &keyfinder)
+
+    raise(JWT::IncorrectAlgorithm, 'An algorithm must be specified') unless options[:algorithm]
+    raise(JWT::IncorrectAlgorithm, 'Expected a different algorithm') unless algo == options[:algorithm]
+
+    Signature.verify(algo, key, signing_input, signature)
+  end
+
+  def signature_algorithm_and_key(header, payload, key, &keyfinder)
+    if keyfinder
+      key = if keyfinder.arity == 2
+              yield(header, payload)
+            else
+              yield(header)
+            end
+      raise JWT::DecodeError, 'No verification key available' unless key
+    end
+    [header['alg'], key]
+  end
+end

data/lib/jwt/decode.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+require 'json'
+
+# JWT::Decode module
+module JWT
+  # Decoding logic for JWT
+  class Decode
+    attr_reader :header, :payload, :signature
+
+    def self.base64url_decode(str)
+      str += '=' * (4 - str.length.modulo(4))
+      Base64.decode64(str.tr('-_', '+/'))
+    end
+
+    def initialize(jwt, verify)
+      @jwt = jwt
+      @verify = verify
+    end
+
+    def decode_segments
+      header_segment, payload_segment, crypto_segment = raw_segments(@jwt, @verify)
+      @header, @payload = decode_header_and_payload(header_segment, payload_segment)
+      @signature = Decode.base64url_decode(crypto_segment.to_s) if @verify
+      signing_input = [header_segment, payload_segment].join('.')
+      [@header, @payload, @signature, signing_input]
+    end
+
+    private
+
+    def raw_segments(jwt, verify)
+      segments = jwt.split('.')
+      required_num_segments = verify ? [3] : [2, 3]
+      raise(JWT::DecodeError, 'Not enough or too many segments') unless required_num_segments.include? segments.length
+      segments
+    end
+
+    def decode_header_and_payload(header_segment, payload_segment)
+      header = JSON.parse(Decode.base64url_decode(header_segment))
+      payload = JSON.parse(Decode.base64url_decode(payload_segment))
+      [header, payload]
+    rescue JSON::ParserError
+      raise JWT::DecodeError, 'Invalid segment encoding'
+    end
+  end
+end

data/lib/jwt/default_options.rb

@@ -0,0 +1,14 @@
+module JWT
+  module DefaultOptions
+    DEFAULT_OPTIONS = {
+      verify_expiration: true,
+      verify_not_before: true,
+      verify_iss: false,
+      verify_iat: false,
+      verify_jti: false,
+      verify_aud: false,
+      verify_sub: false,
+      leeway: 0
+    }.freeze
+  end
+end

data/lib/jwt/encode.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+require 'json'
+
+# JWT::Encode module
+module JWT
+  # Encoding logic for JWT
+  class Encode
+    attr_reader :payload, :key, :algorithm, :header_fields, :segments
+
+    def self.base64url_encode(str)
+      Base64.encode64(str).tr('+/', '-_').gsub(/[\n=]/, '')
+    end
+
+    def initialize(payload, key, algorithm, header_fields)
+      @payload = payload
+      @key = key
+      @algorithm = algorithm
+      @header_fields = header_fields
+      @segments = encode_segments
+    end
+
+    private
+
+    def encoded_header(algorithm, header_fields)
+      header = { 'alg' => algorithm }.merge(header_fields)
+      Encode.base64url_encode(JSON.generate(header))
+    end
+
+    def encoded_payload(payload)
+      raise InvalidPayload, 'exp claim must be an integer' if payload['exp'] && payload['exp'].is_a?(Time)
+      Encode.base64url_encode(JSON.generate(payload))
+    end
+
+    def encoded_signature(signing_input, key, algorithm)
+      if algorithm == 'none'
+        ''
+      else
+        signature = JWT::Signature.sign(algorithm, signing_input, key)
+        Encode.base64url_encode(signature)
+      end
+    end
+
+    def encode_segments
+      segments = []
+      segments << encoded_header(@algorithm, @header_fields)
+      segments << encoded_payload(@payload)
+      segments << encoded_signature(segments.join('.'), @key, @algorithm)
+      segments.join('.')
+    end
+  end
+end

data/lib/jwt/error.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+module JWT
+  class EncodeError < StandardError; end
+  class DecodeError < StandardError; end
+  class VerificationError < DecodeError; end
+  class ExpiredSignature < DecodeError; end
+  class IncorrectAlgorithm < DecodeError; end
+  class ImmatureSignature < DecodeError; end
+  class InvalidIssuerError < DecodeError; end
+  class InvalidIatError < DecodeError; end
+  class InvalidAudError < DecodeError; end
+  class InvalidSubError < DecodeError; end
+  class InvalidJtiError < DecodeError; end
+  class InvalidPayload < DecodeError; end
+end

data/lib/jwt/signature.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+require 'openssl'
+begin
+  require 'rbnacl'
+rescue LoadError
+end
+
+# JWT::Signature module
+module JWT
+  # Signature logic for JWT
+  module Signature
+    extend self
+
+    HMAC_ALGORITHMS = %w(HS256 HS512256 HS384 HS512).freeze
+    RSA_ALGORITHMS = %w(RS256 RS384 RS512).freeze
+    ECDSA_ALGORITHMS = %w(ES256 ES384 ES512 ES256K).freeze
+
+    NAMED_CURVES = {
+      'prime256v1' => 'ES256',
+      'secp384r1' => 'ES384',
+      'secp521r1' => 'ES512',
+      'secp256k1' => 'ES256K'
+    }.freeze
+
+    def sign(algorithm, msg, key)
+      if HMAC_ALGORITHMS.include?(algorithm)
+        sign_hmac(algorithm, msg, key)
+      elsif RSA_ALGORITHMS.include?(algorithm)
+        sign_rsa(algorithm, msg, key)
+      elsif ECDSA_ALGORITHMS.include?(algorithm)
+        sign_ecdsa(algorithm, msg, key)
+      else
+        raise NotImplementedError, 'Unsupported signing method'
+      end
+    end
+
+    def verify(algo, key, signing_input, signature)
+      verified = if HMAC_ALGORITHMS.include?(algo)
+                   verify_hmac(algo, key, signing_input, signature)
+                 elsif RSA_ALGORITHMS.include?(algo)
+                   verify_rsa(algo, key, signing_input, signature)
+                 elsif ECDSA_ALGORITHMS.include?(algo)
+                   verify_ecdsa(algo, key, signing_input, signature)
+                 else
+                   raise JWT::VerificationError, 'Algorithm not supported'
+                 end
+
+      raise(JWT::VerificationError, 'Signature verification raised') unless verified
+    rescue OpenSSL::PKey::PKeyError
+      raise JWT::VerificationError, 'Signature verification raised'
+    ensure
+      OpenSSL.errors.clear
+    end
+
+    private
+
+    def sign_rsa(algorithm, msg, private_key)
+      raise EncodeError, "The given key is a #{private_key.class}. It has to be an OpenSSL::PKey::RSA instance." if private_key.class == String
+      private_key.sign(OpenSSL::Digest.new(algorithm.sub('RS', 'sha')), msg)
+    end
+
+    def sign_ecdsa(algorithm, msg, private_key)
+      key_algorithm = NAMED_CURVES[private_key.group.curve_name]
+      if algorithm != key_algorithm
+        raise IncorrectAlgorithm, "payload algorithm is #{algorithm} but #{key_algorithm} signing key was provided"
+      end
+
+      digest = OpenSSL::Digest.new(algorithm.sub('ES', 'sha').sub('K', ''))
+      asn1_to_raw(private_key.dsa_sign_asn1(digest.digest(msg)), private_key)
+    end
+
+    def sign_hmac(algorithm, msg, key)
+      authenticator, padded_key = rbnacl_fixup(algorithm, key)
+      if authenticator && padded_key
+        authenticator.auth(padded_key, msg.encode('binary'))
+      else
+        OpenSSL::HMAC.digest(OpenSSL::Digest.new(algorithm.sub('HS', 'sha')), key, msg)
+      end
+    end
+
+    def verify_rsa(algorithm, public_key, signing_input, signature)
+      public_key.verify(OpenSSL::Digest.new(algorithm.sub('RS', 'sha')), signature, signing_input)
+    end
+
+    def verify_ecdsa(algorithm, public_key, signing_input, signature)
+      key_algorithm = NAMED_CURVES[public_key.group.curve_name]
+      if algorithm != key_algorithm
+        raise IncorrectAlgorithm, "payload algorithm is #{algorithm} but #{key_algorithm} verification key was provided"
+      end
+
+      digest = OpenSSL::Digest.new(algorithm.sub('ES', 'sha').sub('K', ''))
+      public_key.dsa_verify_asn1(digest.digest(signing_input), raw_to_asn1(signature, public_key))
+    end
+
+    def verify_hmac(algorithm, public_key, signing_input, signature)
+      authenticator, padded_key = rbnacl_fixup(algorithm, public_key)
+      if authenticator && padded_key
+        begin
+          authenticator.verify(padded_key, signature.encode('binary'), signing_input.encode('binary'))
+        rescue RbNaCl::BadAuthenticatorError
+          false
+        end
+      else
+        secure_compare(signature, sign_hmac(algorithm, signing_input, public_key))
+      end
+    end
+
+    def asn1_to_raw(signature, public_key)
+      byte_size = (public_key.group.degree + 7) / 8
+      OpenSSL::ASN1.decode(signature).value.map { |value| value.value.to_s(2).rjust(byte_size, "\x00") }.join
+    end
+
+    def raw_to_asn1(signature, private_key)
+      byte_size = (private_key.group.degree + 7) / 8
+      r = signature[0..(byte_size - 1)]
+      s = signature[byte_size..-1] || ''
+      OpenSSL::ASN1::Sequence.new([r, s].map { |int| OpenSSL::ASN1::Integer.new(OpenSSL::BN.new(int, 2)) }).to_der
+    end
+
+    def rbnacl_fixup(algorithm, key)
+      algorithm = algorithm.sub('HS', 'SHA').to_sym
+
+      return [] unless defined?(RbNaCl) && RbNaCl::HMAC.constants(false).include?(algorithm)
+
+      authenticator = RbNaCl::HMAC.const_get(algorithm)
+
+      # Fall back to OpenSSL for keys larger than 32 bytes.
+      return [] if key.bytesize > authenticator.key_bytes
+
+      [
+        authenticator,
+        key.bytes.fill(0, key.bytesize...authenticator.key_bytes).pack('C*')
+      ]
+    end
+
+    # From devise
+    # constant-time comparison algorithm to prevent timing attacks
+    def secure_compare(a, b)
+      return false if a.nil? || b.nil? || a.empty? || b.empty? || a.bytesize != b.bytesize
+      l = a.unpack "C#{a.bytesize}"
+      res = 0
+      b.each_byte { |byte| res |= byte ^ l.shift }
+      res.zero?
+    end
+  end
+end

data/lib/jwt/verify.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+require 'jwt/error'
+
+module JWT
+  # JWT verify methods
+  class Verify
+    class << self
+      %w(verify_aud verify_expiration verify_iat verify_iss verify_jti verify_not_before verify_sub).each do |method_name|
+        define_method method_name do |payload, options|
+          new(payload, options).send(method_name)
+        end
+      end
+
+      def verify_claims(payload, options)
+        options.each do |key, val|
+          next unless key.to_s =~ /verify/
+          Verify.send(key, payload, options) if val
+        end
+      end
+    end
+
+    def initialize(payload, options)
+      @payload = payload
+      @options = options
+    end
+
+    def verify_aud
+      return unless (options_aud = @options[:aud])
+      raise(JWT::InvalidAudError, "Invalid audience. Expected #{options_aud}, received #{@payload['aud'] || '<none>'}") if ([*@payload['aud']] & [*options_aud]).empty?
+    end
+
+    def verify_expiration
+      return unless @payload.include?('exp')
+      raise(JWT::ExpiredSignature, 'Signature has expired') if @payload['exp'].to_i <= (Time.now.to_i - exp_leeway)
+    end
+
+    def verify_iat
+      return unless @payload.include?('iat')
+      raise(JWT::InvalidIatError, 'Invalid iat') if !@payload['iat'].is_a?(Numeric) || @payload['iat'].to_f > (Time.now.to_f + iat_leeway)
+    end
+
+    def verify_iss
+      return unless (options_iss = @options[:iss])
+      raise(JWT::InvalidIssuerError, "Invalid issuer. Expected #{options_iss}, received #{@payload['iss'] || '<none>'}") if @payload['iss'].to_s != options_iss.to_s
+    end
+
+    def verify_jti
+      options_verify_jti = @options[:verify_jti]
+      if options_verify_jti.respond_to?(:call)
+        raise(JWT::InvalidJtiError, 'Invalid jti') unless options_verify_jti.call(@payload['jti'])
+      elsif @payload['jti'].to_s.strip.empty?
+        raise(JWT::InvalidJtiError, 'Missing jti')
+      end
+    end
+
+    def verify_not_before
+      return unless @payload.include?('nbf')
+      raise(JWT::ImmatureSignature, 'Signature nbf has not been reached') if @payload['nbf'].to_i > (Time.now.to_i + nbf_leeway)
+    end
+
+    def verify_sub
+      return unless (options_sub = @options[:sub])
+      raise(JWT::InvalidSubError, "Invalid subject. Expected #{options_sub}, received #{@payload['sub'] || '<none>'}") unless @payload['sub'].to_s == options_sub.to_s
+    end
+
+    private
+
+    def global_leeway
+      @options[:leeway]
+    end
+
+    def exp_leeway
+      @options[:exp_leeway] || global_leeway
+    end
+
+    def iat_leeway
+      @options[:iat_leeway] || global_leeway
+    end
+
+    def nbf_leeway
+      @options[:nbf_leeway] || global_leeway
+    end
+  end
+end

data/lib/jwt/version.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+# Moments version builder module
+module JWT
+  def self.gem_version
+    Gem::Version.new VERSION::STRING
+  end
+
+  # Moments version builder module
+  module VERSION
+    # major version
+    MAJOR = 2
+    # minor version
+    MINOR = 0
+    # tiny version
+    TINY  = 0
+    # alpha, beta, etc. tag
+    PRE   = 'beta1'.freeze
+
+    # Build version string
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
+  end
+end