Empathy needs to support OTR encryption

Yeah, encryption is a must for me, too. This the only reason using Pidgin instead of telepathy for me.

The draft Messages UI should theoretically allow anything that has a MIME type.
The underlying protocol support is another story, however.

C-library[1] and python binding[2] are availible, too. So "only" the telepathy glue is needed. After that minor extensions to the different user interfaces really make it functional.

[1] http://www.cypherpunks.ca/otr/README-libotr-3.2.0.txt
[2] http://python-otr.pentabarf.de/

if given some mentoring, i could spend some time implementing it.b

(Note to myself: maemo.org downstream ticket at https://bugs.maemo.org/show_bug.cgi?id=1921 )

Downgrading priority; there are more pressing spec issues, and I think that supporting encryption on protocols like XMPP where it can be done cleanly (rather than as misc. sent in the regular plain text stream) is a higher priority.

in my experience this is why i myself and most people i know still use pidgin, though everybody believes telepathy would be nicer.

Re-lowering priority. Daniel: while it's a shame that this is keeping you from using Telepathy, there really are higher-priority spec issues. Also see point 2.1 on <https://bugzilla.mozilla.org/page.cgi?id=etiquette.html>: the priority field is to help developers track the relative priorities of bugs, not for voting on how important you think a bug is.

I consider Telepathy to be completely broken for my purposes unless it interoperates properly with OTR on other clients. If you want to do a better version of OTR with deniability in XMPP, go right ahead. Just make sure that the old way still works.

Adium having built in OTR support has been a fantastic boon.

I will discourage everybody I know from using Empathy and uninstall it on systems I administrate until this is fixed. This should have been thought of in the very beginning and been a feature in the program since its inception. Bad security is unforgivable.

You treating this as a low priority bug tells me a whole lot about what kinds of things the Empathy development team thinks is important, and good security is apparently not an important consideration.

(In reply to comment #9)

Eric:

I will actively discourage everybody I know from reading your drivel until you resolve your issue by rolling up your sleeves and adding this feature. You should have considered doing this yourself ever since you decided to bitch about it here.

Your unwillingness to fix this yourself tells me a whole lot about what kinds of things you think are important, and apparently good security is not an important consideration.

(In reply to comment #9 (of Eric Hopper))
> I will discourage everybody I know from using Empathy and uninstall it on
> systems I administrate until this is fixed. This should have been thought of
> in the very beginning and been a feature in the program since its inception.

As the Empathy developers are more knowledgeable with what users want, or at
least have better tools to gather the information, I guess they have different
list of priorities of tasks to work on.

> Bad security is unforgivable.

This is the kind of program where security is good-to-have feature. The OTR can
be added later, once the basis is stable.

> You treating this as a low priority bug tells me a whole lot about what kinds
> of things the Empathy development team thinks is important, and good security
> is apparently not an important consideration.

Nobody is against good security. It is just a matter of percentage of users
that are needed to be catered to first. As the developer's resources are
scarce, they need to judge carefully where to direct theirs efforts.

At this point empathy is barely suitable for everyday work (which is important
for about 90% of users), whereas security is important for about 5% of users.

I have to disagree. Although I fully understand the fact that no developer is willing to take up that task, security should be a priority for all users. For me security is part of the basis. A chat client without encryption I do not consider to be functional. I dont chat with people sho do not use encryption. I think Telepathy is more than stable, as it is already part of GNOME and Empathy is going to be the default chat client for Ubuntu 9.10. I would have It is also true, that OTR is broken by design. but it works and I dont know of any client which provides a sane implementation of a chat encryption bedides the ones using OTR.

So again its only up to current and upcoming developers to decide if they are going to implement OTR, but I consider it much more important than providing a lot of chat protocols.

(In reply to comment #12)
> OTR is broken by design. but it works

This is not a good justification for an encryption scheme. :)

Well, yes, but name me any other existing chat encrpytion that actually works. There are many standards out there which are far from perfect. GIF wasnt perfect, but it was used. Most of the protocol standards liek MSN or AIM are broken by design also. But they are used and are already implemented.

(In reply to comment #14)
> Well, yes, but name me any other existing chat encrpytion that actually works.
> There are many standards out there which are far from perfect. GIF wasnt
> perfect, but it was used. Most of the protocol standards liek MSN or AIM are
> broken by design also. But they are used and are already implemented.
>

I have no stance for and against OTR encryption and I don't know what OTR encryption is about behind the scenes. I will therefore judge only by your words.

You seem strangely interested in security... provided by (by your own words) a broken security layer? Do you really think that providing broken security, and lulling people into false sense of security is better than providing no "security" at all?

And to others. I am not a Telepathy developer... but seriously guys, flaming developers while not being ready to get yourselves on the line? If you find it useful and especially if you find it critical, do it yourself. Otherwise, feel free to keep using Pidgin until you get this critical feature, which Thilo considers broken by design.

I think there's room for other improvements before encryption, because I, and many other home users, find it unnecessary. Encryption is not important for majority of people on this world.

Take your tinfoil hats off, people, nobody's going to eat your brains. And if you really need it for your company, well, either you or your company can invest resources into Telepathy. I personally don't find OTR important, and I'm sure most users don't, either. And I don't consider myself completely paranoia-free.

If other clients provide you security, use those. Or use email+GPG for even more security. Filing a request is fine. Posting a comment supporting the request is fine. Attacking people like some of you did is not fine.

(In reply to comment #15)
> You seem strangely interested in security... provided by (by your own words) a
> broken security layer? Do you really think that providing broken security, and
> lulling people into false sense of security is better than providing no
> "security" at all?

OTR's brokenness is due to the fact that it is a hacky kludge on top of existing IM protocols, not because it has any security flaws. It's inelegant and ugly, but it works.

I'm all for an elegant solution. But I don't think it should take a backseat to interoperability. I know that the various IM protocols are also mostly a bunch of ugly kludges as well. But that doesn't stop them from being implemented.

> And to others. I am not a Telepathy developer... but seriously guys, flaming
> developers while not being ready to get yourselves on the line? If you find it
> useful and especially if you find it critical, do it yourself. Otherwise, feel
> free to keep using Pidgin until you get this critical feature, which Thilo
> considers broken by design.
>
> I think there's room for other improvements before encryption, because I, and
> many other home users, find it unnecessary. Encryption is not important for
> majority of people on this world.

I am worried because Empathy appears to be getting a huge userbase and being used as the default IM client for a number of distributions without having a feature I think is incredibly important and should've been built in at the start, almost especially because most users don't really care about it.

Most people will not care about encryption. Most people also do not care about ACID database semantics. But anybody who made a database lacking the latter feature (i.e. Microsoft Access) would be roundly and justly flamed. Especially if they managed to somehow get that database into general use.

There are a whole host of features that users do not care about but are critical pieces of infrastructure. One of the things that most pleases me about Adium is that the developers understood and so many of my friends who have no clue or desire for encryption end up using it anyway because they use Adium.

> If other clients provide you security, use those. Or use email+GPG for even
> more security. Filing a request is fine. Posting a comment supporting the
> request is fine. Attacking people like some of you did is not fine.

Email encryption is nearly a lost cause. But with Adium and a couple of other popular IM clients supporting OTR, widespread IM encryption was beginning to happen. I don't think activists in Iran should have to worry about which IM client their friends are using in order to avoid being snooped on. I don't think their choice of IM client should be able to be used to single them out for special treatment by their government. All new IM clients should just do the right thing out of the box.

Widespread support for good encryption is not something I care about because I am especially paranoid about my own IM conversations. It's because I care about the pernicious effects of all IM conversations being potentially public knowledge.

Eric, flaming is not going to give you anything.

If you need OTR so much, either propose a patch, or don't use Empathy.

OTR is not going to happen if nobody gives a patch. End of discussion.

(In reply to comment #17)
> Eric, flaming is not going to give you anything.
>
> If you need OTR so much, either propose a patch, or don't use Empathy.
>
> OTR is not going to happen if nobody gives a patch. End of discussion.

Even if you, or any Empathy developers, don't plan to implement OTR, it's still an important feature and the priority should be set to high.

Or you don't agree it's an important feature? If that's the case I can provide evidence.

"priority" is the priority that we, the current Telepathy developers, give to implementing OTR. If it's a high priority for *you*, you're welcome to implement it, or hire someone to implement it; but it's not a high priority for *us*, and so it stays priority=low in Bugzilla.

I think helping the XMPP Standards people to provide end-to-end encryption (implementing <http://xmpp.org/extensions/inbox/xtls.html> or something like it, and advancing it to Recommended status) is a much better use of developer time; it'll result in a better protocol, with a well-defined security model, that does not conflict with the protocol's normal extensibility mechanisms.

(In reply to comment #19)
> I think helping the XMPP Standards people to provide end-to-end encryption
> (implementing <http://xmpp.org/extensions/inbox/xtls.html> or something like
> it, and advancing it to Recommended status) is a much better use of developer
> time; it'll result in a better protocol, with a well-defined security model,
> that does not conflict with the protocol's normal extensibility mechanisms.
>

OTR also works over non-XMPP networks (I use primarily over AIM). That's something that this XMPP standard can never achieve.

I'm not taking sides - just stating some (hopefully) useful facts.

(In reply to comment #16)

> I am worried because Empathy appears to be getting a huge userbase and being
> used as the default IM client for a number of distributions without having a
> feature I think is incredibly important and should've been built in at the
> start, almost especially because most users don't really care about it.

By far the overwhelming majority of IM clients in use are those provided by the protocol vendors, and I can assure you, they don't ship with OTR. Empathy's userbase is growing, but it's stil early days and it's likely not going to dwarf the others anytime soon.

> Most people will not care about encryption. Most people also do not care
> about ACID database semantics. But anybody who made a database lacking the
> latter feature (i.e. Microsoft Access) would be roundly and justly flamed.

No, they should not be flamed, and this is the reason your posts are so inappropriate: you think that because feature X is missing, developers should be flamed. Developers in a number of projects work on a voluntary basis, and in my opinion deserve some semblance of respect for their contributions, not being hassled by the likes of you.

> There are a whole host of features that users do not care about but are
> critical pieces of infrastructure.

OTR is not a generally accepted critical piece of infrastructure.

> Email encryption is nearly a lost cause. But with Adium and a couple of other
> popular IM clients supporting OTR, widespread IM encryption was beginning to
> happen.

Back up your unqualified assertions about encryption uptake with some verifiable facts.

> I don't think activists in Iran should have to worry about which IM client
> their friends are using in order to avoid being snooped on.

Perhaps a nice utopian vision of the future, but not the basis for a rational discussion. This is an unqualified "oh-won't-someone-please-think-of-the-X" appeal to emotion without presenting reasonable facts or arguments to base it on.

It sounds like you have strong convictions. Strong enough though only to sound off about it here and not really do anything about it. If these objectives are so important to you, why aren't you writing your own OTR extension now?

> I don't think their choice of IM client should be able to be used to single
> them out for special treatment by their government. All new IM clients should
> just do the right thing out of the box.

Reality: People's choices in the technology adoption affect their security. You can't control the proliferation of technology, and you can't control people's choices. You lose on both counts.

> Widespread support for good encryption is not something I care about because I
> am especially paranoid about my own IM conversations. It's because I care
> about the pernicious effects of all IM conversations being potentially public
> knowledge.

You only care enough about it to flame the volunteer developers who are working on the IM technology -- not enough to actually do anything about it yourself and contribute to make it better. Oh right, you're also boycotting Empathy/Telepathy and telling all your friends not to use it.

Hello all,

since I am the creator of this "bug", I feel obliged to calm the waves a bit and add a plea for seriousness in this discussion.

What some developers might call "broken by design" is probably the backside of OTR being a technology that just works with each and every IM protocol out there, even the worst ones like MSN and Yahoo. I presume, providing such a bandwidth of features just wont go without some kludgy solutions.
    In my daily life (and in the life of many others I would bet) practical solutions are what counts and what is needed. OTR is a practical solution.
As a contract worker for several German companies I can tell you that in many European IT departments OTR has become the de facto standard for on-the-fly exchange of information bits like the casual end user password and similar stuff of more-than-zero triviality.
To the best of my knowledge, all current versions of OTR provide no "false security" when properly used and the fact that they might not be working very elegant "under the hood" is actually the bit that is of "minor importance" to me.

For me, the important point is that I totally depend on a cross-protocol encryption solution for IM that "just works" in my daily life and so do many other people. OTR is already here and has been for several years now. And despite the fact that there might be more or less obvious and more or less major disadvantages to OTR from the developers POV, *not* *one* single viable alternative has come to my attention in the last years that is not forcing users to use a specific IM protocol or even a specific OS platform.

Conclusion: Unless proven otherwise I'd like to state as a FACT that in the field of IM privacy, OTR has become the de-facto standard. At least in Europe it is very widely deployed and often expected to be available. And there are just no alternatives available at all which work cross-protcol and cross-platform.
  From my POV this means there is also (currently) no alternative available to implementing OTR for every IM UA that wants to be taken seriously.

Thank you for reading.

There are many good arguments as to why otr support should be high priority in this thread, and others, and to as to why many people consider leaving out otr-support a very bad idea. We
Google: telepathy otr and you'll see a lot of them.

My view: Should be a default out-of-the-box, as it works with all protocols. Almost everyone in my contactlist uses otr now-a-days, and no, they are not all "nerds". We use otr at work too.

if someone would like to create a plugin, does somebody know good documentation
first on creating telepathy or empathy plugins ( C or Python, C++)
and second on using libotr??
please comment or
directly to <email address hidden>

@24: AFAIK there is not even a plugin API available yet.

(In reply to comment #58)
> + type="(say)" access="read">
>
> Are these literally the hex and binary versions of the same digest, or do
> they have different information content? (Or is the string version some
> OTR-specific thing that is easier to transcribe than hex?)

I'm not particularly happy about this type duplicating the information: whenever there's duplication, there's the possibility that the duplicates don't agree. I can see why you did it, though - the OTR library doesn't seem to have a function to convert a human-readable digest back into binary (although we could easily write one), so you currently need the binary digest in order to set trust.

If possible I'd prefer to stick to one encoding or the other, consistently - either always a string (which I think is what I'd prefer), or always a byte-array. At the moment we only put the string form in message headers, not the byte-array.

I'm tempted to implement a function to turn the string into binary (decode hex, ignore whitespace, report an error unless it has exactly 40 hex digits) and just use strings throughout.

> I think it would also be useful to spec that one of the forms of the remote
> fingerprint will appear in the message header (0'th part) of each individual
> message, perhaps { "otr-remote-fingerprint": a string }. That would make it
> easy for someone to do either of these things in a race-condition-free way:
>
> * record in the Logger that the messages were encrypted/verified
> * give the Logger a configuration setting "[ ] do not log OTR messages"
> (which it would recognize by seeing that they have an OTR remote
> fingerprint

You added otr-sender-fingerprint to received messages. I think we should also add a fingerprint to messages that were sent during an OTR session, so that we can associate the logged session with the fingerprint (or avoid logging them at all), too.

For now I'm changing it to otr-remote-fingerprint, because that's always the easier one to get - we could use otr-sender-fingerprint and otr-recipient-fingerprint if there's some reason that's better, but just having one seems easier.

(In reply to comment #50)
> Could we also get a config option that turns this whole feature on/off?

Still needed, IMO.

(In reply to comment #61)
> I would really like im-channel to implement o.fd.Telepathy.Securable

Non-blocker but still desirable. Given what I said in Comment #78, I think we can set Encrypted when OTR is active, but we can't set Verified in any case, because the thing that Securable says we Verified (that the key with which we're encrypting belongs to the contact identified by the Channel's Target_ID) does not seem to be what OTR actually verifies.

(In reply to comment #78)
> In particular, we don't seem to
> be binding a fingerprint to a JID.

On closer inspection of libotr, it seems we are indeed binding a (remote username, local account name, protocol) tuple to a fingerprint; the API just doesn't make that obvious.

I've made most of the changes I wanted but haven't had time to test them yet. Use at own risk:

http://cgit.freedesktop.org/~smcv/telepathy-gabble/log/?h=untested-otr

Still to do:

* testing (in particular, send "&lt;" and "<a message that resembles HTML>"
  in both directions between Empathy and Pidgin, and check that neither is
  misinterpreted)

* review from someone who understands libotr

* Empathy: make sure OTR notifications are presented in a way that
  peers cannot fake. Because Empathy doesn't support HTML messages yet,
  distinctive formatting would be enough.

* string-only handling of fingerprints (emit strings to D-Bus,
  parse hex -> binary when asked to trust a fingerprint from D-Bus)

Nice to have, but not blockers:

* TPAW UI for the enable-otr boolean parameter (for now, early adopters
  can turn it on with mc-tool - but I think real UI *is* a blocker for
  switching the default to be enabled)

* Chan.I.Securable.{Encrypted,Verified} integration

* enable-opportunistic-otr boolean parameter, and UI for the same
  (it will end up looking very similar to enable-otr, but with different
  handling in im-channel*.c)

> fp_data = g_variant_get_data (fp_variant);
> fp = otrl_context_find_fingerprint (context, (guchar *) fp_data, 0, NULL);

I'm still considering "use string fingerprints with error-checking" to be a merge blocker, because I don't think this code is OK for the case where fp_data has length != 20 bytes. I think TrustFingerprint("DEADBEEF") should raise InvalidArgument, whereas TrustFingerprint("12345678 12345678 12345678123456781234578") (with any whitespace) should work.

If you strongly prefer the binary encoding, I'd be OK with making TrustFingerprint([a number of bytes other than 20]) an InvalidArgument, but I think string fingerprints are going to be nicer to deal with.

(In reply to comment #81)
> I've made most of the changes I wanted but haven't had time to test them
> yet. Use at own risk:
>
> http://cgit.freedesktop.org/~smcv/telepathy-gabble/log/?h=untested-otr

I did not manage to start an OTR session with this branch.
The '/otr start' command was displaying "OTR:$blob" in empathy-chat.

I did manage to start a session using Xavier's branch but noticed the following bug:
- Start an OTR session between Empathy and Pidgin
- In Pidgin using the OTR menu pick "End private conversation"
- Try sending a message from Empathy. The message doesn't reach Pidgin and this error is displayed: "Your message was not sent because <email address hidden> closed their connection. Either close your private connection, or refresh it."

(In reply to comment #83)
> I did manage to start a session using Xavier's branch but noticed the
> following bug:
> - Start an OTR session between Empathy and Pidgin
> - In Pidgin using the OTR menu pick "End private conversation"
> - Try sending a message from Empathy. The message doesn't reach Pidgin and
> this error is displayed: "Your message was not sent because
> <email address hidden> closed their connection. Either close your
> private connection, or refresh it."

Fwiw, I think I've seen the same message in pidgin when chatting with an adium user who closed the conversation window or something like that.

(In reply to comment #83)
> I did manage to start a session using Xavier's branch but noticed the
> following bug:
> - Start an OTR session between Empathy and Pidgin
> - In Pidgin using the OTR menu pick "End private conversation"
> - Try sending a message from Empathy. The message doesn't reach Pidgin and
> this error is displayed: "Your message was not sent because
> <email address hidden> closed their connection. Either close your
> private connection, or refresh it."

It's not a bug, it's a feature. User must acknoledge that he's not in private chat anymore by typing "/otr stop" or "/otr start".

(In reply to comment #83)
> I did not manage to start an OTR session with this branch.
> The '/otr start' command was displaying "OTR:$blob" in empathy-chat.

You need to set "enable-otr=true" in your CM parameters, otherwise OTR is disabled in Simon's branch. There is magic mc-tool command for that, did not try yet.

Why is the patch protocol-specific?

Would it be possible to use the same code for the new gnome-chat application which will likely replace Empathy?

As far as I understood it can used with gnome-chat or whatever client using telepathy library - once it's upstreamed of course.

(In reply to comment #88)
> As far as I understood it can used with gnome-chat or whatever client using
> telepathy library - once it's upstreamed of course.

Ah, that's great! Also, why was it necessary to make it protocol-specific? OTR is supposed to be useful for any sychronous messaging

(In reply to comment #87)
> Why is the patch protocol-specific?

Telepathy does not have any central point where OTR can be done for all protocols and all UIs simultaneously. We can either do it once per protocol backend, or once per UI. Once per UI would break the ability to log OTR messages or have them appear correctly in more than one UI (e.g. both Empathy and GNOME Shell). Every attempt at implementing OTR in Telepathy has had the plan to do it once per protocol backend; this implementation is no different. In practice, like most new features, everyone prototyped it in the XMPP protocol backend first, because that's the one that works best.

I think the approach that is most likely to yield results in a finite time is to get the XMPP implementation high-quality and mergeable first, then expand to the other protocols; then any implementation mistakes in the first implementation will hopefully not be repeated, and the rest will be a simple matter of "pretty much what Gabble did". Using a library for common code, or adding functionality to libotr, would be fine too, but that's an implementation detail.

Anyone interested in this could add similar glue to telepathy-haze to cover the various proprietary protocols (AOL, etc.). It might have seemed more natural to go for -haze first, but -haze uses libpurple, which is not really designed for things that aren't shaped like Pidgin, so it can be awkward to get right and doesn't make a great place for prototyping. The missing protocol backends after that would be telepathy-salut for link-local XMPP, telepathy-idle for IRC, and telepathy-rakia for SIP. I think it'd make sense to do -haze and maybe -salut. I'm not sure -idle or -rakia is necessarily worthwhile, but if people do use OTR on those protocols in practice, sure, why not.

(In reply to comment #87)
> Would it be possible to use the same code for the new gnome-chat application
> which will likely replace Empathy?

The majority of the glue between Telepathy and libotr (as exemplified here by patches to Gabble), and the design: yes, it lives in the protocol backend(s).

The UI: no, the UI code in Empathy is specific to Empathy. gnome-chat would need to provide a way to enable/disable OTR and mark fingerprints as trusted, and to be properly secure, it would need to display the notifications from libotr in a way that cannot be spoofed by contacts.

Hi

I am currently working on OTR support for KDE Telepathy. There are some
features we would like to have:
- otr policy settings
- a way to generate a new private key for account
- possibility to manage known fingerprints (trust/distrust)
- two additional ways of peer authentication (shared secret and
question-answer)

Realization of the first three points would require adding a new interface
to gabble. I imagine it as an extension of connection interface providing
settings individually for every account. Would using gdbus codegen just
like in case of the currently implemented otr channel be acceptable here? I
suppose that adding these features would mean some major changes in the
current implementation which is completely closed in the channel interface.

There are also things that need to be fixed as stated above:

> Still to do:
>
> * testing (in particular, send "&lt;" and "<a message that resembles
HTML>"
> in both directions between Empathy and Pidgin, and check that neither is
> misinterpreted)
>
> * review from someone who understands libotr
>
> * string-only handling of fingerprints (emit strings to D-Bus,
> parse hex -> binary when asked to trust a fingerprint from D-Bus)

I understand that they have to be done first before introducing new changes?

(In reply to comment #91)
> Realization of the first three points would require adding a new interface
> to gabble. I imagine it as an extension of connection interface providing
> settings individually for every account. Would using gdbus codegen just
> like in case of the currently implemented otr channel be acceptable here?

You could make it go "next to" the Connection just like Xavier's code produces an object "next to" the Channel, yes.

(Unfortunately, the fact that, in general, telepathy-glib uses the deprecated dbus-glib instead of GDBus is not going to get fixed, unless someone with a lot more time available than me picks it up. See the various "Telepathy 1.0" bugs for details.)

> I
> suppose that adding these features would mean some major changes in the
> current implementation which is completely closed in the channel interface.

Making behind-the-scenes C function calls between the Connection and Channel objects is fine.

> There are also things that need to be fixed as stated above:
> ...
> I understand that they have to be done first before introducing new changes?

Yes, I think that would be better than hoping they will be fixed later.

I consider those fixes to be merge blockers for these branches, because I don't want to add an interop and security feature that, on closer inspection, turns out to be non-interoperable or insecure :-)

What is the status of this project? Is it dead?

(In reply to JKAbrams from comment #93)
> What is the status of this project? Is it dead?

More like (deliberately?) ignored. When most all the work is done, and working patches exist you have to wonder...

In the year 2015, this should have priority "highest" not "medium" (and certainly not "ignore").

There are patches, there are review comments, and 55 subscribers to this bug. If only one of you could just work on it instead of complaining...

Xavier, I'm happy to pay you now. PayPal to email?

Sam
On 2 Jun 2015 21:01, "Xavier Claessens" <email address hidden> wrote:

> There are patches, there are review comments, and 55 subscribers to this
> bug. If only one of you could just work on it instead of complaining...
>
> --
> You received this bug notification because you are subscribed to the bug
> report.
> https://bugs.launchpad.net/bugs/296867
>
> Title:
> empathy needs to support OTR encryption
>
> To manage notifications about this bug go to:
> https://bugs.launchpad.net/empathy/+bug/296867/+subscriptions
>

See comment #81 for the few items missing. As far as I'm concerned it can be merged if someone just fix those, and it's close to trivial to do IIRC.

(In reply to Xavier Claessens from comment #97)
> See comment #81 for the few items missing. As far as I'm concerned it can be
> merged if someone just fix those, and it's close to trivial to do IIRC.

Seeing as the compile process isn't well documented, it's very confusing for newcomers. If you'll also note, someone else asked if you could provide some build instructions on your blog post to help compile it.

From what I've managed to figure out so far, with some hours of trial and error...

--------------------------------------------------------------------------------
git clone git://people.freedesktop.org/~smcv/telepathy-gabble --single-branch untested-otr

cd untested-otr/
sh autogen.sh
cd lib/ext/wocky
sh autogen.sh
make
cd ../../..
cd src
sed -i.bak "s/#define \_BSD_SOURCE/#define \_DEFAULT_SOURCE/g" ft-manager.c
cd ..
cd tools
sed -i.bak "s/xrange/range/g" xincludator.py
//give up at this point since this project has tons of Python3 bugs I need to research...
//then presumably//
./configure
make install
--------------------------------------

You probably want python2. Build just fine on ubuntu 15.04, it just has a warning for a deprecated gnutls function, but you can ignore that with --disable-Werror (or make a fix).

sudo apt-get build-dep telepathy-gabble
./autogen.sh --disable-Werror
make
make install

(In reply to Xavier Claessens from comment #99)
> You probably want python2. Build just fine on ubuntu 15.04, it just has a
> warning for a deprecated gnutls function, but you can ignore that with
> --disable-Werror (or make a fix).
>
> sudo apt-get build-dep telepathy-gabble
> ./autogen.sh --disable-Werror
> make
> make install

I can confirm it compiles after fixing the depreciated function and forcing the Makefile to use python2.7 followed by making it read-only (keeps trying to put 3.4 in there).

So after I ran the make install I started up empathy, but was unable to use "/otr start". It claims command is not found.

I then read this:
> You need to set "enable-otr=true" in your CM parameters, otherwise OTR is disabled

No idea what a CM parameter is or where to set it, so I ran grep on all the files. Nothing says "enable-otr".

Can someone clarify where to put that line?

In regards to my previous comment. I discovered enable-otr is in /src/connection.c, once you get the right branch...

git clone git://people.freedesktop.org/~smcv/telepathy-gabble
git checkout untested-otr

I also tried setting the default "FALSE" option to "TRUE". Still OTR doesn't work for me, perhaps empathy also needs to be patched (instead of just gabble). However Xaivers empathy branch no longer runs properly on my system due to changes in gtk, so I am unable to test the older version.

So, that's as far as I made it.

Anyone still working on getting this into released empathy ?
Thanks,

No idea - I've long migrated to software which cares enough about security not to have critical bugs opened for 5 years.

@Xavier: Can't you provide us, at very least, a small tutorial showing how to compile this with the latest empathy build? Because it doesn't work.

If not - I donated years ago for this to be implemented, so I'll want my money back. :P

"it doesn't work" is too vague plus Bugzilla is not a support forum for general software development question. There are many pages out there which explain how to compile software... Thanks for your understanding.

I would like to point everyone to this bug that I just opened
https://bugs.freedesktop.org/show_bug.cgi?id=93090

It seems there is a better alternative to OTR now, called OMEMO. Maybe the focus should be on implementing that, rather than OTR.

I don't think that OTR and OMEMO are mutually exclusive in any way. Besides, looking at the bug age it doesn't seems like there are much of efforts which could be "focused" anyway.

Worth mentioning that Xavier Claessens's never implemented patch is now likely vulnerable anyway...
https://www.helpnetsecurity.com/2016/03/10/critical-bug-libotr-open-users-chatsecure-adium-pidgin-compromise/

Upstream libotr has already addressed the vulnerability, so any attempts at this should be sure to implement the latest version without the memory bug.

@Andre Klapper: All I asked for was a quick tutorial on how to build it. However, as the years have continued to go by, I am now uninterested and have stopped using most GNOME telecommunication products completely due to lack of documentation and security. ¯\_(ツ)_/¯

(In reply to Luke from comment #107)
> I am now uninterested and
> have stopped using most GNOME telecommunication products completely due to
> lack of documentation and security. ¯\_(ツ)_/¯

1) GNOME is a destkop has nothing to do with communication, you can install any application under gnome
2) GNOME is open-source software not a product
From dictionary
product - "an article or substance that is manufactured or refined for sale"
3) There is plenty of documentation
4) Major part of open-source software is a contribution developed by people in their spare time
5) I believe it's of very minor importance what you use or not, or do in your life for the people signed up for this bug issue

Maybe no one wanted to spend time on this feature for a good reason.

KDE Telepathy has an implementation of OTR, There's a proxy component that handles adding/removing the encryption before passing it to the chat window.

It's in https://quickgit.kde.org/?p=ktp-common-internals.git&a=tree

There's also some UI level code in https://quickgit.kde.org/?p=ktp-text-ui.git&a=tree

A quick skim of the #includes suggests otr-proxy mostly just depends on TelepathyQt and not strongly on other KDE telepathy components.

> Maybe no one wanted to spend time on this feature for a good reason.

Mostly no one wanted to spend time on this because development on Telepathy stalled in 2014. It was largely being maintained by Collabora, and their funding dried up.

I do have the ability to merge code to telepathy, but I don't have time to work on a feature this complex.

Someone else will need to volunteer to implement this.