Linux-ல் sha256sum மூலம் கோப்புகளைச் சரிபார்ப்பது எப்படி?

இரண்டு நிமிடங்களில் checksum மூலம் பதிவிறக்கத்தைச் சரிபார்த்தல்

ஒரு பதிவிறக்கத்தைச் சரிபார்க்க, நீங்கள் பெற்ற கோப்பை hash செய்து, வெளியீட்டாளர் வழங்கிய hash மதிப்புடன் ஒப்பிட வேண்டும். sha256sum இந்த இரண்டு பணிகளையும் செய்கிறது: இது தனியாக இயங்கும்போது ஒரு digest-ஐ உருவாக்குகிறது, மேலும் -c உடன் இயங்கும்போது, digest பட்டியலைப் படித்து எந்தெந்த கோப்புகள் சரியாக உள்ளன என்பதைத் தெரிவிக்கிறது. இந்த வழிகாட்டி நீங்கள் உருவாக்கும் ஒரு கோப்பில் முழு செயல்முறையையும் செய்து காட்டுகிறது; பின்னர், தோல்வி எவ்வாறு நிகழ்கிறது என்பதை நீங்கள் நேரடியாகப் பார்க்க, அந்தக் கோப்பை வேண்டுமென்றே மாற்றுகிறது.

இந்த முழு செயல்முறையின் போதும் ஒரு விஷயத்தை நினைவில் கொள்ளுங்கள். ஒரு checksum என்பது உங்களிடம் உள்ள bytes-கள் அந்த digest-ஐ உருவாக்கிய அதே bytes-களா என்பதை மட்டுமே உறுதிப்படுத்தும்; அதை உருவாக்கியவர் யார் என்பதை அது கூறாது. அந்த இரண்டாவது கேள்விக்கு ஒரு signature மற்றும் நீங்கள் நம்பும் ஒரு key தேவை. இந்த வழிகாட்டியின் கடைசி பகுதி, இந்த இரண்டிற்கும் இடையிலான வேறுபாட்டைத் தெளிவாக விளக்குகிறது.

பயிற்சிக்கான ஒரு கோப்பை உருவாக்குதல்

மற்ற கோப்புகளைப் பாதிக்காதவாறு, ஒரு scratch directory-ல் வேலை செய்யவும். கீழே உள்ள அனைத்து கட்டளைகளும் GNU coreutils தொகுப்பிலிருந்து வருபவை. இவை எந்தவொரு Ubuntu அல்லது Debian server-லும் இயல்பாகவே இருக்கும், எனவே எதையும் புதிதாக நிறுவ வேண்டியதில்லை.

mkdir -p ~/checksum-demo
cd ~/checksum-demo
printf 'the payload of a totally ordinary download\n' > payload.txt
sha256sum payload.txt

உங்களுக்கு ஒரு வரி கிடைக்கும்: 64 hexadecimal எழுத்துக்கள், இரண்டு இடைவெளிகள், அதன் பிறகு கோப்பின் பெயர். அந்த 64 எழுத்துக்களும் கோப்பின் digest ஆகும். hashing என்பது deterministic என்பதால், மீண்டும் அதே கட்டளையை இயக்கினால் அதே வரிதான் கிடைக்கும்: ஒரே உள்ளீடு எப்போதும் ஒரே வெளியீட்டையே தரும். கோப்பில் ஒரு எழுத்தை மாற்றிவிட்டு மீண்டும் இயக்கினால், digest சிறிதளவு மாறாது. அது முற்றிலும் மாறுபட்டதாகத் தோன்றும், ஏனெனில் உள்ளீட்டில் ஒரு பிட் (bit) மாறினாலும், வெளியீட்டில் பாதி பிட்கள் மாறிவிடும். இந்தத் தன்மையே 64-எழுத்து நீளமுள்ள ஒரு சரத்தை, 4 GB அளவுள்ள ஒரு கோப்பிற்குப் பதிலாகப் பயன்படுத்தக்கூடியதாக மாற்றுகிறது.

SHA256SUMS கோப்பைச் சேமித்து, அதைச் சரிபார்த்தல்

திரையில் தோன்றும் digest ஒரு நாள் கழித்துப் பயனற்றது. அதை ஒரு கோப்பில் எழுதவும்; sha256sum எந்த வடிவத்தில் எழுதுமோ அதே வடிவத்தில் எழுதினால், பிற்காலத்தில் அந்த கருவி அதை மீண்டும் வாசிக்க முடியும்.

sha256sum payload.txt > SHA256SUMS
cat SHA256SUMS
sha256sum -c SHA256SUMS

sha256sum -c அந்தப் பட்டியலில் உள்ள ஒவ்வொரு வரியையும் வாசித்து, அந்த வரியில் குறிப்பிடப்பட்டுள்ள கோப்பின் hash-ஐக் கணக்கிட்டு, இரண்டு digest-களையும் ஒப்பிடும். சரியாக இயங்கினால், ஒவ்வொரு கோப்பிற்கும் ஒரு வரி வெளியீடாக வரும்:

payload.txt: OK

Exit status-ஐயும் சரிபார்க்கவும், ஏனெனில் ஒரு script அந்த உரையை வாசிக்காமல் status-ஐ மட்டுமே வாசிக்கும். வெற்றிகரமாக இயங்கிய பிறகு echo $?, 0-ஐ வெளியிடும். SHA256SUMS என்ற பெயர் ஒரு விதியல்ல, ஒரு மரபு மட்டுமே. இருப்பினும், Linux distributions மற்றும் பெரும்பாலான release பக்கங்கள் இதையே பயன்படுத்துவதால், நீங்களும் இதையே பயன்படுத்தவும். அப்போதுதான் கோப்பைத் திறக்காமலேயே அதில் என்ன உள்ளது என்பதை அடுத்த நபர் புரிந்துகொள்ள முடியும்.

ஒரு பைட்டை மாற்றி, சரிபார்ப்பு தோல்வியடைவதைக் கவனித்தல்

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

printf 'X' | dd of=payload.txt bs=1 seek=5 conv=notrunc status=none
cat payload.txt
sha256sum -c SHA256SUMS

conv=notrunc என்பது முக்கியமான flag ஆகும். இது இல்லையென்றால், dd எழுதும் பணியை நிறுத்தும் இடத்தில் கோப்பை வெட்டிவிடும் (truncate). அப்போது நீங்கள் மிகவும் வெளிப்படையான பாதிப்பைச் சோதிக்க வேண்டியிருக்கும். இப்போது சரிபார்ப்பு பின்வருமாறு அச்சிடும்:

payload.txt: FAILED
sha256sum: WARNING: 1 computed checksum did NOT match

echo $? என்பது 1-ஐ அச்சிடுகிறது. FAILED என்பது கோப்பு வாசிக்கப்பட்டதையும், அதன் digest பட்டியலில் உள்ளதோடு பொருந்தவில்லை என்பதையும் குறிக்கிறது. அசல் பைட்டுகளை மீண்டும் வைத்துவிட்டு, சரிபார்ப்பு மீண்டும் OK-க்கு திரும்புவதை உறுதி செய்யவும்:

printf 'the payload of a totally ordinary download\n' > payload.txt
sha256sum -c SHA256SUMS

இதுவே முழுமையான நடைமுறை. கோப்பின் எந்த இடத்தில் ஒரு பைட் மாறினாலும், அது FAILED-ஐ உருவாக்கும். இணைப்பு துண்டிக்கப்பட்டதால் பாதியில் நின்ற download, பழைய build-ஐ வழங்கும் mirror, இடையில் கோப்பை மாற்றிய proxy, அல்லது பழுதடைந்த block-ஐத் தரும் disk என எதுவாக இருந்தாலும், அவை அனைத்தும் இதே முடிவையே தரும்.

நீங்கள் பதிவிறக்கம் செய்யாத கோப்பு பட்டியலில் இருக்கும்போது

ஒரு விநியோகத்திலிருந்து பெறப்பட்ட உண்மையான SHA256SUMS கோப்பு, அந்தத் திட்டம் வெளியிடும் (ships) அனைத்து இமேஜுகளையும் பட்டியலிடும், ஆனால் நீங்கள் அதில் ஒன்றை மட்டுமே பதிவிறக்கம் செய்திருப்பீர்கள். அந்தச் சூழலை இங்கே மீண்டும் உருவாக்குவோம்.

printf 'a second file\n' > notes.txt
sha256sum payload.txt notes.txt > SHA256SUMS.all
rm notes.txt
sha256sum -c SHA256SUMS.all

payload.txt: OK
sha256sum: notes.txt: No such file or directory
notes.txt: FAILED open or read
sha256sum: WARNING: 1 listed file could not be read

FAILED open or read என்பது FAILED-லிருந்து மாறுபட்ட ஒரு தோல்வியாகும், இரண்டையும் குழப்பிக்கொள்வது நேரத்தை வீணடிக்கும். FAILED என்பது பைட்டுகள் தவறாக இருப்பதைக் குறிக்கிறது. FAILED open or read என்பது sha256sum கோப்பையே பெறவில்லை என்பதைக் குறிக்கிறது, எனவே எந்த ஒப்பீடும் நடக்கவில்லை. உண்மையான பதிவிறக்கத்தின் போது, இதற்கு வழக்கமான காரணம் பணிபுரியும் கோப்பகம் (working directory) ஆகும், ஏனெனில் பட்டியலில் உள்ள பெயர்கள் நீங்கள் கட்டளையை இயக்கும் இடத்தைப் பொறுத்தே அமையும். கோப்பு இருக்கும் கோப்பகத்திற்குச் சென்று கட்டளையை மீண்டும் இயக்கவும். உங்களிடம் உள்ளவற்றை மட்டும் சரிபார்க்க, அதைக் குறிப்பிடவும்:

sha256sum --ignore-missing -c SHA256SUMS.all

இது payload.txt: OK என்பதை அச்சிட்டு, 0 என்ற நிலையில் வெளியேறும். பட்டியலிடப்பட்ட கோப்புகள் எதுவும் இல்லை என்றால், --ignore-missing பூஜ்ஜிய கோப்புகளை வைத்து அமைதியாக வெற்றி பெறாது. அது no file was verified என்று தெரிவித்து, பூஜ்ஜியமற்ற நிலையில் வெளியேறும். இதுவே நீங்கள் எதிர்பார்க்கும் செயல்பாடு, ஏனெனில் எதையும் சரிபார்க்காத ஒரு வெற்றி, நீங்கள் கவனிக்கத் தவறிவிடும் தோல்வியாக அமைந்துவிடும்.

வெளியிடப்பட்ட digest-ஐ சரிபார்க்காமல் அப்படியே நகலெடுத்தல்

64 hexadecimal எழுத்துக்களைக் கண்களால் ஒப்பிடுவதுதான் இந்த பழக்கத்தின் மிகப்பெரிய பலவீனம். மக்கள் முதல் நான்கு மற்றும் கடைசி நான்கு எழுத்துக்களை மட்டும் சரிபார்த்துவிட்டு அது சரியாக இருப்பதாகக் கருதுகின்றனர்; ஒரு தாக்குதல் நடத்துபவர் சரியாக இதைத்தான் எதிர்பார்க்கிறார். அதற்குப் பதிலாக கருவியையே ஒப்பிடச் சொல்லுங்கள். வெளியீட்டாளரிடமிருந்து நீங்கள் நகலெடுத்த digest-ஐ EXPECTED-ல் அமைக்கவும். EXPECTED=-ஐத் தொடர்ந்து நகலெடுத்த மதிப்பை உள்ளிடவும், பின் -c எதிர்பார்க்கும் ஒற்றை வரியை உருவாக்கவும்:

printf '%s  %s\n' "$EXPECTED" payload.txt > payload.sha256
cat payload.sha256
sha256sum -c payload.sha256

Digest மற்றும் கோப்பின் பெயருக்கு இடையே இரண்டு இடைவெளிகள் (spaces) உள்ளன, அதனால்தான் format string-ல் இரண்டு இடைவெளிகள் பயன்படுத்தப்படுகின்றன. இதுவே sha256sum எழுதும் வடிவம் மற்றும் -c பகுப்பாய்வு செய்யும் வடிவம் ஆகும். ஒரு கோப்பில் digest மட்டும் இருந்து வேறு எதுவும் இல்லை என்றால், அது checksum வரி அல்ல; எனவே no properly formatted checksum lines found பிழையுடன் அந்தச் சரிபார்ப்பு நிராகரிக்கப்படும், எந்தக் கோப்பைக் குறிப்பிடுகிறீர்கள் என்று அது ஊகிக்காது. சில திட்டங்கள் BSD tagged பாணியைப் பயன்படுத்துகின்றன, அதாவது SHA256 (payload.txt) = -ஐத் தொடர்ந்து digest இருக்கும். GNU coreutils இந்த வடிவத்தை sha256sum --tag payload.txt மூலம் எழுதி -c மூலம் மீண்டும் படிக்கிறது, எனவே எந்த வடிவத்தையும் நீங்கள் சேமிக்கலாம்.

ஒரு சரிபார்ப்பு விசித்திரமாகச் செயல்பட்டால், cat -A SHA256SUMS மூலம் பட்டியலைப் பார்க்கவும். இது ஒவ்வொரு வரியின் முடிவையும் $ மூலம் குறிக்கும் மற்றும் கண்ணுக்குத் தெரியாத எழுத்துக்களைக் காட்டும். ஒரு வரி ^M$-ல் முடிந்தால், அது Windows editor-லிருந்து ஒரு carriage return-ஐப் பெற்றுள்ளது என்று அர்த்தம். GNU sha256sum அந்த trailing எழுத்தைப் புறக்கணித்துவிட்டு OK என்று அச்சிடும், எனவே CRLF பட்டியல் உங்கள் சரிபார்ப்பைப் பாதிக்காது. இருப்பினும், coreutils-க்கு வெளியே உள்ள கருவிகள் இதை அவ்வளவு எளிதாக எடுத்துக்கொள்ளாது. நீங்கள் வைத்திருக்கும் நகலை tr -d '\r' < SHA256SUMS > SHA256SUMS.clean மூலம் சீராக்கிக் கொள்ளவும்.

Checksum எதை உறுதிப்படுத்துகிறது, எதை உறுதிப்படுத்தாது?

ஒரு checksum ஒரே ஒரு விஷயத்தை மட்டுமே உறுதிப்படுத்துகிறது: உங்கள் disk-ல் உள்ள bytes-ம், வெளியிடப்பட்ட digest-ஐ உருவாக்கிய bytes-ம் ஒன்றுதான். இது தற்செயலாக ஏற்படும் கோப்புகளைச் சிதைக்கும் பாதிப்புகளை முழுமையாகத் தடுக்கும். மேலும், ஒரு download mirror-ல் கோப்பை மாற்றிய, ஆனால் digest வெளியிடப்பட்ட பக்கத்தை அணுக முடியாத கவனக்குறைவான தாக்குதல் நடத்துபவர்களிடமிருந்தும் இது பாதுகாக்கும்.

இது கோப்பின் ஆசிரியர் யார் என்பதைப் பற்றி எதையும் உறுதிப்படுத்தாது. ஒரு digest என்பது bytes பற்றிய தகவலே தவிர, நபர்களைப் பற்றியது அல்ல. ஒரே பக்கம் கோப்பையும் digest-ஐயும் வழங்கினால், இரண்டையும் மாற்றக்கூடிய எவராலும் அந்த digest-ஐயும் மாற்ற முடியும். அப்போது உங்கள் OK வரி, அந்த mirror தன்னுடன் தானே ஒத்துப்போகிறது என்பதை மட்டுமே குறிக்கும். எனவே, checksum-களைப் பயன்படுத்துவதை அர்த்தமுள்ளதாக்கும் விதி இதுதான்: கோப்பை எடுத்த இடத்திலிருந்து digest-ஐ எடுக்காதீர்கள். உதாரணமாக, கோப்பை ஒரு mirror அல்லது torrent மூலம் பெற்றுவிட்டு, digest-ஐ அந்தத் திட்டத்தின் சொந்த domain-ல் TLS (transport layer security) மூலம் பெறுங்கள். இப்போது ஒரு தாக்குதல் நடத்துபவர் ஒரு இடத்திற்குப் பதிலாக இரண்டு இடங்களைக் கட்டுப்படுத்த வேண்டிய கட்டாயம் ஏற்படும்.

பயன்படுத்தப்படும் algorithm-ம் முக்கியமானது. SHA-256 (secure hash algorithm, 256-bit output) முறையில் ஆகஸ்ட் 2026 நிலவரப்படி எந்தவிதமான collision-ம் கண்டறியப்படவில்லை, அதனால்தான் வெளியீட்டாளர்கள் இதைப் பயன்படுத்துகின்றனர். MD5 (message digest 5) மற்றும் SHA-1 ஆகியவை தற்போதைய பாதுகாப்புத் தரத்திற்குப் பொருந்தாது: ஒரே MD5 digest-ஐக் கொண்ட இரண்டு வெவ்வேறு கோப்புகளை 2004-லேயே உருவாக்க முடிந்தது, மேலும் 2020-ல் chosen-prefix SHA-1 collision முறை வெளியிடப்பட்டது. ஒரு MD5SUMS கோப்பு, முழுமையற்ற download-ஐ இன்னும் கண்டறியும், ஏனெனில் தற்செயலான சிதைவு என்பது திட்டமிட்டு உருவாக்கப்பட்ட collision அல்ல. ஆனால், உங்களை ஏமாற்ற முயற்சிப்பவரை இது தடுக்காது. ஒரு திட்டம் இரண்டையும் வெளியிட்டால், SHA-256 வரியையே பயன்படுத்துங்கள்.

கையொப்பங்கள் பொறுப்பேற்கும் இடம்

ஒரு digest விட்டுச்செல்லும் இடைவெளியை ஒரு கையொப்பம் (signature) நிரப்புகிறது. வெளியீட்டாளர் ஒரு private key-ஐப் பயன்படுத்தி digest கோப்பில் கையொப்பமிடுகிறார்; நீங்கள் அதை அவர்களின் public key-ஐக் கொண்டு சரிபார்க்கிறீர்கள்: gpg --verify SHA256SUMS.asc SHA256SUMS. இது சரியாக இருந்தால், அந்த digest பட்டியல் அந்த key-ஐ வைத்திருப்பவரிடமிருந்து வந்தது என்பது உறுதியாகிறது. பின்னர், sha256sum -c SHA256SUMS உங்கள் வட்டில் உள்ள கோப்பை அந்தப் பட்டியலுடன் இணைக்கிறது; இதன் மூலம் key-லிருந்து கோப்பின் bytes வரை ஒரு நம்பகமான சங்கிலி உருவாகிறது.

இப்போது பலவீனம் key-க்கு மாறுகிறது. கோப்பைப் பதிவிறக்கிய அதே பக்கத்திலிருந்து key-யையும் பதிவிறக்கினால், தாக்குபவர் இரண்டு பகுதிகளையும் உங்களிடம் வழங்க வாய்ப்புள்ளது. GnuPG இதை வெளிப்படையாகக் கூறுகிறது; முதல்முறை சரிபார்க்கும்போது Good signature உடன் WARNING: This key is not certified with a trusted signature!-ஐயும் அது அச்சிடும். Good signature என்பது கணித ரீதியாகச் சரி என்பதைக் குறிக்கிறது. ஆனால், அந்த key நீங்கள் எதிர்பார்க்கும் திட்டத்திற்குத்தான் சொந்தமானது என்று இது அர்த்தமல்ல. எனவே, அந்தத் திட்டத்தின் ஆவணங்கள் உள்ள வேறொரு தளம் அல்லது ஏற்கனவே அந்த key-ஐ உள்ளடக்கிய distribution package போன்ற மற்றொரு ஆதாரத்திலிருந்து fingerprint-ஐப் பெற்று, கடைசி எட்டு எழுத்துக்களை மட்டும் பார்க்காமல் முழு fingerprint-ஐயும் ஒப்பிட்டுப் பார்க்கவும். இதற்கான காரணம் SSH private key-க்கு அளிக்கப்படும் அதே பாதுகாப்பு, ஏனெனில் key என்பதுதான் நம்பிக்கையைத் தீர்மானிக்கும் காரணி; அதற்குப் பிறகு வரும் அனைத்தும் அந்த நம்பிக்கையையே அடிப்படையாகக் கொள்கின்றன.

Reproducible builds இந்தச் சிந்தனையை அடுத்த கட்டத்திற்கு எடுத்துச் செல்கின்றன. வெளியிடப்பட்ட digest, ஒரு இயந்திரத்தில் உருவாக்கப்பட்ட binary-யுடன் உங்களை இணைக்கிறது. ஒரு திட்டத்தின் build reproducible ஆக இருக்கும்போது, எவரும் அதே source-ஐ compile செய்து byte-க்கு-byte ஒத்த வெளியீட்டைப் பெற முடியும். இதனால், ஒரு server-ன் வார்த்தையை மட்டும் நம்புவதற்குப் பதிலாக, சுயாதீனமான உருவாக்குநர்கள் வெளியிடப்பட்ட digest-ஐ உறுதிப்படுத்த முடியும். தானியங்கி pipelines மற்றும் இயந்திரத்தால் எழுதப்பட்ட patches மூலம் அதிகப்படியான code வருவதால், இது ஒவ்வொரு ஆண்டும் முக்கியத்துவம் பெறுகிறது. ஒரு build-ல் எதை ஏற்றுக்கொள்வது என்பது ஒரு கொள்கை சார்ந்த முடிவு; AI உதவியுடன் எழுதப்பட்ட code-க்கான open source கொள்கைகள் அதே supply chain-ன் மறுமுனையில் செயல்படுகின்றன.

உங்கள் package manager இதையே உங்களுக்காக ஏற்கனவே செய்கிறது

Debian மற்றும் Ubuntu-வில், apt எந்தக் கட்டளையும் இன்றி ஒவ்வொரு நிறுவலின் போதும் இந்தச் சங்கிலித் தொடரை இயக்குகிறது. ஒவ்வொரு .deb கோப்பிற்கும் ஒரு SHA-256 digest-ஐ package index கொண்டுள்ளது. Release கோப்பு அந்த index கோப்புகளின் digest-களைக் கொண்டுள்ளது, மேலும் InRelease என்பது Release-ன் மீதுள்ள கையொப்பத்தைக் கொண்டுள்ளது; இது /usr/share/keyrings மற்றும் /etc/apt/trusted.gpg.d-ல் உள்ள சாவிகளுடன் (keys) ஒப்பிட்டுச் சரிபார்க்கப்படுகிறது. இந்தச் சங்கிலித் தொடர் உடையும்போது, apt அதைத் தெரிவிக்கும்: மூன்றாம் தரப்பு repository-ன் சாவி விடுபட்டிருந்தால் The following signatures couldn't be verified because the public key is not available: NO_PUBKEY என்றும், நீங்கள் பெற்ற index கோப்பு கையொப்பமிடப்பட்ட Release-உடன் பொருந்தவில்லை என்றால் Hash Sum mismatch என்றும் காட்டும். இது பொதுவாக, ஒரு caching proxy பழைய கோப்பை வழங்கியதாலோ அல்லது mirror server sync-ஆகி கொண்டிருக்கும்போது நீங்கள் தரவிறக்கம் செய்ததாலோ நிகழ்கிறது.

ஒரு திட்டத்தின் முகப்புப் பக்கம் curl-லிருந்து ஒரு script-ஐ நேரடியாக shell-க்கு pipe செய்யச் சொல்லும்போது, இதையே தரநிலையாகக் கொண்டு ஒப்பிட வேண்டும். இதில் எந்த bytes-ம் சரிபார்க்கப்படுவதில்லை, மேலும் நீங்கள் அவற்றைப் பார்க்கவும் முடியாது. server ஒரு script-க்கு ஒரு விஷயத்தையும், browser-க்கு வேறொன்றையும் வழங்க முடியும்; சரிபார்ப்பதற்கு உங்களிடம் எந்தப் பிரதியும் இருக்காது. curl -fsSL <url> -o install.sh மூலம் ஒரு கோப்பாகத் தரவிறக்கம் செய்து, அதன் hash-ஐச் சரிபார்த்து, less மூலம் வாசித்த பிறகு மட்டுமே அதை இயக்கவும். இந்த வழக்கத்திற்கு சுமார் இருபது நொடிகள் மட்டுமே ஆகும். புதிதாக வாங்கிய VPS-ன் முதல் பத்து நிமிடங்களில், வேறு எதையும் நிறுவும் முன்பே இதைப் பின்பற்றுவது அவசியமானது.

கைமுறையாக நிறுவும் கோப்புகளின் digests பட்டியலைப் பராமரித்தல்

apt மூலம் நிறுவப்படும் தொகுப்புகள் கண்காணிக்கப்படுகின்றன. நீங்கள் /usr/local/bin-க்குள் நகலெடுத்த ஒரு binary கோப்பு அவ்வாறு கண்காணிக்கப்படுவதில்லை, மேலும் கணினியில் உள்ள எந்தவொரு கருவியும் அதைக் கவனிப்பதில்லை. ஒரு digest பட்டியல் இருந்தால், அதைத் தேவைப்படும்போது சரிபார்க்க முடியும்:

printf 'a second file\n' > notes.txt
sha256sum *.txt > inventory.sha256
sha256sum -c --quiet inventory.sha256

அனைத்து கோப்புகளும் சரியாக இருக்கும்போது --quiet எதையும் அச்சிடாது; ஏதேனும் கோப்பு மாறினால் மட்டுமே தோல்வியடைந்த வரிகளை அச்சிடும். எனவே, அமைதி என்பது வெற்றி என்பதைக் குறிக்கும், மேலும் echo $? அதை 0 மூலம் உறுதிப்படுத்தும். இதைத்தான் நீங்கள் திட்டமிடப்பட்ட பணியில் (scheduled job) பயன்படுத்த வேண்டும். --status இன்னும் ஒரு படி மேலே சென்று எதையுமே அச்சிடாது, அதன் exit status-ஐ மட்டும் உங்களுக்கு வழங்கும். இதே முறையை sha256sum /usr/local/bin/* > ~/local-bin.sha256 மூலம் உண்மையான கோப்புகளுக்குப் பயன்படுத்தினால், உங்களிடம் ஒரு baseline தயாராகிவிடும். கோப்புப் பாதைகள் (paths) நீங்கள் தட்டச்சு செய்தபடியே பட்டியலில் சேமிக்கப்படும், எனவே absolute paths-ஐப் பயன்படுத்தினால் எந்தக் கோப்பகத்திலிருந்தும் சரிபார்ப்பைச் செய்ய முடியும்.

இந்த baseline-ன் மதிப்பு என்ன என்பதைத் தெளிவாகப் புரிந்துகொள்ளுங்கள். இது மாற்றப்பட்ட ஒரு கோப்பைக் கண்டறியும். ஆனால், ஏற்கனவே root அனுமதியைப் பெற்ற ஒரு ஊடுருவல்காரரைக் கண்டறிய இது உதவாது; ஏனெனில், அவர் binary கோப்பை மாற்றியது போலவே inventory.sha256 கோப்பையும் எளிதாக மாற்ற முடியும். இந்தத் தரவு அர்த்தமுள்ளதாக இருக்க வேண்டுமெனில், பட்டியலை அந்த machine-க்கு வெளியே வைத்திருங்கள். இது நீங்கள் ஒரு VPS-ஐ எந்த அளவுக்கு நம்புகிறீர்கள் மற்றும் அந்த வட்டில் வேறு யாருக்கெல்லாம் அணுகல் உள்ளது என்ற பரந்த கேள்வியின் ஒரு பகுதியாகும்.

FAQ

checksum பொருந்துவது பதிவிறக்கம் பாதுகாப்பானது என்று அர்த்தமா?

இல்லை. நீங்கள் பதிவிறக்கிய கோப்பின் பைட்டுகள் (bytes), நீங்கள் ஒப்பிட்ட digest-உடன் ஒத்துப்போகிறது என்று மட்டுமே இது குறிக்கிறது. digest-ஐ வெளியிட்ட பக்கத்தை ஒரு தாக்குபவர் கட்டுப்படுத்தினால், அவர் தனது சொந்த கோப்பின் digest-ஐயே வெளியிடுவார், அப்போது உங்கள் சரிபார்ப்பு OK என்று காட்டும். பொருத்தம் என்பது தரவு மாறாமல் இருப்பதற்கான சான்று மட்டுமே. பாதுகாப்பு என்பது, வேறு ஒரு நம்பகமான மூலத்திலிருந்து பெறப்பட்ட key மூலம் சரிபார்க்கப்பட்ட signature-ஐப் பொறுத்தது; அப்போதுதான் அந்த digest-க்கு நம்பகத்தன்மை கிடைக்கும்.

sha256sum -c ஏன் FAILED open or read என்று காட்டுகிறது?

ஏனெனில் அது கோப்பை வாசிக்கவில்லை. அதற்கு மேலே உள்ள வரியில், அது தேடிய கோப்பின் பெயருடன் No such file or directory என்று காட்டும். SHA256SUMS கோப்பில் உள்ள பெயர்கள், நீங்கள் கட்டளையை இயக்கும் கோப்பகத்தைப் (directory) பொறுத்தவை. எனவே, பதிவிறக்கம் செய்யப்பட்ட கோப்பு இருக்கும் கோப்பகத்திற்குச் சென்று மீண்டும் இயக்கவும். நீங்கள் பதிவிறக்காத கோப்புகளும் அந்தப் பட்டியலில் இருந்தால், --ignore-missing-ஐச் சேர்க்கவும். open or read இல்லாமல் வெறும் FAILED என்று வருவது இதற்கு நேர்மாறானது: கோப்பு வாசிக்கப்பட்டது, ஆனால் அதன் digest பொருந்தவில்லை.

பதிவிறக்கத்தைச் சரிபார்க்க MD5 போதுமானதா?

தற்செயலான தரவுச் சிதைவுக்கு, ஆம். இடையில் துண்டிக்கப்பட்ட பரிமாற்றம் அல்லது பழுதடைந்த disk block போன்றவை தற்செயலாக ஒரே மாதிரியான MD5 digest-ஐ உருவாக்காது. ஆனால், ஒரு தாக்குபவருக்கு எதிராக இது போதாது. ஒரே MD5 digest கொண்ட இரண்டு வெவ்வேறு கோப்புகளை உருவாக்கும் முறை 2004-லேயே கண்டறியப்பட்டது, SHA-1 முறை 2020-ல் முறியடிக்கப்பட்டது. ஒரு திட்டம் SHA-256 மற்றும் MD5 இரண்டையும் வழங்கினால் SHA-256-ஐப் பயன்படுத்தவும்; MD5-ஐ மட்டும் வழங்கும் திட்டம் பழைய வெளியீட்டு முறையைப் பின்பற்றுகிறது என்று பொருள்.

sha256sum -c மற்றும் gpg --verify-க்கு என்ன வித்தியாசம்?

sha256sum -c என்பது ஒரு கோப்பு digest-உடன் பொருந்துகிறதா என்பதை உறுதிப்படுத்துகிறது. gpg --verify என்பது ஒரு digest கோப்பு, குறிப்பிட்ட private key வைத்திருப்பவரால் கையொப்பமிடப்பட்டதா என்பதை உறுதிப்படுத்துகிறது. இவை வெவ்வேறு கேள்விகளுக்குப் பதிலளிக்கின்றன, எனவே ஒரு திட்டம் இரண்டையும் வழங்கினால் இரண்டையும் பயன்படுத்தவும். signature அந்த digest பட்டியலை நம்பகமானதாக்குகிறது, அந்தப் பட்டியல் பதிவிறக்கம் செய்யப்பட்ட கோப்பை நம்பகமானதாக்குகிறது.

இணையப் பக்கத்தில் உள்ள digest-ஐ வைத்து ஒரு கோப்பை எப்படிச் சரிபார்ப்பது?

எழுத்துக்களைக் கண்ணால் ஒப்பிட்டுப் பார்க்க வேண்டாம். digest மற்றும் கோப்பின் பெயரை ஒரே வரியில், இரண்டு இடைவெளிகளுடன் (spaces) சேமிக்கவும். பின் அந்த கோப்பில் sha256sum -c கட்டளையை இயக்கி, அது காட்டும் OK அல்லது FAILED முடிவைப் பார்க்கவும். printf '%s %s\n' மூலம் அந்த வரியை உருவாக்குவது, sha256sum கட்டளையில் no properly formatted checksum lines found பிழை ஏற்படுவதைத் தவிர்க்க உதவும்.