Cookie Django CSRF non impostato

Ho qualche problema da un po 'di tempo, sto riscontrando che il cookie CSRF non è impostato. Si prega di guardare i codici di seguito

Pitone

def deposit(request, account_num):
    if request.method == 'POST':
        account = get_object_or_404(account_info, acct_number=account_num)
        form_ = AccountForm(request.POST or None, instance=account)
        form = BalanceForm(request.POST)
        info = str(account_info.objects.filter(acct_number=account_num))
        inf = info.split()
        
        if form.is_valid():

            # cd=form.cleaned_data
            now = datetime.datetime.now()
            cmodel = form.save()
            cmodel.acct_number = account_num
            
            # RepresentsInt(cmodel.acct_number)
            cmodel.bal_change = "%0.2f" % float(cmodel.bal_change)
            cmodel.total_balance = "%0.2f" % (float(inf[1]) + float(cmodel.bal_change))
            account.balance = "%0.2f" % float(cmodel.total_balance)
            cmodel.total_balance = "%0.2f" % float(cmodel.total_balance)
            
            # cmodel.bal_change=cmodel.bal_change
            cmodel.issued = now.strftime("%m/%d/%y %I:%M:%S %p")
            account.recent_change = cmodel.issued
            cmodel.save()
            account.save()
            
            return HttpResponseRedirect("/history/" + account_num + "/")
        
        else:
            return render_to_response('history.html',
                                      {'account_form': form},
                                      context_instance=RequestContext(request))

Nell'HTML ecco il codice

HTML

<form action="/deposit/{{ account_num }}/" method="post">
    <table>
        <tr>
            {{ account_form.bal_change }}
            &nbsp;
            <input type="submit" value="Deposit"/>
        </tr>
        {% csrf_token %}
    </table>
</form>

Sono bloccato, ho già cancellato il cookie, utilizzato un altro browser ma il cookie csrf non è ancora impostato.

Ciò può verificarsi anche se CSRF_COOKIE_SECURE = Trueè impostato e si accede al sito in modo non sicuro o se CSRF_COOKIE_HTTPONLY = Trueè impostato come indicato qui e qui

from django.http import HttpResponse
from django.views.decorators.csrf import csrf_exempt

@csrf_exempt 
def your_view(request):
    if request.method == "POST":
        # do something
    return HttpResponse("Your response")

Se stai utilizzando l' API Fetch HTML5 per effettuare richieste POST come utente registrato e ottenere Forbidden (CSRF cookie not set.), potrebbe essere perché per impostazione predefinita fetchnon include i cookie di sessione, facendo pensare a Django che sei un utente diverso da quello che ha caricato la pagina .

Puoi includere il token di sessione passando l'opzione credentials: 'include'per recuperare:

var csrftoken = getCookie('csrftoken');
var headers = new Headers();
headers.append('X-CSRFToken', csrftoken);
fetch('/api/upload', {
    method: 'POST',
    body: payload,
    headers: headers,
    credentials: 'include'
})

Da questo Puoi risolverlo aggiungendo il decoratore sure_csrf_cookie alla tua vista

from django.views.decorators.csrf import ensure_csrf_cookie
@ensure_csrf_cookie
def yourView(request):
 #...

se questo metodo non funziona. proverai a commentare csrf nel middleware. e prova di nuovo.

Mi sono imbattuto in una situazione simile mentre lavoravo con DRF, la soluzione era l'aggiunta del metodo .as_view () alla vista in urls.py

Se stai usando DRF, controlla se i tuoi schemi URL sono corretti, forse ti sei dimenticato .as_view():

Quindi come appariva il mio codice:

urlpatterns += path('resource', ResourceView) 

Ed è così che dovrebbe essere:

urlpatterns += path('resource', ResourceView.as_view())

prova a controllare se hai installato nel settings.py

 MIDDLEWARE_CLASSES = (
'django.middleware.common.CommonMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',)

Nel modello i dati sono formattati con csrf_token:

<form>{% csrf_token %}
</form>

Questo problema è sorto di nuovo di recente a causa di un bug in Python stesso.

http://bugs.python.org/issue22931

https://code.djangoproject.com/ticket/24280

Tra le versioni interessate c'erano la 2.7.8 e la 2.7.9. Il cookie non veniva letto correttamente se uno dei valori conteneva un [carattere.

L'aggiornamento di Python (2.7.10) risolve il problema.

Ciò si verifica anche quando non si imposta l'azione del modulo.
Per me, mostrava questo errore quando il codice era:

<form class="navbar-form form-inline my-2 my-lg-0" role="search" method="post">

Quando ho corretto il mio codice in questo:

<form class="navbar-form form-inline my-2 my-lg-0" action="{% url 'someurl' %}" role="search" method="post">

il mio errore è scomparso.

Il problema sembra che tu non stia gestendo le GETrichieste in modo appropriato o pubblicando direttamente i dati senza prima ottenere il modulo.

Quando accedi per la prima volta alla pagina, il client invierà la GETrichiesta, in tal caso dovresti inviare html con l'apposito modulo.

Successivamente, l'utente compila il modulo e invia la POSTrichiesta con i dati del modulo.

La tua vista dovrebbe essere:

def deposit(request,account_num):
   if request.method == 'POST':
      form_=AccountForm(request.POST or None, instance=account)
      if form.is_valid(): 
          #handle form data
          return HttpResponseRedirect("/history/" + account_num + "/")
      else:
         #handle when form not valid
    else:
       #handle when request is GET (or not POST)
       form_=AccountForm(instance=account)

    return render_to_response('history.html',
                          {'account_form': form},
                          context_instance=RequestContext(request))

Verifica che i cookie di Chrome siano impostati con l'opzione predefinita per i siti Web. Consenti l'impostazione dei dati locali (consigliato).

Metodo 1:

from django.shortcuts import render_to_response
return render_to_response(
    'history.html',
    RequestContext(request, {
        'account_form': form,
    })

Metodo 2:

from django.shortcuts import render
return render(request, 'history.html', {
    'account_form': form,
})

Perché il metodo render_to_response può causare qualche problema con i cookie di risposta.

Mi sono appena incontrato una volta, la soluzione è svuotare i biscotti. E può essere modificato durante il debug relativo a SECRET_KEY.

La cancellazione della cache del browser ha risolto questo problema per me. Stavo passando da un ambiente di sviluppo locale a un altro per fare il tutorial django-blog-zinnia dopo aver lavorato su un altro progetto quando è successo. All'inizio, pensavo che la causa fosse la modifica dell'ordine di INSTALLED_APPS in modo che corrispondesse al tutorial, ma li ho reimpostati e non sono stato in grado di correggerlo fino a quando non ho svuotato la cache.

Prima stavo usando Django 1.10, quindi stavo affrontando questo problema. Ora l'ho declassato a Django 1.9 e funziona bene.

Ho avuto lo stesso errore, nel mio caso l'aggiunta di method_decorator aiuta:

from django.views.decorators.csrf import csrf_protect
from django.utils.decorators import method_decorator

method_decorator(csrf_protect)
def post(self, request):
    ...

Assicurati che il backend della tua sessione django sia configurato correttamente in settings.py. Allora prova questo,

class CustomMiddleware(object):
  def process_request(self,request:HttpRequest):
      get_token(request)

Aggiungi questo middleware settings.pysotto MIDDLEWARE_CLASSESo in MIDDLEWAREbase alla versione di django

get_token - Restituisce il token CSRF richiesto per un modulo POST. Il token è un valore alfanumerico. Se non è già impostato, viene creato un nuovo token.

Secondo te stai usando il decoratore csrf ??

from django.views.decorators.csrf import csrf_protect

@csrf_protect def view(request, params): ....