ಉನ್ನತ-ಸವಲತ್ತುಗಳ API ಕೀಯನ್ನು ರೆಸ್ಟ್‌ನಲ್ಲಿ ಎನ್‌ಕ್ರಿಪ್ಟ್ ಮಾಡುವುದು: AI ಟ್ರಾನ್ಸ್‌ಕ್ರಿಪ್ಟ್‌ಗಳಿಂದ ರಹಸ್ಯಗಳನ್ನು ದೂರವಿಡುವ ಒಂದು GPG ವಾಲ್ಟ್

ಹೆಚ್ಚಿನ ರುಜುವಾತುಗಳ (credential) ಸೋರಿಕೆಗಳು ನಾಟಕೀಯವಾಗಿರುವುದಿಲ್ಲ. ಅಲ್ಲಿ ಯಾವುದೇ ಹ್ಯಾಕರ್ ಇರುವುದಿಲ್ಲ, ಬ್ರೀಚ್ ರಿಪೋರ್ಟ್ ಇರುವುದಿಲ್ಲ. ಯಾರೋ ಒಬ್ಬರು ಖಾತೆ-ವ್ಯಾಪಕ API ಕೀಯನ್ನು ತಮ್ಮ ಹೋಮ್ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ಪ್ಲೇನ್‌ಟೆಕ್ಸ್ಟ್ ಫೈಲ್‌ನಲ್ಲಿ ಇಟ್ಟಿರುತ್ತಾರೆ, ಮತ್ತು ಒಂದು ದಿನ ಬ್ಯಾಕಪ್, ಸ್ಕ್ರೀನ್-ಶೇರ್, ಪೇಸ್ಟ್ ಮಾಡಿದ ಕಮಾಂಡ್ ಅಥವಾ AI ಕೋಡಿಂಗ್ ಸೆಷನ್ ಅದನ್ನು ಅದು ಎಂದಿಗೂ ಹೋಗಬಾರದಂತಹ ಸ್ಥಳಕ್ಕೆ ಸದ್ದಿಲ್ಲದೆ ಕೊಂಡೊಯ್ಯುತ್ತದೆ.

ಆಗಸ್ಟ್ 2026 ರ ಹೊತ್ತಿಗೆ, ಆ ಕೊನೆಯ ವೆಕ್ಟರ್ ಲೆಕ್ಕಾಚಾರವನ್ನು ಬದಲಾಯಿಸಿದೆ. ಪ್ರತಿಯೊಬ್ಬ ಡೆವಲಪರ್ ಈಗ AI ಕೋಡಿಂಗ್ ಅಸಿಸ್ಟೆಂಟ್ ಅನ್ನು ರನ್ ಮಾಡುತ್ತಾರೆ, ಅದು ಅವರಿಗಾಗಿ ಫೈಲ್‌ಗಳನ್ನು ಓದುತ್ತದೆ ಮತ್ತು ಕಮಾಂಡ್‌ಗಳನ್ನು ರನ್ ಮಾಡುತ್ತದೆ. ಅಂತಹ ಟೂಲ್ ಓದುವ ಪ್ರತಿಯೊಂದೂ, ಮತ್ತು ಕಮಾಂಡ್ ಮುದ್ರಿಸುವ ಪ್ರತಿಯೊಂದೂ, ಪ್ರತಿ ತಿರುವಿನಲ್ಲಿ ಮಾಡೆಲ್ ಪ್ರೊವೈಡರ್‌ಗೆ ರವಾನೆಯಾಗುವ ಸೆಷನ್ ಟ್ರಾನ್ಸ್‌ಕ್ರಿಪ್ಟ್‌ನ ಭಾಗವಾಗುತ್ತದೆ. ಒಂದು ವೇಳೆ ಪ್ಲೇನ್‌ಟೆಕ್ಸ್ಟ್ ಕೀಯನ್ನು ಪ್ರದರ್ಶಿಸಿದರೆ, ಸ್ಕ್ರೀನ್‌ಗೆ ಡಿಕ್ರಿಪ್ಟ್ ಮಾಡಿದರೆ ಅಥವಾ ಸೆಷನ್‌ನಲ್ಲಿ ಎಕೋ ಮಾಡಿದರೆ, ಅದು ಈಗ ನಿಮ್ಮ ನಿಯಂತ್ರಣದ ಹೊರಗೆ ಆ ಟ್ರಾನ್ಸ್‌ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಕುಳಿತಿರುತ್ತದೆ. ಇದು ಕಾಲ್ಪನಿಕವಲ್ಲ: ಸಂಪೂರ್ಣ ಎಚ್ಚರಿಕೆಯ ಇಂಜಿನಿಯರ್ ಯಾವುದೇ ಸ್ಪಷ್ಟವಾದ ತಪ್ಪು ಮಾಡದೆಯೇ ಕೀಯನ್ನು ಸೋರಿಕೆ ಮಾಡುವುದು ಹೀಗೆಯೇ.

ಈ ಪೋಸ್ಟ್ ಅದನ್ನು ಸರಿಪಡಿಸಲು ಒಂದು ಸಂಪೂರ್ಣ, ಜೆನೆರಿಕ್ ರನ್‌ಬುಕ್ ಆಗಿದೆ. ಉದಾಹರಣೆಗೆ ಇಲ್ಲಿ Cloudflare ಗ್ಲೋಬಲ್ API ಕೀಯನ್ನು ಬಳಸಲಾಗಿದೆ, ಆದರೆ ಈ ತಂತ್ರವು ಯಾವುದೇ ಉನ್ನತ-ಸವಲತ್ತಿನ ರುಜುವಾತಿಗೆ ಅನ್ವಯಿಸುತ್ತದೆ. ಮೊದಲ ಭಾಗವು ಬೇರೇನನ್ನೂ ಬಳಸದೆ gpg ಮತ್ತು bash ಯಾವುದೇ Linux ಅಥವಾ macOS ಯಂತ್ರದಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಎರಡನೇ ಭಾಗವು AI ಕೋಡಿಂಗ್ ಅಸಿಸ್ಟೆಂಟ್ ಅನ್ನು ಬಳಸುವವರಿಗೆ ಮತ್ತು ಅದರ ಮೇಲೆ ಕಠಿಣವಾದ, ಕಡ್ಡಾಯವಾದ ಗಾರ್ಡ್ ಅನ್ನು ಬಯಸುವವರಿಗೆ ಮಾತ್ರ.

ಖಾತೆ-ವ್ಯಾಪಕ ಕೀಗೆ ಏಕೆ ವಿಶೇಷ ಕಾಳಜಿಯ ಅಗತ್ಯವಿದೆ

Cloudflare ಗ್ಲೋಬಲ್ API ಕೀ ಖಾತೆ-ವ್ಯಾಪಕವಾಗಿದೆ ಮತ್ತು ಸ್ಕೋಪ್ ಮಾಡಲಾಗಿಲ್ಲ (unscoped). ಆ ಇಮೇಲ್‌ಗೆ ಲಿಂಕ್ ಆಗಿರುವ ಪ್ರತಿಯೊಂದು ಖಾತೆಯಲ್ಲಿರುವ ಪ್ರತಿ ಝೋನ್, ವರ್ಕರ್ ಮತ್ತು DNS ರೆಕಾರ್ಡ್ ಅನ್ನು ಇದು ಮುಟ್ಟಬಹುದು. ಅದು ಎರಡು ವಿಭಿನ್ನ ಅಪಾಯಗಳನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ:

• ರೆಸ್ಟ್‌ನಲ್ಲಿ. ಹೋಮ್-ಡೈರೆಕ್ಟರಿ ಫೈಲ್‌ನಲ್ಲಿರುವ ಪ್ಲೇನ್‌ಟೆಕ್ಸ್ಟ್ ಕೀಯನ್ನು ನಿಮ್ಮ ಫೈಲ್‌ಸಿಸ್ಟಮ್ ಅನ್ನು ಸ್ಪರ್ಶಿಸುವ ಯಾವುದೇ ಪ್ರಕ್ರಿಯೆ, ಸ್ಕ್ರಿಪ್ಟ್ ಅಥವಾ ಬ್ಯಾಕಪ್‌ನಿಂದ ಓದಬಹುದು. ಇದು ಒಂದು ಅಜಾಗರೂಕತೆಯ chmod, ಒಂದು ಮಿತಿಮೀರಿದ ಬ್ಯಾಕಪ್ ಜಾಬ್, ಒಂದು ಎರವಲು ಪಡೆದ ಲ್ಯಾಪ್‌ಟಾಪ್‌ನಿಂದ ಬಹಿರಂಗಗೊಳ್ಳುವ ಅಪಾಯದಲ್ಲಿದೆ.
• AI ಸೆಷನ್‌ನಲ್ಲಿ. ಕೋಡಿಂಗ್ ಅಸಿಸ್ಟೆಂಟ್ ಓದುವ ಯಾವುದೇ ವಿಷಯ, ಅಥವಾ ಕೀಯನ್ನು ಮುದ್ರಿಸುವ ಯಾವುದೇ ಕಮಾಂಡ್, ಪ್ರೊವೈಡರ್‌ಗೆ ಕಳುಹಿಸಲಾದ ಟ್ರಾನ್ಸ್‌ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಸೇರುತ್ತದೆ. cat ~/.cf, echo $CLOUDFLARE_API_KEY, ಅಥವಾ gpg --decrypt ಸ್ಕ್ರೀನ್‌ಗೆ ಡಂಪ್ ಮಾಡುವ ಪ್ರತಿಯೊಂದೂ ತಕ್ಷಣವೇ ಅದನ್ನು ಸೋರಿಕೆ ಮಾಡುತ್ತವೆ.

ಪರಿಹಾರವು ಮೂರು ಭಾಗಗಳನ್ನು ಹೊಂದಿದೆ: ಕೀಯನ್ನು ಇರಿಸಿ ರೆಸ್ಟ್‌ನಲ್ಲಿ ಎನ್‌ಕ್ರಿಪ್ಟ್ ಮಾಡಲಾಗಿದೆ, ಅದನ್ನು ಡಿಕ್ರಿಪ್ಟ್ ಮಾಡಿ ಅದನ್ನು ಎಂದಿಗೂ ಮುದ್ರಿಸದ ಅಲ್ಪಾವಧಿಯ ಉಪಪ್ರಕ್ರಿಯೆಯೊಳಗೆ ಮಾತ್ರ, ಮತ್ತು — ಲೂಪ್‌ನಲ್ಲಿ AI ಅಸಿಸ್ಟೆಂಟ್ ಇದ್ದರೆ — ಒಂದು ಸೇರಿಸಿ ಕೋಡ್‌ನಿಂದ ಜಾರಿಗೊಳಿಸಲಾದ ಹಾರ್ಡ್ ಬ್ಲಾಕ್, ಕೇವಲ ಎಚ್ಚರಿಕೆಯಿಂದಿರಲು ನೆನಪಿಸಿಕೊಳ್ಳುವುದರಿಂದಲ್ಲ.

ನೀವು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು ಒಂದು ಟಿಪ್ಪಣಿ: ನೀವು ಬಳಸುತ್ತಿರುವ ಟೂಲ್ ಗ್ಲೋಬಲ್ API ಕೀಯ ಬದಲಿಗೆ ಸ್ಕೋಪ್ಡ್ API ಟೋಕನ್ ಅನ್ನು ಬೆಂಬಲಿಸಿದರೆ, ಟೋಕನ್ ಬಳಸಿ. ಟೋಕನ್ ಅನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ರದ್ದುಗೊಳಿಸಬಹುದು ಮತ್ತು ಅದರ ನಿಗದಿತ ಸ್ಕೋಪ್‌ನ ಹೊರಗಿನ ಯಾವುದನ್ನೂ ತಲುಪಲು ಸಾಧ್ಯವಿಲ್ಲ, ಆದ್ದರಿಂದ ಸೋರಿಕೆಯ ಬ್ಲಾಸ್ಟ್ ರೇಡಿಯಸ್ ಗ್ಲೋಬಲ್ ಕೀಯ ಒಂದು ಭಾಗವಾಗಿರುತ್ತದೆ. ಕೆಳಗಿನ ಹಂತಗಳು ಟೋಕನ್‌ಗೆ ಸಮಾನವಾಗಿ ಅನ್ವಯಿಸುತ್ತವೆ; ನೀವು ಇಮೇಲ್ ಮತ್ತು ಕೀ ಜೋಡಿಯ ಬದಲಿಗೆ ಒಂದೇ ಟೋಕನ್ ಮೌಲ್ಯವನ್ನು ಸಂಗ್ರಹಿಸುತ್ತೀರಿ.

ಹಂತ 1: ರುಜುವಾತನ್ನು ಹಿಂಪಡೆಯಿರಿ ಮತ್ತು ಕಟ್ಟುನಿಟ್ಟಾದ ಅನುಮತಿಗಳೊಂದಿಗೆ ಅದನ್ನು ಸ್ಟೇಜ್ ಮಾಡಿ

ನಿಮ್ಮ ಪ್ರೊವೈಡರ್‌ನ ಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ನಿಂದ ಕೀಯನ್ನು ಪಡೆಯಿರಿ. Cloudflare ಗೆ, ಅದು My Profile, ನಂತರ API Tokens ಟ್ಯಾಬ್, ನಂತರ Global API Key ಪಕ್ಕದಲ್ಲಿ View.

ಪ್ರಾಜೆಕ್ಟ್ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿರುವ ಸ್ಟೇಜಿಂಗ್ ಫೈಲ್‌ಗೆ ಅದನ್ನು ಬರೆಯಿರಿ, ಮೊದಲ ಬೈಟ್‌ನಿಂದಲೇ ಅದನ್ನು ಲಾಕ್-ಡೌನ್ ಮಾಡಿ:

mkdir -p ~/vault
umask 077                 # new files are created 600, never world-readable
printf '%s\n' "[email protected] REPLACE_WITH_GLOBAL_API_KEY main-account" > ~/vault/.cf
chmod 600 ~/vault/.cf

ಮುಖ್ಯವಾದುದೆಂದರೆ umask 077 : ರಚನೆಯ ಸಮಯದಲ್ಲಿ ಪ್ಲೇನ್‌ಟೆಕ್ಸ್ಟ್ ಅನ್ನು ಇತರ ಬಳಕೆದಾರರು ಎಂದಿಗೂ ಓದಲಾಗುವುದಿಲ್ಲ ಎಂದು ಇದು ಖಾತರಿಪಡಿಸುತ್ತದೆ, ಇದನ್ನು ನಂತರದ chmod ರದ್ದುಗೊಳಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.

ಹಂತ 2: GPG ಸಿಮೆಟ್ರಿಕ್ AES-256 ನೊಂದಿಗೆ ಇದನ್ನು ಎನ್‌ಕ್ರಿಪ್ಟ್ ಮಾಡಿ

ಸಿಮೆಟ್ರಿಕ್, ಪಾಸ್‌ಫ್ರೇಸ್ ಆಧಾರಿತ ಎನ್‌ಕ್ರಿಪ್ಶನ್ ಇಲ್ಲಿ ಸರಿಯಾದ ಆಯ್ಕೆಯಾಗಿದೆ. ಒಬ್ಬ ವ್ಯಕ್ತಿ ಮಾತ್ರ ಈ ಫೈಲ್ ಅನ್ನು ಡಿಕ್ರಿಪ್ಟ್ ಮಾಡಬೇಕಾಗಿರುವುದರಿಂದ, ಪಬ್ಲಿಕ್/ಪ್ರೈವೇಟ್ ಕೀಪೇರ್ ಯಾವುದೇ ಪ್ರಯೋಜನವಿಲ್ಲದೆ ಸಂಕೀರ್ಣತೆಯನ್ನು ಸೇರಿಸುತ್ತದೆ.

gpg --symmetric --cipher-algo AES256 -o ~/vault/.cf.gpg ~/vault/.cf

ಪಾಸ್‌ಫ್ರೇಸ್ ಅನ್ನು ನಮೂದಿಸಲು ಮತ್ತು ದೃಢೀಕರಿಸಲು GPG ನಿಮ್ಮನ್ನು ಕೇಳುತ್ತದೆ. ಬಲವಾದ ಮತ್ತು ವಿಶಿಷ್ಟವಾದದ್ದನ್ನು ಆರಿಸಿ ಮತ್ತು ಅದನ್ನು ಪಾಸ್‌ವರ್ಡ್ ಮ್ಯಾನೇಜರ್‌ನಲ್ಲಿ ರೆಕಾರ್ಡ್ ಮಾಡಿ, ಏಕೆಂದರೆ ನೀವು ಅದನ್ನು ಮರೆತರೆ ಯಾವುದೇ ರಿಕವರಿ ಇರುವುದಿಲ್ಲ. ಈ ಹಂತದಿಂದ, ಆ ಪಾಸ್‌ಫ್ರೇಸ್ ಫೈಲ್‌ಸಿಸ್ಟಮ್ ಪ್ರವೇಶ ಮತ್ತು ಕೀಯ ನಡುವೆ ನಿಂತಿರುವ ಏಕೈಕ ವಿಷಯವಾಗಿದೆ.

ಹಂತ 3: ಯಾವುದನ್ನಾದರೂ ಅಳಿಸುವ ಮೊದಲು ಎನ್‌ಕ್ರಿಪ್ಟ್ ಮಾಡಿದ ಪ್ರತಿಯನ್ನು ಪರಿಶೀಲಿಸಿ

ಸಿಫರ್‌ಟೆಕ್ಸ್ಟ್ ಬೈಟ್‌-ಬೈಟ್‌ಗೆ ಮತ್ತೆ ಡಿಕ್ರಿಪ್ಟ್ ಆಗುತ್ತದೆ ಎಂದು ನೀವು ಸಾಬೀತುಪಡಿಸುವವರೆಗೆ ಪ್ಲೇನ್‌ಟೆಕ್ಸ್ಟ್ ಅನ್ನು ಎಂದಿಗೂ ಅಳಿಸಬೇಡಿ:

diff <(gpg --quiet --batch --decrypt ~/vault/.cf.gpg) ~/vault/.cf

ಯಾವುದೇ ಔಟ್‌ಪುಟ್ ಬರದಿದ್ದರೆ ಅವೆರಡೂ ಒಂದೇ ಆಗಿವೆ ಮತ್ತು ಮುಂದುವರಿಯಲು ನೀವು ಸುರಕ್ಷಿತರಾಗಿದ್ದೀರಿ ಎಂದರ್ಥ. ಯಾವುದೇ ಔಟ್‌ಪುಟ್ ಬಂದರೆ ಏನೋ ತಪ್ಪಾಗಿದೆ — ತಪ್ಪು ಪಾಸ್‌ಫ್ರೇಸ್, ತಪ್ಪು ಸಿಫರ್, ಭ್ರಷ್ಟಗೊಂಡ ಫೈಲ್ — ಮತ್ತು ನೀವು ಇನ್ನೂ ಪ್ಲೇನ್‌ಟೆಕ್ಸ್ಟ್ ಅನ್ನು ಅಳಿಸಬಾರದು.

ಹಂತ 4: ಪ್ಲೇನ್‌ಟೆಕ್ಸ್ಟ್ ಅನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ಅಳಿಸಿ

shred -u ~/vault/.cf
chmod 600 ~/vault/.cf.gpg
ls -la ~/vault/.cf*        # only .cf.gpg should remain

shred ಅನ್‌ಲಿಂಕ್ ಮಾಡುವ ಮೊದಲು ಬೈಟ್‌ಗಳನ್ನು ಓವರ್‌ರೈಟ್ ಮಾಡುತ್ತದೆ, ಇದು ಇದಕ್ಕಿಂತ ಬಲವಾಗಿರುತ್ತದೆ rm. ಅದರ ಮಿತಿಗಳ ಬಗ್ಗೆ ಪ್ರಾಮಾಣಿಕರಾಗಿರಿ: SSD ಗಳು, ಕಾಪಿ-ಆನ್-ರೈಟ್ ಫೈಲ್‌ಸಿಸ್ಟಮ್‌ಗಳು, ಅಥವಾ ಎಂದಾದರೂ ಸ್ನ್ಯಾಪ್‌ಶಾಟ್ ಮಾಡಲಾದ ಅಥವಾ ಬ್ಯಾಕಪ್ ಮಾಡಲಾದ ಯಾವುದೇ ಫೈಲ್‌ನಲ್ಲಿ, ಓವರ್‌ರೈಟ್ ಗ್ಯಾರಂಟಿ ದುರ್ಬಲಗೊಳ್ಳುತ್ತದೆ. ನಿಜವಾಗಿಯೂ ರಾಜಿ ಮಾಡಿಕೊಂಡ ರುಜುವಾತಿನ ವಿರುದ್ಧದ ಏಕೈಕ ನೈಜ ಖಾತರಿ ಎಂದರೆ ರೊಟೇಶನ್, ಒಂದು ಪ್ರತಿಯನ್ನು ಅಳಿಸುವುದಲ್ಲ.

ಹಂತ 5: ಪಾಸ್‌ಫ್ರೇಸ್ ಕ್ಯಾಶ್ ಅನ್ನು ಕಡಿಮೆ ಮಾಡಿ (ಐಚ್ಛಿಕ ಆದರೆ ಶಿಫಾರಸು ಮಾಡಲಾಗಿದೆ)

ಡೀಫಾಲ್ಟ್ ಆಗಿ gpg-agent ನೀವು ಅದನ್ನು ಟೈಪ್ ಮಾಡಿದ ನಂತರ ಹತ್ತು ನಿಮಿಷಗಳು ಅಥವಾ ಅದಕ್ಕಿಂತ ಹೆಚ್ಚಿನ ಕಾಲ ನಿಮ್ಮ ಪಾಸ್‌ಫ್ರೇಸ್ ಅನ್ನು ಕ್ಯಾಶ್ ಮಾಡುತ್ತದೆ. ಆ ವಿಂಡೋವನ್ನು ಕಿರಿದಾಗಿಸಲು:

mkdir -p ~/.gnupg && chmod 700 ~/.gnupg
cat >> ~/.gnupg/gpg-agent.conf <<'EOF'
default-cache-ttl 60
max-cache-ttl 120
EOF
chmod 600 ~/.gnupg/gpg-agent.conf
gpg-connect-agent reloadagent /bye

ಇದು ಕ್ಯಾಶಿಂಗ್ ಅನ್ನು 60 ರಿಂದ 120 ಸೆಕೆಂಡುಗಳಿಗೆ ಮಿತಿಗೊಳಿಸುತ್ತದೆ — ನೀವು ಡಿಕ್ರಿಪ್ಟ್ ಮಾಡಿದ ತಕ್ಷಣವೇ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ರನ್ ಮಾಡಲು ಸಾಕಷ್ಟು ಉದ್ದವಾಗಿದೆ, ಮತ್ತು ನೀವು ದೂರ ಹೋದರೆ ವಾಲ್ಟ್ ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಅನ್‌ಲಾಕ್ ಆಗಿ ಉಳಿಯದಷ್ಟು ಚಿಕ್ಕದಾಗಿದೆ.

ಹಂತ 6: ಕೀಯನ್ನು ಎಂದಿಗೂ ಮುದ್ರಿಸದ ಡಿಕ್ರಿಪ್ಟ್-ಮತ್ತು-ಎಕ್ಸಿಕ್ಯೂಟ್ ರ್ಯಾಪರ್ ರಚಿಸಿ

ಇದು ಕೀಯನ್ನು ಬಹಿರಂಗಪಡಿಸದೆ ದೈನಂದಿನ ವಾಲ್ಟ್ ಅನ್ನು ಬಳಸಲು ಸಾಧ್ಯವಾಗುವಂತೆ ಮಾಡುವ ಹಂತವಾಗಿದೆ. ಇದನ್ನು ಹೀಗೆ ಉಳಿಸಿ ~/vault/cf-run.sh:

#!/usr/bin/env bash
# cf-run.sh — decrypt .cf.gpg and exec a command with CLOUDFLARE_EMAIL /
# CLOUDFLARE_API_KEY set for that one child process only. The decrypted value
# is never printed, written to disk, or returned as this script's output.
#   Usage: ./cf-run.sh npx wrangler deploy
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
CREDS_FILE="$SCRIPT_DIR/.cf.gpg"

[ -f "$CREDS_FILE" ] || { echo "cf-run.sh: $CREDS_FILE not found" >&2; exit 1; }
[ "$#" -gt 0 ]       || { echo "usage: cf-run.sh <command> [args...]" >&2; exit 1; }

CREDS="$(gpg --quiet --batch --decrypt "$CREDS_FILE")" || { echo "cf-run.sh: decryption failed" >&2; exit 1; }
CF_EMAIL="$(awk '{print $1}' <<<"$CREDS")"
CF_KEY="$(awk '{print $2}' <<<"$CREDS")"
unset CREDS

exec env CLOUDFLARE_EMAIL="$CF_EMAIL" CLOUDFLARE_API_KEY="$CF_KEY" "$@"

chmod +x ~/vault/cf-run.sh

ಇದು ಹೇಗೆ ಸುರಕ್ಷಿತವಾಗಿ ಉಳಿಯುತ್ತದೆ, ಸಾಲಿನಿಂದ ಸಾಲಿಗೆ:

• ಡಿಕ್ರಿಪ್ಟ್ ಮಾಡಿದ ಪಠ್ಯವು ಕಮಾಂಡ್ ಸಬ್‌ಸ್ಟಿಟ್ಯೂಶನ್ ಮೂಲಕ ನೇರವಾಗಿ ಶೆಲ್ ವೇರಿಯಬಲ್‌ಗೆ ಹೋಗುತ್ತದೆ — ಎಂದಿಗೂ ಟರ್ಮಿನಲ್ ಅಥವಾ stdout ಗೆ ಅಲ್ಲ.
• awk ಆ ವೇರಿಯಬಲ್‌ನಿಂದ ಎರಡು ಕ್ಷೇತ್ರಗಳನ್ನು ಹೊರತೆಗೆಯುತ್ತದೆ; ಆದರೂ ಏನೂ ಮುದ್ರಿತವಾಗಿಲ್ಲ.
• unset CREDS ತುಣುಕುಗಳನ್ನು ಹೊರತೆಗೆದ ತಕ್ಷಣವೇ ಸಂಯೋಜಿತ ಸಾಲನ್ನು ಮೆಮೊರಿಯಿಂದ ಕೈಬಿಡುತ್ತದೆ.
• exec env VAR=... "$@" ರ್ಯಾಪರ್‌ನ ಪ್ರಕ್ರಿಯೆಯನ್ನು ನಿಮ್ಮ ಟಾರ್ಗೆಟ್ ಕಮಾಂಡ್‌ನೊಂದಿಗೆ ಬದಲಾಯಿಸುತ್ತದೆ, ಮೌಲ್ಯಗಳನ್ನು ಅದರ ಸ್ವಂತ ಎನ್ವಿರಾನ್‌ಮೆಂಟ್‌ನಲ್ಲಿ ಮಾತ್ರ ನೀಡುತ್ತದೆ. ಯಾವುದೇ ಹಂತದಲ್ಲಿಯೂ ಯಾವುದನ್ನೂ ಡಿಸ್ಕ್‌ಗೆ ಬರೆಯಲಾಗುವುದಿಲ್ಲ, ಲಾಗ್ ಮಾಡಲಾಗುವುದಿಲ್ಲ, ಅಥವಾ ಎಕೋ ಮಾಡಲಾಗುವುದಿಲ್ಲ.

ಹಂತ 7: ಎಲ್ಲದಕ್ಕೂ ರ್ಯಾಪರ್ ಬಳಸಿ

ಎಂದಿಗೂ ಮಾಡಬೇಡಿ CLOUDFLARE_API_KEY=$(cat ...) wrangler deploy ಮತ್ತೆ. ರ್ಯಾಪರ್ ಮೂಲಕ ಪ್ರತಿ ಕಮಾಂಡ್ ಅನ್ನು ರೂಟ್ ಮಾಡಿ, ಮತ್ತು ಟಾರ್ಗೆಟ್ ಟೂಲ್ ತನ್ನದೇ ಆದ ಎನ್ವಿರಾನ್‌ಮೆಂಟ್‌ನಿಂದ ವೇರಿಯಬಲ್‌ಗಳನ್ನು ಓದಲು ಬಿಡಿ:

~/vault/cf-run.sh npx wrangler deploy
~/vault/cf-run.sh curl -s "https://api.cloudflare.com/client/v4/user" \
  -H "X-Auth-Email: $CLOUDFLARE_EMAIL" -H "X-Auth-Key: $CLOUDFLARE_API_KEY"

ಹಂತ 8 (AI-ಅಸಿಸ್ಟೆಂಟ್ ಬಳಕೆದಾರರಿಗೆ ಮಾತ್ರ): ಹಾರ್ಡ್ ಗಾರ್ಡ್ ಹುಕ್ ಅನ್ನು ಸೇರಿಸಿ

ಒಂದು ಕೋಡಿಂಗ್ ಅಸಿಸ್ಟೆಂಟ್ ನಿಮ್ಮ ಯಂತ್ರದಲ್ಲಿ ಕಮಾಂಡ್‌ಗಳನ್ನು ರನ್ ಮಾಡಿದರೆ, "ಕೀಯನ್ನು ಮುದ್ರಿಸದಿರಲು ನೆನಪಿಸಿಕೊಳ್ಳುವುದು" ಒಂದು ನಿಯಂತ್ರಣವಲ್ಲ. ಅನೇಕ ಅಸಿಸ್ಟೆಂಟ್‌ಗಳು ಒಂದು ಕಮಾಂಡ್ ರನ್ ಆಗುವ ಮೊದಲು ಅದನ್ನು ಪರಿಶೀಲಿಸುವ ಮತ್ತು ತಿರಸ್ಕರಿಸುವ ಹುಕ್ ಸಿಸ್ಟಮ್ ಅನ್ನು ಬಹಿರಂಗಪಡಿಸುತ್ತವೆ. ಕಲ್ಪನೆಯು ಪ್ರಿ-ಎಕ್ಸಿಕ್ಯೂಶನ್ ಗಾರ್ಡ್ ಆಗಿದ್ದು, ಅದು ಎರಡು ವಿಷಯಗಳನ್ನು ನಿರ್ಬಂಧಿಸುತ್ತದೆ: ವಾಲ್ಟ್‌ನ ಪ್ಲೇನ್‌ಟೆಕ್ಸ್ಟ್ ಫಾರ್ಮ್ ಅನ್ನು ನೇರವಾಗಿ ಓದುವುದು, ಮತ್ತು ವಾಲ್ಟ್ ಅನ್ನು ಕ್ಯಾಪ್ಚರ್ ಮಾಡಿದ ವೇರಿಯಬಲ್‌ಗೆ ಬದಲಾಗಿ stdout ಅಥವಾ ಪೈಪ್‌ಗೆ ಡಿಕ್ರಿಪ್ಟ್ ಮಾಡುವುದು.

ಗಾರ್ಡ್, ಸರಳವಾಗಿ ಹೇಳುವುದಾದರೆ, ಬಾಕಿ ಇರುವ ಶೆಲ್ ಕಮಾಂಡ್ ಅನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು:

• ನಿರ್ಬಂಧಿಸುತ್ತದೆ ವಾಲ್ಟ್‌ನ ಪ್ಲೇನ್‌ಟೆಕ್ಸ್ಟ್ ಫೈಲ್‌ಹೆಸರಿಗೆ ಪಾಯಿಂಟ್ ಮಾಡಿದ ಓದುವ ಕಮಾಂಡ್ (cat, less, head, strings, ಮತ್ತು ಹೀಗೆ).
• ನಿರ್ಬಂಧಿಸುತ್ತದೆ ಒಂದು gpg --decrypt ವಾಲ್ಟ್‌ನ, ಅದರ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಕಮಾಂಡ್ ಸಬ್‌ಸ್ಟಿಟ್ಯೂಶನ್‌ನಲ್ಲಿ ಕ್ಯಾಪ್ಚರ್ ಮಾಡದ ಹೊರತು X="$(gpg -d ... )".
• ಅನುಮತಿಸುತ್ತದೆ ಕಾನೂನುಬದ್ಧ cf-run.sh ಆವಾಹನೆ ಸೇರಿದಂತೆ ಬೇರೆಲ್ಲವನ್ನೂ.

ಕನಿಷ್ಠ ಪೈಥಾನ್ ಗಾರ್ಡ್ ಅನುಮತಿಸಲು ಎಕ್ಸಿಟ್ ಕೋಡ್ 0 ಮತ್ತು ನಿರ್ಬಂಧಿಸಲು ಎಕ್ಸಿಟ್ ಕೋಡ್ 2 ಅನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ, ಕಾರಣವನ್ನು ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಎರರ್‌ಗೆ ಮುದ್ರಿಸುತ್ತದೆ ಇದರಿಂದ ಅಸಿಸ್ಟೆಂಟ್‌ಗೆ ಏಕೆಂದು ತಿಳಿಯುತ್ತದೆ:

#!/usr/bin/env python3
import json, re, sys

VAULT_HINTS = ("vault/.cf",)                 # add every vault path you protect
READ_CMDS   = r"(cat|less|more|head|tail|strings|xxd|od)"

def main() -> int:
    try:
        cmd = (json.load(sys.stdin).get("tool_input") or {}).get("command", "") or ""
    except Exception:
        return 0                             # never break tooling on a parse error
    # Block reading the plaintext vault directly (matches .cf but not .cf.gpg)
    if re.search(rf"(^|[;&|]\s*){READ_CMDS}\s+[^\n]*vault/\.cf(\s|$)", cmd):
        sys.stderr.write("BLOCKED: reading the plaintext vault would leak it. Use cf-run.sh.\n")
        return 2
    # Only care about decrypting a protected vault
    if re.search(r"gpg\b.{0,60}?(-d\b|--decrypt\b)", cmd) and any(h in cmd for h in VAULT_HINTS):
        if re.search(r"\$\(\s*gpg\b", cmd) or re.search(r"`\s*gpg\b", cmd):
            return 0                         # captured into a variable — safe
        sys.stderr.write("BLOCKED: decrypting to stdout leaks secrets. Capture into a variable.\n")
        return 2
    return 0

if __name__ == "__main__":
    sys.exit(main())

ನಿಮ್ಮ ಅಸಿಸ್ಟೆಂಟ್‌ನ ಪ್ರಿ-ಟೂಲ್ ಹುಕ್ ಕಾನ್ಫಿಗರೇಶನ್‌ಗೆ ಅದನ್ನು ವೈರ್ ಮಾಡಿ, ನಂತರ ಅದನ್ನು ಡಿಕಾಯ್ ಫೈಲ್ ವಿರುದ್ಧ ಪರೀಕ್ಷಿಸಿ — ಎಂದಿಗೂ ನಿಜವಾದ ವಾಲ್ಟ್‌ನೊಂದಿಗೆ ಅಲ್ಲ, ಏಕೆಂದರೆ ಪರೀಕ್ಷೆಯ ಸಮಯದಲ್ಲಿ ನಿಯಮದಲ್ಲಿರುವ ಬಗ್ ನಿಜವಾದ ರಹಸ್ಯವನ್ನು ಮುದ್ರಿಸಬಹುದು. ಹಾನಿಯಿಲ್ಲದ vault/.cf ಅನ್ನು ಥ್ರೋಅವೇ ಡೈರೆಕ್ಟರಿಯ ಅಡಿಯಲ್ಲಿ ರಚಿಸಿ, ಅಸಿಸ್ಟೆಂಟ್ ಅದನ್ನು ಓದಲು ನಿರಾಕರಿಸುತ್ತದೆ ಎಂದು ದೃಢೀಕರಿಸಿ, ಮತ್ತು ಪ್ರತ್ಯೇಕವಾಗಿ ಕಾನೂನುಬದ್ಧ cf-run.sh ಕಮಾಂಡ್ ಇನ್ನೂ ಪಾಸ್ ಆಗುತ್ತದೆ ಎಂದು ದೃಢೀಕರಿಸಿ.

ತೀರ್ಮಾನ

ರುಜುವಾತನ್ನು ರೆಸ್ಟ್‌ನಲ್ಲಿ ಎನ್‌ಕ್ರಿಪ್ಟ್ ಮಾಡುವುದು ತನ್ನಷ್ಟಕ್ಕೆ ತಾನೇ ಸಾಕಾಗುವುದಿಲ್ಲ. ಮೌಲ್ಯವು ಎಂದಿಗೂ ಮೇಲ್ಮೈಗೆ ಬರದ ರೀತಿಯಲ್ಲಿ ಡಿಕ್ರಿಪ್ಟ್ ಮಾಡಿದರೆ ಮಾತ್ರ ಅದು ಸುರಕ್ಷಿತವಾಗಿ ಉಳಿಯುತ್ತದೆ, ಮತ್ತು — AI ಅಸಿಸ್ಟೆಂಟ್ ತೊಡಗಿಸಿಕೊಂಡಿದ್ದರೆ — ಅಸುರಕ್ಷಿತ ಪ್ರವೇಶವನ್ನು ಶಿಸ್ತಿಗಿಂತ ಕೋಡ್ ಮೂಲಕ ನಿರ್ಬಂಧಿಸಿದರೆ. GPG ಸಿಮೆಟ್ರಿಕ್ ಎನ್‌ಕ್ರಿಪ್ಶನ್, ಡಿಕ್ರಿಪ್ಟ್-ಮತ್ತು-ಎಕ್ಸಿಕ್ಯೂಟ್ ರ್ಯಾಪರ್, ಮತ್ತು ಪ್ರಿ-ಎಕ್ಸಿಕ್ಯೂಶನ್ ಗಾರ್ಡ್ ಹುಕ್ ಒಟ್ಟಿಗೆ ಸೇರಿ ನಿಮಗೆ ನಿಜವಾಗಿಯೂ ಬಳಸಬಹುದಾದ ಮತ್ತು ನಿಜವಾಗಿಯೂ ಸೋರಿಕೆ ಮಾಡಲು ಕಷ್ಟವಾದ ವಾಲ್ಟ್ ಅನ್ನು ನೀಡುತ್ತವೆ. ಇದನ್ನು ಹೊಂದಿಸಲು ಹದಿನೈದು ನಿಮಿಷ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಇಡೀ ಕ್ಲಾಸ್‌ನ ಸದ್ದಿಲ್ಲದ, ಮುಜುಗರದ ಬಹಿರಂಗಗೊಳ್ಳುವಿಕೆಗಳನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ.

ಅರ್ಹತೆಗಳು

• ಪೋರ್ಟಬಲ್ ಮತ್ತು ಡಿಪೆಂಡೆನ್ಸಿ-ಮುಕ್ತ: ಕೋರ್ ಸೆಟಪ್‌ಗೆ ಕೇವಲ gpg ಮತ್ತು bashಅಗತ್ಯವಿದೆ, ಇದು ಬಹುತೇಕ ಪ್ರತಿ Unix ಯಂತ್ರದಲ್ಲಿರುತ್ತದೆ.
• ಸಾಮಾನ್ಯ ಬಳಕೆಯ ಸಮಯದಲ್ಲಿ ರಹಸ್ಯವನ್ನು ಎಂದಿಗೂ ಮುದ್ರಿಸಲಾಗುವುದಿಲ್ಲ, ಡಿಸ್ಕ್‌ಗೆ ಬರೆಯಲಾಗುವುದಿಲ್ಲ ಅಥವಾ ಲಾಗ್ ಮಾಡಲಾಗುವುದಿಲ್ಲ.
• ಸಿಮೆಟ್ರಿಕ್ ಎನ್‌ಕ್ರಿಪ್ಶನ್ ಒಬ್ಬ ಆಪರೇಟರ್‌ಗೆ ಮಾಡೆಲ್ ಅನ್ನು ಸರಳವಾಗಿರಿಸುತ್ತದೆ.
• ಐಚ್ಛಿಕ ಗಾರ್ಡ್ ಹುಕ್ "ಎಚ್ಚರಿಕೆಯಿಂದಿರಿ" ಎಂಬುದನ್ನು ಜಾರಿಗೊಳಿಸಿದ, ಕೋಡ್-ಮಟ್ಟದ ನಿಯಂತ್ರಣವನ್ನಾಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ.
• ಇದೇ ಮಾದರಿಯು ಕೇವಲ Cloudflare ಮಾತ್ರವಲ್ಲ, ಯಾವುದೇ ಉನ್ನತ-ಸವಲತ್ತಿನ ರುಜುವಾತಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ.

ಅವಗುಣಗಳು

• ಮರೆತುಹೋದ ಪಾಸ್‌ಫ್ರೇಸ್ ಎಂದರೆ ಶಾಶ್ವತ ನಷ್ಟ; ರಿಕವರಿ ಮಾರ್ಗವಿಲ್ಲ.
• shred SSD ಗಳು, ಕಾಪಿ-ಆನ್-ರೈಟ್ ಫೈಲ್‌ಸಿಸ್ಟಮ್‌ಗಳು ಅಥವಾ ಹಿಂದೆ ಬ್ಯಾಕಪ್ ಮಾಡಿದ ಫೈಲ್‌ಗಳಲ್ಲಿ ಅಳಿಸುವಿಕೆಯನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಖಾತರಿಪಡಿಸಲಾಗುವುದಿಲ್ಲ.
• ಎನ್‌ಕ್ರಿಪ್ಶನ್ ಕೀಯನ್ನು ಭವಿಷ್ಯದಲ್ಲಿ ರಕ್ಷಿಸುತ್ತದೆ ಆದರೆ ಹಿಂದಿನ ಬಹಿರಂಗಗೊಳ್ಳುವಿಕೆಯನ್ನು ರದ್ದುಗೊಳಿಸಲು ಏನೂ ಮಾಡುವುದಿಲ್ಲ.
• ಗಾರ್ಡ್ ಹುಕ್ ಅಸಿಸ್ಟೆಂಟ್-ನಿರ್ದಿಷ್ಟವಾಗಿದೆ ಮತ್ತು ನಿಮ್ಮ ನೈಜ ವಾಲ್ಟ್ ಪಾತ್‌ಗಳೊಂದಿಗೆ ಸಿಂಕ್ ಆಗಿರಬೇಕು.

ಎಚ್ಚರಿಕೆ

ಈ ಲೇಖನದಲ್ಲಿನ ಪ್ರತಿಯೊಂದು ಮೌಲ್ಯ — [email protected], REPLACE_WITH_GLOBAL_API_KEY, main-account, ಮತ್ತು ~/vault ಪಾತ್ — ಪ್ಲೇಸ್‌ಹೋಲ್ಡರ್ ಆಗಿದೆ. ನಿಮ್ಮದೇ ಆದದನ್ನು ಬದಲಿಸಿ ಮತ್ತು ಪ್ಲೇನ್‌ಟೆಕ್ಸ್ಟ್ ರುಜುವಾತನ್ನು ವರ್ಶನ್ ಕಂಟ್ರೋಲ್‌ಗೆ ಎಂದಿಗೂ ಕಮಿಟ್ ಮಾಡಬೇಡಿ. ನಿಜವಾದ ಕೀಯನ್ನು ನಂಬುವ ಮೊದಲು ಡಿಕಾಯ್ ಫೈಲ್‌ಗಳ ವಿರುದ್ಧ ರ್ಯಾಪರ್ ಮತ್ತು ಗಾರ್ಡ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಿ, ಮತ್ತು ಯಾವುದೇ ರುಜುವಾತು ಬಹಿರಂಗಗೊಂಡಿದೆ ಎಂದು ನೀವು ಅನುಮಾನಿಸಿದ ಕ್ಷಣದಲ್ಲಿ ಅದನ್ನು ರೊಟೇಟ್ ಮಾಡಿ. ನಿಮ್ಮ ಸ್ವಂತ ಅಪಾಯದಲ್ಲಿ ಮುಂದುವರಿಯಿರಿ; ನಿಮ್ಮ ಸ್ವಂತ ರುಜುವಾತುಗಳು ಮತ್ತು ಮೂಲಸೌಕರ್ಯಗಳಿಗೆ ನೀವೇ ಜವಾಬ್ದಾರರು.

ಪದೇ ಪದೇ ಕೇಳಲಾಗುವ ಪ್ರಶ್ನೆಗಳು

ಪಬ್ಲಿಕ್/ಪ್ರೈವೇಟ್ ಕೀಪೇರ್ ಬದಲಿಗೆ GPG ಸಿಮೆಟ್ರಿಕ್ ಎನ್‌ಕ್ರಿಪ್ಶನ್ ಅನ್ನು ಏಕೆ ಬಳಸಬೇಕು? ಎನ್‌ಕ್ರಿಪ್ಟ್ ಮಾಡುವ ಮತ್ತು ಏಕೈಕ ಡಿಕ್ರಿಪ್ಟ್ ಮಾಡುವ ಒಬ್ಬ ಆಪರೇಟರ್‌ಗೆ, ಪಾಸ್‌ಫ್ರೇಸ್-ಆಧಾರಿತ ಸಿಮೆಟ್ರಿಕ್ ಸಿಫರ್ ಸರಳವಾಗಿದೆ ಮತ್ತು ಅಷ್ಟೇ ಪ್ರಬಲವಾಗಿದೆ. ಕೀಪೇರ್ ಈ ಸಂದರ್ಭದಲ್ಲಿ ಯಾವುದೇ ಭದ್ರತಾ ಲಾಭವಿಲ್ಲದೆ ಕೀ-ಮ್ಯಾನೇಜ್ಮೆಂಟ್ ಓವರ್‌ಹೆಡ್ ಅನ್ನು ಸೇರಿಸುತ್ತದೆ.

ಎನ್‌ಕ್ರಿಪ್ಟ್ ಮಾಡಿದ .cf.gpg ಫೈಲ್ ಅನ್ನು git ನಲ್ಲಿ ಶೇಖರಿಸುವುದು ಸುರಕ್ಷಿತವೇ? ಸಿಫರ್‌ಟೆಕ್ಸ್ಟ್ ಕಮಿಟ್ ಮಾಡಲು ತಾಂತ್ರಿಕವಾಗಿ ಸುರಕ್ಷಿತವಾಗಿದೆ, ಆದರೆ ಅದು ನಿಮ್ಮ ಯಂತ್ರವನ್ನು ಬಿಟ್ಟು ಹೋಗುವುದರಿಂದ ಯಾವುದೇ ಲಾಭವಿಲ್ಲ. ಅದನ್ನು ಸ್ಥಳೀಯವಾಗಿರಿಸಿ, ಮತ್ತು ಎಂದಿಗೂ, ಎಂದಿಗೂ ಪ್ಲೇನ್‌ಟೆಕ್ಸ್ಟ್ ಅನ್ನು ಕಮಿಟ್ ಮಾಡಬೇಡಿ.

ನಾನು ಗ್ಲೋಬಲ್ API ಕೀಯ ಬದಲಿಗೆ Cloudflare API ಟೋಕನ್ ಬಳಸಬೇಕೇ? ಹೌದು, ಟೂಲ್ ಅದನ್ನು ಬೆಂಬಲಿಸಿದಾಗಲೆಲ್ಲಾ. ಸ್ಕೋಪ್ಡ್ ಟೋಕನ್ ಅನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ರದ್ದುಗೊಳಿಸಬಹುದು ಮತ್ತು ಅದರ ಸ್ಕೋಪ್‌ನ ಹೊರಗಿನ ಸಂಪನ್ಮೂಲಗಳನ್ನು ತಲುಪಲು ಸಾಧ್ಯವಿಲ್ಲ, ಆದ್ದರಿಂದ ಸೋರಿಕೆಯು ಸೋರಿಕೆಯಾದ ಗ್ಲೋಬಲ್ API ಕೀಗಿಂತ ಕಡಿಮೆ ಹಾನಿಕಾರಕವಾಗಿದೆ.

ಡಿಕ್ರಿಪ್ಟ್-ಮತ್ತು-ಎಕ್ಸಿಕ್ಯೂಟ್ ರ್ಯಾಪರ್ ವಾಸ್ತವವಾಗಿ ಯಾವುದರ ವಿರುದ್ಧ ರಕ್ಷಿಸುತ್ತದೆ? ಡಿಕ್ರಿಪ್ಟ್ ಮಾಡಿದ ರಹಸ್ಯವು ಒಂದು ಚೈಲ್ಡ್ ಪ್ರೊಸೆಸ್‌ನ ಪರಿಸರದಲ್ಲಿ ಮಾತ್ರ ಇರುವುದನ್ನು ಇದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಇದು ಟರ್ಮಿನಲ್‌ಗೆ ಎಂದಿಗೂ ಮುದ್ರಿತವಾಗುವುದಿಲ್ಲ, ಶೆಲ್ ಇತಿಹಾಸದಲ್ಲಿ ಸೆರೆಹಿಡಿಯಲ್ಪಡುವುದಿಲ್ಲ, ಅಥವಾ ಡಿಸ್ಕ್‌ಗೆ ಬರೆಯಲ್ಪಡುವುದಿಲ್ಲ, ಇವು ಸಾಮಾನ್ಯ ಆಕಸ್ಮಿಕ-ಸೋರಿಕೆಯ ಮಾರ್ಗಗಳಾಗಿವೆ.

ರಹಸ್ಯವು AI ಕೋಡಿಂಗ್ ಅಸಿಸ್ಟೆಂಟ್‌ಗೆ ಹೇಗೆ ಸೋರಿಕೆಯಾಗುತ್ತದೆ? ಅಸಿಸ್ಟೆಂಟ್ ಓದುವ ಅಥವಾ ಕಮಾಂಡ್ ಮುದ್ರಿಸುವ ಪ್ರತಿಯೊಂದೂ ಮಾಡೆಲ್ ಪ್ರೊವೈಡರ್‌ಗೆ ಕಳುಹಿಸಲಾದ ಸೆಷನ್ ಟ್ರಾನ್ಸ್‌ಕ್ರಿಪ್ಟ್‌ಗೆ ಸೇರಿಸಲ್ಪಡುತ್ತದೆ. ಪ್ಲೇನ್‌ಟೆಕ್ಸ್ಟ್ ಕೀಯ ಒಂದೇ cat , ಅಥವಾ stdout ಗೆ ಡಿಕ್ರಿಪ್ಟ್ ಮಾಡುವುದು, ಕೀಯನ್ನು ಆ ಟ್ರಾನ್ಸ್‌ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಶಾಶ್ವತವಾಗಿ ಇರಿಸುತ್ತದೆ.

ಕೀ ಈಗಾಗಲೇ ಒಮ್ಮೆ ಸೋರಿಕೆಯಾಗಿದ್ದರೆ ಅದನ್ನು ಎನ್‌ಕ್ರಿಪ್ಟ್ ಮಾಡುವುದು ಸಹಾಯ ಮಾಡುತ್ತದೆಯೇ? ಇಲ್ಲ. ಎನ್‌ಕ್ರಿಪ್ಶನ್ ಕೀಯನ್ನು ಭವಿಷ್ಯದ ಬಹಿರಂಗಗೊಳ್ಳುವಿಕೆಯಿಂದ ಮಾತ್ರ ರಕ್ಷಿಸುತ್ತದೆ. ಒಂದು ಕೀಯನ್ನು ಎಂದಾದರೂ ಮುದ್ರಿಸಿದ್ದರೆ, ಅಂಟಿಸಿದ್ದರೆ ಅಥವಾ ಟ್ರಾನ್ಸ್‌ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ನೋಡಿದ್ದರೆ, ನೀವು ಅದನ್ನು ರೊಟೇಟ್ ಮಾಡಬೇಕು; ಹಳೆಯ ಮೌಲ್ಯವನ್ನು ಎನ್‌ಕ್ರಿಪ್ಟ್ ಮಾಡುವುದು ಬಹಿರಂಗಗೊಂಡ ಮೌಲ್ಯದ ಬಗ್ಗೆ ಏನನ್ನೂ ಬದಲಾಯಿಸುವುದಿಲ್ಲ.

ಉನ್ನತ-ಸವಲತ್ತಿನ ಕೀಯನ್ನು ನಾನು ಎಷ್ಟು ಬಾರಿ ರೊಟೇಟ್ ಮಾಡಬೇಕು? ನಿಮ್ಮ ಅಪಾಯ ಸಹಿಷ್ಣುತೆಗೆ ಸರಿಹೊಂದುವ ವೇಳಾಪಟ್ಟಿಯಲ್ಲಿ ರೊಟೇಟ್ ಮಾಡಿ, ಮತ್ತು ಯಾವುದೇ ಶಂಕಿತ ಬಹಿರಂಗಗೊಳ್ಳುವಿಕೆಯ ಮೇಲೆ ತಕ್ಷಣವೇ ರೊಟೇಟ್ ಮಾಡಿ. ಖಾತೆ-ವ್ಯಾಪಕ ಕೀಗಾಗಿ, ಆಗಾಗ್ಗೆ ರೊಟೇಟ್ ಮಾಡುವ ಕಡೆಗೆ ಒಲವು ತೋರಿ, ಏಕೆಂದರೆ ಅದರ ಬ್ಲಾಸ್ಟ್ ರೇಡಿಯಸ್ ಇಡೀ ಖಾತೆಯಾಗಿರುತ್ತದೆ.

ನಾನು ಇದನ್ನು AWS, ಡೇಟಾಬೇಸ್ ಅಥವಾ ಇತರ ರುಜುವಾತುಗಳಿಗೆ ಅಳವಡಿಸಿಕೊಳ್ಳಬಹುದೇ? ಹೌದು. ಅದೇ ಮೂರು ವಿಚಾರಗಳು — ರೆಸ್ಟ್‌ನಲ್ಲಿ ಎನ್‌ಕ್ರಿಪ್ಟ್ ಮಾಡಿ, ಥ್ರೋಅವೇ ಉಪಪ್ರಕ್ರಿಯೆಗೆ ಮಾತ್ರ ಡಿಕ್ರಿಪ್ಟ್ ಮಾಡಿ, ಮತ್ತು ಅಸುರಕ್ಷಿತ ಓದುವಿಕೆಯನ್ನು ನಿರ್ಬಂಧಿಸಿ — ಯಾವುದೇ ರಹಸ್ಯಕ್ಕೆ ಅನ್ವಯಿಸುತ್ತವೆ. ಹೊಂದಿಸಲು ರ್ಯಾಪರ್‌ನಲ್ಲಿರುವ ಫೀಲ್ಡ್ ಪಾರ್ಸಿಂಗ್ ಮತ್ತು ಎನ್ವಿರಾನ್ಮೆಂಟ್ ವೇರಿಯಬಲ್ ಹೆಸರುಗಳನ್ನು ಸರಿಹೊಂದಿಸಿ.

ಟ್ಯಾಗ್‌ಗಳು

#Security #GPG #Encryption #SecretsManagement #Cloudflare #APIKeys #DevOps #DevSecOps #AICoding #Linux