jruby-openssl 0.8.0.pre3 → 0.8.0

data/test/1.8/test_digest.rb

@@ -1,88 +0,0 @@
-begin
-  require "openssl"
-rescue LoadError
-end
-require "digest/md5"
-require "test/unit"
-
-if defined?(OpenSSL)
-
-class OpenSSL::TestDigest < Test::Unit::TestCase
-  def setup
-    @d1 = OpenSSL::Digest::Digest::new("MD5")
-    @d2 = OpenSSL::Digest::MD5.new
-    @md = Digest::MD5.new
-    @data = "DATA"
-  end
-
-  def teardown
-    @d1 = @d2 = @md = nil
-  end
-
-  def test_digest
-    assert_equal(@md.digest, @d1.digest)
-    assert_equal(@md.hexdigest, @d1.hexdigest)
-    @d1 << @data
-    @d2 << @data
-    @md << @data
-    assert_equal(@md.digest, @d1.digest)
-    assert_equal(@md.hexdigest, @d1.hexdigest)
-    assert_equal(@d1.digest, @d2.digest)
-    assert_equal(@d1.hexdigest, @d2.hexdigest)
-    assert_equal(@md.digest, OpenSSL::Digest::MD5.digest(@data))
-    assert_equal(@md.hexdigest, OpenSSL::Digest::MD5.hexdigest(@data))
-  end
-
-  def test_eql
-    assert(@d1 == @d2, "==")
-    d = @d1.clone
-    assert(d == @d1, "clone")
-  end
-
-  def test_info
-    assert_equal("MD5", @d1.name, "name")
-    assert_equal("MD5", @d2.name, "name")
-    assert_equal(16, @d1.size, "size")
-  end
-
-  def test_dup
-    @d1.update(@data)
-    assert_equal(@d1.name, @d1.dup.name, "dup")
-    assert_equal(@d1.name, @d1.clone.name, "clone")
-    assert_equal(@d1.digest, @d1.clone.digest, "clone .digest")
-  end
-
-  def test_reset
-    @d1.update(@data)
-    dig1 = @d1.digest
-    @d1.reset
-    @d1.update(@data)
-    dig2 = @d1.digest
-    assert_equal(dig1, dig2, "reset")
-  end
-
-  if OpenSSL::OPENSSL_VERSION_NUMBER > 0x00908000
-    def encode16(str)
-      str.unpack("H*").first
-    end
-
-    def test_098_features
-      sha224_a = "abd37534c7d9a2efb9465de931cd7055ffdb8879563ae98078d6d6d5"
-      sha256_a = "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"
-      sha384_a = "54a59b9f22b0b80880d8427e548b7c23abd873486e1f035dce9cd697e85175033caa88e6d57bc35efae0b5afd3145f31"
-      sha512_a = "1f40fc92da241694750979ee6cf582f2d5d7d28e18335de05abc54d0560e0f5302860c652bf08d560252aa5e74210546f369fbbbce8c12cfc7957b2652fe9a75"
-
-      assert_equal(sha224_a, OpenSSL::Digest::SHA224.hexdigest("a"))
-      assert_equal(sha256_a, OpenSSL::Digest::SHA256.hexdigest("a"))
-      assert_equal(sha384_a, OpenSSL::Digest::SHA384.hexdigest("a"))
-      assert_equal(sha512_a, OpenSSL::Digest::SHA512.hexdigest("a"))
-
-      assert_equal(sha224_a, encode16(OpenSSL::Digest::SHA224.digest("a")))
-      assert_equal(sha256_a, encode16(OpenSSL::Digest::SHA256.digest("a")))
-      assert_equal(sha384_a, encode16(OpenSSL::Digest::SHA384.digest("a")))
-      assert_equal(sha512_a, encode16(OpenSSL::Digest::SHA512.digest("a")))
-    end
-  end
-end
-
-end

data/test/1.8/test_ec.rb

@@ -1,128 +0,0 @@
-begin
-  require "openssl"
-  require File.join(File.dirname(__FILE__), "utils.rb")
-rescue LoadError
-end
-require "test/unit"
-
-if defined?(OpenSSL::PKey::EC)
-
-class OpenSSL::TestEC < Test::Unit::TestCase
-  def setup
-    @data1 = 'foo'
-    @data2 = 'bar' * 1000 # data too long for DSA sig
-
-    @group1 = OpenSSL::PKey::EC::Group.new('secp112r1')
-    @group2 = OpenSSL::PKey::EC::Group.new('sect163k1')
-
-    @key1 = OpenSSL::PKey::EC.new
-    @key1.group = @group1
-    @key1.generate_key
-
-    @key2 = OpenSSL::PKey::EC.new(@group2.curve_name)
-    @key2.generate_key
-
-    @groups = [@group1, @group2]
-    @keys = [@key1, @key2]
-  end
-
-  def compare_keys(k1, k2)
-    assert_equal(k1.to_pem, k2.to_pem)
-  end
-
-  def test_curve_names
-    @groups.each_with_index do |group, idx|
-      key = @keys[idx]
-      assert_equal(group.curve_name, key.group.curve_name)
-    end
-  end
-
-  def test_check_key
-    for key in @keys
-      assert_equal(key.check_key, true)
-      assert_equal(key.private_key?, true)
-      assert_equal(key.public_key?, true)
-    end
-  end
-
-  def test_encoding
-    for group in @groups
-      for meth in [:to_der, :to_pem]
-        txt = group.send(meth)
-        gr = OpenSSL::PKey::EC::Group.new(txt)
-        assert_equal(txt, gr.send(meth))
-
-        assert_equal(group.generator.to_bn, gr.generator.to_bn)
-        assert_equal(group.cofactor, gr.cofactor)
-        assert_equal(group.order, gr.order)
-        assert_equal(group.seed, gr.seed)
-        assert_equal(group.degree, gr.degree)
-      end
-    end
-
-    for key in @keys
-      group = key.group
-
-      for meth in [:to_der, :to_pem]
-        txt = key.send(meth)
-        assert_equal(txt, OpenSSL::PKey::EC.new(txt).send(meth))
-      end
-
-      bn = key.public_key.to_bn
-      assert_equal(bn, OpenSSL::PKey::EC::Point.new(group, bn).to_bn)
-    end
-  end
-
-  def test_set_keys
-    for key in @keys
-      k = OpenSSL::PKey::EC.new
-      k.group = key.group
-      k.private_key = key.private_key
-      k.public_key = key.public_key
-
-      compare_keys(key, k)
-    end
-  end
-
-  def test_dsa_sign_verify
-    for key in @keys
-      sig = key.dsa_sign_asn1(@data1)
-      assert(key.dsa_verify_asn1(@data1, sig))
-    end
-  end
-
-  def test_dsa_sign_asn1_FIPS186_3
-    for key in @keys
-      size = key.group.order.num_bits / 8 + 1
-      dgst = (1..size).to_a.pack('C*')
-      begin
-        sig = key.dsa_sign_asn1(dgst)
-        # dgst is auto-truncated according to FIPS186-3 after openssl-0.9.8m
-        assert(key.dsa_verify_asn1(dgst + "garbage", sig))
-      rescue OpenSSL::PKey::ECError => e
-        # just an exception for longer dgst before openssl-0.9.8m
-        assert_equal('ECDSA_sign: data too large for key size', e.message)
-        # no need to do following tests
-        return
-      end
-    end
-  end
-
-  def test_dh_compute_key
-    for key in @keys
-      k = OpenSSL::PKey::EC.new(key.group)
-      k.generate_key
-
-      puba = key.public_key
-      pubb = k.public_key
-      a = key.dh_compute_key(pubb)
-      b = k.dh_compute_key(puba)
-      assert_equal(a, b)
-    end
-  end
-
-# test Group: asn1_flag, point_conversion
-
-end
-
-end

data/test/1.8/test_hmac.rb

@@ -1,46 +0,0 @@
-begin
-  require "openssl"
-rescue LoadError
-end
-require "test/unit"
-
-class OpenSSL::TestHMAC < Test::Unit::TestCase
-  def setup
-    @digest = OpenSSL::Digest::MD5
-    @key = "KEY"
-    @data = "DATA"
-    @h1 = OpenSSL::HMAC.new(@key, @digest.new)
-    @h2 = OpenSSL::HMAC.new(@key, "MD5")
-  end
-
-  def teardown
-  end
-
-  def test_hmac
-    @h1.update(@data)
-    @h2.update(@data)
-    assert_equal(@h1.digest, @h2.digest)
-
-    assert_equal(OpenSSL::HMAC.digest(@digest.new, @key, @data), @h1.digest, "digest")
-    assert_equal(OpenSSL::HMAC.hexdigest(@digest.new, @key, @data), @h1.hexdigest, "hexdigest")
-
-    assert_equal(OpenSSL::HMAC.digest("MD5", @key, @data), @h2.digest, "digest")
-    assert_equal(OpenSSL::HMAC.hexdigest("MD5", @key, @data), @h2.hexdigest, "hexdigest")
-  end
-
-  def test_dup
-    @h1.update(@data)
-    h = @h1.dup
-    assert_equal(@h1.digest, h.digest, "dup digest")
-  end
-
-  def test_sha256
-    digest256 = OpenSSL::Digest::Digest.new("sha256")
-    assert_equal(
-      "\210\236-\3270\331Yq\265\177sE\266\231hXa\332\250\026\235O&c*\307\001\227~\260n\362",
-      OpenSSL::HMAC.digest(digest256, 'blah', "blah"))
-    assert_equal(
-      "889e2dd730d95971b57f7345b699685861daa8169d4f26632ac701977eb06ef2",
-      OpenSSL::HMAC.hexdigest(digest256, 'blah', "blah"))
-  end
-end

data/test/1.8/test_ns_spki.rb

@@ -1,59 +0,0 @@
-begin
-  require "openssl"
-  require File.join(File.dirname(__FILE__), "utils.rb")
-rescue LoadError
-end
-require "test/unit"
-
-if defined?(OpenSSL)
-
-
-class OpenSSL::TestNSSPI < Test::Unit::TestCase
-  def setup
-    # This request data is adopt from the specification of
-    # "Netscape Extensions for User Key Generation".
-    # -- http://wp.netscape.com/eng/security/comm4-keygen.html
-    @b64  = "MIHFMHEwXDANBgkqhkiG9w0BAQEFAANLADBIAkEAnX0TILJrOMUue+PtwBRE6XfV"
-    @b64 << "WtKQbsshxk5ZhcUwcwyvcnIq9b82QhJdoACdD34rqfCAIND46fXKQUnb0mvKzQID"
-    @b64 << "AQABFhFNb3ppbGxhSXNNeUZyaWVuZDANBgkqhkiG9w0BAQQFAANBAAKv2Eex2n/S"
-    @b64 << "r/7iJNroWlSzSMtTiQTEB+ADWHGj9u1xrUrOilq/o2cuQxIfZcNZkYAkWP4DubqW"
-    @b64 << "i0//rgBvmco="
-  end
-
-  def teardown
-  end
-
-  def test_build_data
-    key1 = OpenSSL::TestUtils::TEST_KEY_RSA1024
-    key2 = OpenSSL::TestUtils::TEST_KEY_RSA2048
-    spki = OpenSSL::Netscape::SPKI.new
-    spki.challenge = "RandomString"
-    spki.public_key = key1.public_key
-    spki.sign(key1, OpenSSL::Digest::SHA1.new)
-    assert(spki.verify(spki.public_key))
-    assert(spki.verify(key1.public_key))
-    assert(!spki.verify(key2.public_key))
-
-    der = spki.to_der
-    spki = OpenSSL::Netscape::SPKI.new(der)
-    assert_equal("RandomString", spki.challenge)
-    assert_equal(key1.public_key.to_der, spki.public_key.to_der)
-    assert(spki.verify(spki.public_key))
-  end
-
-  def test_decode_data
-    spki = OpenSSL::Netscape::SPKI.new(@b64)
-    assert_equal(@b64, spki.to_pem)
-    assert_equal(@b64.unpack("m").first, spki.to_der)
-    assert_equal("MozillaIsMyFriend", spki.challenge)
-    assert_equal(OpenSSL::PKey::RSA, spki.public_key.class)
-
-    spki = OpenSSL::Netscape::SPKI.new(@b64.unpack("m").first)
-    assert_equal(@b64, spki.to_pem)
-    assert_equal(@b64.unpack("m").first, spki.to_der)
-    assert_equal("MozillaIsMyFriend", spki.challenge)
-    assert_equal(OpenSSL::PKey::RSA, spki.public_key.class)
-  end
-end
-
-end

data/test/1.8/test_pair.rb

@@ -1,149 +0,0 @@
-begin
-  require "openssl"
-rescue LoadError
-end
-require 'test/unit'
-
-if defined?(OpenSSL)
-
-require 'socket'
-require File.join(File.dirname(__FILE__), "../ut_eof")
-
-module SSLPair
-  def server
-    host = "127.0.0.1"
-    port = 0
-    ctx = OpenSSL::SSL::SSLContext.new()
-    ctx.ciphers = "ADH"
-    tcps = TCPServer.new(host, port)
-    ssls = OpenSSL::SSL::SSLServer.new(tcps, ctx)
-    return ssls
-  end
-
-  def client(port)
-    host = "127.0.0.1"
-    ctx = OpenSSL::SSL::SSLContext.new()
-    ctx.ciphers = "ADH"
-    s = TCPSocket.new(host, port)
-    ssl = OpenSSL::SSL::SSLSocket.new(s, ctx)
-    ssl.connect
-    ssl.sync_close = true
-    ssl
-  end
-
-  def ssl_pair
-    ssls = server
-    th = Thread.new {
-      ns = ssls.accept
-      ssls.close
-      ns
-    }
-    port = ssls.to_io.addr[1]
-    c = client(port)
-    s = th.value
-    if block_given?
-      begin
-        yield c, s
-      ensure
-        c.close unless c.closed?
-        s.close unless s.closed?
-      end
-    else
-      return c, s
-    end
-  end
-end
-
-class OpenSSL::TestEOF1 < Test::Unit::TestCase
-  include TestEOF
-  include SSLPair
-
-  def open_file(content)
-    s1, s2 = ssl_pair
-    Thread.new { s2 << content; s2.close }
-    yield s1
-  end
-end
-
-class OpenSSL::TestEOF2 < Test::Unit::TestCase
-  include TestEOF
-  include SSLPair
-
-  def open_file(content)
-    s1, s2 = ssl_pair
-    Thread.new { s1 << content; s1.close }
-    yield s2
-  end
-end
-
-class OpenSSL::TestPair < Test::Unit::TestCase
-  include SSLPair
-
-  def test_getc
-    ssl_pair {|s1, s2|
-      s1 << "a"
-      assert_equal(?a, s2.getc)
-    }
-  end
-
-  def test_readpartial
-    ssl_pair {|s1, s2|
-      s2.write "a\nbcd"
-      assert_equal("a\n", s1.gets)
-      read = s1.readpartial(10)
-      assert_equal("bcd"[0, read.bytesize], read)
-      s1.read(read.bytesize - 3) # drop unread bytes
-
-      s2.write "efg"
-      read = s1.readpartial(10)
-      assert_equal("efg"[0, read.bytesize], read)
-      rest = 3 - read.bytesize
-      while rest > 0
-        rest -= s1.readpartial(rest).size
-      end
-      s2.close
-      assert_raise(EOFError) { s1.readpartial(10) }
-      assert_raise(EOFError) { s1.readpartial(10) }
-      assert_equal("", s1.readpartial(0))
-    }
-  end
-
-  def test_readall
-    ssl_pair {|s1, s2|
-      s2.close
-      assert_equal("", s1.read)
-    }
-  end
-
-  def test_readline
-    ssl_pair {|s1, s2|
-      s2.close
-      assert_raise(EOFError) { s1.readline }
-    }
-  end
-
-  def test_puts_meta
-    ssl_pair {|s1, s2|
-      begin
-        old = $/
-        $/ = '*'
-        s1.puts 'a'
-      ensure
-        $/ = old
-      end
-      s1.close
-      assert_equal("a\n", s2.read)
-    }
-  end
-
-  def test_puts_empty
-    ssl_pair {|s1, s2|
-      s1.puts
-      s1.close
-      assert_equal("\n", s2.read)
-    }
-  end
-
-end
-
-end