OpenVPN કી બનાવવા માટે તમને કોઈ હંગામી ફાઇલની જરૂર નથી

કી બનાવવા માટે હંગામી ફાઇલની જરૂર નથી, અને તેને છોડી દેવાથી મોટાભાગના માર્ગદર્શિકાઓ સૂચવે તેના કરતાં ઓછું સુધરે છે. તે જે દૂર કરે છે તે ફાઇલનું જીવનચક્ર અને તેની આસપાસની સફાઈની દોડ છે. તે જે અડીને રહેવા દે છે તે પછી ગુપ્તતાને લીક કરવાની દરેક તક છે. આ સ્ક્રિપ્ટોમાં શુદ્ધતાની સમસ્યા સામાન્ય રીતે બીજે જ હોય છે, કારણ કે નિદાન અને કીની સામગ્રી જુદા જુદા પ્રવાહોમાં મુસાફરી કરે છે.

ફાઇલ ક્યારેય એ જાહેરાત ન હતી જે તમે વિચાર્યું હતું

હંગામી ફાઇલ તે વખતે ચોક્કસ જોખમ છે જ્યારે તે બધા માટે વાંચવા યોગ્ય હોય, જ્યારે તે ક્રેશમાંથી બચી જાય, અથવા જ્યારે અપવાદ પછી સફાઈનું પગલું છોડી દેવાય. આ સાચા છે, અને તેને સુધારવા યોગ્ય છે. તેઓ સ્થાનિક, દૃશ્યમાન અને પરીક્ષણમાં સરળ પણ છે. પરિવર્તન માત્ર દેખાવનું હતું એવા નિષ્કર્ષ પર આવતા પહેલાં તમારી પોતાની સ્ક્રિપ્ટમાં દરેકનું નામ આપો.

વધુ શાંત જોખમો નીચે બેઠા છે: ડિબગિંગ દરમિયાન છપાયેલી કી, આખા પરિણામ ઑબ્જેક્ટને સીરિયલાઇઝ કરતો અપવાદ, કોર ડમ્પ લખતો ક્રેશ હેન્ડલર, પહેલાં ફાઇલનો પાથ અને પછી સામગ્રી મેળવતો લોગ સંગ્રાહક. હંગામી ફાઇલ ટાળવાથી તેમાંથી એક પણ માટે કંઈ થતું નથી, અને ઊલટું માનવું એ જ રીતે સદ્ભાવનાપૂર્ણ પુનર્લેખન ગુપ્તતાને પહેલાં કરતાં વધુ ખુલ્લી રાખે છે. પરિવર્તનને ક્રમમાં એક સુધારા તરીકે ગણો, ઉપાય તરીકે નહીં.

જ્યારે ફાઇલનું નામ ન આપવામાં આવે ત્યારે ક્લાયન્ટ શું લખે છે

ક્લાયન્ટની વર્તમાન આવૃત્તિઓ જ્યારે આઉટપુટ પાથ વગર કી આદેશ આપવામાં આવે ત્યારે બનાવેલી કીને પ્રમાણભૂત આઉટપુટ પર મોકલે છે. એ જ દસ્તાવેજી વર્તન મેમરી-આધારિત અભિગમને શક્ય બનાવે છે, અને તે સાધનને ઉપકરણ પાથ તરફ દોરવાની જૂની યુક્તિની જરૂર દૂર કરે છે.

import subprocess
proc = subprocess.run(
    ["openvpn", "--genkey", "tls-crypt"],
    stdout=subprocess.PIPE,
    stderr=subprocess.PIPE,
    check=True,
)
key_material = proc.stdout

આદેશને સૂચિ તરીકે આપો. અહીં શેલ વિસ્તરણની જરૂર નથી, અને શેલ સક્ષમ કરવાથી આર્ગ્યુમેન્ટની સીમા એવા અવતરણ ચિહ્નો પર આધારિત થઈ જાય જે તમારા નિયંત્રણમાં નથી. જો સ્ક્રિપ્ટ તમે ધારો તેના કરતાં જુદા શોધ પાથ સાથે ચાલી શકે તો ઇચ્છિત એક્ઝિક્યુટેબલને નિરપેક્ષ પાથથી વાપરો.

રિટર્ન કોડની ચકાસણી નિષ્ફળ કૉલ પછી સફળતાના માર્ગને આગળ વધતો અટકાવે છે. તેના વગર, ખાલી બાઇટ શ્રેણી આગળ વહી શકે છે અને ઘણું મોડું નિષ્ફળ જાય છે, તે બિંદુએ જ્યાં કી વપરાય છે અને ભૂલનો સંદેશ હવે બનાવટનો ઉલ્લેખ પણ કરતો નથી.

બે પ્રવાહ, બે અર્થ

પ્રમાણભૂત આઉટપુટ કી વહન કરે છે. પ્રમાણભૂત ભૂલ તે બધું વહન કરે છે જે સાધન તમને કહેવા માંગે છે, જેમાં રૂપરેખાંકન, આવૃત્તિ અને કીના પ્રકાર વિશેની ચેતવણીઓનો સમાવેશ થાય છે. બંનેને એક બફરમાં ફેરવવી એ જ ભૂલ છે જે વિશ્વસનીય દેખાતી કી પેદા કરે છે જેની વચ્ચે એક વાક્ય સીવેલું હોય છે.

નિષ્ફળતાનો માર્ગ પણ અલગ રાખો. જ્યારે કૉલ નિષ્ફળ જાય, ત્યારે નિષ્ફળ થયેલો આદેશ અને નિકાસ સ્થિતિ જણાવો, અને પછી સભાનપણે નક્કી કરો કે પ્રમાણભૂત ભૂલનો કોઈ ભાગ બતાવવા માટે સુરક્ષિત છે કે નહીં. આખો પરિણામ ઑબ્જેક્ટ લોગમાં ઠાલવવો સામાન્ય શૉર્ટકટ છે, અને તે કીને સાથે લઈ જઈ શકે છે.

બાઇનરી માટે સુરક્ષિત વાંચન મહત્વનું છે જો તમે પછી સામગ્રીનો હેશ કરો અથવા તેની તુલના કરો. અણધારી એન્કોડિંગ સાથેનો ટેક્સ્ટ મોડ એવા બાઇટ્સ બદલી શકે છે જે ક્યારેય ટેક્સ્ટ થવા માટે નહોતા, અને બદલાયેલી કી હેન્ડશેક નિષ્ફળ ન થાય ત્યાં સુધી ખોટી કીથી અલગ પડતી નથી.

જો તમે તેને સાચવો જ, તો સભાનપણે કરો

મોટાભાગની જમાવટને છેવટે કી ડિસ્ક પર, ગેટવે પર અથવા ગુપ્ત ભંડારમાં જોઈએ. તેને એક વાર લખો, બનાવટથી જ મર્યાદિત પરવાનગીઓ સાથે, પછીના chmod સાથે નહીં, અને લખાણને પરમાણુ બનાવો જેથી આંશિક ફાઇલ ક્યારેય એવી ન બને જે સેવા શરૂ થતી વખતે વાંચે. એક જ ડિરેક્ટરીના પાથથી પુનર્નામકરણ સામાન્ય રીતે તે માટે પૂરતું છે. નિષ્ફળતાની શાખામાં સ્ટેજિંગ પાથ દૂર કરો, કારણ કે નિષ્ફળ લખાણ એ જ નકલ છે જે લોકો ભૂલી જાય છે.

ફાઇલ બનાવતી વખતે તેનો મોડ સેટ કરો, અને ડિરેક્ટરીનો મોડ પણ મર્યાદિત રાખો. એવા સ્થાન હેઠળના કોઈ પણ પાથથી બચો જેને બેકઅપ કામ વિચાર્યા વગર ખેંચી લે છે, કારણ કે રાત્રિના બેકઅપમાંનું ગુપ્ત તે બેકઅપની દરેક નકલમાં ગુપ્ત છે. એ જ તર્ક અન્ય સેવાઓ વાંચી શકે તેવા વહેંચાયેલા વોલ્યુમ પર પણ લાગુ પડે છે.

વહેંચાયેલી કી ઓળખ નથી

આ સામગ્રી બનાવવાથી કોઈ પ્રમાણપત્ર અપાયું નથી, ક્લાયન્ટ નોંધાયો નથી અને કોણ જોડાય છે તે સ્થપાતું નથી. વહેંચાયેલી કી એવા પક્ષો વચ્ચેની ચેનલનું રક્ષણ કરે છે જે પહેલેથી એકબીજા પર ભરોસો કરે છે; ઓળખ હજી પણ પ્રમાણપત્રમાંથી અને તેની સામે બેસતી કોઈ પણ પ્રમાણીકરણમાંથી આવે છે.

કીના પ્રકારો પણ એકબીજાના બદલે વપરાઈ શકતા નથી. એક લક્ષણ માટેની સમમિત કી બીજા માટે તૈયાર વિકલ્પ નથી, અને નવી આવૃત્તિઓ દરેક છેડે જુદી ફાઇલો સાથે પોતાના પ્રકારો ઉમેરે છે. તમારું રૂપરેખાંકન ખરેખર જે પ્રકારનું નામ લે તે પ્રકાર બનાવો, પછી તેને એ ભૂમિકામાં વાપરો જે તે પ્રકાર નિર્ધારિત કરે છે.

ફાઇલનું કદ તપાસવાને બદલે વાસ્તવિક કનેક્શનથી પરિણામ ચકાસો. જો હેન્ડશેક પૂર્ણ થાય અને લોગ કોઈ કી ચેતવણી ન બતાવે, તો બનાવટનો માર્ગ સાચો છે; જો કી ભળેલા પ્રવાહને કારણે કપાઈ ગઈ હોત, તો કનેક્શન એ રીતે નિષ્ફળ જાત જે સ્ક્રિપ્ટને નહીં, સામેના પક્ષ તરફ ઇશારો કરે.