MirrorMirror
/
Signal-Server
mirror of https://github.com/signalapp/Signal-Server.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Extract a common base class for public key serializers/deserializers

This commit is contained in:
Jon Chambers 2024-02-21 12:05:40 -05:00 committed by Jon Chambers
parent 6ac2460eb0
commit 106d5e54c7
4 changed files with 67 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
service/src/main/java/org/whispersystems/textsecuregcm/util/AbstractPublicKeyDeserializer.java Normal file
View File

@ -0,0 +1,35 @@
package org.whispersystems.textsecuregcm.util;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import java.io.IOException;
import java.util.Base64;
import org.signal.libsignal.protocol.InvalidKeyException;
abstract class AbstractPublicKeyDeserializer<K> extends JsonDeserializer<K> {
@Override
public K deserialize(final JsonParser parser, final DeserializationContext context) throws IOException {
final byte[] publicKeyBytes;
try {
publicKeyBytes = Base64.getDecoder().decode(parser.getValueAsString());
} catch (final IllegalArgumentException e) {
throw new JsonParseException(parser, "Could not parse public key as a base64-encoded value", e);
}
if (publicKeyBytes.length == 0) {
return null;
}
try {
return deserializePublicKey(publicKeyBytes);
} catch (final InvalidKeyException e) {
throw new JsonParseException(parser, "Could not interpret key bytes as a public key", e);
}
}
protected abstract K deserializePublicKey(final byte[] publicKeyBytes) throws InvalidKeyException;
}

20
service/src/main/java/org/whispersystems/textsecuregcm/util/AbstractPublicKeySerializer.java Normal file
View File

@ -0,0 +1,20 @@
package org.whispersystems.textsecuregcm.util;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import java.io.IOException;
import java.util.Base64;
abstract class AbstractPublicKeySerializer<K> extends JsonSerializer<K> {
@Override
public void serialize(final K publicKey,
final JsonGenerator jsonGenerator,
final SerializerProvider serializerProvider) throws IOException {
jsonGenerator.writeString(Base64.getEncoder().encodeToString(serializePublicKey(publicKey)));
}
protected abstract byte[] serializePublicKey(final K publicKey);
}

40
service/src/main/java/org/whispersystems/textsecuregcm/util/ECPublicKeyAdapter.java
View File

@ -5,52 +5,24 @@
package org.whispersystems.textsecuregcm.util;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import java.io.IOException;
import java.util.Base64;
import org.signal.libsignal.protocol.InvalidKeyException;
import org.signal.libsignal.protocol.ecc.ECPublicKey;
public class ECPublicKeyAdapter {
public static class Serializer extends JsonSerializer<ECPublicKey> {
public static class Serializer extends AbstractPublicKeySerializer<ECPublicKey> {
@Override
public void serialize(final ECPublicKey ecPublicKey,
final JsonGenerator jsonGenerator,
final SerializerProvider serializers) throws IOException {
jsonGenerator.writeString(Base64.getEncoder().encodeToString(ecPublicKey.serialize()));
protected byte[] serializePublicKey(final ECPublicKey publicKey) {
return publicKey.serialize();
}
}
public static class Deserializer extends JsonDeserializer<ECPublicKey> {
public static class Deserializer extends AbstractPublicKeyDeserializer<ECPublicKey> {
@Override
public ECPublicKey deserialize(final JsonParser parser, final DeserializationContext context) throws IOException {
final byte[] ecPublicKeyBytes;
try {
ecPublicKeyBytes = Base64.getDecoder().decode(parser.getValueAsString());
} catch (final IllegalArgumentException e) {
throw new JsonParseException(parser, "Could not parse EC public key as a base64-encoded value", e);
}
if (ecPublicKeyBytes.length == 0) {
return null;
}
try {
return new ECPublicKey(ecPublicKeyBytes);
} catch (final InvalidKeyException e) {
throw new JsonParseException(parser, "Could not interpret identity key bytes as an EC public key", e);
}
protected ECPublicKey deserializePublicKey(final byte[] publicKeyBytes) throws InvalidKeyException {
return new ECPublicKey(publicKeyBytes);
}
}
}

40
service/src/main/java/org/whispersystems/textsecuregcm/util/KEMPublicKeyAdapter.java
View File

@ -5,52 +5,24 @@
package org.whispersystems.textsecuregcm.util;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import org.signal.libsignal.protocol.InvalidKeyException;
import org.signal.libsignal.protocol.kem.KEMPublicKey;
import java.io.IOException;
import java.util.Base64;
public class KEMPublicKeyAdapter {
public static class Serializer extends JsonSerializer<KEMPublicKey> {
public static class Serializer extends AbstractPublicKeySerializer<KEMPublicKey> {
@Override
public void serialize(final KEMPublicKey kemPublicKey,
final JsonGenerator jsonGenerator,
final SerializerProvider serializers) throws IOException {
jsonGenerator.writeString(Base64.getEncoder().encodeToString(kemPublicKey.serialize()));
protected byte[] serializePublicKey(final KEMPublicKey publicKey) {
return publicKey.serialize();
}
}
public static class Deserializer extends JsonDeserializer<KEMPublicKey> {
public static class Deserializer extends AbstractPublicKeyDeserializer<KEMPublicKey> {
@Override
public KEMPublicKey deserialize(final JsonParser parser, final DeserializationContext context) throws IOException {
final byte[] kemPublicKeyBytes;
try {
kemPublicKeyBytes = Base64.getDecoder().decode(parser.getValueAsString());
} catch (final IllegalArgumentException e) {
throw new JsonParseException(parser, "Could not parse KEM public key as a base64-encoded value", e);
}
if (kemPublicKeyBytes.length == 0) {
return null;
}
try {
return new KEMPublicKey(kemPublicKeyBytes);
} catch (final InvalidKeyException e) {
throw new JsonParseException(parser, "Could not interpret key bytes as a KEM public key", e);
}
protected KEMPublicKey deserializePublicKey(final byte[] publicKeyBytes) throws InvalidKeyException {
return new KEMPublicKey(publicKeyBytes);
}
}
}