func condenseRecord(l *libkb.TrackChainLink) (*jsonw.Wrapper, error) {
uid, err := l.GetTrackedUID()
if err != nil {
return nil, err
}
trackedKeys, err := l.GetTrackedKeys()
if err != nil {
return nil, err
}
fpsDisplay := make([]string, len(trackedKeys))
for i, trackedKey := range trackedKeys {
fpsDisplay[i] = strings.ToUpper(trackedKey.Fingerprint.String())
}
un, err := l.GetTrackedUsername()
if err != nil {
return nil, err
}
rp := l.RemoteKeyProofs()
out := jsonw.NewDictionary()
out.SetKey("uid", libkb.UIDWrapper(uid))
out.SetKey("keys", jsonw.NewString(strings.Join(fpsDisplay, ", ")))
out.SetKey("ctime", jsonw.NewInt64(l.GetCTime().Unix()))
out.SetKey("username", jsonw.NewString(un))
out.SetKey("proofs", rp)
return out, nil
}
func (e *ListTrackingEngine) linkPGPKeys(link *libkb.TrackChainLink) (res []keybase1.PublicKey) {
trackedKeys, err := link.GetTrackedKeys()
if err != nil {
e.G().Log.Warning("Bad track of %s: %s", link.ToDisplayString(), err)
return res
}
for _, trackedKey := range trackedKeys {
res = append(res, keybase1.PublicKey{PGPFingerprint: trackedKey.Fingerprint.String()})
}
return res
}
func (e *ListTrackingEngine) linkSocialProofs(link *libkb.TrackChainLink) (res []keybase1.TrackProof) {
for _, sb := range link.ToServiceBlocks() {
if !sb.IsSocial() {
continue
}
proofType, proofName := sb.ToKeyValuePair()
res = append(res, keybase1.TrackProof{
ProofType: proofType,
ProofName: proofName,
IdString: sb.ToIDString(),
})
}
return res
}
func (e *ListTrackingEngine) linkWebProofs(link *libkb.TrackChainLink) (res []keybase1.WebProof) {
webp := make(map[string]*keybase1.WebProof)
for _, sb := range link.ToServiceBlocks() {
if sb.IsSocial() {
continue
}
proofType, proofName := sb.ToKeyValuePair()
p, ok := webp[proofName]
if !ok {
p = &keybase1.WebProof{Hostname: proofName}
webp[proofName] = p
}
p.Protocols = append(p.Protocols, proofType)
}
for _, v := range webp {
res = append(res, *v)
}
return res
}
func (e *UntrackEngine) loadThem() (them *libkb.User, remoteLink, localLink *libkb.TrackChainLink, err error) {
var rLink *libkb.TrackChainLink
trackMap := e.arg.Me.IDTable().GetTrackMap()
if links, ok := trackMap[e.arg.Username]; ok && (len(links) > 0) {
rLink = links[len(links)-1]
}
var uid keybase1.UID
uidTrusted := false
if rLink != nil {
if uid, err = rLink.GetTrackedUID(); err != nil {
return
}
uidTrusted = true
}
if uid.IsNil() {
res := libkb.ResolveUID(e.arg.Username)
if err = res.GetError(); err != nil {
return
}
// This is an untrusted uid.
uid = res.GetUID()
if uid.IsNil() {
err = libkb.NewUntrackError("Could not resolve uid for @%s", e.arg.Username)
return
}
}
lLink, err := libkb.LocalTrackChainLinkFor(e.arg.Me.GetUID(), uid, e.G())
if err != nil {
return
}
if rLink == nil && lLink == nil {
err = libkb.NewUntrackError("You are not tracking %s", e.arg.Username)
return
}
if !uidTrusted {
if lLink == nil {
err = libkb.NewUntrackError("Could not verify resolved uid for @%s", e.arg.Username)
return
}
var trackedUsername string
trackedUsername, err = lLink.GetTrackedUsername()
if err != nil {
return
}
if e.arg.Username != trackedUsername {
err = libkb.NewUntrackError("Username mismatch: expected @%s, got @%s", e.arg.Username, trackedUsername)
return
}
uidTrusted = true
}
them = libkb.NewUserThin(e.arg.Username, uid)
remoteLink = rLink
localLink = lLink
return
}
