# Sådan virker filoverførsel med WebRTC

Source: https://help.strongfolder.com/da/guides/how-webrtc-file-transfer-works/
Updated: 2026-11-05

> Filoverførsel med WebRTC foregår i tre faser. En signaleringsserver præsenterer to browsere for hinanden; STUN og ICE finder en netværksvej gennem routere i hjemmet (NAT) og falder tilbage til et TURN-relay, hvis der ikke findes en direkte vej; derefter åbner browserne en DTLS-krypteret datakanal og streamer filen i stykker, direkte eller via relayet, uden at gemme den.

Filoverførsel med WebRTC lader to browsere sende en fil til hinanden uden at uploade den til
lagring i skyen. Det lyder enkelt, men internettet blev ikke bygget til, at to computere i hjemmet
ringer direkte til hinanden. Denne vejledning gennemgår, hvad der faktisk sker – signalering, NAT,
STUN, ICE, TURN, DTLS og datakanaler – i et enkelt sprog med StrongFolder som
eksempel.

**Key facts**

- **WebRTC** er en browserstandard for direkte, krypterede forbindelser mellem to enheder; filværktøjer bruger dens **datakanaler**.
- **Signalering** præsenterer browserne for hinanden; **STUN** og **ICE** finder en vej gennem routere (**NAT**); et **TURN-relay** videresender trafikken, når der ikke findes en direkte vej.
- **Kryptering:** hver datakanal bruger **DTLS** – WebRTC har ingen ukrypteret tilstand.
- StrongFolder bruger PeerJS oven på WebRTC, en signaleringsserver hos StrongFolder, offentlige STUN-servere (herunder Googles) og sine egne TURN-relays. Filer bliver aldrig uploadet til eller gemt på en server hos StrongFolder.
- Filen streames i stykker fra afsenderens disk til modtagerens disk; afsenderen forbliver online.

## Hvad er WebRTC?

[WebRTC](https://help.strongfolder.com/en/glossary/#webrtc) (Web Real-Time Communication) er et sæt browser-API'er og
netværksprotokoller, standardiseret af W3C og IETF, til realtidsforbindelser mellem
browsere. Chrome, Edge, Firefox, Safari og Opera understøtter det alle. Det blev bygget til video- og
taleopkald, men det har også **datakanaler**, der bærer alle slags binære data – og det er præcis,
hvad en fil er.

Den vigtigste egenskab: når en WebRTC-forbindelse først er sat op, går dataene **mellem de to
endepunkter**, ikke ind i en servers lager. Det er det, der gør
[P2P-filoverførsel i browseren](https://help.strongfolder.com/en/guides/p2p-file-transfer/) mulig.

## Hvorfor kan to browsere ikke bare forbinde direkte til hinanden?

Fordi næsten ingen enhed har sin egen offentlige adresse. Din bærbare sidder bag en router i hjemmet,
en firewall på kontoret eller et mobilselskabs netværk. Routeren udfører
[NAT](https://help.strongfolder.com/en/glossary/#nat) (Network Address Translation): mange private enheder deler én offentlig
IP-adresse, og routeren lukker kun trafik ind, der svarer på noget sendt indefra.

Så to browsere står over for tre problemer, før der kan flyde fildata:

1. De ved ikke, **hvordan de når hinanden** – ingen af dem ved, at den anden findes.
2. De kender ikke **deres egen offentlige adresse** – kun den private, som 192.168.1.20.
3. Deres routere kan **blokere uopfordret indgående trafik**.

WebRTC løser hvert problem med en separat mekanisme.

## Hvordan foregår en filoverførsel med WebRTC trin for trin?

Her er hele forløbet, fra du klikker "del", til den sidste byte:

```
 Sender browser                   Servers                      Recipient browser
 ──────────────                   ───────                      ─────────────────
 1. Choose files ──── metadata ──▶ Signaling server
                                        ◀──────── 2. Open link ────────
 3. Offer (SDP) ─────────────────▶ Signaling ──────────────────▶ Answer (SDP)
 4. Ask STUN "how do I look?" ─▶ STUN servers ◀─ Ask STUN "how do I look?"
 5. ICE candidates ◀─────────────▶ Signaling ◀──────────────────▶ ICE candidates
 6. ICE checks: try LAN → direct internet → TURN relay
 7. DTLS handshake ◀════════════ encrypted ═════════════════▶ DTLS handshake
 8. Data channel: file chunks ═══(direct or via TURN relay)══▶ written to disk
```

**Trin 1–2 – Signalering.** Afsenderen vælger filer; tjenesten registrerer de metadata, der skal bruges
til linket. Når modtageren åbner linket, er begge browsere forbundet til en
[signaleringsserver](https://help.strongfolder.com/en/glossary/#signaling). WebRTC definerer ikke, hvordan signalering foregår;
StrongFolder bruger PeerJS med sin egen signaleringsserver.

**Trin 3 – Tilbud og svar.** Den ene browser opretter et **tilbud** (offer) i SDP (Session Description
Protocol): "Jeg vil have en datakanal, her er mit krypteringsfingeraftryk og mine egenskaber." Den
anden svarer med et **svar** (answer). Begge sendes via signaleringsserveren.

**Trin 4 – STUN.** Hver browser spørger en [STUN](https://help.strongfolder.com/en/glossary/#stun)-server: "Hvilken adresse og
port ser du mig komme fra?" Svaret er dens offentlige adresse, som routeren har oversat den.
STUN-servere håndterer en lille forespørgsel og ingen fildata; StrongFolder bruger offentlige STUN-servere,
herunder Googles, og sine egne.

**Trin 5 – ICE-kandidater.** Hver browser samler **kandidater** – mulige måder at nå den på:
dens adresse i det lokale netværk (host), dens offentlige adresse fra STUN (server-reflexive) og
en adresse på et TURN-relay (relayed). De udveksler kandidater via signaleringen.

**Trin 6 – Forbindelsestjek.** [ICE](https://help.strongfolder.com/en/glossary/#ice) (Interactive Connectivity
Establishment) tester kandidatpar og vælger det bedste, der virker. Hvis begge enheder er
på samme Wi-Fi, vinder en lokal vej. Hvis routerne tillader det, vinder en direkte vej over internettet ("hole
punching"). Hvis intet direkte virker, bruges vejen via relay.

**Trin 7 – DTLS.** Før der flyder data, gennemfører browserne et [DTLS](https://help.strongfolder.com/en/glossary/#dtls)-håndtryk
(TLS tilpasset til UDP) og kontrollerer, at certifikaternes fingeraftryk svarer til dem i
tilbuddet og svaret. Fra nu af er alt krypteret.

**Trin 8 – Datakanal.** Oven på DTLS kører SCTP, som giver datakanalen pålidelig levering
i rækkefølge. I StrongFolder beder modtagerens browser om en fil, afsenderens
browser læser den fra disken i stykker og sender dem, og modtageren skriver hvert stykke til
disken, efterhånden som det kommer – så selv meget store filer aldrig behøver at kunne være i hukommelsen.

## Hvad betyder STUN, TURN, ICE og de andre begreber?

| Begreb | Hvad det gør | Ser fildata? | Standard |
|---|---|---|---|
| Signalering | Videregiver tilbud, svar og kandidater mellem browsere | Nej | Ikke standardiseret (appspecifik) |
| NAT | Routerfunktion, der deler én offentlig IP mellem mange enheder | — | — |
| STUN | Fortæller en browser dens offentlige adresse og port | Nej | IETF RFC 8489 |
| ICE | Samler kandidater og vælger en vej, der virker | Nej | IETF RFC 8445 |
| TURN | Videresender trafik, når ingen direkte vej virker | Kun krypterede pakker | IETF RFC 8656 |
| DTLS | Krypterer forbindelsen (TLS til UDP) | Krypterer dem | IETF RFC 9147 (1.3), RFC 6347 (1.2) |
| SCTP-datakanal | Pålidelig levering af stykker i rækkefølge | Bærer dem (krypteret) | IETF RFC 8831 |

Alle begreberne er kort forklaret i [ordlisten](https://help.strongfolder.com/en/glossary/).

## Hvornår bruges et TURN-relay, og hvad ser det?

Et relay er reserveløsningen, ikke standarden. ICE bruger det kun, når intet direkte kandidatpar
forbinder – typisk på netværk med **symmetrisk NAT** (visse mobilselskaber), **virksomhedsfirewalls**,
der blokerer udgående UDP, eller visse VPN'er.

Hvis en direkte forbindelse er umulig (streng virksomhedsfirewall, visse mobilnet), går den krypterede datastrøm via en relay-server (TURN) hos StrongFolder. Relayet videresender dataene og gemmer dem ikke.

Relayet modtager DTLS-krypterede pakker og sender dem videre. Det kan se, at der flyder
trafik, hvor meget og hvornår – ikke hvad der er indeni. En overførsel via relay kan være langsommere end en
direkte, fordi hver byte tager en ekstra tur gennem relayet. Hvis en overførsel er
usædvanligt langsom, så prøv et andet netværk: et hotspot fra telefonen eller Wi-Fi derhjemme forbinder ofte
direkte, hvor et kontornetværk ikke gør.

[Send filer nu](https://strongfolder.com)
## Hvor sikker er krypteringen i WebRTC?

WebRTC gør kryptering obligatorisk: der er ingen måde at åbne en ukrypteret datakanal på.
DTLS bruger moderne krypteringsalgoritmer, som de to browsere forhandler, og der oprettes nye nøgler til
hver forbindelse.

Der er ét ærligt forbehold, der gælder for alle WebRTC-tjenester. De to browsere verificerer
hinanden via certifikaternes **fingeraftryk**, der udveksles via signaleringsserveren.
Du stoler derfor på, at tjenestens signalering ikke manipulerer med dem. Derfor
beskriver StrongFolder sin beskyttelse som **kryptering under overførsel** – ikke som end-to-end-kryptering
med nøgler, du selv har, og ikke som "zero-knowledge". For et bredere billede af, hvad
"sikker" betyder, kan du læse [Sikker fildeling](https://help.strongfolder.com/en/guides/secure-file-sharing/) og
[Sikkerhed og privatliv](https://help.strongfolder.com/en/security/).

## Hvorfor skal afsenderens browser være åben?

Fordi afsenderens browser *er* kilden. Der findes ingen kopi på en server at falde tilbage på: datakanalen
læser kun stykker fra afsenderens disk, mens fanen er åben, og enheden
er vågen. Afsenderens browserfane skal være åben og online, indtil modtageren er færdig med at downloade – filerne kommer fra afsenderens enhed, ikke fra en server. Hvordan du planlægger efter det, er beskrevet i
[Hvorfor afsenderen skal være online](https://help.strongfolder.com/en/guides/why-sender-stays-online/).

## Hvor hurtig er filoverførsel med WebRTC?

Der er ingen fast hastighed. Loftet er det langsomste led på vejen: som regel afsenderens
**upload**hastighed. Som tommelfingerregel tager 1 GB cirka 2,7 minutter med 50 Mbit/s, cirka 80
sekunder med 100 Mbit/s og et godt stykke under et minut på et hurtigt lokalt netværk. Virkelige overførsler ligger
noget under disse tal på grund af protokol-overhead, diskhastighed og, med et relay,
det ekstra hop. Ét link kan åbnes af flere modtagere; hver af dem downloader direkte fra afsenderen. Flere downloads på én gang deler afsenderens upload.

## Opsummering

En filoverførsel med WebRTC er en kort forhandling efterfulgt af en lang, krypteret strøm:
signalering præsenterer browserne for hinanden, STUN og ICE finder en vej gennem NAT, TURN videresender som en
sidste udvej, og DTLS-krypterede datakanaler bærer filen fra disk til disk. For den
praktiske side – hvad det betyder for dig som afsender – kan du starte med
[P2P-filoverførsel i browseren](https://help.strongfolder.com/en/guides/p2p-file-transfer/) og
[Sådan virker StrongFolder](https://help.strongfolder.com/en/how-it-works/).

## FAQ

### Hvad er en WebRTC-datakanal?

En datakanal er den del af WebRTC, der bærer vilkårlige bytes mellem to browsere i stedet for lyd eller video. Den kører SCTP over DTLS over UDP, så den er krypteret og kan konfigureres til pålidelig levering i rækkefølge – præcis det, filoverførsel kræver.

### Hvad er forskellen mellem STUN og TURN?

En STUN-server fortæller kun en browser, hvordan dens offentlige adresse ser ud, så de to browsere kan prøve at forbinde direkte; ingen fildata går igennem den. En TURN-server er et relay: når ingen direkte vej virker, går den krypterede strøm igennem den. StrongFolder driver sine egne TURN-relays, som videresender og ikke gemmer data.

### Ser signaleringsserveren mine filer?

Nej. Signaleringsserveren videregiver kun forbindelsesbeskeder – sessionsbeskrivelser og netværkskandidater – mellem browserne. Fildata flyder over datakanalen, enten direkte eller via et TURN-relay.

### Er filoverførsel med WebRTC krypteret?

WebRTC krypterer hver datakanal med DTLS, så datastrømmen er krypteret under overførslen på hver forbindelse. WebRTC tillader ikke ukrypterede datakanaler. Nøglerne forhandles af de to browsere; deres fingeraftryk sendes via signaleringen, og derfor er det kryptering under overførsel og ikke end-to-end-kryptering med nøgler, du selv styrer.

### Hvorfor fejler en WebRTC-overførsel nogle gange, eller hvorfor er den langsom?

Som regel på grund af netværksvejen: en streng firewall eller VPN blokerer direkte UDP, så forbindelsen falder tilbage til et TURN-relay over TCP eller slet ikke kan oprettes. Prøv et andet netværk (for eksempel et hotspot fra telefonen), slå VPN'en fra, eller bed IT om at tillade WebRTC.

### Kan et TURN-relay læse mine filer?

Relayet videresender DTLS-krypterede pakker mellem de to browsere. Det ser krypteret trafik, størrelser og tidspunkter, ikke filernes indhold, og StrongFolders relay gemmer ikke det, det videresender.
