作者：carriercom
项目：repbi
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")
}
}
作者：jmptrade
项目：go-schanne
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)
}
}
作者：gitter-badge
项目：alkasi
func GenerateKeys(random io.Reader) (*[64]byte, *[32]byte) {
pub, priv, err := ed25519.GenerateKey(random)
if err != nil {
lg.Fatal(err)
}
return priv, pub
}
作者：rako
项目：challengeaut
func getSigningKey() (*[ed25519.PublicKeySize]byte, *[ed25519.PrivateKeySize]byte) {
pub, priv, err := ed25519.GenerateKey(rand.Reader)
if err != nil {
log.Fatal(err)
}
return pub, priv
}
作者：read-late
项目：bazi
func init() {
var err error
testKeyPub, testKeyPriv, err = ed25519.GenerateKey(rand.Reader)
if err != nil {
panic(err)
}
}
作者：JonathanLoga
项目：mut
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")
}
}
作者：JonathanLoga
项目：mut
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")
}
}
作者：jackyy
项目：isrevers
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()
}
作者：jmptrade
项目：go-schanne
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)
}
}
作者：JonathanLoga
项目：mut
// 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
}
作者：RoPe9
项目：repbi
// 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
}
作者：pyll
项目：balloo
// 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
}
作者：Varjelu
项目：keybase-clien
// 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
}
作者：stella
项目：bridge-serve
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
}
作者：mm
项目：Si
// 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
}
作者：hlanda
项目：degoutil
func TestSPKI(t *testing.T) {
pk, sk, err := ed25519.GenerateKey(rand.Reader)
if err != nil {
panic(err)
}
outs, err := sx.SXCanonical.String(spki.FormEd25519PrivateKey(sk))
if err != nil {
panic(err)
}
v, err := sx.SX.Parse([]byte(outs))
if err != nil {
panic(fmt.Sprintf("failed to parse: %v: %#v", err, outs))
}
var sk2 [64]byte
isPrivate, err := spki.LoadEd25519Key(v, &sk2)
if err != nil {
panic(fmt.Sprintf("failed to load: %v: %#v", err, v))
}
if !isPrivate {
panic("should be private")
}
if !bytes.Equal(sk[:], sk2[:]) {
panic("should be equal")
}
// public key
outs, err = sx.SXCanonical.String(spki.FormEd25519PublicKeyFromPrivateKey(sk))
if err != nil {
panic(err)
}
v, err = sx.SX.Parse([]byte(outs))
if err != nil {
panic(err)
}
var sk3 [64]byte
isPrivate, err = spki.LoadEd25519Key(v, &sk3)
if err != nil {
panic(err)
}
if isPrivate {
panic("should be public")
}
if !bytes.Equal(pk[:], sk3[32:]) {
panic("should be equal")
}
}
作者：jmptrade
项目：gocrypt
// NewIdentity generates a new identity.
func NewIdentity() (*Identity, error) {
var err error
id := &Identity{}
id.public, id.private, err = ed25519.GenerateKey(rand.Reader)
if err != nil {
return nil, err
}
return id, nil
}
作者：JonathanLoga
项目：mut
func TestSplitKey(t *testing.T) {
pubkey, privkey, _ := ed25519.GenerateKey(rand.Reader)
pubkey2, privkey2 := splitKey(privkey)
if *pubkey != *pubkey2 {
t.Error("Split: Public key wrong")
}
if *privkey != *privkey2 {
t.Error("Split: Private key wrong")
}
}
作者：paul-pearc
项目：client-bet
func makeNaclSigningKeyPair(reader io.Reader) (NaclSigningKeyPair, error) {
pub, priv, err := ed25519.GenerateKey(reader)
if err != nil {
return NaclSigningKeyPair{}, err
}
return NaclSigningKeyPair{
Public: *pub,
Private: (*NaclSigningKeyPrivate)(priv),
}, nil
}
作者：aaronlehman
项目：notar
func (trust *Ed25519) Create(role string) (*data.PublicKey, error) {
pub, priv, err := ed25519.GenerateKey(rand.Reader)
if err != nil {
return nil, err
}
public := data.NewPublicKey("ed25519", pub[:])
private := data.NewPrivateKey("ed25519", pub[:], priv[:])
trust.addKey(private)
return public, nil
}
