GitLab

at 2023-05-06T23:44:36+02:00

refactor: OMEMO: Adapt to omemo-dr changes

                 return

 

             plaintext = self._muc_temp_store[properties.omemo.payload]

-            fingerprint = self.backend.get_own_fingerprint()

+            fingerprint = self.backend.get_our_fingerprint()

             trust = OMEMOTrust.VERIFIED

             del self._muc_temp_store[properties.omemo.payload]

 

         if bundle is None:

             bundle = self.backend.get_bundle()

         self._nbxmpp('OMEMO').set_bundle(bundle,

-                                         self.backend.get_own_device())

+                                         self.backend.get_our_device())

 

     @as_task

     def request_bundle(self, jid: str, device_id: int):

             message=EncryptionInfoMsg.UNDECIDED_FINGERPRINTS))

 

     def set_devicelist(self, devicelist: Optional[list[int]] = None) -> None:

-        devicelist_: set[int] = {self.backend.get_own_device()}

+        devicelist_: set[int] = {self.backend.get_our_device()}

         if devicelist is not None:

             devicelist_.update(devicelist)

         self._log.info('Publishing own devicelist: %s', devicelist_)

 

     def clear_devicelist(self) -> None:

         self.backend.update_devicelist(

-            self._own_jid, [self.backend.get_own_device()])

+            self._own_jid, [self.backend.get_our_device()])

         self.set_devicelist()

 

     @as_task

             self._query_for_bundles.remove(jid)

 

         if own_devices:

-            if not self.backend.is_own_device_published():

+            if not self.backend.is_our_device_published():

                 # Our own device_id is not in the list, it could be

                 # overwritten by some other client

                 self.set_devicelist(devicelist)

         return IdentityKeyPair.new(result.public_key,

                                    DjbECPrivateKey(result.private_key))

 

-    def get_local_registration_id(self) -> int:

+    def get_our_device_id(self) -> int:

         query = 'SELECT device_id FROM secret LIMIT 1'

         result = self._con.execute(query).fetchone()

         assert result is not None

         return result.device_id

 

-    def store_own_identity(self,

-                           device_id: int,

-                           identity_key_pair: IdentityKeyPair

-                           ) -> None:

+    def set_our_identity(self,

+                         device_id: int,

+                         identity_key_pair: IdentityKeyPair

+                         ) -> None:

 

         query = 'SELECT * FROM secret'

         result = self._con.execute(query).fetchone()

 

     def needs_init(self) -> bool:

         try:

-            self.get_local_registration_id()

+            self.get_our_device_id()

         except AssertionError:

             return True

         return False
 

         self._omemo = client.get_module('OMEMO')

 

-        our_fpr_formatted = self._omemo.backend.get_own_fingerprint(

+        our_fpr_formatted = self._omemo.backend.get_our_fingerprint(

             formatted=True)

         self._ui.our_fingerprint_1.set_text(our_fpr_formatted)

         self._ui.our_fingerprint_2.set_text(our_fpr_formatted)

 

     def _load_qrcode(self) -> None:

         client = app.get_client(self._account)

+        our_device_id, our_identity_key =\

+            self._omemo.backend.get_our_identity()

         pixbuf = self._get_qrcode(client.get_own_jid(),

-                                  self._omemo.backend.get_own_device(),

-                                  self._omemo.backend.get_own_fingerprint())

+                                  our_device_id,

+                                  our_identity_key.get_fingerprint())

         self._ui.qr_code_image.set_from_pixbuf(pixbuf)

 

     def _on_show_inactive(self, switch: Gtk.Switch, _param: Any) -> None:

Philipp Hörist pushed to branch master at gajim / gajim

Commits:

3 changed files:

Changes: