Dataset Viewer
Auto-converted to Parquet Duplicate
text
stringlengths
144
1.17k
AAA Mobile IP MN, FA, AAAL, AAAH, HA : principal N_FA : nonce K_MnAAAH, K_FaAAAL, K_AAAHAAAL, K_AAAHHa : symkey K_MnFa, K_MnHa, K_FaHa : fresh symkey 1. FA -> MN : FA, N_FA 2. MN -> FA : N_FA, MN, AAAH, {N_FA, MN, AAAH}K_MnAAAH 3. FA -> AAAL : N_FA, MN, AAAH, {N_FA, MN, AAAH}K_MnAAAH 4. AAAL -> AAAH : N_FA, MN, AAAH, {N_FA, MN, AAAH}K_MnAAAH 5. AAAH -> HA : MN, {K_MnHa, K_FaHa}K_AAAHHa, {K_MnFa, K_MnHa}K_MnAAAH, {MN, {K_MnHa, K_FaHa}K_AAAHHa, {K_MnFa, K_MnHa}K_MnAAAH}K_AAAHHa 6. HA -> AAAH : {K_MnFa, K_MnHa}K_MnAAAH, {{K_MnFa, K_MnHa}K_MnAAAH}K_MnHa, {{K_MnFa, K_MnHa}K_MnAAAH, {{K_MnFa, K_MnHa}K_MnAAAH}K_MnHa}K_AAAHHa 7. AAAH -> AAAL : N_FA, {K_MnFa, K_FaHa}K_AAAHAAAL, {K_MnFa, K_MnHa}K_MnAAAH, {{K_MnFa, K_MnHa}K_MnAAAH}K_MnHa, {N_FA, {K_MnFa, K_FaHa}K_AAAHAAAL, {K_MnFa, K_MnHa}K_MnAAAH, {{K_MnFa, K_MnHa}K_MnAAAH}K_MnHa}K_AAAHAAAL 8. AAAL -> FA : N_FA, {K_MnFa, K_FaHa}K_FaAAAL, {K_MnFa, K_MnHa}K_MnAAAH, {{K_MnFa, K_MnHa}K_MnAAAH}K_MnHa, {N_FA, {K_MnFa, K_FaHa}K_FaAAAL, {K_MnFa, K_MnHa}K_MnAAAH, {{K_MnFa, K_MnHa}K_MnAAAH}K_MnHa}K_FaAAAL 9. FA -> MN : {K_MnFa, K_FaHa}K_FaAAAL, {K_MnFa, K_MnHa}K_MnAAAH, {{K_MnFa, K_MnHa}K_MnAAAH}K_MnHa
Amended Needham Schroeder Symmetric Key A, B, S : principal Na, Nb : number Kas, Kbs, Kab : key dec : number -> number 1. A -> B : A 2. B -> A : {A, Nb}Kbs 3. A -> S : A, B, Na, {A, Nb}Kbs 4. S -> A : {Na, B, Kab, {Kab, Nb, A}Kbs}Kas 5. A -> B : {Kab, Nb, A}Kbs 6. B -> A : {Nb}Kab 7. A -> B : {dec(Nb)}Kab
Andrew Secure RPC A, B : principal Kab, K'ab : symkey Na, Nb, N'b : nonce succ : nonce -> nonce 1. A -> B : A, {Na}Kab 2. B -> A : {succNa, Nb}Kab 3. A -> B : {succNb}Kab 4. B -> A : {K'ab, N'b}Kab
BAN concrete Andrew Secure RPC A, B : principal Kab, K'ab : symkey Na, Nb, N'b : nonce succ : nonce -> nonce 1. A -> B : A, Na 2. B -> A : {Na, K'ab}Kab 3. A -> B : {Na}K'ab 4. B -> A : Nb
BAN modified Andrew Secure RPC A, B : principal Kab, K'ab : symkey Na, Nb, N'b : nonce succ : nonce -> nonce 1. A -> B : A, {Na}Kab 2. B -> A : {succNa, Nb}Kab 3. A -> B : {succNb}Kab 4. B -> A : {K'ab, N'b, Na}Kab
BAN modified version of CCITT X.509 (3) A, B : principal Na, Nb : nonce Ya, Yb : userdata Xa, Xb : userdata PK, SK : principal -> key (keypair) 1. A -> B : A, {Na, B, Xa, {Ya}PK(B)}SK(A) 2. B -> A : B, {Nb, A, Na, Xb, {Yb}PK(A)}SK(B) 3. A -> B : A, {B, Nb}SK(A)
BAN simplified version of Yahalom A, B, S : principal Na, Nb : number fresh Kas, Kbs, Kab : key A knows : A, B, S, Kas B knows : B, S, Kbs S knows : S, A, B, Kas, Kbs 1. A -> B : A, Na 2. B -> S : B, Nb, {A, Na}Kbs 3. S -> A : Nb, {B, Kab, Na}Kas, {A, Kab, Nb}Kbs 4. A -> B : {A, Kab, Nb}Kbs, {Nb}Kab
Bilateral Key Exchange with Public Key Protocol A, B : principal Ka, Kb : public key of A and B K : shared symmetric key Na, Nb : nonce f : nonce -> msg 1. B -> A : B, E(Ka : Nb, B) 2. A -> B : E(Kb : f(Nb), Na, A, K) 3. B -> A : E(Kb : f(Na))
Bull's Authentication Protocol A, B, C, S : principal Kab, Kbc : fresh symkey Na, Nb, Nc : fresh number Kas, Kbs, Kcs : symkey h : message, symkey -> message A computes Xa = h((A,B,Na),Kas), (A,B,Na) 1. A -> B : Xa B computes Xb = h((B,C,Nb,Xa),Kbs), (B,C,Nb,Xa) 2. B -> C : Xb C computes Xc = h((C,S,Nc,Xb),Kcs), (C,S,Nc,Xb) 3. C -> S : Xc 4. S -> C : A, B, Kab xor h(Na,Kas), {A,B,Na}Kab, B, A, Kab xor h(Nb,Kbs), {B,A,Nb}Kab, B, C, Kbc xor h(Nb,Kbs), {B,C,Nb}Kbc, C, B, Kbc xor h(Nc,Kcs), {C,B,Nc}Kbc 5. C -> B : A, B, Kab xor h(Na,Kas), {A,B,Na}Kab, B, A, Kab xor h(Nb,Kbs), {B,A,Nb}Kab, B, C, Kbc xor h(Nb,Kbs), {B,C,Nb}Kbc 6. B -> A : A, B, Kab xor h(Na,Kas), {A,B,Na}Kab
CAM M,C : principal Tm : timestamp PK,SK : principal -> key (keypair) HoA : principal -> address CoA : principal -> address i : salt 1. M -> C : CoA(M), HoA(C), HoA(M), PK(M), i, Tm, {H(CoA(M), HoA(C), HoA(M), Tm)}SK(M) HostPart(HoA(M)) = H(PK(M), i)
CCITT X.509 (1) A, B : principal Na, Nb : nonce Ta, Tb : timestamp Ya, Yb : userdata Xa, Xb : userdata PK, SK : principal -> key (keypair) 1. A -> B : A, {Ta, Na, B, Xa, {Ya}PK(B)}SK(A)
CCITT X.509 (1c) A, B : principal Na, Nb : nonce Ta, Tb : timestamp Ya, Yb : userdata Xa, Xb : userdata PK, SK : principal -> key (keypair) h : userdata -> userdata (one-way) 1. A -> B : A, {Ta, Na, B, Xa, {Ya, {h(Ya)}SK(A)}PK(B)}SK(A)
CCITT X.509 (3) A, B : principal Na, Nb : nonce Ta, Tb : timestamp Ya, Yb : userdata Xa, Xb : userdata PK, SK : principal -> key (keypair) 1. A -> B : A, {Ta, Na, B, Xa, {Ya}PK(B)}SK(A) 2. B -> A : B, {Tb, Nb, A, Na, Xb, {Yb}PK(A)}SK(B) 3. A -> B : A, {Nb}SK(A)
Clark and Jacob modified Hwang and Chen modified SPLICE/AS S, C, AS : principal N1, N2, N3 : nonce T : timestamp L : lifetime pk, sk : principal -> key (keypair) 1. C -> AS : C, S, N1 2. AS -> C : AS, {AS, C, N1, S, pk(S)}sk(AS) 3. C -> S : C, S, {T, L, {C, N2}pk(S)}sk(C) 4. S -> AS : S, C, N3 5. AS -> S : AS, {AS, S, N3, C, pk(C)}sk(AS) 6. S -> C : S, C, {inc(N2)}pk(C)
Davis Swick Private Key Certificates Protocol A, B : principal T : trusted translator Kbt : shared key between B and T Kat : shared key between A and T msg : message 1. B -> A : E(Kbt : A, msg) 2. A -> T : E(Kbt : A, msg), B 3. T -> A : E(Kat : msg, B)
Denning-Sacco shared key A, B, S : principal Kas, Kbs, Kab : key T : timestamp 1. A -> S : A, B 2. S -> A : {B, Kab, T, {Kab, A, T}Kbs}Kas 3. A -> B : {Kab,A, T}Kbs
Diffie Helman A, B : principal P, G, Xa, Xb : number one : -> number kap : number, number, number -> number 1. A -> B : P, G 2. A -> B : kap(P, G, Xa) 3. B -> A : kap(P, G, Xb) 4. A -> B : {one()}kap(P, kap(P, G, Xb), Xa)
EAP-TLS P, S : principal Kp, Ks, Kca : public_key Np, Ns, PMS : nonce Version, SessionID, CipherSuite, Cipher : text Ske, Shd, Ccs : text H, KeyGen, PRF : hash_func alias ClientK = KeyGen(P, Np, Ns, PRF(PMS, Np, Ns)) alias ServerK = KeyGen(S, Np, Ns, PRF(PMS, Np, Ns)) alias Finished = H(PRF(PMS, Np, Ns), P, S, Np, Cipher, SessionID) 1. S -> P : request_id 2. P -> S : respond_id, P 3. S -> P : start_tls 4. P -> S : Version, SessionID, Np, CipherSuite 5. S -> P : Version, SessionID, Ns, Cipher, {S, Ks}inv(Kca), Ske, Shd 6. P -> S : {P, Kp}inv(Kca), {PMS}Ks, {H(Np, Ns, S, PMS)}inv(Kp), Ccs, {Finished}ClientK 7. S -> P : Ccs, {Finished}ServerK
EAP-TTLS with Tunneled CHAP P, S : principal Ks, Kca : public_key Np, Ns, PMS : nonce Version, SessionID, CipherSuite, Cipher : text Shd, Ccs, Txt : text UName, ChapRs : text H, PRF, CHAP_PRF, Tranc, KeyGen : hash_func alias MS = PRF(PMS, Np, Ns) alias ClientK = KeyGen(P, Np, Ns, MS) alias ServerK = KeyGen(S, Np, Ns, MS) alias Finished = H(MS, P, S, Np, Cipher, SessionID) alias CHAP_challenge = Tranc(CHAP_PRF(MS, Txt, Np, Ns), 1, 16) alias ChapId = Tranc(CHAP_PRF(MS, Txt, Np, Ns), 17, 17) 1. S -> P : request_id 2. P -> S : respond_id, P 3. S -> P : start_ttls 4. P -> S : Version, SessionID, Np, CipherSuite 5. S -> P : Version, SessionID, Ns, Cipher, {S, Ks}inv(Kca), Shd 6. P -> S : {PMS}Ks, Ccs, {Finished}ClientK 7. S -> P : Ccs, {Finished}ServerK 8. P -> S : {UName, CHAP_challenge, ChapId, ChapRs}ClientK 9. S -> P : success
Encrypted Key Exchange (EKE) Protocol A, B : principal P : password (symmetric key) Ka : A's randomly generated public key R : randomly generated session key Na, Nb : nonces 1. A -> B : E(P : Ka) 2. B -> A : E(P : E(Ka : R)) 3. A -> B : E(R : Na) 4. B -> A : E(R : Na, Nb) 5. A -> B : E(R : Nb)
GJM A,B,T : principal C : msg PCS : (principal,msg,principal,principal):msg S-SIG : (principal,msg):msg TP-SIG : (principal,msg):msg resolved,aborted : bool abort : msg Exchange-1. A -> B : PCS(A,C,B,T) Exchange-2. B -> A : PCS(B,C,A,T) Exchange-3. A -> B : S-SIG(A,C) Exchange-4. B -> A : S-SIG(B,C) Abort-1. A -> T : S-SIG(A,[C,A,B,abort]) Abort-2. T -> A : if (resolved) then S-SIG(B,C) else S-SIG(T,S-SIG(A,[C,A,B,abort])) Resolve-A-1. A -> T : [PCS(B,C,A,T),S-SIG(A,C)] Resolve-A-2. T -> A : if (aborted) then S-SIG(T,S-SIG(A,[C,A,B,abort])) else if (resolved) S-SIG(B,C) else TP-SIG(B,C) Resolve-B-1. B -> T : [PCS(A,C,B,T),S-SIG(B,C)] Resolve-B-2. T -> B : if (aborted) then S-SIG(T,S-SIG(A,[C,A,B,abort])) else if (resolved) S-SIG(A,C) else TP-SIG(A,C)
Geopriv with pseudonym for Location Recipient only T, LR, LS : principal K_T_LR, K_T_LS : symkey K_LS : public_key N_LR : text Psi_LR, PW_LR : text K_LR : symkey LI : text PR : hash_func 1. LR -> T : LR, {LR, N_LR}K_T_LR 2. LR <- T : Psi_LR, {PW_LR, N_LR}K_T_LR 3. LS <- T : T, Psi_LR, {PW_LR, T, PR}K_T_LS 4. LR -> LS : Psi_LR, {PW_LR, K_LR, T}K_LS 5. LR <- LS : {PR(LI), T}K_LR
Geopriv with pseudonyms for Location Recipient and Target T, LR, LS : principal K_T_LR : symkey K_LS : public_key N_LR : text Psi_LR, Psi_T : text K_LR : symkey LI : text PR : hash_func 1. LR -> T : LR, {LR, K_LR, N_LR}K_T_LR 2. LR <- T : {Psi_LR, Psi_T, N_LR}K_T_LR 3. LS <- T : {Psi_LR, Psi_T, PR, LI, K_LR}K_LS 4. LR -> LS : {Psi_LR, Psi_T}K_LS 5. LR <- LS : {PR(LI), Psi_T}K_LR
Gong A, B, S : principal Na, Nb, Ns : number Pa, Pb : number K, Ha, Hb : number f1 : number, number, number, number -> number f2 : number, number, number, number -> number f3 : number, number, number, number -> number g : number, number, number, number -> number xor : number,number -> number alias K = f1(Ns,Na,B,Pa) alias Ha = f2(Ns,Na,B,Pa) alias Hb = f3(Ns,Na,B,Pa) 1. A -> B : A, B, Na 2. B -> S : A, B, Na, Nb 3. S -> B : Ns, xor(f1(Ns, Nb, A, Pb), K), xor(f2(Ns, Nb, A, Pb), Ha), xor(f3(Ns, Nb, A, Pb), Hb), g(K, Ha, Hb, Pb) 4. B -> A : Ns, Hb 5. A -> B : Ha
H.530 Symmetric Security for H.323 Mobility (Fixed) MT, VGK, AuF : principal ZZ, ZZ_VA : symkey X, Y : nonce CH1, CH2, CH3, CH4 : nonce NIL, G : text F : hash_func exp : text, nonce -> message alias M1 = MT, VGK, NIL, CH1, exp(G, X) alias M2 = M1, F(ZZ, M1), VGK, xor(exp(G, X), exp(G, Y)) alias M3 = VGK, MT, F(ZZ, VGK), F(ZZ, xor(exp(G, X), exp(G, Y))), xor(exp(G, X), exp(G, Y)) alias M4 = VGK, MT, CH1, CH2, exp(G, Y), F(ZZ, xor(exp(G, X), exp(G, Y))), F(ZZ, VGK) alias M5 = MT, VGK, CH2, CH3 alias M6 = VGK, MT, CH3, CH4 1. MT -> VGK : M1, F(ZZ, M1) 2. VGK -> AuF : M2, F(ZZ_VA, M2) 3. AuF -> VGK : M3, F(ZZ_VA, M3) 4. VGK -> MT : M4, F(exp(exp(G, X), Y), M4) 5. MT -> VGK : M5, F(exp(exp(G, X), Y), M5) 6. VGK -> MT : M6, F(exp(exp(G, X), Y), M6)
H.530 Symmetric Security for H.323 Mobility (Original) MT, VGK, AuF : principal ZZ, ZZ_VA : symkey X, Y : nonce CH1, CH2, CH3, CH4 : nonce NIL, G : text F : hash_func exp : text, nonce -> message alias M1 = MT, VGK, NIL, CH1, exp(G, X) alias M2 = M1, F(ZZ, M1), VGK, xor(exp(G, X), exp(G, Y)) alias M3 = VGK, MT, F(ZZ, VGK), F(ZZ, xor(exp(G, X), exp(G, Y))) alias M4 = VGK, MT, CH1, CH2, exp(G, Y), F(ZZ, xor(exp(G, X), exp(G, Y))), F(ZZ, VGK) alias M5 = MT, VGK, CH2, CH3 alias M6 = VGK, MT, CH3, CH4 1. MT -> VGK : M1, F(ZZ, M1) 2. VGK -> AuF : M2, F(ZZ_VA, M2) 3. AuF -> VGK : M3, F(ZZ_VA, M3) 4. VGK -> MT : M4, F(exp(exp(G, X), Y), M4) 5. MT -> VGK : M5, F(exp(exp(G, X), Y), M5) 6. VGK -> MT : M6, F(exp(exp(G, X), Y), M6)
Hwang and Chen modified SPLICE/AS S, C, AS : principal N1, N2, N3 : nonce T : timestamp L : lifetime pk, sk : principal -> key (keypair) 1. C -> AS : C, S, N1 2. AS -> C : AS, {AS, C, N1, S, pk(S)}sk(AS) 3. C -> S : C, S, {C, T, L, {N2}pk(S)}sk(C) 4. S -> AS : S, C, N3 5. AS -> S : AS, {AS, S, N3, C, pk(C)}sk(AS) 6. S -> C : S, C, {S, inc(N2)}pk(C)
Hwang modified version of Neumann Stubblebine A, B, S : principal Na, Ma, Nb, Mb : number Kas, Kbs, Kab : key Ta, Tb : time 1. A -> B : A, Na 2. B -> S : B, {A, Na, Tb, Nb}Kbs 3. S -> A : {B, Na, Kab, Tb}Kas, {A, Kab, Tb}Kbs, Nb 4. A -> B : {A, Kab, Tb}Kbs, {Nb}Kab 5. A -> B : Ma, {A, Kab, Tb}Kbs 6. B -> A : Mb, {Mb}Kab 7. A -> B : {Mb}Kab
IEEE 802.1X EAPOL over RADIUS C, A, S : principal Kcs : symkey NAS_ID, NAS_PORT : text Chall_Message : text Success : text EAPOL_Start, EAPOL_Req_Identity, EAPOL_Success, Access_accept : text MD5 : hash_func 1. C -> A : EAPOL_Start 2. A -> C : EAPOL_Req_Identity 3. C -> A : NAS_ID, NAS_PORT, MD5(Kcs) 4. A -> S : NAS_ID, NAS_PORT, MD5(Kcs) 5. S -> A : NAS_ID, Chall_Message 6. A -> C : NAS_ID, Chall_Message 7. C -> A : NAS_ID, {Chall_Message}Kcs 8. A -> S : NAS_ID, {Chall_Message}Kcs 9. S -> A : NAS_ID, Access_accept 10. A -> C : EAPOL_Success 11. C -> A : NAS_ID, Success
ISO Five-Pass Authentication Protocol A, B, S : principal Kab : session symkey Kas, Kbs : long-term symkeys Ra, Rb, R'b : nonce Text1, Text2, Text3, Text4, Text5, Text6, Text7, Text8, Text9 : text 1. A -> B : Ra, Text1 2. B -> S : R'b, Ra, A, Text2 3. S -> B : Text5, {B, Kab, Ra, Text3}Kas, {A, Kab, R'b, Text4}Kbs 4. B -> A : Text7, {B, Kab, Ra, Text3}Kas, {Ra, Rb, Text6}Kab 5. A -> B : Text9, {Ra, Rb, Text8}Kab
ISO One-Pass Unilateral Authentication Protocol with CCFs A, B : principal Kab : shared key between A and B Na : nonce fKab : keyed cryptographic check function text1, text2 : text messages 1. A -> B : [Ta|Na], B, text2, fKab([Ta|Na], B, text1)
ISO Public Key One-Pass Unilateral Authentication Protocol A, B : principal Ka-1 : private key of A Na : nonce CertA : certificate of A text1, text2 : text 1. A -> B : CertA, [Ta|Na], B, text2, E(Ka-1: [Ta|Na], B, text1)
ISO Public Key Three-Pass Mutual Authentication Protocol A, B : principal Ka-1, Kb-1 : private keys of A and B Ra, Rb : nonces CertA, CertB : certificates of A and B text1, text2, text3, text4, text5 : text 1. B -> A : Rb, text1 2. A -> B : CertA, Ra, Rb, B, text3, E(Ka-1: Rb, Ra, B, text2) 3. B -> A : CertB, Rb, Ra, A, text5, E(Kb-1: Rb, Ra, A, text4)
ISO Public Key Two-Pass Mutual Authentication Protocol A, B : principal Ka-1, Kb-1 : private keys of A and B Ta, Tb : timestamps Na, Nb : nonces CertA, CertB : certificates of A and B text1, text2, text3, text4 : text 1. A -> B : CertA, [Ta|Na], B, text2, E(Ka-1: [Ta|Na], B, text1) 2. B -> A : CertB, [Tb|Nb], A, text4, E(Kb-1: [Tb|Nb], A, text3)
ISO Public Key Two-Pass Parallel Mutual Authentication Protocol A, B : principal Ka-1, Kb-1 : private keys of A and B Ra, Rb : nonces CertA, CertB : certificates of A and B text1, text2, text3, text4, text5, text6 : text 1. A -> B : CertA, Ra, text1 2. B -> A : Rb, Ra, A, text6, E(Kb-1: Rb, Ra, A, text5) 3. B -> A : CertB, Rb, text2 4. A -> B : Ra, Rb, B, text4, E(Ka-1: Rb, Ra, B, text3)
ISO Public Key Two-Pass Unilateral Authentication Protocol A, B : principal Ka-1 : private key of A rA, rB : random numbers (nonces) CertA : certificate of A text1, text2, text3 : text 1. B -> A : rB, text1 2. A -> B : CertA, rA, rB, B, text3, E(Ka-1: rB, rA, B, text2)
ISO Symmetric Key One-Pass Unilateral Authentication Protocol A, B : principal Kab : symkey Na : nonce text1, text2 : text 1. A -> B : text2, {Ta | Na, B, text1}Kab
ISO Symmetric Key Three-Pass Mutual Authentication Protocol A, B : principal Kab : symkey Ra, Rb : nonce text1, text2, text3, text4, text5 : text 1. B -> A : Rb, text1 2. A -> B : text3, {Ra, Rb, B, text2}Kab 3. B -> A : text5, {Ra, Rb, text4}Kab
ISO Symmetric Key Two-Pass Mutual Authentication Protocol A, B : principal Kab : symkey Na, Nb : nonce text1, text2, text3, text4 : text 1. A -> B : text2, {Na, B, text1}Kab 2. B -> A : text4, {Nb, A, text3}Kab
ISO Symmetric Key Two-Pass Unilateral Authentication Protocol A, B : principal Kab : symkey Rb : nonce text1, text2, text3 : text 1. B -> A : Rb, text1 2. A -> B : text3, {Rb, B, text2}Kab
ISO Three-Pass Mutual Authentication Protocol with CCFs A, B : principal Kab : shared key between A and B Ra, Rb : nonces generated by A and B respectively fKab : keyed cryptographic check function text1, text2, text3, text4, text5 : text messages 1. B -> A : Rb, text1 2. A -> B : Ra, text3, fKab(Ra, Rb, B, text2) 3. B -> A : text5, fKab(Rb, Ra, A, text4)
ISO Two-Pass Mutual Authentication Protocol with CCFs A, B : principal Kab : shared key between A and B Na, Nb : nonces generated by A and B respectively fKab : keyed cryptographic check function text1, text2, text3, text4 : text messages 1. A -> B : [Ta|Na], text2, fKab([Ta|Na], B, text1) 2. B -> A : [Ta|Na], text4, fKab([Tb|Nb], A, text3)
ISO Two-Pass Unilateral Authentication Protocol with CCFs A, B : principal Kab : shared key between A and B Rb : random nonce generated by B fKab : keyed cryptographic check function text1, text2, text3 : text messages 1. B -> A : Rb, text1 2. A -> B : text3, fKab(Rb, B, text2)
Idemix Anonymous Credential User, Issuer, Verifier : principal Nu, Ns, NuPrime, NsPrime : nonce masec : master_secret K_ptag, K_spk : fresh symkey 1. User -> Issuer : commit(masec, Issuer, Nu) 2. Issuer -> User : credential(Issuer, ptag(masec, Issuer, Nu, Ns), attributes) 3. User -> Verifier : ptag(masec, Verifier, NuPrime, NsPrime), spk(masec, public_values, statement, message)
KSL A, B, S : principal Na, Nb, Nc, Ma, Mb : number Kas, Kbs, Kab, Kbb : key Tb : generalizedTimestamp 1. A -> B : Na, A 2. B -> S : Na, A, Nb, B 3. S -> B : {Nb, A, Kab}Kbs, {Na, B, Kab}Kas 4. B -> A : {Na, B, Kab}Kas, {Tb, A, Kab}Kbb, Nc, {Na}Kab 5. A -> B : {Nc}Kab 6. A -> B : Ma, {Tb, A, Kab}Kbb 7. B -> A : Mb, {Ma}Kab 8. A -> B : {Mb}Kab
Kao Chow Authentication v.1 A, B, S : principal Na, Nb : number Kab, Kbs, Kas : key 1. A -> S : A, B, Na 2. S -> B : {A, B, Na, Kab}Kas, {A, B, Na, Kab}Kbs 3. B -> A : {A, B, Na, Kab}Kas, {Na}Kab, Nb 4. A -> B : {Nb}Kab
Kao Chow Authentication v.2 A, B, S : principal Na, Nb : number Kab, Kbs, Kas : key 1. A -> S : A, B, Na 2. S -> B : {A, B, Na, Kab, Kt}Kas, {A, B, Na, Kab, Kt}Kbs 3. B -> A : B, {A, B, Na, Kab, Kt}Kas, {Na, Kab}Kt, Nb 4. A -> B : {Nb, Kab}Kt
Kao Chow Authentication v.3 A, B, S : principal Na, Nb : number Kab, Kbs, Kas : key 1. A -> S : A, B, Na 2. S -> B : {A, B, Na, Kab, Kt}Kas, {A, B, Na, Kab, Kt}Kbs 3. B -> A : {A, B, Na, Kab, Kt}Kas, {Na, Kab}Kt, Nb, {A, B, Ta, Kab}Kbs 4. A -> B : {Nb, Kab}Kt, {A, B, Ta, Kab}Kbs
Kerberos V5 A, G, C, S, U : principal N1, N2 : nonce L1, L2 : nonce T1start, T1expire : timestamp T2start, T2expire : timestamp Kcg, Kcs, Kag, Ku, Kgs : key 1. C -> A : U, G, L1, N1 2. A -> C : U, {U, C, G, Kcg, T1start, T1expire}Kag, {G, Kcg, T1start, T1expire}Ku 3. C -> G : S, L2, N2, {U, C, G, Kcg, T1start, T1expire}Kag, {C, T1}Kcg 4. G -> C : U, {U, C, S, Kcs, T2start, T2expire}Kgs, {S, Kcs, T2start, T2expire, N2}Kcg 5. C -> S : {U, C, S, Kcs, T2start, T2expire}Kgs, {C, T2}Kcs 6. S -> C : {T2}Kcs
Lowe modified BAN concrete Andrew Secure RPC A, B : principal Kab, K'ab : symkey Na, Nb, N'b : nonce succ : nonce -> nonce 1. A -> B : A, Na 2. B -> A : {Na, K'ab, B}Kab 3. A -> B : {Na}K'ab 4. B -> A : Nb
Lowe modified Denning-Sacco shared key A, B, S : principal Nb : nonce Kas, Kbs, Kab : key T : timestamp dec : nonce -> nonce 1. A -> S : A, B 2. S -> A : {B, Kab, T, {Kab, A, T}Kbs}Kas 3. A -> B : {Kab,A, T}Kbs 4. B -> A : {Nb}Kab 5. A -> B : {dec(Nb)}Kab
Lowe modified KSL A, B, S : principal Na, Nb, Nc, Ma, Mb : number Kas, Kbs, Kab, Kbb : key Tb : generalizedTimestamp 1. A -> B : Na, A 2. B -> S : Na, A, Nb, B 3. S -> B : {A, Nb Kab}Kbs, {Na, B, Kab}Kas 4. B -> A : {Na, B, Kab}Kas, {Tb, A, Kab}Kbb, Nc, {B, Na}Kab 5. A -> B : {Nc}Kab 6. A -> B : Ma, {Tb, A, Kab}Kbb 7. B -> A : Mb, {Ma, B}Kab 8. A -> B : {A, Mb}Kab
Lowe modified Wide Mouthed Frog A, S : principal Kas, Kbs, Kab : symkey Nb : nonce Ta, Ts : timestamp suc : nonce -> nonce 1. A -> S : A, {Ta, B, Kab}Kas 2. S -> B : {Ts, A, Kab}Kbs 3. B -> A : {Nb}Kab 4. A -> B : {succ(Nb)}Kab
Lowe's fixed version of Needham-Schroder Public Key A,B,S : Principal Na,Nb : Nonce KPa,KPb,KPs,KSa,KSb,KSs : Key KPa,KSa : is a key pair KPb,KSb : is a key pair KPs,KSs : is a key pair 1. A -> S : A,B 2. S -> A : {KPb, B}KSs 3. A -> B : {Na, A}KPb 4. B -> S : B,A 5. S -> B : {KPa, A}KSs 6. B -> A : {Na, Nb, B}KPa 7. A -> B : {Nb}KPb
Lowe's modified version of Yahalom A, B, S : principal Na, Nb : number fresh Kas, Kbs, Kab : key A knows : A, B, S, Kas B knows : B, S, Kbs S knows : S, A, B, Kas, Kbs 1. A -> B : A, Na 2. B -> S : {A, Na, Nb}Kbs 3. S -> A : {B, Kab, Na, Nb}Kas 4. S -> B : {A, Kab}Kbs 5. A -> B : {A, B, S, Nb}Kab
Needham Schroeder Symmetric Key A, B, S : principal Na, Nb : nonce Kas, Kbs, Kab : key dec : nonce -> nonce 1. A -> S : A, B, Na 2. S -> A : {Na, B, Kab, {Kab, A}Kbs}Kas 3. A -> B : {Kab,A}Kbs 4. B -> A : {Nb}Kab 5. A -> B : {dec(Nb)}Kab
Needham-Schroeder Public Key A,B,S : Principal Na,Nb : Nonce KPa,KPb,KPs,KSa,KSb,KSs : Key KPa,KSa : is a key pair KPb,KSb : is a key pair KPs,KSs : is a key pair 1. A -> S : A,B 2. S -> A : {KPb, B}KSs 3. A -> B : {Na, A}KPb 4. B -> S : B,A 5. S -> B : {KPa, A}KSs 6. B -> A : {Na, Nb}KPa 7. A -> B : {Nb}KPb
Neumann Stubblebine A, B, S : principal Na, Ma, Nb, Mb : number Kas, Kbs, Kab : key Ta, Tb : time 1. A -> B : A, Na 2. B -> S : B, {A, Na, Tb}Kbs, Nb 3. S -> A : {B, Na, Kab, Tb}Kas, {A, Kab, Tb}Kbs, Nb 4. A -> B : {A, Kab, Tb}Kbs, {Nb}Kab 5. A -> B : Ma, {A, Kab, Tb}Kbs 6. B -> A : Mb, {Ma}Kab 7. A -> B : {Mb}Kab
Otway Rees A, B, S : principal M, Na, Nb : nonce Kas, Kbs, Kab : key 1. A -> B : M, A, B, {Na, M, A, B}Kas 2. B -> S : M, A, B, {Na, M, A, B}Kas , {Nb, M, A, B}Kbs 3. S -> B : M, {Na, Kab}Kas, {Nb, Kab}Kbs 4. B -> A : M, {Na, Kab}Kas
PEAP with MS-CHAP P, S : principal Ks, Kca : public_key Pw : symmetric_key Np, Ns, PMS : nonce SessionID, CipherSuite : text Ccs : text H1, H2, PRF, KeyGen : hash_func alias M = PRF(PMS, Np, Ns) alias ClientK = KeyGen(P, Np, Ns, M) alias ServerK = KeyGen(S, Np, Ns, M) alias Finished = H1(M, P, S, Np, CipherSuite, SessionID) 1. S -> P : id_request 2. P -> S : P 3. S -> P : start_peap 4. P -> S : Np, SessionID, CipherSuite 5. S -> P : Ns, SessionID, CipherSuite, {S, Ks}inv(Kca) 6. P -> S : {PMS}Ks, Ccs 7. S -> P : Ccs, {Finished}ServerK 8. P -> S : {P}ClientK 9. S -> P : {Ns}ServerK 10. P -> S : {Np, H2(Pw, Np, Ns, P)}ClientK 11. S -> P : {H2(Pw, Np)}ServerK 12. P -> S : ack_message 13. S -> P : eap_success
Paulson's strengthened version of Yahalom A, B, S : principal Na, Nb : number fresh Kas, Kbs, Kab : key A knows : A, B, S, Kas B knows : B, S, Kbs S knows : S, A, B, Kas, Kbs 1. A -> B : A, Na 2. B -> S : B, Nb, {A, Na}Kbs 3. S -> A : Nb, {B, Kab, Na}Kas, {A, B, Kab, Nb}Kbs 4. A -> B : {A, B, Kab, Nb}Kbs, {Nb}Kab
RADIUS Remote Authentication Dial In User Service C, S : principal Kcs : symkey NAS_ID, NAS_PORT : text Success, Failure, Access_accept, Access_reject : text MD5 : hash_func 1. C -> S : NAS_ID, NAS_PORT, MD5(Kcs) 2. S -> C : NAS_ID, Access_accept 3. C -> S : NAS_ID, Success
RADIUS Remote Authentication Dial In User Service (with challenge) C, S : principal Kcs : symkey NAS_ID, NAS_PORT : text Chall_Message : text Success, Failure, Access_accept, Access_reject : text MD5 : hash_func 1. C -> S : NAS_ID, NAS_PORT, MD5(Kcs) 2. S -> C : NAS_ID, Chall_Message 3. C -> S : NAS_ID, {Chall_Message}Kcs 4. S -> C : NAS_ID, Access_accept 5. C -> S : NAS_ID, Success
SAML v.2 Web SSO Profile (IdP-initiated with back channels) C, IdP, SP : principal KIdP : public_key URI : protocol_id IDaa, IDresolve, Resource, REF : text 1. C -> IdP : C, URI, SP 2. IdP -> C : SP, IdP, REF 3. C -> SP : IdP, REF 4. SP -> IdP : IDresolve, SP, IdP, REF 5. IdP -> SP : IDresolve, IdP, URI, IDaa, SP, IdP, C, URI 6. SP -> C : URI, Resource
SAML v.2 Web SSO Profile (IdP-initiated with front channels) C, IdP, SP : principal KIdP : public_key URI : protocol_id IDaa, Resource : text 1. C -> IdP : C, URI, SP 2. IdP -> C : IdP, URI, IDaa, SP, IdP, C, URI 3. C -> SP : IDaa, IdP, URI, SP, C 4. SP -> C : URI, Resource
SAML v.2 Web SSO Profile (SP-initiated with back channels) C, IdP, SP : principal KIdP : public_key URI : protocol_id IDar, IDaa, IDresolve_1, IDresolve_2, Resource, REF_1, REF_2 : text 1. C -> SP : C, URI 2. SP -> C : IdP, SP, REF_1 3. C -> IdP : C, SP, REF_1 4. IdP -> SP : IDresolve_1, IdP, SP, REF_1 5. SP -> IdP : IDresolve_1, SP, IdP, IDar, URI 6. IdP -> C : SP, IdP, REF_2 7. C -> SP : IdP, REF_2 8. SP -> IdP : IDresolve_2, SP, IdP, REF_2 9. IdP -> SP : IDresolve_2, IdP, URI, IDar, {SP, IdP, C, IDaa, URI}inv(KIdP) 10. SP -> C : URI, Resource
SAML-based SSO for Google Apps (SP-initiated with front channels, fixed variant) C, IdP, SP : principal KIdP : public_key URI : protocol_id ID, Resource : text 1. C -> SP : URI 2. SP -> C : C, IdP, (ID, SP), URI 3. C -> IdP : C, IdP, (ID, SP), URI 4. IdP -> C : SP, {SP, C, IdP, ID}inv(KIdP), URI 5. C -> SP : SP, {SP, C, IdP, ID}inv(KIdP), URI 6. SP -> C : Resource
SAML-based SSO for Google Apps (SP-initiated, Google unsafe variant) C, IdP, SP : principal KIdP : public_key URI : protocol_id ID, Resource : text 1. C -> SP : URI 2. SP -> C : C, IdP, (ID, SP), URI 3. C -> IdP : C, IdP, (ID, SP), URI 4. IdP -> C : SP, {C, IdP}inv(KIdP), URI 5. C -> SP : SP, {C, IdP}inv(KIdP), URI 6. SP -> C : Resource
SIP Diameter Session Initiation Protocol UAC, SS1, SS2, DS : principal Nonce : nonce PWD : text Dest : protocol_id H : hash_func sipregister, sip401, sip200 : protocol_id 1. UAC -> SS1 : sipregister, UAC, Dest 2. SS1 -> DS : UAC, Dest 3. DS -> SS1 : UAC, SS2 4. SS1 -> SS2 : sipregister, UAC, Dest 5. SS2 -> DS : Dest, UAC 6. DS -> SS2 : Nonce, UAC 7. SS2 -> SS1 : sip401, Nonce 8. SS1 -> UAC : sip401, Nonce 9. UAC -> SS1 : sipregister, UAC, Dest, Nonce, H(Nonce, H(UAC, PWD), H(Dest)) 10. SS1 -> DS : UAC, Dest 11. DS -> SS1 : UAC, SS2 12. SS1 -> SS2 : sipregister, UAC, Dest, Nonce, H(Nonce, H(UAC, PWD), H(Dest)) 13. SS2 -> DS : Dest, UAC, Nonce, H(Nonce, H(UAC, PWD), H(Dest)) 14. DS -> SS2 : UAC, success 15. SS2 -> SS1 : sip200 16. SS1 -> UAC : sip200
SK3 A, B, S, Ca, Cb : principal Ka, Kb : symkey Kac, Kbc : symkey Na, Nb : nonce 0,1,2 : number alias Kab = {A, 0}Kb alias Pab = Kab + {B, 1}Ka 1. A -> S : A, B 2. S -> A : Pab, {Pab, B, 2}Ka 3. A -> Ca : A 4. Ca -> A : Na, {Na, 1, 1}Kac 5. A -> B : A, Na 6. B -> Cb : A, Na 7. Cb -> B : Nb, {Nb, 0, 0}Kab, {Na, Nb, 1}Kab, {Nb, 0, 1}Kab 8. B -> A : Nb, {Na, Nb, 1}Kab 9. A -> Ca : B, Na, Nb, Pab, {Pab, B, 2}Ka, {Na, Nb, 1}Kab, {Nb, 0, 1}Kab 10. Ca -> A : {Nb, 0, 0}Kab, {Nb, 0, 1}Kab 11. A -> B : {Nb, 0, 1}Kab
SPLICE/AS S, C, AS : principal N1, N2, N3 : nonce T : timestamp L : lifetime pk, sk : principal -> key (keypair) 1. C -> AS : C, S, N1 2. AS -> C : AS, {AS, C, N1, pk(S)}sk(AS) 3. C -> S : C, S, {C, T, L, {N2}pk(S)}sk(C) 4. S -> AS : S, C, N3 5. AS -> S : AS, {AS, S, N3, pk(C)}sk(AS) 6. S -> C : S, C, {S, inc(N2)}pk(C)
SRP: Secure Remote Passwords A, B: principal (Client, Server) Password: shared secret between A and B Salt: random value known to server, used to prevent dictionary attacks G: generator for Diffie-Hellman exponentiation Na, Nb: nonces generated by A and B respectively V: password verifier = g^x mod N, with x = SHA(salt | SHA(A | ':' | Password)) DHX, DHY: Diffie-Hellman public values K: session key derived from DH values and verifier M: proof of key, H(A,B,K,...) 1. A -> B: A, G^Na 2. B -> A: Salt, {G^Nb}_V 3. A -> B: M 4. B -> A: H(G^Na, M, K)
Schnorr's Protocol A, B : principal Na, Nb : fresh number Sa : private key Pa = exp(g,Sa) : public key A chooses Na and computes a = exp(g,Na) 1. A -> B : a B chooses Nb 2. B -> A : Nb A computes r = Na + Nb Sa 3. A -> B : r B checks that exp(g, r) = a exp(Pa,Nb)
Shamir-Rivest-Adleman Three Pass Protocol A, B : principal Ka, Kb : symkey M : fresh number 1. A -> B : {M}Ka 2. B -> A : {{M}Ka}Kb 3. A -> B : {M}Kb
SmartRight view-only CC, TC : principal VoKey, VoR, VoRi, CW : number Kc : key h : number -> number 1. CC -> TC : {VoKey, CW+VoR}Kc 2. TC -> CC : VoRi 3. CC -> TC : VoR, {h(VoRi)}VoKey
TESLA: Timed Efficient Stream Loss-tolerant Authentication S, R: principal K_N: random symmetric key generated by S K_i: keys derived from K_N using a one-way function F M_i: messages broadcast by S N: total number of messages F: one-way hash function text: generic message content 1. S -> R: {N, K_0}inv(K_S) where K_0 = F^N(K_N) 2. For i = 1 to N-1, S -> R: M_i, hash(K_i, M_i), K{i-1}
TMN A, B, S : principal Ka, Kb : key PK, SK : principal -> key (keypair) 1. A -> S : B, {Ka}PK(S) 2. S -> B : A 3. B -> S : A, {Kb}PK(S) 4. S -> A : B, {Kb}Ka
TSIG Transaction Signature C, S : principal K : symkey N1, N2 : nonce M1, M2 : text TAG1, TAG2 : text H : hash_func 1. C -> S : TAG1, M1, {H(TAG1, M1), N1}K 2. S -> C : TAG2, M1, M2, {H(TAG2, M1, M2), N2}K
UMTS-AKA: Authentication and Key Agreement S, M: principal (Server, Mobile) k(M): shared secret key between S and M seq: sequence number maintained by both S and M r: random nonce generated by S F1, F2, F3, F4, F5: cryptographic hash or one-way functions CK, IK, KA: session keys derived from k(M) and r AUTN: authentication token 1. M -> S: M 2. S -> M: r; {seq}_Ka; F1(k(M); seq; r) 3. M computes KA, seq, and verifies F1(k(M); seq; r); if valid, increments seq 4. M -> S: F2(k(M); r)
Using Non-reversible Function Protocol A, B : principal Kab, K : symkey Ra, Rb : nonce f : randomNo -> msg 1. B -> A : B, Rb 2. A -> B : A, {f(Rb), Ra, A, K}Kab 3. B -> A : B, {f(Ra)}K
Wide Mouthed Frog A, S : principal Kas, Kbs, Kab : symkey Ta, Ts : timestamp 1. A -> S : A, {Ta, B, Kab}Kas 2. S -> B : {Ts, A, Kab}Kbs
Wired Equivalent Privacy Protocol A, B : principal Kab : symkey RC4 : message, symkey -> message C : message -> message 1. A -> B : v, ((M,C(M)) xor RC4(v,Kab))
Woo and Lam Mutual Authentication P, Q, S : principal Kps, Kqs, Kpq : key N1, N2 : number 1. P -> Q : P, N1 2. Q -> P : Q, N2 3. P -> Q : {P, Q, N1, N2}Kps 4. Q -> S : {P, Q, N1, N2}Kps, {P, Q, N1, N2}Kqs 5. S -> Q : {Q, N1, N2, Kpq}Kps, {P, N1, N2,Kpq}Kqs 6. Q -> P : {Q, N1, N2, Kpq}Kps, {N1, N2}Kpq 7. P -> Q : {N2}Kpq
Woo and Lam Pi A, B, S : principal Nb : nonce Kas, Kbs : skey 1. A -> B : A 2. B -> A : Nb 3. A -> B : {Nb}Kas 4. B -> S : {A, {Nb}Kas}Kbs 5. S -> B : {Nb}Kbs
Woo and Lam Pi 1 A, B, S : principal Nb : nonce Kas, Kbs : skey 1. A -> B : A 2. B -> A : Nb 3. A -> B : {A,B,Nb}Kas 4. B -> S : {A, B, {A, B, Nb}Kas}Kbs 5. S -> B : {A, B, Nb}Kbs
Woo and Lam Pi 2 A, B, S : principal Nb : nonce Kas, Kbs : skey 1. A -> B : A 2. B -> A : Nb 3. A -> B : {A,Nb}Kas 4. B -> S : {A, {A, Nb}Kas}Kbs 5. S -> B : {A, Nb}Kbs
Woo and Lam Pi 3 A, B, S : principal Nb : nonce Kas, Kbs : skey 1. A -> B : A 2. B -> A : Nb 3. A -> B : {Nb}Kas 4. B -> S : {A, {Nb}Kas}Kbs 5. S -> B : {A, Nb}Kbs
Woo and Lam Pi f A, B, S : principal shared : (principal, principal):key Nb : nonce 1. A -> B : A 2. B -> A : Nb 3. A -> B : {A,B,Nb}shared(A, S) 4. B -> S : {A, B, Nb, {A, B, Nb}shared(A, S)}shared(B, S) 5. S -> B : {A, B, Nb}shared(B, S)
Yahalom A, B, S : principal Na, Nb : number fresh Kas, Kbs, Kab : key A knows : A, B, S, Kas B knows : B, S, Kbs S knows : S, A, B, Kas, Kbs 1. A -> B : A, Na 2. B -> S : B, {A, Na, Nb}Kbs 3. S -> A : {B, Kab, Na, Nb}Kas, {A, Kab}Kbs 4. A -> B : {A, Kab}Kbs, {Nb}Kab

Security Protocols Open Repository (SPORE) Dataset

This dataset contains security protocol specifications formatted for training large language models to understand and reason about cryptographic protocols.

Dataset Description

The Security Protocols Open Repository is a comprehensive collection of security protocols that have been formally analyzed. Each protocol specification includes:

  • Principal declarations (participants in the protocol)
  • Cryptographic primitives (keys, nonces, timestamps, etc.)
  • Message exchange sequences with cryptographic operations
  • Clear notation for encryption, signing, and other security operations

UPDATE

  • Oct-23-2025: This dataset now includes additional protocols from the Clark-Jacob Library, the AVISPA Library and the AVANTSSAR Library not originally available in the SPORE dataset.

Dataset Structure

The dataset is available in two flavours: instruction and conversation.

Each entry in the instruction dataset has the schema:

{"text": "<Protocol Name>\n\n<Protocol Specifications>"}

Each entry in the conversation dataset has the schema:

{
  "messages": [
    {"role": "system", "content": "You are an expert in formal verification of security protocols."},
    {"role": "user", "content": "Analyze the following protocol:\n\n<Protocol Name>\n\n<Protocol Specifications>"},
    {"role": "assistant", "content": ""}
  ]
}

The protocol specifications use a standard notation:

  • A, B, S: Principals (participants)
  • Na, Nb: Nonces (random values)
  • Ka, Kb: Cryptographic keys
  • {M}K: Message M encrypted with key K
  • A -> B: Message flow from A to B

Use Cases

This dataset is designed for:

  1. Protocol Understanding: Training LLMs to parse and comprehend security protocol specifications
  2. Protocol Analysis: Learning to identify participants, message flows, and cryptographic operations
  3. Security Research: Understanding historical protocols and their vulnerabilities
  4. Formal Methods: Learning formal notation for security protocols

Dataset Creation

Source Data

All protocols are sourced from:

Data Processing

The original protocol specifications have been:

  • Cleaned of formatting artifacts
  • Stripped of comments and metadata
  • Standardized to a consistent text format
  • Sorted in alphabetical order of the protocol names
  • Converted to JSONL for easy loading

Training Example

from datasets import load_dataset

dataset = load_dataset("dassarthak18/spore-protocols", "instruction")

training_args = TrainingArguments(
    # your args
)

trainer = SFTTrainer(
    model=model,
    args=training_args,
    train_dataset=dataset['train'],
    dataset_text_field="text",
)

Dataset Statistics

  • Total Protocols: 49 protocols from SPORE + 18 protocols from Clark-Jacob library + 16 protocols from AVISPA library + 6 protocols from AVANTSSAR library
  • Protocol Families: Includes variations, fixes, and modified versions of classic protocols
  • Average Length: Varies from simple 3-message protocols to complex multi-party protocols
  • Language: Formal protocol specification language

Limitations

  • The dataset is relatively small (89 protocols)
  • Protocols are represented in a specific formal notation
  • Does not include natural language descriptions or security proofs

Citation

@misc{spore,
  title = {Security Protocols Open Repository},
  author = {{LSV - ENS Paris-Saclay}},
  howpublished = {\url{https://lsv.ens-paris-saclay.fr/Software/spore/}},
  note = {Laboratoire Spécification et Vérification, ENS Paris-Saclay, France}
}

@techreport{wrro72494,
            note = {Query date: 14/01/2011},
            year = {1997},
           title = {A survey of authentication protocol literature: Version 1.0},
            type = {Report},
     institution = {ARRAY(0x557103a11320)},
       publisher = {Citeseer},
        keywords = {Authentication. ,Security Protocols},
             url = {https://eprints.whiterose.ac.uk/id/eprint/72494/},
          author = {Clark, John Andrew and Jacob, Jeremy Lawrence}
}

@inproceedings{Armando2005AVISPA,
  author    = {Armando, Alessandro and Basin, David and Boichut, Yohan and
               Chevalier, Yannick and Compagna, Luca and Cuellar, Juan and
               Hankes Drielsma, Peter and He{\'a}m, P.~C. and Kouchnarenko, O. and
               Mantovani, J. and M{\"o}dersheim, Sebastian and von Oheimb, D. and
               Rusinowitch, Michael and Santiago, J. and Turuani, M. and
               Vigan\`o, Luca and Vigneron, L.},
  title     = {The AVISPA Tool for the Automated Validation of Internet Security Protocols and Applications},
  booktitle = {Proceedings of Computer Aided Verification (CAV)},
  series    = {Lecture Notes in Computer Science},
  volume    = {3576},
  pages     = {281--285},
  year      = {2005},
  publisher = {Springer},
  doi       = {10.1007/11513988\_27}
}

@inproceedings{AVANTSSAR2012,
  author    = {Armando, Alessandro and Carbone, Roberto and Compagna, Luca and
               Cuellar, Jorge and Pellegrino, Giancarlo and Sorniotti, Alessandro},
  title     = {From Multiple Credentials to Browser-Based Single Sign-On: Are We More Secure?},
  booktitle = {Proceedings of the IFIP TC 11 27th International Information Security Conference (SEC)},
  series    = {IFIP Advances in Information and Communication Technology},
  volume    = {376},
  pages     = {68--79},
  year      = {2012},
  publisher = {Springer},
  doi       = {10.1007/978-3-642-30436-1\_6}
}
Downloads last month
39

Collection including dassarthak18/spore-protocols