func nextAddress() interfaces.IAddress {
public, _, _ := ed25519.GenerateKey(zero)
addr := new(factoid.Address)
addr.SetBytes(public[:])
return addr
}
func newCommitChain() *CommitChainMsg {
msg := new(CommitChainMsg)
cc := entryCreditBlock.NewCommitChain()
cc.Version = 0x11
cc.MilliTime = (*primitives.ByteSlice6)(&[6]byte{1, 1, 1, 1, 1, 1})
p, _ := hex.DecodeString("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
cc.ChainIDHash.SetBytes(p)
p, _ = hex.DecodeString("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb")
cc.Weld.SetBytes(p)
p, _ = hex.DecodeString("cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc")
cc.EntryHash.SetBytes(p)
cc.Credits = 11
// make a key and sign the msg
if pub, privkey, err := ed.GenerateKey(rand.Reader); err != nil {
panic(err)
} else {
cc.ECPubKey = (*primitives.ByteSlice32)(pub)
cc.Sig = (*primitives.ByteSlice64)(ed.Sign(privkey, cc.CommitMsg()))
}
msg.CommitChain = cc
//msg.Timestamp = primitives.NewTimestampNow()
return msg
}
func TestSignature(t *testing.T) {
pub, priv, err := ed25519.GenerateKey(rand.Reader)
if err != nil {
t.Error(err)
}
t.Logf("priv, pub - %x, %x", *priv, *pub)
testData := []byte{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07}
sig := ed25519.Sign(priv, testData)
ok := ed25519.Verify(pub, testData, sig)
if ok == false {
t.Error("Signature could not be verified")
}
pub2, err := primitives.PrivateKeyToPublicKey(priv[:])
if err != nil {
t.Error(err)
}
t.Logf("pub1 - %x", pub)
t.Logf("pub2 - %x", pub2)
if primitives.AreBytesEqual(pub[:], pub2[:]) == false {
t.Error("Public keys are not equal")
}
}
func newCommitEntry() *CommitEntryMsg {
cem := new(CommitEntryMsg)
ce := entryCreditBlock.NewCommitEntry()
// build a CommitEntry for testing
ce.Version = 0
ce.MilliTime = (*primitives.ByteSlice6)(&[6]byte{1, 1, 1, 1, 1, 1})
p, _ := hex.DecodeString("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
ce.EntryHash.SetBytes(p)
ce.Credits = 1
// make a key and sign the msg
if pub, privkey, err := ed.GenerateKey(rand.Reader); err != nil {
panic(err)
} else {
ce.ECPubKey = (*primitives.ByteSlice32)(pub)
ce.Sig = (*primitives.ByteSlice64)(ed.Sign(privkey, ce.CommitMsg()))
}
cem.CommitEntry = ce
//cem.Timestamp = primitives.NewTimestampNow()
return cem
}
func nextAddress() IAddress {
public, _, _ := ed25519.GenerateKey(zero)
addr := new(Address)
addr.SetBytes(public[:])
return addr
}
func createECBlock() *ECBlock {
ecb1 := NewECBlock().(*ECBlock)
// build a CommitChain for testing
cc := NewCommitChain()
cc.Version = 0
cc.MilliTime = (*primitives.ByteSlice6)(&[6]byte{1, 1, 1, 1, 1, 1})
cc.ChainIDHash.SetBytes(byteof(0xaa))
cc.Weld.SetBytes(byteof(0xbb))
cc.EntryHash.SetBytes(byteof(0xcc))
cc.Credits = 11
// make a key and sign the msg
if pub, privkey, err := ed.GenerateKey(rand.Reader); err != nil {
panic(err)
} else {
cc.ECPubKey = (*primitives.ByteSlice32)(pub)
cc.Sig = (*primitives.ByteSlice64)(ed.Sign(privkey, cc.CommitMsg()))
}
// create a ECBlock for testing
ecb1.Header.(*ECBlockHeader).ECChainID.SetBytes(byteof(0x11))
ecb1.Header.(*ECBlockHeader).BodyHash.SetBytes(byteof(0x22))
ecb1.Header.(*ECBlockHeader).PrevHeaderHash.SetBytes(byteof(0x33))
ecb1.Header.(*ECBlockHeader).PrevLedgerKeyMR.SetBytes(byteof(0x44))
ecb1.Header.(*ECBlockHeader).DBHeight = 10
ecb1.Header.(*ECBlockHeader).HeaderExpansionArea = byteof(0x55)
ecb1.Header.(*ECBlockHeader).ObjectCount = 0
// add the CommitChain to the ECBlock
ecb1.AddEntry(cc)
m1 := NewMinuteNumber()
m1.Number = 0x01
ecb1.AddEntry(m1)
// add a ServerIndexNumber
si1 := NewServerIndexNumber()
si1.Number = 3
ecb1.AddEntry(si1)
// create an IncreaseBalance for testing
ib := NewIncreaseBalance()
pub := new(primitives.ByteSlice32)
copy(pub[:], byteof(0xaa))
ib.ECPubKey = pub
ib.TXID.SetBytes(byteof(0xbb))
ib.NumEC = uint64(13)
// add the IncreaseBalance
ecb1.AddEntry(ib)
m2 := NewMinuteNumber()
m2.Number = 0x02
ecb1.AddEntry(m2)
return ecb1
}
//Generate creates new PrivateKey / PublciKey pair or returns error
func (pk *PrivateKey) GenerateKey() error {
pub, priv, err := ed25519.GenerateKey(rand.Reader)
if err != nil {
return err
}
pk.Key = priv
pk.Pub = new(PublicKey)
err = pk.Pub.UnmarshalBinary(pub[:])
return err
}
func TestCommitChainMarshalUnmarshal(t *testing.T) {
fmt.Printf("---\nTestCommitChainMarshalUnmarshal\n---\n")
cc := NewCommitChain()
// test MarshalBinary on a zeroed CommitChain
if p, err := cc.MarshalBinary(); err != nil {
t.Error(err)
} else if z := make([]byte, CommitChainSize); string(p) != string(z) {
t.Errorf("Marshal failed on zeroed CommitChain")
}
// build a CommitChain for testing
cc.Version = 0
cc.MilliTime = (*primitives.ByteSlice6)(&[6]byte{1, 1, 1, 1, 1, 1})
p, _ := hex.DecodeString("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
cc.ChainIDHash.SetBytes(p)
p, _ = hex.DecodeString("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb")
cc.Weld.SetBytes(p)
p, _ = hex.DecodeString("cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc")
cc.EntryHash.SetBytes(p)
cc.Credits = 11
// make a key and sign the msg
if pub, privkey, err := ed.GenerateKey(rand.Reader); err != nil {
t.Error(err)
} else {
cc.ECPubKey = (*primitives.ByteSlice32)(pub)
cc.Sig = (*primitives.ByteSlice64)(ed.Sign(privkey, cc.CommitMsg()))
}
// marshal and unmarshal the commit and see if it matches
cc2 := NewCommitChain()
p, err := cc.MarshalBinary()
if err != nil {
t.Error(err)
}
t.Logf("%x\n", p)
err = cc2.UnmarshalBinary(p)
if err != nil {
t.Error(err)
}
if !cc2.IsValid() {
t.Errorf("signature did not match after unmarshalbinary")
}
}
func TestCommitEntryMarshal(t *testing.T) {
fmt.Printf("---\nTestCommitEntryMarshal\n---\n")
ce := common.NewCommitEntry()
// test MarshalBinary on a zeroed CommitEntry
if p, err := ce.MarshalBinary(); err != nil {
t.Error(err)
} else if z := make([]byte, common.CommitEntrySize); string(p) != string(z) {
t.Errorf("Marshal failed on zeroed CommitEntry")
}
// build a CommitEntry for testing
ce.Version = 0
ce.MilliTime = &[6]byte{1, 1, 1, 1, 1, 1}
p, _ := hex.DecodeString("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
ce.EntryHash.SetBytes(p)
ce.Credits = 1
// make a key and sign the msg
if pub, privkey, err := ed.GenerateKey(rand.Reader); err != nil {
t.Error(err)
} else {
ce.ECPubKey = pub
ce.Sig = ed.Sign(privkey, ce.CommitMsg())
}
// marshal and unmarshal the commit and see if it matches
ce2 := common.NewCommitEntry()
if p, err := ce.MarshalBinary(); err != nil {
t.Error(err)
} else {
t.Logf("%x\n", p)
ce2.UnmarshalBinary(p)
}
if !ce2.IsValid() {
t.Errorf("signature did not match after unmarshalbinary")
}
}
func nextSig() []byte {
// Get me a private key.
public, _, _ := ed25519.GenerateKey(zero)
return public[:]
}
//Generate creates new PrivateKey / PublciKey pair or returns error
func (pk *PrivateKey) GenerateKey() (err error) {
pk.Pub.Key, pk.Key, err = ed25519.GenerateKey(rand.Reader)
return err
}
func newRCD_1() *RCD_1 {
public, _, _ := ed25519.GenerateKey(zero1)
rcd := NewRCD_1(public[:])
return rcd.(*RCD_1)
}
func TestECBlockMarshal(t *testing.T) {
ecb1 := common.NewECBlock()
// build a CommitChain for testing
cc := common.NewCommitChain()
cc.Version = 0
cc.MilliTime = &[6]byte{1, 1, 1, 1, 1, 1}
cc.ChainIDHash.SetBytes(byteof(0xaa))
cc.Weld.SetBytes(byteof(0xbb))
cc.EntryHash.SetBytes(byteof(0xcc))
cc.Credits = 11
// make a key and sign the msg
if pub, privkey, err := ed.GenerateKey(rand.Reader); err != nil {
t.Error(err)
} else {
cc.ECPubKey = pub
cc.Sig = ed.Sign(privkey, cc.CommitMsg())
}
// create a ECBlock for testing
ecb1.Header.ECChainID.SetBytes(byteof(0x11))
ecb1.Header.BodyHash.SetBytes(byteof(0x22))
ecb1.Header.PrevHeaderHash.SetBytes(byteof(0x33))
ecb1.Header.PrevLedgerKeyMR.SetBytes(byteof(0x44))
ecb1.Header.EBHeight = 10
ecb1.Header.HeaderExpansionArea = byteof(0x55)
ecb1.Header.ObjectCount = 0
// add the CommitChain to the ECBlock
ecb1.AddEntry(cc)
m1 := common.NewMinuteNumber()
m1.Number = 0x01
ecb1.AddEntry(m1)
// add a ServerIndexNumber
si1 := common.NewServerIndexNumber()
si1.Number = 3
ecb1.AddEntry(si1)
// create an IncreaseBalance for testing
ib := common.NewIncreaseBalance()
pub := new([32]byte)
copy(pub[:], byteof(0xaa))
ib.ECPubKey = pub
ib.TXID.SetBytes(byteof(0xbb))
ib.NumEC = uint64(13)
// add the IncreaseBalance
ecb1.AddEntry(ib)
m2 := common.NewMinuteNumber()
m2.Number = 0x02
ecb1.AddEntry(m2)
ecb2 := common.NewECBlock()
if p, err := ecb1.MarshalBinary(); err != nil {
t.Error(err)
} else {
if err := ecb2.UnmarshalBinary(p); err != nil {
t.Error(err)
}
t.Log(spew.Sdump(ecb1))
t.Log(spew.Sdump(ecb2))
if q, err := ecb2.MarshalBinary(); err != nil {
t.Error(err)
} else if string(p) != string(q) {
t.Errorf("ecb1 = %x\n", p)
t.Errorf("ecb2 = %x\n", q)
}
}
}