Erlang 21 - 3. Using SSL application API

3 एसएसएल एप्लिकेशन एपीआई का उपयोग करना




erlang

3 एसएसएल एप्लिकेशन एपीआई का उपयोग करना

Ssl के लिए प्रासंगिक संस्करण जानकारी देखने के लिए, ssl को कॉल करें ssl:versions/0

सभी समर्थित सिफर सुइट्स को देखने के लिए, ssl:cipher_suites(all) कॉल करें। कनेक्शन के लिए उपलब्ध सिफर सूट आपके प्रमाणपत्र पर निर्भर करता है। विशिष्ट सिफर सूट जो आप चाहते हैं कि आपके कनेक्शन का उपयोग भी निर्दिष्ट किया जा सकता है। डिफ़ॉल्ट उपलब्ध सबसे मजबूत का उपयोग करना है।

3.1 कनेक्शन स्थापित करना

यह खंड इरलांग शेल का उपयोग करके क्लाइंट / सर्वर कनेक्शन कैसे सेट करें, इसका एक छोटा सा उदाहरण दिखाता है। sslsocket का लौटा हुआ मान संक्षिप्त रूप में [...] क्योंकि यह काफी बड़ा हो सकता है और अपारदर्शी है।

न्यूनतम उदाहरण

ध्यान दें

न्यूनतम सेटअप SSL / TLS / DTLS का सबसे सुरक्षित सेटअप नहीं है।

क्लाइंट / सर्वर कनेक्शन सेट करने के लिए:

चरण 1: सर्वर पक्ष प्रारंभ करें:

1 server> ssl:start().
ok

चरण 2: एक TLS सुनो सॉकेट बनाएं: (DTLS विकल्प को जोड़ने के लिए {प्रोटोकॉल, dtls} जोड़ें)

2 server> {ok, ListenSocket} =
ssl:listen(9999, [{certfile, "cert.pem"}, {keyfile, "key.pem"},{reuseaddr, true}]).
{ok,{sslsocket, [...]}}

चरण 3: टीएलएस सुनने वाले सॉकेट पर परिवहन स्वीकार करें:

3 server> {ok, TLSTransportSocket} = ssl:transport_accept(ListenSocket).
{ok,{sslsocket, [...]}}

चरण 4: ग्राहक पक्ष शुरू करें:

1 client> ssl:start().
ok

DTLS चलाने के लिए तीसरे तर्क में विकल्प {प्रोटोकॉल, dtls} जोड़ें।

2 client> {ok, Socket} = ssl:connect("localhost", 9999,  [], infinity).
{ok,{sslsocket, [...]}}

चरण 5: टीएलएस हैंडशेक करें:

4 server> {ok, Socket} = ssl:handshake(TLSTransportSocket).
ok

चरण 6: TLS पर एक संदेश भेजें:

5 server> ssl:send(Socket, "foo").
ok

चरण 7: संदेश संदेश कतार को यह देखने के लिए प्रवाहित करें कि संदेश सर्वर पर भेजा गया था:

3 client> flush().
Shell got {ssl,{sslsocket,[...]},"foo"}
ok

अपग्रेड उदाहरण - केवल टीएलएस

ध्यान दें

एक SSL कनेक्शन के लिए टीसीपी / आईपी कनेक्शन को अपग्रेड करने के लिए, क्लाइंट और सर्वर को ऐसा करने के लिए सहमत होना चाहिए। एक प्रोटोकॉल का उपयोग करके समझौते को पूरा किया जा सकता है, उदाहरण के लिए, HTTP द्वारा उपयोग किया गया RFC 2817 में निर्दिष्ट।

SSL कनेक्शन अपग्रेड करने के लिए:

चरण 1: सर्वर पक्ष प्रारंभ करें:

1 server> ssl:start().
ok

चरण 2: एक सामान्य टीसीपी सुन सॉकेट बनाएं:

2 server> {ok, ListenSocket} = gen_tcp:listen(9999, [{reuseaddr, true}]).
{ok, #Port<0.475>}

चरण 3: ग्राहक कनेक्शन स्वीकार करें:

3 server> {ok, Socket} = gen_tcp:accept(ListenSocket).
{ok, #Port<0.476>}

चरण 4: ग्राहक पक्ष शुरू करें:

1 client> ssl:start().
ok
2 client> {ok, Socket} = gen_tcp:connect("localhost", 9999,  [], infinity).

चरण 5: सुनिश्चित करें कि किसी SSL कनेक्शन से कनेक्शन अपग्रेड करने की कोशिश करने से पहले active को false सेट कर दिया जाए, अन्यथा SSL हैंडशेक संदेशों को गलत प्रक्रिया तक पहुंचाया जा सकता है:

4 server> inet:setopts(Socket, [{active, false}]).
ok

चरण 6: टीएलएस हैंडशेक करें:

5 server> {ok, TLSSocket} = ssl:handshake(Socket, [{cacertfile, "cacerts.pem"},
{certfile, "cert.pem"}, {keyfile, "key.pem"}]).
{ok,{sslsocket,[...]}}

चरण 7: एक टीएलएस कनेक्शन का उन्नयन। क्लाइंट और सर्वर को अपग्रेड पर सहमत होना चाहिए। क्लाइंट को ssl:connect/3. से पहले सर्वर को ssl:handshake/2 को कॉल करना होगा ssl:connect/3.

3 client>{ok, TLSSocket} = ssl:connect(Socket, [{cacertfile, "cacerts.pem"},
{certfile, "cert.pem"}, {keyfile, "key.pem"}], infinity).
{ok,{sslsocket,[...]}}

चरण 8: TLS पर एक संदेश भेजें:

4 client> ssl:send(TLSSocket, "foo").
ok

चरण 9: टीएलएस सॉकेट पर active true सेट करें:

4 server> ssl:setopts(TLSSocket, [{active, true}]).
ok

चरण 10: शेल संदेश कतार को यह देखने के लिए प्रवाहित करें कि ग्राहक की ओर से संदेश भेजा गया था:

5 server> flush().
Shell got {ssl,{sslsocket,[...]},"foo"}
ok

3.2 सिफर सूट का अनुकूलन

TLS / DTLS संस्करण के लिए डिफ़ॉल्ट सिफर सुइट सूची प्राप्त करें। सभी संभव सिफर सुइट प्राप्त करने के लिए सभी में डिफ़ॉल्ट बदलें।

1>  Default = ssl:cipher_suites(default, 'tlsv1.2').
    [#{cipher => aes_256_gcm,key_exchange => ecdhe_ecdsa,
    mac => aead,prf => sha384}, ....]

OTP 20 में rsa kexchange का उपयोग करने वाले सभी सिफर सुइट्स को हटाना वांछनीय है (21 में डिफ़ॉल्ट रूप से हटाया गया)

2> NoRSA =
    ssl:filter_cipher_suites(Default,
                            [{key_exchange, fun(rsa) -> false;
			                       (_) -> true end}]).
    [...]

बस कुछ ही सुइट्स चुनें

 3> Suites =
    ssl:filter_cipher_suites(Default,
                            [{key_exchange, fun(ecdh_ecdsa) -> true;
     (_) -> false end},
                             {cipher, fun(aes_128_cbc) ->true;
(_) ->false end}]).
    [#{cipher => aes_128_cbc,key_exchange => ecdh_ecdsa,
     mac => sha256,prf => sha256},
     #{cipher => aes_128_cbc,key_exchange => ecdh_ecdsa,mac => sha,
     prf => default_prf}]

कुछ विशेष सूटों को सबसे पसंदीदा, या कम से कम पसंदीदा बनाकर प्रीपेन्ड में बदल कर बनाना चाहिए।

4>ssl:prepend_cipher_suites(Suites, Default).
 [#{cipher => aes_128_cbc,key_exchange => ecdh_ecdsa,
    mac => sha256,prf => sha256},
  #{cipher => aes_128_cbc,key_exchange => ecdh_ecdsa,mac => sha,
    prf => default_prf},
  #{cipher => aes_256_cbc,key_exchange => ecdhe_ecdsa,
    mac => sha384,prf => sha384}, ...]

3.3 एक इंजन संग्रहीत कुंजी का उपयोग करना

Erlang ssl एप्लिकेशन OpenSSL इंजन द्वारा दिए गए निजी कुंजी को निम्न तंत्र का उपयोग करने में सक्षम है:

1> ssl:start().
ok

एक क्रिप्टो इंजन को लोड करें, उपयोग किए गए इंजन के अनुसार एक बार किया जाना चाहिए। उदाहरण के लिए गतिशील रूप से MyEngine नामक इंजन को लोड करें:

2> {ok, EngineRef} =
crypto:engine_load(<<"dynamic">>,
                   [{<<"SO_PATH">>, "/tmp/user/engines/MyEngine"},<<"LOAD">>],[]).
{ok,#Ref<0.2399045421.3028942852.173962>}

इंजन की जानकारी और इंजन द्वारा उपयोग किए जाने वाले एल्गोरिदम के साथ एक नक्शा बनाएँ:

3> PrivKey =
 #{algorithm => rsa,
   engine => EngineRef,
   key_id => "id of the private key in Engine"}.

Ssl कुंजी विकल्प में मानचित्र का उपयोग करें:

4> {ok, SSLSocket} =
ssl:connect("localhost", 9999,
            [{cacertfile, "cacerts.pem"},
             {certfile, "cert.pem"},
             {key, PrivKey}], infinity).

crypto documentation भी देखें