Golang ed25519.GenerateKey函数代码示例

func TestSignProof(t *testing.T) {
	pubkeyRec, privKeyRec, _ := ed25519.GenerateKey(rand.Reader)
	pubkeySend, privkeySend, _ := ed25519.GenerateKey(rand.Reader)
	now := time.Now().UnixNano()
	proof := SignProofToken(now, pubkeyRec, pubkeySend, privkeySend)
	ok, nowDec, senderPub := VerifyProofToken(proof, pubkeyRec)
	if !ok {
		t.Error("Siganture did not verify")
	}
	if *senderPub != *pubkeySend {
		t.Error("Sender Pubkey decode failed")
	}
	if now != nowDec {
		t.Error("Time decode failed")
	}
	ok, signedProofToken := CounterSignToken(proof, pubkeyRec, privKeyRec)
	if !ok {
		t.Error("CounterSignToken did not verify")
	}
	ok, nowDec2 := VerifyCounterSig(signedProofToken, pubkeySend)
	if !ok {
		t.Error("VerifyCounterSig did not verify")
	}
	if now != nowDec2 {
		t.Error("Time decode failed")
	}
}

func TestGenerateIDKeys(t *testing.T) {
	var err error
	clientPK, clientSK, err = ed25519.GenerateKey(rand.Reader)
	if err != nil {
		t.Fatalf("%v", err)
	}

	serverPK, serverSK, err = ed25519.GenerateKey(rand.Reader)
	if err != nil {
		t.Fatalf("%v", err)
	}
}

func GenerateKeys(random io.Reader) (*[64]byte, *[32]byte) {
	pub, priv, err := ed25519.GenerateKey(random)
	if err != nil {
		lg.Fatal(err)
	}
	return priv, pub
}

func getSigningKey() (*[ed25519.PublicKeySize]byte, *[ed25519.PrivateKeySize]byte) {
	pub, priv, err := ed25519.GenerateKey(rand.Reader)
	if err != nil {
		log.Fatal(err)
	}
	return pub, priv
}

func init() {
	var err error
	testKeyPub, testKeyPriv, err = ed25519.GenerateKey(rand.Reader)
	if err != nil {
		panic(err)
	}
}

func TestCheckToken(t *testing.T) {
	now := uint64(times.Now()) / SkewWindow
	pubkey, privkey, err := ed25519.GenerateKey(rand.Reader)
	if err != nil {
		t.Fatalf("Key generation failed: %s", err)
	}
	authtoken := CreateToken(pubkey, privkey, 1)
	pubkey2, ltime, lcounter, err := authtoken.CheckToken()
	if err != nil {
		t.Errorf("Token verification failed: %s", err)
	}
	if *pubkey2 != *pubkey {
		t.Errorf("Token decode failed, pubkey does not match: %x!=%x", *pubkey2, *pubkey)
	}
	if lcounter != 1 {
		t.Errorf("Token decode failed. Counter %d!=1", lcounter)
	}
	if uint64(math.Abs(float64(ltime-now))) > 1 {
		t.Errorf("Token decode failed. Time: %d!=%d", now, ltime)
	}
	authtoken[0] = 0x00
	_, _, _, err = authtoken.CheckToken()
	if err == nil {
		t.Error("Token verification MUST fail")
	}
}

func TestConv(t *testing.T) {
	pubkey, privkey, err := ed25519.GenerateKey(rand.Reader)
	if err != nil {
		t.Fatalf("Keygen failed: %s", err)
	}
	sm := make(StringMap)
	sm["alpha"] = "first"
	sm["beta"] = "second"
	sm["gamma"] = "third"
	sm["delta"] = "fourth"
	ss := sm.Sort()
	if ss[0].K != "alpha" || ss[0].V != "first" {
		t.Error("Bad first")
	}
	if ss[3].K != "gamma" || ss[3].V != "third" {
		t.Error("Bad last")
	}
	sig := ss.Sign(10, privkey)
	if !ss.Verify(10, pubkey[:], sig) {
		t.Error("Signature verify failed")
	}
	if ss.Verify(11, pubkey[:], sig) {
		t.Error("Signature verification MUST fail on bad date")
	}
	sig[3] = ^sig[3]
	if ss.Verify(10, pubkey[:], sig) {
		t.Error("Signature verification MUST fail on bad signature")
	}
}

func main() {
	user = new(common.User)
	game = new(common.Game)
	var err error
	pubkey, privkey, err = ed25519.GenerateKey(rand.Reader)
	if err != nil {
		panic(err)
	}
	socket, err := utp.Dial("localhost:5428")
	if err != nil {
		panic(err)
	}
	if !handshake(socket) {
		panic("Handshake to server failed!")
	}
	rl, err = readline.NewEx(&readline.Config{
		Prompt: "> ",
		// HistoryFile: "./readline.history",
		InterruptPrompt: "Ctrl-C received, exiting ...",
		EOFPrompt:       "\n",
		AutoComplete:    completer,
	})
	stderr = rl.Stderr()
	go downstream()
	upstream()
}

func main() {
	showHelp := flag.Bool("h", false, "display a short usage message and exit")
	flag.Parse()

	if *showHelp {
		usage()
		os.Exit(0)
	}

	if flag.NArg() == 0 {
		usage()
		os.Exit(1)
	}

	for _, baseName := range flag.Args() {
		pubFileName := fmt.Sprintf("%s.pub", baseName)
		privFileName := fmt.Sprintf("%s.key", baseName)

		pub, priv, err := ed25519.GenerateKey(rand.Reader)
		die.If(err)

		err = ioutil.WriteFile(pubFileName, pub[:], 0644)
		die.If(err)

		err = ioutil.WriteFile(privFileName, priv[:], 0600)
		die.If(err)
	}
}

// Ed25519Generate generates a new Ed25519 key pair.
func Ed25519Generate(rand io.Reader) (*Ed25519Key, error) {
	publicKey, privateKey, err := ed25519.GenerateKey(rand)
	if err != nil {
		return nil, err
	}
	return &Ed25519Key{publicKey, privateKey}, nil
}

// New returns a MessageServer.
func New(driver, url, path string, pubKey, privKey []byte) (*MessageServer, error) {
	var err error
	ms := new(MessageServer)
	ms.DB = messagestore.New(driver, url, path, Workers)
	if err != nil {
		return nil, err
	}
	ms.path = path
	ms.PeerFile = path + "peers.config"
	ms.AddToPeer = DefaultAddToPeer
	ms.MaxTimeSkew = DefaultMaxTimeSkew
	ms.MinPostSize = MinPostSize
	ms.MaxPostSize = MaxPostSize
	ms.MinHashCashBits = MinHashCashBits
	ms.MaxSleep = DefaultMaxSleep
	ms.MaxIndexGlobal = DefaultIndexGlobal
	ms.MaxIndexKey = DefaultIndexKey
	ms.TimeGrace = DefaultTimeGrace
	ms.MaxAuthTokenAge = DefaultAuthTokenAge
	ms.NotifyDuration = DefaultNotifyDuration
	ms.FetchDuration = DefaultFetchDuration
	ms.FetchMax = DefaultFetchMax
	ms.ExpireDuration = DefaultExpireDuration
	ms.ExpireFSDuration = DefaultExpireFSDuration
	ms.StepLimit = DefaultStepLimit
	ms.ListenPort = DefaultListenPort
	ms.MinStoreTime = DefaultMinStoreTime
	ms.MaxStoreTime = DefaultMaxStoreTime
	ms.MaxAgeSigners = DefaultMaxAgeSigners
	ms.MaxAgeRecipients = DefaultMaxAgeRecipients
	messagestore.MaxAgeRecipients = DefaultMaxAgeRecipients
	messagestore.MaxAgeSigners = DefaultMaxAgeSigners
	ms.EnablePeerHandler = true

	ms.authPrivKey, err = message.GenLongTermKey(true, false)
	if err != nil {
		return nil, err
	}
	ms.AuthPubKey = message.GenPubKey(ms.authPrivKey)
	if pubKey != nil && privKey != nil {
		ms.TokenPubKey = new([ed25519.PublicKeySize]byte)
		ms.TokenPrivKey = new([ed25519.PrivateKeySize]byte)
		copy(ms.TokenPubKey[:], pubKey)
		copy(ms.TokenPrivKey[:], privKey)
	} else {
		ms.TokenPubKey, ms.TokenPrivKey, err = ed25519.GenerateKey(rand.Reader)
		log.Printf("Peer authentication public key: %s\n", utils.B58encode(ms.TokenPubKey[:]))
		log.Printf("Peer authentication private key: %s\n", utils.B58encode(ms.TokenPrivKey[:]))
		if err != nil {
			return nil, err
		}
	}
	ms.InfoStruct = new(ServerInfo)
	ms.InfoStruct.MinHashCashBits = ms.MinHashCashBits
	ms.InfoStruct.MinPostSize = ms.MinPostSize
	ms.InfoStruct.MaxPostSize = ms.MaxPostSize
	ms.InfoStruct.AuthPubKey = utils.B58encode(ms.AuthPubKey[:])
	return ms, nil
}

// GenerateSigningKeyPair attempts to generate a signature key-pair.
func GenerateSigningKeyPair() (sk, vk []byte, err error) {
	pub, priv, err := ed25519.GenerateKey(rand.Reader)
	if err != nil {
		return nil, nil, errors.New("failed to generate secret signing key: " + err.Error())
	}

	return priv[:], pub[:], nil
}

// GenerateSigningKey generates a signing key and import it into the keyring.
func (k *Keyring) GenerateSigningKey() (*SigningSecretKey, error) {
	pub, sec, err := ed25519.GenerateKey(rand.Reader)
	if err != nil {
		return nil, err
	}
	ret := NewSigningSecretKey(pub, sec)
	return &ret, nil
}

func (kp *Full) keys() (*[32]byte, *[64]byte) {
	reader := bytes.NewReader(kp.rawSeed())
	pub, priv, err := ed25519.GenerateKey(reader)
	if err != nil {
		panic(err)
	}
	return pub, priv
}

// GenerateKeyPair creates a public-secret keypair that can be used to sign and
// verify messages.
func GenerateSignatureKeys() (sk SecretKey, pk PublicKey, err error) {
	pkPointer, skPointer, err := ed25519.GenerateKey(rand.Reader)
	if err != nil {
		return
	}
	sk = *skPointer
	pk = *pkPointer
	return
}