{"component": "clause", "props": {"groups": [{"samples": [{"hash": "byGvAbuNm7V", "uri": "/contracts/byGvAbuNm7V#proposed-protocol", "label": "Integrated Shared Random Key Agreement Protocol", "score": 33.1768266976, "published": true}], "snippet": "Based on the need for key generation at reduced energy consumption with low computing and communication costs, we have proposed a protocol that satisfies the NIST framework for cryptographic key management. where each \u03b1i is randomly chosen and belongs to the set. Sequences of random values are generated by both the transmitter and the receiver nodes and are exchanged. If the generated random values are matched, corresponding bits from MSK are extracted and concatenated to form SRK. The key that is shared between the transmitter and receiver nodes if random can further be used for secured transmission of data. The SRK is encrypted using the random key generated by PUF and its randomness is tested using NIST tests for randomness. The transmitter can be either SNs or CHs and the receiver can be either CHs or BSs. SRK is generated once from MSK. This process helps in minimizing energy consumption during key generation. SRK remains the shared secret since it gets generated implicitly. Since our proposed protocol is designed for WSN which needs low energy consumption, SRK can itself be used as the key for encrypting the data transmitted and decrypting the data received. Transmitted packets are encrypted and decrypted with SRK using the bitXOR operation. MSK is encrypted with PK using bitXOR and sent to the receiver node. It gets decrypted with the PK of the transmitter node at the receiver using bitXOR operation. PK is piggybacked in the WSN frame packet. The receiver takes the PK from the WSN frame packet and decrypts it. CH generates MSK using GR and transmits it to the SN, after which both SNs and CH generate SRK. Generated SRK is encrypted using PUF and stored in both SN and CH. MSK gets regenerated when the CH changes. \u2022 Assumptions\n1. CHs are powerful enough to generate MSKs, generate RSs, and receive RSs from all nodes.\n2. Each node is equipped with a PUF. The energy (E) is calculated using, MSK gets generated using (GR(p,n,r)), where p,n,r are computed from WSN parameters as follows: \u2022 p is the number of ones in the PK. \ud835\udc38 = \ud835\udc49 \u2217 \ud835\udc3c \u2217 \ud835\udc47\n(3) where, \u2022 V denotes voltage. \u2022 I denote current. In our experiment, we have taken V as 3 volts and I as 19.7mA to calculate the energy consumed in joules. The flow of operations in our proposed protocol for WSN is illustrated in Figure 1. In this protocol, GR is used for the formation of MSK and the generation of SRK by taking the parameters of SNs as input. The processes involved in the confidential data transmission are illustrated in Figure 2. are equal. The protection of generated SRK from node capture attacks using PUF is explained in Algorithm (3). The secured transmission and reception of data in WSN is explained in Algorithms (4) and (5).", "snippet_links": [{"key": "based-on", "type": "clause", "offset": [0, 8]}, {"key": "key-generation", "type": "definition", "offset": [22, 36]}, {"key": "energy-consumption", "type": "definition", "offset": [48, 66]}, {"key": "communication-costs", "type": "definition", "offset": [90, 109]}, {"key": "cryptographic-key-management", "type": "clause", "offset": [177, 205]}, {"key": "transmission-of-data", "type": "clause", "offset": [595, 615]}, {"key": "shared-secret", "type": "definition", "offset": [945, 958]}, {"key": "designed-for", "type": "definition", "offset": [1026, 1038]}, {"key": "the-data", "type": "clause", "offset": [1128, 1136]}, {"key": "to-generate", "type": "definition", "offset": [1789, 1800]}, {"key": "are-computed", "type": "clause", "offset": [1976, 1988]}, {"key": "number-of", "type": "clause", "offset": [2032, 2041]}, {"key": "calculate-the", "type": "clause", "offset": [2189, 2202]}, {"key": "of-operations", "type": "clause", "offset": [2239, 2252]}, {"key": "figure-1", "type": "definition", "offset": [2304, 2312]}, {"key": "formation-of", "type": "clause", "offset": [2351, 2363]}, {"key": "data-transmission", "type": "clause", "offset": [2479, 2496]}, {"key": "figure-2", "type": "clause", "offset": [2516, 2524]}, {"key": "protection-of", "type": "definition", "offset": [2541, 2554]}, {"key": "the-secured", "type": "clause", "offset": [2636, 2647]}], "size": 1, "hash": "33355c9700ddcf883b1c382a3a4af657", "id": 1}, {"samples": [{"hash": "eHGXeEjfHEm", "uri": "/contracts/eHGXeEjfHEm#proposed-protocol", "label": "Group Key Agreement Protocol", "score": 21.045174538, "published": true}], "snippet": "The proposed protocol chooses a k-bit prime p and determine following public parameters: {Fp, E/Fp, G, P}. where E/Fp: Elliptic curve over Fp. G: Cyclic additive points group formed by points on E/Fp. P: Generator of G. The protocol describes operation to generate common Session key among n members (it is not important whether n is equal to 3k or not) called Initialization operation along with others group operations like Join, Leave, Merge, etc. for dynamic group.\n4.1 Initialization\n1) In first round all members are arranged in subgroups having set of three members in each. (If n is not the multiple of 3 then remaining one or two members supposed to forward in next round and they does nothing in current round. The same condition is in every round) Member in every set form their own common EC points by using ECC based Three Parties Diffie \u2587\u2587\u2587\u2587\u2587\u2587\u2587 key exchange as discussed in section 3.3. At the end of first round every subgroup has its own secret key (a point in EC group) in the form of (axi.ayi.azi.P) for i=1... Where axi, ayi & azi are private keys of first ,second and third member of i\u2019th subgroup. One member from every subgroup comes forward as the group controller (GC) for the next round. In this way we treat every subgroup as a new node controlled by their GC.\n2) In second round There are total nodes (along with the remaining node coming from previous round) form the subgroups having set of three participants of each and calculates their secrete subgroup key as in previous. This time GCs uses x- co-ordinate of their own subgroup keys as the private key. GC1 calculate (x1.P) and unicast to GC2. GC2 calculates (x2.P) and (x2. x1.P) and broadcast {(x1.P) ,( x2.P),( x2.x1.P)} to the all members of third subgroup. The members of third subgroup now can calculate common key as (x3. x2.x1.P) and keep it secret .GC3 additionally calculates {(x3.x1.P), (x3.x2.P)} and broadcast to the all members of its sibling groups. All sibling subgroup members calculates common key by multiplying their own private value. Note that GC1, GC2 and GC3 are group controllers and x1, x2 and x3 are their x co-ordinates of common points of first, second and third subgroups respectively.\n3) Repeats the above process in subsequent rounds .In every round no. of nodes becomes (1/3) of the previous round. After rounds we have a single group which includes all the members, each sharing the group secret key.\n4) If in last round the no of participants remains only two then instead of three parties it employs two parties ECC based \u2587\u2587\u2587\u2587\u2587\u2587 \u2587\u2587\u2587\u2587\u2587\u2587\u2587 for calculating final group key. An example to initialize 12 (12 \u2260 3k) members by above protocols is illustrated in Figure 1. Members of the group are represented by leaf node M1,..,M12. In First round four groups are formed with their own group key shown as the parent nodes G1\u2026G4 of corresponding members. Only one group G5 is possible in second round with participants G1, G2 and G3 they form a common key which is shared by all the members of G1, G2 and G3. Group G4 doing nothing in this round forwarded to the next round. In third round remain only two participants G4 and G5 .They employ two parties ECC based \u2587\u2587\u2587\u2587\u2587\u2587 \u2587\u2587\u2587\u2587\u2587\u2587\u2587 as suggested in our protocol to compute final group key which is shared by all the members M1,..,M12. The worst case cost of initialization operation are summarised in following table: Communication: Computation: Rounds Messages (Unicast + Broadcast) Point Multiplications: h = M11 M12", "snippet_links": [{"key": "the-proposed-protocol", "type": "clause", "offset": [0, 21]}, {"key": "where-e", "type": "clause", "offset": [107, 114]}, {"key": "the-protocol", "type": "clause", "offset": [220, 232]}, {"key": "to-generate", "type": "definition", "offset": [253, 264]}, {"key": "session-key", "type": "definition", "offset": [272, 283]}, {"key": "equal-to", "type": "definition", "offset": [334, 342]}, {"key": "group-operations", "type": "clause", "offset": [404, 420]}, {"key": "first-round", "type": "clause", "offset": [495, 506]}, {"key": "all-members", "type": "definition", "offset": [507, 518]}, {"key": "next-round", "type": "definition", "offset": [670, 680]}, {"key": "same-condition", "type": "clause", "offset": [725, 739]}, {"key": "section-33", "type": "clause", "offset": [888, 899]}, {"key": "at-the-end-of", "type": "clause", "offset": [901, 914]}, {"key": "in-ec", "type": "clause", "offset": [974, 979]}, {"key": "form-of", "type": "definition", "offset": [994, 1001]}, {"key": "private-keys", "type": "definition", "offset": [1054, 1066]}, {"key": "group-controller", "type": "definition", "offset": [1171, 1187]}, {"key": "second-round", "type": "definition", "offset": [1293, 1305]}, {"key": "the-members", "type": "clause", "offset": [1745, 1756]}, {"key": "points-of", "type": "clause", "offset": [2141, 2150]}, {"key": "an-example", "type": "clause", "offset": [2589, 2599]}, {"key": "figure-1", "type": "definition", "offset": [2672, 2680]}, {"key": "members-of-the-group", "type": "clause", "offset": [2682, 2702]}, {"key": "represented-by", "type": "definition", "offset": [2707, 2721]}, {"key": "the-parent", "type": "clause", "offset": [2815, 2825]}, {"key": "one-group", "type": "definition", "offset": [2869, 2878]}, {"key": "form-a", "type": "clause", "offset": [2947, 2953]}, {"key": "third-round", "type": "definition", "offset": [3087, 3098]}, {"key": "cost-of", "type": "definition", "offset": [3305, 3312]}], "size": 1, "hash": "027aece5768e98984f7192ba434a035d", "id": 2}, {"samples": [{"hash": "1Pr5ZWZtgQz", "uri": "/contracts/1Pr5ZWZtgQz#proposed-protocol", "label": "Research Paper", "score": 29.6707555642, "published": true}], "snippet": "This section present a hierarchal multiple-key agreement protocol featuring non-cooperativeness, freshness and more security in WSN. This protocol \ud835\udc44\ud835\udc36\ud835\udc40\ud835\udc56\ud835\udc57 . \ud835\udc463 saves this data {(\ud835\udc44\ud835\udc46. \ud835\udc461, \ud835\udc44\ud835\udc36\ud835\udc3b\ud835\udc56 . \ud835\udc462, \ud835\udc44\ud835\udc36\ud835\udc40\ud835\udc56\ud835\udc57 \ud835\udc463, \ud835\udc464), \ud835\udc44\ud835\udc46, \ud835\udc44\ud835\udc36\ud835\udc3b\ud835\udc56 , \ud835\udc44\ud835\udc36\ud835\udc40\ud835\udc56\ud835\udc57 } to its memory. Sink (ES\u00b7S1, S2, S3) CH1 (ES\u00b7S1, ECH1\u00b7S2, S3) CH2 ... CHj CM11 CM12 CM1k ... CM21 CM22 ... CM2k CMi1 CMi2 CMjk ... ...", "snippet_links": [{"key": "agreement-protocol", "type": "clause", "offset": [47, 65]}], "size": 1, "hash": "6c1928045a9f852b5ae6eafddab27240", "id": 3}, {"samples": [{"hash": "dbM4T0aoxzO", "uri": "/contracts/dbM4T0aoxzO#proposed-protocol", "label": "Group Key Agreement Protocol", "score": 19.8531193306, "published": true}], "snippet": "Step 1: Preparing user contribution and signa- ture Each user Ui with identity IDi chooses its con- tribution (xi) randomly. Let Ci be the current value of counter for user \u2587\u2587. The values of (IDi||ID0||xi||Ci) are then encrypted with U0\u2019s public key. Here || denotes the concatenation op- eration. ei = {IDi||ID0||xi||Ci}pu0 Ui also takes a signature sigi of (IDi||ID0||xi||Ci) using it\u2019s private signature key. sigi = \u03c4 pri (IDi||ID0||xi||Ci) Each user then sends ei, sigi to the U0. Ui \u2192 U0 : ei, sigi All these operations can be performed offline. The advantage of using counter over timestamp is that the operations involving the counter can be per- formed offline. \u2022 Step 2: Receipt of user message and verification at U0 The U0 receives all the messages and decrypts them. It then verifies all the signatures of the cor- responding users. It also checks the validity of the counter Ci and accepts if the signatures are valid. \u2022 Step 3: Computation of secret by U0 The pair of identity and random value (IDi, xi) re- ceived from each user is taken as it\u2019s contribution to construct the key. U0 also selects a random number x0 \u2208 G p as its contribution. The secret is constructed by interpolating all the contributions into a polynomial. The n + 1 values of (IDi, xi) are taken as (n + 1) input points to the interpola- tion algorithm. As, all the identities of the users are distinct, a distinct polynomial will be obtained from the fresh input. Let the coefficients of the resulting polynomial be a0, a1, . . . , an. Thus the polynomial is as follows: A(x) = a0 + a1x + a2x2 + . . . + anxn The secret value is constructed as K = (a0||a1|| . . . ||an). \u2022 Step 4:Computation of reply message from U0 For each user Ui, U0 computes a one way hash H (IDi, ID0, xi,Ci) over the identity IDi, ID0, counter Ci and contribution xi. Then the secret value K is bitwise XORed with this hash value to", "snippet_links": [{"key": "step-1", "type": "clause", "offset": [0, 6]}, {"key": "current-value", "type": "definition", "offset": [139, 152]}, {"key": "public-key", "type": "definition", "offset": [239, 249]}, {"key": "the-operations", "type": "clause", "offset": [605, 619]}, {"key": "step-2", "type": "definition", "offset": [672, 678]}, {"key": "receipt-of", "type": "clause", "offset": [680, 690]}, {"key": "validity-of-the", "type": "clause", "offset": [864, 879]}, {"key": "step-3", "type": "clause", "offset": [934, 940]}, {"key": "computation-of", "type": "clause", "offset": [942, 956]}, {"key": "to-construct", "type": "clause", "offset": [1074, 1086]}, {"key": "the-contributions", "type": "clause", "offset": [1205, 1222]}, {"key": "step-4", "type": "clause", "offset": [1660, 1666]}, {"key": "hash-value", "type": "definition", "offset": [1880, 1890]}], "size": 1, "hash": "bf36d8ae2057f7388c0730bc3cda8bb1", "id": 4}, {"samples": [{"hash": "3iQxgI4HYIn", "uri": "/contracts/3iQxgI4HYIn#proposed-protocol", "label": "Certificateless Authenticated Key Agreement Protocol", "score": 20.501093135, "published": true}], "snippet": "\u200c The basic architecture of proposed DRM system is similar to \u2587\u2587\u2587 et al. [10] system. Here, the content provider handles the content packing (encryption) work. Once the content encryption is over, it provides the content key with usage rules to the license server and protected content with content information to the distributor. License server authenticates the user, receives the payment, and generates the license. While, Distributor works as a service provider and facilitates the protected content distribution in the system. Parties involved in our DRM model are: \u2013 Private key generator (PKG) \u2013 Content provider (C) \u2013 Distributor (D) \u2013 License server (L) \u2013 DRM User (U ) Content provider keeps the original unprotected digital contents and provides these contents for business use after their encryption. If it has r contents, namely, M1, M2,..., Mr with their unique identity idM1 , idM2 ,..., idMr . Then, he gener- ates r symmetric keys K1, K2, K3,... , Kr and encrypts each content with an unique symmetric key and gets Esym(Mi|Ki), i = 1, 2, 3,..., r. Content provider provides content decryption keys (key seeds) with usage rules and permissions to the license server through a secure channel. Distributor achieves encrypted contents Esym(Mi Ki), for all i = 1, 2, 3,..., r with con- tent information from the Packager. Distributors keep protected contents over the media server and display content details over the website. To communicate securely in the system, entities achieve their secret partial keys with the help of packager and generates their public and private keys. In this process system usages five algorithms: Setup, Partial private key extract, Set secret value, Set private key and Set public key. Description of key generation process is as follows: Setup: Private key generator (PKG) chooses an arbitrary generator P \u2208 G1, selects a master key mk \u2208 Zq\u2217 and sets PK = mkP . It chooses hash functions H1 : {0, 1}\u2217 \u2192 G1\u2217 , H2 : {0, 1}k \u00d7 {0, 1}\u2217 \u00d7 {0, 1}\u2217 \u2192 {0, 1}n, and H : {0, 1}\u2217 \u00d7 {0, 1}\u2217 \u00d7 G1 \u00d7 G1 \u00d7 G2 \u2192 {0, 1}k. Then, PKG publishes system parameters \u2587\u2587, \u2587\u2587, \u2587(., .), \u2587, \u2587, \u2587\u2587, \u2587\u2587, \u2587\u2587,\u2587 and Keep master key mk secret. Partial Private key extraction: License server (L) and user U submit their public identities IDL and IDU to the PKG. Then, PKG verifies the proof of identities. If verification succeeds, then generates the partial private keys in the following way: \u2013 Compute QL = H1(IDL) andQU = H1(IDU ) G\u22171 . \u2013 By using its master key mk, PKG generates the partial private \u2587\u2587\u2587\u2587 \u2587\u2587 = mkQL and WU = mkQU and delivers these partial \u2587\u2587\u2587\u2587 \u2587\u2587 and \u2587\u2587 to L and U respectively through a secure channel. On receiving their partial private keys L and U can verify their partial keys respectively as follows: e(WL,P ) = e(mkQL,P ) = e(QL, mkP ) = e(QL, PK) e(\u2587\u2587 ,P ) = e(mkQU ,P ) = e(QU , mkP ) = e(QU , PK). Private and public key extraction: L and U achieve their private and public keys as follows: \u2013 L selects a secret value xL \u2208 Zq\u2217 at random and keeps xL secret. Then, L generates its private key SKL by computing SKL = xLWL = xLmkQL. L constructs its public key PKL = \u27e8XL, YL\u27e9 where XL = xLP and YL = xLPK = xLmkP . \u2013 U selects a secret value xU \u2208 Zq\u2217 at random and keeps xU secret. Then, U generates its private key SKU by computing SKU = \u2587\u2587 \u2587\u2587 = xU mkQU . U constructs its public key PKU = \u27e8XU , YU \u27e9 where XU = xU P and YU = xU PK = xU mkP .", "snippet_links": [{"key": "basic-architecture", "type": "clause", "offset": [6, 24]}, {"key": "similar-to", "type": "definition", "offset": [51, 61]}, {"key": "content-provider", "type": "definition", "offset": [96, 112]}, {"key": "usage-rules", "type": "clause", "offset": [230, 241]}, {"key": "license-server", "type": "clause", "offset": [249, 263]}, {"key": "protected-content", "type": "definition", "offset": [268, 285]}, {"key": "the-distributor", "type": "definition", "offset": [314, 329]}, {"key": "the-user", "type": "clause", "offset": [360, 368]}, {"key": "the-payment", "type": "clause", "offset": [379, 390]}, {"key": "a-service-provider", "type": "definition", "offset": [447, 465]}, {"key": "content-distribution", "type": "clause", "offset": [496, 516]}, {"key": "the-system", "type": "definition", "offset": [520, 530]}, {"key": "parties-involved", "type": "clause", "offset": [532, 548]}, {"key": "key-generator", "type": "definition", "offset": [581, 594]}, {"key": "the-original", "type": "definition", "offset": [702, 714]}, {"key": "business-use", "type": "clause", "offset": [776, 788]}, {"key": "information-from", "type": "clause", "offset": [1303, 1319]}, {"key": "the-media", "type": "clause", "offset": [1376, 1385]}, {"key": "display-content", "type": "clause", "offset": [1397, 1412]}, {"key": "the-website", "type": "clause", "offset": [1426, 1437]}, {"key": "private-keys", "type": "definition", "offset": [1578, 1590]}, {"key": "process-system", "type": "definition", "offset": [1600, 1614]}, {"key": "public-key", "type": "definition", "offset": [1717, 1727]}, {"key": "description-of", "type": "definition", "offset": [1729, 1743]}, {"key": "key-generation", "type": "definition", "offset": [1744, 1758]}, {"key": "master-key", "type": "clause", "offset": [1866, 1876]}, {"key": "hash-functions", "type": "clause", "offset": [1917, 1931]}, {"key": "system-parameters", "type": "clause", "offset": [2069, 2086]}, {"key": "proof-of", "type": "clause", "offset": [2294, 2302]}], "size": 1, "hash": "20f6bcad990026d11d9a7b92b0473d2f", "id": 5}, {"samples": [{"hash": "jmvj2pdZNfi", "uri": "/contracts/jmvj2pdZNfi#proposed-protocol", "label": "Key Agreement Protocol", "score": 19.0, "published": true}], "snippet": "In this subsection, we describe the steps involved in detail.\ni. A chooses a random number ra and generates R = g ra (mod p) then encrypts RA with H (PA ) . After calculating the values sends it to server along with IDs of participating entities. A \u2192 S \u2587\u2587\u2587 , IDB , H (PA )[RA ]\nii. After receiving the values sent by A, server S decrypts the packet to get RA by previously distributed one way hash of password of A. server randomly chooses rs1 and rs2 and computes ephemeral key with A as follows K = (R )rs1(mod p) = (gra )rs1 mod p g rs1 (mod p) and grs2 (mod p) and encrypts with H (PA ) and H (PB ) respectively. Using these quantities server establishes ephemeral keys with A and B respectively and server authentication is done. S sends the values to A\niii. A decrypts this packet with H (PA ) to get g rs1 (mod p) and establishes ephemeral key with S as KAS = (grs1)ra mod p .A calculates one way function FA (PA , KAS ) using which server authenticates A, since only A knows PA it can compute this function. As this is a commutative one way hash function [14], server need not know host password to evaluate this function. Using one way hash of host password server can calculate predicate function and authenticate host. A sends the following values to B FA (PA , KAS ), H (P )(grs2 mod p)\niv. After receiving the values B decrypts it with H (PB ) to get (grs2 mod p) .B chooses randomly rb and generates RB = g rb (mod p) .Then computes ephemeral key for authenticating server as KBS = (grs2 )rb mod p . B calculates one way function FB (PB , KBS ) , using which server authenticates B. Password of B and ephemeral session key KBS are seeds for this function. Since only B knows PB it can compute this function and sends the values to S.\nB \u2192 S FA (PA , KAS ), FB (PB , KBS ), H (PB )[RB ]\nv. server decrypts it with H (PB ) to get RB and computes ephemeral key K = (grb )rs2 mod p . For authentication of A and B server evaluates one way functions FA (...), FB (...) . server need not know host passwords to evaluate these functions. Using one way hash of host password it can evaluate this function as it is a commutative one way hash function. If it results into true then it confirms that host is genuine. It defines a predicate as T (H (P), F (P, K ), K ) . This evaluates to true if and only if the genuine password P was used to create both H (P) and F (P, K ) . K can be KAS , KBS for A and B respectively. S encrypts RB and RA with KAS , KBS respectively and computes one way hash function HK (RA , RB ) using KAS (one time key shared between A and server). Using this host A authenticates the server. Similarly S computes one way hash function HK (RA , RB ) using KBS (one time key shared between B and server) and authenticates B and sends the values to B. S \u2192 B EK (RB ), EK (RA ), HK (RA , RB ), HK (RA , RB )\nvi. After receiving this B decrypts E (R ) with KBS and gets RA . Since KBS is shared between server and B, it ensures B that RA value is from authentic source. B computes one way hash HK (RA , RB ) using KBS as key and authenticates server. B computes session key with A as K = (R )rb (mod p) . B computes a one way hash HK (NAB ) using KAB and NAB as seeds, where NAB is a random number. This one way hash is used for key confirmation (assures that both parties posses same session key). Since NAB is transmitted in plain there is no need of decryption. One way hash suffices decryption. After computing all the values it sends to A.\nB \u2192 A EK (RB ), HK (RA , RB ), HK (NAB ), NAB\nvii. A decrypts E (R ) using KAS to get RB . Since KAS is shared between server and A, it ensures A that RB value is from authentic source. A computes session key with B as K = (R )ra (mod p) .Using KAB and NAB HK (NAB ) and verifies that B posses same key ( KAB ) as A. Using KAB , A once again calculates one way hash H (H (N )) and sends to B. H (H (N ))\nviii. Finally, after receiving this B computes this one way hash using posses same session key ( KAB ) as B. The detail is explained in Fig-1. KAB and verifies that A", "snippet_links": [{"key": "this-subsection", "type": "definition", "offset": [3, 18]}, {"key": "in-detail", "type": "clause", "offset": [51, 60]}, {"key": "calculating-the", "type": "clause", "offset": [163, 178]}, {"key": "participating-entities", "type": "definition", "offset": [223, 245]}, {"key": "after-receiving", "type": "clause", "offset": [282, 297]}, {"key": "a-and-b", "type": "definition", "offset": [679, 686]}, {"key": "session-key", "type": "definition", "offset": [1625, 1636]}, {"key": "ra-value", "type": "definition", "offset": [2958, 2966]}, {"key": "both-parties", "type": "clause", "offset": [3283, 3295]}], "size": 1, "hash": "8ca43816058fe5366116a6397fe95526", "id": 6}, {"samples": [{"hash": "gbctAiH3Krj", "uri": "/contracts/gbctAiH3Krj#proposed-protocol", "label": "Group Key Agreement Protocol", "score": 24.5431693498, "published": true}], "snippet": "This section describes that initially how n numbers of members agreed up on a common session key under ini- tialization operation followed by the the join and leave procedures. of Algorithm 2 started from Ki+1 which is equivalent to the following calculations: U = U1, U2, , Un be the set of mobile nodes. Secondly, each group at beginning must know the identity of Ki+1 R = X others group members by some sort of other mechanism. Thirdly the protocol assumes a trusted server which is responsible for private key generation for the users, called key generation centre (KGC) in the system. The subscript notation for the participants are must be considers in logical ring fashion e.g. Un+1 = U1 and U0 = Un in entire paper.", "snippet_links": [{"key": "of-members", "type": "clause", "offset": [52, 62]}, {"key": "session-key", "type": "definition", "offset": [85, 96]}, {"key": "leave-procedures", "type": "clause", "offset": [159, 175]}, {"key": "group-members", "type": "clause", "offset": [384, 397]}, {"key": "the-protocol", "type": "clause", "offset": [439, 451]}, {"key": "responsible-for", "type": "clause", "offset": [486, 501]}, {"key": "private-key-generation", "type": "clause", "offset": [502, 524]}, {"key": "the-system", "type": "definition", "offset": [578, 588]}, {"key": "the-participants", "type": "clause", "offset": [617, 633]}], "size": 1, "hash": "446e0250d07da5c1b18aff391b4e032b", "id": 7}, {"samples": [{"hash": "aWN4RiIdPn0", "uri": "/contracts/aWN4RiIdPn0#proposed-protocol", "label": "Independent Contractor Agreement", "score": 25.1710422267, "published": true}], "snippet": "Consistent with the pilot projects that have been deployed in Canada, we propose the following protocol: Type of ash tree configurations:", "snippet_links": [{"key": "consistent-with-the", "type": "clause", "offset": [0, 19]}, {"key": "pilot-projects", "type": "clause", "offset": [20, 34]}, {"key": "in-canada", "type": "definition", "offset": [59, 68]}, {"key": "type-of", "type": "definition", "offset": [105, 112]}], "size": 1, "hash": "ccfcb0449eab771331b8361130a7e217", "id": 8}, {"samples": [{"hash": "9xqg2zmqrzP", "uri": "/contracts/9xqg2zmqrzP#proposed-protocol", "label": "Byzantine Agreement & Fault Diagnosis Agreement", "score": 19.0, "published": true}], "snippet": "\u201cMobile Ad-Hoc Agreement Protocol\u201d (MAHAP) collect the messages, the decision-making phase is used to compute a common agreement value for The message-exchange phase is used to The BA protocol involves making each fault-free node agree on a common value transmitted by the source node. Therefore, there are three phases in the MAHAP: message-exchange phase, decision-making phase and extension-agreement phase. the BA problem and the extension-agreement phase is used to allow return nodes to compute a common agreement value that is the same as that of other fault-free nodes\u2019 agreement value. In addition, the number of rounds required for executing MAHAP is t+1 (t\u2264\u23a3(n-1)/3\u23a6). The MAHAP protocol can tolerate fm malicious faulty nodes, and fa away nodes, where n>3fm+fa.", "snippet_links": [{"key": "agreement-protocol", "type": "clause", "offset": [15, 33]}, {"key": "the-decision", "type": "clause", "offset": [65, 77]}, {"key": "phase-is", "type": "definition", "offset": [85, 93]}, {"key": "agreement-value", "type": "clause", "offset": [119, 134]}, {"key": "common-value", "type": "definition", "offset": [241, 253]}, {"key": "the-source", "type": "clause", "offset": [269, 279]}, {"key": "in-addition", "type": "clause", "offset": [595, 606]}, {"key": "number-of", "type": "clause", "offset": [612, 621]}], "size": 1, "hash": "bc8344a7bece39b2bf7ecbcd7278a079", "id": 9}, {"samples": [{"hash": "8taUqcrPSWI", "uri": "/contracts/8taUqcrPSWI#proposed-protocol", "label": "Blockchain Based Authentication and Dynamic Group Key Agreement Protocol", "score": 31.6510972543, "published": true}], "snippet": "\u200c In the distributed group key agreement protocol, each group member is equal, which means that before the group key is negotiated, each group member usually needs to consume many communication and computing resources to perform mutual authentication with all other group members. In order to reduce these costs, in our protocol, we arrange all GNs into a list according to their identities. According to the list, before the group key is negotiated, each GN only needs to send an authentication request to its right neighbor once and be authenticated by its right neighbor. In other words, each GN will receive an authentication request from its left neighbor and authenticate its left neighbor. Since each GN only needs to complete authentication once, this can greatly reduce the computation and communication costs caused by authentication between group members. In addition, when any GN needs to join or leave the group, only the left neighbor of the GN needs to update the parameters, which can also reduce the computation and communication overhead. Our protocol has seven parts: the initialization phase, the registration phase, the mutual authentication phase, the group key generation phase, the GN join phase, the GN leave phase, and the internal attacker detection process. When the system runs for the first time, the initialization phase is performed by the System Administrator (SA). Each GN performs the registration phase before entering the network. When the group key needs to be negotiated, all GNs perform the mutual authentication phase and the group key generation phase. When a GN wants to join a group, it needs to perform the GN join phase. When a GN in the group wants to leave, the GN leave phase is performed. If the group key fails to be generated multiple times, the KDC will execute the internal attacker detection process to find the malicious GN and expel it from the group. Suppose there are GNi(1 \u2264 i \u2264 n) that need to generate the group key, and their identities are IDi(1 \u2264 i \u2264 n), where n is the number of GN. Since there may be multiple groups, we named each group GIDu, where u is the number of groups. Each group has a list L that stores the identity IDi of all GNs in the group and is managed by the KDC. All IDi in L are sorted in descending order, and L is a circular list, which means that the largest IDi and the smallest IDi are linked. Table 1 shows the description of the symbols. The details of the above seven parts are as follows.\nTable 1. Symbols used in our protocol. SA System Administrator KDC Key Distribution Center GN General node G1 Cyclic additive groups of prime order q G2 Cyclic multiplicative groups of prime order q Q The generator of G1 e Bilinear pairing e : G1 G1 G2 IDi The identity of GNi GIDu The identity of the group L A circular list that stores all GN-related information in the group Ppub The KDC\u2019s public key Wi , Ai The GN\u2019s public key Si , ai The GN\u2019s private key t1, t2 Timestamp tnew The timestamp when the latest information was received \u2206t Maximum communication transmission delay KTi Symmetric key Ek Symmetric encryption algorithm Dk Symmetric decryption algorithm h(.) Hash operation (a, b) Concatenation of data a and data b", "snippet_links": [{"key": "agreement-protocol", "type": "clause", "offset": [31, 49]}, {"key": "the-group", "type": "clause", "offset": [103, 112]}, {"key": "computing-resources", "type": "definition", "offset": [198, 217]}, {"key": "mutual-authentication", "type": "clause", "offset": [229, 250]}, {"key": "group-members", "type": "clause", "offset": [266, 279]}, {"key": "in-order-to", "type": "clause", "offset": [281, 292]}, {"key": "a-list", "type": "definition", "offset": [354, 360]}, {"key": "according-to", "type": "definition", "offset": [361, 373]}, {"key": "authentication-request", "type": "definition", "offset": [481, 503]}, {"key": "communication-costs", "type": "definition", "offset": [799, 818]}, {"key": "caused-by", "type": "clause", "offset": [819, 828]}, {"key": "in-addition", "type": "clause", "offset": [867, 878]}, {"key": "communication-overhead", "type": "clause", "offset": [1033, 1055]}, {"key": "initialization-phase", "type": "clause", "offset": [1091, 1111]}, {"key": "registration-phase", "type": "clause", "offset": [1117, 1135]}, {"key": "the-mutual", "type": "definition", "offset": [1137, 1147]}, {"key": "authentication-phase", "type": "clause", "offset": [1148, 1168]}, {"key": "key-generation", "type": "definition", "offset": [1180, 1194]}, {"key": "the-system", "type": "definition", "offset": [1291, 1301]}, {"key": "first-time", "type": "definition", "offset": [1315, 1325]}, {"key": "phase-is", "type": "definition", "offset": [1346, 1354]}, {"key": "performed-by", "type": "clause", "offset": [1355, 1367]}, {"key": "system-administrator", "type": "clause", "offset": [1372, 1392]}, {"key": "the-network", "type": "clause", "offset": [1455, 1466]}, {"key": "to-be-negotiated", "type": "clause", "offset": [1493, 1509]}, {"key": "to-generate", "type": "definition", "offset": [1952, 1963]}, {"key": "number-of", "type": "clause", "offset": [2035, 2044]}, {"key": "where-u", "type": "clause", "offset": [2111, 2118]}, {"key": "table-1", "type": "clause", "offset": [2385, 2392]}, {"key": "description-of-the", "type": "definition", "offset": [2403, 2421]}, {"key": "details-of-the", "type": "clause", "offset": [2435, 2449]}, {"key": "distribution-center", "type": "definition", "offset": [2555, 2574]}, {"key": "the-generator", "type": "clause", "offset": [2685, 2698]}, {"key": "related-information", "type": "definition", "offset": [2829, 2848]}, {"key": "public-key", "type": "definition", "offset": [2877, 2887]}, {"key": "private-key", "type": "definition", "offset": [2933, 2944]}, {"key": "transmission-delay", "type": "clause", "offset": [3047, 3065]}], "size": 1, "hash": "c83449623ea58dec85fce9a0de8c8b27", "id": 10}], "next_curs": "CloSVGoVc35sYXdpbnNpZGVyY29udHJhY3RzcjYLEhZDbGF1c2VTbmlwcGV0R3JvdXBfdjU2Ihpwcm9wb3NlZC1wcm90b2NvbCMwMDAwMDAwYQyiAQJlbhgAIAA=", "clause": {"children": [["", ""], ["initialization-phase", "Initialization Phase"], ["group-key-generation-phase", "Group Key Generation Phase"], ["registration-phase", "Registration Phase"], ["gn-leave-phase", "GN Leave Phase"]], "title": "Proposed Protocol", "size": 11, "parents": [["user-verifiable-contributory-key-agreement", "USER-VERIFIABLE CONTRIBUTORY KEY AGREEMENT"]], "id": "proposed-protocol", "related": [["protocol", "Protocol", "Protocol"], ["research-plan", "Research Plan", "Research Plan"], ["development-plan", "Development Plan", "Development Plan"], ["research-use-reporting", "Research Use Reporting", "Research Use Reporting"], ["review-protocol", "Review Protocol", "Review Protocol"]], "related_snippets": [], "updated": "2025-07-07T12:37:48+00:00"}, "json": true, "cursor": ""}}