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

Update aclstate

Browse source
This commit is contained in:
Mikhail Rakhmanov 2025-05-09 11:57:33 +02:00
parent bc9193b33a
commit 3ab01e7d96
No known key found for this signature in database
GPG key ID: DED12CFEF5B8396B
4 changed files with 255 additions and 89 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -204,8 +204,9 @@ func (m *AclRoot) GetEncryptedOwnerMetadata() []byte {
// AclAccountInvite contains the public invite key, the private part of which is sent to the user directly
type AclAccountInvite struct {
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"`
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"`
Permissions AclUserPermissions `protobuf:"varint,3,opt,name=permissions,proto3,enum=aclrecord.AclUserPermissions" json:"permissions,omitempty"`
}
func (m *AclAccountInvite) Reset() { *m = AclAccountInvite{} }
@ -263,6 +264,13 @@ func (m *AclAccountInvite) GetInviteType() AclInviteType {
return AclInviteType_RequestToJoin
}
func (m *AclAccountInvite) GetPermissions() AclUserPermissions {
if m != nil {
return m.Permissions
}
return AclUserPermissions_None
}
// 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 {
InviteIdentity []byte `protobuf:"bytes,1,opt,name=inviteIdentity,proto3" json:"inviteIdentity,omitempty"`
@ -344,7 +352,7 @@ func (m *AclAccountRequestJoin) GetMetadata() []byte {
// AclInviteJoin contains the reference to the invite record and the data of the person who wants to join, confirmed by the private invite key
// The person must encrypt the key with its own public key
type AclInviteJoin struct {
InviteIdentity []byte `protobuf:"bytes,1,opt,name=inviteIdentity,proto3" json:"inviteIdentity,omitempty"`
Identity []byte `protobuf:"bytes,1,opt,name=identity,proto3" json:"identity,omitempty"`
InviteRecordId string `protobuf:"bytes,2,opt,name=inviteRecordId,proto3" json:"inviteRecordId,omitempty"`
InviteIdentitySignature []byte `protobuf:"bytes,3,opt,name=inviteIdentitySignature,proto3" json:"inviteIdentitySignature,omitempty"`
// Metadata is encrypted with metadata key of the space
@ -393,9 +401,9 @@ func (m *AclInviteJoin) XXX_DiscardUnknown() {
var xxx_messageInfo_AclInviteJoin proto.InternalMessageInfo
func (m *AclInviteJoin) GetInviteIdentity() []byte {
func (m *AclInviteJoin) GetIdentity() []byte {
if m != nil {
return m.InviteIdentity
return m.Identity
}
return nil
}
@ -1178,6 +1186,7 @@ type AclContentValue struct {
// *AclContentValue_PermissionChanges
// *AclContentValue_AccountsAdd
// *AclContentValue_RequestCancel
// *AclContentValue_InviteJoin
Value isAclContentValueValue `protobuf_oneof:"value"`
}
@ -1264,6 +1273,9 @@ type AclContentValue_AccountsAdd struct {
type AclContentValue_RequestCancel struct {
RequestCancel *AclAccountRequestCancel `protobuf:"bytes,12,opt,name=requestCancel,proto3,oneof" json:"requestCancel,omitempty"`
}
type AclContentValue_InviteJoin struct {
InviteJoin *AclInviteJoin `protobuf:"bytes,13,opt,name=inviteJoin,proto3,oneof" json:"inviteJoin,omitempty"`
}
func (*AclContentValue_Invite) isAclContentValueValue() {}
func (*AclContentValue_InviteRevoke) isAclContentValueValue() {}
@ -1277,6 +1289,7 @@ func (*AclContentValue_AccountRequestRemove) isAclContentValueValue() {}
func (*AclContentValue_PermissionChanges) isAclContentValueValue() {}
func (*AclContentValue_AccountsAdd) isAclContentValueValue() {}
func (*AclContentValue_RequestCancel) isAclContentValueValue() {}
func (*AclContentValue_InviteJoin) isAclContentValueValue() {}
func (m *AclContentValue) GetValue() isAclContentValueValue {
if m != nil {
@ -1369,6 +1382,13 @@ func (m *AclContentValue) GetRequestCancel() *AclAccountRequestCancel {
return nil
}
func (m *AclContentValue) GetInviteJoin() *AclInviteJoin {
if x, ok := m.GetValue().(*AclContentValue_InviteJoin); ok {
return x.InviteJoin
}
return nil
}
// XXX_OneofWrappers is for the internal use of the proto package.
func (*AclContentValue) XXX_OneofWrappers() []interface{} {
return []interface{}{
@ -1384,6 +1404,7 @@ func (*AclContentValue) XXX_OneofWrappers() []interface{} {
(*AclContentValue_PermissionChanges)(nil),
(*AclContentValue_AccountsAdd)(nil),
(*AclContentValue_RequestCancel)(nil),
(*AclContentValue_InviteJoin)(nil),
}
}
@ -1468,76 +1489,78 @@ func init() {
}
var fileDescriptor_c8e9f754f34e929b = []byte{
// 1096 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x57, 0x4f, 0x8f, 0xdb, 0x44,
0x14, 0xb7, 0x93, 0xcd, 0x66, 0xf3, 0xb2, 0x9b, 0x7a, 0xa7, 0xd0, 0xba, 0x5b, 0x88, 0x82, 0x51,
0xab, 0x68, 0x85, 0xba, 0x28, 0x68, 0xab, 0xaa, 0x02, 0xb6, 0x6e, 0xb6, 0x6a, 0xd2, 0xaa, 0x50,
0x4d, 0x4b, 0x8b, 0x90, 0x40, 0xf2, 0xda, 0xa3, 0xe2, 0xe2, 0x8c, 0xc3, 0x78, 0x12, 0x94, 0x6f,
0xc1, 0x8d, 0xef, 0xc0, 0x99, 0x2b, 0x77, 0x0e, 0x1c, 0x7a, 0xe4, 0x08, 0xbb, 0x9f, 0x80, 0x6f,
0x80, 0x66, 0xec, 0xd8, 0x63, 0xc7, 0xc9, 0x66, 0x0f, 0x1c, 0x7a, 0x68, 0xd7, 0xf3, 0xfe, 0xbf,
0xf7, 0x7b, 0x6f, 0xde, 0x04, 0x3e, 0x75, 0xc3, 0xd1, 0x28, 0xa4, 0xd1, 0xd8, 0x71, 0xc9, 0x41,
0x78, 0xf2, 0x9a, 0xb8, 0xfc, 0xc0, 0x71, 0x03, 0xf1, 0x8f, 0x11, 0x37, 0x64, 0xde, 0x98, 0x85,
0x3c, 0x3c, 0x90, 0xff, 0x47, 0x19, 0xf5, 0x96, 0x24, 0xa0, 0x46, 0x4a, 0xb0, 0xfe, 0xad, 0x40,
0xdd, 0x76, 0x03, 0x1c, 0x86, 0x1c, 0xed, 0xc1, 0x96, 0xef, 0x11, 0xca, 0x7d, 0x3e, 0x33, 0xf5,
0x8e, 0xde, 0xdd, 0xc6, 0xe9, 0x19, 0xbd, 0x07, 0x8d, 0x91, 0x13, 0x71, 0xc2, 0x1e, 0x93, 0x99,
0x59, 0x91, 0xcc, 0x8c, 0x80, 0x4c, 0xa8, 0xcb, 0x50, 0x86, 0x9e, 0x59, 0xed, 0xe8, 0xdd, 0x06,
0x9e, 0x1f, 0xd1, 0x3e, 0x18, 0x84, 0xba, 0x6c, 0x36, 0xe6, 0xc4, 0xc3, 0xc4, 0xf1, 0x84, 0xfa,
0x86, 0x54, 0x5f, 0xa0, 0x0b, 0x1f, 0xdc, 0x1f, 0x91, 0x88, 0x3b, 0xa3, 0xb1, 0x59, 0xeb, 0xe8,
0xdd, 0x2a, 0xce, 0x08, 0xe8, 0x23, 0xd8, 0x9d, 0x47, 0xf3, 0xcc, 0x7f, 0x45, 0x1d, 0x3e, 0x61,
0xc4, 0xdc, 0x94, 0xa6, 0x16, 0x19, 0xe8, 0x26, 0xb4, 0x46, 0x84, 0x3b, 0x9e, 0xc3, 0x9d, 0xa7,
0x93, 0x13, 0xe1, 0xb5, 0x2e, 0x45, 0x0b, 0x54, 0x74, 0x17, 0xcc, 0x34, 0x8e, 0x27, 0x73, 0x16,
0xf3, 0xa7, 0x42, 0x63, 0x4b, 0x6a, 0x2c, 0xe5, 0xa3, 0xdb, 0x70, 0x25, 0xe5, 0x7d, 0xf9, 0x13,
0x25, 0x6c, 0x2e, 0x60, 0x36, 0xa4, 0xe6, 0x12, 0xae, 0xf5, 0x1a, 0x0c, 0xdb, 0x0d, 0x6c, 0xd7,
0x0d, 0x27, 0x94, 0x0f, 0xe9, 0xd4, 0xe7, 0x44, 0xe4, 0xee, 0xcb, 0x2f, 0xe1, 0x38, 0x2e, 0x7e,
0x46, 0x40, 0x77, 0x00, 0xe2, 0xc3, 0xf3, 0xd9, 0x98, 0xc8, 0xf2, 0xb7, 0x7a, 0xe6, 0xad, 0x0c,
0x56, 0xdb, 0x0d, 0x86, 0x29, 0x1f, 0x2b, 0xb2, 0xd6, 0xef, 0x3a, 0xbc, 0x9b, 0x39, 0xc3, 0xe4,
0xc7, 0x09, 0x89, 0xf8, 0xa3, 0xd0, 0xa7, 0xa2, 0x42, 0xb1, 0xdc, 0x30, 0x8f, 0x79, 0x81, 0x9a,
0xc9, 0x61, 0xe9, 0x6b, 0xe8, 0x49, 0xff, 0x0d, 0x5c, 0xa0, 0xa2, 0x3b, 0x70, 0x35, 0xaf, 0x99,
0xa1, 0x54, 0x95, 0x86, 0x97, 0xb1, 0x45, 0xdf, 0xcd, 0x51, 0x49, 0x7a, 0x23, 0x3d, 0x5b, 0xff,
0xe8, 0xb0, 0x93, 0x66, 0xf7, 0xf6, 0xc4, 0x5d, 0xda, 0xf7, 0xb5, 0xf2, 0xbe, 0xb7, 0xfe, 0xd4,
0xe1, 0xea, 0x02, 0x46, 0xb6, 0xeb, 0x92, 0xf1, 0xea, 0x99, 0xec, 0xc2, 0x25, 0x16, 0x0b, 0x17,
0x52, 0x2c, 0x92, 0x4b, 0xa3, 0xa9, 0x2e, 0x99, 0xc2, 0x23, 0x68, 0x8e, 0x09, 0x1b, 0xf9, 0x51,
0xe4, 0x87, 0x34, 0x92, 0x89, 0xb5, 0x7a, 0xef, 0xe7, 0x9b, 0xed, 0xab, 0x88, 0xb0, 0xa7, 0x99,
0x10, 0x56, 0x35, 0xac, 0x63, 0x30, 0x17, 0xb2, 0x39, 0x26, 0x6e, 0xe0, 0x53, 0x52, 0x16, 0xb2,
0x5e, 0x1a, 0xb2, 0x75, 0x0f, 0xae, 0x14, 0x87, 0x04, 0x93, 0x69, 0xf8, 0x03, 0x29, 0x01, 0x56,
0x2f, 0x03, 0xd6, 0xfa, 0x16, 0x2e, 0xdb, 0x6e, 0xf0, 0xa0, 0x98, 0xdf, 0xaa, 0x8a, 0x96, 0xd5,
0xa9, 0xb2, 0x04, 0xb5, 0xef, 0xe0, 0x7a, 0x16, 0x60, 0x56, 0x8c, 0xfe, 0xf7, 0x0e, 0x7d, 0x45,
0x22, 0x74, 0x04, 0x75, 0x37, 0xfe, 0x34, 0xf5, 0x4e, 0xb5, 0xdb, 0xec, 0xdd, 0xc8, 0x97, 0x70,
0x89, 0x22, 0x9e, 0x6b, 0x59, 0x03, 0x68, 0x65, 0x62, 0x91, 0xed, 0x79, 0xe8, 0x36, 0x34, 0x1c,
0xcf, 0xf3, 0xb9, 0xc4, 0x25, 0x36, 0x6a, 0x96, 0x1a, 0xb5, 0x3d, 0x0f, 0x67, 0xa2, 0xd6, 0x6f,
0xf1, 0x0c, 0x65, 0xcc, 0x95, 0x35, 0x28, 0xe0, 0x5f, 0xb9, 0x28, 0xfe, 0xb9, 0xb1, 0xa8, 0xae,
0x31, 0x16, 0x4b, 0xd6, 0x81, 0x75, 0x58, 0x32, 0x15, 0x7d, 0x87, 0xba, 0x24, 0x10, 0x2e, 0x58,
0x1e, 0xfc, 0xf4, 0x6c, 0xcd, 0x60, 0x6f, 0x79, 0x79, 0xff, 0xd7, 0xcc, 0xad, 0x5f, 0x2b, 0xf2,
0x66, 0x4f, 0x12, 0x48, 0x3c, 0xde, 0x83, 0xa6, 0x13, 0x07, 0xf3, 0x98, 0xcc, 0xe6, 0xb8, 0xb5,
0xf3, 0x56, 0x8b, 0x4d, 0x8a, 0x55, 0x95, 0x92, 0x5d, 0x56, 0xb9, 0xf0, 0x2e, 0xab, 0x9e, 0xb3,
0xcb, 0x3e, 0x86, 0xcb, 0xd9, 0xb6, 0x0a, 0x0a, 0xd8, 0x94, 0xb1, 0xd0, 0xe7, 0xf3, 0x9d, 0x24,
0xd3, 0xaa, 0xad, 0x95, 0x96, 0xa2, 0x61, 0x4d, 0xd4, 0x2d, 0x88, 0xc9, 0x28, 0x9c, 0x12, 0xd4,
0x06, 0x48, 0xd0, 0xf0, 0x93, 0xb9, 0xd9, 0xc6, 0x0a, 0x05, 0xd9, 0xb0, 0xc3, 0xd4, 0xe2, 0xca,
0x42, 0x34, 0x7b, 0xd7, 0xf3, 0x6e, 0x73, 0xf5, 0xc7, 0x79, 0x0d, 0xeb, 0x5a, 0x49, 0x57, 0xc5,
0xde, 0xad, 0x5f, 0xea, 0x70, 0xc9, 0x76, 0x83, 0x7e, 0x48, 0x39, 0xa1, 0xfc, 0x85, 0x13, 0x4c,
0x08, 0x3a, 0x84, 0xcd, 0x38, 0x66, 0xd9, 0x2d, 0x0b, 0xae, 0x72, 0xf7, 0xd3, 0x40, 0xc3, 0x89,
0x30, 0x7a, 0x08, 0xdb, 0xbe, 0x72, 0x67, 0x25, 0x71, 0x7e, 0xb0, 0x42, 0x39, 0x16, 0x1c, 0x68,
0x38, 0xa7, 0x88, 0x8e, 0xa1, 0xc9, 0xb2, 0xa5, 0x2d, 0x61, 0x6c, 0xf6, 0x3a, 0xa5, 0x76, 0x94,
0xe5, 0x3e, 0xd0, 0xb0, 0xaa, 0x86, 0x1e, 0x89, 0xba, 0x29, 0x6b, 0x45, 0xe2, 0xda, 0xec, 0x59,
0xab, 0xec, 0xc4, 0x92, 0x03, 0x0d, 0xe7, 0x55, 0xd1, 0x33, 0x30, 0xc6, 0x85, 0xa9, 0x92, 0x9b,
0x6d, 0xdd, 0x1b, 0x6e, 0xa0, 0xe1, 0x05, 0x03, 0xa8, 0x0f, 0x3b, 0x8e, 0xda, 0x09, 0xf2, 0x61,
0xb7, 0xac, 0xda, 0xb1, 0x88, 0x88, 0x2c, 0xa7, 0x23, 0x8c, 0xe4, 0xbb, 0xa3, 0x7e, 0x6e, 0x77,
0xc4, 0xe9, 0xa9, 0xe3, 0xfa, 0x04, 0x5a, 0x2c, 0xb7, 0xb3, 0xe4, 0x33, 0xb0, 0xd9, 0xfb, 0x70,
0x55, 0xad, 0x12, 0xd1, 0x81, 0x86, 0x0b, 0xca, 0xe8, 0x6b, 0x78, 0xc7, 0x29, 0xe9, 0x35, 0xf9,
0x42, 0x3c, 0x07, 0x80, 0x34, 0xcd, 0x52, 0x0b, 0xe8, 0x05, 0xec, 0x16, 0xcb, 0x18, 0x99, 0x20,
0xcd, 0xde, 0x5c, 0x0b, 0x88, 0x68, 0xa0, 0xe1, 0x45, 0x13, 0xe8, 0xb3, 0xf4, 0xbe, 0x12, 0x4b,
0xc7, 0x6c, 0x4a, 0x8b, 0xd7, 0x4a, 0x2d, 0x0a, 0x01, 0xd1, 0x6a, 0x8a, 0xbc, 0xd2, 0x6a, 0xf1,
0x5d, 0x6d, 0x6e, 0x9f, 0x9f, 0x69, 0x2c, 0xa9, 0xb4, 0x5a, 0x4c, 0xb8, 0x5f, 0x87, 0xda, 0x54,
0x4c, 0xa1, 0xf5, 0x40, 0xfe, 0x48, 0x39, 0x16, 0x1b, 0xe4, 0x2e, 0x80, 0x93, 0xce, 0x68, 0x72,
0x9b, 0xee, 0xe5, 0x8d, 0xab, 0x03, 0x8c, 0x15, 0xe9, 0xfd, 0x43, 0xe5, 0x2d, 0x29, 0x5e, 0xc7,
0x68, 0x17, 0x76, 0x92, 0x10, 0x9e, 0x87, 0x62, 0x50, 0x0c, 0x4d, 0x90, 0x6c, 0x3a, 0x0b, 0x29,
0xe9, 0x3b, 0x54, 0x92, 0xf4, 0xfd, 0x97, 0x80, 0x16, 0x6f, 0x7e, 0xb4, 0x05, 0x1b, 0x5f, 0x84,
0x94, 0x18, 0x1a, 0x6a, 0x40, 0x4d, 0x3e, 0xf0, 0x0d, 0x5d, 0x7c, 0xda, 0xde, 0xc8, 0xa7, 0x46,
0x05, 0x01, 0x6c, 0xbe, 0x64, 0x3e, 0x27, 0xcc, 0xa8, 0x8a, 0x6f, 0xd1, 0x76, 0x84, 0x19, 0x1b,
0x42, 0xe4, 0xa1, 0xf0, 0x68, 0xd4, 0xee, 0x1f, 0xfd, 0x71, 0xda, 0xd6, 0xdf, 0x9c, 0xb6, 0xf5,
0xbf, 0x4f, 0xdb, 0xfa, 0xcf, 0x67, 0x6d, 0xed, 0xcd, 0x59, 0x5b, 0xfb, 0xeb, 0xac, 0xad, 0x7d,
0x73, 0x63, 0xad, 0xdf, 0x77, 0x27, 0x9b, 0xf2, 0xcf, 0x27, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff,
0x02, 0xe7, 0xf9, 0x94, 0x0f, 0x0e, 0x00, 0x00,
// 1122 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x57, 0xdf, 0x6e, 0xdb, 0x54,
0x18, 0xb7, 0x93, 0xa6, 0x69, 0xbe, 0x34, 0x99, 0x7b, 0x06, 0x9b, 0xd7, 0x41, 0x14, 0x8c, 0x36,
0x45, 0x15, 0x5a, 0x51, 0x50, 0xa7, 0xa9, 0x02, 0x3a, 0x2f, 0x9d, 0x96, 0x6c, 0x1a, 0x4c, 0x67,
0x63, 0x43, 0x48, 0x20, 0xb9, 0xf6, 0xd1, 0x30, 0x38, 0xc7, 0xc1, 0x3e, 0x09, 0xca, 0x5b, 0xf0,
0x1c, 0x70, 0xcb, 0x2d, 0xf7, 0x5c, 0x70, 0x51, 0x09, 0x21, 0x71, 0x89, 0xda, 0x27, 0xe0, 0x0d,
0xd0, 0x39, 0x76, 0xec, 0x63, 0xc7, 0x4e, 0xd3, 0x0b, 0xb4, 0x8b, 0x36, 0xf6, 0xf7, 0xff, 0xcf,
0xef, 0x3b, 0xdf, 0x31, 0x7c, 0x6c, 0xfb, 0xe3, 0xb1, 0x4f, 0xc3, 0x89, 0x65, 0x93, 0x7d, 0xff,
0xe4, 0x3b, 0x62, 0xb3, 0x7d, 0xcb, 0xf6, 0xf8, 0x5f, 0x40, 0x6c, 0x3f, 0x70, 0x26, 0x81, 0xcf,
0xfc, 0x7d, 0xf1, 0x3f, 0x4c, 0xa9, 0x77, 0x04, 0x01, 0x35, 0x12, 0x82, 0xf1, 0x6f, 0x05, 0xea,
0xa6, 0xed, 0x61, 0xdf, 0x67, 0x68, 0x17, 0xb6, 0x5c, 0x87, 0x50, 0xe6, 0xb2, 0xb9, 0xae, 0x76,
0xd5, 0xde, 0x36, 0x4e, 0xde, 0xd1, 0x3b, 0xd0, 0x18, 0x5b, 0x21, 0x23, 0xc1, 0x13, 0x32, 0xd7,
0x2b, 0x82, 0x99, 0x12, 0x90, 0x0e, 0x75, 0x11, 0xca, 0xc8, 0xd1, 0xab, 0x5d, 0xb5, 0xd7, 0xc0,
0x8b, 0x57, 0xb4, 0x07, 0x1a, 0xa1, 0x76, 0x30, 0x9f, 0x30, 0xe2, 0x60, 0x62, 0x39, 0x5c, 0x7d,
0x43, 0xa8, 0x2f, 0xd1, 0xb9, 0x0f, 0xe6, 0x8e, 0x49, 0xc8, 0xac, 0xf1, 0x44, 0xaf, 0x75, 0xd5,
0x5e, 0x15, 0xa7, 0x04, 0xf4, 0x01, 0xec, 0x2c, 0xa2, 0x79, 0xee, 0xbe, 0xa6, 0x16, 0x9b, 0x06,
0x44, 0xdf, 0x14, 0xa6, 0x96, 0x19, 0xe8, 0x36, 0xb4, 0xc7, 0x84, 0x59, 0x8e, 0xc5, 0xac, 0x67,
0xd3, 0x13, 0xee, 0xb5, 0x2e, 0x44, 0x73, 0x54, 0x74, 0x08, 0x7a, 0x12, 0xc7, 0xd3, 0x05, 0x2b,
0x70, 0x67, 0x5c, 0x63, 0x4b, 0x68, 0x94, 0xf2, 0xd1, 0x5d, 0xb8, 0x96, 0xf0, 0x3e, 0xff, 0x91,
0x92, 0x60, 0x21, 0xa0, 0x37, 0x84, 0x66, 0x09, 0xd7, 0xf8, 0x45, 0x05, 0xcd, 0xb4, 0x3d, 0xd3,
0xb6, 0xfd, 0x29, 0x65, 0x23, 0x3a, 0x73, 0x19, 0xe1, 0xc9, 0xbb, 0xe2, 0x89, 0x7b, 0x8e, 0xaa,
0x9f, 0x12, 0xd0, 0x3d, 0x80, 0xe8, 0xe5, 0xc5, 0x7c, 0x42, 0x44, 0xfd, 0xdb, 0x7d, 0xfd, 0x4e,
0xda, 0x57, 0xd3, 0xf6, 0x46, 0x09, 0x1f, 0x4b, 0xb2, 0xe8, 0x08, 0x9a, 0x13, 0x12, 0x8c, 0xdd,
0x30, 0x74, 0x7d, 0x1a, 0x8a, 0xf6, 0xb4, 0xfb, 0xef, 0x66, 0x55, 0xbf, 0x08, 0x49, 0xf0, 0x2c,
0x15, 0xc2, 0xb2, 0x86, 0xf1, 0x9b, 0x0a, 0x6f, 0xa7, 0xd1, 0x62, 0xf2, 0xc3, 0x94, 0x84, 0xec,
0xb1, 0xef, 0x52, 0x5e, 0xe3, 0xc8, 0xd1, 0x28, 0x8b, 0x9a, 0x1c, 0x35, 0x95, 0xc3, 0xc2, 0xe3,
0xc8, 0x11, 0x09, 0x34, 0x70, 0x8e, 0x8a, 0xee, 0xc1, 0xf5, 0xac, 0x66, 0xda, 0xe7, 0xaa, 0x30,
0x5c, 0xc6, 0xe6, 0xc8, 0x5d, 0xf4, 0x35, 0x46, 0x57, 0xf2, 0x6e, 0xfc, 0xa5, 0x42, 0x2b, 0x29,
0x8f, 0x88, 0x7b, 0x15, 0xce, 0xdf, 0x68, 0xac, 0x85, 0xd3, 0x52, 0x2b, 0x9e, 0x16, 0xe3, 0x0f,
0x15, 0xae, 0x2f, 0xf5, 0xc5, 0xb4, 0x6d, 0x32, 0x59, 0x3d, 0xc9, 0x3d, 0xb8, 0x12, 0x44, 0xc2,
0xb9, 0x14, 0xf3, 0xe4, 0xc2, 0x68, 0xaa, 0x25, 0xb3, 0x9b, 0x83, 0xd9, 0xc6, 0xa5, 0x61, 0x76,
0x0c, 0xfa, 0x52, 0x36, 0xc7, 0xc4, 0xf6, 0x5c, 0x4a, 0x8a, 0x42, 0x56, 0x0b, 0x43, 0x36, 0xee,
0xc3, 0xb5, 0xfc, 0x64, 0x61, 0x32, 0xf3, 0xbf, 0x27, 0x05, 0x8d, 0x55, 0x8b, 0x1a, 0x6b, 0x7c,
0x0d, 0x57, 0x4d, 0xdb, 0x7b, 0x98, 0xcf, 0x6f, 0x55, 0x45, 0x8b, 0xea, 0x54, 0x29, 0xe9, 0xda,
0x37, 0x70, 0x33, 0x0d, 0x30, 0x2d, 0xc6, 0xe0, 0x5b, 0x8b, 0xbe, 0x26, 0x21, 0x3a, 0x82, 0xba,
0x1d, 0x3d, 0xea, 0x6a, 0xb7, 0xda, 0x6b, 0xf6, 0x6f, 0x65, 0x4b, 0x58, 0xa2, 0x88, 0x17, 0x5a,
0xc6, 0x10, 0xda, 0xa9, 0x58, 0x68, 0x3a, 0x0e, 0xba, 0x0b, 0x0d, 0xcb, 0x71, 0x5c, 0x26, 0xfa,
0x12, 0x19, 0xd5, 0x0b, 0x8d, 0x9a, 0x8e, 0x83, 0x53, 0x51, 0xe3, 0xd7, 0x68, 0x6e, 0x52, 0xe6,
0xca, 0x1a, 0xe4, 0xfa, 0x5f, 0xb9, 0x6c, 0xff, 0x33, 0x63, 0x51, 0x5d, 0x63, 0x2c, 0x4a, 0x96,
0x88, 0x71, 0x50, 0x30, 0x15, 0x03, 0x8b, 0xda, 0xc4, 0xe3, 0x2e, 0x82, 0x6c, 0xf3, 0x93, 0x77,
0x63, 0x0e, 0xbb, 0xe5, 0xe5, 0xfd, 0x5f, 0x33, 0x37, 0x7e, 0xae, 0x88, 0x75, 0x10, 0x27, 0x10,
0x7b, 0xbc, 0x0f, 0x4d, 0x2b, 0x0a, 0xe6, 0x09, 0x99, 0x2f, 0xfa, 0xd6, 0xc9, 0x5a, 0xcd, 0x83,
0x14, 0xcb, 0x2a, 0x05, 0x1b, 0xb0, 0x72, 0xe9, 0x0d, 0x58, 0xbd, 0x60, 0x03, 0x7e, 0x08, 0x57,
0xd3, 0x1d, 0xe7, 0xe5, 0x7a, 0x53, 0xc4, 0x42, 0x9f, 0x2e, 0x16, 0x99, 0x48, 0xab, 0xb6, 0x56,
0x5a, 0x92, 0x86, 0x31, 0x95, 0x57, 0x27, 0x26, 0x63, 0x7f, 0x46, 0x50, 0x07, 0x20, 0xee, 0x86,
0x1b, 0xcf, 0xcd, 0x36, 0x96, 0x28, 0xc8, 0x84, 0x56, 0x20, 0x17, 0x57, 0x14, 0xa2, 0xd9, 0xbf,
0x99, 0x75, 0x9b, 0xa9, 0x3f, 0xce, 0x6a, 0x18, 0x37, 0x0a, 0x50, 0x15, 0x79, 0x37, 0xfe, 0xac,
0xc3, 0x15, 0xd3, 0xf6, 0x06, 0x3e, 0x65, 0x84, 0xb2, 0x97, 0x96, 0x37, 0x25, 0xe8, 0x00, 0x36,
0xa3, 0x98, 0x05, 0x5a, 0x96, 0x5c, 0x65, 0xce, 0xa7, 0xa1, 0x82, 0x63, 0x61, 0xf4, 0x08, 0xb6,
0x5d, 0xe9, 0xcc, 0x8a, 0xe3, 0x7c, 0x6f, 0x85, 0x72, 0x24, 0x38, 0x54, 0x70, 0x46, 0x11, 0x1d,
0x43, 0x33, 0x48, 0x17, 0xb5, 0x68, 0x63, 0xb3, 0xdf, 0x2d, 0xb4, 0x23, 0x2d, 0xf4, 0xa1, 0x82,
0x65, 0x35, 0xf4, 0x98, 0xd7, 0x4d, 0x5a, 0x2b, 0xa2, 0xaf, 0xcd, 0xbe, 0xb1, 0xca, 0x4e, 0x24,
0x39, 0x54, 0x70, 0x56, 0x15, 0x3d, 0x07, 0x6d, 0x92, 0x9b, 0x2a, 0xb1, 0xd9, 0xd6, 0x3d, 0xe1,
0x86, 0x0a, 0x5e, 0x32, 0x80, 0x06, 0xd0, 0xb2, 0x64, 0x24, 0x88, 0xeb, 0x60, 0x59, 0xb5, 0x23,
0x11, 0x1e, 0x59, 0x46, 0x87, 0x1b, 0xc9, 0xa2, 0xa3, 0x7e, 0x21, 0x3a, 0xa2, 0xf4, 0xe4, 0x71,
0x7d, 0x0a, 0xed, 0x20, 0xb3, 0xb3, 0xc4, 0xe5, 0xb1, 0xd9, 0x7f, 0x7f, 0x55, 0xad, 0x62, 0xd1,
0xa1, 0x82, 0x73, 0xca, 0xe8, 0x4b, 0x78, 0xcb, 0x2a, 0xc0, 0x9a, 0xb8, 0x57, 0x5e, 0xd0, 0x80,
0x24, 0xcd, 0x42, 0x0b, 0xe8, 0x25, 0xec, 0xe4, 0xcb, 0x18, 0xea, 0x20, 0xcc, 0xde, 0x5e, 0xab,
0x11, 0xe1, 0x50, 0xc1, 0xcb, 0x26, 0xd0, 0x27, 0xc9, 0x79, 0xc5, 0x97, 0x8e, 0xde, 0x14, 0x16,
0x6f, 0x14, 0x5a, 0xe4, 0x02, 0x1c, 0x6a, 0x92, 0xbc, 0x04, 0xb5, 0xe8, 0xac, 0xd6, 0xb7, 0x2f,
0xce, 0x34, 0x92, 0x94, 0xa0, 0x16, 0x1f, 0xf3, 0x87, 0x8b, 0x23, 0x46, 0x60, 0xbf, 0x25, 0x0c,
0x15, 0xde, 0x95, 0x63, 0xcc, 0x4b, 0xd2, 0x0f, 0xea, 0x50, 0x9b, 0xf1, 0x09, 0x36, 0x1e, 0x8a,
0xcf, 0xa2, 0x63, 0xbe, 0x7d, 0x0e, 0x01, 0xac, 0x64, 0xbe, 0xe3, 0x93, 0x78, 0x37, 0x6b, 0x4f,
0x1e, 0x7e, 0x2c, 0x49, 0xef, 0x1d, 0x48, 0x77, 0x4f, 0x71, 0x1d, 0xdf, 0x81, 0x56, 0x1c, 0xfe,
0x0b, 0x9f, 0x7b, 0xd4, 0x14, 0x4e, 0x32, 0xe9, 0xdc, 0xa7, 0x64, 0x60, 0x51, 0x41, 0x52, 0xf7,
0x5e, 0x01, 0x5a, 0xde, 0x1a, 0x68, 0x0b, 0x36, 0x3e, 0xf3, 0x29, 0xd1, 0x14, 0xd4, 0x80, 0x9a,
0xf8, 0xa4, 0xd0, 0x54, 0xfe, 0x68, 0x3a, 0x63, 0x97, 0x6a, 0x15, 0x04, 0xb0, 0xf9, 0x2a, 0x70,
0x19, 0x09, 0xb4, 0x2a, 0x7f, 0xe6, 0x90, 0x25, 0x81, 0xb6, 0xc1, 0x45, 0x1e, 0x71, 0x8f, 0x5a,
0xed, 0xc1, 0xd1, 0xef, 0x67, 0x1d, 0xf5, 0xf4, 0xac, 0xa3, 0xfe, 0x73, 0xd6, 0x51, 0x7f, 0x3a,
0xef, 0x28, 0xa7, 0xe7, 0x1d, 0xe5, 0xef, 0xf3, 0x8e, 0xf2, 0xd5, 0xad, 0xb5, 0xbe, 0x28, 0x4f,
0x36, 0xc5, 0xcf, 0x47, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff, 0x48, 0xe7, 0x67, 0x87, 0x81, 0x0e,
0x00, 0x00,
}
func (m *AclRoot) Marshal() (dAtA []byte, err error) {
@ -1644,6 +1667,11 @@ func (m *AclAccountInvite) MarshalToSizedBuffer(dAtA []byte) (int, error) {
_ = i
var l int
_ = l
if m.Permissions != 0 {
i = encodeVarintAclrecord(dAtA, i, uint64(m.Permissions))
i--
dAtA[i] = 0x18
}
if m.InviteType != 0 {
i = encodeVarintAclrecord(dAtA, i, uint64(m.InviteType))
i--
@ -1758,10 +1786,10 @@ func (m *AclInviteJoin) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i--
dAtA[i] = 0x12
}
if len(m.InviteIdentity) > 0 {
i -= len(m.InviteIdentity)
copy(dAtA[i:], m.InviteIdentity)
i = encodeVarintAclrecord(dAtA, i, uint64(len(m.InviteIdentity)))
if len(m.Identity) > 0 {
i -= len(m.Identity)
copy(dAtA[i:], m.Identity)
i = encodeVarintAclrecord(dAtA, i, uint64(len(m.Identity)))
i--
dAtA[i] = 0xa
}
@ -2525,6 +2553,27 @@ func (m *AclContentValue_RequestCancel) MarshalToSizedBuffer(dAtA []byte) (int,
}
return len(dAtA) - i, nil
}
func (m *AclContentValue_InviteJoin) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *AclContentValue_InviteJoin) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
if m.InviteJoin != nil {
{
size, err := m.InviteJoin.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintAclrecord(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x6a
}
return len(dAtA) - i, nil
}
func (m *AclData) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
@ -2630,6 +2679,9 @@ func (m *AclAccountInvite) Size() (n int) {
if m.InviteType != 0 {
n += 1 + sovAclrecord(uint64(m.InviteType))
}
if m.Permissions != 0 {
n += 1 + sovAclrecord(uint64(m.Permissions))
}
return n
}
@ -2664,7 +2716,7 @@ func (m *AclInviteJoin) Size() (n int) {
}
var l int
_ = l
l = len(m.InviteIdentity)
l = len(m.Identity)
if l > 0 {
n += 1 + l + sovAclrecord(uint64(l))
}
@ -3054,6 +3106,18 @@ func (m *AclContentValue_RequestCancel) Size() (n int) {
}
return n
}
func (m *AclContentValue_InviteJoin) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.InviteJoin != nil {
l = m.InviteJoin.Size()
n += 1 + l + sovAclrecord(uint64(l))
}
return n
}
func (m *AclData) Size() (n int) {
if m == nil {
return 0
@ -3496,6 +3560,25 @@ func (m *AclAccountInvite) Unmarshal(dAtA []byte) error {
break
}
}
case 3:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Permissions", wireType)
}
m.Permissions = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowAclrecord
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Permissions |= AclUserPermissions(b&0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipAclrecord(dAtA[iNdEx:])
@ -3732,7 +3815,7 @@ func (m *AclInviteJoin) Unmarshal(dAtA []byte) error {
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field InviteIdentity", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field Identity", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
@ -3759,9 +3842,9 @@ func (m *AclInviteJoin) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.InviteIdentity = append(m.InviteIdentity[:0], dAtA[iNdEx:postIndex]...)
if m.InviteIdentity == nil {
m.InviteIdentity = []byte{}
m.Identity = append(m.Identity[:0], dAtA[iNdEx:postIndex]...)
if m.Identity == nil {
m.Identity = []byte{}
}
iNdEx = postIndex
case 2:
@ -5731,6 +5814,41 @@ func (m *AclContentValue) Unmarshal(dAtA []byte) error {
}
m.Value = &AclContentValue_RequestCancel{v}
iNdEx = postIndex
case 13:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field InviteJoin", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowAclrecord
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthAclrecord
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthAclrecord
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
v := &AclInviteJoin{}
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
m.Value = &AclContentValue_InviteJoin{v}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipAclrecord(dAtA[iNdEx:])

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

@ -19,6 +19,7 @@ message AclRoot {
message AclAccountInvite {
bytes inviteKey = 1;
AclInviteType inviteType = 2;
AclUserPermissions permissions = 3;
}
enum AclInviteType {
@ -38,7 +39,7 @@ message AclAccountRequestJoin {
// AclInviteJoin contains the reference to the invite record and the data of the person who wants to join, confirmed by the private invite key
// The person must encrypt the key with its own public key
message AclInviteJoin {
bytes inviteIdentity = 1;
bytes identity = 1;
string inviteRecordId = 2;
bytes inviteIdentitySignature = 3;
// Metadata is encrypted with metadata key of the space
@ -136,6 +137,7 @@ message AclContentValue {
AclAccountPermissionChanges permissionChanges = 10;
AclAccountsAdd accountsAdd = 11;
AclAccountRequestCancel requestCancel = 12;
AclInviteJoin inviteJoin = 13;
}
}

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

@ -52,8 +52,9 @@ type AclKeys struct {
}
type Invite struct {
Key crypto.PubKey
Type aclrecordproto.AclInviteType
Key crypto.PubKey
Type aclrecordproto.AclInviteType
Permissions AclPermissions
}
type AclState struct {
@ -465,6 +466,8 @@ func (st *AclState) Copy() *AclState {
func (st *AclState) applyChangeContent(ch *aclrecordproto.AclContentValue, record *AclRecord) error {
switch {
case ch.GetInviteJoin() != nil:
return st.applyInviteJoin(ch.GetInviteJoin(), record)
case ch.GetPermissionChange() != nil:
return st.applyPermissionChange(ch.GetPermissionChange(), record)
case ch.GetInvite() != nil:
@ -535,8 +538,9 @@ func (st *AclState) applyInvite(ch *aclrecordproto.AclAccountInvite, record *Acl
return err
}
st.invites[record.Id] = Invite{
Key: inviteKey,
Type: ch.InviteType,
Key: inviteKey,
Type: ch.InviteType,
Permissions: AclPermissions(ch.Permissions),
}
return nil
}
@ -667,6 +671,44 @@ func (st *AclState) applyRequestAccept(ch *aclrecordproto.AclAccountRequestAccep
return st.unpackAllKeys(ch.EncryptedReadKey)
}
func (st *AclState) applyInviteJoin(ch *aclrecordproto.AclInviteJoin, record *AclRecord) error {
identity, err := st.keyStore.PubKeyFromProto(ch.Identity)
if err != nil {
return err
}
inviteRecord, _ := st.invites[ch.InviteRecordId]
pKeyString := mapKeyFromPubKey(identity)
state, exists := st.accountStates[pKeyString]
if !exists {
st.accountStates[pKeyString] = AccountState{
PubKey: identity,
Permissions: inviteRecord.Permissions,
RequestMetadata: ch.Metadata,
KeyRecordId: st.CurrentReadKeyId(),
Status: StatusActive,
PermissionChanges: []PermissionChange{
{
Permission: inviteRecord.Permissions,
RecordId: record.Id,
},
},
}
} else {
st.accountStates[pKeyString] = AccountState{
PubKey: identity,
Permissions: inviteRecord.Permissions,
RequestMetadata: ch.Metadata,
KeyRecordId: st.CurrentReadKeyId(),
Status: StatusActive,
PermissionChanges: append(state.PermissionChanges, PermissionChange{
Permission: inviteRecord.Permissions,
RecordId: record.Id,
}),
}
}
return st.unpackAllKeys(ch.EncryptedReadKey)
}
func (st *AclState) unpackAllKeys(rk []byte) error {
iterReadKey, err := st.unmarshallDecryptReadKey(rk, st.key.Decrypt)
if err != nil {

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

@ -152,6 +152,10 @@ func (c *contentValidator) ValidateInvite(ch *aclrecordproto.AclAccountInvite, a
if !c.aclState.Permissions(authorIdentity).CanManageAccounts() {
return ErrInsufficientPermissions
}
if ch.InviteType == aclrecordproto.AclInviteType_AnyoneCanJoin &&
(AclPermissions(ch.Permissions).IsOwner() || AclPermissions(ch.Permissions).NoPermissions()) {
return ErrInsufficientPermissions
}
_, err = c.keyStore.PubKeyFromProto(ch.InviteKey)
return
}