fix(security): fence corporate orchestration and human key administration
This commit is contained in:
1 parent
d80845af0d
commit
435a75a442
24 files changed
+1366
-54
No files matched your search
@@ -143,6 +143,54 @@ export function canonical(value: any): string {
|
||||
);
|
||||
return JSON.stringify(value);
|
||||
}
|
||||
/** Public projection must also cover nested evidence and child records. */
|
||||
export function publicData(value: any): any {
|
||||
if (value instanceof Date) return value;
|
||||
if (Array.isArray(value)) return value.map(publicData);
|
||||
if (value && typeof value === 'object')
|
||||
return Object.fromEntries(
|
||||
Object.entries(value)
|
||||
.filter(([key]) => key !== 'claimToken')
|
||||
.map(([key, item]) => [key, publicData(item)]),
|
||||
);
|
||||
return value;
|
||||
}
|
||||
export function httpsUrl(value: unknown): string {
|
||||
const raw = text(value, 2000);
|
||||
try {
|
||||
if (!/^https:\/\/[a-z0-9]/i.test(raw) || /[\s\\]/.test(raw)) throw new Error();
|
||||
const u = new URL(raw);
|
||||
const host = u.hostname.toLowerCase();
|
||||
if (
|
||||
u.protocol !== 'https:' ||
|
||||
u.username ||
|
||||
u.password ||
|
||||
!/^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,63}$/.test(host) ||
|
||||
host === 'localhost' ||
|
||||
host.endsWith('.localhost') ||
|
||||
/(^|\.)example\.(com|org|net)$/.test(host)
|
||||
)
|
||||
throw new Error();
|
||||
return raw;
|
||||
} catch {
|
||||
throw new BadRequestException('Valid HTTPS host URL required');
|
||||
}
|
||||
}
|
||||
export function timestamp(value: unknown, message: string): Date {
|
||||
if (
|
||||
typeof value !== 'string' ||
|
||||
!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z$/.test(value)
|
||||
)
|
||||
throw new BadRequestException(message);
|
||||
const date = new Date(value);
|
||||
if (
|
||||
!Number.isFinite(date.getTime()) ||
|
||||
date.getTime() > Date.now() ||
|
||||
date.toISOString().slice(0, 19) !== value.slice(0, 19)
|
||||
)
|
||||
throw new BadRequestException(message);
|
||||
return date;
|
||||
}
|
||||
export function evidenceInput(input: unknown) {
|
||||
const b = object(input, [
|
||||
'claimToken',
|
||||
@@ -153,16 +201,14 @@ export function evidenceInput(input: unknown) {
|
||||
'result',
|
||||
]);
|
||||
const uri = text(b.artifactUri, 2000);
|
||||
if (
|
||||
!/^(https:\/\/|urn:sha256:)/.test(uri) ||
|
||||
/example\.(com|org)|localhost|127\.0\.0\.1/.test(uri)
|
||||
)
|
||||
throw new BadRequestException(
|
||||
'Evidence locator must be a real HTTPS artifact or content digest',
|
||||
);
|
||||
|
||||
const sha = text(b.sha256, 64);
|
||||
if (!/^[a-f0-9]{64}$/.test(sha))
|
||||
throw new BadRequestException('Invalid digest');
|
||||
if (uri.startsWith('urn:')) {
|
||||
if (uri !== 'urn:sha256:' + sha)
|
||||
throw new BadRequestException('Digest locator mismatch');
|
||||
} else httpsUrl(uri);
|
||||
return {
|
||||
claimToken: uuid(b.claimToken),
|
||||
artifactUri: uri,
|
||||
|
||||
@@ -80,6 +80,264 @@ integration('corporate API / disposable PostgreSQL', () => {
|
||||
'TRUNCATE corporate_operations, corporate_reports, corporate_effects, corporate_reviews, corporate_evidence, corporate_events, corporate_tasks, corporate_goals, corporate_roadmaps, corporate_sources, corporate_research CASCADE',
|
||||
);
|
||||
});
|
||||
it('rejects children after a parent claim commits while child creation waits on its row lock', async () => {
|
||||
const parent = (await post('tasks', input).expect(201)).body;
|
||||
let release!: () => void, locked!: () => void;
|
||||
const ready = new Promise<void>((r) => (locked = r));
|
||||
const hold = new Promise<void>((r) => (release = r));
|
||||
const claiming = db.$transaction(async (tx) => {
|
||||
await tx.$queryRaw`SELECT id FROM corporate_tasks WHERE id=${parent.id}::uuid FOR UPDATE`;
|
||||
await tx.corporateTask.update({
|
||||
where: { id: parent.id },
|
||||
data: {
|
||||
status: 'IN_PROGRESS',
|
||||
claimToken: key(),
|
||||
assignedAgent: 'executor',
|
||||
leasedUntil: new Date(Date.now() + 60000),
|
||||
},
|
||||
});
|
||||
locked();
|
||||
await hold;
|
||||
});
|
||||
await ready;
|
||||
const pending = post('tasks', { ...input, parentId: parent.id }).then(
|
||||
(r) => r,
|
||||
);
|
||||
try {
|
||||
// Observe actual competing PostgreSQL lock wait, not a timing-only race.
|
||||
let waiting = false;
|
||||
for (let i = 0; i < 100; i++) {
|
||||
const rows = await db.$queryRaw<
|
||||
any[]
|
||||
>`SELECT pid FROM pg_stat_activity WHERE datname=current_database() AND wait_event_type='Lock' AND query LIKE '%corporate_tasks%'`;
|
||||
if (rows.length) {
|
||||
waiting = true;
|
||||
break;
|
||||
}
|
||||
await new Promise((r) => setTimeout(r, 10));
|
||||
}
|
||||
expect(waiting).toBe(true);
|
||||
} finally {
|
||||
release();
|
||||
await claiming;
|
||||
}
|
||||
expect((await pending).status).toBe(409);
|
||||
expect(
|
||||
await db.corporateTask.count({ where: { parentId: parent.id } }),
|
||||
).toBe(0);
|
||||
});
|
||||
it('accepts children on TODO and BLOCKED, which prevents parent claiming', async () => {
|
||||
for (const status of ['TODO', 'BLOCKED'] as const) {
|
||||
const parent = (await post('tasks', input).expect(201)).body;
|
||||
await db.corporateTask.update({
|
||||
where: { id: parent.id },
|
||||
data: { status },
|
||||
});
|
||||
const child = (
|
||||
await post('tasks', { ...input, parentId: parent.id }).expect(201)
|
||||
).body;
|
||||
expect((await post('claims', {}).expect(201)).body.task.id).toBe(
|
||||
child.id,
|
||||
);
|
||||
}
|
||||
});
|
||||
it('rejects malformed artifact locators and mismatched digest URNs before persistence', async () => {
|
||||
const task = (await post('tasks', input).expect(201)).body;
|
||||
const claim = (await post('claims', {}).expect(201)).body.task;
|
||||
const body = {
|
||||
claimToken: claim.claimToken,
|
||||
artifactUri: '',
|
||||
sha256: 'a'.repeat(64),
|
||||
summary: 'receipt',
|
||||
tool: 'jest',
|
||||
result: 'passed',
|
||||
};
|
||||
for (const artifactUri of [
|
||||
'https://',
|
||||
'https://?x',
|
||||
'https:///pubmed.ncbi.nlm.nih.gov/x',
|
||||
'https://pubmed.ncbi.nlm.nih.gov./x',
|
||||
'https://bad host/x',
|
||||
'https://user:pass@host.org/a',
|
||||
'https://localhost/a',
|
||||
'https://127.1/a',
|
||||
'https://[::1]/a',
|
||||
'urn:sha256:',
|
||||
'urn:sha256:' + 'b'.repeat(64),
|
||||
]) {
|
||||
await post(`tasks/${task.id}/evidence`, { ...body, artifactUri }).expect(
|
||||
400,
|
||||
);
|
||||
}
|
||||
expect(await db.corporateEvidence.count()).toBe(0);
|
||||
await post(`tasks/${task.id}/evidence`, {
|
||||
...body,
|
||||
artifactUri: 'https://pubmed.ncbi.nlm.nih.gov/123/',
|
||||
}).expect(201);
|
||||
});
|
||||
it('rejects implicit timestamp coercions in source and effect inputs', async () => {
|
||||
const service = app.get(CorporateService);
|
||||
const research = {
|
||||
title: 'research',
|
||||
category: 'TREND',
|
||||
source: 'receipt',
|
||||
opportunity: 'investigate',
|
||||
impact: 'LOW',
|
||||
recommendedAction: 'measure',
|
||||
cadence: 'MONTHLY',
|
||||
provenance: { method: 'test', collector: 'fixture', context: 'isolated' },
|
||||
sources: [
|
||||
{
|
||||
url: 'https://pubmed.ncbi.nlm.nih.gov/',
|
||||
title: 'source',
|
||||
excerpt: 'receipt',
|
||||
retrievedAt: '',
|
||||
sha256: 'a'.repeat(64),
|
||||
},
|
||||
],
|
||||
};
|
||||
for (const time of [
|
||||
null,
|
||||
0,
|
||||
false,
|
||||
[],
|
||||
'2026-01-01',
|
||||
'2026-02-30T00:00:00Z',
|
||||
]) {
|
||||
await expect(
|
||||
Promise.resolve().then(() =>
|
||||
service.research('fixture', key(), {
|
||||
...research,
|
||||
sources: [{ ...research.sources[0], retrievedAt: time }],
|
||||
}),
|
||||
),
|
||||
).rejects.toThrow();
|
||||
await expect(
|
||||
Promise.resolve().then(() =>
|
||||
service.effect('fixture', key(), key(), {
|
||||
metric: 'views',
|
||||
availability: 'UNAVAILABLE',
|
||||
source: 'none',
|
||||
observedAt: time,
|
||||
}),
|
||||
),
|
||||
).rejects.toThrow('Invalid observation time');
|
||||
}
|
||||
for (const url of ['https://', 'https://?bad', 'https://bad host'])
|
||||
await expect(
|
||||
Promise.resolve().then(() =>
|
||||
service.research('fixture', key(), {
|
||||
...research,
|
||||
sources: [
|
||||
{
|
||||
...research.sources[0],
|
||||
retrievedAt: '2026-01-01T00:00:00Z',
|
||||
url,
|
||||
},
|
||||
],
|
||||
}),
|
||||
),
|
||||
).rejects.toThrow();
|
||||
expect(await db.corporateResearch.count()).toBe(0);
|
||||
});
|
||||
it('public reads strip claim tokens recursively while claim and replay retain ownership token', async () => {
|
||||
const parent = (await post('tasks', input).expect(201)).body;
|
||||
const child = (
|
||||
await post('tasks', { ...input, parentId: parent.id }).expect(201)
|
||||
).body;
|
||||
const op = key();
|
||||
const claim = (await post('claims', {}, 'executor', op).expect(201)).body
|
||||
.task;
|
||||
expect(claim.claimToken).toBeTruthy();
|
||||
expect(
|
||||
(await post('claims', {}, 'executor', op).expect(201)).body.task
|
||||
.claimToken,
|
||||
).toBe(claim.claimToken);
|
||||
await post(`tasks/${child.id}/evidence`, {
|
||||
claimToken: claim.claimToken,
|
||||
artifactUri: 'urn:sha256:' + 'a'.repeat(64),
|
||||
sha256: 'a'.repeat(64),
|
||||
summary: 'receipt',
|
||||
tool: 'jest',
|
||||
result: 'passed',
|
||||
}).expect(201);
|
||||
for (const path of ['tasks', 'tasks/' + child.id, 'tasks/' + parent.id]) {
|
||||
const r = await request(app.getHttpServer())
|
||||
.get('/admin/hermes/' + path)
|
||||
.set('x-api-key', 'competitor')
|
||||
.expect(200);
|
||||
expect(JSON.stringify(r.body)).not.toContain('claimToken');
|
||||
expect(JSON.stringify(r.body)).not.toContain(claim.claimToken);
|
||||
}
|
||||
});
|
||||
it('bounds detail relations and report snapshots with explicit truncation and immutable replay', async () => {
|
||||
const task = (await post('tasks', input).expect(201)).body;
|
||||
await db.corporateEvent.createMany({
|
||||
data: Array.from({ length: 105 }, () => ({
|
||||
taskId: task.id,
|
||||
speaker: 'SYSTEM',
|
||||
speakerName: 'fixture',
|
||||
step: 'FIXTURE',
|
||||
content: 'x'.repeat(10000),
|
||||
payload: { nested: ['x'.repeat(10000)] },
|
||||
})),
|
||||
});
|
||||
const detail = await request(app.getHttpServer())
|
||||
.get('/admin/hermes/tasks/' + task.id)
|
||||
.set('x-api-key', 'executor')
|
||||
.expect(200);
|
||||
expect(detail.body.logs).toHaveLength(100);
|
||||
expect(detail.body.relationsMeta.logs).toEqual({
|
||||
total: 106,
|
||||
returned: 100,
|
||||
limit: 100,
|
||||
truncated: true,
|
||||
});
|
||||
const op = key(),
|
||||
body = { day: new Date().toISOString().slice(0, 10), summary: 'bounded' };
|
||||
const report = (await post('reports', body, 'executor', op).expect(201))
|
||||
.body;
|
||||
expect(report.snapshot.events).toHaveLength(100);
|
||||
expect(report.snapshot.meta.events).toEqual({
|
||||
total: 106,
|
||||
returned: 100,
|
||||
limit: 100,
|
||||
truncated: true,
|
||||
});
|
||||
expect(report.snapshot.events.every((e: any) => !('payload' in e))).toBe(
|
||||
true,
|
||||
);
|
||||
expect(report.snapshot.meta.fieldsTruncated).toBe(true);
|
||||
expect(
|
||||
Buffer.byteLength(JSON.stringify(report.body ?? report)),
|
||||
).toBeLessThan(1000000);
|
||||
await db.corporateEvent.deleteMany();
|
||||
expect(
|
||||
(await post('reports', body, 'executor', op).expect(201)).body,
|
||||
).toEqual(report);
|
||||
});
|
||||
it('rolls back oversized mutation responses instead of persisting huge idempotency values', async () => {
|
||||
const service = app.get(CorporateService) as any;
|
||||
const before = await db.corporateTask.count();
|
||||
await expect(
|
||||
service.operation('fixture', 'oversize', key(), {}, async (tx: any) => {
|
||||
await tx.corporateTask.create({
|
||||
data: {
|
||||
title: 'rollback',
|
||||
description: 'fixture',
|
||||
taskCode: key(),
|
||||
normalizedTitle: 'rollback',
|
||||
normalizedCode: key(),
|
||||
department: 'CONTENT_SEO',
|
||||
createdBy: 'fixture',
|
||||
},
|
||||
});
|
||||
return { value: 'x'.repeat(1100000) };
|
||||
}),
|
||||
).rejects.toThrow('Operation response exceeds limit');
|
||||
expect(await db.corporateTask.count()).toBe(before);
|
||||
expect(await db.corporateOperation.count()).toBe(0);
|
||||
});
|
||||
it('auth, UI list contract, normalized search, immutable idempotent replay', async () => {
|
||||
await request(app.getHttpServer()).get('/admin/hermes/tasks').expect(401);
|
||||
await post('tasks', input, 'unscoped').expect(403);
|
||||
|
||||
@@ -9,9 +9,12 @@ import { createHash, randomUUID } from 'crypto';
|
||||
import { PrismaService } from '../../prisma/prisma.service';
|
||||
import {
|
||||
canonical,
|
||||
publicData,
|
||||
choice,
|
||||
departments,
|
||||
evidenceInput,
|
||||
httpsUrl,
|
||||
timestamp,
|
||||
meta,
|
||||
normalizeSearch,
|
||||
object,
|
||||
@@ -50,7 +53,10 @@ export class CorporateService {
|
||||
return prior.response;
|
||||
}
|
||||
const result = await fn(tx);
|
||||
const response = JSON.parse(JSON.stringify(result));
|
||||
const serialized = JSON.stringify(result);
|
||||
if (Buffer.byteLength(serialized, 'utf8') > 1000000)
|
||||
throw new BadRequestException('Operation response exceeds limit');
|
||||
const response = JSON.parse(serialized);
|
||||
await tx.corporateOperation.create({
|
||||
data: { key: scoped, payloadHash: hash, response },
|
||||
});
|
||||
@@ -112,32 +118,59 @@ export class CorporateService {
|
||||
take: p.limit,
|
||||
orderBy: [{ [p.sortBy]: p.sortOrder }, { id: 'asc' }],
|
||||
});
|
||||
return { data, meta: meta(total, p.page, p.limit) };
|
||||
return publicData({ data, meta: meta(total, p.page, p.limit) });
|
||||
},
|
||||
{ isolationLevel: Prisma.TransactionIsolationLevel.RepeatableRead },
|
||||
);
|
||||
}
|
||||
async detail(id: string) {
|
||||
uuid(id);
|
||||
const task = await this.db.corporateTask.findUnique({
|
||||
where: { id },
|
||||
include: {
|
||||
logs: { orderBy: { timestamp: 'asc' } },
|
||||
evidence: true,
|
||||
reviews: true,
|
||||
effects: true,
|
||||
children: true,
|
||||
return this.db.$transaction(
|
||||
async (tx) => {
|
||||
const order = { id: 'asc' as const };
|
||||
const task = await tx.corporateTask.findUnique({
|
||||
where: { id },
|
||||
include: {
|
||||
logs: { take: 100, orderBy: [{ timestamp: 'asc' }, order] },
|
||||
evidence: { take: 100, orderBy: order },
|
||||
reviews: { take: 100, orderBy: order },
|
||||
effects: { take: 100, orderBy: order },
|
||||
children: { take: 100, orderBy: order },
|
||||
_count: {
|
||||
select: {
|
||||
logs: true,
|
||||
evidence: true,
|
||||
reviews: true,
|
||||
effects: true,
|
||||
children: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
});
|
||||
if (!task) throw new NotFoundException('Task not found');
|
||||
const { _count, ...data } = task;
|
||||
const relationsMeta = Object.fromEntries(
|
||||
Object.entries(_count).map(([name, total]) => [
|
||||
name,
|
||||
{
|
||||
total,
|
||||
returned: Math.min(total, 100),
|
||||
limit: 100,
|
||||
truncated: total > 100,
|
||||
},
|
||||
]),
|
||||
);
|
||||
return publicData({ ...data, relationsMeta });
|
||||
},
|
||||
});
|
||||
if (!task) throw new NotFoundException('Task not found');
|
||||
return task;
|
||||
{ isolationLevel: Prisma.TransactionIsolationLevel.RepeatableRead },
|
||||
);
|
||||
}
|
||||
create(actor: string, key: string, input: unknown) {
|
||||
const b = taskInput(input);
|
||||
return this.operation(actor, 'create-task', key, b, async (tx) => {
|
||||
if (b.parentId) {
|
||||
const parent = await this.lock(tx, b.parentId);
|
||||
if (!['TODO', 'IN_PROGRESS', 'BLOCKED'].includes(parent.status))
|
||||
if (!['TODO', 'BLOCKED'].includes(parent.status))
|
||||
throw new ConflictException('Parent no longer accepts children');
|
||||
}
|
||||
const code = 'TSK-' + randomUUID();
|
||||
@@ -347,7 +380,7 @@ export class CorporateService {
|
||||
? { include: { goals: true } }
|
||||
: {}),
|
||||
});
|
||||
return { data, meta: meta(total, p.page, p.limit) };
|
||||
return publicData({ data, meta: meta(total, p.page, p.limit) });
|
||||
},
|
||||
{ isolationLevel: Prisma.TransactionIsolationLevel.RepeatableRead },
|
||||
);
|
||||
@@ -374,9 +407,9 @@ export class CorporateService {
|
||||
'retrievedAt',
|
||||
'sha256',
|
||||
]);
|
||||
const url = text(s.url, 2000),
|
||||
const url = httpsUrl(s.url),
|
||||
sha256 = text(s.sha256, 64),
|
||||
retrievedAt = new Date(s.retrievedAt);
|
||||
retrievedAt = timestamp(s.retrievedAt, 'Invalid source time');
|
||||
if (
|
||||
!url.startsWith('https://') ||
|
||||
!/^[a-f0-9]{64}$/.test(sha256) ||
|
||||
@@ -531,7 +564,7 @@ export class CorporateService {
|
||||
(b.observed != null || b.baseline != null)
|
||||
)
|
||||
throw new BadRequestException('Unavailable is not zero');
|
||||
const observedAt = new Date(b.observedAt);
|
||||
const observedAt = timestamp(b.observedAt, 'Invalid observation time');
|
||||
if (
|
||||
!Number.isFinite(observedAt.getTime()) ||
|
||||
observedAt.getTime() > Date.now()
|
||||
@@ -571,8 +604,18 @@ export class CorporateService {
|
||||
return this.operation(actor, 'report', key, b, async (tx) => {
|
||||
const start = new Date(day + 'T00:00:00Z'),
|
||||
end = new Date(start.getTime() + 86400000);
|
||||
const taskWhere = { updatedAt: { gte: start, lt: end } };
|
||||
const eventWhere = { timestamp: { gte: start, lt: end } };
|
||||
const effectWhere = { createdAt: { gte: start, lt: end } };
|
||||
const totals = {
|
||||
tasks: await tx.corporateTask.count({ where: taskWhere }),
|
||||
events: await tx.corporateEvent.count({ where: eventWhere }),
|
||||
effects: await tx.corporateEffect.count({ where: effectWhere }),
|
||||
};
|
||||
const tasks = await tx.corporateTask.findMany({
|
||||
where: { updatedAt: { gte: start, lt: end } },
|
||||
where: taskWhere,
|
||||
take: 100,
|
||||
orderBy: [{ updatedAt: 'asc' }, { id: 'asc' }],
|
||||
select: {
|
||||
id: true,
|
||||
taskCode: true,
|
||||
@@ -583,14 +626,75 @@ export class CorporateService {
|
||||
},
|
||||
});
|
||||
const events = await tx.corporateEvent.findMany({
|
||||
where: { timestamp: { gte: start, lt: end } },
|
||||
orderBy: { timestamp: 'asc' },
|
||||
where: eventWhere,
|
||||
take: 100,
|
||||
orderBy: [{ timestamp: 'asc' }, { id: 'asc' }],
|
||||
select: {
|
||||
id: true,
|
||||
taskId: true,
|
||||
timestamp: true,
|
||||
speaker: true,
|
||||
speakerName: true,
|
||||
step: true,
|
||||
content: true,
|
||||
},
|
||||
});
|
||||
const effects = await tx.corporateEffect.findMany({
|
||||
where: { createdAt: { gte: start, lt: end } },
|
||||
where: effectWhere,
|
||||
take: 100,
|
||||
orderBy: [{ createdAt: 'asc' }, { id: 'asc' }],
|
||||
select: {
|
||||
id: true,
|
||||
taskId: true,
|
||||
metric: true,
|
||||
availability: true,
|
||||
baseline: true,
|
||||
observed: true,
|
||||
source: true,
|
||||
observedAt: true,
|
||||
createdAt: true,
|
||||
},
|
||||
});
|
||||
let fieldsTruncated = false;
|
||||
const project = (rows: any[]) =>
|
||||
rows.map((row) =>
|
||||
Object.fromEntries(
|
||||
Object.entries(row).map(([name, value]) => {
|
||||
if (typeof value === 'string' && value.length > 1000) {
|
||||
fieldsTruncated = true;
|
||||
return [name, value.slice(0, 1000)];
|
||||
}
|
||||
return [name, value];
|
||||
}),
|
||||
),
|
||||
);
|
||||
const bounded = {
|
||||
tasks: project(tasks),
|
||||
events: project(events),
|
||||
effects: project(effects),
|
||||
};
|
||||
const counts = Object.fromEntries(
|
||||
Object.entries(totals).map(([name, total]) => [
|
||||
name,
|
||||
{
|
||||
total,
|
||||
returned: Math.min(total, 100),
|
||||
limit: 100,
|
||||
truncated: total > 100,
|
||||
},
|
||||
]),
|
||||
);
|
||||
const snapshot = JSON.parse(
|
||||
JSON.stringify({ timezone: 'UTC', tasks, events, effects }),
|
||||
JSON.stringify({
|
||||
timezone: 'UTC',
|
||||
...bounded,
|
||||
meta: {
|
||||
...counts,
|
||||
fieldsTruncated,
|
||||
stringLimit: 1000,
|
||||
eventPayloadsOmitted: true,
|
||||
},
|
||||
}),
|
||||
);
|
||||
return tx.corporateReport.create({
|
||||
data: { day, summary, snapshot, createdBy: actor },
|
||||
|
||||
Reference in new issue
Block a user