# Så fungerar filöverföring med WebRTC

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

> Filöverföring med WebRTC sker i tre faser. En signaleringsserver presenterar två webbläsare för varandra; STUN och ICE hittar en väg genom hemroutrar (NAT) och faller tillbaka på ett TURN-relä om ingen direkt väg finns; sedan öppnar webbläsarna en DTLS-krypterad datakanal och strömmar filen i bitar, direkt eller via reläet, utan att lagra den.

Filöverföring med WebRTC låter två webbläsare skicka en fil till varandra utan att ladda upp den till
molnlagring. Det låter enkelt, men internet byggdes inte för att två hemdatorer ska kunna ringa
varandra direkt. Den här guiden går igenom vad som faktiskt händer – signalering, NAT, STUN, ICE,
TURN, DTLS och datakanaler – på enkel svenska, med StrongFolder som exempel.

**Key facts**

- **WebRTC** är en webbläsarstandard för direkta, krypterade anslutningar mellan två enheter; filverktyg använder dess **datakanaler**.
- **Signalering** presenterar webbläsarna; **STUN** och **ICE** hittar en väg genom routrar (**NAT**); ett **TURN-relä** vidarebefordrar trafiken när ingen direkt väg finns.
- **Kryptering:** varje datakanal använder **DTLS** – WebRTC har inget okrypterat läge.
- StrongFolder använder PeerJS ovanpå WebRTC, en signaleringsserver hos StrongFolder, publika STUN-servrar (bland annat Googles) och egna TURN-reläer. Filer laddas aldrig upp till eller lagras på någon server hos StrongFolder.
- Filen strömmar i bitar från avsändarens disk till mottagarens disk; avsändaren är online.

## Vad är WebRTC?

[WebRTC](https://help.strongfolder.com/en/glossary/#webrtc) (Web Real-Time Communication) är en uppsättning webbläsar-API:er och
nätverksprotokoll, standardiserade av W3C och IETF, för anslutningar i realtid mellan webbläsare.
Chrome, Edge, Firefox, Safari och Opera stöder alla det. Det byggdes för video- och röstsamtal, men
har också **datakanaler** som bär godtycklig binär data – vilket är exakt vad en fil är.

Den viktiga egenskapen: när en WebRTC-anslutning väl är uppsatt går datan **mellan de två
ändpunkterna**, inte in i en servers lagring. Det är det som gör [P2P-filöverföring i
webbläsaren](https://help.strongfolder.com/en/guides/p2p-file-transfer/) möjlig.

## Varför kan inte två webbläsare bara ansluta till varandra?

För att nästan ingen enhet har en egen publik adress. Din laptop sitter bakom en hemrouter, en
kontorsbrandvägg eller en mobiloperatörs nätverk. Routern utför [NAT](https://help.strongfolder.com/en/glossary/#nat) (Network
Address Translation): många privata enheter delar en publik IP-adress, och routern släpper bara in
trafik som svarar på något som skickats inifrån.

Två webbläsare står alltså inför tre problem innan någon fildata kan flöda:

1. De vet inte **hur de ska nå varandra** – ingen av dem vet att den andra finns.
2. De vet inte **sin egen publika adress** – bara den privata, som 192.168.1.20.
3. Deras routrar kan **blockera oönskad inkommande trafik**.

WebRTC löser varje problem med en separat mekanism.

## Hur fungerar en filöverföring med WebRTC, steg för steg?

Här är hela flödet, från klicket på ”dela” till den sista byten:

```
 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
```

**Steg 1–2 – Signalering.** Avsändaren väljer filer; tjänsten registrerar den metadata som behövs för
länken. När mottagaren öppnar länken är båda webbläsarna anslutna till en
[signalerings](https://help.strongfolder.com/en/glossary/#signaling)server. WebRTC definierar inte hur signaleringen fungerar;
StrongFolder använder PeerJS med sin egen signaleringsserver.

**Steg 3 – Erbjudande och svar.** En webbläsare skapar ett **erbjudande** (offer) i SDP (Session
Description Protocol): ”Jag vill ha en datakanal, här är mitt krypteringsfingeravtryck och mina
förmågor.” Den andra svarar med ett **svar** (answer). Båda går via signaleringsservern.

**Steg 4 – STUN.** Varje webbläsare frågar en [STUN](https://help.strongfolder.com/en/glossary/#stun)-server: ”vilken adress och port
ser du att jag kommer från?” Svaret är dess publika adress så som routern har mappat den.
STUN-servrar hanterar en pytteliten förfrågan och ingen fildata; StrongFolder använder publika
STUN-servrar, bland annat Googles, och egna.

**Steg 5 – ICE-kandidater.** Varje webbläsare samlar in **kandidater** – möjliga sätt att nå den: sin
adress i det lokala nätverket (host), sin publika adress från STUN (server-reflexive) och en adress på
ett TURN-relä (relayed). De utbyter kandidater via signaleringen.

**Steg 6 – Anslutningskontroller.** [ICE](https://help.strongfolder.com/en/glossary/#ice) (Interactive Connectivity Establishment)
testar kandidatpar och väljer det bästa som fungerar. Om båda enheterna är på samma wifi vinner en
lokal väg. Om routrarna tillåter det vinner en direkt väg över internet (”hole punching”). Om ingenting
direkt fungerar används vägen via relä.

**Steg 7 – DTLS.** Innan någon data flödar genomför webbläsarna en [DTLS](https://help.strongfolder.com/en/glossary/#dtls)-handskakning
(TLS anpassat för UDP) och kontrollerar att certifikatens fingeravtryck stämmer med dem i erbjudandet
och svaret. Från och med nu är allt krypterat.

**Steg 8 – Datakanal.** Över DTLS körs SCTP, som ger datakanalen pålitlig, ordnad leverans. I
StrongFolder begär mottagarens webbläsare en fil, avsändarens webbläsare läser den från disken i bitar
och skickar dem, och mottagaren skriver varje bit till disken när den kommer fram – så även mycket
stora filer behöver aldrig rymmas i minnet.

## Vad betyder STUN, TURN, ICE och de andra begreppen?

| Begrepp | Vad det gör | Ser det fildata? | Standard |
|---|---|---|---|
| Signalering | Förmedlar erbjudanden, svar och kandidater mellan webbläsare | Nej | Inte standardiserad (appspecifik) |
| NAT | Routerfunktion som delar en publik IP mellan många enheter | — | — |
| STUN | Berättar för en webbläsare dess publika adress och port | Nej | IETF RFC 8489 |
| ICE | Samlar in kandidater och väljer en fungerande väg | Nej | IETF RFC 8445 |
| TURN | Vidarebefordrar trafik när ingen direkt väg fungerar | Bara krypterade paket | IETF RFC 8656 |
| DTLS | Krypterar anslutningen (TLS för UDP) | Krypterar den | IETF RFC 9147 (1.3), RFC 6347 (1.2) |
| SCTP-datakanal | Pålitlig, ordnad leverans av bitar | Bär den (krypterad) | IETF RFC 8831 |

Alla förklaras kort i [ordlistan](https://help.strongfolder.com/en/glossary/).

## När används ett TURN-relä, och vad ser det?

Ett relä är reservvägen, inte standardvägen. ICE använder det bara när inget direkt kandidatpar
ansluter – typiskt i nätverk med **symmetrisk NAT** (vissa mobiloperatörer), **företagsbrandväggar**
som blockerar utgående UDP eller vissa VPN:er.

Om en direkt anslutning är omöjlig (strikt företagsbrandvägg, vissa mobilnät) går den krypterade dataströmmen via en reläserver (TURN) hos StrongFolder. Reläet vidarebefordrar datan och lagrar den inte.

Reläet tar emot DTLS-krypterade paket och skickar dem vidare. Det kan se att trafik flödar, hur mycket
och när – inte vad som finns i den. En överföring via relä kan vara långsammare än en direkt, eftersom
varje byte gör en extra resa genom reläet. Om en överföring är ovanligt långsam, prova ett annat
nätverk: en surfzon från mobilen eller wifi hemma ansluter ofta direkt där ett kontorsnätverk inte gör det.

[Skicka filer nu](https://strongfolder.com)
## Hur säker är krypteringen i WebRTC?

WebRTC gör kryptering obligatorisk: det finns inget sätt att öppna en okrypterad datakanal. DTLS
använder moderna chiffer som förhandlas fram av de två webbläsarna, och nya nycklar skapas för varje
anslutning.

Det finns en ärlig reservation som gäller alla WebRTC-tjänster. De två webbläsarna verifierar varandra
genom certifikatens **fingeravtryck**, som utbyts via signaleringsservern. Du litar därför på att
tjänstens signalering inte manipulerar dem. Det är därför StrongFolder beskriver sitt skydd som
**kryptering under överföring** – inte som end-to-end-kryptering med nycklar som du har, och inte som
”zero-knowledge”. För en bredare bild av vad ”säker” betyder, läs [Säker
fildelning](https://help.strongfolder.com/en/guides/secure-file-sharing/) och [Säkerhet och integritet](https://help.strongfolder.com/en/security/).

## Varför måste avsändarens webbläsare vara öppen?

För att avsändarens webbläsare *är* källan. Det finns ingen kopia på en server att falla tillbaka på:
datakanalen läser bitar från avsändarens disk bara medan fliken är öppen och enheten är vaken.
Avsändarens webbläsarflik måste vara öppen och online tills mottagaren har laddat ner klart – filerna kommer från avsändarens enhet, inte från en server. Hur du planerar för det går vi igenom i [Därför måste avsändaren vara
online](https://help.strongfolder.com/en/guides/why-sender-stays-online/).

## Hur snabb är filöverföring med WebRTC?

Det finns ingen fast hastighet. Taket är den långsammaste länken på vägen: oftast avsändarens
**uppladdningshastighet**. Som tumregel tar 1 GB ungefär 2,7 minuter med 50 Mbit/s, ungefär 80
sekunder med 100 Mbit/s och klart under en minut i ett snabbt lokalt nätverk. Verkliga överföringar
går något under de här siffrorna på grund av protokolloverhead, diskhastighet och, med ett relä, det
extra steget. En länk kan öppnas av flera mottagare; var och en laddar ner direkt från avsändaren. Flera nedladdningar samtidigt delar på avsändarens uppladdning.

## Sammanfattning

En filöverföring med WebRTC är en kort förhandling följd av en lång, krypterad ström: signaleringen
presenterar webbläsarna, STUN och ICE hittar en väg genom NAT, TURN vidarebefordrar som sista utväg,
och DTLS-krypterade datakanaler bär filen från disk till disk. För den praktiska sidan – vad detta
betyder för dig som avsändare – börja med [P2P-filöverföring i webbläsaren](https://help.strongfolder.com/en/guides/p2p-file-transfer/)
och [Så fungerar StrongFolder](https://help.strongfolder.com/en/how-it-works/).

## FAQ

### Vad är en WebRTC-datakanal?

En datakanal är den del av WebRTC som bär godtyckliga byte mellan två webbläsare i stället för ljud eller video. Den kör SCTP över DTLS över UDP, så den är krypterad och kan ställas in som pålitlig och ordnad – vilket är vad filöverföring behöver.

### Vad är skillnaden mellan STUN och TURN?

En STUN-server berättar bara för en webbläsare hur dess publika adress ser ut, så att de två webbläsarna kan försöka ansluta direkt; ingen fildata passerar den. En TURN-server är ett relä: när ingen direkt väg fungerar går den krypterade strömmen genom den. StrongFolder driver egna TURN-reläer, som vidarebefordrar och inte lagrar data.

### Ser signaleringsservern mina filer?

Nej. Signaleringsservern förmedlar bara anslutningsmeddelanden – sessionsbeskrivningar och nätverkskandidater – mellan webbläsarna. Fildatan flödar över datakanalen, antingen direkt eller via ett TURN-relä.

### Är filöverföring med WebRTC krypterad?

WebRTC krypterar varje datakanal med DTLS, så dataströmmen är krypterad under överföringen på varje anslutning. WebRTC tillåter inte okrypterade datakanaler. Nycklarna förhandlas fram av de två webbläsarna; deras fingeravtryck går via signaleringen, vilket är varför detta är kryptering under överföring snarare än end-to-end-kryptering med nycklar som du hanterar.

### Varför misslyckas en WebRTC-överföring ibland eller förblir långsam?

Oftast på grund av nätverksvägen: en strikt brandvägg eller VPN blockerar direkt UDP, så anslutningen faller tillbaka på ett TURN-relä över TCP, eller kan inte ansluta alls. Prova ett annat nätverk (till exempel en surfzon från mobilen), stäng av VPN:en eller be IT-avdelningen att tillåta WebRTC.

### Kan ett TURN-relä läsa mina filer?

Reläet vidarebefordrar DTLS-krypterade paket mellan de två webbläsarna. Det ser krypterad trafik, storlekar och tidpunkter, inte filens innehåll, och StrongFolders relä lagrar inte det som det vidarebefordrar.
