Den gyllene regeln för säkerhet i webbapplikationer är att aldrig lita på data från källor som inte är betrodda. Ibland kan det vara användbart att skicka data genom ett icke betrott medium. Kryptografiskt signerade värden kan skickas genom en icke betrodd kanal i trygg förvissning om att eventuell manipulering kommer att upptäckas.
\nDjango tillhandahåller både ett API på låg nivå för att signera värden och ett API på hög nivå för att ställa in och läsa signerade cookies, en av de vanligaste användningarna av signering i webbapplikationer.
\nDu kanske också tycker att det är bra att skriva under för följande:
\nGenerering av URL:er för ”återställ mitt konto” som skickas till användare som har förlorat sitt lösenord.
Säkerställa att data som lagras i dolda formulärfält inte har manipulerats.
Generera hemliga URL:er för engångsbruk för att ge tillfällig tillgång till en skyddad resurs, t.ex. en nedladdningsbar fil som en användare har betalat för.
SECRET_KEY och SECRET_KEY_FALLBACKSLink to this heading#När du skapar ett nytt Django-projekt med startproject, genereras filen settings.py automatiskt och får ett slumpmässigt SECRET_KEY-värde. Detta värde är nyckeln till att säkra signerade data - det är viktigt att du håller det säkert, annars kan angripare använda det för att generera sina egna signerade värden.
SECRET_KEY_FALLBACKS kan användas för att rotera hemliga nycklar. Värdena kommer inte att användas för att signera data, men om de anges kommer de att användas för att validera signerade data och måste hållas säkra.
Djangos signeringsmetoder finns i modulen django.core.signing. För att signera ett värde, instansiera först en Signer instans:
>>> from django.core.signing import Signer\n>>> signer = Signer()\n>>> value = signer.sign("My string")\n>>> value\n'My string:v9G-nxfz3iQGTXrePqYPlGvH79WTcIgj1QIQSUODTW0'\nSignaturen läggs till i slutet av strängen, efter kolon. Du kan hämta originalvärdet med hjälp av metoden unsign:
>>> original = signer.unsign(value)\n>>> original\n'My string'\nOm du skickar ett värde som inte är en sträng till sign, kommer värdet att tvingas till sträng innan det signeras, och unsign-resultatet kommer att ge dig strängvärdet:
>>> signed = signer.sign(2.5)\n>>> original = signer.unsign(signed)\n>>> original\n'2.5'\nOm du vill skydda en lista, tupel eller dictionary kan du göra det med hjälp av metoderna sign_object() och unsign_object():
>>> signed_obj = signer.sign_object({"message": "Hello!"})\n>>> signed_obj\n'eyJtZXNzYWdlIjoiSGVsbG8hIn0:bzb48DBkB-bwLaCnUVB75r5VAPUEpzWJPrTb80JMIXM'\n>>> obj = signer.unsign_object(signed_obj)\n>>> obj\n{'message': 'Hello!'}\nSe Skydd av komplexa datastrukturer för mer information.
\nOm signaturen eller värdet har ändrats på något sätt, kommer ett django.core.signing.BadSignature undantag att uppstå:
>>> from django.core import signing\n>>> value += "m"\n>>> try:\n... original = signer.unsign(value)\n... except signing.BadSignature:\n... print("Tampering detected!")\n...\nSom standard använder klassen Signer inställningen SECRET_KEY för att generera signaturer. Du kan använda en annan hemlighet genom att skicka den till konstruktören för Signer:
>>> signer = Signer(key="my-other-secret")\n>>> value = signer.sign("My string")\n>>> value\n'My string:o3DrrsT6JRB73t-HDymfDNbTSxfMlom2d8TiUlb1hWY'\nReturns a signer which uses key to generate signatures and sep to\nseparate values. sep cannot be in the URL safe base64 alphabet. This alphabet contains alphanumeric characters, hyphens,\nand underscores. algorithm must be an algorithm supported by\nhashlib, it defaults to 'sha256'. fallback_keys is a list\nof additional values used to validate signed data, defaults to\nSECRET_KEY_FALLBACKS.
saltLink to this heading#Om du inte vill att alla förekomster av en viss sträng ska ha samma signaturhash kan du använda det valfria argumentet salt till klassen Signer. Om du använder ett salt kommer den signerande hashfunktionen att seedas med både saltet och din SECRET_KEY:
>>> signer = Signer()\n>>> signer.sign("My string")\n'My string:v9G-nxfz3iQGTXrePqYPlGvH79WTcIgj1QIQSUODTW0'\n>>> signer.sign_object({"message": "Hello!"})\n'eyJtZXNzYWdlIjoiSGVsbG8hIn0:bzb48DBkB-bwLaCnUVB75r5VAPUEpzWJPrTb80JMIXM'\n>>> signer = Signer(salt="extra")\n>>> signer.sign("My string")\n'My string:YMD-FR6rof3heDkFRffdmG4pXbAZSOtb-aQxg3vmmfc'\n>>> signer.unsign("My string:YMD-FR6rof3heDkFRffdmG4pXbAZSOtb-aQxg3vmmfc")\n'My string'\n>>> signer.sign_object({"message": "Hello!"})\n'eyJtZXNzYWdlIjoiSGVsbG8hIn0:-UWSLCE-oUAHzhkHviYz3SOZYBjFKllEOyVZNuUtM-I'\n>>> signer.unsign_object(\n... "eyJtZXNzYWdlIjoiSGVsbG8hIn0:-UWSLCE-oUAHzhkHviYz3SOZYBjFKllEOyVZNuUtM-I"\n... )\n{'message': 'Hello!'}\nUsing salt in this way puts the different signatures into different\nnamespaces. A signature that comes from one namespace (a particular salt\nvalue) cannot be used to validate the same plaintext string in a different\nnamespace that is using a different salt setting. The result is to prevent an\nattacker from using a signed string generated in one place in the code as input\nto another piece of code that is generating (and verifying) signatures using a\ndifferent salt.
\nTill skillnad från din SECRET_KEY behöver ditt saltargument inte vara hemligt.
TimestampSigner är en subklass av Signer som lägger till en signerad tidsstämpel till värdet. Detta gör att du kan bekräfta att ett signerat värde skapades inom en viss tidsperiod:
>>> from datetime import timedelta\n>>> from django.core.signing import TimestampSigner\n>>> signer = TimestampSigner()\n>>> value = signer.sign("hello")\n>>> value\n'hello:1stLqR:_rvr4oXCgT4HyfwjXaU39QvTnuNuUthFRCzNOy4Hqt0'\n>>> signer.unsign(value)\n'hello'\n>>> signer.unsign(value, max_age=10)\nSignatureExpired: Signature age 15.5289158821 > 10 seconds\n>>> signer.unsign(value, max_age=20)\n'hello'\n>>> signer.unsign(value, max_age=timedelta(seconds=20))\n'hello'\nSkriv värde och lägg till aktuell tidsstämpel till det.
Checks if value was signed less than max_age seconds ago,\notherwise raises SignatureExpired. The max_age parameter can\naccept an integer or a datetime.timedelta object.
Koda, eventuellt komprimera, lägga till aktuell tidsstämpel och signera komplex datastruktur (t.ex. lista, tupel eller ordbok).
\nChecks if signed_obj was signed less than max_age seconds ago,\notherwise raises SignatureExpired. The max_age parameter can\naccept an integer or a datetime.timedelta object.
Om du vill skydda en lista, tupel eller dictionary kan du göra det med hjälp av metoderna Signer.sign_object() och unsign_object(), eller signeringsmodulens dumps() eller loads() funktioner (som är förkortningar för TimestampSigner(salt='django.core.signing').sign_object()/unsign_object()). Dessa använder JSON-serialisering under huven. JSON säkerställer att även om din SECRET_KEY blir stulen kommer en angripare inte att kunna utföra godtyckliga kommandon genom att utnyttja pickle-formatet:
>>> from django.core import signing\n>>> signer = signing.TimestampSigner()\n>>> value = signer.sign_object({"foo": "bar"})\n>>> value\n'eyJmb28iOiJiYXIifQ:1stLrZ:_QiOBHafwucBF9FyAr54qEs84ZO1UdsO1XiTJCvvdno'\n>>> signer.unsign_object(value)\n{'foo': 'bar'}\n>>> value = signing.dumps({"foo": "bar"})\n>>> value\n'eyJmb28iOiJiYXIifQ:1stLsC:JItq2ZVjmAK6ivrWI-v1Gk1QVf2hOF52oaEqhZHca7I'\n>>> signing.loads(value)\n{'foo': 'bar'}\nPå grund av JSON:s natur (det finns ingen inbyggd skillnad mellan listor och tupler) kommer du att få en lista från signing.loads(object) om du skickar in en tupel:
>>> from django.core import signing\n>>> value = signing.dumps(("a", "b", "c"))\n>>> signing.loads(value)\n['a', 'b', 'c']\nReturnerar URL-säker, signerad base64-komprimerad JSON-sträng. Det serialiserade objektet signeras med hjälp av TimestampSigner.
Motsatsen till dumps(), ger BadSignature om signaturen misslyckas. Kontrollerar max_age (i sekunder) om den är angiven.