0Pricing
Elixir & Phoenix: Scalable Backend Development · Урок

Рекомендации по безопасности Phoenix

Изучите распространённые уязвимости и применяйте лучшие практики для защиты приложений Phoenix.

«Рекомендации по безопасности Phoenix» — бесплатный урок Elixir & Phoenix: Scalable Backend Development на CoddyKit. Это урок 2 из 4. Ты можешь прочитать весь урок бесплатно ниже — а потом практиковать его прямо в браузере с встроенным редактором кода и ИИ-репетитором 24/7. Это часть пути обучения Elixir & Phoenix: Scalable Backend Development, и твой прогресс синхронизируется между веб-версией и приложением CoddyKit. Курс Elixir & Phoenix: Scalable Backend Development содержит 4 уроков всего.

Части этого урока еще не переведены и отображаются на английском.

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.

Часто задаваемые вопросы

Урок «Рекомендации по безопасности Phoenix» бесплатный?

Да — полный текст урока «Рекомендации по безопасности Phoenix» бесплатно доступен здесь в веб-версии. Чтобы практиковать его интерактивно (встроенный редактор кода и ИИ-репетитор 24/7) и разблокировать остальной курс Elixir & Phoenix: Scalable Backend Development, подпишись на CoddyKit PRO. Курс Elixir & Phoenix: Scalable Backend Development содержит 4 уроков всего.

Чему я научусь в уроке «Рекомендации по безопасности Phoenix»?

Изучите распространённые уязвимости и применяйте лучшие практики для защиты приложений Phoenix. Ты практикуешь Elixir & Phoenix: Scalable Backend Development с помощью реального кода, который запускаешь прямо в браузере, и ИИ-репетитор 24/7 отвечает на твои вопросы во время урока.

Нужен ли мне опыт, чтобы начать Elixir & Phoenix: Scalable Backend Development?

Предыдущий опыт не требуется. Elixir & Phoenix: Scalable Backend Development на CoddyKit структурирован для всех уровней — от новичков до продвинутых, поэтому ты можешь начать отсюда или с самого начала и учиться в своем темпе. Это урок 2 из 4.

Сколько времени занимает урок «Рекомендации по безопасности Phoenix»?

Большинство уроков CoddyKit занимают около 5–10 минут. Каждый из них компактный и интерактивный, поэтому ты постоянно делаешь прогресс и продолжаешь с того же места в веб-версии и приложении.

Можно ли писать и запускать код в этом уроке Elixir & Phoenix: Scalable Backend Development?

Да. Каждый урок Elixir & Phoenix: Scalable Backend Development включает встроенный редактор кода, поэтому ты пишешь и запускаешь реальный код прямо в браузере и получаешь моментальную обратную связь от AI — локальная установка не требуется.

Все уроки этого курса

  1. Популярные библиотеки и инструменты Elixir
  2. Рекомендации по безопасности Phoenix
  3. Разработка удобных в сопровождении приложений Elixir и Phoenix
  4. Документирование и статический анализ с помощью Dialyzer
← Назад к Elixir & Phoenix: Scalable Backend Development