nmode's Git Repositories - signal-cli/blob - src/main/java/org/asamk/signal/manager/storage/protocol/JsonSignedPreKeyStore.java

   1 package org.asamk.signal.manager.storage.protocol;
   2
   3 import com.fasterxml.jackson.core.JsonGenerator;
   4 import com.fasterxml.jackson.core.JsonParser;
   5 import com.fasterxml.jackson.databind.DeserializationContext;
   6 import com.fasterxml.jackson.databind.JsonDeserializer;
   7 import com.fasterxml.jackson.databind.JsonNode;
   8 import com.fasterxml.jackson.databind.JsonSerializer;
   9 import com.fasterxml.jackson.databind.SerializerProvider;
  10
  11 import org.slf4j.Logger;
  12 import org.slf4j.LoggerFactory;
  13 import org.whispersystems.libsignal.InvalidKeyIdException;
  14 import org.whispersystems.libsignal.state.SignedPreKeyRecord;
  15 import org.whispersystems.libsignal.state.SignedPreKeyStore;
  16 import org.whispersystems.util.Base64;
  17
  18 import java.io.IOException;
  19 import java.util.HashMap;
  20 import java.util.LinkedList;
  21 import java.util.List;
  22 import java.util.Map;
  23
  24 class JsonSignedPreKeyStore implements SignedPreKeyStore {
  25
  26     private final static Logger logger = LoggerFactory.getLogger(JsonSignedPreKeyStore.class);
  27
  28     private final Map<Integer, byte[]> store = new HashMap<>();
  29
  30     public JsonSignedPreKeyStore() {
  31
  32     }
  33
  34     private void addSignedPreKeys(Map<Integer, byte[]> preKeys) {
  35         store.putAll(preKeys);
  36     }
  37
  38     @Override
  39     public SignedPreKeyRecord loadSignedPreKey(int signedPreKeyId) throws InvalidKeyIdException {
  40         try {
  41             if (!store.containsKey(signedPreKeyId)) {
  42                 throw new InvalidKeyIdException("No such signedprekeyrecord! " + signedPreKeyId);
  43             }
  44
  45             return new SignedPreKeyRecord(store.get(signedPreKeyId));
  46         } catch (IOException e) {
  47             throw new AssertionError(e);
  48         }
  49     }
  50
  51     @Override
  52     public List<SignedPreKeyRecord> loadSignedPreKeys() {
  53         try {
  54             List<SignedPreKeyRecord> results = new LinkedList<>();
  55
  56             for (byte[] serialized : store.values()) {
  57                 results.add(new SignedPreKeyRecord(serialized));
  58             }
  59
  60             return results;
  61         } catch (IOException e) {
  62             throw new AssertionError(e);
  63         }
  64     }
  65
  66     @Override
  67     public void storeSignedPreKey(int signedPreKeyId, SignedPreKeyRecord record) {
  68         store.put(signedPreKeyId, record.serialize());
  69     }
  70
  71     @Override
  72     public boolean containsSignedPreKey(int signedPreKeyId) {
  73         return store.containsKey(signedPreKeyId);
  74     }
  75
  76     @Override
  77     public void removeSignedPreKey(int signedPreKeyId) {
  78         store.remove(signedPreKeyId);
  79     }
  80
  81     public static class JsonSignedPreKeyStoreDeserializer extends JsonDeserializer<JsonSignedPreKeyStore> {
  82
  83         @Override
  84         public JsonSignedPreKeyStore deserialize(
  85                 JsonParser jsonParser, DeserializationContext deserializationContext
  86         ) throws IOException {
  87             JsonNode node = jsonParser.getCodec().readTree(jsonParser);
  88
  89             Map<Integer, byte[]> preKeyMap = new HashMap<>();
  90             if (node.isArray()) {
  91                 for (JsonNode preKey : node) {
  92                     Integer preKeyId = preKey.get("id").asInt();
  93                     try {
  94                         preKeyMap.put(preKeyId, Base64.decode(preKey.get("record").asText()));
  95                     } catch (IOException e) {
  96                         logger.warn("Error while decoding prekey for {}: {}", preKeyId, e.getMessage());
  97                     }
  98                 }
  99             }
 100
 101             JsonSignedPreKeyStore keyStore = new JsonSignedPreKeyStore();
 102             keyStore.addSignedPreKeys(preKeyMap);
 103
 104             return keyStore;
 105
 106         }
 107     }
 108
 109     public static class JsonSignedPreKeyStoreSerializer extends JsonSerializer<JsonSignedPreKeyStore> {
 110
 111         @Override
 112         public void serialize(
 113                 JsonSignedPreKeyStore jsonPreKeyStore, JsonGenerator json, SerializerProvider serializerProvider
 114         ) throws IOException {
 115             json.writeStartArray();
 116             for (Map.Entry<Integer, byte[]> signedPreKey : jsonPreKeyStore.store.entrySet()) {
 117                 json.writeStartObject();
 118                 json.writeNumberField("id", signedPreKey.getKey());
 119                 json.writeStringField("record", Base64.encodeBytes(signedPreKey.getValue()));
 120                 json.writeEndObject();
 121             }
 122             json.writeEndArray();
 123         }
 124     }
 125 }