Exemplo n.º 1
0
  static {
    String[] enabledCiphers = null;
    String[] enabledProtocols = null;

    try {
      SSLContext sslContext = SSLContext.getInstance("TLS");
      sslContext.init(null, null, new SecureRandom());
      SSLSocketFactory sf = sslContext.getSocketFactory();
      SSLSocket sock = (SSLSocket) sf.createSocket();
      enabledCiphers = sock.getEnabledCipherSuites();
      enabledProtocols = sock.getEnabledProtocols();
    } catch (IOException ioe) {
      ioe.printStackTrace();
    } catch (KeyManagementException kme) {
      kme.printStackTrace();
    } catch (NoSuchAlgorithmException nsae) {
      nsae.printStackTrace();
    }

    ENABLED_CIPHERS =
        (enabledCiphers == null)
            ? null
            : reorder(enabledCiphers, ORDERED_KNOWN_CIPHERS, BLACKLISTED_CIPHERS);

    ENABLED_PROTOCOLS =
        (enabledProtocols == null)
            ? null
            : reorder(enabledProtocols, ORDERED_KNOWN_PROTOCOLS, null);
  }
Exemplo n.º 2
0
  private CipherTest(PeerFactory peerFactory) throws IOException {
    THREADS = Integer.parseInt(System.getProperty("numThreads", "4"));
    factory = (SSLSocketFactory) SSLSocketFactory.getDefault();
    SSLSocket socket = (SSLSocket) factory.createSocket();
    String[] cipherSuites = socket.getSupportedCipherSuites();
    String[] protocols = socket.getSupportedProtocols();
    //      String[] clientAuths = {null, "RSA", "DSA"};
    String[] clientAuths = {null};
    tests =
        new ArrayList<TestParameters>(cipherSuites.length * protocols.length * clientAuths.length);
    for (int i = 0; i < cipherSuites.length; i++) {
      String cipherSuite = cipherSuites[i];

      for (int j = 0; j < protocols.length; j++) {
        String protocol = protocols[j];

        if (!peerFactory.isSupported(cipherSuite, protocol)) {
          continue;
        }

        for (int k = 0; k < clientAuths.length; k++) {
          String clientAuth = clientAuths[k];
          if ((clientAuth != null) && (cipherSuite.indexOf("DH_anon") != -1)) {
            // no client with anonymous ciphersuites
            continue;
          }
          tests.add(new TestParameters(cipherSuite, protocol, clientAuth));
        }
      }
    }
    testIterator = tests.iterator();
  }
Exemplo n.º 3
0
    /**
     * Generates an SSL-enabled socket.
     *
     * @return the new socket
     * @throws GeneralSecurityException on error building the socket
     * @throws IOException on error loading the KeyStore
     */
    private SSLSocket getSslSocket(RemoteDevice target)
        throws GeneralSecurityException, IOException {
      // Build a new key store based on the key store manager.
      KeyManager[] keyManagers = coreService.getKeyStoreManager().getKeyManagers();
      TrustManager[] trustManagers = coreService.getKeyStoreManager().getTrustManagers();

      if (keyManagers.length == 0) {
        throw new IllegalStateException("No key managers");
      }

      // Create a new SSLContext, using the new KeyManagers and TrustManagers
      // as the sources of keys and trust decisions, respectively.
      SSLContext sslContext = SSLContext.getInstance("TLS");
      sslContext.init(keyManagers, trustManagers, null);

      // Finally, build a new SSLSocketFactory from the SSLContext, and
      // then generate a new SSLSocket from it.
      SSLSocketFactory factory = sslContext.getSocketFactory();
      SSLSocket sock = (SSLSocket) factory.createSocket();
      sock.setNeedClientAuth(true);
      sock.setUseClientMode(true);
      sock.setKeepAlive(true);
      sock.setTcpNoDelay(true);

      InetSocketAddress fullAddr = new InetSocketAddress(target.getAddress(), target.getPort());
      sock.connect(fullAddr, SOCKET_CREATION_TIMEOUT_MS);
      sock.startHandshake();

      return sock;
    }
Exemplo n.º 4
0
  /*
   * Define the client side of the test.
   *
   * If the server prematurely exits, serverReady will be set to true
   * to avoid infinite hangs.
   */
  void doClientSide() throws Exception {

    /*
     * Wait for server to get started.
     */
    while (!serverReady) {
      Thread.sleep(50);
    }

    SSLSocketFactory sslsf = (SSLSocketFactory) SSLSocketFactory.getDefault();
    SSLSocket sslSocket = (SSLSocket) sslsf.createSocket("localhost", serverPort);

    // enable TLSv1.1 only
    sslSocket.setEnabledProtocols(new String[] {"TLSv1.1"});

    // enable a block cipher
    sslSocket.setEnabledCipherSuites(new String[] {"TLS_RSA_WITH_AES_128_CBC_SHA"});

    InputStream sslIS = sslSocket.getInputStream();
    OutputStream sslOS = sslSocket.getOutputStream();

    sslOS.write('B');
    sslOS.flush();
    sslIS.read();

    sslSocket.close();
  }
Exemplo n.º 5
0
    @Override
    public void run() {
      SSLSocketFactory socFac = _sslCtx.getSocketFactory();
      SSLSocket socket = null;
      try {
        socket = (SSLSocket) socFac.createSocket(_targetAddr.getAddress(), _targetAddr.getPort());
        Utility.logOutConnection(socket, _selfId); // log connection
        BufferedWriter out =
            new BufferedWriter(new OutputStreamWriter(socket.getOutputStream(), Utility.ENCODING));
        Utility.XMLDocToWriter(_doc, out);
        if (_bExpectACK) {
          BufferedReader in =
              new BufferedReader(new InputStreamReader(socket.getInputStream(), Utility.ENCODING));
          Document doc = Utility.ReaderToXMLDoc(in);
          if (!doc.getRootElement().getName().equals(ACK)) { // if not ACK
            _log.error("The Peer didn't send ACK back");
          }
        }

      } catch (Exception e) {
        _log.error("SendJob failed", e);
      } finally {
        try {
          if (null != socket) socket.close();
        } catch (IOException e) {
          _log.error("close sendjob socket failed", e);
        }
      }
    }
  /*
   * Define the client side of the test.
   *
   * If the server prematurely exits, serverReady will be set to true
   * to avoid infinite hangs.
   */
  void doClientSide() throws Exception {

    /*
     * Wait for server to get started.
     */
    while (!serverReady) {
      Thread.sleep(50);
    }

    SSLSocketFactory sslsf = (SSLSocketFactory) SSLSocketFactory.getDefault();
    SSLSocket sslSocket = (SSLSocket) sslsf.createSocket("localhost", serverPort);

    InputStream sslIS = sslSocket.getInputStream();
    OutputStream sslOS = sslSocket.getOutputStream();

    for (int i = 0; i < 10; i++) {
      sslOS.write(280);
      sslOS.flush();
      sslIS.read();
    }

    for (int i = 0; i < 10; i++) {
      sslOS.write(280);
      sslOS.flush();
      sslIS.read();
    }

    sslSocket.close();
  }
Exemplo n.º 7
0
  /**
   * SSL/TLS negotiation. Acquires an SSL socket of a control connection and carries out handshake
   * processing.
   *
   * @throws IOException If server negotiation fails
   */
  protected void sslNegotiation() throws IOException {
    plainSocket = _socket_;
    initSslContext();

    SSLSocketFactory ssf = context.getSocketFactory();
    String ip = _socket_.getInetAddress().getHostAddress();
    int port = _socket_.getPort();
    SSLSocket socket = (SSLSocket) ssf.createSocket(_socket_, ip, port, false);
    socket.setEnableSessionCreation(isCreation);
    socket.setUseClientMode(isClientMode);
    // server mode
    if (!isClientMode) {
      socket.setNeedClientAuth(isNeedClientAuth);
      socket.setWantClientAuth(isWantClientAuth);
    }

    if (protocols != null) {
      socket.setEnabledProtocols(protocols);
    }
    if (suites != null) {
      socket.setEnabledCipherSuites(suites);
    }
    socket.startHandshake();

    _socket_ = socket;
    _controlInput_ =
        new BufferedReader(new InputStreamReader(socket.getInputStream(), getControlEncoding()));
    _controlOutput_ =
        new BufferedWriter(new OutputStreamWriter(socket.getOutputStream(), getControlEncoding()));
  }
Exemplo n.º 8
0
  public boolean connect(int fd, boolean sslVerifyPeer, String hostname) {
    try {
      Logger.I(TAG, "SSL connect to " + hostname);

      RhoSockAddr remote = getRemoteSockAddr(fd);
      Socket s = new RhoSocket(fd, remote);
      SSLSocketFactory f = getFactory(sslVerifyPeer);

      StringTokenizer st = new StringTokenizer(hostname, ":");
      String host = st.nextToken();

      SSLSocket aSock = (SSLSocket) f.createSocket(s, host, remote.port, true);
      aSock.setUseClientMode(true);

      synchronized (this) {
        sock = aSock;
        os = sock.getOutputStream();
        is = sock.getInputStream();
        sockfd = fd;
      }
      return true;
    } catch (Exception e) {
      reportFail("connect", e);
      e.printStackTrace();
      return false;
    }
  }
Exemplo n.º 9
0
  private Socket getSocket(String hostName, int port, boolean useSsl) throws IOException {
    if (useSsl) {
      try {
        TrustManager[] trustAllCerts =
            new TrustManager[] {
              new X509TrustManager() {
                public java.security.cert.X509Certificate[] getAcceptedIssuers() {
                  return new X509Certificate[0];
                }

                public void checkClientTrusted(
                    java.security.cert.X509Certificate[] certs, String authType) {}

                public void checkServerTrusted(
                    java.security.cert.X509Certificate[] certs, String authType) {}
              }
            };

        SSLContext sc = SSLContext.getInstance("TLS");
        sc.init(null, trustAllCerts, new java.security.SecureRandom());
        SSLSocketFactory factory = sc.getSocketFactory();
        SSLSocket sslSocket = (SSLSocket) factory.createSocket(hostName, port);
        sslSocket.setUseClientMode(true);
        return sslSocket;
      } catch (Exception e) {
        log.error("Could not create SSL Connection", e);
      }

      return null;
    } else {
      return new Socket(hostName, port);
    }
  }
Exemplo n.º 10
0
 public void call() {
   BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
   PrintStream out = System.out;
   SSLSocketFactory f = (SSLSocketFactory) SSLSocketFactory.getDefault();
   try {
     SSLSocket c = (SSLSocket) f.createSocket("localhost", 8888);
     printSocketInfo(c);
     c.startHandshake();
     BufferedWriter w = new BufferedWriter(new OutputStreamWriter(c.getOutputStream()));
     BufferedReader r = new BufferedReader(new InputStreamReader(c.getInputStream()));
     String m = null;
     while ((m = r.readLine()) != null) {
       out.println(m);
       m = in.readLine();
       w.write(m, 0, m.length());
       w.newLine();
       w.flush();
     }
     w.close();
     r.close();
     c.close();
   } catch (IOException e) {
     System.err.println(e.toString());
   }
 }
  public HTTPSConnectSocket(String host, int port, String urlString) throws IOException {

    URL url = null;
    try {
      url = new URL(urlString);
    } catch (MalformedURLException me) {
      System.out.println("Malformed url");
      System.exit(1);
    }

    SSLSocketFactory ssf = (SSLSocketFactory) SSLSocketFactory.getDefault();
    ssl = (SSLSocket) ssf.createSocket(host, port);
    ssl.startHandshake();

    // Send the CONNECT request
    ssl.getOutputStream().write(("CONNECT " + url.getFile() + " HTTP/1.0\r\n\r\n").getBytes());

    // Read the first line of the response
    DataInputStream is = new DataInputStream(ssl.getInputStream());
    String str = is.readLine();

    // Check the HTTP error code -- it should be "200" on success
    if (!str.startsWith("HTTP/1.1 200 ")) {
      if (str.startsWith("HTTP/1.1 ")) str = str.substring(9);
      throw new IOException("Proxy reports \"" + str + "\"");
    }

    // Success -- skip remaining HTTP headers
    do {
      str = is.readLine();
    } while (str.length() != 0);
  }
Exemplo n.º 12
0
 public NetworkThread(String server, String channel, int port) {
   try {
     this.channel = channel;
     if (Settings.ssl) {
       SSLSocketFactory sslsocketfactory = (SSLSocketFactory) SSLSocketFactory.getDefault();
       socket = (SSLSocket) sslsocketfactory.createSocket();
       List<String> limited = new LinkedList<String>();
       for (String suite : ((SSLSocket) socket).getEnabledCipherSuites()) {
         if (!suite.contains("_DHE_")) {
           limited.add(suite);
         }
       }
       ((SSLSocket) socket).setEnabledCipherSuites(limited.toArray(new String[limited.size()]));
       socket.connect(new InetSocketAddress(server, port));
     } else {
       socket = new Socket(server, port);
     }
     writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
     reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
     uc = new Utilities();
     line = null;
   } catch (Exception e) {
     e.printStackTrace();
   }
 }
Exemplo n.º 13
0
 private Socket getIncommingSocket() throws IOException {
   Socket s;
   if (info.isUseSSL()) {
     SSLSocketFactory sslsocketfactory = (SSLSocketFactory) SSLSocketFactory.getDefault();
     s = sslsocketfactory.createSocket(info.getIncomingServerName(), info.getIncomingPort());
   } else {
     s = new Socket(info.getIncomingServerName(), info.getIncomingPort());
   }
   return s;
 }
Exemplo n.º 14
0
  public void afterConnect() throws IOException, UnknownHostException {
    if (!isCachedConnection()) {
      SSLSocket s = null;
      SSLSocketFactory factory;
      factory = sslSocketFactory;
      try {
        if (!(serverSocket instanceof SSLSocket)) {
          s = (SSLSocket) factory.createSocket(serverSocket, host, port, true);
        } else {
          s = (SSLSocket) serverSocket;
        }
      } catch (IOException ex) {
        // If we fail to connect through the tunnel, try it
        // locally, as a last resort.  If this doesn't work,
        // throw the original exception.
        try {
          s = (SSLSocket) factory.createSocket(host, port);
        } catch (IOException ignored) {
          throw ex;
        }
      }

      SSLSocketFactoryImpl.checkCreate(s);

      //
      // Force handshaking, so that we get any authentication.
      // Register a handshake callback so our session state tracks any
      // later session renegotiations.
      //
      String[] protocols = getProtocols();
      String[] ciphers = getCipherSuites();
      if (protocols != null) s.setEnabledProtocols(protocols);
      if (ciphers != null) s.setEnabledCipherSuites(ciphers);
      s.addHandshakeCompletedListener(this);
      s.startHandshake();
      session = s.getSession();
      // change the serverSocket and serverOutput
      serverSocket = s;
      try {
        serverOutput =
            new PrintStream(
                new BufferedOutputStream(serverSocket.getOutputStream()), false, encoding);
      } catch (UnsupportedEncodingException e) {
        throw new InternalError(encoding + " encoding not found");
      }

      // check URL spoofing
      checkURLSpoofing(hv);
    } else {
      // if we are reusing a cached https session,
      // we don't need to do handshaking etc. But we do need to
      // set the ssl session
      session = ((SSLSocket) serverSocket).getSession();
    }
  }
Exemplo n.º 15
0
  public static void main(String args[]) throws Exception {
    //        System.setProperty("javax.net.ssl.trustStore",
    //                   "clienttrust");

    SSLSocketFactory ssf = (SSLSocketFactory) SSLSocketFactory.getDefault();
    Socket s = ssf.createSocket("127.0.0.1", 5432);
    BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream()));
    String x = in.readLine();
    System.out.println(x);
    in.close();
  }
Exemplo n.º 16
0
  /*
   * Define the client side of the test.
   *
   * If the server prematurely exits, serverReady will be set to true
   * to avoid infinite hangs.
   */
  void doClientSide() throws Exception {

    /*
     * Wait for server to get started.
     */
    while (!serverReady) {
      Thread.sleep(50);
    }

    /*
     * See if an unknown keystore actually gets checked ok.
     */
    System.out.println("==============");
    System.out.println("Starting test0");
    KeyStore uks = KeyStore.getInstance("JKS");
    SSLContext ctx = SSLContext.getInstance("TLS");
    KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");

    uks.load(new FileInputStream(unknownFilename), cpasswd);
    kmf.init(uks, cpasswd);

    TrustManager[] tms = new TrustManager[] {new MyJavaxX509TrustManager()};

    ctx.init(kmf.getKeyManagers(), tms, null);

    SSLSocketFactory sslsf = (SSLSocketFactory) ctx.getSocketFactory();

    System.out.println("Trying first socket " + serverPort);
    SSLSocket sslSocket = (SSLSocket) sslsf.createSocket("localhost", serverPort);

    doTest(sslSocket);

    /*
     * Now try the other way.
     */
    com.sun.net.ssl.SSLContext ctx1 = com.sun.net.ssl.SSLContext.getInstance("TLS");
    com.sun.net.ssl.KeyManagerFactory kmf1 =
        com.sun.net.ssl.KeyManagerFactory.getInstance("SunX509");
    kmf1.init(uks, cpasswd);

    com.sun.net.ssl.TrustManager[] tms1 =
        new com.sun.net.ssl.TrustManager[] {new MyComX509TrustManager()};

    ctx1.init(kmf1.getKeyManagers(), tms1, null);

    sslsf = (SSLSocketFactory) ctx1.getSocketFactory();

    System.out.println("Trying second socket " + serverPort1);
    sslSocket = (SSLSocket) sslsf.createSocket("localhost", serverPort1);

    doTest(sslSocket);
    System.out.println("Completed test1");
  }
Exemplo n.º 17
0
  /**
   * Creates the ssl collection
   *
   * @param ip - ip of the server
   * @return
   */
  private static SSLSocket handshake(String ip) {
    try {
      SSLSocketFactory sslsocketfactory = (SSLSocketFactory) SSLSocketFactory.getDefault();
      SSLSocket sslsocket = (SSLSocket) sslsocketfactory.createSocket(ip, 9996);
      String[] enabledCipherSuites = {"SSL_DH_anon_WITH_RC4_128_MD5"};
      sslsocket.setEnabledCipherSuites(enabledCipherSuites);
      return sslsocket;

    } catch (Exception exception) {
      exception.printStackTrace();
      return null;
    }
  }
Exemplo n.º 18
0
  public static SSLSocket wrapSocket(Socket socket) throws Exception {
    // ssl socket factory
    SSLSocketFactory sslSocketFactory = sslContext().getSocketFactory();

    // ssl socket
    SSLSocket sslSocket =
        (SSLSocket)
            sslSocketFactory.createSocket(
                socket, socket.getInetAddress().getHostAddress(), socket.getPort(), true);
    sslSocket.setUseClientMode(true);
    sslSocket.startHandshake();
    return sslSocket;
  }
Exemplo n.º 19
0
  protected void logSupportedParameters() {
    if (LOGGED.compareAndSet(false, true)) {
      try {
        final SSLContext context = SSLContext.getDefault();
        final String[] protocols = context.getSupportedSSLParameters().getProtocols();
        final SSLSocketFactory factory = context.getSocketFactory();
        final String[] cipherSuites = factory.getSupportedCipherSuites();
        LOGGER.info("Supported protocols: {}", Arrays.toString(protocols));
        LOGGER.info("Supported cipher suites: {}", Arrays.toString(cipherSuites));
      } catch (NoSuchAlgorithmException ignored) {

      }
    }
  }
Exemplo n.º 20
0
  /**
   * checks if a certificate is installed for given host:port
   *
   * @param context
   * @param host
   * @param port
   * @return
   */
  public IOException checkCertificate() {
    SSLSocketFactory factory = context.getSocketFactory();
    // System.out.println("Opening connection to " + host + ":" + port + "...");

    try {
      SSLSocket socket = (SSLSocket) factory.createSocket(host, port);
      socket.setSoTimeout(10000);
      socket.startHandshake();
      socket.close();
      return null;
    } catch (IOException e) {
      return e;
    }
  }
Exemplo n.º 21
0
 private void processHandshakeFailure(Socket raw) throws Exception {
   SSLContext context = SSLContext.getInstance("TLS");
   context.init(null, new TrustManager[] {UNTRUSTED_TRUST_MANAGER}, new SecureRandom());
   SSLSocketFactory sslSocketFactory = context.getSocketFactory();
   SSLSocket socket =
       (SSLSocket)
           sslSocketFactory.createSocket(
               raw, raw.getInetAddress().getHostAddress(), raw.getPort(), true);
   try {
     socket.startHandshake(); // we're testing a handshake failure
     throw new AssertionError();
   } catch (IOException expected) {
   }
   socket.close();
 }
Exemplo n.º 22
0
  public void connect() throws UnknownHostException, IOException {
    if (ssl_choice) {
      if (http_choice) {
        SSLSocket s = (SSLSocket) ssl_factory.createSocket(getAddress(), getPort());
        s.setTcpNoDelay(true);
        s.startHandshake();
        socket = s;
      } else {
        socket = SSLSocketFactory.getDefault().createSocket(getAddress(), getPort());
      }
    } else {
      socket = new Socket(getAddress(), getPort());
    }

    this.stream = socket.getOutputStream();
  }
Exemplo n.º 23
0
 @Override
 public Socket createSocket(Socket socket, String host, int port, boolean autoClose)
     throws IOException, UnknownHostException {
   SSLSocket sslSocket = (SSLSocket) socketFactory.createSocket(socket, host, port, autoClose);
   hostnameVerifier.verify(host, sslSocket);
   return sslSocket;
 }
Exemplo n.º 24
0
 private static SSLSocketFactory sslFactory(final boolean verify) {
   if (verify) {
     return (SSLSocketFactory) SSLSocketFactory.getDefault();
   } else {
     return (SSLSocketFactory) BlindSSLSocketFactory.getDefault();
   }
 }
Exemplo n.º 25
0
  private void connectToServer() {
    try {
      if (config.getServerSsl()) {
        this.connect(
            config.getServerAddress(),
            config.getServerPort(),
            config.getServerPassword(),
            config.getAcceptInvalidSsl()
                ? new UtilSSLSocketFactory().trustAllCertificates().disableDiffieHellman()
                : SSLSocketFactory.getDefault());
      } else {
        this.connect(config.getServerAddress(), config.getServerPort(), config.getServerPassword());
      }

      if (config.useNickserv()) {
        this.identify(config.getNickservPassword());
      }
    } catch (IOException | IrcException ex) {
      Logger.getLogger(this.getClass().getName()).log(Level.SEVERE, null, ex);
    }

    for (String channel : config.getChannels()) {
      this.joinChannel(channel);
    }
  }
 @Override
 public Socket createSocket(InetAddress inetaddress, int i, InetAddress inetaddress1, int j)
     throws IOException {
   SSLSocket result = (SSLSocket) factory.createSocket(inetaddress, i, inetaddress1, j);
   result.setEnabledProtocols(new String[] {"SSLv3"});
   return result;
 }
Exemplo n.º 27
0
  @Before
  public void setUp() throws Exception {
    server = mock(Server.class);
    container = mock(Container.class);
    when(server.getContainer()).thenReturn(container);
    systemEnvironment = mock(SystemEnvironment.class);
    when(systemEnvironment.getServerPort()).thenReturn(1234);
    when(systemEnvironment.getSslServerPort()).thenReturn(4567);
    when(systemEnvironment.keystore()).thenReturn(temporaryFolder.newFolder());
    when(systemEnvironment.truststore()).thenReturn(temporaryFolder.newFolder());
    when(systemEnvironment.getWebappContextPath()).thenReturn("context");
    when(systemEnvironment.getCruiseWar()).thenReturn("cruise.war");
    when(systemEnvironment.getParentLoaderPriority()).thenReturn(true);
    when(systemEnvironment.useCompressedJs()).thenReturn(true);
    when(systemEnvironment.useNioSslSocket()).thenReturn(true);
    when(systemEnvironment.getListenHost()).thenReturn("localhost");
    when(systemEnvironment.getParentLoaderPriority()).thenReturn(false);
    when(systemEnvironment.get(SystemEnvironment.RESPONSE_BUFFER_SIZE)).thenReturn(1000);
    when(systemEnvironment.get(SystemEnvironment.IDLE_TIMEOUT)).thenReturn(2000);
    when(systemEnvironment.getJettyConfigFile()).thenReturn(new File("foo"));

    sslSocketFactory = mock(SSLSocketFactory.class);
    when(sslSocketFactory.getSupportedCipherSuites()).thenReturn(new String[] {});
    goJetty6CipherSuite = mock(GoJetty6CipherSuite.class);
    when(goJetty6CipherSuite.getExcludedCipherSuites()).thenReturn(new String[] {"CS1", "CS2"});
    configuration = mock(Jetty6GoWebXmlConfiguration.class);
    jetty6Server =
        new Jetty6Server(
            systemEnvironment, "pwd", sslSocketFactory, server, goJetty6CipherSuite, configuration);
  }
 /**
  * Run before every test. Chooses a vin number and makes the server speak https.
  *
  * @throws Exception
  */
 @Override
 public void setUp() throws Exception {
   super.setUp();
   server = new MockWebServer();
   server.useHttps((SSLSocketFactory) SSLSocketFactory.getDefault(), true);
   collector.chooseBus("Ericsson$Vin_Num_001");
 }
Exemplo n.º 29
0
 @Override
 public Socket createSocket(
     final String host,
     final int port,
     final InetAddress localAddress,
     final int localPort,
     final HttpConnectionParams params)
     throws IOException, UnknownHostException, ConnectTimeoutException {
   final int timeout = params.getConnectionTimeout();
   if (timeout == 0) {
     Socket socket = createSocket(host, port, localAddress, localPort);
     if (socket instanceof SSLSocket) {
       ((SSLSocket) socket)
           .setEnabledProtocols(
               SSLUtils.getSupportedProtocols(((SSLSocket) socket).getEnabledProtocols()));
     }
     return socket;
   } else {
     final Socket s = ssf.createSocket();
     if (s instanceof SSLSocket) {
       ((SSLSocket) s)
           .setEnabledProtocols(
               SSLUtils.getSupportedProtocols(((SSLSocket) s).getEnabledProtocols()));
     }
     s.bind(new InetSocketAddress(localAddress, localPort));
     s.connect(new InetSocketAddress(host, port), timeout);
     return s;
   }
 }
  private static SocketFactory getSSLSocketFactory() {
    SocketFactory sslSocketFactory;
    try {
      final TrustManager[] trustAllCerts =
          new TrustManager[] {
            new X509TrustManager() {

              @Override
              public X509Certificate[] getAcceptedIssuers() {
                return null;
              }

              @Override
              public void checkServerTrusted(X509Certificate[] chain, String authType)
                  throws CertificateException {}

              @Override
              public void checkClientTrusted(X509Certificate[] chain, String authType)
                  throws CertificateException {}
            }
          };
      final SSLContext sslContext = SSLContext.getInstance("SSL");
      sslContext.init(null, trustAllCerts, new java.security.SecureRandom());
      // Create an ssl socket factory with our all-trusting manager
      sslSocketFactory = sslContext.getSocketFactory();
      return sslSocketFactory;
    } catch (Exception ex) {
      logger.warn(
          "Unable to build ssl socket factory without certificate validation, using default instead.",
          ex);
    }
    return SSLSocketFactory.getDefault();
  }