SSD Nodes Learn Hosting plans →

Linuxలో checksumతో downloadsను ఎలా ధృవీకరించాలి

Linuxలో sha256sumతో file hash లెక్కించి, SHA256SUMSతో సరిపోల్చండి. ఒక byte మార్చిన వెంటనే వచ్చే failureను చూసి checksum ఏమి నిరూపిస్తుందో తెలుసుకోండి.

Verified Every command ran end-to-end on a fresh Ubuntu 24.04 server, August 12, 2026.

checksum తో download ను రెండు నిమిషాల్లో ధృవీకరించండి

checksum తో download ను ధృవీకరించడానికి, అందుకున్న file కు hash లెక్కించి, ఆ hash ను publisher ఇచ్చిన hash తో tool పోల్చేలా చేయండి. sha256sum ఈ రెండు పనులను చేస్తుంది: స్వతంత్రంగా ఉపయోగిస్తే digest ను చూపిస్తుంది; -c తో ఉపయోగిస్తే digest ల జాబితాను చదివి, ఏ files సరిపోతున్నాయో నివేదిస్తుంది. మీరు సృష్టించే file పై ఈ మొత్తం ప్రక్రియను ఈ guide అమలు చేస్తుంది. తరువాత ఆ file ను ఉద్దేశపూర్వకంగా మార్చి, failure ఎలా జరుగుతుందో ప్రత్యక్షంగా చూడేలా చేస్తుంది.

ఈ మొత్తం ప్రక్రియలో ఒక విషయాన్ని గుర్తుంచుకోండి. checksum ద్వారా మీ వద్ద ఉన్న bytes, digest ను రూపొందించిన bytes అవేనా అనేది తెలుస్తుంది. అయితే వాటిని ఎవరు రూపొందించారో checksum ద్వారా తెలియదు. ఆ రెండవ ప్రశ్నకు signature మరియు మీరు విశ్వసించే key అవసరం. ఈ guide చివరి భాగంలో ఈ రెండింటి మధ్య ఉన్న పరిమితి ఎక్కడో స్పష్టంగా చూపిస్తుంది.

అభ్యాసం కోసం ఒక ఫైల్‌ను సృష్టించండి

ఏదీ సిస్టమ్‌లోని ఇతర భాగాలను ప్రభావితం చేయకుండా scratch directory లో పని చేయండి. క్రింది ప్రతి command GNU coreutils నుంచి వస్తుంది. ఇది ఏ Ubuntu లేదా Debian server లోనైనా ఉండే ప్రాథమిక command సముదాయం. కాబట్టి ఏదీ install చేయాల్సిన అవసరం లేదు.

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

మీకు ఒక line కనిపిస్తుంది: 64 hexadecimal characters, రెండు spaces, ఆ తర్వాత file name. ఆ 64 characters file యొక్క digest. అదే command ను మళ్లీ run చేస్తే line మారదు, ఎందుకంటే hashing deterministic: ఒకే input ఎల్లప్పుడూ ఒకే output ను ఇస్తుంది. File లోని ఒక character ను మార్చి మళ్లీ run చేస్తే digest కొద్దిగా మాత్రమే మారదు. అది పూర్తిగా భిన్నంగా కనిపిస్తుంది, ఎందుకంటే ఒక input bit మారితే output bits లో సుమారు సగం మారుతుంది. ఈ లక్షణం వల్ల 64-character string ను 4 GB image కు ఉపయోగించగల stand-in గా ఉపయోగించవచ్చు.

SHA256SUMS ఫైల్‌ను భద్రపరచి, తరువాత దాన్ని తనిఖీ చేయండి

స్క్రీన్‌పై కనిపించే digest ఒక రోజు తరువాత ఉపయోగపడదు. దాన్ని ఒక ఫైల్‌లో రాయండి. sha256sum స్వయంగా ఉపయోగించే format లోనే రాయండి, తద్వారా tool దాన్ని తరువాత మళ్లీ చదవగలదు.

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

sha256sum -c జాబితాలోని ప్రతి line ను చదివి, ఆ line లో పేర్కొన్న file ను hash చేసి, రెండు digestలను పోల్చుతుంది. విజయవంతమైన run ప్రతి file కు ఒక line ను ముద్రిస్తుంది:

payload.txt: OK

Exit status ను కూడా తనిఖీ చేయండి. ఎందుకంటే script ఆ విలువను చదువుతుంది; text ను ఎప్పుడూ చదవదు. విజయవంతమైన run తర్వాత echo $?, 0 ను ముద్రిస్తుంది. SHA256SUMS అనే పేరు ఒక convention మాత్రమే, తప్పనిసరి నియమం కాదు. అయితే distributions మరియు చాలా release pages దీనినే ఉపయోగిస్తాయి. కాబట్టి మీరు కూడా ఇదే పేరును ఉపయోగించండి. అప్పుడు file తెరవకుండానే అందులో ఏముందో తరువాతి వ్యక్తికి తెలుస్తుంది.

ఒక byte మార్చి తనిఖీ విఫలమవడాన్ని గమనించండి

ఇప్పుడు ఉద్దేశపూర్వకంగా ఫైల్‌ను మార్చండి. ఇది offset 5 వద్ద ఒక byte మాత్రమే రాస్తుంది. మిగతా మొత్తం అలాగే ఉంటుంది. అందువల్ల ఫైల్ పొడవు మరియు పేరు మారవు.

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

ఇక్కడ ముఖ్యమైన flag conv=notrunc. ఇది లేకపోతే, dd రాయడం ఆపిన స్థానంలో ఫైల్‌ను truncate చేస్తుంది. అప్పుడు మీరు మరింత స్పష్టంగా కనిపించే వేరే రకమైన నష్టాన్ని పరీక్షిస్తారు. ఇప్పుడు తనిఖీ ఇలా చూపిస్తుంది:

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

echo $?, 1 ను చూపిస్తుంది. FAILED అంటే ఫైల్ చదవబడింది, కానీ దాని digest జాబితాలో ఉన్న digest తో సరిపోలలేదు. అసలు bytes ను తిరిగి ఉంచి, తనిఖీ మళ్లీ OK కు వస్తుందని నిర్ధారించండి:

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

ఇదే మొత్తం విధానం. ఫైల్‌లో ఎక్కడైనా ఒక byte తేడా ఉన్నా FAILED వస్తుంది. కనెక్షన్ తెగిపోవడం వల్ల మధ్యలో ఆగిపోయిన download, నిన్నటి build ను అందించే mirror, transit సమయంలో ఫైల్‌ను మార్చిన proxy, తప్పు block ను తిరిగి ఇచ్చిన disk — ఇవన్నీ అదే ఫలితానికి దారితీస్తాయి.

జాబితాలో మీరు download చేయని file పేరు ఉన్నప్పుడు

ఒక distribution కు చెందిన అసలైన SHA256SUMS file, దాని download directory లోని ప్రతి image ను జాబితా చేస్తుంది. మీరు వాటిలో ఒకదాన్ని download చేశారు. అయితే project విడుదల చేసే ప్రతి image ఆ జాబితాలో ఉండకపోవచ్చు. November 2026 నాటికి, Ubuntu 24.04 కోసం amd64 మరియు arm64 release ISOలను వేర్వేరు serverలలోని వేర్వేరు జాబితాల్లో ఉంచుతుంది. అయితే దాని daily Noble జాబితాలో amd64 మరియు arm64 desktop 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 కంటే భిన్నమైన failure. ఈ రెండింటిని కలిపి చూడటం వల్ల సమయం వృథా అవుతుంది. FAILED అంటే bytes తప్పుగా ఉన్నాయి. FAILED open or read అంటే sha256sum fileను open చేయలేకపోయింది లేదా దాన్ని పూర్తిగా read చేయలేకపోయింది. అందువల్ల ఏ digestను పోల్చలేదు. నిజమైన downloadలో సాధారణ కారణం working directory. ఎందుకంటే listలోని relative names, మీరు command అమలు చేసే directory నుంచి resolve అవుతాయి. File ఉన్న directoryకి మారి commandను మళ్లీ అమలు చేయండి. మీ వద్ద నిజంగా ఉన్న fileలను మాత్రమే తనిఖీ చేయాలంటే ఇలా అడగండి:

sha256sum --ignore-missing -c SHA256SUMS.all

ఇది payload.txt: OK ను print చేసి 0తో exit అవుతుంది. జాబితాలో ఉన్న పేర్లలో ఏదీ లేకపోతే --ignore-missing, zero filesపై మౌనంగా విజయవంతం కాదు. అది no file was verified అని report చేసి non-zeroతో exit అవుతుంది. మీరు కోరుకునే ప్రవర్తన ఇదే. ఎందుకంటే ఏదీ తనిఖీ చేయని pass, మీరు ఎప్పటికీ గుర్తించని failure అవుతుంది.

కళ్లతో చదవకుండా ప్రచురించిన digest ను paste చేయడం

64 hexadecimal అక్షరాలను కళ్లతో పోల్చడం ఈ అలవాటు విఫలమయ్యే ప్రధాన కారణం. చాలామంది మొదటి నాలుగు అక్షరాలు, చివరి నాలుగు అక్షరాలు చూసి సరిపోలిందని నిర్ణయిస్తారు. పట్టుదలతో దాడి చేసే attacker కూడా ఇదే పోలికపై ఆధారపడతాడు. పోలికను tool‌కే అప్పగించండి. Publisher నుంచి copy చేసిన digest కు EXPECTED విలువను సెట్ చేయండి. ఇందుకోసం EXPECTED= తర్వాత paste చేసిన విలువను ఉంచి, -c ఆశించే ఒకే line ను తయారు చేయండి:

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

Digest మరియు file name మధ్య రెండు spaces ఉంటాయి. అందుకే format string లో కూడా రెండు spaces ఉంటాయి. ఇదే రూపాన్ని sha256sum రాస్తుంది, -c చదువుతుంది. Digest మాత్రమే ఉన్న file checksum line కాదు. అందువల్ల మీరు ఉద్దేశించిన file ఏదో ఊహించకుండా, check మొత్తం file ను no properly formatted checksum lines found తో reject చేస్తుంది. కొన్ని projects బదులుగా BSD tagged style ను publish చేస్తాయి: SHA256 (payload.txt) = తర్వాత digest వస్తుంది. GNU coreutils ఆ రూపాన్ని sha256sum --tag payload.txt తో రాస్తుంది, -c తో తిరిగి చదువుతుంది. కాబట్టి ఈ రెండు రూపాల్లో ఏదైనా save చేయవచ్చు.

Check ఊహించని విధంగా పనిచేస్తే, cat -A SHA256SUMS తో list ను స్వయంగా పరిశీలించండి. ఇది ప్రతి line చివరను $ తో గుర్తిస్తుంది. సాధారణంగా కనిపించని characters ను కూడా చూపిస్తుంది. ^M$ తో ముగిసే line Windows editor నుంచి carriage return ను తీసుకువచ్చింది. GNU sha256sum ఆ చివరి character ను పట్టించుకోకుండా OK ను ముద్రిస్తుంది. కాబట్టి CRLF list మీ check విఫలమయ్యే కారణం కాదు. అయితే coreutils వెలుపల ఉన్న tools దీనిని అంత సులభంగా అంగీకరించకపోవచ్చు. మీరు ఉంచుకునే copy ను tr -d '\r' < SHA256SUMS > SHA256SUMS.clean తో normalise చేయండి.

Checksum ఏమి నిరూపిస్తుంది, ఏమి నిరూపించదు?

Checksum ఒక విషయాన్ని నిరూపిస్తుంది: మీ diskలోని bytes, ప్రచురించిన digest ను ఉత్పత్తి చేసిన bytes తో సమానంగా ఉన్నాయని. అనుకోకుండా జరిగిన నష్టాన్ని ఇది పూర్తిగా గుర్తిస్తుంది. Download mirrorలో fileను మార్చినా, digest ప్రచురించిన pageను మార్చలేని నిర్లక్ష్య దాడి చేసేవారిని కూడా ఇది గుర్తిస్తుంది.

ఇది fileను ఎవరు సృష్టించారో నిరూపించదు. Digest అనేది bytesకు సంబంధించిన వాస్తవం, వ్యక్తులకు సంబంధించిన వాస్తవం కాదు. ఒకే page fileను మరియు digestను అందిస్తే, ఒకదాన్ని మార్చగల వ్యక్తి మరొకదానిని కూడా మార్చగలడు. అప్పుడు మీ OK line mirror తనతో తానే సరిపోతుందని మాత్రమే చూపిస్తుంది. అందువల్ల checksums అమలు చేయడం విలువైనదిగా చేసే నియమం ఇది: fileను తీసుకున్న చోటుకంటే వేరే చోటు నుంచి digestను తీసుకోండి. ఉదాహరణకు, imageను mirror లేదా torrent నుంచి తీసుకున్నప్పుడు, project యొక్క స్వంత domainను TLS (transport layer security) ద్వారా ఉపయోగించండి. ఇప్పుడు దాడి చేసేవారు ఒక చోటు బదులు రెండు చోట్ల నియంత్రణ పొందాలి. అయితే మీరు అమలు చేసిన తర్వాత ఆ verified bytes ఏమి చేస్తాయో ఇది చెప్పదు. మీ తరఫున అమలు అయ్యే ఏదైనా విషయాన్ని, install script నుంచి మీ agent అనుమతులతో నడిచే dsh plugin వరకు, విడిగా పరిశీలించాలి.

Algorithm కూడా ముఖ్యమే. SHA-256 (secure hash algorithm, 256-bit output)కు October 2026 నాటికి తెలిసిన collision లేదు. అందుకే publishers దీనిని ఉపయోగిస్తారు. MD5 (message digest 5) మరియు SHA-1 నమ్మదగినవి కావు: ఒకే MD5 digest కలిగిన రెండు వేర్వేరు filesను 2004 నుంచి రూపొందించగలుగుతున్నారు. Chosen-prefix SHA-1 collisionను 2020లో ప్రచురించారు. ఒక MD5SUMS file truncated downloadను ఇప్పటికీ గుర్తిస్తుంది, ఎందుకంటే యాదృచ్ఛికంగా జరిగిన corruption అనేది రూపొందించిన collision కాదు. మిమ్మల్ని మోసం చేయడానికి ప్రయత్నించే వ్యక్తిని ఇది ఆపలేదు. ఒక project రెండింటినీ ప్రచురిస్తే, SHA-256 lineను తీసుకోండి.

సంతకాలు తీసుకునే బాధ్యత

డైజెస్ట్ వదిలే లోటును సంతకం పూడుస్తుంది. ప్రచురణకర్త private key తో digest file పై సంతకం చేస్తారు. మీరు వారి public key తో దాన్ని తనిఖీ చేస్తారు: gpg --verify SHA256SUMS.asc SHA256SUMS. ఇది విజయవంతమైతే, digest ల జాబితా ఆ key ను కలిగి ఉన్న వ్యక్తి లేదా సంస్థ నుంచే వచ్చిందని అర్థం. తరువాత sha256sum -c SHA256SUMS మీ disk లోని file ను ఆ జాబితాతో సరిపోలుస్తుంది. ఇలా key నుంచి file లోని bytes వరకు విశ్వసనీయత గొలుసు కొనసాగుతుంది.

ఇప్పుడు బలహీనమైన స్థానం key అవుతుంది. File అందించిన అదే page నుంచి key ను పొందితే, దాడి చేసేవారికి రెండు భాగాలూ తిరిగి అప్పగించినట్లే. GnuPG ఈ విషయాన్ని స్పష్టంగా తెలియజేస్తుంది. మొదటి verification లో Good signature తో పాటు WARNING: This key is not certified with a trusted signature! కూడా కనిపిస్తుంది. Good signature అంటే గణితపరమైన తనిఖీ సరిగ్గా జరిగిందని మాత్రమే అర్థం. ఆ key మీరు ఉద్దేశించిన project కు చెందినదని మాత్రం అర్థం కాదు. Fingerprint ను రెండవ మూలం నుంచి పొందండి. ఉదాహరణకు, వేరే domain లోని project documentation లేదా ఇప్పటికే ఆ key ను ship చేసే distribution package ను ఉపయోగించండి. చివరి ఎనిమిది characters కాకుండా పూర్తి fingerprint ను సరిపోల్చండి. ఇదే కారణంతో SSH private key కు అవసరమైన జాగ్రత్త కూడా ఇక్కడ వర్తిస్తుంది: key ఆధారంగానే trust నిర్ణయం తీసుకుంటారు. దాని తర్వాతి మొత్తం ప్రక్రియ ఆ నిర్ణయాన్ని అనుసరిస్తుంది.

Reproducible builds ఈ ఆలోచనను మరో దశ ముందుకు తీసుకెళ్తాయి. ప్రచురించిన digest తోనూ, ఒక machine build చేసిన binary పైనే మీరు ఆధారపడతారు. Project build reproducible గా ఉంటే, ఎవరైనా అదే source ను compile చేసి byte-identical output పొందవచ్చు. అందువల్ల independent builders ప్రచురించిన digest ను స్వతంత్రంగా నిర్ధారించగలరు. ఒక server చెప్పినదాన్ని మాత్రమే నమ్మాల్సిన అవసరం ఉండదు. Automated pipelines ద్వారా మరింత code వస్తున్న కొద్దీ, machine-written patches కూడా పెరుగుతున్నందున ఇది ప్రతి సంవత్సరం మరింత ప్రాముఖ్యం పొందుతోంది. Build లోకి ఏదిని అంగీకరించాలో నిర్ణయించడం policy ప్రశ్న. AI-assisted code కోసం open source policies కూడా ఇదే supply chain పై వ్యతిరేక దిశ నుంచి పనిచేస్తాయి.

మీ package manager ఇప్పటికే దీన్ని మీ కోసం చేస్తుంది

Debian మరియు Ubuntuలో, apt ప్రతి install సమయంలో అడగకుండానే ఈ chainను అమలు చేస్తుంది. Package indexలో ప్రతి .deb fileకు SHA-256 digest ఉంటుంది. Release file ఆ index files యొక్క digestsను కలిగి ఉంటుంది. InRelease, Releaseపై signatureను కలిగి ఉంటుంది. ఈ signatureను ఆ repository యొక్క Signed-By optionలో పేర్కొన్న keyతో తనిఖీ చేస్తారు: /usr/share/keyrings కింద package install చేసిన keyring, /etc/apt/keyringsలో మీరు ఉంచిన key file, లేదా .sources fileలోనే పొందుపరిచిన key. Chain విఫలమైతే apt ఆ విషయాన్ని తెలియజేస్తుంది. అయితే ఖచ్చితమైన పదాలు APT version మరియు దాని వెనుక ఉన్న verifierపై ఆధారపడి ఉంటాయి. gpgvతో verification చేసే APT, third-party repository key కనిపించనప్పుడు The following signatures couldn't be verified because the public key is not available: తర్వాత NO_PUBKEY మరియు key IDను print చేస్తుంది. Sequoia యొక్క sqvతో verification చేసే కొత్త APT, ఉపయోగించగల keyring ఏదీ కనిపించనప్పుడు The signatures couldn't be verified because no keyring is specifiedను report చేస్తుంది. లేకపోతే Sub-process ... returned an error code తర్వాత sqv యొక్క స్వంత errorను అలాగే పంపిస్తుంది. Hash Sum mismatch అనే వేరే message, మీరు fetch చేసిన index, signed Releaseతో సరిపోలడం లేదని అర్థం. సాధారణంగా caching proxy stale fileను అందించడం లేదా mirror sync మధ్యలో మీరు fileను పొందడం దీనికి కారణం.

Project home page, curl నుంచి scriptను నేరుగా shellలోకి pipe చేయమని చెప్పినప్పుడు, దీనినే ప్రమాణంగా తీసుకుని పరిశీలించండి. ఏదీ bytesను verify చేయదు, వాటిని మీరు చూడలేరు. Server ఒక scriptకు ఒక contentను, browserకు మరో contentను కూడా అందించగలదు. తరువాత పరిశీలించడానికి మీ వద్ద copy కూడా ఉండదు. curl -fsSL <url> -o install.shతో fileలోకి download చేయండి, దాని hashను తీసుకోండి, lessతో చదవండి, ఆ తర్వాత మాత్రమే run చేయండి. ఈ అలవాటుకు సుమారు ఇరవై seconds పడుతుంది. Boxలో మరేదీ install చేయకముందే, కొత్త VPSలో మొదటి పది నిమిషాల్లో ప్రారంభించాల్సిన అలవాటు ఇదే.

మీరు చేతితో ఇన్‌స్టాల్ చేసిన వాటి కోసం digests జాబితాను నిర్వహించండి

apt ద్వారా ఇన్‌స్టాల్ చేసిన packages ట్రాక్ చేయబడతాయి. మీరు /usr/local/bin లోకి copy చేసిన binary ట్రాక్ చేయబడదు; దాన్ని system లో ఏదీ పర్యవేక్షించదు. Digest జాబితా ద్వారా అవసరమైనప్పుడు దీన్ని తనిఖీ చేయవచ్చు:

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

అన్ని files సరిపోలినప్పుడు --quiet, OK lines ను తొలగిస్తుంది. అందువల్ల ఏ output ఉండదు. కొన్ని files సరిపోలకపోతే, ప్రతి దానికి FAILED line ను ముద్రిస్తుంది మరియు standard error పై warning summary ను జోడిస్తుంది. కాబట్టి output లేకపోవడం pass ను సూచిస్తుంది; echo $? దాన్ని 0 తో నిర్ధారిస్తుంది. Scheduled job లో ఉపయోగించాల్సిన రూపం ఇదే. --status మరింత ముందుకు వెళ్లి ఎలాంటి output ను ముద్రించదు; మీకు exit status మాత్రమే మిగులుతుంది. sha256sum /usr/local/bin/* > ~/local-bin.sha256 తో అదే pattern ను వాస్తవ files పై అమలు చేస్తే baseline లభిస్తుంది. Paths ను మీరు type చేసిన విధంగానే list లో నిల్వ చేస్తారు. అందువల్ల absolute paths ఉపయోగిస్తే ఏ directory నుంచి అయినా check పనిచేస్తుంది.

ఆ baseline విలువ ఏమిటో స్పష్టంగా అర్థం చేసుకోండి. ఇది మారిన file ను గుర్తిస్తుంది. ఇప్పటికే root ప్రాప్యత కలిగిన attacker ను ఇది గుర్తించదు, ఎందుకంటే binary ను మార్చినంత సులభంగా ఆ attacker inventory.sha256 ను కూడా మార్చగలడు. ఈ జాబితాకు అర్థం ఉండాలంటే దాన్ని machine వెలుపల ఉంచండి. మీరు వాస్తవంగా ఎంతవరకు VPS ను విశ్వసిస్తున్నారు, దాని క్రింద ఉన్న disk ను మరెవరు access చేయగలరు అనే విస్తృత ప్రశ్నలో ఇది కూడా ఒక భాగం: VPS ను మీరు వాస్తవంగా ఎంతవరకు విశ్వసిస్తున్నారు మరియు దాని క్రింద ఉన్న disk ను మరెవరు access చేయగలరు.

FAQ

సరిపోలిన checksum అంటే download సురక్షితమని అర్థమా?

కాదు. మీరు కలిగి ఉన్న bytes, మీరు పోల్చిన digest తో సరిపోలుతున్నాయని మాత్రమే అర్థం. digest ను ప్రచురించిన page పై attacker కు నియంత్రణ ఉంటే, అతను తన file యొక్క digest ను ప్రచురిస్తాడు. మీ check OK ను చూపిస్తుంది. సరిపోలిక అనేది consistency గురించి మాత్రమే చెబుతుంది. భద్రతను నిర్ధారించడానికి, వేరే source నుంచి పొందిన key తో signature ను verify చేయాలి. అప్పుడు మాత్రమే ఆ digest కు ఆ నమ్మకం వర్తిస్తుంది.

sha256sum -c FAILED open or read ను ఎందుకు చూపిస్తుంది?

ఆ command file ను open చేయలేకపోయింది లేదా read చేయలేకపోయింది. అందువల్ల digest పోల్చబడలేదు. file కనిపించనప్పుడు, దాని పైనే ఉన్న ప్రత్యేక line లో అది వెతికిన name తో No such file or directory అని కనిపిస్తుంది. SHA256SUMS file లో / తో ప్రారంభం కాని names, మీరు command ను run చేస్తున్న directory నుంచి resolve అవుతాయి. కాబట్టి download ఉన్న directory కి మారి command ను మళ్లీ run చేయండి. list లో మీరు download చేయని files కూడా ఉంటే, --ignore-missing ను జోడించండి. open or read లేకుండా కనిపించే సాధారణ FAILED దీనికి విరుద్ధమైన పరిస్థితిని సూచిస్తుంది: file read అయింది, కానీ దాని digest సరిపోలలేదు.

download ను verify చేయడానికి MD5 సరిపోతుందా?

అనుకోకుండా జరిగిన damage కోసం అవును. transfer మధ్యలో కత్తిరించబడటం లేదా disk block చెడిపోవడం వల్ల అనుకోకుండా సరిపోలే MD5 digest రావడానికి అవకాశం దాదాపు శూన్యం. attacker ను ఎదుర్కోవడానికి మాత్రం కాదు. ఒకే MD5 digest కలిగిన రెండు వేర్వేరు files ను 2004 నుంచే నిర్మించగలుగుతున్నారు. 2020లో SHA-1 కూడా chosen-prefix collision కు లోనైంది. project SHA-256 మరియు MD5 రెండింటినీ ప్రచురిస్తే, SHA-256 line ను ఉపయోగించండి. MD5 మాత్రమే ఇచ్చే project ను పాత release process కు సంకేతంగా పరిగణించండి.

sha256sum -c మరియు gpg --verify మధ్య తేడా ఏమిటి?

sha256sum -c ఒక file digest తో సరిపోలుతుందని నిర్ధారిస్తుంది. gpg --verify ఒక digest file ను నిర్దిష్ట private key holder sign చేశారని నిర్ధారిస్తుంది. ఇవి వేర్వేరు ప్రశ్నలకు సమాధానాలు ఇస్తాయి. project రెండింటినీ అందిస్తే రెండింటినీ run చేయండి. signature digest list నమ్మదగినదని నిర్ధారిస్తుంది. ఆ digest list download చేసిన file నమ్మదగినదని నిర్ధారిస్తుంది.

web page పై చూపించిన digest తో ఒక file ను ఎలా check చేయాలి?

characters ను కళ్లతో పోల్చవద్దు. digest మరియు file name ను ఒకే line లో, వాటి మధ్య రెండు spaces తో save చేయండి. తరువాత ఆ file పై sha256sum -c ను run చేసి, అది చూపించే OK లేదా FAILED ను పరిశీలించండి. printf '%s %s\n' తో line ను రూపొందిస్తే, sha256sum file ను no properly formatted checksum lines found తో reject చేసే formatting mistakes నివారించవచ్చు.

ఈ వ్యాసం ఉపయోగకరంగా ఉందా?

#checksums#sha256sum#integrity#supply-chain#security