Legal Tech: Protecting Privilege

How a legal technology provider secured AI-assisted drafting and research while preserving confidentiality.

Challenge

The platform supported:

Contract analysis and clause suggestions
Case law research summaries
Drafting and redlining assistance

Critical Requirements

Preserve attorney-client privilege and confidentiality
Isolate case context across firms and matters
Prevent leakage of confidential facts in outputs

Solution

KoreShield scanned prompts and outputs with strict policies and enforced per-matter isolation.

import { Koreshield } from 'koreshield-sdk';

const koreshield = new Koreshield({
  apiKey: process.env.KORESHIELD_API_KEY,
  sensitivity: 'high',
});

async function secureLegalAssist(userId: string, matterId: string, prompt: string) {
  const scan = await koreshield.scan({
    content: prompt,
    userId,
    metadata: { matterId, domain: 'legal' },
  });

  if (scan.threat_detected) {
    return { error: 'Blocked unsafe legal request' };
  }

  const draft = await generateLegalDraft(prompt);

  const outputScan = await koreshield.scan({
    content: draft,
    metadata: { matterId, output: true },
  });

  if (outputScan.threat_detected) {
    return { error: 'Output failed privilege checks' };
  }

  return { draft };
}

Matter Isolation Strategy

Every request included a matter identifier and tenant boundary:

Tenant Scoping

Firm and matter IDs enforced per request

RAG Partitioning

Retrieval limited to the matter workspace

Token Boundaries

Outputs limited to the scoped context

Privilege Controls

Matter Isolation

Prompts and retrieved docs scoped per matter - no cross-contamination

PII/Privilege Redaction

Removed sensitive entities from logs and audit trails

Audit Trails

Every prompt and response recorded for compliance and e-discovery

Human Review

High-risk responses queued for attorney approval before use

Architecture

Implementation Example

Input Scanning
Output Scanning
Matter Isolation

async function scanLegalInput(
  prompt: string,
  userId: string,
  matterId: string
) {
  // Scan for prompt injection and data exfiltration
  const scan = await koreshield.scan({
    content: prompt,
    userId,
    metadata: {
      matterId,
      domain: 'legal',
      sensitivity: 'privileged',
    },
  });

  if (scan.threat_detected) {
    await auditLog.create({
      userId,
      matterId,
      action: 'INPUT_BLOCKED',
      threat: scan.threat_type,
      confidence: scan.confidence,
    });

    throw new SecurityError(
      'Request contains potential security threat'
    );
  }

  return scan;
}

async function scanLegalOutput(
  output: string,
  matterId: string
) {
  // Scan for privileged information leakage
  const scan = await koreshield.scan({
    content: output,
    metadata: {
      matterId,
      output: true,
      checkPrivilege: true,
    },
  });

  if (scan.threat_detected) {
    await auditLog.create({
      matterId,
      action: 'OUTPUT_BLOCKED',
      threat: scan.threat_type,
      reason: 'Potential privilege violation',
    });

    throw new PrivilegeViolationError(
      'Output failed privilege checks'
    );
  }

  return scan;
}

async function getMatterContext(
  matterId: string,
  userId: string
): Promise<MatterContext> {
  // Verify attorney has access to this matter
  const hasAccess = await checkMatterAccess(userId, matterId);
  
  if (!hasAccess) {
    throw new UnauthorizedError(
      'User does not have access to this matter'
    );
  }
  
  // Retrieve only documents for this specific matter
  const documents = await db.documents.findMany({
    where: {
      matterId,
      status: 'active',
    },
    select: {
      id: true,
      content: true,
      metadata: true,
      // Exclude documents from other matters
    },
  });
  
  return {
    matterId,
    documents,
    clientId: await getClientForMatter(matterId),
    jurisdiction: await getJurisdiction(matterId),
  };
}

Review and Compliance Workflow

Redaction Checks

Flagged privileged entities before output:

Client names and identifiers
Opposing party information
Settlement amounts and terms
Attorney work product
Strategic legal analysis

Versioning

Stored drafts with immutable audit metadata:

Document version history
Author and timestamp
Matter association
Review status
Approval workflow state

Access Reviews

Periodic verification of matter access lists:

Quarterly access audits
Automated revocation on matter closure
Role-based permissions
Chinese wall enforcement

Results

Privilege Protection

Reduced risk of privileged data exposure across matters

Output Quality

Improved consistency of legal output quality

Compliance

Clear compliance posture for enterprise clients

Use Cases

Contract Analysis
Case Research
Document Drafting

Secure Clause Review

async function analyzeContract(
  contractText: string,
  matterId: string,
  userId: string
) {
  // Scan input contract for threats
  await scanLegalInput(contractText, userId, matterId);
  
  // Generate analysis with matter context
  const analysis = await ai.analyze({
    contract: contractText,
    context: await getMatterContext(matterId, userId),
    task: 'identify-risks',
  });
  
  // Scan output for privilege leakage
  await scanLegalOutput(analysis, matterId);
  
  return analysis;
}

Isolated Legal Research

async function researchCaseLaw(
  query: string,
  matterId: string,
  userId: string
) {
  // Scan research query
  await scanLegalInput(query, userId, matterId);
  
  // Retrieve relevant case law (public domain)
  const cases = await legalDatabase.search({
    query,
    jurisdiction: await getJurisdiction(matterId),
    filters: { publicDomain: true },
  });
  
  // Generate summary with citations
  const summary = await ai.summarize(cases);
  
  // Verify no privileged info leaked
  await scanLegalOutput(summary, matterId);
  
  return { summary, citations: cases };
}

Privileged Document Generation

async function draftLegalDocument(
  instructions: string,
  template: string,
  matterId: string,
  userId: string
) {
  // Scan instructions and template
  await scanLegalInput(instructions, userId, matterId);
  await scanLegalInput(template, userId, matterId);
  
  // Generate draft with matter-specific context
  const draft = await ai.draft({
    instructions,
    template,
    context: await getMatterContext(matterId, userId),
  });
  
  // Scan output before returning
  await scanLegalOutput(draft, matterId);
  
  // Store with audit trail
  await storeDraft({
    content: draft,
    matterId,
    userId,
    version: await getNextVersion(matterId),
  });
  
  return draft;
}

Best Practices

Legal AI Security Principles

Matter isolation is non-negotiable - Never mix context across matters
Scan inputs and outputs - Threats can appear in prompts or generations
Maintain audit trails - Essential for e-discovery and malpractice defense
Review high-risk outputs - Human attorney oversight for sensitive matters
Educate users - Attorneys must understand AI limitations and risks

Lessons Learned

Start Conservative

Begin with strict policies and high sensitivity settings. Legal privilege violations can result in malpractice claims and ethical violations. It’s better to have false positives than miss a privilege leak.

Clear User Guidelines

Attorneys need training on:

What the AI can and cannot do
How to phrase requests safely
When to escalate to human review
Ethical obligations when using AI

Regular Audits

Conduct monthly reviews of:

Blocked requests (false positives?)
Access patterns (unusual activity?)
Output quality (hallucinations?)
Compliance metrics (audit ready?)

Security

Core security features

Configuration

Policy configuration

Monitoring

Alerts and dashboards

Use Cases

Legal Tech Security

Legal Tech: Protecting Privilege

Challenge

Solution

Matter Isolation Strategy

Tenant Scoping

RAG Partitioning

Token Boundaries

Privilege Controls

Architecture

Implementation Example

Review and Compliance Workflow

Results

Privilege Protection

Output Quality

Compliance

Use Cases

Best Practices

Lessons Learned

Security

Configuration

Monitoring

Build docs developers (and LLMs) love

Use Cases

​Legal Tech: Protecting Privilege

​Challenge

​Solution

​Matter Isolation Strategy

Tenant Scoping

RAG Partitioning

Token Boundaries

​Privilege Controls

​Architecture

​Implementation Example

​Review and Compliance Workflow

​Results

Privilege Protection

Output Quality

Compliance

​Use Cases

​Best Practices

​Lessons Learned

​Related Documentation

Security

Configuration

Monitoring

Build docs developers (and LLMs) love

Legal Tech: Protecting Privilege

Challenge

Solution

Matter Isolation Strategy

Privilege Controls

Architecture

Implementation Example

Review and Compliance Workflow

Results

Use Cases

Best Practices

Lessons Learned

Related Documentation