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, final UUID distributionId, final SenderKeyRecord record
 176     ) {
 177         senderKeyStore.storeSenderKey(sender, distributionId, record);
 178     }
 179
 180     @Override
 181     public SenderKeyRecord loadSenderKey(final SignalProtocolAddress sender, final UUID distributionId) {
 182         return senderKeyStore.loadSenderKey(sender, distributionId);
 183     }
 184
 185     @Override
 186     public Set<SignalProtocolAddress> getSenderKeySharedWith(final DistributionId distributionId) {
 187         return senderKeyStore.getSenderKeySharedWith(distributionId);
 188     }
 189
 190     @Override
 191     public void markSenderKeySharedWith(
 192             final DistributionId distributionId, final Collection<SignalProtocolAddress> addresses
 193     ) {
 194         senderKeyStore.markSenderKeySharedWith(distributionId, addresses);
 195     }
 196
 197     @Override
 198     public void clearSenderKeySharedWith(final Collection<SignalProtocolAddress> addresses) {
 199         senderKeyStore.clearSenderKeySharedWith(addresses);
 200     }
 201
 202     @Override
 203     public boolean isMultiDevice() {
 204         return isMultiDevice.get();
 205     }
 206
 207     @Override
 208     public KyberPreKeyRecord loadKyberPreKey(final int kyberPreKeyId) throws InvalidKeyIdException {
 209         return kyberPreKeyStore.loadKyberPreKey(kyberPreKeyId);
 210     }
 211
 212     @Override
 213     public List<KyberPreKeyRecord> loadKyberPreKeys() {
 214         return kyberPreKeyStore.loadKyberPreKeys();
 215     }
 216
 217     @Override
 218     public void storeKyberPreKey(final int kyberPreKeyId, final KyberPreKeyRecord record) {
 219         kyberPreKeyStore.storeKyberPreKey(kyberPreKeyId, record);
 220     }
 221
 222     @Override
 223     public boolean containsKyberPreKey(final int kyberPreKeyId) {
 224         return kyberPreKeyStore.containsKyberPreKey(kyberPreKeyId);
 225     }
 226
 227     @Override
 228     public void markKyberPreKeyUsed(final int kyberPreKeyId) {
 229         kyberPreKeyStore.markKyberPreKeyUsed(kyberPreKeyId);
 230     }
 231
 232     @Override
 233     public List<KyberPreKeyRecord> loadLastResortKyberPreKeys() {
 234         return kyberPreKeyStore.loadLastResortKyberPreKeys();
 235     }
 236
 237     @Override
 238     public void removeKyberPreKey(final int i) {
 239         kyberPreKeyStore.removeKyberPreKey(i);
 240     }
 241
 242     @Override
 243     public void storeLastResortKyberPreKey(final int i, final KyberPreKeyRecord kyberPreKeyRecord) {
 244         kyberPreKeyStore.storeLastResortKyberPreKey(i, kyberPreKeyRecord);
 245     }
 246
 247     @Override
 248     public void deleteAllStaleOneTimeKyberPreKeys(final long threshold, final int minCount) {
 249         kyberPreKeyStore.deleteAllStaleOneTimeKyberPreKeys(threshold, minCount);
 250     }
 251
 252     @Override
 253     public void markAllOneTimeKyberPreKeysStaleIfNecessary(final long staleTime) {
 254         kyberPreKeyStore.markAllOneTimeKyberPreKeysStaleIfNecessary(staleTime);
 255     }
 256
 257     @Override
 258     public void deleteAllStaleOneTimeEcPreKeys(final long threshold, final int minCount) {
 259         preKeyStore.deleteAllStaleOneTimeEcPreKeys(threshold, minCount);
 260     }
 261
 262     @Override
 263     public void markAllOneTimeEcPreKeysStaleIfNecessary(final long staleTime) {
 264         preKeyStore.markAllOneTimeEcPreKeysStaleIfNecessary(staleTime);
 265     }
 266 }