உள்ளடக்க அட்டவணை
ஜாவாஸ்கிரிப்ட் என்பது ஒரு நவீன நிரலாக்க மொழியாகும், இது பரந்த மற்றும் மாறும் வலைத்தள உள்ளடக்கத்தை உருவாக்குகிறது. சுவாரஸ்யமாக, இது ஒற்றை நூல் கொள்கையில் செயல்படுகிறது. அதாவது நீங்கள் ஒரு நேரத்தில் ஒரு செயல்பாட்டை மட்டுமே செய்ய முடியும். பொருள்களை நேரடியாக உருவாக்க முடியும், மாறிகளுக்கு நிலையான நிலையான வகைகள் இல்லை.
ஜாவாஸ்கிரிப்ட் பல வலை உருவாக்குநர்களுக்கு எளிதானது, மேலும் அதன் பயன்பாட்டுக் குறியீடு பயனர்கள் மற்றும் எவராலும் அடையக்கூடியது. வலைத்தள உருவாக்குநர்களுக்கு ஜாவாஸ்கிரிப்ட் பயன்படுத்துவதில் இது மிகவும் சவாலான பகுதியாகும். இந்த வழியில், பல தாக்குபவர்கள் வலைத்தளம் மற்றும் வணிகத்திற்கு தீங்கு விளைவிக்கும் வலைத்தள குறியீடு மற்றும் தரவு பாதிப்புகளை எளிதாக அணுகலாம் மற்றும் சுரண்டலாம்.
ஜாவாஸ்கிரிப்ட் உருவாக்கிய குறியீட்டைக் கடக்க அல்லது சேமிக்க, டெவலப்பர்கள் ஜாவாஸ்கிரிப்ட் தெளிவின்மை எனப்படும் நுட்பத்தைப் பயன்படுத்துகின்றனர். இந்த கட்டுரையில், நீங்கள் JavaScript Obfuscator, JS குறியீட்டை எவ்வாறு பாதுகாக்கலாம் மற்றும் சேமிக்கலாம் மற்றும் JS தெளிவின்மையை ஆராய்வீர்கள்.
ஜாவாஸ்கிரிப்ட் தெளிவின்மை என்றால் என்ன?
குறியீட்டைப் பாதுகாப்பதற்கான செயல்முறை, இதில் டெவலப்பர்கள் கோர் குறியீட்டை மனிதர்களால் எளிதில் புரிந்து கொள்ள முடியாத சிக்கலான வடிவத்தில் மாற்றுகிறார்கள் அல்லது மாற்றுகிறார்கள், அதே நேரத்தில் குறியீட்டின் சரியான செயல்பாட்டை உறுதி செய்கிறார்கள். குறியாக்கத்தைப் போலன்றி (மாற்றியமைக்கப்பட்ட குறியீட்டை டிகோட் செய்ய ஒரு விசை தேவைப்படுகிறது), மையக் குறியீட்டை மறுசீரமைக்க தெளிவின்மைக்கு எந்த விசையும் தேவையில்லை.
இந்த நிகழ்முறையின் முக்கிய நோக்கம் அங்கீகரிக்கப்படாத அணுகல், பின்னோக்குப் பொறியியல், மற்றும் அறிவுசார் சொத்து திருட்டு ஆகியவற்றைத் தடுப்பது அல்லது நிறுத்துவதாகும்.
JavaScript தெளிவின்மையை ஏன் பயன்படுத்த வேண்டும்?
தெளிவின்மை பல்வேறு நோக்கங்களுக்கும் நன்மைகளுக்கும் பயன்படுகிறது, இதன் காரணமாக அது பயன்படுத்தப்படுகிறது, அவற்றில் சில கீழே கொடுக்கப்பட்டுள்ளன:
1-திருட்டுக்கு எதிரான பாதுகாப்பு
தெளிவின்மை உங்கள் குறியீடு மற்றும் முக்கியமான தகவல்களை சைபர் திருடர்கள் மற்றும் தாக்குபவர்களிடமிருந்து பாதுகாக்கிறது, இதனால் உங்கள் திட்டத்தின் தனியுரிமையை செயல்படுத்துகிறது.
2-கோபம் தடுப்பு
தெளிவற்ற குறியீடுகள் ஹேக்கர்களுக்கு அவற்றைத் தவறாகப் பயன்படுத்துவதை கடினமாக்கும், இதனால் அவை தீங்கிழைக்கும் நோக்கங்களுக்காகப் பயன்படுத்தப்படலாம்.
3-வணிக நலன்களைப் பாதுகாத்தல்
ஒருவரின் தந்திரோபாயங்கள் மற்றும் உத்திகளின் தனித்துவமான செயலாக்கங்களைப் பாதுகாப்பதன் மூலம் தெளிவின்மை ஒரு போட்டி நன்மையை உறுதி செய்யும்.
4-முக்கியமான தகவல்களைப் பாதுகாத்தல்
சில குறியீடுகளில் முக்கியமான தகவல்கள், விசைகள் அல்லது தர்க்கம் ஆகியவை அடங்கும், அவை செயல்பாட்டிற்கு முக்கியமானவை, ஆனால் பொதுமக்களுக்கு வெளிப்படக்கூடாது, உங்கள் தகவல் கசிவைத் தடுக்கிறது மற்றும் தகவல் உங்களுக்கு மட்டுமே உதவுகிறது.
ஜாவாஸ்கிரிப்ட் தெளிவின்மையின் எடுத்துக்காட்டு பின்வருமாறு:
JS இல் ஹலோ என்ற வார்த்தையின் முக்கிய குறியீடு இதுபோல் தெரிகிறது:
செயல்பாடு வாழ்த்து (பெயர்) {
திரும்ப "வணக்கம், " + பெயர் + "!";
}
தெளிவின்மையின் செயல்பாடு பின்வரும் குறியீட்டை இவ்வாறு மாற்றுகிறது:
செயல்பாடு _0x2c56(_0x1a73){திரும்ப 'வணக்கம், '+_0x1a73+'!';}
இரண்டு குறியீடுகளும் ஒரே பொருளைக் கொண்டுள்ளன, மேலும் அவற்றின் வெளியீடு எந்த வித்தியாசத்தையும் ஏற்படுத்தாது, ஆனால் எழுத்துப்பிழை வேறுபாடு குறியீட்டின் குறிப்பிடத்தக்க பாதுகாப்பை விளைவிக்கிறது. சிக்கலான விஷயங்களை அணுகுவது எப்போதும் மிகவும் கடினம்.
JavaScript தெளிவின்மை எவ்வாறு செயல்படுகிறது?
JS தெளிவின்மையின் வேலை கீழே காட்டப்பட்டுள்ளது.
முழு செயல்முறையும் சில படிகளைப் பின்பற்றுகிறது
1-மாறி மறுபெயரிடல்
இங்கே, விளக்க மாறி பெயர்களை அர்த்தமற்ற சரங்களுடன் மாற்றுவது செய்யப்படுகிறது (எ.கா., பயனர்பெயர் a1b2c3 ஆக மாறும்)
நன்கு புரிந்துகொள்ள ஒரு எடுத்துக்காட்டு கீழே கொடுக்கப்பட்டுள்ளது
அசல் குறியீடு:
செயல்பாடு கணக்கிடுகிறதுமொத்தம் (விலை, வரி) {
திரும்ப விலை + (விலை * வரி);
}
இந்த குறியீடு தெளிவற்ற பிறகு இப்படி இருக்கும்
தெளிவற்ற குறியீடு:
செயல்பாடு _0x45a1(x,y){return x+(x*y);}
2-சரம் & எண் குறியாக்கம்
இது string encryption என்றும் அழைக்கப்படுகிறது. URLகள் அல்லது API கீகள் போன்ற சென்சிட்டிவ் டேட்டாக்கள் குறியீட்டிற்குள் உள்ள ஸ்ட்ரிங்குகளுடன் என்கோட் செய்யப்படும் ஒரு செயல்முறை இது. சரம் குறியாக்கத்தின் எடுத்துக்காட்டு பின்வருமாறு:
அசல் குறியீடு:
const apiKey = "ABC123";
தெளிவற்ற பதிப்பு கீழே கொடுக்கப்பட்டுள்ளது.
தெளிவற்ற குறியீடு:
கான்ஸ்ட் _0x3d2a = "\x41\x42\x43\x31\x32\x33";
3-கட்டுப்பாட்டு ஓட்டம் தட்டையானது
சுருக்கமாக குறியீடு தட்டையாக்குதல் என்று அழைக்கப்படுகிறது. சிக்கலான குறியீடு கட்டமைப்புகள் எளிமைப்படுத்தப்பட்டுள்ளன, முடிந்தவரை வாசிப்புத்தன்மையைக் குறைக்க கருத்துரைகள் அகற்றப்படுகின்றன.
அசல் குறியீடு:
ஒரு எளிய குறியீடு இப்படி இருக்கும்
செயல்பாடு checkAccess(பயனர்) {
என்றால் (user.role === "நிர்வாகி") உண்மை திரும்ப;
இல்லையென்றால் பொய்யைத் திருப்பிக் கொடுங்கள்;
}
தெளிவற்ற குறியீடு:
செயல்பாடு _0x1a2b(_0x3c4d) {
திரும்ப _0x3c4d["\x72\x6f\x6c\x65"] === "\x61\x64\x6d\x69\x6e" ? !0x0 : !0x1;
}
மேலே வழங்கப்பட்ட இரண்டு குறியீடுகளுக்கு இடையிலான வேறுபாட்டிலிருந்து கவனிக்கப்பட்டபடி, வாசிப்புத்திறன் பெரிதும் குறைகிறது.
4-இறந்த குறியீடு செருகல்
இது Code flattening & control flow alteration போன்றது. இது அசல் குறியீட்டில் அர்த்தமற்ற குறியீடு துணுக்குகளைச் சேர்ப்பதாகும், இது குறைவாக படிக்கக்கூடியதாக இருக்கும்.
செயல்பாடு validateஉள்ளீடு (உள்ளீடு) {
(உள்ளீடு.நீளம் > 5) உண்மை என்றால்;
இல்லையென்றால் பொய்யைத் திருப்பிக் கொடுங்கள்;
// கீழே உள்ள இறந்த குறியீடு
const x = 10;
console.log("இது ஒருபோதும் இயங்காது");
}
இந்த குறியீட்டின் இறந்த குறியீடு செருகும் பதிப்பு (தெளிவற்றது) இதுபோல் தெரிகிறது :
செயல்பாடு validateஉள்ளீடு (உள்ளீடு) {
என்றால் (உள்ளீடு.நீளம் > 5) {
// எந்த பயனும் செய்யாத இறந்த குறியீடு
const unusedVar = Math.random() * 100;
console.log("இது இறந்த குறியீட்டின் ஒரு பகுதியாகும்: ", பயன்படுத்தப்படாத Var);
உண்மை திரும்பும்;
} வேறு {
// மேலும் இறந்த குறியீடு கீழே
போலி நிபந்தனை = input.include ("ரகசியம்");
என்றால் (போலி நிபந்தனை) {
console.log ("இந்த நிலை போலி மற்றும் பொருத்தமற்றது");
}
பொய்யைத் திரும்பப் பெறுங்கள்;
}
// அடைய முடியாத இறந்த குறியீடு
const x = 10;
தொடர்ச்சி y = 20;
console.log("இது ஒருபோதும் செயல்படுத்தாது, ஆனால் தாக்குபவர்களைக் குழப்புகிறது: ", x + y);
}
5.Anti-Debugging நுட்பங்கள்
JS இல் உள்ள பிழைத்திருத்த எதிர்ப்பு நுட்பம் தனித்துவமானது மற்றும் பிழைத்திருத்த அறிக்கைகள், கன்சோல் கண்டறிதல் மற்றும் குறியீடு மற்றும் பிழைத்திருத்தத்தைத் தடுக்க நேர தாக்குதல்களை உள்ளடக்கியது.
setInterval(function(){
என்றால் (வகை console._commandLineAPI !== 'வரையறுக்கப்படாத') {
எச்சரிக்கை ("பிழைத்திருத்தம் கண்டறியப்பட்டது!");
window.location.href = "பற்றி: வெற்று";
}
}, 1000);
அதே குறியீடு, JS தெளிவற்ற கருவியைப் பயன்படுத்தி ஒரு தெளிவற்ற பதிப்பாக மாற்றப்படும் போது. பிழைத்திருத்த எதிர்ப்பு கூடுதல் அடுக்கைப் பயன்படுத்துவதன் மூலம் புரிந்துகொள்வதும் பகுப்பாய்வு செய்வதும் கடினமாகிவிட்டது.
தெளிவற்ற குறியீடு:
(சார்பு () {
var _0x3c87 = ['_commandLineAPI', 'வரையறுக்கப்படாத', 'பற்றி:வெற்று'];
(செயல்பாடு (_0x4d1b99, _0x1ea782) {
var _0x223b1b = function (_0x234219) {
போது (--_0x234219) {
_0x4d1b99['தள்ளு'](_0x4d1b99['ஷிப்ட்']());
}
};
_0x223b1b(++_0x1ea782);
}(_0x3c87, 0x18f));
var _0x4a68 = function (_0x4d1b99, _0x1ea782) {
_0x4d1b99 = _0x4d1b99 - 0x0;
var _0x223b1b = _0x3c87[_0x4d1b99];
_0x223b1b திரும்பவும்;
};
setInterval(function () {
என்றால் (கன்சோல் வகை[_0x4a68('0x0')] !== _0x4a68('0x1')) {
எச்சரிக்கை ('பிழைத்திருத்தி கண்டறியப்பட்டது!');
சாளரம் ['இடம்'] ['href'] = _0x4a68('0x2');
}
}, 0x3e8);
})();
இவை ஒரு நேரடியான மற்றும் அத்தியாவசிய குறியீட்டை எவ்வாறு மிக உயர்ந்த சிரமத்திற்கு மாற்ற முடியும் என்பதற்கான சில எளிய படிகள் (நுட்பங்கள்) ஆகும், இது ஒரு தெளிவற்ற கருவியைப் பயன்படுத்தி மிகவும் மேம்பட்ட மற்றும் சிக்கலான குறியீடு போல் தோற்றமளிக்கிறது.
ஜாவாஸ்கிரிப்டில் குழப்பத்திற்கான பரிந்துரைகளைப் பயிற்சி செய்யுங்கள்
JS இல் தெளிவின்மையின் சிறந்த நடைமுறைக்கு, அதை நடைமுறையில் வைக்க பல பரிந்துரைகள் உள்ளன.
நம்பகமான கருவிகளின் தேர்வு
வலுவான மாற்றங்களை அகற்ற JavaScript Obfuscator அல்லது UglifyJS போன்ற நம்பகமான தெளிவின்மைகளின் செயல்பாடு.
2-பிற பாதுகாப்பு நடவடிக்கைகளுடன் குழப்பம்
தெளிவின்மை என்பது பாதுகாப்பின் தொடக்க அடுக்கு. கடுமையான சோதனை, பாதுகாப்பான குறியீட்டு நடைமுறைகள் போன்ற பல்வேறு நுட்பங்களுடன் இதை இணைப்பது உங்கள் திட்டத்திற்கு உடைக்க முடியாத பாதுகாப்பை சேர்க்கலாம்.
3-குறியீடு ஆவணம்
அசல் குறியீட்டின் தெளிவான பதிப்பைச் சேமிக்கவும், எதிர்கால பிழைத்திருத்தத்திற்காக பட்டயம் செய்யவும். இது உங்கள் அசல் குறியீட்டை அணுக உங்களை அனுமதிக்கும், இதனால் திருத்த செயல்முறையை எளிதாக்குகிறது.
4-சுறுசுறுப்பு
வளர்ந்து வரும் அச்சுறுத்தல்கள் குறித்து புதுப்பித்த நிலையில் இருங்கள் மற்றும் அதற்கேற்ப உங்கள் தெளிவற்ற தந்திரோபாயங்களை மாற்றவும்.
நெறிமுறை பரிசீலனைகள்
தெளிவின்மை என்ற யோசனை சைபர் தாக்குதல்களிலிருந்து உங்கள் திட்டங்களின் நெறிமுறை பாதுகாப்பு உணர்வுடன் வந்தது. எனவே, அதன் தவறான பயன்பாடு மோசமான சூழ்நிலைகளுக்கு வழிவகுக்கும், அதாவது:
1-தீம்பொருளைப் பயன்படுத்துதல்
சைபர் கிரைமினல்கள் பெரும்பாலும் தங்கள் ஆபத்தான ஸ்கிரிப்ட்கள் அல்லது குற்றவியல் பதிவுகளை மறைக்க தெளிவற்ற நுட்பத்தைப் பயன்படுத்துகின்றனர்.
2-ஏமாற்றும் நடைமுறைகள்
தெளிவின்மை ஒருவரின் தனியுரிமை, டிராக் ஸ்கிரிப்ட்கள் போன்றவற்றையும் ஆக்கிரமிக்கலாம். இத்தகைய நுட்பங்களின் சரியான பயன்பாட்டைக் கருத்தில் கொள்வது எப்போதும் அவசியம். இதுபோன்ற விஷயங்களுக்கு மத்தியில் சமநிலையைப் பேணுவது தெளிவின்மையைச் செய்வதற்கான முதல் படியாகும்.
தெளிவின்மையின் வரம்புகள்
உங்கள் குறியீடு மற்றும் திட்டங்களைப் பாதுகாக்க தெளிவின்மையைப் பயன்படுத்துவது மிகவும் நன்மை பயக்கும் என்றாலும், அது முட்டாள்தனமானது அல்ல. இதைப் பயன்படுத்தும் போது உங்களை எரிச்சலடையச் செய்யும் சில வரம்புகள் உள்ளன. அதன் பூர்த்தி செய்யப்படாத சில இடைவெளிகள் கீழே விவாதிக்கப்படுகின்றன:
1-செயல்திறன் தாக்கம்:
உங்கள் குறியீடு தேவையானதை விட அதிகமாக தெளிவற்றதாக இருந்தால், அது உங்கள் குறியீட்டின் இயக்க நேரத்தை எதிர்மறையாக பாதிக்கும், முக்கியமாக டைனமிக் தலைமுறை அல்லது தேவையற்ற குறியீடு முறைகள் பயன்படுத்தப்பட்டால்.
2-முழுமையான பாதுகாப்பு இல்லாமை:
நிபுணத்துவம் வாய்ந்த ஹேக்கர்கள் அல்லது தாக்குபவர்கள் உங்கள் ஏற்கனவே தெளிவற்ற குறியீட்டில் குழப்பத்தைப் பயன்படுத்தலாம், இறுதியில் உங்கள் குறியீட்டின் பாதுகாப்பை விட்டுவிடாது.
3-பிழைத்திருத்த சவால்கள்:
தெளிவற்ற குறியீடு அதன் பாதுகாப்பிற்காக பயன்படுத்தப்படும் தேவையற்ற வரிகளைச் சேர்ப்பதன் காரணமாக பிழைத்திருத்தம், பராமரிப்பு அல்லது உருவாக்க எப்போதும் தந்திரமானது. அசல் குறியீடு மற்றும் தெளிவற்ற குறியீட்டின் மேம்பாட்டுக் குழுவின் பகுதியாக இல்லாத நிரலாளர்களுக்கு இது இன்னும் கடினம்.
4-இணக்கத்தன்மை சிக்கல்கள்:
குறிப்பிட்ட தெளிவற்ற நுட்பங்கள் அனைத்து உலாவிகள் அல்லது சூழல்களிலும் அணுக முடியாது, இதனால் குறியீட்டின் வெளியீடு அல்லது செயல்பாட்டில் தொழில்நுட்ப சிக்கல்களின் வாய்ப்புகளை அதிகரிக்கிறது.
முடிவு
ஜாவாஸ்கிரிப்ட் தெளிவின்மை என்பது திருட்டு, ஹேக்கர்கள், தாக்குபவர்கள், சேதப்படுத்துதல் மற்றும் தலைகீழ் பொறியியல் ஆகியவற்றிலிருந்து ஒருவரின் குறியீட்டைப் பாதுகாக்க ஒரு சக்திவாய்ந்த மற்றும் நன்மை பயக்கும் கருவியாகும். குறியீட்டு முறை மூலம் உங்கள் கணினியில் சேமிக்கப்பட்ட உங்கள் முக்கியமான தகவல் மற்றும் அறிவுசார் சொத்துக்கான பாதுகாப்பு கவசமாக இது இருக்கும்போது, இது பாதுகாப்புக்கு நிரந்தர அல்லது வெல்ல முடியாத தீர்வு அல்ல.
டெவலப்பர் வெறுமனே இருட்டடிப்பை மட்டுமே நம்பக்கூடாது. அதன் நுட்பங்கள், நன்மைகள் மற்றும் வரம்புகள் பற்றிய போதுமான அறிவைப் புரிந்துகொள்வதன் மூலமும், பெறுவதன் மூலமும், டெவலப்பர்கள் உங்கள் குறியீட்டின் இறுதிப் பாதுகாப்பிற்காக அதை மிகவும் மதிப்புமிக்கதாகவும் பயனுள்ளதாகவும் மாற்ற முடியும்.
இது சில நன்மைகள், வரம்புகள் மற்றும் ஒரு செயல்முறை அல்லது நுட்பம் இருக்க வேண்டிய அனைத்தையும் கொண்டிருந்தாலும், அதன் உண்மையான சக்தி இது ஒரு அடுக்கு பாதுகாப்பு மூலோபாயத்தின் ஒரு பகுதியாக உள்ளது; வேறு எவரையும் விட உங்களுக்கு மிகவும் பயனுள்ள, உதவியான மற்றும் உற்பத்தி செய்ய நீங்கள் போதுமான பயிற்சி செய்ய வேண்டும். இது எப்போதும் வளர்ந்து வரும் டிஜிட்டல் நிலப்பரப்பில் உங்கள் ஜாவாஸ்கிரிப்ட் குறியீட்டின் ஒருமைப்பாடு, ரகசியத்தன்மை மற்றும் நம்பகத்தன்மையை உறுதிப்படுத்த உதவுகிறது.
சுருக்கமாக, இது உங்கள் தனியுரிமையைப் பராமரிக்க உதவும் ஒரு கருவியாகும், மேலும் உங்கள் தகவலைப் பாதுகாக்க மிகவும் பயனுள்ள வழிகளைப் பற்றி சிந்திக்க உங்களைத் தூண்டுகிறது.
உங்கள் வலை அபிவிருத்தியை மேம்படுத்துவதற்கான கூடுதல் கருவிகளுக்கு, பாருங்கள்:
மேலும் பாதுகாப்பு கருவிகளுக்கு, UrwaTools பாதுகாப்புப் பிரிவைப் பார்வையிடவும்.
