func (l *localStorage) Store(data []byte) (string, error) { var ch []byte var err error if len(data) > 120 { ch, err = multihash.EncodeName(data[:120], "sha1") if err != nil { return "", err } } else { ch, err = multihash.EncodeName(data, "sha1") if err != nil { return "", err } } can := hex.EncodeToString(ch) if _, err := os.Stat("login"); os.IsNotExist(err) { os.Mkdir("login", 0777) } filename := "login/" + can if _, err := os.Stat(filename); os.IsNotExist(err) { file, err := os.Create(filename) if err != nil { return "", err } defer file.Close() _, err = file.Write(data) if err != nil { return "", err } file.Sync() return can, nil } else { return "", errors.New("File Exists") } return "", nil }
/** * Generates a new, random peer identity. * * @return {Peer} */ func NewIdentity(cfg *config.Identity) (*Peer, error) { // Select curve given in config. var curve elliptic.Curve switch cfg.Curve { case 224: curve = elliptic.P224() case 256: curve = elliptic.P256() case 384: curve = elliptic.P384() case 521: curve = elliptic.P521() default: return nil, errors.New("Bad curve name in config.") } var ( cSize int = curve.Params().BitSize pubKeySize = base64.StdEncoding.EncodedLen(cSize / 2) privKeySize = base64.StdEncoding.EncodedLen(cSize / 4) bound = cSize / 8 pubKey []byte priv []byte signingPriv *ecdsa.PrivateKey err error ) if len(cfg.PubKey) == pubKeySize && len(cfg.PrivKey) == privKeySize { // Parse saved keypair from config. pubKey, err = base64.StdEncoding.DecodeString(cfg.PubKey) if err != nil { return nil, err } decodedPriv, err := base64.StdEncoding.DecodeString(cfg.PrivKey) if err != nil { return nil, err } signingX := big.NewInt(0) signingY := big.NewInt(0) signingD := big.NewInt(0) signingX.SetBytes(pubKey[bound*2 : bound*3]) signingY.SetBytes(pubKey[bound*3:]) priv = decodedPriv[0:bound] signingD.SetBytes(decodedPriv[bound:]) signingPriv = &ecdsa.PrivateKey{ PublicKey: ecdsa.PublicKey{ Curve: curve, X: signingX, Y: signingY, }, D: signingD, } } else { var buff bytes.Buffer // Generate a random ECDH keypair. priv, x, y, err := elliptic.GenerateKey(curve, rand.Reader) if err != nil { return nil, err } // Generate a random ECDSA keypair. signingPriv, err = ecdsa.GenerateKey(curve, rand.Reader) if err != nil { return nil, err } // Generate pubKey buff.Write(x.Bytes()) buff.Write(y.Bytes()) buff.Write(signingPriv.PublicKey.X.Bytes()) buff.Write(signingPriv.PublicKey.Y.Bytes()) pubKey = buff.Bytes() // Generate privKey var privKey bytes.Buffer privKey.Write(priv) privKey.Write(signingPriv.D.Bytes()) // Save to config. ---- TO DO ? cfg.PubKey = base64.StdEncoding.EncodeToString(pubKey) cfg.PrivKey = base64.StdEncoding.EncodeToString(privKey.Bytes()) } // Generate peer ID hash := sha1.New() // THIS NEEDS TO BE SHA256 hash.Write(pubKey) id, err := mh.EncodeName(hash.Sum(nil), "sha1") if err != nil { return nil, err } return &Peer{ id, pubKey, []*ma.Multiaddr{}, curve, priv, signingPriv, }, nil }