diff -r 000000000000 -r 6474c204b198 mobile/android/base/sync/Utils.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mobile/android/base/sync/Utils.java Wed Dec 31 06:09:35 2014 +0100 @@ -0,0 +1,617 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +package org.mozilla.gecko.sync; + +import java.io.BufferedReader; +import java.io.FileInputStream; +import java.io.IOException; +import java.io.InputStreamReader; +import java.io.UnsupportedEncodingException; +import java.math.BigDecimal; +import java.math.BigInteger; +import java.net.URLDecoder; +import java.security.MessageDigest; +import java.security.NoSuchAlgorithmException; +import java.security.SecureRandom; +import java.text.DecimalFormat; +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Locale; +import java.util.Map; +import java.util.TreeMap; + +import org.json.simple.JSONArray; +import org.mozilla.apache.commons.codec.binary.Base32; +import org.mozilla.apache.commons.codec.binary.Base64; +import org.mozilla.gecko.background.common.log.Logger; +import org.mozilla.gecko.background.nativecode.NativeCrypto; +import org.mozilla.gecko.sync.setup.Constants; + +import android.annotation.SuppressLint; +import android.content.Context; +import android.content.SharedPreferences; +import android.os.Bundle; + +public class Utils { + + private static final String LOG_TAG = "Utils"; + + private static SecureRandom sharedSecureRandom = new SecureRandom(); + + // See + public static final int SHARED_PREFERENCES_MODE = 0; + + public static String generateGuid() { + byte[] encodedBytes = Base64.encodeBase64(generateRandomBytes(9), false); + return new String(encodedBytes).replace("+", "-").replace("/", "_"); + } + + /** + * Helper to generate secure random bytes. + * + * @param length + * Number of bytes to generate. + */ + public static byte[] generateRandomBytes(int length) { + byte[] bytes = new byte[length]; + sharedSecureRandom.nextBytes(bytes); + return bytes; + } + + /** + * Helper to generate a random integer in a specified range. + * + * @param r + * Generate an integer between 0 and r-1 inclusive. + */ + public static BigInteger generateBigIntegerLessThan(BigInteger r) { + int maxBytes = (int) Math.ceil(((double) r.bitLength()) / 8); + BigInteger randInt = new BigInteger(generateRandomBytes(maxBytes)); + return randInt.mod(r); + } + + /** + * Helper to reseed the shared secure random number generator. + */ + public static void reseedSharedRandom() { + sharedSecureRandom.setSeed(sharedSecureRandom.generateSeed(8)); + } + + /** + * Helper to convert a byte array to a hex-encoded string + */ + public static String byte2Hex(final byte[] b) { + return byte2Hex(b, 2 * b.length); + } + + public static String byte2Hex(final byte[] b, int hexLength) { + final StringBuilder hs = new StringBuilder(Math.max(2*b.length, hexLength)); + String stmp; + + for (int n = 0; n < hexLength - 2*b.length; n++) { + hs.append("0"); + } + + for (int n = 0; n < b.length; n++) { + stmp = Integer.toHexString(b[n] & 0XFF); + + if (stmp.length() == 1) { + hs.append("0"); + } + hs.append(stmp); + } + + return hs.toString(); + } + + public static byte[] concatAll(byte[] first, byte[]... rest) { + int totalLength = first.length; + for (byte[] array : rest) { + totalLength += array.length; + } + + byte[] result = new byte[totalLength]; + int offset = first.length; + + System.arraycopy(first, 0, result, 0, offset); + + for (byte[] array : rest) { + System.arraycopy(array, 0, result, offset, array.length); + offset += array.length; + } + return result; + } + + /** + * Utility for Base64 decoding. Should ensure that the correct + * Apache Commons version is used. + * + * @param base64 + * An input string. Will be decoded as UTF-8. + * @return + * A byte array of decoded values. + * @throws UnsupportedEncodingException + * Should not occur. + */ + public static byte[] decodeBase64(String base64) throws UnsupportedEncodingException { + return Base64.decodeBase64(base64.getBytes("UTF-8")); + } + + @SuppressLint("DefaultLocale") + public static byte[] decodeFriendlyBase32(String base32) { + Base32 converter = new Base32(); + final String translated = base32.replace('8', 'l').replace('9', 'o'); + return converter.decode(translated.toUpperCase()); + } + + public static byte[] hex2Byte(String str, int byteLength) { + byte[] second = hex2Byte(str); + if (second.length >= byteLength) { + return second; + } + // New Java arrays are zeroed: + // http://docs.oracle.com/javase/specs/jls/se7/html/jls-4.html#jls-4.12.5 + byte[] first = new byte[byteLength - second.length]; + return Utils.concatAll(first, second); + } + + public static byte[] hex2Byte(String str) { + if (str.length() % 2 == 1) { + str = "0" + str; + } + + byte[] bytes = new byte[str.length() / 2]; + for (int i = 0; i < bytes.length; i++) { + bytes[i] = (byte) Integer.parseInt(str.substring(2 * i, 2 * i + 2), 16); + } + return bytes; + } + + public static String millisecondsToDecimalSecondsString(long ms) { + return millisecondsToDecimalSeconds(ms).toString(); + } + + // For dumping into JSON without quotes. + public static BigDecimal millisecondsToDecimalSeconds(long ms) { + return new BigDecimal(ms).movePointLeft(3); + } + + // This lives until Bug 708956 lands, and we don't have to do it any more. + public static long decimalSecondsToMilliseconds(String decimal) { + try { + return new BigDecimal(decimal).movePointRight(3).longValue(); + } catch (Exception e) { + return -1; + } + } + + // Oh, Java. + public static long decimalSecondsToMilliseconds(Double decimal) { + // Truncates towards 0. + return (long)(decimal * 1000); + } + + public static long decimalSecondsToMilliseconds(Long decimal) { + return decimal * 1000; + } + + public static long decimalSecondsToMilliseconds(Integer decimal) { + return (long)(decimal * 1000); + } + + public static byte[] sha256(byte[] in) + throws NoSuchAlgorithmException { + MessageDigest sha1 = MessageDigest.getInstance("SHA-256"); + return sha1.digest(in); + } + + protected static byte[] sha1(final String utf8) + throws NoSuchAlgorithmException, UnsupportedEncodingException { + final byte[] bytes = utf8.getBytes("UTF-8"); + try { + return NativeCrypto.sha1(bytes); + } catch (final LinkageError e) { + // This will throw UnsatisifiedLinkError (missing mozglue) the first time it is called, and + // ClassNotDefFoundError, for the uninitialized NativeCrypto class, each subsequent time this + // is called; LinkageError is their common ancestor. + Logger.warn(LOG_TAG, "Got throwable stretching password using native sha1 implementation; " + + "ignoring and using Java implementation.", e); + final MessageDigest sha1 = MessageDigest.getInstance("SHA-1"); + return sha1.digest(utf8.getBytes("UTF-8")); + } + } + + protected static String sha1Base32(final String utf8) + throws NoSuchAlgorithmException, UnsupportedEncodingException { + return new Base32().encodeAsString(sha1(utf8)).toLowerCase(Locale.US); + } + + /** + * If we encounter characters not allowed by the API (as found for + * instance in an email address), hash the value. + * @param account + * An account string. + * @return + * An acceptable string. + * @throws UnsupportedEncodingException + * @throws NoSuchAlgorithmException + */ + public static String usernameFromAccount(final String account) throws NoSuchAlgorithmException, UnsupportedEncodingException { + if (account == null || account.equals("")) { + throw new IllegalArgumentException("No account name provided."); + } + if (account.matches("^[A-Za-z0-9._-]+$")) { + return account.toLowerCase(Locale.US); + } + return sha1Base32(account.toLowerCase(Locale.US)); + } + + public static SharedPreferences getSharedPreferences(final Context context, final String product, final String username, final String serverURL, final String profile, final long version) + throws NoSuchAlgorithmException, UnsupportedEncodingException { + String prefsPath = getPrefsPath(product, username, serverURL, profile, version); + return context.getSharedPreferences(prefsPath, SHARED_PREFERENCES_MODE); + } + + /** + * Get shared preferences path for a Sync account. + * + * @param product the Firefox Sync product package name (like "org.mozilla.firefox"). + * @param username the Sync account name, optionally encoded with Utils.usernameFromAccount. + * @param serverURL the Sync account server URL. + * @param profile the Firefox profile name. + * @param version the version of preferences to reference. + * @return the path. + * @throws NoSuchAlgorithmException + * @throws UnsupportedEncodingException + */ + public static String getPrefsPath(final String product, final String username, final String serverURL, final String profile, final long version) + throws NoSuchAlgorithmException, UnsupportedEncodingException { + final String encodedAccount = sha1Base32(serverURL + ":" + usernameFromAccount(username)); + + if (version <= 0) { + return "sync.prefs." + encodedAccount; + } else { + final String sanitizedProduct = product.replace('.', '!').replace(' ', '!'); + return "sync.prefs." + sanitizedProduct + "." + encodedAccount + "." + profile + "." + version; + } + } + + public static void addToIndexBucketMap(TreeMap> map, long index, String value) { + ArrayList bucket = map.get(index); + if (bucket == null) { + bucket = new ArrayList(); + } + bucket.add(value); + map.put(index, bucket); + } + + /** + * Yes, an equality method that's null-safe. + */ + private static boolean same(Object a, Object b) { + if (a == b) { + return true; + } + if (a == null || b == null) { + return false; // If both null, case above applies. + } + return a.equals(b); + } + + /** + * Return true if the two arrays are both null, or are both arrays + * containing the same elements in the same order. + */ + public static boolean sameArrays(JSONArray a, JSONArray b) { + if (a == b) { + return true; + } + if (a == null || b == null) { + return false; + } + final int size = a.size(); + if (size != b.size()) { + return false; + } + for (int i = 0; i < size; ++i) { + if (!same(a.get(i), b.get(i))) { + return false; + } + } + return true; + } + + /** + * Takes a URI, extracting URI components. + * @param scheme the URI scheme on which to match. + */ + @SuppressWarnings("deprecation") + public static Map extractURIComponents(String scheme, String uri) { + if (uri.indexOf(scheme) != 0) { + throw new IllegalArgumentException("URI scheme does not match: " + scheme); + } + + // Do this the hard way to avoid taking a large dependency on + // HttpClient or getting all regex-tastic. + String components = uri.substring(scheme.length()); + HashMap out = new HashMap(); + String[] parts = components.split("&"); + for (int i = 0; i < parts.length; ++i) { + String part = parts[i]; + if (part.length() == 0) { + continue; + } + String[] pair = part.split("=", 2); + switch (pair.length) { + case 0: + continue; + case 1: + out.put(URLDecoder.decode(pair[0]), null); + break; + case 2: + out.put(URLDecoder.decode(pair[0]), URLDecoder.decode(pair[1])); + break; + } + } + return out; + } + + // Because TextUtils.join is not stubbed. + public static String toDelimitedString(String delimiter, Collection items) { + if (items == null || items.size() == 0) { + return ""; + } + + StringBuilder sb = new StringBuilder(); + int i = 0; + int c = items.size(); + for (Object object : items) { + sb.append(object.toString()); + if (++i < c) { + sb.append(delimiter); + } + } + return sb.toString(); + } + + public static String toCommaSeparatedString(Collection items) { + return toDelimitedString(", ", items); + } + + /** + * Names of stages to sync: (ALL intersect SYNC) intersect (ALL minus SKIP). + * + * @param knownStageNames collection of known stage names (set ALL above). + * @param toSync set SYNC above, or null to sync all known stages. + * @param toSkip set SKIP above, or null to not skip any stages. + * @return stage names. + */ + public static Collection getStagesToSync(final Collection knownStageNames, Collection toSync, Collection toSkip) { + if (toSkip == null) { + toSkip = new HashSet(); + } else { + toSkip = new HashSet(toSkip); + } + + if (toSync == null) { + toSync = new HashSet(knownStageNames); + } else { + toSync = new HashSet(toSync); + } + toSync.retainAll(knownStageNames); + toSync.removeAll(toSkip); + return toSync; + } + + /** + * Get names of stages to sync: (ALL intersect SYNC) intersect (ALL minus SKIP). + * + * @param knownStageNames collection of known stage names (set ALL above). + * @param extras + * a Bundle instance (possibly null) optionally containing keys + * EXTRAS_KEY_STAGES_TO_SYNC (set SYNC above) and + * EXTRAS_KEY_STAGES_TO_SKIP (set SKIP above). + * @return stage names. + */ + public static Collection getStagesToSyncFromBundle(final Collection knownStageNames, final Bundle extras) { + if (extras == null) { + return knownStageNames; + } + String toSyncString = extras.getString(Constants.EXTRAS_KEY_STAGES_TO_SYNC); + String toSkipString = extras.getString(Constants.EXTRAS_KEY_STAGES_TO_SKIP); + if (toSyncString == null && toSkipString == null) { + return knownStageNames; + } + + ArrayList toSync = null; + ArrayList toSkip = null; + if (toSyncString != null) { + try { + toSync = new ArrayList(ExtendedJSONObject.parseJSONObject(toSyncString).keySet()); + } catch (Exception e) { + Logger.warn(LOG_TAG, "Got exception parsing stages to sync: '" + toSyncString + "'.", e); + } + } + if (toSkipString != null) { + try { + toSkip = new ArrayList(ExtendedJSONObject.parseJSONObject(toSkipString).keySet()); + } catch (Exception e) { + Logger.warn(LOG_TAG, "Got exception parsing stages to skip: '" + toSkipString + "'.", e); + } + } + + Logger.info(LOG_TAG, "Asked to sync '" + Utils.toCommaSeparatedString(toSync) + + "' and to skip '" + Utils.toCommaSeparatedString(toSkip) + "'."); + return getStagesToSync(knownStageNames, toSync, toSkip); + } + + /** + * Put names of stages to sync and to skip into sync extras bundle. + * + * @param bundle + * a Bundle instance (possibly null). + * @param stagesToSync + * collection of stage names to sync: key + * EXTRAS_KEY_STAGES_TO_SYNC; ignored if null. + * @param stagesToSkip + * collection of stage names to skip: key + * EXTRAS_KEY_STAGES_TO_SKIP; ignored if null. + */ + public static void putStageNamesToSync(final Bundle bundle, final String[] stagesToSync, final String[] stagesToSkip) { + if (bundle == null) { + return; + } + + if (stagesToSync != null) { + ExtendedJSONObject o = new ExtendedJSONObject(); + for (String stageName : stagesToSync) { + o.put(stageName, 0); + } + bundle.putString(Constants.EXTRAS_KEY_STAGES_TO_SYNC, o.toJSONString()); + } + + if (stagesToSkip != null) { + ExtendedJSONObject o = new ExtendedJSONObject(); + for (String stageName : stagesToSkip) { + o.put(stageName, 0); + } + bundle.putString(Constants.EXTRAS_KEY_STAGES_TO_SKIP, o.toJSONString()); + } + } + + /** + * Read contents of file as a string. + * + * @param context Android context. + * @param filename name of file to read; must not be null. + * @return String instance. + */ + public static String readFile(final Context context, final String filename) { + if (filename == null) { + throw new IllegalArgumentException("Passed null filename in readFile."); + } + + FileInputStream fis = null; + InputStreamReader isr = null; + BufferedReader br = null; + + try { + fis = context.openFileInput(filename); + isr = new InputStreamReader(fis); + br = new BufferedReader(isr); + StringBuilder sb = new StringBuilder(); + String line; + while ((line = br.readLine()) != null) { + sb.append(line); + } + return sb.toString(); + } catch (Exception e) { + return null; + } finally { + if (isr != null) { + try { + isr.close(); + } catch (IOException e) { + // Ignore. + } + } + if (fis != null) { + try { + fis.close(); + } catch (IOException e) { + // Ignore. + } + } + } + } + + /** + * Format a duration as a string, like "0.56 seconds". + * + * @param startMillis start time in milliseconds. + * @param endMillis end time in milliseconds. + * @return formatted string. + */ + public static String formatDuration(long startMillis, long endMillis) { + final long duration = endMillis - startMillis; + return new DecimalFormat("#0.00 seconds").format(((double) duration) / 1000); + } + + /** + * This will take a string containing a UTF-8 representation of a UTF-8 + * byte array — e.g., "pïgéons1" — and return UTF-8 (e.g., "pïgéons1"). + * + * This is the format produced by desktop Firefox when exchanging credentials + * containing non-ASCII characters. + */ + public static String decodeUTF8(final String in) throws UnsupportedEncodingException { + final int length = in.length(); + final byte[] asciiBytes = new byte[length]; + for (int i = 0; i < length; ++i) { + asciiBytes[i] = (byte) in.codePointAt(i); + } + return new String(asciiBytes, "UTF-8"); + } + + /** + * Replace "foo@bar.com" with "XXX@XXX.XXX". + */ + public static String obfuscateEmail(final String in) { + return in.replaceAll("[^@\\.]", "X"); + } + + public static String nodeWeaveURL(String serverURL, String username) { + String userPart = username + "/node/weave"; + if (serverURL == null) { + return SyncConstants.DEFAULT_AUTH_SERVER + "user/1.0/" + userPart; + } + if (!serverURL.endsWith("/")) { + serverURL = serverURL + "/"; + } + return serverURL + "user/1.0/" + userPart; + } + + public static void throwIfNull(Object... objects) { + for (Object object : objects) { + if (object == null) { + throw new IllegalArgumentException("object must not be null"); + } + } + } + + /** + * Gecko uses locale codes like "es-ES", whereas a Java {@link Locale} + * stringifies as "es_ES". + * + * This method approximates the Java 7 method Locale#toLanguageTag(). + *

+ * Warning: all consumers of this method will need to be audited when + * we have active locale switching. + * + * @return a locale string suitable for passing to Gecko. + */ + public static String getLanguageTag(final Locale locale) { + // If this were Java 7: + // return locale.toLanguageTag(); + + String language = locale.getLanguage(); // Can, but should never be, an empty string. + // Modernize certain language codes. + if (language.equals("iw")) { + language = "he"; + } else if (language.equals("in")) { + language = "id"; + } else if (language.equals("ji")) { + language = "yi"; + } + + String country = locale.getCountry(); // Can be an empty string. + if (country.equals("")) { + return language; + } + return language + "-" + country; + } +}