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

   1 package org.asamk.signal.manager.storage.protocol;
   2
   3 import org.signal.libsignal.protocol.IdentityKey;
   4 import org.signal.libsignal.protocol.IdentityKeyPair;
   5 import org.signal.libsignal.protocol.InvalidKeyIdException;
   6 import org.signal.libsignal.protocol.NoSessionException;
   7 import org.signal.libsignal.protocol.SignalProtocolAddress;
   8 import org.signal.libsignal.protocol.groups.state.SenderKeyRecord;
   9 import org.signal.libsignal.protocol.state.IdentityKeyStore;
  10 import org.signal.libsignal.protocol.state.KyberPreKeyRecord;
  11 import org.signal.libsignal.protocol.state.PreKeyRecord;
  12 import org.signal.libsignal.protocol.state.SessionRecord;
  13 import org.signal.libsignal.protocol.state.SignedPreKeyRecord;
  14 import org.signal.libsignal.protocol.state.SignedPreKeyStore;
  15 import org.whispersystems.signalservice.api.SignalServiceAccountDataStore;
  16 import org.whispersystems.signalservice.api.SignalServiceKyberPreKeyStore;
  17 import org.whispersystems.signalservice.api.SignalServicePreKeyStore;
  18 import org.whispersystems.signalservice.api.SignalServiceSenderKeyStore;
  19 import org.whispersystems.signalservice.api.SignalServiceSessionStore;
  20 import org.whispersystems.signalservice.api.push.DistributionId;
  21
  22 import java.util.Collection;
  23 import java.util.List;
  24 import java.util.Map;
  25 import java.util.Set;
  26 import java.util.UUID;
  27 import java.util.function.Supplier;
  28
  29 public class SignalProtocolStore implements SignalServiceAccountDataStore {
  30
  31     private final SignalServicePreKeyStore preKeyStore;
  32     private final SignedPreKeyStore signedPreKeyStore;
  33     private final SignalServiceKyberPreKeyStore kyberPreKeyStore;
  34     private final SignalServiceSessionStore sessionStore;
  35     private final IdentityKeyStore identityKeyStore;
  36     private final SignalServiceSenderKeyStore senderKeyStore;
  37     private final Supplier<Boolean> isMultiDevice;
  38
  39     public SignalProtocolStore(
  40             final SignalServicePreKeyStore preKeyStore,
  41             final SignedPreKeyStore signedPreKeyStore,
  42             final SignalServiceKyberPreKeyStore kyberPreKeyStore,
  43             final SignalServiceSessionStore sessionStore,
  44             final IdentityKeyStore identityKeyStore,
  45             final SignalServiceSenderKeyStore senderKeyStore,
  46             final Supplier<Boolean> isMultiDevice
  47     ) {
  48         this.preKeyStore = preKeyStore;
  49         this.signedPreKeyStore = signedPreKeyStore;
  50         this.kyberPreKeyStore = kyberPreKeyStore;
  51         this.sessionStore = sessionStore;
  52         this.identityKeyStore = identityKeyStore;
  53         this.senderKeyStore = senderKeyStore;
  54         this.isMultiDevice = isMultiDevice;
  55     }
  56
  57     @Override
  58     public IdentityKeyPair getIdentityKeyPair() {
  59         return identityKeyStore.getIdentityKeyPair();
  60     }
  61
  62     @Override
  63     public int getLocalRegistrationId() {
  64         return identityKeyStore.getLocalRegistrationId();
  65     }
  66
  67     @Override
  68     public boolean saveIdentity(SignalProtocolAddress address, IdentityKey identityKey) {
  69         return identityKeyStore.saveIdentity(address, identityKey);
  70     }
  71
  72     @Override
  73     public boolean isTrustedIdentity(SignalProtocolAddress address, IdentityKey identityKey, Direction direction) {
  74         return identityKeyStore.isTrustedIdentity(address, identityKey, direction);
  75     }
  76
  77     @Override
  78     public IdentityKey getIdentity(SignalProtocolAddress address) {
  79         return identityKeyStore.getIdentity(address);
  80     }
  81
  82     @Override
  83     public PreKeyRecord loadPreKey(int preKeyId) throws InvalidKeyIdException {
  84         return preKeyStore.loadPreKey(preKeyId);
  85     }
  86
  87     @Override
  88     public void storePreKey(int preKeyId, PreKeyRecord record) {
  89         preKeyStore.storePreKey(preKeyId, record);
  90     }
  91
  92     @Override
  93     public boolean containsPreKey(int preKeyId) {
  94         return preKeyStore.containsPreKey(preKeyId);
  95     }
  96
  97     @Override
  98     public void removePreKey(int preKeyId) {
  99         preKeyStore.removePreKey(preKeyId);
 100     }
 101
 102     @Override
 103     public SessionRecord loadSession(SignalProtocolAddress address) {
 104         return sessionStore.loadSession(address);
 105     }
 106
 107     @Override
 108     public List<SessionRecord> loadExistingSessions(final List<SignalProtocolAddress> addresses) throws NoSessionException {
 109         return sessionStore.loadExistingSessions(addresses);
 110     }
 111
 112     @Override
 113     public List<Integer> getSubDeviceSessions(String name) {
 114         return sessionStore.getSubDeviceSessions(name);
 115     }
 116
 117     @Override
 118     public void storeSession(SignalProtocolAddress address, SessionRecord record) {
 119         sessionStore.storeSession(address, record);
 120     }
 121
 122     @Override
 123     public boolean containsSession(SignalProtocolAddress address) {
 124         return sessionStore.containsSession(address);
 125     }
 126
 127     @Override
 128     public void deleteSession(SignalProtocolAddress address) {
 129         sessionStore.deleteSession(address);
 130     }
 131
 132     @Override
 133     public void deleteAllSessions(String name) {
 134         sessionStore.deleteAllSessions(name);
 135     }
 136
 137     @Override
 138     public void archiveSession(final SignalProtocolAddress address) {
 139         sessionStore.archiveSession(address);
 140         senderKeyStore.clearSenderKeySharedWith(List.of(address));
 141     }
 142
 143     @Override
 144     public Map<SignalProtocolAddress, SessionRecord> getAllAddressesWithActiveSessions(final List<String> addressNames) {
 145         return sessionStore.getAllAddressesWithActiveSessions(addressNames);
 146     }
 147
 148     @Override
 149     public SignedPreKeyRecord loadSignedPreKey(int signedPreKeyId) throws InvalidKeyIdException {
 150         return signedPreKeyStore.loadSignedPreKey(signedPreKeyId);
 151     }
 152
 153     @Override
 154     public List<SignedPreKeyRecord> loadSignedPreKeys() {
 155         return signedPreKeyStore.loadSignedPreKeys();
 156     }
 157
 158     @Override
 159     public void storeSignedPreKey(int signedPreKeyId, SignedPreKeyRecord record) {
 160         signedPreKeyStore.storeSignedPreKey(signedPreKeyId, record);
 161     }
 162
 163     @Override
 164     public boolean containsSignedPreKey(int signedPreKeyId) {
 165         return signedPreKeyStore.containsSignedPreKey(signedPreKeyId);
 166     }
 167
 168     @Override
 169     public void removeSignedPreKey(int signedPreKeyId) {
 170         signedPreKeyStore.removeSignedPreKey(signedPreKeyId);
 171     }
 172
 173     @Override
 174     public void storeSenderKey(
 175             final SignalProtocolAddress sender,
 176             final UUID distributionId,
 177             final SenderKeyRecord record
 178     ) {
 179         senderKeyStore.storeSenderKey(sender, distributionId, record);
 180     }
 181
 182     @Override
 183     public SenderKeyRecord loadSenderKey(final SignalProtocolAddress sender, final UUID distributionId) {
 184         return senderKeyStore.loadSenderKey(sender, distributionId);
 185     }
 186
 187     @Override
 188     public Set<SignalProtocolAddress> getSenderKeySharedWith(final DistributionId distributionId) {
 189         return senderKeyStore.getSenderKeySharedWith(distributionId);
 190     }
 191
 192     @Override
 193     public void markSenderKeySharedWith(
 194             final DistributionId distributionId,
 195             final Collection<SignalProtocolAddress> addresses
 196     ) {
 197         senderKeyStore.markSenderKeySharedWith(distributionId, addresses);
 198     }
 199
 200     @Override
 201     public void clearSenderKeySharedWith(final Collection<SignalProtocolAddress> addresses) {
 202         senderKeyStore.clearSenderKeySharedWith(addresses);
 203     }
 204
 205     @Override
 206     public boolean isMultiDevice() {
 207         return isMultiDevice.get();
 208     }
 209
 210     @Override
 211     public KyberPreKeyRecord loadKyberPreKey(final int kyberPreKeyId) throws InvalidKeyIdException {
 212         return kyberPreKeyStore.loadKyberPreKey(kyberPreKeyId);
 213     }
 214
 215     @Override
 216     public List<KyberPreKeyRecord> loadKyberPreKeys() {
 217         return kyberPreKeyStore.loadKyberPreKeys();
 218     }
 219
 220     @Override
 221     public void storeKyberPreKey(final int kyberPreKeyId, final KyberPreKeyRecord record) {
 222         kyberPreKeyStore.storeKyberPreKey(kyberPreKeyId, record);
 223     }
 224
 225     @Override
 226     public boolean containsKyberPreKey(final int kyberPreKeyId) {
 227         return kyberPreKeyStore.containsKyberPreKey(kyberPreKeyId);
 228     }
 229
 230     @Override
 231     public void markKyberPreKeyUsed(final int kyberPreKeyId) {
 232         kyberPreKeyStore.markKyberPreKeyUsed(kyberPreKeyId);
 233     }
 234
 235     @Override
 236     public List<KyberPreKeyRecord> loadLastResortKyberPreKeys() {
 237         return kyberPreKeyStore.loadLastResortKyberPreKeys();
 238     }
 239
 240     @Override
 241     public void removeKyberPreKey(final int i) {
 242         kyberPreKeyStore.removeKyberPreKey(i);
 243     }
 244
 245     @Override
 246     public void storeLastResortKyberPreKey(final int i, final KyberPreKeyRecord kyberPreKeyRecord) {
 247         kyberPreKeyStore.storeLastResortKyberPreKey(i, kyberPreKeyRecord);
 248     }
 249
 250     @Override
 251     public void deleteAllStaleOneTimeKyberPreKeys(final long threshold, final int minCount) {
 252         kyberPreKeyStore.deleteAllStaleOneTimeKyberPreKeys(threshold, minCount);
 253     }
 254
 255     @Override
 256     public void markAllOneTimeKyberPreKeysStaleIfNecessary(final long staleTime) {
 257         kyberPreKeyStore.markAllOneTimeKyberPreKeysStaleIfNecessary(staleTime);
 258     }
 259
 260     @Override
 261     public void deleteAllStaleOneTimeEcPreKeys(final long threshold, final int minCount) {
 262         preKeyStore.deleteAllStaleOneTimeEcPreKeys(threshold, minCount);
 263     }
 264
 265     @Override
 266     public void markAllOneTimeEcPreKeysStaleIfNecessary(final long staleTime) {
 267         preKeyStore.markAllOneTimeEcPreKeysStaleIfNecessary(staleTime);
 268     }
 269 }