CORS-i demüstifitseerimine: põhjalik juhend päritoluülese ressursside jagamise kohta

Tänapäeva ühendatud veebis peavad rakendused sageli pääsema juurde ressurssidele erinevatest päritoludest. Siin tulebki mängu päritoluülene ressursside jagamine (CORS). CORS on oluline turvamehhanism, mis reguleerib, kuidas veebibrauserid käsitlevad päringuid ühest päritolust (domeen, protokoll ja port) teise päritolusse. CORS-i mõistmine on iga veebiarendaja jaoks hädavajalik turvaliste ja funktsionaalsete veebirakenduste loomiseks.

Mis on sama päritolu poliitika?

Enne CORS-i süvenemist on oluline mõista sama päritolu poliitikat (SOP). SOP on veebibrauserites rakendatav fundamentaalne turvamehhanism. Selle eesmärk on takistada ühel veebisaidil olevatel pahatahtlikel skriptidel juurdepääsu teise veebisaidi tundlikele andmetele. Päritolu on määratletud protokolli (nt HTTP või HTTPS), domeeni (nt example.com) ja pordi numbri (nt 80 või 443) kombinatsiooniga. Kahte URL-i peetakse sama päritoluga, kui neil on sama protokoll, domeen ja port.

Näide:

• http://example.com/app1 ja http://example.com/app2 - Sama päritolu (sama protokoll, domeen ja port)
• https://example.com/app1 ja http://example.com/app1 - Erinev päritolu (erinev protokoll)
• http://example.com:8080/app1 ja http://example.com/app1 - Erinev päritolu (erinev port)
• http://sub.example.com/app1 ja http://example.com/app1 - Erinev päritolu (erinev alamdomeen – loetakse erinevaks domeeniks)

SOP piirab skriptide juurdepääsu erineva päritoluga ressurssidele, välja arvatud juhul, kui selle lubamiseks on kehtestatud spetsiifilised meetmed, näiteks CORS.

Miks on CORS vajalik?

Kuigi sama päritolu poliitika on turvalisuse seisukohalt ülioluline, võib see olla ka piirav. Paljud kaasaegsed veebirakendused tuginevad andmete hankimisele erinevatest serveritest, näiteks API-dest või sisuedastusvõrkudest (CDN). CORS pakub kontrollitud viisi SOP leevendamiseks ja seaduslike päritoluüleste päringute lubamiseks, säilitades samal ajal turvalisuse.

Kujutage ette stsenaariumi, kus veebirakendus, mis asub aadressil http://example.com, peab hankima andmeid API serverist, mis asub aadressil http://api.example.net. Ilma CORS-ita blokeeriks brauser selle päringu SOP tõttu. CORS võimaldab API serveril selgesõnaliselt määrata, millised päritolud on lubatud selle ressurssidele juurde pääsema, võimaldades veebirakendusel korrektselt toimida.

Kuidas CORS töötab: põhitõed

CORS töötab läbi rea HTTP päiste, mida vahetatakse kliendi (brauseri) ja serveri vahel. Server kasutab neid päiseid, et teavitada brauserit, kas tal on lubatud taotletud ressursile juurde pääseda. Peamine kaasatud HTTP päis on Access-Control-Allow-Origin.

Stsenaarium 1: Lihtne päring

„Lihtne päring” on GET, HEAD või POST päring, mis vastab teatud kriteeriumidele (nt Content-Type päis on üks järgmistest: application/x-www-form-urlencoded, multipart/form-data või text/plain). Sel juhul saadab brauser päringu otse serverile ja server vastab Access-Control-Allow-Origin päisega.

Kliendi päring (saidilt http://example.com):

            GET /data HTTP/1.1
Host: api.example.net
Origin: http://example.com
            

              
                Copy
              
            
          

Serveri vastus (saidilt http://api.example.net):

            HTTP/1.1 200 OK
Access-Control-Allow-Origin: http://example.com
Content-Type: application/json

{
  "data": "Mõned andmed serverist"
}
            

              
                Copy
              
            
          

Selles näites vastab server päisega Access-Control-Allow-Origin: http://example.com, mis näitab, et päringud saidilt http://example.com on lubatud. Kui päringu päritolu ei vasta Access-Control-Allow-Origin päise väärtusele (või kui päis puudub), blokeerib brauser vastuse ja takistab kliendipoolsel skriptil andmetele juurdepääsu.

Stsenaarium 2: Eelkontrolli päring (keerukamate päringute jaoks)

Keerukamate päringute puhul, näiteks need, mis kasutavad HTTP meetodeid nagu PUT, DELETE, või need, millel on kohandatud päised, teostab brauser „eelkontrolli” päringu, kasutades HTTP OPTIONS meetodit. See eelkontrolli päring küsib serverilt luba enne tegeliku päringu saatmist. Server vastab päistega, mis määravad, millised meetodid, päised ja päritolud on lubatud.

Kliendi eelkontrolli päring (saidilt http://example.com):

            OPTIONS /data HTTP/1.1
Host: api.example.net
Origin: http://example.com
Access-Control-Request-Method: PUT
Access-Control-Request-Headers: X-Custom-Header
            

              
                Copy
              
            
          

Serveri vastus (saidilt http://api.example.net):

            HTTP/1.1 200 OK
Access-Control-Allow-Origin: http://example.com
Access-Control-Allow-Methods: GET, PUT, DELETE
Access-Control-Allow-Headers: X-Custom-Header, Content-Type
Access-Control-Max-Age: 3600
            

              
                Copy
              
            
          

Päiste selgitus:

• Access-Control-Allow-Origin: http://example.com - Näitab, et päringud saidilt http://example.com on lubatud.
• Access-Control-Allow-Methods: GET, PUT, DELETE - Määrab päritoluüleste päringute jaoks lubatud HTTP meetodid.
• Access-Control-Allow-Headers: X-Custom-Header, Content-Type - Loetleb tegelikus päringus lubatud kohandatud päised.
• Access-Control-Max-Age: 3600 - Määrab aja (sekundites), mille jooksul brauser saab eelkontrolli vastust vahemällu salvestada. See aitab vähendada eelkontrolli päringute arvu.

Kui serveri eelkontrolli vastus näitab, et päring on lubatud, jätkab brauser tegeliku päringu saatmisega. Vastasel juhul blokeerib brauser päringu.

Kliendi tegelik päring (saidilt http://example.com):

            PUT /data HTTP/1.1
Host: api.example.net
Origin: http://example.com
X-Custom-Header: some-value
Content-Type: application/json

{
  "data": "Mõned uuendatavad andmed"
}
            

              
                Copy
              
            
          

Serveri vastus (saidilt http://api.example.net):

            HTTP/1.1 200 OK
Access-Control-Allow-Origin: http://example.com
Content-Type: application/json

{
  "status": "Andmed on edukalt uuendatud"
}
            

              
                Copy
              
            
          

Levinud CORS-i päised

Siin on ülevaade peamistest CORS-i päistest, mida peate mõistma:

• Access-Control-Allow-Origin: See on kõige fundamentaalsem päis. See määrab päritolu(d), millel on lubatud ressursile juurde pääseda. Võimalikud väärtused on:
  • Spetsiifiline päritolu (nt http://example.com).
  • * (jokker): see lubab päringuid mis tahes päritolust. Kasutage ettevaatlikult, kuna see võib ohustada turvalisust, kui tegemist on tundlike andmetega. Tootmiskeskkondades tuleks seda üldiselt vältida.
• Access-Control-Allow-Methods: See päis määrab HTTP meetodid (nt GET, POST, PUT, DELETE), mis on lubatud päritoluüleste päringute jaoks. Seda kasutatakse eelkontrolli vastuses.
• Access-Control-Allow-Headers: See päis loetleb kohandatud päised, mis on lubatud päritoluülestes päringutes. Seda kasutatakse samuti eelkontrolli vastuses.
• Access-Control-Allow-Credentials: See päis näitab, kas server lubab mandaatide (nt küpsised, autoriseerimispäised) lisamist päritoluülestesse päringutesse. See tuleks seada väärtusele true, kui peate saatma mandaate. Kliendi poolel peate samuti seadma withCredentials = true XMLHttpRequest objektil.
• Access-Control-Expose-Headers: Vaikimisi paljastavad brauserid kliendipoolsetele skriptidele ainult piiratud hulga vastuse päiseid (nt Cache-Control, Content-Language, Content-Type, Expires, Last-Modified, Pragma). Kui soovite paljastada teisi päiseid, peate need loetlema Access-Control-Expose-Headers päises.
• Access-Control-Max-Age: See päis määrab maksimaalse aja (sekundites), mille jooksul brauser saab eelkontrolli päringut vahemällu salvestada. Pikem väärtus vähendab eelkontrolli päringute arvu, parandades jõudlust.

CORS erinevates serveripoolsetes keeltes

CORS-i rakendamine hõlmab tavaliselt teie serveripoolse rakenduse seadistamist sobivate CORS-i päiste saatmiseks. Siin on näiteid, kuidas seda teha erinevates keeltes ja raamistikes:

Node.js koos Expressiga

Saate kasutada cors vahevara paketti:

            const express = require('express');
const cors = require('cors');

const app = express();

// Luba CORS kõikidele päritoludele (KASUTAGE TOODANGUS ETTEVAATLIKULT)
app.use(cors());

// Alternatiivselt seadistage CORS konkreetsete päritolude jaoks
// app.use(cors({
//   origin: 'http://example.com'
// }));

app.get('/data', (req, res) => {
  res.json({ message: 'See on CORS-toega kõikidele päritoludele!' });
});

app.listen(3000, () => {
  console.log('Server töötab pordil 3000');
});
            

              
                Copy
              
            
          

Python koos Flaskiga

Saate kasutada Flask-CORS laiendust:

            from flask import Flask
from flask_cors import CORS

app = Flask(__name__)
CORS(app)

# Alternatiivselt seadistage CORS konkreetsete päritolude jaoks
# CORS(app, resources={r"/api/*": {"origins": "http://example.com"}})

@app.route("/data")
def hello():
    return {"message": "See on CORS-toega kõikidele päritoludele!"}

if __name__ == '__main__':
    app.run(debug=True)
            

              
                Copy
              
            
          

Java koos Spring Bootiga

Saate CORS-i oma Spring Boot rakenduses seadistada annotatsioonide või konfiguratsiooniklasside abil:

Annotatsioonide kasutamine:

            import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@CrossOrigin(origins = "http://example.com") // Luba päringud saidilt http://example.com
public class DataController {

    @GetMapping("/data")
    public String getData() {
        return "See on CORS-toega saidile http://example.com!";
    }
}
            

              
                Copy
              
            
          

Konfiguratsiooni kasutamine:

            import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class CorsConfig implements WebMvcConfigurer {

    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/data")
                .allowedOrigins("http://example.com") // Luba päringud saidilt http://example.com
                .allowedMethods("GET", "POST", "PUT", "DELETE")
                .allowedHeaders("*");
    }
}
            

              
                Copy
              
            
          

PHP

             "See on CORS-toega saidile http://example.com!");
echo json_encode($data);
?>
            

              
                Copy
              
            
          

CORS ja turvakaalutlused

Kuigi CORS võimaldab päritoluüleseid päringuid, on ülioluline seda turvaliselt rakendada. Siin on mõned olulised kaalutlused:

• Vältige * kasutamist Access-Control-Allow-Origin päises tootmises: See lubab päringuid mis tahes päritolust, mis võib olla turvarisk. Selle asemel määrake selgesõnaliselt päritolud, millel on lubatud teie ressurssidele juurde pääseda.
• Valideerige Origin päis serveripoolel: Isegi kui kasutate raamistikku, mis haldab CORS-i seadistamist, on hea tava valideerida Origin päis serveripoolel, et tagada päringu pärinemine oodatud päritolust.
• Olge teadlik Access-Control-Allow-Credentials päisest: Kui kasutate mandaate (nt küpsised, autoriseerimispäised), veenduge, et serveripoolel on seatud Access-Control-Allow-Credentials: true ja kliendi poolel withCredentials = true. Siiski olge teadlik, et Access-Control-Allow-Origin: * kasutamine ei ole lubatud, kui Access-Control-Allow-Credentials on seatud väärtusele true. Peate selgesõnaliselt määrama lubatud päritolud.
• Seadistage Access-Control-Allow-Methods ja Access-Control-Allow-Headers õigesti: Lubage ainult need HTTP meetodid ja päised, mis on teie rakenduse korrektseks toimimiseks vajalikud. See aitab vähendada rünnakupinda.
• Kasutage HTTPS-i: Kasutage alati HTTPS-i oma veebirakenduste ja API-de jaoks, et kaitsta andmeid edastamise ajal.

CORS-i probleemide tõrkeotsing

CORS-i probleemide silumine võib olla masendav. Siin on mõned levinud probleemid ja kuidas neid lahendada:

• „No 'Access-Control-Allow-Origin' header is present on the requested resource”: See on kõige levinum CORS-i viga. See tähendab, et server ei saada oma vastuses Access-Control-Allow-Origin päist. Kontrollige oma serveripoolset seadistust, et veenduda, kas päis saadetakse korrektselt.
• „Response to preflight request doesn't pass access control check: It does not have HTTP ok status”: See viga näitab, et eelkontrolli päring ebaõnnestus. See võib juhtuda, kui server ei ole seadistatud OPTIONS-päringute käsitlemiseks või kui Access-Control-Allow-Methods või Access-Control-Allow-Headers päised ei ole õigesti seadistatud.
• „The value of the 'Access-Control-Allow-Origin' header in the response is not equal to the origin in the request”: See viga tähendab, et päringu päritolu ei vasta Access-Control-Allow-Origin päise väärtusele. Veenduge, et server saadab vastuses õige päritolu.
• Brauseri vahemälu: Mõnikord võivad brauserid CORS-i vastuseid vahemällu salvestada, mis võib põhjustada ootamatut käitumist. Proovige tühjendada oma brauseri vahemälu või kasutada teist brauserit, et näha, kas see lahendab probleemi. Saate kasutada ka Access-Control-Max-Age päist, et kontrollida, kui kaua brauser eelkontrolli vastust vahemällu salvestab.

Silumistööriistad:

• Brauseri arendaja tööriistad: Kasutage brauseri arendaja tööriistu (tavaliselt avatav F12 klahviga), et kontrollida võrgupäringuid ja vastuseid. Otsige CORS-iga seotud päiseid ja veateateid.
• Online CORS-i kontrollijad: On olemas veebitööriistu, mis aitavad teil testida oma CORS-i seadistust. Need tööriistad saadavad päringu teie serverile ja analüüsivad vastuse päiseid, et tuvastada potentsiaalseid probleeme.

Täiustatud CORS-i stsenaariumid

Kuigi CORS-i põhikontseptsioonid on suhteliselt lihtsad, on ka mõningaid täiustatud stsenaariume, mida kaaluda:

• CORS alamdomeenidega: Kui peate lubama päringuid mitmelt alamdomeenilt (nt app1.example.com, app2.example.com), ei saa te lihtsalt kasutada jokkerit nagu *.example.com Access-Control-Allow-Origin päises. Selle asemel peate dünaamiliselt genereerima Access-Control-Allow-Origin päise, mis põhineb päringu Origin päisel. Pidage meeles, et peate valideerima päritolu lubatud alamdomeenide valge nimekirja alusel, et vältida turvaauke.
• CORS mitme päritoluga: Kui peate lubama päringuid mitmest konkreetsest päritolust, ei saa te määrata mitut päritolu Access-Control-Allow-Origin päises (nt Access-Control-Allow-Origin: http://example.com, http://another.com on kehtetu). Selle asemel peate dünaamiliselt genereerima Access-Control-Allow-Origin päise, mis põhineb päringu Origin päisel.
• CORS ja CDN-id: Kui kasutate oma API teenindamiseks CDN-i, peate seadistama CDN-i edastama Origin päise oma lähteserverile ja vahemällu salvestama Access-Control-Allow-Origin päise korrektselt. Täpsemate juhiste saamiseks pöörduge oma CDN-i pakkuja dokumentatsiooni poole.

CORS-i parimad praktikad

Turvalise ja tõhusa CORS-i rakendamise tagamiseks järgige neid parimaid praktikaid:

• Vähima privileegi põhimõte: Lubage ainult minimaalne hulk päritolusid, meetodeid ja päiseid, mis on teie rakenduse korrektseks toimimiseks vajalikud.
• Vaadake CORS-i seadistus regulaarselt üle: Teie rakenduse arenedes vaadake regulaarselt üle oma CORS-i seadistus, et tagada selle asjakohasus ja turvalisus.
• Kasutage raamistikku või teeki: Kasutage olemasolevaid raamistikke või teeke, mis pakuvad sisseehitatud CORS-i tuge. See võib lihtsustada rakendamist ja vähendada vigade riski.
• Jälgige CORS-i rikkumisi: Rakendage seiret, et tuvastada ja reageerida potentsiaalsetele CORS-i rikkumistele.
• Olge kursis: Hoidke end kursis uusimate CORS-i spetsifikatsioonide ja turvasoovitustega.

Kokkuvõte

CORS on oluline turvamehhanism, mis võimaldab kontrollitud päritoluüleseid päringuid veebirakendustes. CORS-i toimimise ja selle õige seadistamise mõistmine on iga veebiarendaja jaoks hädavajalik. Järgides selles põhjalikus juhendis toodud juhiseid ja parimaid praktikaid, saate luua turvalisi ja funktsionaalseid veebirakendusi, mis suhtlevad sujuvalt ressurssidega erinevatest päritoludest.

Pidage meeles, et alati tuleb eelistada turvalisust ja vältida liiga lubavaid CORS-i seadistusi. Hoolikalt kaaludes oma CORS-i seadete turvamõjusid, saate kaitsta oma rakendusi ja andmeid volitamata juurdepääsu eest.

Loodame, et see juhend aitas teil CORS-i demüstifitseerida. Head kodeerimist!