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