---
title: "Conas cosaint CSRF Django a úsáid"
version: 6.1
locale: ga
source: https://docs.djangoproject.com/ga/6.1/howto/csrf/
canonical: https://djangodocs.dev/ga/6.1/howto/csrf/
---
# Conas cosaint CSRF Django a úsáid

Chun leas a bhaint as cosaint CSRF i do thuairimí, lean na céimeanna seo:

1. The CSRF middleware is activated by default in the [`MIDDLEWARE`](/ga/6.1/ref/settings/#std-setting-MIDDLEWARE)
   setting. If you override that setting, remember that
   `'django.middleware.csrf.CsrfViewMiddleware'` should come before any view
   middleware that assumes that CSRF attacks have been dealt with.

   Má dhíchumasaigh tú é, nach moltar, is féidir leat: func: ~django.views.decorators.csrf.csrf\_protect a úsáid ar thuairimí áirithe ar mhaith leat a chosaint (féach thíos).
2. In aon teimpléad a úsáideann foirm POST, bain úsáid as an clibe:ttag: csrf\_token taobh istigh den eilimint má tá an fhoirm le haghaidh URL inmheánach, \<form\>m.sh.:

   ```html+django
   <form method="post">{% csrf_token %}
   ```

   Níor cheart é seo a dhéanamh le haghaidh foirmeacha POST a dhíríonn ar URLanna seachtracha, mar go mbeadh sé sin ina chúis le sceitheadh ​​an chomhartha CSRF, rud a d’fhágfadh go mbeadh leochaileacht ann.
3. Sna feidhmeanna amharc comhfhreagracha, cinntigh go n-úsáidtear: class: ~django.template.requestContext chun an freagra a thabhairt ionas go n-oibreoidh ```{% csrf_token%} `i gceart. Má tá tú ag úsáid an fheidhme:func: `~django.shortcuts.render`, tuairimí cineálacha, nó aipeanna contrib, tá tú clúdaithe cheana ós rud é go n-úsáideann siad seo go léir ``RequestContext```.

## Cosaint CSRF a úsáid le AJAX

Cé gur féidir an modh thuas a úsáid le haghaidh iarratais AJAX POST, tá roinnt míchompordach aige: caithfidh tú cuimhneamh an comhartha CSRF a chur isteach mar shonraí POST le gach iarratas POST. Ar an gcúis seo, tá modh malartach ann: ar gach XMLHttpRequest, socraigh ceannteideal saincheaptha X-CSRFToken\` (mar a shonraítear leis an socrú:setting: CSRF\_HEADER\_NAME) le luach an chomhartha CSRF. Is minic a bhíonn sé seo níos éasca toisc go soláthraíonn go leor creataí JavaScript crúcaí a cheadaíonn ceanntásca a shocrú ar gach iarratas.

Ar dtús, ní mór duit an comhartha CSRF a fháil. Braitheann conas é sin a dhéanamh ar an bhfuil na socruithe: 'CSRF\_USE\_SESSIONS\` agus:setting: CSRF\_COOKIE\_HTTPONLY cumasaithe nó nach bhfuil.

### An comhartha a fháil má tá: socrú: CSRF\_USE\_SESSIONS agus:setting: CSRF\_COOKIE\_HTTPONLY `False`

Is é an fhoinse molta don chomhartha an fianán csrftoken\`, a shocrófar má chuir tú cosaint CSRF ar chumas do do thuairimí mar a leagtar amach thuas.

Ainmnítear “csrftoken\`\` ar an bhfianán comhartha CSRF de réir réamhshocraithe, ach is féidir leat ainm na fianán a rialú tríd an socrú:setting: CSRF\_COOKIE\_NAME.

Is féidir leat an comhartha a fháil mar seo:

```javascript
function getCookie(name) {
    let cookieValue = null;
    if (document.cookie && document.cookie !== '') {
        const cookies = document.cookie.split(';');
        for (let i = 0; i < cookies.length; i++) {
            const cookie = cookies[i].trim();
            // Does this cookie string begin with the name we want?
            if (cookie.substring(0, name.length + 1) === (name + '=')) {
                cookieValue = decodeURIComponent(cookie.substring(name.length + 1));
                break;
            }
        }
    }
    return cookieValue;
}
const csrftoken = getCookie('csrftoken');
```

D'fhéadfaí an cód thuas a shimpliú trí úsáid a bhaint as an leabharlann [JavaScript Cookie](https://github.com/js-cookie/js-cookie/) chun `getCookie` a chur in ionad:

```javascript
const csrftoken = Cookies.get('csrftoken');
```

> **Note**
>
> Tá an comhartha CSRF i láthair sa DOM i bhfoirm masctha freisin, ach amháin má chuirtear san áireamh go sainráite ag baint úsáidea:ttag: csrf\_token i dteimpléad. Tá an comhartha canónach, neamhchumtha sa fhianán. Glacfaidh an: Class: ~django.middleware.csrf.csrfViewMiddleware ceachtar acu. Mar sin féin, d'fhonn cosaint a dhéanamh ar ionsaithe [BREACH](https://www.breachattack.com/), moltar comhartha masctha a úsáid.

> **Warning**
>
> Mura bhfuil teimpléad á rindreáil ag d'amharc ina bhfuil an clib teimpléad:ttag: csrf\_token, b'fhéidir nach socraíonn Django an fianán comhartha CSRF. Tá sé seo coitianta i gcásanna ina gcuirtear foirmeacha go dinimiciúil leis an leathanach. Chun aghaidh a thabhairt ar an gcás seo, soláthraíonn Django maisitheoir amharc a chuireann iallach ar an bhfianán a shocrú: :func: ~django.views.decorators.csrf.ensure\_csrf\_cookie.

### An comhartha a fháil más:socrú: CSRF\_USE\_SESSIONS nó:setting: CSRF\_COOKIE\_HTTPONLY `True`

Má ghníomhachtaí:setting: CSRF\_USE\_SESSIONS nó:setting: CSRF\_COOKIE\_HTTPONLY, ní mór duit an comhartha CSRF a áireamh i do HTML agus an comhartha ón DOM a léamh le JavaScript:

```html+django
{% csrf_token %}
<script>
const csrftoken = document.querySelector('[name=csrfmiddlewaretoken]').value;
</script>
```

### An comhartha a shocrú ar an iarratas AJAX

Faoi dheireadh, beidh ort an ceanntásc a shocrú ar d'iarratas AJAX. Ag baint úsáide as an API fetch () \_:

```javascript
const request = new Request(
    /* URL */,
    {
        method: 'POST',
        headers: {'X-CSRFToken': csrftoken},
        mode: 'same-origin' // Do not send CSRF token to another domain.
    }
);
fetch(request).then(function(response) {
    // ...
});
```

## Cosaint CSRF a úsáid i dteimpléid Jinja2

Django's:class: ~django.template.backends.jinja2.jinja2 cuireann cúltaca teimpléad `{{csrf_input}}` le comhthéacs na teimpléid go léir atá comhionann le `{% csrf_token%}` sa teanga teimpléid Django. Mar shampla:

```html+jinja
<form method="post">{{ csrf_input }}
```

## An modh maisitheora a úsáid

Seachas csrfViewMiddleware\` a chur leis mar chosaint blaincéid, is féidir leat an maisitheoir: func: ~django.views.decorators.csrf.csrf\_protect a úsáid, a bhfuil an fheidhmiúlacht chéanna díreach aige, ar thuairimí áirithe a dteastaíonn an cosaint uathu. Caithfear é a úsáid\*\*an bheath\*\* ar thuairimí a chuireann an comhartha CSRF isteach san aschur, agus ar na tuairimí a ghlacann leis na sonraí foirme POST. (Is minic gurb iad seo an fheidhm radharc céanna, ach ní i gcónaí).

Ní mholtar an maisitheoir a úsáid leis féin , ós rud é má dhéanann tú dearmad é a úsáid, beidh poll slándála agat. Tá an straitéis 'crios agus brísea' chun an dá cheann a úsáid go breá, agus beidh lasbhreas íosta ann.

## Iarrataí a dhiúltaithe

De réir réamhshocraithe, seoltar freagra '403 Forbidden' chuig an úsáideoir má theipeann ar iarratas isteach ar na seiceálacha a dhéanann CSRFViewMiddleware\`. Níor cheart é seo a fheiceáil de ghnáth ach nuair a bhíonn fíorbhóideacht Iarratas Tras-Láithreáin ann, nó nuair nach bhfuil an comhartha CSRF san áireamh le foirm POST mar gheall ar earráid cláraithe.

Níl an leathanach earráide an-chairdiúil, áfach, mar sin b'fhéidir gur mhaith leat do dhearcadh féin a sholáthar chun an riocht seo a láimhseáil. Chun seo a dhéanamh, socraigh an socrú: setting: CSRF\_FAILURE\_VIEW.

\<django-security-logger\>Déantar teipeanna CSRF a logáil mar rabhaidh don logger: ref: django.security.csrf .

## Cosaint CSRF a úsáid le caching

Má úsáideann teimpléad an chlib teimpléad:ttag: csrf\_token (nó tugtar bealach eile ar an bhfeidhm `get_token`), cuirfidh CSRFViewMiddleware\` fianán agus ceannteideal `Vary: Cookie` leis an bhfreagra. Ciallaíonn sé seo go n-imrífidh an middleware go maith leis an middleware taisce má úsáidtear é mar a threoraítear (téann UpdateCacheMiddleware\` roimh gach meán-earraí eile).

Mar sin féin, má úsáideann tú maisitheoirí taisce ar thuairimí aonair, ní bheidh an middleware CSRF in ann an ceannteideal Vary nó an fianán CSRF a shocrú fós, agus cuirfear an freagra a chosc gan ceachtar ceann amháin. Sa chás seo, ar aon tuairimí a éilíonn comhartha CSRF a chur isteach ba chóir duit an maisitheoir: func: django.views.decorators.csrf.csrf\_protect a úsáid ar dtús:

```
from django.views.decorators.cache import cache_page
from django.views.decorators.csrf import csrf_protect

@cache_page(60 * 15)
@csrf_protect
def my_view(request): ...
```

\<decorating-class-based-views\>Má tá tuairimí bunaithe ar rang-bhunaithe á úsáid agat, is féidir leat tagairt a thabhairt do:ref: Tuairimí rangbhunaithe a mhaisiú .

## Tástáil agus cosaint CSRF

De ghnáth beidh an CSRFViewMiddleware 'ina bhac mór ar fheidhmeanna radhairc a thástáil, mar gheall ar an ngá atá leis an gcomhartha CSRF nach mór a sheoladh le gach iarratas POST. Ar an gcúis seo, modhnaíodh cliant HTTP Django le haghaidh tástálacha chun bratach a shocrú ar iarratais a mhaolann an middleware agus an maisitheoir csrf\_protect\` ionas nach dhiúltaíonn siad iarratais a thuilleadh. I ngach leith eile (m.sh. fianáin a sheoladh srl.), iompraíonn siad mar an gcéanna.

Más mian leat, ar chúis éigin, \* an cliant tástála seiceálacha CSRF a dhéanamh, is féidir leat sampla den chliant tástála a chruthú a fhorfheidhmíonn seiceálacha CSRF:

```pycon
>>> from django.test import Client
>>> csrf_client = Client(enforce_csrf_checks=True)
```

## Cásanna imeall

Is féidir go mbeadh riachtanais neamhghnácha ag tuairimí áirithe a chiallaíonn nach n-oireann siad don ghnáthphatrún Is féidir le roinnt fóntais a bheith úsáideach sna cásanna seo. Déantar cur síos ar na cásanna a d'fhéadfadh a bheith ag teastáil iontu sa chuid seo a leanas.

### Cosaint CSRF a dhíchumasú le haghaidh ach cúpla tuairim

Éilíonn cosaint CSRF ar an gcuid is mó de na tuairimí, ach níl cúpla ceann acu.

Réiteach: seachas an middleware a dhíchumasú agus csrf\_protect\` a chur i bhfeidhm ar na tuairimí go léir a theastaíonn uathu, cumasaigh an middleware agus úsáide:func: ~django.views.decorators.csrf.csrf\_exempt.

### An comhartha a shocrú nuair nach n-úsáidtear CSRFViewMiddleware.process\_view () \`\`

Tá cásanna ann nuair nach raibh CSRFViewMiddleware.process\_view\` rith sula ndéantar do radharc a reáchtáil - 404 agus 500 láimhseálaí, mar shampla - ach teastaíonn an comhartha CSRF uait fós i bhfoirm.

Réiteach: úsáid: func: ~django.views.decorators.csrf.requires\_csrf\_token

### An comhartha CSRF san áireamh i radharc gan chosaint

D'fhéadfadh go mbeadh roinnt tuairimí ann nach bhfuil gan chosaint agus a bhfuil díolmhaithe orthu ag csrf\_exempt\`, ach ní mór an comhartha CSRF a áireamh fós.

Réiteach: úsáid: func: ~django.views.decorators.csrf.csrf\_exempt ina dhiaidh sin: func: ~django.views.decorators.csrf.requires\_csrf\_token. (ie, ba chóir go mbeadh requires\_csrf\_token\` an maisitheoir is istigh).

### Radharc a chosaint le haghaidh cosán amháin amháin

Teastaíonn cosaint CSRF ó dhearcadh faoi shraith amháin coinníollacha amháin, agus níor cheart dó é a bheith aige don chuid eile den am.

Réiteach: úsáid: func: ~django.views.decorators.csrf.csrf\_exempt don fheidhm amharc iomlán, agus:func: ~django.views.decorators.csrf.csrf\_protect don chosán laistigh de dhíth a chosaint air. Sampla:

```
from django.views.decorators.csrf import csrf_exempt, csrf_protect

@csrf_exempt
def my_view(request):
    @csrf_protect
    def protected_path(request):
        do_something()

    if some_condition():
        return protected_path(request)
    else:
        do_something_else()
```

### Leathanach a chosaint a úsáideann AJAX gan foirm HTML

Déanann leathanach iarratas POST trí AJAX, agus níl foirm HTML ag an leathanach le a:ttag: csrf\_token a chuirfeadh an fianán CSRF riachtanach a sheoladh.

Réiteach: úsáid: func: ~django.views.decorators.csrf.ensure\_csrf\_cookie ar an radharc a sheolann an leathanach.

## Cosaint CSRF in iarratais in-athúsáidte

Toisc go bhfuil sé indéanta don fhorbróir an CSRFViewMiddleware a mhúchadh, úsáideann gach tuairim ábhartha in aipeanna contrib an maisitheoir csrf\_protect\` chun slándáil na bhfeidhmchlár seo i gcoinne CSRF a chinntiú. Moltar go n-úsáideann forbróirí aipeanna in-athúsáidte eile a dteastaíonn na ráthaíochtaí céanna uathu an maisitheoir csrf\_protect\` ar a dtuairimí.