108 líneas
2.8 KiB
TypeScript
108 líneas
2.8 KiB
TypeScript
import { NextRequest, NextResponse } from 'next/server';
|
|
import { storeHashDocument, findByPlaintext, findByHash, initializeRedis } from '@/lib/redis';
|
|
import { generateHashes, detectHashType } from '@/lib/hash';
|
|
|
|
export async function POST(request: NextRequest) {
|
|
try {
|
|
const { query } = await request.json();
|
|
|
|
if (!query || typeof query !== 'string') {
|
|
return NextResponse.json(
|
|
{ error: 'Query parameter is required' },
|
|
{ status: 400 }
|
|
);
|
|
}
|
|
|
|
// Ensure Redis is connected
|
|
await initializeRedis();
|
|
|
|
const cleanQuery = query.trim().split(/\s+/)[0];
|
|
|
|
if (!cleanQuery) {
|
|
return NextResponse.json(
|
|
{ error: 'Invalid query: only whitespace provided' },
|
|
{ status: 400 }
|
|
);
|
|
}
|
|
|
|
const cleanQueryLower = cleanQuery.toLowerCase();
|
|
const hashType = detectHashType(cleanQueryLower);
|
|
|
|
if (hashType) {
|
|
// Query is a hash - search for it in Redis
|
|
const doc = await findByHash(hashType, cleanQueryLower);
|
|
|
|
if (doc) {
|
|
// Found matching plaintext
|
|
return NextResponse.json({
|
|
found: true,
|
|
hashType,
|
|
hash: cleanQuery,
|
|
results: [{
|
|
plaintext: doc.plaintext,
|
|
hashes: {
|
|
md5: doc.md5,
|
|
sha1: doc.sha1,
|
|
sha256: doc.sha256,
|
|
sha512: doc.sha512,
|
|
}
|
|
}]
|
|
});
|
|
} else {
|
|
// Hash not found in database
|
|
return NextResponse.json({
|
|
found: false,
|
|
hashType,
|
|
hash: cleanQuery,
|
|
message: 'Hash not found in database'
|
|
});
|
|
}
|
|
} else {
|
|
// Query is plaintext - check if it already exists first
|
|
const existingDoc = await findByPlaintext(cleanQuery);
|
|
|
|
let hashes;
|
|
let wasGenerated = false;
|
|
|
|
if (existingDoc) {
|
|
// Plaintext found, retrieve existing hashes
|
|
hashes = {
|
|
md5: existingDoc.md5,
|
|
sha1: existingDoc.sha1,
|
|
sha256: existingDoc.sha256,
|
|
sha512: existingDoc.sha512,
|
|
};
|
|
} else {
|
|
// Plaintext not found, generate and store hashes
|
|
hashes = await generateHashes(cleanQuery);
|
|
|
|
await storeHashDocument({
|
|
...hashes,
|
|
created_at: new Date().toISOString()
|
|
});
|
|
|
|
wasGenerated = true;
|
|
}
|
|
|
|
return NextResponse.json({
|
|
found: true,
|
|
isPlaintext: true,
|
|
plaintext: cleanQuery,
|
|
wasGenerated,
|
|
hashes: {
|
|
md5: hashes.md5,
|
|
sha1: hashes.sha1,
|
|
sha256: hashes.sha256,
|
|
sha512: hashes.sha512,
|
|
}
|
|
});
|
|
}
|
|
} catch (error) {
|
|
console.error('Search error:', error);
|
|
return NextResponse.json(
|
|
{ error: 'Internal server error', details: error instanceof Error ? error.message : 'Unknown error' },
|
|
{ status: 500 }
|
|
);
|
|
}
|
|
}
|