func (e *SaltpackEncrypt) loadMe(ctx *Context) error { loggedIn, uid, err := IsLoggedIn(e, ctx) if err != nil || !loggedIn { return err } e.me, err = libkb.LoadMeByUID(e.G(), uid) return err }
func (e *Identify2WithUID) loadMe(ctx *Context) (err error) { // Short circuit loadMe for testing if e.testArgs != nil && e.testArgs.noMe { return nil } var ok bool var uid keybase1.UID ok, uid, err = IsLoggedIn(e, ctx) if err != nil || !ok { return err } e.me, err = libkb.LoadMeByUID(e.G(), uid) return err }
// Run starts the engine. func (e *Identify) Run(ctx *Context) error { if err := e.loadUser(); err != nil { return err } ok, uid, err := IsLoggedIn(e, ctx) if err != nil { return err } if ok { e.me, err = libkb.LoadMeByUID(e.G(), uid) if err != nil { return err } if e.user.Equal(e.me) { e.arg.WithTracking = false if e.arg.Source == keybase1.ClientType_KBFS { // if this is a self identify from kbfs, then short-circuit the identify process: return e.shortCircuitSelfID(ctx) } } else { e.arg.WithTracking = true } } ctx.IdentifyUI.Start(e.user.GetName(), e.arg.Reason) e.outcome, err = e.run(ctx) if err != nil { return err } // set the flags in the outcome with the track options to // inform the ui what to do with the remote tracking prompt: e.outcome.TrackOptions = e.arg.TrackOptions e.G().Log.Debug("inserting identify outcome for %q in TrackCache", e.user.GetName()) key, err := e.G().TrackCache.Insert(e.outcome) if err != nil { return err } e.G().Log.Debug("TrackCache key: %q", key) e.trackToken = key return nil }
// Run starts the engine. func (e *PGPEncrypt) Run(ctx *Context) error { // verify valid options based on logged in state: ok, uid, err := IsLoggedIn(e, ctx) if err != nil { return err } if !ok { // not logged in. this is fine, unless they requested signing the message. if !e.arg.NoSign { return libkb.LoginRequiredError{Context: "you must be logged in to sign"} } // or trying to encrypt for self if !e.arg.NoSelf { return libkb.LoginRequiredError{Context: "you must be logged in to encrypt for yourself"} } } else { me, err := libkb.LoadMeByUID(e.G(), uid) if err != nil { return err } e.me = me } var mykey *libkb.PGPKeyBundle var signer *libkb.PGPKeyBundle if !e.arg.NoSign { ska := libkb.SecretKeyArg{ Me: e.me, KeyType: libkb.PGPKeyType, KeyQuery: e.arg.KeyQuery, } key, err := e.G().Keyrings.GetSecretKeyWithPrompt(ctx.SecretKeyPromptArg(ska, "command-line signature")) if err != nil { return err } var ok bool mykey, ok = key.(*libkb.PGPKeyBundle) if !ok { return errors.New("Can only sign with PGP keys") } signer = mykey } usernames, err := e.verifyUsers(ctx, e.arg.Recips, ok) if err != nil { return err } kfarg := &PGPKeyfinderArg{ Usernames: usernames, } kf := NewPGPKeyfinder(kfarg, e.G()) if err := RunEngine(kf, ctx); err != nil { return err } uplus := kf.UsersPlusKeys() var writer io.WriteCloser if e.arg.BinaryOutput { writer = e.arg.Sink } else { aw, err := armor.Encode(e.arg.Sink, "PGP MESSAGE", libkb.PGPArmorHeaders) if err != nil { return err } writer = aw } ks := newKeyset() if !e.arg.NoSelf { if mykey == nil { // need to load the public key for the logged in user mykey, err = e.loadSelfKey() if err != nil { return err } } // mykey could still be nil if mykey != nil { ks.Add(mykey) } } for _, up := range uplus { for _, k := range up.Keys { ks.Add(k) } } recipients := ks.Sorted() if err := libkb.PGPEncrypt(e.arg.Source, writer, signer, recipients); err != nil { return err } if !e.arg.BinaryOutput { return e.arg.Sink.Close() } return nil }