WrappedLogSSLSocket.java

/*
 * GovWay - A customizable API Gateway 
 * https://govway.org
 * 
 * Copyright (c) 2005-2024 Link.it srl (https://link.it). 
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 3, as published by
 * the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */


package org.openspcoop2.utils.transport.http;

import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.SocketAddress;
import java.net.SocketException;
import java.nio.channels.SocketChannel;
import java.security.cert.Certificate;

import javax.net.ssl.HandshakeCompletedEvent;
import javax.net.ssl.HandshakeCompletedListener;
import javax.net.ssl.SSLParameters;
import javax.net.ssl.SSLSession;
import javax.net.ssl.SSLSocket;

import org.openspcoop2.utils.certificate.CertificateUtils;
import org.openspcoop2.utils.resources.Charset;
import org.slf4j.Logger;

/**
 * WrappedLogSSLSocket
 *
 * @author Poli Andrea (apoli@link.it)
 * @author $Author$
 * @version $Rev$, $Date$
 */
public class WrappedLogSSLSocket extends SSLSocket {

	private SSLSocket delegate;
    private Logger log;
    private String prefixLog;
    private boolean clientCertificateConfigurated;
    private String clientCertificateConfiguratedPath;

    public WrappedLogSSLSocket(SSLSocket s, Logger log, String prefixLog, String clientCertificateConfigurated) {
    	this.delegate = s;
        this.log = log;
        this.prefixLog = prefixLog;
        this.clientCertificateConfiguratedPath = clientCertificateConfigurated;
        this.clientCertificateConfigurated = this.clientCertificateConfiguratedPath!=null;
    }

    @Override
	public OutputStream getOutputStream() throws IOException {
        return new WrappedLogOutputStream(this.delegate.getOutputStream(), this.log, this.prefixLog);
    }

    private static class WrappedLogOutputStream extends FilterOutputStream {

		private static final String CHARSET = Charset.UTF_8.getValue();
        private Logger log;
        private String prefixLog;
        private StringBuilder sb;

        public WrappedLogOutputStream(OutputStream out, Logger log, String prefixLog) {
            super(out);
            this.log = log;
            this.prefixLog = prefixLog;
            this.sb = new StringBuilder(this.prefixLog);
        }

        @Override
		public void write(byte[] b, int off, int len)
                throws IOException {
        	this.sb.append(new String(b, off, len, CHARSET));
            this.out.write(b, off, len);
        }

        @Override
		public void write(int b) throws IOException {
        	this.sb.append(b);
            this.out.write(b);
        }
        
        @Override
		public void write(byte[] b) throws IOException {
        	if(b!=null) {
        		this.sb.append(new String(b));
        		this.out.write(b);
        	}
		}

        @Override
        public void close() throws IOException {
            this.log.info(this.sb.toString());
            super.close();
        }
        
		@Override
		public void flush() throws IOException {
			super.flush();
		}
    }
  
   	@Override
   	public void startHandshake() throws IOException {
   		StringBuilder sb = new StringBuilder(this.prefixLog);
   		sb.append("startHandshake");
   		this.log.info(sb.toString());
   		this.delegate.startHandshake();
   	}
    
    private WrappedLogHandshakeCompletedListener handshakeCompletedListener = null;
	@Override
   	public void addHandshakeCompletedListener(HandshakeCompletedListener listener) {
    	this.handshakeCompletedListener = new WrappedLogHandshakeCompletedListener(this, listener);
    	this.delegate.addHandshakeCompletedListener(this.handshakeCompletedListener);
   	}
   	@Override
   	public void removeHandshakeCompletedListener(HandshakeCompletedListener listener) {
   		this.delegate.removeHandshakeCompletedListener(this.handshakeCompletedListener);
   	}
    
    private static class WrappedLogHandshakeCompletedListener implements HandshakeCompletedListener {

    	private HandshakeCompletedListener delegate;
    	private WrappedLogSSLSocket sslSocket;
        private Logger log;
        private String prefixLog;
        private StringBuilder sb;
        private StringBuilder sbError;
            	
		public WrappedLogHandshakeCompletedListener(WrappedLogSSLSocket sslSocket, HandshakeCompletedListener delegate) {
    		this.delegate = delegate;
    		this.sslSocket = sslSocket;
    		this.log = sslSocket.log;
    		this.prefixLog = sslSocket.prefixLog;
    		this.sb = new StringBuilder(this.prefixLog);
    		this.sbError = new StringBuilder(); // prefisso aggiunto dopo
    	}
    	
		@Override
		public void handshakeCompleted(HandshakeCompletedEvent event) {
			this.delegate.handshakeCompleted(event);
			
//			boolean needClientAuth = this.sslSocket.getNeedClientAuth();
//			boolean useClientMode = this.sslSocket.getUseClientMode();
//			boolean wClientAuth = this.sslSocket.getWantClientAuth();
			
			this.sb.append("handshakeCompleted");
			if(event!=null) {
				
				if(event.getCipherSuite()!=null) {
					this.sb.append("\nCipherSuite: "+event.getCipherSuite());
				}
				
				if(event.getLocalPrincipal()!=null) {
					this.sb.append("\nLocalPrincipal: "+event.getLocalPrincipal().getName());
				}
				else if(this.sslSocket.clientCertificateConfigurated){
					this.sbError.append("LocalPrincipal");
				}
				if(event.getLocalCertificates()!=null && event.getLocalCertificates().length>0) {
					this.sb.append("\nLocalCertificates: "+event.getLocalCertificates().length);
					this.sb.append("\n");
					print(event.getLocalCertificates(), "LocalCertificate");
				}
				else if(this.sslSocket.clientCertificateConfigurated){
					if(this.sbError.length()>0) {
						this.sbError.append(",");
					}
					this.sbError.append("LocalCertificates");
				}
				
				try {
					if(event.getPeerPrincipal()!=null) {
						this.sb.append("\nPeerPrincipal: "+event.getPeerPrincipal().getName());
					}
				}catch(Exception e) {
					this.sb.append("\nPeerPrincipal: "+e.getMessage());
				}
				try {
					if(event.getPeerCertificates()!=null && event.getPeerCertificates().length>0) {
						this.sb.append("\nPeerCertificates: "+event.getPeerCertificates().length);
						this.sb.append("\n");
						print(event.getPeerCertificates(), "PeerCertificate");
					}
				}catch(Exception e) {
					this.sb.append("\nPeerCertificates: "+e.getMessage());
				}
				
			}
			
			this.log.info(this.sb.toString());
			if(this.sbError.length()>0) {
				this.sbError.append(" non inviato, nonostante sia configurato un certificato client (keystore: "+this.sslSocket.clientCertificateConfiguratedPath+")");
				this.log.error(this.prefixLog+this.sbError.toString());
			}
		}
		
		private void print(Certificate [] certs, String tipo) {
			for (int j = 0; j < certs.length; j++) {
				if(certs[j] instanceof java.security.cert.X509Certificate) {
					java.security.cert.X509Certificate x509 = (java.security.cert.X509Certificate) certs[j];
					CertificateUtils.printCertificate(this.sb, x509, tipo+"-"+j, true);
				}
				else {
					this.sb.append("#### Certificate["+tipo+"-"+j+"]\n");
					this.sb.append("Certificate["+tipo+"-"+j+"] non è X509");
				}
			}
		}
   	
    }
    

   	@Override
   	public boolean getEnableSessionCreation() {
   		boolean returnValue = this.delegate.getEnableSessionCreation(); 
   		StringBuilder sb = new StringBuilder(this.prefixLog);
   		sb.append("getEnableSessionCreation=").append(returnValue);
   		this.log.info(sb.toString());
   		return returnValue;
   	}

   	@Override
   	public String[] getEnabledCipherSuites() {
   		String[] cipherSuites = this.delegate.getEnabledCipherSuites();
   		if(cipherSuites!=null && cipherSuites.length>0) {
   			StringBuilder sb = new StringBuilder(this.prefixLog);
   			sb.append("EnabledCipherSuites: ");
   			for (String cs : cipherSuites) {
   				if(sb.length()>0) {
   					sb.append(",");
   				}
   				sb.append(cs);
			}
   			this.log.info(sb.toString());
   		} 
   		return cipherSuites;
   	}
   	
   	@Override
   	public String[] getSupportedCipherSuites() {
   		String[] cipherSuites = this.delegate.getSupportedCipherSuites();
   		if(cipherSuites!=null && cipherSuites.length>0) {
   			StringBuilder sb = new StringBuilder(this.prefixLog);
   			sb.append("SupportedCipherSuites: ");
   			for (String cs : cipherSuites) {
   				if(sb.length()>0) {
   					sb.append(",");
   				}
   				sb.append(cs);
			}
   			this.log.info(sb.toString());
   		} 
   		return cipherSuites;
   	}

   	@Override
   	public String[] getEnabledProtocols() {
   		String[] enabledProtocols = this.delegate.getEnabledProtocols();
   		if(enabledProtocols!=null && enabledProtocols.length>0) {
   			StringBuilder sb = new StringBuilder(this.prefixLog);		
   			sb.append("EnabledProtocols: ");
   			for (String ep : enabledProtocols) {
   				if(sb.length()>0) {
   					sb.append(",");
   				}
   				sb.append(ep);
			}
   			this.log.info(sb.toString());
   		} 
   		return enabledProtocols;
   	}
   	
   	@Override
   	public String[] getSupportedProtocols() {
   		String[] supportedProtocols = this.delegate.getSupportedProtocols();
   		if(supportedProtocols!=null && supportedProtocols.length>0) {
   			StringBuilder sb = new StringBuilder(this.prefixLog);		
   			sb.append("SupportedProtocols: ");
   			for (String ep : supportedProtocols) {
   				if(sb.length()>0) {
   					sb.append(",");
   				}
   				sb.append(ep);
			}
   			this.log.info(sb.toString());
   		} 
   		return supportedProtocols;
   	}

   	@Override
   	public boolean getNeedClientAuth() {
   		boolean returnValue = this.delegate.getNeedClientAuth(); 
   		StringBuilder sb = new StringBuilder(this.prefixLog);
   		sb.append("getNeedClientAuth=").append(returnValue);
   		this.log.info(sb.toString());
   		return returnValue;
   	}
   	
   	@Override
   	public boolean getUseClientMode() {
   		boolean returnValue = this.delegate.getUseClientMode(); 
   		StringBuilder sb = new StringBuilder(this.prefixLog);
   		sb.append("getUseClientMode=").append(returnValue);
   		this.log.info(sb.toString());
   		return returnValue;
   	}
   	
   	@Override
   	public boolean getWantClientAuth() {
   		boolean returnValue = this.delegate.getWantClientAuth(); 
   		StringBuilder sb = new StringBuilder(this.prefixLog);
   		sb.append("getWantClientAuth=").append(returnValue);
   		this.log.info(sb.toString());
   		return returnValue;
   	}
   	
   	@Override
   	public SSLSession getHandshakeSession() {
   		return this.delegate.getHandshakeSession();
   	}

   	@Override
   	public SSLParameters getSSLParameters() {
   		return this.delegate.getSSLParameters();
   	}

   	@Override
   	public SSLSession getSession() {
   		return this.delegate.getSession();
   	}

   	@Override
   	public void setEnableSessionCreation(boolean flag) {
   		this.delegate.setEnableSessionCreation(flag);
   	}

   	@Override
   	public void setEnabledCipherSuites(String[] suites) {
   		this.delegate.setEnabledCipherSuites(suites);
   	}

   	@Override
   	public void setEnabledProtocols(String[] protocols) {
   		this.delegate.setEnabledProtocols(protocols);
   	}

   	@Override
   	public void setNeedClientAuth(boolean need) {
   		this.delegate.setNeedClientAuth(need);
   	}

   	@Override
   	public void setSSLParameters(SSLParameters params) {
   		this.delegate.setSSLParameters(params);
   	}

   	@Override
   	public void setUseClientMode(boolean mode) {
   		this.delegate.setUseClientMode(mode);
   	}

   	@Override
   	public void setWantClientAuth(boolean want) {
   		this.delegate.setWantClientAuth(want);
   	}

   	// METODI NON MODIFICATI
   	
   	@Override
	public void connect(SocketAddress endpoint) throws IOException {
		this.delegate.connect(endpoint);
	}

	@Override
	public void connect(SocketAddress endpoint, int timeout) throws IOException {
		this.delegate.connect(endpoint, timeout);
	}

	@Override
	public void bind(SocketAddress bindpoint) throws IOException {
		this.delegate.bind(bindpoint);
	}

	@Override
	public InetAddress getInetAddress() {
		return this.delegate.getInetAddress();
	}

	@Override
	public InetAddress getLocalAddress() {
		return this.delegate.getLocalAddress();
	}

	@Override
	public int getPort() {
		return this.delegate.getPort();
	}

	@Override
	public int getLocalPort() {
		return this.delegate.getLocalPort();
	}

	@Override
	public SocketAddress getRemoteSocketAddress() {
		return this.delegate.getRemoteSocketAddress();
	}

	@Override
	public SocketAddress getLocalSocketAddress() {
		return this.delegate.getLocalSocketAddress();
	}

	@Override
	public SocketChannel getChannel() {
		return this.delegate.getChannel();
	}

	@Override
	public InputStream getInputStream() throws IOException {
		return this.delegate.getInputStream();
	}

	@Override
	public void setTcpNoDelay(boolean on) throws SocketException {
		this.delegate.setTcpNoDelay(on);
	}

	@Override
	public boolean getTcpNoDelay() throws SocketException {
		return this.delegate.getTcpNoDelay();
	}

	@Override
	public void setSoLinger(boolean on, int linger) throws SocketException {
		this.delegate.setSoLinger(on, linger);
	}

	@Override
	public int getSoLinger() throws SocketException {
		return this.delegate.getSoLinger();
	}

	@Override
	public void sendUrgentData(int data) throws IOException {
		this.delegate.sendUrgentData(data);
	}

	@Override
	public void setOOBInline(boolean on) throws SocketException {
		this.delegate.setOOBInline(on);
	}

	@Override
	public boolean getOOBInline() throws SocketException {
		return this.delegate.getOOBInline();
	}

	@Override
	public synchronized void setSoTimeout(int timeout) throws SocketException {
		this.delegate.setSoTimeout(timeout);
	}

	@Override
	public synchronized int getSoTimeout() throws SocketException {
		return this.delegate.getSoTimeout();
	}

	@Override
	public synchronized void setSendBufferSize(int size) throws SocketException {
		this.delegate.setSendBufferSize(size);
	}

	@Override
	public synchronized int getSendBufferSize() throws SocketException {
		return this.delegate.getSendBufferSize();
	}

	@Override
	public synchronized void setReceiveBufferSize(int size) throws SocketException {
		this.delegate.setReceiveBufferSize(size);
	}

	@Override
	public synchronized int getReceiveBufferSize() throws SocketException {
		return this.delegate.getReceiveBufferSize();
	}

	@Override
	public void setKeepAlive(boolean on) throws SocketException {
		this.delegate.setKeepAlive(on);
	}

	@Override
	public boolean getKeepAlive() throws SocketException {
		return this.delegate.getKeepAlive();
	}

	@Override
	public void setTrafficClass(int tc) throws SocketException {
		this.delegate.setTrafficClass(tc);
	}

	@Override
	public int getTrafficClass() throws SocketException {
		return this.delegate.getTrafficClass();
	}

	@Override
	public void setReuseAddress(boolean on) throws SocketException {
		this.delegate.setReuseAddress(on);
	}

	@Override
	public boolean getReuseAddress() throws SocketException {
		return this.delegate.getReuseAddress();
	}

	@Override
	public synchronized void close() throws IOException {
		this.delegate.close();
	}

	@Override
	public void shutdownInput() throws IOException {
		this.delegate.shutdownInput();
	}

	@Override
	public void shutdownOutput() throws IOException {
		this.delegate.shutdownOutput();
	}

	@Override
	public String toString() {
		return this.delegate.toString();
	}

	@Override
	public boolean isConnected() {
		return this.delegate.isConnected();
	}

	@Override
	public boolean isBound() {
		return this.delegate.isBound();
	}

	@Override
	public boolean isClosed() {
		return this.delegate.isClosed();
	}

	@Override
	public boolean isInputShutdown() {
		return this.delegate.isInputShutdown();
	}

	@Override
	public boolean isOutputShutdown() {
		return this.delegate.isOutputShutdown();
	}

	@Override
	public void setPerformancePreferences(int connectionTime, int latency, int bandwidth) {
		this.delegate.setPerformancePreferences(connectionTime, latency, bandwidth);
	}

	@Override
	public int hashCode() {
		return this.delegate.hashCode();
	}

	@Override
	public boolean equals(Object obj) {
		return this.delegate.equals(obj);
	}
}