Share
Scopul principal al unei semnături digitale este de a verifica integritatea unor informații. Pentru un exemplu simplu, să presupunem că ați avut un fișier care a fost transferat prin rețea și doriți să verificați dacă întregul fișier a fost transferat corect. În acest caz, ați utiliza o sumă de control.
"O sumă de control este un punct de mărime mic derivat dintr-un bloc de date digitale în scopul detectării erorilor care ar fi putut fi introduse în timpul transmisiei sau stocării" - Wikipedia
Cum obținem acel sumă de control? Cea mai bună opțiune este utilizarea unui hash. O funcție hash va lua o cantitate variabilă de date și va scoate o semnătură de lungime fixă. De exemplu, am putea publica un fișier împreună cu hash-ul său online. Când cineva descarcă fișierul, poate executa aceeași funcție de hash pe versiunea lor a fișierului și poate compara rezultatul. Dacă hash-urile sunt aceleași, atunci fișierul copiat sau descărcat este același ca și originalul.
Un hash este, de asemenea, o funcție unică. Având în vedere rezultatul rezultat, nu există nicio modalitate fezabilă de a inversa acel hash pentru a arăta ce a fost intrarea inițială. SHA, Secure Hash Algorithm, este un standard binecunoscut care se referă la un grup de funcții hash care au această proprietate și anumite altele, ceea ce le face utile pentru semnăturile digitale.
SHA a suferit numeroase iterații de când a fost publicată pentru prima oară. Prima și a doua iterație, SHA-0 și SHA-1, sunt acum cunoscute ca având puncte slabe majore. Ele nu mai sunt aprobate pentru implementările de securitate: în general, acestea nu ar trebui să fie utilizate pentru aplicații bazate pe securitate. Cu toate acestea, familia SHA-2 include versiuni denumite SHA-256 și SHA-512, acestea fiind considerate sigure. "256" și "512" se referă pur și simplu la numărul rezultat de biți produsi. Pentru acest tutorial, vom folosi SHA-512.
Notă: Un alt algoritm popular al hash-ului a fost MD5. Sa constatat, de asemenea, că au defecte semnificative.
Utilizarea SHA este excelentă pentru a verifica dacă datele au fost corupte accidental, dar acest lucru nu împiedică utilizatorul rău intenționat să manipuleze datele. Dat fiind faptul că o ieșire hash are o dimensiune fixă, tot ce trebuie să facă un atacator este să dai seama care algoritm a fost folosit având în vedere dimensiunea de ieșire, să modifice datele și să recompute hașul. Ceea ce avem nevoie este o informație secretă adăugată amestecului atunci când hashes datele, astfel încât atacatorul nu poate recompune hash fără cunoașterea secretului. Acest lucru se numește un cod de autentificare a mesajelor Hash (HMAC).
HMAC poate autentifica o informație sau un mesaj pentru a se asigura că a provenit de la expeditorul corect și că informațiile nu au fost modificate. Un scenariu comun este când discutați cu un server cu un API back-end pentru aplicația dvs. Poate fi important să vă autentificați pentru a vă asigura că numai aplicația dvs. are voie să vorbească cu API-ul. API ar avea controlul accesului la o anumită resursă, cum ar fi / register_user punct final. Clientul ar trebui să facă acest lucru semn cererea sa către / register_user pentru a putea folosi cu succes.
Atunci când semnați o solicitare, este o practică obișnuită să preluați anumite părți ale cererii, cum ar fi parametrii POST și adresa URL, și să le îmbinați împreună într-un șir. Luarea de elemente convenite și punerea lor într-o anumită ordine este chemată canonicalization. În HMAC, șirul îmbinat este șters împreună cu cheia secretă pentru a produce semnătură. În loc să-i numim un hash, folosim termenul semnătura în același mod în care semnătura unei persoane în viața reală este folosită pentru a verifica identitatea sau integritatea. Semnătura este adăugată înapoi la solicitarea clientului ca antet de solicitare (de obicei denumit și "Semnătură"). O semnătură este numită uneori un mesaj digest, dar cei doi termeni pot fi utilizați în mod interschimbabil.
Pe partea API, serverul repetă procesul de îmbinare a șirurilor și crearea unei semnături. Dacă semnăturile se potrivesc, dovedește că aplicația trebuie să dețină secretul. Aceasta dovedește identitatea aplicației. Întrucât parametrii specifici ai cererii au făcut parte, de asemenea, din șirul care urmează să fie semnat, garantează, de asemenea, integritatea cererii. Împiedică un atacator să efectueze un atac de tip "man-in-the-middle", de exemplu, și să modifice parametrii solicitării în funcție de preferințele lor.
Accentsconagua
class function hmacExample () // Unele exemple de adrese URL ... permiteți urlString = "https://example.com" lasă postString = "id = 123" permite url = URL.init (string: urlString) var request = URLRequest (url: url!) request.httpMethod = "POST" request.httpBody = postString.data (folosind: .utf8) let session = URLSession.shared // Creați o semnătură lasă stringToSign = request.httpMethod! + "&" + urlString + "&" + postString print ("Șirul de semnat este:", stringToSign) dacă permiteți dataToSign = stringToSign.data (folosind :.utf8) let signingSecret = "4kDfjgQhcw4dG6J80QnvRFbtuJfkgitH6phkLN90" if let signingSecretData = signingSecret .data (folosind: .utf8) lasa digestLength = Int (CC_SHA512_DIGEST_LENGTH) lasa digestBytes = UnsafeMutablePointer.alocați (capacitate: digestLength) CCHmac (CCHmacAlgorithm (kCCHmacAlgSHA512), [UInt8] (signingSecretData), signingSecretData.count, [UInt8] (dataToSign), dataToSign.count, digestBytes) count: digestLength) permite semnătura = hmacData.base64EncodedString () print ("Semnătura HMAC în base64 este" + signature) // sau ieșire HEX lasă hexString = NSMutableString () pentru i în 0 ... În acest cod, CCHmac funcția are un parametru pentru tipul de funcție hash care va fi folosit, împreună cu două șiruri de octeți și lungimile lor - mesajul și o cheie secretă. Pentru cea mai bună securitate, utilizați cel puțin o cheie de 256 biți (32 de octeți), generată de un generator de numere aleatoare securizate criptografic. Pentru a verifica dacă totul funcționează corect pe cealaltă parte, executați exemplul, apoi introduceți cheia secretă și mesajul de pe acest server la distanță și verificați dacă ieșirea este aceeași.
De asemenea, puteți adăuga un antet de timbru la șirul de solicitare și semnare pentru a face cererea mai unică. Acest lucru poate ajuta API să elimine atacurile de replay. De exemplu, API-ul ar putea renunța la solicitare dacă timestamp-ul este de 10 minute învechit.
Deși este bine să rămânem la utilizarea versiunilor SHA care sunt sigure, se pare că multe dintre vulnerabilitățile versiunilor SHA nesigure nu se aplică la HMAC. Din acest motiv, puteți vedea SHA1 utilizat în codul de producție. Cu toate acestea, din punctul de vedere al relațiilor publice, ar putea părea rău dacă trebuie să explicați de ce, din punct de vedere criptografic, este bine să utilizați SHA1 în acest context. Multe dintre punctele slabe ale SHA1 se datorează a ceea ce se numește atacurile de coliziune. Auditorii de cod sau cercetătorii de securitate se pot aștepta ca codul dvs. să fie rezistent la coliziune, indiferent de context. De asemenea, dacă scrieți un cod modular în care puteți schimba funcția de semnare pentru altul în viitor, s-ar putea să uitați să actualizați funcțiile hash nesigure. Prin urmare, vom rămâne la SHA-512 ca algoritmul nostru de alegere.
Operațiile HMAC CPU sunt rapide, dar un dezavantaj este problema schimbului de chei. Cum ne permitem reciproc să știm ce este cheia secretă fără a fi interceptată? De exemplu, poate că API-ul dvs. va trebui să adauge sau să elimine dinamic mai multe aplicații sau platforme dintr-o listă albă. În acest scenariu, aplicațiile ar trebui să se înregistreze și secretul ar trebui să fie transmis aplicației după înregistrarea cu succes. Ați putea trimite cheia peste HTTPS și utilizați fixarea SSL, dar chiar și atunci există întotdeauna o îngrijorare că într-un fel cheia este furată în timpul schimbului. Soluția la problema schimbului de chei este generarea unei chei care nu trebuie să părăsească dispozitivul în primul rând. Acest lucru poate fi realizat utilizând Cryptography Public Key, iar un standard foarte popular și acceptat este RSA.
RSA
RSA înseamnă Rivest-Shamir-Adleman (autorii sistemului criptosist). Aceasta implică profitarea de dificultatea de a factoriza produsul a două numere prime foarte mari. RSA poate fi folosit pentru criptare sau autentificare, deși pentru acest exemplu o vom folosi doar pentru autentificare. RSA generează două chei, public și privat, pe care le putem realiza folosind SecKeyGeneratePair funcţie. Atunci când este utilizat pentru autentificare, cheia privată este utilizată pentru a crea semnătura, în timp ce cheia publică verifică semnătura. Având în vedere o cheie publică, este imposibil de calculat să se deducă cheia privată.
Următorul exemplu demonstrează ce utilizează Apple și toate companiile de consolă de jocuri populare atunci când distribuie software-ul lor. Să presupunem că compania dvs. creează și distribuie periodic un fișier pe care utilizatorii îl vor trage în porțiunea de distribuire a fișierelor din aplicația dvs. din iTunes. Doriți să vă asigurați că fișierele pe care le trimiteți nu sunt niciodată manipulate înainte de a fi analizate în aplicație. Compania dvs. va păstra și păstra cheia privată pe care o folosește pentru a semna fișierele. În pachetul aplicației este o copie a cheii publice folosită pentru a verifica fișierul. Dat fiind faptul că cheia privată nu este niciodată transmisă sau inclusă în aplicație, nu există nicio modalitate pentru ca un utilizator rău intenționat să poată semna propriile versiuni ale fișierelor (cu excepția spargerii în companie și furarea cheii private).
Noi vom folosi SecKeyRawSign pentru a semna fișierul. Ar fi lent sa semnati intregul continut al fisierului folosind RSA, astfel incat hash-ul fișierului sa fie semnat. În plus, datele transmise către RSA ar trebui, de asemenea, să fie șterse înainte de semnare din cauza unor deficiențe de securitate.
@ disponibil (clasa iOS 10.0, *) FileSigner private var publicKey: SecKey? private var privateKey: SecKey? func generateKeys () -> String? var publicKeyString: String? // generează o nouă cheie cheie permiteți parametrii: [String: AnyObject] = [kSecAttrKeyType ca șir: kSecAttrKeyTypeRSA, kSecAttrKeySizeInBits ca șir: 4096 ca AnyObject]] = status SecKeyGeneratePair (parametri ca CFDictionary, & publicKey, & privateKey) cheia aici --- // Conversia obiectului SecKey într-o reprezentare pe care o putem trimite prin rețea dacă status == noErr && publicKey! = nil if let cfData = SecKeyCopyExternalRepresentation (publicKey !, nil) let data = cfData ca date publicKeyString = data.base64EncodedString () retur publicKeyString func signFile (_ cale: String) -> String? semnătura var: String? dacă permiteți fileData = FileManager.default.contents (atPath: calea) if (privateKey! = nil) // hash mesajul lăsa mai întâi digestLength = Int (CC_SHA512_DIGEST_LENGTH) let hashBytes = UnsafeMutablePointer.alocați (capacitate: digestLength) CC_SHA512 ([UInt8] (fileData), CC_LONG (fileData.count), hashBytes) // semn let blockSize = SecKeyGetBlockSize (privateKey!) // în cazul RSA, modulul este același mărime var signatureBytes = [UInt8] (repetare: 0, count: blockSize) var signatureDataLength = blockSize let status = SecKeyRawSign (privateKey !, .PKCS1SHA512, hashBytes, digestLength, & signatureBytes, & signatureDataLength) if status == noErr octeți: signatureBytes, count: signatureDataLength) signature = data.base64EncodedString () returnează semnătura
În acest cod, am folosit CC_SHA512 pentru a specifica din nou SHA-512. (RSA, spre deosebire de HMAC, devine nesigur dacă funcția hash de bază este nesigură.) De asemenea, folosim 4096 ca dimensiune cheie, care este stabilită de kSecAttrKeySizeInBits parametru. 2048 este dimensiunea minimă recomandată. Aceasta este pentru a împiedica o rețea puternică de sisteme de calculatoare să spargă cheia RSA (prin spargere vreau să spun factoringul cheii RSA - cunoscut și ca factorizarea unui modul public). Grupul RSA a estimat că cheile de 2048 de biți ar putea deveni ușor accesibile înainte de 2030. Dacă doriți ca datele dvs. să fie în siguranță dincolo de acel moment, atunci este o idee bună să alegeți o dimensiune cheie mai mare ca 4096.
Cheile generate sunt în formă de SecKey obiecte. O problemă cu punerea în aplicare a Apple de SecKey este că nu include toate informațiile esențiale care constituie o cheie publică, deci nu este un certificat valid X.509 codificat DER. Adăugarea informațiilor lipsă înapoi în formatul pentru o aplicație iOS sau OS X, chiar și pentru platforme de la server, cum ar fi PHP, necesită o muncă și implică lucrul într-un format cunoscut ca ASN.1. Din fericire, acest lucru a fost stabilit în noul iOS 10 SecKey funcții pentru generarea, exportul și importul cheilor.
Codul de mai jos vă arată cealaltă parte a comunicării - clasa care acceptă o cheie publică prin SecKeyCreateWithData pentru a verifica fișierele utilizând SecKeyRawVerify funcţie.
@ disponibil (clasa iOS 10.0, *) FileVerifier private var publicKey: SecKey? funcția addPublicKey (_keyString: String) -> Bool var succes = false dacă permiteți keyData = Data.init (base64Encoded: keyString) let parameters: String: AnySection , kSecAttrKeySizeInBits ca șir: 4096 ca AnyObject, kSecReturnPersistentRef ca String: true ca AnyObject] publicKey = SecKeyCreateWithData (cheieData ca CFData, parametri ca CFDictionary, nil) if (publicKey! = nil) (dacă nu permiteți fileData = FileManager.default.contents (atPath: calea) if let signatureData = Data.init (base64Encoded : semnătura) // hash mesajul lăsați mai întâi digestLength = Int (CC_SHA512_DIGEST_LENGTH) let hashBytes = UnsafeMutablePointer.alocați (capacitate: digestLength) CC_SHA512 ([UInt8] (fileData), CC_LONG (fileData.count), hashBytes) // verificați let status = signatureData.withUnsafeBytes signatureBytes în schimb SecKeyRawVerify (publicKey !, .PKCS1SHA512, hashBytes, digestLength, signatureBytes , signatureData.count) dacă status == noErr succes = true altceva print ("Semnătura confirmă eroarea") // - 9809: errSSLCrypto, etc întoarce succesul
Puteți încerca acest lucru și verificați dacă funcționează utilizând un test simplu, cum ar fi:
dacă #available (iOS 10.0, *) guard păstrează plistPath = Bundle.main.path (pentruResurse: "Info", dinType: "plist") altceva print ("Nu se poate obține plist"); return lăsați fileSigner = FileSigner () DispatchQueue.global (qos: .userInitiated) .async // Genul cheie RSA poate fi o activitate de lungă durată pază publicKeyString = fileSigner.generateKeys () else print ("Eroare de generare a cheilor"); întoarcere // Înapoi la subiectul principal DispatchQueue.main.async guard leave signature = fileSigner.signFile (plistPath) altceva print ("No signature"); returnați // Salvează semnătura pe celălalt capăt lasă fișierVerifier = FileVerifier () fișier de pazăVerifier.addPublicKey (publicKeyString) altceva print ("Cheia nu a fost adăugată"); returnați succesul = fileVerifier.verifyFile (plistPath, cuSignature: signature) dacă succesul print ("Semnături se potrivesc!") altceva print ("Semnăturile nu se potrivesc" Există un dezavantaj la generația cheie RSA este lentă! Timpul de generare a tastelor depinde de dimensiunea cheii. La dispozitivele mai noi, o tastă de 4096 biți durează doar câteva secunde, dar dacă executați acest cod pe o generație iPod Touch 4, este posibil să dureze aproximativ un minut. Acest lucru este bine dacă generați cheile de câteva ori pe un computer, dar ce se întâmplă când trebuie să generăm chei frecvent pe un dispozitiv mobil? Nu putem doar să micșorăm dimensiunea cheii, deoarece aceasta va downgrada securitatea.
Deci, care este soluția? Ei bine, criptografia curbelor eliptice (ECC) este o abordare up-and-coming - un nou set de algoritmi bazat pe curbele eliptice peste câmpurile finite. Clasele ECC sunt mult mai mici în mărime și mai rapid decât generatoarele de chei RSA. O cheie de numai 256 biți oferă un nivel foarte ridicat de securitate! Pentru a profita de ECC, nu este nevoie să schimbăm multe coduri. Putem semna datele noastre utilizând aceeași metodă SecKeyRawSign funcția și apoi reglați parametrii pentru a utiliza algoritmul de semnal digital al curbei eliptice (ECDSA).
Sfat: Pentru mai multe idei de implementare RSA, puteți să verificați SwiftyRSA helper bibliotecă, care se concentrează pe criptare, precum și pe semnarea mesajelor.
ECDSA
Imaginați-vă următorul scenariu: o aplicație de chat permite utilizatorilor să trimită mesaje private între ele, dar doriți să vă asigurați că un adversar nu a schimbat mesajul în drum spre celălalt utilizator. Să vedem cum ați putea asigura comunicarea lor cu criptografia.
În primul rând, fiecare utilizator generează o pereche cheie de chei publice și private pe dispozitivul mobil. Cheile lor private sunt stocate în memorie și nu părăsesc niciodată dispozitivul, în timp ce cheile publice sunt transmise una la cealaltă. Ca și înainte, cheia privată este utilizată pentru semnarea datelor trimise, în timp ce cheia publică este utilizată pentru verificare. Dacă un atacator ar trebui să capteze o cheie publică în timpul tranzitului, tot ce se poate face este să verifice integritatea mesajului original de la expeditor. Un atacator nu poate modifica un mesaj deoarece nu are cheia privată necesară pentru a reconstrui semnătura.
Există un alt profesionist în utilizarea ECDSA pe iOS. Putem folosi faptul că, în prezent, cheile cu curbă eliptică sunt singurele care pot fi stocate în enclavă sigură a dispozitivului. Toate celelalte chei sunt stocate în breloc care criptează elementele sale în zona de stocare prestabilită a dispozitivului. Pe dispozitivele care au una, enclavele sigure sunt separate de procesor, iar stocarea cheilor este implementată în hardware fără acces direct la software. Cifla protejată poate stoca o cheie privată și poate funcționa pe aceasta pentru a produce o ieșire trimisă aplicației fără a expune cheia privată reală prin încărcarea acesteia în memorie!
Voi adăuga suport pentru crearea cheii private ECDSA pe enclava securizată adăugând kSecAttrTokenIDSecureEnclave opțiune pentru kSecAttrTokenID parametru. Putem porni acest exemplu cu un a Utilizator obiect care va genera o pereche cheie la initializare.
@ disponibil (clasa iOS 9.0, *) Utilizator public var publicKey: SecKey? private var privateKey: SecKey? privat destinatar: Utilizator? init (cu ID-ul de utilizator: String) // dacă permite accesul = SecAccessControlCreateWithFlags (nil, kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly, [.privateKeyUsage / *, .userPresence] UI de autentificare pentru a obține cheia privată * /], nil) // Force store only if passcode Atingeți ID-ul setat ... dacă permiteți acces = SecAccessControlCreateWithFlags (nil, kSecAttrAccessibleWhenUnlockedThisDeviceOnly, [.privateKeyUsage], nil) // Păstrați cheia privată pe dispozitiv let privateTagString = "com.example.privateKey." + id lăsați privateTag = privateTagString.data (folosind: .utf8)! // Stocare: AnyObject] = [kSecAttrIsPermanent ca String: true ca AnyObject, kSecAttrAccessControl ca String: acces ca AnyObject, kSecAttrApplicationTag ca String: privateTag ca AnyObject,] let publicTagString = " com.example.publicKey.“ + id permite publicTag = publicTagString.data (folosind: .utf8)! // String: AnyObject] = [kSecAttrIsPermanent ca String: false ca AnyObject, kSecAttrApplicationTag ca String: publicTag ca AnyObject,] lasa keyPairParameters: [String: AnyObject] = [kSecAttrKeySizeInBits ca String: 256 ca AnyObject , kSecAttrKeyType cum String: kSecAttrKeyTypeEC, kSecPrivateKeyAttrs ca String: privateKeyParameters ca AnyObject, kSecAttrTokenID ca String: kSecAttrTokenIDSecureEnclave ca AnyObject, // păstra în kSecPublicKeyAttrs Enclave Secure ca String: publicKeyParameters ca AnyObject] lasa status = SecKeyGeneratePair (keyPairParameters ca CFDictionary, & publicKey, & privateKey) dacă status! = noErr print ("Eroare de generare a cheii") // ... Apoi, vom crea câteva funcții ajutoare și exemple. De exemplu, clasa va permite unui utilizator să inițieze o conversație și să trimită un mesaj. Desigur, în aplicația dvs., ați configura acest lucru pentru a include configurația dvs. specifică de rețea.
// ... private func sha512Digest (pentru datele date: date) -> date let len = Int (CC_SHA512_DIGEST_LENGTH) permite digest = UnsafeMutablePointer.alocați (capacitatea: len) CC_SHA512 ((date ca NSData) .bytes, CC_LONG (data.count), digest) return NSData (bytesNoCopy: UnsafeMutableRawPointer (digest), length: len) ) -> Bool var succes = false dacă publicKey! = Nil user.receiveInitializare (self) recipient = user success = true return success public func receiveInitialization (user: mesaj: String) dacă da date = message.data (folosind: .utf8) let signature = auto.signData (plainText: data) dacă semnătura! = nil auto.recipient? .receiveMessage (message, withSignature: public func receiveMessage (_ mesaj: String, cuSignature signature: Data) let signatureMatch = verifySignature (plainText: message.data (folosind: .utf8)! Mesajul este: ", mesaj) altceva print (" Mesaj primit, eroare de semnătura. ") // ...
Apoi, vom face semnarea și verificarea reală. ECDSA, spre deosebire de RSA, nu trebuie să fie ruptă înainte de semnare. Cu toate acestea, dacă doriți să aveți o funcție în care algoritmul poate fi schimbat cu ușurință fără a face multe modificări, atunci este bine să continuați să rupă datele înainte de a semna.
// ... func semnData (plainText: Date) -> Date? guard privateKey! = nici altul print ("Cheia privată indisponibilă") returnați nil permite digestToSign = self.sha512Digest (forData: plainText) let signature = UnsafeMutablePointer.alocați (capacitate: 512) // 512 - semnătura var varăLength = 512 let status = SecKeyRawSign (privateKey !, .PKCS1SHA512, [UInt8] (digestToSign), Int (CC_SHA512_DIGEST_LENGTH) "Signature fail: \ (status)") return Data.init (octeți: semnătură, număr: semnăturaLength) // redimensionare la dimensiunea efectivă a semnăturii func verifySignature (plainText: Data, signature: Data) -> .publicKey! = nu altceva print ("Recipient public key indispensabil") return false permite digestToVerify = self.sha512Digest (pentruData: plainText) letHashBytesSize = signature.count let status = SecKeyRawVerify (recipient! .publicKey !, .PKCS1SHA512, [UInt8] (digestToVerify), Int (CC_SHA512_DIGEST_LENGTH), [UInt8] (semnătura ca date), signedHashBytesSize) starea de returnare == noErr Aceasta verifică mesajul, precum și "identificarea" unui anumit utilizator, deoarece numai acel utilizator deține cheia privată.
Acest lucru nu înseamnă că conectăm cheia cu cine este utilizatorul în viața reală - problema potrivirii unei chei publice cu un anumit utilizator este un alt domeniu. Deși soluțiile nu sunt incluse în acest tutorial, aplicațiile populare de chat securizate, cum ar fi Semnal și Telegram, permit utilizatorilor să verifice o amprentă digitală sau un număr printr-un canal secundar de comunicare. În mod similar, Pidgin oferă o schemă de întrebări și răspunsuri prin care puneți o întrebare pe care numai utilizatorul ar trebui să o cunoască. Aceste soluții deschid o întreagă lume de dezbateri cu privire la ce ar trebui să fie cea mai bună abordare.
Cu toate acestea, soluția criptografică confirmă faptul că mesajul nu poate fi trimis decât de cineva care deține o cheie privată specifică.
Să facem un simplu test al exemplului nostru:
dacă #available (iOS 9.0, *) let alice = User.init (cuUserID: "aaaaaa1") bob = User.init (cuUserID: "aaaaaa2") acceptat = alice.initiateConversation ) alice.sendMessage ("Bună ziua") bob.sendMessage ("Mesaj de test") alice.sendMessage ("Un alt mesaj de test")OAuth și SSO
Adesea, atunci când lucrați cu servicii ale unor terțe părți, veți observa alți termeni de nivel înalt utilizați pentru autentificare, cum ar fi OAuth și SSO. În timp ce acest tutorial vizează crearea unei semnături, voi explica pe scurt ce înseamnă ceilalți termeni.
OAuth este un protocol pentru autentificare și autorizare. Ea acționează ca un intermediar în utilizarea contului cuiva pentru servicii terțe și are drept scop rezolvarea problemei autorizării selective a accesului la datele dvs. Dacă vă conectați la serviciul X prin Facebook, un ecran vă întreabă, de exemplu, dacă serviciul X are permisiunea de a accesa fotografiile de pe Facebook. Realizează acest lucru prin furnizarea unui simbol fără a dezvălui parola utilizatorului.
Sign-on single sau SSO descrie fluxul în care un utilizator autentificat poate utiliza aceleași acreditări de conectare pentru a accesa mai multe servicii. Un exemplu este modul în care funcționează contul dvs. Gmail pentru a vă conecta la YouTube. Dacă ați avea mai multe servicii diferite la compania dvs., este posibil să nu doriți să creați conturi de utilizator separate pentru toate serviciile diferite.
Concluzie
În acest tutorial, ați văzut cum să creați semnături utilizând cele mai populare standarde. Acum că am acoperit toate conceptele principale, să recapitulăm!
- Utilizați HMAC atunci când aveți nevoie de viteză și sunteți sigur că cheia secretă poate fi schimbată în siguranță.
- Dacă cheile trebuie să circule într-o rețea, este mai bine să utilizați RSA sau ECDSA.
- RSA este în continuare cel mai popular standard. Pasul său de verificare este destul de rapid. Utilizați RSA dacă restul echipei dvs. este deja familiarizat sau folosind standardul.
- Dacă trebuie să generați în mod constant chei pe un dispozitiv lent, cu toate acestea, utilizați ECDSA. În timp ce verificarea ECDSA este mai mică decât verificarea RSA, aceasta nu se compară cu multe secunde salvate pe RSA pentru generarea cheilor.
Deci asta e pentru semnăturile digitale din Swift. Dacă aveți întrebări, nu ezitați să renunțați la o linie în secțiunea de comentarii și, între timp, verificați câteva dintre celelalte tutoriale ale noastre despre securitatea datelor și dezvoltarea aplicațiilor în Swift!
