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
}