func (h *AccountHandler) PassphraseChange(_ context.Context, arg keybase1.PassphraseChangeArg) error { eng := engine.NewPassphraseChange(&arg, h.G()) ctx := &engine.Context{ SecretUI: h.getSecretUI(arg.SessionID), } return engine.RunEngine(eng, ctx) }
func (h *PGPHandler) keygen(sessionID int, earg engine.PGPKeyImportEngineArg, doInteractive bool) (err error) { ctx := &engine.Context{LogUI: h.getLogUI(sessionID), SecretUI: h.getSecretUI(sessionID)} earg.Gen.AddDefaultUID() eng := engine.NewPGPKeyImportEngine(earg) err = engine.RunEngine(eng, ctx) return err }
// FavoriteAdd handles the favoriteAdd RPC. func (h *FavoriteHandler) FavoriteAdd(_ context.Context, arg keybase1.FavoriteAddArg) error { eng := engine.NewFavoriteAdd(&arg, h.G()) ctx := &engine.Context{ IdentifyUI: h.NewRemoteIdentifyUI(arg.SessionID, h.G()), } return engine.RunEngine(eng, ctx) }
func (h *SigsHandler) run(args keybase1.SigListArgs) (*engine.SigsList, error) { ctx := &engine.Context{} ea := engine.SigsListArgs{ Username: args.Username, AllKeys: args.AllKeys, Filterx: args.Filterx, Verbose: args.Verbose, Revoked: args.Revoked, Types: nil, } if args.Types != nil { t := make(map[string]bool) f := func(v bool, name string) { if v { t[name] = true } } f(args.Types.Track, "track") f(args.Types.Proof, "proof") f(args.Types.Cryptocurrency, "cryptocurrency") f(args.Types.IsSelf, "self") ea.Types = t } eng := engine.NewSigsList(ea, h.G()) if err := engine.RunEngine(eng, ctx); err != nil { return nil, err } return eng, nil }
func CreateAndSignupFakeUser(prefix string, g *libkb.GlobalContext) (*FakeUser, error) { fu, err := NewFakeUser(prefix) if err != nil { return nil, err } arg := engine.SignupEngineRunArg{ Username: fu.Username, Email: fu.Email, InviteCode: testInviteCode, Passphrase: fu.Passphrase, DeviceName: "my device", SkipGPG: true, SkipMail: true, } ctx := &engine.Context{ LogUI: g.UI.GetLogUI(), GPGUI: &gpgtestui{}, SecretUI: fu.NewSecretUI(), LoginUI: libkb.TestLoginUI{Username: fu.Username}, } s := engine.NewSignupEngine(&arg, g) if err := engine.RunEngine(s, ctx); err != nil { return nil, err } return fu, nil }
func (h *PGPHandler) PGPDecrypt(_ context.Context, arg keybase1.PGPDecryptArg) (keybase1.PGPSigVerification, error) { cli := h.getStreamUICli() src := libkb.NewRemoteStreamBuffered(arg.Source, cli, arg.SessionID) snk := libkb.NewRemoteStreamBuffered(arg.Sink, cli, arg.SessionID) earg := &engine.PGPDecryptArg{ Sink: snk, Source: src, AssertSigned: arg.Opts.AssertSigned, SignedBy: arg.Opts.SignedBy, } ctx := &engine.Context{ SecretUI: h.getSecretUI(arg.SessionID, h.G()), IdentifyUI: h.NewRemoteSkipPromptIdentifyUI(arg.SessionID, h.G()), LogUI: h.getLogUI(arg.SessionID), PgpUI: h.getPgpUI(arg.SessionID), SessionID: arg.SessionID, } eng := engine.NewPGPDecrypt(earg, h.G()) err := engine.RunEngine(eng, ctx) if err != nil { return keybase1.PGPSigVerification{}, err } return sigVer(eng.SignatureStatus(), eng.Owner()), nil }
// BTC creates a BTCEngine and runs it. func (h *BTCHandler) RegisterBTC(_ context.Context, arg keybase1.RegisterBTCArg) error { ctx := engine.Context{ LogUI: h.getLogUI(arg.SessionID), SecretUI: h.getSecretUI(arg.SessionID), } eng := engine.NewBTCEngine(arg.Address, arg.Force, h.G()) return engine.RunEngine(eng, &ctx) }
// FavoriteList handles the favoriteList RPC. func (h *FavoriteHandler) GetFavorites(_ context.Context, sessionID int) (keybase1.FavoritesResult, error) { eng := engine.NewFavoriteList(h.G()) ctx := &engine.Context{} if err := engine.RunEngine(eng, ctx); err != nil { return keybase1.FavoritesResult{}, err } return eng.Result(), nil }
// DeviceAdd starts the kex2 device provisioning on the // provisioner (device X/C1) func (h *DeviceHandler) DeviceAdd(_ context.Context, sessionID int) error { ctx := &engine.Context{ ProvisionUI: h.getProvisionUI(sessionID), SecretUI: h.getSecretUI(sessionID), } eng := engine.NewDeviceAdd(h.G()) return engine.RunEngine(eng, ctx) }
// DeviceList returns a list of all the devices for a user. func (h *DeviceHandler) DeviceList(_ context.Context, sessionID int) ([]keybase1.Device, error) { ctx := &engine.Context{LogUI: h.getLogUI(sessionID)} eng := engine.NewDevList(h.G()) if err := engine.RunEngine(eng, ctx); err != nil { return nil, err } return eng.List(), nil }
func (h *LoginHandler) Deprovision(_ context.Context, arg keybase1.DeprovisionArg) error { eng := engine.NewDeprovisionEngine(h.G(), arg.Username) ctx := engine.Context{ LogUI: h.getLogUI(arg.SessionID), SecretUI: h.getSecretUI(arg.SessionID), } return engine.RunEngine(eng, &ctx) }
func (h *LoginHandler) XLogin(_ context.Context, arg keybase1.XLoginArg) error { ctx := &engine.Context{ LogUI: h.getLogUI(arg.SessionID), ProvisionUI: h.getProvisionUI(arg.SessionID), } eng := engine.NewXLogin(h.G(), arg.DeviceType, arg.Username) return engine.RunEngine(eng, ctx) }
func (h *PGPHandler) PGPUpdate(_ context.Context, arg keybase1.PGPUpdateArg) error { ctx := engine.Context{ LogUI: h.getLogUI(arg.SessionID), SecretUI: h.getSecretUI(arg.SessionID), } eng := engine.NewPGPUpdateEngine(arg.Fingerprints, arg.All, h.G()) return engine.RunEngine(eng, &ctx) }
func (h *LoginHandler) PaperKeySubmit(_ context.Context, arg keybase1.PaperKeySubmitArg) error { ctx := &engine.Context{ LogUI: h.getLogUI(arg.SessionID), SessionID: arg.SessionID, } eng := engine.NewPaperKeySubmit(h.G(), arg.PaperPhrase) return engine.RunEngine(eng, ctx) }
func (h *RevokeHandler) RevokeSigs(_ context.Context, arg keybase1.RevokeSigsArg) error { ctx := engine.Context{ LogUI: h.getLogUI(arg.SessionID), SecretUI: h.getSecretUI(arg.SessionID), } eng := engine.NewRevokeSigsEngine(arg.SigIDs, h.G()) return engine.RunEngine(eng, &ctx) }
func (h *LoginHandler) Unlock(_ context.Context, sessionID int) error { ctx := &engine.Context{ LogUI: h.getLogUI(sessionID), SecretUI: h.getSecretUI(sessionID), } eng := engine.NewUnlock(h.G()) return engine.RunEngine(eng, ctx) }
// FavoriteList handles the favoriteList RPC. func (h *FavoriteHandler) FavoriteList(_ context.Context, sessionID int) ([]keybase1.Folder, error) { eng := engine.NewFavoriteList(h.G()) ctx := &engine.Context{} if err := engine.RunEngine(eng, ctx); err != nil { return nil, err } return eng.Favorites(), nil }
func (h *UserHandler) listTrackers(sessionID int, eng *engine.ListTrackersEngine) ([]keybase1.Tracker, error) { ctx := &engine.Context{LogUI: h.getLogUI(sessionID)} if err := engine.RunEngine(eng, ctx); err != nil { return nil, err } res := eng.ExportedList() return res, nil }
func (h *LoginHandler) UnlockWithPassphrase(_ context.Context, arg keybase1.UnlockWithPassphraseArg) error { ctx := &engine.Context{ LogUI: h.getLogUI(arg.SessionID), SecretUI: h.getSecretUI(arg.SessionID), } eng := engine.NewUnlockWithPassphrase(h.G(), arg.Passphrase) return engine.RunEngine(eng, ctx) }
func (h *RevokeHandler) RevokeDevice(_ context.Context, arg keybase1.RevokeDeviceArg) error { sessionID := arg.SessionID ctx := engine.Context{ LogUI: h.getLogUI(sessionID), SecretUI: h.getSecretUI(sessionID), } eng := engine.NewRevokeDeviceEngine(engine.RevokeDeviceEngineArgs{ID: arg.DeviceID, Force: arg.Force}, h.G()) return engine.RunEngine(eng, &ctx) }
func (h *RevokeHandler) RevokeKey(_ context.Context, arg keybase1.RevokeKeyArg) error { sessionID := arg.SessionID ctx := engine.Context{ LogUI: h.getLogUI(sessionID), SecretUI: h.getSecretUI(sessionID), } eng := engine.NewRevokeKeyEngine(arg.KeyID, h.G()) return engine.RunEngine(eng, &ctx) }
func (h *UserHandler) LoadUncheckedUserSummaries(_ context.Context, arg keybase1.LoadUncheckedUserSummariesArg) ([]keybase1.UserSummary, error) { ctx := &engine.Context{} eng := engine.NewUserSummary(arg.Uids, h.G()) if err := engine.RunEngine(eng, ctx); err != nil { return nil, err } res := eng.ExportedSummariesList() return res, nil }
func (h *PGPHandler) PGPSign(_ context.Context, arg keybase1.PGPSignArg) (err error) { cli := h.getStreamUICli() src := libkb.NewRemoteStreamBuffered(arg.Source, cli, arg.SessionID) snk := libkb.NewRemoteStreamBuffered(arg.Sink, cli, arg.SessionID) earg := engine.PGPSignArg{Sink: snk, Source: src, Opts: arg.Opts} ctx := engine.Context{SecretUI: h.getSecretUI(arg.SessionID)} eng := engine.NewPGPSignEngine(&earg, h.G()) return engine.RunEngine(eng, &ctx) }
func (h *PGPHandler) PGPPull(_ context.Context, arg keybase1.PGPPullArg) error { earg := engine.PGPPullEngineArg{ UserAsserts: arg.UserAsserts, } ctx := engine.Context{ LogUI: h.getLogUI(arg.SessionID), } eng := engine.NewPGPPullEngine(&earg, h.G()) return engine.RunEngine(eng, &ctx) }
func (h *LoginHandler) PaperKey(_ context.Context, sessionID int) error { ctx := &engine.Context{ LogUI: h.getLogUI(sessionID), LoginUI: h.getLoginUI(sessionID), SecretUI: h.getSecretUI(sessionID, h.G()), SessionID: sessionID, } eng := engine.NewPaperKey(h.G()) return engine.RunEngine(eng, ctx) }
func (h *UserHandler) ListTrackingJSON(_ context.Context, arg keybase1.ListTrackingJSONArg) (res string, err error) { eng := engine.NewListTrackingEngine(&engine.ListTrackingEngineArg{ JSON: true, Filter: arg.Filter, Verbose: arg.Verbose, }, h.G()) err = engine.RunEngine(eng, &engine.Context{}) res = eng.JSONResult() return }
func (h *UserHandler) ListTracking(_ context.Context, arg keybase1.ListTrackingArg) (res []keybase1.UserSummary, err error) { eng := engine.NewListTrackingEngine(&engine.ListTrackingEngineArg{ Filter: arg.Filter, // Verbose has no effect on this call. At the engine level, it only // affects JSON output. }, h.G()) err = engine.RunEngine(eng, &engine.Context{}) res = eng.TableResult() return }
// Untrack creates an UntrackEngine and runs it. func (h *TrackHandler) Untrack(_ context.Context, arg keybase1.UntrackArg) error { earg := engine.UntrackEngineArg{ Username: arg.Username, } ctx := engine.Context{ SecretUI: h.getSecretUI(arg.SessionID), } eng := engine.NewUntrackEngine(&earg, h.G()) return engine.RunEngine(eng, &ctx) }
func (h *PGPHandler) PGPKeyGen(_ context.Context, arg keybase1.PGPKeyGenArg) error { ctx := &engine.Context{ LogUI: h.getLogUI(arg.SessionID), SecretUI: h.getSecretUI(arg.SessionID, h.G()), SessionID: arg.SessionID, } earg := engine.ImportPGPKeyImportEngineArg(arg) eng := engine.NewPGPKeyImportEngine(earg) return engine.RunEngine(eng, ctx) }
func (h *PGPHandler) export(sessionID int, ex exporter) ([]keybase1.KeyInfo, error) { ctx := &engine.Context{ SecretUI: h.getSecretUI(sessionID), LogUI: h.getLogUI(sessionID), } if err := engine.RunEngine(ex, ctx); err != nil { return nil, err } return ex.Results(), nil }