sdnr/wireless-transport/code-Carbon-SR1/apps/devicemanager/impl/src/main/java/org/opendaylight/mwtn/dcaeConnector/test/HttpsClient.java

   1 /**
   2  *
   3  */
   4 package org.opendaylight.mwtn.dcaeConnector.test;
   5
   6 import java.io.BufferedReader;
   7 import java.io.File;
   8 import java.io.IOException;
   9 import java.io.InputStreamReader;
  10 import java.net.MalformedURLException;
  11 import java.net.URL;
  12 import java.security.KeyManagementException;
  13 import java.security.NoSuchAlgorithmException;
  14 import java.security.SecureRandom;
  15 import java.security.cert.Certificate;
  16 import java.security.cert.X509Certificate;
  17
  18 import javax.net.ssl.HttpsURLConnection;
  19 import javax.net.ssl.SSLContext;
  20 import javax.net.ssl.SSLPeerUnverifiedException;
  21 import javax.net.ssl.SSLSocketFactory;
  22 import javax.net.ssl.TrustManager;
  23 import javax.net.ssl.X509TrustManager;
  24
  25 import org.opendaylight.mwtn.dcaeConnector.impl.DcaeProviderClient;
  26
  27 /**
  28  * @author herbert
  29  *
  30  */
  31 public class HttpsClient{
  32
  33     private static final MyLogger LOG = MyLogger.getLogger(DcaeProviderClient.class);
  34
  35     void test() {
  36
  37         TrustManager tm = new X509TrustManager() {
  38
  39             @Override
  40             public void checkClientTrusted(X509Certificate[] chain, String authType)
  41                     throws java.security.cert.CertificateException {
  42                 //do nothing, you're the client
  43             }
  44
  45             @Override
  46             public void checkServerTrusted(X509Certificate[] chain, String authType)
  47                     throws java.security.cert.CertificateException {
  48                 /* chain[chain.length -1] is the candidate for the
  49                  * root certificate.
  50                  * Look it up to see whether it's in your list.
  51                  * If not, ask the user for permission to add it.
  52                  * If not granted, reject.
  53                  * Validate the chain using CertPathValidator and
  54                  * your list of trusted roots.
  55                  */
  56             }
  57
  58             @Override
  59             public X509Certificate[] getAcceptedIssuers() {
  60                    //also only relevant for servers
  61                  return null;
  62             }
  63         };
  64
  65         TrustManager tml[] = new TrustManager[1];
  66         tml[0] = tm;
  67
  68
  69         try {
  70             SSLContext ctx = SSLContext.getInstance("TLS");
  71             ctx.init(null, tml, null);
  72             @SuppressWarnings("unused")
  73                         SSLSocketFactory sslF = ctx.getSocketFactory();
  74
  75         } catch (NoSuchAlgorithmException | KeyManagementException e) {
  76             e.printStackTrace();
  77         }
  78
  79
  80     };
  81
  82     void setupAllTrustingManager() {
  83         // Create a trust manager that does not validate certificate chains
  84         TrustManager[] trustAllCerts = new TrustManager[]{new X509TrustManager(){
  85             @Override
  86             public X509Certificate[] getAcceptedIssuers(){return null;}
  87             @Override
  88             public void checkClientTrusted(X509Certificate[] certs, String authType){}
  89             @Override
  90             public void checkServerTrusted(X509Certificate[] certs, String authType){}
  91         }};
  92
  93         // Install the all-trusting trust manager
  94         try {
  95             SSLContext sc = SSLContext.getInstance("TLS");
  96             sc.init(null, trustAllCerts, new SecureRandom());
  97             HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
  98         } catch (Exception e) {
  99             ;
 100         }
 101     }
 102
 103     void testIt(String https_url, String keyStoreName, String keyStorePassword){
 104
 105         LOG.info("Message to: {} begin.", https_url);
 106
 107         if (https_url.equals("off")) {
 108             LOG.info("Function switched off");
 109             return;
 110         }
 111
 112         /*
 113         KeyManagerFactory keyManagerFactory = null;
 114
 115         try {
 116             KeyStore ks = KeyStore.getInstance("JKS");
 117             FileInputStream in = new FileInputStream(keyStoreName);
 118             ks.load(in, keyStorePassword.toCharArray());
 119
 120             CertificateFactory certFactory = CertificateFactory.getInstance("X.509");
 121             FileInputStream in2 = new FileInputStream("etc/eventprovider.cert");
 122             X509Certificate cert = (X509Certificate)certFactory.generateCertificate(in2);
 123
 124             KeyStore.Entry newEntry = new KeyStore.TrustedCertificateEntry(cert);
 125             ks.setEntry("someAlias", newEntry, null);
 126
 127             keyManagerFactory = KeyManagerFactory.getInstance("X509");
 128             keyManagerFactory.init(ks, "yourKeyStorePassword".toCharArray());
 129
 130         } catch (KeyStoreException e1) {
 131             LOG.info("Exception: {}", e1.getMessage());
 132         } catch (FileNotFoundException e1) {
 133             LOG.info("Exception: {}", e1.getMessage());
 134         } catch (NoSuchAlgorithmException e1) {
 135             LOG.info("Exception: {}", e1.getMessage());
 136         } catch (CertificateException e1) {
 137             LOG.info("Exception: {}", e1.getMessage());
 138         } catch (IOException e1) {
 139             LOG.info("Exception: {}", e1.getMessage());
 140         } catch (UnrecoverableKeyException e1) {
 141             LOG.info("Exception: {}", e1.getMessage());
 142         }
 143
 144         // Create a trust manager that does not validate certificate chains
 145         TrustManager[] trustAllCerts = new TrustManager[]{new X509TrustManager(){
 146             @Override
 147             public X509Certificate[] getAcceptedIssuers(){return null;}
 148             @Override
 149             public void checkClientTrusted(X509Certificate[] certs, String authType){}
 150             @Override
 151             public void checkServerTrusted(X509Certificate[] certs, String authType){}
 152         }};
 153          */
 154         File file = new File(keyStoreName);
 155         LOG.info("Setup keystore begin "+keyStoreName+" "+keyStorePassword+" Exists: "+file.exists());
 156
 157         System.setProperty("javax.net.debug","ssl");
 158         System.setProperty("javax.net.ssl.keyStoreType", "jks");
 159         System.setProperty("javax.net.ssl.keyStore", keyStoreName);
 160         System.setProperty("javax.net.ssl.keyStorePassword", keyStorePassword);
 161
 162         LOG.info("Setup keystore complete");
 163
 164         javax.net.ssl.HttpsURLConnection.setDefaultHostnameVerifier(
 165                 (hostname, sslSession) -> {
 166                  LOG.info("Hostname check {}", hostname);
 167                  return true;
 168               });
 169         LOG.info("Setup name verifier.");
 170
 171         try {
 172             /*
 173             SSLContext sslContext = SSLContext.getInstance("TLS");
 174             sslContext.init(keyManagerFactory.getKeyManagers(), trustAllCerts, null);
 175             SSLContext.setDefault(sslContext);
 176             */
 177
 178             URL url = new URL(https_url);
 179             LOG.info("Url object created");
 180
 181             HttpsURLConnection con = (HttpsURLConnection)url.openConnection();
 182
 183             LOG.info("openConnection");
 184
 185             //dumpl all cert info
 186             print_https_cert(con);
 187
 188             //dump all the content
 189             print_content(con);
 190
 191         } catch (MalformedURLException e) {
 192             LOG.info("Exception: {}", e.getMessage());
 193         } catch (IOException e) {
 194             LOG.info("Exception: {}", e.getMessage());
 195         }
 196
 197         LOG.info("Message to: {} end.", https_url);
 198
 199     }
 200
 201     private void print_https_cert(HttpsURLConnection con){
 202
 203         StringBuffer logMsg = new StringBuffer();
 204
 205         if(con!=null){
 206
 207             try {
 208                 logMsg.append("Response Code : " + con.getResponseCode());
 209                 logMsg.append("Cipher Suite : " + con.getCipherSuite());
 210                 logMsg.append("\n");
 211
 212                 Certificate[] certs = con.getServerCertificates();
 213                 for(Certificate cert : certs){
 214                     logMsg.append("Cert Type : " + cert.getType());
 215                     logMsg.append("Cert Hash Code : " + cert.hashCode());
 216                     logMsg.append("Cert Public Key Algorithm : " + cert.getPublicKey().getAlgorithm());
 217                     logMsg.append("Cert Public Key Format : " + cert.getPublicKey().getFormat());
 218                     logMsg.append("\n");
 219                 }
 220
 221
 222             } catch (SSLPeerUnverifiedException e) {
 223                 logMsg.append(e.getMessage());
 224             } catch (IOException e){
 225                 logMsg.append(e.getMessage());
 226             }
 227         } else {
 228             logMsg.append("No connection");
 229         }
 230
 231         LOG.info(logMsg.toString());
 232    }
 233
 234     private void print_content(HttpsURLConnection con){
 235
 236          StringBuffer logMsg = new StringBuffer();
 237          if(con!=null){
 238
 239             try {
 240
 241
 242                 logMsg.append("****** Content of the URL ********");
 243                 BufferedReader br =
 244                         new BufferedReader(
 245                                 new InputStreamReader(con.getInputStream()));
 246
 247                 String input;
 248
 249                 while ((input = br.readLine()) != null){
 250                     logMsg.append(input);
 251                 }
 252                 br.close();
 253
 254
 255             } catch (IOException e) {
 256                 logMsg.append(e.getMessage());
 257             }
 258
 259         } else {
 260             logMsg.append("No connection");
 261         }
 262
 263         LOG.info(logMsg.toString());
 264
 265     }
 266
 267     private static class MyLogger {
 268
 269         private void out( String s, Object...oList) {
 270             StringBuffer sb = new StringBuffer();
 271             sb.append("-------> ");
 272             sb.append(s);
 273             sb.append(" P: ");
 274             int t = 0;
 275             for (Object o: oList) {
 276                 sb.append("[");
 277                 sb.append(t++);
 278                 sb.append("](");
 279                 sb.append(o.toString());
 280                 sb.append(")");
 281             }
 282             System.out.println(sb.toString());
 283         }
 284
 285         void info( String s, Object...o) {
 286             out(s,o);
 287         }
 288
 289         static MyLogger getLogger(Class<?> c) {
 290             return new MyLogger();
 291         }
 292     }
 293 }