jruby-openssl 0.7.4 → 0.7.6.1

data/test/1.9/test_pkey_dsa.rb

@@ -0,0 +1,224 @@
+require_relative 'utils'
+require 'base64'
+
+if defined?(OpenSSL)
+
+class OpenSSL::TestPKeyDSA < Test::Unit::TestCase
+  def test_private
+    key = OpenSSL::PKey::DSA.new(256)
+    assert(key.private?)
+    key2 = OpenSSL::PKey::DSA.new(key.to_der)
+    assert(key2.private?)
+    key3 = key.public_key
+    assert(!key3.private?)
+    key4 = OpenSSL::PKey::DSA.new(key3.to_der)
+    assert(!key4.private?)
+  end
+
+  def test_new
+    key = OpenSSL::PKey::DSA.new 256
+    pem  = key.public_key.to_pem
+    OpenSSL::PKey::DSA.new pem
+    assert_equal([], OpenSSL.errors)
+  end
+
+  def test_sys_sign_verify
+    key = OpenSSL::TestUtils::TEST_KEY_DSA256
+    data = 'Sign me!'
+    digest = OpenSSL::Digest::SHA1.digest(data)
+    sig = key.syssign(digest)
+    assert(key.sysverify(digest, sig))
+  end
+
+  def test_sign_verify
+    check_sign_verify(OpenSSL::Digest::DSS1.new)
+  end
+
+if (OpenSSL::OPENSSL_VERSION_NUMBER > 0x10000000)
+  def test_sign_verify_sha1
+    check_sign_verify(OpenSSL::Digest::SHA1.new)
+  end
+
+  def test_sign_verify_sha256
+    check_sign_verify(OpenSSL::Digest::SHA256.new)
+  end
+end
+
+  def test_digest_state_irrelevant_verify
+    key = OpenSSL::TestUtils::TEST_KEY_DSA256
+    digest1 = OpenSSL::Digest::DSS1.new
+    digest2 = OpenSSL::Digest::DSS1.new
+    data = 'Sign me!'
+    sig = key.sign(digest1, data)
+    digest1.reset
+    digest1 << 'Change state of digest1'
+    assert(key.verify(digest1, sig, data))
+    assert(key.verify(digest2, sig, data))
+  end
+
+  def test_read_DSA_PUBKEY
+    p = 7188211954100152441468596248707152960171255279130004340103875772401008316444412091945435731597638374542374929457672178957081124632837356913990200866056699
+    q = 957032439192465935099784319494405376402293318491
+    g = 122928973717064636255205666162891733518376475981809749897454444301389338825906076467196186192907631719698166056821519884939865041993585844526937010746285
+    y = 1235756183583465414789073313502727057075641172514181938731172021825149551960029708596057102104063395063907739571546165975727369183495540798749742124846271
+    algo = OpenSSL::ASN1::ObjectId.new('DSA')
+    params = OpenSSL::ASN1::Sequence.new([OpenSSL::ASN1::Integer.new(p),
+                                          OpenSSL::ASN1::Integer.new(q),
+                                          OpenSSL::ASN1::Integer.new(g)])
+    algo_id = OpenSSL::ASN1::Sequence.new ([algo, params])
+    pub_key = OpenSSL::ASN1::Integer.new(y)
+    seq = OpenSSL::ASN1::Sequence.new([algo_id, OpenSSL::ASN1::BitString.new(pub_key.to_der)])
+    key = OpenSSL::PKey::DSA.new(seq.to_der)
+    assert(key.public?)
+    assert(!key.private?)
+    assert_equal(p, key.p)
+    assert_equal(q, key.q)
+    assert_equal(g, key.g)
+    assert_equal(y, key.pub_key)
+    assert_equal(nil, key.priv_key)
+    assert_equal([], OpenSSL.errors)
+  end
+
+  def test_read_DSAPublicKey_pem
+    p = 12260055936871293565827712385212529106400444521449663325576634579961635627321079536132296996623400607469624537382977152381984332395192110731059176842635699
+    q = 979494906553787301107832405790107343409973851677
+    g = 3731695366899846297271147240305742456317979984190506040697507048095553842519347835107669437969086119948785140453492839427038591924536131566350847469993845
+    y = 10505239074982761504240823422422813362721498896040719759460296306305851824586095328615844661273887569281276387605297130014564808567159023649684010036304695
+    pem = <<-EOF
+-----BEGIN DSA PUBLIC KEY-----
+MIHfAkEAyJSJ+g+P/knVcgDwwTzC7Pwg/pWs2EMd/r+lYlXhNfzg0biuXRul8VR4
+VUC/phySExY0PdcqItkR/xYAYNMbNwJBAOoV57X0FxKO/PrNa/MkoWzkCKV/hzhE
+p0zbFdsicw+hIjJ7S6Sd/FlDlo89HQZ2FuvWJ6wGLM1j00r39+F2qbMCFQCrkhIX
+SG+is37hz1IaBeEudjB2HQJAR0AloavBvtsng8obsjLb7EKnB+pSeHr/BdIQ3VH7
+fWLOqqkzFeRrYMDzUpl36XktY6Yq8EJYlW9pCMmBVNy/dQ==
+-----END DSA PUBLIC KEY-----
+    EOF
+    key = OpenSSL::PKey::DSA.new(pem)
+    assert(key.public?)
+    assert(!key.private?)
+    assert_equal(p, key.p)
+    assert_equal(q, key.q)
+    assert_equal(g, key.g)
+    assert_equal(y, key.pub_key)
+    assert_equal(nil, key.priv_key)
+    assert_equal([], OpenSSL.errors)
+  end
+
+  def test_read_DSA_PUBKEY_pem
+    p = 12260055936871293565827712385212529106400444521449663325576634579961635627321079536132296996623400607469624537382977152381984332395192110731059176842635699
+    q = 979494906553787301107832405790107343409973851677
+    g = 3731695366899846297271147240305742456317979984190506040697507048095553842519347835107669437969086119948785140453492839427038591924536131566350847469993845
+    y = 10505239074982761504240823422422813362721498896040719759460296306305851824586095328615844661273887569281276387605297130014564808567159023649684010036304695
+    pem = <<-EOF
+-----BEGIN PUBLIC KEY-----
+MIHxMIGoBgcqhkjOOAQBMIGcAkEA6hXntfQXEo78+s1r8yShbOQIpX+HOESnTNsV
+2yJzD6EiMntLpJ38WUOWjz0dBnYW69YnrAYszWPTSvf34XapswIVAKuSEhdIb6Kz
+fuHPUhoF4S52MHYdAkBHQCWhq8G+2yeDyhuyMtvsQqcH6lJ4ev8F0hDdUft9Ys6q
+qTMV5GtgwPNSmXfpeS1jpirwQliVb2kIyYFU3L91A0QAAkEAyJSJ+g+P/knVcgDw
+wTzC7Pwg/pWs2EMd/r+lYlXhNfzg0biuXRul8VR4VUC/phySExY0PdcqItkR/xYA
+YNMbNw==
+-----END PUBLIC KEY-----
+    EOF
+    key = OpenSSL::PKey::DSA.new(pem)
+    assert(key.public?)
+    assert(!key.private?)
+    assert_equal(p, key.p)
+    assert_equal(q, key.q)
+    assert_equal(g, key.g)
+    assert_equal(y, key.pub_key)
+    assert_equal(nil, key.priv_key)
+    assert_equal([], OpenSSL.errors)
+  end
+
+  def test_export_format_is_DSA_PUBKEY_pem
+    key = OpenSSL::TestUtils::TEST_KEY_DSA256
+    pem = key.public_key.to_pem
+    pem.gsub!(/^-+(\w|\s)+-+$/, "") # eliminate --------BEGIN...-------
+    asn1 = OpenSSL::ASN1.decode(Base64.decode64(pem))
+    assert_equal(OpenSSL::ASN1::SEQUENCE, asn1.tag)
+    assert_equal(2, asn1.value.size)
+    seq = asn1.value
+    assert_equal(OpenSSL::ASN1::SEQUENCE, seq[0].tag)
+    assert_equal(2, seq[0].value.size)
+    algo_id = seq[0].value
+    assert_equal(OpenSSL::ASN1::OBJECT, algo_id[0].tag)
+    assert_equal('DSA', algo_id[0].value)
+    assert_equal(OpenSSL::ASN1::SEQUENCE, algo_id[1].tag)
+    assert_equal(3, algo_id[1].value.size)
+    params = algo_id[1].value
+    assert_equal(OpenSSL::ASN1::INTEGER, params[0].tag)
+    assert_equal(key.p, params[0].value)
+    assert_equal(OpenSSL::ASN1::INTEGER, params[1].tag)
+    assert_equal(key.q, params[1].value)
+    assert_equal(OpenSSL::ASN1::INTEGER, params[2].tag)
+    assert_equal(key.g, params[2].value)
+    assert_equal(OpenSSL::ASN1::BIT_STRING, seq[1].tag)
+    assert_equal(0, seq[1].unused_bits)
+    pub_key = OpenSSL::ASN1.decode(seq[1].value)
+    assert_equal(OpenSSL::ASN1::INTEGER, pub_key.tag)
+    assert_equal(key.pub_key, pub_key.value)
+    assert_equal([], OpenSSL.errors)
+  end
+
+  def test_read_private_key_der
+    key = OpenSSL::TestUtils::TEST_KEY_DSA256
+    der = key.to_der
+    key2 = OpenSSL::PKey.read(der)
+    assert(key2.private?)
+    assert_equal(der, key2.to_der)
+    assert_equal([], OpenSSL.errors)
+  end
+
+  def test_read_private_key_pem
+    key = OpenSSL::TestUtils::TEST_KEY_DSA256
+    pem = key.to_pem
+    key2 = OpenSSL::PKey.read(pem)
+    assert(key2.private?)
+    assert_equal(pem, key2.to_pem)
+    assert_equal([], OpenSSL.errors)
+  end
+
+  def test_read_public_key_der
+    key = OpenSSL::TestUtils::TEST_KEY_DSA256.public_key
+    der = key.to_der
+    key2 = OpenSSL::PKey.read(der)
+    assert(!key2.private?)
+    assert_equal(der, key2.to_der)
+    assert_equal([], OpenSSL.errors)
+  end
+
+  def test_read_public_key_pem
+    key = OpenSSL::TestUtils::TEST_KEY_DSA256.public_key
+    pem = key.to_pem
+    key2 = OpenSSL::PKey.read(pem)
+    assert(!key2.private?)
+    assert_equal(pem, key2.to_pem)
+    assert_equal([], OpenSSL.errors)
+  end
+
+  def test_read_private_key_pem_pw
+    key = OpenSSL::TestUtils::TEST_KEY_DSA256
+    pem = key.to_pem(OpenSSL::Cipher.new('AES-128-CBC'), 'secret')
+    #callback form for password
+    key2 = OpenSSL::PKey.read(pem) do
+      'secret'
+    end
+    assert(key2.private?)
+    # pass password directly
+    key2 = OpenSSL::PKey.read(pem, 'secret')
+    assert(key2.private?)
+    #omit pem equality check, will be different due to cipher iv
+    assert_equal([], OpenSSL.errors)
+  end
+
+  private
+
+  def check_sign_verify(digest)
+    key = OpenSSL::TestUtils::TEST_KEY_DSA256
+    data = 'Sign me!'
+    sig = key.sign(digest, data)
+    assert(key.verify(digest, sig, data))
+  end
+end
+
+end

data/test/1.9/test_pkey_ec.rb

@@ -0,0 +1,182 @@
+require_relative 'utils'
+
+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')
+    @group3 = OpenSSL::PKey::EC::Group.new('prime256v1')
+
+    @key1 = OpenSSL::PKey::EC.new
+    @key1.group = @group1
+    @key1.generate_key
+
+    @key2 = OpenSSL::PKey::EC.new(@group2.curve_name)
+    @key2.generate_key
+
+    @key3 = OpenSSL::PKey::EC.new(@group3)
+    @key3.generate_key
+
+    @groups = [@group1, @group2, @group3]
+    @keys = [@key1, @key2, @key3]
+  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
+  
+  def test_read_private_key_der
+    ec = OpenSSL::TestUtils::TEST_KEY_EC_P256V1
+    der = ec.to_der
+    ec2 = OpenSSL::PKey.read(der)
+    assert(ec2.private_key?)
+    assert_equal(der, ec2.to_der)
+    assert_equal([], OpenSSL.errors)
+  end
+
+  def test_read_private_key_pem
+    ec = OpenSSL::TestUtils::TEST_KEY_EC_P256V1
+    pem = ec.to_pem
+    ec2 = OpenSSL::PKey.read(pem)
+    assert(ec2.private_key?)
+    assert_equal(pem, ec2.to_pem)
+    assert_equal([], OpenSSL.errors)
+  end
+
+  def test_read_public_key_der
+    ec = OpenSSL::TestUtils::TEST_KEY_EC_P256V1
+    ec2 = OpenSSL::PKey::EC.new(ec.group)
+    ec2.public_key = ec.public_key
+    der = ec2.to_der
+    ec3 = OpenSSL::PKey.read(der)
+    assert(!ec3.private_key?)
+    assert_equal(der, ec3.to_der)
+    assert_equal([], OpenSSL.errors)
+  end
+
+  def test_read_public_key_pem
+    ec = OpenSSL::TestUtils::TEST_KEY_EC_P256V1
+    ec2 = OpenSSL::PKey::EC.new(ec.group)
+    ec2.public_key = ec.public_key
+    pem = ec2.to_pem
+    ec3 = OpenSSL::PKey.read(pem)
+    assert(!ec3.private_key?)
+    assert_equal(pem, ec3.to_pem)
+    assert_equal([], OpenSSL.errors)
+  end
+
+  def test_read_private_key_pem_pw
+    ec = OpenSSL::TestUtils::TEST_KEY_EC_P256V1
+    pem = ec.to_pem(OpenSSL::Cipher.new('AES-128-CBC'), 'secret')
+    #callback form for password
+    ec2 = OpenSSL::PKey.read(pem) do
+      'secret'
+    end
+    assert(ec2.private_key?)
+    # pass password directly
+    ec2 = OpenSSL::PKey.read(pem, 'secret')
+    assert(ec2.private_key?)
+    #omit pem equality check, will be different due to cipher iv
+    assert_equal([], OpenSSL.errors)
+  end
+
+# test Group: asn1_flag, point_conversion
+
+end
+
+end

data/test/1.9/test_pkey_rsa.rb

@@ -0,0 +1,244 @@
+require_relative 'utils'
+require 'base64'
+
+if defined?(OpenSSL)
+
+class OpenSSL::TestPKeyRSA < Test::Unit::TestCase
+  def test_padding
+    key = OpenSSL::PKey::RSA.new(512, 3)
+
+    # Need right size for raw mode
+    plain0 = "x" * (512/8)
+    cipher = key.private_encrypt(plain0, OpenSSL::PKey::RSA::NO_PADDING)
+    plain1 = key.public_decrypt(cipher, OpenSSL::PKey::RSA::NO_PADDING)
+    assert_equal(plain0, plain1)
+
+    # Need smaller size for pkcs1 mode
+    plain0 = "x" * (512/8 - 11)
+    cipher1 = key.private_encrypt(plain0, OpenSSL::PKey::RSA::PKCS1_PADDING)
+    plain1 = key.public_decrypt(cipher1, OpenSSL::PKey::RSA::PKCS1_PADDING)
+    assert_equal(plain0, plain1)
+
+    cipherdef = key.private_encrypt(plain0) # PKCS1_PADDING is default
+    plain1 = key.public_decrypt(cipherdef)
+    assert_equal(plain0, plain1)
+    assert_equal(cipher1, cipherdef)
+
+    # Failure cases
+    assert_raise(ArgumentError){ key.private_encrypt() }
+    assert_raise(ArgumentError){ key.private_encrypt("hi", 1, nil) }
+    assert_raise(OpenSSL::PKey::RSAError){ key.private_encrypt(plain0, 666) }
+  end
+
+  def test_private
+    key = OpenSSL::PKey::RSA.new(512, 3)
+    assert(key.private?)
+    key2 = OpenSSL::PKey::RSA.new(key.to_der)
+    assert(key2.private?)
+    key3 = key.public_key
+    assert(!key3.private?)
+    key4 = OpenSSL::PKey::RSA.new(key3.to_der)
+    assert(!key4.private?)
+  end
+
+  def test_new
+    key = OpenSSL::PKey::RSA.new 512
+    pem  = key.public_key.to_pem
+    OpenSSL::PKey::RSA.new pem
+    assert_equal([], OpenSSL.errors)
+  end
+
+  def test_sign_verify
+    key = OpenSSL::TestUtils::TEST_KEY_RSA1024
+    digest = OpenSSL::Digest::SHA1.new
+    data = 'Sign me!'
+    sig = key.sign(digest, data)
+    assert(key.verify(digest, sig, data))
+  end
+
+  def test_digest_state_irrelevant_sign
+    key = OpenSSL::TestUtils::TEST_KEY_RSA1024
+    digest1 = OpenSSL::Digest::SHA1.new
+    digest2 = OpenSSL::Digest::SHA1.new
+    data = 'Sign me!'
+    digest1 << 'Change state of digest1'
+    sig1 = key.sign(digest1, data)
+    sig2 = key.sign(digest2, data)
+    assert_equal(sig1, sig2)
+  end
+
+  def test_digest_state_irrelevant_verify
+    key = OpenSSL::TestUtils::TEST_KEY_RSA1024
+    digest1 = OpenSSL::Digest::SHA1.new
+    digest2 = OpenSSL::Digest::SHA1.new
+    data = 'Sign me!'
+    sig = key.sign(digest1, data)
+    digest1.reset
+    digest1 << 'Change state of digest1'
+    assert(key.verify(digest1, sig, data))
+    assert(key.verify(digest2, sig, data))
+  end
+
+  def test_read_RSAPublicKey
+    modulus = 10664264882656732240315063514678024569492171560814833397008094754351396057398262071307709191731289492697968568138092052265293364132872019762410446076526351
+    exponent = 65537
+    seq = OpenSSL::ASN1::Sequence.new([OpenSSL::ASN1::Integer.new(modulus), OpenSSL::ASN1::Integer.new(exponent)])
+    key = OpenSSL::PKey::RSA.new(seq.to_der)
+    assert(key.public?)
+    assert(!key.private?)
+    assert_equal(modulus, key.n)
+    assert_equal(exponent, key.e)
+    assert_equal(nil, key.d)
+    assert_equal(nil, key.p)
+    assert_equal(nil, key.q)
+    assert_equal([], OpenSSL.errors)
+  end
+
+  def test_read_RSA_PUBKEY
+    modulus = 10664264882656732240315063514678024569492171560814833397008094754351396057398262071307709191731289492697968568138092052265293364132872019762410446076526351
+    exponent = 65537
+    algo = OpenSSL::ASN1::ObjectId.new('rsaEncryption')
+    null_params = OpenSSL::ASN1::Null.new(nil)
+    algo_id = OpenSSL::ASN1::Sequence.new ([algo, null_params])
+    pub_key = OpenSSL::ASN1::Sequence.new([OpenSSL::ASN1::Integer.new(modulus), OpenSSL::ASN1::Integer.new(exponent)])
+    seq = OpenSSL::ASN1::Sequence.new([algo_id, OpenSSL::ASN1::BitString.new(pub_key.to_der)])
+    key = OpenSSL::PKey::RSA.new(seq.to_der)
+    assert(key.public?)
+    assert(!key.private?)
+    assert_equal(modulus, key.n)
+    assert_equal(exponent, key.e)
+    assert_equal(nil, key.d)
+    assert_equal(nil, key.p)
+    assert_equal(nil, key.q)
+    assert_equal([], OpenSSL.errors)
+  end
+
+  def test_read_RSAPublicKey_pem
+    modulus = 9416340886363418692990906464787534854462163316648195510702927337693641649864839352187127240942127674615733815606532506566068276485089353644309497938966061
+    exponent = 65537
+    pem = <<-EOF
+-----BEGIN RSA PUBLIC KEY-----
+MEgCQQCzyh2RIZK62E2PbTWqUljD+K23XR9AGBKNtXjal6WD2yRGcLqzPJLNCa60
+AudJR1JobbIbDJrQu6AXnWh5k/YtAgMBAAE=
+-----END RSA PUBLIC KEY-----
+    EOF
+    key = OpenSSL::PKey::RSA.new(pem)
+    assert(key.public?)
+    assert(!key.private?)
+    assert_equal(modulus, key.n)
+    assert_equal(exponent, key.e)
+    assert_equal(nil, key.d)
+    assert_equal(nil, key.p)
+    assert_equal(nil, key.q)
+    assert_equal([], OpenSSL.errors)
+  end
+
+  def test_read_RSA_PUBKEY_pem
+    modulus = 9416340886363418692990906464787534854462163316648195510702927337693641649864839352187127240942127674615733815606532506566068276485089353644309497938966061
+    exponent = 65537
+    pem = <<-EOF
+-----BEGIN PUBLIC KEY-----
+MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBALPKHZEhkrrYTY9tNapSWMP4rbdd
+H0AYEo21eNqXpYPbJEZwurM8ks0JrrQC50lHUmhtshsMmtC7oBedaHmT9i0C
+AwEAAQ==
+-----END PUBLIC KEY-----
+    EOF
+    key = OpenSSL::PKey::RSA.new(pem)
+    assert(key.public?)
+    assert(!key.private?)
+    assert_equal(modulus, key.n)
+    assert_equal(exponent, key.e)
+    assert_equal(nil, key.d)
+    assert_equal(nil, key.p)
+    assert_equal(nil, key.q)
+    assert_equal([], OpenSSL.errors)
+  end
+
+  def test_export_format_is_RSA_PUBKEY
+    key = OpenSSL::PKey::RSA.new(512)
+    asn1 = OpenSSL::ASN1.decode(key.public_key.to_der)
+    check_PUBKEY(asn1, key)
+  end
+
+  def test_export_format_is_RSA_PUBKEY_pem
+    key = OpenSSL::PKey::RSA.new(512)
+    pem = key.public_key.to_pem
+    pem.gsub!(/^-+(\w|\s)+-+$/, "") # eliminate --------BEGIN...-------
+    asn1 = OpenSSL::ASN1.decode(Base64.decode64(pem))
+    check_PUBKEY(asn1, key)
+  end
+
+  def test_read_private_key_der
+    der = OpenSSL::TestUtils::TEST_KEY_RSA1024.to_der
+    key = OpenSSL::PKey.read(der)
+    assert(key.private?)
+    assert_equal(der, key.to_der)
+    assert_equal([], OpenSSL.errors)
+  end
+
+  def test_read_private_key_pem
+    pem = OpenSSL::TestUtils::TEST_KEY_RSA1024.to_pem
+    key = OpenSSL::PKey.read(pem)
+    assert(key.private?)
+    assert_equal(pem, key.to_pem)
+    assert_equal([], OpenSSL.errors)
+  end
+
+  def test_read_public_key_der
+    der = OpenSSL::TestUtils::TEST_KEY_RSA1024.public_key.to_der
+    key = OpenSSL::PKey.read(der)
+    assert(!key.private?)
+    assert_equal(der, key.to_der)
+    assert_equal([], OpenSSL.errors)
+  end
+
+  def test_read_public_key_pem
+    pem = OpenSSL::TestUtils::TEST_KEY_RSA1024.public_key.to_pem
+    key = OpenSSL::PKey.read(pem)
+    assert(!key.private?)
+    assert_equal(pem, key.to_pem)
+    assert_equal([], OpenSSL.errors)
+  end
+
+  def test_read_private_key_pem_pw
+    pem = OpenSSL::TestUtils::TEST_KEY_RSA1024.to_pem(OpenSSL::Cipher.new('AES-128-CBC'), 'secret')
+    #callback form for password
+    key = OpenSSL::PKey.read(pem) do
+      'secret'
+    end
+    assert(key.private?)
+    # pass password directly
+    key = OpenSSL::PKey.read(pem, 'secret')
+    assert(key.private?)
+    #omit pem equality check, will be different due to cipher iv
+    assert_equal([], OpenSSL.errors)
+  end
+
+  private
+
+  def check_PUBKEY(asn1, key)
+    assert_equal(OpenSSL::ASN1::SEQUENCE, asn1.tag)
+    assert_equal(2, asn1.value.size)
+    seq = asn1.value
+    assert_equal(OpenSSL::ASN1::SEQUENCE, seq[0].tag)
+    assert_equal(2, seq[0].value.size)
+    algo_id = seq[0].value
+    assert_equal(OpenSSL::ASN1::OBJECT, algo_id[0].tag)
+    assert_equal('rsaEncryption', algo_id[0].value)
+    assert_equal(OpenSSL::ASN1::NULL, algo_id[1].tag)
+    assert_equal(nil, algo_id[1].value)
+    assert_equal(OpenSSL::ASN1::BIT_STRING, seq[1].tag)
+    assert_equal(0, seq[1].unused_bits)
+    pub_key = OpenSSL::ASN1.decode(seq[1].value)
+    assert_equal(OpenSSL::ASN1::SEQUENCE, pub_key.tag)
+    assert_equal(2, pub_key.value.size)
+    assert_equal(OpenSSL::ASN1::INTEGER, pub_key.value[0].tag)
+    assert_equal(key.n, pub_key.value[0].value)
+    assert_equal(OpenSSL::ASN1::INTEGER, pub_key.value[1].tag)
+    assert_equal(key.e, pub_key.value[1].value)
+    assert_equal([], OpenSSL.errors)
+  end
+
+end
+
+end