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