0Pricing
Elixir & Phoenix: Scalable Backend Development · Lección

Buenas prácticas de seguridad para Phoenix

Aprenda sobre vulnerabilidades de seguridad habituales e implemente buenas prácticas para proteger sus aplicaciones Phoenix.

Buenas prácticas de seguridad para Phoenix es una lección gratuita de Elixir & Phoenix: Scalable Backend Development en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Elixir & Phoenix: Scalable Backend Development, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Elixir & Phoenix: Scalable Backend Development incluye 4 lecciones en total.

Partes de esta lección aún no han sido traducidas y se muestran en inglés.

Intro to Phoenix Security

Welcome to a critical lesson on securing your Phoenix applications! Building robust, functional apps is great, but ensuring their security is paramount to protect your users and data.

In this lesson, we'll explore common web vulnerabilities and the best practices Phoenix offers to defend against them. A secure application builds trust and prevents costly breaches.

Cross-Site Scripting (XSS)

Cross-Site Scripting (XSS) is a common attack where malicious scripts are injected into trusted websites. When a user visits the compromised site, the malicious script executes in their browser, potentially stealing cookies, session tokens, or defacing content.

XSS attacks often occur when user-supplied data is rendered directly in a web page without proper sanitization or escaping.

Preventing XSS Attacks

Phoenix, through its templating engine EEx, automatically escapes HTML content by default. This means any user-provided string containing HTML tags like <script> will be rendered as plain text, not executable code.

However, be cautious when using Phoenix.HTML.raw/1 or <%= raw @content %> in templates, as this explicitly bypasses escaping. Only use it when you are absolutely sure the content is safe or has been sanitized by a trusted library.

Here's a simple example showing safe vs. unsafe rendering logic:

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 an attack that tricks a user's browser into sending an authenticated request to a web application without their knowledge. Imagine a logged-in user visiting a malicious site, which then subtly triggers a request to your banking site to transfer money.

The key here is that the request is initiated from an external site but uses the victim's active session on your application.

CSRF Protection in Phoenix

Phoenix has built-in CSRF protection via Plug.CSRFProtection. This plug ensures that all non-GET requests (like POST, PUT, DELETE) include a special token, which is then validated by the server.

The token is typically embedded in forms as a hidden field or included in AJAX request headers. If the token is missing or invalid, the request is rejected, preventing CSRF attacks.

  • Automatic: Phoenix projects include this by default.
  • Forms: Use <%= csrf_input_tag() %> in your forms.
  • APIs: Include the token in a custom header (e.g., X-CSRF-Token).

Secure Input Validation

Validating all user input is crucial, not just for data integrity, but for security. Malicious input can lead to various vulnerabilities:

  • SQL Injection: If input is used directly in database queries.
  • Command Injection: If input is passed to system commands.
  • Logic Flaws: If unexpected input breaks application logic.

Always validate input on the server-side, even if client-side validation is present. Phoenix applications often use Ecto Changesets for robust data validation before saving to the database.

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()

Managing Secure Sessions

Sessions are used to maintain state between requests for a specific user. In Phoenix, sessions are typically stored in encrypted, signed cookies. This ensures:

  • Confidentiality: The data cannot be read by an attacker.
  • Integrity: The data cannot be tampered with.

Best practices:

  • Use httpOnly cookies to prevent client-side script access.
  • Use secure cookies to ensure they are only sent over HTTPS.
  • Set a reasonable expiration time for sessions.
  • Rotate session keys regularly (Phoenix handles this).

These settings are configured in your endpoint.ex file.

Essential Security Headers

HTTP security headers provide an additional layer of defense by instructing browsers on how to behave when interacting with your site. Key headers include:

  • Content Security Policy (CSP): Prevents XSS and data injection attacks by restricting which resources (scripts, styles, etc.) a browser can load.
  • Strict-Transport-Security (HSTS): Forces browsers to interact with your site only over HTTPS, preventing downgrade attacks.
  • X-Frame-Options: Prevents clickjacking by controlling if your site can be embedded in an <iframe>.
  • X-Content-Type-Options: Prevents browsers from MIME-sniffing a response away from the declared Content-Type.

Phoenix allows you to configure these in your endpoint.ex file.

Dependency Security Scan

Your application relies on many third-party libraries (dependencies). These can introduce vulnerabilities if they are outdated or contain known flaws. It's crucial to:

  • Keep dependencies updated: Regularly run mix deps.update --all and review changes.
  • Scan for vulnerabilities: Use tools like mix audit (community project) to check your dependencies against known security advisories.
  • Review new dependencies: Before adding a new library, check its reputation, maintenance status, and any reported security issues.

A proactive approach to dependency management is vital for maintaining a secure application.

Security Best Practices Check

Which of the following is NOT a recommended security best practice for a Phoenix application?

Recap: Fortifying Phoenix

Congratulations! You've covered essential security best practices for Phoenix applications. We learned about common threats like XSS and CSRF, and how Phoenix's built-in features and careful coding can mitigate them.

  • XSS: Rely on EEx auto-escaping; use `raw/1` sparingly.
  • CSRF: Leverage `Plug.CSRFProtection`.
  • Validation: Use Ecto Changesets for robust server-side input validation.
  • Sessions: Ensure secure, encrypted, and signed session cookies.
  • Headers: Implement security headers like CSP and HSTS.
  • Dependencies: Keep them updated and scan for vulnerabilities.

By applying these practices, you can build more resilient and trustworthy Phoenix applications.

Preguntas frecuentes

¿La lección «Buenas prácticas de seguridad para Phoenix» es gratis?

Sí — el texto completo de «Buenas prácticas de seguridad para Phoenix» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Elixir & Phoenix: Scalable Backend Development, actualiza a CoddyKit PRO. El curso de Elixir & Phoenix: Scalable Backend Development incluye 4 lecciones en total.

¿Qué aprenderé en «Buenas prácticas de seguridad para Phoenix»?

Aprenda sobre vulnerabilidades de seguridad habituales e implemente buenas prácticas para proteger sus aplicaciones Phoenix. Practicas Elixir & Phoenix: Scalable Backend Development con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Elixir & Phoenix: Scalable Backend Development?

No se requiere experiencia previa. Elixir & Phoenix: Scalable Backend Development en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Buenas prácticas de seguridad para Phoenix»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Elixir & Phoenix: Scalable Backend Development?

Sí. Cada lección de Elixir & Phoenix: Scalable Backend Development incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Bibliotecas y herramientas populares de Elixir
  2. Buenas prácticas de seguridad para Phoenix
  3. Escritura de código mantenible en Elixir y Phoenix
  4. Documentación y análisis estático con Dialyzer
← Volver a Elixir & Phoenix: Scalable Backend Development