func testKexMeta(t *testing.T, username string, sec *kex.Secret) *kex.Meta {
sendID, err := libkb.NewDeviceID()
if err != nil {
t.Fatal(err)
}
recID, err := libkb.NewDeviceID()
if err != nil {
t.Fatal(err)
}
return &kex.Meta{UID: libkb.UsernameToUID(username), Seqno: 0, StrongID: sec.StrongID(), WeakID: sec.WeakID(), Sender: sendID, Receiver: recID}
}
func (d *DeviceRegister) Run(ctx *Context) error {
if d.args.Me.HasCurrentDeviceInCurrentInstall() {
return ErrDeviceAlreadyRegistered
}
var err error
if d.deviceID, err = libkb.NewDeviceID(); err != nil {
return err
}
if err := d.args.Lks.GenerateServerHalf(); err != nil {
return err
}
d.G().Log.Debug("Device name: %s", d.args.Name)
d.G().Log.Debug("Device ID: %s", d.deviceID)
if wr := d.G().Env.GetConfigWriter(); wr != nil {
if err := wr.SetDeviceID(d.deviceID); err != nil {
return err
}
ctx.LogUI.Debug("Setting Device ID to %s", d.deviceID)
}
return nil
}
func rekeySetup(tc libkb.TestContext) (gregor1.UID, *gregorHandler, *RekeyUIHandler) {
tc.G.SetService()
kbUID, err := keybase1.UIDFromString("9f9611a4b7920637b1c2a839b2a0e119")
if err != nil {
tc.T.Fatal(err)
}
gUID := gregor1.UID(kbUID.ToBytes())
did, err := libkb.NewDeviceID()
if err != nil {
tc.T.Fatal(err)
}
tc.G.Env.GetConfigWriter().SetUserConfig(libkb.NewUserConfig(kbUID, "", nil, did), true)
h, err := newGregorHandler(tc.G)
if err != nil {
tc.T.Fatal(err)
}
rekeyHandler := NewRekeyUIHandler(tc.G, 0)
rekeyHandler.alwaysAlive = true
rekeyHandler.notifyStart = make(chan int, 10)
rekeyHandler.notifyComplete = make(chan int, 10)
rekeyHandler.scorer = fakeScoreProblemFoldersEmpty
h.PushHandler(rekeyHandler)
return gUID, h, rekeyHandler
}
func testBody(t *testing.T) *kex.Body {
did, err := libkb.NewDeviceID()
if err != nil {
t.Fatal(err)
}
a := kex.MsgArgs{
DeviceID: did,
DevKeyID: keybase1.KIDFromString("123456"),
}
return &kex.Body{
Name: kex.StartKexMsg,
Args: a,
}
}
func TestDeviceAddPhrase(t *testing.T) {
// device X (provisioner) context:
tcX := SetupEngineTest(t, "kex2provision")
defer tcX.Cleanup()
// device Y (provisionee) context:
tcY := SetupEngineTest(t, "template")
defer tcY.Cleanup()
// provisioner needs to be logged in
userX := CreateAndSignupFakeUser(tcX, "login")
var secretX kex2.Secret
if _, err := rand.Read(secretX[:]); err != nil {
t.Fatal(err)
}
secretY, err := libkb.NewKex2Secret()
if err != nil {
t.Fatal(err)
}
var wg sync.WaitGroup
// start provisionee
wg.Add(1)
go func() {
defer wg.Done()
f := func(lctx libkb.LoginContext) error {
ctx := &Context{
ProvisionUI: &testProvisionUI{secretCh: make(chan kex2.Secret, 1)},
LoginContext: lctx,
NetContext: context.TODO(),
}
deviceID, err := libkb.NewDeviceID()
if err != nil {
t.Errorf("provisionee device id error: %s", err)
return err
}
suffix, err := libkb.RandBytes(5)
if err != nil {
t.Errorf("provisionee device suffix error: %s", err)
return err
}
dname := fmt.Sprintf("device_%x", suffix)
device := &libkb.Device{
ID: deviceID,
Description: &dname,
Type: libkb.DeviceTypeDesktop,
}
provisionee := NewKex2Provisionee(tcY.G, device, secretY.Secret())
if err := RunEngine(provisionee, ctx); err != nil {
t.Errorf("provisionee error: %s", err)
return err
}
return nil
}
if err := tcY.G.LoginState().ExternalFunc(f, "Test - DeviceAdd"); err != nil {
t.Errorf("kex2 provisionee error: %s", err)
}
}()
// run DeviceAdd engine on device X
ctx := &Context{
SecretUI: userX.NewSecretUI(),
ProvisionUI: &testPhraseProvisionUI{phrase: secretY.Phrase()},
NetContext: context.TODO(),
}
eng := NewDeviceAdd(tcX.G)
if err := RunEngine(eng, ctx); err != nil {
t.Errorf("device add error: %s", err)
}
wg.Wait()
}
func TestKex2Provision(t *testing.T) {
// device X (provisioner) context:
tcX := SetupEngineTest(t, "kex2provision")
defer tcX.Cleanup()
// provisioner needs to be logged in
userX := CreateAndSignupFakeUser(tcX, "login")
// device Y (provisionee) context:
tcY := SetupEngineTest(t, "kex2provision")
defer tcY.Cleanup()
var secretX kex2.Secret
if _, err := rand.Read(secretX[:]); err != nil {
t.Fatal(err)
}
var secretY kex2.Secret
if _, err := rand.Read(secretY[:]); err != nil {
t.Fatal(err)
}
var wg sync.WaitGroup
// start provisionee
wg.Add(1)
go func() {
defer wg.Done()
ctx := &Context{
ProvisionUI: &testProvisionUI{secretCh: make(chan kex2.Secret, 1)},
}
deviceID, err := libkb.NewDeviceID()
if err != nil {
t.Errorf("provisionee device id error: %s", err)
return
}
suffix, err := libkb.RandBytes(5)
if err != nil {
t.Errorf("provisionee device suffix error: %s", err)
return
}
dname := fmt.Sprintf("device_%x", suffix)
device := &libkb.Device{
ID: deviceID,
Description: &dname,
Type: libkb.DeviceTypeDesktop,
}
provisionee := NewKex2Provisionee(tcY.G, device, secretY)
if err := RunEngine(provisionee, ctx); err != nil {
t.Errorf("provisionee error: %s", err)
return
}
}()
// start provisioner
wg.Add(1)
go func() {
defer wg.Done()
ctx := &Context{
SecretUI: userX.NewSecretUI(),
ProvisionUI: &testProvisionUI{},
}
provisioner := NewKex2Provisioner(tcX.G, secretX)
go provisioner.AddSecret(secretY)
if err := RunEngine(provisioner, ctx); err != nil {
t.Errorf("provisioner error: %s", err)
return
}
}()
wg.Wait()
}
// deviceWithType provisions this device with an existing device using the
// kex2 protocol. provisionerType is the existing device type.
func (e *loginProvision) deviceWithType(ctx *Context, provisionerType keybase1.DeviceType) error {
// make a new secret:
secret, err := libkb.NewKex2Secret()
if err != nil {
return err
}
e.G().Log.Debug("secret phrase received")
// make a new device:
deviceID, err := libkb.NewDeviceID()
if err != nil {
return err
}
device := &libkb.Device{
ID: deviceID,
Type: e.arg.DeviceType,
}
// create provisionee engine
provisionee := NewKex2Provisionee(e.G(), device, secret.Secret())
var canceler func()
// display secret and prompt for secret from X in a goroutine:
go func() {
sb := secret.Secret()
arg := keybase1.DisplayAndPromptSecretArg{
Secret: sb[:],
Phrase: secret.Phrase(),
OtherDeviceType: provisionerType,
}
var contxt context.Context
contxt, canceler = context.WithCancel(context.Background())
receivedSecret, err := ctx.ProvisionUI.DisplayAndPromptSecret(contxt, arg)
if err != nil {
// cancel provisionee run:
provisionee.Cancel()
e.G().Log.Warning("DisplayAndPromptSecret error: %s", err)
} else if receivedSecret.Secret != nil && len(receivedSecret.Secret) > 0 {
e.G().Log.Debug("received secret, adding to provisionee")
var ks kex2.Secret
copy(ks[:], receivedSecret.Secret)
provisionee.AddSecret(ks)
} else if len(receivedSecret.Phrase) > 0 {
e.G().Log.Debug("received secret phrase, adding to provisionee")
ks, err := libkb.NewKex2SecretFromPhrase(receivedSecret.Phrase)
if err != nil {
e.G().Log.Warning("DisplayAndPromptSecret error: %s", err)
} else {
provisionee.AddSecret(ks.Secret())
}
}
}()
defer func() {
if canceler != nil {
e.G().Log.Debug("canceling DisplayAndPromptSecret call")
canceler()
}
}()
f := func(lctx libkb.LoginContext) error {
// run provisionee
ctx.LoginContext = lctx
return RunEngine(provisionee, ctx)
}
if err := e.G().LoginState().ExternalFunc(f, "loginProvision.device - Run provisionee"); err != nil {
return err
}
// need username, device name for ProvisionUI.ProvisioneeSuccess()
e.username = provisionee.GetName()
pdevice := provisionee.Device()
if pdevice == nil {
e.G().Log.Warning("nil provisionee device")
} else if pdevice.Description == nil {
e.G().Log.Warning("nil provisionee device description")
} else {
e.devname = *pdevice.Description
}
return nil
}
// device provisions this device with an existing device using the
// kex2 protocol.
func (e *XLoginProvision) device(ctx *Context) error {
provisionerType, err := ctx.ProvisionUI.ChooseDeviceType(context.TODO(), 0)
if err != nil {
return err
}
e.G().Log.Debug("provisioner device type: %v", provisionerType)
// make a new secret:
secret, err := libkb.NewKex2Secret()
if err != nil {
return err
}
e.G().Log.Debug("secret phrase: %s", secret.Phrase())
// make a new device:
deviceID, err := libkb.NewDeviceID()
if err != nil {
return err
}
device := &libkb.Device{
ID: deviceID,
Type: e.deviceType,
}
// create provisionee engine
provisionee := NewKex2Provisionee(e.G(), device, secret.Secret())
var canceler func()
// display secret and prompt for secret from X in a goroutine:
go func() {
sb := secret.Secret()
arg := keybase1.DisplayAndPromptSecretArg{
Secret: sb[:],
Phrase: secret.Phrase(),
OtherDeviceType: provisionerType,
}
var contxt context.Context
contxt, canceler = context.WithCancel(context.Background())
receivedSecret, err := ctx.ProvisionUI.DisplayAndPromptSecret(contxt, arg)
if err != nil {
// XXX ???
e.G().Log.Warning("DisplayAndPromptSecret error: %s", err)
} else if receivedSecret != nil {
var ks kex2.Secret
copy(ks[:], receivedSecret)
provisionee.AddSecret(ks)
}
}()
defer func() {
if canceler != nil {
e.G().Log.Debug("canceling DisplayAndPromptSecret call")
canceler()
}
}()
// run provisionee
if err := RunEngine(provisionee, ctx); err != nil {
return err
}
return nil
}
// device provisions this device with an existing device using the
// kex2 protocol.
func (e *XLoginProvision) device(ctx *Context) error {
provisionerType, err := ctx.ProvisionUI.ChooseDeviceType(context.TODO(), 0)
if err != nil {
return err
}
e.G().Log.Debug("provisioner device type: %v", provisionerType)
// make a new secret:
secret, err := libkb.NewKex2Secret()
if err != nil {
return err
}
e.G().Log.Debug("secret phrase: %s", secret.Phrase())
// make a new device:
deviceID, err := libkb.NewDeviceID()
if err != nil {
return err
}
device := &libkb.Device{
ID: deviceID,
Type: e.arg.DeviceType,
}
// create provisionee engine
provisionee := NewKex2Provisionee(e.G(), device, secret.Secret())
var canceler func()
// display secret and prompt for secret from X in a goroutine:
go func() {
sb := secret.Secret()
arg := keybase1.DisplayAndPromptSecretArg{
Secret: sb[:],
Phrase: secret.Phrase(),
OtherDeviceType: provisionerType,
}
var contxt context.Context
contxt, canceler = context.WithCancel(context.Background())
receivedSecret, err := ctx.ProvisionUI.DisplayAndPromptSecret(contxt, arg)
if err != nil {
// could cancel provisionee run here?
e.G().Log.Warning("DisplayAndPromptSecret error: %s", err)
} else if receivedSecret != nil && len(receivedSecret) > 0 {
var ks kex2.Secret
copy(ks[:], receivedSecret)
provisionee.AddSecret(ks)
}
}()
defer func() {
if canceler != nil {
e.G().Log.Debug("canceling DisplayAndPromptSecret call")
canceler()
}
}()
// run provisionee
if err := RunEngine(provisionee, ctx); err != nil {
return err
}
if err := e.G().LoginState().LocalSession(func(s *libkb.Session) {
s.SetDeviceProvisioned(deviceID)
}, "XLoginProvision - device"); err != nil {
return err
}
// need username, device name for ProvisionUI.ProvisioneeSuccess()
e.username = provisionee.GetName()
pdevice := provisionee.Device()
if pdevice == nil {
e.G().Log.Warning("nil provisionee device")
} else if pdevice.Description == nil {
e.G().Log.Warning("nil provisionee device description")
} else {
e.devname = *pdevice.Description
}
return nil
}