public static string GenerateToken(int id, string username, string email)
{
IdentityKey identityKey = new IdentityKey();
identityKey.Email = email;
identityKey.UserName = username;
identityKey.Id = id;
identityKey.ExpiresLogin = DateTime.Now.AddHours(12);
string Token = Barayand.Common.Services.CryptoJsService.EncryptStringToAES(JsonConvert.SerializeObject(identityKey));
return(Token);
//byte[] key = Convert.FromBase64String(Secret);
//SymmetricSecurityKey securityKey;
//securityKey = new SymmetricSecurityKey(key);
//SecurityTokenDescriptor descriptor = new SecurityTokenDescriptor
//{
// Subject = new ClaimsIdentity(new[] {
// new Claim(ClaimTypes.Name, username)
//}),
// Expires = DateTime.UtcNow.AddDays(1),
// SigningCredentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256Signature)
//};
//JwtSecurityTokenHandler handler = new JwtSecurityTokenHandler();
//JwtSecurityToken token = handler.CreateJwtSecurityToken(descriptor);
//return handler.WriteToken(token);
}
public bool IsTrustedIdentity(string name, IdentityKey identityKey)
{
long recipientId = RecipientFactory.getRecipientsFromString(name, true).getPrimaryRecipient().getRecipientId();
return(DatabaseFactory.getIdentityDatabase()
.IsValidIdentity(recipientId, identityKey));
}
//--------------------------------------------------------Misc Methods:---------------------------------------------------------------\\
#region --Misc Methods (Public)--
public bool SaveIdentity(string name, IdentityKey identityKey)
{
bool contains = OmemoSignalKeyDBManager.INSTANCE.containsIdentityKey(name, ACCOUNT.getBareJid());
OmemoSignalKeyDBManager.INSTANCE.setIdentityKey(name, identityKey, ACCOUNT.getBareJid());
return(contains);
}
public KeyExchangeMessage(UInt32 messageVersion, UInt32 sequence, UInt32 flags,
ECPublicKey baseKey, byte[] baseKeySignature,
ECPublicKey ratchetKey,
IdentityKey identityKey)
{
MaxVersion = CiphertextMessage.CURRENT_VERSION;
Version = messageVersion;
Sequence = sequence;
Flags = flags;
BaseKey = baseKey;
BaseKeySignature = baseKeySignature;
RatchetKey = ratchetKey;
IdentityKey = identityKey;
byte[] version = { ByteUtil.IntsToByteHighAndLow(Version, MaxVersion) };
var keyExchangeMsg = new WhisperProtos.KeyExchangeMessage {
id = (Sequence << 5) | Flags,
baseKey = BaseKey.Serialize(),
ratchetKey = RatchetKey.Serialize(),
identityKey = IdentityKey.Serialize()
};
if(Version >= 3)
{
keyExchangeMsg.baseKeySignature = BaseKeySignature;
}
byte[] bytes;
using(var stream = new MemoryStream())
{
Serializer.Serialize(stream, keyExchangeMsg);
bytes = stream.ToArray();
}
_serialized = ByteUtil.Combine(version, bytes);
}
public bool SaveIdentity(string name, IdentityKey identityKey)
{
long recipientId = RecipientFactory.getRecipientsFromString(name, true).getPrimaryRecipient().getRecipientId();
DatabaseFactory.getIdentityDatabase().SaveIdentity(recipientId, identityKey);
return(true);
}
public PreKeySignalMessage(uint messageVersion, uint registrationId, May <uint> preKeyId,
uint signedPreKeyId, IEcPublicKey baseKey, IdentityKey identityKey,
SignalMessage message)
{
_version = messageVersion;
_registrationId = registrationId;
_preKeyId = preKeyId;
_signedPreKeyId = signedPreKeyId;
_baseKey = baseKey;
_identityKey = identityKey;
_message = message;
PreKeySignalMessage preKeySignalMessage = new PreKeySignalMessage
{
SignedPreKeyId = signedPreKeyId,
BaseKey = ByteString.CopyFrom(baseKey.Serialize()),
IdentityKey = ByteString.CopyFrom(identityKey.Serialize()),
Message = ByteString.CopyFrom(message.Serialize()),
RegistrationId = registrationId
};
if (preKeyId.HasValue) // .isPresent()
{
preKeySignalMessage.PreKeyId = preKeyId.ForceGetValue(); // get()
}
byte[] versionBytes = { ByteUtil.IntsToByteHighAndLow((int)_version, (int)CurrentVersion) };
byte[] messageBytes = preKeySignalMessage.ToByteArray();
_serialized = ByteUtil.Combine(versionBytes, messageBytes);
}
//--------------------------------------------------------Misc Methods:---------------------------------------------------------------\\
#region --Misc Methods (Public)--
public bool SaveIdentity(string name, IdentityKey identityKey)
{
bool contains = SignalKeyDBManager.INSTANCE.containsIdentityKey(name, ACCOUNT.getIdAndDomain());
SignalKeyDBManager.INSTANCE.setIdentityKey(name, identityKey, ACCOUNT.getIdAndDomain());
return(contains);
}
private byte[] GetMac(uint messageVersion,
IdentityKey senderIdentityKey,
IdentityKey receiverIdentityKey,
byte[] macKey, byte[] serialized)
{
try
{
MemoryStream stream = new MemoryStream();
if (messageVersion >= 3)
{
byte[] sik = senderIdentityKey.GetPublicKey().Serialize();
stream.Write(sik, 0, sik.Length);
byte[] rik = receiverIdentityKey.GetPublicKey().Serialize();
stream.Write(rik, 0, rik.Length);
}
stream.Write(serialized, 0, serialized.Length);
byte[] fullMac = Sign.Sha256sum(macKey, stream.ToArray());
return(ByteUtil.Trim(fullMac, MAC_LENGTH));
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public void testMismatchingFingerprints()
{
ECKeyPair aliceKeyPair = Curve.generateKeyPair();
ECKeyPair bobKeyPair = Curve.generateKeyPair();
ECKeyPair mitmKeyPair = Curve.generateKeyPair();
IdentityKey aliceIdentityKey = new IdentityKey(aliceKeyPair.getPublicKey());
IdentityKey bobIdentityKey = new IdentityKey(bobKeyPair.getPublicKey());
IdentityKey mitmIdentityKey = new IdentityKey(mitmKeyPair.getPublicKey());
NumericFingerprintGenerator generator = new NumericFingerprintGenerator(1024);
Fingerprint aliceFingerprint = generator.createFor(VERSION_1,
Encoding.UTF8.GetBytes("+14152222222"), aliceIdentityKey,
Encoding.UTF8.GetBytes("+14153333333"), mitmIdentityKey);
Fingerprint bobFingerprint = generator.createFor(VERSION_1,
Encoding.UTF8.GetBytes("+14153333333"), bobIdentityKey,
Encoding.UTF8.GetBytes("+14152222222"), aliceIdentityKey);
Assert.AreNotEqual(aliceFingerprint.getDisplayableFingerprint().getDisplayText(),
bobFingerprint.getDisplayableFingerprint().getDisplayText());
Assert.IsFalse(aliceFingerprint.getScannableFingerprint().compareTo(bobFingerprint.getScannableFingerprint().getSerialized()));
Assert.IsFalse(bobFingerprint.getScannableFingerprint().compareTo(aliceFingerprint.getScannableFingerprint().getSerialized()));
}
/// <summary>
/// Finds entity by key (PK)
/// </summary>
/// <param name="identityKey"></param>
/// <returns></returns>
public EntityTrack FindByIdentity(IdentityKey identityKey)
{
EntityTrack entityTrack;
entitiesByKey.TryGetValue(identityKey, out entityTrack);
return(entityTrack);
}
public bool IsTrustedIdentity(string name, IdentityKey identityKey)
{
if (!_trustedKeys.ContainsKey (name))
return false;
else
return _trustedKeys [name].Equals (identityKey);
}
public PreKeySignalMessage(uint messageVersion, uint registrationId, May <uint> preKeyId,
uint signedPreKeyId, ECPublicKey baseKey, IdentityKey identityKey,
SignalMessage message)
{
this.version = messageVersion;
this.registrationId = registrationId;
this.preKeyId = preKeyId;
this.signedPreKeyId = signedPreKeyId;
this.baseKey = baseKey;
this.identityKey = identityKey;
this.message = message;
PreKeySignalMessage preKeySignalMessage = new PreKeySignalMessage
{
SignedPreKeyId = signedPreKeyId,
BaseKey = ByteString.CopyFrom(baseKey.serialize()),
IdentityKey = ByteString.CopyFrom(identityKey.serialize()),
Message = ByteString.CopyFrom(message.serialize()),
RegistrationId = registrationId
};
if (preKeyId.HasValue) // .isPresent()
{
preKeySignalMessage.PreKeyId = preKeyId.ForceGetValue(); // get()
}
byte[] versionBytes = { ByteUtil.intsToByteHighAndLow((int)this.version, (int)CURRENT_VERSION) };
byte[] messageBytes = preKeySignalMessage.ToByteArray();
this.serialized = ByteUtil.combine(versionBytes, messageBytes);
}
/// <summary>
/// Register an identity key, last resort key, signed prekey, and list of one time prekeys
/// with the server.
/// </summary>
/// <param name="identityKey">The client's long-term identity keypair.</param>
/// <param name="lastResortKey">The client's "last resort" prekey.</param>
/// <param name="signedPreKey">The client's signed prekey.</param>
/// <param name="oneTimePreKeys">The client's list of one-time prekeys.</param>
/// <returns></returns>
public async Task <bool> setPreKeys(IdentityKey identityKey, PreKeyRecord lastResortKey,
SignedPreKeyRecord signedPreKey, IList <PreKeyRecord> oneTimePreKeys)//throws IOException
{
await this.pushServiceSocket.registerPreKeys(identityKey, lastResortKey, signedPreKey, oneTimePreKeys);
return(true);
}
public void testMatchingFingerprints()
{
ECKeyPair aliceKeyPair = Curve.generateKeyPair();
ECKeyPair bobKeyPair = Curve.generateKeyPair();
IdentityKey aliceIdentityKey = new IdentityKey(aliceKeyPair.getPublicKey());
IdentityKey bobIdentityKey = new IdentityKey(bobKeyPair.getPublicKey());
NumericFingerprintGenerator generator = new NumericFingerprintGenerator(1024);
Fingerprint aliceFingerprint = generator.createFor("+14152222222", aliceIdentityKey,
"+14153333333", bobIdentityKey);
Fingerprint bobFingerprint = generator.createFor("+14153333333", bobIdentityKey,
"+14152222222", aliceIdentityKey);
Assert.AreEqual <string>(aliceFingerprint.getDisplayableFingerprint().getDisplayText(),
bobFingerprint.getDisplayableFingerprint().getDisplayText());
Assert.IsTrue(
aliceFingerprint.getScannableFingerprint().compareTo(
bobFingerprint.getScannableFingerprint().getSerialized()));
Assert.IsTrue(
bobFingerprint.getScannableFingerprint().compareTo(
aliceFingerprint.getScannableFingerprint().getSerialized()));
Assert.AreEqual <int>(aliceFingerprint.getDisplayableFingerprint().getDisplayText().Length, 60);
}
public PreKeySignalMessage(uint messageVersion, uint registrationId, May <uint> preKeyId,
uint signedPreKeyId, IEcPublicKey baseKey, IdentityKey identityKey,
SignalMessage message)
{
_version = messageVersion;
_registrationId = registrationId;
_preKeyId = preKeyId;
_signedPreKeyId = signedPreKeyId;
_baseKey = baseKey;
_identityKey = identityKey;
_message = message;
WhisperProtos.PreKeySignalMessage.Builder builder =
WhisperProtos.PreKeySignalMessage.CreateBuilder()
.SetSignedPreKeyId(signedPreKeyId)
.SetBaseKey(ByteString.CopyFrom(baseKey.Serialize()))
.SetIdentityKey(ByteString.CopyFrom(identityKey.Serialize()))
.SetMessage(ByteString.CopyFrom(message.Serialize()))
.SetRegistrationId(registrationId);
if (preKeyId.HasValue) // .isPresent()
{
builder.SetPreKeyId(preKeyId.ForceGetValue()); // get()
}
byte[] versionBytes = { ByteUtil.IntsToByteHighAndLow((int)_version, (int)CurrentVersion) };
byte[] messageBytes = builder.Build().ToByteArray();
_serialized = ByteUtil.Combine(versionBytes, messageBytes);
}
//--------------------------------------------------------Misc Methods:---------------------------------------------------------------\\
#region --Misc Methods (Public)--
public bool SaveIdentity(string name, IdentityKey identityKey)
{
bool contains = IDENTITY_KEYS.ContainsKey(name);
IDENTITY_KEYS[name] = identityKey;
return(contains);
}
public VerifiedMessage(SignalServiceAddress destination, IdentityKey identityKey, VerifiedState verified, long timestamp)
{
Destination = destination;
IdentityKey = identityKey;
Verified = verified;
Timestamp = timestamp;
}
private string getDisplayStringFor(string stableIdentifier, IdentityKey identityKey)
{
try
{
IHashAlgorithmProvider digest = HashAlgorithmProvider.OpenAlgorithm(PCLCrypto.HashAlgorithm.Sha512);
byte[] publicKey = identityKey.getPublicKey().serialize();
byte[] hash = ByteUtil.combine(ByteUtil.shortToByteArray(VERSION),
publicKey, Encoding.UTF8.GetBytes(stableIdentifier));
for (int i = 0; i < iterations; i++)
{
hash = digest.HashData(ByteUtil.combine(new byte[][] { hash, publicKey }));
}
return(getEncodedChunk(hash, 0) +
getEncodedChunk(hash, 5) +
getEncodedChunk(hash, 10) +
getEncodedChunk(hash, 15) +
getEncodedChunk(hash, 20) +
getEncodedChunk(hash, 25));
}
catch (Exception e)
{
Debug.Assert(false, e.Message);
throw e;
}
}
/// <summary>
/// Generate an identity key pair. Clients should only do this once, at install time.
/// </summary>
/// <returns>the generated IdentityKeyPair.</returns>
public static IdentityKeyPair generateIdentityKeyPair()
{
ECKeyPair keyPair = Curve.generateKeyPair();
IdentityKey publicKey = new IdentityKey(keyPair.getPublicKey());
return(new IdentityKeyPair(publicKey, keyPair.getPrivateKey()));
}
public PreKeyWhisperMessage(UInt32 messageVersion, UInt32 registrationId, Maybe<UInt32> preKeyId,
UInt32 signedPreKeyId, ECPublicKey baseKey, IdentityKey identityKey,
WhisperMessage message)
{
MessageVersion = messageVersion;
RegistrationId = registrationId;
PreKeyId = preKeyId;
SignedPreKeyId = signedPreKeyId;
BaseKey = baseKey;
IdentityKey = identityKey;
Message = message;
var preKeyMessage = new WhisperProtos.PreKeyWhisperMessage {
signedPreKeyId = SignedPreKeyId,
baseKey = BaseKey.Serialize(),
identityKey = IdentityKey.Serialize(),
message = Message.Serialize(),
registrationId = registrationId
};
preKeyId.Do(pKid => preKeyMessage.preKeyId = pKid);
byte[] versionBytes = { ByteUtil.IntsToByteHighAndLow(MessageVersion, CURRENT_VERSION) };
byte[] messageBytes;
using(var stream = new MemoryStream())
{
Serializer.Serialize(stream, preKeyMessage);
messageBytes = stream.ToArray();
}
_serialized = ByteUtil.Combine(versionBytes, messageBytes);
}
public KeyExchangeMessage(uint messageVersion, uint sequence, uint flags,
ECPublicKey baseKey, byte[] baseKeySignature,
ECPublicKey ratchetKey,
IdentityKey identityKey)
{
this.supportedVersion = CiphertextMessage.CURRENT_VERSION;
this.version = messageVersion;
this.sequence = sequence;
this.flags = flags;
this.baseKey = baseKey;
this.baseKeySignature = baseKeySignature;
this.ratchetKey = ratchetKey;
this.identityKey = identityKey;
byte[] version = { ByteUtil.intsToByteHighAndLow((int)this.version, (int)this.supportedVersion) };
WhisperProtos.KeyExchangeMessage.Builder builder = WhisperProtos.KeyExchangeMessage
.CreateBuilder()
.SetId((sequence << 5) | flags) //(sequence << 5) | flags
.SetBaseKey(ByteString.CopyFrom(baseKey.serialize()))
.SetRatchetKey(ByteString.CopyFrom(ratchetKey.serialize()))
.SetIdentityKey(ByteString.CopyFrom(identityKey.serialize()));
if (messageVersion >= 3)
{
builder.SetBaseKeySignature(ByteString.CopyFrom(baseKeySignature));
}
this.serialized = ByteUtil.combine(version, builder.Build().ToByteArray());
}
public bool IsTrustedIdentity(String name, IdentityKey identityKey)
{
IdentityKey trusted;
trustedKeys.TryGetValue(name, out trusted); // get(name)
return(trusted == null || trusted.Equals(identityKey));
}
public PreKeyWhisperMessage(uint messageVersion, uint registrationId, May<uint> preKeyId,
uint signedPreKeyId, ECPublicKey baseKey, IdentityKey identityKey,
WhisperMessage message)
{
this.version = messageVersion;
this.registrationId = registrationId;
this.preKeyId = preKeyId;
this.signedPreKeyId = signedPreKeyId;
this.baseKey = baseKey;
this.identityKey = identityKey;
this.message = message;
WhisperProtos.PreKeyWhisperMessage.Builder builder =
WhisperProtos.PreKeyWhisperMessage.CreateBuilder()
.SetSignedPreKeyId(signedPreKeyId)
.SetBaseKey(ByteString.CopyFrom(baseKey.serialize()))
.SetIdentityKey(ByteString.CopyFrom(identityKey.serialize()))
.SetMessage(ByteString.CopyFrom(message.serialize()))
.SetRegistrationId(registrationId);
if (preKeyId.HasValue) // .isPresent()
{
builder.SetPreKeyId(preKeyId.ForceGetValue()); // get()
}
byte[] versionBytes = { ByteUtil.intsToByteHighAndLow((int)this.version, (int)CURRENT_VERSION) };
byte[] messageBytes = builder.Build().ToByteArray();
this.serialized = ByteUtil.combine(versionBytes, messageBytes);
}
public WhisperMessage(UInt32 messageVersion, byte[] macKey, ECPublicKey senderRatchetKey,
UInt32 counter, UInt32 previousCounter, byte[] ciphertext,
IdentityKey senderIdentityKey,
IdentityKey receiverIdentityKey)
{
byte[] version = { ByteUtil.IntsToByteHighAndLow(messageVersion, CURRENT_VERSION) };
var messageObj = new WhisperProtos.WhisperMessage {
RatchetKey = senderRatchetKey.Serialize(),
Counter = counter,
PreviousCounter = previousCounter,
Ciphertext = ciphertext
};
byte[] message;
using(var stream = new MemoryStream())
{
Serializer.Serialize<WhisperProtos.WhisperMessage>(stream, messageObj);
message = stream.ToArray();
}
byte[] mac = GetMac(messageVersion, senderIdentityKey, receiverIdentityKey, macKey,
ByteUtil.Combine(version, message));
_serialized = ByteUtil.Combine(version, message, mac);
SenderRatchetKey = senderRatchetKey;
Counter = counter;
PreviousCounter = previousCounter;
Body = ciphertext;
MessageVersion = messageVersion;
}
public bool registerPreKeys(IdentityKey identityKey,
PreKeyRecord lastResortKey,
SignedPreKeyRecord signedPreKey,
IList <PreKeyRecord> records)
//throws IOException
{
List <PreKeyEntity> entities = new List <PreKeyEntity>();
foreach (PreKeyRecord record in records)
{
PreKeyEntity entity = new PreKeyEntity(record.getId(),
record.getKeyPair().getPublicKey());
entities.Add(entity);
}
PreKeyEntity lastResortEntity = new PreKeyEntity(lastResortKey.getId(),
lastResortKey.getKeyPair().getPublicKey());
SignedPreKeyEntity signedPreKeyEntity = new SignedPreKeyEntity(signedPreKey.getId(),
signedPreKey.getKeyPair().getPublicKey(),
signedPreKey.getSignature());
makeRequest(string.Format(PREKEY_PATH, ""), "PUT",
JsonUtil.toJson(new PreKeyState(entities, lastResortEntity,
signedPreKeyEntity, identityKey)));
return(true);
}
public bool IsValidIdentity(long recipientId,
IdentityKey theirIdentity)
{
try
{
var query = conn.Table <Identity>().Where(v => v.RecipientId.Equals(recipientId));
if (query.Count() > 0)
{
var identity = query.First();
String serializedIdentity = identity.Key;
String mac = identity.Mac;
IdentityKey ourIdentity = new IdentityKey(Base64.decode(serializedIdentity), 0);
return(ourIdentity.Equals(theirIdentity));
}
else
{
return(true);
}
}
catch (IOException e) { return(false); }
catch (InvalidKeyException e) { return(false); }
catch (Exception e) { return(false); }
}
public SignalMessage(uint messageVersion, byte[] macKey, ECPublicKey senderRatchetKey,
uint counter, uint previousCounter, byte[] ciphertext,
IdentityKey senderIdentityKey,
IdentityKey receiverIdentityKey)
{
byte[] version = { ByteUtil.intsToByteHighAndLow((int)messageVersion, (int)CURRENT_VERSION) };
byte[] message = new SignalMessage
{
ratchedKeyOneofCase_ = RatchedKeyOneofOneofCase.RatchetKey,
RatchetKey = ByteString.CopyFrom(senderRatchetKey.serialize()), //TODO serialize ok?
counterOneofCase_ = CounterOneofOneofCase.Counter,
Counter = counter,
previousCounterOneofCase_ = PreviousCounterOneofOneofCase.PreviousCounter,
PreviousCounter = previousCounter,
ciphertextOneofCase_ = CiphertextOneofOneofCase.Ciphertext,
Ciphertext = ByteString.CopyFrom(ciphertext),
}.ToByteArray();
byte[] mac = getMac(senderIdentityKey, receiverIdentityKey, macKey, ByteUtil.combine(version, message));
this.serialized = ByteUtil.combine(version, message, mac);
this.senderRatchetKey = senderRatchetKey;
this.counter = counter;
this.previousCounter = previousCounter;
this.ciphertext = ciphertext;
this.messageVersion = messageVersion;
}
public KeyExchangeMessage(uint messageVersion, uint sequence, uint flags,
ECPublicKey baseKey, byte[] baseKeySignature,
ECPublicKey ratchetKey,
IdentityKey identityKey)
{
this.supportedVersion = CiphertextMessage.CURRENT_VERSION;
this.version = messageVersion;
this.sequence = sequence;
this.flags = flags;
this.baseKey = baseKey;
this.baseKeySignature = baseKeySignature;
this.ratchetKey = ratchetKey;
this.identityKey = identityKey;
byte[] version = { ByteUtil.intsToByteHighAndLow((int)this.version, (int)this.supportedVersion) };
WhisperProtos.KeyExchangeMessage.Builder builder = WhisperProtos.KeyExchangeMessage
.CreateBuilder()
.SetId((sequence << 5) | flags) //(sequence << 5) | flags
.SetBaseKey(ByteString.CopyFrom(baseKey.serialize()))
.SetRatchetKey(ByteString.CopyFrom(ratchetKey.serialize()))
.SetIdentityKey(ByteString.CopyFrom(identityKey.serialize()));
if (messageVersion >= 3)
{
builder.SetBaseKeySignature(ByteString.CopyFrom(baseKeySignature));
}
this.serialized = ByteUtil.combine(version, builder.Build().ToByteArray());
}
public bool IsTrustedIdentity(SignalProtocolAddress address, IdentityKey identityKey, Direction direction)
{
IdentityKey trusted;
trustedKeys.TryGetValue(address, out trusted); // get(name)
return(trusted == null || trusted.Equals(identityKey));
}
public PreKeySignalMessage(uint messageVersion, uint registrationId, May <uint> preKeyId,
uint signedPreKeyId, ECPublicKey baseKey, IdentityKey identityKey,
SignalMessage message)
{
this.version = messageVersion;
this.registrationId = registrationId;
this.preKeyId = preKeyId;
this.signedPreKeyId = signedPreKeyId;
this.baseKey = baseKey;
this.identityKey = identityKey;
this.message = message;
WhisperProtos.PreKeySignalMessage.Builder builder =
WhisperProtos.PreKeySignalMessage.CreateBuilder()
.SetSignedPreKeyId(signedPreKeyId)
.SetBaseKey(ByteString.CopyFrom(baseKey.serialize()))
.SetIdentityKey(ByteString.CopyFrom(identityKey.serialize()))
.SetMessage(ByteString.CopyFrom(message.serialize()))
.SetRegistrationId(registrationId);
if (preKeyId.HasValue) // .isPresent()
{
builder.SetPreKeyId(preKeyId.ForceGetValue()); // get()
}
byte[] versionBytes = { ByteUtil.intsToByteHighAndLow((int)this.version, (int)CURRENT_VERSION) };
byte[] messageBytes = builder.Build().ToByteArray();
this.serialized = ByteUtil.combine(versionBytes, messageBytes);
}
private byte[] getMac(uint messageVersion,
IdentityKey senderIdentityKey,
IdentityKey receiverIdentityKey,
byte[] macKey, byte[] serialized)
{
try
{
MemoryStream stream = new MemoryStream();
if (messageVersion >= 3)
{
byte[] sik = senderIdentityKey.getPublicKey().serialize();
stream.Write(sik, 0, sik.Length);
byte[] rik = receiverIdentityKey.getPublicKey().serialize();
stream.Write(rik, 0, rik.Length);
}
stream.Write(serialized, 0, serialized.Length);
byte[] fullMac = Sign.sha256sum(macKey, stream.ToArray());
return(ByteUtil.trim(fullMac, MAC_LENGTH));
}
catch (/*NoSuchAlgorithmException | java.security.InvalidKey*/ Exception e)
{
throw new Exception(e.Message);
}
}
/// <summary>
///
/// </summary>
/// <param name="recipientId"></param>
/// <param name="identityKey"></param>
/// <returns></returns>
public bool IsTrustedIdentity(string recipientId, IdentityKey identityKey)
{
IdentitiesObject trusted;
IdentitiesObjectDic.TryGetValue(recipientId, out trusted);
return(true);
}
public VerifiedMessage(string destination, IdentityKey identityKey, VerifiedState verified, long timestamp)
{
Destination = destination;
IdentityKey = identityKey;
Verified = verified;
Timestamp = timestamp;
}
public bool SaveIdentity(string name, IdentityKey identityKey)
{
if (this.OnsaveIdentity != null)
{
return(this.OnsaveIdentity(name, identityKey.serialize()));
}
return(false);
}
public PreKeyState(List <PreKeyEntity> preKeys, PreKeyEntity lastResortKey,
SignedPreKeyEntity signedPreKey, IdentityKey identityKey)
{
this.preKeys = preKeys;
this.lastResortKey = lastResortKey;
this.signedPreKey = signedPreKey;
this.identityKey = identityKey;
}
public bool IsTrustedIdentity(string name, IdentityKey identityKey)
{
if (this.OnisTrustedIdentity != null)
{
return(this.OnisTrustedIdentity(name, identityKey.serialize()));
}
return(false); // FIXME: this isn't correct workaround only
}
public PreKeyBundle(uint registrationId, uint deviceId, uint preKeyId, ECPublicKey preKeyPublic,
uint signedPreKeyId, ECPublicKey signedPreKeyPublic, byte[] signedPreKeySignature,
IdentityKey identityKey)
{
this.registrationId = registrationId;
this.deviceId = deviceId;
this.preKeyId = preKeyId;
this.preKeyPublic = preKeyPublic;
this.signedPreKeyId = signedPreKeyId;
this.signedPreKeyPublic = signedPreKeyPublic;
this.signedPreKeySignature = signedPreKeySignature;
this.identityKey = identityKey;
}
public PreKeyBundle(UInt32 registrationId, UInt32 deviceId, UInt32 preKeyId, ECPublicKey preKeyPublic,
UInt32 signedPreKeyId, ECPublicKey signedPreKeyPublic, byte[] signedPreKeySignature,
IdentityKey identityKey)
{
RegistrationID = registrationId;
DeviceID = deviceId;
PreKeyId = preKeyId;
PreKeyPublic = preKeyPublic;
SignedPreKeyID = signedPreKeyId;
SignedPreKeyPublic = signedPreKeyPublic;
SignedPreKeySignature = signedPreKeySignature;
IdentityKey = identityKey;
}
BobAxolotlParameters(IdentityKeyPair ourIdentityKey, ECKeyPair ourSignedPreKey,
ECKeyPair ourRatchetKey, May<ECKeyPair> ourOneTimePreKey,
IdentityKey theirIdentityKey, ECPublicKey theirBaseKey)
{
this.ourIdentityKey = ourIdentityKey;
this.ourSignedPreKey = ourSignedPreKey;
this.ourRatchetKey = ourRatchetKey;
this.ourOneTimePreKey = ourOneTimePreKey;
this.theirIdentityKey = theirIdentityKey;
this.theirBaseKey = theirBaseKey;
if (ourIdentityKey == null || ourSignedPreKey == null || ourRatchetKey == null ||
ourOneTimePreKey == null || theirIdentityKey == null || theirBaseKey == null)
{
throw new Exception("Null value!");
}
}
SymmetricAxolotlParameters(ECKeyPair ourBaseKey, ECKeyPair ourRatchetKey,
IdentityKeyPair ourIdentityKey, ECPublicKey theirBaseKey,
ECPublicKey theirRatchetKey, IdentityKey theirIdentityKey)
{
this.ourBaseKey = ourBaseKey;
this.ourRatchetKey = ourRatchetKey;
this.ourIdentityKey = ourIdentityKey;
this.theirBaseKey = theirBaseKey;
this.theirRatchetKey = theirRatchetKey;
this.theirIdentityKey = theirIdentityKey;
if (ourBaseKey == null || ourRatchetKey == null || ourIdentityKey == null ||
theirBaseKey == null || theirRatchetKey == null || theirIdentityKey == null)
{
throw new Exception("Null values!");
}
}
public AliceAxolotlParameters(IdentityKeyPair ourIdentityKey, ECKeyPair ourBaseKey,
IdentityKey theirIdentityKey, ECPublicKey theirSignedPreKey,
ECPublicKey theirRatchetKey, Maybe<ECPublicKey> theirOneTimePreKey)
{
OurIdentityKey = ourIdentityKey;
OurBaseKey = ourBaseKey;
TheirIdentityKey = theirIdentityKey;
TheirSignedPreKey = theirSignedPreKey;
TheirRatchetKey = theirRatchetKey;
TheirOneTimePreKey = theirOneTimePreKey;
if (ourIdentityKey == null || ourBaseKey == null || theirIdentityKey == null ||
theirSignedPreKey == null || theirRatchetKey == null)
{
throw new Exception ("Null values!");
}
}
public PreKeyWhisperMessage(byte[] serialized)
{
try
{
MessageVersion = (UInt32)ByteUtil.HighBitsToUInt(serialized[0]);
if(MessageVersion > CiphertextMessage.CURRENT_VERSION)
{
throw new InvalidVersionException("Unknown version: " + MessageVersion);
}
WhisperProtos.PreKeyWhisperMessage preKeyWhisperMessage;
using(var stream = new MemoryStream(serialized))
{
preKeyWhisperMessage = Serializer.Deserialize<WhisperProtos.PreKeyWhisperMessage>(stream);
}
if((MessageVersion == 2 && !preKeyWhisperMessage.preKeyId.HasValue) ||
(MessageVersion == 3 && !preKeyWhisperMessage.signedPreKeyId.HasValue) ||
preKeyWhisperMessage.baseKey == null ||
preKeyWhisperMessage.identityKey == null ||
preKeyWhisperMessage.message == null)
{
throw new InvalidMessageException("Incomplete message.");
}
_serialized = serialized;
RegistrationId = preKeyWhisperMessage.registrationId.Value;
PreKeyId = preKeyWhisperMessage.preKeyId.Value.ToMaybe();
SignedPreKeyId = preKeyWhisperMessage.signedPreKeyId.Value; //() ? preKeyWhisperMessage.getSignedPreKeyId() : -1;
BaseKey = Curve.DecodePoint(preKeyWhisperMessage.baseKey, 0);
IdentityKey = new IdentityKey(Curve.DecodePoint(preKeyWhisperMessage.identityKey, 0));
Message = new WhisperMessage(preKeyWhisperMessage.message);
}
catch(InvalidKeyException e)
{
throw new InvalidMessageException(e);
}
catch(LegacyMessageException e)
{
throw new InvalidMessageException(e);
}
}
public PreKeyWhisperMessage(byte[] serialized)
{
try
{
this.version = (uint)ByteUtil.highBitsToInt(serialized[0]);
if (this.version > CiphertextMessage.CURRENT_VERSION)
{
throw new InvalidVersionException("Unknown version: " + this.version);
}
WhisperProtos.PreKeyWhisperMessage preKeyWhisperMessage
= WhisperProtos.PreKeyWhisperMessage.ParseFrom(ByteString.CopyFrom(serialized, 1,
serialized.Length - 1));
if ((version == 2 && !preKeyWhisperMessage.HasPreKeyId) ||
(version == 3 && !preKeyWhisperMessage.HasSignedPreKeyId) ||
!preKeyWhisperMessage.HasBaseKey ||
!preKeyWhisperMessage.HasIdentityKey ||
!preKeyWhisperMessage.HasMessage)
{
throw new InvalidMessageException("Incomplete message.");
}
this.serialized = serialized;
this.registrationId = preKeyWhisperMessage.RegistrationId;
this.preKeyId = preKeyWhisperMessage.HasPreKeyId ? new May<uint>(preKeyWhisperMessage.PreKeyId) : May<uint>.NoValue;
this.signedPreKeyId = preKeyWhisperMessage.HasSignedPreKeyId ? preKeyWhisperMessage.SignedPreKeyId : uint.MaxValue; // -1
this.baseKey = Curve.decodePoint(preKeyWhisperMessage.BaseKey.ToByteArray(), 0);
this.identityKey = new IdentityKey(Curve.decodePoint(preKeyWhisperMessage.IdentityKey.ToByteArray(), 0));
this.message = new WhisperMessage(preKeyWhisperMessage.Message.ToByteArray());
}
catch (Exception e)
{
//(InvalidProtocolBufferException | InvalidKeyException | LegacyMessage
throw new InvalidMessageException(e.Message);
}
}
public WhisperMessage(uint messageVersion, byte[] macKey, ECPublicKey senderRatchetKey,
uint counter, uint previousCounter, byte[] ciphertext,
IdentityKey senderIdentityKey,
IdentityKey receiverIdentityKey)
{
byte[] version = { ByteUtil.intsToByteHighAndLow((int)messageVersion, (int)CURRENT_VERSION) };
byte[] message = WhisperProtos.WhisperMessage.CreateBuilder()
.SetRatchetKey(ByteString.CopyFrom(senderRatchetKey.serialize()))
.SetCounter(counter)
.SetPreviousCounter(previousCounter)
.SetCiphertext(ByteString.CopyFrom(ciphertext))
.Build().ToByteArray();
byte[] mac = getMac(messageVersion, senderIdentityKey, receiverIdentityKey, macKey,
ByteUtil.combine(version, message));
this.serialized = ByteUtil.combine(version, message, mac);
this.senderRatchetKey = senderRatchetKey;
this.counter = counter;
this.previousCounter = previousCounter;
this.ciphertext = ciphertext;
this.messageVersion = messageVersion;
}
public Builder setTheirIdentityKey(IdentityKey theirIdentityKey)
{
this.theirIdentityKey = theirIdentityKey;
return this;
}
public UntrustedIdentityException(String name, IdentityKey key)
{
this.name = name;
this.key = key;
}
private byte[] GetMac(UInt32 messageVersion,
IdentityKey senderIdentityKey,
IdentityKey receiverIdentityKey,
byte[] macKey, byte[] serialized)
{
try
{
byte[] fullMac;
using(var mac = new HMACSHA256(macKey))
{
if(messageVersion >= 3)
{
var SIk = senderIdentityKey.PublicKey.Serialize();
var RIk = receiverIdentityKey.PublicKey.Serialize();
mac.TransformBlock(SIk, 0, SIk.Length, null, 0);
mac.TransformBlock(RIk, 0, RIk.Length, null, 0);
}
fullMac = mac.TransformFinalBlock(serialized, 0, serialized.Length);
}
return ByteUtil.Trim(fullMac, MAC_LENGTH);
}
catch(Exception e)
{
throw new InvalidOperationException("Assertion error", e);
}
}
public void SetLocalIdentityKey(IdentityKey identityKey)
{
Structure.LocalIdentityPublic = identityKey.Serialize();
}
public KeyExchangeMessage(byte[] serialized)
{
try
{
byte[][] parts = ByteUtil.split(serialized, 1, serialized.Length - 1);
this.version = (uint)ByteUtil.highBitsToInt(parts[0][0]);
this.supportedVersion = (uint)ByteUtil.lowBitsToInt(parts[0][0]);
if (this.version <= CiphertextMessage.UNSUPPORTED_VERSION)
{
throw new LegacyMessageException("Unsupported legacy version: " + this.version);
}
if (this.version > CiphertextMessage.CURRENT_VERSION)
{
throw new InvalidVersionException("Unknown version: " + this.version);
}
WhisperProtos.KeyExchangeMessage message = WhisperProtos.KeyExchangeMessage.ParseFrom(parts[1]);
if (!message.HasId || !message.HasBaseKey ||
!message.HasRatchetKey || !message.HasIdentityKey ||
(this.version >= 3 && !message.HasBaseKeySignature))
{
throw new InvalidMessageException("Some required fields missing!");
}
this.sequence = message.Id >> 5;
this.flags = message.Id & 0x1f;
this.serialized = serialized;
this.baseKey = Curve.decodePoint(message.BaseKey.ToByteArray(), 0);
this.baseKeySignature = message.BaseKeySignature.ToByteArray();
this.ratchetKey = Curve.decodePoint(message.RatchetKey.ToByteArray(), 0);
this.identityKey = new IdentityKey(message.IdentityKey.ToByteArray(), 0);
}
catch (InvalidKeyException e)
{
throw new InvalidMessageException(e);
}
}
public void SetRemoteIdentityKey(IdentityKey identityKey)
{
Structure.RemoteIdentityPublic = identityKey.Serialize ();
}
public bool SaveIdentity(String name, IdentityKey identityKey)
{
trustedKeys[name] = identityKey; //put
return true;
}
public bool IsTrustedIdentity(String name, IdentityKey identityKey)
{
IdentityKey trusted;
trustedKeys.TryGetValue(name, out trusted); // get(name)
return (trusted == null || trusted.Equals(identityKey));
}
public void VerifyMac(UInt32 messageVersion, IdentityKey senderIdentityKey,
IdentityKey receiverIdentityKey, byte[] macKey)
{
byte[][] parts = ByteUtil.Split(_serialized, _serialized.Length - MAC_LENGTH, MAC_LENGTH);
byte[] ourMac = GetMac(messageVersion, senderIdentityKey, receiverIdentityKey, macKey, parts[0]);
byte[] theirMac = parts[1];
if(!CompareArraysExhaustively(ourMac, theirMac))
{
throw new InvalidMessageException("Bad Mac!");
}
}
public Builder SetTheirIdentityKey(IdentityKey theirIdentityKey)
{
_theirIdentityKey = theirIdentityKey;
return this;
}
/**
* Generate an identity key pair. Clients should only do this once,
* at install time.
*
* @return the generated IdentityKeyPair.
*/
public static IdentityKeyPair generateIdentityKeyPair()
{
ECKeyPair keyPair = Curve.generateKeyPair();
IdentityKey publicKey = new IdentityKey(keyPair.getPublicKey());
return new IdentityKeyPair(publicKey, keyPair.getPrivateKey());
}
private byte[] getMac(uint messageVersion,
IdentityKey senderIdentityKey,
IdentityKey receiverIdentityKey,
byte[] macKey, byte[] serialized)
{
try
{
MemoryStream stream = new MemoryStream();
if (messageVersion >= 3)
{
byte[] sik = senderIdentityKey.getPublicKey().serialize();
stream.Write(sik, 0, sik.Length);
byte[] rik = receiverIdentityKey.getPublicKey().serialize();
stream.Write(rik, 0, rik.Length);
}
stream.Write(serialized, 0, serialized.Length);
byte[] fullMac = Sign.sha256sum(macKey, stream.ToArray());
return ByteUtil.trim(fullMac, MAC_LENGTH);
}
catch (/*NoSuchAlgorithmException | java.security.InvalidKey*/Exception e)
{
throw new Exception(e.Message);
}
}
public IdentityKeyPair getPendingKeyExchangeIdentityKey()
{
IdentityKey publicKey = new IdentityKey(sessionStructure.PendingKeyExchange
.LocalIdentityKey.ToByteArray(), 0);
ECPrivateKey privateKey = Curve.decodePrivatePoint(sessionStructure.PendingKeyExchange
.LocalIdentityKeyPrivate
.ToByteArray());
return new IdentityKeyPair(publicKey, privateKey);
}
public void verifyMac(uint messageVersion, IdentityKey senderIdentityKey,
IdentityKey receiverIdentityKey, byte[] macKey)
{
byte[][] parts = ByteUtil.split(serialized, serialized.Length - MAC_LENGTH, MAC_LENGTH);
byte[] ourMac = getMac(messageVersion, senderIdentityKey, receiverIdentityKey, macKey, parts[0]);
byte[] theirMac = parts[1];
if (!ourMac.SequenceEqual(theirMac))
{
throw new InvalidMessageException("Bad Mac!");
}
}
public void setLocalIdentityKey(IdentityKey identityKey)
{
this.sessionStructure = this.sessionStructure.ToBuilder()
.SetLocalIdentityPublic(ByteString.CopyFrom(identityKey.serialize()))
.Build();
}
public void SaveIdentity(string name, IdentityKey identityKey)
{
_trustedKeys.Add(name, identityKey);
}
