Erlang 21

ssh




erlang

ssh

मॉड्यूल

ssh

मॉड्यूल सारांश

Ssh एप्लिकेशन का मुख्य एपीआई

विवरण

यह SSH एप्लिकेशन के लिए इंटरफ़ेस मॉड्यूल है। सिक्योर शेल (SSH) प्रोटोकॉल एक असुरक्षित नेटवर्क पर सुरक्षित रिमोट लॉगिन और अन्य सुरक्षित नेटवर्क सेवाओं के लिए एक प्रोटोकॉल है। समर्थित RFC, संस्करण, एल्गोरिदम और यूनिकोड हैंडलिंग के विवरण के लिए ssh(6) देखें।

एसएसएच एप्लिकेशन के साथ ग्राहकों को शुरू करना और डेमोंस (सर्वर) शुरू करना संभव है।

ग्राहकों को connect/2 , connect/3 या connect/4 । वे टीसीपी / आईपी के शीर्ष पर एक एन्क्रिप्टेड कनेक्शन खोलते हैं। उस एन्क्रिप्टेड कनेक्शन में ssh_connection:session_channel/2,4 साथ एक या अधिक चैनल खोले जा सकते हैं।

प्रत्येक चैनल क्लाइंट-साइड प्रक्रिया और सर्वर-साइड प्रक्रिया के बीच एक पृथक "पाइप" है। थोज़ोज़ प्रक्रिया जोड़े उदाहरण फ़ाइल स्थानांतरण (sftp) या दूरस्थ कमांड निष्पादन (शेल, निष्पादन और / या cli) को संभाल सकते हैं। यदि कोई कस्टम शेल कार्यान्वित किया जाता है, तो क्लाइंट का उपयोगकर्ता दूरस्थ रूप से विशेष कमांड निष्पादित कर सकता है। ध्यान दें कि उपयोगकर्ता आवश्यक रूप से एक मानव नहीं है, लेकिन संभवतः SSH ऐप को बाधित करने वाला सिस्टम है।

सर्वर-साइड सबसिस्टम (चैनल) सर्वर क्लाइंट द्वारा ssh_connection:subsystem/4 साथ अनुरोध किया जाता है।

एक सर्वर (डेमॉन) daemon/1 , daemon/1 या daemon/1 साथ शुरू किया गया है। संभावित चैनल हैंडलर (सबसिस्टम) को डेमन शुरू होने पर subsystem विकल्प के साथ घोषित किया जाता है।

किसी दूरस्थ मशीन पर एक शेल चलाने के लिए, ऐसे कार्य हैं जो आवश्यक तीन चरणों को एक में shell/1,2,3 : shell/1,2,3 । इसी तरह, रिमोट मशीन से केवल एक sftp (फाइल ट्रांसफर) कनेक्शन को खोलने के लिए, सबसे आसान तरीका ssh_sftp:start_channel/1,2,3 का उपयोग ssh_sftp:start_channel/1,2,3

अपने खुद के क्लाइंट चैनल हैंडलर लिखने के लिए, व्यवहार ssh_client_channel उपयोग करें। सर्वर चैनल हैंडलर के लिए ssh_server_channel व्यवहार (बदले ssh_daemon_channel) का उपयोग ssh_server_channel हैं।

क्लाइंट और डेमॉन दोनों ही ऐसे विकल्पों को स्वीकार करते हैं जो सटीक व्यवहार को नियंत्रित करते हैं। कुछ विकल्प दोनों के लिए सामान्य हैं। तीन सेट को Client Options , Daemon Options और Common Options कहा जाता है।

विकल्पों का वर्णन व्याख्या पाठ के साथ Erlang Type Language का उपयोग करता है।

ध्यान दें

User's Guide में उदाहरण और Getting Started अनुभाग है।

कुंजी और फ़ाइलें

SSH एप्लिकेशन को कार्य करने के लिए कई ऑब्जेक्ट मौजूद होने चाहिए। थॉयस ऑब्जेक्ट्स डिफ़ॉल्ट रूप से फाइलों में संग्रहीत होती हैं। डिफ़ॉल्ट नाम, पथ और फ़ाइल प्रारूप OpenSSH लिए समान हैं। OpenSSH से ssh-keygen प्रोग्राम के साथ कुंजी उत्पन्न की जा सकती है। User's Guide देखें।

रास्ते आसानी से विकल्प द्वारा बदले जा सकते हैं: user_dir और system_dir

ssh_client_key_api और / या ssh_server_key_api के व्यवहार का उपयोग करके कॉल-बैक मॉड्यूल लिखकर एक पूरी तरह से अलग भंडारण को ssh_server_key_api । कॉलबैक मॉड्यूल क्लाइंट और / या डेमॉन के लिए विकल्प key_cb साथ स्थापित किया गया है।

डेमॉन

कुंजी डिफ़ॉल्ट रूप से फ़ाइलों में संग्रहीत होती हैं:

  • अनिवार्य: निजी या सार्वजनिक दोनों में से एक या अधिक होस्ट कुंजी । डिफॉल्ट उन्हें डायरेक्ट्री /etc/ssh में फाइल्स में स्टोर करना है
    • ssh_host_dsa_key और ssh_host_dsa_key.pub
    • ssh_host_rsa_key और ssh_host_rsa_key.pub
    • ssh_host_ecdsa_key और ssh_host_ecdsa_key.pub

    होस्ट कुंजी निर्देशिका को विकल्प system_dir साथ बदला जा सकता है।

  • वैकल्पिक: publickey प्राधिकरण के मामले में एक या अधिक उपयोगकर्ता की सार्वजनिक कुंजी । डिफॉल्ट उपयोगकर्ता के होम डायरेक्टरी में उन्हें .ssh/authorized_keys में संगृहीत स्टोर करना है।

    उपयोगकर्ता कुंजियाँ निर्देशिका को विकल्प user_dir साथ बदला जा सकता है।

ग्राहकों

कुंजी और कुछ अन्य डेटा निर्देशिका में फ़ाइलों में संग्रहीत डिफ़ॉल्ट रूप से होते हैं। उपयोगकर्ता के घर निर्देशिका में .ssh

निर्देशिका को user_dir विकल्प के साथ बदला जा सकता है।

  • वैकल्पिक: पहले से जुड़े मेजबानों के लिए होस्ट सार्वजनिक कुंजी की सूची। यह सूची उपयोगकर्ता सहायता की आवश्यकता के बिना SSH अनुप्रयोग द्वारा नियंत्रित की जाती है। डिफ़ॉल्ट को उन्हें known_hosts फ़ाइल में संग्रहीत करना है।

    host_accepting_client_options() कुंजी की इस सूची से जुड़े हैं।

  • वैकल्पिक: publickey प्राधिकरण के मामले में एक या एक से अधिक उपयोगकर्ता की निजी कुंजी । डिफ़ॉल्ट फ़ाइलें हैं
    • id_dsa और id_dsa.pub
    • id_rsa और id_rsa.pub
    • id_ecdsa और id_ecdsa.pub

जानकारी का प्रकार

ग्राहक विकल्प

connect/3 लिए विकल्प। हाइपरलिंक का अनुसरण करके या नीचे दिए गए अलग-अलग विकल्पों को समझाया गया है।

pref_public_key_algs_client_option() =
{pref_public_key_algs, [ pubkey_alg() ]}

उपयोग करने की कोशिश करने के लिए उपयोगकर्ता (ग्राहक) सार्वजनिक कुंजी एल्गोरिदम की सूची।

डिफ़ॉल्ट मान ssh:default_algorithms/0 द्वारा दी गई सूची में public_key प्रविष्टि है ssh:default_algorithms/0

यदि कोई निर्दिष्ट प्रकार की सार्वजनिक कुंजी उपलब्ध नहीं है, तो संबंधित प्रविष्टि को अनदेखा किया जाता है। ध्यान दें कि उपलब्ध सेट अंतर्निहित क्रिप्टोलिब और वर्तमान उपयोगकर्ता की सार्वजनिक कुंजी पर निर्भर है।

उपयोगकर्ता की कुंजियों के लिए पथ निर्दिष्ट करने के लिए विकल्प user_dir भी देखें।

pubkey_passphrase_client_options() =
{dsa_pass_phrase, string()} |
{rsa_pass_phrase, string()} |
{ecdsa_pass_phrase, string()}

यदि उपयोगकर्ता का डीएसए, आरएसए या ईसीडीएसए कुंजी पासफ़्रेज़ द्वारा सुरक्षित है, तो इसे थोज़ विकल्प के साथ आपूर्ति की जा सकती है।

host_accepting_client_options() =
{silently_accept_hosts, accept_hosts() } |
{user_interaction, boolean()} |
{save_accepted_host, boolean()} |
{quiet_mode, boolean()}

accept_hosts() =
boolean() |
accept_callback() |
{HashAlgoSpec :: fp_digest_alg() , accept_callback() }

fp_digest_alg() = md5 | sha | sha224 | sha256 | sha384 | sha512
accept_callback() =
fun((PeerName :: string(), fingerprint() ) -> boolean())

fingerprint() = string() | [string()]
silently_accept_hosts

यह विकल्प connect फ़ंक्शन को निर्देशित करता है कि कैसे connect किया जाए जब जुड़ा सर्वर एक होस्ट कुंजी प्रस्तुत करता है जिसे क्लाइंट ने पहले नहीं देखा है। डिफॉल्ट यह है कि उपयोगकर्ता को नई होस्ट कुंजी को स्वीकार करने या अस्वीकार करने के stdio पर एक प्रश्न पूछना है। फ़ाइल को पथ को निर्दिष्ट करने के लिए विकल्प user_dir देखें, जिसे पहले जाना user_dir होस्ट होस्ट रिकॉर्ड किया गया है। कुंजियों को संभालने के सामान्य तरीके के लिए विकल्प key_cb भी देखें।

विकल्प तीन अलग-अलग रूपों में दिया जा सकता है जैसा कि ऊपर देखा गया है:

  • मान एक boolean() true मूल्य ग्राहक को किसी भी उपयोगकर्ता की बातचीत के बिना किसी भी अज्ञात होस्ट कुंजी को स्वीकार करेगा। मान false उपयोगकर्ता को stdio पर पूछने का व्यवहार सुरक्षित रखता है।
  • एक accept_callback() कहा जाएगा और बूलियन रिटर्न वैल्यू true होने पर क्लाइंट होस्ट होस्ट को स्वीकार करेगा। false का एक वापसी मान क्लाइंट को होस्ट कुंजी को अस्वीकार करने के लिए बनाएगा और परिणामस्वरूप कनेक्शन बंद हो जाएगा। मज़ा के तर्क हैं:
    • PeerName - रिमोट होस्ट के नाम या पते के साथ एक स्ट्रिंग।
    • फ़िंगरप्रिंट - होस्ट कुंजी का फिंगरप्रिंट public_key:ssh_hostkey_fingerprint/1 गणना करता है।
  • एक टपल {HashAlgoSpec, accept_callback} HashAlgoSpec निर्दिष्ट करता है कि कौन से हैश एल्गोरिथ्म का उपयोग accept_callback() के कॉल में प्रयुक्त फिंगरप्रिंट की गणना करने के लिए किया जाएगा। HashALgoSpec या तो atom या परमाणुओं की सूची public_key:ssh_hostkey_fingerprint/2 में पहले तर्क के रूप में है public_key:ssh_hostkey_fingerprint/2 । यदि यह हैश एल्गोरिथ्म नामों की सूची है, तो accept_callback() में फ़िंगरप्रिंट तर्क उसी क्रम में फ़िंगरप्रिंट की सूची होगी, जो HashAlgoSpec सूची में संबंधित नाम के समान है।
user_interaction

यदि false , तो क्लाइंट को सर्वर से कनेक्ट करने के लिए अक्षम करता है यदि किसी उपयोगकर्ता की सहभागिता आवश्यक है, जैसे कि सर्वर को known_hosts फ़ाइल में जोड़ा जाना स्वीकार करना, या पासवर्ड की आपूर्ति करना।

यदि उपयोगकर्ता इंटरैक्शन की अनुमति है, तो भी इसे अन्य विकल्पों द्वारा दबाया जा सकता है, जैसे कि silently_accept_hosts और password । हालांकि, उन विकल्पों को हमेशा सुरक्षा के दृष्टिकोण से उपयोग करने के लिए वांछनीय नहीं है।

true अवहेलना।

save_accepted_host

यदि true , तो क्लाइंट अगली बार उसी होस्ट से कनेक्ट होने पर स्वीकार किए जाने वाले प्रश्न से बचने के लिए एक स्वीकृत होस्ट कुंजी बचाता है। यदि विकल्प key_cb मौजूद नहीं है, तो कुंजी को "ज्ञात_होस्ट" फ़ाइल में सहेजा जाता है। उस फ़ाइल के स्थान के लिए विकल्प user_dir देखें।

यदि false , तो कुंजी सहेजी नहीं गई है और कुंजी अभी भी उसी होस्ट के अगले एक्सेस पर अज्ञात होगी।

true अवहेलना

quiet_mode

यदि true , तो क्लाइंट प्राधिकरण पर कुछ भी प्रिंट नहीं करता है।

false अवहेलना करता false

authentication_client_options() =
{user, string()} | {password, string()}

user

उपयोगकर्ता नाम प्रदान करता है। यदि यह विकल्प नहीं दिया गया है, तो ssh वातावरण से पढ़ता है ( LOGNAME पर LOGNAME या USER , Windows पर USERNAME )।

password

पासवर्ड प्रमाणीकरण के लिए एक पासवर्ड प्रदान करता है। यदि यह विकल्प नहीं दिया गया है, तो पासवर्ड प्रमाणीकरण विधि का प्रयास करने पर उपयोगकर्ता से पासवर्ड मांगा जाता है।

diffie_hellman_group_exchange_client_option() =
{dh_gex_limits,
{Min :: integer() >= 1,
I :: integer() >= 1,
Max :: integer() >= 1}}

समूह को चुनने में जुड़े सर्वर का मार्गदर्शन करने वाले तीन डिफिएरे-हेलमैन-ग्रुप-एक्सचेंज पैरामीटर सेट करता है। विवरण के लिए RFC 4419 देखें। डिफ़ॉल्ट मान {1024, 6144, 8192}

connect_timeout_client_option() = {connect_timeout, timeout()}

ट्रांसपोर्ट लेयर कनेक्ट टाइम पर टाइमआउट सेट करता है। gen_tcp लिए समय मिलि-सेकंड में है और डिफ़ॉल्ट मान infinity

बातचीत चरण के टाइमआउट के लिए connect/4 में पैरामीटर Timeout देखें।

recv_ext_info_client_option() = {recv_ext_info, boolean()}

क्लाइंट को सर्वर को बताएं कि क्लाइंट एक्सटेंशन बातचीत को स्वीकार करता है, अर्थात भेजे गए kexinit संदेश में ext-info-c शामिल करें। वर्तमान में लागू एक्सटेंशन की सूची के लिए विवरण और ssh(6) लिए RFC 8308 देखें।

डिफ़ॉल्ट मान true जो अन्य सूचनाओं के साथ संगत true जो पूर्व सूचना का समर्थन नहीं करता है।

डेमन विकल्प (सर्वर विकल्प)

daemons लिए विकल्प। हाइपरलिंक का अनुसरण करके या नीचे दिए गए अलग-अलग विकल्पों को समझाया गया है।

subsystem_daemon_option() = {subsystems, subsystem_spec() }
subsystem_spec() = {Name :: string(), mod_args() }

डेमॉन में एक सबसिस्टम को परिभाषित करता है।

subsystem_name एक ऐसा नाम है जिसे क्लाइंट उदाहरण ssh_connection:subsystem/4 साथ शुरू करने का अनुरोध करता है ssh_connection:subsystem/4

ssh_server_channel वह मॉड्यूल है जो डेमॉन में ssh_server_channel (ssh_daemon_channel) व्यवहार को लागू करता है। अधिक जानकारी और उदाहरण के लिए उपयोगकर्ता गाइड में Creating a Subsystem अनुभाग देखें।

यदि सबसिस्टम विकल्प मौजूद नहीं है, तो ssh_sftpd:subsystem_spec([]) के मान का उपयोग किया जाता है। यह डिफ़ॉल्ट रूप से sftp सबसिस्टम को सक्षम करता है। विकल्प खाली सूची पर सेट किया जा सकता है यदि आप डेमॉन को किसी भी सबसिस्टम को चलाने के लिए नहीं चाहते हैं।

shell_daemon_option() =
{shell, mod_fun_args() | 'shell_fun/1'() | 'shell_fun/2'() }

'shell_fun/1'() = fun((User :: string()) -> pid())
'shell_fun/2'() =
fun((User :: string(), PeerAddr :: inet:ip_address() ) -> pid())

क्लाइंट द्वारा एक शेल का अनुरोध किए जाने पर डेमॉन में उपयोग किए जाने वाले रीड-इवल-प्रिंट लूप को परिभाषित करता है। डिफ़ॉल्ट एर्लैंग शेल का उपयोग करना है: {shell, start, []}

शेल-और निष्पादन-विकल्पों के आधार पर डेमॉन निष्पादन-अनुरोधों को कैसे निष्पादित करता है, इसके विवरण के लिए विकल्प निष्पादित देखें।

exec_daemon_option() =
{exec, 'exec_fun/1'() | 'exec_fun/2'() | 'exec_fun/3'() }

'exec_fun/1'() = fun((Cmd :: string()) -> exec_result() )
'exec_fun/2'() =
fun((Cmd :: string(), User :: string()) -> exec_result() )

'exec_fun/3'() =
fun((Cmd :: string(),
User :: string(),
ClientAddr :: ip_port() ) ->
exec_result() )

exec_result() =
{ok, Result :: term()} | {error, Reason :: term()}

यह विकल्प बदलता है कि डेमॉन ग्राहकों से निष्पादन-अनुरोधों को कैसे निष्पादित करता है। यदि यह एक गैर-स्ट्रिंग प्रकार है, तो रिटर्न वैल्यू में इस शब्द को एक स्ट्रिंग में स्वरूपित किया जाता है। ओके-केस में कोई त्रुटि वाली अनुवर्ती न्यूलाइन नहीं जोड़ी गई है, लेकिन त्रुटि मामले में।

त्रुटि ग्रंथों को चैनल-प्रकार 1 पर लौटाया जाता है जो आमतौर पर उदाहरण के लिए लिनक्स सिस्टम पर stderr लिए पाइप किया stderr है। एक सफल निष्पादन से ग्रंथों को इसी तरह से स्टडआउट किया जाएगा। निकास-स्थिति कोड सफलता के लिए 0 और त्रुटियों के लिए -1 पर सेट है। ग्राहक पक्ष पर प्रस्तुत सटीक परिणाम ग्राहक और ग्राहक के ऑपरेटिंग सिस्टम पर निर्भर करता है।

विकल्प निम्नलिखित तरीके से डेमन-ऑप्शन shell_daemon_option() साथ सहयोग करता है:

1. यदि निष्पादन-विकल्प मौजूद है (शेल-विकल्प मौजूद हो सकता है या नहीं भी हो सकता है):

निष्पादन-विकल्प मज़ा को उसी संख्या में मापदंडों के साथ कहा जाता है, जो मज़ा की समता के रूप में है, और परिणाम क्लाइंट को वापस कर दिया जाता है।

2. यदि निष्पादन-विकल्प अनुपस्थित है, लेकिन एक शेल-विकल्प डिफ़ॉल्ट Erlang शेल के साथ मौजूद है:

डिफ़ॉल्ट Erlang मूल्यांकनकर्ता का उपयोग किया जाता है और परिणाम क्लाइंट को वापस कर दिया जाता है।

3. यदि निष्पादन-विकल्प अनुपस्थित है, लेकिन एक शेल-विकल्प मौजूद है जो डिफ़ॉल्ट एर्लैंग शेल नहीं है:

निष्पादन-अनुरोध का मूल्यांकन नहीं किया जाता है और क्लाइंट को एक त्रुटि संदेश दिया जाता है।

4. यदि न तो निष्पादन-विकल्प और न ही शेल-विकल्प मौजूद है:

डिफ़ॉल्ट Erlang मूल्यांकनकर्ता का उपयोग किया जाता है और परिणाम क्लाइंट को वापस कर दिया जाता है।

यदि एक कस्टम सीएलआई स्थापित है (विकल्प ssh_cli_daemon_option() देखें) कस्टम CLI द्वारा निहित ssh_cli_daemon_option() द्वारा प्रतिस्थापित किए गए नियम ऊपर दिए गए हैं।

ध्यान दें

निष्पादन-विकल्प लंबे समय से मौजूद है, लेकिन पहले दस्तावेज नहीं किया गया है। पुरानी परिभाषा और व्यवहार बनाए रखा जाता है, लेकिन यदि विरोधाभासी है तो 1-4 नियमों का पालन करें। नए कार्यक्रमों में पुरानी और अविवादित शैली का उपयोग नहीं किया जाना चाहिए।

ssh_cli_daemon_option() = {ssh_cli, mod_args() | no_cli}

एक डेमन में अपने सीएलआई कार्यान्वयन प्रदान करता है।

यह एक चैनल कॉलबैक मॉड्यूल है जो एक शेल और कमांड निष्पादन को लागू करता है। शेल का रीड-एवल-प्रिंट लूप विकल्प shell_daemon_option() का उपयोग करके अनुकूलित किया जा सकता है। इसका मतलब है खुद के CLI चैनल को लागू करने से कम काम। यदि ssh_cli पर सेट है, तो shell_daemon_option() और exec_daemon_option() जैसे CLI चैनल अक्षम हैं और केवल सबसिस्टम चैनल की अनुमति है।

authentication_daemon_options() =
{system_dir, string()} |
{auth_method_kb_interactive_data, prompt_texts() } |
{user_passwords, [{UserName :: string(), Pwd :: string()}]} |
{password, string()} |
{pwdfun, pwdfun_2() | pwdfun_4() }

prompt_texts() = kb_int_tuple() | kb_int_fun_3()
kb_int_tuple() =
{Name :: string(),
Instruction :: string(),
Prompt :: string(),
Echo :: boolean()}

kb_int_fun_3() =
fun((Peer :: ip_port() , User :: string(), Service :: string()) ->
kb_int_tuple() )

pwdfun_2() =
fun((User :: string(), Password :: string()) -> boolean())

pwdfun_4() =
fun((User :: string(),
Password :: string(),
PeerAddress :: ip_port() ,
State :: any()) ->
boolean() |
disconnect |
{boolean(), NewState :: any()})

system_dir

सिस्टम निर्देशिका सेट करता है, जिसमें होस्ट कुंजी फाइलें होती हैं जो ssh लिए होस्ट कीज की पहचान करती हैं। /etc/ssh लिए चूक।

सुरक्षा कारणों से, यह निर्देशिका केवल रूट उपयोगकर्ता के लिए ही सुलभ है।

कुंजियों को संभालने के सामान्य तरीके के लिए विकल्प key_cb भी देखें।

auth_method_kb_interactive_data

keyboard-interactive प्रमाणीकरण का उपयोग करते समय उपयोगकर्ता को प्रस्तुति के लिए डेमन क्लाइंट को भेजता है जो पाठ स्ट्रिंग सेट करता है।

यदि मजेदार / 3 का उपयोग किया जाता है, तो यह तब कहा जाता है जब वास्तविक प्रमाणीकरण होता है और इसलिए समय, रिमोट आईपी आदि जैसे गतिशील डेटा वापस कर सकते हैं।

पैरामीटर Echo क्लाइंट को पासवर्ड छिपाने की आवश्यकता के बारे में मार्गदर्शन करता है।

डिफ़ॉल्ट मान है: {auth_method_kb_interactive_data, {"SSH server", "Enter password for \""++User++"\"", "password: ", false}>

user_passwords

पासवर्ड प्रमाणीकरण के लिए पासवर्ड प्रदान करता है। पासवर्ड का उपयोग तब किया जाता है जब कोई सर्वर से कनेक्ट करने का प्रयास करता है और सार्वजनिक कुंजी उपयोगकर्ता-प्रमाणीकरण विफल हो जाता है। विकल्प मान्य उपयोगकर्ता नाम और संबंधित पासवर्ड की एक सूची प्रदान करता है।

password

एक वैश्विक पासवर्ड प्रदान करता है जो किसी भी उपयोगकर्ता को प्रमाणित करता है।

चेतावनी

परीक्षण की सुविधा के लिए इरादा है।

सुरक्षा के दृष्टिकोण से यह विकल्प सर्वर को बहुत कमजोर बनाता है।

pwdfun साथ pwdfun_4()

पासवर्ड सत्यापन के लिए एक फ़ंक्शन प्रदान करता है। यह हैश मान के रूप में संग्रहीत किसी बाहरी सिस्टम या पासवर्ड को कॉल करने के लिए उपयोग किया जा सकता है।

इस मज़ा का उपयोग timer:sleep/1 बनाने के लिए प्रमाणीकरण की कोशिश में देरी करने के लिए भी किया जा सकता है timer:sleep/1 कॉल करके।

उदाहरण के लिए विफल प्रयासों की गिनती की सुविधा के लिए, State चर का उपयोग किया जा सकता है। यह राज्य केवल कनेक्शन के अनुसार है। पहली बार pwdfun को एक कनेक्शन के लिए कहा जाता है, State चर में undefined मूल्य होता है।

मज़ा वापस आ जाना चाहिए:

  • true अगर उपयोगकर्ता और पासवर्ड मान्य है
  • यदि उपयोगकर्ता या पासवर्ड अमान्य है तो गलत है
  • disconnect यदि SSH_MSG_DISCONNECT संदेश तुरंत भेजा जाना चाहिए। इसके बाद अंतर्निहित टीसीपी कनेक्शन को बंद किया जाएगा।
  • {true, NewState:any()} यदि उपयोगकर्ता और पासवर्ड वैध है
  • {false, NewState:any()} यदि उपयोगकर्ता या पासवर्ड अमान्य है

तीसरा उपयोग एक मिसबिहेव करने वाले सहकर्मी से लॉगिन प्रयासों को अवरुद्ध करना है। ऊपर वर्णित State उपयोग इसके लिए किया जा सकता है। इसके लिए रिटर्न वैल्यू disconnect उपयोगी है।

pwdfun साथ pwdfun_2()

पासवर्ड सत्यापन के लिए एक फ़ंक्शन प्रदान करता है। इस फ़ंक्शन को स्ट्रिंग के रूप में उपयोगकर्ता और पासवर्ड के साथ कहा जाता है, और रिटर्न:

  • true अगर उपयोगकर्ता और पासवर्ड मान्य है
  • यदि उपयोगकर्ता या पासवर्ड अमान्य है तो गलत है

इस संस्करण को संगतता के लिए रखा गया है।

diffie_hellman_group_exchange_daemon_option() =
{dh_gex_groups,
[ explicit_group() ] |
explicit_group_file() |
ssh_moduli_file() } |
{dh_gex_limits, {Min :: integer() >= 1, Max :: integer() >= 1}}

explicit_group() =
{Size :: integer() >= 1,
G :: integer() >= 1,
P :: integer() >= 1}

explicit_group_file() = {file, string()}
ssh_moduli_file() = {ssh_moduli_file, string()}
dh_gex_groups

परिभाषित करता है कि जब सर्वर डिफीयर-हेलमैन-ग्रुप-एक्सचेंज के बीच बातचीत हो तो सर्वर उसे चुन सकता है। जानकारी के लिए RFC 4419 देखें। इस विकल्प के तीन प्रकार हैं:

{Size=integer(),G=integer(),P=integer()}
इस सूची में समूह स्पष्ट रूप से दिए गए हैं। एक ही Size साथ कई तत्व हो सकते हैं। ऐसे मामले में, सर्वर बातचीत के आकार में एक बेतरतीब ढंग से चुन लेगा।
{file,filename()}
फ़ाइल में एक या अधिक तीन-टैपल्स होना चाहिए {Size=integer(),G=integer(),P=integer()} एक बिंदु द्वारा समाप्त। जब डेमॉन शुरू होता है तो फ़ाइल पढ़ी जाती है।
{ssh_moduli_file,filename()}
फ़ाइल ssh-keygen moduli file format में होनी चाहिए। जब डेमॉन शुरू होता है तो फ़ाइल पढ़ी जाती है।

डिफ़ॉल्ट सूची public_key एप्लिकेशन से प्राप्त की public_key है।

dh_gex_limits

एक ग्राहक डिफी-हेलमैन-ग्रुप-एक्सचेंज में क्या मांग सकता है, इसे सीमित करता है। सीमाएँ {MaxUsed = min(MaxClient,Max), MinUsed = max(MinClient,Min)} MinClient जहाँ MaxClient और MinClient एक कनेक्टिंग क्लाइंट द्वारा प्रस्तावित मूल्य हैं।

डिफ़ॉल्ट मान {0,infinity}

यदि एक प्रमुख एक्सचेंज में MaxUsed < MinUsed , तो यह डिस्कनेक्ट के साथ विफल हो जाएगा।

अधिकतम और न्यूनतम मानों के कार्य के लिए RFC 4419 देखें।

negotiation_timeout_daemon_option() =
{negotiation_timeout, timeout()}

प्रमाणीकरण वार्ता के लिए मिलीसेकंड में अधिकतम समय। 120000 एमएस (2 मिनट) के लिए चूक। यदि क्लाइंट इस समय के भीतर लॉग इन करने में विफल रहता है, तो कनेक्शन बंद है।

hardening_daemon_options() =
{max_sessions, integer() >= 1} |
{max_channels, integer() >= 1} |
{parallel_login, boolean()} |
{minimal_remote_max_packet_size, integer() >= 1}

max_sessions

इस डेमॉन के लिए किसी भी समय स्वीकार किए जाने वाले सत्रों की अधिकतम संख्या। इसमें ऐसे सत्र शामिल हैं जिन्हें अधिकृत किया जा रहा है। इस प्रकार, यदि N लिए सेट किया गया N , और N क्लाइंट कनेक्ट हो गए हैं लेकिन लॉगिन प्रक्रिया शुरू नहीं की है, तो कनेक्शन का प्रयास N+1 निरस्त है यदि N कनेक्शन प्रमाणित हैं और अभी भी लॉग इन हैं, तो कोई भी अधिक लॉगिन स्वीकार नहीं किया जाता है, जब तक कि उनमें से कोई एक लॉग आउट न हो जाए।

प्रति श्रवण पोर्ट में काउंटर है। इस प्रकार, यदि दो डेमॉन शुरू किए जाते हैं, तो एक {max_sessions,N} और दूसरा {max_sessions,M} , कुल N+M कनेक्शन में पूरे ssh एप्लिकेशन के लिए स्वीकार किए जाते हैं।

ध्यान दें कि यदि parallel_login false , तो एक बार में केवल एक क्लाइंट प्रमाणीकरण चरण में हो सकता है।

डिफ़ॉल्ट रूप से, यह विकल्प सेट नहीं है। इसका मतलब है कि संख्या सीमित नहीं है।

max_channels

सक्रिय रिमोट सबसिस्टम वाले अधिकतम चैनल हैं जो इस डेमॉन के प्रत्येक कनेक्शन के लिए स्वीकार किए जाते हैं

डिफ़ॉल्ट रूप से, यह विकल्प सेट नहीं है। इसका मतलब है कि संख्या सीमित नहीं है।

parallel_login

यदि गलत (डिफ़ॉल्ट मान) पर सेट किया जाता है, तो एक समय में केवल एक लॉगिन ही संभाला जाता है। यदि यह सच है, तो एक साथ असीमित संख्या में लॉगिन प्रयास की अनुमति है।

यदि max_sessions विकल्प N सेट है और parallel_login login true सेट true , तो किसी भी समय एक साथ लॉगिन प्रयासों की अधिकतम संख्या NK तक सीमित है, जहां K इस डेमॉन में मौजूद प्रमाणीकृत कनेक्शनों की संख्या है।

चेतावनी

अन्य तरीकों से सर्वर की सुरक्षा के बिना parallel_logins को सक्षम न करें, उदाहरण के लिए, max_sessions विकल्प या फ़ायरवॉल कॉन्फ़िगरेशन द्वारा। अगर यह true , तो डॉस हमलों के खिलाफ कोई सुरक्षा नहीं है।

minimal_remote_max_packet_size

कम से कम अधिकतम पैकेट का आकार जो डेमन ग्राहक से चैनल के खुले अनुरोधों को स्वीकार करेगा। डिफॉल्यू मूल्य शून्य है।

callbacks_daemon_options() =
{failfun,
fun((User :: string(),
PeerAddress :: inet:ip_address() ,
Reason :: term()) ->
term())} |
{connectfun,
fun((User :: string(),
PeerAddress :: inet:ip_address() ,
Method :: string()) ->
term())}

connectfun

जब कोई उपयोगकर्ता सर्वर पर प्रमाणीकरण करता है, तो अपने लॉगिंग को लागू करने के लिए एक मजेदार प्रदान करता है।

failfun

जब उपयोगकर्ता प्रमाणित करने में विफल रहता है, तो अपने स्वयं के लॉगिंग को लागू करने के लिए एक मजेदार प्रदान करता है।

send_ext_info_daemon_option() = {send_ext_info, boolean()}

सर्वर (डेमन) क्लाइंट को बताएं कि सर्वर एक्सटेंशन बातचीत को स्वीकार करता है, अर्थात भेजे गए kexinit संदेश में ext-info-s शामिल करें। वर्तमान में लागू एक्सटेंशन की सूची के लिए विवरण और ssh(6) लिए RFC 8308 देखें।

डिफ़ॉल्ट मान true जो अन्य सूचनाओं के साथ संगत true जो पूर्व सूचना का समर्थन नहीं करता है।

ग्राहकों और डेमॉन के लिए आम विकल्प

उपरोक्त विकल्पों का उपयोग क्लाइंट और डेमॉन (सर्वर) दोनों में किया जा सकता है। उन्हें आगे बताया गया है।

user_dir_common_option() = {user_dir, false | string()}

उपयोगकर्ता निर्देशिका सेट करता है। वह है, निर्देशिका जो उपयोगकर्ता के लिए ssh विन्यास फाइल id_dsa , जैसे कि id_dsa , id_rsa , id_dsa >, id_ecdsa और id_ecdsa । आमतौर पर ~/.ssh रूप में संदर्भित निर्देशिका में डिफ़ॉल्ट।

कुंजियों को संभालने के सामान्य तरीके के लिए विकल्प key_cb भी देखें।

profile_common_option() = {profile, atom()}

ip-address और port साथ एक विशिष्ट ढंग से एक ssh डेमॉन की पहचान करने के लिए उपयोग किया जाता है। यह एक वर्चुअलाइज्ड वातावरण में उपयोगी हो सकता है, जहां एक से अधिक सर्वर हो सकते हैं जिनमें समान ip-address और port । यदि यह संपत्ति स्पष्ट रूप से सेट नहीं है, तो यह माना जाता है कि ip-address और port विशिष्ट रूप से SSH डेमॉन की पहचान करता है।

max_idle_time_common_option() = {idle_time, timeout()}

जब कोई चैनल सक्रिय नहीं है, तो एक कनेक्शन पर टाइम-आउट सेट करता है। infinity

rekey_limit_common_option() =
{rekey_limit,
Bytes ::
limit_bytes() |
{Minutes :: limit_time() , Bytes :: limit_bytes() }}

limit_bytes() = integer() >= 0 | infinity
limit_time() = integer() >= 1 | infinity

जब सीमा शुरू की जानी है तो सीमा निर्धारित की जाती है। डेटा का अधिकतम समय और अधिकतम राशि दोनों को कॉन्फ़िगर किया जा सकता है:

  • {Minutes, Bytes} सीमाएं {Minutes, Bytes} किसी भी सीमा तक पहुंचने पर रीगिंग शुरू करते हैं।
  • जब Bytes संख्या स्थानांतरित हो जाती हैं, या एक घंटे के बाद नवीनतम होती हैं, तो Bytes रीगिंग शुरू करते हैं।

जब एक री theकग किया जाता है, तो टाइमर और बाइट काउंटर दोनों को फिर से शुरू किया जाता है। एक घंटे और एक GByte के लिए डिफ़ॉल्ट।

यदि Minutes को infinity सेट किया infinity , तो उस अधिकतम समय के बीत जाने के कारण कोई भी पुनरावृत्ति कभी नहीं होगी। डेटा को एक निश्चित मात्रा में स्थानांतरित करने के बाद Bytes को infinity सेट करना Bytes को रोक देगा। यदि विकल्प मान को {infinity, infinity} सेट किया {infinity, infinity} , तो कोई भी पुनः आरंभ नहीं किया जाएगा। ध्यान दें कि सहकर्मी द्वारा शुरू किया गया फिर भी प्रदर्शन किया जाएगा।

key_cb_common_option() =
{key_cb,
Module :: atom() | {Module :: atom(), Opts :: [term()]}}

व्यवहार को लागू करने का मॉड्यूल ssh_client_key_api और / या ssh_server_key_api । सार्वजनिक कुंजी की हैंडलिंग को अनुकूलित करने के लिए इस्तेमाल किया जा सकता है। यदि मॉड्यूल नाम के साथ कॉलबैक विकल्प प्रदान किए जाते हैं, तो उन्हें कॉलबैक मॉड्यूल के लिए कुंजी 'key_cb_pStreet' के तहत दिए गए विकल्पों के माध्यम से उपलब्ध कराया जाता है।

Opts डिफॉल्ट करता है [] जब केवल Module निर्दिष्ट किया जाता है।

इस विकल्प का डिफ़ॉल्ट मान {ssh_file, []}

कॉल-बैक फ़ंक्शन F का कॉल होगा

Module:F(..., [{key_cb_private,Opts}|UserOptions])

जहाँ ... ssh_client_key_api में ssh_client_key_api और / या ssh_server_key_api रूप में F तर्क हैं। UserOptions विकल्प ssh:connect लिए दिए गए विकल्प हैं ssh:connect , ssh:shell या ssh:daemon

disconnectfun_common_option() =
{disconnectfun, fun((Reason :: term()) -> void | any())}

सहकर्मी के डिस्कनेक्ट होने पर अपनी लॉगिंग को लागू करने के लिए एक मजेदार प्रदान करता है।

unexpectedfun_common_option() =
{unexpectedfun,
fun((Message :: term(), {Host :: term(), Port :: term()}) ->
report | skip)}

अनपेक्षित संदेश आने पर अपनी लॉगिंग या अन्य क्रिया को कार्यान्वित करने के लिए एक मजेदार प्रदान करता है। यदि मजेदार रिटर्न report करता है तो सामान्य जानकारी रिपोर्ट जारी की जाती है लेकिन अगर skip जाता है तो कोई रिपोर्ट उत्पन्न नहीं होती है।

ssh_msg_debug_fun_common_option() =
{ssh_msg_debug_fun,
fun(( ssh:connection_ref() ,
AlwaysDisplay :: boolean(),
Msg :: binary(),
LanguageTag :: binary()) ->
any())}

SSH संदेश SSH_MSG_DEBUG के अपने लॉगिंग को लागू करने के लिए एक मजेदार प्रदान करें। अंतिम तीन पैरामीटर संदेश से हैं, RFC 4253, section 11.3 । कनेक्शन_ connection_ref() उस कनेक्शन का संदर्भ है जिस पर संदेश आया था। मज़ा से वापसी मूल्य की जाँच नहीं की जाती है।

डिफ़ॉल्ट व्यवहार संदेश को अनदेखा कर रहा है। AlwaysDisplay = true साथ प्रत्येक संदेश के लिए एक प्रिंटआउट प्राप्त करने के लिए, उदाहरण के लिए {ssh_msg_debug_fun, fun(_,true,M,_)-> io:format("DEBUG: ~p~n", [M]) end}

id_string_common_option() =
{id_string,
string() |
random |
{random, Nmin :: integer() >= 1, Nmax :: integer() >= 1}}

स्ट्रिंग डेमन शुरू में एक कनेक्टिंग पीयर को प्रस्तुत करेगा। डिफ़ॉल्ट मान "Erlang / VSN" है जहां VSN ssh एप्लिकेशन संस्करण संख्या है।

मूल्य random प्रत्येक कनेक्शन के प्रयास में एक यादृच्छिक स्ट्रिंग का निर्माण होगा। यह एक दुर्भावनापूर्ण सहकर्मी के लिए ssh सॉफ़्टवेयर ब्रांड और संस्करण को खोजने के लिए थोड़ा अधिक कठिन बनाना है।

मान {random, Nmin, Nmax} कम से कम Nmin वर्ण और अधिकांश Nmax वर्णों के साथ एक यादृच्छिक स्ट्रिंग बना देगा।

preferred_algorithms_common_option() =
{preferred_algorithms, algs_list() }

algs_list() = [ alg_entry() ]
alg_entry() =
{kex, [ kex_alg() ]} |
{public_key, [ pubkey_alg() ]} |
{cipher, double_algs ( cipher_alg() )} |
{mac, double_algs ( mac_alg() )} |
{compression, double_algs ( compression_alg() )}

kex_alg() =
'diffie-hellman-group-exchange-sha1' |
'diffie-hellman-group-exchange-sha256' |
'diffie-hellman-group1-sha1' |
'diffie-hellman-group14-sha1' |
'diffie-hellman-group14-sha256' |
'diffie-hellman-group16-sha512' |
'diffie-hellman-group18-sha512' |
'ecdh-sha2-nistp256' |
'ecdh-sha2-nistp384' |
'ecdh-sha2-nistp521'

pubkey_alg() =
'ecdsa-sha2-nistp256' |
'ecdsa-sha2-nistp384' |
'ecdsa-sha2-nistp521' |
'rsa-sha2-256' |
'rsa-sha2-512' |
'ssh-dss' |
'ssh-rsa'

cipher_alg() =
'3des-cbc' |
'AEAD_AES_128_GCM' |
'AEAD_AES_256_GCM' |
'aes128-cbc' |
'aes128-ctr' |
'[email protected]' |
'aes192-ctr' |
'aes256-ctr' |
'[email protected]'

mac_alg() =
'AEAD_AES_128_GCM' |
'AEAD_AES_256_GCM' |
'hmac-sha1' |
'hmac-sha2-256' |
'hmac-sha2-512'

compression_alg() = none | zlib | '[email protected]'
double_algs(AlgType) =
[{client2server, [AlgType]} | {server2client, [AlgType]}] |
[AlgType]

एल्गोरिथ्म वार्ता में उपयोग करने के लिए एल्गोरिदम की सूची। डिफ़ॉल्ट algs_list() ssh:default_algorithms/0 से प्राप्त किया जा सकता है।

यदि alg_entry () algs_list () में गुम है, तो उस प्रविष्टि के लिए डिफ़ॉल्ट मान का उपयोग किया जाता है।

यहाँ इस विकल्प का एक उदाहरण है:

{preferred_algorithms, 
[{public_key,['ssh-rsa','ssh-dss']},
{cipher,[{client2server,['aes128-ctr']},
          {server2client,['aes128-cbc','3des-cbc']}]},
{mac,['hmac-sha2-256','hmac-sha1']},
{compression,[none,zlib]}
]
}

उदाहरण सिफर के लिए दो दिशाओं (क्लाइंट 2 ऑवर और सर्वर 2 क्लिएंट) में अलग-अलग एल्गोरिदम को निर्दिष्ट करता है, लेकिन दोनों दिशाओं में मैक और संपीड़न के लिए एक ही एल्गोरिदम को निर्दिष्ट करता है। Kex (कुंजी विनिमय) निहित है, लेकिन public_key स्पष्ट रूप से सेट है।

पृष्ठभूमि और अधिक उदाहरणों के लिए User's Guide

यदि किसी सूची में एक एल्गोरिथ्म नाम एक से अधिक बार होता है, तो व्यवहार अपरिभाषित होता है। संपत्ति की सूचियों में टैग को भी एक समय में होने वाली माना जाता है।

चेतावनी

मूल्यों को बदलने से कनेक्शन कम सुरक्षित हो सकता है। तब तक न बदलें जब तक आपको पता न हो कि आप क्या कर रहे हैं। यदि आप मूल्यों को नहीं समझते हैं तो आप उन्हें बदलने वाले नहीं हैं।

modify_algorithms_common_option() =
{modify_algorithms, modify_algs_list() }

modify_algs_list() =
[{append, algs_list() } |
{prepend, algs_list() } |
{rm, algs_list() }]

एल्गोरिथ्म वार्ता में उपयोग करने के लिए एल्गोरिदम की सूची को संशोधित करता है। विकल्प preferred_algorithms (यदि मौजूदा है) लागू होने के बाद संशोधनों को लागू किया जाता है।

संशोधनों के लिए इस तरह काम करता है:

  • इनपुट modify_algs_list() और एल्गोरिदम का एक सेट है, जो modify_algs_list() विकल्प से प्राप्त किया जाता है यदि मौजूदा है, या फिर ssh:default_algorithms/0

  • modify_algs_list() का सिर A को परिणाम A'

    संभावित संशोधन हैं:

    • समर्थित या प्रीपेंड समर्थित लेकिन एल्गोरिदम की सूची में सक्षम एल्गोरिदम (ओं) को नहीं। यदि पहले से ही वांछित एल्गोरिदम A में हैं, तो उन्हें पहले हटा दिया जाएगा और उसके बाद जोड़ा जाएगा या पहले से रखा जाएगा।

    • A से A या अधिक एल्गोरिदम निकालें (rm)।

  • मॉडिफिकेशन स्टेप को modify_algs_list() और परिणामस्वरूप A' की पूंछ के साथ दोहराएं।

यदि एक असमर्थित एल्गोरिथ्म modify_algs_list() , तो इसे चुपचाप नजरअंदाज कर दिया जाएगा

यदि एक से अधिक संशोधित_ एल्गोरिदम विकल्प हैं, तो परिणाम अपरिभाषित है।

यहाँ इस विकल्प का एक उदाहरण है:

{modify_algorithms, 
[{prepend, [{kex, ['diffie-hellman-group1-sha1']}],
{rm,      [{compression, [none]}]}
]
}

उदाहरण निर्दिष्ट करता है कि:

  • पुरानी कुंजी एक्सचेंज एल्गोरिथ्म 'डिफी-हेलमैन-ग्रुप1-श 1' मुख्य विकल्प होना चाहिए। यह मुख्य विकल्प होगा क्योंकि यह सूची के लिए तैयार है

  • कम्प्रेशन अल्गोरिदम कोई भी (= कोई कम्प्रेशन नहीं) निकाला जाता है ताकि कम्प्रेशन लागू हो

पृष्ठभूमि और अधिक उदाहरणों के लिए User's Guide

inet_common_option() = {inet, inet | inet6}

जब होस्ट पता निर्दिष्ट किया जाता है, तो उपयोग करने के लिए आईपी संस्करण।

auth_methods_common_option() = {auth_methods, string()}

कॉमा-सेपरेटेड स्ट्रिंग जो यह निर्धारित करती है कि क्लाइंट किन प्रमाणीकरण विधियों का समर्थन करेगा और किस क्रम में उनका प्रयास किया जाएगा। "publickey,keyboard-interactive,password" लिए डिफ़ॉल्ट

ध्यान दें कि ग्राहक किसी भी आदेश का उपयोग करने और विधियों को बाहर करने के लिए स्वतंत्र है।

fd_common_option() = {fd, gen_tcp:socket() }

एक मौजूदा फ़ाइल-डिस्क्रिप्टर का उपयोग करने की अनुमति देता है (परिवहन प्रोटोकॉल पर पारित)।

अन्य डेटा प्रकार

host() = string() | inet:ip_address() | loopback
ip_port() = { inet:ip_address() , inet:port_number() }
mod_args() = {Module :: atom(), Args :: list()}
mod_fun_args() =
{Module :: atom(), Function :: atom(), Args :: list()}

open_socket() = gen_tcp:socket()

सॉकेट को एक gen_tcp:connect का परिणाम माना जाता है gen_tcp:connect या एक gen_tcp:accept । सॉकेट निष्क्रिय मोड में होना चाहिए (अर्थात, विकल्प {active,false}) साथ खोला गया {active,false})

daemon_ref()

अपारदर्शी डेटा प्रकार एक डेमन का प्रतिनिधित्व करता है।

फ़ंक्शन daemon/1,2,3 द्वारा लौटाया गया।

connection_ref ()

एक ग्राहक और एक सर्वर (डेमन) के बीच संबंध का प्रतिनिधित्व करने वाला अपारदर्शी डेटा प्रकार।

फ़ंक्शन द्वारा लौटाए गए connect/2,3,4 और ssh_sftp:start_channel/2,3

channel_id()

एक कनेक्शन के अंदर एक चैनल का प्रतिनिधित्व करने वाला अपारदर्शी डेटा प्रकार।

फ़ंक्शन द्वारा लौटाया गया ssh_connection:session_channel/2,4

opaque_client_options
opaque_daemon_options
opaque_common_options

अपारदर्शी प्रकार जो प्रयोगात्मक विकल्पों को परिभाषित करते हैं जो उत्पादों में उपयोग नहीं किए जाते हैं।

निर्यात

बंद (ConnectionRef) -> ठीक | {त्रुटिपूर्ण शर्त()}

प्रकार

एक SSH कनेक्शन बंद कर देता है।

कनेक्ट (होस्ट, पोर्ट, विकल्प) -> परिणाम
कनेक्ट (होस्ट, पोर्ट, विकल्प, बातचीत का समय) -> परिणाम
कनेक्ट (TcpSocket, विकल्प) -> परिणाम
कनेक्ट (TcpSocket, Options, NegotiationTimeout) -> परिणाम

प्रकार

Port पर Host में एक SSH सर्वर से जोड़ता है।

एक विकल्प के रूप में, टीसीपी सॉकेट में पहले से ही खुले टीसीपी सॉकेट को फंक्शन में पास किया जा सकता है। SSH दीक्षा और बातचीत उस SSH के साथ शुरू की जाएगी जो दूसरे छोर पर होनी चाहिए।

कोई चैनल शुरू नहीं हुआ है। यह ssh_connection:session_channel/2,4 कहकर किया जाता है।

NegotiationTimeout टाइमआउट मिली-सेकंड में है। डिफ़ॉल्ट मान infinity । कनेक्शन टाइमआउट के लिए, connect_timeout_client_option() विकल्प का उपयोग करें।

connection_info (ConnectionRef, Keys) -> ConnectionInfo

प्रकार

एक कनेक्शन के बारे में जानकारी प्राप्त करता है। सूची Keys परिभाषित करती है कि कौन सी जानकारी वापस आ गई है।

डेमॉन (पोर्ट | TcpSocket) -> परिणाम
डेमन (पोर्ट | TcpSocket, विकल्प) -> परिणाम
डेमन (HostAddress, पोर्ट, विकल्प) -> परिणाम

प्रकार

दिए गए पोर्ट पर SSH कनेक्शन के लिए सुनने वाला सर्वर शुरू करता है। यदि Port 0 है, तो एक यादृच्छिक मुक्त पोर्ट चयनित है। चयनित पोर्ट नंबर को खोजने के तरीके के बारे में daemon_info/1 देखें।

एक विकल्प के रूप में, टीसीपी सॉकेट में पहले से ही खुले टीसीपी सॉकेट को फंक्शन में पास किया जा सकता है। SSH दीक्षा और बातचीत उस पर शुरू की जाएगी जब एक SSH TCP सॉकेट के दूसरे छोर पर शुरू होता है।

विकल्पों के विवरण के लिए, Daemon Options देखें।

कृपया ध्यान दें कि ऐतिहासिक कारणों से दोनों HostAddress तर्क और gen_tcp connect_option() {ip,Address} सुनने का पता सेट करते हैं। यह संभव असंगत सेटिंग्स का एक स्रोत है।

दो पते पासिंग विकल्प को संभालने के नियम हैं:

  • अगर HostAddress एक IP- पता है, तो वह IP- पता सुनने वाला पता है। यदि मौजूद है तो एक 'ip'-option को छोड़ दिया जाएगा।
  • यदि HostAddress परमाणु loopback , तो सुनने का पता loopback और एक लूपबैक पता अंतर्निहित परतों द्वारा चुना जाएगा। यदि मौजूद है तो एक 'ip'-option को छोड़ दिया जाएगा।
  • अगर HostAddress परमाणु है और कोई 'ip' विकल्प मौजूद नहीं है, तो सुनने का पता any और सॉकेट सभी पते को सुनेगा
  • यदि HostAddress any और एक 'ip' विकल्प मौजूद है, तो सुनने का पता 'ip'- विकल्प के मान पर सेट है।
Daemon_info (Daemon) -> {ठीक है, DaemonInfo} | {त्रुटिपूर्ण शर्त()}

प्रकार

डेमन के बारे में जानकारी के साथ एक कुंजी-मूल्य सूची देता है।

default_algorithms () -> algs_list()

एक कुंजी-मूल्य सूची लौटाता है, जहाँ कुंजियाँ विभिन्न प्रकार के एल्गोरिदम हैं और मान स्वयं एल्गोरिदम हैं।

एक उदाहरण के लिए User's Guide देखें।

शेल (होस्ट | TcpSocket) -> परिणाम
शेल (होस्ट | TcpSocket, विकल्प) -> परिणाम
शेल (होस्ट, पोर्ट, विकल्प) -> परिणाम

प्रकार

Host और Port पर एक SSH सर्वर से Host (22 को डिफ़ॉल्ट) और उस दूरस्थ होस्ट पर एक इंटरैक्टिव शेल शुरू करता है।

एक विकल्प के रूप में, टीसीपी सॉकेट में पहले से ही खुले टीसीपी सॉकेट को फंक्शन में पास किया जा सकता है। SSH दीक्षा और बातचीत उस पर शुरू की जाएगी और अंतिम रूप से टीसीपी सॉकेट के दूसरे छोर पर मेजबान पर एक शेल शुरू किया जाएगा।

विकल्पों के विवरण के लिए, Client Options देखें।

फ़ंक्शन उपयोगकर्ता इनपुट की प्रतीक्षा करता है, और जब तक रिमोट शेल समाप्त नहीं होता है (यानी शेल से बाहर निकलें) वापस नहीं आता है।

start () -> ठीक है | {त्रुटिपूर्ण शर्त()}
start (प्रकार) -> ठीक | {त्रुटिपूर्ण शर्त()}

प्रकार

उपयोगिता फ़ंक्शन जो अनुप्रयोगों को crypto , public_key , और ssh शुरू करता है। डिफ़ॉल्ट प्रकार temporary । अधिक जानकारी के लिए, कर्नेल में application(3) मैनुअल पेज देखें।

रोक () -> ठीक है | {त्रुटिपूर्ण शर्त()}

ssh एप्लिकेशन को रोकता है। अधिक जानकारी के लिए, कर्नेल में application(3) मैनुअल पेज देखें।

stop_daemon (DaemonRef :: daemon_ref() ) -> ठीक है
stop_daemon (पता :: inet:ip_address() ,
पोर्ट :: inet:port_number() ) ->
ठीक
stop_daemon (पता :: कोई भी | inet:ip_address() ,
पोर्ट :: inet:port_number() ,
प्रोफ़ाइल :: परमाणु ()) ->
ठीक

श्रोता को रोकता है और श्रोता द्वारा शुरू किए गए सभी कनेक्शन।

stop_listener (SysSup :: daemon_ref() ) -> ठीक है
stop_listener (पता :: inet:ip_address() ,
पोर्ट :: inet:port_number() ) ->
ठीक
stop_listener (पता :: कोई भी | inet:ip_address() ,
पोर्ट :: inet:port_number() ,
प्रोफ़ाइल :: शब्द ()) ->
ठीक

श्रोता को रोकता है, लेकिन मौजूदा कनेक्शन को श्रोता परिचालन द्वारा शुरू करता है।