ବିଶ୍ରାମ ସମୟରେ ଏକ ଉଚ୍ଚ-ବିଶେଷାଧିକାର ପ୍ରାପ୍ତ API Key କୁ ଏନକ୍ରିପ୍ଟ କରନ୍ତୁ: ଏକ GPG Vault ଯାହା AI ଟ୍ରାନ୍ସକ୍ରିପ୍ଟରୁ ଗୁପ୍ତ ତଥ୍ୟକୁ ଦୂରରେ ରଖେ

ଅଧିକାଂଶ କ୍ରେଡେନ୍ସିଆଲ୍ ଲିକ୍ ନାଟକୀୟ ନୁହେଁ। କୌଣସି ହ୍ୟାକର୍ ନାହିଁ, କୌଣସି ଉଲ୍ଲଂଘନ ରିପୋର୍ଟ ନାହିଁ। କେହି ଜଣେ ସାଧାରଣତଃ ସେମାନଙ୍କର ହୋମ୍ ଡିରେକ୍ଟୋରୀରେ ଏକ ପ୍ଲେନ୍‌ଟେକ୍ସଟ୍ ଫାଇଲ୍‌ରେ ଏକ ଆକାଉଣ୍ଟ-ସ୍ତରୀୟ API key ରଖନ୍ତି, ଏବଂ ଦିନେ ଏକ ବ୍ୟାକଅପ୍, ଏକ ସ୍କ୍ରିନ୍-ସେୟାର୍, ଏକ ପେଷ୍ଟ କରାଯାଇଥିବା କମାଣ୍ଡ, କିମ୍ବା ଏକ AI କୋଡିଂ ସେସନ୍ ଧୀରେ ଧୀରେ ଏହାକୁ ଏପରି କେଉଁଠାକୁ ନେଇଯାଏ ଯେଉଁଠାକୁ ଏହା କେବେ ଯିବା ଉଚିତ୍ ନୁହେଁ।

ଅଗଷ୍ଟ 2026 ସୁଦ୍ଧା, ସେହି ଶେଷ ଭେକ୍ଟରଟି ହେଉଛି ଯାହା ଗଣିତକୁ ପରିବର୍ତ୍ତନ କରିଛି। ପ୍ରାୟ ପ୍ରତ୍ୟେକ ଡେଭଲପର୍ ବର୍ତ୍ତମାନ ଏକ AI କୋଡିଂ ଆସିଷ୍ଟାଣ୍ଟ୍ ଚଲାଉଛନ୍ତି ଯାହା ସେମାନଙ୍କ ତରଫରୁ ଫାଇଲ୍ ପଢ଼େ ଏବଂ କମାଣ୍ଡ୍ ଚଲାଏ। ଏହିପରି ଏକ ଟୁଲ୍ ଯାହା ପଢ଼େ, ଏବଂ ଏକ କମାଣ୍ଡ୍ ଯାହା ପ୍ରିଣ୍ଟ କରେ, ସବୁକିଛି ଏକ ସେସନ୍ ଟ୍ରାନ୍ସକ୍ରିପ୍ଟର ଅଂଶ ହୋଇଯାଏ ଯାହା ପ୍ରତିଥର ମଡେଲ୍ ପ୍ରଦାନକାରୀଙ୍କୁ ପଠାଯାଏ। ଯଦି ଏକ ପ୍ଲେନ୍‌ଟେକ୍ସଟ୍ key କେବେ ପ୍ରଦର୍ଶିତ ହୁଏ, ସ୍କ୍ରିନ୍‌ରେ ଡିକ୍ରିପ୍ଟ ହୁଏ, କିମ୍ବା ଏକ ସେସନ୍ ସମୟରେ ଇକୋ ହୁଏ, ଏହା ବର୍ତ୍ତମାନ ଆପଣଙ୍କ ନିୟନ୍ତ୍ରଣ ବାହାରେ, ସେହି ଟ୍ରାନ୍ସକ୍ରିପ୍ଟରେ ବସିଛି। ଏହା କାଳ୍ପନିକ ନୁହେଁ: ଜଣେ ସମ୍ପୂର୍ଣ୍ଣ ସତର୍କ ଇଞ୍ଜିନିୟର କିପରି ସ୍ପଷ୍ଟ ଭାବରେ କିଛି ଭୁଲ୍ ନକରି ଏକ key ଲିକ୍ କରିପାରନ୍ତି ଏହା ଠିକ୍ ସେହିପରି ଅଟେ।

ଏହି ପୋଷ୍ଟଟି ସେଥିରେ ସୁଧାର ଆଣିବା ପାଇଁ ଏକ ସମ୍ପୂର୍ଣ୍ଣ, ସାଧାରଣ ରନ୍‌ବୁକ୍ ଅଟେ। କାମ କରାଯାଇଥିବା ଉଦାହରଣଟି ଏକ Cloudflare Global API Key ଅଟେ, କିନ୍ତୁ ଏହି କୌଶଳଟି ଯେକୌଣସି ଉଚ୍ଚ-ବିଶେଷାଧିକାର ପ୍ରାପ୍ତ କ୍ରେଡେନ୍ସିଆଲ୍ ପାଇଁ ପ୍ରଯୁଜ୍ୟ ଅଟେ। ଭାଗ ଏକ କେବଳ ଏହା ବ୍ୟତୀତ ଅନ୍ୟ କିଛି ବ୍ୟବହାର କରେ ନାହିଁ gpg ଏବଂ bash ଏବଂ ଯେକୌଣସି Linux କିମ୍ବା macOS ମେସିନ୍‌ରେ କାମ କରେ। ଭାଗ ଦୁଇ କେବଳ ସେହି ଲୋକମାନଙ୍କ ପାଇଁ ଯେଉଁମାନେ ଏକ AI କୋଡିଂ ଆସିଷ୍ଟାଣ୍ଟ୍ ବ୍ୟବହାର କରନ୍ତି ଏବଂ ଏହା ଉପରେ ଏକ କଠିନ, ବାଧ୍ୟତାମୂଳକ ଗାର୍ଡ ଚାହାଁନ୍ତି।

ଏକ ଆକାଉଣ୍ଟ-ସ୍ତରୀୟ key କାହିଁକି ସ୍ୱତନ୍ତ୍ର ବ୍ୟବହାରର ଯୋଗ୍ୟ ଅଟେ

ଏକ Cloudflare Global API Key ଆକାଉଣ୍ଟ-ସ୍ତରୀୟ ଏବଂ ଅନ୍‌ସ୍କୋପ୍ଡ୍ ଅଟେ। ଏହା ସେହି ଇମେଲ୍ ସହିତ ଯୋଡି ହୋଇଥିବା ପ୍ରତ୍ୟେକ ଆକାଉଣ୍ଟରେ ଥିବା ପ୍ରତ୍ୟେକ ଜୋନ୍, ୱର୍କର ଏବଂ DNS ରେକର୍ଡକୁ ଛୁଇଁପାରେ। ତାହା ଦୁଇଟି ଭିନ୍ନ ବିପଦ ସୃଷ୍ଟି କରେ:

• ବିଶ୍ରାମ ସମୟରେ। ଏକ ହୋମ୍-ଡିରେକ୍ଟୋରୀ ଫାଇଲ୍‌ରେ ଥିବା ଏକ ପ୍ଲେନ୍‌ଟେକ୍ସଟ୍ key ଯେକୌଣସି ପ୍ରୋସେସ୍, ସ୍କ୍ରିପ୍ଟ କିମ୍ବା ବ୍ୟାକଅପ୍ ଦ୍ୱାରା ପଢ଼ାଯାଇପାରିବ ଯାହା ଆପଣଙ୍କର ଫାଇଲ୍‌ସିଷ୍ଟମ୍‌କୁ ଛୁଏଁ। ଏହା ଗୋଟିଏ ଅସାବଧାନ chmod, ଗୋଟିଏ ଅତ୍ୟଧିକ-ବ୍ୟାପକ ବ୍ୟାକଅପ୍ ଜବ୍, ଏକ୍ସପୋଜର୍ ଠାରୁ ଗୋଟିଏ ଧାର କରାଯାଇଥିବା ଲ୍ୟାପଟପ୍ ଦୂରରେ ଅଛି।
• ଏକ AI ସେସନ୍‌ରେ। ଯେକୌଣସି ଜିନିଷ ଯାହା ଏକ କୋଡିଂ ଆସିଷ୍ଟାଣ୍ଟ୍ ପଢ଼େ, କିମ୍ବା ଯେକୌଣସି କମାଣ୍ଡ୍ ଯାହା key କୁ ପ୍ରିଣ୍ଟ କରେ, ପ୍ରଦାନକାରୀଙ୍କୁ ପଠାଯାଇଥିବା ଟ୍ରାନ୍ସକ୍ରିପ୍ଟରେ ସ୍ଥାନ ପାଏ। cat ~/.cf, echo $CLOUDFLARE_API_KEY, କିମ୍ବା ଏକ gpg --decrypt ଯାହା ସ୍କ୍ରିନ୍‌କୁ ଡମ୍ପ କରେ ସବୁକିଛି ତୁରନ୍ତ ଏହାକୁ ଲିକ୍ କରିଦିଏ।

ଏହି ସମାଧାନର ତିନୋଟି ଭାଗ ଅଛି: key କୁ ରଖନ୍ତୁ ବିଶ୍ରାମ ସମୟରେ ଏନକ୍ରିପ୍ଟ ହୋଇଥିବା, ଏହାକୁ ଡିକ୍ରିପ୍ଟ କରନ୍ତୁ କେବଳ ଏକ ସ୍ୱଳ୍ପକାଳୀନ ସବ୍‌ପ୍ରୋସେସ୍ ଭିତରେ ଯାହା ଏହାକୁ କେବେ ପ୍ରିଣ୍ଟ କରେ ନାହିଁ, ଏବଂ — ଯଦି ଏକ AI ଆସିଷ୍ଟାଣ୍ଟ୍ ଲୁପ୍‌ରେ ଥାଏ — ଯୋଡନ୍ତୁ ଏକ କୋଡ୍ ଦ୍ୱାରା ଲାଗୁ କରାଯାଇଥିବା କଠିନ ବ୍ଲକ୍, ସତର୍କ ରହିବାକୁ ମନେରଖିବା ଦ୍ୱାରା ନୁହେଁ।

ଆପଣ ଆରମ୍ଭ କରିବା ପୂର୍ବରୁ ଏକ ନୋଟ୍: ଯଦି ଆପଣ ବ୍ୟବହାର କରୁଥିବା ଟୁଲ୍ Global API Key ପରିବର୍ତ୍ତେ ଏକ ସ୍କୋପ୍ଡ୍ API token କୁ ସମର୍ଥନ କରେ, ତେବେ token ବ୍ୟବହାର କରନ୍ତୁ। ଏକ token କୁ ବ୍ୟକ୍ତିଗତ ଭାବରେ ପ୍ରତ୍ୟାହାର କରାଯାଇପାରିବ ଏବଂ ଏହା ତାର ନ୍ୟସ୍ତ ସ୍କୋପ୍ ବାହାରେ କୌଣସି ଜିନିଷରେ ପହଞ୍ଚିପାରିବ ନାହିଁ, ତେଣୁ ଏକ ଲିକ୍‌ର ବ୍ଲାଷ୍ଟ୍ ବ୍ୟାସାର୍ଦ୍ଧ Global Key ର ଏକ ଅଂଶ ଅଟେ। ନିମ୍ନଲିଖିତ ପଦକ୍ଷେପଗୁଡ଼ିକ ସମାନ ଭାବରେ ଏକ token ପାଇଁ ପ୍ରଯୁଜ୍ୟ ଅଟେ; ଆପଣ କେବଳ ଏକ ଇମେଲ୍ ପ୍ଲସ୍ key ପେୟାର୍ ପରିବର୍ତ୍ତେ ଏକ ଏକକ token ମୂଲ୍ୟ ଷ୍ଟୋର୍ କରନ୍ତି।

ପଦକ୍ଷେପ 1: କ୍ରେଡେନ୍ସିଆଲ୍ ପୁନରୁଦ୍ଧାର କରନ୍ତୁ ଏବଂ କଠୋର ଅନୁମତି ସହିତ ଏହାକୁ ଷ୍ଟେଜ୍ କରନ୍ତୁ

ଆପଣଙ୍କ ପ୍ରଦାନକାରୀଙ୍କ ଡ୍ୟାସ୍‌ବୋର୍ଡରୁ key ଆଣନ୍ତୁ। 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

The umask 077 ଗୁରୁତ୍ୱପୂର୍ଣ୍ଣ: ଏହା ଗ୍ୟାରେଣ୍ଟି ଦିଏ ଯେ ପ୍ଲେନ୍‌ଟେକ୍ସଟ୍ କେବେ ମଧ୍ୟ ସୃଷ୍ଟି ସମୟରେ ଅନ୍ୟ ଉପଯୋଗକର୍ତ୍ତାମାନଙ୍କ ଦ୍ୱାରା ସଂକ୍ଷେପରେ ପଢ଼ିବା ଯୋଗ୍ୟ ନୁହେଁ, ଯାହା ପରବର୍ତ୍ତୀ ସମୟରେ ଏକ chmod ଅନ୍‌ଡୁ କରିପାରିବ ନାହିଁ।

ପଦକ୍ଷେପ 2: ଏହାକୁ GPG ସିମେଟ୍ରିକ୍ AES-256 ସହିତ ଏନକ୍ରିପ୍ଟ କରନ୍ତୁ

ସିମେଟ୍ରିକ୍, ପାସ୍‌ଫ୍ରେଜ୍-ଆଧାରିତ ଏନକ୍ରିପ୍ସନ୍ ଏଠାରେ ସଠିକ୍ ପସନ୍ଦ ଅଟେ। ଏହି ଫାଇଲ୍‌କୁ ଡିକ୍ରିପ୍ଟ କରିବାକୁ କେବଳ ଜଣେ ବ୍ୟକ୍ତିଙ୍କୁ କେବେ ଆବଶ୍ୟକ ହୁଏ, ତେଣୁ ଏକ ପବ୍ଲିକ୍/ପ୍ରାଇଭେଟ୍ କି-ପେୟାର୍ ବିନା ଲାଭରେ ଜଟିଳତା ଯୋଡିବ।

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

GPG ଆପଣଙ୍କୁ ଏକ ପାସ୍‌ଫ୍ରେଜ୍ ପ୍ରବେଶ କରିବାକୁ ଏବଂ ନିଶ୍ଚିତ କରିବାକୁ ପ୍ରମ୍ପ୍ଟ କରେ। କିଛି ଶକ୍ତିଶାଳୀ ଏବଂ ସ୍ୱତନ୍ତ୍ର ବାଛନ୍ତୁ ଏବଂ ଏହାକୁ ଏକ ପାସୱାର୍ଡ ମ୍ୟାନେଜର୍‌ରେ ରେକର୍ଡ କରନ୍ତୁ, କାରଣ ଯଦି ଆପଣ ଏହାକୁ ଭୁଲିଯାଆନ୍ତି ତେବେ କୌଣସି ପୁନରୁଦ୍ଧାର ନାହିଁ। ଏହି ବିନ୍ଦୁଠାରୁ, ସେହି ପାସ୍‌ଫ୍ରେଜ୍ ହେଉଛି ଏକମାତ୍ର ଜିନିଷ ଯାହା ଫାଇଲ୍‌ସିଷ୍ଟମ୍ ଆକ୍ସେସ୍ ଏବଂ key ମଧ୍ୟରେ ଠିଆ ହୋଇଛି।

ପଦକ୍ଷେପ 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: ଏକ ଡିକ୍ରିପ୍ଟ-ଏବଂ-ଏକ୍ସେକ୍ ର‍୍ୟାପର୍ ସୃଷ୍ଟି କରନ୍ତୁ ଯାହା ସିକ୍ରେଟ୍‌କୁ କେବେ ପ୍ରିଣ୍ଟ କରେ ନାହିଁ

ଏହା ହେଉଛି ସେହି ପଦକ୍ଷେପ ଯାହା ଭଲ୍ଟକୁ ପ୍ରତିଦିନ ବ୍ୟବହାର ଯୋଗ୍ୟ କରିଥାଏ କେବେବି key କୁ ଏକ୍ସପୋଜ୍ ନକରି। ଏହାକୁ ଏପରି ସେଭ୍ କରନ୍ତୁ ~/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-ଆସିଷ୍ଟାଣ୍ଟ୍ ବ୍ୟବହାରକାରୀ): ଏକ ହାର୍ଡ ଗାର୍ଡ ହୁକ୍ ଯୋଡନ୍ତୁ

ଯଦି ଏକ କୋଡିଂ ଆସିଷ୍ଟାଣ୍ଟ୍ ଆପଣଙ୍କ ମେସିନ୍‌ରେ କମାଣ୍ଡ୍ ଚଲାଏ, ତେବେ "key କୁ ପ୍ରିଣ୍ଟ ନକରିବାକୁ ମନେରଖିବା" ଏକ ନିୟନ୍ତ୍ରଣ ନୁହେଁ। ଅନେକ ଆସିଷ୍ଟାଣ୍ଟ୍ ଏକ ହୁକ୍ ସିଷ୍ଟମ୍ ଏକ୍ସପୋଜ୍ କରନ୍ତି ଯାହା ଏକ କମାଣ୍ଡ୍ ଚାଲିବା ପୂର୍ବରୁ ଯାଞ୍ଚ କରିପାରିବ ଏବଂ ଏହାକୁ ପ୍ରତ୍ୟାଖ୍ୟାନ କରିପାରିବ। ଧାରଣାଟି ହେଉଛି ଏକ ପ୍ରି-ଏକ୍ସିକ୍ୟୁସନ୍ ଗାର୍ଡ ଯାହା ଦୁଇଟି ଜିନିଷକୁ ଅବରୋଧ କରେ: ସିଧାସଳଖ ଏକ ଭଲ୍ଟର ପ୍ଲେନ୍‌ଟେକ୍ସଟ୍ ଫର୍ମ ପଢ଼ିବା, ଏବଂ ଭଲ୍ଟକୁ ଏକ କ୍ୟାପଚର୍ ହୋଇଥିବା ଭେରିଏବଲ୍ ପରିବର୍ତ୍ତେ stdout କିମ୍ବା ଏକ ପାଇପ୍‌କୁ ଡିକ୍ରିପ୍ଟ କରିବା।

ଗାର୍ଡ, ସରଳ ଭାଷାରେ, ପେଣ୍ଡିଂ ସେଲ୍ କମାଣ୍ଡ୍‌କୁ ଯାଞ୍ଚ କରେ ଏବଂ:

• ବ୍ଲକ୍ କରେ ଏକ ରିଡ୍ କମାଣ୍ଡ୍ (cat, less, head, strings, ଇତ୍ୟାଦି) ଭଲ୍ଟର ପ୍ଲେନ୍‌ଟେକ୍ସଟ୍ ଫାଇଲ୍‌ନେମ୍ ଆଡକୁ ନିର୍ଦ୍ଦେଶିତ।
• ବ୍ଲକ୍ କରେ ଏକ gpg --decrypt ଭଲ୍ଟର ଯେପର୍ଯ୍ୟନ୍ତ ଏହାର ଆଉଟପୁଟ୍ ଏକ କମାଣ୍ଡ୍ ସବ୍‌ଷ୍ଟିଚ୍ୟୁସନ୍‌ରେ କ୍ୟାପଚର୍ ହୋଇନାହିଁ ଯେପରିକି X="$(gpg -d ... )".
• ଅନୁମତି ଦିଏ ଅନ୍ୟ ସବୁକିଛି, ବୈଧ ସହିତ cf-run.sh ଆହ୍ୱାନ।

ଏକ ସର୍ବନିମ୍ନ Python ଗାର୍ଡ ଅନୁମତି ଦେବାକୁ exit code 0 ଫେରାଏ ଏବଂ ବ୍ଲକ୍ କରିବାକୁ exit code 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, ପ୍ରାୟ ପ୍ରତ୍ୟେକ ୟୁନିକ୍ସ ମେସିନ୍‌ରେ ଉପସ୍ଥିତ।
• ସାଧାରଣ ବ୍ୟବହାର ସମୟରେ ସିକ୍ରେଟ୍ କେବେବି ପ୍ରିଣ୍ଟ ହୁଏ ନାହିଁ, ଡିସ୍କରେ ଲେଖାଯାଏ ନାହିଁ, କିମ୍ବା ଲଗ୍ ହୁଏ ନାହିଁ।
• ସିମେଟ୍ରିକ୍ ଏନକ୍ରିପ୍ସନ୍ ଏକକ ଅପରେଟର୍ ପାଇଁ ମଡେଲ୍‌କୁ ସରଳ ରଖେ।
• ବୈକଳ୍ପିକ ଗାର୍ଡ ହୁକ୍ "ସତର୍କ ରୁହନ୍ତୁ" କୁ ଏକ ବାଧ୍ୟତାମୂଳକ, କୋଡ୍-ସ୍ତରୀୟ ନିୟନ୍ତ୍ରଣରେ ପରିଣତ କରେ।
• କେବଳ Cloudflare ନୁହେଁ, ଯେକୌଣସି ଉଚ୍ଚ-ବିଶେଷାଧିକାର ପ୍ରାପ୍ତ କ୍ରେଡେନ୍ସିଆଲ୍ ପାଇଁ ସମାନ ପ୍ୟାଟର୍ଣ୍ଣ କାମ କରେ।

ଦୋଷଗୁଡିକ

• ଏକ ଭୁଲିଯାଇଥିବା ପାସ୍‌ଫ୍ରେଜ୍ ମାନେ ସ୍ଥାୟୀ କ୍ଷତି; କୌଣସି ପୁନରୁଦ୍ଧାର ପଥ ନାହିଁ।
• shred SSD ଗୁଡ଼ିକରେ, କପି-ଅନ୍-ରାଇଟ୍ ଫାଇଲ୍‌ସିଷ୍ଟମ୍, କିମ୍ବା ପୂର୍ବରୁ ବ୍ୟାକଅପ୍ ହୋଇଥିବା ଫାଇଲ୍‌ଗୁଡ଼ିକରେ ଡିଲିସନ୍‌କୁ ସମ୍ପୂର୍ଣ୍ଣ ରୂପେ ଗ୍ୟାରେଣ୍ଟି ଦେଇପାରିବ ନାହିଁ।
• ଏନକ୍ରିପ୍ସନ୍ key କୁ ଆଗକୁ ସୁରକ୍ଷିତ ରଖେ କିନ୍ତୁ ଏକ ଅତୀତର ଏକ୍ସପୋଜର୍‌କୁ ଅନ୍‌ଡୁ କରିବାକୁ କିଛି କରେ ନାହିଁ।
• ଗାର୍ଡ ହୁକ୍ ଆସିଷ୍ଟାଣ୍ଟ୍-ନିର୍ଦ୍ଦିଷ୍ଟ ଅଟେ ଏବଂ ଆପଣଙ୍କର ପ୍ରକୃତ ଭଲ୍ଟ ପାଥ୍ ସହିତ ସିଙ୍କ୍‌ରେ ରଖିବାକୁ ହେବ।

ସାବଧାନତା

ଏହି ଆର୍ଟିକିଲ୍‌ରେ ଥିବା ପ୍ରତ୍ୟେକ ମୂଲ୍ୟ — [email protected], REPLACE_WITH_GLOBAL_API_KEY, main-account, ଏବଂ ~/vault ପାଥ୍ — ଏକ ପ୍ଲେସ୍‌ହୋଲ୍ଡର୍ ଅଟେ। ଆପଣଙ୍କର ନିଜସ୍ୱ ବଦଳାନ୍ତୁ ଏବଂ କେବେବି ଏକ ପ୍ଲେନ୍‌ଟେକ୍ସଟ୍ କ୍ରେଡେନ୍ସିଆଲ୍‌କୁ ଭର୍ସନ୍ କଣ୍ଟ୍ରୋଲ୍‌ରେ କମିଟ୍ କରନ୍ତୁ ନାହିଁ। ଏକ ପ୍ରକୃତ key ସହିତ ସେମାନଙ୍କ ଉପରେ ବିଶ୍ୱାସ କରିବା ପୂର୍ବରୁ ଡିକୟ ଫାଇଲ୍ ବିରୁଦ୍ଧରେ ର‍୍ୟାପର୍ ଏବଂ ଗାର୍ଡକୁ ପରୀକ୍ଷା କରନ୍ତୁ, ଏବଂ ଯେଉଁ ମୁହୂର୍ତ୍ତରେ ଆପଣ ସନ୍ଦେହ କରନ୍ତି ଯେ ଏହା ଏକ୍ସପୋଜ୍ ହୋଇଛି ସେତେବେଳେ ଯେକୌଣସି କ୍ରେଡେନ୍ସିଆଲ୍‌କୁ ରୋଟେଟ୍ କରନ୍ତୁ। ନିଜ ବିପଦରେ ଆଗକୁ ବଢ଼ନ୍ତୁ; ଆପଣ ଆପଣଙ୍କର ନିଜସ୍ୱ କ୍ରେଡେନ୍ସିଆଲ୍ ଏବଂ ଭିତ୍ତିଭୂମି ପାଇଁ ଦାୟୀ।

ବାରମ୍ବାର ପଚରାଯାଉଥିବା ପ୍ରଶ୍ନ

ଏକ ପବ୍ଲିକ୍/ପ୍ରାଇଭେଟ୍ କି-ପେୟାର୍ ପରିବର୍ତ୍ତେ GPG ସିମେଟ୍ରିକ୍ ଏନକ୍ରିପ୍ସନ୍ କାହିଁକି ବ୍ୟବହାର କରିବେ? ଜଣେ ଏକକ ଅପରେଟର୍ ଯିଏ ଉଭୟ ଏନକ୍ରିପ୍ଟର୍ ଏବଂ ଏକମାତ୍ର ଡିକ୍ରିପ୍ଟର୍ ଅଟନ୍ତି, ସେମାନଙ୍କ ପାଇଁ ଏକ ପାସ୍‌ଫ୍ରେଜ୍-ଆଧାରିତ ସିମେଟ୍ରିକ୍ ସାଇଫର୍ ସରଳ ଏବଂ ସମାନ ଭାବରେ ଶକ୍ତିଶାଳୀ ଅଟେ। ଏକ କି-ପେୟାର୍ ଏହି କ୍ଷେତ୍ରରେ କୌଣସି ସୁରକ୍ଷା ଲାଭ ବିନା କି-ମ୍ୟାନେଜମେଣ୍ଟ୍ ଓଭରହେଡ୍ ଯୋଡିଥାଏ।

ଏନକ୍ରିପ୍ଟ ହୋଇଥିବା .cf.gpg ଫାଇଲ୍‌କୁ git ରେ ଷ୍ଟୋର୍ କରିବା ସୁରକ୍ଷିତ କି? ସାଇଫର୍‌ଟେକ୍ସଟ୍ ବୈଷୟିକ ଭାବରେ କମିଟ୍ କରିବାକୁ ସୁରକ୍ଷିତ ଅଟେ, କିନ୍ତୁ ଏହା ଆପଣଙ୍କ ମେସିନ୍ ଛାଡିବାରେ କୌଣସି ଲାଭ ନାହିଁ। ଏହାକୁ ଲୋକାଲ୍ ରଖନ୍ତୁ, ଏବଂ କେବେବି, କେବେବି ପ୍ଲେନ୍‌ଟେକ୍ସଟ୍‌କୁ କମିଟ୍ କରନ୍ତୁ ନାହିଁ।

ମୁଁ Global API Key ପରିବର୍ତ୍ତେ ଏକ Cloudflare API Token ବ୍ୟବହାର କରିବା ଉଚିତ୍ କି? ହଁ, ଯେତେବେଳେ ବି ଟୁଲ୍ ଏହାକୁ ସମର୍ଥନ କରେ। ଏକ ସ୍କୋପ୍ଡ୍ ଟୋକେନ୍‌କୁ ବ୍ୟକ୍ତିଗତ ଭାବରେ ପ୍ରତ୍ୟାହାର କରାଯାଇପାରିବ ଏବଂ ଏହାର ସ୍କୋପ୍ ବାହାରେ ଥିବା ରିସୋର୍ସରେ ପହଞ୍ଚିପାରିବ ନାହିଁ, ତେଣୁ ଏକ ଲିକ୍ ହୋଇଥିବା Global API Key ତୁଳନାରେ ଏକ ଲିକ୍ ବହୁତ କମ୍ କ୍ଷତିକାରକ ଅଟେ।

ଡିକ୍ରିପ୍ଟ-ଏବଂ-ଏକ୍ସେକ୍ ର‍୍ୟାପର୍ ପ୍ରକୃତରେ କାହା ବିରୁଦ୍ଧରେ ସୁରକ୍ଷା ଦିଏ? ଏହା ନିଶ୍ଚିତ କରେ ଯେ ଡିକ୍ରିପ୍ଟ ହୋଇଥିବା ସିକ୍ରେଟ୍ କେବଳ ଗୋଟିଏ ଚାଇଲ୍ଡ ପ୍ରୋସେସ୍‌ର ପରିବେଶରେ ରହିଥାଏ। ଏହା କେବେବି ଏକ ଟର୍ମିନାଲ୍‌ରେ ପ୍ରିଣ୍ଟ ହୁଏ ନାହିଁ, ସେଲ୍ ହିଷ୍ଟ୍ରିରେ କ୍ୟାପଚର୍ ହୁଏ ନାହିଁ, କିମ୍ବା ଡିସ୍କରେ ଲେଖାଯାଏ ନାହିଁ, ଯାହାକି ସାଧାରଣ ଦୁର୍ଘଟଣାଜନିତ-ଲିକ୍ ପାଥ୍ ଅଟେ।

ଏକ AI କୋଡିଂ ଆସିଷ୍ଟାଣ୍ଟ୍‌ରେ ଏକ ସିକ୍ରେଟ୍ କିପରି ଲିକ୍ ହୁଏ? ଆସିଷ୍ଟାଣ୍ଟ୍ ଯାହା ପଢ଼େ କିମ୍ବା ଏକ କମାଣ୍ଡ୍ ଯାହା ପ୍ରିଣ୍ଟ କରେ ତାହା ମଡେଲ୍ ପ୍ରଦାନକାରୀଙ୍କୁ ପଠାଯାଇଥିବା ସେସନ୍ ଟ୍ରାନ୍ସକ୍ରିପ୍ଟରେ ଯୋଡାଯାଏ। ଏକ ଏକକ cat ଏକ ପ୍ଲେନ୍‌ଟେକ୍ସଟ୍ key ର, କିମ୍ବା stdout କୁ ଏକ ଡିକ୍ରିପ୍ଟ, ସେହି ଟ୍ରାନ୍ସକ୍ରିପ୍ଟରେ ସ୍ଥାୟୀ ଭାବରେ key ରଖେ।

ଯଦି ଏହା ପୂର୍ବରୁ ଥରେ ଲିକ୍ ହୋଇସାରିଛି ତେବେ key କୁ ଏନକ୍ରିପ୍ଟ କରିବା ସାହାଯ୍ୟ କରେ କି? ନା। ଏନକ୍ରିପ୍ସନ୍ କେବଳ ଭବିଷ୍ୟତର ଏକ୍ସପୋଜର୍‌ରୁ key କୁ ସୁରକ୍ଷିତ ରଖେ। ଯଦି ଏକ key କେବେ ପ୍ରିଣ୍ଟ, ପେଷ୍ଟ କରାଯାଇଥିଲା, କିମ୍ବା ଏକ ଟ୍ରାନ୍ସକ୍ରିପ୍ଟରେ ଦେଖାଯାଇଥିଲା, ତେବେ ଆପଣଙ୍କୁ ଏହାକୁ ରୋଟେଟ୍ କରିବାକୁ ପଡିବ; ପୁରୁଣା ମୂଲ୍ୟକୁ ଏନକ୍ରିପ୍ଟ କରିବା ଏକ୍ସପୋଜ୍ ହୋଇଥିବା ବିଷୟରେ କିଛି ପରିବର୍ତ୍ତନ କରେ ନାହିଁ।

ମୁଁ କେତେଥର ଏକ ଉଚ୍ଚ-ବିଶେଷାଧିକାର ପ୍ରାପ୍ତ key ରୋଟେଟ୍ କରିବା ଉଚିତ୍? ଏକ ସୂଚୀରେ ରୋଟେଟ୍ କରନ୍ତୁ ଯାହା ଆପଣଙ୍କର ବିପଦ ସହନଶୀଳତା ସହିତ ମେଳ ଖାଏ, ଏବଂ ଯେକୌଣସି ସନ୍ଦିଗ୍ଧ ଏକ୍ସପୋଜର୍ ଉପରେ ତୁରନ୍ତ। ଏକ ଆକାଉଣ୍ଟ-ସ୍ତରୀୟ key ପାଇଁ, ଅଧିକ ବାରମ୍ବାର ରୋଟେଟ୍ କରିବା ଦିଗରେ ଭୁଲ୍ କରନ୍ତୁ, କାରଣ ଏହାର ବ୍ଲାଷ୍ଟ୍ ବ୍ୟାସାର୍ଦ୍ଧ ହେଉଛି ସମ୍ପୂର୍ଣ୍ଣ ଆକାଉଣ୍ଟ୍।

ମୁଁ ଏହାକୁ AWS, ଡାଟାବେସ୍ କିମ୍ବା ଅନ୍ୟ କ୍ରେଡେନ୍ସିଆଲ୍ ସହିତ ଖାପ ଖୁଆଇ ପାରିବି କି? ହଁ। ସମାନ ତିନୋଟି ଧାରଣା — ବିଶ୍ରାମ ସମୟରେ ଏନକ୍ରିପ୍ଟ କରନ୍ତୁ, କେବଳ ଏକ ଥ୍ରୋଆୱେ ସବ୍‌ପ୍ରୋସେସ୍‌ରେ ଡିକ୍ରିପ୍ଟ କରନ୍ତୁ, ଏବଂ ଅସୁରକ୍ଷିତ ପଢ଼ିବାକୁ ଅବରୋଧ କରନ୍ତୁ — ଯେକୌଣସି ସିକ୍ରେଟ୍ ପାଇଁ ପ୍ରଯୁଜ୍ୟ। ମେଳ କରିବା ପାଇଁ ର‍୍ୟାପର୍‌ରେ ଫିଲ୍ଡ ପାର୍ସିଂ ଏବଂ ଏନଭାଇରନ୍‌ମେଣ୍ଟ୍ ଭେରିଏବଲ୍ ନାମଗୁଡିକ ଆଡଜଷ୍ଟ କରନ୍ତୁ।

ଟ୍ୟାଗ୍‌ଗୁଡ଼ିକ

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