← Back to branch summary

~ubuntu-branches/ubuntu/trusty/ruby1.9/trusty

« back to all changes in this revision

Viewing changes to test/openssl/test_ssl.rb

  • Committer: Bazaar Package Importer
  • Author(s): Stephan Hermann
  • Date: 2008-01-24 11:42:29 UTC
  • mfrom: (1.1.9 upstream)
  • Revision ID: james.westby@ubuntu.com-20080124114229-jw2f87rdxlq6gp11
Tags: 1.9.0.0-2ubuntu1
* Merge from debian unstable, remaining changes:
  - Robustify check for target_os, fixing build failure on lpia.

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/openssl/test_ssl.rb
94
94
  end
95
95
 
96
96
  def test_connect_and_close
97
 
    start_server(PORT, OpenSSL::SSL::VERIFY_NONE, true){|s, p|
98
 
      sock = TCPSocket.new("127.0.0.1", p)
 
97
    start_server(PORT, OpenSSL::SSL::VERIFY_NONE, true){|server, port|
 
98
      sock = TCPSocket.new("127.0.0.1", port)
99
99
      ssl = OpenSSL::SSL::SSLSocket.new(sock)
100
100
      assert(ssl.connect)
101
101
      ssl.close
102
102
      assert(!sock.closed?)
103
103
      sock.close
104
104
 
105
 
      sock = TCPSocket.new("127.0.0.1", p)
 
105
      sock = TCPSocket.new("127.0.0.1", port)
106
106
      ssl = OpenSSL::SSL::SSLSocket.new(sock)
107
107
      ssl.sync_close = true  # !!
108
108
      assert(ssl.connect)
112
112
  end
113
113
 
114
114
  def test_read_and_write
115
 
    start_server(PORT, OpenSSL::SSL::VERIFY_NONE, true){|s, p|
116
 
      sock = TCPSocket.new("127.0.0.1", p)
 
115
    start_server(PORT, OpenSSL::SSL::VERIFY_NONE, true){|server, port|
 
116
      sock = TCPSocket.new("127.0.0.1", port)
117
117
      ssl = OpenSSL::SSL::SSLSocket.new(sock)
118
118
      ssl.sync_close = true
119
119
      ssl.connect
136
136
        str = "x" * 100 + "\n"
137
137
        ssl.puts(str)
138
138
        assert_equal(str, ssl.gets)
 
139
 
 
140
        str = "x" * 100
 
141
        ssl.puts(str)
 
142
        assert_equal(str, ssl.gets("\n", 100))
 
143
        assert_equal("\n", ssl.gets)
139
144
      }
140
145
 
141
146
      # read and write
157
162
 
158
163
  def test_client_auth
159
164
    vflag = OpenSSL::SSL::VERIFY_PEER|OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT
160
 
    start_server(PORT, vflag, true){|s, p|
 
165
    start_server(PORT, vflag, true){|server, port|
161
166
      assert_raises(OpenSSL::SSL::SSLError){
162
 
        sock = TCPSocket.new("127.0.0.1", p)
 
167
        sock = TCPSocket.new("127.0.0.1", port)
163
168
        ssl = OpenSSL::SSL::SSLSocket.new(sock)
164
169
        ssl.connect
165
170
      }
167
172
      ctx = OpenSSL::SSL::SSLContext.new
168
173
      ctx.key = @cli_key
169
174
      ctx.cert = @cli_cert
170
 
      sock = TCPSocket.new("127.0.0.1", p)
 
175
      sock = TCPSocket.new("127.0.0.1", port)
171
176
      ssl = OpenSSL::SSL::SSLSocket.new(sock, ctx)
172
177
      ssl.sync_close = true
173
178
      ssl.connect
181
186
        called = true
182
187
        [@cli_cert, @cli_key]
183
188
      }
184
 
      sock = TCPSocket.new("127.0.0.1", p)
 
189
      sock = TCPSocket.new("127.0.0.1", port)
185
190
      ssl = OpenSSL::SSL::SSLSocket.new(sock, ctx)
186
191
      ssl.sync_close = true
187
192
      ssl.connect
193
198
  end
194
199
 
195
200
  def test_starttls
196
 
    start_server(PORT, OpenSSL::SSL::VERIFY_NONE, false){|s, p|
197
 
      sock = TCPSocket.new("127.0.0.1", p)
 
201
    start_server(PORT, OpenSSL::SSL::VERIFY_NONE, false){|server, port|
 
202
      sock = TCPSocket.new("127.0.0.1", port)
198
203
      ssl = OpenSSL::SSL::SSLSocket.new(sock)
199
204
      ssl.sync_close = true
200
205
      str = "x" * 1000 + "\n"
217
222
 
218
223
  def test_parallel
219
224
    GC.start
220
 
    start_server(PORT, OpenSSL::SSL::VERIFY_NONE, true){|s, p|
 
225
    start_server(PORT, OpenSSL::SSL::VERIFY_NONE, true){|server, port|
221
226
      ssls = []
222
227
      10.times{
223
 
        sock = TCPSocket.new("127.0.0.1", p)
 
228
        sock = TCPSocket.new("127.0.0.1", port)
224
229
        ssl = OpenSSL::SSL::SSLSocket.new(sock)
225
230
        ssl.connect
226
231
        ssl.sync_close = true
237
242
    }
238
243
  end
239
244
 
 
245
  def test_verify_result
 
246
    start_server(PORT, OpenSSL::SSL::VERIFY_NONE, true){|server, port|
 
247
      sock = TCPSocket.new("127.0.0.1", port)
 
248
      ctx = OpenSSL::SSL::SSLContext.new
 
249
      ctx.set_params
 
250
      ssl = OpenSSL::SSL::SSLSocket.new(sock, ctx)
 
251
      assert_raise(OpenSSL::SSL::SSLError){ ssl.connect }
 
252
      assert_equal(OpenSSL::X509::V_ERR_SELF_SIGNED_CERT_IN_CHAIN, ssl.verify_result)
 
253
 
 
254
      sock = TCPSocket.new("127.0.0.1", port)
 
255
      ctx = OpenSSL::SSL::SSLContext.new
 
256
      ctx.set_params(
 
257
        :verify_callback => Proc.new do |preverify_ok, store_ctx|
 
258
          store_ctx.error = OpenSSL::X509::V_OK
 
259
          true
 
260
        end
 
261
      )
 
262
      ssl = OpenSSL::SSL::SSLSocket.new(sock, ctx)
 
263
      ssl.connect
 
264
      assert_equal(OpenSSL::X509::V_OK, ssl.verify_result)
 
265
 
 
266
      sock = TCPSocket.new("127.0.0.1", port)
 
267
      ctx = OpenSSL::SSL::SSLContext.new
 
268
      ctx.set_params(
 
269
        :verify_callback => Proc.new do |preverify_ok, store_ctx|
 
270
          store_ctx.error = OpenSSL::X509::V_ERR_APPLICATION_VERIFICATION
 
271
          false
 
272
        end
 
273
      )
 
274
      ssl = OpenSSL::SSL::SSLSocket.new(sock, ctx)
 
275
      assert_raise(OpenSSL::SSL::SSLError){ ssl.connect }
 
276
      assert_equal(OpenSSL::X509::V_ERR_APPLICATION_VERIFICATION, ssl.verify_result)
 
277
    }
 
278
  end
 
279
 
 
280
  def test_sslctx_set_params
 
281
    start_server(PORT, OpenSSL::SSL::VERIFY_NONE, true){|server, port|
 
282
      sock = TCPSocket.new("127.0.0.1", port)
 
283
      ctx = OpenSSL::SSL::SSLContext.new
 
284
      ctx.set_params
 
285
      assert_equal(OpenSSL::SSL::VERIFY_PEER, ctx.verify_mode)
 
286
      assert_equal(OpenSSL::SSL::OP_ALL, ctx.options)
 
287
      ciphers = ctx.ciphers
 
288
      ciphers_versions = ciphers.collect{|_, v, _, _| v }
 
289
      ciphers_names = ciphers.collect{|v, _, _, _| v }
 
290
      assert(ciphers_names.all?{|v| /ADH/ !~ v })
 
291
      assert(ciphers_versions.all?{|v| /SSLv2/ !~ v })
 
292
      ssl = OpenSSL::SSL::SSLSocket.new(sock, ctx)
 
293
      assert_raise(OpenSSL::SSL::SSLError){ ssl.connect }
 
294
      assert_equal(OpenSSL::X509::V_ERR_SELF_SIGNED_CERT_IN_CHAIN, ssl.verify_result)
 
295
    }
 
296
  end
 
297
 
240
298
  def test_post_connection_check
241
299
    sslerr = OpenSSL::SSL::SSLError
242
300
 
243
 
    start_server(PORT, OpenSSL::SSL::VERIFY_NONE, true){|s, p|
244
 
      sock = TCPSocket.new("127.0.0.1", p)
 
301
    start_server(PORT, OpenSSL::SSL::VERIFY_NONE, true){|server, port|
 
302
      sock = TCPSocket.new("127.0.0.1", port)
245
303
      ssl = OpenSSL::SSL::SSLSocket.new(sock)
246
304
      ssl.connect
247
305
      assert_raises(sslerr){ssl.post_connection_check("localhost.localdomain")}
248
306
      assert_raises(sslerr){ssl.post_connection_check("127.0.0.1")}
249
307
      assert(ssl.post_connection_check("localhost"))
250
308
      assert_raises(sslerr){ssl.post_connection_check("foo.example.com")}
 
309
 
 
310
      cert = ssl.peer_cert
 
311
      assert(!OpenSSL::SSL.verify_certificate_identity(cert, "localhost.localdomain"))
 
312
      assert(!OpenSSL::SSL.verify_certificate_identity(cert, "127.0.0.1"))
 
313
      assert(OpenSSL::SSL.verify_certificate_identity(cert, "localhost"))
 
314
      assert(!OpenSSL::SSL.verify_certificate_identity(cert, "foo.example.com"))
251
315
    }
252
316
 
253
317
    now = Time.now
258
322
    ]
259
323
    @svr_cert = issue_cert(@svr, @svr_key, 4, now, now+1800, exts,
260
324
                           @ca_cert, @ca_key, OpenSSL::Digest::SHA1.new)
261
 
    start_server(PORT, OpenSSL::SSL::VERIFY_NONE, true){|s, p|
262
 
      sock = TCPSocket.new("127.0.0.1", p)
 
325
    start_server(PORT, OpenSSL::SSL::VERIFY_NONE, true){|server, port|
 
326
      sock = TCPSocket.new("127.0.0.1", port)
263
327
      ssl = OpenSSL::SSL::SSLSocket.new(sock)
264
328
      ssl.connect
265
329
      assert(ssl.post_connection_check("localhost.localdomain"))
266
330
      assert(ssl.post_connection_check("127.0.0.1"))
267
331
      assert_raises(sslerr){ssl.post_connection_check("localhost")}
268
332
      assert_raises(sslerr){ssl.post_connection_check("foo.example.com")}
 
333
 
 
334
      cert = ssl.peer_cert
 
335
      assert(OpenSSL::SSL.verify_certificate_identity(cert, "localhost.localdomain"))
 
336
      assert(OpenSSL::SSL.verify_certificate_identity(cert, "127.0.0.1"))
 
337
      assert(!OpenSSL::SSL.verify_certificate_identity(cert, "localhost"))
 
338
      assert(!OpenSSL::SSL.verify_certificate_identity(cert, "foo.example.com"))
269
339
    }
270
340
 
271
341
    now = Time.now
275
345
    ]
276
346
    @svr_cert = issue_cert(@svr, @svr_key, 5, now, now+1800, exts,
277
347
                           @ca_cert, @ca_key, OpenSSL::Digest::SHA1.new)
278
 
    start_server(PORT, OpenSSL::SSL::VERIFY_NONE, true){|s, p|
279
 
      sock = TCPSocket.new("127.0.0.1", p)
 
348
    start_server(PORT, OpenSSL::SSL::VERIFY_NONE, true){|server, port|
 
349
      sock = TCPSocket.new("127.0.0.1", port)
280
350
      ssl = OpenSSL::SSL::SSLSocket.new(sock)
281
351
      ssl.connect
282
352
      assert(ssl.post_connection_check("localhost.localdomain"))
283
353
      assert_raises(sslerr){ssl.post_connection_check("127.0.0.1")}
284
354
      assert_raises(sslerr){ssl.post_connection_check("localhost")}
285
355
      assert_raises(sslerr){ssl.post_connection_check("foo.example.com")}
 
356
      cert = ssl.peer_cert
 
357
      assert(OpenSSL::SSL.verify_certificate_identity(cert, "localhost.localdomain"))
 
358
      assert(!OpenSSL::SSL.verify_certificate_identity(cert, "127.0.0.1"))
 
359
      assert(!OpenSSL::SSL.verify_certificate_identity(cert, "localhost"))
 
360
      assert(!OpenSSL::SSL.verify_certificate_identity(cert, "foo.example.com"))
286
361
    }
287
362
  end
288
363
end