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

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

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

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

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

ఇక్కడి ఏదీ మిగతా సిస్టమ్‌పై ప్రభావం చూపకుండా scratch directory లో పని చేయండి. దిగువ ఉన్న ప్రతి command GNU coreutils నుంచి వస్తుంది. ఇవి ప్రతి Ubuntu లేదా Debian server లో ఉండే ప్రాథమిక command set, కాబట్టి ఏదీ 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 కు ఉపయోగకరమైన ప్రతినిధిగా ఉపయోగించవచ్చు.

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

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

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

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

payload.txt: OK

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

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

ఇప్పుడు ఉద్దేశపూర్వకంగా file ను పాడుచేయండి. ఇది offset 5 వద్ద ఒక byte మాత్రమే రాస్తుంది. మిగతా భాగాన్ని మార్చదు. అందువల్ల file length మరియు name అలాగే ఉంటాయి.

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

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

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

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

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

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

జాబితాలో మీరు డౌన్‌లోడ్ చేయని ఫైల్ పేరు ఉన్నప్పుడు

నిజమైన SHA256SUMS ఫైల్‌లో ప్రాజెక్ట్ విడుదల చేసే ప్రతి 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 కు ఆ ఫైల్ అసలు అందలేదు. అందువల్ల ఏదీ పోల్చబడలేదు. నిజమైన download లో సాధారణ కారణం working directory. ఎందుకంటే జాబితాలోని పేర్లు మీరు command నడిపే ప్రదేశానికి సంబంధించి relative paths గా ఉంటాయి. ఫైల్ ఉన్న directory కి మారి command ను మళ్లీ నడపండి. మీ వద్ద వాస్తవంగా ఉన్న ఫైళ్లను మాత్రమే తనిఖీ చేయాలంటే ఇలా అడగండి:

sha256sum --ignore-missing -c SHA256SUMS.all

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

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

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

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 parse చేసే ఆకృతి కూడా ఇదే. 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 ఆ trailing character ను విస్మరించి కూడా OK ను print చేస్తుంది. కాబట్టి CRLF list మీ check విఫలమవడానికి కారణం కాదు. అయితే coreutils వెలుపల ఉన్న tools దాన్ని అంత సులభంగా అంగీకరించకపోవచ్చు. మీరు ఉంచుకునే copy ను tr -d '\r' < SHA256SUMS > SHA256SUMS.clean తో normalise చేయండి.

Checksum ఏమి నిర్ధారిస్తుంది, ఏమి నిర్ధారించదు?

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

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

Algorithm కూడా ముఖ్యమే. SHA-256 (secure hash algorithm, 256-bit output)కు August 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ను ఉపయోగించండి.

సంతకాలు భర్తీ చేసే దశ

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

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

Reproducible builds ఈ ఆలోచనను మరో దశ ముందుకు తీసుకెళ్తాయి. Published digestతో ఒక machine build చేసిన binaryపైనే మీరు ఆధారపడతారు. Project build reproducibleగా ఉంటే, ఎవరైనా అదే sourceను compile చేసి byte-identical output పొందవచ్చు. అందువల్ల ఒక server మాటను మాత్రమే నమ్మమని అడగకుండా, స్వతంత్రంగా build చేసినవారు published digestను నిర్ధారించగలరు. ప్రతి సంవత్సరం ఇది మరింత ముఖ్యమవుతోంది. ఎందుకంటే automated pipelines మరియు machine-written patches ద్వారా మరింత code వస్తోంది. 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ను /usr/share/keyrings మరియు /etc/apt/trusted.gpg.dలోని keysతో తనిఖీ చేస్తారు. ఈ chainలో సమస్య ఉంటే apt దాన్ని స్పష్టంగా తెలియజేస్తుంది: third-party repository key లేకపోతే The following signatures couldn't be verified because the public key is not available: NO_PUBKEY చూపిస్తుంది. మీరు పొందిన index signed Releaseతో సరిపోలకపోతే Hash Sum mismatch చూపిస్తుంది. సాధారణంగా దీనికి caching proxy పాత fileను అందించడం లేదా mirror sync మధ్యలో ఉండటం కారణం.

ఒక 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 చేయండి. ఈ అలవాటుకు సుమారు twenty seconds పడుతుంది. ఏదైనా మరొకటి install చేయడానికి ముందు, మొదటి ten minutesలోనే కొత్తగా సృష్టించిన VPSలో ప్రారంభించాల్సిన అలవాటు ఇదే.

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

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

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

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

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

FAQ

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

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

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

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

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

అనుకోకుండా జరిగిన నష్టం కోసం అవును. మధ్యలో కత్తిరించబడిన 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 downloaded file విశ్వసనీయమని నిర్ధారిస్తుంది.

Web page పై ముద్రించిన digest తో ఒక file ను ఎలా check చేయాలి?

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