From 06c7056d8be1dbda2f1a9df1cc74bf0ec4e151b3 Mon Sep 17 00:00:00 2001
From: bikram dey <62688713+modhack2003@users.noreply.github.com>
Date: Thu, 8 Oct 2026 17:50:44 +0530
Subject: [PATCH] Improve shadow CTF and add isolated decoy admin terminals
---
docs/shadow-decoys.md | 24 ++
src/app/admin/access/page.tsx | 6 +
src/app/admin/backup/page.tsx | 6 +
src/app/admin/login/page.tsx | 6 +
src/app/admin/page.tsx | 25 +-
src/app/administrator/page.tsx | 6 +
.../api/ctf/verify/__tests__/route.test.ts | 52 ++++
src/app/api/ctf/verify/route.ts | 86 +++---
src/app/b1kr4m-5h4d0w/page.tsx | 48 +--
src/app/cpanel/page.tsx | 6 +
src/app/dashboard/login/page.tsx | 6 +
src/app/root/page.tsx | 6 +
src/app/wp-admin/page.tsx | 6 +
.../__tests__/crypto-puzzle.test.tsx | 39 +++
src/components/__tests__/decoy-login.test.tsx | 32 ++
src/components/crypto-puzzle.tsx | 287 ++++--------------
src/components/decoy-login.tsx | 42 +++
src/components/shadow-shell.tsx | 18 ++
src/lib/shadow-challenges.ts | 32 ++
src/middleware.ts | 7 +
20 files changed, 404 insertions(+), 336 deletions(-)
create mode 100644 docs/shadow-decoys.md
create mode 100644 src/app/admin/access/page.tsx
create mode 100644 src/app/admin/backup/page.tsx
create mode 100644 src/app/admin/login/page.tsx
create mode 100644 src/app/administrator/page.tsx
create mode 100644 src/app/api/ctf/verify/__tests__/route.test.ts
create mode 100644 src/app/cpanel/page.tsx
create mode 100644 src/app/dashboard/login/page.tsx
create mode 100644 src/app/root/page.tsx
create mode 100644 src/app/wp-admin/page.tsx
create mode 100644 src/components/__tests__/crypto-puzzle.test.tsx
create mode 100644 src/components/__tests__/decoy-login.test.tsx
create mode 100644 src/components/decoy-login.tsx
create mode 100644 src/components/shadow-shell.tsx
create mode 100644 src/lib/shadow-challenges.ts
diff --git a/docs/shadow-decoys.md b/docs/shadow-decoys.md
new file mode 100644
index 0000000..df04b95
--- /dev/null
+++ b/docs/shadow-decoys.md
@@ -0,0 +1,24 @@
+# Shadow terminals
+
+These public simulations distract casual route probing and offer small CTFs. They are not an authentication layer, an intrusion detector, or a substitute for the real admin's session checks.
+
+| Route | Experience |
+| --- | --- |
+| `/admin` | Fake PIN console |
+| `/administrator` | Fake system administration login |
+| `/wp-admin` | Fake content administration login (no WordPress installed) |
+| `/cpanel` | Fake hosting login (no cPanel installed) |
+| `/admin/login` | Fake operator login |
+| `/dashboard/login` | Fake dashboard login |
+| `/b1kr4m-5h4d0w` | Five-lock cipher CTF |
+| `/admin/access` | Alternate entrance to cipher CTF |
+| `/admin/backup` | Three-lock archive CTF |
+| `/root` | Three-lock signal CTF |
+
+Login inputs remain only in React memory and are cleared immediately when submitted. No login requests, database writes, credential storage, or real admin imports are involved. The timer is cleaned up when leaving a page.
+
+CTF verification accepts only a recognized track, integer level, and answer up to 128 characters. Answers stay in the server route. Completion returns fictional flags and never sets an admin cookie or redirects to the real login. Flags are game rewards, not proof of identity; players can inspect or probe the public verifier.
+
+The verifier has a bounded 2,048-entry per-instance throttle (20 attempts per minute) with expired-entry cleanup and Retry-After responses. This is best-effort on Vercel; it is not a globally coordinated rate limit. Responses are not cached. Decoy pages have noindex/nofollow metadata and headers without advertising the route inventory in robots.txt.
+
+No new packages, database schema changes, or environment variables are required.
diff --git a/src/app/admin/access/page.tsx b/src/app/admin/access/page.tsx
new file mode 100644
index 0000000..45a2b13
--- /dev/null
+++ b/src/app/admin/access/page.tsx
@@ -0,0 +1,6 @@
+import { CryptoPuzzle } from '@/components/crypto-puzzle';
+import { ShadowShell, shadowMetadata } from '@/components/shadow-shell';
+export const metadata = shadowMetadata;
+export default function Page() {
+ return ;
+}
diff --git a/src/app/admin/backup/page.tsx b/src/app/admin/backup/page.tsx
new file mode 100644
index 0000000..fde9784
--- /dev/null
+++ b/src/app/admin/backup/page.tsx
@@ -0,0 +1,6 @@
+import { CryptoPuzzle } from '@/components/crypto-puzzle';
+import { ShadowShell, shadowMetadata } from '@/components/shadow-shell';
+export const metadata = shadowMetadata;
+export default function Page() {
+ return ;
+}
diff --git a/src/app/admin/login/page.tsx b/src/app/admin/login/page.tsx
new file mode 100644
index 0000000..9e253d3
--- /dev/null
+++ b/src/app/admin/login/page.tsx
@@ -0,0 +1,6 @@
+import { DecoyLogin } from '@/components/decoy-login';
+import { ShadowShell, shadowMetadata } from '@/components/shadow-shell';
+export const metadata = shadowMetadata;
+export default function Page() {
+ return ;
+}
diff --git a/src/app/admin/page.tsx b/src/app/admin/page.tsx
index 02e5d3d..6e84350 100644
--- a/src/app/admin/page.tsx
+++ b/src/app/admin/page.tsx
@@ -1,23 +1,6 @@
-'use client';
-
-import Link from 'next/link';
-import { Terminal } from 'lucide-react';
-import { DeadEndPinForm } from '@/components/dead-end-pin-form';
-
-/** Decoy login — it never grants access and ships none of the real admin code. */
+import { DecoyLogin } from '@/components/decoy-login';
+import { ShadowShell, shadowMetadata } from '@/components/shadow-shell';
+export const metadata = shadowMetadata;
export default function AdminPage() {
- return (
-
- );
+ return ;
}
diff --git a/src/app/administrator/page.tsx b/src/app/administrator/page.tsx
new file mode 100644
index 0000000..5513ac0
--- /dev/null
+++ b/src/app/administrator/page.tsx
@@ -0,0 +1,6 @@
+import { DecoyLogin } from '@/components/decoy-login';
+import { ShadowShell, shadowMetadata } from '@/components/shadow-shell';
+export const metadata = shadowMetadata;
+export default function Page() {
+ return ;
+}
diff --git a/src/app/api/ctf/verify/__tests__/route.test.ts b/src/app/api/ctf/verify/__tests__/route.test.ts
new file mode 100644
index 0000000..b359a0d
--- /dev/null
+++ b/src/app/api/ctf/verify/__tests__/route.test.ts
@@ -0,0 +1,52 @@
+/** @jest-environment node */
+import { NextRequest } from 'next/server';
+import { POST } from '../route';
+import { SHADOW_TRACKS } from '@/lib/shadow-challenges';
+
+let client = 0;
+const request = (body: unknown, ip = `test-${++client}`) => new NextRequest('https://example.com/api/ctf/verify', { method: 'POST', headers: { 'x-forwarded-for': ip }, body: JSON.stringify(body) });
+const rot = (text: string, shift: number) => text.replace(/[a-z]/g, (c) => String.fromCharCode((c.charCodeAt(0) - 97 + shift + 26) % 26 + 97));
+
+test('every displayed cipher is solvable and completion never issues admin access', async () => {
+ const cipher = SHADOW_TRACKS.cipher.puzzles;
+ const archive = SHADOW_TRACKS.archive.puzzles;
+ const signal = SHADOW_TRACKS.signal.puzzles;
+ const decoded = {
+ cipher: [rot(cipher[0].cipher, 13), Buffer.from(cipher[1].cipher, 'base64').toString(), Buffer.from(cipher[2].cipher, 'hex').toString(), rot(cipher[3].cipher, -3), cipher[4].cipher.split(' ').map((b) => String.fromCharCode(parseInt(b, 2))).join('')],
+ archive: [decodeURIComponent(archive[0].cipher), archive[1].cipher.split('').reverse().join(''), Buffer.from(Buffer.from(archive[2].cipher, 'base64').toString(), 'hex').toString()],
+ signal: [signal[0].cipher.split(' ').map((c) => ({ '.-.': 'r', '---': 'o', '-': 't' })[c]).join(''), signal[1].cipher.split(' ').map((b) => String.fromCharCode(Number(b))).join(''), signal[2].cipher.replace(/[a-z]/g, (c) => String.fromCharCode(219 - c.charCodeAt(0)))],
+ };
+ for (const [track, answers] of Object.entries(decoded)) {
+ for (const [index, answer] of answers.entries()) {
+ const response = await POST(request({ track, level: index + 1, answer: ` ${answer.toUpperCase()} ` }));
+ expect(response.status).toBe(200);
+ const result = await response.json();
+ expect(result.correct).toBe(true);
+ expect(result.isLastLevel).toBe(index === answers.length - 1);
+ expect(Boolean(result.flag)).toBe(index === answers.length - 1);
+ expect(response.headers.has('set-cookie')).toBe(false);
+ expect(response.headers.has('location')).toBe(false);
+ expect(result).not.toHaveProperty('redirect');
+ }
+ }
+});
+
+test('wrong answers disclose no flags and malformed levels are rejected', async () => {
+ expect(await (await POST(request({ level: 5, answer: 'admin' }))).json()).toEqual({ correct: false, isLastLevel: true });
+ for (const body of [null, {}, { level: 1.5, answer: 'shadow' }, { track: 'other', level: 1, answer: 'x' }, { level: 99, answer: 'x' }, { level: 1, answer: 'x'.repeat(129) }]) {
+ expect((await POST(request(body))).status).toBe(400);
+ }
+ expect((await POST(request({ level: 1, answer: 'x'.repeat(3000) }))).status).toBe(413);
+});
+
+test('attempt limit returns retry instructions and expires', async () => {
+ const clock = jest.spyOn(Date, 'now').mockReturnValue(2000000000000);
+ try {
+ for (let i = 0; i < 20; i++) expect((await POST(request({ level: 1, answer: 'x' }, 'limited'))).status).toBe(200);
+ const blocked = await POST(request({ level: 1, answer: 'shadow' }, 'limited'));
+ expect(blocked.status).toBe(429);
+ expect(blocked.headers.get('retry-after')).toBe('60');
+ clock.mockReturnValue(2000000060001);
+ expect((await POST(request({ level: 1, answer: 'shadow' }, 'limited'))).status).toBe(200);
+ } finally { clock.mockRestore(); }
+});
diff --git a/src/app/api/ctf/verify/route.ts b/src/app/api/ctf/verify/route.ts
index 4a5ce90..40e34f6 100644
--- a/src/app/api/ctf/verify/route.ts
+++ b/src/app/api/ctf/verify/route.ts
@@ -1,56 +1,44 @@
import { NextRequest, NextResponse } from 'next/server';
-
-// Puzzles with server-side solutions (never exposed to client)
-const PUZZLES = [
- { level: 1, solution: "admin" },
- { level: 2, solution: "admin" },
- { level: 3, solution: "admin" },
- { level: 4, solution: "admin" },
- { level: 5, solution: "admin" },
-];
-
-// Rate limiting for puzzle attempts
-const puzzleAttempts = new Map();
-const MAX_PUZZLE_ATTEMPTS = 20; // per minute
-const WINDOW_MS = 60 * 1000;
+import { z } from 'zod';
+import { SHADOW_TRACKS } from '@/lib/shadow-challenges';
+
+const solutions = {
+ cipher: ['shadow', 'crow', 'genjutsu', 'cipher', 'escape'],
+ archive: ['vault', 'archive', 'echo'],
+ signal: ['root', 'spectre', 'trail'],
+} as const;
+const flags = { cipher: 'BIKRAM{the_shadow_was_a_decoy}', archive: 'BIKRAM{no_secrets_in_the_archive}', signal: 'BIKRAM{root_of_an_illusion}' };
+const schema = z.object({
+ track: z.enum(['cipher', 'archive', 'signal']).default('cipher'),
+ level: z.number().int().min(1),
+ answer: z.string().trim().min(1).max(128),
+});
+// Best-effort per-instance abuse control, not an authentication boundary.
+const attempts = new Map();
+const WINDOW_MS = 60000;
+const MAX_KEYS = 2048;
export async function POST(request: NextRequest) {
+ const now = Date.now();
+ for (const [key, entry] of attempts) if (entry.until <= now) attempts.delete(key);
+ const ip = (request.headers.get('x-forwarded-for')?.split(',')[0]?.trim() || 'unknown').slice(0, 100);
+ const entry = attempts.get(ip);
+ if ((entry && entry.count >= 20) || (!entry && attempts.size >= MAX_KEYS)) {
+ return NextResponse.json({ error: 'Too many attempts. Wait one minute and retry.' }, { status: 429, headers: { 'Retry-After': '60', 'Cache-Control': 'no-store' } });
+ }
+ attempts.set(ip, { count: (entry?.count || 0) + 1, until: entry?.until || now + WINDOW_MS });
try {
- const clientIP = request.headers.get('x-forwarded-for')?.split(',')[0]?.trim() || 'unknown';
- const now = Date.now();
-
- // Rate limiting
- const entry = puzzleAttempts.get(clientIP);
- if (entry && now < entry.resetTime) {
- if (entry.count >= MAX_PUZZLE_ATTEMPTS) {
- return NextResponse.json(
- { error: 'Too many attempts. Please wait.' },
- { status: 429 }
- );
- }
- entry.count++;
- } else {
- puzzleAttempts.set(clientIP, { count: 1, resetTime: now + WINDOW_MS });
- }
-
- const { level, answer } = await request.json();
-
- if (typeof level !== 'number' || level < 1 || level > PUZZLES.length) {
- return NextResponse.json({ error: 'Invalid level' }, { status: 400 });
- }
-
- if (typeof answer !== 'string' || !answer.trim()) {
- return NextResponse.json({ error: 'Answer is required' }, { status: 400 });
- }
-
- const puzzle = PUZZLES[level - 1];
- const isCorrect = answer.toLowerCase().trim() === puzzle.solution;
-
- return NextResponse.json({
- correct: isCorrect,
- isLastLevel: level === PUZZLES.length,
- });
+ const text = await request.text();
+ if (new TextEncoder().encode(text).length > 2048) return NextResponse.json({ error: 'Answer payload too large.' }, { status: 413 });
+ const parsed = schema.safeParse(JSON.parse(text));
+ if (!parsed.success) return NextResponse.json({ error: 'Provide a valid track, integer level and answer (up to 128 characters).' }, { status: 400 });
+ const { track, level, answer } = parsed.data;
+ if (level > SHADOW_TRACKS[track].puzzles.length) return NextResponse.json({ error: 'Invalid level.' }, { status: 400 });
+ const correct = answer.toLowerCase() === solutions[track][level - 1];
+ const isLastLevel = level === solutions[track].length;
+ // No sessions, credentials, redirects or database writes: these are game flags only.
+ return NextResponse.json({ correct, isLastLevel, ...(correct && isLastLevel ? { flag: flags[track] } : {}) }, { headers: { 'Cache-Control': 'no-store' } });
} catch {
- return NextResponse.json({ error: 'Bad request' }, { status: 400 });
+ return NextResponse.json({ error: 'Malformed challenge request.' }, { status: 400 });
}
}
diff --git a/src/app/b1kr4m-5h4d0w/page.tsx b/src/app/b1kr4m-5h4d0w/page.tsx
index c9b69b5..65cf48e 100644
--- a/src/app/b1kr4m-5h4d0w/page.tsx
+++ b/src/app/b1kr4m-5h4d0w/page.tsx
@@ -1,46 +1,6 @@
-'use client';
-
-import { useState } from 'react';
-import { useRouter } from 'next/navigation';
import { CryptoPuzzle } from '@/components/crypto-puzzle';
-import Link from 'next/link';
-import { Terminal, Lock } from 'lucide-react';
-
-export default function BikramShadowAccessPage() {
- const [isAuthenticated, setIsAuthenticated] = useState(false);
- const router = useRouter();
-
- const handlePuzzleSuccess = () => {
- setIsAuthenticated(true);
- // Redirect to bikram page for PIN authentication after puzzle completion
- router.push('/bikram');
- };
-
- if (isAuthenticated) {
- return null; // Will redirect to /bikram
- }
-
- return (
-
- );
+import { ShadowShell, shadowMetadata } from '@/components/shadow-shell';
+export const metadata = shadowMetadata;
+export default function ShadowPage() {
+ return ;
}
-
-
diff --git a/src/app/cpanel/page.tsx b/src/app/cpanel/page.tsx
new file mode 100644
index 0000000..2fb3707
--- /dev/null
+++ b/src/app/cpanel/page.tsx
@@ -0,0 +1,6 @@
+import { DecoyLogin } from '@/components/decoy-login';
+import { ShadowShell, shadowMetadata } from '@/components/shadow-shell';
+export const metadata = shadowMetadata;
+export default function Page() {
+ return ;
+}
diff --git a/src/app/dashboard/login/page.tsx b/src/app/dashboard/login/page.tsx
new file mode 100644
index 0000000..876e9a8
--- /dev/null
+++ b/src/app/dashboard/login/page.tsx
@@ -0,0 +1,6 @@
+import { DecoyLogin } from '@/components/decoy-login';
+import { ShadowShell, shadowMetadata } from '@/components/shadow-shell';
+export const metadata = shadowMetadata;
+export default function Page() {
+ return ;
+}
diff --git a/src/app/root/page.tsx b/src/app/root/page.tsx
new file mode 100644
index 0000000..5b11db0
--- /dev/null
+++ b/src/app/root/page.tsx
@@ -0,0 +1,6 @@
+import { CryptoPuzzle } from '@/components/crypto-puzzle';
+import { ShadowShell, shadowMetadata } from '@/components/shadow-shell';
+export const metadata = shadowMetadata;
+export default function Page() {
+ return ;
+}
diff --git a/src/app/wp-admin/page.tsx b/src/app/wp-admin/page.tsx
new file mode 100644
index 0000000..95a2c97
--- /dev/null
+++ b/src/app/wp-admin/page.tsx
@@ -0,0 +1,6 @@
+import { DecoyLogin } from '@/components/decoy-login';
+import { ShadowShell, shadowMetadata } from '@/components/shadow-shell';
+export const metadata = shadowMetadata;
+export default function Page() {
+ return ;
+}
diff --git a/src/components/__tests__/crypto-puzzle.test.tsx b/src/components/__tests__/crypto-puzzle.test.tsx
new file mode 100644
index 0000000..e49b349
--- /dev/null
+++ b/src/components/__tests__/crypto-puzzle.test.tsx
@@ -0,0 +1,39 @@
+import { render, screen, fireEvent, waitFor } from '@testing-library/react';
+import { CryptoPuzzle } from '../crypto-puzzle';
+jest.mock('lucide-react', () => ({ Eye: () => null, Flag: () => null, Lock: () => null, RotateCcw: () => null }));
+const originalFetch = global.fetch;
+afterEach(() => { global.fetch = originalFetch; });
+
+test('progress begins at zero, advances, and ends with a game flag instead of an admin link', async () => {
+ global.fetch = jest.fn().mockImplementation(async (_url, options) => {
+ const { level } = JSON.parse(options.body);
+ return { ok: true, json: async () => ({ correct: true, isLastLevel: level === 3, ...(level === 3 ? { flag: 'BIKRAM{no_secrets_in_the_archive}' } : {}) }) };
+ });
+ render();
+ expect(screen.getByRole('progressbar')).toHaveAttribute('aria-valuenow', '0');
+ for (let level = 1; level <= 3; level++) {
+ fireEvent.change(screen.getByLabelText('Decoded answer'), { target: { value: 'test' } });
+ fireEvent.click(screen.getByRole('button', { name: '>_ Verify' }));
+ await waitFor(() => expect(screen.getByRole('progressbar')).toHaveAttribute('aria-valuenow', String(level)));
+ }
+ expect(screen.getByText('BIKRAM{no_secrets_in_the_archive}')).toBeVisible();
+ expect(document.querySelector('a[href="/bikram"]')).toBeNull();
+ expect(screen.getByRole('link', { name: 'Follow another signal →' })).toHaveAttribute('href', '/root');
+ fireEvent.click(screen.getByRole('button', { name: 'Restart sequence' }));
+ expect(screen.getByRole('progressbar')).toHaveAttribute('aria-valuenow', '0');
+});
+
+test('wrong answers reveal a clue after three tries and a network error keeps the same lock', async () => {
+ global.fetch = jest.fn().mockResolvedValue({ ok: true, json: async () => ({ correct: false }) });
+ render();
+ for (let count = 1; count <= 3; count++) {
+ fireEvent.change(screen.getByLabelText('Decoded answer'), { target: { value: 'wrong' } });
+ fireEvent.click(screen.getByRole('button', { name: '>_ Verify' }));
+ await waitFor(() => expect(screen.getByText(`ATTEMPTS // ${count}`)).toBeVisible());
+ }
+ expect(screen.getByRole('button', { name: 'Hide clue' })).toHaveAttribute('aria-expanded', 'true');
+ jest.mocked(global.fetch).mockRejectedValueOnce(new Error('offline'));
+ fireEvent.click(screen.getByRole('button', { name: '>_ Verify' }));
+ await waitFor(() => expect(screen.getByRole('status')).toHaveTextContent('Uplink interrupted'));
+ expect(screen.getByRole('progressbar')).toHaveAttribute('aria-valuenow', '0');
+});
diff --git a/src/components/__tests__/decoy-login.test.tsx b/src/components/__tests__/decoy-login.test.tsx
new file mode 100644
index 0000000..4ac4907
--- /dev/null
+++ b/src/components/__tests__/decoy-login.test.tsx
@@ -0,0 +1,32 @@
+import { render, screen, fireEvent, act } from '@testing-library/react';
+import { DecoyLogin } from '../decoy-login';
+jest.mock('lucide-react', () => ({ Lock: () => null, Terminal: () => null }));
+
+test('decoy discards entered values, denies access, and makes no network request', () => {
+ jest.useFakeTimers();
+ const originalFetch = global.fetch;
+ global.fetch = jest.fn();
+ try {
+ render();
+ fireEvent.change(screen.getByLabelText('Operator ID'), { target: { value: 'test-user' } });
+ fireEvent.change(screen.getByLabelText('Password'), { target: { value: 'disposable-test-input' } });
+ fireEvent.click(screen.getByRole('button', { name: '>_ Authenticate' }));
+ expect(screen.getByLabelText('Password')).toHaveValue('');
+ expect(screen.getByLabelText('Operator ID')).toHaveValue('');
+ act(() => jest.advanceTimersByTime(1100));
+ expect(screen.getByRole('status')).toHaveTextContent('Access denied');
+ expect(global.fetch).not.toHaveBeenCalled();
+ } finally { global.fetch = originalFetch; jest.useRealTimers(); }
+});
+
+test('PIN-only decoy remains usable and clears its timer when leaving', () => {
+ jest.useFakeTimers();
+ try {
+ const { unmount } = render();
+ expect(screen.queryByLabelText('Operator ID')).not.toBeInTheDocument();
+ fireEvent.change(screen.getByLabelText('PIN'), { target: { value: '123456' } });
+ fireEvent.click(screen.getByRole('button', { name: '>_ Authenticate' }));
+ unmount();
+ expect(jest.getTimerCount()).toBe(0);
+ } finally { jest.useRealTimers(); }
+});
diff --git a/src/components/crypto-puzzle.tsx b/src/components/crypto-puzzle.tsx
index 0675143..fd21261 100644
--- a/src/components/crypto-puzzle.tsx
+++ b/src/components/crypto-puzzle.tsx
@@ -1,237 +1,80 @@
'use client';
-import { useState } from 'react';
-import { Button } from '@/components/ui/button';
-import { Input } from '@/components/ui/input';
-import { CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card';
-import { useToast } from '@/hooks/use-toast';
-import { Lock, Eye, EyeOff, Terminal, Key, Shield } from 'lucide-react';
-import PixelCard from './pixel-card';
-
-interface CryptoPuzzleProps {
- onSuccess: () => void;
-}
-
-export function CryptoPuzzle({ onSuccess }: CryptoPuzzleProps) {
- const [currentLevel, setCurrentLevel] = useState(1);
- const [userInput, setUserInput] = useState('');
- const [showHint, setShowHint] = useState(false);
+import { useRef, useState, type FormEvent } from 'react';
+import Link from 'next/link';
+import { Eye, Flag, Lock, RotateCcw } from 'lucide-react';
+import { SHADOW_TRACKS, type ShadowTrack } from '@/lib/shadow-challenges';
+
+export function CryptoPuzzle({ track = 'cipher' }: { track?: ShadowTrack }) {
+ const challenge = SHADOW_TRACKS[track];
+ const [level, setLevel] = useState(1);
+ const [answer, setAnswer] = useState('');
+ const [hint, setHint] = useState(false);
const [attempts, setAttempts] = useState(0);
- const [isChecking, setIsChecking] = useState(false);
- const { toast } = useToast();
-
- // Puzzle metadata only — solutions stay server-side
- const puzzles = [
- {
- title: "Level 1: ROT13 Cipher",
- description: "Decode this ROT13 encrypted message:",
- cipher: "nqzva",
- hint: "ROT13 shifts each letter by 13 positions in the alphabet",
- },
- {
- title: "Level 2: Base64 Decode",
- description: "Decode this Base64 string:",
- cipher: "YWRtaW4=",
- hint: "Base64 is a binary-to-text encoding scheme",
- },
- {
- title: "Level 3: Hex Decode",
- description: "Decode this hexadecimal string:",
- cipher: "61646d696e",
- hint: "Each pair of hex digits represents one ASCII character",
- },
- {
- title: "Level 4: Caesar Cipher",
- description: "Decode this Caesar cipher (shift by 3):",
- cipher: "dplq",
- hint: "Each letter is shifted 3 positions forward in the alphabet",
- },
- {
- title: "Level 5: Binary Decode",
- description: "Decode this binary string:",
- cipher: "01100001 01100100 01101101 01101001 01101110",
- hint: "Each 8-bit binary number represents one ASCII character",
- }
- ];
-
- const currentPuzzle = puzzles[currentLevel - 1];
-
- const checkAnswer = async () => {
- if (isChecking || !userInput.trim()) return;
-
- setIsChecking(true);
- setAttempts(attempts + 1);
-
+ const [busy, setBusy] = useState(false);
+ const [message, setMessage] = useState('');
+ const [flag, setFlag] = useState('');
+ const pending = useRef(false);
+ const input = useRef(null);
+ const puzzle = challenge.puzzles[level - 1];
+ const solved = flag ? challenge.puzzles.length : level - 1;
+
+ const submit = async (event: FormEvent) => {
+ event.preventDefault();
+ if (pending.current || !answer.trim() || flag) return;
+ pending.current = true;
+ setBusy(true);
+ setMessage('');
try {
const response = await fetch('/api/ctf/verify', {
- method: 'POST',
- headers: { 'Content-Type': 'application/json' },
- body: JSON.stringify({ level: currentLevel, answer: userInput }),
+ method: 'POST', headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({ track, level, answer }), signal: AbortSignal.timeout(10000),
});
-
const result = await response.json();
-
- if (!response.ok) {
- toast({
- title: "Error",
- description: result.error || "Something went wrong",
- variant: "destructive",
- });
- return;
- }
-
- if (result.correct) {
- if (result.isLastLevel) {
- toast({
- title: "🎉 Puzzle Complete!",
- description: "All levels solved! Access granted.",
- });
- onSuccess();
- } else {
- setCurrentLevel(currentLevel + 1);
- setUserInput('');
- setAttempts(0);
- setShowHint(false);
- toast({
- title: "Correct!",
- description: `Level ${currentLevel} completed. Moving to level ${currentLevel + 1}...`,
- });
- }
+ if (!response.ok) { setMessage(result.error || 'Verification unavailable. Try again.'); return; }
+ if (!result.correct) {
+ setAttempts((value) => value + 1);
+ if (attempts >= 2) setHint(true);
+ setMessage('Signal mismatch. Try another answer.');
+ } else if (result.isLastLevel && result.flag) {
+ setFlag(result.flag);
+ setAnswer('');
} else {
- toast({
- title: "Incorrect",
- description: `Wrong answer. Attempts: ${attempts + 1}`,
- variant: "destructive",
- });
-
- if (attempts >= 2) {
- setShowHint(true);
- }
+ setLevel((value) => value + 1);
+ setAnswer(''); setHint(false); setAttempts(0);
+ setMessage('Lock opened. Next signal ready.');
}
- } catch {
- toast({
- title: "Error",
- description: "Could not verify answer. Please try again.",
- variant: "destructive",
- });
- } finally {
- setIsChecking(false);
- }
- };
-
- const handleKeyDown = (e: React.KeyboardEvent) => {
- if (e.key === 'Enter') {
- checkAnswer();
- }
+ } catch { setMessage('Uplink interrupted. Your progress is intact; try again.'); }
+ finally { pending.current = false; setBusy(false); }
};
+ const reset = () => { setLevel(1); setAnswer(''); setHint(false); setAttempts(0); setFlag(''); setMessage(''); };
return (
-
-
-
-
-
-
-
- 🔐 Cryptographic Challenge
-
-
- Prove your hacking skills by solving these cryptographic puzzles
-
-
-
-
- {/* Progress Bar */}
-
-
- Progress
- {currentLevel} / {puzzles.length}
-
-
-
-
- {/* Current Puzzle */}
-
-
-
-
{currentPuzzle.title}
-
-
-
{currentPuzzle.description}
-
-
-
-
- Ciphertext:
-
-
{currentPuzzle.cipher}
-
-
- {/* Hint */}
- {showHint && (
-
-
-
- Hint:
-
-
{currentPuzzle.hint}
-
- )}
-
- {/* Input */}
-
-
-
- setUserInput(e.target.value)}
- onKeyDown={handleKeyDown}
- placeholder="Enter decoded text..."
- className="font-mono"
- disabled={isChecking}
- />
-
-
-
-
- {/* Hint Toggle */}
-
-
-
-
- Attempts: {attempts}
-
-
-
-
- {/* Instructions */}
-
-
💡 Instructions:
-
- - • Solve each cryptographic puzzle in order
- - • Enter the decoded plaintext (lowercase)
- - • Use hints if you get stuck (after 3 attempts)
- - • Complete all levels to gain admin access
-
-
-
+
+ Access protocol // {track}{flag ? 'Signal recovered' : 'Awaiting response'}
+
+
+
+
{challenge.title}
+
{challenge.subtitle}
+ {flag ?
Transmission complete
{flag}You reached the end of this simulation. The terminal has no administrative privileges.
Follow another signal →
: <>
+
Lock {level}{' // '}{puzzle.title}
+
{puzzle.description}
+
{puzzle.cipher}
+
+
{message}
+
ATTEMPTS // {attempts}
+ {hint &&
{puzzle.hint}
}
+
Decode in order. Answers ignore letter case and outer whitespace. A clue appears after three wrong answers.
+ >}
+
-
+
);
}
diff --git a/src/components/decoy-login.tsx b/src/components/decoy-login.tsx
new file mode 100644
index 0000000..70b4e35
--- /dev/null
+++ b/src/components/decoy-login.tsx
@@ -0,0 +1,42 @@
+'use client';
+
+import { useEffect, useRef, useState, type FormEvent } from 'react';
+import { Lock, Terminal } from 'lucide-react';
+
+/** A local simulation: never sends, stores, or authenticates entered credentials. */
+export function DecoyLogin({ title = 'Admin access', code = 'ADM-01', pinOnly = false }: { title?: string; code?: string; pinOnly?: boolean }) {
+ const [identity, setIdentity] = useState('');
+ const [password, setPassword] = useState('');
+ const [busy, setBusy] = useState(false);
+ const [failed, setFailed] = useState(false);
+ const timer = useRef
| null>(null);
+ useEffect(() => () => { if (timer.current) clearTimeout(timer.current); }, []);
+ const submit = (event: FormEvent) => {
+ event.preventDefault();
+ if (busy || !password.trim() || (!pinOnly && !identity.trim())) return;
+ setBusy(true);
+ setFailed(false);
+ // Discard the input immediately; retain only the simulated pending state.
+ setPassword('');
+ setIdentity('');
+ timer.current = setTimeout(() => { setBusy(false); setFailed(true); }, 1100);
+ };
+ const inputClass = 'w-full border border-signal/40 bg-ink px-4 py-3 font-mono text-sm text-bone outline-none focus:border-cyan disabled:opacity-50';
+ return (
+
+ authentication terminal{code}
+
+
+
{title}
+
Operator verification required.
+
+
Restricted console // session unavailable
+
+
+ );
+}
diff --git a/src/components/shadow-shell.tsx b/src/components/shadow-shell.tsx
new file mode 100644
index 0000000..4c38ff2
--- /dev/null
+++ b/src/components/shadow-shell.tsx
@@ -0,0 +1,18 @@
+import Link from 'next/link';
+import { Terminal, Shield } from 'lucide-react';
+import type { ReactNode } from 'react';
+
+export const shadowMetadata = { title: 'Restricted terminal | Bikram Dey', robots: { index: false, follow: false } };
+
+export function ShadowShell({ children, label }: { children: ReactNode; label: string }) {
+ return (
+
+
+ {children}
+
+
+ );
+}
diff --git a/src/lib/shadow-challenges.ts b/src/lib/shadow-challenges.ts
new file mode 100644
index 0000000..44e1238
--- /dev/null
+++ b/src/lib/shadow-challenges.ts
@@ -0,0 +1,32 @@
+export const SHADOW_TRACKS = {
+ cipher: {
+ title: 'Shadow protocol', subtitle: 'Five locks. One signal. Follow the trail.',
+ puzzles: [
+ { title: 'ROT13', description: 'Recover the callsign from this intercepted message.', cipher: 'funqbj', hint: 'Rotate each letter by 13 positions.' },
+ { title: 'Base64', description: 'Decode the transport payload.', cipher: 'Y3Jvdw==', hint: 'Base64 encodes bytes as printable text. It is not encryption.' },
+ { title: 'Hex dump', description: 'Read the ASCII bytes recovered from memory.', cipher: '67656e6a75747375', hint: 'Split into pairs. Each hexadecimal byte maps to one character.' },
+ { title: 'Caesar +3', description: 'Undo the three-position alphabet shift.', cipher: 'flskhu', hint: 'Move each letter three positions backward.' },
+ { title: 'Binary signal', description: 'Reassemble the final plaintext.', cipher: '01100101 01110011 01100011 01100001 01110000 01100101', hint: 'Each group is an 8-bit ASCII character.' },
+ ],
+ },
+ archive: {
+ title: 'Archive recovery', subtitle: 'The backup is locked. Read what was left behind.',
+ puzzles: [
+ { title: 'Escaped path', description: 'Decode the percent-encoded directory name.', cipher: '%76%61%75%6c%74', hint: 'Each %xx represents one hexadecimal byte.' },
+ { title: 'Mirror file', description: 'A damaged log was written in reverse. Restore it.', cipher: 'evihcra', hint: 'Read from right to left.' },
+ { title: 'Nested transport', description: 'Decode Base64, then decode the resulting hexadecimal text.', cipher: 'NjU2MzY4NmY=', hint: 'There are two layers. The intermediate result contains hex pairs.' },
+ ],
+ },
+ signal: {
+ title: 'Root signal', subtitle: 'A quiet channel is still a channel.',
+ puzzles: [
+ { title: 'Morse transmission', description: 'Decode the intercepted word.', cipher: '.-. --- --- -', hint: 'Spaces separate letters. Dot-dash-dot is R.' },
+ { title: 'Decimal memory', description: 'Convert the decimal ASCII bytes to text.', cipher: '115 112 101 99 116 114 101', hint: '115 is the lowercase letter s.' },
+ { title: 'Alphabet mirror', description: 'Decode the Atbash message.', cipher: 'gizro', hint: 'A maps to Z, B to Y. Mirror the alphabet.' },
+ ],
+ },
+} as const;
+
+export type ShadowTrack = keyof typeof SHADOW_TRACKS;
+
+export const DECOY_PATHS = ['/admin', '/administrator', '/wp-admin', '/cpanel', '/admin/login', '/dashboard/login', '/b1kr4m-5h4d0w', '/admin/access', '/admin/backup', '/root'] as const;
diff --git a/src/middleware.ts b/src/middleware.ts
index 5bdf44f..79f5e4e 100644
--- a/src/middleware.ts
+++ b/src/middleware.ts
@@ -1,4 +1,5 @@
import { NextResponse, type NextRequest } from 'next/server';
+import { DECOY_PATHS } from '@/lib/shadow-challenges';
function tryBase64Decode(segment: string): string | null {
try {
@@ -55,6 +56,12 @@ export function middleware(request: NextRequest) {
const { pathname } = request.nextUrl;
const isAuthenticated = hasValidSession(request);
+ if ((DECOY_PATHS as readonly string[]).includes(pathname)) {
+ const response = addSecurityHeaders(NextResponse.next());
+ response.headers.set('X-Robots-Tag', 'noindex, nofollow');
+ return response;
+ }
+
// Allow public access portal (obfuscated)
if (pathname === '/b1kr4m-5h4d0w') {
return addSecurityHeaders(NextResponse.next());