func TestMakeBareTlfHandleFailures(t *testing.T) {
_, err := MakeBareTlfHandle(nil, nil, nil, nil, nil)
assert.Equal(t, ErrNoWriters, err)
w := []keybase1.UID{
keybase1.MakeTestUID(4),
keybase1.MakeTestUID(3),
}
r := []keybase1.UID{
keybase1.PUBLIC_UID,
keybase1.MakeTestUID(2),
}
_, err = MakeBareTlfHandle(r, nil, nil, nil, nil)
assert.Equal(t, ErrInvalidWriter, err)
_, err = MakeBareTlfHandle(w, r, nil, nil, nil)
assert.Equal(t, ErrInvalidReader, err)
ur := []keybase1.SocialAssertion{
{
User: "******",
Service: "service3",
},
}
_, err = MakeBareTlfHandle(w, r[:1], nil, ur, nil)
assert.Equal(t, ErrInvalidReader, err)
}
func TestMdcachePutPastCapacity(t *testing.T) {
mockCtrl, config := mdCacheInit(t, 2)
defer mdCacheShutdown(mockCtrl, config)
id0, h0, _ := newDir(t, config, 1, true, false)
h0.Writers = append(h0.Writers, keybase1.MakeTestUID(0))
id1, h1, _ := newDir(t, config, 2, true, false)
h1.Writers = append(h1.Writers, keybase1.MakeTestUID(1))
id2, h2, _ := newDir(t, config, 3, true, false)
h2.Writers = append(h2.Writers, keybase1.MakeTestUID(2))
testMdcachePut(t, id0, 0, Merged, h0, config)
testMdcachePut(t, id1, 0, Unmerged, h1, config)
testMdcachePut(t, id2, 1, Merged, h2, config)
// id 0 should no longer be in the cache
// make sure we can get it successfully
expectUsernameCalls(h0, config)
expectedErr := NoSuchMDError{id0, 0, Merged}
if _, err := config.MDCache().Get(id0, 0, Merged); err == nil {
t.Errorf("No expected error on get")
} else if err != expectedErr {
t.Errorf("Got unexpected error on get: %v", err)
}
}
func TestKBPKIClientHasVerifyingKey(t *testing.T) {
c, _, localUsers := makeTestKBPKIClient(t)
err := c.HasVerifyingKey(context.Background(), keybase1.MakeTestUID(1),
localUsers[0].VerifyingKeys[0], time.Now())
if err != nil {
t.Error(err)
}
err = c.HasVerifyingKey(context.Background(), keybase1.MakeTestUID(1),
VerifyingKey{}, time.Now())
if err == nil {
t.Error("HasVerifyingKey unexpectedly succeeded")
}
}
// NewFolderWithIDAndWriter returns a new RootMetadataSigned for testing.
func NewFolderWithIDAndWriter(t *testing.T, id TlfID, revision MetadataRevision,
share bool, public bool, writer keybase1.UID) (*TlfHandle, *RootMetadataSigned) {
h := NewTlfHandle()
if public {
h.Readers = []keybase1.UID{keybase1.PublicUID}
}
h.Writers = append(h.Writers, writer)
if share {
h.Writers = append(h.Writers, keybase1.MakeTestUID(16))
}
rmd := NewRootMetadataForTest(h, id)
rmd.Revision = revision
rmd.LastModifyingWriter = h.Writers[0]
rmd.LastModifyingUser = h.Writers[0]
if !public {
AddNewKeysOrBust(t, rmd, *NewTLFKeyBundle())
}
rmds := &RootMetadataSigned{}
rmds.SigInfo = SignatureInfo{
Version: SigED25519,
Signature: []byte{42},
VerifyingKey: MakeFakeVerifyingKeyOrBust("fake key"),
}
rmds.MD = *rmd
return h, rmds
}
// Test that KBPKI forces a cache flush one time if it can't find a
// given verifying key.
func TestKBPKIClientHasVerifyingKeyStaleCache(t *testing.T) {
ctr := NewSafeTestReporter(t)
mockCtrl := gomock.NewController(ctr)
config := NewConfigMock(mockCtrl, ctr)
c := NewKBPKIClient(config)
config.SetKBPKI(c)
defer func() {
config.ctr.CheckForFailures()
mockCtrl.Finish()
}()
u := keybase1.MakeTestUID(1)
key1 := MakeLocalUserVerifyingKeyOrBust("u_1")
key2 := MakeLocalUserVerifyingKeyOrBust("u_2")
info1 := UserInfo{
VerifyingKeys: []VerifyingKey{key1},
}
config.mockKbd.EXPECT().LoadUserPlusKeys(gomock.Any(), u).
Return(info1, nil)
config.mockKbd.EXPECT().FlushUserFromLocalCache(gomock.Any(), u)
info2 := UserInfo{
VerifyingKeys: []VerifyingKey{key1, key2},
}
config.mockKbd.EXPECT().LoadUserPlusKeys(gomock.Any(), u).
Return(info2, nil)
err := c.HasVerifyingKey(context.Background(), u, key2, time.Now())
if err != nil {
t.Error(err)
}
}
func TestMdcachePut(t *testing.T) {
mockCtrl, config := mdCacheInit(t, 100)
defer mdCacheShutdown(mockCtrl, config)
id, h, _ := newDir(t, config, 1, true, false)
h.Writers = append(h.Writers, keybase1.MakeTestUID(0))
testMdcachePut(t, id, 1, Merged, h, config)
}
func makeTestKBPKIClient(t *testing.T) (
client *KBPKIClient, currentUID keybase1.UID, users []LocalUser) {
currentUID = keybase1.MakeTestUID(1)
names := []libkb.NormalizedUsername{"test_name1", "test_name2"}
users = MakeLocalUsers(names)
daemon := NewKeybaseDaemonMemory(currentUID, users)
config := &ConfigLocal{codec: NewCodecMsgpack(), daemon: daemon}
setTestLogger(config, t)
return NewKBPKIClient(config), currentUID, users
}
func TestMdcachePut(t *testing.T) {
mockCtrl, config := mdCacheInit(t, 100)
defer mdCacheShutdown(mockCtrl, config)
id := FakeTlfID(1, false)
h := parseTlfHandleOrBust(t, config, "alice", false)
h.Writers = append(h.Writers, keybase1.MakeTestUID(0))
testMdcachePut(t, id, 1, Merged, NullBranchID, h, config)
}
func TestKBPKIClientGetNormalizedUsername(t *testing.T) {
c, _, _ := makeTestKBPKIClient(t)
name, err := c.GetNormalizedUsername(context.Background(), keybase1.MakeTestUID(1))
if err != nil {
t.Fatal(err)
}
if name == libkb.NormalizedUsername("") {
t.Fatal("empty user")
}
}
func TestIdentify(t *testing.T) {
nug := testNormalizedUsernameGetter{
keybase1.MakeTestUID(1): "alice",
keybase1.MakeTestUID(2): "bob",
keybase1.MakeTestUID(3): "charlie",
}
ti := &testIdentifier{
assertions: map[string]UserInfo{
"alice": {
Name: "alice",
UID: keybase1.MakeTestUID(1),
},
"bob": {
Name: "bob",
UID: keybase1.MakeTestUID(2),
},
"charlie": {
Name: "charlie",
UID: keybase1.MakeTestUID(3),
},
},
}
uids := make(map[keybase1.UID]bool, len(nug))
uidList := make([]keybase1.UID, 0, len(nug))
for u := range nug {
uids[u] = true
uidList = append(uidList, u)
}
err := identifyUserList(context.Background(), nug, ti, uidList, false)
require.NoError(t, err)
require.Equal(t, uids, ti.identifiedUids)
}
func TestKBPKIClientHasRevokedVerifyingKey(t *testing.T) {
revokeTime := time.Now()
c, _, localUsers := makeTestKBPKIClientWithRevokedKey(t, revokeTime)
var revokedKey VerifyingKey
for k := range localUsers[0].RevokedVerifyingKeys {
revokedKey = k
break
}
// Something verified before the key was revoked
err := c.HasVerifyingKey(context.Background(), keybase1.MakeTestUID(1),
revokedKey, revokeTime.Add(-10*time.Second))
if err != nil {
t.Error(err)
}
// Something verified after the key was revoked
err = c.HasVerifyingKey(context.Background(), keybase1.MakeTestUID(1),
revokedKey, revokeTime.Add(10*time.Second))
if err == nil {
t.Error("HasVerifyingKey unexpectedly succeeded")
}
}
// MakeLocalUsers is a helper function to generate a list of
// LocalUsers suitable to use with KBPKILocal.
func MakeLocalUsers(users []libkb.NormalizedUsername) []LocalUser {
localUsers := make([]LocalUser, len(users))
for i := 0; i < len(users); i++ {
verifyingKey := MakeLocalUserVerifyingKeyOrBust(users[i])
cryptPublicKey := MakeLocalUserCryptPublicKeyOrBust(users[i])
localUsers[i] = LocalUser{
UserInfo: UserInfo{
Name: users[i],
UID: keybase1.MakeTestUID(uint32(i + 1)),
VerifyingKeys: []VerifyingKey{verifyingKey},
CryptPublicKeys: []CryptPublicKey{cryptPublicKey},
},
CurrentCryptPublicKeyIndex: 0,
CurrentVerifyingKeyIndex: 0,
}
}
return localUsers
}
func TestKBPKIClientGetCryptPublicKeys(t *testing.T) {
c, _, localUsers := makeTestKBPKIClient(t)
cryptPublicKeys, err := c.GetCryptPublicKeys(context.Background(),
keybase1.MakeTestUID(1))
if err != nil {
t.Fatal(err)
}
if len(cryptPublicKeys) != 1 {
t.Fatalf("Expected 1 crypt public key, got %d", len(cryptPublicKeys))
}
kid := cryptPublicKeys[0].kid
expectedKID := localUsers[0].CryptPublicKeys[0].kid
if kid != expectedKID {
t.Errorf("Expected %s, got %s", expectedKID, kid)
}
}
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 TestMDOpsGetForHandleFailHandleCheck(t *testing.T) {
mockCtrl, config, ctx := mdOpsInit(t)
defer mdOpsShutdown(mockCtrl, config)
// expect one call to fetch MD, and one to verify it, and fail that one
id, h, rmds := newDir(t, config, 1, true, false)
rmds.MD.cachedTlfHandle = NewTlfHandle()
// add a new writer after the MD was made, to force a failure
newWriter := keybase1.MakeTestUID(100)
h.Writers = append(h.Writers, newWriter)
expectUsernameCall(newWriter, config)
config.mockMdserv.EXPECT().GetForHandle(ctx, h, Merged).Return(NullTlfID, rmds, nil)
verifyMDForPrivate(config, rmds, id)
if _, err := config.MDOps().GetForHandle(ctx, h); err == nil {
t.Errorf("Got no error on bad handle check test")
} else if _, ok := err.(MDMismatchError); !ok {
t.Errorf("Got unexpected error on bad handle check test: %v", err)
}
}
// NewFolderWithID returns a new RootMetadataSigned for testing.
func NewFolderWithID(t *testing.T, id TlfID, revision MetadataRevision, share bool, public bool) (
*TlfHandle, *RootMetadataSigned) {
return NewFolderWithIDAndWriter(t, id, revision, share, public, keybase1.MakeTestUID(15))
}
// NewFolder returns a new RootMetadataSigned for testing.
func NewFolder(t *testing.T, x byte, revision MetadataRevision, share bool, public bool) (
TlfID, *TlfHandle, *RootMetadataSigned) {
id := FakeTlfID(x, public)
h, rmds := NewFolderWithIDAndWriter(t, id, revision, share, public, keybase1.MakeTestUID(15))
return id, h, rmds
}
func TestBareTlfHandleResolveAssertions(t *testing.T) {
w := []keybase1.UID{
keybase1.MakeTestUID(4),
keybase1.MakeTestUID(3),
}
r := []keybase1.UID{
keybase1.MakeTestUID(5),
keybase1.MakeTestUID(1),
}
uw := []keybase1.SocialAssertion{
{
User: "******",
Service: "service3",
},
{
User: "******",
Service: "service2",
},
{
User: "******",
Service: "service1",
},
}
ur := []keybase1.SocialAssertion{
{
User: "******",
Service: "service3",
},
{
User: "******",
Service: "service1",
},
{
User: "******",
Service: "service1",
},
{
User: "******",
Service: "service2",
},
{
User: "******",
Service: "service1",
},
{
User: "******",
Service: "service3",
},
}
h, err := MakeBareTlfHandle(w, r, uw, ur, nil)
require.NoError(t, err)
assertions := make(map[keybase1.SocialAssertion]keybase1.UID)
assertions[uw[0]] = keybase1.MakeTestUID(2) // new writer
assertions[uw[2]] = keybase1.MakeTestUID(1) // reader promoted to writer
assertions[ur[0]] = keybase1.MakeTestUID(6) // new reader
assertions[ur[2]] = keybase1.MakeTestUID(5) // already a reader
assertions[ur[3]] = keybase1.MakeTestUID(1) // already a writer
assertions[ur[4]] = keybase1.MakeTestUID(9) // new reader
assertions[ur[5]] = keybase1.MakeTestUID(9) // already a reader
h = h.ResolveAssertions(assertions)
require.Equal(t, []keybase1.UID{
keybase1.MakeTestUID(1),
keybase1.MakeTestUID(2),
keybase1.MakeTestUID(3),
keybase1.MakeTestUID(4),
}, h.Writers)
require.Equal(t, []keybase1.UID{
keybase1.MakeTestUID(5),
keybase1.MakeTestUID(6),
keybase1.MakeTestUID(9),
}, h.Readers)
require.Equal(t, []keybase1.SocialAssertion{
{
User: "******",
Service: "service2",
},
}, h.UnresolvedWriters)
require.Equal(t, []keybase1.SocialAssertion{
{
User: "******",
Service: "service1",
},
}, h.UnresolvedReaders)
}
func TestMakeBareTlfHandle(t *testing.T) {
w := []keybase1.UID{
keybase1.MakeTestUID(4),
keybase1.MakeTestUID(3),
}
r := []keybase1.UID{
keybase1.MakeTestUID(5),
keybase1.MakeTestUID(1),
}
uw := []keybase1.SocialAssertion{
{
User: "******",
Service: "service3",
},
{
User: "******",
Service: "service1",
},
}
ur := []keybase1.SocialAssertion{
{
User: "******",
Service: "service3",
},
{
User: "******",
Service: "service2",
},
}
h, err := MakeBareTlfHandle(w, r, uw, ur, nil)
require.NoError(t, err)
require.Equal(t, []keybase1.UID{
keybase1.MakeTestUID(3),
keybase1.MakeTestUID(4),
}, h.Writers)
require.Equal(t, []keybase1.UID{
keybase1.MakeTestUID(1),
keybase1.MakeTestUID(5),
}, h.Readers)
require.Equal(t, []keybase1.SocialAssertion{
{
User: "******",
Service: "service1",
},
{
User: "******",
Service: "service3",
},
}, h.UnresolvedWriters)
require.Equal(t, []keybase1.SocialAssertion{
{
User: "******",
Service: "service2",
},
{
User: "******",
Service: "service3",
},
}, h.UnresolvedReaders)
}