android에서 멀티 엔티티와 함께 ​​SSL을 사용하는 방법

Question

다음은 웹 URL에 데이터를 POST하기 위해 appache를 사용하는 코드입니다. 백엔드와 상호 작용하는 응용 프로그램의 주요 논리는 데이터를 URL (PHP)에 게시하고 PHP가 데이터베이스 등을 사용하기위한 로직을 실행한다는 것입니다. ......

SSL을 구현하는 방법을 알고 있습니까? 아니면 PHP 프로그램을 변경하고, "http"대신 "https"로 시작하는 웹 사이트의 Android 측 POST를 변경해야합니까? 감사합니다

protected class FormHandler extends AsyncTask<Object, Void, JSONObject> { 
     private FormListener listener; 
     private ProgressDialog pd; 

     public FormHandler() { 
      pd = ProgressDialog.show(ctx,"", ctx.getResources().getString(R.string.loading),true); 
     } 

     @Override 
     protected JSONObject doInBackground(Object... params) { 

      MultipartEntityBuilder builder = MultipartEntityBuilder.create(); 
      builder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE); 

      listener = (FormListener) params[0]; 

      // Wordpress default parameter 
      builder.addTextBody("_wpcf7", "610"); 
      builder.addTextBody("_wpcf7_version", "3.7.2"); 
      builder.addTextBody("_wpcf7_locale", "en_US"); 
      builder.addTextBody("_wpcf7_unit_tag", "wpcf7-f610-p611-o1"); 
      builder.addTextBody("_wpnonce", "4ddf1f1d07"); 
      builder.addPart("your-firstname", new StringBody((String) params[1], ContentType.create("text/plain", Consts.UTF_8))); 
      builder.addPart("your-lastname", new StringBody((String) params[2], ContentType.create("text/plain", Consts.UTF_8))); 
      builder.addPart("your-email", new StringBody((String) params[3], ContentType.create("text/plain", Consts.UTF_8))); 
      builder.addPart("your-question", new StringBody((String) params[4], ContentType.create("text/plain", Consts.UTF_8))); 
      builder.addPart("your-details", new StringBody((String) params[5], ContentType.create("text/plain", Consts.UTF_8))); 
      builder.addTextBody("_wpcf7_is_ajax_call", "1"); 

      // Set timeout (1 minute) 
      HttpParams httpParameters = new BasicHttpParams(); 
      HttpConnectionParams.setConnectionTimeout(httpParameters, Constant.uploadTimeout); 
      HttpConnectionParams.setSoTimeout(httpParameters, Constant.uploadTimeout); 

      HttpClient client = new DefaultHttpClient(httpParameters); 
      HttpPost post = new HttpPost(Constant.formURL); 
      HttpEntity entity = builder.build(); 
      post.setEntity(entity); 

      try { 
       HttpResponse response = client.execute(post); 
       BufferedReader reader = new BufferedReader(new InputStreamReader(response.getEntity().getContent(), "UTF-8")); 
       StringBuilder strBuild = new StringBuilder(); 

       for (String line = null; (line = reader.readLine()) != null;) { 
        strBuild.append(line).append("\n"); 
       } 

       String result = strBuild.toString().replace("<textarea>", "").replace("</textarea>", ""); 

       JSONTokener tokener = new JSONTokener(result); 

       if (tokener != null) 
        return (new JSONObject(tokener)); 

      } catch (ClientProtocolException e) { 
       // TODO Auto-generated catch block 
       e.printStackTrace(); 
      } catch (IOException e) { 
       // TODO Auto-generated catch block 
       e.printStackTrace(); 
      } catch (JSONException e) { 
       // TODO Auto-generated catch block 
       e.printStackTrace(); 
      } 
      return null; 
     } 

     @Override 
     protected void onPostExecute(JSONObject result) { 
      if(pd != null) { 
       pd.dismiss(); 
      } 
      if(result != null) { 
       try { 
        if (result.getString("mailSent").equals("true")) 
         listener.submitComplete(); 
        else 
         listener.submitFailure(); 
       } catch (JSONException e) { 
        listener.submitFailure(); 
       } 
      } else { 
       Utility.showErrorDialog(ctx, getResources().getString(R.string.sys_info), getResources().getString(R.string.err_submit), getResources().getString(R.string.close)); 
      } 
     } 
    } 

Answer 1

// Http Client with SSL factory 

public HttpClient getNewHttpClient() { 
try { 
KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType()); 
trustStore.load(null, null); 

SSLSocketFactory sf = new MySSLSocketFactory(trustStore); 
sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER); 

HttpParams params = new BasicHttpParams(); 
HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1); 
HttpProtocolParams.setContentCharset(params, HTTP.UTF_8); 

SchemeRegistry registry = new SchemeRegistry(); 
registry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80)); 
registry.register(new Scheme("https", sf, 443)); 

ClientConnectionManager ccm = new ThreadSafeClientConnManager(params, registry); 

return new DefaultHttpClient(ccm, params); 
} catch (Exception e) { 
    return new DefaultHttpClient(); 
} 
} 

// Post request for multi part entity 

public void postRequest(){ 

    DefaultHttpClient httpClient = new getNewHttpClient(); 
    HttpPost postRequest = new HttpPost(url); 
    String auth = "USER_NAME" + ":" + "PASSWORD"; 
    byte[] bytes = auth.getBytes(); 
    postRequest.setHeader("Authorization", "Basic " + new String(Base64.encodeBytes(bytes))); 

    try { 
     MultipartEntity mpC = new MultipartEntity(); 
     FileBody fb = new FileBody(message); 
     StringBody sbPicID = new StringBody(fb.getFilename()); 
     mpC.addPart("name", sbPicID); 
     mpC.addPart("file", fb); 
     postRequest.setEntity(mpC); 
     HttpResponse res; 
     res = httpClient.execute(postRequest); 
     BufferedReader rd = new BufferedReader(new InputStreamReader(res.getEntity().getContent())); 
     String resPictureId = ""; 
     resPictureId = rd.readLine(); 

     Session.put("PICTURE_"+position, resPictureId); 
     res.getEntity().getContent().close(); 
    }catch (Exception e) { 
     // TODO: handle exception 
    } 

} 

// SSL factory class 

public class MySSLSocketFactory extends SSLSocketFactory { 
    SSLContext sslContext = SSLContext.getInstance("TLS"); 

    public MySSLSocketFactory(KeyStore truststore) 
      throws NoSuchAlgorithmException, KeyManagementException, 
      KeyStoreException, UnrecoverableKeyException { 
     super(truststore); 

     TrustManager tm = new X509TrustManager() { 
      public void checkClientTrusted(X509Certificate[] chain, 
        String authType) throws CertificateException { 
      } 

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

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

     sslContext.init(null, new TrustManager[] { tm }, null); 
    } 

    @Override 
    public Socket createSocket(Socket socket, String host, int port, 
      boolean autoClose) throws IOException, UnknownHostException { 
     return sslContext.getSocketFactory().createSocket(socket, host, port, 
       autoClose); 
    } 

    @Override 
    public Socket createSocket() throws IOException { 
     return sslContext.getSocketFactory().createSocket(); 
    } 

} 

CustomSSlSocketFactory.java을 SSL을 구현 할 수 있습니다

Answer 2

ssl을 (를) 사용하는 목적은 무엇입니까? 다른 사용 사례가 있습니다

• SSL 단지 보안 통신 채널로
• 는 SSL을 사용하면 서버가 연결이 앱에서되었는지 확인할 수 있도록
• SSL 올바른 서버와 통신하고 있는지 확인하기 위해

처음 두 가지를 제안했지만 마지막으로 웹 서버가 확인할 수있는 앱에 인증서가 필요합니다.

Answer 3

이봐, 당신은 지금

 private HttpResponse getResponse(HttpPost request) { 
    try { 
     BasicHttpParams httpParams = new BasicHttpParams(); 

     ConnManagerParams.setTimeout(httpParams, connectionTimeout); 
     HttpConnectionParams.setSoTimeout(httpParams, connectionTimeout); 
     HttpConnectionParams.setConnectionTimeout(httpParams, connectionTimeout); 
     HttpConnectionParams.setTcpNoDelay(httpParams, true); 
     HttpProtocolParams.setVersion(httpParams, HttpVersion.HTTP_1_1); 

     KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType()); 
     trustStore.load(null, null); 

     SSLSocketFactory socketFactory = new CustomSSLSocketFactory(trustStore); 
     socketFactory.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER); 

     SchemeRegistry schemeRegistry = new SchemeRegistry(); 
     schemeRegistry.register(new Scheme("https", socketFactory, Integer.parseInt(Constants.PORT_NUMBER))); 
     ThreadSafeClientConnManager cManager = new ThreadSafeClientConnManager(httpParams, schemeRegistry); 

     HttpClient httpClient = new DefaultHttpClient(cManager, httpParams); 
     return httpClient.execute(request); 
    } catch (Exception e) { 
     if (Constants.DEBUG) { 
      Log.e(TAG, "", e); 
     } 
    } 
    return null; 
} 

... 아래와 같이

import java.io.IOException; 
    import java.net.Socket; 
    import java.net.UnknownHostException; 
    import java.security.KeyManagementException; 
    import java.security.KeyStore; 
    import java.security.KeyStoreException; 
    import java.security.NoSuchAlgorithmException; 
    import java.security.UnrecoverableKeyException; 
    import java.security.cert.CertificateException; 
    import java.security.cert.X509Certificate; 

    import javax.net.ssl.SSLContext; 
    import javax.net.ssl.TrustManager; 
    import javax.net.ssl.X509TrustManager; 

    import org.apache.http.conn.ssl.SSLSocketFactory; 

    public class CustomSSLSocketFactory extends SSLSocketFactory { 
SSLContext sslContext = SSLContext.getInstance("TLS"); 

public CustomSSLSocketFactory(KeyStore truststore) throws NoSuchAlgorithmException, KeyManagementException, KeyStoreException, UnrecoverableKeyException { 
    super(truststore); 

    TrustManager tm = new X509TrustManager() { 
     public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException { 
     } 

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

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

    sslContext.init(null, new TrustManager[] { tm }, null); 
} 

@Override 
public Socket createSocket(Socket socket, String host, int port, boolean autoClose) throws IOException, UnknownHostException { 
    return sslContext.getSocketFactory().createSocket(socket, host, port, autoClose); 
} 

@Override 
public Socket createSocket() throws IOException { 
    return sslContext.getSocketFactory().createSocket(); 
} 

}