itsdangerousr 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7c4b1d444326a60bd2883c0caedb94b97766ff88
+  data.tar.gz: c5400e1c54f6da695dd3b2a371d17265bdfbaef7
+SHA512:
+  metadata.gz: ccab08b04c56006df9fd1ad3e61c31b307f02f7a25f28f6e6fe8b719b59188bafc13daa096681d191045be64a191d629646d05c4ef955e8d95e501359645277d
+  data.tar.gz: e265c0df86033ff8c0450dc4c847d9e9284e43b52c5f1973193d89caf88d2a35dea5b5dbe94da3fccbb1a62efb06c199afef43166f764c349b7edb6b879ff6f0

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm: 
+    - jruby-19mode 

data/Gemfile

@@ -0,0 +1,11 @@
+source 'http://rubygems.org'
+
+gem 'json', '>= 1.6.0'
+
+group :development do
+  gem 'rdoc', '~> 3.12'
+  gem 'bundler', '~> 1.0'
+  gem 'jeweler', '~> 2.0.1'
+  gem 'simplecov', '>= 0'
+  gem 'reek', '~> 1.2.8'
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2014 Marcus McCurdy
+
+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,44 @@
+#It's Dangerous to go alone take this...
+
+
+[![Build Status](https://travis-ci.org/volker48/itsdangerousr.svg?branch=master)](https://travis-ci.org/volker48/itsdangerousr)
+
+This is a port of Python's [itsdangerous](https://github.com/mitsuhiko/itsdangerous) to Ruby
+
+###Examples
+
+```ruby
+  require 'itsdangerousr'
+
+  serializer = Itsdangerousr::URLSafeSerializer.new('super secret key')
+
+  payload = {:message => 'Keep it secret, keep it safe', :status => 'ok'}
+
+  result = serializer.dumps(payload)
+
+  puts result
+
+  # "eyJtZXNzYWdlIjoiS2VlcCBpdCBzZWNyZXQsIGtlZXAgaXQgc2FmZSIsInN0YXR1cyI6Im9rIn0.nzD92ZMbV52tUW-yp9IWTKqYHRo"
+
+  decoded = serializer.loads(result)
+
+  puts decoded
+
+  # {:message=>"Keep it secret, keep it safe", :status=>"ok"}
+```
+
+### Contributing to itsdangerousr
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+### Copyright
+
+Copyright (c) 2014 Marcus McCurdy. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://guides.rubygems.org/specification-reference/ for more options
+  gem.name = "itsdangerousr"
+  gem.homepage = "http://github.com/volker48/itsdangerousr"
+  gem.license = "MIT"
+  gem.summary = %Q{Python's itsdangerous ported to Ruby}
+  gem.description = %Q{Sometimes you just want to send some data to untrusted environments. But how to do this safely? The trick involves signing. Given a key only you know, you can cryptographically sign your data and hand it over to someone else. When you get the data back you can easily ensure that nobody tampered with it.}
+  gem.email = "marcus.mccurdy@gmail.com"
+  gem.authors = ["Marcus McCurdy"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+desc "Code coverage detail"
+task :simplecov do
+  ENV['COVERAGE'] = "true"
+  Rake::Task['test'].execute
+end
+
+require 'reek/rake/task'
+Reek::Rake::Task.new do |t|
+  t.fail_on_error = true
+  t.verbose = false
+  t.source_files = 'lib/**/*.rb'
+end
+
+task :default => :test
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "itsdangerousr-gem #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/itsdangerousr.gemspec

@@ -0,0 +1,65 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+# stub: itsdangerousr 1.0.0 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "itsdangerousr"
+  s.version = "1.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib"]
+  s.authors = ["Marcus McCurdy"]
+  s.date = "2014-09-01"
+  s.description = "Sometimes you just want to send some data to untrusted environments. But how to do this safely? The trick involves signing. Given a key only you know, you can cryptographically sign your data and hand it over to someone else. When you get the data back you can easily ensure that nobody tampered with it."
+  s.email = "marcus.mccurdy@gmail.com"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".travis.yml",
+    "Gemfile",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "itsdangerousr.gemspec",
+    "lib/itsdangerousr.rb",
+    "test/helper.rb",
+    "test/test_itsdangerousr.rb"
+  ]
+  s.homepage = "http://github.com/volker48/itsdangerousr"
+  s.licenses = ["MIT"]
+  s.rubygems_version = "2.4.1"
+  s.summary = "Python's itsdangerous ported to Ruby"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<json>, [">= 1.6.0"])
+      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 2.0.1"])
+      s.add_development_dependency(%q<simplecov>, [">= 0"])
+      s.add_development_dependency(%q<reek>, ["~> 1.2.8"])
+    else
+      s.add_dependency(%q<json>, [">= 1.6.0"])
+      s.add_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_dependency(%q<bundler>, ["~> 1.0"])
+      s.add_dependency(%q<jeweler>, ["~> 2.0.1"])
+      s.add_dependency(%q<simplecov>, [">= 0"])
+      s.add_dependency(%q<reek>, ["~> 1.2.8"])
+    end
+  else
+    s.add_dependency(%q<json>, [">= 1.6.0"])
+    s.add_dependency(%q<rdoc>, ["~> 3.12"])
+    s.add_dependency(%q<bundler>, ["~> 1.0"])
+    s.add_dependency(%q<jeweler>, ["~> 2.0.1"])
+    s.add_dependency(%q<simplecov>, [">= 0"])
+    s.add_dependency(%q<reek>, ["~> 1.2.8"])
+  end
+end
+

data/lib/itsdangerousr.rb

@@ -0,0 +1,313 @@
+require 'json'
+require 'base64'
+require 'openssl'
+require 'time'
+require 'zlib'
+
+module Itsdangerousr
+
+  # 2011/01/01 in UTC
+  EPOCH = 1293840000
+
+  def self.base64_encode(string)
+    Base64.urlsafe_encode64(string).gsub(/=+$/, '')
+  end
+
+  def self.base64_decode(string)
+    Base64.urlsafe_decode64(string + '=' * (-string.length % 4))
+  end
+
+
+  def self.constant_time_compare(val1, val2)
+    check = val1.bytesize ^ val2.bytesize
+    val1.bytes.zip(val2.bytes) { |x, y| check |= x ^ y.to_i }
+    check == 0
+  end
+
+  class SigningAlgorithm
+
+    def get_signature(key, value)
+      raise 'Not Implemented'
+    end
+
+    def verify_signature(key, value, sig)
+      Itsdangerousr.constant_time_compare(sig, get_signature(key, value))
+    end
+
+  end
+
+  class HMACAlgorithm < SigningAlgorithm
+
+    def initialize(digest_method=OpenSSL::Digest::SHA1)
+      @digest_method = digest_method
+    end
+
+    def get_signature(key, value)
+      OpenSSL::HMAC.digest(@digest_method.new, key, value)
+    end
+  end
+
+
+  class Signer
+
+    def initialize(secret_key, options={})
+      defaults = {:salt => 'itsdangerous.Signer', :sep => '.',
+                  :key_derivation => 'django-concat',
+                  :digest_method => OpenSSL::Digest::SHA1,
+                  :algorithm => HMACAlgorithm.new()}
+      options = defaults.merge(options)
+      @secret_key = secret_key
+      @sep = options[:sep]
+      @salt = options[:salt]
+      @key_derivation = options[:key_derivation]
+      @digest_method = options[:digest_method]
+      @algorithm = options[:algorithm]
+    end
+
+    def get_signature(value)
+      key = derive_key()
+      sig = @algorithm.get_signature(key, value)
+      Itsdangerousr.base64_encode(sig)
+    end
+
+    def sign(value)
+      value + @sep + get_signature(value)
+    end
+
+    def derive_key
+      case @key_derivation
+        when 'concat'
+          @digest_method.digest(@salt + @secret_key)
+        when 'django-concat'
+          @digest_method.digest(@salt + 'signer' + @secret_key)
+        when 'hmac'
+          hmac = OpenSSL::HMAC.new(@secret_key, @digest_method)
+          hmac.update(@salt)
+          hmac.digest()
+        when 'none'
+          @secret_key
+        else
+          raise TypeError, 'Unknown key derivation method'
+      end
+    end
+
+    def validate(signed_value)
+      begin
+        unsign(signed_value)
+        true
+      rescue BadSignature
+        false
+      end
+    end
+
+    def unsign(signed_value)
+      unless signed_value.include?('.')
+        raise BadSignature, "No #{@sep} found in signed value"
+      end
+      value, _, sig = signed_value.rpartition(@sep)
+      unless verify_signature(value, sig)
+        raise BadSignature.new("Signature #{sig} does not match", value)
+      end
+      value
+    end
+
+    def verify_signature(value, sig)
+      key = derive_key()
+      sig = Itsdangerousr.base64_decode(sig)
+      @algorithm.verify_signature(key, value, sig)
+    end
+
+  end
+
+  class TimestampSigner < Signer
+    def sign(value)
+      timestamp = Itsdangerousr::base64_encode((Time.now.to_i - Itsdangerousr::EPOCH).to_s)
+      value = value + @sep + timestamp
+      value + @sep + get_signature(value)
+    end
+
+    def unsign(value, options={})
+      defaults = {:max_age => nil, :return_timestamp => false}
+      options = defaults.merge(options)
+      @max_age = options[:max_age]
+      @return_timestamp = options[:return_timestamp]
+      begin
+        result = super(value)
+        sig_error = nil
+      rescue BadSignature => e
+        sig_error = e
+        if e.payload.nil?
+          result = e.paylod
+        else
+          result = ''
+        end
+
+      end
+
+      unless result.include?(@sep)
+        if sig_error
+          raise sig_error
+        end
+        raise BadTimeSignature, 'Timestamp missing'
+      end
+
+      value, _, timestamp = result.rpartition(@sep)
+
+      begin
+        timestamp = Itsdangerousr::base64_decode(timestamp).to_i
+      rescue StandardError
+        timestamp = nil
+      end
+
+      unless sig_error.nil?
+        raise BadTimeSignature.new(sig_error.message, value, timestamp)
+      end
+
+      if timestamp.nil?
+        raise BadTimeSignature.new('Malformed timestamp', value)
+      end
+
+      unless @max_age.nil?
+        age = (Time.now.to_i - Itsdangerousr::EPOCH) - timestamp.to_i
+        if age > @max_age
+          raise SignatureExpired.new("Signature age %s > %s seconds" % [age, @max_age], value,)
+        end
+      end
+
+      if @return_timestamp
+        return value, timestamp
+      end
+      value
+    end
+  end
+
+  class BadSignature < StandardError
+
+    attr_reader :payload
+
+    def initialize(message, payload=nil)
+      super(message)
+      @payload = payload
+    end
+
+  end
+
+  class BadTimeSignature < BadSignature
+    def initialize (message, payload=nil, date_signed=nil)
+      super(message, payload)
+      @date_signed = date_signed
+    end
+  end
+
+  class SignatureExpired < BadTimeSignature
+
+  end
+
+  class BadPayload < StandardError
+
+  end
+
+  class Serializer
+
+    def initialize(secret_key, options={})
+      defaults = {:salt => 'itsdangerous', :serializer => JSON,
+                  :signer => Signer, :signer_kwargs => {}}
+      options = defaults.merge(options)
+      @secret_key = secret_key
+      @salt = options[:salt]
+      @serializer = options[:serializer]
+      @signer = options[:signer]
+      @signer_kwargs = options[:signer_kwargs]
+    end
+
+    def load_payload(payload, options={})
+      defaults = {:serializer => @serializer}
+      options = defaults.merge(options)
+      serializer = options[:serializer]
+      serializer.load(payload, nil, :symbolize_names => true)
+    end
+
+    def dump_payload(obj)
+      @serializer.dump(obj)
+    end
+
+    def make_signer(options={})
+      defaults = {:salt => @salt}
+      options = defaults.merge(options)
+      @signer.new(@secret_key, @signer_kwargs.merge(:salt => options[:salt]))
+    end
+
+    def dumps(obj, salt=@salt)
+      payload = dump_payload(obj)
+      make_signer(:salt => salt).sign(payload)
+    end
+
+    def loads(s, salt=@salt)
+      load_payload(make_signer(:salt => salt).unsign(s))
+    end
+
+  end
+
+  module URLSafeSerializerMixin
+
+    def load_payload(payload)
+      decompress = false
+      if payload.start_with?('.')
+        payload = payload[1..-1]
+        decompress = true
+      end
+      json = Itsdangerousr.base64_decode(payload)
+      if decompress
+        begin
+          json = Zlib::Inflate.inflate(json)
+        rescue => e
+          raise BadPayload, "Could not zlib decompress the payload before decoding the payload. #{e}"
+        end
+      end
+      super(json)
+    end
+
+    def dump_payload(obj)
+      json = super(obj)
+      is_compressed = false
+      compressed = Zlib::Deflate.deflate(json)
+      if compressed.length < json.length - 1
+        json = compressed
+        is_compressed = true
+      end
+      base64d = Itsdangerousr.base64_encode(json)
+      base64d.prepend('.') if is_compressed
+      base64d
+    end
+
+  end
+
+  class TimedSerializer < Serializer
+
+    def initialize(secret_key, options={:signer => TimestampSigner})
+      super(secret_key, options)
+    end
+
+    def loads(s, options={})
+      defaults = {:max_age=>nil, :return_timestamp=>false, :salt=>@salt}
+      options = defaults.merge(options)
+      signer = make_signer(:salt => options[:salt])
+      base64d, timestamp = signer.unsign(s, options)
+      payload = load_payload(base64d)
+      if options[:return_timestamp]
+        return payload, timestamp
+      end
+      payload
+    end
+
+  end
+
+  class URLSafeSerializer < Serializer
+    include URLSafeSerializerMixin
+  end
+
+  class URLSafeTimedSerializer < TimedSerializer
+    include URLSafeSerializerMixin
+  end
+
+end

data/test/helper.rb

@@ -0,0 +1,30 @@
+require 'simplecov'
+
+module SimpleCov::Configuration
+  def clean_filters
+    @filters = []
+  end
+end
+
+SimpleCov.configure do
+  clean_filters
+  load_adapter 'test_frameworks'
+end
+
+ENV["COVERAGE"] && SimpleCov.start do
+  add_filter "/.rvm/"
+end
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'itsdangerousr'

data/test/test_itsdangerousr.rb

@@ -0,0 +1,214 @@
+require_relative 'helper'
+
+class UtilityTests < Test::Unit::TestCase
+
+  def test_base64_encode
+    encoded = Itsdangerousr.base64_encode('this is a long test')
+    assert(encoded == 'dGhpcyBpcyBhIGxvbmcgdGVzdA')
+  end
+
+  def test_base64_decode
+    decoded = Itsdangerousr.base64_decode('dGhpcyBpcyBhIGxvbmcgdGVzdA')
+    assert(decoded == 'this is a long test')
+  end
+
+  def test_ctc_equal
+    assert(Itsdangerousr.constant_time_compare('abc123', 'abc123'))
+
+  end
+
+  def test_ctc_val1_longer
+    assert(!Itsdangerousr.constant_time_compare('asdfasdfasdf', 'a'))
+  end
+
+  def test_ctc_val2_longer
+    assert(!Itsdangerousr.constant_time_compare('a', 'asdf123asdf235a'))
+  end
+
+  def test_ctc_empty_string
+    assert(Itsdangerousr.constant_time_compare('', ''))
+  end
+
+end
+
+class SignerTests < Test::Unit::TestCase
+  def setup
+    @signer = Itsdangerousr::Signer.new('key')
+  end
+
+  def test_derive_key
+      sha1 = OpenSSL::Digest.new('sha1')
+      expected_digest = sha1.digest('itsdangerous.Signer' + 'signer' + 'key')
+      digest = @signer.derive_key()
+      assert(expected_digest == digest)
+    end
+end
+
+class SerializerTests < Test::Unit::TestCase
+
+  def setup
+    @serializer = Itsdangerousr::Serializer.new('key')
+  end
+
+  def test_dump_payload
+    payload = {:message => 'hello', :status => 'ok'}
+    dumped = @serializer.dump_payload(payload)
+    assert(dumped == '{"message":"hello","status":"ok"}')
+  end
+
+  def test_load_payload
+    payload = '{"message":"hello","status":"ok"}'
+    loaded = @serializer.load_payload(payload)
+    assert(loaded[:message] == 'hello')
+    assert(loaded[:status] == 'ok')
+  end
+
+  def test_dumps
+    payload = {:message => 'python rules'}
+    dumped = @serializer.dumps(payload)
+    signer = Itsdangerousr::Signer.new('key', :salt => 'itsdangerous')
+    key = signer.derive_key()
+    hmaced = OpenSSL::HMAC.digest(OpenSSL::Digest::SHA1.new, key, '{"message":"python rules"}'.encode('utf-8'))
+    encoded = Itsdangerousr.base64_encode(hmaced)
+    assert(dumped == "{\"message\":\"python rules\"}.#{encoded}")
+  end
+
+  def test_dumps_loads
+    test_cases = [['a', 'list'], 'a string', 'a unicode string \u2019', {:a => 'dictionary'}, 42, 42.5]
+    test_cases.each do |test_case|
+      dumped = @serializer.dumps(test_case)
+      assert_not_equal(test_case, dumped)
+      loaded = @serializer.loads(dumped)
+      assert_equal(test_case, loaded)
+    end
+  end
+
+end
+
+class URLSafeSerializerTests < Test::Unit::TestCase
+
+  def setup
+    @serializer = Itsdangerousr::URLSafeSerializer.new('key')
+    @short_payload = {:message => 'This is a test', :status => 'ok'}
+    @long_payload = {:message => 'This is a longer message so we can see if it will compress something long', :lift => 'do you even, bro?', :status => 'copacetic'}
+  end
+
+  def test_dump_payload_short
+    dumped = @serializer.dumps(@short_payload)
+    assert(dumped[0] != '.')
+    assert(dumped.include?('.'))
+  end
+
+  def test_dumps_loads
+    test_cases = [['a', 'list'], 'a string', 'a unicode string \u2019',
+                  {:a => 'dictionary'}, 42, 42.5,
+                  {:message => 'this is a longer dict want to test out compression',
+                   :status => 'great thanks for asking'}]
+    test_cases.each do |test_case|
+      dumped = @serializer.dumps(test_case)
+      assert_not_equal(test_case, dumped)
+      loaded = @serializer.loads(dumped)
+      assert_equal(test_case, loaded)
+    end
+  end
+
+  def test_load_from_python
+    key = "\x18j\xe4iiw\xdd\xcb\xacF\x1a\xc0\x17\xc5\x8b\xe7"
+    plain_text = 'this is something i want secure'
+    from_python = 'InRoaXMgaXMgc29tZXRoaW5nIGkgd2FudCBzZWN1cmUi.8frS9vZcZJCSLAW7zK-gGC68JKM'
+    s = Itsdangerousr::URLSafeSerializer.new(key)
+    loaded = s.loads(from_python)
+    assert_equal(plain_text, loaded)
+  end
+
+end
+
+
+class TimedSignerTests < Test::Unit::TestCase
+  def setup
+    @signer = Itsdangerousr::TimestampSigner.new('secret')
+  end
+
+  def test_sign
+    signed = @signer.sign('this is a test')
+    assert(signed.include?('this is a test'))
+    assert(signed.count('.') == 2)
+  end
+
+  def test_unsign_no_options
+    signed = @signer.sign('this is a test')
+    unsigned = @signer.unsign(signed)
+    assert(unsigned == 'this is a test')
+  end
+
+  def test_sig_error
+    signed = @signer.sign('my test')
+    other_signer = Itsdangerousr::TimestampSigner.new('other secret')
+    assert_raise(Itsdangerousr::BadSignature, "Raise exception on bad signature") {
+      other_signer.unsign(signed)
+    }
+  end
+
+  def test_raises_badtimesignature
+    non_timestamp_signed = Itsdangerousr::Signer.new('secret').sign('test')
+    assert_raise(Itsdangerousr::BadTimeSignature, "Raise exception on missing timestamp") {
+      @signer.unsign(non_timestamp_signed)
+    }
+  end
+
+end
+
+class TimedSerializerTests < Test::Unit::TestCase
+
+  def setup
+    @serializer = Itsdangerousr::TimedSerializer.new('secret')
+  end
+
+  def test_not_expired
+    original = 'My data'
+    payload = @serializer.dumps(original)
+    assert_not_equal(payload, original)
+    loaded = @serializer.loads(payload, :max_age => 500)
+    assert_equal(original, loaded)
+  end
+
+  def test_expired
+    original = {:message => 'The files are _in_ the computer?'}
+    payload = @serializer.dumps(original)
+    assert_not_equal(payload, original)
+    sleep(2)
+    assert_raise(Itsdangerousr::SignatureExpired, "Timestamp should be too old") {
+      @serializer.loads(payload, :max_age => 1)
+    }
+  end
+
+
+
+end
+
+class URLSafeTimedSerializerTests < Test::Unit::TestCase
+
+  def setup
+    @serializer = Itsdangerousr::URLSafeTimedSerializer.new('secret')
+  end
+
+  def test_from_python
+      original = {:message => 'this better work'}
+      from_python = 'eyJtZXNzYWdlIjoidGhpcyBiZXR0ZXIgd29yayJ9.BuZqLQ.bjbIUg3pAgW4URRFHWkzIrC4OgU'
+      loaded = @serializer.loads(from_python, :max_age => 60*60*24*365*100)
+      assert_equal(original, loaded)
+  end
+  
+  def test_expired
+    original = {:message => 'The files are _in_ the computer?'}
+    payload = @serializer.dumps(original)
+    assert_not_equal(payload, original)
+    sleep(2)
+    assert_raise(Itsdangerousr::SignatureExpired, "Timestamp should be too old") {
+      @serializer.loads(payload, :max_age => 1)
+    }
+  end
+
+end
+
+

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: itsdangerousr
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Marcus McCurdy
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2014-09-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+  name: json
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  name: rdoc
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  name: bundler
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+  name: jeweler
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: simplecov
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.8
+  name: reek
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.8
+description: Sometimes you just want to send some data to untrusted environments. But how to do this safely? The trick involves signing. Given a key only you know, you can cryptographically sign your data and hand it over to someone else. When you get the data back you can easily ensure that nobody tampered with it.
+email: marcus.mccurdy@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- itsdangerousr.gemspec
+- lib/itsdangerousr.rb
+- test/helper.rb
+- test/test_itsdangerousr.rb
+homepage: http://github.com/volker48/itsdangerousr
+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.4.1
+signing_key:
+specification_version: 4
+summary: Python's itsdangerous ported to Ruby
+test_files: []