SSD Nodes Learn Hosting plans →
మార్గదర్శకాలు Matt Connorద్వారా Matt Connor · అప్‌డేట్ చేయబడింది 2026-11-11

Ubuntu ట్రస్ట్ స్టోర్‌కు మీ స్వంత CA సర్టిఫికేట్‌ను

Ubuntuలో మీ సొంత CAని ఎలా చేర్చాలో తెలుసుకోండి. రూట్ సర్టిఫికేట్‌ను /usr/local/share/ca-certificates లో కాపీ చేసి, update-ca-certificates కమాండ్‌తో HTTPS ట్రస్ట్‌ను పొందండి.

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

Ubuntu ట్రస్ట్ స్టోర్‌కు మీ స్వంత CAని జోడించడం

Ubuntu ట్రస్ట్ స్టోర్‌కు మీ స్వంత CAని జోడించడానికి, రూట్ సర్టిఫికేట్‌ను /usr/local/share/ca-certificates/ లోకి .crt తో ముగిసే పేరుతో కాపీ చేయండి, ఆపై sudo update-ca-certificates ని రన్ చేయండి. CA (సర్టిఫికేట్ అథారిటీ) అనేది ఒక కీ జత, దీని సర్టిఫికేట్ ఇతర సర్టిఫికేట్‌లను సంతకం చేయడానికి అనుమతించబడుతుంది. మీ రూట్ సర్టిఫికేట్‌ను మెషిన్ నమ్మిన తర్వాత, ఆ రూట్ సంతకం చేసిన ప్రతి సర్టిఫికేట్ ఆమోదించబడుతుంది, తద్వారా మీ స్వంత సేవల మధ్య HTTPS వెరిఫికేషన్ విఫలం కావడం ఆగిపోతుంది.

ఈ గైడ్ openssl ఉపయోగించి మొత్తం చైన్‌ను ఆఫ్‌లైన్‌లో నిర్మిస్తుంది. మీరు ఒక రూట్ కీ మరియు రూట్ సర్టిఫికేట్‌ను సృష్టించి, సర్వర్ కోసం ఒక లీఫ్ సర్టిఫికేట్‌ను జారీ చేసి, ఆపై రూట్‌ను ఇన్‌స్టాల్ చేసి, అదే వెరిఫికేషన్ కమాండ్ దాని సమాధానాన్ని ఎలా మారుస్తుందో గమనించండి. ఈ క్రమం చాలా ముఖ్యం: ఇన్‌స్టాలేషన్‌కు ముందు మరియు తర్వాత వెరిఫై చేయడం ద్వారా, ఫలితాన్ని మార్చింది ఈ ఇన్‌స్టాలేషన్ అని మీరు అర్థం చేసుకోగలరు.

Ubuntu 24.04 డిఫాల్ట్ ఇమేజ్‌లో OpenSSL 3 మరియు ca-certificates ప్యాకేజీని కలిగి ఉంటుంది, కాబట్టి ముందుగా ఏదీ ఇన్‌స్టాల్ చేయాల్సిన అవసరం లేదు (ఆగస్టు 2026 నాటికి ధృవీకరించబడింది).

మీరు సొంతంగా CAను ఎప్పుడు నిర్వహించాలి?

Let's Encrypt వంటి పబ్లిక్ CAకు పబ్లిక్ DNSలో పేరు మరియు అది చేరుకోగల సర్వర్ అవసరం. అంతర్గత (internal) పేర్లు దీనికి సరిపోవు. ప్రైవేట్ నెట్‌వర్క్‌లోని డేటాబేస్ లేదా టన్నెల్‌కు కట్టుబడి ఉన్న అడ్మిన్ ప్యానెల్ పబ్లిక్ సర్టిఫికేట్‌ను పొందలేవు, అలాగే సర్టిఫికేట్ పొందడం కోసం వాటిని ఇంటర్నెట్‌కు బహిర్గతం చేయకూడదు.

Ubuntuపై self-signed certificate ఒకే హోస్ట్‌కు మాత్రమే పరిష్కారం చూపుతుంది. ప్రతి క్లయింట్ ఆ ఒక్క సర్టిఫికేట్‌ను నమ్మాలి, మరియు తదుపరి హోస్ట్ కోసం మళ్ళీ అదే పని చేయాలి. ప్రైవేట్ CA ఈ నిర్ణయాన్ని ఒక స్థాయి పైకి తీసుకెళ్తుంది. క్లయింట్లు రూట్ సర్టిఫికేట్‌ను ఒక్కసారి నమ్మితే చాలు, ఆ తర్వాత రూట్ సంతకం చేసిన ప్రతి సర్టిఫికేట్‌ను అవి నమ్ముతాయి; ఇంకా ఉనికిలో లేని హోస్ట్‌ల సర్టిఫికేట్‌లు కూడా ఇందులో ఉంటాయి.

దీని వల్ల కలిగే నష్టాలు కూడా ఉన్నాయి. రూట్ కీ నిబంధనలు అనుమతించిన దేనినైనా సంతకం చేయగలదు, కాబట్టి ca.keyని ఎవరైతే చదవగలరో వారు మీ మెషీన్లు అంగీకరించే సర్టిఫికేట్‌లను జారీ చేయగలరు. SSH key managementలో ప్రైవేట్ కీని ఎలా కాపాడుకుంటారో, దీన్ని కూడా అలాగే కాపాడండి. ఒక సేవకు పబ్లిక్ DNS పేరు ఉంటే, ఇదంతా వదిలేసి పబ్లిక్ CAను ఉపయోగించండి: Certbot with nginx and Let's Encrypt వాడటం సులభం మరియు క్లయింట్ వైపు ఏమీ ఇన్‌స్టాల్ చేయాల్సిన అవసరం ఉండదు.

CA key మరియు root certificate సృష్టించండి

మీ user మాత్రమే తెరవగల directory లో పని చేయండి. Root key ఆ directory ని ఎప్పుడూ విడిచి వెళ్లకూడదు.

install -d -m 700 ~/ca
cd ~/ca
openssl genrsa -aes256 -out ca.key 4096
chmod 600 ca.key

-aes256 మీరు ఎంచుకున్న passphrase తో key ని encrypt చేస్తుంది. తరువాత ఈ key తో sign చేసే ప్రతి command కు ఆ passphrase అవసరం. Terminal లో passphrase ను OpenSSL అడుగుతుంది. లేదా -passin ద్వారా వేరే విధంగా అందించవచ్చు. ఇది file లేదా environment variable ను స్వీకరిస్తుంది. అందువల్ల automation కోసం passphrase ను ఎక్కడ ఉంచినా, key కు ఉన్న రక్షణనే దానికి కూడా అమలు చేయాలి. -aes256 ను వదిలేస్తే key disk పై plain text గా ఉంటుంది. అప్పుడు backup లేదా రెండో admin account ఉన్న వ్యక్తికి మీ machines విశ్వసించే certificates జారీ చేసే సామర్థ్యం లభిస్తుంది.

ఇప్పుడు CA key తనకోసం తానే sign చేసే root certificate ను సృష్టించండి.

openssl req -x509 -new -key ca.key -sha256 -days 3650 \
  -subj "/O=Example Internal/CN=Example Internal Root CA" \
  -addext "basicConstraints=critical,CA:TRUE,pathlen:0" \
  -addext "keyUsage=critical,keyCertSign,cRLSign" \
  -addext "subjectKeyIdentifier=hash" \
  -addext "nameConstraints=critical,permitted;DNS:internal.example" \
  -out ca.crt

internal.example స్థానంలో మీరు వాస్తవంగా ఉపయోగించే name suffix ను పెట్టండి. చివరి extension ను ఉంచే ముందు తదుపరి section చదవండి.

ప్రతి extension ఒక పని చేస్తుంది.

  • basicConstraints తో CA:TRUE కలిపి ఈ certificate ను CA certificate గా మారుస్తాయి. ఇవి లేకపోతే signature సరైనదైనా, ఈ key sign చేసిన ఏ certificate ను client అంగీకరించదు.
  • pathlen:0 ఈ CA leaf certificates ను sign చేయవచ్చని, దాని కింద మరిన్ని CAs ను sign చేయకూడదని చెబుతుంది.
  • keyUsage key ను certificates మరియు revocation lists sign చేయడానికి మాత్రమే పరిమితం చేస్తుంది. అందువల్ల పొరపాటున అదే key ను TLS server key గా ఉపయోగించలేరు.
  • subjectKeyIdentifier root కు ఒక identifier ఇస్తుంది. Leaf certificates దానిని సూచిస్తాయి. కొన్ని వందల certificates ఉన్న store లో client సరైన issuer ను ఈ విధంగా గుర్తిస్తుంది.
  • nameConstraints ఈ CA హామీ ఇవ్వగల పేర్లను పరిమితం చేస్తుంది.

Command మీరు ఉద్దేశించిన విధంగానే పనిచేసిందని ఊహించకుండా, మీరు సృష్టించిన వివరాలను మళ్లీ పరిశీలించండి.

openssl x509 -noout -subject -issuer -serial -dates -in ca.crt
openssl x509 -noout -text -in ca.crt

Root certificate తనకోసం తానే sign చేసుకుంటుంది కాబట్టి subject మరియు issuer ఒకే string ను చూపిస్తాయి. Serial మరియు రెండు dates మీరు ఇప్పుడే సృష్టించిన file నుంచి వస్తాయి. కాబట్టి వాటిని ఇతరుల guide నుంచి కాకుండా ఆ output నుంచి తీసుకోండి.

మీ CA దేనిని సంతకం చేయవచ్చో పరిమితం చేయండి

మీరు వేరేలా పేర్కొనకపోతే, సిస్టమ్ స్టోర్‌లోని ఒక root సర్టిఫికేట్ ఇంటర్నెట్‌లోని ప్రతి పేరుకు విశ్వసనీయంగా ఉంటుంది. ఒక సర్వర్‌లోని ఒకే ఫైల్‌కు ఇంత పెద్ద మొత్తంలో అధికారం ఉండటం ప్రమాదకరం. nameConstraints దీనిని తగ్గిస్తుంది. root లో permitted;DNS:internal.example ఉన్నప్పుడు, సంతకం సరిగ్గా ఉన్నప్పటికీ, internal.example వెలుపల ఉన్న పేరు కోసం ఈ CA నుండి వచ్చే చైన్ తిరస్కరించబడుతుంది.

దీనిని నమ్మే బదులు పరీక్షించండి.

openssl req -new -newkey rsa:2048 -nodes -keyout /tmp/outside.key -out /tmp/outside.csr \
  -subj "/CN=www.example.com"
openssl x509 -req -in /tmp/outside.csr -CA ca.crt -CAkey ca.key -CAcreateserial \
  -days 30 -sha256 \
  -extfile <(printf 'subjectAltName=DNS:www.example.com\n') -out /tmp/outside.crt
openssl verify -CAfile ca.crt /tmp/outside.crt
echo $?

మీ CA మీరు అడిగిన దేనినైనా సంతకం చేస్తుంది కాబట్టి, సర్టిఫికేట్ జారీ చేయబడుతుంది. ధృవీకరణ (verification) దశలోనే ఇది విఫలమవుతుంది: exit status సున్నా కాదు మరియు OpenSSL అది ఎదుర్కొన్న constraint ను పేర్కొంటుంది. ఎక్స్‌టెన్షన్ యొక్క విలువ ఇదే. ఒకవేళ CA కీ దొంగిలించబడినా, అది సబ్‌ట్రీ వెలుపల ఉన్న పేరు కోసం పనిచేసే సర్టిఫికేట్‌ను సృష్టించలేదు. మీరు పూర్తి చేసిన తర్వాత rm /tmp/outside.* తో మిగిలిన ఫైళ్లను తొలగించండి.

constraint ను అమలు చేసే ముందు తెలుసుకోవలసిన నాలుగు విషయాలు. ఇది critical గా మార్క్ చేయబడింది, కాబట్టి ఈ ఎక్స్‌టెన్షన్ అర్థం కాని క్లయింట్ దానిని విస్మరించడానికి బదులుగా చైన్‌ను తిరస్కరించాలి. ఇది సురక్షితమైన పద్ధతి, కానీ పాత TLS లైబ్రరీలకు ఇది ఆశ్చర్యం కలిగించవచ్చు. DNS పేర్ల కోసం అనుమతించబడిన సబ్‌ట్రీ IP అడ్రస్ SANలను నియంత్రించదు, ఎందుకంటే సబ్‌ట్రీ జాబితాలో లేని పేరు రకంపై ఎటువంటి నియంత్రణ ఉండదు. కాబట్టి మీ సర్టిఫికేట్‌లలో IP అడ్రస్‌లు ఉంటే, అదే ఎక్స్‌టెన్షన్‌లో permitted;IP:10.0.0.0/255.255.0.0 ని కూడా జోడించండి. సబ్‌ట్రీ మీరు జారీ చేసే ప్రతి పేరును కవర్ చేయాలి, ఇందులో చిన్న హోస్ట్‌నేమ్‌లు కూడా ఉంటాయి. కాబట్టి app వంటి బేర్ నేమ్ (bare name) కోసం సర్టిఫికేట్ పైన పేర్కొన్న ఉదాహరణకు వ్యతిరేకంగా విఫలమవుతుంది. ఈ constraint root లోనే ఉంటుంది, కాబట్టి మీరు నిర్ణయం మార్చుకుంటే, కొత్త root సర్టిఫికేట్ అవసరమవుతుంది మరియు ప్రతి క్లయింట్‌లో కొత్తగా ఇన్‌స్టాల్ చేయాల్సి ఉంటుంది.

CA సంతకం చేసిన leaf certificate జారీ చేయడం

సర్వర్ clients కు అందించే certificate ను leaf certificate అంటారు. ముందుగా దాని కోసం ప్రత్యేక key మరియు CSR (certificate signing request) రూపొందించాలి. CSR లో public key మరియు అభ్యర్థించిన పేరు ఉంటాయి. అభ్యర్థి private key ను కలిగి ఉన్నాడని నిరూపించడానికి CSR పై leaf key తో సంతకం చేస్తారు.

openssl req -new -newkey rsa:2048 -nodes \
  -keyout app.key -out app.csr \
  -subj "/CN=app.internal.example"
chmod 600 app.key

అవసరమైన పేర్లను CSR లో కాకుండా extension file లో ఉంచాలి. Clients hostname ను subjectAltName (SAN) తో సరిపోలుస్తాయి. Browsers మరియు Go common name ను పూర్తిగా విస్మరిస్తాయి. ఇంకా common name కు fallback అయ్యే clients, వాటిలో curl కూడా ఉంది, certificate లో DNS లేదా IP SAN ఏదీ లేనప్పుడు మాత్రమే అలా చేస్తాయి. అందువల్ల CN ఉండి SAN లేకపోతే కొన్ని tools లో certificate పనిచేసి, మరికొన్నింటిలో విఫలమవుతుంది. కాబట్టి ప్రతి పేరును SAN లో నమోదు చేసి, CN ను label గా మాత్రమే పరిగణించాలి.

basicConstraints = CA:FALSE
keyUsage = critical, digitalSignature, keyEncipherment
extendedKeyUsage = serverAuth
subjectAltName = DNS:app.internal.example, DNS:api.internal.example
subjectKeyIdentifier = hash
authorityKeyIdentifier = keyid:always

దాన్ని app.ext గా save చేసి, తరువాత CA తో request పై సంతకం చేయండి.

openssl x509 -req -in app.csr -CA ca.crt -CAkey ca.key -CAcreateserial \
  -days 397 -sha256 -extfile app.ext -out app.crt

-CAcreateserial తదుపరి serial number ను నిల్వ చేసే ca.srl ను CA పక్కనే రాస్తుంది. అందువల్ల ఈ CA నుంచి జారీ చేసిన రెండు certificates కు ఒకే serial number ఉండదు. ఆ file ను CA directory లో ఉంచండి. -days 397 ఒక ఎంపిక మాత్రమే; అది tool పరిమితి కాదు. Public CA తో పోలిస్తే ఇక్కడ తక్కువ కాలపరిమితి మరింత ముఖ్యమైనది. Private CA వద్ద revocation infrastructure ఉండదు. మీరు స్వయంగా ఏర్పాటు చేయకపోతే CRL లేదా OCSP responder ఉండదు. అందువల్ల లీక్ అయిన leaf key certificate expire అయ్యే వరకు ఉపయోగించగలుగుతారు.

Trust store ను పరిశీలించే ముందు ఫలితాన్ని తనిఖీ చేయండి.

openssl x509 -noout -subject -issuer -serial -dates -in app.crt
openssl x509 -noout -ext subjectAltName -in app.crt

ఇప్పుడు issuer line leaf certificate కు బదులుగా CA పేరును చూపిస్తుంది. SAN line ఈ certificate చెల్లుబాటు అయ్యే పేర్లను చూపిస్తుంది. Client ఆ జాబితాతోనే సరిపోల్చుతుంది; మరే ఇతర విలువతో కాదు.

ఏదైనా ఇన్‌స్టాల్ చేసే ముందు, స్పష్టమైన -CAfile తో ధృవీకరించండి

openssl verify -CAfile ca.crt app.crt
echo $?

ఇది ఒక చిన్న ప్రశ్నను అడుగుతుంది: app.crt లోని సర్టిఫికేట్, ca.crt లోని సర్టిఫికేట్‌కు అనుసంధానించబడి ఉందా? మీరు OpenSSL కి కమాండ్ లైన్ ద్వారా రూట్ సర్టిఫికేట్‌ను అందించారు కాబట్టి, ఈ యంత్రం దేనిని నమ్ముతుందనే దానితో దీనికి సంబంధం లేదు. ఇక్కడ ధృవీకరణ విఫలమైతే, అది సర్టిఫికేట్‌లలోనే ఉన్న సమస్య అని అర్థం, కాబట్టి ముందుకు వెళ్లే ముందు దానిని సరిచేయండి.

ఇప్పుడు యంత్రాన్ని అడగండి.

openssl verify app.crt
echo $?

-CAfile లేనప్పుడు, OpenSSL తన అంతర్నిర్మిత సర్టిఫికేట్ డైరెక్టరీని ఉపయోగిస్తుంది. openssl version -d మీ బిల్డ్ ఉపయోగించే బేస్ డైరెక్టరీని ప్రింట్ చేస్తుంది, మరియు Ubuntu లో దాని కింద ఉన్న certs డైరెక్టరీ /etc/ssl/certs కి మారుతుంది. మీ రూట్ సర్టిఫికేట్ ఇంకా అక్కడ లేదు, కాబట్టి ధృవీకరణ విఫలమవుతుంది: చైన్ ఒక ఇష్యూయర్ వద్దకు చేరుకుంటుంది, కానీ ఆ స్టోర్‌లో అది ఉండదు, వెతకడానికి వేరే చోటు ఉండదు. ఎగ్జిట్ స్టేటస్ (exit status) గమనించండి. రెండు దశల తర్వాత మారేది ఇదే.

openssl verify కంటే ఒక నిజమైన క్లయింట్ మెరుగైన పరీక్షను అందిస్తుంది, ఎందుకంటే ఇది చైన్‌తో పాటు హోస్ట్‌నేమ్‌ను కూడా తనిఖీ చేస్తుంది. సర్టిఫికేట్‌ను సర్వ్ చేసి, దానిని ఫెచ్ (fetch) చేయండి.

openssl s_server -accept 8443 -cert app.crt -key app.key -www &
curl --resolve app.internal.example:8443:127.0.0.1 https://app.internal.example:8443/

--resolve కనెక్షన్‌ను 127.0.0.1 కి పంపుతుంది, అదే సమయంలో app.internal.example ని అభ్యర్థిస్తుంది, కాబట్టి SAN సరిపోలుతుంది మరియు ఇప్పుడు మిగిలి ఉన్న ఏకైక ప్రశ్న నమ్మకం (trust) మాత్రమే. curl విఫలమవుతుంది మరియు చైన్‌ను ఎందుకు ధృవీకరించలేకపోయిందో కారణాన్ని ప్రింట్ చేస్తుంది. మరిన్ని వివరాల కోసం -v ని జోడించండి. టెస్ట్ సర్వర్‌ను రన్ అవుతూనే ఉంచండి.

root ను /usr/local/share/ca-certificates లో ఇన్‌స్టాల్ చేయండి

sudo cp ca.crt /usr/local/share/ca-certificates/example-internal-root.crt
sudo chmod 644 /usr/local/share/ca-certificates/example-internal-root.crt
sudo update-ca-certificates

ఇది అసలు పనిచేస్తుందో లేదో నిర్ణయించే అంశాలు ఇవి:

  • ఫైల్ పేరు .crt తో ముగియాలి. update-ca-certificates manual page ప్రకారం, /usr/local/share/ca-certificates కింద కనిపించే .crt extension ఉన్న certificates చేర్చబడతాయి మరియు implicit trust పొందుతాయి. root.pem లేదా root.cer పేరున్న ఫైల్ ఎలాంటి సందేశం లేకుండా skip చేయబడుతుంది.
  • కంటెంట్ PEM అయి ఉండాలి. అంటే BEGIN CERTIFICATE మరియు END CERTIFICATE lines మధ్య ఉన్న base64 block కావాలి. update-ca-certificates ఫైల్‌లోని కంటెంట్‌ను పరిశీలించదు. అందువల్ల DER file కు .crt పేరు పెట్టినా అది skip కాదు. అది /etc/ssl/certs లో link చేయబడుతుంది, దాని raw bytes ను clients PEM text గా ఆశించే bundle కు append చేస్తుంది, అలాగే added గా లెక్కించబడుతుంది. Copy చేయడానికి ముందు openssl x509 -noout -subject -in ca.crt తో ఫైల్‌ను తనిఖీ చేయండి. DER input పై ఇది విఫలమవుతుంది. DER file ను openssl x509 -inform DER -in ca.der -out ca.crt తో convert చేయండి.
  • ఇక్కడ root మాత్రమే ఉండాలి. CA private key మరియు leaf certificate trust store లో ఉండకూడదు.

update-ca-certificates ఎన్ని certificates add చేసి, ఎన్ని remove చేసిందో చూపిస్తుంది. ఏదీ add కాకపోతే కారణం filename extension. Count one అంటే .crt file కనిపించిందని మాత్రమే అర్థం. ఆ ఫైల్‌లో ఉపయోగించగల certificate ఉందని కాదు. కాబట్టి ఆ సందేశాన్ని కాకుండా system వైపు నుంచి మార్పును నిర్ధారించండి.

ls -l /etc/ssl/certs/$(openssl x509 -noout -subject_hash -in /usr/local/share/ca-certificates/example-internal-root.crt).0
grep -c 'BEGIN CERTIFICATE' /etc/ssl/certs/ca-certificates.crt

మొదటి command మీ certificate యొక్క స్వంత subject hash ఆధారంగా filename ను రూపొందించి, దాన్ని list చేస్తుంది. update-ca-certificates, openssl rehash ను అమలు చేయడం ద్వారా ఆ symlink ను సృష్టించింది. అది మీరు install చేసిన file కు తిరిగి సూచిస్తుంది. DER file తో ఈ తనిఖీ విఫలమవుతుంది. ఎందుకంటే PEM గా చదవలేని file కు openssl rehash hash link ను సృష్టించదు. రెండవ command single-file bundle లోని certificates సంఖ్యను లెక్కిస్తుంది. Install చేయడానికి ముందు కూడా దీన్ని run చేస్తే, సంఖ్య ఒకటితో పెరిగినట్టు గమనించవచ్చు.

ఈ root ను ఇతర machines కు copy చేసినప్పుడు, install చేయడానికి ముందు ఆ copy సంపూర్ణంగా చేరిందో లేదో నిర్ధారించండి. root certificate తప్పుగా ఉండకూడని అత్యంత ముఖ్యమైన file; అందువల్ల ఉపయోగించే ముందు మీరు checksum తో నిర్ధారించే ఇతర download లాగే దీనినీ పరిశీలించండి. Rocky Linux మరియు AlmaLinux machines లో root ను వేరే directory ద్వారా, అలాగే update-ca-trust కు బదులుగా update-ca-certificates ద్వారా స్వీకరిస్తారు. కాబట్టి వాటి కోసం Rocky Linux మరియు AlmaLinux లో CA జోడించడం విధానాన్ని అనుసరించండి.

సిస్టమ్ స్టోర్‌కు వ్యతిరేకంగా మళ్ళీ ధృవీకరించండి

openssl verify app.crt
echo $?
curl --resolve app.internal.example:8443:127.0.0.1 https://app.internal.example:8443/

అవే కమాండ్లు, అవే సర్టిఫికేట్ ఫైళ్లు, కానీ భిన్నమైన సమాధానం. app.crt గురించి ఏదీ మారలేదు, మరియు మీరు ఇంతకుముందు ప్రారంభించిన సర్వరే ఇది. ఏకైక వ్యత్యాసం ఏమిటంటే, క్లయింట్లు చదివే స్టోర్‌లో ఇప్పుడు root ఉంది, కాబట్టి చైన్ పూర్తవుతుంది. గుర్తుంచుకోవలసిన విధానం ఇది: ధృవీకరణ అనేది క్లయింట్ ఇప్పటికే నమ్మే జారీదారు (issuer) కోసం చేసే అన్వేషణ, మరియు CAని ఇన్‌స్టాల్ చేయడం ద్వారానే ఆ జారీదారు క్లయింట్ వెతికే చోటుకు చేరుకుంటాడు.

kill %1 ఉపయోగించి టెస్ట్ సర్వర్‌ను ఆపివేయండి.

/etc/ssl/certs లో మీ ఫైల్‌ను ఎందుకు ఉంచకూడదు

/etc/ssl/certs ఉత్పత్తి చేయబడిన output. update-ca-certificates అందులో నిజమైన certificate files కు తిరిగి చూపించే symlinks ను సృష్టించి, కలిపిన bundle /etc/ssl/certs/ca-certificates.crt ను వాటి పక్కనే రాస్తుంది.

మీరు ఆ directory లోకి చేతితో copy చేసిన certificate ను ఏదీ కనుగొనదు. OpenSSL directory lookup, certificate subject hash పేరుతో ఉన్న files ను మాత్రమే తెరుస్తుంది. అందువల్ల myca.crt పేరున్న file దానికి కనిపించదు. Ubuntu లో curl bundle file ను చదువుతుంది. ఆ bundle registered sources నుంచి మళ్లీ నిర్మించబడుతుంది. కాబట్టి మీ copy ఆ path లో కూడా ఉండదు. update-ca-certificates --fresh రెండు source directories లోకి చూపించే links ను, dangling గా మిగిలిన ఏ link ఉన్నా, తొలగిస్తుంది. తరువాత ఆ sources లో ఉన్న వాటినే ఉపయోగించి మళ్లీ నిర్మిస్తుంది.

ఈ విభజనలోని మరో భాగం /usr/share/ca-certificates. ఇది ca-certificates package కు చెందినది మరియు /etc/ca-certificates.conf లో జాబితా చేయబడింది. Package updates దానిని తిరిగి రాస్తాయి. /usr/local/share/ca-certificates local administrator కోసం కేటాయించిన directory. అందువల్ల మిగతా certificates ను నిర్వహించే package upgrade అయినా మీ CA అలాగే ఉంటుంది.

ఏ ప్రోగ్రామ్‌లు system trust store ను పట్టించుకోవు

OpenSSL ను ఉపయోగించే లేదా /etc/ssl/certs ను చదివే ప్రతి ప్రోగ్రామ్‌కు root certificate ను install చేస్తే అది పనిచేస్తుంది. ఇందులో curl, wget, git, Python యొక్క ప్రామాణిక ssl module, అలాగే Linux లోని system files ను చదివే Go programs ఉన్నాయి. స్వంత certificate list తో వచ్చే runtimes పై ఇది ప్రభావం చూపదు. విజయవంతమైన install తర్వాత ఎక్కువ గందరగోళానికి ఇదే ప్రధాన కారణం.

  • Node.js compiled-in list ను ఉపయోగిస్తుంది. NODE_EXTRA_CA_CERTS=/usr/local/share/ca-certificates/example-internal-root.crt ద్వారా దానికి మీ root ను చూపించండి. ఈ విలువను process ప్రారంభమయ్యే ముందు environment లో set చేయాలి, ఎందుకంటే Node ఆ variable ను startup సమయంలో ఒక్కసారి మాత్రమే చదువుతుంది. ప్రస్తుత Node releases లో system store ను చదివే option కూడా ఉంది. మీ version లో అది ఉందో లేదో చూడటానికి node --help | grep -i system-ca ను run చేయండి.
  • Python యొక్క requests library certifi bundle ను ఉపయోగిస్తుంది. ఆ process కోసం REQUESTS_CA_BUNDLE=/etc/ssl/certs/ca-certificates.crt ను set చేయండి లేదా call కు verify="/etc/ssl/certs/ca-certificates.crt" ను pass చేయండి. అదే కారణంతో pip --cert ను తీసుకుంటుంది.
  • Java ఒక keystore ను చదువుతుంది. Ubuntu లో ca-certificates-java package, /etc/ca-certificates/update.d/ కింద ఒక hook ను install చేస్తుంది. ఆ package ఉన్నప్పుడు update-ca-certificates Java keystore ను కూడా refresh చేస్తుంది. అది లేకపోతే keytool -importcert తో root ను import చేయండి.
  • Firefox తన స్వంత store ను ఉంచుతుంది. అది /etc/ssl/certs ను ఎప్పుడూ చూడదు. దాని certificate settings ద్వారా import చేయండి. Linux లో Chromium per-user NSS database ను చదువుతుంది. libnss3-tools package లోని certutil తో దాన్ని edit చేయవచ్చు.
  • Containers కు స్వంత filesystem ఉంటుంది. అందువల్ల host యొక్క store వాటిలో ఎలాంటి ప్రభావం చూపదు. Root ను image లోకి copy చేసి, build సమయంలో update-ca-certificates ను run చేయండి. మీ services VPS పై Docker Compose కింద నడిస్తే దీనికి ముందుగానే ప్రణాళిక చేసుకోండి.

Clean install చేసిన తర్వాత కూడా ఒక program certificate ను తిరస్కరిస్తే, మరేదైనా మార్చే ముందు అది ఏ files ను open చేస్తుందో కనుగొనండి. strace -f -e trace=openat <command> 2>&1 | grep -i cert నేరుగా పరిశీలిస్తుంది. చాలా runs లో అది ఈ ప్రశ్నకు సమాధానం ఇస్తుంది. ఇది openat calls ను మాత్రమే trace చేస్తుంది. అలాగే path లో cert అనే పదం లేని bundle లను filter తొలగిస్తుంది. అందువల్ల ఏమీ print కాకపోతే, program ఏ file ను చదవడం లేదని నిర్ధారించుకునే ముందు grep లేకుండా మళ్లీ run చేయండి. Compiled-in list సాధారణంగా ఇలాగే కనిపిస్తుంది.

CA ను కాలక్రమేణా ఉపయోగపడేలా ఉంచడం

ఒక leaf certificate ను మళ్ళీ జారీ చేయడం అంటే, అదే app.ext ఫైల్‌ను ఉపయోగించి CSR మరియు signing ప్రక్రియలను మళ్ళీ నిర్వహించడం. క్లయింట్లు ఎటువంటి చర్య తీసుకోవాల్సిన అవసరం లేదు, ఎందుకంటే వారు నమ్మే root మారలేదు. ca.srl మరియు ప్రతి .ext ఫైల్‌ను CA డైరెక్టరీలోనే ఉంచండి; తద్వారా తదుపరి జారీ ప్రక్రియ అనేది జ్ఞాపకశక్తిపై ఆధారపడకుండా, గతంలో పనిచేసిన కమాండ్‌ను మళ్ళీ అమలు చేయడం ద్వారా సులభంగా పూర్తవుతుంది.

ca.key మరియు ca.crt ఫైళ్లను సర్వర్ వెలుపల ఎక్కడైనా సురక్షితంగా, ఎన్‌క్రిప్ట్ చేసిన స్థితిలో బ్యాకప్ తీసుకోండి. ఒకవేళ కీని కోల్పోతే, మీరు కొత్తగా ఏదీ జారీ చేయలేరు: అప్పుడు మీరు రెండవ CA ను నిర్మించి, మొదటి CA ఎక్కడెక్కడైతే ఇన్‌స్టాల్ చేయబడిందో, అక్కడంతా కొత్త root ను ఇన్‌స్టాల్ చేయాల్సి ఉంటుంది. రూట్ సర్టిఫికేట్‌ను స్వీకరించిన ప్రతి మెషీన్ మరియు ప్రతి అప్లికేషన్ స్టోర్ యొక్క లిఖితపూర్వక జాబితాను ఉంచండి, ఎందుకంటే ఆ జాబితా వల్లే భవిష్యత్తులో సర్టిఫికేట్ రొటేషన్ మరియు తొలగింపు సాధ్యమవుతాయి.

రూట్ సర్టిఫికేట్ గడువు ముగిసే సమయం దగ్గరపడుతున్నప్పుడు, ముందుగానే కొత్త దానిని రూపొందించి, పాత మరియు కొత్త రూట్లను పక్కపక్కనే ఇన్‌స్టాల్ చేయండి. స్టోర్‌లో రెండు రూట్లు ఉండటం వల్ల ఎటువంటి ఇబ్బంది లేదు, క్లయింట్ రెండింటిలో దేనినైనా అంగీకరిస్తుంది. కొత్త రూట్ ఆధారంగా leaf సర్టిఫికేట్లను మళ్ళీ జారీ చేయండి, ఆపై పాత రూట్‌పై ఏదీ ఆధారపడటం లేదని నిర్ధారించుకున్నాక దానిని తొలగించండి.

Trust store నుంచి CA ను తొలగించండి

sudo rm /usr/local/share/ca-certificates/example-internal-root.crt
sudo update-ca-certificates --fresh

--fresh, /etc/ssl/certs లోని source directories వైపు చూపించే symlinks ను తొలగిస్తుంది. మీరు తొలగించిన file కారణంగా ఇప్పుడు dangling గా మిగిలిన symlink కూడా ఇందులో ఉంటుంది. తరువాత ప్రస్తుతం ఉన్న sources ఆధారంగా ఆ symlinks ను మళ్లీ నిర్మిస్తుంది. అందువల్ల తొలగించిన root, directory మరియు bundle రెండింటి నుంచీ తొలగిపోతుంది. Install ను నిర్ధారించిన విధంగానే removal ను కూడా నిర్ధారించండి.

openssl verify app.crt
echo $?
grep -c 'BEGIN CERTIFICATE' /etc/ssl/certs/ca-certificates.crt
ls -l /etc/ssl/certs/$(openssl x509 -noout -subject_hash -in ~/ca/ca.crt).0

Verification మళ్లీ విఫలమవుతుంది. Certificate count మొదట ఉన్న స్థితికి తిరిగి వస్తుంది. Hash symlink కూడా తొలగిపోతుంది.

ఆ command system store ను మాత్రమే మారుస్తుంది; మరేదీ మార్చదు. మిగిలిన ప్రదేశాల్లో install ను చేతితో undo చేయాలి: NODE_EXTRA_CA_CERTS ను ఖాళీ చేయండి, ఏదైనా Java keystore లోని alias ను తొలగించండి, ప్రతి browser profile నుంచి root ను తొలగించండి, అలాగే దాన్ని చేర్చుకున్న container image ఏదైనా ఉంటే దాన్ని మళ్లీ build చేయండి. Root ను తొలగించడం వల్ల అది sign చేసిన certificates invalid కావు. దాన్ని ఇంకా trust చేసే ప్రతి machine లో అవి valid గానే ఉంటాయి. అందుకే private CA లో root ఎక్కడికి చేర్చబడిందో తెలిపే లిఖితపూర్వక జాబితా అవసరం. CA ను పూర్తిగా withdraw చేయలేకపోతే అది శాశ్వత security hole గా మిగులుతుంది. కాబట్టి CA ను setup చేసిన రోజే, జాబితా ఇంకా చిన్నగా ఉన్నప్పుడు, ఒక machine పై removal ను test చేయండి.

FAQ

Ubuntuలో CA certificateను ఎక్కడ ఉంచాలి?

/usr/local/share/ca-certificates/ లో, .crt తో ముగిసే filename మరియు PEM contentతో ఉంచి, తరువాత sudo update-ca-certificates ను అమలు చేయాలి. ఆ directory local administrator కోసం కేటాయించబడింది, కాబట్టి package upgrades దానిని మార్చవు. /usr/share/ca-certificates అనేది ca-certificates packageకు చెందినది. /etc/ssl/certs ఈ రెండింటి నుంచి రూపొందించబడుతుంది. అందువల్ల వీటిలో ఏదైనా directoryలో ఉంచిన file overwrite అవుతుంది లేదా విస్మరించబడుతుంది.

update-ca-certificates అమలు చేసిన తర్వాత కూడా curl certificateను ఎందుకు తిరస్కరిస్తుంది?

కారణాలను క్రమంగా పరిశీలించండి. File .crt తో ముగియకపోవచ్చు. అప్పుడు update-ca-certificates దానిని దాటవేసి ఏదీ జోడించదు. అది PEMకు బదులుగా DER కావచ్చు. ఈ విషయం tool గుర్తించదు. Tool ఆ fileకు link చేసి, దానిని bundleకు జోడించి, addedగా లెక్కిస్తుంది. కానీ hash link సృష్టించదు. కాబట్టి దానిని PEMకు మార్చి, fileను భర్తీ చేసి, commandను మళ్లీ అమలు చేయాలి. Certificate యొక్క subjectAltName మీరు connect అవుతున్న hostnameను జాబితా చేయకపోవచ్చు. ఇది trust failure కాకుండా hostname failure. Certificateలో DNS లేదా IP SAN ఏదీ లేనప్పుడు మాత్రమే curl common nameకు fallback అవుతుంది. కాబట్టి openssl x509 -noout -ext subjectAltName -in app.crt తో తనిఖీ చేయండి. Intermediate certificate కూడా అవసరమైనప్పుడు server leaf certificateను మాత్రమే పంపుతుండవచ్చు. CURL_CA_BUNDLE లేదా --cacert ద్వారా curl వేరే bundleను ఉపయోగిస్తుండవచ్చు. ఎక్కువసేపు నడుస్తున్న serviceను restart చేయాలి, ఎందుకంటే చాలా programs ప్రారంభమైనప్పుడు trust storeను ఒక్కసారి మాత్రమే చదువుతాయి.

System trust store Firefox, Chrome, Node మరియు Javaకు వర్తిస్తుందా?

లేదు. curl, wget, git, Python యొక్క ప్రామాణిక ssl module మరియు Go programs system filesను చదువుతాయి. కాబట్టి update-ca-certificates అమలు చేసిన వెంటనే అవి పనిచేస్తాయి. Firefox తన స్వంత storeను ఉంచుతుంది. Linuxలో Chromium ప్రతి userకు ప్రత్యేకమైన NSS databaseను ఉపయోగిస్తుంది. దానిని libnss3-tools packageలోని certutil తో సవరించాలి. Node.jsకు మీ root fileను సూచించే NODE_EXTRA_CA_CERTS అవసరం. Java ఒక keystoreను చదువుతుంది. update-ca-certificates దానిని ca-certificates-java package install చేసినప్పుడు మాత్రమే refresh చేస్తుంది. Python యొక్క requests, certifi ను ఉపయోగిస్తుంది మరియు REQUESTS_CA_BUNDLE అవసరం.

Ubuntu trust store నుంచి CAను ఎలా తొలగించాలి?

/usr/local/share/ca-certificates/ నుంచి fileను తొలగించి, sudo update-ca-certificates --fresh ను అమలు చేయాలి. --fresh option, source directoriesలోకి చూపించే /etc/ssl/certs లోని symlinksను తొలగించి, వాటిని మళ్లీ నిర్మిస్తుంది. అందువల్ల certificate hash symlinks మరియు ca-certificates.crt bundle రెండింటి నుంచీ ఒకేసారి తొలగించబడుతుంది. ఆ CA sign చేసిన certificateపై openssl verify ను అమలు చేసి, exit statusను పరిశీలించడం ద్వారా నిర్ధారించండి. తరువాత మీరు certificateను జోడించిన ఇతర ప్రతి storeలోనూ తొలగింపు ప్రక్రియను పునరావృతం చేయండి. ఆ command వాటిలో దేనినీ మార్చదు.

Public site కోసం Let's Encryptకు బదులుగా private CAను ఉపయోగించవచ్చా?

లేదు. Visitor browser మీ rootను ఎప్పుడూ చూడలేదు. అందువల్ల అది పూర్తి పేజీ warningను చూపుతుంది. మీరు నియంత్రించని machinesలో మీ rootను install చేయలేరు. మీ స్వంత machines మాత్రమే resolve చేసే names కోసం, అలాగే మీరు నిర్వహించే clients కోసం private CA ఉపయోగించాలి. అపరిచితులు సందర్శించే ఏ siteకైనా certificateను public CA నుంచి పొందాలి.

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

#tls#certificates#openssl#ubuntu#security#pki