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();
}
}
}
