certusone
/
dc4bc
mirror of https://github.com/certusone/dc4bc.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

wip

This commit is contained in:
programmer10110 2020-11-02 13:56:02 +03:00
parent c6e95948bf
commit 0528c779d7
7 changed files with 29 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
airgapped/bls.go
View File

@ -107,10 +107,9 @@ func (am *Machine) reconstructThresholdSignature(o *client.Operation) error {
} }
response := client.ReconstructedSignature{ response := client.ReconstructedSignature{
Data: payload.SrcPayload, SrcPayload: payload.SrcPayload,
Signature: reconstructedSignature, Signature: reconstructedSignature,
DKGRoundID: o.DKGIdentifier, DKGRoundID: o.DKGIdentifier,
SigningID: payload.SigningId,
} }
respBz, err := json.Marshal(response) respBz, err := json.Marshal(response)
if err != nil { if err != nil {

8
client/client.go
View File

@ -146,7 +146,8 @@ func (c *BaseClient) processSignature(message storage.Message) error {
if err = json.Unmarshal(message.Data, &signature); err != nil { if err = json.Unmarshal(message.Data, &signature); err != nil {
return fmt.Errorf("failed to unmarshal reconstructed signature: %w", err) return fmt.Errorf("failed to unmarshal reconstructed signature: %w", err)
} }
signature.Participant = message.SenderAddr signature.Username = message.SenderAddr
signature.DKGRoundID = message.DkgRoundID
return c.state.SaveSignature(signature) return c.state.SaveSignature(signature)
} }
@ -160,6 +161,11 @@ func (c *BaseClient) ProcessMessage(message storage.Message) error {
} }
return nil return nil
} }
if fsm.Event(message.Event) == sipf.EventSigningStart {
if err := c.processSignature(message); err != nil {
return fmt.Errorf("failed to process signature: %w", err)
}
}
fsmInstance, err := c.getFSMInstance(message.DkgRoundID) fsmInstance, err := c.getFSMInstance(message.DkgRoundID)
if err != nil { if err != nil {
return fmt.Errorf("failed to getFSMInstance: %w", err) return fmt.Errorf("failed to getFSMInstance: %w", err)

2
client/http_server.go
View File

@ -243,7 +243,7 @@ func (c *BaseClient) getSignatureByIDHandler(w http.ResponseWriter, r *http.Requ
return return
} }
signature, err := c.GetSignatureByID(r.URL.Query().Get("dkgID"), r.URL.Query().Get("hash")) signature, err := c.GetSignatureByID(r.URL.Query().Get("dkgID"), r.URL.Query().Get("id"))
if err != nil { if err != nil {
errorResponse(w, http.StatusInternalServerError, fmt.Sprintf("failed to get signature: %v", err)) errorResponse(w, http.StatusInternalServerError, fmt.Sprintf("failed to get signature: %v", err))
return return

8
client/state.go
View File

@ -1,7 +1,9 @@
package client package client
import ( import (
"crypto/md5"
"encoding/binary" "encoding/binary"
"encoding/hex"
"encoding/json" "encoding/json"
"errors" "errors"
"fmt" "fmt"
@ -338,9 +340,11 @@ func (s *LevelDBState) SaveSignature(signature types.ReconstructedSignature) err
signatures = make(map[string][]types.ReconstructedSignature) signatures = make(map[string][]types.ReconstructedSignature)
} }
sig := signatures[signature.SigningID] dataHash := md5.Sum(signature.SrcPayload)
dataHashString := hex.EncodeToString(dataHash[:])
sig := signatures[dataHashString]
sig = append(sig, signature) sig = append(sig, signature)
signatures[signature.SigningID] = sig signatures[dataHashString] = sig
signaturesJSON, err := json.Marshal(signatures) signaturesJSON, err := json.Marshal(signatures)
if err != nil { if err != nil {

9
client/types/types.go
View File

@ -23,11 +23,10 @@ const (
) )
type ReconstructedSignature struct { type ReconstructedSignature struct {
SigningID string SrcPayload []byte
Data []byte Signature []byte
Signature []byte Username string
Participant string DKGRoundID string
DKGRoundID string
} }
// Operation is the type for any Operation that might be required for // Operation is the type for any Operation that might be required for

9
cmd/dc4bc_cli/main.go
View File

@ -122,7 +122,6 @@ func getOperationsCommand() *cobra.Command {
} }
msgHash := md5.Sum(payload.SrcPayload) msgHash := md5.Sum(payload.SrcPayload)
fmt.Printf("Hash of the message to sign - %s\n", hex.EncodeToString(msgHash[:])) fmt.Printf("Hash of the message to sign - %s\n", hex.EncodeToString(msgHash[:]))
fmt.Printf("Signing ID: %s", payload.SigningId)
} }
fmt.Println("-----------------------------------------------------") fmt.Println("-----------------------------------------------------")
} }
@ -170,7 +169,7 @@ func getSignaturesCommand() *cobra.Command {
fmt.Printf("Hash of the signing data: %s\n", dataHash) fmt.Printf("Hash of the signing data: %s\n", dataHash)
for _, participantSig := range signature { for _, participantSig := range signature {
fmt.Printf("\tDKG round ID: %s\n", participantSig.DKGRoundID) fmt.Printf("\tDKG round ID: %s\n", participantSig.DKGRoundID)
fmt.Printf("\tParticipant: %s\n", participantSig.Participant) fmt.Printf("\tParticipant: %s\n", participantSig.Username)
fmt.Printf("\tReconstructed signature for the data: %s\n", base64.StdEncoding.EncodeToString(participantSig.Signature)) fmt.Printf("\tReconstructed signature for the data: %s\n", base64.StdEncoding.EncodeToString(participantSig.Signature))
fmt.Println() fmt.Println()
} }
@ -181,7 +180,7 @@ func getSignaturesCommand() *cobra.Command {
} }
func getSignatureRequest(host string, dkgID, dataHash string) (*SignatureResponse, error) { func getSignatureRequest(host string, dkgID, dataHash string) (*SignatureResponse, error) {
resp, err := http.Get(fmt.Sprintf("http://%s/getSignatureByDataHash?dkgID=%s&hash=%s", host, dkgID, dataHash)) resp, err := http.Get(fmt.Sprintf("http://%s/getSignatureByID?dkgID=%s&id=%s", host, dkgID, dataHash))
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to get signatures: %w", err) return nil, fmt.Errorf("failed to get signatures: %w", err)
} }
@ -216,7 +215,7 @@ func getSignatureCommand() *cobra.Command {
return fmt.Errorf("failed to get signatures: %s", signatures.ErrorMessage) return fmt.Errorf("failed to get signatures: %s", signatures.ErrorMessage)
} }
for _, participantSig := range signatures.Result { for _, participantSig := range signatures.Result {
fmt.Printf("\tParticipant: %s\n", participantSig.Participant) fmt.Printf("\tParticipant: %s\n", participantSig.Username)
fmt.Printf("\tReconstructed signature for the data: %s\n", base64.StdEncoding.EncodeToString(participantSig.Signature)) fmt.Printf("\tReconstructed signature for the data: %s\n", base64.StdEncoding.EncodeToString(participantSig.Signature))
fmt.Println() fmt.Println()
} }
@ -243,7 +242,7 @@ func getSignatureDataCommand() *cobra.Command {
return fmt.Errorf("failed to get signatures: %s", signatures.ErrorMessage) return fmt.Errorf("failed to get signatures: %s", signatures.ErrorMessage)
} }
if len(signatures.Result) > 0 { if len(signatures.Result) > 0 {
fmt.Println(string(signatures.Result[0].Data)) fmt.Println(string(signatures.Result[0].SrcPayload))
} }
return nil return nil
}, },

12
mocks/clientMocks/state_mock.go
View File

@ -180,19 +180,19 @@ func (mr *MockStateMockRecorder) SaveSignature(signature interface{}) *gomock.Ca
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveSignature", reflect.TypeOf((*MockState)(nil).SaveSignature), signature) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveSignature", reflect.TypeOf((*MockState)(nil).SaveSignature), signature)
} }
// GetSignatureByDataHash mocks base method // GetSignatureByID mocks base method
func (m *MockState) GetSignatureByDataHash(dkgID, signatureID string) ([]types.ReconstructedSignature, error) { func (m *MockState) GetSignatureByID(dkgID, signatureID string) ([]types.ReconstructedSignature, error) {
m.ctrl.T.Helper() m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetSignatureByDataHash", dkgID, signatureID) ret := m.ctrl.Call(m, "GetSignatureByID", dkgID, signatureID)
ret0, _ := ret[0].([]types.ReconstructedSignature) ret0, _ := ret[0].([]types.ReconstructedSignature)
ret1, _ := ret[1].(error) ret1, _ := ret[1].(error)
return ret0, ret1 return ret0, ret1
} }
// GetSignatureByDataHash indicates an expected call of GetSignatureByDataHash // GetSignatureByID indicates an expected call of GetSignatureByID
func (mr *MockStateMockRecorder) GetSignatureByDataHash(dkgID, signatureID interface{}) *gomock.Call { func (mr *MockStateMockRecorder) GetSignatureByID(dkgID, signatureID interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper() mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSignatureByDataHash", reflect.TypeOf((*MockState)(nil).GetSignatureByDataHash), dkgID, signatureID) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSignatureByID", reflect.TypeOf((*MockState)(nil).GetSignatureByID), dkgID, signatureID)
} }
// GetSignatures mocks base method // GetSignatures mocks base method