func (e *ServerFault) UpdateState(state interfaces.IState) error {
core, err := e.MarshalCore()
if err != nil {
return err
}
verifiedSignatures := 0
for _, fullSig := range e.SignatureList.List {
sig := fullSig.GetSignature()
v, err := state.VerifyAuthoritySignature(core, sig, state.GetLeaderHeight())
if err != nil {
if err.Error() != "Signature Key Invalid or not Federated Server Key" {
return err
}
}
if v == 1 {
verifiedSignatures++
}
}
feds := state.GetFedServers(state.GetLeaderHeight())
//50% threshold
if verifiedSignatures <= len(feds)/2 {
return fmt.Errorf("Quorum not reached for ServerFault")
}
//TODO: do
/*
state.AddFedServer(e.DBHeight, e.IdentityChainID)
state.UpdateAuthorityFromABEntry(e)
*/
return nil
}
// Validate the message, given the state. Three possible results:
// < 0 -- Message is invalid. Discard
// 0 -- Cannot tell if message is Valid
// 1 -- Message is valid
func (m *Ack) Validate(state interfaces.IState) int {
if m.authvalid {
return 1
}
// Only new acks are valid. Of course, the VMIndex has to be valid too.
msg, err := state.GetMsg(m.VMIndex, int(m.DBHeight), int(m.Height))
if err != nil || msg != nil {
return -1
}
// Check signature
bytes, err := m.MarshalForSignature()
if err != nil {
//fmt.Println("Err is not nil on Ack sig check: ", err)
return -1
}
sig := m.Signature.GetSignature()
ackSigned, err := state.VerifyAuthoritySignature(bytes, sig, m.DBHeight)
//ackSigned, err := m.VerifySignature()
if err != nil {
//fmt.Println("Err is not nil on Ack sig check: ", err)
return -1
}
if ackSigned < 1 {
return -1
}
m.authvalid = true
return 1
}
func (m *FullServerFault) SigTally(state interfaces.IState) int {
validSigCount := 0
// Check main signature
bytes, err := m.MarshalForSignature()
if err != nil {
return 0
}
sig := m.Signature.GetSignature()
sfSigned, err := state.VerifyAuthoritySignature(bytes, sig, m.DBHeight)
if err != nil {
return 0
}
if sfSigned < 1 {
return 0
}
cb, err := m.MarshalCore()
if err != nil {
return 0
}
for _, fedSig := range m.SignatureList.List {
check, err := state.VerifyAuthoritySignature(cb, fedSig.GetSignature(), m.DBHeight)
if err == nil && check == 1 {
validSigCount++
}
}
return validSigCount
}
func (m *ChangeServerKeyMsg) Validate(state interfaces.IState) int {
return 1
// Check to see if identity exists and is audit or fed server
if !state.VerifyIsAuthority(m.IdentityChainID) {
fmt.Println("ChangeServerKey Error. Server is not an authority")
return -1
}
// Should only be 20 bytes in the hash
if m.AdminBlockChange == constants.TYPE_ADD_BTC_ANCHOR_KEY {
for _, b := range m.Key.Bytes()[21:] {
if b != 0 {
fmt.Println("ChangeServerKey Error. Newkey is invalid length")
return -1
}
}
}
// Check signatures
bytes, err := m.MarshalForSignature()
if err != nil {
fmt.Println("ChangeServerKey Error: Err is not nil, err: ", err.Error())
return -1
}
if m.Signature == nil {
fmt.Println("ChangeServerKey Error: No signiture on ChangeServerKeyMessage")
return -1
}
sig := m.Signature.GetSignature()
authSigned, err := state.VerifyAuthoritySignature(bytes, sig, state.GetLeaderHeight())
//ackSigned, err := m.VerifySignature()
if err != nil {
fmt.Println("ChangeServerKey Error: Err is not nil, err: ", err.Error())
return -1
}
if authSigned < 1 {
fmt.Println("ChangeServerKey Error: Message not signed by an authority")
return -1
}
return 1
}