在 Java 中为 Web Push API 加密消息
Encrypt message for Web Push API in Java
我正在尝试创建一个能够使用 Push API 发送推送消息的服务器：https://developer.mozilla.org/en-US/docs/Web/API/Push_API
我已经让客户端正常工作，但现在我希望能够从 Java 服务器发送带有负载的消息。
我看到了 nodejs web-push 示例 (https://www.npmjs.com/package/web-push) 但我无法将其正确翻译成 Java.
我尝试按照示例使用此处找到的 DH 密钥交换：http://docs.oracle.com/javase/7/docs/technotes/guides/security/crypto/CryptoSpec.html#DH2Ex
在下面的 sheltond 的帮助下，我能够找出一些应该工作但没有工作的代码。
当我 post 将加密消息发送到推送服务时，我得到了预期的 201 状态代码，但推送从未到达 Firefox。如果我删除有效负载和 headers 并简单地向同一个 URL 发送一个 POST 请求，则消息成功到达 Firefox，但没有任何数据。我怀疑这可能与我使用 Cipher.getInstance("AES/GCM/NoPadding");
加密数据的方式有关
这是我目前使用的代码：
try {
final byte[] alicePubKeyEnc = Util.fromBase64("BASE_64_PUBLIC_KEY_FROM_PUSH_SUBSCRIPTION");
KeyPairGenerator kpg = KeyPairGenerator.getInstance("EC");
ECGenParameterSpec kpgparams = new ECGenParameterSpec("secp256r1");
kpg.initialize(kpgparams);
ECParameterSpec params = ((ECPublicKey) kpg.generateKeyPair().getPublic()).getParams();
final ECPublicKey alicePubKey = fromUncompressedPoint(alicePubKeyEnc, params);
KeyPairGenerator bobKpairGen = KeyPairGenerator.getInstance("EC");
bobKpairGen.initialize(params);
KeyPair bobKpair = bobKpairGen.generateKeyPair();
KeyAgreement bobKeyAgree = KeyAgreement.getInstance("ECDH");
bobKeyAgree.init(bobKpair.getPrivate());
byte[] bobPubKeyEnc = toUncompressedPoint((ECPublicKey) bobKpair.getPublic());
bobKeyAgree.doPhase(alicePubKey, true);
Cipher bobCipher = Cipher.getInstance("AES/GCM/NoPadding");
SecretKey bobDesKey = bobKeyAgree.generateSecret("AES");
byte[] saltBytes = new byte[16];
new SecureRandom().nextBytes(saltBytes);
Mac extract = Mac.getInstance("HmacSHA256");
extract.init(new SecretKeySpec(saltBytes, "HmacSHA256"));
final byte[] prk = extract.doFinal(bobDesKey.getEncoded());
// Expand
Mac expand = Mac.getInstance("HmacSHA256");
expand.init(new SecretKeySpec(prk, "HmacSHA256"));
String info = "Content-Encoding: aesgcm128";
expand.update(info.getBytes(StandardCharsets.US_ASCII));
expand.update((byte) 1);
final byte[] key_bytes = expand.doFinal();
// Use the result
SecretKeySpec key = new SecretKeySpec(key_bytes, 0, 16, "AES");
bobCipher.init(Cipher.ENCRYPT_MODE, key);
byte[] cleartext = "{\"this\":\"is a test that is supposed to be working but it is not\"}".getBytes();
byte[] ciphertext = bobCipher.doFinal(cleartext);
URL url = new URL("PUSH_ENDPOINT_URL");
HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
urlConnection.setRequestMethod("POST");
urlConnection.setRequestProperty("Content-Length", ciphertext.length + "");
urlConnection.setRequestProperty("Content-Type", "application/octet-stream");
urlConnection.setRequestProperty("Encryption-Key", "keyid=p256dh;dh=" + Util.toBase64UrlSafe(bobPubKeyEnc));
urlConnection.setRequestProperty("Encryption", "keyid=p256dh;salt=" + Util.toBase64UrlSafe(saltBytes));
urlConnection.setRequestProperty("Content-Encoding", "aesgcm128");
urlConnection.setDoInput(true);
urlConnection.setDoOutput(true);
final OutputStream outputStream = urlConnection.getOutputStream();
outputStream.write(ciphertext);
outputStream.flush();
outputStream.close();
if (urlConnection.getResponseCode() == 201) {
String result = Util.readStream(urlConnection.getInputStream());
Log.v("PUSH", "OK: " + result);
} else {
InputStream errorStream = urlConnection.getErrorStream();
String error = Util.readStream(errorStream);
Log.v("PUSH", "Not OK: " + error);
}
} catch (Exception e) {
Log.v("PUSH", "Not OK: " + e.toString());
}
其中 "BASE_64_PUBLIC_KEY_FROM_PUSH_SUBSCRIPTION" 是浏览器提供的 Push API 订阅方法的密钥，"PUSH_ENDPOINT_URL" 是浏览器提供的推送端点。
如果我从成功的 nodejs web-push 请求中获取值（密文、base64 bobPubKeyEnc 和 salt）并在 Java 中获取它们 hard-code，它就可以工作。如果我将上面的代码与动态值一起使用，它就不起作用。
我确实注意到在 nodejs 实现中工作的密文总是比上面代码的 Java 密文大 1 个字节。我在这里使用的例子总是产生一个 81 字节的密文，但在 nodejs 中它总是 82 字节。这是否为我们提供了可能出错的线索？
如何正确加密有效负载以使其到达 Firefox？
提前感谢您的帮助
参见 https://datatracker.ietf.org/doc/html/draft-ietf-webpush-encryption-01#section-5 and https://w3c.github.io/push-api/#widl-PushSubscription-getKey-ArrayBuffer-PushEncryptionKeyName-name（第 4 点）。
密钥使用 ANSI X9.62 中定义的未压缩格式进行编码，因此您不能使用 x509EncodedKeySpec。
您可以使用 BouncyCastle，它应该支持 X9.62 编码。
看看 Maarten Bodewes 在 this question 中的回答。
他为 encoding/decoding 提供了 Java 从 X9.62 未压缩格式到 ECPublicKey 的源代码，我认为这应该适合你正在尝试做的事情。
== 更新 1 ==
规范说“强制加密的用户代理必须公开椭圆曲线 Diffie-Hellman 在 P-256 曲线 上共享”。
P-256曲线是NIST批准用于美国政府加密应用的标准曲线。 here.
给出了选择此特定曲线（以及其他一些曲线）的定义、参数值和理由
标准库中使用名称“secp256r1”支持这条曲线，但由于我无法完全解决的原因（我认为这与密码学提供者与JDK 本身），您似乎必须跳过一些非常低效的环节才能从此名称获得这些 ECParameterSpec 值之一：
KeyPairGenerator kpg = KeyPairGenerator.getInstance("EC");
ECGenParameterSpec kpgparams = new ECGenParameterSpec("secp256r1");
kpg.initialize(kpgparams);
ECParameterSpec params = ((ECPublicKey) kpg.generateKeyPair().getPublic()).getParams();
这是非常重量级的，因为它实际上使用命名的 ECGenParameterSpec object 生成密钥对，然后从中提取 ECParameterSpec。然后你应该能够使用它来解码（我建议将这个值缓存在某个地方以避免必须经常这样做 key-generation）。
或者，您可以只取 the NIST document 第 8 页的数字并将它们直接插入 ECParameterSpec 构造函数。
有一些代码 here which looks like it does exactly that (around line 124). That code is Apache licensed。我自己没有使用过该代码，但看起来这些常量与 NIST 文档中的内容相匹配。
== 更新 2 ==
实际加密密钥是从 salt（随机生成）和共享秘密（由 DH 密钥交换商定）派生的，使用 HMAC-based 密钥派生函数（HKDF）在 Encrypted Content-Encoding for HTTP.
该文档引用 RFC 5869 并指定使用 SHA-256 作为 HKDF 中使用的哈希值。
此 RFC 描述了一个两阶段过程：提取和扩展。提取阶段定义为：
PRK = HMAC-Hash(salt, IKM)
在web-push的情况下，这应该是一个HMAC-SHA-256操作，盐值应该是你已经拥有的“saltBytes”值，据我所知IKM 值应该是共享密钥（webpush 文档只是说“这些值用于计算内容加密密钥”，而没有具体说明共享密钥是 IKM）。
Expand 阶段采用 Extract 阶段产生的值加上一个 'info' 值，并重复对它们进行 HMAC，直到它为您正在使用的加密算法产生足够的密钥数据（每个的输出HMAC 被送入下一个 - 有关详细信息，请参阅 the RFC）。
本例算法为AEAD_AES_128_GCM，需要128位的密钥，比SHA-256的输出要小，所以只需要在Expand阶段做一次hash即可。
本例中的'info'值必须是“Content-Encoding:aesgcm128”（在Encrypted Content-Encoding for HTTP中指定），所以你需要的操作是：
HMAC-SHA-256(PRK, "Content-Encoding: aesgcm128" | 0x01)
'|'是连接。然后取结果的前 16 个字节，这应该是加密密钥。
在 Java 术语中，这看起来像：
// Extract
Mac extract = Mac.getInstance("HmacSHA256");
extract.init(new SecretKeySpec(saltBytes, "HmacSHA256"));
final byte[] prk = extract.doFinal(bobDesKey.getEncoded());
// Expand
Mac expand = Mac.getInstance("HmacSHA256");
expand.init(new SecretKeySpec(prk, "HmacSHA256"));
String info = "Content-Encoding: aesgcm128";
expand.update(info.getBytes(StandardCharsets.US_ASCII));
expand.update((byte)1);
final byte[] key_bytes = expand.doFinal();
// Use the result
SecretKeySpec key = new SecretKeySpec(key_bytes, 0, 16, "AES");
bobCipher.init(Cipher.ENCRYPT_MODE, key);
作为参考，here's a link 执行此操作的 BouncyCastle 库部分。
终于在webpush文档中注意到了这部分：
Public keys, such as are encoded into the "dh" parameter, MUST be in
the form of an uncompressed point
所以看起来你需要使用这样的东西：
byte[] bobPubKeyEnc = toUncompressedPoint((ECPublicKey)bobKpair.getPublic());
而不是使用标准的 getEncoded() 方法。
== 更新 3 ==
首先，我要指出的是，http 内容加密的规范草案比我之前链接到的规范草案更新：draft-ietf-httpbis-encryption-encoding-00。想要使用这个系统的人应该确保他们使用的是最新的可用规范草案——这项工作正在进行中，似乎每隔几个月就会略有变化。
其次，在该文档的 section 2 中，它指定必须在加密前向明文添加一些填充（并在解密后删除）。
这将解释您提到的您得到的内容与 Node.js 示例生成的内容之间的一个字节长度差异。
文档说：
Each record contains between 1 and 256 octets of padding, inserted
into a record before the enciphered content. Padding consists of a
length byte, followed that number of zero-valued octets. A receiver
MUST fail to decrypt if any padding octet other than the first is
non-zero, or a record has more padding than the record size can
accommodate.
所以我认为您需要做的是在明文之前将一个“0”字节推入密码。您 可以 添加比这更多的填充 - 我看不到任何指定填充必须是可能的最小数量的内容，但是单个 '0' 字节是最简单的（任何阅读此内容的人）试图从另一端解码这些消息的人应该确保它们支持任何合法数量的填充。
一般来说，对于 http 内容加密，机制比这复杂一点（因为你必须将输入拆分为记录并为每个记录添加填充一个），但是 webpush 规范说加密消息必须适合单个记录，因此您无需担心。
注意 webpush 加密规范中的以下文本：
Note that a push service is not required to support more than 4096
octets of payload body, which equates to 4080 octets of cleartext
这里的 4080 个八位字节的明文包括 1 个字节的填充，因此实际上似乎有 4079 个字节的限制。您可以使用“加密”中的“rs”参数指定更大的记录大小header，但根据上面引用的文本，收件人不需要支持。
一个警告：我看到的一些执行此操作的代码似乎正在更改为使用 2 个字节的填充，大概是由于某些拟议的规范更改，但我无法跟踪这是从哪里来的。目前 1 个字节的填充应该没问题，但如果将来停止工作，您可能需要转到 2 个字节 - 正如我上面提到的，该规范正在进行中，浏览器支持目前处于试验阶段。
根据https://jrconlin.github.io/WebPushDataTestPage/
更改代码后可以接收通知
在下面找到修改后的代码：
import com.sun.org.apache.xerces.internal.impl.dv.util.Base64;
import java.io.BufferedInputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.math.BigInteger;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.Security;
import java.security.interfaces.ECPublicKey;
import java.security.spec.ECFieldFp;
import java.security.spec.ECParameterSpec;
import java.security.spec.ECPoint;
import java.security.spec.ECPublicKeySpec;
import java.security.spec.EllipticCurve;
import java.util.Arrays;
import javax.crypto.Cipher;
import javax.crypto.KeyAgreement;
import javax.crypto.Mac;
import javax.crypto.SecretKey;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public class WebPushEncryption {
private static final byte UNCOMPRESSED_POINT_INDICATOR = 0x04;
private static final ECParameterSpec params = new ECParameterSpec(
new EllipticCurve(new ECFieldFp(new BigInteger(
"FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFF",
16)), new BigInteger(
"FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFC",
16), new BigInteger(
"5AC635D8AA3A93E7B3EBBD55769886BC651D06B0CC53B0F63BCE3C3E27D2604B",
16)), new ECPoint(new BigInteger(
"6B17D1F2E12C4247F8BCE6E563A440F277037D812DEB33A0F4A13945D898C296",
16), new BigInteger(
"4FE342E2FE1A7F9B8EE7EB4A7C0F9E162BCE33576B315ECECBB6406837BF51F5",
16)), new BigInteger(
"FFFFFFFF00000000FFFFFFFFFFFFFFFFBCE6FAADA7179E84F3B9CAC2FC632551",
16), 1);
public static void main(String[] args) throws Exception {
Security.addProvider(new BouncyCastleProvider());
String endpoint = "https://updates.push.services.mozilla.com/push/v1/xxx";
final byte[] alicePubKeyEnc = Base64.decode("base64 encoded public key ");
KeyPairGenerator keyGen = KeyPairGenerator.getInstance("ECDH", "BC");
keyGen.initialize(params);
KeyPair bobKpair = keyGen.generateKeyPair();
PrivateKey localPrivateKey = bobKpair.getPrivate();
PublicKey localpublickey = bobKpair.getPublic();
final ECPublicKey remoteKey = fromUncompressedPoint(alicePubKeyEnc, params);
KeyAgreement bobKeyAgree = KeyAgreement.getInstance("ECDH", "BC");
bobKeyAgree.init(localPrivateKey);
byte[] bobPubKeyEnc = toUncompressedPoint((ECPublicKey) bobKpair.getPublic());
bobKeyAgree.doPhase(remoteKey, true);
SecretKey bobDesKey = bobKeyAgree.generateSecret("AES");
byte[] saltBytes = new byte[16];
new SecureRandom().nextBytes(saltBytes);
Mac extract = Mac.getInstance("HmacSHA256", "BC");
extract.init(new SecretKeySpec(saltBytes, "HmacSHA256"));
final byte[] prk = extract.doFinal(bobDesKey.getEncoded());
// Expand
Mac expand = Mac.getInstance("HmacSHA256", "BC");
expand.init(new SecretKeySpec(prk, "HmacSHA256"));
//aes algorithm
String info = "Content-Encoding: aesgcm128";
expand.update(info.getBytes(StandardCharsets.US_ASCII));
expand.update((byte) 1);
final byte[] key_bytes = expand.doFinal();
byte[] key_bytes16 = Arrays.copyOf(key_bytes, 16);
SecretKeySpec key = new SecretKeySpec(key_bytes16, 0, 16, "AES-GCM");
//nonce
expand.reset();
expand.init(new SecretKeySpec(prk, "HmacSHA256"));
String nonceinfo = "Content-Encoding: nonce";
expand.update(nonceinfo.getBytes(StandardCharsets.US_ASCII));
expand.update((byte) 1);
final byte[] nonce_bytes = expand.doFinal();
byte[] nonce_bytes12 = Arrays.copyOf(nonce_bytes, 12);
Cipher bobCipher = Cipher.getInstance("AES/GCM/NoPadding", "BC");
byte[] iv = generateNonce(nonce_bytes12, 0);
bobCipher.init(Cipher.ENCRYPT_MODE, key, new IvParameterSpec(iv));
byte[] cleartext = ("{\n"
+ " \"message\" : \"great match41eeee!\",\n"
+ " \"title\" : \"Portugal vs. Denmark4255\",\n"
+ " \"icon\" : \"http://icons.iconarchive.com/icons/artdesigner/tweet-my-web/256/single-bird-icon.png\",\n"
+ " \"tag\" : \"testtag1\",\n"
+ " \"url\" : \"http://www.yahoo.com\"\n"
+ " }").getBytes();
byte[] cc = new byte[cleartext.length + 1];
cc[0] = 0;
for (int i = 0; i < cleartext.length; i++) {
cc[i + 1] = cleartext[i];
}
cleartext = cc;
byte[] ciphertext = bobCipher.doFinal(cleartext);
URL url = new URL(endpoint);
HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
urlConnection.setRequestMethod("POST");
urlConnection.setRequestProperty("Content-Length", ciphertext.length + "");
urlConnection.setRequestProperty("Content-Type", "application/octet-stream");
urlConnection.setRequestProperty("encryption-key", "keyid=p256dh;dh=" + Base64.encode(bobPubKeyEnc));
urlConnection.setRequestProperty("encryption", "keyid=p256dh;salt=" + Base64.encode(saltBytes));
urlConnection.setRequestProperty("content-encoding", "aesgcm128");
urlConnection.setRequestProperty("ttl", "60");
urlConnection.setDoInput(true);
urlConnection.setDoOutput(true);
final OutputStream outputStream = urlConnection.getOutputStream();
outputStream.write(ciphertext);
outputStream.flush();
outputStream.close();
if (urlConnection.getResponseCode() == 201) {
String result = readStream(urlConnection.getInputStream());
System.out.println("PUSH OK: " + result);
} else {
InputStream errorStream = urlConnection.getErrorStream();
String error = readStream(errorStream);
System.out.println("PUSH" + "Not OK: " + error);
}
}
static byte[] generateNonce(byte[] base, int index) {
byte[] nonce = Arrays.copyOfRange(base, 0, 12);
for (int i = 0; i < 6; ++i) {
nonce[nonce.length - 1 - i] ^= (byte) ((index / Math.pow(256, i))) & (0xff);
}
return nonce;
}
private static String readStream(InputStream errorStream) throws Exception {
BufferedInputStream bs = new BufferedInputStream(errorStream);
int i = 0;
byte[] b = new byte[1024];
StringBuilder sb = new StringBuilder();
while ((i = bs.read(b)) != -1) {
sb.append(new String(b, 0, i));
}
return sb.toString();
}
public static ECPublicKey fromUncompressedPoint(
final byte[] uncompressedPoint, final ECParameterSpec params)
throws Exception {
int offset = 0;
if (uncompressedPoint[offset++] != UNCOMPRESSED_POINT_INDICATOR) {
throw new IllegalArgumentException(
"Invalid uncompressedPoint encoding, no uncompressed point indicator");
}
int keySizeBytes = (params.getOrder().bitLength() + Byte.SIZE - 1)
/ Byte.SIZE;
if (uncompressedPoint.length != 1 + 2 * keySizeBytes) {
throw new IllegalArgumentException(
"Invalid uncompressedPoint encoding, not the correct size");
}
final BigInteger x = new BigInteger(1, Arrays.copyOfRange(
uncompressedPoint, offset, offset + keySizeBytes));
offset += keySizeBytes;
final BigInteger y = new BigInteger(1, Arrays.copyOfRange(
uncompressedPoint, offset, offset + keySizeBytes));
final ECPoint w = new ECPoint(x, y);
final ECPublicKeySpec ecPublicKeySpec = new ECPublicKeySpec(w, params);
final KeyFactory keyFactory = KeyFactory.getInstance("EC");
return (ECPublicKey) keyFactory.generatePublic(ecPublicKeySpec);
}
public static byte[] toUncompressedPoint(final ECPublicKey publicKey) {
int keySizeBytes = (publicKey.getParams().getOrder().bitLength() + Byte.SIZE - 1)
/ Byte.SIZE;
final byte[] uncompressedPoint = new byte[1 + 2 * keySizeBytes];
int offset = 0;
uncompressedPoint[offset++] = 0x04;
final byte[] x = publicKey.getW().getAffineX().toByteArray();
if (x.length <= keySizeBytes) {
System.arraycopy(x, 0, uncompressedPoint, offset + keySizeBytes
- x.length, x.length);
} else if (x.length == keySizeBytes + 1 && x[0] == 0) {
System.arraycopy(x, 1, uncompressedPoint, offset, keySizeBytes);
} else {
throw new IllegalStateException("x value is too large");
}
offset += keySizeBytes;
final byte[] y = publicKey.getW().getAffineY().toByteArray();
if (y.length <= keySizeBytes) {
System.arraycopy(y, 0, uncompressedPoint, offset + keySizeBytes
- y.length, y.length);
} else if (y.length == keySizeBytes + 1 && y[0] == 0) {
System.arraycopy(y, 1, uncompressedPoint, offset, keySizeBytes);
} else {
throw new IllegalStateException("y value is too large");
}
return uncompressedPoint;
}
}
santosh kumar 的解决方案只需修改一下即可：
我在定义明文字节[]之前添加了一个 1 字节的密码填充。
Cipher bobCipher = Cipher.getInstance("AES/GCM/NoPadding", "BC");
byte[] iv = generateNonce(nonce_bytes12, 0);
bobCipher.init(Cipher.ENCRYPT_MODE, key, new IvParameterSpec(iv));
// adding firefox padding:
bobCipher.update(new byte[1]);
byte[] cleartext = {...};
我正在尝试创建一个能够使用 Push API 发送推送消息的服务器：https://developer.mozilla.org/en-US/docs/Web/API/Push_API
我已经让客户端正常工作，但现在我希望能够从 Java 服务器发送带有负载的消息。
我看到了 nodejs web-push 示例 (https://www.npmjs.com/package/web-push) 但我无法将其正确翻译成 Java.
我尝试按照示例使用此处找到的 DH 密钥交换：http://docs.oracle.com/javase/7/docs/technotes/guides/security/crypto/CryptoSpec.html#DH2Ex
在下面的 sheltond 的帮助下，我能够找出一些应该工作但没有工作的代码。
当我 post 将加密消息发送到推送服务时，我得到了预期的 201 状态代码，但推送从未到达 Firefox。如果我删除有效负载和 headers 并简单地向同一个 URL 发送一个 POST 请求，则消息成功到达 Firefox，但没有任何数据。我怀疑这可能与我使用 Cipher.getInstance("AES/GCM/NoPadding");
加密数据的方式有关这是我目前使用的代码：
try {
final byte[] alicePubKeyEnc = Util.fromBase64("BASE_64_PUBLIC_KEY_FROM_PUSH_SUBSCRIPTION");
KeyPairGenerator kpg = KeyPairGenerator.getInstance("EC");
ECGenParameterSpec kpgparams = new ECGenParameterSpec("secp256r1");
kpg.initialize(kpgparams);
ECParameterSpec params = ((ECPublicKey) kpg.generateKeyPair().getPublic()).getParams();
final ECPublicKey alicePubKey = fromUncompressedPoint(alicePubKeyEnc, params);
KeyPairGenerator bobKpairGen = KeyPairGenerator.getInstance("EC");
bobKpairGen.initialize(params);
KeyPair bobKpair = bobKpairGen.generateKeyPair();
KeyAgreement bobKeyAgree = KeyAgreement.getInstance("ECDH");
bobKeyAgree.init(bobKpair.getPrivate());
byte[] bobPubKeyEnc = toUncompressedPoint((ECPublicKey) bobKpair.getPublic());
bobKeyAgree.doPhase(alicePubKey, true);
Cipher bobCipher = Cipher.getInstance("AES/GCM/NoPadding");
SecretKey bobDesKey = bobKeyAgree.generateSecret("AES");
byte[] saltBytes = new byte[16];
new SecureRandom().nextBytes(saltBytes);
Mac extract = Mac.getInstance("HmacSHA256");
extract.init(new SecretKeySpec(saltBytes, "HmacSHA256"));
final byte[] prk = extract.doFinal(bobDesKey.getEncoded());
// Expand
Mac expand = Mac.getInstance("HmacSHA256");
expand.init(new SecretKeySpec(prk, "HmacSHA256"));
String info = "Content-Encoding: aesgcm128";
expand.update(info.getBytes(StandardCharsets.US_ASCII));
expand.update((byte) 1);
final byte[] key_bytes = expand.doFinal();
// Use the result
SecretKeySpec key = new SecretKeySpec(key_bytes, 0, 16, "AES");
bobCipher.init(Cipher.ENCRYPT_MODE, key);
byte[] cleartext = "{\"this\":\"is a test that is supposed to be working but it is not\"}".getBytes();
byte[] ciphertext = bobCipher.doFinal(cleartext);
URL url = new URL("PUSH_ENDPOINT_URL");
HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
urlConnection.setRequestMethod("POST");
urlConnection.setRequestProperty("Content-Length", ciphertext.length + "");
urlConnection.setRequestProperty("Content-Type", "application/octet-stream");
urlConnection.setRequestProperty("Encryption-Key", "keyid=p256dh;dh=" + Util.toBase64UrlSafe(bobPubKeyEnc));
urlConnection.setRequestProperty("Encryption", "keyid=p256dh;salt=" + Util.toBase64UrlSafe(saltBytes));
urlConnection.setRequestProperty("Content-Encoding", "aesgcm128");
urlConnection.setDoInput(true);
urlConnection.setDoOutput(true);
final OutputStream outputStream = urlConnection.getOutputStream();
outputStream.write(ciphertext);
outputStream.flush();
outputStream.close();
if (urlConnection.getResponseCode() == 201) {
String result = Util.readStream(urlConnection.getInputStream());
Log.v("PUSH", "OK: " + result);
} else {
InputStream errorStream = urlConnection.getErrorStream();
String error = Util.readStream(errorStream);
Log.v("PUSH", "Not OK: " + error);
}
} catch (Exception e) {
Log.v("PUSH", "Not OK: " + e.toString());
}
其中 "BASE_64_PUBLIC_KEY_FROM_PUSH_SUBSCRIPTION" 是浏览器提供的 Push API 订阅方法的密钥，"PUSH_ENDPOINT_URL" 是浏览器提供的推送端点。
如果我从成功的 nodejs web-push 请求中获取值（密文、base64 bobPubKeyEnc 和 salt）并在 Java 中获取它们 hard-code，它就可以工作。如果我将上面的代码与动态值一起使用，它就不起作用。
我确实注意到在 nodejs 实现中工作的密文总是比上面代码的 Java 密文大 1 个字节。我在这里使用的例子总是产生一个 81 字节的密文，但在 nodejs 中它总是 82 字节。这是否为我们提供了可能出错的线索？
如何正确加密有效负载以使其到达 Firefox？
提前感谢您的帮助
参见 https://datatracker.ietf.org/doc/html/draft-ietf-webpush-encryption-01#section-5 and https://w3c.github.io/push-api/#widl-PushSubscription-getKey-ArrayBuffer-PushEncryptionKeyName-name（第 4 点）。
密钥使用 ANSI X9.62 中定义的未压缩格式进行编码，因此您不能使用 x509EncodedKeySpec。
您可以使用 BouncyCastle，它应该支持 X9.62 编码。
看看 Maarten Bodewes 在 this question 中的回答。
他为 encoding/decoding 提供了 Java 从 X9.62 未压缩格式到 ECPublicKey 的源代码，我认为这应该适合你正在尝试做的事情。
== 更新 1 ==
规范说“强制加密的用户代理必须公开椭圆曲线 Diffie-Hellman 在 P-256 曲线 上共享”。
P-256曲线是NIST批准用于美国政府加密应用的标准曲线。 here.
给出了选择此特定曲线（以及其他一些曲线）的定义、参数值和理由标准库中使用名称“secp256r1”支持这条曲线，但由于我无法完全解决的原因（我认为这与密码学提供者与JDK 本身），您似乎必须跳过一些非常低效的环节才能从此名称获得这些 ECParameterSpec 值之一：
KeyPairGenerator kpg = KeyPairGenerator.getInstance("EC");
ECGenParameterSpec kpgparams = new ECGenParameterSpec("secp256r1");
kpg.initialize(kpgparams);
ECParameterSpec params = ((ECPublicKey) kpg.generateKeyPair().getPublic()).getParams();
这是非常重量级的，因为它实际上使用命名的 ECGenParameterSpec object 生成密钥对，然后从中提取 ECParameterSpec。然后你应该能够使用它来解码（我建议将这个值缓存在某个地方以避免必须经常这样做 key-generation）。
或者，您可以只取 the NIST document 第 8 页的数字并将它们直接插入 ECParameterSpec 构造函数。
有一些代码 here which looks like it does exactly that (around line 124). That code is Apache licensed。我自己没有使用过该代码，但看起来这些常量与 NIST 文档中的内容相匹配。
== 更新 2 ==
实际加密密钥是从 salt（随机生成）和共享秘密（由 DH 密钥交换商定）派生的，使用 HMAC-based 密钥派生函数（HKDF）在 Encrypted Content-Encoding for HTTP.
该文档引用 RFC 5869 并指定使用 SHA-256 作为 HKDF 中使用的哈希值。
此 RFC 描述了一个两阶段过程：提取和扩展。提取阶段定义为：
PRK = HMAC-Hash(salt, IKM)
在web-push的情况下，这应该是一个HMAC-SHA-256操作，盐值应该是你已经拥有的“saltBytes”值，据我所知IKM 值应该是共享密钥（webpush 文档只是说“这些值用于计算内容加密密钥”，而没有具体说明共享密钥是 IKM）。
Expand 阶段采用 Extract 阶段产生的值加上一个 'info' 值，并重复对它们进行 HMAC，直到它为您正在使用的加密算法产生足够的密钥数据（每个的输出HMAC 被送入下一个 - 有关详细信息，请参阅 the RFC）。
本例算法为AEAD_AES_128_GCM，需要128位的密钥，比SHA-256的输出要小，所以只需要在Expand阶段做一次hash即可。
本例中的'info'值必须是“Content-Encoding:aesgcm128”（在Encrypted Content-Encoding for HTTP中指定），所以你需要的操作是：
HMAC-SHA-256(PRK, "Content-Encoding: aesgcm128" | 0x01)
'|'是连接。然后取结果的前 16 个字节，这应该是加密密钥。
在 Java 术语中，这看起来像：
// Extract
Mac extract = Mac.getInstance("HmacSHA256");
extract.init(new SecretKeySpec(saltBytes, "HmacSHA256"));
final byte[] prk = extract.doFinal(bobDesKey.getEncoded());
// Expand
Mac expand = Mac.getInstance("HmacSHA256");
expand.init(new SecretKeySpec(prk, "HmacSHA256"));
String info = "Content-Encoding: aesgcm128";
expand.update(info.getBytes(StandardCharsets.US_ASCII));
expand.update((byte)1);
final byte[] key_bytes = expand.doFinal();
// Use the result
SecretKeySpec key = new SecretKeySpec(key_bytes, 0, 16, "AES");
bobCipher.init(Cipher.ENCRYPT_MODE, key);
作为参考，here's a link 执行此操作的 BouncyCastle 库部分。
终于在webpush文档中注意到了这部分：
Public keys, such as are encoded into the "dh" parameter, MUST be in the form of an uncompressed point
所以看起来你需要使用这样的东西：
byte[] bobPubKeyEnc = toUncompressedPoint((ECPublicKey)bobKpair.getPublic());
而不是使用标准的 getEncoded() 方法。
== 更新 3 ==
首先，我要指出的是，http 内容加密的规范草案比我之前链接到的规范草案更新：draft-ietf-httpbis-encryption-encoding-00。想要使用这个系统的人应该确保他们使用的是最新的可用规范草案——这项工作正在进行中，似乎每隔几个月就会略有变化。
其次，在该文档的 section 2 中，它指定必须在加密前向明文添加一些填充（并在解密后删除）。
这将解释您提到的您得到的内容与 Node.js 示例生成的内容之间的一个字节长度差异。
文档说：
Each record contains between 1 and 256 octets of padding, inserted into a record before the enciphered content. Padding consists of a length byte, followed that number of zero-valued octets. A receiver MUST fail to decrypt if any padding octet other than the first is non-zero, or a record has more padding than the record size can accommodate.
所以我认为您需要做的是在明文之前将一个“0”字节推入密码。您 可以 添加比这更多的填充 - 我看不到任何指定填充必须是可能的最小数量的内容，但是单个 '0' 字节是最简单的（任何阅读此内容的人）试图从另一端解码这些消息的人应该确保它们支持任何合法数量的填充。
一般来说，对于 http 内容加密，机制比这复杂一点（因为你必须将输入拆分为记录并为每个记录添加填充一个），但是 webpush 规范说加密消息必须适合单个记录，因此您无需担心。
注意 webpush 加密规范中的以下文本：
Note that a push service is not required to support more than 4096 octets of payload body, which equates to 4080 octets of cleartext
这里的 4080 个八位字节的明文包括 1 个字节的填充，因此实际上似乎有 4079 个字节的限制。您可以使用“加密”中的“rs”参数指定更大的记录大小header，但根据上面引用的文本，收件人不需要支持。
一个警告：我看到的一些执行此操作的代码似乎正在更改为使用 2 个字节的填充，大概是由于某些拟议的规范更改，但我无法跟踪这是从哪里来的。目前 1 个字节的填充应该没问题，但如果将来停止工作，您可能需要转到 2 个字节 - 正如我上面提到的，该规范正在进行中，浏览器支持目前处于试验阶段。
根据https://jrconlin.github.io/WebPushDataTestPage/
更改代码后可以接收通知在下面找到修改后的代码：
import com.sun.org.apache.xerces.internal.impl.dv.util.Base64;
import java.io.BufferedInputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.math.BigInteger;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.Security;
import java.security.interfaces.ECPublicKey;
import java.security.spec.ECFieldFp;
import java.security.spec.ECParameterSpec;
import java.security.spec.ECPoint;
import java.security.spec.ECPublicKeySpec;
import java.security.spec.EllipticCurve;
import java.util.Arrays;
import javax.crypto.Cipher;
import javax.crypto.KeyAgreement;
import javax.crypto.Mac;
import javax.crypto.SecretKey;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public class WebPushEncryption {
private static final byte UNCOMPRESSED_POINT_INDICATOR = 0x04;
private static final ECParameterSpec params = new ECParameterSpec(
new EllipticCurve(new ECFieldFp(new BigInteger(
"FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFF",
16)), new BigInteger(
"FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFC",
16), new BigInteger(
"5AC635D8AA3A93E7B3EBBD55769886BC651D06B0CC53B0F63BCE3C3E27D2604B",
16)), new ECPoint(new BigInteger(
"6B17D1F2E12C4247F8BCE6E563A440F277037D812DEB33A0F4A13945D898C296",
16), new BigInteger(
"4FE342E2FE1A7F9B8EE7EB4A7C0F9E162BCE33576B315ECECBB6406837BF51F5",
16)), new BigInteger(
"FFFFFFFF00000000FFFFFFFFFFFFFFFFBCE6FAADA7179E84F3B9CAC2FC632551",
16), 1);
public static void main(String[] args) throws Exception {
Security.addProvider(new BouncyCastleProvider());
String endpoint = "https://updates.push.services.mozilla.com/push/v1/xxx";
final byte[] alicePubKeyEnc = Base64.decode("base64 encoded public key ");
KeyPairGenerator keyGen = KeyPairGenerator.getInstance("ECDH", "BC");
keyGen.initialize(params);
KeyPair bobKpair = keyGen.generateKeyPair();
PrivateKey localPrivateKey = bobKpair.getPrivate();
PublicKey localpublickey = bobKpair.getPublic();
final ECPublicKey remoteKey = fromUncompressedPoint(alicePubKeyEnc, params);
KeyAgreement bobKeyAgree = KeyAgreement.getInstance("ECDH", "BC");
bobKeyAgree.init(localPrivateKey);
byte[] bobPubKeyEnc = toUncompressedPoint((ECPublicKey) bobKpair.getPublic());
bobKeyAgree.doPhase(remoteKey, true);
SecretKey bobDesKey = bobKeyAgree.generateSecret("AES");
byte[] saltBytes = new byte[16];
new SecureRandom().nextBytes(saltBytes);
Mac extract = Mac.getInstance("HmacSHA256", "BC");
extract.init(new SecretKeySpec(saltBytes, "HmacSHA256"));
final byte[] prk = extract.doFinal(bobDesKey.getEncoded());
// Expand
Mac expand = Mac.getInstance("HmacSHA256", "BC");
expand.init(new SecretKeySpec(prk, "HmacSHA256"));
//aes algorithm
String info = "Content-Encoding: aesgcm128";
expand.update(info.getBytes(StandardCharsets.US_ASCII));
expand.update((byte) 1);
final byte[] key_bytes = expand.doFinal();
byte[] key_bytes16 = Arrays.copyOf(key_bytes, 16);
SecretKeySpec key = new SecretKeySpec(key_bytes16, 0, 16, "AES-GCM");
//nonce
expand.reset();
expand.init(new SecretKeySpec(prk, "HmacSHA256"));
String nonceinfo = "Content-Encoding: nonce";
expand.update(nonceinfo.getBytes(StandardCharsets.US_ASCII));
expand.update((byte) 1);
final byte[] nonce_bytes = expand.doFinal();
byte[] nonce_bytes12 = Arrays.copyOf(nonce_bytes, 12);
Cipher bobCipher = Cipher.getInstance("AES/GCM/NoPadding", "BC");
byte[] iv = generateNonce(nonce_bytes12, 0);
bobCipher.init(Cipher.ENCRYPT_MODE, key, new IvParameterSpec(iv));
byte[] cleartext = ("{\n"
+ " \"message\" : \"great match41eeee!\",\n"
+ " \"title\" : \"Portugal vs. Denmark4255\",\n"
+ " \"icon\" : \"http://icons.iconarchive.com/icons/artdesigner/tweet-my-web/256/single-bird-icon.png\",\n"
+ " \"tag\" : \"testtag1\",\n"
+ " \"url\" : \"http://www.yahoo.com\"\n"
+ " }").getBytes();
byte[] cc = new byte[cleartext.length + 1];
cc[0] = 0;
for (int i = 0; i < cleartext.length; i++) {
cc[i + 1] = cleartext[i];
}
cleartext = cc;
byte[] ciphertext = bobCipher.doFinal(cleartext);
URL url = new URL(endpoint);
HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
urlConnection.setRequestMethod("POST");
urlConnection.setRequestProperty("Content-Length", ciphertext.length + "");
urlConnection.setRequestProperty("Content-Type", "application/octet-stream");
urlConnection.setRequestProperty("encryption-key", "keyid=p256dh;dh=" + Base64.encode(bobPubKeyEnc));
urlConnection.setRequestProperty("encryption", "keyid=p256dh;salt=" + Base64.encode(saltBytes));
urlConnection.setRequestProperty("content-encoding", "aesgcm128");
urlConnection.setRequestProperty("ttl", "60");
urlConnection.setDoInput(true);
urlConnection.setDoOutput(true);
final OutputStream outputStream = urlConnection.getOutputStream();
outputStream.write(ciphertext);
outputStream.flush();
outputStream.close();
if (urlConnection.getResponseCode() == 201) {
String result = readStream(urlConnection.getInputStream());
System.out.println("PUSH OK: " + result);
} else {
InputStream errorStream = urlConnection.getErrorStream();
String error = readStream(errorStream);
System.out.println("PUSH" + "Not OK: " + error);
}
}
static byte[] generateNonce(byte[] base, int index) {
byte[] nonce = Arrays.copyOfRange(base, 0, 12);
for (int i = 0; i < 6; ++i) {
nonce[nonce.length - 1 - i] ^= (byte) ((index / Math.pow(256, i))) & (0xff);
}
return nonce;
}
private static String readStream(InputStream errorStream) throws Exception {
BufferedInputStream bs = new BufferedInputStream(errorStream);
int i = 0;
byte[] b = new byte[1024];
StringBuilder sb = new StringBuilder();
while ((i = bs.read(b)) != -1) {
sb.append(new String(b, 0, i));
}
return sb.toString();
}
public static ECPublicKey fromUncompressedPoint(
final byte[] uncompressedPoint, final ECParameterSpec params)
throws Exception {
int offset = 0;
if (uncompressedPoint[offset++] != UNCOMPRESSED_POINT_INDICATOR) {
throw new IllegalArgumentException(
"Invalid uncompressedPoint encoding, no uncompressed point indicator");
}
int keySizeBytes = (params.getOrder().bitLength() + Byte.SIZE - 1)
/ Byte.SIZE;
if (uncompressedPoint.length != 1 + 2 * keySizeBytes) {
throw new IllegalArgumentException(
"Invalid uncompressedPoint encoding, not the correct size");
}
final BigInteger x = new BigInteger(1, Arrays.copyOfRange(
uncompressedPoint, offset, offset + keySizeBytes));
offset += keySizeBytes;
final BigInteger y = new BigInteger(1, Arrays.copyOfRange(
uncompressedPoint, offset, offset + keySizeBytes));
final ECPoint w = new ECPoint(x, y);
final ECPublicKeySpec ecPublicKeySpec = new ECPublicKeySpec(w, params);
final KeyFactory keyFactory = KeyFactory.getInstance("EC");
return (ECPublicKey) keyFactory.generatePublic(ecPublicKeySpec);
}
public static byte[] toUncompressedPoint(final ECPublicKey publicKey) {
int keySizeBytes = (publicKey.getParams().getOrder().bitLength() + Byte.SIZE - 1)
/ Byte.SIZE;
final byte[] uncompressedPoint = new byte[1 + 2 * keySizeBytes];
int offset = 0;
uncompressedPoint[offset++] = 0x04;
final byte[] x = publicKey.getW().getAffineX().toByteArray();
if (x.length <= keySizeBytes) {
System.arraycopy(x, 0, uncompressedPoint, offset + keySizeBytes
- x.length, x.length);
} else if (x.length == keySizeBytes + 1 && x[0] == 0) {
System.arraycopy(x, 1, uncompressedPoint, offset, keySizeBytes);
} else {
throw new IllegalStateException("x value is too large");
}
offset += keySizeBytes;
final byte[] y = publicKey.getW().getAffineY().toByteArray();
if (y.length <= keySizeBytes) {
System.arraycopy(y, 0, uncompressedPoint, offset + keySizeBytes
- y.length, y.length);
} else if (y.length == keySizeBytes + 1 && y[0] == 0) {
System.arraycopy(y, 1, uncompressedPoint, offset, keySizeBytes);
} else {
throw new IllegalStateException("y value is too large");
}
return uncompressedPoint;
}
}
santosh kumar 的解决方案只需修改一下即可：
我在定义明文字节[]之前添加了一个 1 字节的密码填充。
Cipher bobCipher = Cipher.getInstance("AES/GCM/NoPadding", "BC");
byte[] iv = generateNonce(nonce_bytes12, 0);
bobCipher.init(Cipher.ENCRYPT_MODE, key, new IvParameterSpec(iv));
// adding firefox padding:
bobCipher.update(new byte[1]);
byte[] cleartext = {...};