func ParseDevice(jw *jsonw.Wrapper, t time.Time) (ret *Device, err error) { var obj Device if err = jw.UnmarshalAgain(&obj); err == nil { ret = &obj ret.CTime = keybase1.ToTime(t) ret.MTime = keybase1.ToTime(t) } return }
func (cr CheckResult) Export() *keybase1.CheckResult { return &keybase1.CheckResult{ ProofResult: ExportProofError(cr.Status), Time: keybase1.ToTime(cr.Time), Freshness: cr.Freshness(), } }
func (cr CheckResult) Export() *keybase1.CheckResult { return &keybase1.CheckResult{ ProofResult: ExportProofError(cr.Status), Time: keybase1.ToTime(cr.Time), DisplayMarkup: cr.ToDisplayString(), } }
func (l LinkCheckResult) Export() keybase1.LinkCheckResult { ret := keybase1.LinkCheckResult{ ProofId: l.position, ProofResult: ExportProofError(l.err), SnoozedResult: ExportProofError(l.snoozedErr), TorWarning: l.torWarning, } if l.cached != nil { ret.Cached = l.cached.Export() } bt := false if l.diff != nil { ret.Diff = ExportTrackDiff(l.diff) if l.diff.BreaksTracking() { bt = true } } if l.remoteDiff != nil { ret.RemoteDiff = ExportTrackDiff(l.remoteDiff) if l.remoteDiff.BreaksTracking() { bt = true } } if l.hint != nil { ret.Hint = l.hint.Export() } ret.TmpTrackExpireTime = keybase1.ToTime(l.tmpTrackExpireTime) ret.BreaksTracking = bt return ret }
func (i *Identify2WithUIDTester) Insert(up *keybase1.UserPlusKeys) error { tmp := *up copy := &tmp copy.Uvv.CachedAt = keybase1.ToTime(i.now) i.cache[up.Uid] = copy return nil }
func (ir IdentifyOutcome) ExportToUncheckedIdentity() *keybase1.Identity { tmp := keybase1.Identity{ Status: ExportErrorAsStatus(ir.Error), } if ir.TrackUsed != nil { tmp.WhenLastTracked = keybase1.ToTime(ir.TrackUsed.GetCTime()) } pc := ir.ProofChecksSorted() tmp.Proofs = make([]keybase1.IdentifyRow, len(pc)) for j, p := range pc { tmp.Proofs[j] = p.ExportToIdentifyRow(j) } tmp.Revoked = make([]keybase1.TrackDiff, len(ir.Revoked)) for j, d := range ir.Revoked { // Should have all non-nil elements... tmp.Revoked[j] = *ExportTrackDiff(d) if d.BreaksTracking() { tmp.BreaksTracking = true } } tmp.RevokedDetails = ir.RevokedDetails return &tmp }
func ExportRemoteProof(p RemoteProofChainLink) keybase1.RemoteProof { k, v := p.ToKeyValuePair() return keybase1.RemoteProof{ ProofType: p.GetProofType(), Key: k, Value: v, DisplayMarkup: v, SigID: p.GetSigID(), MTime: keybase1.ToTime(p.GetCTime()), } }
func (k *KeybaseDaemonLocal) revokeDeviceForTesting(clock Clock, uid keybase1.UID, index int) error { k.lock.Lock() defer k.lock.Unlock() user, err := k.localUsers.getLocalUser(uid) if err != nil { return fmt.Errorf("No such user %s: %v", uid, err) } if index >= len(user.VerifyingKeys) || (k.currentUID == uid && index == user.CurrentCryptPublicKeyIndex) { return fmt.Errorf("Can't revoke index %d", index) } if user.RevokedVerifyingKeys == nil { user.RevokedVerifyingKeys = make(map[VerifyingKey]keybase1.KeybaseTime) } if user.RevokedCryptPublicKeys == nil { user.RevokedCryptPublicKeys = make(map[CryptPublicKey]keybase1.KeybaseTime) } kbtime := keybase1.KeybaseTime{ Unix: keybase1.ToTime(clock.Now()), Chain: 100, } user.RevokedVerifyingKeys[user.VerifyingKeys[index]] = kbtime user.RevokedCryptPublicKeys[user.CryptPublicKeys[index]] = kbtime user.VerifyingKeys = append(user.VerifyingKeys[:index], user.VerifyingKeys[index+1:]...) user.CryptPublicKeys = append(user.CryptPublicKeys[:index], user.CryptPublicKeys[index+1:]...) if k.currentUID == uid && index < user.CurrentCryptPublicKeyIndex { user.CurrentCryptPublicKeyIndex-- } if k.currentUID == uid && index < user.CurrentVerifyingKeyIndex { user.CurrentVerifyingKeyIndex-- } k.localUsers[uid] = user return nil }
func (e *ListTrackingEngine) runTable(trackList TrackList) error { for _, link := range trackList { uid, err := link.GetTrackedUID() if err != nil { return err } entry := keybase1.UserSummary{ Username: link.ToDisplayString(), SigIDDisplay: link.GetSigID().ToDisplayString(true), TrackTime: keybase1.ToTime(link.GetCTime()), Uid: keybase1.UID(uid), } entry.Proofs.PublicKeys = e.linkPGPKeys(link) entry.Proofs.Social = e.linkSocialProofs(link) entry.Proofs.Web = e.linkWebProofs(link) e.tableResult = append(e.tableResult, entry) } return nil }
// Check checks for an update. If not requested (by user) and not forced it will // exit early if check has already been applied within checkDuration(). func (u *UpdateChecker) Check(force bool, requested bool) error { if !requested && !force { if lastCheckedPTime := u.updater.config.GetUpdateLastChecked(); lastCheckedPTime > 0 { lastChecked := keybase1.FromTime(lastCheckedPTime) if time.Now().Before(lastChecked.Add(checkDuration())) { u.log.Debug("Already checked: %s", lastChecked) return nil } } } checkTime := time.Now() _, err := u.updater.Update(u.ui, force, requested) if err != nil { return err } u.log.Debug("Saving updater last checked: %s", checkTime) u.updater.config.SetUpdateLastChecked(keybase1.ToTime(checkTime)) return nil }
// Sigs returns the sig list, after processing. func (e *SigsList) Sigs() []keybase1.Sig { res := make([]keybase1.Sig, len(e.sigs)) for i, s := range e.sigs { var key string fp := s.GetPGPFingerprint() if fp != nil { key = fp.ToDisplayString(e.Verbose) } res[i] = keybase1.Sig{ Seqno: int(s.GetSeqno()), SigIDDisplay: s.GetSigID().ToDisplayString(e.Verbose), Type: s.Type(), CTime: keybase1.ToTime(s.GetCTime()), Revoked: s.IsRevoked(), Active: e.isActiveKey(s), Key: key, Body: s.ToDisplayString(), } } return res }
func makeTestKBPKIClientWithRevokedKey(t *testing.T, revokeTime time.Time) ( client *KBPKIClient, currentUID keybase1.UID, users []LocalUser) { currentUID = keybase1.MakeTestUID(1) names := []libkb.NormalizedUsername{"test_name1", "test_name2"} users = MakeLocalUsers(names) // Give each user a revoked key for i, user := range users { index := 99 keySalt := keySaltForUserDevice(user.Name, index) newVerifyingKey := MakeLocalUserVerifyingKeyOrBust(keySalt) user.RevokedVerifyingKeys = map[VerifyingKey]keybase1.KeybaseTime{ newVerifyingKey: {Unix: keybase1.ToTime(revokeTime), Chain: 100}, } users[i] = user } codec := NewCodecMsgpack() daemon := NewKeybaseDaemonMemory(currentUID, users, codec) config := &ConfigLocal{codec: codec, daemon: daemon} setTestLogger(config, t) return NewKBPKIClient(config), currentUID, users }
func (t *Tracker2Syncer) syncFromServer(uid keybase1.UID, sr SessionReader) (err error) { defer t.G().Trace(fmt.Sprintf("syncFromServer(%s)", uid), func() error { return err })() hargs := HTTPArgs{ "uid": UIDArg(uid), "reverse": B{t.reverse}, "autoCamel": B{true}, } lv := t.getLoadedVersion() if lv >= 0 { hargs.Add("version", I{lv}) } var res *APIRes res, err = t.G().API.Get(APIArg{ Endpoint: "user/list_followers_for_display", Args: hargs, NeedSession: false, }) t.G().Log.Debug("| syncFromServer() -> %s", ErrToOk(err)) if err != nil { return err } var tmp keybase1.UserSummary2Set if err = res.Body.UnmarshalAgain(&tmp); err != nil { return } tmp.Time = keybase1.ToTime(time.Now()) if lv < 0 || tmp.Version > lv { t.G().Log.Debug("| syncFromServer(): got update %d > %d (%d records)", tmp.Version, lv, len(tmp.Users)) t.res = &tmp t.dirty = true } else { t.G().Log.Debug("| syncFromServer(): no change needed @ %d", lv) } return nil }
func (u *UpdateChecker) Check(force bool, requested bool) error { ui, _ := u.ui.GetUpdateUI() if ui == nil && !force { return fmt.Errorf("No UI for update check") } if !requested && !force { if lastCheckedPTime := u.updater.config.GetUpdateLastChecked(); lastCheckedPTime > 0 { lastChecked := keybase1.FromTime(lastCheckedPTime) if time.Now().Before(lastChecked.Add(checkDuration())) { u.log.Debug("Already checked: %s", lastChecked) return nil } } } _, err := u.updater.Update(ui, force, requested) if err != nil { return err } u.log.Debug("Updater checked") u.updater.config.SetUpdateLastChecked(keybase1.ToTime(time.Now())) return nil }
func (e *Identify2WithUID) toUserPlusKeys() keybase1.UserPlusKeys { return e.them.ExportToUserPlusKeys(keybase1.ToTime(e.getNow())) }
func (s TrackSummary) Export(username string) (ret keybase1.TrackSummary) { ret.Time = keybase1.ToTime(s.time) ret.IsRemote = s.isRemote ret.Username = username return }
// Insert adds a user to the cache, keyed on UID. func (c *Identify2Cache) Insert(up *keybase1.UserPlusKeys) error { tmp := *up copy := &tmp copy.Uvv.CachedAt = keybase1.ToTime(time.Now()) return c.cache.Set(string(up.Uid), copy) }