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

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

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

முழு செயல்முறையின் போதும் ஒரு வாக்கியத்தை நினைவில் கொள்ளுங்கள். உங்களிடம் உள்ள bytes-கள் அந்த digest-ஐ உருவாக்கிய அதே bytes-களா என்பதை மட்டுமே checksum உறுதிப்படுத்தும்; அவற்றை உருவாக்கியது யார் என்பதை அது கூறாது. அந்த இரண்டாவது கேள்விக்கு ஒரு 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 அதைத்தான் வாசிக்கும், உரையை ஒருபோதும் வாசிக்காது. ஒருமுறை சரியாக இயங்கிய பிறகு echo $?, 0 என்பதை அச்சிடும். SHA256SUMS என்ற பெயர் ஒரு விதிமுறை என்பதை விட ஒரு மரபு ஆகும், ஆனால் விநியோகங்களும் (distributions) பெரும்பாலான release பக்கங்களும் இதையே பயன்படுத்துகின்றன. எனவே நீங்களும் இதையே பயன்படுத்தினால், கோப்பைத் திறக்காமலேயே அதில் என்ன உள்ளது என்பதை அடுத்த நபர் எளிதில் புரிந்துகொள்வார்.

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

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

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-ஐ உருவாக்கும். துண்டிக்கப்பட்ட இணைப்பால் பாதியில் நின்ற பதிவிறக்கம், பழைய பதிப்பை வழங்கும் மிரர் (mirror), இடையில் கோப்பை மாற்றியமைத்த ப்ராக்ஸி (proxy), அல்லது பழுதடைந்த பிளாக்கை (bad block) வழங்கிய டிஸ்க் என அனைத்தும் ஒரே முடிவையே தரும்.

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

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

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

sha256sum --ignore-missing -c SHA256SUMS.all

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

வெளியிடப்பட்ட 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-ஐ உருவாக்கியவை. இது தற்செயலான தரவுச் சிதைவுகளை முழுமையாகக் கையாளும். மேலும், download mirror-ல் உள்ள கோப்பை மாற்றிய, ஆனால் digest வெளியிடப்பட்ட பக்கத்தை அணுக முடியாத கவனக்குறைவான தாக்குதலையும் இது தடுக்கும்.

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

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

பலவீனம் இப்போது key-க்கு மாறுகிறது. கோப்பைப் பதிவிறக்கிய அதே பக்கத்திலிருந்து key-யையும் பெறுவது, தாக்குபவருக்கு இரண்டு பகுதிகளையும் வழங்கிவிடும். GnuPG இதில் வெளிப்படையாகச் செயல்படுகிறது, முதல் சரிபார்ப்பின் போது WARNING: This key is not certified with a trusted signature! உடன் சேர்த்து Good 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 எந்தக் கட்டளையும் இன்றி ஒவ்வொரு install-ன் போதும் இந்தச் சங்கிலித் தொடரை இயக்குகிறது. ஒவ்வொரு .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 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 எதையும் அச்சிடாது, ஏதேனும் கோப்பு மாறினால் தோல்வியடைந்த வரிகளை மட்டும் அச்சிடும். எனவே, அமைதியாக இருப்பது வெற்றியை உணர்த்துகிறது, மேலும் 0 கொடியைப் பயன்படுத்தி echo $? மூலம் அதை உறுதிப்படுத்தலாம். திட்டமிடப்பட்ட பணிகளில் (scheduled jobs) இதைப் பயன்படுத்தலாம். --status இன்னும் கூடுதலாக எதையும் அச்சிடாது, வெறும் exit status-ஐ மட்டுமே வழங்கும். sha256sum /usr/local/bin/* > ~/local-bin.sha256 மூலம் உண்மையான கோப்புகளைக் குறிப்பிட்டு ஒரு baseline-ஐ உருவாக்கலாம். நீங்கள் தட்டச்சு செய்தபடியே கோப்புப் பாதைகள் (paths) பட்டியலில் சேமிக்கப்படும், எனவே absolute paths-ஐப் பயன்படுத்துவது எந்தக் கோப்பகத்திலிருந்தும் சரிபார்ப்பைச் சரியாகச் செய்ய உதவும்.

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

FAQ

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

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

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

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

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

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

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

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

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

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