protected override async Task <string> ExecuteAsync() { //if (!TextSecurePreferences.isPushRegistered()) return; int availableKeys = await App.Current.accountManager.getPreKeysCount(); if (availableKeys >= PREKEY_MINIMUM && TextSecurePreferences.isSignedPreKeyRegistered()) { Debug.WriteLine("Available keys sufficient: " + availableKeys); return(""); } List <PreKeyRecord> preKeyRecords = await PreKeyUtil.generatePreKeys(/*context, masterSecret*/); PreKeyRecord lastResortKeyRecord = await PreKeyUtil.generateLastResortKey(/*context, masterSecret*/); IdentityKeyPair identityKey = IdentityKeyUtil.GetIdentityKeyPair(/*context, masterSecret*/); SignedPreKeyRecord signedPreKeyRecord = PreKeyUtil.generateSignedPreKey(/*context, masterSecret, */ identityKey); Debug.WriteLine("Registering new prekeys..."); await App.Current.accountManager.setPreKeys(identityKey.getPublicKey(), lastResortKeyRecord, signedPreKeyRecord, preKeyRecords); TextSecurePreferences.setSignedPreKeyRegistered(true); //App.Current.Worker.AddTaskActivities(new CleanPreKeysTask()); return(""); }
public void StoreLocalData(uint registrationId, IdentityKeyPair identityKeyPair) { if (this.OnStoreLocalData != null) { this.OnStoreLocalData(registrationId, identityKeyPair); } }
/// <summary> /// Fetch a ProvisionMessage from the server. /// </summary> /// <param name="token"></param> /// <param name="tempIdentity"></param> /// <returns></returns> public async Task <SignalServiceProvisionMessage> GetProvisioningMessage(CancellationToken token, IdentityKeyPair tempIdentity) { ProvisionMessage protoPm = await ProvisioningSocket.GetProvisioningMessage(token, tempIdentity); string provisioningCode = protoPm.ProvisioningCode; byte[] publicKeyBytes = protoPm.IdentityKeyPublic.ToByteArray(); if (publicKeyBytes.Length == 32) { byte[] type = { Curve.DJB_TYPE }; publicKeyBytes = ByteUtil.combine(type, publicKeyBytes); } ECPublicKey publicKey = Curve.decodePoint(publicKeyBytes, 0); byte[] privateKeyBytes = protoPm.IdentityKeyPrivate.ToByteArray(); ECPrivateKey privateKey = Curve.decodePrivatePoint(privateKeyBytes); IdentityKeyPair identity = new IdentityKeyPair(new IdentityKey(publicKey), privateKey); return(new SignalServiceProvisionMessage() { Number = protoPm.Number, Identity = identity, Code = protoPm.ProvisioningCode }); }
/// <summary> /// Generate the keysets for ourself /// </summary> /// <returns></returns> public bool sendSetPreKeys(bool isnew = false) { uint registrationId = 0; if (!isnew) { registrationId = (uint)this.GetLocalRegistrationId(); } else { registrationId = libaxolotl.util.KeyHelper.generateRegistrationId(true); } Random random = new Random(); uint randomid = (uint)libaxolotl.util.KeyHelper.getRandomSequence(65536); IdentityKeyPair identityKeyPair = libaxolotl.util.KeyHelper.generateIdentityKeyPair(); byte[] privateKey = identityKeyPair.getPrivateKey().serialize(); byte[] publicKey = identityKeyPair.getPublicKey().serialize(); IList <PreKeyRecord> preKeys = libaxolotl.util.KeyHelper.generatePreKeys((uint)random.Next(), 200); SignedPreKeyRecord signedPreKey = libaxolotl.util.KeyHelper.generateSignedPreKey(identityKeyPair, randomid); PreKeyRecord lastResortKey = libaxolotl.util.KeyHelper.generateLastResortPreKey(); this.StorePreKeys(preKeys); this.StoreLocalData(registrationId, identityKeyPair.getPublicKey().serialize(), identityKeyPair.getPrivateKey().serialize()); this.StoreSignedPreKey(signedPreKey.getId(), signedPreKey); List <ProtocolTreeNode> preKeyNodes = new List <ProtocolTreeNode>(); for (int i = 0; i < 200; i++) { byte[] prekeyId = adjustId(preKeys[i].getId().ToString()); byte[] prekey = preKeys[i].getKeyPair().getPublicKey().serialize().Skip(1).ToArray(); ProtocolTreeNode NodeId = new ProtocolTreeNode("id", null, null, prekeyId); ProtocolTreeNode NodeValue = new ProtocolTreeNode("value", null, null, prekey); preKeyNodes.Add(new ProtocolTreeNode("key", null, new[] { NodeId, NodeValue }, null)); } ProtocolTreeNode registration = new ProtocolTreeNode("registration", null, null, adjustId(registrationId.ToString())); ProtocolTreeNode identity = new ProtocolTreeNode("identity", null, null, publicKey.Skip(1).ToArray()); ProtocolTreeNode type = new ProtocolTreeNode("type", null, null, new byte[] { Curve.DJB_TYPE }); ProtocolTreeNode list = new ProtocolTreeNode("list", null, preKeyNodes.ToArray(), null); ProtocolTreeNode sid = new ProtocolTreeNode("id", null, null, adjustId(signedPreKey.getId().ToString())); ProtocolTreeNode value = new ProtocolTreeNode("value", null, null, signedPreKey.getKeyPair().getPublicKey().serialize().Skip(1).ToArray()); ProtocolTreeNode signature = new ProtocolTreeNode("signature", null, null, signedPreKey.getSignature()); ProtocolTreeNode secretKey = new ProtocolTreeNode("skey", null, new[] { sid, value, signature }, null); String id = TicketManager.GenerateId(); Helper.DebugAdapter.Instance.fireOnPrintDebug(string.Format("axolotl id = {0}", id)); ProtocolTreeNode Node = new ProtocolTreeNode("iq", new[] { new KeyValue("id", id), new KeyValue("xmlns", "encrypt"), new KeyValue("type", "set"), new KeyValue("to", "s.whatsapp.net") }, new ProtocolTreeNode[] { identity, registration, type, list, secretKey }, null); this.SendNode(Node); return(true); }
public NewDeviceLinkResult FinishNewDeviceRegistration(IdentityKeyPair tempIdentity, string signalingKey, string password, bool sms, bool fetches, int regid, string name) { ProvisionMessage pm = ProvisioningSocket.GetProvisioningMessage(tempIdentity); string provisioningCode = pm.ProvisioningCode; byte[] publicKeyBytes = pm.IdentityKeyPublic.ToByteArray(); if (publicKeyBytes.Length == 32) { byte[] type = { Curve.DJB_TYPE }; publicKeyBytes = ByteUtil.combine(type, publicKeyBytes); } ECPublicKey publicKey = Curve.decodePoint(publicKeyBytes, 0); byte[] privateKeyBytes = pm.IdentityKeyPrivate.ToByteArray(); ECPrivateKey privateKey = Curve.decodePrivatePoint(privateKeyBytes); IdentityKeyPair identity = new IdentityKeyPair(new IdentityKey(publicKey), privateKey); pushServiceSocket = new PushServiceSocket(Urls, new StaticCredentialsProvider(pm.Number, password, null, -1), userAgent); int deviceId = pushServiceSocket.finishNewDeviceRegistration(provisioningCode, signalingKey, sms, fetches, regid, name); return(new NewDeviceLinkResult() { DeviceId = deviceId, Identity = identity, Number = pm.Number }); }
public DeviceConsistencyMessage(DeviceConsistencyCommitment commitment, IdentityKeyPair identityKeyPair) { try { byte[] signatureBytes = Curve.CalculateVrfSignature(identityKeyPair.GetPrivateKey(), commitment.ToByteArray()); byte[] vrfOutputBytes = Curve.VerifyVrfSignature(identityKeyPair.GetPublicKey().GetPublicKey(), commitment.ToByteArray(), signatureBytes); _generation = commitment.GetGeneration(); _signature = new DeviceConsistencySignature(signatureBytes, vrfOutputBytes); _serialized = SignalProtos.DeviceConsistencyCodeMessage.CreateBuilder() .SetGeneration((uint)commitment.GetGeneration()) .SetSignature(ByteString.CopyFrom(_signature.GetSignature())) .Build() .ToByteArray(); } catch (InvalidKeyException e) { Debug.Assert(false); throw e; } catch (VrfSignatureVerificationFailedException e) { Debug.Assert(false); throw e; } }
/// <summary> /// TODO /// </summary> /// <param name="deviceIdentifier"></param> /// <param name="deviceKey"></param> /// <param name="identityKeyPair"></param> /// <param name="profileKey"></param> /// <param name="code"></param> /// <param name="token"></param> /// <exception cref="InvalidKeyException"><</exception> /// <exception cref="IOException"></exception> public async Task AddDeviceAsync(string deviceIdentifier, ECPublicKey deviceKey, IdentityKeyPair identityKeyPair, byte[] profileKey, string code, CancellationToken?token = null) { if (token == null) { token = CancellationToken.None; } ProvisioningCipher cipher = new ProvisioningCipher(deviceKey); ProvisionMessage message = new ProvisionMessage { IdentityKeyPublic = ByteString.CopyFrom(identityKeyPair.getPublicKey().serialize()), IdentityKeyPrivate = ByteString.CopyFrom(identityKeyPair.getPrivateKey().serialize()), Number = credentials.E164, ProvisioningCode = code }; if (profileKey != null) { message.ProfileKey = ByteString.CopyFrom(profileKey); } byte[] ciphertext = cipher.Encrypt(message); await pushServiceSocket.SendProvisioningMessageAsync(deviceIdentifier, ciphertext, token); }
private void initializeSessionsV2(SessionState aliceSessionState, SessionState bobSessionState) { ECKeyPair aliceIdentityKeyPair = Curve.generateKeyPair(); IdentityKeyPair aliceIdentityKey = new IdentityKeyPair(new IdentityKey(aliceIdentityKeyPair.getPublicKey()), aliceIdentityKeyPair.getPrivateKey()); ECKeyPair aliceBaseKey = Curve.generateKeyPair(); ECKeyPair aliceEphemeralKey = Curve.generateKeyPair(); ECKeyPair bobIdentityKeyPair = Curve.generateKeyPair(); IdentityKeyPair bobIdentityKey = new IdentityKeyPair(new IdentityKey(bobIdentityKeyPair.getPublicKey()), bobIdentityKeyPair.getPrivateKey()); ECKeyPair bobBaseKey = Curve.generateKeyPair(); ECKeyPair bobEphemeralKey = bobBaseKey; AliceAxolotlParameters aliceParameters = AliceAxolotlParameters.newBuilder() .setOurIdentityKey(aliceIdentityKey) .setOurBaseKey(aliceBaseKey) .setTheirIdentityKey(bobIdentityKey.getPublicKey()) .setTheirSignedPreKey(bobEphemeralKey.getPublicKey()) .setTheirRatchetKey(bobEphemeralKey.getPublicKey()) .setTheirOneTimePreKey(May <ECPublicKey> .NoValue) .create(); BobAxolotlParameters bobParameters = BobAxolotlParameters.newBuilder() .setOurIdentityKey(bobIdentityKey) .setOurOneTimePreKey(May <ECKeyPair> .NoValue) .setOurRatchetKey(bobEphemeralKey) .setOurSignedPreKey(bobBaseKey) .setTheirBaseKey(aliceBaseKey.getPublicKey()) .setTheirIdentityKey(aliceIdentityKey.getPublicKey()) .create(); RatchetingSession.initializeSession(aliceSessionState, 2, aliceParameters); RatchetingSession.initializeSession(bobSessionState, 2, bobParameters); }
public ProvisionMessage Decrypt(IdentityKeyPair tmpIdentity, byte[] message) { ProvisionEnvelope env = ProvisionEnvelope.Parser.ParseFrom(message); ECPublicKey publicKey = Curve.decodePoint(env.PublicKey.ToByteArray(), 0); byte[] sharedSecret = Curve.calculateAgreement(publicKey, tmpIdentity.getPrivateKey()); byte[] derivedSecret = new HKDFv3().deriveSecrets(sharedSecret, Encoding.UTF8.GetBytes("TextSecure Provisioning Message"), 64); byte[][] parts = Util.Split(derivedSecret, 32, 32); byte[] joined = env.Body.ToByteArray(); if (joined[0] != 0x01) { throw new Exception("Bad version number on provision message!"); } byte[] iv = new byte[16]; Array.Copy(joined, 1, iv, 0, 16); byte[] ciphertext = new byte[joined.Length - 32 - 17]; Array.Copy(joined, 17, ciphertext, 0, joined.Length - 32 - 17); byte[] ivAndCiphertext = new byte[joined.Length - 32]; Array.Copy(joined, ivAndCiphertext, joined.Length - 32); byte[] mac = new byte[32]; Array.Copy(joined, joined.Length - 32, mac, 0, 32); VerifyMac(parts[1], ivAndCiphertext, mac); return(ProvisionMessage.Parser.ParseFrom(Decrypt(parts[0], iv, ciphertext))); }
/// <summary> /// Fetch a ProvisionMessage from the server. /// </summary> /// <param name="tempIdentity"></param> /// <param name="token"></param> /// <returns></returns> public async Task <SignalServiceProvisionMessage> GetProvisioningMessageAsync(IdentityKeyPair tempIdentity, CancellationToken?token = null) { if (token == null) { token = CancellationToken.None; } if (provisioningSocket == null) { throw new NullReferenceException($"{nameof(provisioningSocket)} is null. Maybe you forgot to call GetNewDeviceUuid?"); } ProvisionMessage protoPm = await provisioningSocket.GetProvisioningMessageAsync(tempIdentity, token); string provisioningCode = protoPm.ProvisioningCode; byte[] publicKeyBytes = protoPm.IdentityKeyPublic.ToByteArray(); if (publicKeyBytes.Length == 32) { byte[] type = { Curve.DJB_TYPE }; publicKeyBytes = ByteUtil.combine(type, publicKeyBytes); } ECPublicKey publicKey = Curve.decodePoint(publicKeyBytes, 0); byte[] privateKeyBytes = protoPm.IdentityKeyPrivate.ToByteArray(); ECPrivateKey privateKey = Curve.decodePrivatePoint(privateKeyBytes); IdentityKeyPair identity = new IdentityKeyPair(new IdentityKey(publicKey), privateKey); return(new SignalServiceProvisionMessage() { Number = protoPm.Number, Identity = identity, Code = protoPm.ProvisioningCode }); }
public void Test_OmemoBundleInformation_2() { IdentityKeyPair aliceIdentKey = CryptoUtils.generateOmemoIdentityKeyPair(); IList <PreKeyRecord> alicePreKeys = CryptoUtils.generateOmemoPreKeys(); SignedPreKeyRecord aliceSignedPreKey = CryptoUtils.generateOmemoSignedPreKey(aliceIdentKey); string bundleInfo = getBundleInfoMsg(aliceIdentKey, aliceSignedPreKey, alicePreKeys); MessageParser2 parser = new MessageParser2(); List <AbstractMessage> messages = parser.parseMessages(ref bundleInfo); // Check if message parsed successfully: Assert.IsTrue(messages.Count == 1); Assert.IsInstanceOfType(messages[0], typeof(OmemoBundleInformationResultMessage)); OmemoBundleInformationResultMessage bundleInfoMsg = messages[0] as OmemoBundleInformationResultMessage; // Check if keys match: Assert.IsTrue(bundleInfoMsg.BUNDLE_INFO.PUBLIC_IDENTITY_KEY.serialize().SequenceEqual(aliceIdentKey.getPublicKey().serialize())); Assert.IsTrue(bundleInfoMsg.BUNDLE_INFO.PUBLIC_SIGNED_PRE_KEY.serialize().SequenceEqual(aliceSignedPreKey.getKeyPair().getPublicKey().serialize())); Assert.IsTrue(bundleInfoMsg.BUNDLE_INFO.SIGNED_PRE_KEY_ID == aliceSignedPreKey.getId()); Assert.IsTrue(bundleInfoMsg.BUNDLE_INFO.SIGNED_PRE_KEY_SIGNATURE.SequenceEqual(aliceSignedPreKey.getSignature())); Assert.IsTrue(bundleInfoMsg.BUNDLE_INFO.PUBLIC_PRE_KEYS.Count == alicePreKeys.Count); foreach (PreKeyRecord key in alicePreKeys) { IEnumerable <Tuple <uint, ECPublicKey> > matches = bundleInfoMsg.BUNDLE_INFO.PUBLIC_PRE_KEYS.Where(x => x.Item1 == key.getId()); Assert.IsTrue(matches.Count() == 1); byte[] a = matches.First().Item2.serialize(); byte[] b = key.getKeyPair().getPublicKey().serialize(); Assert.IsTrue(a.SequenceEqual(b)); } }
public ProvisionMessage GetProvisioningMessage(IdentityKeyPair tmpIdentity) { byte[] raw = IncomingRequests.Take(Token); WebSocketMessage msg = WebSocketMessage.Parser.ParseFrom(raw); return(new ProvisioningCipher(null).Decrypt(tmpIdentity, msg.Request.Body.ToByteArray())); }
public DeviceConsistencyMessage(DeviceConsistencyCommitment commitment, IdentityKeyPair identityKeyPair) { try { byte[] signatureBytes = Curve.calculateVrfSignature(identityKeyPair.getPrivateKey(), commitment.toByteArray()); byte[] vrfOutputBytes = Curve.verifyVrfSignature(identityKeyPair.getPublicKey().getPublicKey(), commitment.toByteArray(), signatureBytes); this.generation = commitment.getGeneration(); this.signature = new DeviceConsistencySignature(signatureBytes, vrfOutputBytes); this.serialized = new DeviceConsistencyCodeMessage { Generation = (uint)commitment.getGeneration(), Signature = ByteString.CopyFrom(signature.getSignature()) }.ToByteArray(); } catch (InvalidKeyException e) { Debug.Assert(false); throw e; } catch (VrfSignatureVerificationFailedException e) { Debug.Assert(false); throw e; } }
/// <summary> /// Generate a signed PreKey /// </summary> /// <param name="identityKeyPair">The local client's identity key pair.</param> /// <param name="signedPreKeyId">The PreKey id to assign the generated signed PreKey</param> /// <returns>the generated signed PreKey</returns> /// <exception cref="InvalidKeyException">when the provided identity key is invalid</exception> public static SignedPreKeyRecord generateSignedPreKey(IdentityKeyPair identityKeyPair, uint signedPreKeyId) { ECKeyPair keyPair = Curve.generateKeyPair(); byte[] signature = Curve.calculateSignature(identityKeyPair.getPrivateKey(), keyPair.getPublicKey().serialize()); return(new SignedPreKeyRecord(signedPreKeyId, getTime(), keyPair, signature)); }
/// <summary> /// Generates a new omemoIdentityKeyPair, omemoSignedPreKeyPair, omemoPreKeys. /// Sets omemoDeviceId to 0. /// Sets omemoBundleInfoAnnounced to false. /// </summary> public void generateOmemoKeys() { omemoDeviceId = 0; omemoBundleInfoAnnounced = false; omemoIdentityKeyPair = CryptoUtils.generateOmemoIdentityKeyPair(); omemoPreKeys = CryptoUtils.generateOmemoPreKeys(); omemoSignedPreKeyPair = CryptoUtils.generateOmemoSignedPreKey(omemoIdentityKeyPair); omemoSignedPreKeyId = omemoSignedPreKeyPair.getId(); }
public static SignedPreKeyRecord GenerateSignedPreKey(IdentityKeyPair identityKeyPair, UInt32 signedPreKeyId) { var keyPair = Curve.GenerateKeyPair(); var signature = Curve.CalculateSignature(identityKeyPair.PrivateKey, keyPair.PublicKey.Serialize()); var Jan1st1970 = new DateTime (1970, 1, 1, 0, 0, 0, DateTimeKind.Utc); return new SignedPreKeyRecord(signedPreKeyId, (long)(DateTime.UtcNow - Jan1st1970).TotalMilliseconds, keyPair, signature); }
public async Task <ProvisionMessage> GetProvisioningMessageAsync(IdentityKeyPair tmpIdentity, CancellationToken?token = null) { if (token == null) { token = CancellationToken.None; } var msg = await TakeAsync(token); return(new ProvisioningCipher(null !).Decrypt(tmpIdentity, msg.Request.Body.ToByteArray())); }
private static Task <SignedPreKeyRecord> generateSignedPreKey(IdentityKeyPair identityKeyPair, uint signedPreKeyId) { return(Task.Run(() => { ECKeyPair keyPair = Curve.generateKeyPair(); byte[] signature = Curve.calculateSignature(identityKeyPair.getPrivateKey(), keyPair.getPublicKey().serialize()); SignedPreKeyRecord record = new SignedPreKeyRecord(signedPreKeyId, KeyHelper.getTime(), keyPair, signature); return record; })); }
private async Task <bool> handleRegistration(string receivedSmsVerificationCode) { try { var registrationId = KeyHelper.generateRegistrationId(false); TextSecurePreferences.setLocalRegistrationId((int)registrationId); await App.Current.accountManager.verifyAccountWithCode(receivedSmsVerificationCode, signalingKey, registrationId, false); //await PushHelper.getInstance().OpenChannelAndUpload(); // also updates push channel id Recipient self = DatabaseFactory.getRecipientDatabase().GetSelfRecipient(number); IdentityKeyUtil.generateIdentityKeys(); IdentityKeyPair identityKey = IdentityKeyUtil.GetIdentityKeyPair(); List <PreKeyRecord> records = await PreKeyUtil.generatePreKeys(); PreKeyRecord lastResort = await PreKeyUtil.generateLastResortKey(); SignedPreKeyRecord signedPreKey = await PreKeyUtil.generateSignedPreKey(identityKey); await App.Current.accountManager.setPreKeys(identityKey.getPublicKey(), lastResort, signedPreKey, records); DatabaseFactory.getIdentityDatabase().SaveIdentity(self.getRecipientId(), identityKey.getPublicKey()); //await DirectoryHelper.refreshDirectory(App.Current.accountManager, TextSecurePreferences.getLocalNumber()); markAsVerified(number, password, signalingKey); } catch (RateLimitException ex) { return(false); } catch (AuthorizationFailedException ex) { return(false); } catch (PushNetworkException ex) { return(false); } catch (NonSuccessfulResponseCodeException ex) { return(false); } catch (Exception ex) { return(false); //throw new Exception(ex.Message); } return(true); }
private static SignedPreKeyRecord generateSignedPreKey(IdentityKeyPair identityKeyPair, uint signedPreKeyId) { //return Task.Run(() => //{ ECKeyPair keyPair = Curve.generateKeyPair(); byte[] signature = Curve.calculateSignature(identityKeyPair.getPrivateKey(), keyPair.getPublicKey().serialize()); SignedPreKeyRecord record = new SignedPreKeyRecord(signedPreKeyId, (ulong)TimeUtil.GetUnixTimestampMillis(), keyPair, signature); return(record); // }); }
public void Test_CryptoUtils_GenOmemoFingerprint() { string identKeyPairSerializedHex = "0a210511dbad7fcece74492f390f0a2a8387c543e802ab7f2176e303e28840559c41521220a082ae07fd8941536457cb2f3e4b560a87991d380f02af460b5204e46ca7b15a"; byte[] identKeyPairSerialized = CryptoUtils.hexStringToByteArray(identKeyPairSerializedHex); IdentityKeyPair identKeyPair = new IdentityKeyPair(identKeyPairSerialized); string outputRef = "11dbad7f cece7449 2f390f0a 2a8387c5 43e802ab 7f2176e3 03e28840 559c4152"; string output = CryptoUtils.generateOmemoFingerprint(identKeyPair.getPublicKey(), false); Assert.AreEqual(outputRef, output); }
/// <summary> /// /// </summary> /// <returns></returns> public IdentityKeyPair GetIdentityKeyPair() { IdentityKeyPair result = null; IdentitiesObject identity; IdentitiesObjectDic.TryGetValue("-1", out identity); if (identity != null) { result = new IdentityKeyPair(new IdentityKey(new DjbECPublicKey(identity.PublicKey)), new DjbECPrivateKey(identity.PrivateKey)); } return(result); }
public void StoreLocalData(uint registrationId, IdentityKeyPair identityKey) { IdentityKeysRepository identityKeysRepository = new IdentityKeysRepository(); IdentityKeys newKeys = new IdentityKeys() { RecipientId = "-1", RegistrationId = Convert.ToString(registrationId), PublicKey = identityKey.GetPublicKey().Serialize(), PrivateKey = identityKey.GetPrivateKey().Serialize() }; identityKeysRepository.Save(newKeys); }
// Implement OnLogin method public void OnRegister(object sender, EventArgs e) { IdentityKeyPair identityKeyPair = KeyHelper.generateIdentityKeyPair(); uint registrationId = KeyHelper.generateRegistrationId(false); List <PreKeyRecord> preKeys = KeyHelper.generatePreKeys(registrationId, 100).ToList(); Random random = new Random(); SignedPreKeyRecord signedPreKey = KeyHelper.generateSignedPreKey(identityKeyPair, Convert.ToUInt32(random.Next())); InMemorySessionStore SessionStore = new InMemorySessionStore(); //SessionStore.StoreSession(new SignalProtocolAddress("1234", 1), new SessionRecord()); PreKeyStore PreKeyStore = new InMemoryPreKeyStore(); SignedPreKeyStore SignedPreKeyStore = new InMemorySignedPreKeyStore(); InMemoryIdentityKeyStore IdentityStore = new InMemoryIdentityKeyStore(identityKeyPair, registrationId); // Store preKeys in PreKeyStore. foreach (PreKeyRecord preKey in preKeys) { PreKeyStore.StorePreKey(preKey.getId(), preKey); } // Store signed prekey in SignedPreKeyStore. SignedPreKeyStore.StoreSignedPreKey(signedPreKey.getId(), signedPreKey); // Save stores in local Database ISharedPreferences sharedprefs = PreferenceManager.GetDefaultSharedPreferences(this); ISharedPreferencesEditor editor = sharedprefs.Edit(); editor.PutString("PreKeyStore", JsonConvert.SerializeObject(PreKeyStore)); editor.PutString("SignedPreKeyStore", JsonConvert.SerializeObject(SignedPreKeyStore)); List <Session> AllSessions = SessionStore.GetAllSessions(); editor.PutString("AllSessions", JsonConvert.SerializeObject(AllSessions)); editor.PutString("SessionStore", JsonConvert.SerializeObject(SessionStore)); editor.PutString("IdentityStore", JsonConvert.SerializeObject(IdentityStore)); List <TrustedKey> AllTrustedKeys = IdentityStore.GetAllTrustedKeys(); editor.PutString("AllTrustedKeys", JsonConvert.SerializeObject(AllTrustedKeys)); editor.Apply(); //var sessionStore = JsonConvert.DeserializeObject<InMemorySessionStore>(sharedprefs.GetString("SessionStore", string.Empty)); //var allSessions = JsonConvert.DeserializeObject<List<Session>>(sharedprefs.GetString("AllSessions", string.Empty)); //foreach (Session item in allSessions) //{ // sessionStore.StoreSession(item.Name, item.DeviceID, item.array); //} // method to regidter in database RequestRegister(registrationId, identityKeyPair, signedPreKey, preKeys); StartActivity(typeof(FriendsActivity)); }
private void InitializeSessions(TestInMemorySignalProtocolStore aliceStore, TestInMemorySignalProtocolStore bobStore) { ECKeyPair bobPreKey = Curve.generateKeyPair(); IdentityKeyPair bobIdentityKey = bobStore.GetIdentityKeyPair(); SignedPreKeyRecord bobSignedPreKey = KeyHelper.generateSignedPreKey(bobIdentityKey, 2); PreKeyBundle bobBundle = new PreKeyBundle(1, 1, 1, bobPreKey.getPublicKey(), 2, bobSignedPreKey.getKeyPair().getPublicKey(), bobSignedPreKey.getSignature(), bobIdentityKey.getPublicKey()); SessionBuilder aliceSessionBuilder = new SessionBuilder(aliceStore, new SignalProtocolAddress("+14152222222", 1)); aliceSessionBuilder.process(bobBundle); bobStore.StoreSignedPreKey(2, bobSignedPreKey); bobStore.StorePreKey(1, new PreKeyRecord(1, bobPreKey)); }
/// <summary> /// /// </summary> /// <param name="registrationId"></param> /// <param name="identityKey"></param> public void StoreLocalData(uint registrationId, IdentityKeyPair identityKey) { if (IdentitiesObjectDic.ContainsKey("-1")) { IdentitiesObjectDic.Remove("-1"); } IdentitiesObjectDic.Add("-1", new IdentitiesObject() { RecipientId = "-1", RegistrationId = registrationId.ToString(), PublicKey = identityKey.GetPublicKey().Serialize(), PrivateKey = identityKey.GetPrivateKey().Serialize() }); }
protected override string Execute() { if (TextSecurePreferences.isSignedPreKeyRegistered()) { Log.Warn("Signed prekey already registered..."); return(""); } IdentityKeyPair identityKeyPair = IdentityKeyUtil.GetIdentityKeyPair(); var signedPreKeyRecord = PreKeyUtil.generateSignedPreKey(identityKeyPair); App.Current.accountManager.setSignedPreKey(signedPreKeyRecord); TextSecurePreferences.setSignedPreKeyRegistered(true); return(""); }
public async void addDevice(string deviceIdentifier, ECPublicKey deviceKey, IdentityKeyPair identityKeyPair, string code)//throws InvalidKeyException, IOException { ProvisioningCipher cipher = new ProvisioningCipher(deviceKey); ProvisionMessage message = ProvisionMessage.CreateBuilder() .SetIdentityKeyPublic(ByteString.CopyFrom(identityKeyPair.getPublicKey().serialize())) .SetIdentityKeyPrivate(ByteString.CopyFrom(identityKeyPair.getPrivateKey().serialize())) .SetNumber(user) .SetProvisioningCode(code) .Build(); byte[] ciphertext = cipher.encrypt(message); await this.pushServiceSocket.sendProvisioningMessage(deviceIdentifier, ciphertext); }
public void testDeviceConsistency() { IdentityKeyPair deviceOne = KeyHelper.generateIdentityKeyPair(); IdentityKeyPair deviceTwo = KeyHelper.generateIdentityKeyPair(); IdentityKeyPair deviceThree = KeyHelper.generateIdentityKeyPair(); List <IdentityKey> keyList = new List <IdentityKey>(new[] { deviceOne.getPublicKey(), deviceTwo.getPublicKey(), deviceThree.getPublicKey() }); Random random = new Random(); HelperMethods.Shuffle(keyList, random); DeviceConsistencyCommitment deviceOneCommitment = new DeviceConsistencyCommitment(1, keyList); HelperMethods.Shuffle(keyList, random); DeviceConsistencyCommitment deviceTwoCommitment = new DeviceConsistencyCommitment(1, keyList); HelperMethods.Shuffle(keyList, random); DeviceConsistencyCommitment deviceThreeCommitment = new DeviceConsistencyCommitment(1, keyList); CollectionAssert.AreEqual(deviceOneCommitment.toByteArray(), deviceTwoCommitment.toByteArray()); CollectionAssert.AreEqual(deviceTwoCommitment.toByteArray(), deviceThreeCommitment.toByteArray()); DeviceConsistencyMessage deviceOneMessage = new DeviceConsistencyMessage(deviceOneCommitment, deviceOne); DeviceConsistencyMessage deviceTwoMessage = new DeviceConsistencyMessage(deviceOneCommitment, deviceTwo); DeviceConsistencyMessage deviceThreeMessage = new DeviceConsistencyMessage(deviceOneCommitment, deviceThree); DeviceConsistencyMessage receivedDeviceOneMessage = new DeviceConsistencyMessage(deviceOneCommitment, deviceOneMessage.getSerialized(), deviceOne.getPublicKey()); DeviceConsistencyMessage receivedDeviceTwoMessage = new DeviceConsistencyMessage(deviceOneCommitment, deviceTwoMessage.getSerialized(), deviceTwo.getPublicKey()); DeviceConsistencyMessage receivedDeviceThreeMessage = new DeviceConsistencyMessage(deviceOneCommitment, deviceThreeMessage.getSerialized(), deviceThree.getPublicKey()); CollectionAssert.AreEqual(deviceOneMessage.getSignature().getVrfOutput(), receivedDeviceOneMessage.getSignature().getVrfOutput()); CollectionAssert.AreEqual(deviceTwoMessage.getSignature().getVrfOutput(), receivedDeviceTwoMessage.getSignature().getVrfOutput()); CollectionAssert.AreEqual(deviceThreeMessage.getSignature().getVrfOutput(), receivedDeviceThreeMessage.getSignature().getVrfOutput()); string codeOne = generateCode(deviceOneCommitment, deviceOneMessage, receivedDeviceTwoMessage, receivedDeviceThreeMessage); string codeTwo = generateCode(deviceTwoCommitment, deviceTwoMessage, receivedDeviceThreeMessage, receivedDeviceOneMessage); string codeThree = generateCode(deviceThreeCommitment, deviceThreeMessage, receivedDeviceTwoMessage, receivedDeviceOneMessage); Assert.AreEqual(codeOne, codeTwo); Assert.AreEqual(codeTwo, codeThree); }
BobSignalProtocolParameters(IdentityKeyPair ourIdentityKey, EcKeyPair ourSignedPreKey, EcKeyPair ourRatchetKey, May <EcKeyPair> ourOneTimePreKey, IdentityKey theirIdentityKey, IEcPublicKey theirBaseKey) { _ourIdentityKey = ourIdentityKey; _ourSignedPreKey = ourSignedPreKey; _ourRatchetKey = ourRatchetKey; _ourOneTimePreKey = ourOneTimePreKey; _theirIdentityKey = theirIdentityKey; _theirBaseKey = theirBaseKey; if (ourIdentityKey == null || ourSignedPreKey == null || ourRatchetKey == null || ourOneTimePreKey == null || theirIdentityKey == null || theirBaseKey == null) { throw new Exception("Null value!"); } }
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!"); } }
SymmetricSignalProtocolParameters(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!"); } }
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!"); } }
/** * Generate a signed PreKey * * @param identityKeyPair The local client's identity key pair. * @param signedPreKeyId The PreKey id to assign the generated signed PreKey * * @return the generated signed PreKey * @throws InvalidKeyException when the provided identity key is invalid */ public static SignedPreKeyRecord generateSignedPreKey(IdentityKeyPair identityKeyPair, uint signedPreKeyId) { ECKeyPair keyPair = Curve.generateKeyPair(); byte[] signature = Curve.calculateSignature(identityKeyPair.getPrivateKey(), keyPair.getPublicKey().serialize()); return new SignedPreKeyRecord(signedPreKeyId, getTime(), keyPair, signature); }
public Builder setOurIdentityKey(IdentityKeyPair ourIdentityKey) { this.ourIdentityKey = ourIdentityKey; return this; }
public void SetPendingKeyExchange(UInt32 sequence, ECKeyPair ourBaseKey, ECKeyPair ourRatchetKey, IdentityKeyPair ourIdentityKey) { var structure = new PendingKeyExchange { Sequence = sequence, LocalBaseKey = ourBaseKey.PublicKey.Serialize(), LocalBaseKeyPrivate = ourBaseKey.PrivateKey.Serialize(), LocalRatchetKey = ourRatchetKey.PublicKey.Serialize(), LocalRatchetKeyPrivate = ourRatchetKey.PrivateKey.Serialize(), LocalIdentityKey = ourIdentityKey.PublicKey.Serialize(), LocalIdentityKeyPrivate = ourIdentityKey.PrivateKey.Serialize() }; Structure.PendKeyExchange = structure; }
public Builder SetOurIdentityKey(IdentityKeyPair ourIdentityKey) { _ourIdentityKey = ourIdentityKey; return this; }
public InMemoryAxolotlStore(IdentityKeyPair identityKeyPair, uint registrationId) { this.identityKeyStore = new InMemoryIdentityKeyStore(identityKeyPair, registrationId); }
public void setPendingKeyExchange(uint sequence, ECKeyPair ourBaseKey, ECKeyPair ourRatchetKey, IdentityKeyPair ourIdentityKey) { PendingKeyExchange structure = PendingKeyExchange.CreateBuilder() .SetSequence(sequence) .SetLocalBaseKey(ByteString.CopyFrom(ourBaseKey.getPublicKey().serialize())) .SetLocalBaseKeyPrivate(ByteString.CopyFrom(ourBaseKey.getPrivateKey().serialize())) .SetLocalRatchetKey(ByteString.CopyFrom(ourRatchetKey.getPublicKey().serialize())) .SetLocalRatchetKeyPrivate(ByteString.CopyFrom(ourRatchetKey.getPrivateKey().serialize())) .SetLocalIdentityKey(ByteString.CopyFrom(ourIdentityKey.getPublicKey().serialize())) .SetLocalIdentityKeyPrivate(ByteString.CopyFrom(ourIdentityKey.getPrivateKey().serialize())) .Build(); this.sessionStructure = this.sessionStructure.ToBuilder() .SetPendingKeyExchange(structure) .Build(); }
/// <summary> /// .ctor /// </summary> public InMemoryIdentityKeyStore(IdentityKeyPair identityKeyPair, uint localRegistrationId) { this.identityKeyPair = identityKeyPair; this.localRegistrationId = localRegistrationId; }
public InMemoryAxolotlStore(IdentityKeyPair identityKeyPair, UInt32 registrationId) { _identityKeyStore = new InMemoryIdentityKeyStore(identityKeyPair, registrationId); }
public InMemoryIdentityKeyStore(IdentityKeyPair identityKeyPair, UInt32 localRegistrationId) { _trustedKeys = new Dictionary<string, IdentityKey> (); _identityKeyPair = identityKeyPair; _localRegistrationId = localRegistrationId; }