Erlang 21

crypto




erlang

crypto

मॉड्यूल

क्रिप्टो

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

क्रिप्टो कार्य

विवरण

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

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

key_value() = integer() | binary() 

हमेशा binary() जब वापसी मूल्य के रूप में उपयोग किया जाता है

rsa_public() = [key_value()] = [E, N]  

जहां E सार्वजनिक प्रतिपादक है और N सार्वजनिक मापांक है।

rsa_private() = [key_value()] = [E, N, D] | [E, N, D, P1, P2, E1, E2, C] 

जहाँ E सार्वजनिक प्रतिपादक है, N सार्वजनिक मापांक है और D निजी प्रतिपादक है। लंबे कुंजी प्रारूप में निरर्थक सूचनाएँ होती हैं जो गणना को तेज़ बनाती हैं। पी 1, पी 2 पहले और दूसरे प्रमुख कारक हैं। ई 1, ई 2 पहले और दूसरे एक्सपोर्टर हैं। C CRT गुणांक है। शब्दावली RFC 3447 से ली गई है।

dss_public() = [key_value()] = [P, Q, G, Y] 

जहां P, Q और G dss पैरामीटर हैं और Y सार्वजनिक कुंजी है।

dss_private() = [key_value()] = [P, Q, G, X] 

जहां P, Q और G dss पैरामीटर हैं और X निजी कुंजी है।

srp_public() = key_value() 

SRP design से A या B कहां है

srp_private() = key_value() 

जहाँ SRP design से a या b है

जहाँ वेरीफ़ायर v , जेनरेटर g और प्राइम N , डेरिवेडके X , और SRP design संस्करण = '3' से स्क्रैम्बलर u (वैकल्पिक प्रदान नहीं होने पर उत्पन्न होगा)। '6' | '6a'

dh_public() = key_value() 
dh_private() = key_value() 
dh_params() = [key_value()] = [P, G] | [P, G, PrivateKeyBitLength]
ecdh_public() = key_value() 
ecdh_private() = key_value() 
ecdh_params() = ec_named_curve() | ec_explicit_curve()
ec_explicit_curve() =
    {ec_field(), Prime :: key_value(), Point :: key_value(), Order :: integer(),
     CoFactor :: none | integer()} 
ec_field() = {prime_field, Prime :: integer()} |
    {characteristic_two_field, M :: integer(), Basis :: ec_basis()}
ec_basis() = {tpbasis, K :: non_neg_integer()} |
    {ppbasis, K1 :: non_neg_integer(), K2 :: non_neg_integer(), K3 :: non_neg_integer()} |
    onbasis
ec_named_curve() ->
      sect571r1| sect571k1| sect409r1| sect409k1| secp521r1| secp384r1| secp224r1| secp224k1|
      secp192k1| secp160r2| secp128r2| secp128r1| sect233r1| sect233k1| sect193r2| sect193r1|
      sect131r2| sect131r1| sect283r1| sect283k1| sect163r2| secp256k1| secp160k1| secp160r1|
      secp112r2| secp112r1| sect113r2| sect113r1| sect239k1| sect163r1| sect163k1| secp256r1|
      secp192r1|
      brainpoolP160r1| brainpoolP160t1| brainpoolP192r1| brainpoolP192t1| brainpoolP224r1|
      brainpoolP224t1| brainpoolP256r1| brainpoolP256t1| brainpoolP320r1| brainpoolP320t1|
      brainpoolP384r1| brainpoolP384t1| brainpoolP512r1| brainpoolP512t1

ध्यान दें कि संप्रदाय घटता GF2m (दो विशेषता) घटता है और केवल समर्थित है यदि अंतर्निहित OpenSSL उनके लिए समर्थन है। crypto:supports/0 भी देखें crypto:supports/0

engine_key_ref() = #{engine   := engine_ref(),
                               key_id   := key_id(),
                               password => password()}
engine_ref() = term()

engine_load/3 कॉल का परिणाम।

key_id() = string() | binary()

उपयोग की जाने वाली कुंजी की पहचान करता है। प्रारूप लोड इंजन पर निर्भर करता है। यह ENGINE_load_(private|public)_key में ENGINE_load_(private|public)_key कार्यों के लिए दिया जाता है।

password() = string() | binary()

कुंजी का पासवर्ड

stream_cipher() = rc4 | aes_ctr 
block_cipher() = aes_cbc | aes_cfb8 | aes_cfb128 | aes_ige256 | blowfish_cbc |
     blowfish_cfb64 | des_cbc | des_cfb | des3_cbc | des3_cfb | des_ede3 | rc2_cbc 
aead_cipher() = aes_gcm | chacha20_poly1305 
stream_key() = aes_key() | rc4_key() 
block_key() = aes_key() |  blowfish_key() | des_key()| des3_key() 
aes_key() = iodata() 

मुख्य लंबाई 128, 192 या 256 बिट्स है

rc4_key() = iodata() 

2048 बिट्स (आमतौर पर 40 और 256 के बीच) 8 बिट्स से परिवर्तनीय कुंजी लंबाई

blowfish_key() = iodata() 

32 बिट्स से 448 बिट्स तक चर कुंजी लंबाई

des_key() = iodata() 

मुख्य लंबाई 64 बिट्स है (CBC मोड में केवल 8 बिट्स का उपयोग किया जाता है)

des3_key() = [binary(), binary(), binary()] 

प्रत्येक प्रमुख भाग 64 बिट्स है (CBC मोड में केवल 8 बिट्स का उपयोग किया जाता है)

digest_type() =  md5 | sha | sha224 | sha256 | sha384 | sha512
rsa_digest_type() = md5 | ripemd160 | sha | sha224 | sha256 | sha384 | sha512
dss_digest_type() = sha | sha224 | sha256 | sha384 | sha512

ध्यान दें कि वास्तविक समर्थित dss_digest_type अंतर्निहित क्रिप्टो लाइब्रेरी पर निर्भर करता है। OpenSSL संस्करण में = = 1.0.1 सूचीबद्ध डाइजेस्ट समर्थित हैं, जबकि 1.0.0 में केवल sha, sha224 और sha256 समर्थित हैं। संस्करण 0.9.8 में केवल शा समर्थित है।

ecdsa_digest_type() = sha | sha224 | sha256 | sha384 | sha512
sign_options() = [{rsa_pad, rsa_sign_padding()} | {rsa_pss_saltlen, integer()}]
rsa_sign_padding() = rsa_pkcs1_padding | rsa_pkcs1_pss_padding
hash_algorithms() =  md5 | ripemd160 | sha | sha224 | sha256 | sha384 | sha512 

md4 hash_init / 1 और hash / 2 के लिए भी समर्थित है। ध्यान दें कि md4 और md5 दोनों को केवल मौजूदा अनुप्रयोगों के साथ संगतता के लिए अनुशंसित किया गया है।

cipher_algorithms() = aes_cbc | aes_cfb8 | aes_cfb128 | aes_ctr | aes_gcm |
    aes_ige256 | blowfish_cbc | blowfish_cfb64 | chacha20_poly1305 | des_cbc |
    des_cfb | des3_cbc | des3_cfb | des_ede3 | rc2_cbc | rc4 
mac_algorithms() = hmac | cmac
public_key_algorithms() = rsa |dss | ecdsa | dh | ecdh | ec_gf2m

ध्यान दें कि ec_gf2m कड़ाई से एक सार्वजनिक कुंजी एल्गोरिथ्म नहीं है, लेकिन जो वक्र curds ecdsa और ecdh के साथ समर्थित हैं, उस पर प्रतिबंध है।

engine_method_type() = engine_method_rsa | engine_method_dsa | engine_method_dh |
     engine_method_rand | engine_method_ecdh | engine_method_ecdsa |
     engine_method_ciphers | engine_method_digests | engine_method_store |
     engine_method_pkey_meths | engine_method_pkey_asn1_meths

निर्यात

block_encrypt (Type, Key, PlainText) -> CipherText

प्रकार

Type ब्लॉक साइफर के अनुसार PlainText एन्क्रिप्ट करें।

अंतर्निहित OpenSSL कार्यान्वयन द्वारा समर्थित Type मामले में अपवाद notsup को फेंक दिया जा सकता है।

block_decrypt (Type, Key, CipherText) -> PlainText

प्रकार

Type ब्लॉक सिफर के अनुसार CipherText डिक्रिप्ट करें।

अंतर्निहित OpenSSL कार्यान्वयन द्वारा समर्थित Type मामले में अपवाद notsup को फेंक दिया जा सकता है।

block_encrypt (Type, Key, Ivec, PlainText) -> CipherText
block_encrypt (AeadType, Key, Ivec, {AAD, PlainText}) -> {CipherText, CipherTag}
block_encrypt (anes_gcm, Key, Ivec, {AAD, PlainText, TagLength}) -> {CipherText, CipherTag}

प्रकार

Type ब्लॉक साइफर के अनुसार PlainText एन्क्रिप्ट करें। IVec एक मनमाना प्रारंभिक वेक्टर है।

AEAD (एसोसिएटेड डेटा के साथ प्रमाणित एन्क्रिप्शन) मोड में, Type ब्लॉक सिफर के अनुसार PlainText को एन्क्रिप्ट करें और CipherTag गणना CipherTag जो AAD (एसोसिएटेड ऑथेंटिकेटेड डेटा) को प्रमाणित करता है।

अंतर्निहित OpenSSL कार्यान्वयन द्वारा समर्थित Type मामले में अपवाद notsup को फेंक दिया जा सकता है।

block_decrypt (Type, Key, Ivec, CipherText) -> सादा पाठ
block_decrypt (AeadType, Key, Ivec, {AAD, CipherText, CipherTag}) -> PlainText | त्रुटि

प्रकार

Type ब्लॉक सिफर के अनुसार CipherText डिक्रिप्ट करें। IVec एक मनमाना प्रारंभिक वेक्टर है।

AEAD (एसोसिएटेड डेटा के साथ प्रमाणित एन्क्रिप्शन) मोड में, Type ब्लॉक ब्लॉक सिफर के अनुसार CipherText को डिक्रिप्ट करें और PlainText का उपयोग करके PlainText और AAD (एसोसिएटेड प्रमाणित डेटा) की प्रामाणिकता की CipherTag । यदि डिक्रिप्शन या सत्यापन विफल रहता है तो error वापस कर सकते हैं

अंतर्निहित OpenSSL कार्यान्वयन द्वारा समर्थित Type मामले में अपवाद notsup को फेंक दिया जा सकता है।

बाइट्स_तो_इन्टेगर (बिन) -> पूर्णांक

प्रकार

बाइनरी प्रतिनिधित्व को एक पूर्णांक में, एक अर्लंग पूर्णांक में परिवर्तित करें।

compute_key (टाइप करें, OthersPublicKey, MyKey, Params) -> SharedSecret

प्रकार

निजी कुंजी और अन्य पार्टी की सार्वजनिक कुंजी से साझा रहस्य की गणना करता है। यह भी देखें public_key:compute_key/2

exor (Data1, Data2) -> परिणाम

प्रकार

आपूर्ति किए गए डेटा पर बिट-वार XOR (अनन्य या) करता है।

generate_key (प्रकार, परम) -> {PublicKey, PrivKeyOut}
Gener_key (प्रकार, परम, PrivKeyIn) -> {PublicKey, PrivKeyOut}

प्रकार

प्रकार की एक सार्वजनिक कुंजी Type । यह भी देखें public_key:generate_key/1 वर्ग error अपवाद को फेंक सकते हैं:

  • badarg : एक तर्क गलत प्रकार का है या उसका अवैध मूल्य है,
  • low_entropy : सुरक्षित "यादृच्छिकता" की कमी के कारण यादृच्छिक जनरेटर विफल हो गया,
  • computation_failed : कम्प्यूटेशन low_entropy अलावा किसी अन्य कारण से विफल हो जाता है।
ध्यान दें

RSA कुंजी पीढ़ी केवल तभी उपलब्ध है जब रनटाइम को गंदे शेड्यूलर समर्थन के साथ बनाया गया था। अन्यथा, आरएसए कुंजी उत्पन्न करने का प्रयास अपवाद error:notsup को फेंक देगा error:notsup

हैश (प्रकार, डेटा) -> डाइजेस्ट

प्रकार

Data से टाइप के संदेश को पचाता है।

अंतर्निहित OpenSSL कार्यान्वयन द्वारा समर्थित Type मामले में अपवाद notsup को फेंक दिया जा सकता है।

hash_init (प्रकार) -> संदर्भ

प्रकार

हैश संचालन स्ट्रीमिंग के लिए संदर्भ को प्रारंभ करता है। Type निर्धारित करता है कि कौन सा उपयोग करने के लिए पचता है लौटे संदर्भ को hash_update तर्क के रूप में उपयोग किया जाना चाहिए।

अंतर्निहित OpenSSL कार्यान्वयन द्वारा समर्थित Type मामले में अपवाद notsup को फेंक दिया जा सकता है।

hash_update (संदर्भ, डेटा) -> NewContext

प्रकार

दिए गए Data का उपयोग करके Context द्वारा दर्शाए गए पाचन को अद्यतन करता है। इस फ़ंक्शन के लिए hash_init या पिछले कॉल का उपयोग करके Context उत्पन्न किया गया होगा। Data किसी भी लम्बाई का हो सकता है। NewContext को hash_update या hash_final के अगले कॉल में पास किया जाना चाहिए।

हैश_फाइनल (संदर्भ) -> डाइजेस्ट

प्रकार

अंतिम ऑपरेशन से संदर्भित हैश ऑपरेशन को hash_update लिए पिछले कॉल से hash_update Digest का आकार इसे उत्पन्न करने के लिए उपयोग किए जाने वाले हैश फ़ंक्शन के प्रकार से निर्धारित होता है।

hmac (प्रकार, कुंजी, डेटा) -> मैक
hmac (प्रकार, कुंजी, डेटा, MacLength) -> मैक

प्रकार

प्रमाणीकरण कुंजी के रूप में Key का उपयोग करके Data से प्रकार के एक HMAC की गणना करता है।

MacLength परिणामी Mac के आकार को सीमित करेगी।

hmac_init (प्रकार, कुंजी) -> संदर्भ

प्रकार

HMAC संचालन स्ट्रीमिंग के लिए संदर्भ को प्रारंभ करता है। Type निर्धारित करता है कि HMAC ऑपरेशन में किस हैश फ़ंक्शन का उपयोग करना है। Key प्रमाणीकरण कुंजी है। कुंजी किसी भी लंबाई हो सकती है।

hmac_update (संदर्भ, डेटा) -> NewContext

प्रकार

दिए गए Data का उपयोग करके Context द्वारा एचएमएसी को अद्यतन करता है। Context HMAC init फ़ंक्शन (जैसे hmac_init ) का उपयोग करके उत्पन्न किया गया होगा। Data किसी भी लम्बाई का हो सकता है। NewContext को hmac_update या hmac_final और hmac_final_n से किसी एक कार्य के लिए अगली कॉल में पारित किया जाना चाहिए

चेतावनी

Hmac_update या hmac_final को एक से अधिक कॉल में तर्क के रूप में एक Context उपयोग न करें। किसी भी तरह से पुराने संदर्भों के पुन: उपयोग के शब्दार्थ अपरिभाषित हैं और इससे पहले के विमोचन में भी वीएम दुर्घटनाग्रस्त हो सकता है। इस सीमा का कारण अंतर्निहित ओपनएसएसएल एपीआई में समर्थन की कमी है।

hmac_final (संदर्भ) -> मैक

प्रकार

Context द्वारा संदर्भित एचएमएसी ऑपरेशन को अंतिम रूप देता है। परिणामी मैक का आकार इसे उत्पन्न करने के लिए उपयोग किए जाने वाले हैश फ़ंक्शन के प्रकार से निर्धारित होता है।

hmac_final_n (संदर्भ, हैशलेन) -> मैक

प्रकार

Context द्वारा संदर्भित एचएमएसी ऑपरेशन को अंतिम रूप देता है। HashLen शून्य से अधिक होना चाहिए। Mac सबसे HashLen बाइट्स के साथ एक द्विआधारी होगा। ध्यान दें कि यदि हैशलेन अंतर्निहित हैश से लौटे बाइट्स की वास्तविक संख्या से अधिक है, तो लौटे हैश के पास HashLen बाइट्स से कम होगा।

cmac (प्रकार, कुंजी, डेटा) -> मैक
cmac (टाइप, की, डेटा, मैकलेरंग) -> मैक

प्रकार

प्रमाणीकरण कुंजी के रूप में Key का उपयोग करके Data से प्रकार के एक CMAC की गणना करता है।

MacLength परिणामी Mac के आकार को सीमित करेगी।

info_fips () -> स्थिति

प्रकार

क्रिप्टो की अंतर्निहित परिचालन स्थिति और अंतर्निहित ओपनएसएसएल पुस्तकालय के बारे में जानकारी प्रदान करता है। यदि क्रिप्टो को FIPS समर्थन के साथ बनाया गया था, तो इसे या तो enabled किया जा सकता है (जब FIPS मोड में चल रहा है) या not_enabled । अन्य बिल्ड के लिए यह मान हमेशा not_supported

चेतावनी

FIPS मोड में सभी गैर- not_supported एल्गोरिथ्म अक्षम होते हैं और अपवाद not_supported फेंक देते हैं। चेक crypto:supports/0 कि दान मोड में उपलब्ध एल्गोरिदम की प्रतिबंधित सूची देता है।

info_lib () -> [{नाम, VerNum, VerStr}]

प्रकार

क्रिप्टो द्वारा उपयोग किए जाने वाले पुस्तकालयों का नाम और संस्करण प्रदान करता है।

Name पुस्तकालय का Name है। VerNum पुस्तकालय की अपनी संस्करण योजना के अनुसार संख्यात्मक संस्करण है। VerStr में संस्करण का एक पाठ संस्करण है।

> info_lib().
[{<<"OpenSSL">>,269484095,<<"OpenSSL 1.1.0c  10 Nov 2016"">>}]
        
ध्यान दें

OTP R16 से सांख्यिक संस्करण OpenSSL हेडर फ़ाइलों के संस्करण का प्रतिनिधित्व करता है (क्रिप्टो संकलित किए जाने पर इस्तेमाल किया जाता है) पाठ संस्करण रनटाइम में उपयोग की जाने वाली ओपनएसएसएल लाइब्रेरी का प्रतिनिधित्व करता है। पहले के OTP संस्करणों में संख्यात्मक और पाठ दोनों को लाइब्रेरी से लिया गया था।

mod_pow (एन, पी, एम) -> परिणाम

प्रकार

फ़ंक्शन की गणना करता है N^P mod M M।

next_iv (प्रकार, डेटा) -> NextIVec
next_iv (प्रकार, डेटा, IVec) -> NextIVec

प्रकार

प्रकार के एन्क्रिप्ट / डिक्रिप्ट के अगले पुनरावृत्ति में उपयोग किए जाने वाले प्रारंभिक वेक्टर को लौटाता है। Data पिछले चलना कदम से एन्क्रिप्टेड डेटा है। IVec तर्क केवल des_cfb लिए आवश्यक है क्योंकि वेक्टर पिछले पुनरावृत्ति चरण में उपयोग किया जाता है।

Private_decrypt (Type, CipherText, PrivateKey, Padding) -> प्लेनटेक्स्ट

प्रकार

PrivateKey का उपयोग करते हुए public_encrypt/4 (या समतुल्य फ़ंक्शन) के साथ एन्क्रिप्टेड CipherText का CipherText , और CipherText (संदेश पचा) देता है। यह एसएसएल प्रोटोकॉल के पुराने संस्करणों द्वारा उदाहरण के लिए उपयोग किया जाने वाला एक निम्न स्तरीय हस्ताक्षर सत्यापन ऑपरेशन है। public_key:decrypt_private/[2,3] भी देखें public_key:decrypt_private/[2,3]

privkey_to_pubkey (प्रकार, इंजनपेयरकेयर रीफ) -> PublicKey

प्रकार

एक इंजन में संग्रहीत एक निजी कुंजी से संबंधित सार्वजनिक कुंजी प्राप्त करता है। कुंजी टाइप पैरामीटर द्वारा इंगित प्रकार की होनी चाहिए।

Private_encrypt (Type, PlainText, PrivateKey, Padding) -> सिफरटेक्स्ट

प्रकार

PlainText का आकार byte_size(N)-11 से कम होना चाहिए यदि rsa_pkcs1_padding का उपयोग किया जाता है, और byte_size(N) यदि rsa_no_padding का उपयोग किया जाता है, जहां N RSA कुंजी का सार्वजनिक मापांक है।

PrivateKey का उपयोग करके PlainText को PlainText करता है और सिफरटेक्स्ट देता है। यह एक निम्न स्तर का हस्ताक्षर ऑपरेशन है जिसका उपयोग एसएसएल प्रोटोकॉल के पुराने संस्करणों द्वारा किया जाता है। यह भी देखें public_key:encrypt_private/[2,3]

public_decrypt (Type, CipherText, PublicKey, Padding) -> सादा पाठ

प्रकार

CipherText का CipherText , PrivateKey का उपयोग करके private_encrypt/4 (या समतुल्य फ़ंक्शन) के साथ एन्क्रिप्ट किया गया और private_encrypt/4 (संदेश पचा) देता है। यह एसएसएल प्रोटोकॉल के पुराने संस्करणों द्वारा उदाहरण के लिए उपयोग किया जाने वाला एक निम्न स्तरीय हस्ताक्षर सत्यापन ऑपरेशन है। यह भी देखें public_key:decrypt_public/[2,3]

public_encrypt (Type, PlainText, PublicKey, Padding) -> सिफरटेक्स्ट

प्रकार

PlainText का आकार byte_size(N)-11 से कम होना चाहिए यदि rsa_pkcs1_padding का उपयोग किया जाता है, और byte_size(N) यदि rsa_no_padding का उपयोग किया जाता है, जहां N RSA कुंजी का सार्वजनिक मापांक है।

PlainText का उपयोग करके PlainText (संदेश पचा) को PublicKey और PublicKey देता है। यह एक निम्न स्तर का हस्ताक्षर ऑपरेशन है जिसका उपयोग एसएसएल प्रोटोकॉल के पुराने संस्करणों द्वारा किया जाता है। public_key:encrypt_public/[2,3] भी देखें public_key:encrypt_public/[2,3]

rand_seed (बीज) -> ठीक है

प्रकार

दिए गए बाइनरी को PRNG के लिए बीज सेट करें। यह खुलता से RAND_seed फ़ंक्शन को कॉल करता है। इसका उपयोग केवल तभी करें जब आप जिस सिस्टम पर चल रहे हैं, उसमें पर्याप्त "यादृच्छिकता" नहीं है। आम तौर पर ऐसा तब strong_rand_bytes/1 है जब strong_rand_bytes/1 low_entropy फेंकता है

रैंड_निफ़ॉर्म (लो, हाय) -> एन

प्रकार

एक यादृच्छिक संख्या N, Lo =< N < Hi. उत्पन्न करें N, Lo =< N < Hi. crypto लाइब्रेरी छद्म यादृच्छिक संख्या जनरेटर का उपयोग करता है। Hi Lo से बड़ा होना चाहिए।

संकेत (एल्गोरिथम, डाइजेस्ट टाइप, Msg, की) -> बाइनरी ()
संकेत (एल्गोरिथम, डाइजेस्ट टाइप, एमएसजी, कुंजी, विकल्प) -> बाइनरी ()

प्रकार

संदेश या तो द्विआधारी "क्लीयरटेक्स्ट" डेटा है जिस पर हस्ताक्षर किया जाना है या यह "क्लीटेक्स्ट" का हैशेड मान है जो पाचन (प्लेटेक्स्ट) है।

एक डिजिटल हस्ताक्षर बनाता है।

एलगोरिदम dss उपयोग केवल डाइजेस्ट टाइप sha साथ ही किया जा सकता है।

public_key:sign/3 भी देखें public_key:sign/3

start () -> ठीक है

आवेदन के बराबर: प्रारंभ (क्रिप्टो)।

रोक () -> ठीक है

आवेदन के बराबर: स्टॉप (क्रिप्टो)।

strong_rand_bytes (N) -> बाइनरी ()

प्रकार

एन बाइट्स को बेतरतीब ढंग से समान 0..255 उत्पन्न करता है, और एक द्विआधारी में परिणाम देता है। क्रिप्टोग्राफिक रूप से सुरक्षित प्रिंग बोया गया और समय-समय पर प्रदान की गई ऑपरेटिंग सिस्टम के साथ मिश्रित का उपयोग करता है। डिफ़ॉल्ट रूप से यह ओपनएसएसएल से RAND_bytes विधि है।

रैंडम जनरेटर के सुरक्षित "अभाव" के अभाव में रैंडम जेनरेटर विफल होने की स्थिति में अपवाद को फेंक दें।

rand_seed () -> rand: state ()

क्रिप्टोग्राफिक रूप से मजबूत यादृच्छिक संख्या (ओपनएसएसएल की BN_rand_range पर आधारित) उत्पन्न करने के लिए, random number generation लिए राज्य वस्तु बनाता है, और इसे वापस करने से पहले इसे प्रक्रिया शब्दकोश में सहेजता है। rand:seed/1 भी देखें rand:seed/1 और rand_seed_s/0

इस फ़ंक्शन से राज्य ऑब्जेक्ट का उपयोग करते समय rand फ़ंक्शंस का उपयोग करते हुए अपवाद को फेंक सकता है यदि सुरक्षित "यादृच्छिकता" की कमी के कारण यादृच्छिक जनरेटर विफल हो गया।

उदाहरण

_ = crypto:rand_seed(),
_IntegerValue = rand:uniform(42), % [1; 42]
_FloatValue = rand:uniform().     % [0.0; 1.0[
rand_seed_s () -> rand: state ()

क्रिप्टोग्राफिक रूप से दृढ़ता से रैंडम नंबर (ओपनएसएसएल के BN_rand_range आधार पर) उत्पन्न करने के लिए, random number generation लिए राज्य वस्तु बनाता है। rand:seed_s/1 भी देखें rand:seed_s/1

इस फ़ंक्शन से राज्य ऑब्जेक्ट का उपयोग करते समय rand फ़ंक्शंस का उपयोग करते हुए अपवाद को फेंक सकता है यदि सुरक्षित "यादृच्छिकता" की कमी के कारण यादृच्छिक जनरेटर विफल हो गया।

ध्यान दें

इस फ़ंक्शन से लौटाए गए राज्य का उपयोग अन्य rand फ़ंक्शंस के रूप में एक पुन: प्रयोज्य यादृच्छिक अनुक्रम प्राप्त करने के लिए नहीं किया जा सकता है, क्योंकि पुन: प्रयोज्य क्रिप्टोग्राफिक रूप से सुरक्षित से मेल नहीं खाता है।

एकमात्र समर्थित उपयोग इस प्रारंभ स्थिति से एक अलग यादृच्छिक अनुक्रम उत्पन्न करना है।

rand_seed_alg (Alg) -> रैंड: राज्य ()

प्रकार

क्रिप्टोग्राफिक रूप से मजबूत यादृच्छिक संख्या उत्पन्न करने के लिए random number generation लिए राज्य वस्तु बनाता है। rand:seed/1 भी देखें rand:seed/1 और rand_seed_alg_s/1

इस फ़ंक्शन से राज्य ऑब्जेक्ट का उपयोग करते समय rand फ़ंक्शंस का उपयोग करते हुए अपवाद को फेंक सकता है यदि सुरक्षित "यादृच्छिकता" की कमी के कारण यादृच्छिक जनरेटर विफल हो गया।

crypto app's कॉन्फ़िगरेशन पैरामीटर rand_cache_size crypto app's उपयोग करके इसके डिफ़ॉल्ट मान से कैश आकार को बदला जा सकता है।

उदाहरण

_ = crypto:rand_seed_alg(crypto_cache),
_IntegerValue = rand:uniform(42), % [1; 42]
_FloatValue = rand:uniform().     % [0.0; 1.0[
rand_seed_alg_s (Alg) -> रैंड: राज्य ()

प्रकार

क्रिप्टोग्राफिक रूप से दृढ़ता से यादृच्छिक संख्या उत्पन्न करने के लिए random number generation लिए राज्य वस्तु बनाता है। rand:seed_s/1 भी देखें rand:seed_s/1

अगर Alg crypto यह फ़ंक्शन बिल्कुल rand_seed_s/0 तरह व्यवहार करता है।

अगर Alg crypto_cache यह फ़ंक्शन OpenSSL के RAND_bytes साथ यादृच्छिक डेटा प्राप्त करता है और 56 बिट्स के आंतरिक शब्द आकार का उपयोग करके गति के लिए इसे कैश करता है जो 64 बिट मशीनों पर तेजी से गणना करता है।

इस फ़ंक्शन से राज्य ऑब्जेक्ट का उपयोग करते समय rand फ़ंक्शंस का उपयोग करते हुए अपवाद को फेंक सकता है यदि सुरक्षित "यादृच्छिकता" की कमी के कारण यादृच्छिक जनरेटर विफल हो गया।

crypto app's कॉन्फ़िगरेशन पैरामीटर rand_cache_size crypto app's उपयोग करके इसके डिफ़ॉल्ट मान से कैश आकार को बदला जा सकता है।

ध्यान दें

इस फ़ंक्शन से लौटाए गए राज्य का उपयोग अन्य rand फ़ंक्शंस के रूप में एक पुन: प्रयोज्य यादृच्छिक अनुक्रम प्राप्त करने के लिए नहीं किया जा सकता है, क्योंकि पुन: प्रयोज्य क्रिप्टोग्राफिक रूप से सुरक्षित से मेल नहीं खाता है।

वास्तव में चूंकि यादृच्छिक डेटा को कैश किया जाता है इसलिए यदि आप कोशिश करते हैं तो कुछ संख्याओं को पुन: प्राप्त किया जा सकता है, लेकिन यह अप्रत्याशित है।

एकमात्र समर्थित उपयोग इस प्रारंभ स्थिति से एक अलग यादृच्छिक अनुक्रम उत्पन्न करना है।

stream_init (प्रकार, कुंजी) -> राज्य

प्रकार

RC4 स्ट्रीम एन्क्रिप्शन में उपयोग के लिए राज्य को प्रारंभ करता है stream_encrypt और stream_decrypt

stream_init (प्रकार, कुंजी, IVec) -> राज्य

प्रकार

काउंटर मोड (CTR) का उपयोग करके AES एन्क्रिप्शन स्ट्रीमिंग में उपयोग के लिए राज्य को प्रारंभ करता है। Key AES कुंजी है और यह 128, 192 या 256 बिट लंबी होनी चाहिए। IVec 128 बिट्स (16 बाइट्स) का एक मनमाना प्रारंभिक वेक्टर है। यह राज्य stream_encrypt और stream_decrypt साथ उपयोग के लिए है।

stream_encrypt (राज्य, सादा पाठ) -> {NewState, CipherText}

प्रकार

स्ट्रीम सेफर Type अनुसार PlainText को PlainText करता है। Text बाइट्स की कोई भी संख्या हो सकती है। प्रारंभिक State stream_init का उपयोग करके बनाया stream_init stream_encrypt को stream_encrypt को अगली कॉल में पारित किया जाना चाहिए।

stream_decrypt (स्थिति, CipherText) -> {NewState, PlainText}

प्रकार

स्ट्रीम सिफर में निर्दिष्ट सिफर Type अनुसार प्रयास CipherText / 3/3 में। PlainText किसी भी संख्या में बाइट्स हो सकते हैं। प्रारंभिक State stream_init का उपयोग करके बनाया stream_init stream_decrypt को stream_decrypt के अगले कॉल में पास किया जाना चाहिए।

समर्थन () -> एल्गोरिथ्मिस्ट

प्रकार

यह निर्धारित करने के लिए इस्तेमाल किया जा सकता है कि अंतर्निहित ओपनएसएसएल पुस्तकालय द्वारा समर्थित कौन से क्रिप्टो एल्गोरिदम हैं

ec_curves () -> एलिप्टिकचुरवेलिस्ट

प्रकार

यह निर्धारित करने के लिए इस्तेमाल किया जा सकता है कि किस नाम के अण्डाकार वक्र का समर्थन किया गया है।

ec_curve (NamedCurve) -> एलिप्टिकचुरवे

प्रकार

एक अण्डाकार वक्र के परिभाषित मापदंडों को वापस करें।

सत्यापित करें (एल्गोरिथम, डाइजेस्ट टाइप, संदेश, हस्ताक्षर, कुंजी) -> बूलियन ()
सत्यापित करें (एल्गोरिथम, डाइजेस्ट टाइप, Msg, हस्ताक्षर, कुंजी, विकल्प) -> बूलियन ()

प्रकार

संदेश या तो द्विआधारी "क्लीयरटेक्स्ट" डेटा है या यह "क्लीटेक्स्ट" का डाइजेस्ट मूल्य है (यानी डाइजेस्टेक्स)।

एक डिजिटल हस्ताक्षर सत्यापित करता है

एलगोरिदम dss उपयोग केवल डाइजेस्ट टाइप sha साथ ही किया जा सकता है।

public_key:verify/4 भी देखें public_key:verify/4

engine_get_all_methods () -> परिणाम

प्रकार

सभी संभावित इंजन विधियों की सूची लौटाता है।

अंतर्निहित OpenSSL कार्यान्वयन में कोई इंजन समर्थन नहीं होने की स्थिति में अपवाद को फेंक दें।

उपयोगकर्ता गाइड में अध्याय Engine Load भी देखें।

इंजन_लोड (EngineId, PreCmds, PostCmds) -> परिणाम

प्रकार

यदि उपलब्ध है तो EngineId द्वारा दिए गए OpenSSL इंजन को लोड करता है और फिर ओके और एक इंजन हैंडल को लौटाता है। यह फ़ंक्शन सभी संभावित तरीकों की सूची में सेट किए गए EngineMethods साथ EngineMethods करने के लिए engine_load/4 के EngineMethods । यदि इंजन लोड नहीं किया जा सकता है तो एक त्रुटि टपल लौटाया जाता है।

यदि पैरामीटर गलत प्रारूप में हैं, तो फ़ंक्शन एक बैगर को फेंकता है। अंतर्निहित OpenSSL कार्यान्वयन में कोई इंजन समर्थन नहीं होने की स्थिति में यह अपवाद नोटस को भी फेंक सकता है।

उपयोगकर्ता गाइड में अध्याय Engine Load भी देखें।

Engine_load (EngineId, PreCmds, PostCmds, EngineMethods) -> परिणाम

प्रकार

यदि उपलब्ध है तो EngineId द्वारा दिए गए OpenSSL इंजन को लोड करता है और फिर ओके और एक इंजन हैंडल को लौटाता है। यदि इंजन लोड नहीं किया जा सकता है तो एक त्रुटि टपल लौटाया जाता है।

यदि पैरामीटर गलत प्रारूप में हैं, तो फ़ंक्शन एक बैगर को फेंकता है। अंतर्निहित OpenSSL कार्यान्वयन में कोई इंजन समर्थन नहीं होने की स्थिति में यह अपवाद नोटस को भी फेंक सकता है।

उपयोगकर्ता गाइड में अध्याय Engine Load भी देखें।

engine_unload (इंजन) -> परिणाम

प्रकार

EngineId द्वारा दिए गए OpenSSL इंजन को EngineId । यदि इंजन अनलोड नहीं किया जा सकता है तो एक त्रुटि टपल लौटाया जाता है।

यदि पैरामीटर गलत प्रारूप में है, तो फ़ंक्शन एक बैगर को फेंकता है। अंतर्निहित OpenSSL कार्यान्वयन में कोई इंजन समर्थन नहीं होने की स्थिति में यह अपवाद नोटस को भी फेंक सकता है।

उपयोगकर्ता गाइड में अध्याय Engine Load भी देखें।

इंजन_सूची () -> परिणाम

प्रकार

OpenSSL की आंतरिक सूची में सभी इंजनों की आईडी सूचीबद्ध करें।

अंतर्निहित OpenSSL कार्यान्वयन में कोई इंजन समर्थन नहीं होने की स्थिति में यह अपवाद नोटस को भी फेंक सकता है।

उपयोगकर्ता गाइड में अध्याय Engine Load भी देखें।

engine_ctrl_cmd_string (इंजन, CmdName, CmdArg) -> परिणाम

प्रकार

इंजन द्वारा दिए गए OpenSSL इंजन को ctrl कमांड भेजता है। यह फ़ंक्शन कॉल करने के लिए समान है जैसे कि engine_ctrl_cmd_string/4 false लिए Optional सेट के साथ।

यदि पैरामीटर गलत प्रारूप में हैं, तो फ़ंक्शन एक बैगर को फेंकता है। अंतर्निहित OpenSSL कार्यान्वयन में कोई इंजन समर्थन नहीं होने की स्थिति में यह अपवाद नोटस को भी फेंक सकता है।

engine_ctrl_cmd_string (इंजन, CmdName, CmdArg, वैकल्पिक)> परिणाम

प्रकार

इंजन द्वारा दिए गए OpenSSL इंजन को ctrl कमांड भेजता है। Optional एक बूलियन तर्क है जो फ़ंक्शन के शब्दार्थ को शांत कर सकता है। यदि यह true तो यह केवल असफलता लौटाएगा यदि इंजन दिए गए कमांड नाम का समर्थन करता है, लेकिन इसे निष्पादित करते समय विफल रहा है, अगर इंजन कमांड नाम का समर्थन नहीं करता है तो यह बस कुछ भी किए बिना सफलता लौटाएगा। इस मामले में हम मानते हैं कि उपयोगकर्ता केवल दिए गए इंजन के लिए विशिष्ट कमांड की आपूर्ति कर रहा है, इसलिए हम इसे false सेट false

यदि पैरामीटर गलत प्रारूप में हैं, तो फ़ंक्शन एक बैगर को फेंकता है। अंतर्निहित OpenSSL कार्यान्वयन में कोई इंजन समर्थन नहीं होने की स्थिति में यह अपवाद नोटस को भी फेंक सकता है।