// FromObject creates a message from a protobuf-marshallable message. func FromObject(p peer.Peer, data proto.Message) (NetMessage, error) { bytes, err := proto.Marshal(data) if err != nil { return nil, err } return New(p, bytes), nil }
func (sk *RsaPrivateKey) Bytes() ([]byte, error) { b := x509.MarshalPKCS1PrivateKey(sk.k) pbmes := new(pb.PrivateKey) typ := pb.KeyType_RSA pbmes.Type = &typ pbmes.Data = b return proto.Marshal(pbmes) }
// GetNode gets the modified DAG Node func (dm *DagModifier) GetNode() (*mdag.Node, error) { b, err := proto.Marshal(dm.pbdata) if err != nil { return nil, err } dm.curNode.Data = b return dm.curNode.Copy(), nil }
func (mb *MultiBlock) GetBytes() ([]byte, error) { pbn := new(pb.Data) t := pb.Data_File pbn.Type = &t pbn.Filesize = proto.Uint64(uint64(len(mb.Data)) + mb.subtotal) pbn.Blocksizes = mb.blocksizes pbn.Data = mb.Data return proto.Marshal(pbn) }
func newTestMessage() *pb.MyMessage { msg := &pb.MyMessage{ Count: proto.Int32(42), Name: proto.String("Dave"), Quote: proto.String(`"I didn't want to go."`), Pet: []string{"bunny", "kitty", "horsey"}, Inner: &pb.InnerMessage{ Host: proto.String("footrest.syd"), Port: proto.Int32(7001), Connected: proto.Bool(true), }, Others: []*pb.OtherMessage{ { Key: proto.Int64(0xdeadbeef), Value: []byte{1, 65, 7, 12}, }, { Weight: proto.Float32(6.022), Inner: &pb.InnerMessage{ Host: proto.String("lesha.mtv"), Port: proto.Int32(8002), }, }, }, Bikeshed: pb.MyMessage_BLUE.Enum(), Somegroup: &pb.MyMessage_SomeGroup{ GroupField: proto.Int32(8), }, // One normally wouldn't do this. // This is an undeclared tag 13, as a varint (wire type 0) with value 4. XXX_unrecognized: []byte{13<<3 | 0, 4}, } ext := &pb.Ext{ Data: proto.String("Big gobs for big rats"), } if err := proto.SetExtension(msg, pb.E_Ext_More, ext); err != nil { panic(err) } greetings := []string{"adg", "easy", "cow"} if err := proto.SetExtension(msg, pb.E_Greeting, greetings); err != nil { panic(err) } // Add an unknown extension. We marshal a pb.Ext, and fake the ID. b, err := proto.Marshal(&pb.Ext{Data: proto.String("3G skiing")}) if err != nil { panic(err) } b = append(proto.EncodeVarint(201<<3|proto.WireBytes), b...) proto.SetRawExtension(msg, 201, b) // Extensions can be plain fields, too, so let's test that. b = append(proto.EncodeVarint(202<<3|proto.WireVarint), 19) proto.SetRawExtension(msg, 202, b) return msg }
// Returns Bytes that represent a Directory func FolderPBData() []byte { pbfile := new(pb.Data) typ := pb.Data_Directory pbfile.Type = &typ data, err := proto.Marshal(pbfile) if err != nil { //this really shouldnt happen, i promise panic(err) } return data }
func (pk *RsaPublicKey) Bytes() ([]byte, error) { b, err := x509.MarshalPKIXPublicKey(pk.k) if err != nil { return nil, err } pbmes := new(pb.PublicKey) typ := pb.KeyType_RSA pbmes.Type = &typ pbmes.Data = b return proto.Marshal(pbmes) }
func wrapData(data []byte, pid pb.ProtocolID) ([]byte, error) { // Marshal pbm := new(pb.PBProtocolMessage) pbm.ProtocolID = &pid pbm.Data = data b, err := proto.Marshal(pbm) if err != nil { return nil, err } return b, nil }
// putLocal stores the key value pair in the datastore func (dht *IpfsDHT) putLocal(key u.Key, value []byte) error { rec, err := dht.makePutRecord(key, value) if err != nil { return err } data, err := proto.Marshal(rec) if err != nil { return err } return dht.datastore.Put(key.DsKey(), data) }
func wrapData(data []byte, rid RequestID) ([]byte, error) { // Marshal pbm := new(pb.PBRequest) pbm.Data = data pbm.Tag = rid b, err := proto.Marshal(pbm) if err != nil { return nil, err } return b, nil }
func WrapData(b []byte) []byte { pbdata := new(pb.Data) typ := pb.Data_Raw pbdata.Data = b pbdata.Type = &typ out, err := proto.Marshal(pbdata) if err != nil { // This shouldnt happen. seriously. panic(err) } return out }
func createRoutingEntryData(pk ci.PrivKey, val string) ([]byte, error) { entry := new(pb.IpnsEntry) entry.Value = []byte(val) typ := pb.IpnsEntry_EOL entry.ValidityType = &typ entry.Validity = []byte(u.FormatRFC3339(time.Now().Add(time.Hour * 24))) sig, err := pk.Sign(ipnsEntryDataForSig(entry)) if err != nil { return nil, err } entry.Signature = sig return proto.Marshal(entry) }
// Handshake3 exchanges local and remote service information func Handshake3(ctx context.Context, c Conn) (*handshake.Handshake3Result, error) { rpeer := c.RemotePeer() lpeer := c.LocalPeer() // setup + send the message to remote var remoteH, localH *hspb.Handshake3 localH = handshake.Handshake3Msg(lpeer, c.RemoteMultiaddr()) localB, err := proto.Marshal(localH) if err != nil { return nil, err } c.Out() <- localB log.Debugf("Handshake1: sent to %s", rpeer) // wait + listen for response select { case <-ctx.Done(): return nil, ctx.Err() case <-c.Closing(): return nil, errors.New("Handshake3: error remote connection closed") case remoteB, ok := <-c.In(): if !ok { return nil, fmt.Errorf("Handshake3 error receiving from conn: %v", rpeer) } remoteH = new(hspb.Handshake3) err = proto.Unmarshal(remoteB, remoteH) if err != nil { return nil, fmt.Errorf("Handshake3 could not decode remote msg: %q", err) } log.Debugf("Handshake3 received from %s", rpeer) } // actually update our state based on the new knowledge res, err := handshake.Handshake3Update(lpeer, rpeer, remoteH) if err != nil { log.Errorf("Handshake3 failed to update %s", rpeer) } res.RemoteObservedAddress = c.RemoteMultiaddr() return res, nil }
func FilePBData(data []byte, totalsize uint64) []byte { pbfile := new(pb.Data) typ := pb.Data_File pbfile.Type = &typ pbfile.Data = data pbfile.Filesize = proto.Uint64(totalsize) data, err := proto.Marshal(pbfile) if err != nil { // This really shouldnt happen, i promise // The only failure case for marshal is if required fields // are not filled out, and they all are. If the proto object // gets changed and nobody updates this function, the code // should panic due to programmer error panic(err) } return data }
// Handshake1 exchanges local and remote versions and compares them // closes remote and returns an error in case of major difference func Handshake1(ctx context.Context, c Conn) error { rpeer := c.RemotePeer() lpeer := c.LocalPeer() var remoteH, localH *hspb.Handshake1 localH = handshake.Handshake1Msg() myVerBytes, err := proto.Marshal(localH) if err != nil { return err } c.Out() <- myVerBytes log.Debugf("Sent my version (%s) to %s", localH, rpeer) select { case <-ctx.Done(): return ctx.Err() case <-c.Closing(): return errors.New("remote closed connection during version exchange") case data, ok := <-c.In(): if !ok { return fmt.Errorf("error retrieving from conn: %v", rpeer) } remoteH = new(hspb.Handshake1) err = proto.Unmarshal(data, remoteH) if err != nil { return fmt.Errorf("could not decode remote version: %q", err) } log.Debugf("Received remote version (%s) from %s", remoteH, rpeer) } if err := handshake.Handshake1Compatible(localH, remoteH); err != nil { log.Infof("%s (%s) incompatible version with %s (%s)", lpeer, localH, rpeer, remoteH) return err } log.Debugf("%s version handshake compatible %s", lpeer, rpeer) return nil }
// Store a value in this peer local storage func (dht *IpfsDHT) handlePutValue(p peer.Peer, pmes *pb.Message) (*pb.Message, error) { dht.dslock.Lock() defer dht.dslock.Unlock() dskey := u.Key(pmes.GetKey()).DsKey() err := dht.verifyRecord(pmes.GetRecord()) if err != nil { fmt.Println(u.Key(pmes.GetRecord().GetAuthor())) log.Error("Bad dht record in put request") return nil, err } data, err := proto.Marshal(pmes.GetRecord()) if err != nil { return nil, err } err = dht.datastore.Put(dskey, data) log.Debugf("%s handlePutValue %v\n", dht.self, dskey) return pmes, err }
// handsahke performs initial communication over insecure channel to share // keys, IDs, and initiate communication. func (s *SecurePipe) handshake() error { // Generate and send Hello packet. // Hello = (rand, PublicKey, Supported) nonce := make([]byte, 16) _, err := rand.Read(nonce) if err != nil { return err } log.Debugf("handshake: %s <--> %s", s.local, s.remote) myPubKey, err := s.local.PubKey().Bytes() if err != nil { return err } proposeMsg := new(pb.Propose) proposeMsg.Rand = nonce proposeMsg.Pubkey = myPubKey proposeMsg.Exchanges = &SupportedExchanges proposeMsg.Ciphers = &SupportedCiphers proposeMsg.Hashes = &SupportedHashes encoded, err := proto.Marshal(proposeMsg) if err != nil { return err } // Send our Propose packet select { case s.insecure.Out <- encoded: case <-s.ctx.Done(): return ErrClosed } // Parse their Propose packet and generate an Exchange packet. // Exchange = (EphemeralPubKey, Signature) var resp []byte select { case <-s.ctx.Done(): return ErrClosed case resp = <-s.insecure.In: } // u.POut("received encoded handshake\n") proposeResp := new(pb.Propose) err = proto.Unmarshal(resp, proposeResp) if err != nil { return err } // get remote identity remotePubKey, err := ci.UnmarshalPublicKey(proposeResp.GetPubkey()) if err != nil { return err } // get or construct peer s.remote, err = getOrConstructPeer(s.peers, remotePubKey) if err != nil { return err } log.Debugf("%s Remote Peer Identified as %s", s.local, s.remote) exchange, err := SelectBest(SupportedExchanges, proposeResp.GetExchanges()) if err != nil { return err } cipherType, err := SelectBest(SupportedCiphers, proposeResp.GetCiphers()) if err != nil { return err } hashType, err := SelectBest(SupportedHashes, proposeResp.GetHashes()) if err != nil { return err } // u.POut("Selected %s %s %s\n", exchange, cipherType, hashType) epubkey, genSharedKey, err := ci.GenerateEKeyPair(exchange) // Generate EphemeralPubKey var handshake bytes.Buffer // Gather corpus to sign. handshake.Write(encoded) handshake.Write(resp) handshake.Write(epubkey) exPacket := new(pb.Exchange) exPacket.Epubkey = epubkey exPacket.Signature, err = s.local.PrivKey().Sign(handshake.Bytes()) if err != nil { return err } exEncoded, err := proto.Marshal(exPacket) // send out Exchange packet select { case s.insecure.Out <- exEncoded: case <-s.ctx.Done(): return ErrClosed } // Parse their Exchange packet and generate a Finish packet. // Finish = E('Finish') var resp1 []byte select { case <-s.ctx.Done(): return ErrClosed case resp1 = <-s.insecure.In: } exchangeResp := new(pb.Exchange) err = proto.Unmarshal(resp1, exchangeResp) if err != nil { return err } var theirHandshake bytes.Buffer theirHandshake.Write(resp) theirHandshake.Write(encoded) theirHandshake.Write(exchangeResp.GetEpubkey()) // u.POut("Remote Peer Identified as %s\n", s.remote) ok, err := s.remote.PubKey().Verify(theirHandshake.Bytes(), exchangeResp.GetSignature()) if err != nil { return err } if !ok { return errors.New("Bad signature!") } secret, err := genSharedKey(exchangeResp.GetEpubkey()) if err != nil { return err } cmp := bytes.Compare(myPubKey, proposeResp.GetPubkey()) mIV, tIV, mCKey, tCKey, mMKey, tMKey := ci.KeyStretcher(cmp, cipherType, hashType, secret) go s.handleSecureIn(hashType, cipherType, tIV, tCKey, tMKey) go s.handleSecureOut(hashType, cipherType, mIV, mCKey, mMKey) finished := []byte("Finished") // send finished msg select { case <-s.ctx.Done(): return ErrClosed case s.Out <- finished: } // recv finished msg var resp2 []byte select { case <-s.ctx.Done(): return ErrClosed case resp2 = <-s.In: } if bytes.Compare(resp2, finished) != 0 { return fmt.Errorf("Negotiation failed, got: %s", resp2) } log.Debugf("%s handshake: Got node id: %s", s.local, s.remote) return nil }