OpenVPN കീ സൃഷ്ടിക്കാൻ നിങ്ങൾക്ക് താൽക്കാലിക ഫയൽ ആവശ്യമില്ല

കീ സൃഷ്ടിക്കാൻ താൽക്കാലിക ഫയൽ ആവശ്യമില്ല, അത് ഒഴിവാക്കുന്നത് മിക്ക ഗൈഡുകളും സൂചിപ്പിക്കുന്നതിനേക്കാൾ കുറച്ചേ ശരിയാക്കുന്നു. അത് നീക്കുന്നത് ഒരു ഫയലിന്റെ ജീവിതചക്രവും അതിനുചുറ്റുമുള്ള ക്ലീനപ്പ് മത്സരവുമാണ്. അത് തൊടാതെ വിടുന്നത് പിന്നീട് രഹസ്യം ചോർത്താനുള്ള എല്ലാ അവസരവുമാണ്. ഈ സ്ക്രിപ്റ്റുകളിലെ കൃത്യതയുടെ പ്രശ്നം സാധാരണയായി മറ്റൊരിടത്താണ് ഇരിക്കുന്നത്, കാരണം ഡയഗ്നോസ്റ്റിക്സും കീയുടെ വസ്തുവും വ്യത്യസ്ത സ്ട്രീമുകളിലൂടെ സഞ്ചരിക്കുന്നു.

ഫയൽ ഒരിക്കലും നിങ്ങൾ കരുതിയ ആ വെളിപ്പെടുത്തലായിരുന്നില്ല

എല്ലാവർക്കും വായിക്കാവുന്നതാകുമ്പോൾ, ക്രാഷിൽ നിന്ന് അതിജീവിക്കുമ്പോൾ, അല്ലെങ്കിൽ ഒരു എക്സെപ്ഷനുശേഷം ക്ലീനപ്പ് ഘട്ടം ഒഴിവാക്കുമ്പോൾ താൽക്കാലിക ഫയൽ ഒരു നിർദ്ദിഷ്ട അപകടമാണ്. ഇവ യഥാർത്ഥമാണ്, ഇവ ശരിയാക്കുന്നത് മൂല്യവത്താണ്. അവ പ്രാദേശികവും ദൃശ്യവും പരിശോധിക്കാൻ എളുപ്പവുമാണ്. മാറ്റം കേവലം ഉപരിപ്ലവമായിരുന്നു എന്ന് തീരുമാനിക്കുന്നതിന് മുമ്പ് നിങ്ങളുടെ സ്വന്തം സ്ക്രിപ്റ്റിൽ ഓരോന്നിനും പേര് നൽകുക.

കൂടുതൽ ശാന്തമായ അപകടങ്ങൾ താഴെയാണ് ഇരിക്കുന്നത്: ഡീബഗ്ഗിംഗിനിടയിൽ അച്ചടിക്കുന്ന കീ, മുഴുവൻ ഫല വസ്തുവിനെയും സീരിയലൈസ് ചെയ്യുന്ന എക്സെപ്ഷൻ, കോർ ഡംപ് എഴുതുന്ന ക്രാഷ് ഹാൻഡ്ലർ, ആദ്യം ഫയലിന്റെ പാത്തും പിന്നീട് ഉള്ളടക്കവും സ്വീകരിക്കുന്ന ലോഗ് സംഭരണി. താൽക്കാലിക ഫയൽ ഒഴിവാക്കുന്നത് അവയിൽ ഒന്നിനും ഒന്നും ചെയ്യുന്നില്ല, വിപരീതം വിശ്വസിക്കുന്നതാണ് നല്ല ഉദ്ദേശ്യത്തോടെയുള്ള പുനരെഴുത്ത് രഹസ്യത്തെ മുമ്പത്തേക്കാൾ തുറന്നുവിടുന്ന വഴി. മാറ്റത്തെ ഒരു ശ്രേണിയിലെ ഒരു മെച്ചപ്പെടുത്തലായി കാണുക, പരിഹാരമായി അല്ല.

ഫയലിന്റെ പേര് നൽകാത്തപ്പോൾ ക്ലയന്റ് എന്ത് എഴുതുന്നു

ക്ലയന്റിന്റെ നിലവിലെ പതിപ്പുകൾ ഔട്ട്പുട്ട് പാത്ത് ഇല്ലാതെ കീ കമാൻഡ് നൽകുമ്പോൾ സൃഷ്ടിച്ച കീയെ സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ടിലേക്ക് അയയ്ക്കുന്നു. ഈ രേഖപ്പെടുത്തിയ പെരുമാറ്റമാണ് മെമ്മറി അടിസ്ഥാനമാക്കിയ സമീപനത്തെ സാധ്യമാക്കുന്നത്, അത് ഉപകരണത്തിന്റെ പാത്തിലേക്ക് ഉപകരണം തിരിച്ചുവിടുന്ന പഴയ തന്ത്രത്തിന്റെ ആവശ്യകത നീക്കുന്നു.

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

കമാൻഡ് ഒരു ലിസ്റ്റായി നൽകുക. ഇവിടെ ഷെൽ വിപുലീകരണം ആവശ്യമില്ല, ഷെൽ പ്രവർത്തനക്ഷമമാക്കുന്നത് ആർഗ്യുമെന്റിന്റെ അതിർത്തിയെ നിങ്ങൾ നിയന്ത്രിക്കാത്ത ഉദ്ധരണികളെ ആശ്രയിച്ചാക്കും. സ്ക്രിപ്റ്റ് നിങ്ങൾ പ്രതീക്ഷിക്കുന്നതിൽ നിന്ന് വ്യത്യസ്തമായ തിരയൽ പാത്തിലൂടെ പ്രവർത്തിക്കാമെങ്കിൽ ഉദ്ദേശിച്ച എക്സിക്യൂട്ടബിൾ കേവല പാത്തിലൂടെ ഉപയോഗിക്കുക.

റിട്ടേൺ കോഡ് പരിശോധന പരാജയപ്പെട്ട വിളിക്കുശേഷം വിജയ പാത തുടരുന്നത് തടയുന്നു. അതില്ലാതെ, ശൂന്യമായ ബൈറ്റ് സ്ട്രിംഗ് മുന്നോട്ട് ഒഴുകാം, വളരെ വൈകിയാണ് പരാജയപ്പെടുന്നത്, കീ ഉപയോഗിക്കുന്ന ഘട്ടത്തിൽ, അപ്പോൾ പിശക് സന്ദേശം സൃഷ്ടിയെക്കുറിച്ച് ഒട്ടും പറയുന്നില്ല.

രണ്ട് സ്ട്രീം, രണ്ട് അർത്ഥം

സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ട് കീയെ വഹിക്കുന്നു. സ്റ്റാൻഡേർഡ് പിശക് ഉപകരണം നിങ്ങളോട് പറയാൻ ആഗ്രഹിക്കുന്ന എല്ലാം വഹിക്കുന്നു, കോൺഫിഗറേഷൻ, പതിപ്പ്, കീ തരം എന്നിവയെക്കുറിച്ചുള്ള മുന്നറിയിപ്പുകളും ഉൾപ്പെടെ. രണ്ടും ഒരു ബഫറിലേക്ക് തിരിച്ചുവിടുന്നതാണ് വിശ്വസനീയമായി കാണുന്ന കീയുടെ നടുവിൽ ഒരു വാക്യം തുന്നിച്ചേർത്ത് നിർമ്മിക്കുന്ന തെറ്റ്.

പരാജയത്തിന്റെ പാതയും വേർതിരിച്ചു വയ്ക്കുക. വിളി പരാജയപ്പെടുമ്പോൾ, പരാജയപ്പെട്ട കമാൻഡും പുറത്തുകടക്കൽ അവസ്ഥയും റിപ്പോർട്ട് ചെയ്യുക, പിന്നീട് സ്റ്റാൻഡേർഡ് പിശകിന്റെ ഏതെങ്കിലും ഭാഗം കാണിക്കുന്നത് സുരക്ഷിതമാണോ എന്ന് ബോധപൂർവം തീരുമാനിക്കുക. മുഴുവൻ ഫല വസ്തുവും ലോഗിലേക്ക് ഒഴുക്കുന്നതാണ് സാധാരണ കുറുക്കുവഴി, അത് കീയെ തന്നോടൊപ്പം കൊണ്ടുപോകാം.

പിന്നീട് വസ്തു ഹാഷ് ചെയ്യുകയോ താരതമ്യം ചെയ്യുകയോ ചെയ്യുന്നെങ്കിൽ ബൈനറിക്ക് സുരക്ഷിതമായ വായന പ്രധാനമാണ്. അപ്രതീക്ഷിതമായ എൻകോഡിംഗുള്ള ടെക്സ്റ്റ് മോഡ് ഒരിക്കലും ടെക്സ്റ്റ് ആകാൻ ഉദ്ദേശിക്കാത്ത ബൈറ്റുകൾ മാറ്റാം, മാറിയ കീ ഹസ്തദാനം പരാജയപ്പെടുന്നതുവരെ തെറ്റായ കീയിൽ നിന്ന് വേർതിരിക്കാനാവില്ല.

എങ്കിലും സൂക്ഷിക്കുന്നെങ്കിൽ, ബോധപൂർവം ചെയ്യുക

മിക്ക വിന്യാസങ്ങൾക്കും ഒടുവിൽ കീ ഡിസ്കിൽ, ഗേറ്റ്വേയിൽ, അല്ലെങ്കിൽ രഹസ്യ കലവറയിൽ ആവശ്യമാണ്. ഒരിക്കൽ എഴുതുക, നിർമ്മാണം മുതൽ നിയന്ത്രിത അനുമതികളോടെ, പിന്നീടുള്ള chmod യിലൂടെയല്ല, എഴുത്ത് ആറ്റോമിക് ആക്കുക, ഭാഗിക ഫയൽ ഒരിക്കലും സേവനം ആരംഭിക്കുമ്പോൾ വായിക്കുന്ന ഫയലാകാതിരിക്കാൻ. ഒരേ ഡയറക്ടറിയിലെ പാത്തിൽ നിന്നുള്ള പുനർനാമകരണം അതിന് സാധാരണയായി മതി. പരാജയ ശാഖയിൽ സ്റ്റേജിംഗ് പാത്ത് നീക്കുക, കാരണം പരാജയപ്പെട്ട എഴുത്താണ് ആളുകൾ മറക്കുന്ന പകർപ്പ്.

ഫയൽ സൃഷ്ടിക്കുമ്പോൾ അതിന്റെ മോഡ് സജ്ജമാക്കുക, ഡയറക്ടറിയുടെ മോഡും നിയന്ത്രിതമായി വയ്ക്കുക. ബാക്കപ്പ് ജോലി ആലോചിക്കാതെ വാരിക്കൂട്ടുന്ന സ്ഥലത്തിനടിയിലുള്ള ഏത് പാത്തും ഒഴിവാക്കുക, കാരണം രാത്രി ബാക്കപ്പിലെ രഹസ്യം ആ ബാക്കപ്പിന്റെ എല്ലാ പകർപ്പിലും രഹസ്യമാണ്. മറ്റ് സേവനങ്ങൾക്ക് വായിക്കാവുന്ന പങ്കിട്ട വോള്യത്തിനും ഇതേ യുക്തി ബാധകമാണ്.

പങ്കിട്ട കീ ഒരു അടയാളമല്ല

ഈ വസ്തു സൃഷ്ടിക്കുന്നത് സർട്ടിഫിക്കറ്റ് നൽകുന്നില്ല, ക്ലയന്റിനെ രജിസ്റ്റർ ചെയ്യുന്നില്ല, ആരാണ് ബന്ധിപ്പിക്കുന്നതെന്ന് സ്ഥാപിക്കുന്നുമില്ല. പങ്കിട്ട കീ ഇതിനകം പരസ്പരം വിശ്വസിക്കുന്ന പക്ഷങ്ങൾക്കിടയിലുള്ള ചാനൽ സംരക്ഷിക്കുന്നു; അടയാളം ഇപ്പോഴും സർട്ടിഫിക്കറ്റിൽ നിന്നും അതിനു മുന്നിൽ ഇരിക്കുന്ന ഏതൊരു പ്രാമാണീകരണത്തിൽ നിന്നും വരുന്നു.

കീ തരങ്ങളും പരസ്പരം മാറ്റാനാവില്ല. ഒരു സവിശേഷതയ്ക്കുള്ള സമമിത കീ മറ്റൊന്നിനുള്ള തയ്യാറായ പകരമല്ല, പുതിയ പതിപ്പുകൾ ഓരോ അറ്റത്തും വ്യത്യസ്ത ഫയലുകളുള്ള സ്വന്തം വകഭേദങ്ങൾ ചേർക്കുന്നു. നിങ്ങളുടെ കോൺഫിഗറേഷൻ യഥാർത്ഥത്തിൽ പേരിടുന്ന തരം സൃഷ്ടിക്കുക, പിന്നീട് ആ തരം നിർവചിക്കുന്ന റോളിൽ അത് ഉപയോഗിക്കുക.

ഫയലിന്റെ വലിപ്പം പരിശോധിക്കുന്നതിനു പകരം യഥാർത്ഥ കണക്ഷൻ ഉപയോഗിച്ച് ഫലം പരീക്ഷിക്കുക. ഹസ്തദാനം പൂർത്തിയാകുകയും ലോഗുകൾ കീ മുന്നറിയിപ്പുകൾ കാണിക്കാതിരിക്കുകയും ചെയ്താൽ സൃഷ്ടിയുടെ പാത ശരിയാണ്; കീ ലയിപ്പിച്ച സ്ട്രീമിൽ മുറിഞ്ഞിരുന്നെങ്കിൽ, കണക്ഷൻ സ്ക്രിപ്റ്റിനെയല്ല, എതിർപക്ഷത്തെ ചൂണ്ടിക്കാണിക്കുന്ന രീതിയിൽ പരാജയപ്പെടുമായിരുന്നു.