SSD Nodes Learn Hosting plans →
Mga Gabay Matt ConnorNi Matt Connor · Na-update 2026-10-25

Self-Signed TLS Certificate sa Ubuntu 24.04

Gumawa ng self-signed TLS cert na tinatanggap ng Chrome sa Ubuntu 24.04, may SAN, nginx o Apache setup, at tamang trust nang walang curl -k.

Ano ang ginagawa mo

Isang self-signed TLS certificate na talagang tinatanggap ng mga modern browser at client, tamang subjectAltName, maayos na key permissions, naka-configure sa nginx o Apache, pati ang bahaging madalas laktawan ng mga guide: ang tamang pag-trust dito ng iyong mga client, sa halip na palaging i-click ang mga warning at i-hard-code ang curl -k sa mga script. Sa huli, may five-command private CA para sa sitwasyong ang isang internal service ay naging anim.

Una, kailangang piliin nang tama ang approach, dahil mas madalang maging tamang tool ang self-signed certificate kaysa sa aktuwal na paggamit nito. Kung naa-access ang service mula sa public internet gamit ang totoong DNS name, tumigil na rito at kumuha ng libreng Let's Encrypt certificate gamit ang certbot sa nginx o katumbas nito para sa Apache. Wala itong bayad, awtomatikong nagre-renew, at pinagkakatiwalaan na ng mga mainstream browser at operating system. Kapag gumamit ka ng self-signed certificate sa isang public site, nasasanay ang mga user na lampasan ang security warning. Mas masama itong practice kaysa plain HTTP.

Self-signed ang tamang tool kapag walang kinalaman ang public internet: isang admin panel na naka-bind sa WireGuard tunnel address sa iyong VPS, isang staging box sa private network, service-to-service traffic sa pagitan ng mga backend, isang home-lab appliance, o pagpapalit sa placeholder certificate na ginagawa mismo ng Webmin sa port 10000. Hindi pa rin makakapag-issue ang Let's Encrypt para sa 10.8.0.1 o git.internal.lan, at walang public CA na maglalagay ng private IP o gawa-gawang TLD sa certificate. Para sa mga pangalang iyon, ikaw ang CA.

Ang lahat ng nasa ibaba ay tumatakbo sa isang bagong Ubuntu 24.04 box, na may kasamang OpenSSL 3.0.x (openssl version para makumpirma). Walang kailangan dito na internet access; gumagana ang lahat kahit air-gapped.

Bakit nagpo-produce ang lumang one-liner ng mga certificate na nire-reject ng Chrome

Ganito ang command na makikita sa halos lahat ng tutorial bago ang 2017:

# Do not run this: shown so you recognise it in old guides
openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
  -keyout selfsigned.key -out selfsigned.crt

Nagtatanong ito ng sunod-sunod na interactive na tanong, inilalagay ang hostname mo sa Common Name field, at nagpo-produce ng certificate na walang subjectAltName extension. Hindi gagana ang certificate na iyon. Tumigil ang Chrome sa pagbasa ng Common Name sa version 58 noong April 2017. Na-deprecate na ng RFC 2818 ang CN matching noong 2000. Pareho rin ang behavior ng Firefox at Safari. Nagfa-fallback pa rin ang curl at Python's ssl module sa Common Name kapag walang SAN ang certificate. Dahil dito, maaaring pumasa ang certificate na walang SAN sa isang mabilis na curl test pero mabigo pa rin sa lahat ng browser. Para sa browser, kinikilala ng certificate ang server nito sa pamamagitan ng SAN extension, o hindi talaga ito kinikilala. Ipinapakita ito ng browser gamit ang eksaktong mensaheng ito:

NET::ERR_CERT_COMMON_NAME_INVALID

This server could not prove that it is git.internal.lan; its security
certificate does not specify Subject Alternative Names.

Walang silbi ang paulit-ulit na pag-configure ng trust store para ayusin ang error na iyon, dahil talagang walang pangalan ang certificate. Kung nakikita mo ngayon ang NET::ERR_CERT_COMMON_NAME_INVALID, walang SAN ang certificate mo o mali ang SAN nito, kaya kailangan mong gumawa ng bago. Mabuti na lang at isang command lang ang kailangan para ayusin ito.

Mag-mint ng certificate na tatanggapin ng mga browser: isang command

Nagdagdag ang OpenSSL ng -addext flag sa 1.1.1. Dahil dito, hindi mo na kailangang gamitin ang config-file gymnastics ng mga lumang guide para mag-inject ng SAN. Sa Ubuntu 24.04:

sudo openssl req -x509 -newkey rsa:4096 -sha256 -days 730 -noenc \
  -keyout /etc/ssl/private/git.internal.key \
  -out /etc/ssl/certs/git.internal.crt \
  -subj "/CN=git.internal.lan" \
  -addext "subjectAltName=DNS:git.internal.lan,IP:10.8.0.1"

Narito ang ginagawa ng bawat flag:

  • Direktang naglalabas ang -x509 ng self-signed certificate sa halip na signing request.
  • Gumagawa ang -newkey rsa:4096 ng bagong key sa parehong hakbang. Hindi magiging problema sa mga lumang client ang RSA 4096; kung modern lahat ng kumokonekta, mas maliit at mas mabilis ang -newkey ec -pkeyopt ec_paramgen_curve:P-256.
  • Ang -noenc ang spelling sa OpenSSL 3.x ng dating -nodes: walang passphrase ang key. Parehong gumagana ang dalawang spelling. Kapag may passphrase ang key, maghihintay ang nginx ng input sa bawat boot. Kaya para sa server key, ito ang dapat gamitin.
  • Dalawang taon ang -days 730; tatalakayin pa ang numerong iyon sa expiry section.
  • Sinasagot ng -subj ang interactive questions inline. Cosmetic na lamang ngayon ang CN, pero itakda pa rin ito sa primary name; ipinapakita pa rin ito ng ilang tool.
  • Ang -addext "subjectAltName=..." ang pangunahing flag. Ilagay ang bawat pangalan at bawat IP na ita-type ng mga client: DNS: entries para sa mga hostname (puwedeng gumamit ng wildcard gaya ng DNS:*.internal.lan), at IP: entries para sa mga address. Kung may magba-browse sa https://10.8.0.1, dapat naroon ang IP:10.8.0.1 entry. Kung DNS-only SAN ang gagamitin, makukuha nila muli ang NET::ERR_CERT_COMMON_NAME_INVALID.

Kumpirmahing aktuwal na naisama ang SAN bago mag-configure ng iba:

openssl x509 -in /etc/ssl/certs/git.internal.crt -noout -ext subjectAltName

Tamang output:

X509v3 Subject Alternative Name:
    DNS:git.internal.lan, IP Address:10.8.0.1

Kung No extensions in certificate ang lumabas sa halip, walang SAN ang certificate at tatanggihan ito ng mga browser. Mag-regenerate ng certificate sa halip na ituloy ang configuration.

Lock down ang key

Ang private key na nababasa ng bawat user sa server ay hindi na private key. Sa standard Ubuntu 24.04 server, naka-700 root:root na ang /etc/ssl/private, kaya root lamang ang makakapaglista nito; nagiging 710 root:ssl-cert lamang ito kapag may nag-install ng ssl-cert package (nirerekomenda ito ng apache2). Anuman ang sitwasyon, tahasang itakda ang file mismo:

sudo chown root:root /etc/ssl/private/git.internal.key
sudo chmod 600 /etc/ssl/private/git.internal.key

Parehong binabasa ng nginx at Apache ang mga certificate bilang root bago ibaba ang kanilang privilege, kaya gumagana sa kanila ang mode 600 na root:root. Kung para sa isang service ang key na tumatakbo sa sarili nitong user at mismong naglo-load ng key, gaya ng Node app, Gitea, o Python daemon, chown ito sa user ng service na iyon, at panatilihin ang mode na 600. Huwag na huwag gagamit ng mode 644, maglalagay ng kopya sa git repository, o maglalagay ng kopya sa /tmp.

Iugnay ito sa nginx

server {
    listen 443 ssl;
    listen [::]:443 ssl;
    server_name git.internal.lan;

    ssl_certificate     /etc/ssl/certs/git.internal.crt;
    ssl_certificate_key /etc/ssl/private/git.internal.key;

    location / {
        proxy_pass http://127.0.0.1:3000;
    }
}
sudo nginx -t && sudo systemctl reload nginx

Dapat i-print ng nginx -t ang syntax is ok at test is successful bago gumawa ng anuman ang reload. Kung sa halip ay i-print nito ang SSL_CTX_use_PrivateKey_file() failed ... key values mismatch, mula sa magkaibang generation run ang certificate at key; tingnan ang seksyong failure modes.

I-configure ito sa Apache

sudo a2enmod ssl proxy proxy_http

Hindi sapat dito ang ssl: gumagamit ang vhost sa ibaba ng ProxyPass, at kung wala ang mod_proxy at mod_proxy_http, mabibigo ang config test dahil sa Invalid command 'ProxyPass', perhaps misspelled or defined by a module not included in the server configuration. I-save ang vhost bilang /etc/apache2/sites-available/git-internal.conf:

<VirtualHost *:443>
    ServerName git.internal.lan
    SSLEngine on
    SSLCertificateFile      /etc/ssl/certs/git.internal.crt
    SSLCertificateKeyFile   /etc/ssl/private/git.internal.key

    ProxyPass        / http://127.0.0.1:3000/
    ProxyPassReverse / http://127.0.0.1:3000/
</VirtualHost>
sudo a2ensite git-internal
sudo apache2ctl configtest && sudo systemctl reload apache2

Dapat tumugon ang configtest sa Syntax OK. Ngayon, mag-test mula sa isang client machine:

curl -v https://git.internal.lan/

at makakakuha ka ng error:

curl: (60) SSL certificate problem: self-signed certificate

Hindi ito bug. Gumagana ang TLS: hindi pa nakikilala ng curl ang certificate mo, kaya tumatanggi itong makipag-ugnayan sa server na hindi nito ma-authenticate. Ang susunod na seksyon ang aktuwal na solusyon, at hindi ito ang karaniwang ginagawa ng maraming tao sa internet sa mismong sandaling ito.

Gawing trusted ito ng mga client, at ang mga anti-pattern na dapat tanggihan

Unahin ang maling mga fix, at tukuyin kung ano talaga ang mga ito. Ang curl -k (o --insecure) na isinama sa script, verify=False sa Python requests, at NODE_TLS_REJECT_UNAUTHORIZED=0 sa Node ay hindi gumagawang trusted ng certificate. Ino-off ng mga ito ang certificate verification. Dahil dito, makikipag-usap ang client sa anumang server na nagpapakita ng anumang certificate, kabilang ang certificate na inilagay ng attacker sa path. Napapanatili mo ang overhead ng TLS ngunit nawawala ang authentication na siyang dahilan kung bakit ito ginagamit. Mas masama, kumakalat ang mga flag na ito: kinokopya sa isang cron job, pagkatapos sa deploy script, at pagkatapos sa production code, hanggang sa wala nang nakaaalam kung aling mga koneksyon ang dapat sanang pansamantala lamang. Kung nananatili ang isang verify=False matapos ang debugging session na pinagmulan nito, mali ang disenyo.

Ang tamang fix ay turuan ang OS ng bawat client na trusted root ang certificate na ito. Sa mga Ubuntu at Debian client:

sudo cp git.internal.crt /usr/local/share/ca-certificates/git.internal.crt
sudo update-ca-certificates

Ang mahalagang linya sa output (sinusundan ito ng Running hooks in /etc/ca-certificates/update.d... block) ay:

Updating certificates in /etc/ssl/certs...
1 added, 0 removed; done.

May dalawang posibleng problema sa mga linyang iyon. Dapat magtapos ang file sa .crt. Tahimik na binabalewala ang extension na .pem, kaya nakakakuha ka ng 0 added nang walang error message. Dapat ding PEM ang laman; nagsisimula ang file sa -----BEGIN CERTIFICATE-----. I-convert muna ang DER binary gamit ang openssl x509 -inform der -in file.der -out file.crt. Gumagana ang pagdagdag ng self-signed certificate mismo bilang root dahil ang self-signed certificate ay sarili nitong root.

Pagkatapos nito, nagtitiwala sa server nang walang anumang flag ang curl, wget, git, apt, at iba pang gumagamit ng OpenSSL laban sa system bundle. May ilang client na may sarili nilang trust store at nangangailangan ng indibidwal na configuration:

  • Chrome/Chromium sa Linux ay nagbabasa ng NSS database, hindi ng system store: sudo apt install libnss3-tools, pagkatapos ay certutil -d sql:$HOME/.local/share/pki/nssdb -A -t "C,," -n "git.internal" -i git.internal.crt para sa bawat user. Ang path na ito ang default ng Chrome mula version 146. Kung mayroon pa ring legacy na ~/.pki/nssdb ang user mula sa mas lumang installation, iyon pa rin ang babasahin ng Chrome. Ituro ang -d sa sql:$HOME/.pki/nssdb sa mga machine na iyon.
  • Firefox ay may sarili nitong store: Settings → Privacy & Security → Certificates → Import. Sa Windows at macOS, maaari mong baguhin ang security.enterprise_roots.enabled sa true sa about:config upang basahin nito ang OS store. Idinodokumento ng Mozilla ang preference na ito para sa Windows at macOS, hindi para sa Linux. Kaya sa Ubuntu, gamitin ang import.
  • Python requests ay may sarili nitong CA bundle (certifi) at binabalewala ang system store: ipasa ang verify="/usr/local/share/ca-certificates/git.internal.crt" o i-export ang REQUESTS_CA_BUNDLE=/etc/ssl/certs/ca-certificates.crt.
  • Node.js ay gumagamit bilang default ng sarili nitong bundled roots: i-export ang NODE_EXTRA_CA_CERTS=/usr/local/share/ca-certificates/git.internal.crt, o ipabasa rito ang system store na kaka-update mo lamang gamit ang flag na --use-system-ca (Node 23.9 at mas bago sa Linux) o NODE_USE_SYSTEM_CA=1 (Node 24.6 at Node 22.19 at mas bago).

Sa mga Windows client, i-double-click ang .crt at i-install ito sa Trusted Root Certification Authorities. Sa macOS, idagdag ito sa System keychain gamit ang Keychain Access at itakda sa Always Trust.

Isang root para sa maraming serbisyo: isang maliit na private CA

Hindi agad nasusukat ang per-certificate trust: anim na serbisyo na mino-monitor ng apat na client machine ay dalawampu’t apat na trust installation, at bawat bagong serbisyo ay nagdaragdag pa nito. Ang solusyon ay isang private CA. Isang root lang ang pinagkakatiwalaan ng mga client, at gamit ito, sina-sign mo ang certificate ng bawat serbisyo.

Ang mas madaling opsyon ay mkcert, na nasa Ubuntu 24.04 repos at kayang mag-handle ng NSS stores (Firefox at Chrome, na may isang caveat sa ibaba) na hindi kayang hawakan ng update-ca-certificates:

sudo apt install -y mkcert libnss3-tools
mkcert -install
mkcert git.internal.lan "*.internal.lan" 10.8.0.1

Lumilikha ang mkcert -install ng root at nirerehistro ito sa system store, sa mga browser NSS store na matatagpuan nito, at sa Java store kapag naka-set ang JAVA_HOME. Hindi binabasa ng Node ang system store maliban kung sasabihan ito, kaya simulan ang Node apps gamit ang --use-system-ca (o NODE_USE_SYSTEM_CA=1) gaya sa itaas, o i-export ang NODE_EXTRA_CA_CERTS="$(mkcert -CAROOT)/rootCA.pem". Inilalabas ng ikatlong command ang git.internal.lan+2.pem at git.internal.lan+2-key.pem, na handa nang ilagay sa mga nginx o Apache snippet sa itaas. Ipinapalagay ng disenyo nito na development machine ang gamit. Nasa anumang box na nagpatakbo ng -install ang root key, kaya perpekto ito para sa dev laptop ngunit hindi angkop para sa server fleet.

Ang caveat, noong October 2026: hinahanap lamang ng mkcert ang Chrome NSS database sa legacy na ~/.pki/nssdb path, hindi sa ~/.local/share/pki/nssdb, na default na ginagamit ng Chrome mula version 146. Sa machine na walang legacy database, manu-manong idagdag ang root para sa Chrome gamit ang certutil command mula sa nakaraang seksyon, at gamitin ang -i "$(mkcert -CAROOT)/rootCA.pem".

Para sa mga server, kayang isagawa ng plain OpenSSL ang buong CA sa limang command:

openssl genrsa -out lab-ca.key 4096
openssl req -x509 -new -key lab-ca.key -sha256 -days 3650 \
  -out lab-ca.crt -subj "/CN=Lab Internal CA" \
  -addext "basicConstraints=critical,CA:TRUE,pathlen:0" \
  -addext "keyUsage=critical,keyCertSign,cRLSign"
openssl genrsa -out git.key 2048
openssl req -new -key git.key -out git.csr -subj "/CN=git.internal.lan" \
  -addext "subjectAltName=DNS:git.internal.lan,IP:10.8.0.1"
openssl x509 -req -in git.csr -CA lab-ca.crt -CAkey lab-ca.key \
  -CAcreateserial -days 730 -sha256 -copy_extensions copy -out git.crt

Ang problema ay nasa huling command: bilang default, inaalis ng openssl x509 -req ang lahat ng extension mula sa CSR, kasama ang SAN na maingat mong idinagdag. Dinadala ng -copy_extensions copy (isang opsyon sa OpenSSL 3.x, kaya gumagana ito sa 24.04) ang mga extension sa nilagdaang certificate. Kapag iniwan mo ito, walang SAN ang signed certificate at muli kang babatiin ng Chrome ng NET::ERR_CERT_COMMON_NAME_INVALID. I-verify ito gamit ang parehong openssl x509 -noout -ext subjectAltName check gaya ng dati.

Ipamahagi ang lab-ca.crt sa mga client gamit ang mga trust-store step sa itaas, isang beses para sa bawat machine. Ingatan ang lab-ca.key na para bang napakahalagang credential nito: gamitin ang mode 600 at, kung maaari, panatilihin ito sa isang box na hindi kabilang sa mga server na sina-sign nito, dahil maaaring gumawa ng certificate para sa anumang pangalan ang sinumang may hawak nito na paniniwalaan ng iyong mga client.

Pag-expire at rotation

Pababa nang pababa ang validity period ng mga certificate mula sa public CA. Nilimitahan ng CA/Browser Forum ang mga bagong publicly trusted certificate sa 200 days noong March 2026, mula sa dating 398 days. Babalik ito sa 100 days sa 2027 at 47 days pagsapit ng March 2029. Gayunman, ang mga panuntunang ito ay para lamang sa publicly trusted CA. Hindi saklaw ng mga ito ang private CA mo, at hindi ipinapatupad ng mga browser ang mga ito sa mga manually installed root. May isang aktuwal na limitasyon: tinatanggihan ng Apple platforms ang TLS server certificate na valid nang higit sa 825 days, kahit sino pa ang nag-issue nito. Kaya kung kokonekta ang mga iPhone o Mac, panatilihing dalawang taon o mas maikli ang validity ng leaf certificate. Pasado sa limitasyong iyon ang -days 730 sa lahat ng environment. Komportable para sa internal setup ang ten-year root na may two-year leaves.

Isang paraan lang pumapalya ang mga long-lived certificate: tahimik at sabay-sabay, sa petsang walang nakakaalala kung bakit iyon ang napili. Suriin kung ano ang mayroon ka:

openssl x509 -in /etc/ssl/certs/git.internal.crt -noout -enddate

Ilagay ang renewal sa aktuwal na calendar, o ipa-remind ito sa cron 30 days bago ang expiry. Mag-e-exit ang openssl x509 -checkend 2592000 -in cert.crt nang non-zero kapag ang nalalabing validity ay pasok na sa itinakdang bilang ng seconds. Kung gumagamit ka na ng Uptime Kuma para sa status monitoring, awtomatikong nagfa-flag ang HTTPS monitors nito kapag papalapit na ang certificate expiry, nang walang dagdag na bayad.

Madali lang ang rotation gamit ang private CA: patakbuhin muli ang mga CSR-and-sign command, palitan ang mga file, at i-reload ang web server. Hindi nagbago ang root, kaya walang mapapansin ang mga client.

Mga failure mode at mga string na makikita mo

NET::ERR_CERT_AUTHORITY_INVALID, ito ang inaasahang state bago ka mag-install ng trust; hindi ito depekto sa certificate. Kung nagpapatuloy ito pagkatapos mong idagdag ang root: sa Linux, NSS ang binabasa ng Chrome sa halip na system store (tingnan ang step na certutil), at mula Chrome 146, nasa ~/.local/share/pki/nssdb ang database na iyon maliban kung may legacy na ~/.pki/nssdb. Kaya hindi kailanman makikita ang root na idinagdag sa ibang path. Maaari ring hindi nagtatapos sa .crt ang kinopyang file at sinabi ng update-ca-certificates na 0 added. Posible ring ibang certificate ang ipinapakita ng server kaysa sa certificate na pinagkatiwalaan mo; ikumpara ang fingerprints gamit ang openssl s_client -connect git.internal.lan:443 </dev/null 2>/dev/null | openssl x509 -noout -fingerprint -sha256.

NET::ERR_CERT_COMMON_NAME_INVALID, walang SAN ang certificate, o hindi saklaw ng SAN ang pangalan sa address bar. Karaniwang halimbawa: nakalista sa SAN ang DNS:git.internal.lan pero nag-browse ang user sa https://10.8.0.1. Hindi ito maaayos ng mga pagbabago sa trust store; i-reissue ang certificate kasama ang nawawalang entry.

curl: (60) SSL certificate problem: self-signed certificate, hindi pinagkakatiwalaan ng curl ang certificate. Ganito rin ang ibig sabihin ng variant na self-signed certificate in certificate chain para sa certificate na nilagdaan ng private CA mo. Pang-isahang fix: curl --cacert lab-ca.crt https://...; permanenteng fix: ang trust store. Hindi -k.

unable to load certificate ... Expecting: TRUSTED CERTIFICATE (o Expecting: CERTIFICATE REQUEST, o no start line), may kalituhan sa PEM. Maling uri ng file ang ibinigay mo sa OpenSSL: key o CSR kung certificate ang inaasahan nito, o DER binary kung PEM ang inaasahan nito. Ipinapakita ng head -1 filename kung ano talaga ang mayroon ka; nagsisimula ang certificate sa -----BEGIN CERTIFICATE-----. Para sa DER, mag-convert gamit ang openssl x509 -inform der -in file.der -out file.crt.

nginx: [emerg] SSL_CTX_use_PrivateKey_file(...) failed (SSL: error ... key values mismatch), hindi magkapareha ang certificate at key, karaniwan dahil dalawang beses pinatakbo ang generation command at napaghalo ang mga file. Kumpirmahin gamit ang openssl x509 -in git.internal.crt -noout -pubkey | sha256sum laban sa openssl pkey -in git.internal.key -pubout | sha256sum; ang magkaparehong hash ay nangangahulugang magkaparehang pair. Kung magkaiba ang mga ito, muling i-generate ang dalawa nang magkasama.

FAQ

Bakit sinasabi pa rin ng Chrome na “Not secure” kahit gumawa na ako ng self-signed certificate?

Kung ang error ay NET::ERR_CERT_AUTHORITY_INVALID, maayos ang certificate; wala pa lang dahilan ang Chrome para pagkatiwalaan ito. I-install ito, o ang private CA root mo, sa trust store ng client. Tandaan na sa Linux, ginagamit ng Chrome ang NSS database sa pamamagitan ng certutil (sa ~/.local/share/pki/nssdb simula Chrome 146, o isang legacy na ~/.pki/nssdb kung mayroon), hindi ang system store. Kung ang error ay NET::ERR_CERT_COMMON_NAME_INVALID, walang Subject Alternative Name ang certificate na tumutugma sa URL. Kailangan itong i-issue muli gamit ang -addext "subjectAltName=...".

Paano mapagkakatiwalaan ng curl ang self-signed certificate nang hindi gumagamit ng -k?

Kopyahin ang certificate (PEM format, extension na .crt) sa /usr/local/share/ca-certificates/ at patakbuhin ang sudo update-ca-certificates. Dapat sabihin ng output na 1 added. Mula noon, ive-verify ito ng curl gaya ng anumang public certificate. Para sa isang request lang nang hindi binabago ang system, nagve-verify ang curl --cacert /path/to/cert.crt batay lamang sa file na iyon. Ganap na dini-disable ng -k ang verification at hindi ito dapat ilagay sa anumang script.

Gaano katagal maaaring maging valid ang self-signed certificate?

Sa teknikal na paraan, maaari itong maging valid nang gaano katagal mo gusto. Ang mga limitasyon ng CA/Browser Forum (200 araw ngayon, 47 pagsapit ng 2029) ay para sa mga CA na pinagkakatiwalaan ng publiko, hindi sa private trust. Sa praktika, limitahan sa 825 araw ang server certificates, dahil tinatanggihan ng mga Apple device ang mas mahaba rito anuman ang issuer. Ang private root na sampung taon ang validity, kasama ang mga leaf certificate na dalawang taon ang validity (-days 730), ay maayos na default. Itala lang sa calendar ang renewal, dahil maaaring tahimik na patigilin ng expired internal certificate ang lahat sa petsang walang nakakaalala.

Dapat ba akong gumamit ng self-signed certificate o Let's Encrypt?

Kung may public DNS name ang serbisyo at naaabot ito mula sa internet, palaging gamitin ang Let's Encrypt: libre ito, automated, at pinagkakatiwalaan na ng karamihan ng browser at operating system. Suriin ang compatibility list ng Let's Encrypt kung kailangang kumonekta ang napakalumang mga device. Ang self-signed certificate, o private CA, ay para sa mga hindi maaaring i-issue ng Let's Encrypt: private IP, mga internal-only hostname gaya ng .lan, air-gapped network, at mga serbisyong sadyang itinago sa likod ng VPN. Ang desisyon ay tungkol sa reachability at naming, hindi sa lakas ng seguridad. Magkapareho ang cryptography.

Bakit tinatanggihan ang certificate ko kahit naidagdag ko na ito sa /usr/local/share/ca-certificates?

Suriin ang tatlong bagay. Dapat magtapos ang file sa .crt. Tahimik na nilalaktawan ang extension na .pem, at iniuulat ng update-ca-certificates ang 0 added. Dapat PEM text ang laman nito na nagsisimula sa -----BEGIN CERTIFICATE-----, hindi DER binary. Dapat ding aktuwal na gamitin ng application ang system store. Ang Chrome sa Linux, Firefox, Python requests, Node.js (maliban kung sinimulan gamit ang --use-system-ca), at Java ay may kani-kaniyang private trust store at kailangang paglagyan ng certificate nang hiwalay.

Nakatulong ba ang artikulong ito?