Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.commons.net.pop3; import java.io.BufferedWriter; import java.io.IOException; import java.io.InputStreamReader; import java.io.OutputStreamWriter; import javax.net.ssl.KeyManager; import javax.net.ssl.SSLContext; import javax.net.ssl.SSLException; import javax.net.ssl.SSLSocket; import javax.net.ssl.SSLSocketFactory; import javax.net.ssl.TrustManager; import org.apache.commons.net.io.CRLFLineReader; import org.apache.commons.net.util.SSLContextUtils; /** * POP3 over SSL processing. Copied from FTPSClient.java and modified to suit POP3. * If implicit mode is selected (NOT the default), SSL/TLS negotiation starts right * after the connection has been established. In explicit mode (the default), SSL/TLS * negotiation starts when the user calls execTLS() and the server accepts the command. * Implicit usage: * POP3SClient c = new POP3SClient(true); * c.connect("127.0.0.1", 995); * Explicit usage: * POP3SClient c = new POP3SClient(); * c.connect("127.0.0.1", 110); * if (c.execTLS()) { /rest of the commands here/ } * @since 3.0 */ public class POP3SClient extends POP3Client { // from http://www.iana.org/assignments/port-numbers // pop3s 995/tcp pop3 protocol over TLS/SSL (was spop3) // pop3s 995/udp pop3 protocol over TLS/SSL (was spop3) private static final int DEFAULT_POP3S_PORT = 995; /** Default secure socket protocol name, like TLS */ private static final String DEFAULT_PROTOCOL = "TLS"; /** The security mode. True - Implicit Mode / False - Explicit Mode. */ private final boolean isImplicit; /** The secure socket protocol to be used, like SSL/TLS. */ private final String protocol; /** The context object. */ private SSLContext context = null; /** The cipher suites. SSLSockets have a default set of these anyway, so no initialization required. */ private String[] suites = null; /** The protocol versions. */ private String[] protocols = //null; null;//{"SSLv2", "SSLv3", "TLSv1", "TLSv1.1", "SSLv2Hello"}; /** The FTPS {@link TrustManager} implementation, default null. */ private TrustManager trustManager = null; /** The {@link KeyManager}, default null. */ private KeyManager keyManager = null; /** * Constructor for POP3SClient, using {@link #DEFAULT_PROTOCOL} i.e. TLS * Sets security mode to explicit. */ public POP3SClient() { this(DEFAULT_PROTOCOL, false); } /** * Constructor for POP3SClient, using {@link #DEFAULT_PROTOCOL} i.e. TLS * @param implicit The security mode, {@code true} for implicit, {@code false} for explicit */ public POP3SClient(boolean implicit) { this(DEFAULT_PROTOCOL, implicit); } /** * Constructor for POP3SClient. * Sets security mode to explicit. * @param proto the protocol. */ public POP3SClient(String proto) { this(proto, false); } /** * Constructor for POP3SClient. * @param proto the protocol. * @param implicit The security mode, {@code true} for implicit, {@code false} for explicit */ public POP3SClient(String proto, boolean implicit) { this(proto, implicit, null); } /** * Constructor for POP3SClient. * Sets the default port to {@link #DEFAULT_POP3S_PORT} - 995 - if using implicit mode * @param proto the protocol. * @param implicit The security mode, {@code true} for implicit, {@code false} for explicit * @param ctx the context to be used */ public POP3SClient(String proto, boolean implicit, SSLContext ctx) { super(); protocol = proto; isImplicit = implicit; context = ctx; if (isImplicit) { setDefaultPort(DEFAULT_POP3S_PORT); } } /** * Constructor for POP3SClient, using {@link #DEFAULT_PROTOCOL} i.e. TLS * @param implicit The security mode, {@code true} for implicit, {@code false} for explicit * @param ctx A pre-configured SSL Context. */ public POP3SClient(boolean implicit, SSLContext ctx) { this(DEFAULT_PROTOCOL, implicit, ctx); } /** * Constructor for POP3SClient, using {@link #DEFAULT_PROTOCOL} - TLS - and isImplicit = false * @param context A pre-configured SSL Context. * @see #POP3SClient(boolean, SSLContext) */ public POP3SClient(SSLContext context) { this(false, context); } /** * Because there are so many connect() methods, * the _connectAction_() method is provided as a means of performing * some action immediately after establishing a connection, * rather than reimplementing all of the connect() methods. * @throws IOException If it is thrown by _connectAction_(). * @see org.apache.commons.net.SocketClient#_connectAction_() */ @Override protected void _connectAction_() throws IOException { // Implicit mode. if (isImplicit) { performSSLNegotiation(); } super._connectAction_(); // Explicit mode - don't do anything. The user calls execTLS() } /** * Performs a lazy init of the SSL context. * @throws IOException When could not initialize the SSL context. */ private void initSSLContext() throws IOException { if (context == null) { context = SSLContextUtils.createSSLContext(protocol, getKeyManager(), getTrustManager()); } } /** * SSL/TLS negotiation. Acquires an SSL socket of a * connection and carries out handshake processing. * @throws IOException If server negotiation fails. */ private void performSSLNegotiation() throws IOException { initSSLContext(); SSLSocketFactory ssf = context.getSocketFactory(); String ip = getRemoteAddress().getHostAddress(); int port = getRemotePort(); SSLSocket socket = (SSLSocket) ssf.createSocket(_socket_, ip, port, true); socket.setEnableSessionCreation(true); socket.setUseClientMode(true); if (protocols != null) { socket.setEnabledProtocols(protocols); } if (suites != null) { socket.setEnabledCipherSuites(suites); } socket.startHandshake(); _socket_ = socket; _input_ = socket.getInputStream(); _output_ = socket.getOutputStream(); _reader = new CRLFLineReader(new InputStreamReader(_input_, _DEFAULT_ENCODING)); _writer = new BufferedWriter(new OutputStreamWriter(_output_, _DEFAULT_ENCODING)); } /** * Get the {@link KeyManager} instance. * @return The current {@link KeyManager} instance. */ private KeyManager getKeyManager() { return keyManager; } /** * Set a {@link KeyManager} to use. * @param newKeyManager The KeyManager implementation to set. * @see org.apache.commons.net.util.KeyManagerUtils */ public void setKeyManager(KeyManager newKeyManager) { keyManager = newKeyManager; } /** * Controls which particular cipher suites are enabled for use on this * connection. Called before server negotiation. * @param cipherSuites The cipher suites. */ public void setEnabledCipherSuites(String[] cipherSuites) { suites = new String[cipherSuites.length]; System.arraycopy(cipherSuites, 0, suites, 0, cipherSuites.length); } /** * Returns the names of the cipher suites which could be enabled * for use on this connection. * When the underlying {@link java.net.Socket Socket} is not an {@link SSLSocket} instance, returns null. * @return An array of cipher suite names, or <code>null</code>. */ public String[] getEnabledCipherSuites() { if (_socket_ instanceof SSLSocket) { return ((SSLSocket) _socket_).getEnabledCipherSuites(); } return null; } /** * Controls which particular protocol versions are enabled for use on this * connection. I perform setting before a server negotiation. * @param protocolVersions The protocol versions. */ public void setEnabledProtocols(String[] protocolVersions) { protocols = new String[protocolVersions.length]; System.arraycopy(protocolVersions, 0, protocols, 0, protocolVersions.length); } /** * Returns the names of the protocol versions which are currently * enabled for use on this connection. * When the underlying {@link java.net.Socket Socket} is not an {@link SSLSocket} instance, returns null. * @return An array of protocols, or <code>null</code>. */ public String[] getEnabledProtocols() { if (_socket_ instanceof SSLSocket) { return ((SSLSocket) _socket_).getEnabledProtocols(); } return null; } /** * The TLS command execution. * @throws SSLException If the server reply code is not positive. * @throws IOException If an I/O error occurs while sending * the command or performing the negotiation. * @return TRUE if the command and negotiation succeeded. */ public boolean execTLS() throws SSLException, IOException { if (sendCommand("STLS") != POP3Reply.OK) { return false; //throw new SSLException(getReplyString()); } performSSLNegotiation(); return true; } /** * Get the currently configured {@link TrustManager}. * @return A TrustManager instance. */ public TrustManager getTrustManager() { return trustManager; } /** * Override the default {@link TrustManager} to use. * @param newTrustManager The TrustManager implementation to set. * @see org.apache.commons.net.util.TrustManagerUtils */ public void setTrustManager(TrustManager newTrustManager) { trustManager = newTrustManager; } } /* kate: indent-width 4; replace-tabs on; */