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
|
/* 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.crypto;
import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import javax.crypto.KeyGenerator;
import javax.crypto.Mac;
import org.mozilla.apache.commons.codec.binary.Base64;
import org.mozilla.gecko.sync.Utils;
public class KeyBundle {
private static final String KEY_ALGORITHM_SPEC = "AES";
private static final int KEY_SIZE = 256;
private byte[] encryptionKey;
private byte[] hmacKey;
// These are the same for every sync key bundle.
private static final byte[] EMPTY_BYTES = {};
private static final byte[] ENCR_INPUT_BYTES = {1};
private static final byte[] HMAC_INPUT_BYTES = {2};
/*
* Mozilla's use of HKDF for getting keys from the Sync Key string.
*
* We do exactly 2 HKDF iterations and make the first iteration the
* encryption key and the second iteration the HMAC key.
*
*/
public KeyBundle(String username, String base32SyncKey) throws CryptoException {
if (base32SyncKey == null) {
throw new IllegalArgumentException("No sync key provided.");
}
if (username == null || username.equals("")) {
throw new IllegalArgumentException("No username provided.");
}
// Hash appropriately.
try {
username = Utils.usernameFromAccount(username);
} catch (NoSuchAlgorithmException | UnsupportedEncodingException e) {
throw new IllegalArgumentException("Invalid username.");
}
byte[] syncKey = Utils.decodeFriendlyBase32(base32SyncKey);
byte[] user = username.getBytes();
Mac hmacHasher;
try {
hmacHasher = HKDF.makeHMACHasher(syncKey);
} catch (NoSuchAlgorithmException | InvalidKeyException e) {
throw new CryptoException(e);
}
assert(hmacHasher != null); // If makeHMACHasher doesn't throw, then hmacHasher is non-null.
byte[] encrBytes = Utils.concatAll(EMPTY_BYTES, HKDF.HMAC_INPUT, user, ENCR_INPUT_BYTES);
byte[] encrKey = HKDF.digestBytes(encrBytes, hmacHasher);
byte[] hmacBytes = Utils.concatAll(encrKey, HKDF.HMAC_INPUT, user, HMAC_INPUT_BYTES);
this.hmacKey = HKDF.digestBytes(hmacBytes, hmacHasher);
this.encryptionKey = encrKey;
}
public KeyBundle(byte[] encryptionKey, byte[] hmacKey) {
this.setEncryptionKey(encryptionKey);
this.setHMACKey(hmacKey);
}
/**
* Make a KeyBundle with the specified base64-encoded keys.
*
* @return A KeyBundle with the specified keys.
*/
public static KeyBundle fromBase64EncodedKeys(String base64EncryptionKey, String base64HmacKey) throws UnsupportedEncodingException {
return new KeyBundle(Base64.decodeBase64(base64EncryptionKey.getBytes("UTF-8")),
Base64.decodeBase64(base64HmacKey.getBytes("UTF-8")));
}
/**
* Make a KeyBundle with two random 256 bit keys (encryption and HMAC).
*
* @return A KeyBundle with random keys.
*/
public static KeyBundle withRandomKeys() throws CryptoException {
KeyGenerator keygen;
try {
keygen = KeyGenerator.getInstance(KEY_ALGORITHM_SPEC);
} catch (NoSuchAlgorithmException e) {
throw new CryptoException(e);
}
keygen.init(KEY_SIZE);
byte[] encryptionKey = keygen.generateKey().getEncoded();
byte[] hmacKey = keygen.generateKey().getEncoded();
return new KeyBundle(encryptionKey, hmacKey);
}
public byte[] getEncryptionKey() {
return encryptionKey;
}
public void setEncryptionKey(byte[] encryptionKey) {
this.encryptionKey = encryptionKey;
}
public byte[] getHMACKey() {
return hmacKey;
}
public void setHMACKey(byte[] hmacKey) {
this.hmacKey = hmacKey;
}
@Override
public boolean equals(Object o) {
if (!(o instanceof KeyBundle)) {
return false;
}
KeyBundle other = (KeyBundle) o;
return Arrays.equals(other.encryptionKey, this.encryptionKey) &&
Arrays.equals(other.hmacKey, this.hmacKey);
}
@Override
public int hashCode() {
throw new UnsupportedOperationException("No hashCode for KeyBundle.");
}
}
|
