Elixir en Phoenix: schaalbare backendontwikkeling · Les

Beveiligingsbest practices voor Phoenix

Leer veelvoorkomende beveiligingskwetsbaarheden kennen en implementeer best practices om uw Phoenix-applicaties te beschermen.

Les 2 van 411 stappen

Beveiligingsbest practices voor Phoenix is een gratis Elixir en Phoenix: schaalbare backendontwikkeling-les op CoddyKit. Dit is les 2 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Elixir en Phoenix: schaalbare backendontwikkeling. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Elixir en Phoenix: schaalbare backendontwikkeling bevat in totaal 4 lessen.

Inleiding tot Phoenix-beveiliging

Welkom bij een belangrijke les over het beveiligen van je Phoenix-toepassingen! Robuuste, functionele toepassingen bouwen is mooi, maar hun beveiliging waarborgen is essentieel om je gebruikers en gegevens te beschermen.

In deze les bekijken we veelvoorkomende kwetsbaarheden in het web en de aanbevolen werkwijzen die Phoenix biedt om je ertegen te beschermen. Een veilige toepassing wekt vertrouwen en voorkomt kostbare inbreuken.

Cross-site scripting (XSS)

Cross-site scripting (XSS) is een veelvoorkomende aanval waarbij schadelijke scripts in vertrouwde websites worden geïnjecteerd. Wanneer een gebruiker de gecompromitteerde site bezoekt, wordt het schadelijke script in diens browser uitgevoerd. Hierdoor kunnen cookies en sessietokens worden gestolen of kan inhoud worden verminkt.

XSS-aanvallen ontstaan vaak wanneer door de gebruiker aangeleverde gegevens rechtstreeks op een webpagina worden weergegeven zonder de juiste opschoning of escaping.

XSS-aanvallen voorkomen

Phoenix ontsnapt via zijn sjabloonengine EEx standaard automatisch aan HTML-inhoud. Dat betekent dat elke door de gebruiker aangeleverde tekenreeks met HTML-tags zoals <script> als platte tekst wordt weergegeven en niet als uitvoerbare code.

Wees echter voorzichtig bij het gebruik van Phoenix.HTML.raw/1 of <%= raw @content %> in sjablonen, omdat je daarmee escaping expliciet omzeilt. Gebruik dit alleen als je absoluut zeker weet dat de inhoud veilig is of door een vertrouwde bibliotheek is opgeschoond.

Hier is een eenvoudig voorbeeld dat veilige en onveilige weergavelogica toont:

defmodule SecurityDemo do
  # Simulates rendering user input safely
  def safe_render(input) do
    Phoenix.HTML.html_escape(input)
  end

  # Simulates rendering user input unsafely (e.g., if 'raw' was used carelessly)
  def unsafe_render(input) do
    input
  end

  def run do
    user_input = "<script>alert('XSS!')</script>"
    IO.puts "Safe output: #{safe_render(user_input)}"
    IO.puts "Unsafe output: #{unsafe_render(user_input)}"
  end
end

# To run this, you'd typically need Phoenix.HTML in your deps.
# For demonstration, assume html_escape is available.
# In a real Phoenix app, EEx does this automatically.
SecurityDemo.run()

Cross-site request forgery (CSRF)

Cross-site request forgery (CSRF) is een aanval die de browser van een gebruiker misleidt om zonder diens medeweten een geauthenticeerde aanvraag naar een webtoepassing te versturen. Stel je voor dat een ingelogde gebruiker een schadelijke site bezoekt, die vervolgens ongemerkt een aanvraag naar je bankwebsite activeert om geld over te maken.

De kern is dat de aanvraag vanaf een externe site wordt gestart, maar de actieve sessie van het slachtoffer in je toepassing gebruikt.

CSRF-bescherming in Phoenix

Phoenix heeft ingebouwde CSRF-bescherming via Plug.CSRFProtection. Deze plug zorgt ervoor dat alle aanvragen die geen GET-aanvragen zijn (zoals POST, PUT en DELETE) een speciaal token bevatten, dat vervolgens door de server wordt gevalideerd.

Het token wordt doorgaans in formulieren opgenomen als verborgen veld of toegevoegd aan de kopteksten van AJAX-aanvragen. Als het token ontbreekt of ongeldig is, wordt de aanvraag afgewezen, waardoor CSRF-aanvallen worden voorkomen.

Automatisch: Phoenix-projecten bevatten dit standaard.
Formulieren: Gebruik <%= csrf_input_tag() %> in je formulieren.
API's: Voeg het token toe aan een aangepaste koptekst (bijvoorbeeld X-CSRF-Token).

Veilige invoervalidatie

Alle gebruikersinvoer valideren is cruciaal, niet alleen voor de integriteit van gegevens, maar ook voor de beveiliging. Schadelijke invoer kan tot verschillende kwetsbaarheden leiden:

SQL-injectie: Als invoer rechtstreeks in databasequery's wordt gebruikt.
Opdrachtinjectie: Als invoer aan systeemopdrachten wordt doorgegeven.
Logische fouten: Als onverwachte invoer de toepassingslogica doorbreekt.

Valideer invoer altijd aan de serverzijde, zelfs als er validatie aan de clientzijde aanwezig is. Phoenix-toepassingen gebruiken vaak Ecto Changesets voor robuuste gegevensvalidatie voordat gegevens in de database worden opgeslagen.

defmodule UserValidator do
  import Ecto.Changeset

  # A dummy struct for demonstration without a real database
  defstruct [:username, :password]

  def changeset(user, attrs) do
    user
    |> cast(attrs, [:username, :password])
    |> validate_required([:username, :password])
    |> validate_length(:username, min: 3, max: 20)
    |> validate_length(:password, min: 8) # Enforce minimum password length
    |> unique_username_check() # Placeholder for a real DB check
  end

  defp unique_username_check(changeset) do
    # In a real app, this would query the database
    # to ensure username is unique.
    # For demo, just pass it through.
    changeset
  end

  def run do
    # Example of valid input
    valid_attrs = %{username: "coder_kit", password: "secureP@ss123"}
    valid_cs = changeset(%UserValidator{}, valid_attrs)
    IO.puts "Valid Changeset? #{inspect valid_cs.valid?}"

    # Example of invalid input
    invalid_attrs = %{username: "a", password: "short"}
    invalid_cs = changeset(%UserValidator{}, invalid_attrs)
    IO.puts "Invalid Changeset? #{inspect invalid_cs.valid?}"
    IO.puts "Errors: #{inspect invalid_cs.errors}"
  end
end

UserValidator.run()

Veilige sessies beheren

Sessies worden gebruikt om de status tussen aanvragen voor een specifieke gebruiker te behouden. In Phoenix worden sessies doorgaans opgeslagen in versleutelde, ondertekende cookies. Dit zorgt voor:

Vertrouwelijkheid: De gegevens kunnen niet door een aanvaller worden gelezen.
Integriteit: Er kan niet met de gegevens worden geknoeid.

Aanbevolen werkwijzen:

Gebruik httpOnly-cookies om toegang vanuit scripts aan de clientzijde te voorkomen.
Gebruik secure-cookies om ervoor te zorgen dat ze alleen via HTTPS worden verzonden.
Stel een redelijke vervaltijd voor sessies in.
Roteer sessiesleutels regelmatig (Phoenix handelt dit af).

Deze instellingen worden geconfigureerd in je endpoint.ex-bestand.

Essentiële beveiligingskopteksten

HTTP-beveiligingsheaders bieden een extra verdedigingslaag doordat ze browsers instrueren over hoe ze zich moeten gedragen bij interactie met je site. Belangrijke headers zijn:

Content Security Policy (CSP): Voorkomt XSS- en gegevensinjectieaanvallen door te beperken welke resources (scripts, stijlen enzovoort) een browser mag laden.
Strict-Transport-Security (HSTS): Dwingt browsers om alleen via HTTPS met je site te communiceren en voorkomt downgrade-aanvallen.
X-Frame-Options: Voorkomt clickjacking door te bepalen of je site in een <iframe> mag worden ingesloten.
X-Content-Type-Options: Voorkomt dat browsers het MIME-type van een response afleiden in plaats van het gedeclareerde Content-Type te gebruiken.

In Phoenix kun je deze configureren in je bestand endpoint.ex.

Beveiligingsscan van afhankelijkheden

Je applicatie is afhankelijk van veel bibliotheken van derden (afhankelijkheden). Deze kunnen kwetsbaarheden introduceren als ze verouderd zijn of bekende gebreken bevatten. Het is cruciaal om:

Afhankelijkheden bijgewerkt te houden: Voer regelmatig mix deps.update --all uit en controleer de wijzigingen.
Op kwetsbaarheden te scannen: Gebruik tools zoals mix audit (een project van de community) om je afhankelijkheden te controleren op bekende beveiligingsadviezen.
Nieuwe afhankelijkheden te beoordelen: Controleer voordat je een nieuwe bibliotheek toevoegt de reputatie, onderhoudsstatus en gemelde beveiligingsproblemen ervan.

Een proactieve aanpak van afhankelijkheidsbeheer is essentieel om een veilige applicatie te onderhouden.

Controle van aanbevolen beveiligingspraktijken

Welke van de volgende opties is GEEN aanbevolen beveiligingspraktijk voor een Phoenix-applicatie?

Beantwoord dit in de interactieve les

Samenvatting: Phoenix versterken

Gefeliciteerd! Je hebt essentiële aanbevolen beveiligingspraktijken voor Phoenix-applicaties behandeld. Je hebt geleerd over veelvoorkomende bedreigingen zoals XSS en CSRF, en hoe de ingebouwde functies van Phoenix en zorgvuldige code deze kunnen beperken.

XSS: Vertrouw op automatisch escapen in EEx; gebruik `raw/1` spaarzaam.
CSRF: Gebruik `Plug.CSRFProtection`.
Validatie: Gebruik Ecto Changesets voor grondige validatie van invoer aan de serverkant.
Sessies: Zorg voor veilige, versleutelde en ondertekende sessiecookies.
Headers: Implementeer beveiligingsheaders zoals CSP en HSTS.
Afhankelijkheden: Houd ze bijgewerkt en scan op kwetsbaarheden.

Door deze praktijken toe te passen, kun je veerkrachtigere en betrouwbaardere Phoenix-applicaties bouwen.

Gratis beginnen

Leer Elixir met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 12
Lessen: 48

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Beveiligingsbest practices voor Phoenix” gratis?

Ja — de volledige tekst van “Beveiligingsbest practices voor Phoenix” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Elixir en Phoenix: schaalbare backendontwikkeling wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Elixir en Phoenix: schaalbare backendontwikkeling bevat in totaal 4 lessen.

Wat leer ik in “Beveiligingsbest practices voor Phoenix”?

Leer veelvoorkomende beveiligingskwetsbaarheden kennen en implementeer best practices om uw Phoenix-applicaties te beschermen. Je oefent met Elixir en Phoenix: schaalbare backendontwikkeling door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Elixir en Phoenix: schaalbare backendontwikkeling te beginnen?

Ervaring vooraf is niet nodig. Elixir en Phoenix: schaalbare backendontwikkeling op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “Beveiligingsbest practices voor Phoenix”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Elixir en Phoenix: schaalbare backendontwikkeling?

Ja. Elke les over Elixir en Phoenix: schaalbare backendontwikkeling bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

Populaire Elixir-bibliotheken en hulpmiddelen
Beveiligingsbest practices voor Phoenix
Onderhoudbare Elixir- en Phoenix-code schrijven
Documentatie en statische analyse met Dialyzer

← Terug naar Elixir en Phoenix: schaalbare backendontwikkeling