Ejemplo n.º 1
0
func NewIdentity(keys cipherset.Keys, parts cipherset.Parts, addrs []net.Addr) (*Identity, error) {
	var err error

	ident := &Identity{
		keys:  keys,
		parts: parts,
		addrs: addrs,
	}

	if len(ident.keys) == 0 {
		return nil, ErrNoKeys
	}

	if ident.parts == nil {
		ident.parts = make(cipherset.Parts, len(ident.keys))
	}

	for csid, part := range hashname.PartsFromKeys(ident.keys) {
		ident.parts[csid] = part
	}

	ident.hashname, err = hashname.FromIntermediates(ident.parts)
	if err != nil {
		return nil, err
	}

	return ident, nil
}
Ejemplo n.º 2
0
func main() {
	args, _ := docopt.Parse(usage, nil, true, "0.1-dev", false)

	var (
		output = args["--output"].(string)
		keys   = cipherset.Keys{}
		data   []byte
		err    error
		out    struct {
			Hashname hashname.H            `json:"hashname,omitempty"`
			Parts    cipherset.Parts       `json:"parts,omitempty"`
			Keys     cipherset.PrivateKeys `json:"keys,omitempty"`
		}
	)

	{ // CS 1a
		k, err := cipherset.GenerateKey(0x1a)
		assert(err)
		keys[0x1a] = k
	}

	{ // CS 3a
		k, err := cipherset.GenerateKey(0x3a)
		assert(err)
		keys[0x3a] = k
	}

	out.Keys = cipherset.PrivateKeys(keys)
	out.Parts = hashname.PartsFromKeys(keys)
	out.Hashname, err = hashname.FromIntermediates(out.Parts)
	assert(err)

	if len(out.Keys) == 0 {
		out.Keys = nil
	}
	if len(out.Parts) == 0 {
		out.Keys = nil
	}

	data, err = json.MarshalIndent(out, "", "  ")
	assert(err)

	fmt.Fprintf(os.Stderr, "Generated keys for: %s\n", out.Hashname)

	if output == "-" {
		fmt.Println(string(data))
	} else {
		err := ioutil.WriteFile(output, data, 0600)
		assert(err)
	}
}
Ejemplo n.º 3
0
func (mod *module) handle_connect(ch *e3x.Channel) {
	defer ch.Kill()

	var (
		from        hashname.H
		localIdent  *e3x.Identity
		remoteIdent *e3x.Identity
		handshake   cipherset.Handshake
		innerData   = bufpool.New()
		err         error
	)

	localIdent, err = mod.e.LocalIdentity()
	if err != nil {
		return
	}

	pkt, err := ch.ReadPacket()
	if err != nil {
		return
	}

	pkt.Body(innerData.SetLen(pkt.BodyLen()).RawBytes()[:0])

	inner, err := lob.Decode(innerData)
	if err != nil {
		return
	}

	innerHdr := inner.Header()
	if innerHdr.IsBinary() && len(innerHdr.Bytes) == 1 {
		// handshake
		var (
			csid = innerHdr.Bytes[0]
			key  = localIdent.Keys()[csid]
		)
		if key == nil {
			return
		}

		handshake, err = cipherset.DecryptHandshake(csid, key, inner.Body(nil))
		if err != nil {
			return
		}

		from, err = hashname.FromIntermediates(handshake.Parts())
		if err != nil {
			return
		}

		remoteIdent, err = e3x.NewIdentity(cipherset.Keys{
			handshake.CSID(): handshake.PublicKey(),
		}, handshake.Parts(), nil)
		if err != nil {
			return
		}

	} else {
		// key packet

		var parts = make(cipherset.Parts)
		var csid uint8
		for key, value := range inner.Header().Extra {
			if len(key) != 2 {
				continue
			}

			keyData, err := hex.DecodeString(key)
			if err != nil {
				continue
			}

			partCSID := keyData[0]
			switch v := value.(type) {
			case bool:
				csid = partCSID
			case string:
				parts[partCSID] = v
			}
		}

		hn, err := hashname.FromKeyAndIntermediates(csid, inner.Body(nil), parts)
		if err != nil {
			return
		}

		from = hn

		pubKey, err := cipherset.DecodeKeyBytes(csid, inner.Body(nil), nil)
		if err != nil {
			return
		}

		remoteIdent, err = e3x.NewIdentity(cipherset.Keys{csid: pubKey}, parts, nil)
		if err != nil {
			return
		}
	}

	if from == "" {
		return
	}

	if mod.config.AllowConnect != nil && !mod.config.AllowConnect(from, ch.RemoteHashname()) {
		return
	}

	x, err := mod.e.CreateExchange(remoteIdent)
	if err != nil {
		return
	}

	// when the BODY contains a handshake
	if handshake != nil {
		routerExchange := ch.Exchange()
		routerAddr := &peerAddr{
			router: routerExchange.RemoteHashname(),
		}

		conn := newConnection(x.RemoteHashname(), routerAddr, routerExchange, func() {
			mod.unregisterConnection(routerExchange, x.LocalToken())
		})

		pipe, added := x.AddPipeConnection(conn, nil)
		if added {
			mod.registerConnection(routerExchange, x.LocalToken(), conn)
		}

		resp, ok := x.ApplyHandshake(handshake, pipe)
		if !ok {
			return
		}

		if resp != nil {
			err = mod.peerVia(ch.Exchange(), from, resp)
			if err != nil {
				return
			}
		}
	}

	// when the BODY contains a key packet
	if handshake == nil {
		pkt, err := x.GenerateHandshake()
		if err != nil {
			return
		}

		err = mod.peerVia(ch.Exchange(), from, pkt)
		if err != nil {
			return
		}
	}

	// Notify on-exchange callbacks
	mod.getIntroduction(from).resolve(x, nil)
}