nehonix-uri-processor
Version:
A powerful URI processor for encoding, decoding, and analyzing URI data securely.
161 lines • 6.07 kB
JavaScript
import { NSB } from "../../services/NehonixSecurityBooster.service";
import { AppLogger } from "../../common/AppLogger";
/**
* NSB Express middleware for securing incoming requests
* @param options - Middleware options
* @returns Express middleware function
*/
export const nehonixShieldMiddleware = (options = {}) => {
return async (req, res, next) => {
try {
const fullUrl = `${req.protocol}://${req.get("host")}${req.originalUrl}`;
let result = {
confidence: "low",
detectedPatterns: [],
isMalicious: false,
recommendation: "No issues detected.",
score: 0,
contextAnalysis: {
relatedPatterns: [],
entropyScore: 0,
anomalyScore: 0,
encodingLayers: 0,
},
};
const hostHeader = req.get("Host") || "";
const queryString = new URLSearchParams(req.query).toString();
const bodyString = JSON.stringify(req.body);
const components = [
{
name: "url",
input: fullUrl,
},
{
input: `http://${hostHeader}`,
name: "headers",
},
{
input: `http://mock.nehonix.space?${queryString}`,
name: "query string",
},
{
input: `http://mock.nehonix.space?data=${encodeURIComponent(bodyString)}`,
name: "body string",
},
];
for (const v of components) {
await NSB.analyzeUrl(v.input, v.options || options);
}
if (options.logDetails) {
AppLogger.info(`NSB Analysis for ${fullUrl}:`, result);
}
if (result.isMalicious && options.blockOnMalicious) {
return res.status(403).json({
error: "Malicious request detected",
details: result.detectedPatterns,
recommendation: result.recommendation,
});
}
req.nehonixShield = result;
next();
}
catch (error) {
AppLogger.error("Nehonix Shield Middleware Error:", error);
next(error);
}
};
};
/**
* Utility to analyze specific request components
* @param req - Express request object
* @param components - Components to analyze (url, headers, query, body)
* @param options - NSB analysis options
* @returns Analysis result
*/
export const scanRequest = async (req, components = ["url"], options = {}) => {
const results = [];
if (components.includes("url")) {
const fullUrl = `${req.protocol}://${req.get("host")}${req.originalUrl}`;
const urlResult = await NSB.analyzeUrl(fullUrl, options);
results.push(urlResult);
}
if (components.includes("headers")) {
const hostHeader = req.get("Host") || "";
if (hostHeader) {
const headerResult = await NSB.analyzeUrl(`http://${hostHeader}`, options);
results.push(headerResult);
}
}
if (components.includes("query")) {
const queryString = new URLSearchParams(req.query).toString();
if (queryString) {
const queryResult = await NSB.analyzeUrl(`http://mock.nehonix.space?${queryString}`, options);
results.push(queryResult);
}
}
if (components.includes("body") && req.body) {
const bodyString = JSON.stringify(req.body);
if (bodyString) {
const bodyResult = await NSB.analyzeUrl(`http://mock.nehonix.space?data=${encodeURIComponent(bodyString)}`, options);
results.push(bodyResult);
}
}
return combineResults(results);
};
/**
* Combines multiple analysis results
*/
function combineResults(results) {
const combined = {
isMalicious: false,
detectedPatterns: [],
score: 0,
confidence: "low",
recommendation: "No issues detected.",
contextAnalysis: {
relatedPatterns: [],
entropyScore: 0,
anomalyScore: 0,
encodingLayers: 0,
},
};
results.forEach((result) => {
var _a, _b, _c;
combined.isMalicious = combined.isMalicious || result.isMalicious;
combined.detectedPatterns.push(...result.detectedPatterns);
combined.score += result.score;
combined.contextAnalysis.entropyScore +=
((_a = result.contextAnalysis) === null || _a === void 0 ? void 0 : _a.entropyScore) || 0;
combined.contextAnalysis.anomalyScore +=
((_b = result.contextAnalysis) === null || _b === void 0 ? void 0 : _b.anomalyScore) || 0;
combined.contextAnalysis.encodingLayers +=
((_c = result.contextAnalysis) === null || _c === void 0 ? void 0 : _c.encodingLayers) || 0;
if (result.confidence === "high") {
combined.confidence = "high";
}
else if (result.confidence === "medium" &&
combined.confidence !== "high") {
combined.confidence = "medium";
}
});
combined.detectedPatterns = deduplicatePatterns(combined.detectedPatterns);
combined.score = Math.min(combined.score, 200);
combined.recommendation = results.some((r) => r.isMalicious)
? "Malicious patterns detected. Review and mitigate."
: combined.recommendation;
return combined;
}
/**
* Deduplicates patterns
*/
function deduplicatePatterns(patterns) {
const seen = new Map();
patterns.forEach((pattern) => {
const key = `${pattern.type}:${pattern.matchedValue}:${pattern.location}`;
if (!seen.has(key)) {
seen.set(key, pattern);
}
});
return Array.from(seen.values());
}
//# sourceMappingURL=import%20%7B%20Request,%20Response,%20NextFunction.js.map