M

MLOG

தமிழ்

CORS (Cross-Origin Resource Sharing)-ன் இரகசியங்களைத் திறந்து, உங்கள் வலைப் பயன்பாடுகளில் கிராஸ்-டொமைன் கோரிக்கைகளை எவ்வாறு பாதுகாப்பாக இயக்குவது என்பதை அறியுங்கள். இந்த விரிவான வழிகாட்டி அடிப்படைகள் முதல் மேம்பட்ட கட்டமைப்புகள் வரை அனைத்தையும் உள்ளடக்கி, வெவ்வேறு மூலங்களுக்கு இடையே தடையற்ற மற்றும் பாதுகாப்பான தொடர்பை உறுதி செய்கிறது.

CORS-ஐ எளிமையாக்குதல்: Cross-Origin Resource Sharing-க்கான ஒரு விரிவான வழிகாட்டி

இன்றைய இணைக்கப்பட்ட வலையமைப்பில், பயன்பாடுகள் அடிக்கடி வெவ்வேறு மூலங்களிலிருந்து வளங்களை அணுக வேண்டியுள்ளது. இங்குதான் Cross-Origin Resource Sharing (CORS) செயல்பாட்டிற்கு வருகிறது. CORS என்பது ஒரு முக்கியமான பாதுகாப்பு வழிமுறையாகும், இது ஒரு மூலத்திலிருந்து (டொமைன், புரோட்டோகால் மற்றும் போர்ட்) மற்றொரு மூலத்திற்கு வரும் கோரிக்கைகளை வலை உலாவிகள் எவ்வாறு கையாள வேண்டும் என்பதை நிர்வகிக்கிறது. பாதுகாப்பான மற்றும் செயல்பாட்டு வலைப் பயன்பாடுகளை உருவாக்க ஒவ்வொரு வலை உருவாக்குநருக்கும் CORS-ஐப் புரிந்துகொள்வது அவசியமாகும்.

ஒரே மூலக் கொள்கை (Same-Origin Policy) என்றால் என்ன?

CORS-க்குள் நுழைவதற்கு முன், ஒரே மூலக் கொள்கையை (SOP) புரிந்துகொள்வது முக்கியம். SOP என்பது வலை உலாவிகளில் செயல்படுத்தப்பட்ட ஒரு அடிப்படை பாதுகாப்பு வழிமுறையாகும். இதன் நோக்கம், ஒரு இணையதளத்தில் உள்ள தீங்கிழைக்கும் ஸ்கிரிப்ட்கள் மற்றொரு இணையதளத்தில் உள்ள முக்கியமான தரவை அணுகுவதைத் தடுப்பதாகும். ஒரு மூலம் என்பது புரோட்டோகால் (எ.கா., HTTP அல்லது HTTPS), டொமைன் (எ.கா., example.com), மற்றும் போர்ட் எண் (எ.கா., 80 அல்லது 443) ஆகியவற்றின் கலவையால் வரையறுக்கப்படுகிறது. இரண்டு URL-கள் ஒரே புரோட்டோகால், டொமைன் மற்றும் போர்ட்டைப் பகிர்ந்து கொண்டால், அவை ஒரே மூலத்தைக் கொண்டதாகக் கருதப்படுகின்றன.

உதாரணம்:

CORS போன்ற குறிப்பிட்ட நடவடிக்கைகள் அதை அனுமதிக்காத வரை, ஒரு வேறுபட்ட மூலத்திலிருந்து வளங்களை அணுகுவதிலிருந்து SOP ஸ்கிரிப்ட்களைக் கட்டுப்படுத்துகிறது.

CORS ஏன் அவசியம்?

ஒரே மூலக் கொள்கை பாதுகாப்பிற்கு இன்றியமையாததாக இருந்தாலும், அது கட்டுப்பாடாகவும் இருக்கலாம். பல நவீன வலைப் பயன்பாடுகள் API-கள் அல்லது உள்ளடக்க விநியோக நெட்வொர்க்குகள் (CDN-கள்) போன்ற வெவ்வேறு சர்வர்களிலிருந்து தரவைப் பெறுவதை நம்பியுள்ளன. CORS, பாதுகாப்பைப் பேணிக்கொண்டே, சட்டப்பூர்வமான கிராஸ்-ஆரிஜின் கோரிக்கைகளை அனுமதிக்க SOP-ஐ தளர்த்துவதற்கான ஒரு கட்டுப்படுத்தப்பட்ட வழியை வழங்குகிறது.

http://example.com இல் ஹோஸ்ட் செய்யப்பட்ட ஒரு வலைப் பயன்பாடு http://api.example.net இல் ஹோஸ்ட் செய்யப்பட்ட API சர்வரிலிருந்து தரவைப் பெற வேண்டும் என்று ஒரு சூழ்நிலையைக் கவனியுங்கள். CORS இல்லாமல், SOP காரணமாக உலாவி இந்த கோரிக்கையைத் தடுக்கும். CORS, API சர்வர் அதன் வளங்களை அணுக எந்த மூலங்கள் அனுமதிக்கப்படுகின்றன என்பதை வெளிப்படையாகக் குறிப்பிட அனுமதிக்கிறது, இதனால் வலைப் பயன்பாடு சரியாக செயல்பட உதவுகிறது.

CORS எவ்வாறு செயல்படுகிறது: அடிப்படைகள்

CORS, கிளையன்ட் (உலாவி) மற்றும் சர்வருக்கு இடையில் பரிமாறப்படும் HTTP தலைப்புகளின் தொடர் மூலம் செயல்படுகிறது. கோரப்பட்ட வளத்தை அணுக அனுமதிக்கப்படுகிறதா என்பதை உலாவிக்குத் தெரிவிக்க சர்வர் இந்தத் தலைப்புகளைப் பயன்படுத்துகிறது. இதில் உள்ள முக்கிய HTTP தலைப்பு Access-Control-Allow-Origin ஆகும்.

காட்சி 1: எளிய கோரிக்கை

ஒரு "எளிய கோரிக்கை" என்பது ஒரு GET, HEAD, அல்லது POST கோரிக்கை ஆகும், இது குறிப்பிட்ட நிபந்தனைகளை பூர்த்தி செய்கிறது (எ.கா., Content-Type தலைப்பு application/x-www-form-urlencoded, multipart/form-data, அல்லது text/plain இல் ஒன்றாகும்). இந்த நிலையில், உலாவி கோரிக்கையை நேரடியாக சர்வருக்கு அனுப்புகிறது, மேலும் சர்வர் Access-Control-Allow-Origin தலைப்புடன் பதிலளிக்கிறது.

கிளையன்ட் கோரிக்கை (http://example.com-லிருந்து):

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

சர்வர் பதில் (http://api.example.net-லிருந்து):

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

{
  "data": "சர்வரிலிருந்து சில தரவு"
}

இந்த எடுத்துக்காட்டில், சர்வர் Access-Control-Allow-Origin: http://example.com உடன் பதிலளிக்கிறது, இது http://example.com இலிருந்து வரும் கோரிக்கைகள் அனுமதிக்கப்படுகின்றன என்பதைக் குறிக்கிறது. கோரிக்கையில் உள்ள மூலம் Access-Control-Allow-Origin தலைப்பில் உள்ள மதிப்புடன் பொருந்தவில்லை என்றால் (அல்லது தலைப்பு இல்லை என்றால்), உலாவி பதிலை தடுத்து, கிளையன்ட் பக்க ஸ்கிரிப்ட் தரவை அணுகுவதைத் தடுக்கும்.

காட்சி 2: முன் கோரிக்கை (சிக்கலான கோரிக்கைகளுக்கு)

PUT, DELETE போன்ற HTTP முறைகளைப் பயன்படுத்தும் அல்லது தனிப்பயன் தலைப்புகளைக் கொண்ட சிக்கலான கோரிக்கைகளுக்கு, உலாவி HTTP OPTIONS முறையைப் பயன்படுத்தி ஒரு "முன் கோரிக்கையை" செய்கிறது. இந்த முன் கோரிக்கை உண்மையான கோரிக்கையை அனுப்புவதற்கு முன்பு சர்வரிடம் அனுமதி கேட்கிறது. எந்த முறைகள், தலைப்புகள் மற்றும் மூலங்கள் அனுமதிக்கப்படுகின்றன என்பதைக் குறிப்பிடும் தலைப்புகளுடன் சர்வர் பதிலளிக்கிறது.

கிளையன்ட் முன் கோரிக்கை (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

சர்வர் பதில் (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

தலைப்புகளின் விளக்கம்:

சர்வரின் முன் கோரிக்கை பதில் கோரிக்கை அனுமதிக்கப்பட்டிருப்பதைக் குறித்தால், உலாவி உண்மையான கோரிக்கையைத் தொடரும். இல்லையெனில், உலாவி கோரிக்கையைத் தடுக்கும்.

கிளையன்ட் உண்மையான கோரிக்கை (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": "புதுப்பிக்கப்பட வேண்டிய சில தரவு"
}

சர்வர் பதில் (http://api.example.net-லிருந்து):

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

{
  "status": "தரவு வெற்றிகரமாக புதுப்பிக்கப்பட்டது"
}

பொதுவான CORS தலைப்புகள்

நீங்கள் புரிந்து கொள்ள வேண்டிய முக்கிய CORS தலைப்புகளின் முறிவு இங்கே:

பல்வேறு சர்வர்-பக்க மொழிகளில் CORS

CORS-ஐ செயல்படுத்துவது என்பது பொதுவாக உங்கள் சர்வர் பக்க பயன்பாட்டை பொருத்தமான CORS தலைப்புகளை அனுப்ப உள்ளமைப்பதை உள்ளடக்கியது. பல்வேறு மொழிகள் மற்றும் கட்டமைப்புகளில் இதை எப்படி செய்வது என்பதற்கான எடுத்துக்காட்டுகள் இங்கே:

Node.js மற்றும் Express-ல்

நீங்கள் cors மிடில்வேர் பேக்கேஜை பயன்படுத்தலாம்:

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

const app = express();

// அனைத்து மூலங்களுக்கும் CORS-ஐ இயக்கு (தயாரிப்பில் எச்சரிக்கையுடன் பயன்படுத்தவும்)
app.use(cors());

// மாற்றாக, குறிப்பிட்ட மூலங்களுக்கு CORS-ஐ உள்ளமைக்கவும்
// app.use(cors({
//   origin: 'http://example.com'
// }));

app.get('/data', (req, res) => {
  res.json({ message: 'இது அனைத்து மூலங்களுக்கும் CORS-இயக்கப்பட்டது!' });
});

app.listen(3000, () => {
  console.log('சர்வர் போர்ட் 3000-ல் இயங்குகிறது');
});

Python மற்றும் Flask-ல்

நீங்கள் Flask-CORS நீட்டிப்பைப் பயன்படுத்தலாம்:

from flask import Flask
from flask_cors import CORS

app = Flask(__name__)
CORS(app)

# மாற்றாக, குறிப்பிட்ட மூலங்களுக்கு CORS-ஐ உள்ளமைக்கவும்
# CORS(app, resources={r"/api/*": {"origins": "http://example.com"}})

@app.route("/data")
def hello():
    return {"message": "இது அனைத்து மூலங்களுக்கும் CORS-இயக்கப்பட்டது!"}

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

Java மற்றும் Spring Boot-ல்

உங்கள் Spring Boot பயன்பாட்டில் குறிப்புகள் அல்லது உள்ளமைவு வகுப்புகளைப் பயன்படுத்தி CORS-ஐ உள்ளமைக்கலாம்:

குறிப்புகளைப் பயன்படுத்துதல்:

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") // http://example.com இலிருந்து கோரிக்கைகளை அனுமதி
public class DataController {

    @GetMapping("/data")
    public String getData() {
        return "இது http://example.com-க்கு CORS-இயக்கப்பட்டது!";
    }
}

உள்ளமைவைப் பயன்படுத்துதல்:

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") // http://example.com இலிருந்து கோரிக்கைகளை அனுமதி
                .allowedMethods("GET", "POST", "PUT", "DELETE")
                .allowedHeaders("*");
    }
}

PHP

 "இது http://example.com-க்கு CORS-இயக்கப்பட்டது!");
echo json_encode($data);
?>

CORS மற்றும் பாதுகாப்பு பரிசீலனைகள்

CORS கிராஸ்-ஆரிஜின் கோரிக்கைகளை இயக்கும்போது, அதை பாதுகாப்பாக செயல்படுத்துவது மிகவும் முக்கியம். இங்கே சில முக்கியமான பரிசீலனைகள்:

CORS சிக்கல்களை சரிசெய்தல்

CORS சிக்கல்களை சரிசெய்வது வெறுப்பாக இருக்கலாம். இங்கே சில பொதுவான சிக்கல்கள் மற்றும் அவற்றை எவ்வாறு தீர்ப்பது:

பிழைதிருத்தும் கருவிகள்:

மேம்பட்ட CORS காட்சிகள்

அடிப்படை CORS கருத்துக்கள் ஒப்பீட்டளவில் நேரடியானவை என்றாலும், கருத்தில் கொள்ள வேண்டிய சில மேம்பட்ட காட்சிகள் உள்ளன:

CORS சிறந்த நடைமுறைகள்

பாதுப்பான மற்றும் திறமையான CORS செயலாக்கத்தை உறுதிப்படுத்த, இந்த சிறந்த நடைமுறைகளைப் பின்பற்றவும்:

முடிவுரை

CORS என்பது வலைப் பயன்பாடுகளில் கட்டுப்படுத்தப்பட்ட கிராஸ்-ஆரிஜின் கோரிக்கைகளை இயக்கும் ஒரு முக்கியமான பாதுகாப்பு வழிமுறையாகும். CORS எவ்வாறு செயல்படுகிறது மற்றும் அதை எவ்வாறு சரியாக உள்ளமைப்பது என்பதைப் புரிந்துகொள்வது ஒவ்வொரு வலை உருவாக்குநருக்கும் அவசியமாகும். இந்த விரிவான வழிகாட்டியில் கோடிட்டுக் காட்டப்பட்டுள்ள வழிகாட்டுதல்கள் மற்றும் சிறந்த நடைமுறைகளைப் பின்பற்றுவதன் மூலம், வெவ்வேறு மூலங்களிலிருந்து வரும் வளங்களுடன் தடையின்றி தொடர்பு கொள்ளும் பாதுகாப்பான மற்றும் செயல்பாட்டு வலைப் பயன்பாடுகளை நீங்கள் உருவாக்கலாம்.

எப்போதும் பாதுகாப்பிற்கு முன்னுரிமை அளிக்கவும், அதிகப்படியான தளர்வான CORS உள்ளமைவுகளைப் பயன்படுத்துவதைத் தவிர்க்கவும் நினைவில் கொள்ளுங்கள். உங்கள் CORS அமைப்புகளின் பாதுகாப்பு தாக்கங்களை கவனமாக பரிசீலிப்பதன் மூலம், உங்கள் பயன்பாடுகளையும் தரவையும் அங்கீகரிக்கப்படாத அணுகலில் இருந்து பாதுகாக்கலாம்.

இந்த வழிகாட்டி உங்களுக்கு CORS-ஐ எளிமையாக்க உதவியுள்ளது என்று நம்புகிறோம். மகிழ்ச்சியான நிரலாக்கம்!