>> (p.1)
    Author Topic: Pay to contract with forgability (using a chameleon hash)  (Read 5511 times)
    gmaxwell (OP)
    Moderator
    Legendary
    *
    expert
    Offline Offline

    Activity: 4550
    Merit: 9989



    View Profile WWW
    October 25, 2013, 11:39:40 PM
     #1

    Motivation:

    Alice wants to pay Bob according to some mutually agreed terms, and doesn't want Bob to be able to later claim that the terms were different.

    One way that people have proposed to accomplish this is pay-to-contract:

    Bob publishes an EC public point for which he knows the private key.
    Alice computes H(contract) and adds this value to Bob's public point, we'll call the result a contract key.
    Alice sends funds to 1 of 2 {Alice Pubkey, Contract Key}.
    Bob, knowing both his private key and the contract can derive the private key and redeem the payment.

    If the contract gets forgotten (or Bob decides that he didn't like Alice's last minute negotiations) Bob can fail to redeem it and Alice can retrieve the funds.

    If Bob fails to make good on the deal, Alice can show people the contract and everyone can see that Bob agreed to it (by virtue of redeeming the coins).

    Pay to contract reduces the importance of authentication in payment, because we know that necessarily anyone who redeemed the coins knew the contract.

    One problem with pay-to-contract is that a third party could potentially coerce Alice or Bob into revealing the contract. The situation for pay to contract is worse than what you have if, instead,  Bob had just given Alice a regular signed invoice which specified the address for Alice to pay, because if someone attempted coercion to obtain the contract Bob could sign a forged contract and give them that instead.

    This might not really be much of a problem in practice, and it could be solved with the simple expedient of always destroying contracts after they are fulfilled... but I thought it was worth making a note that it's possible to retain the forgability in the context of pay to contract.

    Pay to contract with forgability:

    Alice, and Bob agree on a contract. The message hash in the above basic pay-to-contract protocol is replaced with a chameleon hash (such as this one based on gap-DH, or really any other one this protocol doesn't need the secret preservation property). Bob additionally sends Alice a public key and random value for the chameleon hash, and the protocol proceeds as normal.

    A chameleon hash is a hash function that takes a message, a pubkey, and a random value. The function is designed so that it works as a strong hash function but the holder of the corresponding private key can produce free collisions. E.g.  he can easily find an random2 for message2 such that CH(message,random,pubkey) == CH(message2,random2,pubkey).

    So if someone attempts to coerce the parties into handing over their contract Bob can produce a forged contract that matches the pay to contract transaction and this forgery is indistinguishable.

    If Bob cheats Alice, Alice can still publish the original contract and the public can be satisfied that Bob is behaving unreliably. (Even if Bob goes on to publish other forgeries, it doesn't matter which one is the original for the purpose of showing that Bob's behavior was unreliable).

    This gets you back to the same security against coercion as a signed-invoice while allowing the use of pay-to-contract.

    If stronger non-repudiation is required two chameleon hashes could be used— cascaded on top of each other— one keyed by Alice and one keyed by Bob so that both parties must cooperate to produce a forged contract.
Page 1
Viewing Page: 1