public bool ContainsSession(AxolotlAddress address)
{
if (this.OncontainsSession != null)
{
return(this.OncontainsSession(address.getName(), address.getDeviceId()));
}
return(false);
}
public SessionRecord LoadSession(AxolotlAddress axolotlAddress)
{
// TODO: add checks
if (ContainsSession (axolotlAddress)) {
return new SessionRecord (_sessions [axolotlAddress]);
} else {
return new SessionRecord ();
}
}
/// <summary>
///
/// </summary>
/// <param name="address"></param>
public void DeleteSession(AxolotlAddress address)
{
String recipientId = address.GetName();
if (SessionsObjectDic.ContainsKey(recipientId))
{
SessionsObjectDic.Remove(recipientId);
}
}
public void DeleteSession(AxolotlAddress address)
{
SessionsRepository sessionsRepository = new SessionsRepository();
List <Sessions> sessions = sessionsRepository.GetSessions(address.GetName(), address.GetDeviceId());
if (sessions != null && sessions.Count > 0)
{
Sessions session = sessions.First();
sessionsRepository.Delete(session);
}
}
public void StoreSession(AxolotlAddress address, SessionRecord record)
{
DeleteSession(address); // TODO: sqlite-net combined private keys for insertOrReplace
var session = new Session()
{
DeviceId = address.getDeviceId(), Name = address.getName(), Record = record.serialize()
};
conn.InsertOrReplace(session);
return;
}
/// <summary>
/// return the stored session cypher for this number
/// </summary>
public SessionCipher getSessionCipher(string number)
{
if (sessionCiphers.ContainsKey(number))
{
return(sessionCiphers[number]);
}
else
{
AxolotlAddress address = new AxolotlAddress(number, 1);
sessionCiphers.Add(number, new SessionCipher(this, this, this, this, address));
return(sessionCiphers[number]);
}
}
public SessionRecord LoadSession(AxolotlAddress address)
{
SessionsRepository sessionsRepository = new SessionsRepository();
List <Sessions> sessions = sessionsRepository.GetSessions(address.GetName(), address.GetDeviceId());
if (sessions != null && sessions.Count > 0)
{
Sessions session = sessions.First();
SessionRecord sessionRecord = new SessionRecord(session.Record);
return(sessionRecord);
}
return(new SessionRecord());
}
public void StoreSession(AxolotlAddress address, SessionRecord record)
{
DeleteSession(address);
SessionsRepository sessionsRepository = new SessionsRepository();
Sessions session = new Sessions()
{
RecipientId = address.GetName(),
DeviceId = address.GetDeviceId(),
Record = record.Serialize()
};
sessionsRepository.Save(session);
}
public SessionRecord LoadSession(AxolotlAddress address)
{
var name = address.getName();
var deviceId = address.getDeviceId();
var query = conn.Table <Session>().Where(t => t.Name == name && t.DeviceId == deviceId);
if (query != null && query.Count() > 0)
{
return(new SessionRecord(query.First().Record));
}
else
{
return(new SessionRecord());
}
}
public SessionRecord LoadSession(AxolotlAddress address)
{
if (this.OnloadSession != null)
{
byte[] session = this.OnloadSession(address.getName(), address.getDeviceId());
if (session == null)
{
return(new SessionRecord());
}
else
{
return(new SessionRecord(session));
}
}
return(null);
}
/// <summary>
///
/// </summary>
/// <param name="address"></param>
/// <param name="record"></param>
public void StoreSession(AxolotlAddress address, SessionRecord record)
{
String recipientId = address.GetName();
uint deviceId = address.GetDeviceId();
if (SessionsObjectDic.ContainsKey(recipientId))
{
SessionsObjectDic.Remove(recipientId);
}
SessionsObjectDic.Add(recipientId, new SessionsObject()
{
DeviceId = deviceId,
RecipientId = recipientId,
Record = record.Serialize()
});
}
//[MethodImpl(MethodImplOptions.Synchronized)]
public SessionRecord loadSession(AxolotlAddress remoteAddress)
{
try
{
if (containsSession(remoteAddress))
{
byte[] session;
sessions.TryGetValue(remoteAddress, out session); // get()
return(new SessionRecord(session));
}
else
{
return(new SessionRecord());
}
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public OutgoingPushMessage encrypt(AxolotlAddress destination, byte[] unpaddedMessage, bool legacy)
{
SessionCipher sessionCipher = new SessionCipher(axolotlStore, destination);
PushTransportDetails transportDetails = new PushTransportDetails(sessionCipher.getSessionVersion());
CiphertextMessage message = sessionCipher.encrypt(transportDetails.getPaddedMessageBody(unpaddedMessage));
uint remoteRegistrationId = sessionCipher.getRemoteRegistrationId();
String body = Base64.encodeBytes(message.serialize());
uint type;
switch (message.getType())
{
case CiphertextMessage.PREKEY_TYPE: type = (uint)Envelope.Types.Type.PREKEY_BUNDLE; break; // todo check
case CiphertextMessage.WHISPER_TYPE: type = (uint)Envelope.Types.Type.CIPHERTEXT; break; // todo check
default: throw new Exception("Bad type: " + message.getType());
}
return(new OutgoingPushMessage(type, destination.getDeviceId(), remoteRegistrationId, legacy ? body : null, legacy ? null : body));
}
private async Task <OutgoingPushMessage> getEncryptedMessage(PushServiceSocket socket, TextSecureAddress recipient, uint deviceId, byte[] plaintext, bool legacy)
{
AxolotlAddress axolotlAddress = new AxolotlAddress(recipient.getNumber(), deviceId);
TextSecureCipher cipher = new TextSecureCipher(localAddress, store);
if (!store.ContainsSession(axolotlAddress))
{
try
{
List <PreKeyBundle> preKeys = await socket.getPreKeys(recipient, deviceId);
foreach (PreKeyBundle preKey in preKeys)
{
try
{
AxolotlAddress preKeyAddress = new AxolotlAddress(recipient.getNumber(), preKey.getDeviceId());
SessionBuilder sessionBuilder = new SessionBuilder(store, preKeyAddress);
sessionBuilder.process(preKey);
}
catch (libaxolotl.exceptions.UntrustedIdentityException e)
{
throw new UntrustedIdentityException("Untrusted identity key!", recipient.getNumber(), preKey.getIdentityKey());
}
}
if (eventListener.HasValue)
{
eventListener.ForceGetValue().onSecurityEvent(recipient);
}
}
catch (InvalidKeyException e)
{
throw new Exception(e.Message);
}
}
return(cipher.encrypt(axolotlAddress, plaintext, legacy));
}
public void StoreSession(AxolotlAddress address, SessionRecord record)
{
_sessions.Add(address, record.Serialize());
}
public void StoreSession(AxolotlAddress address, SessionRecord record)
{
_sessionStore.StoreSession(address, record);
}
public void DeleteSession(AxolotlAddress address)
{
_sessions.Remove(address);
}
public bool ContainsSession(AxolotlAddress address)
{
return _sessionStore.ContainsSession(address);
}
public void DeleteSession(AxolotlAddress address)
{
var name = address.getName();
var deviceId = address.getDeviceId();
var query = conn.Table <Session>().Delete(t => t.Name == name && t.DeviceId == deviceId);
}
public SessionRecord LoadSession(AxolotlAddress address)
{
return _sessionStore.LoadSession(address);
}
public bool ContainsSession(AxolotlAddress address)
{
return(sessionStore.ContainsSession(address));
}
public bool containsSession(AxolotlAddress address)
{
return sessionStore.containsSession(address);
}
public SessionRecord LoadSession(AxolotlAddress address)
{
return(sessionStore.LoadSession(address));
}
public void StoreSession(AxolotlAddress address, SessionRecord record)
{
sessionStore.StoreSession(address, record);
}
public SenderKeyName(String groupId, AxolotlAddress sender)
{
this.groupId = groupId;
this.sender = sender;
}
public void DeleteSession(AxolotlAddress address)
{
_sessionStore.DeleteSession(address);
}
public bool containsSession(AxolotlAddress address)
{
return(sessions.ContainsKey(address));
}
public SessionRecord loadSession(AxolotlAddress address)
{
return sessionStore.loadSession(address);
}
public void DeleteSession(AxolotlAddress address)
{
sessionStore.DeleteSession(address);
}
public void deleteSession(AxolotlAddress address)
{
sessionStore.deleteSession(address);
}
public SenderKeyName(String groupId, AxolotlAddress sender)
{
this.groupId = groupId;
this.sender = sender;
}
public bool ContainsSession(AxolotlAddress address)
{
SessionsRepository sessionsRepository = new SessionsRepository();
return(sessionsRepository.Contains(address.GetName(), address.GetDeviceId()));
}
public bool ContainsSession(AxolotlAddress axolotlAddress)
{
return _sessions.ContainsKey (axolotlAddress);
}
public void deleteSession(AxolotlAddress address)
{
sessions.Remove(address);
}
public void StoreSession(AxolotlAddress address, SessionRecord record)
{
sessions[address] = record.Serialize();
}
