// Run starts the engine.
func (e *Kex2Provisionee) Run(ctx *Context) error {
// check device struct:
if len(e.device.Type) == 0 {
return errors.New("provisionee device requires Type to be set")
}
if e.device.ID.IsNil() {
return errors.New("provisionee device requires ID to be set")
}
// ctx is needed in some of the kex2 functions:
e.ctx = ctx
if len(e.secret) == 0 {
panic("empty secret")
}
karg := kex2.KexBaseArg{
Ctx: context.TODO(),
Mr: libkb.NewKexRouter(e.G()),
DeviceID: e.device.ID,
Secret: e.secret,
SecretChannel: e.secretCh,
Timeout: 5 * time.Minute,
}
parg := kex2.ProvisioneeArg{
KexBaseArg: karg,
Provisionee: e,
}
if err := kex2.RunProvisionee(parg); err != nil {
return err
}
return nil
}
// Run starts the engine.
func (e *Kex2Provisionee) Run(ctx *Context) error {
e.G().Log.Debug("+ Kex2Provisionee.Run()")
// check device struct:
if len(e.device.Type) == 0 {
return errors.New("provisionee device requires Type to be set")
}
if e.device.ID.IsNil() {
return errors.New("provisionee device requires ID to be set")
}
// ctx is needed in some of the kex2 functions:
e.ctx = ctx
karg := kex2.KexBaseArg{
Ctx: context.TODO(),
Mr: libkb.NewKexRouter(e.G()),
DeviceID: e.device.ID,
Secret: e.secret,
SecretChannel: e.secretCh,
Timeout: 5 * time.Minute,
}
parg := kex2.ProvisioneeArg{
KexBaseArg: karg,
Provisionee: e,
}
err := kex2.RunProvisionee(parg)
e.G().Log.Debug("- Kex2Provisionee.Run() -> %s", libkb.ErrToOk(err))
return err
}
// Run starts the provisioner engine.
func (e *Kex2Provisioner) Run(ctx *Context) (err error) {
e.G().Log.Debug("+ Kex2Provisioner.Run()")
defer func() { e.G().Log.Debug("- Kex2Provisioner.Run() -> %s", libkb.ErrToOk(err)) }()
// before starting provisioning, need to load some information:
// load self:
e.me, err = libkb.LoadMe(libkb.NewLoadUserArg(e.G()))
if err != nil {
return err
}
// get signing key (including secret key):
arg := libkb.SecretKeyArg{
Me: e.me,
KeyType: libkb.DeviceSigningKeyType,
}
e.signingKey, err = e.G().Keyrings.GetSecretKeyWithPrompt(ctx.LoginContext, arg, ctx.SecretUI, "new device install")
if err != nil {
return err
}
// get current passphrase stream:
e.pps, err = e.G().LoginState().GetPassphraseStream(ctx.SecretUI)
if err != nil {
return err
}
// ctx needed by some kex2 functions
e.ctx = ctx
deviceID := e.G().Env.GetDeviceID()
// all set: start provisioner
karg := kex2.KexBaseArg{
Ctx: context.TODO(),
Mr: libkb.NewKexRouter(e.G()),
DeviceID: deviceID,
Secret: e.secret,
SecretChannel: e.secretCh,
Timeout: 5 * time.Minute,
}
parg := kex2.ProvisionerArg{
KexBaseArg: karg,
Provisioner: e,
}
err = kex2.RunProvisioner(parg)
if err == nil {
ctx.ProvisionUI.ProvisionSuccess(context.TODO(), 0)
}
return err
}
// Run starts the engine.
func (e *Kex2Provisionee) Run(ctx *Context) error {
// check device struct:
if len(e.device.Type) == 0 {
return errors.New("provisionee device requires Type to be set")
}
if e.device.ID.IsNil() {
return errors.New("provisionee device requires ID to be set")
}
// ctx is needed in some of the kex2 functions:
e.ctx = ctx
if e.ctx.LoginContext == nil {
return errors.New("Kex2Provisionee needs LoginContext set in engine.Context")
}
if len(e.secret) == 0 {
panic("empty secret")
}
var nctx context.Context
nctx, e.kex2Cancel = context.WithCancel(ctx.GetNetContext())
defer e.kex2Cancel()
karg := kex2.KexBaseArg{
Ctx: nctx,
Mr: libkb.NewKexRouter(e.G()),
DeviceID: e.device.ID,
Secret: e.secret,
SecretChannel: e.secretCh,
Timeout: 5 * time.Minute,
}
parg := kex2.ProvisioneeArg{
KexBaseArg: karg,
Provisionee: e,
}
if err := kex2.RunProvisionee(parg); err != nil {
return err
}
return nil
}
// Run starts the provisioner engine.
func (e *Kex2Provisioner) Run(ctx *Context) error {
// before starting provisioning, need to load some information:
// load self:
var err error
e.me, err = libkb.LoadMe(libkb.NewLoadUserArg(e.G()))
if err != nil {
return err
}
// get signing key (including secret key):
ska := libkb.SecretKeyArg{
Me: e.me,
KeyType: libkb.DeviceSigningKeyType,
}
e.signingKey, err = e.G().Keyrings.GetSecretKeyWithPrompt(ctx.SecretKeyPromptArg(ska, "new device install"))
if err != nil {
return err
}
// get current passphrase stream if necessary:
if e.pps == nil {
e.pps, err = e.G().LoginState().GetPassphraseStream(ctx.SecretUI)
if err != nil {
return err
}
}
// ctx needed by some kex2 functions
e.ctx = ctx
deviceID := e.G().Env.GetDeviceID()
// all set: start provisioner
karg := kex2.KexBaseArg{
Ctx: context.TODO(),
Mr: libkb.NewKexRouter(e.G()),
DeviceID: deviceID,
Secret: e.secret,
SecretChannel: e.secretCh,
Timeout: 5 * time.Minute,
}
parg := kex2.ProvisionerArg{
KexBaseArg: karg,
Provisioner: e,
HelloTimeout: 15 * time.Second,
}
if err := kex2.RunProvisioner(parg); err != nil {
return err
}
// succesfully provisioned the other device
sarg := keybase1.ProvisionerSuccessArg{
DeviceName: e.provisioneeDeviceName,
DeviceType: e.provisioneeDeviceType,
}
if err := ctx.ProvisionUI.ProvisionerSuccess(context.TODO(), sarg); err != nil {
return err
}
return nil
}