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 }