1 /*
2 * Copyright (c) 2003, 2015, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 /*
25 * @test
26 * @bug 4948079
27 * @summary SSLEngineResult needs updating [none yet]
28 *
29 * This is a simple hack to test a bunch of conditions and check
30 * their return codes.
31 *
32 * @run main/othervm -Djsse.enableCBCProtection=false CheckStatus
33 *
34 * @author Brad Wetmore
35 */
36
37 import javax.net.ssl.*;
38 import javax.net.ssl.SSLEngineResult.*;
39 import java.io.*;
40 import java.security.*;
41 import java.nio.*;
42
43 public class CheckStatus {
44
45 private static boolean debug = true;
46
47 private SSLContext sslc;
48 private SSLEngine ssle1; // client
49 private SSLEngine ssle2; // server
50
51 private static String pathToStores = "../etc";
52 private static String keyStoreFile = "keystore";
53 private static String trustStoreFile = "truststore";
54 private static String passwd = "passphrase";
55
56 private static String keyFilename =
57 System.getProperty("test.src", "./") + "/" + pathToStores +
58 "/" + keyStoreFile;
59 private static String trustFilename =
60 System.getProperty("test.src", "./") + "/" + pathToStores +
61 "/" + trustStoreFile;
62
63 private ByteBuffer appOut1; // write side of ssle1
64 private ByteBuffer appIn1; // read side of ssle1
65 private ByteBuffer appOut2; // write side of ssle2
66 private ByteBuffer appIn2; // read side of ssle2
67
68 private ByteBuffer oneToTwo; // "reliable" transport ssle1->ssle2
69 private ByteBuffer twoToOne; // "reliable" transport ssle2->ssle1
70
71 /*
72 * Majority of the test case is here, setup is done below.
73 */
74
75 private void createSSLEngines() throws Exception {
76 ssle1 = sslc.createSSLEngine("client", 1);
77 ssle1.setUseClientMode(true);
78
79 ssle2 = sslc.createSSLEngine("server", 2);
80 ssle2.setUseClientMode(false);
81 }
82
83 private boolean isHandshaking(SSLEngine e) {
84 return (e.getHandshakeStatus() != HandshakeStatus.NOT_HANDSHAKING);
85 }
86
87 private void checkResult(ByteBuffer bbIn, ByteBuffer bbOut,
88 SSLEngineResult result,
89 Status status, HandshakeStatus hsStatus,
90 int consumed, int produced)
91 throws Exception {
92
93 if ((status != null) && (result.getStatus() != status)) {
94 throw new Exception("Unexpected Status: need = " + status +
95 " got = " + result.getStatus());
96 }
97
98 if ((hsStatus != null) && (result.getHandshakeStatus() != hsStatus)) {
99 throw new Exception("Unexpected hsStatus: need = " + hsStatus +
100 " got = " + result.getHandshakeStatus());
101 }
102
103 if ((consumed != -1) && (consumed != result.bytesConsumed())) {
104 throw new Exception("Unexpected consumed: need = " + consumed +
105 " got = " + result.bytesConsumed());
106 }
107
108 if ((produced != -1) && (produced != result.bytesProduced())) {
109 throw new Exception("Unexpected produced: need = " + produced +
110 " got = " + result.bytesProduced());
111 }
112
113 if ((consumed != -1) && (bbIn.position() != result.bytesConsumed())) {
114 throw new Exception("Consumed " + bbIn.position() +
115 " != " + consumed);
116 }
117
118 if ((produced != -1) && (bbOut.position() != result.bytesProduced())) {
119 throw new Exception("produced " + bbOut.position() +
120 " != " + produced);
121 }
122 }
123
124 private void test() throws Exception {
125 createSSLEngines();
126 createBuffers();
127
128 SSLEngineResult result1; // ssle1's results from last operation
129 SSLEngineResult result2; // ssle2's results from last operation
130
131 String [] suite1 = new String [] {
132 "SSL_RSA_WITH_RC4_128_MD5" };
133 String [] suite2 = new String [] {
134 "SSL_DHE_DSS_WITH_3DES_EDE_CBC_SHA" };
135
136 ssle1.setEnabledCipherSuites(suite1);
137 ssle2.setEnabledCipherSuites(suite1);
138
139 log("================");
140
141 log("unexpected empty unwrap");
142 twoToOne.limit(0);
143 result1 = ssle1.unwrap(twoToOne, appIn1);
144 checkResult(twoToOne, appIn1, result1,
145 Status.OK, HandshakeStatus.NEED_WRAP, 0, 0);
146 twoToOne.limit(twoToOne.capacity());
147
148 log("======================================");
149 log("client hello");
150 result1 = ssle1.wrap(appOut1, oneToTwo);
151 checkResult(appOut1, oneToTwo, result1,
152 Status.OK, HandshakeStatus.NEED_UNWRAP, 0, -1);
153
154 oneToTwo.flip();
155 result2 = ssle2.unwrap(oneToTwo, appIn2);
156
157 checkResult(oneToTwo, appIn2, result2,
158 Status.OK, HandshakeStatus.NEED_TASK, result1.bytesProduced(), 0);
159 runDelegatedTasks(ssle2);
160
161 oneToTwo.compact();
162
163 log("Check for unwrap when wrap needed");
164 result2 = ssle2.unwrap(oneToTwo, appIn2);
165 checkResult(oneToTwo, appIn2, result2,
166 Status.OK, HandshakeStatus.NEED_WRAP, 0, 0);
167
168 log("======================================");
169 log("ServerHello");
170
171 result2 = ssle2.wrap(appOut2, twoToOne);
172 checkResult(appOut2, twoToOne, result2,
173 Status.OK, HandshakeStatus.NEED_UNWRAP, 0, -1);
174 twoToOne.flip();
175
176 result1 = ssle1.unwrap(twoToOne, appIn1);
177 checkResult(twoToOne, appIn1, result1,
178 Status.OK, HandshakeStatus.NEED_TASK, result2.bytesProduced(), 0);
179 twoToOne.compact();
180
181 runDelegatedTasks(ssle1);
182
183 log("======================================");
184 log("Key Exchange");
185 result1 = ssle1.wrap(appOut1, oneToTwo);
186 checkResult(appOut1, oneToTwo, result1,
187 Status.OK, HandshakeStatus.NEED_WRAP, 0, -1);
188
189 oneToTwo.flip();
190 result2 = ssle2.unwrap(oneToTwo, appIn2);
191
192 checkResult(oneToTwo, appIn2, result2,
193 Status.OK, HandshakeStatus.NEED_TASK, result1.bytesProduced(), 0);
194 runDelegatedTasks(ssle2);
195
196 oneToTwo.compact();
197
198 log("======================================");
199 log("CCS");
200 result1 = ssle1.wrap(appOut1, oneToTwo);
201 checkResult(appOut1, oneToTwo, result1,
202 Status.OK, HandshakeStatus.NEED_WRAP, 0, -1);
203
204 oneToTwo.flip();
205 result2 = ssle2.unwrap(oneToTwo, appIn2);
206
207 checkResult(oneToTwo, appIn2, result2,
208 Status.OK, HandshakeStatus.NEED_UNWRAP,
209 result1.bytesProduced(), 0);
210
211 oneToTwo.compact();
212
213 log("======================================");
214 log("Finished");
215 result1 = ssle1.wrap(appOut1, oneToTwo);
216 checkResult(appOut1, oneToTwo, result1,
217 Status.OK, HandshakeStatus.NEED_UNWRAP, 0, -1);
218
219 oneToTwo.flip();
220 result2 = ssle2.unwrap(oneToTwo, appIn2);
221
222 checkResult(oneToTwo, appIn2, result2,
223 Status.OK, HandshakeStatus.NEED_WRAP, result1.bytesProduced(), 0);
224
225 oneToTwo.compact();
226
227 log("======================================");
228 log("CCS");
229
230 result2 = ssle2.wrap(appOut2, twoToOne);
231 checkResult(appOut2, twoToOne, result2,
232 Status.OK, HandshakeStatus.NEED_WRAP, 0, -1);
233 twoToOne.flip();
234
235 result1 = ssle1.unwrap(twoToOne, appIn1);
236 checkResult(twoToOne, appIn1, result1,
237 Status.OK, HandshakeStatus.NEED_UNWRAP, result2.bytesProduced(), 0);
238 twoToOne.compact();
239
240 log("======================================");
241 log("FINISHED");
242
243 result2 = ssle2.wrap(appOut2, twoToOne);
244 checkResult(appOut2, twoToOne, result2,
245 Status.OK, HandshakeStatus.FINISHED, 0, -1);
246 twoToOne.flip();
247
248 result1 = ssle1.unwrap(twoToOne, appIn1);
249 checkResult(twoToOne, appIn1, result1,
250 Status.OK, HandshakeStatus.FINISHED, result2.bytesProduced(), 0);
251 twoToOne.compact();
252
253 log("======================================");
254 log("Check Session/Ciphers");
255
256 String suite = ssle1.getSession().getCipherSuite();
257 if (!suite.equals(suite1[0])) {
258 throw new Exception("suites not equal: " + suite + "/" +
259 suite1[0]);
260 }
261
262 suite = ssle2.getSession().getCipherSuite();
263 if (!suite.equals(suite1[0])) {
264 throw new Exception("suites not equal: " + suite + "/" +
265 suite1[0]);
266 }
267
268 log("======================================");
269 log("DATA");
270
271 result1 = ssle1.wrap(appOut1, oneToTwo);
272 checkResult(appOut1, oneToTwo, result1,
273 Status.OK, HandshakeStatus.NOT_HANDSHAKING,
274 appOut1.capacity(), -1);
275 oneToTwo.flip();
276
277 result2 = ssle2.wrap(appOut2, twoToOne);
278 checkResult(appOut2, twoToOne, result2,
279 Status.OK, HandshakeStatus.NOT_HANDSHAKING,
280 appOut2.capacity(), -1);
281 twoToOne.flip();
282
283 SSLEngineResult result3 = ssle1.unwrap(twoToOne, appIn1);
284 checkResult(twoToOne, appIn1, result3,
285 Status.OK, HandshakeStatus.NOT_HANDSHAKING,
286 result2.bytesProduced(), result2.bytesConsumed());
287 twoToOne.compact();
288
289 SSLEngineResult result4 = ssle2.unwrap(oneToTwo, appIn2);
290 checkResult(oneToTwo, appIn2, result4,
291 Status.OK, HandshakeStatus.NOT_HANDSHAKING,
292 result1.bytesProduced(), result1.bytesConsumed());
293 oneToTwo.compact();
294
295 appIn1.clear();
296 appIn2.clear();
297 appOut1.rewind();
298 appOut2.rewind();
299
300 log("======================================");
301 log("RENEGOTIATE");
302
303 ssle2.getSession().invalidate();
304 ssle2.setNeedClientAuth(true);
305
306 ssle1.setEnabledCipherSuites(suite2);
307 ssle2.setEnabledCipherSuites(suite2);
308
309 ssle2.beginHandshake();
310
311 log("======================================");
312 log("HelloRequest");
313
314 result2 = ssle2.wrap(appOut2, twoToOne);
315 checkResult(appOut2, twoToOne, result2,
316 Status.OK, HandshakeStatus.NEED_UNWRAP, 0, -1);
317 twoToOne.flip();
318
319 result1 = ssle1.unwrap(twoToOne, appIn1);
320 checkResult(twoToOne, appIn1, result1,
321 Status.OK, HandshakeStatus.NEED_TASK, result2.bytesProduced(), 0);
322 twoToOne.compact();
323
324 runDelegatedTasks(ssle1);
325
326 log("======================================");
327 log("ClientHello");
328
329 result1 = ssle1.wrap(appOut1, oneToTwo);
330 checkResult(appOut1, oneToTwo, result1,
331 Status.OK, HandshakeStatus.NEED_UNWRAP, 0, -1);
332
333 oneToTwo.flip();
334 result2 = ssle2.unwrap(oneToTwo, appIn2);
335
336 checkResult(oneToTwo, appIn2, result2,
337 Status.OK, HandshakeStatus.NEED_TASK, result1.bytesProduced(), 0);
338 runDelegatedTasks(ssle2);
339
340 oneToTwo.compact();
341
342 log("======================================");
343 log("CLIENT->SERVER DATA IN MIDDLE OF HANDSHAKE");
344
345 result1 = ssle1.wrap(appOut1, oneToTwo);
346 checkResult(appOut1, oneToTwo, result1,
347 Status.OK, HandshakeStatus.NEED_UNWRAP,
348 appOut1.capacity(), -1);
349 oneToTwo.flip();
350
351 result4 = ssle2.unwrap(oneToTwo, appIn2);
352 checkResult(oneToTwo, appIn2, result4,
353 Status.OK, HandshakeStatus.NEED_WRAP,
354 result1.bytesProduced(), result1.bytesConsumed());
355 oneToTwo.compact();
356
357 appIn2.clear();
358 appOut1.rewind();
359
360 log("======================================");
361 log("ServerHello");
362
363 result2 = ssle2.wrap(appOut2, twoToOne);
364 checkResult(appOut2, twoToOne, result2,
365 Status.OK, HandshakeStatus.NEED_UNWRAP, 0, -1);
366 twoToOne.flip();
367
368 result1 = ssle1.unwrap(twoToOne, appIn1);
369 checkResult(twoToOne, appIn1, result1,
370 Status.OK, HandshakeStatus.NEED_TASK, result2.bytesProduced(), 0);
371 twoToOne.compact();
372
373 runDelegatedTasks(ssle1);
374
375 log("======================================");
376 log("SERVER->CLIENT DATA IN MIDDLE OF HANDSHAKE");
377
378 result2 = ssle2.wrap(appOut2, twoToOne);
379 checkResult(appOut2, twoToOne, result2,
380 Status.OK, HandshakeStatus.NEED_UNWRAP,
381 appOut2.capacity(), -1);
382 twoToOne.flip();
383
384 result3 = ssle1.unwrap(twoToOne, appIn1);
385 checkResult(twoToOne, appIn1, result3,
386 Status.OK, HandshakeStatus.NEED_WRAP,
387 result2.bytesProduced(), result2.bytesConsumed());
388 twoToOne.compact();
389
390 appIn1.clear();
391 appOut2.rewind();
392
393 log("======================================");
394 log("Client Cert");
395 result1 = ssle1.wrap(appOut1, oneToTwo);
396 checkResult(appOut1, oneToTwo, result1,
397 Status.OK, HandshakeStatus.NEED_WRAP, 0, -1);
398
399 oneToTwo.flip();
400 result2 = ssle2.unwrap(oneToTwo, appIn2);
401
402 checkResult(oneToTwo, appIn2, result2,
403 Status.OK, HandshakeStatus.NEED_TASK, result1.bytesProduced(), 0);
404 runDelegatedTasks(ssle2);
405
406 oneToTwo.compact();
407
408 log("======================================");
409 log("Key Exchange");
410 result1 = ssle1.wrap(appOut1, oneToTwo);
411 checkResult(appOut1, oneToTwo, result1,
412 Status.OK, HandshakeStatus.NEED_WRAP, 0, -1);
413
414 oneToTwo.flip();
415 result2 = ssle2.unwrap(oneToTwo, appIn2);
416
417 checkResult(oneToTwo, appIn2, result2,
418 Status.OK, HandshakeStatus.NEED_TASK,
419 result1.bytesProduced(), 0);
420 runDelegatedTasks(ssle2);
421
422 oneToTwo.compact();
423
424 log("======================================");
425 log("CCS");
426 result1 = ssle1.wrap(appOut1, oneToTwo);
427 checkResult(appOut1, oneToTwo, result1,
428 Status.OK, HandshakeStatus.NEED_WRAP, 0, -1);
429
430 oneToTwo.flip();
431 result2 = ssle2.unwrap(oneToTwo, appIn2);
432
433 checkResult(oneToTwo, appIn2, result2,
434 Status.OK, HandshakeStatus.NEED_UNWRAP,
435 result1.bytesProduced(), 0);
436
437 oneToTwo.compact();
438
439 log("======================================");
440 log("Finished");
441 result1 = ssle1.wrap(appOut1, oneToTwo);
442 checkResult(appOut1, oneToTwo, result1,
443 Status.OK, HandshakeStatus.NEED_UNWRAP, 0, -1);
444
445 oneToTwo.flip();
446 result2 = ssle2.unwrap(oneToTwo, appIn2);
447
448 checkResult(oneToTwo, appIn2, result2,
449 Status.OK, HandshakeStatus.NEED_WRAP, result1.bytesProduced(), 0);
450
451 oneToTwo.compact();
452
453 log("======================================");
454 log("CCS");
455
456 result2 = ssle2.wrap(appOut2, twoToOne);
457 checkResult(appOut2, twoToOne, result2,
458 Status.OK, HandshakeStatus.NEED_WRAP, 0, -1);
459 twoToOne.flip();
460
461 result1 = ssle1.unwrap(twoToOne, appIn1);
462 checkResult(twoToOne, appIn1, result1,
463 Status.OK, HandshakeStatus.NEED_UNWRAP, result2.bytesProduced(), 0);
464 twoToOne.compact();
465
466 log("======================================");
467 log("FINISHED");
468
469 result2 = ssle2.wrap(appOut2, twoToOne);
470 checkResult(appOut2, twoToOne, result2,
471 Status.OK, HandshakeStatus.FINISHED, 0, -1);
472 twoToOne.flip();
473
474 result1 = ssle1.unwrap(twoToOne, appIn1);
475 checkResult(twoToOne, appIn1, result1,
476 Status.OK, HandshakeStatus.FINISHED, result2.bytesProduced(), 0);
477 twoToOne.compact();
478
479 log("======================================");
480 log("Check Session/Ciphers");
481
482 suite = ssle1.getSession().getCipherSuite();
483 if (!suite.equals(suite2[0])) {
484 throw new Exception("suites not equal: " + suite + "/" +
485 suite2[0]);
486 }
487
488 suite = ssle2.getSession().getCipherSuite();
489 if (!suite.equals(suite2[0])) {
490 throw new Exception("suites not equal: " + suite + "/" +
491 suite2[0]);
492 }
493
494 log("======================================");
495 log("DATA USING NEW SESSION");
496
497 result1 = ssle1.wrap(appOut1, oneToTwo);
498 checkResult(appOut1, oneToTwo, result1,
499 Status.OK, HandshakeStatus.NOT_HANDSHAKING,
500 appOut1.capacity(), -1);
501 oneToTwo.flip();
502
503 result2 = ssle2.wrap(appOut2, twoToOne);
504 checkResult(appOut2, twoToOne, result2,
505 Status.OK, HandshakeStatus.NOT_HANDSHAKING,
506 appOut2.capacity(), -1);
507 twoToOne.flip();
508
509 result3 = ssle1.unwrap(twoToOne, appIn1);
510 checkResult(twoToOne, appIn1, result3,
511 Status.OK, HandshakeStatus.NOT_HANDSHAKING,
512 result2.bytesProduced(), result2.bytesConsumed());
513 twoToOne.compact();
514
515 result4 = ssle2.unwrap(oneToTwo, appIn2);
516 checkResult(oneToTwo, appIn2, result4,
517 Status.OK, HandshakeStatus.NOT_HANDSHAKING,
518 result1.bytesProduced(), result1.bytesConsumed());
519 oneToTwo.compact();
520
521 appIn1.clear();
522 appIn2.clear();
523 appOut1.rewind();
524 appOut2.rewind();
525
526 log("======================================");
527 log("CN");
528
529 if (isHandshaking(ssle1)) {
530 throw new Exception("ssle1 IS handshaking");
531 }
532
533 if (isHandshaking(ssle2)) {
534 throw new Exception("ssle2 IS handshaking");
535 }
536
537 ssle2.closeOutbound();
538
539 if (!isHandshaking(ssle2)) {
540 throw new Exception("ssle1 IS NOT handshaking");
541 }
542
543 appOut1.rewind();
544 appOut2.rewind();
545
546 result2 = ssle2.wrap(appOut2, twoToOne);
547 checkResult(appOut2, twoToOne, result2,
548 Status.CLOSED, HandshakeStatus.NEED_UNWRAP, 0, -1);
549 twoToOne.flip();
550
551 if (ssle1.isInboundDone()) {
552 throw new Exception("ssle1 inboundDone");
553 }
554
555 result1 = ssle1.unwrap(twoToOne, appIn1);
556 checkResult(twoToOne, appIn1, result1,
557 Status.CLOSED, HandshakeStatus.NEED_WRAP,
558 result2.bytesProduced(), 0);
559 twoToOne.compact();
560
561 if (!ssle1.isInboundDone()) {
562 throw new Exception("ssle1 inboundDone");
563 }
564
565 if (!isHandshaking(ssle1)) {
566 throw new Exception("ssle1 IS NOT handshaking");
567 }
568
569 result2 = ssle2.wrap(appOut2, twoToOne);
570 checkResult(appOut2, twoToOne, result2,
571 Status.CLOSED, HandshakeStatus.NEED_UNWRAP, 0, 0);
572 twoToOne.flip();
573
574 log("======================================");
575 log("CN response");
576
577 if (ssle1.isOutboundDone()) {
578 throw new Exception("ssle1 outboundDone");
579 }
580
581 result1 = ssle1.wrap(appOut1, oneToTwo);
582 checkResult(appOut1, oneToTwo, result1,
583 Status.CLOSED, HandshakeStatus.NOT_HANDSHAKING, 0, -1);
584
585 if (!ssle1.isOutboundDone()) {
586 throw new Exception("ssle1 outboundDone is NOT done");
587 }
588
589 if (isHandshaking(ssle1)) {
590 throw new Exception("ssle1 IS handshaking");
591 }
592
593 oneToTwo.flip();
594
595 if (!ssle2.isOutboundDone()) {
596 throw new Exception("ssle1 outboundDone");
597 }
598
599 if (ssle2.isInboundDone()) {
600 throw new Exception("ssle1 inboundDone");
601 }
602
603 result2 = ssle2.unwrap(oneToTwo, appIn2);
604
605 checkResult(oneToTwo, appIn2, result2,
606 Status.CLOSED, HandshakeStatus.NOT_HANDSHAKING,
607 result1.bytesProduced(), 0);
608
609 if (!ssle2.isOutboundDone()) {
610 throw new Exception("ssle1 outboundDone is NOT done");
611 }
612
613 if (!ssle2.isInboundDone()) {
614 throw new Exception("ssle1 inboundDone is NOT done");
615 }
616
617 if (isHandshaking(ssle2)) {
618 throw new Exception("ssle1 IS handshaking");
619 }
620
621 oneToTwo.compact();
622 }
623
624 public static void main(String args[]) throws Exception {
625 // reset the security property to make sure that the algorithms
626 // and keys used in this test are not disabled.
627 Security.setProperty("jdk.tls.disabledAlgorithms", "");
628
629 CheckStatus cs;
630
631 cs = new CheckStatus();
632
633 cs.createSSLEngines();
634
635 cs.test();
636
637 System.out.println("Test Passed.");
638 }
639
640 /*
641 * **********************************************************
642 * Majority of the test case is above, below is just setup stuff
643 * **********************************************************
644 */
645
646 public CheckStatus() throws Exception {
647 sslc = getSSLContext(keyFilename, trustFilename);
648 }
649
650 /*
651 * Create an initialized SSLContext to use for this test.
652 */
653 private SSLContext getSSLContext(String keyFile, String trustFile)
654 throws Exception {
655
656 KeyStore ks = KeyStore.getInstance("JKS");
657 KeyStore ts = KeyStore.getInstance("JKS");
658
659 char[] passphrase = "passphrase".toCharArray();
660
661 ks.load(new FileInputStream(keyFile), passphrase);
662 ts.load(new FileInputStream(trustFile), passphrase);
663
664 KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
665 kmf.init(ks, passphrase);
666
667 TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");
668 tmf.init(ts);
669
670 SSLContext sslCtx = SSLContext.getInstance("TLS");
671
672 sslCtx.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);
673
674 return sslCtx;
675 }
676
677 private void createBuffers() {
678 // Size the buffers as appropriate.
679
680 SSLSession session = ssle1.getSession();
681 int appBufferMax = session.getApplicationBufferSize();
682 int netBufferMax = session.getPacketBufferSize();
683
684 appIn1 = ByteBuffer.allocateDirect(appBufferMax + 50);
685 appIn2 = ByteBuffer.allocateDirect(appBufferMax + 50);
686
687 oneToTwo = ByteBuffer.allocateDirect(netBufferMax);
688 twoToOne = ByteBuffer.allocateDirect(netBufferMax);
689
690 appOut1 = ByteBuffer.wrap("Hi Engine2, I'm SSLEngine1".getBytes());
691 appOut2 = ByteBuffer.wrap("Hello Engine1, I'm SSLEngine2".getBytes());
692
693 log("AppOut1 = " + appOut1);
694 log("AppOut2 = " + appOut2);
695 log("");
696 }
697
698 private static void runDelegatedTasks(SSLEngine engine) throws Exception {
699
700 Runnable runnable;
701 while ((runnable = engine.getDelegatedTask()) != null) {
702 log("running delegated task...");
703 runnable.run();
704 }
705 }
706
707 private static void checkTransfer(ByteBuffer a, ByteBuffer b)
708 throws Exception {
709 a.flip();
710 b.flip();
711
712 if (!a.equals(b)) {
713 throw new Exception("Data didn't transfer cleanly");
714 } else {
715 log("Data transferred cleanly");
716 }
717
718 a.position(a.limit());
719 b.position(b.limit());
720 a.limit(a.capacity());
721 b.limit(b.capacity());
722 }
723
724 private static void log(String str) {
725 if (debug) {
726 System.out.println(str);
727 }
728 }
729 }