Java SSLServerSocket.getEnabledCipherSuites方法代码示例

import javax.net.ssl.SSLServerSocket; //导入方法依赖的package包/类
public static void printInfo(SSLServerSocket socket) {
    System.out.println();
    System.out.println("--- SSL ServerSocket Info ---");
    System.out.print("SupportedProtocols    : ");
    printStringArray(socket.getSupportedProtocols());
    System.out.print("SupportedCipherSuites : ");
    printStringArray(socket.getSupportedCipherSuites());
    System.out.print("EnabledProtocols      : ");
    printStringArray(socket.getEnabledProtocols());
    System.out.print("EnabledCipherSuites   : ");
    String[] supportedCipherSuites = socket.getEnabledCipherSuites();
    Arrays.sort(supportedCipherSuites);
    printStringArray(supportedCipherSuites);
    System.out.println("NeedClientAuth        : "
            + socket.getNeedClientAuth());
    System.out.println("WantClientAuth        : "
            + socket.getWantClientAuth());
    System.out.println("-----------------------");
}
 

import javax.net.ssl.SSLServerSocket; //导入方法依赖的package包/类
@Test
public void testSetEnabledCipherSuitesStoresCopy() throws Exception {
    SSLServerSocket socket =
            (SSLServerSocket) SSLServerSocketFactory.getDefault().createServerSocket();
    String[] array = new String[] {socket.getEnabledCipherSuites()[0]};
    String originalFirstElement = array[0];
    socket.setEnabledCipherSuites(array);
    array[0] = "Modified after having been set";
    assertEquals(originalFirstElement, socket.getEnabledCipherSuites()[0]);
}
 

import javax.net.ssl.SSLServerSocket; //导入方法依赖的package包/类
/**
 * getSupportedCipherSuites() method testing.
 */
public void testGetSupportedCipherSuites() throws Exception {
    SSLServerSocket ssocket = createSSLServerSocket();
    String[] supported = ssocket.getSupportedCipherSuites();
    assertNotNull(supported);
    supported[0] = "NOT_SUPPORTED_CIPHER_SUITE";
    supported = ssocket.getEnabledCipherSuites();
    for (int i=0; i<supported.length; i++) {
        if ("NOT_SUPPORTED_CIPHER_SUITE".equals(supported[i])) {
            fail("Modification of the returned result "
                    + "causes the modification of the internal state");
        }
    }
}
 

import javax.net.ssl.SSLServerSocket; //导入方法依赖的package包/类
private static void narrowServerSocketCipherSuites( ServerSocket serverSocket ) {
    
    
    if( !( serverSocket instanceof SSLServerSocket ) )
        return;
    
    logger.finest("Entering ProxiedClientListener:narrowCipherSuites ... ");
    
    SSLServerSocket sslServerSocket = (SSLServerSocket) serverSocket;
    String[] suites = sslServerSocket.getEnabledCipherSuites();
    logger.finest("Defaulty Support cipher suites are:");
    for (int i = 0; i < suites.length; i++) {
        logger.finest( suites[i] );
    }
    
    String[] filteredSuites = filterSuites(suites, excludeCipher );
    logger.finest("nerrowed from " + suites.length + " to " + filteredSuites.length );
    for( int i=0; i<filteredSuites.length; i++ )
        logger.finest( filteredSuites[i] );
    
    //after this line, the socket's enabledCipherSuites should be only 3
    sslServerSocket.setEnabledCipherSuites( filteredSuites );
    
    //if( logger.getLevel().equals( Level.finest ) )
    {
        String[] newSuites = sslServerSocket.getEnabledCipherSuites();
        logger.finest( "Supported cipher suites are: " );
        for(int i=0; i<newSuites.length; i++  ) {
            logger.finest( newSuites[i] );
        }
    }
}
 

import javax.net.ssl.SSLServerSocket; //导入方法依赖的package包/类
/**
 * Creates the SSL ServerSocket.
 */
public ServerSocketBar create(InetAddress host, int port)
  throws IOException, GeneralSecurityException
{
  SSLServerSocketFactory ssFactory = null;
  
  if (_keyStore != null) {
    SSLContext sslContext = SSLContext.getInstance(_sslContext);

    KeyManagerFactory kmf
      = KeyManagerFactory.getInstance(keyManagerFactory());
  
    kmf.init(_keyStore, keyStorePassword().toCharArray());
    
    sslContext.init(kmf.getKeyManagers(), null, null);

    /*
    if (_cipherSuites != null)
      sslContext.createSSLEngine().setEnabledCipherSuites(_cipherSuites);

    if (_protocols != null)
      sslContext.createSSLEngine().setEnabledProtocols(_protocols);
    */
    
    SSLEngine engine = sslContext.createSSLEngine();
    
    engine.setEnabledProtocols(enabledProtocols(engine.getSupportedProtocols()));

    ssFactory = sslContext.getServerSocketFactory();
  }
  else {
    ssFactory = createAnonymousServerFactory(host, port);
  }
  
  ServerSocket serverSocket;

  int listen = 100;

  if (host == null)
    serverSocket = ssFactory.createServerSocket(port, listen);
  else
    serverSocket = ssFactory.createServerSocket(port, listen, host);

  SSLServerSocket sslServerSocket = (SSLServerSocket) serverSocket;
  
  if (_cipherSuites != null) {
    sslServerSocket.setEnabledCipherSuites(_cipherSuites);
  }
  
  if (_cipherSuitesForbidden != null) {
    String []cipherSuites = sslServerSocket.getEnabledCipherSuites();
    
    if (cipherSuites == null)
      cipherSuites = sslServerSocket.getSupportedCipherSuites();
    
    ArrayList<String> cipherList = new ArrayList<String>();
    
    for (String cipher : cipherSuites) {
      if (! isCipherForbidden(cipher, _cipherSuitesForbidden)) {
        cipherList.add(cipher);
      }
    }
    
    cipherSuites = new String[cipherList.size()];
    cipherList.toArray(cipherSuites);
    
    sslServerSocket.setEnabledCipherSuites(cipherSuites);
  }

  sslServerSocket.setEnabledProtocols(enabledProtocols(sslServerSocket.getSupportedProtocols()));
  
  if ("required".equals(_verifyClient))
    sslServerSocket.setNeedClientAuth(true);
  else if ("optional".equals(_verifyClient))
    sslServerSocket.setWantClientAuth(true);

  return new ServerSocketWrapper(serverSocket);
}
 

import javax.net.ssl.SSLServerSocket; //导入方法依赖的package包/类
/**
 * getEnabledCipherSuites() method testing.
 */
public void testGetEnabledCipherSuites() throws Exception {
    SSLServerSocket ssocket = createSSLServerSocket();
    String[] enabled = ssocket.getEnabledCipherSuites();
    assertNotNull(enabled);
    String[] supported = ssocket.getSupportedCipherSuites();
    for (int i=0; i<enabled.length; i++) {
        //System.out.println("Checking of "+enabled[i]);
        found: {
            for (int j=0; j<supported.length; j++) {
                if (enabled[i].equals(supported[j])) {
                    break found;
                }
            }
            fail("Enabled suite does not belong to the set "
                    + "of supported cipher suites: " + enabled[i]);
        }
    }
    ssocket.setEnabledCipherSuites(supported);
    for (int i=0; i<supported.length; i++) {
        enabled = new String[supported.length - i];
        System.arraycopy(supported, 0,
                enabled, 0, supported.length-i);
        ssocket.setEnabledCipherSuites(enabled);
        String[] result = ssocket.getEnabledCipherSuites();
        if (result.length != enabled.length) {
            fail("Returned result does not correspond to expected.");
        }
        for (int k=0; k<result.length; k++) {
            found: {
                for (int n=0; n<enabled.length; n++) {
                    if (result[k].equals(enabled[n])) {
                        break found;
                    }
                }
                if (result.length != enabled.length) {
                    fail("Returned result does not correspond "
                            + "to expected.");
                }
            }
        }
    }
}
 

import javax.net.ssl.SSLServerSocket; //导入方法依赖的package包/类
/**
 * setEnabledCipherSuites(String[] suites) method testing.
 */
public void testSetEnabledCipherSuites() throws Exception {
    SSLServerSocket ssocket = createSSLServerSocket();
    String[] enabled = ssocket.getEnabledCipherSuites();
    assertNotNull(enabled);
    String[] supported = ssocket.getSupportedCipherSuites();
    for (int i=0; i<enabled.length; i++) {
        //System.out.println("Checking of "+enabled[i]);
        found: {
            for (int j=0; j<supported.length; j++) {
                if (enabled[i].equals(supported[j])) {
                    break found;
                }
            }
            fail("Enabled suite does not belong to the set "
                    + "of supported cipher suites: " + enabled[i]);
        }
    }
    ssocket.setEnabledCipherSuites(supported);
    ssocket.setEnabledCipherSuites(enabled);
    ssocket.setEnabledCipherSuites(supported);
    String[] more_than_supported = new String[supported.length+1];
    for (int i=0; i<supported.length+1; i++) {
        more_than_supported[i]
            = "NOT_SUPPORTED_CIPHER_SUITE";
        System.arraycopy(supported, 0,
                more_than_supported, 0, i);
        System.arraycopy(supported, i,
                more_than_supported, i+1, supported.length-i);
        try {
            ssocket.setEnabledCipherSuites(more_than_supported);
            fail("Expected IllegalArgumentException was not thrown");
        } catch (IllegalArgumentException e) { }
    }
    enabled = ssocket.getEnabledCipherSuites();
    enabled[0] = "NOT_SUPPORTED_CIPHER_SUITE";
    enabled = ssocket.getEnabledCipherSuites();
    for (int i=0; i<enabled.length; i++) {
        if ("NOT_SUPPORTED_CIPHER_SUITE".equals(enabled[i])) {
            fail("Modification of the returned result "
                    + "causes the modification of the internal state");
        }
    }
}