Commit 72c5ddd3 authored by Caro Axel's avatar Caro Axel Committed by Loïck Bonniot

[t] Add Alert API

- Add mgdb entities to handle resolution protocol
- Add unit tests
parent 83c49738
......@@ -36,6 +36,11 @@ Unit tests:
- "go test -coverprofile dfssc_security.part -v dfss/dfssc/security"
- "go test -coverprofile dfssc_user.part -v dfss/dfssc/user"
- "go test -coverprofile dfssc_user.part -v dfss/dfssc/sign"
- "go test -coverprofile dfsst_archivesManager.part -v dfss/dfsst/archivesManager"
- "go test -coverprofile dfsst_checker.part -v dfss/dfsst/checker"
- "go test -coverprofile dfsst_entities.part -v dfss/dfsst/entities"
- "go test -coverprofile dfsst_resolve.part -v dfss/dfsst/resolve"
- "go test -coverprofile dfsst_server.part -v dfss/dfsst/server"
- "echo 'mode: set' *part > c.out"
- "grep -h -v 'mode: set' *part >> c.out"
- "go tool cover -html=c.out -o coverage.html"
......@@ -80,7 +85,7 @@ Code lint:
- "./build/deps.sh"
- "cd $GOPATH/src/dfss && make install_all"
- "gometalinter --install --update"
- "gometalinter -t --deadline=600s -j1 --skip=api --skip=fixtures --skip=gui --skip=dfssd --disable=aligncheck ./..."
- "gometalinter -t --deadline=900s -j1 --skip=api --skip=fixtures --skip=gui --skip=dfssd --disable=aligncheck ./..."
Deploy:
stage: deploy
......
......@@ -36,11 +36,13 @@ var _ = math.Inf
const _ = proto.ProtoPackageIsVersion1
type Context struct {
RecipientKeyHash []byte `protobuf:"bytes,1,opt,name=recipientKeyHash,proto3" json:"recipientKeyHash,omitempty"`
SenderKeyHash []byte `protobuf:"bytes,2,opt,name=senderKeyHash,proto3" json:"senderKeyHash,omitempty"`
SignatureUuid string `protobuf:"bytes,3,opt,name=signatureUuid" json:"signatureUuid,omitempty"`
ContractUuid string `protobuf:"bytes,4,opt,name=contractUuid" json:"contractUuid,omitempty"`
ContractDocumentHash string `protobuf:"bytes,5,opt,name=contractDocumentHash" json:"contractDocumentHash,omitempty"`
RecipientKeyHash []byte `protobuf:"bytes,1,opt,name=recipientKeyHash,proto3" json:"recipientKeyHash,omitempty"`
SenderKeyHash []byte `protobuf:"bytes,2,opt,name=senderKeyHash,proto3" json:"senderKeyHash,omitempty"`
Sequence []uint32 `protobuf:"varint,3,rep,name=sequence" json:"sequence,omitempty"`
Signers [][]byte `protobuf:"bytes,4,rep,name=signers,proto3" json:"signers,omitempty"`
ContractDocumentHash []byte `protobuf:"bytes,5,opt,name=contractDocumentHash,proto3" json:"contractDocumentHash,omitempty"`
SignatureUUID string `protobuf:"bytes,6,opt,name=signatureUUID" json:"signatureUUID,omitempty"`
SignedHash []byte `protobuf:"bytes,7,opt,name=signedHash,proto3" json:"signedHash,omitempty"`
}
func (m *Context) Reset() { *m = Context{} }
......@@ -109,10 +111,6 @@ func init() {
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion1
// Client API for Client service
type ClientClient interface {
......@@ -225,27 +223,29 @@ var _Client_serviceDesc = grpc.ServiceDesc{
}
var fileDescriptor0 = []byte{
// 348 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x8c, 0x92, 0xd1, 0x4a, 0xfb, 0x30,
0x14, 0xc6, 0xd7, 0xed, 0xbf, 0xf5, 0xbf, 0x63, 0x37, 0x24, 0xec, 0x62, 0x4c, 0x04, 0x2d, 0x43,
0xc4, 0x8b, 0x0e, 0xe6, 0x23, 0x6c, 0xc2, 0x40, 0x04, 0xa9, 0xfa, 0x00, 0x31, 0xcd, 0x34, 0xd0,
0x35, 0x25, 0xc9, 0x64, 0x7b, 0x0d, 0xdf, 0xce, 0xb7, 0x31, 0x3d, 0x59, 0xe6, 0x8a, 0xbb, 0xf0,
0xa6, 0xf4, 0xfb, 0xce, 0xaf, 0xe7, 0x9c, 0x2f, 0x0d, 0x9c, 0x65, 0x4b, 0xad, 0x27, 0xd5, 0x83,
0x4d, 0x68, 0x29, 0x26, 0x2c, 0x17, 0xbc, 0x30, 0x49, 0xa9, 0xa4, 0x91, 0xa4, 0x65, 0x9d, 0xd1,
0xf9, 0x9e, 0x28, 0x91, 0x28, 0x73, 0x6a, 0x96, 0x52, 0xad, 0x1c, 0x13, 0x7f, 0x05, 0x10, 0xce,
0x64, 0x61, 0xf8, 0xc6, 0x90, 0x1b, 0x38, 0x55, 0x9c, 0x89, 0xb2, 0x6a, 0x71, 0xcf, 0xb7, 0x0b,
0xaa, 0xdf, 0x87, 0xc1, 0x45, 0x70, 0x1d, 0xa5, 0xbf, 0x7c, 0x32, 0x86, 0x9e, 0xe6, 0x45, 0xc6,
0x95, 0x07, 0x9b, 0x08, 0xd6, 0x4d, 0xa4, 0xc4, 0x5b, 0x41, 0xcd, 0x5a, 0xf1, 0x97, 0xb5, 0xc8,
0x86, 0x2d, 0x4b, 0x75, 0xd3, 0xba, 0x49, 0x62, 0x88, 0x98, 0x5d, 0x41, 0x51, 0x66, 0x10, 0xfa,
0x87, 0x50, 0xcd, 0x23, 0x53, 0x18, 0x78, 0x3d, 0x97, 0x6c, 0xbd, 0xb2, 0xab, 0xe0, 0xd8, 0x36,
0xb2, 0x47, 0x6b, 0x31, 0x85, 0xf0, 0x51, 0xc9, 0x95, 0xd0, 0x9c, 0x5c, 0x41, 0xc8, 0x5c, 0x4a,
0x4c, 0x74, 0x32, 0x8d, 0x12, 0x7b, 0x18, 0xc9, 0x2e, 0x79, 0xea, 0x8b, 0x64, 0x00, 0x6d, 0x61,
0x03, 0x6c, 0x30, 0x4e, 0x2f, 0x75, 0x82, 0x0c, 0x21, 0x2c, 0xe9, 0x36, 0x97, 0xd4, 0x05, 0x88,
0x52, 0x2f, 0xe3, 0x07, 0xe8, 0x3e, 0xf9, 0x2c, 0x7f, 0x1e, 0x72, 0xd0, 0xae, 0x59, 0x6f, 0x77,
0x09, 0xed, 0x05, 0xcf, 0x73, 0x59, 0x21, 0x1f, 0x5c, 0x69, 0x21, 0x0b, 0x6c, 0xd5, 0x4d, 0xbd,
0x9c, 0x7e, 0x06, 0xd0, 0x99, 0xe1, 0x5f, 0x26, 0x09, 0x44, 0xcf, 0x8a, 0x53, 0xe3, 0x43, 0xba,
0x71, 0x3b, 0x35, 0xea, 0xa3, 0xba, 0x53, 0x4a, 0xaa, 0x99, 0xcc, 0x78, 0xdc, 0xb0, 0x67, 0xd8,
0x47, 0xfe, 0x67, 0x63, 0xc7, 0xec, 0xf5, 0x91, 0x6f, 0xc6, 0xf0, 0x7f, 0x2e, 0x34, 0x93, 0x76,
0x3c, 0x01, 0xac, 0xe2, 0x82, 0xa3, 0x83, 0xf7, 0xb8, 0xf1, 0xda, 0xc1, 0xcb, 0x74, 0xfb, 0x1d,
0x00, 0x00, 0xff, 0xff, 0x8e, 0x21, 0x38, 0xfd, 0x8f, 0x02, 0x00, 0x00,
// 380 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x8c, 0x52, 0x5d, 0x4f, 0xc2, 0x30,
0x14, 0xe5, 0x43, 0x18, 0x5c, 0x07, 0x31, 0x0d, 0x0f, 0xcb, 0x8c, 0x06, 0x17, 0x62, 0x88, 0x0f,
0x23, 0xc1, 0x9f, 0x00, 0x26, 0x18, 0x63, 0x62, 0xa6, 0xfc, 0x80, 0xda, 0x15, 0x6d, 0x32, 0xd6,
0xd9, 0x16, 0x03, 0xbf, 0xc1, 0x37, 0x7f, 0xb1, 0xdd, 0x1d, 0x43, 0x88, 0x3c, 0xf8, 0xb2, 0xec,
0xdc, 0x7b, 0x7a, 0xce, 0xbd, 0xa7, 0x85, 0xf3, 0x78, 0xa1, 0xf5, 0x28, 0xff, 0xb0, 0x11, 0xcd,
0xc4, 0x88, 0x25, 0x82, 0xa7, 0x26, 0xcc, 0x94, 0x34, 0x92, 0xd4, 0x6d, 0xc5, 0xbf, 0xd8, 0x31,
0x32, 0x64, 0x64, 0x09, 0x35, 0x0b, 0xa9, 0x96, 0x05, 0x27, 0xf8, 0xaa, 0x81, 0x33, 0x91, 0xa9,
0xe1, 0x6b, 0x43, 0x6e, 0xe0, 0x4c, 0x71, 0x26, 0xb2, 0x5c, 0xe2, 0x81, 0x6f, 0x66, 0x54, 0xbf,
0x7b, 0xd5, 0x7e, 0x75, 0xe8, 0x46, 0x7f, 0xea, 0x64, 0x00, 0x1d, 0xcd, 0xd3, 0x98, 0xab, 0x92,
0x58, 0x43, 0xe2, 0x61, 0x91, 0xf8, 0xd0, 0xd2, 0xfc, 0x63, 0xc5, 0x53, 0xc6, 0xbd, 0x7a, 0xbf,
0x3e, 0xec, 0x44, 0x3b, 0x4c, 0x3c, 0x70, 0xb4, 0x78, 0x4b, 0xb9, 0xd2, 0xde, 0x89, 0x6d, 0xb9,
0x51, 0x09, 0xc9, 0x18, 0x7a, 0xcc, 0x8e, 0xa4, 0x28, 0x33, 0x53, 0xc9, 0x56, 0x4b, 0x6b, 0x8b,
0x16, 0x0d, 0xb4, 0x38, 0xda, 0xc3, 0x79, 0xec, 0x71, 0x6a, 0x56, 0x8a, 0xcf, 0xe7, 0xf7, 0x53,
0xaf, 0x69, 0xc9, 0xed, 0xe8, 0xb0, 0x48, 0x2e, 0x01, 0xd0, 0x24, 0x46, 0x3d, 0x07, 0xf5, 0xf6,
0x2a, 0x01, 0x05, 0xe7, 0x49, 0xc9, 0xa5, 0xd0, 0x9c, 0x5c, 0x83, 0xc3, 0x8a, 0x5c, 0x30, 0x83,
0xd3, 0xb1, 0x1b, 0xda, 0xf8, 0xc2, 0x6d, 0x56, 0x51, 0xd9, 0x24, 0x3d, 0x68, 0x08, 0xbb, 0xf2,
0x1a, 0x03, 0xe8, 0x44, 0x05, 0xc8, 0x97, 0xcb, 0xe8, 0x26, 0x91, 0x34, 0xb6, 0x7b, 0xe7, 0x2e,
0x25, 0x0c, 0x1e, 0xa1, 0xfd, 0x5c, 0xce, 0xf4, 0x6f, 0x93, 0x3d, 0xb9, 0xda, 0xa1, 0xdc, 0x15,
0x34, 0x66, 0x3c, 0x49, 0x64, 0x4e, 0xf9, 0xb4, 0xe1, 0x09, 0x99, 0xa2, 0x54, 0x3b, 0x2a, 0xe1,
0xf8, 0xbb, 0x0a, 0xcd, 0x09, 0xbe, 0x0b, 0x12, 0x82, 0xfb, 0xa2, 0x38, 0x35, 0xe5, 0x92, 0x85,
0xdd, 0x16, 0xf9, 0x5d, 0x44, 0x77, 0x4a, 0x49, 0x35, 0x91, 0x31, 0x0f, 0x2a, 0xf6, 0x26, 0xba,
0xc8, 0xff, 0x9d, 0xb8, 0xe0, 0xec, 0xf0, 0x91, 0x33, 0x03, 0x68, 0x4d, 0x85, 0x66, 0xd2, 0xda,
0x13, 0xc0, 0x2e, 0x0e, 0xe8, 0xef, 0xfd, 0x07, 0x95, 0xd7, 0x26, 0x3e, 0xbf, 0xdb, 0x9f, 0x00,
0x00, 0x00, 0xff, 0xff, 0xb4, 0xf1, 0xe7, 0x80, 0xc1, 0x02, 0x00, 0x00,
}
......@@ -13,16 +13,18 @@ service Client {
message Context {
bytes recipientKeyHash = 1; // SHA-512
bytes senderKeyHash = 2; // SHA-512
string signatureUuid = 3;
string contractUuid = 4;
string contractDocumentHash = 5;
repeated uint32 sequence = 3; // Signing sequence
repeated bytes signers = 4; // List of the signers' hashes
bytes contractDocumentHash = 5;
string signatureUUID = 6;
bytes signedHash = 7; // (sequence + signers' hashes + contractDocumentHash + signatureUUID) crypted by the platform
}
// Promise message contains all the required information to verify
// the identity of the sender and receiver, and the actual promise
message Promise {
Context context = 1;
uint32 index = 2;
uint32 index = 2; // The index of the sequence for this message
bytes payload = 3;
}
......
......@@ -18,9 +18,10 @@ func (m *SignatureManager) createContext(from, to uint32) (*cAPI.Context, error)
return &cAPI.Context{
RecipientKeyHash: m.keyHash[to],
SenderKeyHash: m.keyHash[from],
ContractDocumentHash: m.contract.File.Hash,
SignatureUuid: m.uuid,
ContractUuid: m.contract.UUID,
Sequence: m.sequence,
Signers: m.keyHash,
ContractDocumentHash: []byte(m.contract.File.Hash),
SignatureUUID: m.uuid,
}, nil
}
......
......@@ -18,6 +18,7 @@ package api
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import api2 "dfss/dfssc/api"
import (
context "golang.org/x/net/context"
......@@ -35,6 +36,7 @@ const _ = proto.ProtoPackageIsVersion1
// Alert message sent by a signer
type AlertRequest struct {
Promises []*api2.Promise `protobuf:"bytes,1,rep,name=promises" json:"promises,omitempty"`
}
func (m *AlertRequest) Reset() { *m = AlertRequest{} }
......@@ -42,8 +44,16 @@ func (m *AlertRequest) String() string { return proto.CompactTextStri
func (*AlertRequest) ProtoMessage() {}
func (*AlertRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
func (m *AlertRequest) GetPromises() []*api2.Promise {
if m != nil {
return m.Promises
}
return nil
}
// RecoverRequest message to get a signed contract
type RecoverRequest struct {
SignatureUUID string `protobuf:"bytes,1,opt,name=signatureUUID" json:"signatureUUID,omitempty"`
}
func (m *RecoverRequest) Reset() { *m = RecoverRequest{} }
......@@ -74,10 +84,6 @@ func init() {
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion1
// Client API for TTP service
type TTPClient interface {
......@@ -163,17 +169,21 @@ var _TTP_serviceDesc = grpc.ServiceDesc{
}
var fileDescriptor0 = []byte{
// 188 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x92, 0x4f, 0x49, 0x2b, 0x2e,
0xd6, 0x07, 0x11, 0x25, 0xfa, 0x89, 0x05, 0x99, 0xfa, 0x45, 0xa9, 0xc5, 0xf9, 0x39, 0xa5, 0x25,
0x99, 0xf9, 0x79, 0x7a, 0x05, 0x45, 0xf9, 0x25, 0xf9, 0x42, 0xcc, 0x40, 0x51, 0x25, 0x3e, 0x2e,
0x1e, 0xc7, 0x9c, 0xd4, 0xa2, 0x92, 0xa0, 0xd4, 0xc2, 0xd2, 0xd4, 0xe2, 0x12, 0x25, 0x01, 0x2e,
0xbe, 0xa0, 0xd4, 0xe4, 0xfc, 0xb2, 0xd4, 0x22, 0x98, 0x88, 0x3d, 0x17, 0x77, 0x48, 0x48, 0x40,
0x50, 0x6a, 0x71, 0x41, 0x7e, 0x5e, 0x71, 0xaa, 0x90, 0x08, 0x17, 0x6b, 0x62, 0x52, 0x7e, 0x51,
0x89, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0x47, 0x10, 0x84, 0x23, 0x24, 0xc5, 0xc5, 0x91, 0x9c, 0x9f,
0x57, 0x52, 0x94, 0x98, 0x5c, 0x22, 0xc1, 0x04, 0x94, 0xe0, 0x09, 0x82, 0xf3, 0x8d, 0x32, 0xb9,
0x98, 0x81, 0x06, 0x08, 0xe9, 0x71, 0xb1, 0x82, 0x6d, 0x12, 0x12, 0xd4, 0x03, 0x5a, 0xac, 0x87,
0x6c, 0xab, 0x94, 0x00, 0x58, 0x08, 0xc9, 0x1a, 0x25, 0x06, 0x21, 0x23, 0x2e, 0x76, 0xa8, 0x4b,
0x84, 0x84, 0xc1, 0xd2, 0xa8, 0xee, 0xc2, 0xa6, 0x27, 0x89, 0x0d, 0xec, 0x33, 0x63, 0x40, 0x00,
0x00, 0x00, 0xff, 0xff, 0xa7, 0x4b, 0x1a, 0xea, 0xfc, 0x00, 0x00, 0x00,
// 245 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x6c, 0x90, 0xcd, 0x4a, 0xc4, 0x30,
0x10, 0xc7, 0x5d, 0xcb, 0x6a, 0x9d, 0xad, 0xa2, 0xd1, 0xc3, 0x52, 0x0f, 0x4a, 0xf1, 0xd0, 0x53,
0x0b, 0x15, 0xc4, 0x9b, 0x08, 0x5e, 0xbc, 0x2d, 0x61, 0xf7, 0x01, 0xb2, 0x71, 0x94, 0x40, 0x4d,
0x6a, 0x66, 0xea, 0xf3, 0x1b, 0x53, 0x2d, 0x5b, 0xd8, 0x4b, 0x60, 0xfe, 0x1f, 0x93, 0x5f, 0x02,
0x37, 0x6f, 0xef, 0x44, 0xf5, 0xef, 0xc1, 0xb5, 0xea, 0x4c, 0xed, 0x91, 0x5c, 0xdb, 0xb3, 0x71,
0xb6, 0xea, 0xbc, 0x63, 0x27, 0x92, 0xa0, 0xe6, 0xd7, 0x63, 0x4a, 0xc7, 0x94, 0x6e, 0x0d, 0x5a,
0x1e, 0x12, 0xc5, 0x23, 0x64, 0xcf, 0x2d, 0x7a, 0x96, 0xf8, 0xd5, 0x23, 0xb1, 0x28, 0x21, 0x0d,
0xc6, 0xa7, 0x21, 0xa4, 0xe5, 0xec, 0x36, 0x29, 0x17, 0x4d, 0x56, 0x85, 0x52, 0xb5, 0x1a, 0x44,
0x39, 0xba, 0xc5, 0x03, 0x9c, 0x49, 0xd4, 0xee, 0x1b, 0xfd, 0x7f, 0xf7, 0x0e, 0x4e, 0xc9, 0x7c,
0x58, 0xc5, 0xbd, 0xc7, 0xcd, 0xe6, 0xf5, 0x25, 0x2c, 0x98, 0x95, 0x27, 0x72, 0x2a, 0x16, 0x4f,
0xb0, 0x58, 0xaf, 0x57, 0x12, 0xa9, 0x73, 0x96, 0x50, 0x5c, 0xc1, 0x5c, 0x6d, 0x9d, 0xe7, 0x18,
0x4e, 0xe5, 0x30, 0x88, 0x1c, 0x52, 0xed, 0x2c, 0x7b, 0xa5, 0x79, 0x79, 0x18, 0x8c, 0x4c, 0x8e,
0x73, 0x63, 0x20, 0x09, 0x0b, 0x44, 0x05, 0xf3, 0x48, 0x2e, 0x2e, 0x22, 0xe0, 0xee, 0x2b, 0xf2,
0xf3, 0x28, 0xed, 0x5c, 0x53, 0x1c, 0x88, 0x06, 0x8e, 0xff, 0x78, 0xc5, 0x65, 0xb4, 0xa7, 0xf4,
0xfb, 0x3a, 0xdb, 0xa3, 0xf8, 0x49, 0xf7, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xe0, 0xac, 0x9b,
0x9a, 0x69, 0x01, 0x00, 0x00,
}
......@@ -2,16 +2,22 @@ syntax = "proto3";
package api;
import "dfss/dfssc/api/client.proto";
service TTP {
rpc Alert(AlertRequest) returns (TTPResponse) {}
rpc Recover(RecoverRequest) returns (TTPResponse) {}
}
// Alert message sent by a signer
message AlertRequest {}
message AlertRequest {
repeated Promise promises = 1;
}
// RecoverRequest message to get a signed contract
message RecoverRequest {}
message RecoverRequest {
string signatureUUID = 1;
}
// TTPResponse message to answer an Alert or Recover message
message TTPResponse {
......
package archivesManager
import (
cAPI "dfss/dfssc/api"
"dfss/dfsst/entities"
"dfss/mgdb"
"gopkg.in/mgo.v2/bson"
)
// ArchivesManager : handles the structure of a SignatureArchives, with functions suited for the TTP resolve protocol.
type ArchivesManager struct {
DB *mgdb.MongoManager
Archives *entities.SignatureArchives
}
// NewArchivesManager : create a new archivesManager, with the specified mgdb manager, but
// doesn't initialize the signatureArchives. (see function 'InitializeArchives').
func NewArchivesManager(db *mgdb.MongoManager) *ArchivesManager {
return &ArchivesManager{
DB: db,
}
}
// InitializeArchives : if an entry in the database for this signature exists, retrieves it, otherwise creates it.
//
// This function should only be called after function IsRequestValid.
func (manager *ArchivesManager) InitializeArchives(promise *cAPI.Promise, signatureUUID bson.ObjectId, signers *[]entities.Signer) {
present, archives := manager.ContainsSignature(signatureUUID)
if !present {
archives = entities.NewSignatureArchives(signatureUUID, promise.Context.Sequence, *signers, promise.Context.ContractDocumentHash, promise.Context.SignedHash)
}
manager.Archives = archives
}
// ContainsSignature : checks if the specified signatureUUID matches a SignatureArchives in the database.
// If it exists, returns it.
func (manager *ArchivesManager) ContainsSignature(signatureUUID bson.ObjectId) (present bool, archives *entities.SignatureArchives) {
err := manager.DB.Get("signatures").FindByID(entities.SignatureArchives{ID: signatureUUID}, &archives)
if err != nil {
present = false
archives = &entities.SignatureArchives{}
return
}
present = true
return
}
// HasReceivedAbortToken : determines if the specified signer has already been sent an abort token in the specified signatureArchives.
func (manager *ArchivesManager) HasReceivedAbortToken(signerIndex uint32) bool {
for _, s := range manager.Archives.AbortedSigners {
if signerIndex == s.SignerIndex {
return true
}
}
return false
}
// WasContractSigned : determines if the ttp already generated a signed contract for this signatureArchives, and returns it if true.
func (manager *ArchivesManager) WasContractSigned() (bool, []byte) {
signedContract := manager.Archives.SignedContract
if len(signedContract) != 0 {
return true, signedContract
}
return false, []byte{}
}
// HasSignerPromised : determines if the specified signer has promised to sign to at least one other signer.
func (manager *ArchivesManager) HasSignerPromised(signer uint32) bool {
for _, p := range manager.Archives.ReceivedPromises {
if (p.SenderKeyIndex == signer) && (p.RecipientKeyIndex != signer) {
return true
}
}
return false
}
// AddToAbort : adds the specified signer to the aborted signers of the signatureArchives.
// If the signer is already present, does nothing.
func (manager *ArchivesManager) AddToAbort(signerIndex uint32) {
for _, s := range manager.Archives.AbortedSigners {
if s.SignerIndex == signerIndex {
return
}
}
// TODO
// This requires the implementation of promises
var abortIndex uint32
abortIndex = 0
abortedSigner := entities.NewAbortedSigner(signerIndex, abortIndex)
manager.Archives.AbortedSigners = append(manager.Archives.AbortedSigners, *abortedSigner)
}
// AddToDishonest : adds the specified signer to the dishonest signers of the signatureArchives.
// If the signer is already present, does nothing.
func (manager *ArchivesManager) AddToDishonest(signerIndex uint32) {
for _, s := range manager.Archives.DishonestSigners {
if s == signerIndex {
return
}
}
manager.Archives.DishonestSigners = append(manager.Archives.DishonestSigners, signerIndex)
}
// AddPromise : adds the specified promises to the list of received promises of the SignatureArchives.
func (manager *ArchivesManager) AddPromise(promise *entities.Promise) {
for _, p := range manager.Archives.ReceivedPromises {
if entities.ArePromisesEqual(&p, promise) {
return
}
}
manager.Archives.ReceivedPromises = append(manager.Archives.ReceivedPromises, *promise)
}
package archivesManager
import (
"crypto/sha512"
cAPI "dfss/dfssc/api"
"dfss/dfsst/checker"
"dfss/dfsst/entities"
"dfss/mgdb"
"fmt"
"github.com/bmizerany/assert"
"gopkg.in/mgo.v2/bson"
"os"
"testing"
)
var (
db string
collection *mgdb.MongoCollection
dbManager *mgdb.MongoManager
sequence []uint32
signers [][]byte
contractDocumentHash []byte
signatureUUID string
signatureUUIDBson bson.ObjectId
signedHash []byte
signersEntities []entities.Signer
err error
)
func init() {
db = os.Getenv("DFSS_MONGO_URI")
if db == "" {
db = "mongodb://localhost/dfss-test"
}
sequence = []uint32{0, 1, 2, 0, 1, 2, 0, 1, 2}
for i := 0; i < 3; i++ {
h := sha512.Sum512([]byte{byte(i)})
signer := h[:]
signers = append(signers, signer)
}
contractDocumentHash = []byte{1, 2, 3, 4, 5, 6, 7, 8, 9}
signatureUUIDBson = bson.NewObjectId()
signatureUUID = signatureUUIDBson.Hex()
signedHash = []byte{}
signersEntities = make([]entities.Signer, 0)
for _, s := range signers {
signerEntity := entities.NewSigner(s)
signersEntities = append(signersEntities, *signerEntity)
}
}
func TestMain(m *testing.M) {
dbManager, err = mgdb.NewManager(db)
if err != nil {
fmt.Fprintln(os.Stderr, "An error occured during the connection to MongoDB:", err)
os.Exit(2)
}
collection = dbManager.Get("signatures")
err = collection.Drop()
code := m.Run()
err = collection.Drop()
if err != nil {
fmt.Println("An error occurred while droping the collection")
}
dbManager.Close()
os.Exit(code)
}
func TestInitializeArchives(t *testing.T) {
promise := &cAPI.Promise{
Context: &cAPI.Context{
ContractDocumentHash: contractDocumentHash,
Sequence: sequence,
Signers: signers,
SignatureUUID: signatureUUID,
SignedHash: signedHash,
},
}
archives := entities.NewSignatureArchives(signatureUUIDBson, sequence, signersEntities, contractDocumentHash, signedHash)
manager := &ArchivesManager{
DB: dbManager,
Archives: archives,
}
arch := entities.NewSignatureArchives(signatureUUIDBson, sequence, signersEntities, contractDocumentHash, signedHash)
manager.InitializeArchives(promise, signatureUUIDBson, &signersEntities)
arch.Signers = manager.Archives.Signers
assert.Equal(t, manager.Archives, arch)
ok, err := collection.Insert(manager.Archives)
assert.Equal(t, ok, true)
assert.Equal(t, err, nil)
manager.Archives = &entities.SignatureArchives{}
manager.InitializeArchives(promise, signatureUUIDBson, &signersEntities)
assert.Equal(t, err, nil)
assert.Equal(t, manager.Archives, arch)
ok, err = collection.DeleteByID(*manager.Archives)
assert.Equal(t, err, nil)
assert.Equal(t, ok, true)
}
func TestContainsSignature(t *testing.T) {
archives := entities.NewSignatureArchives(signatureUUIDBson, sequence, signersEntities, contractDocumentHash, signedHash)
manager := &ArchivesManager{
DB: dbManager,
Archives: archives,
}
b, arch := manager.ContainsSignature(signatureUUIDBson)
assert.Equal(t, b, false)
assert.Equal(t, arch, &entities.SignatureArchives{})
ok, err := collection.Insert(archives)
assert.Equal(t, ok, true)
assert.Equal(t, err, nil)
b, arch = manager.ContainsSignature(signatureUUIDBson)
assert.Equal(t, b, true)
assert.Equal(t, arch, archives)
ok, err = collection.DeleteByID(*archives)
assert.Equal(t, err, nil)
assert.Equal(t, ok, true)
}
func TestHasReceivedAbortToken(t *testing.T) {
archives := entities.NewSignatureArchives(signatureUUIDBson, sequence, signersEntities, contractDocumentHash, signedHash)
manager := &ArchivesManager{
DB: dbManager,
Archives: archives,
}
signerIndex := uint32(1)
abortedSigner0 := entities.NewAbortedSigner(uint32(0), uint32(1))
abortedSigner1 := entities.NewAbortedSigner(signerIndex, uint32(1))
assert.Equal(t, len(archives.AbortedSigners), 0)
aborted := manager.HasReceivedAbortToken(signerIndex)
assert.Equal(t, aborted, false)
archives.AbortedSigners = append(archives.AbortedSigners, *abortedSigner0)
aborted = manager.HasReceivedAbortToken(signerIndex)
assert.Equal(t, aborted, false)
archives.AbortedSigners = append(archives.AbortedSigners, *abortedSigner1)
aborted = manager.HasReceivedAbortToken(signerIndex)
assert.Equal(t, aborted, true)
}
func TestWasContractSigned(t *testing.T) {
archives := entities.NewSignatureArchives(signatureUUIDBson, sequence, signersEntities, contractDocumentHash, signedHash)
manager := &ArchivesManager{
DB: dbManager,
Archives: archives,
}
signed, contract := manager.WasContractSigned()
assert.Equal(t, signed, false)
assert.Equal(t, len(contract), 0)
c := []byte{0}
archives.SignedContract = c
signed, contract = manager.WasContractSigned()
assert.Equal(t, signed, true)
assert.Equal(t, contract, c)
}
func TestHasSignerPromised(t *testing.T) {
archives := entities.NewSignatureArchives(signatureUUIDBson, sequence, signersEntities, contractDocumentHash, signedHash)
manager := &ArchivesManager{
DB: dbManager,
Archives: archives,
}
ok := manager.HasSignerPromised(1)
assert.Equal(t, len(archives.ReceivedPromises), 0)
assert.Equal(t, ok, false)
promise0 := &entities.Promise{
RecipientKeyIndex: 1,
SenderKeyIndex: 0,
}
archives.ReceivedPromises = append(archives.ReceivedPromises, *promise0)
assert.Equal(t, len(archives.ReceivedPromises), 1)
ok = manager.HasSignerPromised(1)
assert.Equal(t, ok, false)
promise1 := &entities.Promise{
RecipientKeyIndex: 1,
SenderKeyIndex: 1,
}
archives.ReceivedPromises = append(archives.ReceivedPromises, *promise1)
assert.Equal(t, len(archives.ReceivedPromises), 2)
ok = manager.HasSignerPromised(1)
assert.Equal(t, ok, false)
promise2 := &entities.Promise{
RecipientKeyIndex: 0,
SenderKeyIndex: 1,
}
archives.ReceivedPromises = append(archives.ReceivedPromises, *promise2)
assert.Equal(t, len(archives.ReceivedPromises), 3)
ok = manager.HasSignerPromised(1)
assert.Equal(t, ok, true)
}
// TO MODIFY WHEN SOURCE FUNCTION WILL BE UPDATED
func TestAddToAbort(t *testing.T) {
// TODO
// Test the abortedIndex field, when promises will be implemented
archives := entities.NewSignatureArchives(signatureUUIDBson, sequence, signersEntities, contractDocumentHash, signedHash)
manager := &ArchivesManager{
DB: dbManager,
Archives: archives,
}
promise := &cAPI.Promise{
Context: &cAPI.Context{
Signers: [][]byte{},
Sequence: sequence,
},
}
assert.Equal(t, len(archives.AbortedSigners), 0)
sIndex, err := checker.GetIndexOfSigner(promise, signers[1])
assert.Equal(t, err.Error(), "Signer's hash couldn't be matched")
promise.Context.Signers = signers
sIndex, err = checker.GetIndexOfSigner(promise, signers[1])
assert.Equal(t, err, nil)
assert.Equal(t, sIndex, uint32(1))
manager.AddToAbort(sIndex)
assert.Equal(t, len(archives.AbortedSigners), 1)
assert.Equal(t, archives.AbortedSigners[0].SignerIndex, uint32(1))
manager.AddToAbort(sIndex)
assert.Equal(t, len(archives.AbortedSigners), 1)
assert.Equal(t, archives.AbortedSigners[0].SignerIndex, uint32(1))
}
func TestAddToDishonest(t *testing.T) {
archives := entities.NewSignatureArchives(signatureUUIDBson, sequence, signersEntities, contractDocumentHash, signedHash)
manager := &ArchivesManager{
DB: dbManager,
Archives: archives,
}
promise := &cAPI.Promise{
Context: &cAPI.Context{
Signers: [][]byte{},
Sequence: sequence,
},
}
assert.Equal(t, len(archives.DishonestSigners), 0)
sIndex, err := checker.GetIndexOfSigner(promise, signers[1])
assert.Equal(t, err.Error(), "Signer's hash couldn't be matched")
promise.Context.Signers = signers
sIndex, err = checker.GetIndexOfSigner(promise, signers[1])
assert.Equal(t, err, nil)
assert.Equal(t, sIndex, uint32(1))
manager.AddToDishonest(sIndex)
assert.Equal(t, len(archives.DishonestSigners), 1)
assert.Equal(t, archives.DishonestSigners[0], uint32(1))
manager.AddToDishonest(sIndex)
assert.Equal(t, len(archives.DishonestSigners), 1)
assert.Equal(t, archives.DishonestSigners[0], uint32(1))
}
func TestAddPromise(t *testing.T) {
archives := entities.NewSignatureArchives(signatureUUIDBson, sequence, signersEntities, contractDocumentHash, signedHash)
manager := &ArchivesManager{
DB: dbManager,
Archives: archives,
}
assert.Equal(t, len(archives.ReceivedPromises), 0)
promise0 := &entities.Promise{
RecipientKeyIndex: 1,
SenderKeyIndex: 0,
SequenceIndex: 0,
}
promise1 := &entities.Promise{