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
}