Skip to content
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Commit 1584cc0

Browse files
reda-alaouireda-alaoui
committedJan 27, 2025·
Init
1 parent 58d90ab commit 1584cc0

13 files changed

+1074
-0
lines changed
 

‎README.md

+64
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,67 @@
1+
[![Build Status](https://github.com/Cosium/standard-webhooks-consumer/actions/workflows/ci.yml/badge.svg)](https://github.com/Cosium/standard-webhooks-consumer/actions/workflows/ci.yml)
2+
![Maven Central Version](https://img.shields.io/maven-central/v/com.cosium.standard_webhooks_consumer/standard-webhooks-consumer)
3+
14
# standard-webhooks-consumer
25

36
https://www.standardwebhooks.com/ consumer side java library.
7+
8+
# Maven dependency
9+
10+
```xml
11+
<dependency>
12+
<groupId>com.cosium.standard_webhooks_consumer</groupId>
13+
<artifactId>standard-webhooks-consumer</artifactId>
14+
<version>${standard-webhooks-consumer.version}</version>
15+
</dependency>
16+
```
17+
18+
# Signature verification
19+
20+
```java
21+
public class App {
22+
23+
public void verifySymmetricSignature() throws WebhookSignatureVerificationException {
24+
25+
WebhookSignatureVerifier verifier =
26+
WebhookSignatureVerifier.builder("whsec_b6Ovv5eS7H5seJrGSStBYDivs8v2/KrFjfMaVZYsi7w=")
27+
.build();
28+
HttpHeaders httpHeaders =
29+
createHttpHeaders(
30+
Map.of(
31+
"webhook-id",
32+
"7a2486b3-31cf-4bd3-a460-df8845d16cd5",
33+
"webhook-timestamp",
34+
String.valueOf(1737987215),
35+
"webhook-signature",
36+
"v1,iayM3VaiYCEDP/CxWUFWcxUCJk2YmBDQHtHTsaHzrwo="));
37+
verifier.verify(httpHeaders, "{\"greetings\": \"Hello World\"}");
38+
}
39+
40+
public void verifyAsymmetricSignature() throws WebhookSignatureVerificationException {
41+
42+
WebhookSignatureVerifier verifier =
43+
WebhookSignatureVerifier.builder("whpk_MCowBQYDK2VwAyEAkp3dScDPIzT1CwUFUMdzyPbWOAQaCF9z4ucuKuZD7Io=")
44+
.build();
45+
46+
HttpHeaders httpHeaders =
47+
createHttpHeaders(
48+
Map.of(
49+
"webhook-id",
50+
"7a2486b3-31cf-4bd3-a460-df8845d16cd5",
51+
"webhook-timestamp",
52+
String.valueOf(1737987215),
53+
"webhook-signature",
54+
"v1a,XVbiOe+IzCKsXBuhb52iHLroqxFJofJNMQRL80I2kWO0+kXu2gcqgXAzontxDDgpMDw6SMh4sjzr+67EmUUzDg=="));
55+
56+
verifier.verify(httpHeaders, "{\"greetings\": \"Hello World\"}");
57+
}
58+
59+
private HttpHeaders createHttpHeaders(Map<String, String> headers) {
60+
return HttpHeaders.of(
61+
headers.entrySet().stream()
62+
.map(entry -> Map.entry(entry.getKey(), List.of(entry.getValue())))
63+
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)),
64+
(s, s2) -> true);
65+
}
66+
}
67+
```

‎pom.xml

+2
Original file line numberDiff line numberDiff line change
@@ -17,6 +17,8 @@
1717
<version>1.0-SNAPSHOT</version>
1818

1919
<properties>
20+
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
21+
2022
<slf4j.version>2.0.15</slf4j.version>
2123
<logback-classic.version>1.4.5</logback-classic.version>
2224
<junit.version>5.10.2</junit.version>

‎src/main/java/com/cosium/standard_webhooks_consumer/CompositeVerificationKeyParser.java

+35
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,35 @@
1+
package com.cosium.standard_webhooks_consumer;
2+
3+
import java.util.List;
4+
import java.util.Optional;
5+
6+
/**
7+
* @author Réda Housni Alaoui
8+
*/
9+
class CompositeVerificationKeyParser {
10+
11+
private final List<VerificationKeyParser> parsers;
12+
13+
CompositeVerificationKeyParser(VerificationKeyParser... parsers) {
14+
this.parsers = List.of(parsers);
15+
}
16+
17+
public VerificationKey parse(String serializedVerificationKey) {
18+
return parsers.stream()
19+
.map(verificationKeyParser -> verificationKeyParser.parse(serializedVerificationKey))
20+
.filter(Optional::isPresent)
21+
.map(Optional::get)
22+
.findFirst()
23+
.orElseThrow(
24+
() ->
25+
new IllegalArgumentException(
26+
"Could not parse verification key <%s>"
27+
.formatted(conceal(serializedVerificationKey))));
28+
}
29+
30+
private String conceal(String serializedVerificationKey) {
31+
int halfLength = Math.round(serializedVerificationKey.length() / 2f);
32+
return serializedVerificationKey.substring(0, halfLength)
33+
+ "*".repeat(serializedVerificationKey.length() - halfLength);
34+
}
35+
}

‎src/main/java/com/cosium/standard_webhooks_consumer/IdentifiedSignature.java

+72
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,72 @@
1+
package com.cosium.standard_webhooks_consumer;
2+
3+
import static java.util.Objects.requireNonNull;
4+
5+
import java.net.http.HttpHeaders;
6+
import java.util.List;
7+
import java.util.Optional;
8+
import java.util.stream.Stream;
9+
import org.slf4j.Logger;
10+
import org.slf4j.LoggerFactory;
11+
12+
/**
13+
* @author Réda Housni Alaoui
14+
*/
15+
record IdentifiedSignature(SignatureSchemeId schemeId, Signature content) {
16+
17+
private static final Logger LOGGER = LoggerFactory.getLogger(IdentifiedSignature.class);
18+
19+
private static final String MESSAGE_SIGNATURE_HEADER_NAME = "webhook-signature";
20+
21+
IdentifiedSignature {
22+
requireNonNull(schemeId);
23+
requireNonNull(content);
24+
}
25+
26+
public static List<IdentifiedSignature> parseAtLeastOne(HttpHeaders headers)
27+
throws WebhookSignatureVerificationException {
28+
String messageSignatureHeaderValue =
29+
headers.firstValue(MESSAGE_SIGNATURE_HEADER_NAME).orElse(null);
30+
if (messageSignatureHeaderValue == null || messageSignatureHeaderValue.isBlank()) {
31+
throw new WebhookSignatureVerificationException(
32+
"No value found for header <%s>".formatted(MESSAGE_SIGNATURE_HEADER_NAME));
33+
}
34+
35+
List<IdentifiedSignature> signatures =
36+
Stream.of(messageSignatureHeaderValue.split(" "))
37+
.map(IdentifiedSignature::parse)
38+
.filter(Optional::isPresent)
39+
.map(Optional::get)
40+
.toList();
41+
42+
if (signatures.isEmpty()) {
43+
throw new WebhookSignatureVerificationException(
44+
"No well-formed signature(s) found for signature header value <%s>. A well-formed signature should have the form '$version,$base64encodedContent'."
45+
.formatted(messageSignatureHeaderValue));
46+
}
47+
48+
return signatures;
49+
}
50+
51+
private static Optional<IdentifiedSignature> parse(String messageSignature) {
52+
if (messageSignature == null || messageSignature.isBlank()) {
53+
return Optional.empty();
54+
}
55+
String[] signatureParts = messageSignature.split(",");
56+
if (signatureParts.length != 2) {
57+
return Optional.empty();
58+
}
59+
60+
IdentifiedSignature signature;
61+
try {
62+
signature =
63+
new IdentifiedSignature(
64+
new SignatureSchemeId(signatureParts[0]), new Signature(signatureParts[1]));
65+
} catch (RuntimeException e) {
66+
LOGGER.warn(e.getMessage());
67+
return Optional.empty();
68+
}
69+
70+
return Optional.of(signature);
71+
}
72+
}

‎src/main/java/com/cosium/standard_webhooks_consumer/PublicKey.java

+82
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,82 @@
1+
package com.cosium.standard_webhooks_consumer;
2+
3+
import static java.util.Objects.requireNonNull;
4+
5+
import java.nio.charset.StandardCharsets;
6+
import java.security.InvalidKeyException;
7+
import java.security.KeyFactory;
8+
import java.security.NoSuchAlgorithmException;
9+
import java.security.SignatureException;
10+
import java.security.spec.InvalidKeySpecException;
11+
import java.security.spec.X509EncodedKeySpec;
12+
import java.util.Base64;
13+
import java.util.Optional;
14+
15+
/**
16+
* @author Réda Housni Alaoui
17+
*/
18+
class PublicKey implements VerificationKey {
19+
20+
private static final String SERIALIZATION_PREFIX = "whpk_";
21+
private static final SignatureSchemeId SCHEME_ID = new SignatureSchemeId("v1a");
22+
private static final String ALGORITHM = "Ed25519";
23+
24+
private final byte[] value;
25+
26+
private PublicKey(byte[] value) {
27+
this.value = requireNonNull(value);
28+
}
29+
30+
public static Optional<PublicKey> parseKey(String serializedVerificationKey) {
31+
if (!serializedVerificationKey.startsWith(SERIALIZATION_PREFIX)) {
32+
return Optional.empty();
33+
}
34+
return Optional.of(
35+
new PublicKey(
36+
Base64.getDecoder()
37+
.decode(serializedVerificationKey.substring(SERIALIZATION_PREFIX.length()))));
38+
}
39+
40+
@Override
41+
public boolean supports(SignatureSchemeId signatureSchemeId) {
42+
return SCHEME_ID.equals(signatureSchemeId);
43+
}
44+
45+
@Override
46+
public void verify(String messageId, long timestamp, String payload, Signature signatureToVerify)
47+
throws WebhookSignatureVerificationException {
48+
try {
49+
doVerify(messageId, timestamp, payload, signatureToVerify);
50+
} catch (NoSuchAlgorithmException
51+
| InvalidKeyException
52+
| SignatureException
53+
| InvalidKeySpecException
54+
| RuntimeException e) {
55+
throw new WebhookSignatureVerificationException(e);
56+
}
57+
}
58+
59+
private void doVerify(
60+
String messageId, long timestamp, String payload, Signature signatureToVerify)
61+
throws NoSuchAlgorithmException,
62+
InvalidKeyException,
63+
SignatureException,
64+
InvalidKeySpecException,
65+
WebhookSignatureVerificationException {
66+
67+
java.security.Signature signature = java.security.Signature.getInstance(ALGORITHM);
68+
69+
java.security.PublicKey publicKey =
70+
KeyFactory.getInstance(ALGORITHM).generatePublic(new X509EncodedKeySpec(value, ALGORITHM));
71+
72+
String signedContent = "%s.%s.%s".formatted(messageId, timestamp, payload);
73+
signature.initVerify(publicKey);
74+
signature.update(signedContent.getBytes(StandardCharsets.UTF_8));
75+
76+
if (signature.verify(signatureToVerify.decode())) {
77+
return;
78+
}
79+
80+
throw new WebhookSignatureVerificationException("%s is not valid".formatted(signatureToVerify));
81+
}
82+
}

‎src/main/java/com/cosium/standard_webhooks_consumer/SecretKey.java

+80
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,80 @@
1+
package com.cosium.standard_webhooks_consumer;
2+
3+
import static java.util.Objects.requireNonNull;
4+
5+
import java.nio.charset.StandardCharsets;
6+
import java.security.InvalidKeyException;
7+
import java.security.NoSuchAlgorithmException;
8+
import java.util.Base64;
9+
import java.util.Optional;
10+
import javax.crypto.Mac;
11+
import javax.crypto.spec.SecretKeySpec;
12+
13+
/**
14+
* @author Réda Housni Alaoui
15+
*/
16+
class SecretKey implements VerificationKey {
17+
18+
private static final String SERIALIZATION_PREFIX = "whsec_";
19+
private static final SignatureSchemeId SCHEME_ID = new SignatureSchemeId("v1");
20+
private static final String ALGORITHM = "HmacSHA256";
21+
22+
private final byte[] value;
23+
24+
private SecretKey(byte[] value) {
25+
this.value = requireNonNull(value);
26+
}
27+
28+
public static Optional<SecretKey> parseKey(String serializedVerificationKey) {
29+
if (!serializedVerificationKey.startsWith(SERIALIZATION_PREFIX)) {
30+
return Optional.empty();
31+
}
32+
return Optional.of(
33+
new SecretKey(
34+
Base64.getDecoder()
35+
.decode(serializedVerificationKey.substring(SERIALIZATION_PREFIX.length()))));
36+
}
37+
38+
@Override
39+
public boolean supports(SignatureSchemeId signatureSchemeId) {
40+
return SCHEME_ID.equals(signatureSchemeId);
41+
}
42+
43+
@Override
44+
public void verify(String messageId, long timestamp, String payload, Signature signatureToVerify)
45+
throws WebhookSignatureVerificationException {
46+
47+
try {
48+
doVerify(messageId, timestamp, payload, signatureToVerify);
49+
} catch (RuntimeException e) {
50+
throw new WebhookSignatureVerificationException(e);
51+
}
52+
}
53+
54+
private void doVerify(
55+
String messageId, long timestamp, String payload, Signature signatureToVerify)
56+
throws WebhookSignatureVerificationException {
57+
String expectedBase64EncodedSignatureContent;
58+
try {
59+
expectedBase64EncodedSignatureContent = sign(messageId, timestamp, payload);
60+
} catch (NoSuchAlgorithmException | InvalidKeyException e) {
61+
throw new WebhookSignatureVerificationException(e);
62+
}
63+
64+
if (expectedBase64EncodedSignatureContent.equals(signatureToVerify.base64EncodedValue())) {
65+
return;
66+
}
67+
68+
throw new WebhookSignatureVerificationException("%s is not valid".formatted(signatureToVerify));
69+
}
70+
71+
private String sign(String messageId, long timestamp, String payload)
72+
throws NoSuchAlgorithmException, InvalidKeyException {
73+
String contentToSign = "%s.%s.%s".formatted(messageId, timestamp, payload);
74+
Mac sha512Hmac = Mac.getInstance(ALGORITHM);
75+
SecretKeySpec keySpec = new SecretKeySpec(value, ALGORITHM);
76+
sha512Hmac.init(keySpec);
77+
byte[] macData = sha512Hmac.doFinal(contentToSign.getBytes(StandardCharsets.UTF_8));
78+
return Base64.getEncoder().encodeToString(macData);
79+
}
80+
}

‎src/main/java/com/cosium/standard_webhooks_consumer/Signature.java

+19
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,19 @@
1+
package com.cosium.standard_webhooks_consumer;
2+
3+
import java.util.Base64;
4+
5+
/**
6+
* @author Réda Housni Alaoui
7+
*/
8+
record Signature(String base64EncodedValue) {
9+
10+
Signature {
11+
if (base64EncodedValue == null || base64EncodedValue.isBlank()) {
12+
throw new IllegalArgumentException("base64EncodedValue cannot be blank");
13+
}
14+
}
15+
16+
public byte[] decode() {
17+
return Base64.getDecoder().decode(base64EncodedValue);
18+
}
19+
}

‎src/main/java/com/cosium/standard_webhooks_consumer/SignatureSchemeId.java

+13
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,13 @@
1+
package com.cosium.standard_webhooks_consumer;
2+
3+
/**
4+
* @author Réda Housni Alaoui
5+
*/
6+
record SignatureSchemeId(String value) {
7+
8+
SignatureSchemeId {
9+
if (value == null || value.isBlank()) {
10+
throw new IllegalArgumentException("The value cannot be blank");
11+
}
12+
}
13+
}

‎src/main/java/com/cosium/standard_webhooks_consumer/VerificationKey.java

+12
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,12 @@
1+
package com.cosium.standard_webhooks_consumer;
2+
3+
/**
4+
* @author Réda Housni Alaoui
5+
*/
6+
interface VerificationKey {
7+
8+
boolean supports(SignatureSchemeId signatureSchemeId);
9+
10+
void verify(String messageId, long timestamp, String payload, Signature signatureToVerify)
11+
throws WebhookSignatureVerificationException;
12+
}

‎src/main/java/com/cosium/standard_webhooks_consumer/VerificationKeyParser.java

+11
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,11 @@
1+
package com.cosium.standard_webhooks_consumer;
2+
3+
import java.util.Optional;
4+
5+
/**
6+
* @author Réda Housni Alaoui
7+
*/
8+
interface VerificationKeyParser {
9+
10+
Optional<? extends VerificationKey> parse(String serializedVerificationKey);
11+
}

‎src/main/java/com/cosium/standard_webhooks_consumer/WebhookSignatureVerificationException.java

+15
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,15 @@
1+
package com.cosium.standard_webhooks_consumer;
2+
3+
/**
4+
* @author Réda Housni Alaoui
5+
*/
6+
public final class WebhookSignatureVerificationException extends Exception {
7+
8+
WebhookSignatureVerificationException(Throwable cause) {
9+
super(cause);
10+
}
11+
12+
WebhookSignatureVerificationException(String message) {
13+
super(message);
14+
}
15+
}

‎src/main/java/com/cosium/standard_webhooks_consumer/WebhookSignatureVerifier.java

+157
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,157 @@
1+
package com.cosium.standard_webhooks_consumer;
2+
3+
import static java.util.Objects.requireNonNull;
4+
5+
import java.net.http.HttpHeaders;
6+
import java.time.Clock;
7+
import java.time.Duration;
8+
import java.util.ArrayList;
9+
import java.util.List;
10+
import org.slf4j.Logger;
11+
import org.slf4j.LoggerFactory;
12+
13+
/**
14+
* @author Réda Housni Alaoui
15+
*/
16+
public class WebhookSignatureVerifier {
17+
18+
private static final Logger LOGGER = LoggerFactory.getLogger(WebhookSignatureVerifier.class);
19+
20+
private static final CompositeVerificationKeyParser VERIFICATION_KEY_PARSER =
21+
new CompositeVerificationKeyParser(SecretKey::parseKey, PublicKey::parseKey);
22+
23+
private static final String MESSAGE_ID_HEADER_NAME = "webhook-id";
24+
private static final String MESSAGE_TIMESTAMP_HEADER_NAME = "webhook-timestamp";
25+
26+
private static final Duration DEFAULT_MESSAGE_TIMESTAMP_ALLOWED_SKEW = Duration.ofMinutes(5);
27+
28+
private final List<VerificationKey> verificationKeys;
29+
private final Clock clock;
30+
private final Duration messageTimestampAllowedSkew;
31+
32+
private WebhookSignatureVerifier(Builder builder) {
33+
34+
verificationKeys =
35+
builder.serializedVerificationKeys.stream().map(VERIFICATION_KEY_PARSER::parse).toList();
36+
clock = builder.clock;
37+
messageTimestampAllowedSkew = builder.messageTimestampAllowedSkew;
38+
}
39+
40+
/**
41+
* @param serializedVerificationKey e.g. "v1,K5oZfzN95Z9UVu1EsfQmfVNQhnkZ2pj9o9NDN/H/pI4="
42+
*/
43+
public static Builder builder(String serializedVerificationKey) {
44+
return new Builder(serializedVerificationKey);
45+
}
46+
47+
public void verify(HttpHeaders headers, String payload)
48+
throws WebhookSignatureVerificationException {
49+
50+
String messageId = headers.firstValue(MESSAGE_ID_HEADER_NAME).orElse(null);
51+
if (messageId == null || messageId.isBlank()) {
52+
throw new WebhookSignatureVerificationException(
53+
"No value found for header <%s>".formatted(MESSAGE_ID_HEADER_NAME));
54+
}
55+
56+
String messageTimestampAsString =
57+
headers.firstValue(MESSAGE_TIMESTAMP_HEADER_NAME).orElse(null);
58+
if (messageTimestampAsString == null || messageTimestampAsString.isBlank()) {
59+
throw new WebhookSignatureVerificationException(
60+
"No value found for header <%s>".formatted(MESSAGE_TIMESTAMP_HEADER_NAME));
61+
}
62+
63+
long timestamp = verifyTimestamp(messageTimestampAsString);
64+
65+
List<WebhookSignatureVerificationException> verificationExceptions = new ArrayList<>();
66+
67+
List<IdentifiedSignature> signatures = IdentifiedSignature.parseAtLeastOne(headers);
68+
for (IdentifiedSignature signature : signatures) {
69+
for (VerificationKey verificationKey : verificationKeys) {
70+
SignatureSchemeId signatureSchemeId = signature.schemeId();
71+
if (!verificationKey.supports(signatureSchemeId)) {
72+
LOGGER.debug("{} does not support {}", verificationKey, signatureSchemeId);
73+
continue;
74+
}
75+
try {
76+
verificationKey.verify(messageId, timestamp, payload, signature.content());
77+
} catch (WebhookSignatureVerificationException e) {
78+
verificationExceptions.add(e);
79+
continue;
80+
}
81+
return;
82+
}
83+
}
84+
85+
if (verificationExceptions.isEmpty()) {
86+
throw new WebhookSignatureVerificationException(
87+
"No supporting verification key found for any signature among %s".formatted(signatures));
88+
}
89+
90+
WebhookSignatureVerificationException collectingException =
91+
new WebhookSignatureVerificationException(
92+
"No signature among %s is valid".formatted(signatures));
93+
verificationExceptions.forEach(collectingException::addSuppressed);
94+
throw collectingException;
95+
}
96+
97+
private long verifyTimestamp(String messageTimestamp)
98+
throws WebhookSignatureVerificationException {
99+
long nowInSeconds = Duration.ofMillis(clock.millis()).toSeconds();
100+
101+
long timestamp;
102+
try {
103+
timestamp = Long.parseLong(messageTimestamp);
104+
} catch (NumberFormatException e) {
105+
throw new WebhookSignatureVerificationException(
106+
"Cannot parse timestamp <%s>".formatted(messageTimestamp));
107+
}
108+
109+
if (timestamp < (nowInSeconds - messageTimestampAllowedSkew.toSeconds())) {
110+
throw new WebhookSignatureVerificationException(
111+
"Message timestamp <%s seconds> is too old compared to the current timestamp <%s seconds>"
112+
.formatted(timestamp, nowInSeconds));
113+
}
114+
if (timestamp > (nowInSeconds + messageTimestampAllowedSkew.toSeconds())) {
115+
throw new WebhookSignatureVerificationException(
116+
"Message timestamp <%s seconds> is too new compared to the current timestamp <%s seconds>"
117+
.formatted(timestamp, nowInSeconds));
118+
}
119+
return timestamp;
120+
}
121+
122+
public static class Builder {
123+
private final List<String> serializedVerificationKeys = new ArrayList<>();
124+
private Duration messageTimestampAllowedSkew = DEFAULT_MESSAGE_TIMESTAMP_ALLOWED_SKEW;
125+
private Clock clock = Clock.systemDefaultZone();
126+
127+
private Builder(String serializedVerificationKey) {
128+
serializedVerificationKeys.add(requireNonNull(serializedVerificationKey));
129+
}
130+
131+
/**
132+
* @param serializedVerificationKey e.g. "v1,K5oZfzN95Z9UVu1EsfQmfVNQhnkZ2pj9o9NDN/H/pI4="
133+
*/
134+
public Builder addSerializedVerificationKey(String serializedVerificationKey) {
135+
serializedVerificationKeys.add(requireNonNull(serializedVerificationKey));
136+
return this;
137+
}
138+
139+
/**
140+
* @param messageTimestampAllowedSkew Allowable tolerance of the current timestamp to prevent
141+
* replay attacks.
142+
*/
143+
public Builder messageTimestampAllowedSkew(Duration messageTimestampAllowedSkew) {
144+
this.messageTimestampAllowedSkew = requireNonNull(messageTimestampAllowedSkew);
145+
return this;
146+
}
147+
148+
public Builder clock(Clock clock) {
149+
this.clock = requireNonNull(clock);
150+
return this;
151+
}
152+
153+
public WebhookSignatureVerifier build() {
154+
return new WebhookSignatureVerifier(this);
155+
}
156+
}
157+
}

‎src/test/java/com/cosium/standard_webhooks_consumer/VerifierTest.java

+512
Large diffs are not rendered by default.

0 commit comments

Comments
 (0)
Please sign in to comment.