func (tran *TransactionList) Print() {
for _, tx := range tran.Txs {
log.Printf("TxId: %v", tx.Hash)
log.Print("TxIns:")
if tx.TxInCnt == 1 && tx.TxIns[0].InputVout == 4294967295 {
log.Printf("TxIn coinbase, newly generated coins")
} else {
for txin_index, txin := range tx.TxIns {
log.Printf("TxIn index: %v", txin_index)
log.Printf("TxIn Input_Hash: %v", txin.InputHash)
log.Printf("TxIn Input_Index: %v", txin.InputVout)
}
}
log.Print("TxOuts:")
for txo_index, txout := range tx.TxOuts {
log.Printf("TxOut index: %v", txo_index)
log.Printf("TxOut value: %v", txout.Value)
txout_addr := txout.Addr
if txout_addr != "" {
log.Printf("TxOut address: %v", txout_addr)
} else {
log.Printf("TxOut address: can't decode address")
}
}
}
}
// printConn prints the status response that is returned from the server
func printConn(e *status.Response) {
var a []string
for key, value := range e.Msg["Status"].Field {
a = append(a, (key + ": " + value + "\n"))
}
sort.Strings(a)
strings.Join(a, "\n")
log.Print(a)
}
// readGroup takes a toml file name and reads the file, returning the entities within
func readGroup(tomlFileName string) (*onet.Roster, error) {
log.Print("Reading From File")
f, err := os.Open(tomlFileName)
if err != nil {
return nil, err
}
el, err := config.ReadGroupToml(f)
if err != nil {
return nil, err
}
if len(el.List) <= 0 {
return nil, errors.New("Empty or invalid group file:" +
tomlFileName)
}
log.Lvl3(el)
return el, err
}
func (jv *JVSS) initSecret(sid SID) error {
if sid.IsLTSS() && jv.ltssInit {
return errors.New("Only one longterm secret allowed per JVSS instance")
}
// Initialise shared secret of given type if necessary
if sec, err := jv.secrets.secret(sid); sec == nil && err != nil {
log.Lvlf4("Node %d: Initialising %s shared secret", jv.Index(),
sid)
sec := &secret{
receiver: poly.NewReceiver(jv.keyPair.Suite, jv.info, jv.keyPair),
deals: make(map[int]*poly.Deal),
sigs: make(map[int]*poly.SchnorrPartialSig),
numLongtermConfs: 0,
}
jv.secrets.addSecret(sid, sec)
}
secret, err := jv.secrets.secret(sid)
if err != nil { // this should never happen here
log.Error(err)
return err
}
// Initialise and broadcast our deal if necessary
if len(secret.deals) == 0 {
kp := config.NewKeyPair(jv.keyPair.Suite)
deal := new(poly.Deal).ConstructDeal(kp, jv.keyPair, jv.info.T, jv.info.R, jv.pubKeys)
log.Lvlf4("Node %d: Initialising %v deal", jv.Index(), sid)
secret.deals[jv.Index()] = deal
db, _ := deal.MarshalBinary()
msg := &SecInitMsg{
Src: jv.Index(),
SID: sid,
Deal: db,
}
if err := jv.Broadcast(msg); err != nil {
log.Print(jv.Name(), "Error broadcast secInit:", err)
return err
}
}
return nil
}
// verify takes a file and a group-definition, calls the signature
// verification and prints the result. If sigFileName is empty it
// assumes to find the standard signature in fileName.sig
func verify(fileName, sigFileName, groupToml string) error {
// if the file hash matches the one in the signature
log.Lvl4("Reading file " + fileName)
b, err := ioutil.ReadFile(fileName)
if err != nil {
return errors.New("Couldn't open msgFile: " + err.Error())
}
// Read the JSON signature file
log.Lvl4("Reading signature")
var sigBytes []byte
if sigFileName == "" {
log.Print("[+] Reading signature from standard input ...")
sigBytes, err = ioutil.ReadAll(os.Stdin)
} else {
sigBytes, err = ioutil.ReadFile(sigFileName)
}
if err != nil {
return err
}
sig := &s.SignatureResponse{}
log.Lvl4("Unmarshalling signature ")
if err := json.Unmarshal(sigBytes, sig); err != nil {
return err
}
fGroup, err := os.Open(groupToml)
if err != nil {
return err
}
log.Lvl4("Reading group definition")
el, err := config.ReadGroupToml(fGroup)
if err != nil {
return err
}
log.Lvl4("Verfifying signature")
err = verifySignatureHash(b, sig, el)
return err
}
// verifyPrintResult prints out OK or what failed.
func verifyPrintResult(err error) {
log.ErrFatal(err, "Invalid: Signature verification failed:")
log.Print("[+] OK: Signature is valid.")
}
// getpass contacts the guard servers, then gets the passwords and
// reconstructs the secret keys.
func getpass(c *cli.Context, uid []byte, epoch []byte, pass string) {
if getuser(uid) == nil {
log.Fatal("Wrong username")
}
keys := make([]string, len(db.Cothority.List))
blind := make([]byte, 12)
_, err := rand.Read(blind)
log.ErrFatal(err)
blinds := saltgen(blind, len(db.Cothority.List))
iv := getuser(uid).Iv
// pwhash is the password hash that will be sent to the guard servers
// with Gu and bi.
pwhash := abstract.Sum(network.Suite, []byte(pass), getuser(uid).Salt)
GuHash := abstract.Sum(network.Suite, uid, epoch)
// creating stream for Scalar.Pick from the hash
blocky, err := aes.NewCipher(iv)
log.ErrFatal(err)
GuStream := cipher.NewCTR(blocky, iv)
gupoint := network.Suite.Point()
Gu, _ := gupoint.Pick(GuHash, GuStream)
for i, si := range db.Cothority.List {
cl := guard.NewClient()
// blankpoints needed for computations.
blankpoint := network.Suite.Point()
blankscalar := network.Suite.Scalar()
// pwbytes and blindbytes are actually scalars that are
// initialized to the values of the bytes.
pwbytes := network.Suite.Scalar()
pwbytes.SetBytes(pwhash)
blindbytes := network.Suite.Scalar()
blindbytes.SetBytes(blinds[i])
// The following sections of the code perform the computations
// to Create Xi, here called sendy.
blankscalar.Add(pwbytes, blindbytes).MarshalBinary()
_, err := blankpoint.Mul(Gu, blankscalar.Mul(pwbytes, blindbytes)).MarshalBinary()
sendy := blankpoint.Mul(Gu, blankscalar.Mul(pwbytes, blindbytes))
rep, cerr := cl.SendToGuard(si, uid, epoch, sendy)
log.ErrFatal(cerr)
// This section of the program removes the blinding factor from
// the Zi for storage.
reply, err := blankpoint.Mul(rep.Msg, blankscalar.Inv(blindbytes)).MarshalBinary()
log.ErrFatal(err)
// This section Xors the data with the response.
block, err := aes.NewCipher(reply)
stream := cipher.NewCTR(block, getuser(uid).Iv)
msg := make([]byte, len([]byte(getuser(uid).Keys[i])))
stream.XORKeyStream(msg, []byte(getuser(uid).Keys[i]))
keys[i] = string(msg)
}
k := s.Combine(keys)
if len(k) == 0 {
log.Fatal("You entered the wrong password")
}
block, err := aes.NewCipher([]byte(k))
log.ErrFatal(err)
aesgcm, err := cipher.NewGCM(block)
log.ErrFatal(err)
plaintext, err := aesgcm.Open(nil, getuser(uid).Salt, getuser(uid).Data, nil)
log.ErrFatal(err)
log.Print(string(plaintext))
}