Ruby » Ruby master

# By specifying a keyword argument _exception_ to +false+, you can indicate

# return the symbol +:wait_writable+ or +:wait_readable+ instead. At EOF,

# it will return +nil+ instead of raising EOFError.

# By specifying a keyword argument _exception_ to +false+, you can indicate

# return the symbol +:wait_writable+ or +:wait_readable+ instead.

# stub: openssl 2.0.5 ruby lib

s.version = "2.0.5"

s.date = "2017-08-08"

s.rubygems_version = "2.6.12".freeze

static rb_nativethread_lock_t *ossl_locks;

ossl_lock_unlock(int mode, rb_nativethread_lock_t *lock)

if (mode & CRYPTO_LOCK) {

rb_nativethread_lock_lock(lock);

} else {

rb_nativethread_lock_unlock(lock);

}

ossl_lock_callback(int mode, int type, const char *file, int line)

ossl_lock_unlock(mode, &ossl_locks[type]);

struct CRYPTO_dynlock_value {

rb_nativethread_lock_t lock;

};

struct CRYPTO_dynlock_value *dynlock = (struct CRYPTO_dynlock_value *)OPENSSL_malloc((int)sizeof(struct CRYPTO_dynlock_value));

rb_nativethread_lock_initialize(&dynlock->lock);

ossl_lock_unlock(mode, &l->lock);

if ((unsigned)num_locks >= INT_MAX / (int)sizeof(VALUE)) {

rb_raise(rb_eRuntimeError, "CRYPTO_num_locks() is too big: %d", num_locks);

}

ossl_locks = (rb_nativethread_lock_t *) OPENSSL_malloc(num_locks * (int)sizeof(rb_nativethread_lock_t));

if (!ossl_locks) {

rb_raise(rb_eNoMemError, "CRYPTO_num_locks() is too big: %d", num_locks);

}

for (i = 0; i < num_locks; i++) {

rb_nativethread_lock_initialize(&ossl_locks[i]);

}

}

/*

* Check if all symbols are OK with 'make LDSHARED=gcc all'

*/

int

main(int argc, char *argv[])

{

return 0;

#endif /* OSSL_DEBUG */

* Sets the authentication tag to verify the contents of the

* ciphertext. The tag must be set after calling Cipher#decrypt,

* Cipher#key= and Cipher#iv=, but before assigning the associated

* authenticated data using Cipher#auth_data= and of course, before

* decrypting any of the ciphertext. After all decryption is

* performed, the tag is verified automatically in the call to

* Cipher#final.

* By specifying a keyword argument _exception_ to +false+, you can indicate

* IO::WaitWritable exception, but return the symbol +:wait_readable+ or

* +:wait_writable+ instead.

* By specifying a keyword argument _exception_ to +false+, you can indicate

* IO::WaitWritable exception, but return the symbol +:wait_readable+ or

* +:wait_writable+ instead.

if(NIL_P(str)) str = rb_str_new(0, ilen);

else{

StringValue(str);

rb_str_modify(str);

rb_str_resize(str, ilen);

if(ilen == 0) return str;

if(!nonblock && SSL_pending(ssl) <= 0)

rb_thread_wait_fd(FPTR_TO_FD(fptr));

nread = SSL_read(ssl, RSTRING_PTR(str), RSTRING_LENINT(str));

OBJ_TAINT(str);

#define OSSL_VERSION "2.0.5"

/* for Ruby 2.3 compatibility */

#define RB_INTEGER_TYPE_P(obj) (RB_FIXNUM_P(obj) || RB_TYPE_P(obj, T_BIGNUM))

key = OpenSSL::TestUtils::TEST_KEY_RSA1024

end if defined?(OpenSSL::TestUtils)

require 'stringio'

class OpenSSL::TestBuffering < OpenSSL::TestCase

end if defined?(OpenSSL::TestUtils)

OpenSSL::TestUtils.silent do

OpenSSL::TestUtils.silent do

OpenSSL::TestUtils.silent do

end if defined?(OpenSSL::TestUtils)

algs = %w(MD4 MD5 RIPEMD160 SHA1)

if OpenSSL::OPENSSL_VERSION_NUMBER < 0x10100000

if OpenSSL::OPENSSL_VERSION_NUMBER > 0x00908000

algs += %w(SHA224 SHA256 SHA384 SHA512)

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

def test_digest_by_oid_and_name_sha2

check_digest(OpenSSL::ASN1::ObjectId.new("SHA224"))

check_digest(OpenSSL::ASN1::ObjectId.new("SHA256"))

check_digest(OpenSSL::ASN1::ObjectId.new("SHA384"))

check_digest(OpenSSL::ASN1::ObjectId.new("SHA512"))

end

def libressl?

OpenSSL::OPENSSL_VERSION.include?('LibreSSL')

end

def version_since(verary)

(OpenSSL::OPENSSL_LIBRARY_VERSION.scan(/\d+/).map(&:to_i) <=> verary) != -1

end

class OpenSSL::TestEngine < OpenSSL::TestCase

with_openssl <<-'end;'

begin

engine = get_engine

algo = "RC4" #AES is not supported by openssl Engine (<=1.0.0e)

data = "a" * 1000

key = OpenSSL::Random.random_bytes(16)

# suppress message from openssl Engine's RC4 cipher [ruby-core:41026]

err_back = $stderr.dup

$stderr.reopen(IO::NULL)

encrypted = crypt_data(data, key, :encrypt) { engine.cipher(algo) }

decrypted = crypt_data(encrypted, key, :decrypt) { OpenSSL::Cipher.new(algo) }

assert_equal(data, decrypted)

ensure

if err_back

$stderr.reopen(err_back)

err_back.close

end

end

def with_openssl(code)

assert_separately([{ "OSSL_MDEBUG" => nil }, "-ropenssl"], <<~"end;")

end if defined?(OpenSSL::TestUtils) && defined?(OpenSSL::Engine)

end if defined?(OpenSSL::TestUtils)

key1 = OpenSSL::TestUtils::TEST_KEY_RSA1024

key2 = OpenSSL::TestUtils::TEST_KEY_RSA2048

@ca_key = OpenSSL::TestUtils::TEST_KEY_RSA1024

@cert_key = OpenSSL::TestUtils::TEST_KEY_RSA1024

@cert2_key = OpenSSL::TestUtils::TEST_KEY_RSA1024

@ocsp_key = OpenSSL::TestUtils::TEST_KEY_RSA2048

if ret || OpenSSL::OPENSSL_VERSION =~ /OpenSSL/ && OpenSSL::OPENSSL_VERSION_NUMBER >= 0x10002000

require 'socket'

require_relative 'ut_eof'

def server

host = "127.0.0.1"

port = 0

ctx = OpenSSL::SSL::SSLContext.new()

ctx.ciphers = "ADH"

ctx.security_level = 0

ctx.tmp_dh_callback = proc { OpenSSL::TestUtils::TEST_KEY_DH1024 }

tcps = create_tcp_server(host, port)

ssls = OpenSSL::SSL::SSLServer.new(tcps, ctx)

return ssls

def client(port)

ctx = OpenSSL::SSL::SSLContext.new()

ctx.ciphers = "ADH"

ctx.security_level = 0

s = create_tcp_client(host, port)

ssl = OpenSSL::SSL::SSLSocket.new(s, ctx)

ssl.connect

ssl.sync_close = true

ssl

end

def ssl_pair

ssls = server

port = ssls.to_io.local_address.ip_port

c = client(port)

if block_given?

begin

yield c, s

ensure

c.close unless c.closed?

s.close unless s.closed?

end

else

return c, s

end

if th&.alive?

th.kill

th.join

end

s1, s2 = ssl_pair

th = Thread.new { s2 << content; s2.close }

yield s1

ensure

th.join if th

s1.close

s1, s2 = ssl_pair

th = Thread.new { s1 << content; s1.close }

yield s2

ensure

th.join if th

s2.close

sleep 0.1

sleep 0.1

def write_nonblock(socket, meth, str)

ret = socket.send(meth, str)

ret.is_a?(Symbol) ? 0 : ret

end

def write_nonblock_no_ex(socket, str)

ret = socket.write_nonblock str, exception: false

ret.is_a?(Symbol) ? 0 : ret

n = 0

begin

n += write_nonblock s1, :write_nonblock, "a" * 100000

n += write_nonblock s1, :write_nonblock, "b" * 100000

n += write_nonblock s1, :write_nonblock, "c" * 100000

n += write_nonblock s1, :write_nonblock, "d" * 100000

n += write_nonblock s1, :write_nonblock, "e" * 100000

n += write_nonblock s1, :write_nonblock, "f" * 100000

rescue IO::WaitWritable

s1.close

assert_equal(n, s2.read.length)

n = 0

n += write_nonblock_no_ex s1, "a" * 100000

n += write_nonblock_no_ex s1, "b" * 100000

n += write_nonblock_no_ex s1, "c" * 100000

n += write_nonblock_no_ex s1, "d" * 100000

n += write_nonblock_no_ex s1, "e" * 100000

n += write_nonblock_no_ex s1, "f" * 100000

s1.close

assert_equal(n, s2.read.length)

ctx2.ciphers = "ADH"

ctx2.security_level = 0

ctx2.tmp_dh_callback = proc { OpenSSL::TestUtils::TEST_KEY_DH1024 }

ctx1.ciphers = "ADH"

ctx1.security_level = 0

ctx.ciphers = "ADH"

ctx.security_level = 0

ctx.tmp_dh_callback = proc { OpenSSL::TestUtils::TEST_KEY_DH1024 }

ctx.ciphers = "ADH"

ctx.security_level = 0

include OpenSSL::TestUtils

@cacert = issue_cert(ca, TEST_KEY_RSA2048, 1, ca_exts, nil, nil)

@inter_cacert = issue_cert(inter_ca, inter_ca_key, 2, ca_exts, @cacert, TEST_KEY_RSA2048)

@mycert = issue_cert(ee, TEST_KEY_RSA1024, 3, exts, @inter_cacert, inter_ca_key)

TEST_KEY_RSA1024,

assert_equal @mycert, pkcs12.certificate

assert_equal TEST_KEY_RSA1024, pkcs12.key

TEST_KEY_RSA1024,

assert_equal @mycert, pkcs12.certificate

assert_equal TEST_KEY_RSA1024, pkcs12.key

TEST_KEY_RSA1024,

TEST_KEY_RSA1024,

assert_equal TEST_KEY_RSA1024.to_der, decoded.key.to_der

TEST_KEY_RSA1024,

TEST_KEY_RSA1024,

TEST_KEY_RSA1024,

TEST_KEY_RSA1024,