
Show HN: Gfile, a WebRTC based file transfer utility in Go - Antonito
https://github.com/Antonito/gfile/tree/v0.1.0
======
hardwaresofton
Despite how awesome WebRTC is, every time I see it my mind instantly goes to
whether I understand STUN/TURN enough. They're part of the overall concept of
ICE (Interactive Connection Establishment)[0], and STUN is a protocol for
negotiated direct peer-to-peer connections[1] whereas TURN[2] is a relay mode
that is used when a direct connection cannot be achieved for either side.

When I saw the claim "without the need of a third party", it didn't fit with
my knowledge of WebRTC so I went spelunking through the code and found that
they do indeed use a STUN server[3], in particular google's
"stun.l.google.com:19302".

Just want to point out to those who might be relatively new to WebRTC, p2p
mechanisms, etc -- it is surprisingly hard for two computers to talk to each
other over the wide internet, even in this day and age. _Even if you 're
behind the same router_ things aren't necessarily straight forward.

[EDIT] - Also note that in the case of TURN, it is up to the application layer
to encrypt communications[4].

[0]:
[https://en.wikipedia.org/wiki/Interactive_Connectivity_Estab...](https://en.wikipedia.org/wiki/Interactive_Connectivity_Establishment)

[1]: [https://en.wikipedia.org/wiki/STUN](https://en.wikipedia.org/wiki/STUN)

[2]:
[https://en.wikipedia.org/wiki/Traversal_Using_Relays_around_...](https://en.wikipedia.org/wiki/Traversal_Using_Relays_around_NAT)

[3]:
[https://github.com/Antonito/gfile/blob/v0.1.0/internal/sessi...](https://github.com/Antonito/gfile/blob/v0.1.0/internal/session/session.go#L47)

[4]: [https://stackoverflow.com/questions/23085335/is-webrtc-
traff...](https://stackoverflow.com/questions/23085335/is-webrtc-traffic-over-
turn-end-to-end-encrypted)

~~~
lossolo
> it is surprisingly hard for two computers to talk to each other over the
> wide internet, even in this day and age

Only if both are behind NAT without forwarded ports and even then you can just
use services like this[1] if you want to send files/data and it's super easy.

> Even if you're behind the same router things aren't necessarily straight
> forward.

I don't think this is true for most cases today.

1\. [https://justbeamit.com/](https://justbeamit.com/)

------
knocte
> It allows to share a file directly between two computers, without the need
> of a third party.

I'm guessing it still depends on STUN and TURN servers?

~~~
Antonito
Yup, it still relies on a STUN server to get the connection's metadata. As
hardwaresofton pointed out, I'm using Google's STUN server.

Since it's only STUN, and not TURN, the actual transferred data does not go
transit through it though.

~~~
davidcollantes
Is there no way to run this, without relying on a third party server/service?

------
kkapelon
Honest question: what is the advantage over nc + compression utility of your
choice?

If you are just learning Golang, then congrats on shipping!

~~~
Antonito
Hey!

It can be useful if your transmitting data between two different clients on
two different networks. In this case, you don't need to open ports on your
firewall nor change your network configuration :)

Thank you!

------
tpaschalis
Thanks for this! I've wanted to learn more about WebRTC and Go, and digging
through the source seems a good opportunity.

To solve the same problem I've been using another [0] simple silly solution,
but security is a concern.

[0] [https://github.com/tpaschalis/goof](https://github.com/tpaschalis/goof)

~~~
Antonito
Glad you like it!

If you think of any feature/improvements, feel free to open a issue/pull
request! :)

------
est
> gfile is a WebRTC based file exchange software.

> It allows to share a file directly between two computers, without the need
> of a third party.

Can it be done with a single HTML file instead of Go?

You know, which can be hosted anywhere even on Github pages.

~~~
ggerganov
I actually did such kind of experiment recently [0]. As a bonus, the users do
not have to copy/paste the SDP data manually - instead it is transmitted
through sound!

[0] [https://ggerganov.github.io/wave-share](https://ggerganov.github.io/wave-
share)

~~~
Antonito
That project is really cool!

I'm planning to work on the SDP stuff at some point. It works well, but
sharing two base64 encoded strings isn't very practical :/

------
ignoramous
Another similar service I've found useful is
[https://instant.io/](https://instant.io/) which does bit-torrent over WebRTC.

~~~
Antonito
Didn't know about it, that's pretty cool!

------
equalunique
I wonder if I can use this to send ZFS snapshots over WebRTC

~~~
kim0
Interesting, what's the use case here?

~~~
equalunique
Possibly a more robust protocol to send/recieve datasets, perhaps involving a
Project-FiFo installation.

------
maracuja-juice
How about a tool like croc instead?
[https://github.com/schollz/croc](https://github.com/schollz/croc)

~~~
qrv3w
croc currently doesn't do peer-to-peer with WebRTC, but I've actually been
working on a branch that does. [1] Currently, croc uses a rendezvous server
unless you happen to be on the same local network.

Thanks to Antonito (and their usage of MIT license) I'll fork their code into
croc so it can do WebRTC with a secure PAKE channel.

[1]:
[https://github.com/schollz/croc/tree/v5](https://github.com/schollz/croc/tree/v5)

------
siwatanejo
I'm not a fan of Go. If anyone is interested in developing a Rust equivalent
of this (all Rust with no C/C++ deps) I'm willing to pay for it, contact me at
andrew.forsure@gmail.com (end result can be opensource)

~~~
arghwhat
As someone who is personally a great fan of Rust, I have to say that this is a
very defective attitude.

If you're not writing it yourself (WebRTC is super simple, and this tool is
basically the absolute bare-bone example of it—make a pipe and transfer
something over it), why in the world would you care about what language it is
written in beyond whether the language is safe, performant enough, and not a
nightmare to execute on the target PC?

If you're not making it, you don't get to pick the tools. _Paying_ just to get
decide tools for _other_ people also seems like a really weird thing to do.

~~~
GoblinSlayer
Tools affect the result. If you ordered a tool in C, you will get more
features than you wanted.

~~~
arghwhat
Tools, at a high level, do not affect what the end result is. Instead, it
affects how end result is achieved.

In real life, languages are more than tools, but as long as
features/performance/behavior is acceptable, it still reduces to an
implementation detail.

(also, unless segfaults can be considered features, I don't see why C would
get you anything extra.)

~~~
pjmlp
I guess black hats would consider memory corruption welcomed features.

