குறுக்கு-மூல பாதுகாப்பு செயல்படுத்தல்: ஜாவாஸ்கிரிப்ட் தொடர்புக்கான சிறந்த நடைமுறைகள்

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

ஒரே-மூலக் கொள்கையைப் புரிந்துகொள்ளுதல்

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

உதாரணமாக:

• http://www.example.com மற்றும் http://www.example.com/path: ஒரே மூலம்
• http://www.example.com மற்றும் https://www.example.com: வேறு மூலம் (வேறு நெறிமுறை)
• http://www.example.com மற்றும் http://subdomain.example.com: வேறு மூலம் (வேறு டொமைன்)
• http://www.example.com:80 மற்றும் http://www.example.com:8080: வேறு மூலம் (வேறு போர்ட்)

குறுக்கு-தள ஸ்கிரிப்டிங் (XSS) தாக்குதல்களுக்கு எதிராக SOP ஒரு முக்கியமான பாதுகாப்பாகும். இத்தகைய தாக்குதல்களில், ஒரு இணையதளத்தில் செலுத்தப்படும் தீங்கிழைக்கும் ஸ்கிரிப்ட்கள் பயனர் தரவைத் திருடலாம் அல்லது பயனர் சார்பாக அங்கீகரிக்கப்படாத செயல்களைச் செய்யலாம்.

குறுக்கு-மூல வளப் பகிர்வு (CORS) என்றால் என்ன?

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

அனுமதிக்கப்பட்ட மூலங்கள் மற்றும் குறுக்கு-மூல கோரிக்கைகளுக்கு அனுமதிக்கப்பட்ட முறைகளை (எ.கா., GET, POST, PUT, DELETE) குறிப்பிடும் புதிய HTTP தலைப்புகளைச் சேர்ப்பதன் மூலம் CORS செயல்படுகிறது. ஒரு உலாவி குறுக்கு-மூல கோரிக்கையை உருவாக்கும் போது, அது கோரிக்கையுடன் ஒரு Origin தலைப்பை அனுப்புகிறது. சேவையகம் Access-Control-Allow-Origin தலைப்புடன் பதிலளிக்கிறது, இது அனுமதிக்கப்பட்ட மூல(ங்களை) குறிப்பிடுகிறது. கோரிக்கையின் மூலம் Access-Control-Allow-Origin தலைப்பில் உள்ள மதிப்புடன் பொருந்தினால் (அல்லது மதிப்பு * ஆக இருந்தால்), உலாவி ஜாவாஸ்கிரிப்ட் குறியீட்டை பதிலில் அணுக அனுமதிக்கிறது.

CORS எவ்வாறு செயல்படுகிறது: ஒரு விரிவான விளக்கம்

CORS செயல்முறை பொதுவாக இரண்டு வகையான கோரிக்கைகளை உள்ளடக்கியது:

1. எளிய கோரிக்கைகள் (Simple Requests): இவை குறிப்பிட்ட நிபந்தனைகளைப் பூர்த்தி செய்யும் கோரிக்கைகள். ஒரு கோரிக்கை இந்த நிபந்தனைகளைப் பூர்த்தி செய்தால், உலாவி நேரடியாக கோரிக்கையை அனுப்புகிறது.
2. முன்-பரிசோதனை செய்யப்பட்ட கோரிக்கைகள் (Preflighted Requests): இவை மிகவும் சிக்கலான கோரிக்கைகள். உண்மையான கோரிக்கையை அனுப்புவது பாதுகாப்பானதா என்பதை தீர்மானிக்க, உலாவி முதலில் சேவையகத்திற்கு ஒரு "முன்-பரிசோதனை" OPTIONS கோரிக்கையை அனுப்ப வேண்டும்.

1. எளிய கோரிக்கைகள்

ஒரு கோரிக்கை பின்வரும் அனைத்து நிபந்தனைகளையும் பூர்த்தி செய்தால் அது "எளியது" என்று கருதப்படுகிறது:

• முறை GET, HEAD, அல்லது POST ஆக இருக்க வேண்டும்.
• முறை POST ஆக இருந்தால், Content-Type தலைப்பு பின்வருவனவற்றில் ஒன்றாக இருக்க வேண்டும்:
• application/x-www-form-urlencoded
• multipart/form-data
• text/plain
• தனிப்பயன் தலைப்புகள் எதுவும் அமைக்கப்படவில்லை.

ஒரு எளிய கோரிக்கையின் உதாரணம்:

GET /resource HTTP/1.1
Origin: http://www.example.com

மூலத்தை அனுமதிக்கும் ஒரு சேவையக பதிலின் உதாரணம்:

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

{
  "data": "Some data"
}

Access-Control-Allow-Origin தலைப்பு இருந்து, அதன் மதிப்பு கோரிக்கையின் மூலத்துடன் பொருந்தினால் அல்லது * என அமைக்கப்பட்டிருந்தால், உலாவி ஸ்கிரிப்டை பதில் தரவை அணுக அனுமதிக்கிறது. இல்லையெனில், உலாவி பதிலுக்கான அணுகலைத் தடுக்கிறது, மேலும் கன்சோலில் ஒரு பிழை செய்தி காட்டப்படும்.

2. முன்-பரிசோதனை செய்யப்பட்ட கோரிக்கைகள்

ஒரு கோரிக்கை ஒரு எளிய கோரிக்கைக்கான நிபந்தனைகளைப் பூர்த்தி செய்யவில்லை என்றால் அது "முன்-பரிசோதனை செய்யப்பட்டது" என்று கருதப்படுகிறது. இது பொதுவாக கோரிக்கை வேறு HTTP முறையைப் பயன்படுத்தும்போது (எ.கா., PUT, DELETE), தனிப்பயன் தலைப்புகளை அமைக்கும்போது, அல்லது அனுமதிக்கப்பட்ட மதிப்புகளைத் தவிர வேறு Content-Type ஐப் பயன்படுத்தும்போது நிகழ்கிறது.

உண்மையான கோரிக்கையை அனுப்புவதற்கு முன்பு, உலாவி முதலில் சேவையகத்திற்கு ஒரு OPTIONS கோரிக்கையை அனுப்புகிறது. இந்த "முன்-பரிசோதனை" கோரிக்கை பின்வரும் தலைப்புகளை உள்ளடக்கியது:

• Origin: கோரும் பக்கத்தின் மூலம்.
• Access-Control-Request-Method: உண்மையான கோரிக்கையில் பயன்படுத்தப்படும் HTTP முறை (எ.கா., PUT, DELETE).
• Access-Control-Request-Headers: உண்மையான கோரிக்கையில் அனுப்பப்படும் தனிப்பயன் தலைப்புகளின் கமாவால் பிரிக்கப்பட்ட பட்டியல்.

ஒரு முன்-பரிசோதனை கோரிக்கையின் உதாரணம்:

OPTIONS /resource HTTP/1.1
Origin: http://www.example.com
Access-Control-Request-Method: PUT
Access-Control-Request-Headers: X-Custom-Header, Content-Type

சேவையகம் OPTIONS கோரிக்கைக்கு பின்வரும் தலைப்புகளுடன் பதிலளிக்க வேண்டும்:

• Access-Control-Allow-Origin: கோரிக்கையை உருவாக்க அனுமதிக்கப்பட்ட மூலம் (அல்லது எந்த மூலத்தையும் அனுமதிக்க *).
• Access-Control-Allow-Methods: குறுக்கு-மூல கோரிக்கைகளுக்கு அனுமதிக்கப்பட்ட HTTP முறைகளின் கமாவால் பிரிக்கப்பட்ட பட்டியல் (எ.கா., GET, POST, PUT, DELETE).
• Access-Control-Allow-Headers: கோரிக்கையில் அனுப்ப அனுமதிக்கப்பட்ட தனிப்பயன் தலைப்புகளின் கமாவால் பிரிக்கப்பட்ட பட்டியல்.
• Access-Control-Max-Age: முன்-பரிசோதனை பதிலை உலாவியால் தற்காலிகமாக சேமிக்கக்கூடிய விநாடிகளின் எண்ணிக்கை.

ஒரு முன்-பரிசோதனை கோரிக்கைக்கான சேவையக பதிலின் உதாரணம்:

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

முன்-பரிசோதனை கோரிக்கைக்கான சேவையகத்தின் பதில் உண்மையான கோரிக்கை அனுமதிக்கப்பட்டுள்ளது என்பதைக் குறித்தால், உலாவி பின்னர் உண்மையான கோரிக்கையை அனுப்பும். இல்லையெனில், உலாவி கோரிக்கையைத் தடுத்து ஒரு பிழை செய்தியைக் காண்பிக்கும்.

சேவையகப் பக்கத்தில் CORS-ஐ செயல்படுத்துதல்

CORS முதன்மையாக சேவையகப் பக்கத்தில் பதிலில் பொருத்தமான HTTP தலைப்புகளை அமைப்பதன் மூலம் செயல்படுத்தப்படுகிறது. குறிப்பிட்ட செயல்படுத்தல் விவரங்கள் பயன்படுத்தப்படும் சேவையகப் பக்க தொழில்நுட்பத்தைப் பொறுத்து மாறுபடும்.

Node.js உடன் Express ஐப் பயன்படுத்தும் உதாரணம்:

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

// எல்லா மூலங்களுக்கும் CORS-ஐ இயக்கு
app.use(cors());

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

app.get('/resource', (req, res) => {
  res.json({ message: 'This is a CORS-enabled resource' });
});

app.listen(3000, () => {
  console.log('Server listening on port 3000');
});

cors மிடில்வேர் Express இல் CORS தலைப்புகளை அமைக்கும் செயல்முறையை எளிதாக்குகிறது. நீங்கள் cors() ஐப் பயன்படுத்தி எல்லா மூலங்களுக்கும் CORS ஐ இயக்கலாம் அல்லது cors(corsOptions) ஐப் பயன்படுத்தி குறிப்பிட்ட மூலங்களுக்கு உள்ளமைக்கலாம்.

Python உடன் Flask ஐப் பயன்படுத்தும் உதாரணம்:

from flask import Flask
from flask_cors import CORS

app = Flask(__name__)
CORS(app)

@app.route("/resource")
def hello():
    return {"message": "This is a CORS-enabled resource"}

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

flask_cors நீட்டிப்பு Flask பயன்பாடுகளில் CORS ஐ இயக்குவதற்கான ஒரு எளிய வழியை வழங்குகிறது. app ஐ CORS() க்கு அனுப்புவதன் மூலம் எல்லா மூலங்களுக்கும் CORS ஐ இயக்கலாம். குறிப்பிட்ட மூலங்களுக்கான உள்ளமைவும் சாத்தியமாகும்.

Java உடன் Spring Boot ஐப் பயன்படுத்தும் உதாரணம்:

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("/resource")
                .allowedOrigins("http://www.example.com")
                .allowedMethods("GET", "POST", "PUT", "DELETE")
                .allowedHeaders("Content-Type", "X-Custom-Header")
                .allowCredentials(true)
                .maxAge(3600);
    }
}

Spring Boot இல், நீங்கள் ஒரு WebMvcConfigurer ஐப் பயன்படுத்தி CORS ஐ உள்ளமைக்கலாம். இது அனுமதிக்கப்பட்ட மூலங்கள், முறைகள், தலைப்புகள் மற்றும் பிற CORS அமைப்புகளின் மீது நுணுக்கமான கட்டுப்பாட்டை அனுமதிக்கிறது.

CORS தலைப்புகளை நேரடியாக அமைத்தல் (பொதுவான உதாரணம்)

நீங்கள் எந்த கட்டமைப்பையும் பயன்படுத்தவில்லை என்றால், உங்கள் சேவையகப் பக்க குறியீட்டில் (எ.கா. PHP, Ruby on Rails, போன்றவை) நேரடியாக தலைப்புகளை அமைக்கலாம்:

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

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

1. தயாரிப்பில் Access-Control-Allow-Origin: * பயன்படுத்துவதைத் தவிர்க்கவும்: எல்லா மூலங்களையும் உங்கள் வளங்களை அணுக அனுமதிப்பது ஒரு பாதுகாப்பு அபாயமாக இருக்கலாம். அதற்குப் பதிலாக, அனுமதிக்கப்பட்ட சரியான மூலங்களைக் குறிப்பிடவும்.
2. HTTPS ஐப் பயன்படுத்தவும்: பரிமாற்றத்தில் உள்ள தரவைப் பாதுகாக்க, கோரும் மற்றும் வழங்கும் மூலங்களுக்கு எப்போதும் HTTPS ஐப் பயன்படுத்தவும்.
3. உள்ளீட்டைச் சரிபார்க்கவும்: ஊடுருவல் தாக்குதல்களைத் தடுக்க, குறுக்கு-மூல கோரிக்கைகளிலிருந்து பெறப்பட்ட தரவை எப்போதும் சரிபார்த்து சுத்திகரிக்கவும்.
4. சரியான அங்கீகாரம் மற்றும் அங்கீகாரத்தைச் செயல்படுத்தவும்: அங்கீகரிக்கப்பட்ட பயனர்கள் மட்டுமே முக்கியமான வளங்களை அணுக முடியும் என்பதை உறுதிப்படுத்தவும்.
5. முன்-பரிசோதனை பதில்களைத் தற்காலிகமாக சேமிக்கவும்: முன்-பரிசோதனை பதில்களைத் தற்காலிகமாக சேமிக்கவும் மற்றும் OPTIONS கோரிக்கைகளின் எண்ணிக்கையைக் குறைக்கவும் Access-Control-Max-Age ஐப் பயன்படுத்தவும்.
6. அடையாளச் சான்றுகளைப் பயன்படுத்துவதைக் கருத்தில் கொள்ளவும்: உங்கள் API க்கு குக்கீகள் அல்லது HTTP அங்கீகாரத்துடன் அங்கீகாரம் தேவைப்பட்டால், நீங்கள் சேவையகத்தில் Access-Control-Allow-Credentials தலைப்பை true ஆகவும், உங்கள் ஜாவாஸ்கிரிப்ட் குறியீட்டில் (எ.கா., fetch அல்லது XMLHttpRequest ஐப் பயன்படுத்தும்போது) credentials விருப்பத்தை 'include' ஆகவும் அமைக்க வேண்டும். இந்த விருப்பத்தைப் பயன்படுத்தும்போது மிகவும் கவனமாக இருங்கள், ஏனெனில் இது சரியாகக் கையாளப்படாவிட்டால் பாதுகாப்பு பாதிப்புகளை அறிமுகப்படுத்தலாம். மேலும், Access-Control-Allow-Credentials ஆனது true என அமைக்கப்பட்டால், Access-Control-Allow-Origin ஐ "*" என அமைக்க முடியாது. நீங்கள் அனுமதிக்கப்பட்ட மூல(ங்களை) வெளிப்படையாகக் குறிப்பிட வேண்டும்.
7. CORS உள்ளமைவை தவறாமல் மதிப்பாய்வு செய்து புதுப்பிக்கவும்: உங்கள் பயன்பாடு உருவாகும்போது, உங்கள் CORS உள்ளமைவு பாதுகாப்பாகவும் உங்கள் தேவைகளைப் பூர்த்தி செய்வதாகவும் இருப்பதை உறுதிசெய்ய, அதைத் தவறாமல் மதிப்பாய்வு செய்து புதுப்பிக்கவும்.
8. வெவ்வேறு CORS உள்ளமைவுகளின் தாக்கங்களைப் புரிந்துகொள்ளுங்கள்: வெவ்வேறு CORS உள்ளமைவுகளின் பாதுகாப்பு தாக்கங்களைப் பற்றி எச்சரிக்கையாக இருங்கள் மற்றும் உங்கள் பயன்பாட்டிற்கு பொருத்தமான உள்ளமைவைத் தேர்வு செய்யவும்.
9. உங்கள் CORS செயலாக்கத்தைச் சோதிக்கவும்: உங்கள் CORS செயலாக்கம் எதிர்பார்த்தபடி செயல்படுகிறதா என்பதையும், அது எந்தப் பாதுகாப்பு பாதிப்புகளையும் அறிமுகப்படுத்தவில்லை என்பதையும் உறுதிப்படுத்த அதை முழுமையாகச் சோதிக்கவும். பிணைய கோரிக்கைகள் மற்றும் பதில்களை ஆய்வு செய்ய உலாவி டெவலப்பர் கருவிகளைப் பயன்படுத்தவும், மற்றும் CORS நடத்தையைச் சரிபார்க்க தானியங்கு சோதனை கருவிகளைப் பயன்படுத்தவும்.

உதாரணம்: Fetch API ஐ CORS உடன் பயன்படுத்துதல்

ஒரு குறுக்கு-மூல கோரிக்கையைச் செய்ய fetch API ஐ எவ்வாறு பயன்படுத்துவது என்பதற்கான உதாரணம் இங்கே:

fetch('https://api.example.com/data', {
  method: 'GET',
  mode: 'cors', // இது ஒரு CORS கோரிக்கை என்பதை உலாவிக்குச் சொல்கிறது
  headers: {
    'Content-Type': 'application/json',
    'X-Custom-Header': 'value'
  }
})
.then(response => {
  if (!response.ok) {
    throw new Error('Network response was not ok');
  }
  return response.json();
})
.then(data => {
  console.log(data);
})
.catch(error => {
  console.error('There was a problem with the fetch operation:', error);
});

mode: 'cors' விருப்பம் இது ஒரு CORS கோரிக்கை என்பதை உலாவிக்குச் சொல்கிறது. சேவையகம் மூலத்தை அனுமதிக்கவில்லை என்றால், உலாவி பதிலுக்கான அணுகலைத் தடுத்து, ஒரு பிழை ஏற்படும்.

நீங்கள் அடையாளச் சான்றுகளை (எ.கா., குக்கீகள்) பயன்படுத்தினால், நீங்கள் credentials விருப்பத்தை 'include' ஆக அமைக்க வேண்டும்:

fetch('https://api.example.com/data', {
  method: 'GET',
  mode: 'cors',
  credentials: 'include', // கோரிக்கையில் குக்கீகளைச் சேர்க்கவும்
  headers: {
    'Content-Type': 'application/json'
  }
})
.then(response => {
  // ...
});

CORS மற்றும் JSONP

JSON with Padding (JSONP) என்பது ஒரே-மூலக் கொள்கையைத் தவிர்ப்பதற்கான ஒரு பழைய நுட்பமாகும். இது வேறு டொமைனிலிருந்து தரவை ஏற்றும் ஒரு <script> குறிச்சொல்லை மாறும் வகையில் உருவாக்குவதன் மூலம் செயல்படுகிறது. JSONP சில சூழ்நிலைகளில் பயனுள்ளதாக இருந்தாலும், இது குறிப்பிடத்தக்க பாதுகாப்பு வரம்புகளைக் கொண்டுள்ளது மற்றும் முடிந்தவரை தவிர்க்கப்பட வேண்டும். CORS குறுக்கு-மூலத் தொடர்புக்கான விருப்பமான தீர்வாகும், ஏனெனில் இது மிகவும் பாதுகாப்பான மற்றும் நெகிழ்வான பொறிமுறையை வழங்குகிறது.

CORS மற்றும் JSONP இடையே உள்ள முக்கிய வேறுபாடுகள்:

• பாதுகாப்பு: CORS, JSONP ஐ விட பாதுகாப்பானது, ஏனெனில் இது எந்த மூலங்கள் அதன் வளங்களை அணுக அனுமதிக்கப்படுகின்றன என்பதைக் கட்டுப்படுத்த சேவையகத்தை அனுமதிக்கிறது. JSONP எந்த மூலக் கட்டுப்பாட்டையும் வழங்காது.
• HTTP முறைகள்: CORS அனைத்து HTTP முறைகளையும் (எ.கா., GET, POST, PUT, DELETE) ஆதரிக்கிறது, அதே நேரத்தில் JSONP GET கோரிக்கைகளை மட்டுமே ஆதரிக்கிறது.
• பிழை கையாளுதல்: CORS, JSONP ஐ விட சிறந்த பிழை கையாளுதலை வழங்குகிறது. ஒரு CORS கோரிக்கை தோல்வியுற்றால், உலாவி விரிவான பிழை செய்திகளை வழங்குகிறது. JSONP பிழை கையாளுதல், ஸ்கிரிப்ட் வெற்றிகரமாக ஏற்றப்பட்டதா என்பதைக் கண்டறிவதில் மட்டுமே περιορίζεται.

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

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

• உலாவி கன்சோலைச் சரிபார்க்கவும்: உலாவி கன்சோல் பொதுவாக CORS சிக்கல்கள் பற்றிய விரிவான பிழை செய்திகளை வழங்கும்.
• பிணைய கோரிக்கைகளை ஆய்வு செய்யவும்: கோரிக்கை மற்றும் பதில் இரண்டின் HTTP தலைப்புகளை ஆய்வு செய்ய உலாவியின் டெவலப்பர் கருவிகளைப் பயன்படுத்தவும். Origin மற்றும் Access-Control-Allow-Origin தலைப்புகள் சரியாக அமைக்கப்பட்டுள்ளதா என சரிபார்க்கவும்.
• சேவையகப் பக்க உள்ளமைவைச் சரிபார்க்கவும்: உங்கள் சேவையகப் பக்க CORS உள்ளமைவு சரியான மூலங்கள், முறைகள் மற்றும் தலைப்புகளை அனுமதிக்கிறதா என்பதை உறுதிப்படுத்த அதை இருமுறை சரிபார்க்கவும்.
• உலாவி தற்காலிக சேமிப்பை அழிக்கவும்: சில நேரங்களில், தற்காலிகமாக சேமிக்கப்பட்ட முன்-பரிசோதனை பதில்கள் CORS சிக்கல்களை ஏற்படுத்தக்கூடும். உங்கள் உலாவி தற்காலிக சேமிப்பை அழிக்க முயற்சிக்கவும் அல்லது ஒரு தனிப்பட்ட உலாவல் சாளரத்தைப் பயன்படுத்தவும்.
• ஒரு CORS ப்ராக்ஸியைப் பயன்படுத்தவும்: சில சமயங்களில், CORS கட்டுப்பாடுகளைத் தவிர்க்க நீங்கள் ஒரு CORS ப்ராக்ஸியைப் பயன்படுத்த வேண்டியிருக்கலாம். இருப்பினும், ஒரு CORS ப்ராக்ஸியைப் பயன்படுத்துவது பாதுகாப்பு அபாயங்களை அறிமுகப்படுத்தலாம் என்பதை நினைவில் கொள்ளுங்கள்.
• தவறான உள்ளமைவுகளைச் சரிபார்க்கவும்: விடுபட்ட Access-Control-Allow-Origin தலைப்பு, தவறான Access-Control-Allow-Methods அல்லது Access-Control-Allow-Headers மதிப்புகள், அல்லது கோரிக்கையில் தவறான Origin தலைப்பு போன்ற பொதுவான தவறான உள்ளமைவுகளைத் தேடுங்கள்.

முடிவுரை

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

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

மேலும் வளங்கள்

• MDN வலை ஆவணங்கள்: குறுக்கு-மூல வளப் பகிர்வு (CORS)
• W3C: குறுக்கு-மூல வளப் பகிர்வு (CORS)
• PortSwigger வலை பாதுகாப்பு அகாடமி: CORS