src/com/owncloud/android/network/OwnCloudClientUtils.java

   1 /* ownCloud Android client application
   2  *   Copyright (C) 2012-2013 ownCloud Inc.
   3  *
   4  *   This program is free software: you can redistribute it and/or modify
   5  *   it under the terms of the GNU General Public License version 2,
   6  *   as published by the Free Software Foundation.
   7  *
   8  *   This program is distributed in the hope that it will be useful,
   9  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  *   GNU General Public License for more details.
  12  *
  13  *   You should have received a copy of the GNU General Public License
  14  *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15  *
  16  */
  17 package com.owncloud.android.network;
  18
  19 import java.io.File;
  20 import java.io.FileInputStream;
  21 import java.io.FileOutputStream;
  22 import java.io.IOException;
  23 import java.io.InputStream;
  24 import java.security.GeneralSecurityException;
  25 import java.security.KeyStore;
  26 import java.security.KeyStoreException;
  27 import java.security.NoSuchAlgorithmException;
  28 import java.security.cert.Certificate;
  29 import java.security.cert.CertificateException;
  30
  31 import javax.net.ssl.SSLContext;
  32 import javax.net.ssl.TrustManager;
  33
  34 import org.apache.commons.httpclient.MultiThreadedHttpConnectionManager;
  35 import org.apache.commons.httpclient.methods.GetMethod;
  36 import org.apache.commons.httpclient.protocol.Protocol;
  37 import org.apache.http.conn.ssl.BrowserCompatHostnameVerifier;
  38 import org.apache.http.conn.ssl.X509HostnameVerifier;
  39
  40 import com.owncloud.android.authentication.AccountAuthenticator;
  41 import com.owncloud.android.authentication.AccountUtils;
  42 import com.owncloud.android.authentication.AccountUtils.AccountNotFoundException;
  43 import com.owncloud.android.Log_OC;
  44
  45 import eu.alefzero.webdav.WebdavClient;
  46
  47 import android.accounts.Account;
  48 import android.accounts.AccountManager;
  49 import android.accounts.AccountManagerFuture;
  50 import android.accounts.AuthenticatorException;
  51 import android.accounts.OperationCanceledException;
  52 import android.app.Activity;
  53 import android.content.Context;
  54 import android.net.Uri;
  55 import android.os.Bundle;
  56
  57 public class OwnCloudClientUtils {
  58
  59     final private static String TAG = OwnCloudClientUtils.class.getSimpleName();
  60
  61     /** Default timeout for waiting data from the server */
  62     public static final int DEFAULT_DATA_TIMEOUT = 60000;
  63
  64     /** Default timeout for establishing a connection */
  65     public static final int DEFAULT_CONNECTION_TIMEOUT = 60000;
  66
  67     /** Connection manager for all the WebdavClients */
  68     private static MultiThreadedHttpConnectionManager mConnManager = null;
  69
  70     private static Protocol mDefaultHttpsProtocol = null;
  71
  72     private static AdvancedSslSocketFactory mAdvancedSslSocketFactory = null;
  73
  74     private static X509HostnameVerifier mHostnameVerifier = null;
  75
  76
  77     /**
  78      * Creates a WebdavClient setup for an ownCloud account
  79      *
  80      * Do not call this method from the main thread.
  81      *
  82      * @param account                       The ownCloud account
  83      * @param appContext                    Android application context
  84      * @return                              A WebdavClient object ready to be used
  85      * @throws AuthenticatorException       If the authenticator failed to get the authorization token for the account.
  86      * @throws OperationCanceledException   If the authenticator operation was cancelled while getting the authorization token for the account.
  87      * @throws IOException                  If there was some I/O error while getting the authorization token for the account.
  88      * @throws AccountNotFoundException     If 'account' is unknown for the AccountManager
  89      */
  90     public static WebdavClient createOwnCloudClient (Account account, Context appContext) throws OperationCanceledException, AuthenticatorException, IOException, AccountNotFoundException {
  91         //Log_OC.d(TAG, "Creating WebdavClient associated to " + account.name);
  92
  93         Uri uri = Uri.parse(AccountUtils.constructFullURLForAccount(appContext, account));
  94         AccountManager am = AccountManager.get(appContext);
  95         boolean isOauth2 = am.getUserData(account, AccountAuthenticator.KEY_SUPPORTS_OAUTH2) != null;   // TODO avoid calling to getUserData here
  96         boolean isSamlSso = am.getUserData(account, AccountAuthenticator.KEY_SUPPORTS_SAML_WEB_SSO) != null;
  97         WebdavClient client = createOwnCloudClient(uri, appContext, !isSamlSso);
  98         if (isOauth2) {
  99             String accessToken = am.blockingGetAuthToken(account, AccountAuthenticator.AUTH_TOKEN_TYPE_ACCESS_TOKEN, false);
 100             client.setBearerCredentials(accessToken);   // TODO not assume that the access token is a bearer token
 101
 102         } else if (isSamlSso) {    // TODO avoid a call to getUserData here
 103             String accessToken = am.blockingGetAuthToken(account, AccountAuthenticator.AUTH_TOKEN_TYPE_SAML_WEB_SSO_SESSION_COOKIE, false);
 104             client.setSsoSessionCookie(accessToken);
 105             Log_OC.e(TAG, "client with auth token: " + accessToken);
 106
 107         } else {
 108             String username = account.name.substring(0, account.name.lastIndexOf('@'));
 109             //String password = am.getPassword(account);
 110             String password = am.blockingGetAuthToken(account, AccountAuthenticator.AUTH_TOKEN_TYPE_PASSWORD, false);
 111             client.setBasicCredentials(username, password);
 112         }
 113
 114         return client;
 115     }
 116
 117
 118     public static WebdavClient createOwnCloudClient (Account account, Context appContext, Activity currentActivity) throws OperationCanceledException, AuthenticatorException, IOException, AccountNotFoundException {
 119         Uri uri = Uri.parse(AccountUtils.constructFullURLForAccount(appContext, account));
 120         AccountManager am = AccountManager.get(appContext);
 121         boolean isOauth2 = am.getUserData(account, AccountAuthenticator.KEY_SUPPORTS_OAUTH2) != null;   // TODO avoid calling to getUserData here
 122         boolean isSamlSso = am.getUserData(account, AccountAuthenticator.KEY_SUPPORTS_SAML_WEB_SSO) != null;
 123         WebdavClient client = createOwnCloudClient(uri, appContext, !isSamlSso);
 124
 125         if (isOauth2) {    // TODO avoid a call to getUserData here
 126             AccountManagerFuture<Bundle> future =  am.getAuthToken(account, AccountAuthenticator.AUTH_TOKEN_TYPE_ACCESS_TOKEN, null, currentActivity, null, null);
 127             Bundle result = future.getResult();
 128             String accessToken = result.getString(AccountManager.KEY_AUTHTOKEN);
 129             if (accessToken == null) throw new AuthenticatorException("WTF!");
 130             client.setBearerCredentials(accessToken);   // TODO not assume that the access token is a bearer token
 131
 132         } else if (isSamlSso) {    // TODO avoid a call to getUserData here
 133             AccountManagerFuture<Bundle> future =  am.getAuthToken(account, AccountAuthenticator.AUTH_TOKEN_TYPE_SAML_WEB_SSO_SESSION_COOKIE, null, currentActivity, null, null);
 134             Bundle result = future.getResult();
 135             String accessToken = result.getString(AccountManager.KEY_AUTHTOKEN);
 136             if (accessToken == null) throw new AuthenticatorException("WTF!");
 137             client.setSsoSessionCookie(accessToken);
 138             Log_OC.e(TAG, "client with auth token: " + accessToken);
 139
 140         } else {
 141             String username = account.name.substring(0, account.name.lastIndexOf('@'));
 142             //String password = am.getPassword(account);
 143             //String password = am.blockingGetAuthToken(account, AccountAuthenticator.AUTH_TOKEN_TYPE_PASSWORD, false);
 144             AccountManagerFuture<Bundle> future =  am.getAuthToken(account, AccountAuthenticator.AUTH_TOKEN_TYPE_PASSWORD, null, currentActivity, null, null);
 145             Bundle result = future.getResult();
 146             String password = result.getString(AccountManager.KEY_AUTHTOKEN);
 147             client.setBasicCredentials(username, password);
 148         }
 149
 150         return client;
 151     }
 152
 153     /**
 154      * Creates a WebdavClient to access a URL and sets the desired parameters for ownCloud client connections.
 155      *
 156      * @param uri       URL to the ownCloud server
 157      * @param context   Android context where the WebdavClient is being created.
 158      * @return          A WebdavClient object ready to be used
 159      */
 160     public static WebdavClient createOwnCloudClient(Uri uri, Context context, boolean followRedirects) {
 161         try {
 162             registerAdvancedSslContext(true, context);
 163         }  catch (GeneralSecurityException e) {
 164             Log_OC.e(TAG, "Advanced SSL Context could not be loaded. Default SSL management in the system will be used for HTTPS connections", e);
 165
 166         } catch (IOException e) {
 167             Log_OC.e(TAG, "The local server truststore could not be read. Default SSL management in the system will be used for HTTPS connections", e);
 168         }
 169
 170         WebdavClient client = new WebdavClient(getMultiThreadedConnManager());
 171
 172         client.setDefaultTimeouts(DEFAULT_DATA_TIMEOUT, DEFAULT_CONNECTION_TIMEOUT);
 173         client.setBaseUri(uri);
 174         client.setFollowRedirects(followRedirects);
 175
 176         return client;
 177     }
 178
 179
 180     /**
 181      * Registers or unregisters the proper components for advanced SSL handling.
 182      * @throws IOException
 183      */
 184     private static void registerAdvancedSslContext(boolean register, Context context) throws GeneralSecurityException, IOException {
 185         Protocol pr = null;
 186         try {
 187             pr = Protocol.getProtocol("https");
 188             if (pr != null && mDefaultHttpsProtocol == null) {
 189                 mDefaultHttpsProtocol = pr;
 190             }
 191         } catch (IllegalStateException e) {
 192             // nothing to do here; really
 193         }
 194         boolean isRegistered = (pr != null && pr.getSocketFactory() instanceof AdvancedSslSocketFactory);
 195         if (register && !isRegistered) {
 196             Protocol.registerProtocol("https", new Protocol("https", getAdvancedSslSocketFactory(context), 443));
 197
 198         } else if (!register && isRegistered) {
 199             if (mDefaultHttpsProtocol != null) {
 200                 Protocol.registerProtocol("https", mDefaultHttpsProtocol);
 201             }
 202         }
 203     }
 204
 205     public static AdvancedSslSocketFactory getAdvancedSslSocketFactory(Context context) throws GeneralSecurityException, IOException {
 206         if (mAdvancedSslSocketFactory  == null) {
 207             KeyStore trustStore = getKnownServersStore(context);
 208             AdvancedX509TrustManager trustMgr = new AdvancedX509TrustManager(trustStore);
 209             TrustManager[] tms = new TrustManager[] { trustMgr };
 210
 211             SSLContext sslContext = SSLContext.getInstance("TLS");
 212             sslContext.init(null, tms, null);
 213
 214             mHostnameVerifier = new BrowserCompatHostnameVerifier();
 215             mAdvancedSslSocketFactory = new AdvancedSslSocketFactory(sslContext, trustMgr, mHostnameVerifier);
 216         }
 217         return mAdvancedSslSocketFactory;
 218     }
 219
 220
 221     private static String LOCAL_TRUSTSTORE_FILENAME = "knownServers.bks";
 222
 223     private static String LOCAL_TRUSTSTORE_PASSWORD = "password";
 224
 225     private static KeyStore mKnownServersStore = null;
 226
 227     /**
 228      * Returns the local store of reliable server certificates, explicitly accepted by the user.
 229      *
 230      * Returns a KeyStore instance with empty content if the local store was never created.
 231      *
 232      * Loads the store from the storage environment if needed.
 233      *
 234      * @param context                       Android context where the operation is being performed.
 235      * @return                              KeyStore instance with explicitly-accepted server certificates.
 236      * @throws KeyStoreException            When the KeyStore instance could not be created.
 237      * @throws IOException                  When an existing local trust store could not be loaded.
 238      * @throws NoSuchAlgorithmException     When the existing local trust store was saved with an unsupported algorithm.
 239      * @throws CertificateException         When an exception occurred while loading the certificates from the local trust store.
 240      */
 241     private static KeyStore getKnownServersStore(Context context) throws KeyStoreException, IOException, NoSuchAlgorithmException, CertificateException {
 242         if (mKnownServersStore == null) {
 243             //mKnownServersStore = KeyStore.getInstance("BKS");
 244             mKnownServersStore = KeyStore.getInstance(KeyStore.getDefaultType());
 245             File localTrustStoreFile = new File(context.getFilesDir(), LOCAL_TRUSTSTORE_FILENAME);
 246             Log_OC.d(TAG, "Searching known-servers store at " + localTrustStoreFile.getAbsolutePath());
 247             if (localTrustStoreFile.exists()) {
 248                 InputStream in = new FileInputStream(localTrustStoreFile);
 249                 try {
 250                     mKnownServersStore.load(in, LOCAL_TRUSTSTORE_PASSWORD.toCharArray());
 251                 } finally {
 252                     in.close();
 253                 }
 254             } else {
 255                 mKnownServersStore.load(null, LOCAL_TRUSTSTORE_PASSWORD.toCharArray()); // necessary to initialize an empty KeyStore instance
 256             }
 257         }
 258         return mKnownServersStore;
 259     }
 260
 261
 262     public static void addCertToKnownServersStore(Certificate cert, Context context) throws  KeyStoreException, NoSuchAlgorithmException,
 263                                                                                             CertificateException, IOException {
 264         KeyStore knownServers = getKnownServersStore(context);
 265         knownServers.setCertificateEntry(Integer.toString(cert.hashCode()), cert);
 266         FileOutputStream fos = null;
 267         try {
 268             fos = context.openFileOutput(LOCAL_TRUSTSTORE_FILENAME, Context.MODE_PRIVATE);
 269             knownServers.store(fos, LOCAL_TRUSTSTORE_PASSWORD.toCharArray());
 270         } finally {
 271             fos.close();
 272         }
 273     }
 274
 275
 276     static private MultiThreadedHttpConnectionManager getMultiThreadedConnManager() {
 277         if (mConnManager == null) {
 278             mConnManager = new MultiThreadedHttpConnectionManager();
 279             mConnManager.getParams().setDefaultMaxConnectionsPerHost(5);
 280             mConnManager.getParams().setMaxTotalConnections(5);
 281         }
 282         return mConnManager;
 283     }
 284
 285
 286 }