anyproto/any-sync
1
0
Fork 0
mirror of https://github.com/anyproto/any-sync.git synced 2025-06-08 05:57:03 +09:00
Code Activity

Implement iinvite join and tests

Browse source
This commit is contained in:
Mikhail Rakhmanov 2025-05-11 16:42:51 +02:00
parent 33a586c1af
commit ab01e874bb
No known key found for this signature in database
GPG key ID: DED12CFEF5B8396B
7 changed files with 207 additions and 146 deletions
Download patch file Download diff file Expand all files Collapse all files

203
commonspace/object/acl/aclrecordproto/aclrecord.pb.go
View file

@ -204,9 +204,10 @@ func (m *AclRoot) GetEncryptedOwnerMetadata() []byte {
// AclAccountInvite contains the public invite key, the private part of which is sent to the user directly // AclAccountInvite contains the public invite key, the private part of which is sent to the user directly
type AclAccountInvite struct { type AclAccountInvite struct {
InviteKey []byte `protobuf:"bytes,1,opt,name=inviteKey,proto3" json:"inviteKey,omitempty"` InviteKey []byte `protobuf:"bytes,1,opt,name=inviteKey,proto3" json:"inviteKey,omitempty"`
InviteType AclInviteType `protobuf:"varint,2,opt,name=inviteType,proto3,enum=aclrecord.AclInviteType" json:"inviteType,omitempty"` InviteType AclInviteType `protobuf:"varint,2,opt,name=inviteType,proto3,enum=aclrecord.AclInviteType" json:"inviteType,omitempty"`
Permissions AclUserPermissions `protobuf:"varint,3,opt,name=permissions,proto3,enum=aclrecord.AclUserPermissions" json:"permissions,omitempty"` Permissions AclUserPermissions `protobuf:"varint,3,opt,name=permissions,proto3,enum=aclrecord.AclUserPermissions" json:"permissions,omitempty"`
EncryptedReadKey []byte `protobuf:"bytes,4,opt,name=encryptedReadKey,proto3" json:"encryptedReadKey,omitempty"`
} }
func (m *AclAccountInvite) Reset() { *m = AclAccountInvite{} } func (m *AclAccountInvite) Reset() { *m = AclAccountInvite{} }
@ -271,6 +272,13 @@ func (m *AclAccountInvite) GetPermissions() AclUserPermissions {
return AclUserPermissions_None return AclUserPermissions_None
} }
func (m *AclAccountInvite) GetEncryptedReadKey() []byte {
if m != nil {
return m.EncryptedReadKey
}
return nil
}
// AclAccountRequestJoin contains the reference to the invite record and the data of the person who wants to join, confirmed by the private invite key // AclAccountRequestJoin contains the reference to the invite record and the data of the person who wants to join, confirmed by the private invite key
type AclAccountRequestJoin struct { type AclAccountRequestJoin struct {
InviteIdentity []byte `protobuf:"bytes,1,opt,name=inviteIdentity,proto3" json:"inviteIdentity,omitempty"` InviteIdentity []byte `protobuf:"bytes,1,opt,name=inviteIdentity,proto3" json:"inviteIdentity,omitempty"`
@ -1489,78 +1497,78 @@ func init() {
} }
var fileDescriptor_c8e9f754f34e929b = []byte{ var fileDescriptor_c8e9f754f34e929b = []byte{
// 1124 bytes of a gzipped FileDescriptorProto // 1125 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x57, 0x5f, 0x6f, 0xdb, 0x54, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x57, 0xdf, 0x6e, 0xdb, 0x54,
0x14, 0xb7, 0x93, 0xa6, 0x69, 0x4e, 0x9a, 0xcc, 0xbd, 0x1b, 0x9b, 0xd7, 0x41, 0x08, 0x46, 0x9b, 0x18, 0xb7, 0x93, 0xa6, 0x69, 0xbe, 0x34, 0x99, 0x7b, 0x36, 0x36, 0xaf, 0x83, 0x10, 0x8c, 0x36,
0xa2, 0x0a, 0xad, 0x28, 0xa8, 0xd3, 0x34, 0x01, 0x9d, 0x97, 0x4e, 0x4b, 0x36, 0x0d, 0xa6, 0xbb, 0x45, 0x15, 0x5a, 0x51, 0x50, 0xa7, 0x69, 0x02, 0x3a, 0x2f, 0x9d, 0x96, 0x6c, 0x1a, 0x4c, 0x67,
0xb1, 0x21, 0x24, 0x90, 0x5c, 0xfb, 0x6a, 0x18, 0x9c, 0xeb, 0x60, 0xdf, 0x04, 0xe5, 0x5b, 0xf0, 0x63, 0x43, 0x48, 0x20, 0xb9, 0xf6, 0xd1, 0x30, 0x38, 0xc7, 0xc1, 0x3e, 0x09, 0xca, 0x5b, 0xf0,
0x39, 0xe0, 0x95, 0x57, 0xde, 0x79, 0xe0, 0xa1, 0x8f, 0x08, 0xf1, 0x80, 0xda, 0x4f, 0xc0, 0x37, 0x1c, 0x5c, 0x73, 0xcb, 0x3d, 0x17, 0x5c, 0xf4, 0x0e, 0x84, 0xb8, 0x40, 0xed, 0x13, 0xf0, 0x06,
0x40, 0xf7, 0xda, 0xb1, 0xaf, 0x1d, 0x3b, 0x4d, 0x1f, 0xd0, 0x1e, 0xda, 0xf8, 0x9e, 0xff, 0xe7, 0xe8, 0x1c, 0x3b, 0xf6, 0xb1, 0x63, 0xa7, 0xe9, 0x05, 0xda, 0x45, 0x1b, 0x9f, 0xef, 0x7c, 0xff,
0xfc, 0xce, 0xb9, 0xc7, 0x86, 0x8f, 0x6d, 0x7f, 0x3c, 0xf6, 0x69, 0x38, 0xb1, 0x6c, 0xb2, 0xef, 0x7f, 0xdf, 0x1f, 0x1b, 0x3e, 0xb6, 0xfd, 0xf1, 0xd8, 0xa7, 0xe1, 0xc4, 0xb2, 0xc9, 0xbe, 0x7f,
0x1f, 0x7f, 0x47, 0x6c, 0xb6, 0x6f, 0xd9, 0x1e, 0xff, 0x0b, 0x88, 0xed, 0x07, 0xce, 0x24, 0xf0, 0xfc, 0x1d, 0xb1, 0xd9, 0xbe, 0x65, 0x7b, 0xfc, 0x2f, 0x20, 0xb6, 0x1f, 0x38, 0x93, 0xc0, 0x67,
0x99, 0xbf, 0x2f, 0xfe, 0x87, 0x29, 0xf5, 0xb6, 0x20, 0xa0, 0x46, 0x42, 0x30, 0xfe, 0xad, 0x40, 0xfe, 0xbe, 0xf8, 0x1f, 0xa6, 0xd4, 0xdb, 0x82, 0x80, 0x1a, 0x09, 0xc1, 0xf8, 0xb7, 0x02, 0x75,
0xdd, 0xb4, 0x3d, 0xec, 0xfb, 0x0c, 0xed, 0xc2, 0x96, 0xeb, 0x10, 0xca, 0x5c, 0x36, 0xd7, 0xd5, 0xd3, 0xf6, 0xb0, 0xef, 0x33, 0xb4, 0x0b, 0x5b, 0xae, 0x43, 0x28, 0x73, 0xd9, 0x5c, 0x57, 0xbb,
0xae, 0xda, 0xdb, 0xc6, 0xc9, 0x19, 0xbd, 0x0d, 0x8d, 0xb1, 0x15, 0x32, 0x12, 0x3c, 0x21, 0x73, 0x6a, 0x6f, 0x1b, 0x27, 0x67, 0xf4, 0x36, 0x34, 0xc6, 0x56, 0xc8, 0x48, 0xf0, 0x84, 0xcc, 0xf5,
0xbd, 0x22, 0x98, 0x29, 0x01, 0xe9, 0x50, 0x17, 0xa1, 0x8c, 0x1c, 0xbd, 0xda, 0x55, 0x7b, 0x0d, 0x8a, 0xb8, 0x4c, 0x09, 0x48, 0x87, 0xba, 0x70, 0x65, 0xe4, 0xe8, 0xd5, 0xae, 0xda, 0x6b, 0xe0,
0xbc, 0x38, 0xa2, 0x3d, 0xd0, 0x08, 0xb5, 0x83, 0xf9, 0x84, 0x11, 0x07, 0x13, 0xcb, 0xe1, 0xea, 0xc5, 0x11, 0xed, 0x81, 0x46, 0xa8, 0x1d, 0xcc, 0x27, 0x8c, 0x38, 0x98, 0x58, 0x0e, 0x17, 0xdf,
0x1b, 0x42, 0x7d, 0x89, 0xce, 0x7d, 0x30, 0x77, 0x4c, 0x42, 0x66, 0x8d, 0x27, 0x7a, 0xad, 0xab, 0x10, 0xe2, 0x4b, 0x74, 0x6e, 0x83, 0xb9, 0x63, 0x12, 0x32, 0x6b, 0x3c, 0xd1, 0x6b, 0x5d, 0xb5,
0xf6, 0xaa, 0x38, 0x25, 0xa0, 0x0f, 0x60, 0x67, 0x11, 0xcd, 0x73, 0xf7, 0x35, 0xb5, 0xd8, 0x34, 0x57, 0xc5, 0x29, 0x01, 0x7d, 0x00, 0x3b, 0x0b, 0x6f, 0x9e, 0xbb, 0xaf, 0xa9, 0xc5, 0xa6, 0x01,
0x20, 0xfa, 0xa6, 0x30, 0xb5, 0xcc, 0x40, 0xb7, 0xa0, 0x3d, 0x26, 0xcc, 0x72, 0x2c, 0x66, 0x3d, 0xd1, 0x37, 0x85, 0xaa, 0xe5, 0x0b, 0x74, 0x0b, 0xda, 0x63, 0xc2, 0x2c, 0xc7, 0x62, 0xd6, 0xb3,
0x9b, 0x1e, 0x73, 0xaf, 0x75, 0x21, 0x9a, 0xa3, 0xa2, 0x7b, 0xa0, 0x27, 0x71, 0x3c, 0x5d, 0xb0, 0xe9, 0x31, 0xb7, 0x5a, 0x17, 0xac, 0x39, 0x2a, 0xba, 0x07, 0x7a, 0xe2, 0xc7, 0xd3, 0xc5, 0x55,
0x02, 0x77, 0xc6, 0x35, 0xb6, 0x84, 0x46, 0x29, 0x1f, 0xdd, 0x81, 0xab, 0x09, 0xef, 0xf3, 0x1f, 0xe0, 0xce, 0xb8, 0xc4, 0x96, 0x90, 0x28, 0xbd, 0x47, 0x77, 0xe0, 0x6a, 0x72, 0xf7, 0xf9, 0x8f,
0x29, 0x09, 0x16, 0x02, 0x7a, 0x43, 0x68, 0x96, 0x70, 0x8d, 0x5f, 0x54, 0xd0, 0x4c, 0xdb, 0x33, 0x94, 0x04, 0x0b, 0x06, 0xbd, 0x21, 0x24, 0x4b, 0x6e, 0x8d, 0x3f, 0x54, 0xd0, 0x4c, 0xdb, 0x33,
0x6d, 0xdb, 0x9f, 0x52, 0x36, 0xa2, 0x33, 0x97, 0x11, 0x9e, 0xbc, 0x2b, 0x9e, 0xb8, 0xe7, 0xa8, 0x6d, 0xdb, 0x9f, 0x52, 0x36, 0xa2, 0x33, 0x97, 0x11, 0x1e, 0xbc, 0x2b, 0x9e, 0xb8, 0xe5, 0x28,
0xfa, 0x29, 0x01, 0xdd, 0x05, 0x88, 0x0e, 0x2f, 0xe6, 0x13, 0x22, 0xea, 0xdf, 0xee, 0xeb, 0xb7, 0xfb, 0x29, 0x01, 0xdd, 0x05, 0x88, 0x0e, 0x2f, 0xe6, 0x13, 0x22, 0xf2, 0xdf, 0xee, 0xeb, 0xb7,
0x53, 0x5c, 0x4d, 0xdb, 0x1b, 0x25, 0x7c, 0x2c, 0xc9, 0xa2, 0x43, 0x68, 0x4e, 0x48, 0x30, 0x76, 0x53, 0x5c, 0x4d, 0xdb, 0x1b, 0x25, 0xf7, 0x58, 0xe2, 0x45, 0x87, 0xd0, 0x9c, 0x90, 0x60, 0xec,
0xc3, 0xd0, 0xf5, 0x69, 0x28, 0xe0, 0x69, 0xf7, 0xdf, 0xc9, 0xaa, 0x7e, 0x11, 0x92, 0xe0, 0x59, 0x86, 0xa1, 0xeb, 0xd3, 0x50, 0xc0, 0xd3, 0xee, 0xbf, 0x93, 0x15, 0xfd, 0x22, 0x24, 0xc1, 0xb3,
0x2a, 0x84, 0x65, 0x0d, 0xe3, 0x37, 0x15, 0xde, 0x4a, 0xa3, 0xc5, 0xe4, 0x87, 0x29, 0x09, 0xd9, 0x94, 0x09, 0xcb, 0x12, 0x17, 0x41, 0xd0, 0xf8, 0x55, 0x85, 0xb7, 0xd2, 0xc8, 0x30, 0xf9, 0x61,
0x63, 0xdf, 0xa5, 0xbc, 0xc6, 0x91, 0xa3, 0x51, 0xb6, 0x6b, 0x72, 0xd4, 0x54, 0x0e, 0x0b, 0x8f, 0x4a, 0x42, 0xf6, 0xd8, 0x77, 0x29, 0xc7, 0x23, 0x72, 0x6a, 0x94, 0xad, 0xb0, 0x1c, 0x35, 0xe5,
0x23, 0x47, 0x24, 0xd0, 0xc0, 0x39, 0x2a, 0xba, 0x0b, 0xd7, 0xb2, 0x9a, 0x29, 0xce, 0x55, 0x61, 0xc3, 0xc2, 0xbb, 0x91, 0x23, 0x82, 0x6d, 0xe0, 0x1c, 0x15, 0xdd, 0x85, 0x6b, 0x59, 0xc9, 0xb4,
0xb8, 0x8c, 0xcd, 0x3b, 0x77, 0x81, 0x6b, 0xdc, 0x5d, 0xc9, 0xd9, 0xf8, 0x5b, 0x85, 0x2b, 0xf9, 0x26, 0xaa, 0x42, 0x71, 0xd9, 0x35, 0xaf, 0xf2, 0x45, 0x0d, 0xc4, 0x71, 0x24, 0x67, 0xe3, 0x6f,
0x6a, 0x8b, 0xf0, 0x57, 0xb5, 0xfb, 0x1b, 0x0d, 0xb9, 0x70, 0x68, 0x6a, 0xc5, 0x43, 0x63, 0xfc, 0x15, 0xae, 0xe4, 0x91, 0x11, 0xee, 0xaf, 0x6a, 0x8d, 0x37, 0xea, 0x72, 0x21, 0x3c, 0xb5, 0x12,
0xa1, 0xc2, 0xb5, 0x25, 0x78, 0x4c, 0xdb, 0x26, 0x93, 0xd5, 0x03, 0xdd, 0x83, 0x4b, 0x41, 0x24, 0x78, 0x7e, 0x57, 0xe1, 0xda, 0x12, 0x3c, 0xa6, 0x6d, 0x93, 0xc9, 0xea, 0xe6, 0xef, 0xc1, 0xa5,
0x9c, 0x4b, 0x31, 0x4f, 0x2e, 0x8c, 0xa6, 0x5a, 0x32, 0xc2, 0xb9, 0x6e, 0xdb, 0xb8, 0x70, 0xb7, 0x20, 0x62, 0xce, 0x85, 0x98, 0x27, 0x17, 0x7a, 0x53, 0x2d, 0x69, 0xf7, 0x5c, 0x65, 0x6e, 0x5c,
0x1d, 0x81, 0xbe, 0x94, 0xcd, 0x11, 0xb1, 0x3d, 0x97, 0x92, 0xa2, 0x90, 0xd5, 0xc2, 0x90, 0x8d, 0xb4, 0x32, 0x8d, 0x23, 0xd0, 0x97, 0xa2, 0x39, 0x22, 0xb6, 0xe7, 0x52, 0x52, 0xe4, 0xb2, 0x5a,
0xfb, 0x70, 0x35, 0x0f, 0x39, 0x26, 0x33, 0xff, 0x7b, 0x52, 0x00, 0xac, 0x5a, 0x04, 0xac, 0xf1, 0xe8, 0xb2, 0x71, 0x1f, 0xae, 0xe6, 0x21, 0xc7, 0x64, 0xe6, 0x7f, 0x4f, 0x0a, 0x80, 0x55, 0x8b,
0x35, 0x5c, 0x36, 0x6d, 0xef, 0x61, 0x3e, 0xbf, 0x55, 0x15, 0x2d, 0xaa, 0x53, 0xa5, 0x04, 0xb5, 0x80, 0x35, 0xbe, 0x86, 0xcb, 0xa6, 0xed, 0x3d, 0xcc, 0xc7, 0xb7, 0x2a, 0xa3, 0x45, 0x79, 0xaa,
0x6f, 0xe0, 0x46, 0x1a, 0x60, 0x5a, 0x8c, 0xc1, 0xb7, 0x16, 0x7d, 0x4d, 0x42, 0x74, 0x08, 0x75, 0x94, 0xa0, 0xf6, 0x0d, 0xdc, 0x48, 0x1d, 0x4c, 0x93, 0x31, 0xf8, 0xd6, 0xa2, 0xaf, 0x49, 0x88,
0x3b, 0x7a, 0xd4, 0xd5, 0x6e, 0xb5, 0xd7, 0xec, 0xdf, 0xcc, 0x96, 0xb0, 0x44, 0x11, 0x2f, 0xb4, 0x0e, 0xa1, 0x6e, 0x47, 0x8f, 0xba, 0xda, 0xad, 0xf6, 0x9a, 0xfd, 0x9b, 0xd9, 0x14, 0x96, 0x08,
0x8c, 0x21, 0xb4, 0x53, 0xb1, 0xd0, 0x74, 0x1c, 0x74, 0x07, 0x1a, 0x96, 0xe3, 0xb8, 0x4c, 0xe0, 0xe2, 0x85, 0x94, 0x31, 0x84, 0x76, 0xca, 0x16, 0x9a, 0x8e, 0x83, 0xee, 0x40, 0xc3, 0x72, 0x1c,
0x12, 0x19, 0xd5, 0x0b, 0x8d, 0x9a, 0x8e, 0x83, 0x53, 0x51, 0xe3, 0x57, 0x15, 0x5a, 0x19, 0xe6, 0x97, 0x09, 0x5c, 0x22, 0xa5, 0x7a, 0xa1, 0x52, 0xd3, 0x71, 0x70, 0xca, 0x6a, 0xfc, 0xa2, 0x42,
0xca, 0x1a, 0xe4, 0xf0, 0xaf, 0x5c, 0x14, 0xff, 0xcc, 0x58, 0x54, 0xd7, 0x18, 0x8b, 0x92, 0x5d, 0x2b, 0x73, 0xb9, 0x32, 0x07, 0x39, 0xfc, 0x2b, 0x17, 0x9e, 0x4c, 0x72, 0x5b, 0x54, 0xd7, 0x68,
0x62, 0x1c, 0x14, 0x4c, 0xc5, 0xc0, 0xa2, 0x36, 0xf1, 0xb8, 0x8b, 0x20, 0x0b, 0x7e, 0x72, 0x36, 0x8b, 0xb2, 0xa9, 0x75, 0x50, 0xd0, 0x15, 0x03, 0x8b, 0xda, 0xc4, 0xe3, 0x26, 0x82, 0x2c, 0xf8,
0xe6, 0xb0, 0x5b, 0x5e, 0xde, 0xff, 0x35, 0x73, 0xe3, 0xe7, 0x8a, 0xd8, 0x0a, 0x71, 0x02, 0xb1, 0xc9, 0xd9, 0x98, 0xc3, 0x6e, 0x79, 0x7a, 0xff, 0xd7, 0xc8, 0x8d, 0x9f, 0x2b, 0x62, 0x83, 0xc4,
0xc7, 0xfb, 0xd0, 0xb4, 0xa2, 0x60, 0x9e, 0x90, 0xf9, 0x02, 0xb7, 0x4e, 0xd6, 0x6a, 0xbe, 0x49, 0x01, 0xc4, 0x16, 0xef, 0x43, 0xd3, 0x8a, 0x9c, 0x79, 0x42, 0xe6, 0x0b, 0xdc, 0x3a, 0x59, 0xad,
0xb1, 0xac, 0x52, 0xb0, 0x08, 0x2b, 0x17, 0x5e, 0x84, 0xd5, 0x73, 0x16, 0xe1, 0x87, 0x70, 0x39, 0xf9, 0x22, 0xc5, 0xb2, 0x48, 0xc1, 0xd2, 0xac, 0x5c, 0x78, 0x69, 0x56, 0xcf, 0x59, 0x9a, 0x1f,
0x5d, 0x75, 0x5e, 0x0e, 0x9b, 0x22, 0x16, 0xfa, 0x74, 0xb1, 0xcf, 0x44, 0x5a, 0xb5, 0xb5, 0xd2, 0xc2, 0xe5, 0x74, 0x2d, 0x7a, 0x39, 0x6c, 0x8a, 0xae, 0xd0, 0xa7, 0x8b, 0xdd, 0x27, 0xc2, 0xaa,
0x92, 0x34, 0x8c, 0xa9, 0xbc, 0x41, 0x31, 0x19, 0xfb, 0x33, 0x82, 0x3a, 0x00, 0x31, 0x1a, 0x6e, 0xad, 0x15, 0x96, 0x24, 0x61, 0x4c, 0xe5, 0x6d, 0x8b, 0xc9, 0xd8, 0x9f, 0x11, 0xd4, 0x01, 0x88,
0x3c, 0x37, 0xdb, 0x58, 0xa2, 0x20, 0x13, 0x5a, 0x81, 0x5c, 0x5c, 0x51, 0x88, 0x66, 0xff, 0x46, 0xd1, 0x70, 0xe3, 0xbe, 0xd9, 0xc6, 0x12, 0x05, 0x99, 0xd0, 0x0a, 0xe4, 0xe4, 0x8a, 0x44, 0x34,
0xd6, 0x6d, 0xa6, 0xfe, 0x38, 0xab, 0x61, 0x5c, 0x2f, 0xe8, 0xaa, 0xc8, 0xbb, 0xf1, 0x57, 0x1d, 0xfb, 0x37, 0xb2, 0x66, 0x33, 0xf9, 0xc7, 0x59, 0x09, 0xe3, 0x7a, 0x41, 0x55, 0x45, 0xd6, 0x8d,
0x2e, 0x99, 0xb6, 0x37, 0xf0, 0x29, 0x23, 0x94, 0xbd, 0xb4, 0xbc, 0x29, 0x41, 0x07, 0xb0, 0x19, 0xbf, 0xea, 0x70, 0xc9, 0xb4, 0xbd, 0x81, 0x4f, 0x19, 0xa1, 0xec, 0xa5, 0xe5, 0x4d, 0x09, 0x3a,
0xc5, 0x2c, 0xba, 0x65, 0xc9, 0x55, 0xe6, 0x7e, 0x1a, 0x2a, 0x38, 0x16, 0x46, 0x8f, 0x60, 0xdb, 0x80, 0xcd, 0xc8, 0x67, 0x51, 0x2d, 0x4b, 0xa6, 0x32, 0xf3, 0x69, 0xa8, 0xe0, 0x98, 0x19, 0x3d,
0x95, 0xee, 0xac, 0x38, 0xce, 0xf7, 0x56, 0x28, 0x47, 0x82, 0x43, 0x05, 0x67, 0x14, 0xd1, 0x11, 0x82, 0x6d, 0x57, 0x9a, 0x59, 0xb1, 0x9f, 0xef, 0xad, 0x10, 0x8e, 0x18, 0x87, 0x0a, 0xce, 0x08,
0x34, 0x83, 0x74, 0x5f, 0x0b, 0x18, 0x9b, 0xfd, 0x6e, 0xa1, 0x1d, 0x69, 0xaf, 0x0f, 0x15, 0x2c, 0xa2, 0x23, 0x68, 0x06, 0xe9, 0xbe, 0x16, 0x30, 0x36, 0xfb, 0xdd, 0x42, 0x3d, 0xd2, 0x5e, 0x1f,
0xab, 0xa1, 0xc7, 0xbc, 0x6e, 0xd2, 0x5a, 0x11, 0xb8, 0x36, 0xfb, 0xc6, 0x2a, 0x3b, 0x91, 0xe4, 0x2a, 0x58, 0x16, 0x43, 0x8f, 0x79, 0xde, 0xa4, 0xb5, 0x22, 0x70, 0x6d, 0xf6, 0x8d, 0x55, 0x7a,
0x50, 0xc1, 0x59, 0x55, 0xf4, 0x1c, 0xb4, 0x49, 0x6e, 0xaa, 0xc4, 0x66, 0x5b, 0xf7, 0x86, 0x1b, 0x22, 0xce, 0xa1, 0x82, 0xb3, 0xa2, 0xe8, 0x39, 0x68, 0x93, 0x5c, 0x57, 0x89, 0xcd, 0xb6, 0xee,
0x2a, 0x78, 0xc9, 0x00, 0x1a, 0x40, 0xcb, 0x92, 0x3b, 0x41, 0xbc, 0x15, 0x96, 0x55, 0x3b, 0x12, 0x84, 0x1b, 0x2a, 0x78, 0x49, 0x01, 0x1a, 0x40, 0xcb, 0x92, 0x2b, 0x41, 0xbc, 0x41, 0x96, 0x65,
0xe1, 0x91, 0x65, 0x74, 0xb8, 0x91, 0x6c, 0x77, 0xd4, 0xcf, 0xed, 0x8e, 0x28, 0x3d, 0x79, 0x5c, 0x3b, 0x62, 0xe1, 0x9e, 0x65, 0x64, 0xb8, 0x92, 0x6c, 0x75, 0xd4, 0xcf, 0xad, 0x8e, 0x28, 0x3c,
0x9f, 0x42, 0x3b, 0xc8, 0xec, 0x2c, 0xf1, 0x0e, 0xd9, 0xec, 0xbf, 0xbf, 0xaa, 0x56, 0xb1, 0xe8, 0xb9, 0x5d, 0x9f, 0x42, 0x3b, 0xc8, 0xec, 0x2c, 0xf1, 0xbe, 0xd9, 0xec, 0xbf, 0xbf, 0x2a, 0x57,
0x50, 0xc1, 0x39, 0x65, 0xf4, 0x25, 0x5c, 0xb1, 0x0a, 0x7a, 0x4d, 0xbc, 0x5e, 0x9e, 0x03, 0x40, 0x31, 0xeb, 0x50, 0xc1, 0x39, 0x61, 0xf4, 0x25, 0x5c, 0xb1, 0x0a, 0x6a, 0x4d, 0xbc, 0x8a, 0x9e,
0x92, 0x66, 0xa1, 0x05, 0xf4, 0x12, 0x76, 0xf2, 0x65, 0x0c, 0x75, 0x10, 0x66, 0x6f, 0xad, 0x05, 0x03, 0x40, 0x12, 0x66, 0xa1, 0x06, 0xf4, 0x12, 0x76, 0xf2, 0x69, 0x0c, 0x75, 0x10, 0x6a, 0x6f,
0x44, 0x38, 0x54, 0xf0, 0xb2, 0x09, 0xf4, 0x49, 0x72, 0x5f, 0xf1, 0xa5, 0xa3, 0x37, 0x85, 0xc5, 0xad, 0x05, 0x44, 0x38, 0x54, 0xf0, 0xb2, 0x0a, 0xf4, 0x49, 0x32, 0xaf, 0xf8, 0xd2, 0xd1, 0x9b,
0xeb, 0x85, 0x16, 0xb9, 0x00, 0x6f, 0x35, 0x49, 0x5e, 0x6a, 0xb5, 0xe8, 0xae, 0xd6, 0xb7, 0xcf, 0x42, 0xe3, 0xf5, 0x42, 0x8d, 0x9c, 0x81, 0x97, 0x9a, 0xc4, 0x2f, 0x95, 0x5a, 0x34, 0xab, 0xf5,
0xcf, 0x34, 0x92, 0x94, 0x5a, 0x2d, 0xbe, 0xe6, 0xcd, 0xc5, 0x15, 0x23, 0x7a, 0xbf, 0x25, 0x0c, 0xed, 0xf3, 0x23, 0x8d, 0x38, 0xa5, 0x52, 0x8b, 0xc7, 0xbc, 0xb9, 0x18, 0x31, 0xa2, 0xf6, 0x5b,
0xbd, 0xbb, 0x62, 0x86, 0xe2, 0xd6, 0x97, 0x94, 0x1e, 0xd4, 0xa1, 0x36, 0xe3, 0x83, 0x6c, 0x3c, 0x42, 0xd1, 0xbb, 0x2b, 0x7a, 0x28, 0x2e, 0x7d, 0x49, 0xe8, 0x41, 0x1d, 0x6a, 0x33, 0xde, 0xc8,
0x14, 0x1f, 0x49, 0x47, 0x7c, 0x09, 0xdd, 0x03, 0xb0, 0x92, 0x31, 0x8f, 0x2f, 0xe4, 0xdd, 0xac, 0xc6, 0x43, 0xf1, 0x41, 0x75, 0xc4, 0x97, 0xd0, 0x3d, 0x00, 0x2b, 0x69, 0xf3, 0x78, 0x20, 0xef,
0x59, 0xf9, 0x0e, 0xc0, 0x92, 0xf4, 0xde, 0x81, 0x58, 0xa5, 0xe9, 0x8b, 0x3a, 0xda, 0x81, 0x56, 0x66, 0xd5, 0xca, 0x33, 0x00, 0x4b, 0xdc, 0x7b, 0x07, 0x62, 0x95, 0xa6, 0x2f, 0xf5, 0x68, 0x07,
0x9c, 0xc5, 0x0b, 0x9f, 0x7b, 0xd4, 0x14, 0x4e, 0x32, 0xe9, 0xdc, 0xa7, 0x64, 0x60, 0x51, 0x41, 0x5a, 0x71, 0x14, 0x2f, 0x7c, 0x6e, 0x51, 0x53, 0x38, 0xc9, 0xa4, 0x73, 0x9f, 0x92, 0x81, 0x45,
0x52, 0xf7, 0x5e, 0x01, 0x5a, 0x5e, 0x1e, 0x68, 0x0b, 0x36, 0x3e, 0xf3, 0x29, 0xd1, 0x14, 0xd4, 0x05, 0x49, 0xdd, 0x7b, 0x05, 0x68, 0x79, 0x79, 0xa0, 0x2d, 0xd8, 0xf8, 0xcc, 0xa7, 0x44, 0x53,
0x80, 0x9a, 0xf8, 0xc0, 0xd0, 0x54, 0xfe, 0x68, 0x3a, 0x63, 0x97, 0x6a, 0x15, 0x04, 0xb0, 0xf9, 0x50, 0x03, 0x6a, 0xe2, 0x63, 0x44, 0x53, 0xf9, 0xa3, 0xe9, 0x8c, 0x5d, 0xaa, 0x55, 0x10, 0xc0,
0x2a, 0x70, 0x19, 0x09, 0xb4, 0x2a, 0x7f, 0xe6, 0x9d, 0x4b, 0x02, 0x6d, 0x83, 0x8b, 0x3c, 0xe2, 0xe6, 0xab, 0xc0, 0x65, 0x24, 0xd0, 0xaa, 0xfc, 0x99, 0x57, 0x2e, 0x09, 0xb4, 0x0d, 0xce, 0xf2,
0x1e, 0xb5, 0xda, 0x83, 0xc3, 0xdf, 0x4f, 0x3b, 0xea, 0xc9, 0x69, 0x47, 0xfd, 0xe7, 0xb4, 0xa3, 0x88, 0x5b, 0xd4, 0x6a, 0x0f, 0x0e, 0x7f, 0x3b, 0xed, 0xa8, 0x27, 0xa7, 0x1d, 0xf5, 0x9f, 0xd3,
0xfe, 0x74, 0xd6, 0x51, 0x4e, 0xce, 0x3a, 0xca, 0x9f, 0x67, 0x1d, 0xe5, 0xab, 0x9b, 0x6b, 0x7d, 0x8e, 0xfa, 0xd3, 0x59, 0x47, 0x39, 0x39, 0xeb, 0x28, 0x7f, 0x9e, 0x75, 0x94, 0xaf, 0x6e, 0xae,
0x5f, 0x1e, 0x6f, 0x8a, 0x9f, 0x8f, 0xfe, 0x0b, 0x00, 0x00, 0xff, 0xff, 0x3c, 0x5d, 0xff, 0xb8, 0xf5, 0x2d, 0x7a, 0xbc, 0x29, 0x7e, 0x3e, 0xfa, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x75, 0x08, 0x98,
0x8f, 0x0e, 0x00, 0x00, 0x61, 0xbb, 0x0e, 0x00, 0x00,
} }
func (m *AclRoot) Marshal() (dAtA []byte, err error) { func (m *AclRoot) Marshal() (dAtA []byte, err error) {
@ -1667,6 +1675,13 @@ func (m *AclAccountInvite) MarshalToSizedBuffer(dAtA []byte) (int, error) {
_ = i _ = i
var l int var l int
_ = l _ = l
if len(m.EncryptedReadKey) > 0 {
i -= len(m.EncryptedReadKey)
copy(dAtA[i:], m.EncryptedReadKey)
i = encodeVarintAclrecord(dAtA, i, uint64(len(m.EncryptedReadKey)))
i--
dAtA[i] = 0x22
}
if m.Permissions != 0 { if m.Permissions != 0 {
i = encodeVarintAclrecord(dAtA, i, uint64(m.Permissions)) i = encodeVarintAclrecord(dAtA, i, uint64(m.Permissions))
i-- i--
@ -2682,6 +2697,10 @@ func (m *AclAccountInvite) Size() (n int) {
if m.Permissions != 0 { if m.Permissions != 0 {
n += 1 + sovAclrecord(uint64(m.Permissions)) n += 1 + sovAclrecord(uint64(m.Permissions))
} }
l = len(m.EncryptedReadKey)
if l > 0 {
n += 1 + l + sovAclrecord(uint64(l))
}
return n return n
} }
@ -3579,6 +3598,40 @@ func (m *AclAccountInvite) Unmarshal(dAtA []byte) error {
break break
} }
} }
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field EncryptedReadKey", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowAclrecord
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthAclrecord
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthAclrecord
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.EncryptedReadKey = append(m.EncryptedReadKey[:0], dAtA[iNdEx:postIndex]...)
if m.EncryptedReadKey == nil {
m.EncryptedReadKey = []byte{}
}
iNdEx = postIndex
default: default:
iNdEx = preIndex iNdEx = preIndex
skippy, err := skipAclrecord(dAtA[iNdEx:]) skippy, err := skipAclrecord(dAtA[iNdEx:])

1
commonspace/object/acl/aclrecordproto/protos/aclrecord.proto
View file

@ -20,6 +20,7 @@ message AclAccountInvite {
bytes inviteKey = 1; bytes inviteKey = 1;
AclInviteType inviteType = 2; AclInviteType inviteType = 2;
AclUserPermissions permissions = 3; AclUserPermissions permissions = 3;
bytes encryptedReadKey = 4;
} }
enum AclInviteType { enum AclInviteType {

27
commonspace/object/acl/list/aclrecordbuilder.go
View file

@ -28,7 +28,6 @@ type RequestJoinPayload struct {
type InviteJoinPayload struct { type InviteJoinPayload struct {
InviteKey crypto.PrivKey InviteKey crypto.PrivKey
ReadKey crypto.SymKey
Metadata []byte Metadata []byte
} }
@ -89,6 +88,7 @@ type AclRecordBuilder interface {
BuildInvite() (res InviteResult, err error) BuildInvite() (res InviteResult, err error)
BuildInviteAnyone() (res InviteResult, err error) BuildInviteAnyone() (res InviteResult, err error)
BuildInviteRevoke(inviteRecordId string) (rawRecord *consensusproto.RawRecord, err error) BuildInviteRevoke(inviteRecordId string) (rawRecord *consensusproto.RawRecord, err error)
BuildInviteJoin(payload InviteJoinPayload) (rawRecord *consensusproto.RawRecord, err error)
BuildRequestJoin(payload RequestJoinPayload) (rawRecord *consensusproto.RawRecord, err error) BuildRequestJoin(payload RequestJoinPayload) (rawRecord *consensusproto.RawRecord, err error)
BuildRequestAccept(payload RequestAcceptPayload) (rawRecord *consensusproto.RawRecord, err error) BuildRequestAccept(payload RequestAcceptPayload) (rawRecord *consensusproto.RawRecord, err error)
BuildRequestDecline(requestRecordId string) (rawRecord *consensusproto.RawRecord, err error) BuildRequestDecline(requestRecordId string) (rawRecord *consensusproto.RawRecord, err error)
@ -334,10 +334,23 @@ func (a *aclRecordBuilder) BuildInviteAnyone() (res InviteResult, err error) {
if err != nil { if err != nil {
return return
} }
curReadKey, err := a.state.CurrentReadKey()
if err != nil {
return
}
raw, err := curReadKey.Marshall()
if err != nil {
return
}
encReadKey, err := pubKey.Encrypt(raw)
if err != nil {
return
}
inviteRec := &aclrecordproto.AclAccountInvite{ inviteRec := &aclrecordproto.AclAccountInvite{
InviteKey: invitePubKey, InviteKey: invitePubKey,
InviteType: aclrecordproto.AclInviteType_AnyoneCanJoin, InviteType: aclrecordproto.AclInviteType_AnyoneCanJoin,
Permissions: aclrecordproto.AclUserPermissions_Reader, Permissions: aclrecordproto.AclUserPermissions_Reader,
EncryptedReadKey: encReadKey,
} }
content := &aclrecordproto.AclContentValue{Value: &aclrecordproto.AclContentValue_Invite{Invite: inviteRec}} content := &aclrecordproto.AclContentValue{Value: &aclrecordproto.AclContentValue_Invite{Invite: inviteRec}}
rawRec, err := a.buildRecord(content) rawRec, err := a.buildRecord(content)
@ -463,7 +476,11 @@ func (a *aclRecordBuilder) BuildInviteJoin(payload InviteJoinPayload) (rawRecord
if err != nil { if err != nil {
return return
} }
readKey, err := payload.ReadKey.Marshall() key, err := a.state.DecryptInvite(payload.InviteKey)
if err != nil {
return
}
readKey, err := key.Marshall()
if err != nil { if err != nil {
return return
} }

97
commonspace/object/acl/list/aclstate.go
View file

@ -55,9 +55,10 @@ type AclKeys struct {
} }
type Invite struct { type Invite struct {
Key crypto.PubKey Key crypto.PubKey
Type aclrecordproto.AclInviteType Type aclrecordproto.AclInviteType
Permissions AclPermissions Permissions AclPermissions
encryptedKey []byte
} }
type AclState struct { type AclState struct {
@ -250,69 +251,20 @@ func (st *AclState) RequestIds() []string {
return requests return requests
} }
func (st *AclState) DecryptInvite(invitePk crypto.PrivKey) (keys AclKeys, err error) { func (st *AclState) DecryptInvite(invitePk crypto.PrivKey) (key crypto.SymKey, err error) {
if invitePk == nil { if invitePk == nil {
return AclKeys{}, ErrNoReadKey return nil, ErrNoReadKey
} }
var recId string for _, invite := range st.invites {
for id, invite := range st.invites {
if invite.Key.Equals(invitePk.GetPublic()) { if invite.Key.Equals(invitePk.GetPublic()) {
recId = id res, err := st.unmarshallDecryptReadKey(invite.encryptedKey, invitePk.Decrypt)
}
}
if recId == "" {
return AclKeys{}, ErrNoSuchInvite
}
currentKey := st.CurrentReadKeyId()
currentRec, err := st.list.Get(currentKey)
if err != nil {
return AclKeys{}, err
}
model, ok := currentRec.Model.(*aclrecordproto.AclData)
if !ok {
return AclKeys{}, ErrNoReadKey
}
var value *aclrecordproto.AclReadKeyChange
for _, ch := range model.GetAclContent() {
if ch.GetAccountRemove() != nil {
value = ch.GetReadKeyChange()
break
} else if ch.GetReadKeyChange() != nil {
value = ch.GetReadKeyChange()
break
}
}
if value == nil {
return AclKeys{}, ErrNoReadKey
}
mkPubKey, err := st.keyStore.PubKeyFromProto(value.MetadataPubKey)
if err != nil {
return AclKeys{}, err
}
keys = AclKeys{
MetadataPubKey: mkPubKey,
}
for _, key := range value.InviteKeys {
invKey, err := st.keyStore.PubKeyFromProto(key.Identity)
if err != nil {
return AclKeys{}, err
}
if invitePk.Equals(invKey) {
keys.ReadKey, err = st.unmarshallDecryptReadKey(key.EncryptedReadKey, invitePk.Decrypt)
if err != nil { if err != nil {
return AclKeys{}, err return nil, err
} }
break return res, nil
} }
} }
if keys.ReadKey == nil { return nil, ErrNoSuchInvite
return AclKeys{}, ErrNoReadKey
}
keys.MetadataPrivKey, err = st.unmarshallDecryptPrivKey(value.EncryptedMetadataPrivKey, keys.ReadKey.Decrypt)
if err != nil {
return AclKeys{}, err
}
return keys, nil
} }
func (st *AclState) ApplyRecord(record *AclRecord) (err error) { func (st *AclState) ApplyRecord(record *AclRecord) (err error) {
@ -544,9 +496,10 @@ func (st *AclState) applyInvite(ch *aclrecordproto.AclAccountInvite, record *Acl
return err return err
} }
st.invites[record.Id] = Invite{ st.invites[record.Id] = Invite{
Key: inviteKey, Key: inviteKey,
Type: ch.InviteType, Type: ch.InviteType,
Permissions: AclPermissions(ch.Permissions), Permissions: AclPermissions(ch.Permissions),
encryptedKey: ch.EncryptedReadKey,
} }
return nil return nil
} }
@ -677,7 +630,7 @@ func (st *AclState) applyRequestAccept(ch *aclrecordproto.AclAccountRequestAccep
return st.unpackAllKeys(ch.EncryptedReadKey) return st.unpackAllKeys(ch.EncryptedReadKey)
} }
func (st *AclState) applyInviteJoin(ch *aclrecordproto.AclInviteJoin, record *AclRecord) error { func (st *AclState) applyInviteJoin(ch *aclrecordproto.AclAccountInviteJoin, record *AclRecord) error {
err := st.contentValidator.ValidateInviteJoin(ch, record.Identity) err := st.contentValidator.ValidateInviteJoin(ch, record.Identity)
if err != nil { if err != nil {
return err return err
@ -716,7 +669,10 @@ func (st *AclState) applyInviteJoin(ch *aclrecordproto.AclInviteJoin, record *Ac
}), }),
} }
} }
return st.unpackAllKeys(ch.EncryptedReadKey) if st.pubKey.Equals(identity) {
return st.unpackAllKeys(ch.EncryptedReadKey)
}
return nil
} }
func (st *AclState) unpackAllKeys(rk []byte) error { func (st *AclState) unpackAllKeys(rk []byte) error {
@ -870,6 +826,19 @@ func (st *AclState) applyReadKeyChange(ch *aclrecordproto.AclReadKeyChange, reco
aclKeys.ReadKey = res aclKeys.ReadKey = res
} }
} }
for _, encKey := range ch.InviteKeys {
invKey, err := st.keyStore.PubKeyFromProto(encKey.Identity)
if err != nil {
return err
}
for key, invite := range st.invites {
if invite.Key.Equals(invKey) {
invite.encryptedKey = encKey.EncryptedReadKey
st.invites[key] = invite
break
}
}
}
if aclKeys.ReadKey != nil { if aclKeys.ReadKey != nil {
metadataKey, err := st.unmarshallDecryptPrivKey(ch.EncryptedMetadataPrivKey, aclKeys.ReadKey.Decrypt) metadataKey, err := st.unmarshallDecryptPrivKey(ch.EncryptedMetadataPrivKey, aclKeys.ReadKey.Decrypt)
if err != nil { if err != nil {

15
commonspace/object/acl/list/acltestsuite.go
View file

@ -498,6 +498,21 @@ func (a *AclTestExecutor) Execute(cmd string) (err error) {
if err != nil { if err != nil {
return err return err
} }
case "invite_join":
invite := a.invites[args[0]]
inviteJoin, err := acl.RecordBuilder().BuildInviteJoin(InviteJoinPayload{
InviteKey: invite,
Metadata: []byte(account),
})
if err != nil {
return err
}
err = addRec(WrapAclRecord(inviteJoin))
if err != nil {
return err
}
a.expectedAccounts[account].status = StatusActive
a.expectedAccounts[account].perms = AclPermissions(aclrecordproto.AclUserPermissions_Reader)
case "remove": case "remove":
identities := strings.Split(args[0], ",") identities := strings.Split(args[0], ",")
var pubKeys []crypto.PubKey var pubKeys []crypto.PubKey

3
commonspace/object/acl/list/acltestsuite_test.go
View file

@ -128,6 +128,9 @@ func TestAclExecutor(t *testing.T) {
{"a.changes::guest,none", ErrInsufficientPermissions}, {"a.changes::guest,none", ErrInsufficientPermissions},
// can't change permission of existing user to guest, should be only possible to create it with add // can't change permission of existing user to guest, should be only possible to create it with add
{"a.changes::r,g", ErrInsufficientPermissions}, {"a.changes::r,g", ErrInsufficientPermissions},
{"a.invite_anyone::invAnyoneId", nil},
{"new.invite_join::invAnyoneId", nil},
{"new1.invite_join::invAnyoneId", nil},
} }
for _, cmd := range cmds { for _, cmd := range cmds {
err := a.Execute(cmd.cmd) err := a.Execute(cmd.cmd)

7
commonspace/object/acl/list/validator.go
View file

@ -13,7 +13,7 @@ type ContentValidator interface {
ValidatePermissionChanges(ch *aclrecordproto.AclAccountPermissionChanges, authorIdentity crypto.PubKey) (err error) ValidatePermissionChanges(ch *aclrecordproto.AclAccountPermissionChanges, authorIdentity crypto.PubKey) (err error)
ValidateAccountsAdd(ch *aclrecordproto.AclAccountsAdd, authorIdentity crypto.PubKey) (err error) ValidateAccountsAdd(ch *aclrecordproto.AclAccountsAdd, authorIdentity crypto.PubKey) (err error)
ValidateInvite(ch *aclrecordproto.AclAccountInvite, authorIdentity crypto.PubKey) (err error) ValidateInvite(ch *aclrecordproto.AclAccountInvite, authorIdentity crypto.PubKey) (err error)
ValidateInviteJoin(ch *aclrecordproto.AclInviteJoin, authorIdentity crypto.PubKey) (err error) ValidateInviteJoin(ch *aclrecordproto.AclAccountInviteJoin, authorIdentity crypto.PubKey) (err error)
ValidateInviteRevoke(ch *aclrecordproto.AclAccountInviteRevoke, authorIdentity crypto.PubKey) (err error) ValidateInviteRevoke(ch *aclrecordproto.AclAccountInviteRevoke, authorIdentity crypto.PubKey) (err error)
ValidateRequestJoin(ch *aclrecordproto.AclAccountRequestJoin, authorIdentity crypto.PubKey) (err error) ValidateRequestJoin(ch *aclrecordproto.AclAccountRequestJoin, authorIdentity crypto.PubKey) (err error)
ValidateRequestAccept(ch *aclrecordproto.AclAccountRequestAccept, authorIdentity crypto.PubKey) (err error) ValidateRequestAccept(ch *aclrecordproto.AclAccountRequestAccept, authorIdentity crypto.PubKey) (err error)
@ -69,7 +69,7 @@ func (c *contentValidator) ValidateAccountsAdd(ch *aclrecordproto.AclAccountsAdd
return nil return nil
} }
func (c *contentValidator) ValidateInviteJoin(ch *aclrecordproto.AclInviteJoin, authorIdentity crypto.PubKey) (err error) { func (c *contentValidator) ValidateInviteJoin(ch *aclrecordproto.AclAccountInviteJoin, authorIdentity crypto.PubKey) (err error) {
if !c.aclState.Permissions(authorIdentity).NoPermissions() { if !c.aclState.Permissions(authorIdentity).NoPermissions() {
return ErrInsufficientPermissions return ErrInsufficientPermissions
} }
@ -104,6 +104,9 @@ func (c *contentValidator) ValidateInviteJoin(ch *aclrecordproto.AclInviteJoin,
if len(ch.Metadata) > MaxMetadataLen { if len(ch.Metadata) > MaxMetadataLen {
return ErrMetadataTooLarge return ErrMetadataTooLarge
} }
if ch.EncryptedReadKey == nil {
return ErrIncorrectReadKey
}
return nil return nil
} }