Try   HackMD

BLS Signature Aggregate and Rogue-Key Attacks

BLS Signature

There are

P0,
P1
,
P2
,
P3
four parties.

P0: secret key
sk0
, message
m0
, public key
P0=sk0G
, signature
S0=H(m0)sk0

P1: secret key
sk1
, message
m1
, public key
P1=sk1G
, signature
S1=H(m1)sk1

P2: secret key
sk2
, message
m2
, public key
P2=sk2G
, signature
S2=H(m2)sk2

P3: secret key
sk3
, message
m3
, public key
P3=sk3G
, signature
S3=H(m3)sk3

one by one:

e(G,S0)=e(P0,H(m0)) and so on.

H, hash to curve, result is a point.

S=S0+S1+S2+S3

e(G,S)=e(G,S0+S1+S2+S3)=e(G,S0)e(G,S1)e(G,S2)e(G,S3)=e(G,sk0H(m0))e(G,sk1H(m1))e(G,sk2H(m2))e(G,sk3H(m3))=e(sk0G,H(m0))e(sk1G,H(m1))e(sk2G,H(m2))e(sk3G,H(m3))=e(P0,H(m0))e(P1,H(m1))e(P2,H(m2))e(P3,H(m3))

Use aggregated signature, we can compute

n1 less expensive pairings. (
2n
vs
n+1
)

Rogue-Key Attacks

if

m0=m1=m2=m3=m, for example, in consensus, different nodes sign the same block.

There are 5 parties: 4 validators and 1 leader.

Normal Process

  • The leader broadcasts block(
    m
    ) to all the validators
  • The validators send back signatures
    S0,,S3
    .
  • The leader broadcasts the aggregated signature
    S=S0+S1+S2+S3
  • The validators validate
    e(G,S)=e(P,H(m))
    with
    P=P0+P1+P2+P3
    , as
    e(G,S)=e(P0,H(m))e(P1,H(m))e(P2,H(m))e(P3,H(m))=e(P0+P1+P2+P3,H(m))
    .

As a malicious leader

The malicious leader want to change the block, such as he want to double-spend.

  • The leader new a secret key
    sk
    , with public key
    P=skG
  • The leader sign the new block(
    m
    ):
    S=skH(m)
  • The leader public new public key
    P4=P(P0+P1+P2+P3)=PPorigin
  • The leader public new signature
    S4=S(S0+S1+S2+S3)=SSorigin
  • Other validators aggregate:
    Snew=S0++S4=S
    ,
    Pnew=P0++P4=P
    ,
    e(G,Snew)=e(G,S)=e(P,H(m))=e(Pnew,H(m))
    , So validators think the new block(
    m)
    is legal.

Reference