1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
|
/* 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.IOException;
import java.io.UnsupportedEncodingException;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map.Entry;
import java.util.Set;
import org.json.simple.JSONArray;
import org.mozilla.apache.commons.codec.binary.Base64;
import org.mozilla.gecko.sync.crypto.CryptoException;
import org.mozilla.gecko.sync.crypto.KeyBundle;
public class CollectionKeys {
private KeyBundle defaultKeyBundle = null;
private final HashMap<String, KeyBundle> collectionKeyBundles = new HashMap<String, KeyBundle>();
/**
* Randomly generate a basic CollectionKeys object.
* @throws CryptoException
*/
public static CollectionKeys generateCollectionKeys() throws CryptoException {
CollectionKeys ck = new CollectionKeys();
ck.clear();
ck.defaultKeyBundle = KeyBundle.withRandomKeys();
// TODO: eventually we would like to keep per-collection keys, just generate
// new ones as appropriate.
return ck;
}
public KeyBundle defaultKeyBundle() throws NoCollectionKeysSetException {
if (this.defaultKeyBundle == null) {
throw new NoCollectionKeysSetException();
}
return this.defaultKeyBundle;
}
public boolean keyBundleForCollectionIsNotDefault(String collection) {
return collectionKeyBundles.containsKey(collection);
}
public KeyBundle keyBundleForCollection(String collection)
throws NoCollectionKeysSetException {
if (this.defaultKeyBundle == null) {
throw new NoCollectionKeysSetException();
}
if (keyBundleForCollectionIsNotDefault(collection)) {
return collectionKeyBundles.get(collection);
}
return this.defaultKeyBundle;
}
/**
* Take a pair of values in a JSON array, handing them off to KeyBundle to
* produce a usable keypair.
*/
private static KeyBundle arrayToKeyBundle(JSONArray array) throws UnsupportedEncodingException {
String encKeyStr = (String) array.get(0);
String hmacKeyStr = (String) array.get(1);
return KeyBundle.fromBase64EncodedKeys(encKeyStr, hmacKeyStr);
}
@SuppressWarnings("unchecked")
private static JSONArray keyBundleToArray(KeyBundle bundle) {
// Generate JSON.
JSONArray keysArray = new JSONArray();
keysArray.add(new String(Base64.encodeBase64(bundle.getEncryptionKey())));
keysArray.add(new String(Base64.encodeBase64(bundle.getHMACKey())));
return keysArray;
}
private ExtendedJSONObject asRecordContents() throws NoCollectionKeysSetException {
ExtendedJSONObject json = new ExtendedJSONObject();
json.put("id", "keys");
json.put("collection", "crypto");
json.put("default", keyBundleToArray(this.defaultKeyBundle()));
ExtendedJSONObject colls = new ExtendedJSONObject();
for (Entry<String, KeyBundle> collKey : collectionKeyBundles.entrySet()) {
colls.put(collKey.getKey(), keyBundleToArray(collKey.getValue()));
}
json.put("collections", colls);
return json;
}
public CryptoRecord asCryptoRecord() throws NoCollectionKeysSetException {
ExtendedJSONObject payload = this.asRecordContents();
CryptoRecord record = new CryptoRecord(payload);
record.collection = "crypto";
record.guid = "keys";
record.deleted = false;
return record;
}
/**
* Set my key bundle and collection keys with the given key bundle and data
* (possibly decrypted) from the given record.
*
* @param keys
* A "crypto/keys" <code>CryptoRecord</code>, encrypted with
* <code>syncKeyBundle</code> if <code>syncKeyBundle</code> is non-null.
* @param syncKeyBundle
* If non-null, the sync key bundle to decrypt <code>keys</code> with.
*/
public void setKeyPairsFromWBO(CryptoRecord keys, KeyBundle syncKeyBundle)
throws CryptoException, IOException, NonObjectJSONException {
if (keys == null) {
throw new IllegalArgumentException("cannot set key pairs from null record");
}
if (syncKeyBundle != null) {
keys.keyBundle = syncKeyBundle;
keys.decrypt();
}
ExtendedJSONObject cleartext = keys.payload;
KeyBundle defaultKey = arrayToKeyBundle((JSONArray) cleartext.get("default"));
ExtendedJSONObject collections = cleartext.getObject("collections");
HashMap<String, KeyBundle> collectionKeys = new HashMap<String, KeyBundle>();
for (Entry<String, Object> pair : collections.entrySet()) {
KeyBundle bundle = arrayToKeyBundle((JSONArray) pair.getValue());
collectionKeys.put(pair.getKey(), bundle);
}
this.collectionKeyBundles.clear();
this.collectionKeyBundles.putAll(collectionKeys);
this.defaultKeyBundle = defaultKey;
}
public void setKeyBundleForCollection(String collection, KeyBundle keys) {
this.collectionKeyBundles.put(collection, keys);
}
public void setDefaultKeyBundle(KeyBundle keys) {
this.defaultKeyBundle = keys;
}
public void clear() {
this.defaultKeyBundle = null;
this.collectionKeyBundles.clear();
}
/**
* Return set of collections where key is either missing from one collection
* or not the same in both collections.
* <p>
* Does not check for different default keys.
*/
public static Set<String> differences(CollectionKeys a, CollectionKeys b) {
Set<String> differences = new HashSet<String>();
Set<String> collections = new HashSet<String>(a.collectionKeyBundles.keySet());
collections.addAll(b.collectionKeyBundles.keySet());
// Iterate through one collection, collecting missing and differences.
for (String collection : collections) {
KeyBundle keyA;
KeyBundle keyB;
try {
keyA = a.keyBundleForCollection(collection); // Will return default key as appropriate.
keyB = b.keyBundleForCollection(collection); // Will return default key as appropriate.
} catch (NoCollectionKeysSetException e) {
differences.add(collection);
continue;
}
// keyA and keyB are not null at this point.
if (!keyA.equals(keyB)) {
differences.add(collection);
}
}
return differences;
}
@Override
public boolean equals(Object o) {
if (!(o instanceof CollectionKeys)) {
return false;
}
CollectionKeys other = (CollectionKeys) o;
try {
// It would be nice to use map equality here, but there can be map entries
// where the key is the default key that should compare equal to a missing
// map entry. Therefore, we always compute the set of differences.
return defaultKeyBundle().equals(other.defaultKeyBundle()) &&
CollectionKeys.differences(this, other).isEmpty();
} catch (NoCollectionKeysSetException e) {
// If either default key bundle is not set, we'll say the bundles are not equal.
return false;
}
}
@Override
public int hashCode() {
return super.hashCode();
}
}
|
