jruby-openssl 0.0.4 → 0.1

data/test/openssl/test_x509cert.rb

@@ -0,0 +1,174 @@
+begin
+  require "openssl"
+  require File.join(File.dirname(__FILE__), "utils.rb")
+rescue LoadError
+end
+require "test/unit"
+
+if defined?(OpenSSL)
+
+class OpenSSL::TestX509Certificate < Test::Unit::TestCase
+  def setup
+    @rsa1024 = OpenSSL::TestUtils::TEST_KEY_RSA1024
+    @rsa2048 = OpenSSL::TestUtils::TEST_KEY_RSA2048
+    @dsa256  = OpenSSL::TestUtils::TEST_KEY_DSA256
+    @dsa512  = OpenSSL::TestUtils::TEST_KEY_DSA512
+    @ca = OpenSSL::X509::Name.parse("/DC=org/DC=ruby-lang/CN=CA")
+    @ee1 = OpenSSL::X509::Name.parse("/DC=org/DC=ruby-lang/CN=EE1")
+    @ee2 = OpenSSL::X509::Name.parse("/DC=org/DC=ruby-lang/CN=EE2")
+  end
+
+  def teardown
+  end
+
+  def issue_cert(*args)
+    OpenSSL::TestUtils.issue_cert(*args)
+  end
+
+  def test_serial
+    [1, 2**32, 2**100].each{|s|
+      cert = issue_cert(@ca, @rsa2048, s, Time.now, Time.now+3600, [],
+                        nil, nil, OpenSSL::Digest::SHA1.new) 
+      assert_equal(s, cert.serial)
+      cert = OpenSSL::X509::Certificate.new(cert.to_der)
+      assert_equal(s, cert.serial)
+    }
+  end
+
+  def test_public_key
+    exts = [
+      ["basicConstraints","CA:TRUE",true],
+      ["subjectKeyIdentifier","hash",false],
+      ["authorityKeyIdentifier","keyid:always",false],
+    ]
+
+    sha1 = OpenSSL::Digest::SHA1.new
+    dss1 = OpenSSL::Digest::DSS1.new
+    [
+      [@rsa1024, sha1], [@rsa2048, sha1], [@dsa256, dss1], [@dsa512, dss1],
+    ].each{|pk, digest|
+      cert = issue_cert(@ca, pk, 1, Time.now, Time.now+3600, exts,
+                        nil, nil, digest)
+      assert_equal(cert.extensions[1].value,OpenSSL::TestUtils.get_subject_key_id(cert))
+      cert = OpenSSL::X509::Certificate.new(cert.to_der)
+      assert_equal(cert.extensions[1].value,
+                   OpenSSL::TestUtils.get_subject_key_id(cert))
+    }
+  end
+
+  def test_validity
+    now = Time.now until now && now.usec != 0
+    cert = issue_cert(@ca, @rsa2048, 1, now, now+3600, [],
+                      nil, nil, OpenSSL::Digest::SHA1.new) 
+    assert_not_equal(now, cert.not_before)
+    assert_not_equal(now+3600, cert.not_after)
+
+    now = Time.at(now.to_i)
+    cert = issue_cert(@ca, @rsa2048, 1, now, now+3600, [],
+                      nil, nil, OpenSSL::Digest::SHA1.new) 
+    assert_equal(now.getutc, cert.not_before)
+    assert_equal((now+3600).getutc, cert.not_after)
+
+    now = Time.at(0)
+    cert = issue_cert(@ca, @rsa2048, 1, now, now, [],
+                      nil, nil, OpenSSL::Digest::SHA1.new) 
+    assert_equal(now.getutc, cert.not_before)
+    assert_equal(now.getutc, cert.not_after)
+
+    now = Time.at(0x7fffffff)
+    cert = issue_cert(@ca, @rsa2048, 1, now, now, [],
+                      nil, nil, OpenSSL::Digest::SHA1.new) 
+    assert_equal(now.getutc, cert.not_before)
+    assert_equal(now.getutc, cert.not_after)
+  end
+
+  def test_extension
+    ca_exts = [
+      ["basicConstraints","CA:TRUE",true],
+      ["keyUsage","keyCertSign, cRLSign",true],
+      ["subjectKeyIdentifier","hash",false],
+      ["authorityKeyIdentifier","keyid:always",false],
+    ]
+    ca_cert = issue_cert(@ca, @rsa2048, 1, Time.now, Time.now+3600, ca_exts,
+                         nil, nil, OpenSSL::Digest::SHA1.new) 
+    ca_cert.extensions.each_with_index{|ext, i|
+      assert_equal(ca_exts[i].first, ext.oid)
+      assert_equal(ca_exts[i].last, ext.critical?)
+    }
+
+    ee1_exts = [
+      ["keyUsage","Non Repudiation, Digital Signature, Key Encipherment",true],
+      ["subjectKeyIdentifier","hash",false],
+      ["authorityKeyIdentifier","keyid:always",false],
+      ["extendedKeyUsage","clientAuth, emailProtection, codeSigning",false],
+      ["subjectAltName","email:ee1@ruby-lang.org",false],
+    ]
+    ee1_cert = issue_cert(@ee1, @rsa1024, 2, Time.now, Time.now+1800, ee1_exts,
+                          ca_cert, @rsa2048, OpenSSL::Digest::SHA1.new) 
+    assert_equal(ca_cert.subject.to_der, ee1_cert.issuer.to_der)
+    ee1_cert.extensions.each_with_index{|ext, i|
+      assert_equal(ee1_exts[i].first, ext.oid)
+      assert_equal(ee1_exts[i].last, ext.critical?)
+    }
+
+    ee2_exts = [
+      ["keyUsage","Non Repudiation, Digital Signature, Key Encipherment",true],
+      ["subjectKeyIdentifier","hash",false],
+      ["authorityKeyIdentifier","issuer:always",false],
+      ["extendedKeyUsage","clientAuth, emailProtection, codeSigning",false],
+      ["subjectAltName","email:ee2@ruby-lang.org",false],
+    ]
+    ee2_cert = issue_cert(@ee2, @rsa1024, 3, Time.now, Time.now+1800, ee2_exts,
+                          ca_cert, @rsa2048, OpenSSL::Digest::MD5.new) 
+    assert_equal(ca_cert.subject.to_der, ee2_cert.issuer.to_der)
+    ee2_cert.extensions.each_with_index{|ext, i|
+      assert_equal(ee2_exts[i].first, ext.oid)
+      assert_equal(ee2_exts[i].last, ext.critical?)
+    }
+
+  end
+
+  def test_sign_and_verify
+    cert = issue_cert(@ca, @rsa2048, 1, Time.now, Time.now+3600, [],
+                      nil, nil, OpenSSL::Digest::SHA1.new) 
+    assert_equal(false, cert.verify(@rsa1024))
+    assert_equal(true,  cert.verify(@rsa2048))
+    assert_equal(false, cert.verify(@dsa256))
+    assert_equal(false, cert.verify(@dsa512))
+    cert.serial = 2
+    assert_equal(false, cert.verify(@rsa2048))
+
+    cert = issue_cert(@ca, @rsa2048, 1, Time.now, Time.now+3600, [],
+                      nil, nil, OpenSSL::Digest::MD5.new) 
+    assert_equal(false, cert.verify(@rsa1024))
+    assert_equal(true,  cert.verify(@rsa2048))
+    assert_equal(false, cert.verify(@dsa256))
+    assert_equal(false, cert.verify(@dsa512))
+    cert.subject = @ee1
+    assert_equal(false, cert.verify(@rsa2048))
+
+    cert = issue_cert(@ca, @dsa512, 1, Time.now, Time.now+3600, [],
+                      nil, nil, OpenSSL::Digest::DSS1.new) 
+    assert_equal(false, cert.verify(@rsa1024))
+    assert_equal(false, cert.verify(@rsa2048))
+    assert_equal(false, cert.verify(@dsa256))
+    assert_equal(true,  cert.verify(@dsa512))
+    cert.not_after = Time.now 
+    assert_equal(false, cert.verify(@dsa512))
+
+    assert_raises(OpenSSL::X509::CertificateError){
+      cert = issue_cert(@ca, @rsa2048, 1, Time.now, Time.now+3600, [],
+                        nil, nil, OpenSSL::Digest::DSS1.new) 
+    }
+    assert_raises(OpenSSL::X509::CertificateError){
+      cert = issue_cert(@ca, @dsa512, 1, Time.now, Time.now+3600, [],
+                        nil, nil, OpenSSL::Digest::MD5.new) 
+    }
+    assert_raises(OpenSSL::X509::CertificateError){
+      cert = issue_cert(@ca, @dsa512, 1, Time.now, Time.now+3600, [],
+                        nil, nil, OpenSSL::Digest::SHA1.new) 
+    }
+  end
+end
+
+end

data/test/openssl/test_x509crl.rb

@@ -0,0 +1,218 @@
+begin
+  require "openssl"
+  require File.join(File.dirname(__FILE__), "utils.rb")
+rescue LoadError
+end
+require "test/unit"
+
+if defined?(OpenSSL)
+
+class OpenSSL::TestX509CRL < Test::Unit::TestCase
+  def setup
+    @rsa1024 = OpenSSL::TestUtils::TEST_KEY_RSA1024
+    @rsa2048 = OpenSSL::TestUtils::TEST_KEY_RSA2048
+    @dsa256  = OpenSSL::TestUtils::TEST_KEY_DSA256
+    @dsa512  = OpenSSL::TestUtils::TEST_KEY_DSA512
+    @ca = OpenSSL::X509::Name.parse("/DC=org/DC=ruby-lang/CN=CA")
+    @ee1 = OpenSSL::X509::Name.parse("/DC=org/DC=ruby-lang/CN=EE1")
+    @ee2 = OpenSSL::X509::Name.parse("/DC=org/DC=ruby-lang/CN=EE2")
+  end
+
+  def teardown
+  end
+
+  def issue_crl(*args)
+    OpenSSL::TestUtils.issue_crl(*args)
+  end
+
+  def issue_cert(*args)
+    OpenSSL::TestUtils.issue_cert(*args)
+  end
+
+  def test_basic
+    now = Time.at(Time.now.to_i)
+
+    cert = issue_cert(@ca, @rsa2048, 1, now, now+3600, [],
+                      nil, nil, OpenSSL::Digest::SHA1.new)
+    crl = issue_crl([], 1, now, now+1600, [],
+                    cert, @rsa2048, OpenSSL::Digest::SHA1.new)
+    assert_equal(1, crl.version)
+    assert_equal(cert.issuer.to_der, crl.issuer.to_der)
+    assert_equal(now, crl.last_update)
+    assert_equal(now+1600, crl.next_update)
+
+    crl = OpenSSL::X509::CRL.new(crl.to_der)
+    assert_equal(1, crl.version)
+    assert_equal(cert.issuer.to_der, crl.issuer.to_der)
+    assert_equal(now, crl.last_update)
+    assert_equal(now+1600, crl.next_update)
+  end
+
+  def test_revoked
+
+    # CRLReason ::= ENUMERATED {
+    #      unspecified             (0),
+    #      keyCompromise           (1),
+    #      cACompromise            (2),
+    #      affiliationChanged      (3),
+    #      superseded              (4),
+    #      cessationOfOperation    (5),
+    #      certificateHold         (6),
+    #      removeFromCRL           (8),
+    #      privilegeWithdrawn      (9),
+    #      aACompromise           (10) }
+
+    now = Time.at(Time.now.to_i)
+    revoke_info = [
+      [1, Time.at(0),          1],
+      [2, Time.at(0x7fffffff), 2],
+      [3, now,                 3],
+      [4, now,                 4],
+      [5, now,                 5],
+    ]
+    cert = issue_cert(@ca, @rsa2048, 1, Time.now, Time.now+3600, [],
+                      nil, nil, OpenSSL::Digest::SHA1.new)
+    crl = issue_crl(revoke_info, 1, Time.now, Time.now+1600, [],
+                    cert, @rsa2048, OpenSSL::Digest::SHA1.new)
+    revoked = crl.revoked
+    assert_equal(5, revoked.size)
+    assert_equal(1, revoked[0].serial)
+    assert_equal(2, revoked[1].serial)
+    assert_equal(3, revoked[2].serial)
+    assert_equal(4, revoked[3].serial)
+    assert_equal(5, revoked[4].serial)
+
+    assert_equal(Time.at(0), revoked[0].time)
+    assert_equal(Time.at(0x7fffffff), revoked[1].time)
+    assert_equal(now, revoked[2].time)
+    assert_equal(now, revoked[3].time)
+    assert_equal(now, revoked[4].time)
+
+    assert_equal("CRLReason", revoked[0].extensions[0].oid)
+    assert_equal("CRLReason", revoked[1].extensions[0].oid)
+    assert_equal("CRLReason", revoked[2].extensions[0].oid)
+    assert_equal("CRLReason", revoked[3].extensions[0].oid)
+    assert_equal("CRLReason", revoked[4].extensions[0].oid)
+
+    assert_equal("Key Compromise", revoked[0].extensions[0].value)
+    assert_equal("CA Compromise", revoked[1].extensions[0].value)
+    assert_equal("Affiliation Changed", revoked[2].extensions[0].value)
+    assert_equal("Superseded", revoked[3].extensions[0].value)
+    assert_equal("Cessation Of Operation", revoked[4].extensions[0].value)
+
+    assert_equal(false, revoked[0].extensions[0].critical?)
+    assert_equal(false, revoked[1].extensions[0].critical?)
+    assert_equal(false, revoked[2].extensions[0].critical?)
+    assert_equal(false, revoked[3].extensions[0].critical?)
+    assert_equal(false, revoked[4].extensions[0].critical?)
+
+    crl = OpenSSL::X509::CRL.new(crl.to_der)
+    assert_equal("Key Compromise", revoked[0].extensions[0].value)
+    assert_equal("CA Compromise", revoked[1].extensions[0].value)
+    assert_equal("Affiliation Changed", revoked[2].extensions[0].value)
+    assert_equal("Superseded", revoked[3].extensions[0].value)
+    assert_equal("Cessation Of Operation", revoked[4].extensions[0].value)
+
+    revoke_info = (1..1000).collect{|i| [i, now, 0] }
+    crl = issue_crl(revoke_info, 1, Time.now, Time.now+1600, [],
+                    cert, @rsa2048, OpenSSL::Digest::SHA1.new)
+    revoked = crl.revoked
+    assert_equal(1000, revoked.size)
+    assert_equal(1, revoked[0].serial)
+    assert_equal(1000, revoked[999].serial)
+  end
+
+  def test_extension
+    cert_exts = [
+      ["basicConstraints", "CA:TRUE", true],
+      ["subjectKeyIdentifier", "hash", false], 
+      ["authorityKeyIdentifier", "keyid:always", false], 
+      ["subjectAltName", "email:xyzzy@ruby-lang.org", false],
+      ["keyUsage", "cRLSign, keyCertSign", true],
+    ]
+    crl_exts = [
+      ["authorityKeyIdentifier", "keyid:always", false], 
+      ["issuerAltName", "issuer:copy", false],
+    ]
+    
+    cert = issue_cert(@ca, @rsa2048, 1, Time.now, Time.now+3600, cert_exts,
+                      nil, nil, OpenSSL::Digest::SHA1.new)
+    crl = issue_crl([], 1, Time.now, Time.now+1600, crl_exts,
+                    cert, @rsa2048, OpenSSL::Digest::SHA1.new)
+    exts = crl.extensions
+    assert_equal(3, exts.size)
+    assert_equal("1", exts[0].value)
+    assert_equal("crlNumber", exts[0].oid)
+    assert_equal(false, exts[0].critical?)
+
+    assert_equal("authorityKeyIdentifier", exts[1].oid)
+    keyid = OpenSSL::TestUtils.get_subject_key_id(cert)
+    assert_match(/^keyid:#{keyid}/, exts[1].value)
+    assert_equal(false, exts[1].critical?)
+
+    assert_equal("issuerAltName", exts[2].oid)
+    assert_equal("email:xyzzy@ruby-lang.org", exts[2].value)
+    assert_equal(false, exts[2].critical?)
+
+    crl = OpenSSL::X509::CRL.new(crl.to_der)
+    exts = crl.extensions
+    assert_equal(3, exts.size)
+    assert_equal("1", exts[0].value)
+    assert_equal("crlNumber", exts[0].oid)
+    assert_equal(false, exts[0].critical?)
+
+    assert_equal("authorityKeyIdentifier", exts[1].oid)
+    keyid = OpenSSL::TestUtils.get_subject_key_id(cert)
+    assert_match(/^keyid:#{keyid}/, exts[1].value)
+    assert_equal(false, exts[1].critical?)
+
+    assert_equal("issuerAltName", exts[2].oid)
+    assert_equal("email:xyzzy@ruby-lang.org", exts[2].value)
+    assert_equal(false, exts[2].critical?)
+  end
+
+  def test_crlnumber
+    cert = issue_cert(@ca, @rsa2048, 1, Time.now, Time.now+3600, [],
+                      nil, nil, OpenSSL::Digest::SHA1.new)
+    crl = issue_crl([], 1, Time.now, Time.now+1600, [],
+                    cert, @rsa2048, OpenSSL::Digest::SHA1.new)
+    assert_match(1.to_s, crl.extensions[0].value)
+    assert_match(/X509v3 CRL Number:\s+#{1}/m, crl.to_text)
+
+    crl = issue_crl([], 2**32, Time.now, Time.now+1600, [],
+                    cert, @rsa2048, OpenSSL::Digest::SHA1.new)
+    assert_match((2**32).to_s, crl.extensions[0].value)
+    assert_match(/X509v3 CRL Number:\s+#{2**32}/m, crl.to_text)
+
+    crl = issue_crl([], 2**100, Time.now, Time.now+1600, [],
+                    cert, @rsa2048, OpenSSL::Digest::SHA1.new)
+    assert_match(/X509v3 CRL Number:\s+#{2**100}/m, crl.to_text)
+    assert_match((2**100).to_s, crl.extensions[0].value)
+  end
+
+  def test_sign_and_verify
+    cert = issue_cert(@ca, @rsa2048, 1, Time.now, Time.now+3600, [],
+                      nil, nil, OpenSSL::Digest::SHA1.new)
+    crl = issue_crl([], 1, Time.now, Time.now+1600, [],
+                    cert, @rsa2048, OpenSSL::Digest::SHA1.new)
+    assert_equal(false, crl.verify(@rsa1024))
+    assert_equal(true,  crl.verify(@rsa2048))
+    assert_equal(false, crl.verify(@dsa256))
+    assert_equal(false, crl.verify(@dsa512))
+    crl.version = 0
+    assert_equal(false, crl.verify(@rsa2048))
+
+    cert = issue_cert(@ca, @dsa512, 1, Time.now, Time.now+3600, [],
+                      nil, nil, OpenSSL::Digest::DSS1.new)
+    crl = issue_crl([], 1, Time.now, Time.now+1600, [],
+                    cert, @dsa512, OpenSSL::Digest::DSS1.new)
+    assert_equal(false, crl.verify(@rsa1024))
+    assert_equal(false, crl.verify(@rsa2048))
+    assert_equal(false, crl.verify(@dsa256))
+    assert_equal(true,  crl.verify(@dsa512))
+    crl.version = 0
+    assert_equal(false, crl.verify(@dsa512))
+  end
+end
+
+end

data/test/openssl/test_x509ext.rb

@@ -0,0 +1,74 @@
+begin
+  require "openssl"
+  require File.join(File.dirname(__FILE__), "utils.rb")
+rescue LoadError
+end
+require "test/unit"
+
+if defined?(OpenSSL)
+
+class OpenSSL::TestX509Extension < Test::Unit::TestCase
+  def setup
+    @basic_constraints_value = OpenSSL::ASN1::Sequence([
+      OpenSSL::ASN1::Boolean(true),   # CA
+      OpenSSL::ASN1::Integer(2)       # pathlen
+    ])
+    @basic_constraints = OpenSSL::ASN1::Sequence([
+      OpenSSL::ASN1::ObjectId("basicConstraints"),
+      OpenSSL::ASN1::Boolean(true),
+      OpenSSL::ASN1::OctetString(@basic_constraints_value.to_der),
+    ])
+  end
+
+  def teardown
+  end
+
+  def test_new
+    ext = OpenSSL::X509::Extension.new(@basic_constraints.to_der)
+    assert_equal("basicConstraints", ext.oid)
+    assert_equal(true, ext.critical?)
+    assert_equal("CA:TRUE, pathlen:2", ext.value)
+
+    ext = OpenSSL::X509::Extension.new("2.5.29.19",
+                                       @basic_constraints_value.to_der, true)
+    assert_equal(@basic_constraints.to_der, ext.to_der)
+  end
+
+  def test_create_by_factory
+    ef = OpenSSL::X509::ExtensionFactory.new
+
+    bc = ef.create_extension("basicConstraints", "critical, CA:TRUE, pathlen:2")
+    assert_equal(@basic_constraints.to_der, bc.to_der)
+
+    bc = ef.create_extension("basicConstraints", "CA:TRUE, pathlen:2", true)
+    assert_equal(@basic_constraints.to_der, bc.to_der)
+
+    begin
+      ef.config = OpenSSL::Config.parse(<<-_end_of_cnf_)
+      [crlDistPts]
+      URI.1 = http://www.example.com/crl
+      URI.2 = ldap://ldap.example.com/cn=ca?certificateRevocationList;binary
+      _end_of_cnf_
+    rescue NotImplementedError
+      return
+    end
+
+    cdp = ef.create_extension("crlDistributionPoints", "@crlDistPts")
+    assert_equal(false, cdp.critical?)
+    assert_equal("crlDistributionPoints", cdp.oid)
+    assert_match(%{URI:http://www\.example\.com/crl}, cdp.value)
+    assert_match(
+      %r{URI:ldap://ldap\.example\.com/cn=ca\?certificateRevocationList;binary},
+      cdp.value)
+
+    cdp = ef.create_extension("crlDistributionPoints", "critical, @crlDistPts")
+    assert_equal(true, cdp.critical?)
+    assert_equal("crlDistributionPoints", cdp.oid)
+    assert_match(%{URI:http://www.example.com/crl}, cdp.value)
+    assert_match(
+      %r{URI:ldap://ldap.example.com/cn=ca\?certificateRevocationList;binary},
+      cdp.value)
+  end
+end
+
+end