2020-01-01 19:10:13 +01:00
|
|
|
import 'dart:convert';
|
|
|
|
|
|
|
|
import 'package:famedlysdk/famedlysdk.dart';
|
2020-09-26 20:27:15 +02:00
|
|
|
import 'package:fluffychat/utils/platform_infos.dart';
|
2020-05-13 15:58:59 +02:00
|
|
|
import 'package:flutter/material.dart';
|
2020-01-26 12:17:54 +01:00
|
|
|
import 'package:flutter/foundation.dart';
|
|
|
|
import 'package:flutter_secure_storage/flutter_secure_storage.dart';
|
|
|
|
import 'package:localstorage/localstorage.dart';
|
|
|
|
import 'dart:async';
|
|
|
|
import 'dart:core';
|
2020-05-13 15:58:59 +02:00
|
|
|
import './database/shared.dart';
|
|
|
|
import 'package:olm/olm.dart' as olm; // needed for migration
|
|
|
|
import 'package:random_string/random_string.dart';
|
|
|
|
|
2020-05-20 09:10:13 +02:00
|
|
|
Future<Database> getDatabase(Client client) async {
|
2020-07-20 17:33:52 +02:00
|
|
|
while (_generateDatabaseLock) {
|
|
|
|
await Future.delayed(Duration(milliseconds: 50));
|
2020-05-13 15:58:59 +02:00
|
|
|
}
|
2020-07-20 17:33:52 +02:00
|
|
|
_generateDatabaseLock = true;
|
|
|
|
try {
|
|
|
|
if (_db != null) return _db;
|
|
|
|
final store = Store();
|
|
|
|
var password = await store.getItem('database-password');
|
|
|
|
var needMigration = false;
|
|
|
|
if (password == null || password.isEmpty) {
|
|
|
|
needMigration = true;
|
|
|
|
password = randomString(255);
|
|
|
|
}
|
|
|
|
_db = await constructDb(
|
|
|
|
logStatements: false,
|
|
|
|
filename: 'moor.sqlite',
|
|
|
|
password: password,
|
|
|
|
);
|
|
|
|
if (needMigration) {
|
|
|
|
await migrate(client.clientName, _db, store);
|
|
|
|
await store.setItem('database-password', password);
|
|
|
|
}
|
|
|
|
return _db;
|
|
|
|
} finally {
|
|
|
|
_generateDatabaseLock = false;
|
2020-05-13 15:58:59 +02:00
|
|
|
}
|
|
|
|
}
|
2020-01-01 19:10:13 +01:00
|
|
|
|
2020-05-20 09:10:13 +02:00
|
|
|
Database _db;
|
2020-07-20 17:33:52 +02:00
|
|
|
bool _generateDatabaseLock = false;
|
2020-05-20 09:10:13 +02:00
|
|
|
|
2020-05-13 15:58:59 +02:00
|
|
|
Future<void> migrate(String clientName, Database db, Store store) async {
|
|
|
|
debugPrint('[Store] attempting old migration to moor...');
|
|
|
|
final oldKeys = await store.getAllItems();
|
|
|
|
if (oldKeys == null || oldKeys.isEmpty) {
|
|
|
|
debugPrint('[Store] empty store!');
|
|
|
|
return; // we are done!
|
|
|
|
}
|
|
|
|
final credentialsStr = oldKeys[clientName];
|
|
|
|
if (credentialsStr == null || credentialsStr.isEmpty) {
|
|
|
|
debugPrint('[Store] no credentials found!');
|
|
|
|
return; // no credentials
|
|
|
|
}
|
|
|
|
final Map<String, dynamic> credentials = json.decode(credentialsStr);
|
|
|
|
if (!credentials.containsKey('homeserver') ||
|
|
|
|
!credentials.containsKey('token') ||
|
|
|
|
!credentials.containsKey('userID')) {
|
|
|
|
debugPrint('[Store] invalid credentials!');
|
|
|
|
return; // invalid old store, we are done, too!
|
|
|
|
}
|
|
|
|
var clientId = 0;
|
|
|
|
final oldClient = await db.getClient(clientName);
|
|
|
|
if (oldClient == null) {
|
|
|
|
clientId = await db.insertClient(
|
|
|
|
clientName,
|
|
|
|
credentials['homeserver'],
|
|
|
|
credentials['token'],
|
|
|
|
credentials['userID'],
|
|
|
|
credentials['deviceID'],
|
|
|
|
credentials['deviceName'],
|
|
|
|
null,
|
|
|
|
credentials['olmAccount'],
|
|
|
|
);
|
|
|
|
} else {
|
|
|
|
clientId = oldClient.clientId;
|
|
|
|
await db.updateClient(
|
|
|
|
credentials['homeserver'],
|
|
|
|
credentials['token'],
|
|
|
|
credentials['userID'],
|
|
|
|
credentials['deviceID'],
|
|
|
|
credentials['deviceName'],
|
|
|
|
null,
|
|
|
|
credentials['olmAccount'],
|
|
|
|
clientId,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
await db.clearCache(clientId);
|
|
|
|
debugPrint('[Store] Inserted/updated client, clientId = ${clientId}');
|
|
|
|
await db.transaction(() async {
|
|
|
|
// alright, we stored / updated the client and have the account ID, time to import everything else!
|
|
|
|
// user_device_keys and user_device_keys_key
|
|
|
|
debugPrint('[Store] Migrating user device keys...');
|
|
|
|
final deviceKeysListString = oldKeys['${clientName}.user_device_keys'];
|
|
|
|
if (deviceKeysListString != null && deviceKeysListString.isNotEmpty) {
|
|
|
|
Map<String, dynamic> rawUserDeviceKeys =
|
|
|
|
json.decode(deviceKeysListString);
|
|
|
|
for (final entry in rawUserDeviceKeys.entries) {
|
|
|
|
final map = entry.value;
|
|
|
|
await db.storeUserDeviceKeysInfo(
|
|
|
|
clientId, map['user_id'], map['outdated']);
|
|
|
|
for (final rawKey in map['device_keys'].entries) {
|
|
|
|
final jsonVaue = rawKey.value;
|
|
|
|
await db.storeUserDeviceKey(
|
|
|
|
clientId,
|
|
|
|
jsonVaue['user_id'],
|
|
|
|
jsonVaue['device_id'],
|
|
|
|
json.encode(jsonVaue),
|
|
|
|
jsonVaue['verified'],
|
|
|
|
jsonVaue['blocked']);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for (final entry in oldKeys.entries) {
|
|
|
|
final key = entry.key;
|
|
|
|
final value = entry.value;
|
|
|
|
if (value == null || value.isEmpty) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
// olm_sessions
|
|
|
|
final olmSessionsMatch =
|
|
|
|
RegExp(r'^\/clients\/([^\/]+)\/olm-sessions$').firstMatch(key);
|
|
|
|
if (olmSessionsMatch != null) {
|
|
|
|
if (olmSessionsMatch[1] != credentials['deviceID']) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
debugPrint('[Store] migrating olm sessions...');
|
|
|
|
final identityKey = json.decode(value);
|
|
|
|
for (final olmKey in identityKey.entries) {
|
|
|
|
final identKey = olmKey.key;
|
|
|
|
final sessions = olmKey.value;
|
|
|
|
for (final pickle in sessions) {
|
|
|
|
var sess = olm.Session();
|
|
|
|
sess.unpickle(credentials['userID'], pickle);
|
|
|
|
await db.storeOlmSession(
|
2020-06-25 16:29:06 +02:00
|
|
|
clientId, identKey, sess.session_id(), pickle, null);
|
2020-05-13 15:58:59 +02:00
|
|
|
sess?.free();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// outbound_group_sessions
|
|
|
|
final outboundGroupSessionsMatch = RegExp(
|
|
|
|
r'^\/clients\/([^\/]+)\/rooms\/([^\/]+)\/outbound_group_session$')
|
|
|
|
.firstMatch(key);
|
|
|
|
if (outboundGroupSessionsMatch != null) {
|
|
|
|
if (outboundGroupSessionsMatch[1] != credentials['deviceID']) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
final pickle = value;
|
|
|
|
final roomId = outboundGroupSessionsMatch[2];
|
|
|
|
debugPrint(
|
|
|
|
'[Store] Migrating outbound group sessions for room ${roomId}...');
|
|
|
|
final devicesString = oldKeys[
|
|
|
|
'/clients/${outboundGroupSessionsMatch[1]}/rooms/${roomId}/outbound_group_session_devices'];
|
|
|
|
var devices = <String>[];
|
|
|
|
if (devicesString != null) {
|
|
|
|
devices = List<String>.from(json.decode(devicesString));
|
|
|
|
}
|
|
|
|
await db.storeOutboundGroupSession(
|
2020-05-20 09:10:13 +02:00
|
|
|
clientId,
|
|
|
|
roomId,
|
|
|
|
pickle,
|
|
|
|
json.encode(devices),
|
|
|
|
DateTime.now(),
|
|
|
|
0,
|
|
|
|
);
|
2020-05-13 15:58:59 +02:00
|
|
|
}
|
|
|
|
// session_keys
|
|
|
|
final sessionKeysMatch =
|
|
|
|
RegExp(r'^\/clients\/([^\/]+)\/rooms\/([^\/]+)\/session_keys$')
|
|
|
|
.firstMatch(key);
|
|
|
|
if (sessionKeysMatch != null) {
|
|
|
|
if (sessionKeysMatch[1] != credentials['deviceID']) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
final roomId = sessionKeysMatch[2];
|
|
|
|
debugPrint('[Store] Migrating session keys for room ${roomId}...');
|
|
|
|
final map = json.decode(value);
|
|
|
|
for (final entry in map.entries) {
|
|
|
|
await db.storeInboundGroupSession(
|
|
|
|
clientId,
|
|
|
|
roomId,
|
|
|
|
entry.key,
|
|
|
|
entry.value['inboundGroupSession'],
|
|
|
|
json.encode(entry.value['content']),
|
2020-08-22 11:25:29 +02:00
|
|
|
json.encode(entry.value['indexes']),
|
|
|
|
null,
|
|
|
|
null);
|
2020-05-13 15:58:59 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
class Store {
|
2020-01-26 12:17:54 +01:00
|
|
|
final LocalStorage storage;
|
|
|
|
final FlutterSecureStorage secureStorage;
|
2020-01-01 19:10:13 +01:00
|
|
|
|
2020-05-13 15:58:59 +02:00
|
|
|
Store()
|
2020-01-30 14:45:35 +01:00
|
|
|
: storage = LocalStorage('LocalStorage'),
|
2020-09-26 20:27:15 +02:00
|
|
|
secureStorage = PlatformInfos.isMobile ? FlutterSecureStorage() : null;
|
2020-01-01 19:10:13 +01:00
|
|
|
|
2020-01-26 12:17:54 +01:00
|
|
|
Future<dynamic> getItem(String key) async {
|
2020-09-26 20:27:15 +02:00
|
|
|
if (!PlatformInfos.isMobile) {
|
2020-01-26 12:17:54 +01:00
|
|
|
await storage.ready;
|
2020-03-06 13:05:52 +01:00
|
|
|
try {
|
|
|
|
return await storage.getItem(key);
|
|
|
|
} catch (_) {
|
|
|
|
return null;
|
|
|
|
}
|
2020-01-26 12:17:54 +01:00
|
|
|
}
|
2020-03-29 12:06:25 +02:00
|
|
|
try {
|
|
|
|
return await secureStorage.read(key: key);
|
|
|
|
} catch (_) {
|
|
|
|
return null;
|
|
|
|
}
|
2020-01-26 12:17:54 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
Future<void> setItem(String key, String value) async {
|
2020-09-26 20:27:15 +02:00
|
|
|
if (!PlatformInfos.isMobile) {
|
2020-01-26 12:17:54 +01:00
|
|
|
await storage.ready;
|
|
|
|
return await storage.setItem(key, value);
|
|
|
|
}
|
2020-02-17 14:46:05 +01:00
|
|
|
if (value == null) {
|
|
|
|
return await secureStorage.delete(key: key);
|
|
|
|
} else {
|
|
|
|
return await secureStorage.write(key: key, value: value);
|
|
|
|
}
|
2020-01-26 12:17:54 +01:00
|
|
|
}
|
|
|
|
|
2020-05-13 15:58:59 +02:00
|
|
|
Future<Map<String, dynamic>> getAllItems() async {
|
2020-09-26 20:27:15 +02:00
|
|
|
if (!PlatformInfos.isMobile) {
|
2020-05-13 15:58:59 +02:00
|
|
|
try {
|
|
|
|
final rawStorage = await getLocalstorage('LocalStorage');
|
|
|
|
return json.decode(rawStorage);
|
|
|
|
} catch (_) {
|
|
|
|
return {};
|
2020-01-02 22:31:39 +01:00
|
|
|
}
|
2020-01-01 19:10:13 +01:00
|
|
|
}
|
2020-05-13 15:58:59 +02:00
|
|
|
try {
|
|
|
|
return await secureStorage.readAll();
|
|
|
|
} catch (_) {
|
|
|
|
return {};
|
2020-01-02 12:27:02 +01:00
|
|
|
}
|
2020-03-29 12:06:25 +02:00
|
|
|
}
|
2020-01-01 19:10:13 +01:00
|
|
|
}
|