starter.go 6.27 KB
Newer Older
1
2
3
4
5
package sign

import (
	"errors"
	"fmt"
6
	"log"
7
	"strconv"
Loïck Bonniot's avatar
Loïck Bonniot committed
8
	"time"
9

Caro Axel's avatar
Caro Axel committed
10
11
	"dfss"
	cAPI "dfss/dfssc/api"
12
	"dfss/dfssc/common"
13
	"dfss/dfssc/security"
Caro Axel's avatar
Caro Axel committed
14
	pAPI "dfss/dfssp/api"
15
16
17
	"dfss/dfssp/contract"
	"dfss/net"
	"golang.org/x/net/context"
Caro Axel's avatar
Caro Axel committed
18
	"google.golang.org/grpc"
19
20
21
22
)

// SignatureManager handles the signature of a contract.
type SignatureManager struct {
23
24
25
26
	auth         *security.AuthContainer
	localPort    int
	contract     *contract.JSON // contains the contractUUID, the list of the signers' hashes, the hash of the contract
	platform     pAPI.PlatformClient
27
28
	platformConn *grpc.ClientConn
	peersConn    map[string]*grpc.ClientConn
29
	peers        map[string]*cAPI.ClientClient
30
	hashToID     map[string]uint32
31
32
	nbReady      int
	cServer      *grpc.Server
33
	cServerIface clientServer
34
35
36
37
38
39
	sequence     []uint32
	currentIndex int
	uuid         string
	keyHash      [][]byte
	mail         string
	archives     *Archives
40
41
42
43
44
45
46
47
}

// Archives stores the recieved and sent messages, as evidence if needed
type Archives struct {
	sentPromises       []*cAPI.Promise
	recievedPromises   []*cAPI.Promise
	sentSignatures     []*cAPI.Signature
	recievedSignatures []*cAPI.Signature
48
49
50
51
52
53
54
55
}

// NewSignatureManager populates a SignatureManager and connects to the platform.
func NewSignatureManager(fileCA, fileCert, fileKey, addrPort, passphrase string, port int, c *contract.JSON) (*SignatureManager, error) {
	m := &SignatureManager{
		auth:      security.NewAuthContainer(fileCA, fileCert, fileKey, addrPort, passphrase),
		localPort: port,
		contract:  c,
56
57
58
59
60
61
		archives: &Archives{
			sentPromises:       make([]*cAPI.Promise, 0),
			recievedPromises:   make([]*cAPI.Promise, 0),
			sentSignatures:     make([]*cAPI.Signature, 0),
			recievedSignatures: make([]*cAPI.Signature, 0),
		},
62
	}
Caro Axel's avatar
Caro Axel committed
63
	var err error
64
	_, _, _, err = m.auth.LoadFiles()
65
66
67
68
	if err != nil {
		return nil, err
	}

69
	m.mail = m.auth.Cert.Subject.CommonName
70

Caro Axel's avatar
Caro Axel committed
71
	m.cServer = m.GetServer()
72
	go func() { log.Fatalln(net.Listen("0.0.0.0:"+strconv.Itoa(port), m.cServer)) }()
Caro Axel's avatar
Caro Axel committed
73

74
	conn, err := net.Connect(m.auth.AddrPort, m.auth.Cert, m.auth.Key, m.auth.CA)
75
76
77
78
	if err != nil {
		return nil, err
	}

Caro Axel's avatar
Caro Axel committed
79
	m.platform = pAPI.NewPlatformClient(conn)
80
	m.platformConn = conn
81

82
	m.peersConn = make(map[string]*grpc.ClientConn)
Caro Axel's avatar
Caro Axel committed
83
	m.peers = make(map[string]*cAPI.ClientClient)
84
	for _, u := range c.Signers {
85
		if u.Email != m.auth.Cert.Subject.CommonName {
86
87
			m.peers[u.Email] = nil
		}
88
89
90
91
92
93
94
	}

	return m, nil
}

// ConnectToPeers tries to fetch the list of users for this contract, and tries to establish a connection to each peer.
func (m *SignatureManager) ConnectToPeers() error {
Caro Axel's avatar
Caro Axel committed
95
	stream, err := m.platform.JoinSignature(context.Background(), &pAPI.JoinSignatureRequest{
96
97
98
99
100
101
102
103
104
105
106
107
108
		ContractUuid: m.contract.UUID,
		Port:         uint32(m.localPort),
	})
	if err != nil {
		return err
	}

	for {
		userConnected, err := stream.Recv()
		if err != nil {
			return err
		}
		errorCode := userConnected.GetErrorCode()
Caro Axel's avatar
Caro Axel committed
109
		if errorCode.Code != pAPI.ErrorCode_SUCCESS {
110
111
112
113
			return errors.New(errorCode.Message)
		}
		ready, err := m.addPeer(userConnected.User)
		if err != nil {
114
			continue // Unable to connect to this user, ignore it for the moment
115
116
117
118
119
120
121
122
123
124
		}
		if ready {
			break
		}
	}

	return nil
}

// addPeer stores a peer from the platform and tries to establish a connection to this peer.
Caro Axel's avatar
Caro Axel committed
125
func (m *SignatureManager) addPeer(user *pAPI.User) (ready bool, err error) {
126
127
128
129
	if user == nil {
		err = errors.New("unexpected user format")
		return
	}
130
131
132
	if _, ok := m.peers[user.Email]; !ok {
		return // Ignore if unknown
	}
133

Caro Axel's avatar
Caro Axel committed
134
	addrPort := user.Ip + ":" + strconv.Itoa(int(user.Port))
135
	fmt.Println("- Trying to connect with", user.Email, "/", addrPort)
136

137
	conn, err := net.Connect(addrPort, m.auth.Cert, m.auth.Key, m.auth.CA)
Caro Axel's avatar
Caro Axel committed
138
139
140
141
142
143
	if err != nil {
		return false, err
	}

	// Sending Hello message
	client := cAPI.NewClientClient(conn)
144
	lastConnection := m.peers[user.Email]
Caro Axel's avatar
Caro Axel committed
145
	m.peers[user.Email] = &client
146
147
148
	// The connection is encapsulated into the interface, so we
	// need to create another way to access it
	m.peersConn[user.Email] = conn
149
150
151
152

	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
	defer cancel()
	msg, err := client.Discover(ctx, &cAPI.Hello{Version: dfss.Version})
Caro Axel's avatar
Caro Axel committed
153
154
155
	if err != nil {
		return false, err
	}
156

Caro Axel's avatar
Caro Axel committed
157
	// Printing answer: application version
158
159
	// TODO check certificate
	fmt.Println("  Successfully connected!", "[", msg.Version, "]")
160
161

	// Check if we have any other peer to connect to
162
163
164
165
	if lastConnection == nil {
		m.nbReady++
		if m.nbReady == len(m.contract.Signers)-1 {
			return true, nil
166
167
168
		}
	}

169
	return false, nil
170
}
Loïck Bonniot's avatar
Loïck Bonniot committed
171
172
173

// SendReadySign sends the READY signal to the platform, and wait (potentially a long time) for START signal.
func (m *SignatureManager) SendReadySign() (signatureUUID string, err error) {
174
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Minute)
Loïck Bonniot's avatar
Loïck Bonniot committed
175
	defer cancel()
Loïck Bonniot's avatar
Loïck Bonniot committed
176
	launch, err := m.platform.ReadySign(ctx, &pAPI.ReadySignRequest{
Loïck Bonniot's avatar
Loïck Bonniot committed
177
178
179
180
181
182
183
		ContractUuid: m.contract.UUID,
	})
	if err != nil {
		return
	}

	errorCode := launch.GetErrorCode()
Loïck Bonniot's avatar
Loïck Bonniot committed
184
	if errorCode.Code != pAPI.ErrorCode_SUCCESS {
Loïck Bonniot's avatar
Loïck Bonniot committed
185
186
187
188
		err = errors.New(errorCode.Code.String() + " " + errorCode.Message)
		return
	}

189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
	// Check signers from platform data
	if len(m.contract.Signers) != len(launch.KeyHash) {
		err = errors.New("Corrupted DFSS file: bad number of signers, unable to sign safely")
		return
	}

	for i, s := range m.contract.Signers {
		if s.Hash != fmt.Sprintf("%x", launch.KeyHash[i]) {
			err = errors.New("Corrupted DFSS file: signer " + s.Email + " has an invalid hash, unable to sign safely")
			return
		}
	}

	m.sequence = launch.Sequence
	m.uuid = launch.SignatureUuid
204
	m.keyHash = launch.KeyHash
205
	signatureUUID = m.uuid
Loïck Bonniot's avatar
Loïck Bonniot committed
206
207
	return
}
208

209
// Initialize computes the values needed for the start of the signing
210
func (m *SignatureManager) Initialize() (uint32, int, error) {
211
212
	myID, err := m.FindID()
	if err != nil {
213
		return 0, 0, err
214
215
	}

216
	m.currentIndex, err = common.FindNextIndex(m.sequence, myID, -1)
217
	if err != nil {
218
		return 0, 0, err
219
220
	}

221
	nextIndex, err := common.FindNextIndex(m.sequence, myID, m.currentIndex)
222
	if err != nil {
223
		return 0, 0, err
224
225
	}

226
	return myID, nextIndex, nil
227
228
229
230
}

// FindID finds the sequence id for the user's email and the contract to sign
func (m *SignatureManager) FindID() (uint32, error) {
231
232
	signers := m.contract.Signers
	for id, signer := range signers {
233
		if signer.Email == m.mail {
234
235
236
237
238
			return uint32(id), nil
		}
	}
	return 0, errors.New("Mail couldn't be found amongst signers")
}