func (sn *Node) NotifyOfAction(view int, v *Vote) {
dbg.Lvl4(sn.Name(), "Notifying node to be added/removed of action")
gcm := &SigningMessage{
Suite: sn.Suite().String(),
Type: GroupChanged,
From: sn.Name(),
ViewNbr: view,
//LastSeenVote: int(sn.LastSeenVote),
Gcm: &GroupChangedMessage{
V: v,
HostList: sn.HostListOn(view)}}
switch v.Type {
case AddVT:
if sn.Name() == v.Av.Parent {
sn.PutTo(context.TODO(), v.Av.Name, gcm)
}
case RemoveVT:
if sn.Name() == v.Rv.Parent {
sn.PutTo(context.TODO(), v.Rv.Name, gcm)
}
default:
dbg.Error("notifyofaction: unkown action type")
}
}
// getAddress gets the localhosts IPv4 address.
func GetAddress() (string, error) {
name, err := os.Hostname()
if err != nil {
dbg.Error("Error Resolving Hostname:", err)
return "", err
}
if ipv4host == "NONE" {
as, err := net.LookupHost(name)
if err != nil {
return "", err
}
addr := ""
for _, a := range as {
dbg.Lvl4("a = %+v", a)
if ipv4Reg.MatchString(a) {
dbg.Lvl4("matches")
addr = a
}
}
if addr == "" {
err = errors.New("No IPv4 Address for Hostname")
}
return addr, err
}
return ipv4host, nil
}
func (sn *Node) StartGossip() {
go func() {
t := time.Tick(GOSSIP_TIME)
for {
select {
case <-t:
sn.viewmu.Lock()
c := sn.HostListOn(sn.ViewNo)
sn.viewmu.Unlock()
if len(c) == 0 {
dbg.Error(sn.Name(), "StartGossip: none in hostlist for view:", sn.ViewNo, len(c))
continue
}
sn.randmu.Lock()
from := c[sn.Rand.Int()%len(c)]
sn.randmu.Unlock()
dbg.Lvl4("Gossiping with:", from)
// we dont use voting anyway
// sn.CatchUp(int(atomic.LoadInt64(&sn.LastAppliedVote)+1), from)
case <-sn.closed:
dbg.Lvl3("stopping gossip: closed")
return
}
}
}()
}
// initiated by root, propagated by all others
func (sn *Node) Challenge(sm *SigningMessage) error {
view := sm.ViewNbr
RoundNbr := sm.RoundNbr
dbg.Lvl3("Challenge for round", RoundNbr)
// update max seen round
sn.roundmu.Lock()
sn.LastSeenRound = max(sn.LastSeenRound, RoundNbr)
sn.roundmu.Unlock()
children := sn.Children(view)
challs := make([]*SigningMessage, len(children))
i := 0
for child := range children {
challs[i] = &SigningMessage{
Suite: sn.Suite().String(),
ViewNbr: view,
RoundNbr: RoundNbr,
Type: Challenge,
To: child,
Chm: &ChallengeMessage{
Message: make([]byte, 0),
}}
i++
}
round := sn.Rounds[RoundNbr]
if round == nil {
dbg.Lvl3("No Round Interface created for this round. Children:",
len(children))
} else {
err := round.Challenge(sm, challs)
if err != nil {
return err
}
}
// if we are a leaf, send the respond up
if len(children) == 0 {
sn.Respond(&SigningMessage{
Suite: sn.Suite().String(),
Type: Response,
ViewNbr: view,
RoundNbr: RoundNbr,
})
} else {
// otherwise continue to pass down challenge
for _, out := range challs {
if out.To != "" {
conn := children[out.To]
conn.PutData(out)
} else {
dbg.Error("Out.To == nil with children", children)
}
}
}
// dbg.Lvl4(sn.Name(), "Done handling challenge message")
return nil
}
func (sn *Node) multiplexOnChildren(view int, sm *SigningMessage) {
messgs := make([]coconet.BinaryMarshaler, sn.NChildren(view))
for i := range messgs {
messgs[i] = sm
}
// ctx, _ := context.WithTimeout(context.Background(), 2000*time.Millisecond)
ctx := context.TODO()
if err := sn.PutDown(ctx, view, messgs); err != nil {
dbg.Error("failed to putdown messg to children")
}
}
func ApprovalCheck(PolicyFile, SignaturesFile, Id string) (bool, error) {
var (
commit SignedCommit // Commit corresponding to be verified
developers openpgp.EntityList // List of all developers whose public keys are in the policy file
approvers map[string]*openpgp.Entity // Map of developers who provided a valid signature. Indexed by public key id (openpgp.PrimaryKey.KeyIdString)
err error
)
commit.Policy.Threshold, commit.Policy.DevPubKeys, commit.Policy.CothKey, err = PolicyScanner(PolicyFile)
checkFileError(err, PolicyFile)
commit.Signatures, err = SigScanner(SignaturesFile)
checkFileError(err, SignaturesFile)
commit.CommitID = Id
// commit.CommitID, err = CommitScanner(CommitIdFile)
// checkFileError(err, CommitIdFile)
// commit.Approval = false
approvers = make(map[string]*openpgp.Entity)
// Creating openpgp entitylist from list of public keys
developers = make(openpgp.EntityList, 0)
for _, pubkey := range commit.Policy.DevPubKeys {
keybuf, err := openpgp.ReadArmoredKeyRing(strings.NewReader(pubkey))
if err != nil {
dbg.Error("Could not decode armored public key", err)
}
for _, entity := range keybuf {
developers = append(developers, entity)
}
}
// Verifying every signature in the list and counting valid ones
for _, signature := range commit.Signatures {
result, err := openpgp.CheckArmoredDetachedSignature(developers, bytes.NewBufferString(commit.CommitID), strings.NewReader(signature))
if err != nil {
dbg.Lvl1("The signature is invalid or cannot be verified due to", err)
} else {
if approvers[result.PrimaryKey.KeyIdString()] == nil { // We need to check that this is a unique signature
approvers[result.PrimaryKey.KeyIdString()] = result
dbg.Lvl3("Approver: %+v", result.Identities)
}
}
}
dbg.Lvl3("Is release approved? ", len(approvers) >= commit.Policy.Threshold)
// commit.Approval = (len(approvers) >= commit.Policy.Threshold)
return len(approvers) >= commit.Policy.Threshold, err
// return commit, err
}
func (sn *Node) ApplyAction(view int, v *Vote) {
dbg.Lvl4(sn.Name(), "APPLYING ACTION")
switch v.Type {
case AddVT:
sn.AddPeerToHostlist(view, v.Av.Name)
if sn.Name() == v.Av.Parent {
sn.AddChildren(view, v.Av.Name)
}
case RemoveVT:
// removes node from Hostlist, and from children list
sn.RemovePeer(view, v.Rv.Name)
// not closing TCP connection on remove because if view
// does not go through, connection essential to old/ current view closed
default:
dbg.Error("applyvote: unkown action type")
}
}
// Scanner for a file containing policy
func PolicyScanner(filename string) (int, []string, string, error) {
var threshold int
var cothkey string
dbg.Lvl3("Reading file", filename)
file, err := os.Open(filename)
defer file.Close()
if err != nil {
dbg.Lvl1("Couldn't open file", file, err)
return -1, nil, "", err
}
scanner := bufio.NewScanner(file)
keyblock := make([]string, 0)
devkeys := make([]string, 0)
for scanner.Scan() {
text := scanner.Text()
dbg.Lvl3("Decoding", text)
switch text {
case "Threshold:":
// reading threshold number
dbg.Lvl3("Found Threshold")
// if we have found "threshold" word, we know that the value is
// in the next line so we scan next line and if it is not empty,
// we save the value as the threshold
scanner.Scan()
text := scanner.Text()
if len(text) > 0 {
threshold, err = strconv.Atoi(text)
}
if err != nil {
dbg.Error("Could not convert threshold into a number")
}
// If there is a key block being constructed when we encounter the threshold,
// we know that the key block is fulfilled so we have have to append it to
// the array of developer keys
if len(keyblock) > 0 {
devkeys = append(devkeys, strings.Join(keyblock, "\n"))
keyblock = make([]string, 0)
}
case "-----BEGIN PGP PUBLIC KEY BLOCK-----":
// reading developers' public keys
dbg.Lvl3("Found Developers' public keys")
if len(keyblock) > 0 {
// if keyblock already exsits, it means that we encounter beggining of a new key,
// so we need to save the previous one and start constructing a new one
devkeys = append(devkeys, strings.Join(keyblock, "\n"))
keyblock = make([]string, 0)
}
keyblock = append(keyblock, text)
case "Cothority Public Key:":
// reading cothority public key
dbg.Lvl3("Found Cothority public key")
if len(keyblock) > 0 {
devkeys = append(devkeys, strings.Join(keyblock, "\n"))
keyblock = make([]string, 0)
}
scanner.Scan()
text := scanner.Text()
for text != "" {
keyblock = append(keyblock, text)
err := scanner.Scan()
if err != false {
text = scanner.Text()
} else {
break
}
}
cothkey = strings.Join(keyblock, "")
keyblock = make([]string, 0)
case "":
if len(keyblock) == 0 {
continue
}
keyblock = append(keyblock, text)
default:
if text != "Developers Public Keys:" {
// All parameters except PGP keys follow at next line from a name of the parameter
// so by default we a new line to a current key block
keyblock = append(keyblock, text)
}
}
}
return threshold, devkeys, cothkey, err
}
func main() {
const text = `cf0b83954b84c27b2e7c345e1356b4d0f9de9a33`
const privatering = `-----BEGIN PGP PRIVATE KEY BLOCK-----
Comment: GPGTools - https://gpgtools.org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=eWT7
-----END PGP PRIVATE KEY BLOCK-----`
developers, err := openpgp.ReadArmoredKeyRing(strings.NewReader(privatering))
if err != nil {
dbg.Error("Could not read private keyring", err)
}
w := new(bytes.Buffer)
for _, entity := range developers {
openpgp.ArmoredDetachSign(w, entity, strings.NewReader(text), nil)
w.WriteByte(byte('\n'))
}
err = ioutil.WriteFile("signatures.txt", w.Bytes(), 0660)
if err != nil {
dbg.Error("Could not write to a file", err)
}
fmt.Println(w.String())
}
func checkFileError(err error, filename string) {
if err != nil {
dbg.Error("Could not read file", filename)
}
}
func main() {
conf := &app.ConfigColl{}
app.ReadConfig(conf)
// we must know who we are
if app.RunFlags.Hostname == "" {
dbg.Fatal("Hostname empty: Abort")
}
// Do some common setup
if app.RunFlags.Mode == "client" {
app.RunFlags.Hostname = app.RunFlags.Name
}
hostname := app.RunFlags.Hostname
if hostname == conf.Hosts[0] {
dbg.Lvlf3("Tree is %+v", conf.Tree)
}
dbg.Lvl3(hostname, "Starting to run")
app.RunFlags.StartedUp(len(conf.Hosts))
peer := conode.NewPeer(hostname, conf.ConfigConode)
Releases = make(map[string]CommitEntry)
//ReleaseInformation()
ReadRelease(PolicyFile, SignaturesFile, CommitIdFile)
if app.RunFlags.AmRoot {
err := peer.WaitRoundSetup(len(conf.Hosts), 5, 2)
if err != nil {
dbg.Fatal(err)
}
dbg.Lvl1("Starting the rounds")
}
if app.RunFlags.AmRoot {
for round := 0; round < conf.Rounds; round++ {
dbg.Lvl1("Doing round", round, "of", conf.Rounds)
wallTime := monitor.NewMeasure("round")
hashToSign, _ := CommitScanner(CommitIdFile) // retrieve commitid/hash that the root is willing to get signed
entry := Releases[hashToSign]
if entry.policy != "" && entry.signatures != "" {
rootpgpTime := monitor.NewMeasure("rootpgp")
decision, err := ApprovalCheck(entry.policy, entry.signatures, hashToSign)
rootpgpTime.Measure()
if decision && err == nil {
round := NewRoundSwsign(peer.Node)
round.Hash = []byte(hashToSign) // passing hash of the file that we want to produce a signature for
peer.StartAnnouncement(round)
wallTime.Measure()
Signature := <-round.Signature
dbg.Lvlf1("Received signature %+v", Signature)
} else {
dbg.Fatal("Developers related to the root haven't approved the release so the root didn't start signing process")
}
} else {
dbg.Error("There is no input with such commitid", hashToSign)
}
}
peer.SendCloseAll()
} else {
peer.LoopRounds(RoundSwsignType, conf.Rounds)
}
dbg.Lvlf3("Done - flags are %+v", app.RunFlags)
monitor.End()
}
// Get multiplexes all messages from TCPHost using application logic
func (sn *Node) ProcessMessages() error {
dbg.Lvl4(sn.Name(), "getting")
defer dbg.Lvl4(sn.Name(), "done getting")
sn.UpdateTimeout()
dbg.Lvl4("Going to get", sn.Name())
msgchan := sn.Host.GetNetworkMessg()
// heartbeat for intiating viewChanges, allows intial 500s setup time
/* sn.hbLock.Lock()
sn.heartbeat = time.NewTimer(500 * time.Second)
sn.hbLock.Unlock() */
// gossip to make sure we are up to date
sn.StartGossip()
errReset := syscall.ECONNRESET.Error()
for {
select {
case <-sn.closed:
dbg.Lvl3("Received closed-message through channel")
sn.StopHeartbeat()
return nil
default:
dbg.Lvl4(sn.Name(), "waiting for message")
nm, ok := <-msgchan
err := nm.Err
errStr := ""
if err != nil {
errStr = err.Error()
}
// One of the errors doesn't have an error-number applied, so we need
// to check for the string - will probably be fixed in go 1.6
if !ok || err == coconet.ErrClosed || err == io.EOF ||
err == io.ErrClosedPipe {
dbg.Lvl3(sn.Name(), "getting from closed host")
sn.Close()
return coconet.ErrClosed
}
// if it is a non-fatal error try again
if err != nil {
if strings.Contains(errStr, errReset) {
dbg.Lvl2(sn.Name(), "connection reset error")
return coconet.ErrClosed
}
dbg.Lvl1(sn.Name(), "error getting message (still continuing)", err)
continue
}
// interpret network message as Signing Message
sm := nm.Data.(*SigningMessage)
sm.From = nm.From
dbg.Lvlf4("Message on %s is type %s and %+v", sn.Name(), sm.Type, sm)
switch sm.Type {
// if it is a bad message just ignore it
default:
continue
case Announcement:
dbg.Lvl3(sn.Name(), "got announcement")
sn.ReceivedHeartbeat(sm.ViewNbr)
var err error
if sm.Am.Vote != nil {
err = sn.Propose(sm.ViewNbr, sm.RoundNbr, sm.Am, sm.From)
dbg.Lvl4(sn.Name(), "done proposing")
} else {
if !sn.IsParent(sm.ViewNbr, sm.From) {
log.Fatalln(sn.Name(), "received announcement from non-parent on view", sm.ViewNbr)
continue
}
err = sn.Announce(sm)
}
if err != nil {
dbg.Error(sn.Name(), "announce error:", err)
}
// if it is a commitment or response it is from the child
case Commitment:
dbg.Lvl3(sn.Name(), "got commitment")
if !sn.IsChild(sm.ViewNbr, sm.From) {
log.Fatalln(sn.Name(), "received commitment from non-child on view", sm.ViewNbr)
continue
}
var err error
if sm.Com.Vote != nil {
err = sn.Promise(sm.ViewNbr, sm.RoundNbr, sm)
} else {
err = sn.Commit(sm)
}
if err != nil {
dbg.Error(sn.Name(), "commit error:", err)
}
case Challenge:
dbg.Lvl3(sn.Name(), "got challenge")
if !sn.IsParent(sm.ViewNbr, sm.From) {
log.Fatalln(sn.Name(), "received challenge from non-parent on view", sm.ViewNbr)
continue
}
sn.ReceivedHeartbeat(sm.ViewNbr)
var err error
if sm.Chm.Vote != nil {
err = sn.Accept(sm.ViewNbr, sm.RoundNbr, sm.Chm)
} else {
err = sn.Challenge(sm)
}
if err != nil {
dbg.Error(sn.Name(), "challenge error:", err)
}
case Response:
dbg.Lvl3(sn.Name(), "received response from", sm.From)
if !sn.IsChild(sm.ViewNbr, sm.From) {
log.Fatalln(sn.Name(), "received response from non-child on view", sm.ViewNbr)
continue
}
var err error
if sm.Rm.Vote != nil {
err = sn.Accepted(sm.ViewNbr, sm.RoundNbr, sm)
} else {
err = sn.Respond(sm)
}
if err != nil {
dbg.Error(sn.Name(), "response error:", err)
}
case SignatureBroadcast:
dbg.Lvl3(sn.Name(), "received SignatureBroadcast", sm.From)
sn.ReceivedHeartbeat(sm.ViewNbr)
err = sn.SignatureBroadcast(sm)
case StatusReturn:
sn.StatusReturn(sm.ViewNbr, sm)
case CatchUpReq:
v := sn.VoteLog.Get(sm.Cureq.Index)
ctx := context.TODO()
sn.PutTo(ctx, sm.From,
&SigningMessage{
Suite: sn.Suite().String(),
From: sn.Name(),
Type: CatchUpResp,
//LastSeenVote: int(atomic.LoadInt64(&sn.LastSeenVote)),
Curesp: &CatchUpResponse{Vote: v}})
case CatchUpResp:
if sm.Curesp.Vote == nil || sn.VoteLog.Get(sm.Curesp.Vote.Index) != nil {
continue
}
vi := sm.Curesp.Vote.Index
// put in votelog to be streamed and applied
sn.VoteLog.Put(vi, sm.Curesp.Vote)
// continue catching up
sn.CatchUp(vi+1, sm.From)
case GroupChange:
if sm.ViewNbr == -1 {
sm.ViewNbr = sn.ViewNo
if sm.Vrm.Vote.Type == AddVT {
sn.AddPeerToPending(sm.From)
}
}
// TODO sanity checks: check if view is == sn.ViewNo
if sn.RootFor(sm.ViewNbr) == sn.Name() {
dbg.Fatal("Group change not implementekd. BTH")
//go sn.StartVotingRound(sm.Vrm.Vote)
continue
}
sn.PutUp(context.TODO(), sm.ViewNbr, sm)
case GroupChanged:
if !sm.Gcm.V.Confirmed {
dbg.Lvl4(sn.Name(), " received attempt to group change not confirmed")
continue
}
if sm.Gcm.V.Type == RemoveVT {
dbg.Lvl4(sn.Name(), " received removal notice")
} else if sm.Gcm.V.Type == AddVT {
dbg.Lvl4(sn.Name(), " received addition notice")
sn.NewView(sm.ViewNbr, sm.From, nil, sm.Gcm.HostList)
} else {
log.Errorln(sn.Name(), "received GroupChanged for unacceptable action")
}
case StatusConnections:
sn.ReceivedHeartbeat(sm.ViewNbr)
err = sn.StatusConnections(sm.ViewNbr, sm.Am)
case CloseAll:
sn.ReceivedHeartbeat(sm.ViewNbr)
err = sn.CloseAll(sm.ViewNbr)
return nil
case Error:
dbg.Lvl4("Received Error Message:", errors.New("received message of unknown type"), sm, sm.Err)
}
}
}
}
// ConstructTree does a depth-first construction of the tree specified in the
// config file. ConstructTree must be called AFTER populating the HostConfig with
// ALL the possible hosts.
func ConstructTree(
node *Tree,
hc *HostConfig,
parent string,
suite abstract.Suite,
rand cipher.Stream,
hosts map[string]coconet.Host,
nameToAddr map[string]string,
opts ConfigOptions) (int, error) {
// passes up its X_hat, and/or an error
// get the name associated with this address
name, ok := nameToAddr[node.Name]
if !ok {
dbg.Lvl3("unknown name in address book:", node.Name)
return 0, errors.New("unknown name in address book")
}
// generate indicates whether we should generate the signing
// node for this hostname
//dbg.Lvl4("opts.Host - name", opts.Host, name)
generate := opts.Host == "" || opts.Host == name
// check to make sure the this hostname is in the tree
// it can be backed by a nil pointer
h, ok := hosts[name]
if !ok {
dbg.Lvl3("unknown host in tree:", name)
return 0, errors.New("unknown host in tree")
}
var prikey abstract.Secret
var pubkey abstract.Point
var sn *sign.Node
// if the JSON holds the fields field is set load from there
if len(node.PubKey) != 0 {
// dbg.Lvl4("decoding point")
encoded, err := hex.DecodeString(string(node.PubKey))
if err != nil {
dbg.Error("failed to decode hex from encoded")
return 0, err
}
pubkey = suite.Point()
err = pubkey.UnmarshalBinary(encoded)
if err != nil {
dbg.Error("failed to decode point from hex")
return 0, err
}
}
if len(node.PriKey) != 0 {
// dbg.Lvl4("decoding point")
encoded, err := hex.DecodeString(string(node.PriKey))
if err != nil {
dbg.Error("failed to decode hex from encoded")
return 0, err
}
prikey = suite.Secret()
err = prikey.UnmarshalBinary(encoded)
if err != nil {
dbg.Error("failed to decode point from hex")
return 0, err
}
}
if generate {
if prikey != nil {
// if we have been given a private key load that
aux := sign.NewKeyedNode(h, suite, prikey)
aux.GenSetPool()
hc.SNodes = append(hc.SNodes, aux)
h.SetPubKey(pubkey)
} else {
// otherwise generate a random new one
sn := sign.NewNode(h, suite, rand)
sn.GenSetPool()
hc.SNodes = append(hc.SNodes, sn)
h.SetPubKey(sn.PubKey)
}
sn = hc.SNodes[len(hc.SNodes)-1]
hc.Hosts[name] = sn
if prikey == nil {
prikey = sn.PrivKey
pubkey = sn.PubKey
}
// dbg.Lvl4("pubkey:", sn.PubKey)
// dbg.Lvl4("given:", pubkey)
}
// if the parent of this call is empty then this must be the root node
if parent != "" && generate {
//dbg.Lvl5("Adding parent for", h.Name(), "to", parent)
h.AddParent(0, parent)
}
// dbg.Lvl4("name:", n.Name)
// dbg.Lvl4("prikey:", prikey)
// dbg.Lvl4("pubkey:", pubkey)
height := 0
for _, c := range node.Children {
// connect this node to its children
cname, ok := nameToAddr[c.Name]
if !ok {
dbg.Lvl3("unknown name in address book:", node.Name)
return 0, errors.New("unknown name in address book")
}
if generate {
//dbg.Lvl4("Adding children for", h.Name())
h.AddChildren(0, cname)
}
// recursively construct the children
// Don't enable this debugging-line - it will make the constructtree VERY slow
//dbg.Lvl5("ConstructTree:", h, suite, rand, hosts, nameToAddr, opts)
h, err := ConstructTree(c, hc, name, suite, rand, hosts, nameToAddr, opts)
if err != nil {
return 0, err
}
height = max(h+1, height)
// if generating all csn will be availible
}
if generate {
sn.Height = height
}
// dbg.Lvl4("name:", n.Name)
// dbg.Lvl4("final x_hat:", x_hat)
// dbg.Lvl4("final pubkey:", pubkey)
return height, nil
}
func main() {
const text = `cf0b83954b84c27b2e7c345e1356b4d0f9de9a33`
const amount = 100
const poname = "policy.txt"
const cothk = `BFZMf2MBCADjrCHk+W+MTXh9ZiwAScnaROwEER39zuieHdz0g9whVVTubl8SakGp
sCw7ZjHJARC+YqRH2oiqqLQ0ZYp7SFLcByin4FLJBqHeuCONhP1j6DHj5yDfNcyP`
var developers openpgp.EntityList
for i := 0; i < amount; i++ {
entity, err := openpgp.NewEntity(strconv.Itoa(i), "", "", nil)
developers = append(developers, entity)
if err != nil {
dbg.Errorf("PGP entity %+v has not been created %+v", i, err)
}
}
// Creating a policy file
w := new(bytes.Buffer)
_, err := w.WriteString("Threshold:\n")
_, err = w.WriteString(strconv.Itoa(amount))
_, err = w.WriteString("\n\n\nDevelopers Public Keys:\n")
err = ioutil.WriteFile(poname, w.Bytes(), 0660)
w.Reset()
f, _ := os.OpenFile(poname, os.O_APPEND|os.O_WRONLY, 0660)
defer f.Close()
for _, entity := range developers {
asciiwr := new(bytes.Buffer)
arm, _ := armor.Encode(asciiwr, openpgp.PublicKeyType, nil)
err := entity.SerializePrivate(arm, nil)
err = entity.Serialize(arm)
if err != nil {
dbg.Error("Problem with serializing public key", err)
}
arm.Close()
asciiwr.WriteByte(byte('\n'))
n, er := f.Write(asciiwr.Bytes())
if er != nil {
dbg.Error("Could not write a public key to policy file", n)
}
}
_, err = f.WriteString("\n\nCothority Public Key:\n")
_, err = f.WriteString(cothk)
if err != nil {
dbg.Error("Could not write to policy a file", err)
}
for _, entity := range developers {
openpgp.ArmoredDetachSign(w, entity, strings.NewReader(text), nil)
w.WriteByte(byte('\n'))
}
err = ioutil.WriteFile("signatures.txt", w.Bytes(), 0660)
if err != nil {
dbg.Error("Could not write to a signatures file", err)
}
//fmt.Println(w.String())
}
