/// <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); }
/// <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 StorePreKey(uint preKeyId, PreKeyRecord record) { if (this.OnstorePreKey != null) { this.OnstorePreKey(preKeyId, record.serialize()); } }
public void StorePreKey(uint preKeyId, PreKeyRecord record) { conn.Insert(new PreKeyRecordI() { PreKeyId = preKeyId, Record = record.serialize() }); }
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 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 static Task <PreKeyRecord> generateLastResortKey() { return(Task.Run(() => { PreKeyStore preKeyStore = new TextSecurePreKeyStore(conn); if (preKeyStore.ContainsPreKey(Medium.MAX_VALUE)) { try { //return preKeyStore.loadPreKey(Medium.MAX_VALUE); return preKeyStore.LoadPreKey(Medium.MAX_VALUE); } catch (InvalidKeyIdException e) { //Log.w("PreKeyUtil", e); preKeyStore.RemovePreKey(Medium.MAX_VALUE); } } ECKeyPair keyPair = Curve.generateKeyPair(); PreKeyRecord record = new PreKeyRecord(Medium.MAX_VALUE, keyPair); preKeyStore.StorePreKey(Medium.MAX_VALUE, record); return record; })); }
public void StorePreKey(uint preKeyId, PreKeyRecord record) { if (this.OnStorePreKey != null) { this.OnStorePreKey(preKeyId, record); } }
public void storePreKey(uint preKeyId, PreKeyRecord record) { if (store.ContainsKey(preKeyId)) // mimic Java HashMap { store.Remove(preKeyId); } store.Add(preKeyId, record.serialize()); // put }
public static void RefreshPreKeys(SignalServiceAccountManager accountManager) //TODO wrap in extra lock? enforce reload? { List <PreKeyRecord> oneTimePreKeys = GeneratePreKeys(); PreKeyRecord lastResortKey = getOrGenerateLastResortPreKey(); SignedPreKeyRecord signedPreKeyRecord = generateSignedPreKey(GetIdentityKeyPair()); accountManager.setPreKeys(GetIdentityKeyPair().getPublicKey(), lastResortKey, signedPreKeyRecord, oneTimePreKeys); }
public PreKeyRecord LoadPreKey(uint preKeyId) { PreKeyRecord preKeyRecord = SignalKeyDBManager.INSTANCE.getPreKeyRecord(preKeyId, ACCOUNT.getIdAndDomain()); if (preKeyRecord == null) { throw new InvalidKeyIdException("No such key: " + preKeyId); } return(preKeyRecord); }
public void setPreKey(uint preKeyId, PreKeyRecord preKey, string accountId) { dB.InsertOrReplace(new PreKeyTable() { id = PreKeyTable.generateId(preKeyId, accountId), preKeyId = preKeyId, accountId = accountId, preKey = preKey.serialize() }); }
public PreKeyRecord LoadPreKey(uint preKeyId) { PreKeyRecord preKeyRecord = OmemoSignalKeyDBManager.INSTANCE.getPreKeyRecord(preKeyId, ACCOUNT.getBareJid()); if (preKeyRecord is null) { throw new InvalidKeyIdException("No such key: " + preKeyId); } return(preKeyRecord); }
private static Task <PreKeyRecord> generatePreKey(uint preKeyId) { return(Task.Run(() => { ECKeyPair keyPair = Curve.generateKeyPair(); PreKeyRecord record = new PreKeyRecord(preKeyId, keyPair); 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); }
/// <summary> /// /// </summary> /// <param name="prekeyId"></param> /// <param name="preKeyRecord"></param> public void StorePreKey(uint prekeyId, PreKeyRecord preKeyRecord) { if (PreKeysObjectDic.ContainsKey(prekeyId)) { PreKeysObjectDic.Remove(prekeyId); } PreKeysObjectDic.Add(prekeyId, new PreKeysObject() { PreKeyId = prekeyId.ToString(), Record = preKeyRecord.Serialize() }); }
public PreKeyRecord LoadPreKey(uint preKeyId) { PreKeysRepository preKeysRepository = new PreKeysRepository(); List <PreKeys> preKeys = preKeysRepository.GetPreKeys(Convert.ToString(preKeyId)); if (preKeys != null && preKeys.Count > 0) { PreKeyRecord preKeyRecord = new PreKeyRecord(preKeys.First().Record); return(preKeyRecord); } return(null); }
public void StorePreKey(uint preKeyId, PreKeyRecord record) { if (ContainsPreKey(preKeyId)) { RemovePreKey(preKeyId); } PreKeysRepository preKeysRepository = new PreKeysRepository(); PreKeys preKey = new PreKeys() { PreKeyId = Convert.ToString(preKeyId), Record = record.Serialize() }; bool result = preKeysRepository.Save(preKey); }
public static void StorePreKey(uint preKeyId, PreKeyRecord record) { lock (DBLock) { using (var ctx = new LibsignalDBContext()) { ctx.PreKeys.Add(new SignalPreKey() { Id = preKeyId, Key = Base64.encodeBytes(record.serialize()) }); ctx.SaveChanges(); } } }
private static List <PreKeyRecord> GeneratePreKeys() { List <PreKeyRecord> records = new List <PreKeyRecord>(); for (uint i = 1; i < App.PREKEY_BATCH_SIZE; i++) { uint preKeyId = (App.Store.PreKeyIdOffset + i) % Medium.MAX_VALUE; ECKeyPair keyPair = Curve.generateKeyPair(); PreKeyRecord record = new PreKeyRecord(preKeyId, keyPair); StorePreKey(preKeyId, record); records.Add(record); } UpdatePreKeyIdOffset((App.Store.PreKeyIdOffset + App.PREKEY_BATCH_SIZE + 1) % Medium.MAX_VALUE); return(records); }
private static PreKeyRecord getOrGenerateLastResortPreKey() { if (ContainsPreKey(Medium.MAX_VALUE)) { try { return(LoadPreKey(Medium.MAX_VALUE)); } catch (InvalidKeyIdException) { RemovePreKey(Medium.MAX_VALUE); } } ECKeyPair keyPair = Curve.generateKeyPair(); PreKeyRecord record = new PreKeyRecord(Medium.MAX_VALUE, keyPair); StorePreKey(Medium.MAX_VALUE, record); return(record); }
public static async Task <List <PreKeyRecord> > generatePreKeys() { PreKeyStore preKeyStore = new TextSecurePreKeyStore(conn); List <PreKeyRecord> records = new List <PreKeyRecord>(); uint preKeyIdOffset = getNextPreKeyId(); for (uint i = 0; i < BATCH_SIZE; i++) { uint preKeyId = (preKeyIdOffset + i) % Medium.MAX_VALUE; PreKeyRecord record = await generatePreKey(preKeyId); preKeyStore.StorePreKey(preKeyId, record); records.Add(record); } setNextPreKeyId((preKeyIdOffset + BATCH_SIZE + 1) % Medium.MAX_VALUE); return(records); }
public void replaceOmemoPreKey(uint preKeyId, IOmemoStore omemoStore) { // Remove key: foreach (PreKeyRecord key in OMEMO_PRE_KEYS) { if (key.getId() == preKeyId) { OMEMO_PRE_KEYS.Remove(key); omemoStore.RemovePreKey(preKeyId); break; } } // Generate new key: PreKeyRecord newKey = KeyHelper.generatePreKeys(preKeyId, 1)[0]; OMEMO_PRE_KEYS.Add(newKey); omemoStore.StorePreKey(newKey.getId(), newKey); omemoBundleInfoAnnounced = false; }
public void StorePreKey(uint preKeyId, PreKeyRecord preKey) { SignalKeyDBManager.INSTANCE.setPreKey(preKeyId, preKey, ACCOUNT.getIdAndDomain()); }
public void StorePreKey(uint preKeyId, PreKeyRecord record) { store[preKeyId] = record.serialize(); }
public void storePreKey(uint preKeyId, PreKeyRecord record) { preKeyStore.storePreKey(preKeyId, record); }
public void StorePreKey(uint preKeyId, PreKeyRecord record) { LibsignalDBContext.StorePreKey(preKeyId, record); }
public void StorePreKey(uint preKeyId, PreKeyRecord preKey) { OmemoSignalKeyDBManager.INSTANCE.setPreKey(preKeyId, preKey, ACCOUNT.getBareJid()); }
public void StorePreKey(uint preKeyId, PreKeyRecord record) { preKeyStore.StorePreKey(preKeyId, record); }
public void StorePreKey(uint preKeyId, PreKeyRecord record) { PRE_KEYS[preKeyId] = record; }
public void StorePreKey(uint preKeyId, PreKeyRecord record) { _store[preKeyId] = record.Serialize(); }