Päritoludevaheliste ressursside jagamine (CORS): konfiguratsioon vs turvalisus

Interneti omavahel seotud maailmas suhtlevad veebirakendused sageli ressurssidega, mida hostitakse erinevatel päritoludel. See interaktsioon kujutab aga endast märkimisväärset turvaprobleemi. Päritoludevaheliste ressursside jagamine (CORS) on oluline mehhanism, mis reguleerib, kuidas ühelt päritolult laaditud veebileht saab suhelda teise päritoluga ressurssidega. See juhend annab põhjaliku ülevaate CORS-ist, uurides selle konfiguratsiooni, turvalisuse mõjusid ja parimaid tavasid, mis on kohandatud veebiarendajate ülemaailmsele publikule.

CORS-i põhitõdede mõistmine

CORS-i mõistmiseks peame esmalt määratlema mõiste „päritolu“. Päritolu määratletakse protokolli (nt http, https), domeeni (nt example.com) ja pordi (nt 80, 443) kombinatsiooniga. Kui mõni neist kolmest komponendist erineb, loetakse päritolu erinevaks. Näiteks http://example.com ja https://example.com on erinevad päritolud, kuigi need viitavad samale domeenile.

CORS on veebibrauserite poolt rakendatud turvamehhanism. See piirab veebilehtede päringute esitamist teisele domeenile kui see, mis veebilehe esitas. See piirang takistab pahatahtlikel veebisaitidel volitamata päringute esitamist teisele päritolule, potentsiaalselt tundlikele andmetele juurdepääsu või soovimatute toimingute tegemist kasutaja nimel. CORS pakub kontrollitud mehhanismi selle piirangu leevendamiseks.

HTTP päiste roll CORS-is

CORS kasutab päritoludevaheliste päringute haldamiseks HTTP päiste komplekti. Need päised, mida vahetatakse brauseri ja serveri vahel, määravad, kas päritoludevaheline päring on lubatud. Siin on mõned kõige olulisemad päised:

• Origin: Brauser lisab selle päise päringusse, et näidata päringut tegeva veebilehe päritolu.
• Access-Control-Allow-Origin: Server lisab selle päise vastusesse, et määrata, millistel päritoludel on lubatud ressursile juurde pääseda. See võib olla konkreetne päritolu (nt Access-Control-Allow-Origin: https://example.com) või metamärk (Access-Control-Allow-Origin: *), mis võimaldab mis tahes päritolu.
• Access-Control-Allow-Methods: Server lisab selle päise, et loetleda HTTP meetodid (nt GET, POST, PUT, DELETE), mis on päritoludevahelise päringu jaoks lubatud.
• Access-Control-Allow-Headers: Server lisab selle päise, et loetleda HTTP päised, mida on lubatud kasutada päritoludevahelises päringus.
• Access-Control-Allow-Credentials: See päis, kui väärtuseks on seatud true, näitab, et brauser peaks päringusse lisama mandaadid (nt küpsised, autoriseerimispäised).
• Access-Control-Max-Age: See päis näitab, kui kaua saab brauser eellennupäringu tulemust sekundites vahemällu salvestada. See võib parandada jõudlust, vähendades eellennupäringute arvu.

CORS-i päringutüübid

CORS-i päringuid on kahte peamist tüüpi:

• Lihtsad päringud: Need päringud vastavad konkreetsetele kriteeriumidele ja ei vaja eellennupäringut. Lihtsad päringud sisaldavad järgmisi omadusi:
  • Meetod on üks järgmistest: GET, HEAD või POST.
  • Ainus lubatud päised on:
    • Accept
    • Accept-Language
    • Content-Language
    • Content-Type (väärtusega application/x-www-form-urlencoded, multipart/form-data või text/plain)
• Eellennupäringud: Need päringud on keerukamad ja nõuavad eellennupäringut enne tegeliku päringu esitamist. Eellennupäring on HTTP OPTIONS päring, mille brauser saadab serverile, et teha kindlaks, kas tegelikku päringut on ohutu saata. See on vajalik, kui päring ei vasta lihtsa päringu kriteeriumidele. Eellennupäring sisaldab päiseid Origin, Access-Control-Request-Method ja Access-Control-Request-Headers, mida server kasutab selle kindlaksmääramiseks, kas tegelik päring on lubatud.

CORS-i konfigureerimine serveris

CORS-i konfiguratsioon tehakse peamiselt serveripoolsel küljel. Server peab päritoludevaheliste päringute lubamiseks saatma oma vastustes sobivad HTTP päised. Konkreetne rakendamine sõltub kasutatavast serveripoolsest tehnoloogiast (nt Node.js koos Expressiga, Python koos Django/Flaskiga, Java koos Spring Bootiga, PHP koos Laraveliga).

Näide: Node.js koos Expressiga

Siin on näide, kuidas konfigureerida CORS-i, kasutades Node.js-is Expressiga vahevara cors:

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

// Konfigureeri CORS, et lubada päringuid konkreetselt päritolult
const corsOptions = {
  origin: 'https://allowed-origin.com',
  methods: 'GET,POST,PUT,DELETE',
  credentials: true,
  optionsSuccessStatus: 200 // mõned vanad brauserid (IE11, erinevad SmartTV-d) lämbuvad 204-ga
};

app.use(cors(corsOptions));

app.get('/api/data', (req, res) => {
  res.json({ message: 'Andmed serverist' });
});

app.listen(3000, () => {
  console.log('Server kuulab porti 3000');
});

            

              
                Copy
              
            
          

Selles näites on server konfigureeritud lubama päringuid päritolult https://allowed-origin.com, kasutades konkreetseid meetodeid. credentials: true lubamine võimaldab kasutada küpsiseid ja autoriseerimispäiseid, suurendades veelgi turvalisust. optionsSuccessStatus: 200 kasutamine on hea tava vanemate brauseritega ühilduvuse tagamiseks.

Näide: Python koos Flaskiga

Siin on näide CORS-i konfigureerimisest Pythonis koos Flaskiga, kasutades Flask-CORS teeki:

            
from flask import Flask, jsonify
from flask_cors import CORS, cross_origin

app = Flask(__name__)
CORS(app, resources={r"/*": {"origins": "https://allowed-origin.com"}})

@app.route('/api/data')
@cross_origin(origin='https://allowed-origin.com',headers=['Content-Type','Authorization'])
def get_data():
    return jsonify({'message': 'Andmed serverist'})

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

            

              
                Copy
              
            
          

See Flaski näide kasutab Flask-CORS laiendust, võimaldades sellel hõlpsalt konfigureerida CORS-i sätteid. Saame määrata lubatud päritolu ja päised konkreetsete marsruutide jaoks, suurendades nii paindlikkust kui ka turvalisust.

Näide: Java koos Spring Bootiga

Siin on näide CORS-i konfigureerimisest Spring Bootis:

            
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;

@Configuration
public class CorsConfig {

    @Bean
    public CorsFilter corsFilter() {
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        CorsConfiguration config = new CorsConfiguration();
        config.setAllowCredentials(true);
        config.addAllowedOrigin("https://allowed-origin.com"); // Luba konkreetne päritolu
        config.addAllowedHeader("*"); // Luba kõik päised
        config.addAllowedMethod("*"); // Luba kõik meetodid
        source.registerCorsConfiguration("/**", config);
        return new CorsFilter(source);
    }
}

            

              
                Copy
              
            
          

See Spring Booti kasutav näide pakub CORS-i filtri üksikasjalikku konfiguratsiooni. See võimaldab konkreetset päritolu ja muid meetodeid. Selline seadistus parandab turvalisust ja kontrolli päritoludevaheliste päringute üle.

CORS-i turvalisuse mõjud

CORS, pakkudes samas olulist funktsionaalsust, toob kaasa ka potentsiaalseid turvariske, kui seda pole õigesti konfigureeritud. On oluline mõista neid riske ja rakendada parimaid tavasid nende leevendamiseks.

1. Ülemäära lubav konfiguratsioon (Access-Control-Allow-Origin jaoks * lubamine)

Access-Control-Allow-Origin: * kasutamine on tootmiskeskkondades üldiselt heaks kiidetud. Kuigi see võimaldab päringuid mis tahes päritolult, avab see tava teie API volitamata juurdepääsuks mis tahes veebisaidilt. See on vastuvõetav arendus- või testimiseesmärkidel, kuid mitte kunagi tootmiseks. Selle asemel määrake täpselt need päritolud, millel on lubatud teie ressurssidele juurde pääseda.

2. Valesti konfigureeritud Access-Control-Allow-Credentials

Kui Access-Control-Allow-Credentials: true on seatud, tähendab see, et server lubab päringutel lisada mandaate, nagu küpsised või HTTP autentimispäised. See säte koos metamärgiga päritoluga (Access-Control-Allow-Origin: *) võib aga põhjustada olulisi turvaauke. See võimaldab mis tahes päritolul pääseda juurde kasutaja mandaatidega ressurssidele, mis võivad põhjustada seansi kaaperdamise või andmete rikkumise.

3. Ebapiisav sisendi valideerimine

Kui teie API tugineb kliendi esitatud andmetele, nagu päised või andmed päringu kehas, ega valideeri neid andmeid korralikult, võib ründaja neid päringuid potentsiaalselt manipuleerida. Näiteks puuduv autoriseerimistunnus oleks oluline turvalisuse rike. Nende rünnakute vältimiseks valideerige sisendid alati põhjalikult serveripoolsel küljel.

4. Teabe leke

Halvad CORS-i konfiguratsioonid võivad kogemata lekitada tundlikku teavet. Näiteks kui server lubab kõiki HTTP meetodeid ja kõiki päiseid ega valideeri päringuandmeid, võivad ründajad lugeda andmeid, millele neil ei tohiks olla juurdepääsu. Kaaluge hoolikalt, millised meetodid ja päised on tõesti vajalikud, ja valideerige põhjalikult päringu sisu.

CORS-i turvalise konfigureerimise parimad tavad

Siin on mõned parimad tavad CORS-i turvaliseks konfigureerimiseks, mis on kohaldatavad erinevates riikides ja piirkondades:

• Määrake päritolud: Loetlege alati selgesõnaliselt päritolud, millel on lubatud teie ressurssidele juurde pääseda. Ärge kunagi kasutage tootmiskeskkondades metamärki (*). See pakub esimese kaitseliini pahatahtlike veebisaitide vastu. Näiteks selle asemel, et lubada kõiki päritolusid, määrake oma esirakenduste täpsed domeenid (nt Access-Control-Allow-Origin: https://your-frontend-app.com).
• Hallake mandaate hoolikalt: Kui teie API kasutab mandaate (küpsised, HTTP autentimine), kasutage Access-Control-Allow-Credentials: true ainult koos konkreetse päritoluga. Ärge kunagi kombineerige seda metamärgiga.
• Piirake HTTP meetodeid: Lubage ainult HTTP meetodeid (GET, POST, PUT, DELETE jne), mis on teie API jaoks vajalikud. Ärge lubage mittevajalikke meetodeid. See vähendab rünnakute pinda ja takistab soovimatuid toiminguid. Näiteks kui vajate ainult GET- ja POST-päringuid, määrake Access-Control-Allow-Methods: GET, POST.
• Piirake lubatud päiseid: Samamoodi lubage ainult HTTP päised, mida teie rakendus tegelikult kasutab. See takistab ründajatel pahatahtlike päiste sisestamist. Näiteks määrake lubatud päised: Access-Control-Allow-Headers: Content-Type, Authorization.
• Rakendage serveripoolset valideerimist: Sõltumata CORS-i konfiguratsioonist, valideerige alati serveripoolsel küljel sissetulevad päringud. Puhastage ja valideerige kõik sisendid, sealhulgas päised ja päringu kehad, et vältida sisestus-rünnakuid ja andmete manipuleerimist. See on kriitiline turvameede, eriti kui töötate kasutaja esitatud andmetega.
• Kasutage HTTPS-i: Kasutage alati HTTPS-i, et krüptida klientide ja serveri vaheline side. See kaitseb tundlikke andmeid pealtkuulamise ja rikkumise eest. Veenduge, et teie veebisait ja API on esitatud HTTPS-i kaudu, pakkudes andmete vahetamiseks turvalist kanalit.
• Regulaarsed turvaauditid: Tehke oma CORS-i konfiguratsiooni ja API kui terviku regulaarseid turvaauditeid. Automatiseeritud tööriistad aitavad tuvastada võimalikke turvaauke ja tagada, et teie konfiguratsioon on aja jooksul turvaline. Kontrollige oma CORS-i seadistust regulaarselt, et tuvastada ja kõrvaldada mis tahes valed konfiguratsioonid.
• Kaaluge eellennupäringu optimeerimist: Kui teie API kasutab eellennupäringuid (OPTIONS), kaaluge päise Access-Control-Max-Age, et vahemällu salvestada eellennutulemused ja parandada jõudlust, eriti sageli kasutatavate ressursside puhul. Olge aga teadlik pikkade vahemälu kestustega seotud riskidest, eriti turvavärskenduste või API muudatuste ajal.
• Püsige kursis: Olge kursis viimaste turvalisuse parimate tavade ja tekkivate ohtudega. Turvalisuse maastik areneb pidevalt ja on oluline olla teadlik uutest turvaaukudest ja leevendusstrateegiatest. Tellige turvalisuse uudiskirjad ja jälgige turvalisuse blogisid ja foorumeid.

Praktilised näited ja kaalutlused ülemaailmsele publikule

Vaatleme mõningaid praktilisi stsenaariume ja kohandame neid ülemaailmse konteksti jaoks:

Näide 1: E-kaubanduse platvorm

E-kaubanduse platvorm, millel on erinevad esirakendused erinevatele piirkondadele (nt https://us.example.com, https://eu.example.com, https://asia.example.com). API taustaprogramm (nt https://api.example.com) on eraldi. Sel juhul konfigureeriksite CORS-i, et lubada nende esirakenduste konkreetsed päritolud. Näiteks teie taustaprogrammis on konfiguratsioon järgmine:

            
  Access-Control-Allow-Origin: https://us.example.com, https://eu.example.com, https://asia.example.com

            

              
                Copy
              
            
          

Ja kui kasutate mandaate, on hädavajalik määrata kõik päritolud eraldi ja lisada ka Access-Control-Allow-Credentials: true.

Näide 2: Mobiilirakendus koos veebipõhise administraatoripaneeliga

Mobiilirakendus (nt React Native'i abil) kasutab andmete jaoks API-t. Administraatoripaneel, veebirakendus, peab samuti juurde pääsema samale API-le. Veebirakenduse päritolu võib olla https://admin.example.com. CORS-i konfiguratsioon peab lubama päringuid sellest päritolust.

Näide 3: Mikroteenuste arhitektuur

Mikroteenuste arhitektuuris võivad erinevad teenused asuda erinevatel domeenidel. Õige CORS-i konfiguratsioon on oluline, et need teenused saaksid üksteisega turvaliselt suhelda. Teenusevõrgu kasutamine CORS-i poliitikate haldamiseks võib lihtsustada päritoludevahelise side haldamist.

Kaalutlused globaalsete juurutuste jaoks

• Lokaliseerimine: Kui teie rakendus toetab mitut keelt või piirkonda, veenduge, et teie CORS-i konfiguratsioon oleks piisavalt paindlik, et tulla toime domeeninimede või alamdomeenide variatsioonidega.
• Piirkondlikud eeskirjad: Olge teadlik kõigist piirkondlikest eeskirjadest, mis võivad mõjutada teie CORS-i konfiguratsiooni. Andmete privaatsuse seadused, nagu GDPR (Euroopas) ja CCPA (California), mõjutavad seda, millist teavet jagate ja kuidas päringuid käsitlete.
• Sisu edastusvõrgud (CDN-id): Kui kasutate CDN-e, veenduge, et teie CDN-i konfiguratsioon ühilduks CORS-iga, kuna CDN-i vahemällu salvestamine võib mõjutada päise vastuseid.
• Testimine ja jälgimine: Testige oma CORS-i konfiguratsiooni põhjalikult erinevates brauserites ja seadmetes ning jälgige pidevalt logisid võimalike turvaprobleemide või valede konfiguratsioonide suhtes.

Levinud CORS-i probleemide tõrkeotsing

• CORS-i vead brauseri konsoolis: Need näitavad tavaliselt, et server ei saada õigeid CORS-i päiseid. Kontrollige oma serveripoolset konfiguratsiooni.
• Eellennupäringu tõrked: See juhtub sageli seetõttu, et eellennupäringut (OPTIONS) ei käsitleta õigesti. Vaadake üle päringu meetod, päised ja päritolu. Veenduge, et server vastab OPTIONS-päringutele õigete päistega.
• Mandaatidega seotud probleemid: Kui mandaate ei edastata, veenduge, et Access-Control-Allow-Credentials: true on seatud ja päritolu on selgesõnaliselt määratud ning et klient on konfigureeritud mandaatide saatmiseks (nt seadistades JavaScripti fetch või XMLHttpRequestis withCredentials: true).
• Vale päise suurtähestus: Päise nimed on tõstutundlikud. Veenduge, et teil on nii serveri konfiguratsioonis kui ka kliendipäringutes õige suurtähestus.
• Vahemällu salvestamise probleemid: Veenduge, et teie brauser ei salvesta vastuseid vahemällu. Tühjendage brauseri vahemälu ja keelake arenduse ajal vahemällu salvestamine.

Tööriistad ja ressursid CORS-i haldamiseks

• Brauseri arendajatööriistad: Kasutage oma brauseri arendajatööriistu (nt Chrome DevTools, Firefox Developer Tools), et kontrollida HTTP päiseid ja tõrkeotsida CORS-i probleeme. Võrgukaart on eriti kasulik päringute ja vastuste uurimiseks.
• CORS-i kontrollija: Veebipõhised CORS-i kontrollijad saavad kiiresti kontrollida teie konfiguratsiooni ja tuvastada levinud probleeme.
• Postman või muud API testimise tööriistad: Need tööriistad võimaldavad teil saata kohandatud HTTP päringuid ja uurida vastuseid, mis on kasulik CORS-i konfiguratsioonide testimiseks.
• Serveripoolse raamistiku dokumentatsioon: CORS-i konfigureerimise kohta üksikasjaliku teabe saamiseks vaadake oma serveripoolse raamistiku (nt Express.js, Django, Spring Boot) ametlikku dokumentatsiooni.
• MDN veebidokumendid: Mozilla arendajate võrk (MDN) pakub CORS-i ja HTTP päiste kohta põhjalikku dokumentatsiooni.

Kokkuvõte

CORS on oluline turvamehhanism, mis võimaldab turvalist sidet erinevatelt päritoludelt pärit veebirakenduste vahel. Mõistes selle konfiguratsiooni, turvalisuse mõjusid ja järgides parimaid tavasid, saavad arendajad ehitada tugevaid ja turvalisi veebirakendusi ülemaailmsele publikule. Pidage meeles, et õige CORS-i konfiguratsioon ei tähenda ainult funktsionaalsuse lubamist; see tähendab teie kasutajate ja andmete ennetavat kaitsmist potentsiaalsete ohtude eest. Seadke alati esikohale turvalisus ja vaadake oma konfiguratsioon regulaarselt üle, et tagada selle tõhusus arenevate ohtude vastu. See juhend on kindel lähtepunkt CORS-i valdamiseks ja selle turvaliseks rakendamiseks oma projektides, aidates teil luua turvalisemaid, globaalseid veebirakendusi.