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

   1 package org.asamk.signal.manager.storage.senderKeys;
   2
   3 import org.asamk.signal.manager.storage.recipients.RecipientId;
   4 import org.asamk.signal.manager.storage.recipients.RecipientResolver;
   5 import org.asamk.signal.manager.util.IOUtils;
   6 import org.slf4j.Logger;
   7 import org.slf4j.LoggerFactory;
   8 import org.whispersystems.libsignal.SignalProtocolAddress;
   9 import org.whispersystems.libsignal.groups.state.SenderKeyRecord;
  10
  11 import java.io.File;
  12 import java.io.FileInputStream;
  13 import java.io.FileOutputStream;
  14 import java.io.IOException;
  15 import java.nio.file.Files;
  16 import java.util.Arrays;
  17 import java.util.HashMap;
  18 import java.util.List;
  19 import java.util.Map;
  20 import java.util.Objects;
  21 import java.util.UUID;
  22 import java.util.regex.Matcher;
  23 import java.util.regex.Pattern;
  24
  25 public class SenderKeyRecordStore implements org.whispersystems.libsignal.groups.state.SenderKeyStore {
  26
  27     private final static Logger logger = LoggerFactory.getLogger(SenderKeyRecordStore.class);
  28
  29     private final Map<Key, SenderKeyRecord> cachedSenderKeys = new HashMap<>();
  30
  31     private final File senderKeysPath;
  32
  33     private final RecipientResolver resolver;
  34
  35     public SenderKeyRecordStore(
  36             final File senderKeysPath, final RecipientResolver resolver
  37     ) {
  38         this.senderKeysPath = senderKeysPath;
  39         this.resolver = resolver;
  40     }
  41
  42     @Override
  43     public SenderKeyRecord loadSenderKey(final SignalProtocolAddress address, final UUID distributionId) {
  44         final var key = getKey(address, distributionId);
  45
  46         synchronized (cachedSenderKeys) {
  47             return loadSenderKeyLocked(key);
  48         }
  49     }
  50
  51     @Override
  52     public void storeSenderKey(
  53             final SignalProtocolAddress address, final UUID distributionId, final SenderKeyRecord record
  54     ) {
  55         final var key = getKey(address, distributionId);
  56
  57         synchronized (cachedSenderKeys) {
  58             storeSenderKeyLocked(key, record);
  59         }
  60     }
  61
  62     long getCreateTimeForKey(final RecipientId selfRecipientId, final int selfDeviceId, final UUID distributionId) {
  63         final var key = getKey(selfRecipientId, selfDeviceId, distributionId);
  64         final var senderKeyFile = getSenderKeyFile(key);
  65
  66         if (!senderKeyFile.exists()) {
  67             return -1;
  68         }
  69
  70         return IOUtils.getFileCreateTime(senderKeyFile);
  71     }
  72
  73     void deleteSenderKey(final RecipientId recipientId, final UUID distributionId) {
  74         synchronized (cachedSenderKeys) {
  75             cachedSenderKeys.clear();
  76             final var keys = getKeysLocked(recipientId);
  77             for (var key : keys) {
  78                 if (key.distributionId.equals(distributionId)) deleteSenderKeyLocked(key);
  79             }
  80         }
  81     }
  82
  83     void deleteAll() {
  84         synchronized (cachedSenderKeys) {
  85             cachedSenderKeys.clear();
  86             final var files = senderKeysPath.listFiles((_file, s) -> senderKeyFileNamePattern.matcher(s).matches());
  87             if (files == null) {
  88                 return;
  89             }
  90
  91             for (final var file : files) {
  92                 try {
  93                     Files.delete(file.toPath());
  94                 } catch (IOException e) {
  95                     logger.error("Failed to delete sender key file {}: {}", file, e.getMessage());
  96                 }
  97             }
  98         }
  99     }
 100
 101     void deleteAllFor(final RecipientId recipientId) {
 102         synchronized (cachedSenderKeys) {
 103             cachedSenderKeys.clear();
 104             final var keys = getKeysLocked(recipientId);
 105             for (var key : keys) {
 106                 deleteSenderKeyLocked(key);
 107             }
 108         }
 109     }
 110
 111     void mergeRecipients(RecipientId recipientId, RecipientId toBeMergedRecipientId) {
 112         synchronized (cachedSenderKeys) {
 113             final var keys = getKeysLocked(toBeMergedRecipientId);
 114             final var otherHasSenderKeys = keys.size() > 0;
 115             if (!otherHasSenderKeys) {
 116                 return;
 117             }
 118
 119             logger.debug("To be merged recipient had sender keys, re-assigning to the new recipient.");
 120             for (var key : keys) {
 121                 final var toBeMergedSenderKey = loadSenderKeyLocked(key);
 122                 deleteSenderKeyLocked(key);
 123                 if (toBeMergedSenderKey == null) {
 124                     continue;
 125                 }
 126
 127                 final var newKey = new Key(recipientId, key.deviceId(), key.distributionId);
 128                 final var senderKeyRecord = loadSenderKeyLocked(newKey);
 129                 if (senderKeyRecord != null) {
 130                     continue;
 131                 }
 132                 storeSenderKeyLocked(newKey, toBeMergedSenderKey);
 133             }
 134         }
 135     }
 136
 137     /**
 138      * @param identifier can be either a serialized uuid or a e164 phone number
 139      */
 140     private RecipientId resolveRecipient(String identifier) {
 141         return resolver.resolveRecipient(identifier);
 142     }
 143
 144     private Key getKey(final RecipientId recipientId, int deviceId, final UUID distributionId) {
 145         return new Key(recipientId, deviceId, distributionId);
 146     }
 147
 148     private Key getKey(final SignalProtocolAddress address, final UUID distributionId) {
 149         final var recipientId = resolveRecipient(address.getName());
 150         return new Key(recipientId, address.getDeviceId(), distributionId);
 151     }
 152
 153     private List<Key> getKeysLocked(RecipientId recipientId) {
 154         final var files = senderKeysPath.listFiles((_file, s) -> s.startsWith(recipientId.id() + "_"));
 155         if (files == null) {
 156             return List.of();
 157         }
 158         return parseFileNames(files);
 159     }
 160
 161     final Pattern senderKeyFileNamePattern = Pattern.compile("([0-9]+)_([0-9]+)_([0-9a-z\\-]+)");
 162
 163     private List<Key> parseFileNames(final File[] files) {
 164         return Arrays.stream(files)
 165                 .map(f -> senderKeyFileNamePattern.matcher(f.getName()))
 166                 .filter(Matcher::matches)
 167                 .map(matcher -> {
 168                     final var recipientId = resolver.resolveRecipient(Long.parseLong(matcher.group(1)));
 169                     if (recipientId == null) {
 170                         return null;
 171                     }
 172                     return new Key(recipientId, Integer.parseInt(matcher.group(2)), UUID.fromString(matcher.group(3)));
 173                 })
 174                 .filter(Objects::nonNull)
 175                 .toList();
 176     }
 177
 178     private File getSenderKeyFile(Key key) {
 179         try {
 180             IOUtils.createPrivateDirectories(senderKeysPath);
 181         } catch (IOException e) {
 182             throw new AssertionError("Failed to create sender keys path", e);
 183         }
 184         return new File(senderKeysPath,
 185                 key.recipientId().id() + "_" + key.deviceId() + "_" + key.distributionId.toString());
 186     }
 187
 188     private SenderKeyRecord loadSenderKeyLocked(final Key key) {
 189         {
 190             final var senderKeyRecord = cachedSenderKeys.get(key);
 191             if (senderKeyRecord != null) {
 192                 return senderKeyRecord;
 193             }
 194         }
 195
 196         final var file = getSenderKeyFile(key);
 197         if (!file.exists()) {
 198             return null;
 199         }
 200         try (var inputStream = new FileInputStream(file)) {
 201             final var senderKeyRecord = new SenderKeyRecord(inputStream.readAllBytes());
 202             cachedSenderKeys.put(key, senderKeyRecord);
 203             return senderKeyRecord;
 204         } catch (IOException e) {
 205             logger.warn("Failed to load sender key, resetting sender key: {}", e.getMessage());
 206             return null;
 207         }
 208     }
 209
 210     private void storeSenderKeyLocked(final Key key, final SenderKeyRecord senderKeyRecord) {
 211         cachedSenderKeys.put(key, senderKeyRecord);
 212
 213         final var file = getSenderKeyFile(key);
 214         try {
 215             try (var outputStream = new FileOutputStream(file)) {
 216                 outputStream.write(senderKeyRecord.serialize());
 217             }
 218         } catch (IOException e) {
 219             logger.warn("Failed to store sender key, trying to delete file and retry: {}", e.getMessage());
 220             try {
 221                 Files.delete(file.toPath());
 222                 try (var outputStream = new FileOutputStream(file)) {
 223                     outputStream.write(senderKeyRecord.serialize());
 224                 }
 225             } catch (IOException e2) {
 226                 logger.error("Failed to store sender key file {}: {}", file, e2.getMessage());
 227             }
 228         }
 229     }
 230
 231     private void deleteSenderKeyLocked(final Key key) {
 232         cachedSenderKeys.remove(key);
 233
 234         final var file = getSenderKeyFile(key);
 235         if (!file.exists()) {
 236             return;
 237         }
 238         try {
 239             Files.delete(file.toPath());
 240         } catch (IOException e) {
 241             logger.error("Failed to delete sender key file {}: {}", file, e.getMessage());
 242         }
 243     }
 244
 245     private record Key(RecipientId recipientId, int deviceId, UUID distributionId) {}
 246 }