1 /*

     2  * Copyright (c) 2018, 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 8164879

    27  * @library /lib/testlibrary ../../

    28  * @summary Verify AES/GCM's limits set in the jdk.tls.keyLimits property

    29  * start a new handshake sequence to renegotiate the symmetric key with an

    30  * SSLSocket connection.  This test verifies the handshake method was called

    31  * via debugging info.  It does not verify the renegotiation was successful

    32  * as that is very hard.

    33  *

    34  * @run main SSLEngineKeyLimit 0 server AES/GCM/NoPadding keyupdate 1050000

    35  * @run main SSLEngineKeyLimit 1 client AES/GCM/NoPadding keyupdate 2^22

    36  */

    37 

    38 /*

    39  * This test runs in another process so we can monitor the debug

    40  * results.  The OutputAnalyzer must see correct debug output to return a

    41  * success.

    42  */

    43 

    44 import javax.net.ssl.KeyManagerFactory;

    45 import javax.net.ssl.SSLContext;

    46 import javax.net.ssl.SSLEngine;

    47 import javax.net.ssl.SSLEngineResult;

    48 import javax.net.ssl.TrustManagerFactory;

    49 import java.io.File;

    50 import java.io.PrintWriter;

    51 import java.nio.ByteBuffer;

    52 import java.security.KeyStore;

    53 import java.security.SecureRandom;

    54 import java.util.Arrays;

    55 

    56 import jdk.testlibrary.ProcessTools;

    57 import jdk.testlibrary.Utils;

    58 import jdk.testlibrary.OutputAnalyzer;

    59 

    60 public class SSLEngineKeyLimit {

    61 

    62     SSLEngine eng;

    63     static ByteBuffer cTos;

    64     static ByteBuffer sToc;

    65     static ByteBuffer outdata;

    66     ByteBuffer buf;

    67     static boolean ready = false;

    68 

    69     static String pathToStores = "../../../../javax/net/ssl/etc/";

    70     static String keyStoreFile = "keystore";

    71     static String trustStoreFile = "truststore";

    72     static String passwd = "passphrase";

    73     static String keyFilename;

    74     static int dataLen = 10240;

    75     static boolean serverwrite = true;

    76     int totalDataLen = 0;

    77     static boolean sc = true;

    78     static boolean debug = false;

    79     int delay = 1;

    80 

    81     SSLEngineKeyLimit() {

    82         buf = ByteBuffer.allocate(dataLen*4);

    83     }

    84 

    85     /**

    86      * args should have two values:  server|client, <limit size>

    87      * Prepending 'p' is for internal use only.

    88      */

    89     public static void main(String args[]) throws Exception {

    90 

    91         for (int i = 0; i < args.length; i++) {

    92             System.out.print(" " + args[i]);

    93         }

    94         System.out.println();

    95         if (args[0].compareTo("p") != 0) {

    96             boolean expectedFail = (Integer.parseInt(args[0]) == 1);

    97             if (expectedFail) {

    98                 System.out.println("Test expected to not find updated msg");

    99             }

   100 

   101             // Write security property file to overwrite default

   102             File f = new File("keyusage."+ System.nanoTime());

   103             PrintWriter p = new PrintWriter(f);

   104             p.write("jdk.tls.keyLimits=");

   105             for (int i = 2; i < args.length; i++) {

   106                 p.write(" "+ args[i]);

   107             }

   108             p.close();

   109 

   110             System.setProperty("test.java.opts",

   111                     "-Dtest.src=" + System.getProperty("test.src") +

   112                             " -Dtest.jdk=" + System.getProperty("test.jdk") +

   113                             " -Djavax.net.debug=ssl" +

   114                             " -Djava.security.properties=" + f.getName());

   115 

   116             System.out.println("test.java.opts: " +

   117                     System.getProperty("test.java.opts"));

   118 

   119             ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(true,

   120                     Utils.addTestJavaOpts("SSLEngineKeyLimit", "p", args[1]));

   121 

   122             OutputAnalyzer output = ProcessTools.executeProcess(pb);

   123             try {

   124                 if (expectedFail) {

   125                     output.shouldNotContain("KeyUpdate: write key updated");

   126                     output.shouldNotContain("KeyUpdate: read key updated");

   127                 } else {

   128                     output.shouldContain("KeyUpdate: write key updated");

   129                     output.shouldContain("KeyUpdate: read key updated");

   130                 }

   131             } catch (Exception e) {

   132                 throw e;

   133             } finally {

   134                 System.out.println("-- BEGIN Stdout:");

   135                 System.out.println(output.getStdout());

   136                 System.out.println("-- END Stdout");

   137                 System.out.println("-- BEGIN Stderr:");

   138                 System.out.println(output.getStderr());

   139                 System.out.println("-- END Stderr");

   140             }

   141             return;

   142         }

   143 

   144         if (args[0].compareTo("p") != 0) {

   145             throw new Exception ("Tried to run outside of a spawned process");

   146         }

   147 

   148         if (args[1].compareTo("client") == 0) {

   149             serverwrite = false;

   150         }

   151 

   152         cTos = ByteBuffer.allocateDirect(dataLen*4);

   153         keyFilename =

   154             System.getProperty("test.src", "./") + "/" + pathToStores +

   155                 "/" + keyStoreFile;

   156 

   157         System.setProperty("javax.net.ssl.keyStore", keyFilename);

   158         System.setProperty("javax.net.ssl.keyStorePassword", passwd);

   159 

   160         sToc = ByteBuffer.allocateDirect(dataLen*4);

   161         outdata = ByteBuffer.allocateDirect(dataLen);

   162 

   163         byte[] data  = new byte[dataLen];

   164         Arrays.fill(data, (byte)0x0A);

   165         outdata.put(data);

   166         outdata.flip();

   167         cTos.clear();

   168         sToc.clear();

   169 

   170         Thread ts = new Thread(serverwrite ? new Client() : new Server());

   171         ts.start();

   172         (serverwrite ? new Server() : new Client()).run();

   173         ts.interrupt();

   174         ts.join();

   175     }

   176 

   177     private static void doTask(SSLEngineResult result,

   178             SSLEngine engine) throws Exception {

   179 

   180         if (result.getHandshakeStatus() == SSLEngineResult.HandshakeStatus.NEED_TASK) {

   181             Runnable runnable;

   182             while ((runnable = engine.getDelegatedTask()) != null) {

   183                 System.out.println("\trunning delegated task...");

   184                 runnable.run();

   185             }

   186             SSLEngineResult.HandshakeStatus hsStatus = engine.getHandshakeStatus();

   187             if (hsStatus == SSLEngineResult.HandshakeStatus.NEED_TASK) {

   188                 throw new Exception(

   189                     "handshake shouldn't need additional tasks");

   190             }

   191             print("\tnew HandshakeStatus: " + hsStatus);

   192         }

   193     }

   194 

   195     static void print(String s) {

   196         if (debug) {

   197             System.out.println(s);

   198         }

   199     }

   200 

   201     static void log(String s, SSLEngineResult r) {

   202         if (!debug) {

   203             return;

   204         }

   205         System.out.println(s + ": " +

   206                 r.getStatus() + "/" + r.getHandshakeStatus()+ " " +

   207                 r.bytesConsumed() + "/" + r.bytesProduced() + " ");

   208 

   209     }

   210 

   211     void write() throws Exception {

   212         int i = 0;

   213         SSLEngineResult r;

   214         boolean again = true;

   215 

   216         while (!ready) {

   217             Thread.sleep(delay);

   218         }

   219         print("Write-side. ");

   220 

   221         while (i++ < 120) {

   222             while (sc) {

   223                 Thread.sleep(delay);

   224             }

   225 

   226             outdata.rewind();

   227             print("write wrap");

   228 

   229             while (true) {

   230                 r = eng.wrap(outdata, getWriteBuf());

   231                 log("write wrap", r);

   232                 if (debug && r.getStatus() != SSLEngineResult.Status.OK) {

   233                     System.out.println("outdata pos: " + outdata.position() +

   234                             " rem: " + outdata.remaining() +

   235                             " lim: " + outdata.limit() +

   236                             " cap: " + outdata.capacity());

   237                     System.out.println("writebuf pos: " + getWriteBuf().position() +

   238                             " rem: " + getWriteBuf().remaining() +

   239                             " lim: " + getWriteBuf().limit() +

   240                             " cap: " + getWriteBuf().capacity());

   241                 }

   242                 if (again && r.getStatus() == SSLEngineResult.Status.OK &&

   243                         r.getHandshakeStatus() == SSLEngineResult.HandshakeStatus.NEED_WRAP) {

   244                     print("again");

   245                     again = false;

   246                     continue;

   247                 }

   248                 break;

   249             }

   250             doTask(r, eng);

   251             getWriteBuf().flip();

   252             sc = true;

   253             while (sc) {

   254                 Thread.sleep(delay);

   255             }

   256 

   257             while (true) {

   258                 buf.clear();

   259                 r = eng.unwrap(getReadBuf(), buf);

   260                 log("write unwrap", r);

   261                 if (debug && r.getStatus() != SSLEngineResult.Status.OK) {

   262                     System.out.println("buf pos: " + buf.position() +

   263                             " rem: " + buf.remaining() +

   264                             " lim: " + buf.limit() +

   265                             " cap: " + buf.capacity());

   266                     System.out.println("readbuf pos: " + getReadBuf().position() +

   267                             " rem: " + getReadBuf().remaining() +

   268                             " lim: " + getReadBuf().limit() +

   269                             " cap:"  + getReadBuf().capacity());

   270                 }

   271                 break;

   272             }

   273             doTask(r, eng);

   274             getReadBuf().compact();

   275             print("compacted readbuf pos: " + getReadBuf().position() +

   276                     " rem: " + getReadBuf().remaining() +

   277                     " lim: " + getReadBuf().limit() +

   278                     " cap: " + getReadBuf().capacity());

   279             sc = true;

   280         }

   281     }

   282 

   283     void read() throws Exception {

   284         byte b = 0x0B;

   285         ByteBuffer buf2 = ByteBuffer.allocateDirect(dataLen);

   286         SSLEngineResult r = null;

   287         boolean exit, again = true;

   288 

   289         while (eng == null) {

   290             Thread.sleep(delay);

   291         }

   292 

   293         try {

   294             System.out.println("connected");

   295             print("entering read loop");

   296             ready = true;

   297             while (true) {

   298 

   299                 while (!sc) {

   300                     Thread.sleep(delay);

   301                 }

   302 

   303                 print("read wrap");

   304                 exit = false;

   305                 while (!exit) {

   306                     buf2.put(b);

   307                     buf2.flip();

   308                     r = eng.wrap(buf2, getWriteBuf());

   309                     log("read wrap", r);

   310                     if (debug ) { //&& r.getStatus() != SSLEngineResult.Status.OK) {

   311                         System.out.println("buf2 pos: " + buf2.position() +

   312                                 " rem: " + buf2.remaining() +

   313                                 " cap: " + buf2.capacity());

   314                         System.out.println("writebuf pos: " + getWriteBuf().position() +

   315                                 " rem: " + getWriteBuf().remaining() +

   316                                 " cap: " + getWriteBuf().capacity());

   317                     }

   318                     if (again && r.getStatus() == SSLEngineResult.Status.OK &&

   319                             r.getHandshakeStatus() == SSLEngineResult.HandshakeStatus.NEED_WRAP) {

   320                         buf2.compact();

   321                         again = false;

   322                         continue;

   323                     }

   324                     exit = true;

   325                 }

   326                 doTask(r, eng);

   327                 buf2.clear();

   328                 getWriteBuf().flip();

   329 

   330                 sc = false;

   331 

   332                 while (!sc) {

   333                     Thread.sleep(delay);

   334                 }

   335 

   336                 while (true) {

   337                         buf.clear();

   338                         r = eng.unwrap(getReadBuf(), buf);

   339                         log("read unwrap", r);

   340                         if (debug && r.getStatus() != SSLEngineResult.Status.OK) {

   341                             System.out.println("buf pos " + buf.position() +

   342                                     " rem: " + buf.remaining() +

   343                                     " lim: " + buf.limit() +

   344                                     " cap: " + buf.capacity());

   345                             System.out.println("readbuf pos: " + getReadBuf().position() +

   346                                     " rem: " + getReadBuf().remaining() +

   347                                     " lim: " + getReadBuf().limit() +

   348                                     " cap: " + getReadBuf().capacity());

   349                             doTask(r, eng);

   350                         }

   351 

   352                     if (again && r.getStatus() == SSLEngineResult.Status.OK &&

   353                             r.getHandshakeStatus() == SSLEngineResult.HandshakeStatus.NEED_UNWRAP) {

   354                         buf.clear();

   355                         print("again");

   356                         again = false;

   357                         continue;

   358 

   359                     }

   360                     break;

   361                 }

   362                 buf.clear();

   363                 getReadBuf().compact();

   364 

   365                 totalDataLen += r.bytesProduced();

   366                 sc = false;

   367             }

   368         } catch (Exception e) {

   369             System.out.println(e.getMessage());

   370             e.printStackTrace();

   371         }

   372         print("TotalDataLen = " + totalDataLen);

   373     }

   374 

   375     ByteBuffer getReadBuf() {

   376         return null;

   377     }

   378 

   379     ByteBuffer getWriteBuf() {

   380         return null;

   381     }

   382 

   383 

   384     SSLContext initContext() throws Exception {

   385         SSLContext sc = SSLContext.getInstance("TLSv1.3");

   386         KeyStore ks = KeyStore.getInstance(

   387                 new File(System.getProperty("javax.net.ssl.keyStore")),

   388                 passwd.toCharArray());

   389         KeyManagerFactory kmf =

   390                 KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());

   391         kmf.init(ks, passwd.toCharArray());

   392         TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());

   393         tmf.init(ks);

   394         sc.init(kmf.getKeyManagers(), tmf.getTrustManagers(), new SecureRandom());

   395         return sc;

   396     }

   397 

   398     static class Server extends SSLEngineKeyLimit implements Runnable {

   399         Server() throws Exception {

   400             super();

   401             eng = initContext().createSSLEngine();

   402             eng.setUseClientMode(false);

   403             eng.setNeedClientAuth(true);

   404         }

   405         

   406         public void run() {

   407             try {

   408                 if (serverwrite) {

   409                     write();

   410                 } else {

   411                     read();

   412                 }

   413 

   414             } catch (Exception e) {

   415                 System.out.println("server: " + e.getMessage());

   416                 e.printStackTrace();

   417             }

   418             System.out.println("Server closed");

   419         }

   420 

   421         @Override

   422         ByteBuffer getWriteBuf() {

   423             return sToc;

   424         }

   425         @Override

   426         ByteBuffer getReadBuf() {

   427             return cTos;

   428         }

   429     }

   430 

   431 

   432     static class Client extends SSLEngineKeyLimit implements Runnable {

   433         Client() throws Exception {

   434             super();

   435             eng = initContext().createSSLEngine("client", 80);

   436             eng.setUseClientMode(true);

   437         }

   438 

   439         public void run() {

   440             try {

   441                 if (!serverwrite) {

   442                     write();

   443                 } else {

   444                     read();

   445                 }

   446             } catch (Exception e) {

   447                 System.out.println("client: " + e.getMessage());

   448                 e.printStackTrace();

   449             }

   450         }

   451         @Override

   452         ByteBuffer getWriteBuf() {

   453             return cTos;

   454         }

   455         @Override

   456         ByteBuffer getReadBuf() {

   457             return sToc;

   458         }

   459     }

   460 }