public static void StoreSession(SignalProtocolAddress address, SessionRecord record) { string index = GetSessionCacheIndex(address.Name, address.DeviceId); lock (DBLock) { using (var ctx = new LibsignalDBContext()) { var session = ctx.Sessions .Where(s => s.DeviceId == address.DeviceId && s.Username == address.Name) .SingleOrDefault(); if (session != null) { session.Session = Base64.encodeBytes(record.serialize()); } else { ctx.Sessions.Add(new SignalSession() { DeviceId = address.DeviceId, Session = Base64.encodeBytes(record.serialize()), Username = address.Name }); } SessionsCache[index] = record; ctx.SaveChanges(); } } }
public static void SaveIdentityLocked(SignalProtocolAddress address, string identity) { lock (DBLock) { using (var ctx = new LibsignalDBContext()) { var old = ctx.Identities .Where(i => i.Username == address.Name) .FirstOrDefault(); //could contain stale data if (old == null) { ctx.Identities.Add(new SignalIdentity() { IdentityKey = identity, Username = address.Name, VerifiedStatus = VerifiedStatus.Default }); } else if (old.IdentityKey != identity) { if (old.VerifiedStatus == VerifiedStatus.Verified) { old.VerifiedStatus = VerifiedStatus.Unverified; } old.IdentityKey = identity; var childSessions = ctx.Sessions .Where(s => s.Username == address.Name && s.DeviceId != address.DeviceId); ctx.Sessions.RemoveRange(childSessions); var messages = InsertIdentityChangedMessages(address.Name); SignalLibHandle.Instance.DispatchHandleIdentityKeyChange(messages); } ctx.SaveChanges(); } } }
public static void SaveOrUpdateSignalStore(SignalStore store) { lock (DBLock) { using (var ctx = new LibsignalDBContext()) { var old = ctx.Store.SingleOrDefault(); if (old != null) { old.DeviceId = store.DeviceId; old.IdentityKeyPair = store.IdentityKeyPair; old.NextSignedPreKeyId = store.NextSignedPreKeyId; old.Password = store.Password; old.PreKeyIdOffset = store.PreKeyIdOffset; old.Registered = store.Registered; old.RegistrationId = store.RegistrationId; old.SignalingKey = store.SignalingKey; old.Username = store.Username; } else { ctx.Store.Add(store); } ctx.SaveChanges(); } } }
public static SessionRecord LoadSession(SignalProtocolAddress address) { string index = GetSessionCacheIndex(address.Name, address.DeviceId); SessionRecord record; lock (DBLock) { if (SessionsCache.TryGetValue(index, out record)) { return(record); } using (var ctx = new LibsignalDBContext()) { var session = ctx.Sessions .Where(s => s.Username == address.Name && s.DeviceId == address.DeviceId) .AsNoTracking() .SingleOrDefault(); if (session != null) { record = new SessionRecord(Base64.decode(session.Session)); } else { record = new SessionRecord(); } SessionsCache[index] = record; return(record); } } }
public static void Migrate() { lock (DBLock) { using (var ctx = new LibsignalDBContext()) { ctx.Database.Migrate(); } } }
public static SignalStore GetSignalStore() { lock (DBLock) { using (var ctx = new LibsignalDBContext()) { return(ctx.Store .AsNoTracking() .SingleOrDefault()); } } }
public static uint GetLocalRegistrationId() { lock (DBLock) { using (var ctx = new LibsignalDBContext()) { return(ctx.Store .AsNoTracking() .Single().RegistrationId); } } }
public static void UpdateNextSignedPreKeyId(uint nextSignedPreKeyId) { lock (DBLock) { using (var ctx = new LibsignalDBContext()) { var s = ctx.Store.Single(); s.NextSignedPreKeyId = nextSignedPreKeyId; ctx.SaveChanges(); } } }
public static void UpdatePreKeyIdOffset(uint preKeyIdOffset) { lock (DBLock) { using (var ctx = new LibsignalDBContext()) { var s = ctx.Store.Single(); s.PreKeyIdOffset = preKeyIdOffset; ctx.SaveChanges(); } } }
internal static IdentityKey GetIdentityKey(SignalProtocolAddress address) { lock (DBLock) { using (var ctx = new LibsignalDBContext()) { return(new IdentityKey(Base64.Decode(ctx.Identities .Where(identity => identity.Username == address.Name) .Single().IdentityKey), 0)); } } }
public static IdentityKeyPair GetIdentityKeyPair() { lock (DBLock) { using (var ctx = new LibsignalDBContext()) { var ikp = ctx.Store .AsNoTracking() .Single().IdentityKeyPair; return(new IdentityKeyPair(Base64.decode(ikp))); } } }
public static bool ContainsSession(SignalProtocolAddress address) { lock (DBLock) { using (var ctx = new LibsignalDBContext()) { var session = ctx.Sessions .Where(s => s.Username == address.Name && s.DeviceId == address.DeviceId) .SingleOrDefault(); return(session != null); } } }
public static bool ContainsPreKey(uint preKeyId) { lock (DBLock) { using (var ctx = new LibsignalDBContext()) { return(ctx.PreKeys .Where(p => p.Id == preKeyId) .AsNoTracking() .SingleOrDefault() != null); } } }
public static void Migrate() { lock (DBLock) { using (var ctx = new LibsignalDBContext()) { if (ctx.Database.GetPendingMigrations().Count() > 0) { ctx.Database.Migrate(); } } } }
public static PreKeyRecord LoadPreKey(uint preKeyId) { lock (DBLock) { using (var ctx = new LibsignalDBContext()) { var pk = ctx.PreKeys .Where(p => p.Id == preKeyId) .AsNoTracking() .Single(); return(new PreKeyRecord(Base64.decode(pk.Key))); } } }
public static SignedPreKeyRecord LoadSignedPreKey(uint signedPreKeyId) { lock (DBLock) { using (var ctx = new LibsignalDBContext()) { var preKeys = ctx.SignedPreKeys .AsNoTracking() .Where(b => b.Id == signedPreKeyId) .Single(); return(new SignedPreKeyRecord(Base64.decode(preKeys.Key))); } } }
public static void DeleteSession(SignalProtocolAddress address) { lock (DBLock) { string index = GetSessionCacheIndex(address.Name, address.DeviceId); SessionsCache.Remove(index); using (var ctx = new LibsignalDBContext()) { var sessions = ctx.Sessions .Where(s => s.Username == address.Name && s.DeviceId == address.DeviceId); ctx.Sessions.RemoveRange(sessions); ctx.SaveChanges(); } } }
public static string GetIdentityLocked(string number) { lock (DBLock) { using (var ctx = new LibsignalDBContext()) { var identity = ctx.Identities.LastOrDefault(i => i.Username == number); if (identity == null) { return(null); } return(identity.IdentityKey); } } }
public static bool ContainsSignedPreKey(uint signedPreKeyId) { lock (DBLock) { using (var ctx = new LibsignalDBContext()) { var old = ctx.SignedPreKeys.Where(k => k.Id == signedPreKeyId).SingleOrDefault(); if (old != null) { return(true); } return(false); } } }
public static void RemoveSignedPreKey(uint id) { lock (DBLock) { using (var ctx = new LibsignalDBContext()) { var old = ctx.SignedPreKeys.Where(k => k.Id == id).SingleOrDefault(); if (old != null) { ctx.SignedPreKeys.Remove(old); ctx.SaveChanges(); } } } }
public static void StoreSignedPreKey(uint signedPreKeyId, SignedPreKeyRecord record) { lock (DBLock) { using (var ctx = new LibsignalDBContext()) { ctx.SignedPreKeys.Add(new SignalSignedPreKey() { Id = signedPreKeyId, Key = Base64.encodeBytes(record.serialize()) }); ctx.SaveChanges(); } } }
public static async Task SaveIdentityLocked(SignalProtocolAddress address, string identity) { LinkedList <SignalMessage> messages = null; lock (DBLock) { using (var ctx = new LibsignalDBContext()) { var old = ctx.Identities .Where(i => i.Username == address.Name) .FirstOrDefault(); //could contain stale data if (old == null) { ctx.Identities.Add(new SignalIdentity() { IdentityKey = identity, Username = address.Name, VerifiedStatus = VerifiedStatus.Default }); } else if (old.IdentityKey != identity) { if (old.VerifiedStatus == VerifiedStatus.Verified) { old.VerifiedStatus = VerifiedStatus.Unverified; } old.IdentityKey = identity; var oldSessions = ctx.Sessions .Where(s => s.Username == address.Name); foreach (var oldSession in oldSessions) { SessionRecord sessionRecord = new SessionRecord(Base64.Decode(oldSession.Session)); sessionRecord.archiveCurrentState(); oldSession.Session = Base64.EncodeBytes(sessionRecord.serialize()); SessionsCache[GetSessionCacheIndex(address.Name, oldSession.DeviceId)] = sessionRecord; } messages = InsertIdentityChangedMessages(address.Name); } ctx.SaveChanges(); } } if (messages != null) { await SignalLibHandle.Instance.DispatchHandleIdentityKeyChange(messages); } }
public static List <SignedPreKeyRecord> LoadSignedPreKeys() { lock (DBLock) { using (var ctx = new LibsignalDBContext()) { var preKeys = ctx.SignedPreKeys .AsNoTracking() .ToList(); var v = new List <SignedPreKeyRecord>(); foreach (var preKey in preKeys) { v.Add(new SignedPreKeyRecord(Base64.decode(preKey.Key))); } return(v); } } }
public static void RemovePreKey(uint preKeyId) { lock (DBLock) { using (var ctx = new LibsignalDBContext()) { var preKey = ctx.PreKeys .AsNoTracking() .Where(b => b.Id == preKeyId) .SingleOrDefault(); if (preKey != null) { ctx.PreKeys.Remove(preKey); ctx.SaveChanges(); } } } }
public static void DeleteAllSessions(string name) { lock (DBLock) { using (var ctx = new LibsignalDBContext()) { var sessions = ctx.Sessions .Where(s => s.Username == name) .ToList(); foreach (var session in sessions) { SessionsCache.Remove(GetSessionCacheIndex(name, session.DeviceId)); } ctx.Sessions.RemoveRange(sessions); ctx.SaveChanges(); } } }
public bool IsTrustedIdentity(SignalProtocolAddress address, IdentityKey identityKey, Direction direction) { if (direction == Direction.RECEIVING) { return(true); } string savedIdentity = LibsignalDBContext.GetIdentityLocked(address.Name); if (savedIdentity == null) { return(true); } else { //TODO compare timestamps & firstUse, see Signal-Android impl string identity = Base64.encodeBytes(identityKey.serialize()); return(savedIdentity == Base64.encodeBytes(identityKey.serialize())); } }
public static void PurgeAccountData() { lock (DBLock) { using (var ctx = new LibsignalDBContext()) { ctx.Database.ExecuteSqlCommand("DELETE FROM Store;"); ctx.Database.ExecuteSqlCommand("DELETE FROM sqlite_sequence WHERE name = 'Store';"); ctx.Database.ExecuteSqlCommand("DELETE FROM SignedPreKeys;"); ctx.Database.ExecuteSqlCommand("DELETE FROM sqlite_sequence WHERE name = 'SignedPreKeys';"); ctx.Database.ExecuteSqlCommand("DELETE FROM PreKeys;"); ctx.Database.ExecuteSqlCommand("DELETE FROM sqlite_sequence WHERE name = 'PreKeys';"); ctx.Database.ExecuteSqlCommand("DELETE FROM Sessions;"); ctx.Database.ExecuteSqlCommand("DELETE FROM sqlite_sequence WHERE name = 'Sessions';"); } } }
public static bool ContainsSession(SignalProtocolAddress address) { lock (DBLock) { using (var ctx = new LibsignalDBContext()) { var session = ctx.Sessions .Where(s => s.Username == address.Name && s.DeviceId == address.DeviceId) .SingleOrDefault(); if (session == null) { return(false); } SessionRecord sessionRecord = new SessionRecord(Base64.Decode(session.Session)); return(sessionRecord.getSessionState().hasSenderChain() && sessionRecord.getSessionState().getSessionVersion() == libsignal.protocol.CiphertextMessage.CURRENT_VERSION); } } }
public static List <uint> GetSubDeviceSessions(string name) { lock (DBLock) { using (var ctx = new LibsignalDBContext()) { var sessions = ctx.Sessions .Where(se => se.Username == name) .AsNoTracking() .ToList(); var s = new List <uint>(); foreach (var session in sessions) { if (session.DeviceId != SignalServiceAddress.DEFAULT_DEVICE_ID) { s.Add(session.DeviceId); } } return(s); } } }
public static void SaveIdentityLocked(SignalProtocolAddress address, string identity) { lock (DBLock) { using (var ctx = new LibsignalDBContext()) { var old = ctx.Identities .Where(i => i.Username == address.Name) .FirstOrDefault(); //could contain stale data if (old == null) { ctx.Identities.Add(new SignalIdentity() { IdentityKey = identity, Username = address.Name, VerifiedStatus = VerifiedStatus.Default }); } else if (old.IdentityKey != identity) { if (old.VerifiedStatus == VerifiedStatus.Verified) { old.VerifiedStatus = VerifiedStatus.Unverified; } old.IdentityKey = identity; var childSessions = ctx.Sessions .Where(s => s.Username == address.Name && s.DeviceId != address.DeviceId); ctx.Sessions.RemoveRange(childSessions); Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() => { await App.ViewModels.MainPageInstance.UIHandleIdentityKeyChange(address.Name); }).AsTask().Wait(); } ctx.SaveChanges(); } } }