func (e *Identify2WithUID) loadAssertion() (err error) {
e.themAssertion, err = libkb.AssertionParseAndOnly(e.arg.UserAssertion)
if err == nil {
e.remoteAssertion, e.localAssertion = libkb.CollectAssertions(e.themAssertion)
}
return err
}
// TODO: this function can likely be replaced with a call to
// AssertionParseAndOnly when CORE-2967 and CORE-2968 are fixed.
func normalizeAssertionOrName(s string) (string, error) {
if libkb.CheckUsername.F(s) {
return libkb.NewNormalizedUsername(s).String(), nil
}
// TODO: this fails for http and https right now (see CORE-2968).
socialAssertion, isSocialAssertion := libkb.NormalizeSocialAssertion(s)
if isSocialAssertion {
return socialAssertion.String(), nil
}
if expr, err := libkb.AssertionParseAndOnly(s); err == nil {
// If the expression only contains a single url, make sure
// it's not a just considered a single keybase username. If
// it is, then some non-username slipped into the default
// "keybase" case and should be considered an error.
urls := expr.CollectUrls(nil)
if len(urls) == 1 && urls[0].IsKeybase() {
return "", NoSuchUserError{s}
}
// Normalize and return. Ideally `AssertionParseAndOnly`
// would normalize for us, but that doesn't work yet, so for
// now we'll just lower-case. This will incorrectly lower
// case http/https/web assertions, as well as case-sensitive
// social assertions in AND expressions. TODO: see CORE-2967.
return strings.ToLower(s), nil
}
return "", BadTLFNameError{s}
}
func (k *KeybaseDaemonLocal) assertionToUIDLocked(ctx context.Context,
assertion string) (uid keybase1.UID, err error) {
expr, err := libkb.AssertionParseAndOnly(assertion)
if err != nil {
return keybase1.UID(""), err
}
urls := expr.CollectUrls(nil)
if len(urls) == 0 {
return keybase1.UID(""), errors.New("No assertion URLs")
}
for _, url := range urls {
var currUID keybase1.UID
if url.IsUID() {
currUID = url.ToUID()
} else {
key, val := url.ToKeyValuePair()
a := fmt.Sprintf("%s@%s", val, key)
if url.IsKeybase() {
a = val
}
var ok bool
currUID, ok = k.asserts[a]
if !ok {
return keybase1.UID(""), NoSuchUserError{a}
}
}
if uid != keybase1.UID("") && currUID != uid {
return keybase1.UID(""),
errors.New("AND assertions resolve to different UIDs")
}
uid = currUID
}
return uid, nil
}
func (e *Identify) loadExpr(assertion string) error {
// Parse assertion but don't allow OR operators, only AND operators
expr, err := libkb.AssertionParseAndOnly(assertion)
if err != nil {
return fmt.Errorf("assertion parse error: %s", err)
}
e.userExpr = expr
return nil
}
func (e *PGPPullEngine) getTrackedUserSummaries(ctx *Context) ([]keybase1.UserSummary, error) {
err := RunEngine(e.listTrackingEngine, ctx)
if err != nil {
return nil, err
}
allTrackedSummaries := e.listTrackingEngine.TableResult()
// Without any userAsserts specified, just return everything.
if e.userAsserts == nil || len(e.userAsserts) == 0 {
return allTrackedSummaries, nil
}
// With userAsserts specified, return only those summaries. If an assert
// doesn't match any tracked users, that's an error. If an assert matches
// more than one tracked user, that is also an error. If multiple
// assertions match the same user, that's fine.
// First parse all the assertion expressions.
parsedAsserts := make(map[string]libkb.AssertionExpression)
for _, assertString := range e.userAsserts {
assertExpr, err := libkb.AssertionParseAndOnly(assertString)
if err != nil {
return nil, err
}
parsedAsserts[assertString] = assertExpr
}
// Then loop over all the tracked users, keeping track of which expressions
// have matched before.
matchedSummaries := make(map[string]keybase1.UserSummary)
assertionsUsed := make(map[string]bool)
for _, summary := range allTrackedSummaries {
proofSet := proofSetFromUserSummary(summary)
for assertStr, parsedAssert := range parsedAsserts {
if parsedAssert.MatchSet(*proofSet) {
if assertionsUsed[assertStr] {
return nil, fmt.Errorf("Assertion \"%s\" matched more than one tracked user.", assertStr)
}
assertionsUsed[assertStr] = true
matchedSummaries[summary.Username] = summary
}
}
}
// Make sure every assertion found a match.
for _, assertString := range e.userAsserts {
if !assertionsUsed[assertString] {
return nil, fmt.Errorf("Assertion \"%s\" did not match any tracked users.", assertString)
}
}
matchedList := []keybase1.UserSummary{}
for _, summary := range matchedSummaries {
matchedList = append(matchedList, summary)
}
return matchedList, nil
}
