<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Maneesha S on Medium]]></title>
        <description><![CDATA[Stories by Maneesha S on Medium]]></description>
        <link>https://medium.com/@manishas053?source=rss-406ce43494e7------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*b6to9chkVIsN0YXI.</url>
            <title>Stories by Maneesha S on Medium</title>
            <link>https://medium.com/@manishas053?source=rss-406ce43494e7------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 14:25:02 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@manishas053/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[BLS Signature]]></title>
            <link>https://medium.com/@manishas053/bls-signature-c52a5cbdcd92?source=rss-406ce43494e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/c52a5cbdcd92</guid>
            <category><![CDATA[distributed-systems]]></category>
            <category><![CDATA[security]]></category>
            <dc:creator><![CDATA[Maneesha S]]></dc:creator>
            <pubDate>Mon, 23 Oct 2017 13:38:24 GMT</pubDate>
            <atom:updated>2017-11-17T05:38:46.060Z</atom:updated>
            <content:encoded><![CDATA[<p>Dan Boney, Ben Lyn and Hovav Schacham, three professors from Stanford University introduced a short signature scheme known as BLS signature which allows a user to verify that a signer is authentic. The main advantage of using BLS signature is that its signature length is half the size of DSA signature for a similar level of security. Say for example, for a 1024 bit modulus, DSA algorithm produces a signature of 320 bits while BLS produces a signature of length 160 bit.</p><p>This scheme is provably secure assuming both the existence of random oracles and the intractability of the computational Diffie-Hellman problem. In order to achieve all these, it uses Gap Diffie Hellman(GDH) class using pairing over elliptic curves. GDH is a group where Computational Diffie Hellman(CDH) problem is defined to be hard but Decisional Diffie Hellman(DDH) problem is easy.</p><p><strong><em>CDH problem: </em></strong>For any two integers in a multiplicative group [a, b ∈ Z*p] and g ∈ G’ where G’ is a multiplicative cyclic group, given (g, g^a, g^b) compute g^ab.</p><p><strong><em>DDH problem: </em></strong>For a, b, c ∈ Z*p and g ∈ G’, given (g, g^a, g^b, g^c) decide whether c = ab.</p><p>For BLS signature we take elliptic curve groups on which GDH groups are formed. It performs some operations on the elements of such groups and the resulting signature will also be in that elliptic curve. For signature verification, it uses pairing functions. Pairing is one of the functions on specified elliptic curves. Let us consider a group G on elliptic curves enabling pairing. Let e denote the symbol for pairing function.</p><p><em>A pairing function has the following properties:</em></p><blockquote>* For P1, P2, Q ∈ G, then e(P1+P2, Q) = e(P1, Q) e(P2, Q).</blockquote><blockquote>* For P, Q1, Q2 ∈ G, then e(P, Q1+Q2) = e(P, Q1) e(Q, P2).</blockquote><blockquote>* For a, b ∈ Z*p and P, Q ∈ G, then e(aP, bQ) = e(bP, aQ) = e(abP, Q) = e(P, abQ) = e(P, Q)ab.</blockquote><p>Now lets see how BLS signature scheme works.</p><p>BLS signature scheme comprises of 3 stages : Key Generation, Signing and Verification</p><h4><strong>Key Generation:</strong></h4><p>Suppose g is a generator of a group G. Secret key of a signer is a random element x ∈ Z*p while his public key is v =xg.</p><h4>Signing:</h4><p>H is a one way hash function, which outputs a random element in the whole group G. Let m be the plain message which is to be signed. Signer computes h = H(m) and returns σ = xh where σ is the signature on message m.</p><h4>Verification:</h4><p>When the verifier is given g, v, m and σ, he computes h=H(m) and verifies if (g, v, h, σ) is a valid Diffie Hellman tuple. That is, it checks if e(g, σ)=e (v, h).</p><p>If a signer generates a signature correctly, then a verifier can verify the signature as follows:</p><p>e(g, σ) = e(g, xh) = e(g, h)^x (from the 3rd property of pairing function)</p><p>Similarly, e(v, h) = e(xg, h) = e(x, h)^x</p><p>Therefore if e(g, σ) = e( v, h), then σ has been gener­ated correctly.</p><p>BLS signatures can be generated in a single round trip time. It may offer an appealing alternative cryptographic foundation for Collective Co-Signing(CoSi), requiring pairing-based elliptic curves but avoiding the need for two communication round-trips.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c52a5cbdcd92" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Imitation Game]]></title>
            <link>https://medium.com/@manishas053/the-imitation-game-565cfa976047?source=rss-406ce43494e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/565cfa976047</guid>
            <category><![CDATA[technology]]></category>
            <dc:creator><![CDATA[Maneesha S]]></dc:creator>
            <pubDate>Thu, 05 Oct 2017 13:53:58 GMT</pubDate>
            <atom:updated>2017-10-05T13:53:58.325Z</atom:updated>
            <content:encoded><![CDATA[<p>The Imitation Game is a 2014 American film directed by Morten Tyldum and written by Graham Moore based on the biography Alan Turing: The Enigma by Andrew Hodges. At the beginning of the movie, we see two cops head into Alan Turing’s home to investigate a robbery at Turing’s place. During his interrogation, Turing tells of his time working at Bletchley Park. During the World War II, he joins the cryptographic team in Bletchley Park to decrypt the Enigma machine, which Nazis use to send encrypted messages. The problem is that Enigma is recoded every day, so that even if the team can decipher a coded message transmitted by the Nazis, that code would be obsolete by the next day. While the rest of the team work on breaking the day-to-day codes, Alan works by himself on developing a machine to break any code immediately when it is input into Enigma. Turing’s machine, which he names Christopher, is constructed, but cannot determine the Enigma settings before the Germans reset the Enigma encryption each day. He proposes one of the team mate Joan and during his engagement party however, Turing confesses to John that he is homosexual. That evening, a girl who Hugh strikes up a conversation with, says something about familiar words exchanged between two people. By narrowing down the familiar phrases words routinely exchanged by the Enigma machines, he could make cracking the codes easy. And it works. They crack the codes. Turing realises they cannot act on every decoded message or the Germans will realise Enigma has been broken. After the war, Menzies tells the cryptographers to destroy their work and that they can never see one another again or share what they have done.</p><p>Turing has been sentenced for indecency (homosexuality) and given the choice of jail time or chemical castration. Turing choses chemical castration else he wont be able to work and they may destroy Christopher. Two years later, Turing committed suicide by cyanide, using an apple as the delivery device.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=565cfa976047" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How To Prove Yourself: Practical Solutions to Identification and Signature Problems]]></title>
            <link>https://medium.com/@manishas053/how-to-prove-yourself-practical-solutions-to-identification-and-signature-problems-66345a8f3495?source=rss-406ce43494e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/66345a8f3495</guid>
            <category><![CDATA[blockchain]]></category>
            <dc:creator><![CDATA[Maneesha S]]></dc:creator>
            <pubDate>Mon, 21 Aug 2017 17:21:15 GMT</pubDate>
            <atom:updated>2017-08-21T17:21:15.593Z</atom:updated>
            <content:encoded><![CDATA[<p>Most of the identification and signature schemes rely on the shared or public keys. With the help of the shared or public key one can prove his identity and the authenticity of his messages to the other. This paper describes a new method which can be used for identification and signatures without any shared or public key. Its security is based on discrete logarithm problem and it is provably secure against any known or chosen message attack. The protocol distinguishes between three levels of protection: Authentication scheme, Identification scheme and Signature scheme.</p><p>The identification scheme is a combination of zero-knowledge interactive proofs and identity-based schemes. That is, it enables any pair of users to communicate securely and to verify each other’s signatures without exchanging public or private keys, without keeping any key directories and without using the services of any third party. The protocol assumes a trusted center which issues smart cards to users. Once the trusted center issues the smart card, further interaction with the trusted center is not required either to generate or to verify the proof of identities. The center chooses a value modulus n (which is the product of two large prime numbers p and q) and a random function f. Everyone can use the same n because only the center knows the factorization of the modulus. When a user applies for a smart card, the center prepares a string I which contains all the relevant information about the user and about the card. It then compute the values vj = f (I, j) for small values of j. It pick k distinct values of j for which vj is a quadratic residue (mod n) and compute smallest square root sj of vj^-1 (mod n) and issue a smart card which contains I, the k sj values. The user will be using this I for further proceedings. Suppose say A is the prover and B is the verifier. A will send this I to B. B generates vj = f(I, j) for j = 1 to k. A then picks a random ri and sends xi = ri² modn to B. B sends a random binary vector (ei1,……,eik) to A. A sends yi = ri Πsj modn to B. B checks that xi = yi² Πvj modn. This is how identification scheme works.</p><p>In the signature scheme, in order to sign a message m, A picks a random ri and computes xi = ri² modn for i = 1 to t. It then computes f(m, x1,…, xt) and uses its first kt bits as eij values. A computes yi = ri Π sj modn for i = 1 to t and sends I, m, the eij matrix, and yi to B. The verification process includes B computing vj = f(I, j) for j = 1 to k. B then computes zi = (yi ^2) Πvj modn for i= 1 to t. B verifies that the first kt bits of f(m, z1,….., zt) are eij.</p><p>The proof of security assumes that n is sufficiently large and f is a truly random function. Consequently, there can be no generic attack which breaks the scheme for any n and f unless factoring is easy. The schemes are provably secure against any known or chosen message attack if factoring is difficult, and the typical implementation requires only 1% to 4% of the number of modular multiplications required by the RSA scheme.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=66345a8f3495" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Schnorr Signature]]></title>
            <link>https://medium.com/@manishas053/schnorr-signature-e940343d40da?source=rss-406ce43494e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/e940343d40da</guid>
            <category><![CDATA[blockchain]]></category>
            <dc:creator><![CDATA[Maneesha S]]></dc:creator>
            <pubDate>Sun, 20 Aug 2017 08:38:25 GMT</pubDate>
            <atom:updated>2017-08-20T08:38:25.569Z</atom:updated>
            <content:encoded><![CDATA[<p>In cryptography, Schnorr signature is considered the simplest digital signature scheme that is provably secure. Schnorr signature is an efficient identification and signature scheme that is suitable for smart cards. Its security is based on discrete logarithm problem. The paper proposes an efficient algorithm to preprocess the exponentiation of random numbers. This makes the signature generation very fast.<br>The main advantage of the Schnorr signature is that most of the computations can be done before sending the message thus increasing the speed. The important parameters includes p which is a prime number, q which is a factor of p-1. There is a base α such that α^q = 1 modp. All these parameters are global. Key Authentication Center (KAC) chooses p, q, α, a one way hash function h, and a public and private key. When a user comes for registration, KAC verifies its identity and generates an identification string I and signs the pair (I, v) where v is the public key of the user. Each user can choose its own private key, s which should be between 0 and q. Once the private key is chosen, the public key can be computed by v = α ^ (-s) modq.<br>The identification protocol involves initiation in which prover A send (I, v) to verifier B. B checks v by verifying the KAC’s signature sent by A. The second step is preprocessing in which A chooses a random number r, computes x = α ^ r modp and sends it to B. B sends back another random e. A computes y = r + se modq and sends to B. The final step is identification step in which B computes x = (α ^ y) (v ^ e) (mod p) and checks if the computed x is same as the one sent by A.<br>Inorder to sign a message r is chosen between 0 and q, and it is used to compute the x value ie, α ^ r (mod p). The x is concatenated with the message M and hashed to get e value. y = r + se modq is also computed. Message M and the signature (e, y) is sent to the receiver. Here note that while digitally signing a message we are not hiding the message, but we are verifying actually who did sent the message. The receiver have M, e, y and the publically known parameters like a, p, q, and v. For verification receiver first computes x’ = (α ^ y) (v ^ e) modp. If the signature is valid then x’ will be same as x. However x is not given to B. So B computes e by concatenating x’ with the original message M and hashing it and checks if both e’s are the same.<br>The purpose of preprocessing algorithm is the reduction of computational effort. Each user initially stores a collection of k pairs (ri, xi). Here k is a security parameter and its proposed value is k = 8. For each signature, the pair (r, x) is chosen as a combination of the currently stored pairs (ri, xi), while the stored collection is rejuvenated by replacing one of these pairs by a similar combination.<br>It is proposed to take p and q in the order of 512 bits and 140 bits respectively in order to obtain security level of 2 ^72. For the preprocessing algorithm, the parameters k = 8, and d = 6. For the new scheme the number of multiplication steps and the length of signatures are independent of the bit length of p. Only the length of the public key depends on p. Compared to other algorithms this scheme is most efficient for signature generation.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e940343d40da" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Reaching Agreement in the Presence of Faults]]></title>
            <link>https://medium.com/@manishas053/reaching-agreement-in-the-presence-of-faults-67b0a1b23b6a?source=rss-406ce43494e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/67b0a1b23b6a</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[distributed-systems]]></category>
            <dc:creator><![CDATA[Maneesha S]]></dc:creator>
            <pubDate>Fri, 30 Jun 2017 16:09:57 GMT</pubDate>
            <atom:updated>2017-06-30T16:09:57.611Z</atom:updated>
            <content:encoded><![CDATA[<p>Distributed system possess certain problems out of which the faulty behaviour of processors is being addressed in this paper. While considering a set of isolated processors, some may be faulty that eventually induces inconsistencies. Each processor has a private value which must be communicated with each other. The faulty processors may lie during the communication so that the value inferred by each processor may differ and hence the system will show inconsistency. This algorithm allows the independent processors to arrive at an exact mutual agreement in such a way that the value inferred for a non faulty processor is that processor’s private value and the value inferred for a faulty processor is consistent with the corresponding value inferred by each other non faulty processor. The algorithm works for a total of 3m+1 processors in which m is the number of faulty ones.</p><p>The basic idea of the algorithm is that the processors in the system compute a vector of values for every processor such that the non faulty processors compute the exact same vector and the element of this vector corresponding to a given non faulty processor is the private value of that processor. This guarantees interactive consistency as it allows the non faulty processors to come to a consistent view of all processors. The vector computed by the processors is known as the interactive consistency(ic) vector.</p><p>Consider a single fault case which has n=4 and m=1. For a system with one faulty processor, two rounds of communication is required. In the first round, the processors will exchange their own private value and in the second round, they exchange the results obtained in the first round. The processors computes the ic vector on the basis of the results of exchange. The agreement is reached based on the majority value. In the case of m faulty processors, m+1 rounds of communication is required. Let P be the set of processors and V be the set of values. For a k-level scenario, mapping is from a set of non-empty strings {p1,p2,…pn} over P of length &lt;=k+1, to V. For example, for a k-level scenario σ and string w= p1p2…pn, σ(w) = the value of pn that pn tells p(n-1)….which p2 tells p1. For an arbitrary processor p, a non faulty processor q and a string w, σ(pqw) = σ(qw).</p><p>The problem of obtaining interactive consistency is fundamental to the design of distributed fault-tolerant systems. This algorithm helps to achieve three aspects of design which are synchronization of clocks, stabilization of inputs from sensors, and agreement of results of diagnostic tests.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=67b0a1b23b6a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Practical Byzantine Fault Tolerance]]></title>
            <link>https://medium.com/@manishas053/practical-byzantine-fault-tolerance-87011dbb75cb?source=rss-406ce43494e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/87011dbb75cb</guid>
            <category><![CDATA[distributed-systems]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Maneesha S]]></dc:creator>
            <pubDate>Fri, 30 Jun 2017 15:55:57 GMT</pubDate>
            <atom:updated>2017-06-30T15:55:57.429Z</atom:updated>
            <content:encoded><![CDATA[<p>In distributed system, the rapid growth in malicious attacks and software errors may cause some nodes to exhibit byzantine (arbitrary) behaviour. The information should be safely replicated to all nodes even if there are faulty nodes. Several solutions were proposed but all of them relied on synchronous systems and were too slow to be practical. So we need a practical algorithm for this problem. This paper describes a replication algorithm that is byzantine fault tolerant and works in asynchronous environments like internet. The algorithm is practical and it offers both liveness and safety.</p><p>PBFT is the first replicated system that works correctly in asynchronous system like internet and it improves performance of previous algorithms by more than an order of magnitude. To make the system actually practical for real-world applications, several optimizations are presented. Logs are kept small by periodically cleaning out messages whose requests have been proven to be executed by f+1 non-faulty nodes, these events are called stable checkpoints. To reduce communication, only one replica send the complete result and the rest send only digests of the result to the client. A replication library is implemented as the basis for any replicated service using which a real BFT NFS is built.</p><p>The algorithm assumes a state machine system of 3f+1 replicas where f is the maximum number of nodes that can be faulty. The replicas move through a series of views which consist of a primary and backups.Each replica is deterministic and starts with the same initial state. The state of each replica includes the state of service, a message log of accepted messages and the view number. To invoke a service operation, client sends a request to primary. The primary starts a three-phase (pre-prepare, prepare and commit) protocol. In pre-prepare phase, the primary multicast a pre-prepare message to other replicas. If the replicas accept the pre-prepare they log it and send a prepare message to all other replicas. Replicas verify whether the prepare matches the pre-prepare by checking their view, sequence number and digest.Both these phases ensures that non-faulty replicas agree on a total order for the requests within a view. Once a replica is prepared it sends a commit message to all other replicas. Commit phase ensures that non-faulty replicas agree on the sequence numbers of requests that commit locally even if they commit in different views at each replica. Finally, once the replica is committed locally it executes the request and sends the result to the client. The client waits for f+1 replies from different replicas with the same result.</p><p>The real Andrew benchmark results show that their BFT NFS has very low overhead compared with standard NFS. The performance of BFS is found to be only 3% worse than that of the standard NFS implementation in Digital Unix. It can mask errors that occur independently at different replicas, including nondeterministic software errors, which are the most problematic and persistent errors since they are the hardest to detect. This good performance is due to a number of important optimizations, including replacing public-key signatures by vectors of message authentication codes, reducing the size and number of messages, and the incremental checkpoint-management techniques.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=87011dbb75cb" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>