// OutputSignatureSuccess prints the details of a successful verification. func OutputSignatureSuccess(ctx *Context, fingerprint libkb.PGPFingerprint, owner *libkb.User, signatureTime time.Time) { arg := keybase1.OutputSignatureSuccessArg{ Fingerprint: fingerprint.String(), Username: owner.GetName(), SignedAt: keybase1.TimeFromSeconds(signatureTime.Unix()), } ctx.PgpUI.OutputSignatureSuccess(context.TODO(), arg) }
// OutputSignatureSuccess prints the details of a successful verification. func OutputSignatureSuccess(ctx *Context, fingerprint libkb.PGPFingerprint, owner *libkb.User, signatureTime time.Time) { if signatureTime.IsZero() { ctx.LogUI.Notice("Signature verified. Signed by %s.", owner.GetName()) } else { ctx.LogUI.Notice("Signature verified. Signed by %s %s (%s).", owner.GetName(), humanize.Time(signatureTime), signatureTime) } ctx.LogUI.Notice("PGP Fingerprint: %s.", fingerprint) }
func checkTrackCommon(tc libkb.TestContext, blocks []sb, outcome *keybase1.IdentifyOutcome, them *libkb.User, ui *FakeIdentifyUI) error { me, err := libkb.LoadMe(libkb.NewLoadUserArg(tc.G)) if err != nil { return err } if them == nil { tc.T.Fatal("checkTrackCommon called with nil 'them' user") } s, err := me.TrackChainLinkFor(them.GetName(), them.GetUID()) if err != nil { return err } if s == nil { tc.T.Fatal("me.TrackChainLinkFor(...) returned nil, nil") } tc.T.Logf("payload json:\n%s", s.GetPayloadJSON().MarshalPretty()) sbs := s.ToServiceBlocks() if len(sbs) != len(blocks) { return fmt.Errorf("num service blocks: %d, expected %d", len(sbs), len(blocks)) } sort.Sort(byID(sbs)) for i, sb := range sbs { tsb := blocks[i] if sb.IsSocial() != tsb.social { return fmt.Errorf("(sb %d): social: %v, expected %v", i, sb.IsSocial(), tsb.social) } if sb.ToIDString() != tsb.id { return fmt.Errorf("(sb %d): id: %s, expected %s", i, sb.ToIDString(), tsb.id) } if sb.GetProofState() != tsb.proofState { return fmt.Errorf("(sb %d): proof state: %d, expected %d", i, sb.GetProofState(), tsb.proofState) } } if ui.Outcome.TrackStatus != outcome.TrackStatus { return fmt.Errorf("track status: %d, expected %d", ui.Outcome.TrackStatus, outcome.TrackStatus) } if ui.Outcome.NumTrackFailures != outcome.NumTrackFailures { return fmt.Errorf("num track failures: %d, expected %d", ui.Outcome.NumTrackFailures, outcome.NumTrackFailures) } if ui.Outcome.NumTrackChanges != outcome.NumTrackChanges { return fmt.Errorf("num track changes: %d, expected %d", ui.Outcome.NumTrackChanges, outcome.NumTrackChanges) } if ui.Outcome.NumProofFailures != outcome.NumProofFailures { return fmt.Errorf("num proof failures: %d, expected %d", ui.Outcome.NumProofFailures, outcome.NumProofFailures) } if ui.Outcome.NumProofSuccesses != outcome.NumProofSuccesses { return fmt.Errorf("num proof successes: %d, expected %d", ui.Outcome.NumProofSuccesses, outcome.NumProofSuccesses) } if ui.Outcome.NumRevoked != outcome.NumRevoked { return fmt.Errorf("num revoked: %d, expected %d", ui.Outcome.NumRevoked, outcome.NumRevoked) } return nil }
func (e *PGPPullEngine) exportKeysToGPG(ctx *Context, user *libkb.User, tfp map[string]bool) error { for _, bundle := range user.GetActivePGPKeys(false) { // Check each key against the tracked set. if tfp != nil && !tfp[bundle.GetFingerprint().String()] { ctx.LogUI.Warning("Keybase says that %s owns key %s, but you have not tracked this fingerprint before.", user.GetName(), bundle.GetFingerprint()) continue } if err := e.gpgClient.ExportKey(*bundle, false /* export public key only */); err != nil { return err } ctx.LogUI.Info("Imported key for %s.", user.GetName()) } return nil }
// findPaperKeys checks if the user has paper backup keys. If he/she // does, it prompts for a paperkey phrase. This is used to // regenerate paper keys, which are then matched against the // paper keys found in the keyfamily. func findPaperKeys(ctx *Context, g *libkb.GlobalContext, me *libkb.User) (*keypair, error) { cki := me.GetComputedKeyInfos() if cki == nil { return nil, fmt.Errorf("no computed key infos") } bdevs := cki.PaperDevices() if len(bdevs) == 0 { return nil, libkb.NoPaperKeysError{} } passphrase, err := libkb.GetPaperKeyPassphrase(ctx.SecretUI, me.GetName()) if err != nil { return nil, err } paperPhrase := libkb.NewPaperKeyPhrase(passphrase) version, err := paperPhrase.Version() if err != nil { return nil, err } if version != libkb.PaperKeyVersion { g.Log.Debug("paper version mismatch: generated paper key version = %d, libkb version = %d", version, libkb.PaperKeyVersion) return nil, libkb.KeyVersionError{} } bkarg := &PaperKeyGenArg{ Passphrase: libkb.NewPaperKeyPhrase(passphrase), SkipPush: true, Me: me, } bkeng := NewPaperKeyGen(bkarg, g) if err := RunEngine(bkeng, ctx); err != nil { return nil, err } sigKey := bkeng.SigKey() encKey := bkeng.EncKey() var match bool ckf := me.GetComputedKeyFamily() for _, bdev := range bdevs { sk, err := ckf.GetSibkeyForDevice(bdev.ID) if err != nil { continue } ek, err := ckf.GetEncryptionSubkeyForDevice(bdev.ID) if err != nil { continue } if sk.GetKID().Equal(sigKey.GetKID()) && ek.GetKID().Equal(encKey.GetKID()) { match = true break } } if !match { return nil, libkb.PassphraseError{Msg: "no matching paper backup keys found"} } return &keypair{sigKey: sigKey, encKey: encKey}, nil }