Review this RESTlet for security issues.
Load the injection prevention reference.
Load the CSP header templates appendix.

/**
 * Shared validation utilities.
 *
 * @NApiVersion 2.1
 * @NModuleScope Public
 * @module ./lib/SecurityValidation
 */
define(['N/error'], (error) => {

    /**
     * Validate that a value is a positive integer.
     * @param {*} val - The value to validate.
     * @param {string} fieldName - The field name for error messages.
     * @returns {number} The parsed integer.
     */
    const requirePositiveInt = (val, fieldName) => {
        const n = parseInt(val, 10);
        if (isNaN(n) || n < 1) {
            throw error.create({
                name: 'INVALID_INPUT',
                message: `${fieldName} must be a positive integer.`,
                notifyOff: true
            });
        }
        return n;
    };

    /**
     * Validate that a value is one of an allowed set.
     * @param {*} val - The value to validate.
     * @param {Array} allowed - The allowed values.
     * @param {string} fieldName - The field name for error messages.
     * @returns {*} The validated value.
     */
    const requireEnum = (val, allowed, fieldName) => {
        if (!allowed.includes(val)) {
            throw error.create({
                name: 'INVALID_INPUT',
                message: `${fieldName} must be one of: ${allowed.join(', ')}`,
                notifyOff: true
            });
        }
        return val;
    };

    /**
     * Validate that a string matches an alphanumeric pattern.
     * Use for structured identifiers, codes, and keys.
     * @param {string} val - The value to validate.
     * @param {string} fieldName - The field name for error messages.
     * @param {number} [maxLength=200] - Maximum allowed length.
     * @returns {string} The validated string.
     */
    const requireAlphanumeric = (val, fieldName, maxLength) => {
        maxLength = maxLength || 200;
        if (typeof val !== 'string' || val.length === 0 || val.length > maxLength) {
            throw error.create({
                name: 'INVALID_INPUT',
                message: `${fieldName} must be a non-empty string up to ${maxLength} characters.`,
                notifyOff: true
            });
        }
        if (!/^[a-zA-Z0-9_-]+$/.test(val)) {
            throw error.create({
                name: 'INVALID_INPUT',
                message: `${fieldName} contains disallowed characters. Only alphanumeric, hyphens, and underscores are permitted.`,
                notifyOff: true
            });
        }
        return val;
    };

    /**
     * Sanitize a string for safe inclusion in HTML body context.
     * Encodes the five critical HTML characters as entities.
     * @param {*} val - The value to sanitize.
     * @returns {string} The HTML-safe string.
     */
    const sanitizeHtml = (val) => {
        if (val == null) return '';
        return String(val)
            .replace(/&/g, '&amp;')
            .replace(/</g, '&lt;')
            .replace(/>/g, '&gt;')
            .replace(/"/g, '&quot;')
            .replace(/'/g, '&#x27;');
    };

    /**
     * Sanitize a value for safe inclusion in log messages.
     * Strips newlines, control characters, and truncates.
     * @param {*} val - The value to sanitize.
     * @param {number} [maxLength=500] - Maximum output length.
     * @returns {string} The log-safe string.
     */
    const sanitizeForLog = (val) => {
        return String(val)
            .replace(/[\r\n]/g, ' ')
            .replace(/[\x00-\x1F]/g, '')
            .substring(0, 500);
    };

    return {
        requirePositiveInt,
        requireEnum,
        requireAlphanumeric,
        sanitizeHtml,
        sanitizeForLog
    };
});

define(['./lib/encoding', './lib/SecurityValidation'], (enc, validate) => {
    // enc.forHtml(), enc.forAttribute(), enc.forJavaScript(), enc.forUrl(), enc.forCss()
    // validate.requirePositiveInt(), validate.sanitizeHtml(), etc.
});

/**
 * Security configuration constants.
 *
 * @NApiVersion 2.1
 * @NModuleScope Public
 * @module ./lib/SecurityConfig
 */
define([], () => {
    return Object.freeze({
        ALLOWED_ROLES: Object.freeze({
            ADMIN: [3],
            FINANCE: [3, 1032, 1045],
            READ_ONLY: [3, 1032, 1045, 1060]
        }),
        FILE_UPLOAD: Object.freeze({
            ALLOWED_EXTENSIONS: ['.pdf', '.csv', '.xlsx', '.png', '.jpg', '.jpeg'],
            MAX_SIZE_BYTES: 10 * 1024 * 1024,
            UPLOAD_FOLDER_PARAM: 'custscript_upload_folder_id'
        }),
        RATE_LIMIT: Object.freeze({
            MAX_REQUESTS: 100,
            WINDOW_SECONDS: 3600
        }),
        CSP_DIRECTIVES: Object.freeze([
            "default-src 'self'",
            "script-src 'self' https://*.netsuite.com",
            "style-src 'self' 'unsafe-inline' https://*.netsuite.com",
            "img-src 'self' data: https://*.netsuite.com",
            "frame-ancestors 'self' https://*.netsuite.com",
            "form-action 'self'",
            "base-uri 'self'"
        ])
    });
});

// ===== BAD: String concatenation in SuiteQL =====
/**
 * @NApiVersion 2.1
 * @NScriptType Suitelet
 */
define(['N/query'], (query) => {
    const onRequest = (context) => {
        const name = context.request.parameters.customerName;
        // VULNERABLE: attacker sends name = "' OR '1'='1"
        const sql = "SELECT id, companyname FROM customer WHERE companyname = '" + name + "'";
        const results = query.runSuiteQL({ query: sql });
        context.response.write(JSON.stringify(results.asMappedResults()));
    };
    return { onRequest };
});

// ===== GOOD: Parameterized query with ? placeholders =====
/**
 * @NApiVersion 2.1
 * @NScriptType Suitelet
 */
define(['N/query'], (query) => {
    const onRequest = (context) => {
        const name = context.request.parameters.customerName;
        // SAFE: params array escapes all values; injection is impossible
        const sql = "SELECT id, companyname FROM customer WHERE companyname = ?";
        const results = query.runSuiteQL({ query: sql, params: [name] });
        context.response.write(JSON.stringify(results.asMappedResults()));
    };
    return { onRequest };
});

// ===== BAD: exec() with user-controlled input =====
const { exec } = require('child_process');

function runDeploy(projectName) {
    // VULNERABLE: projectName = "myproject; rm -rf /"
    exec(`sdfcli deploy -project ${projectName}`, (err, stdout) => {
        console.log(stdout);
    });
}

// ===== GOOD: execFile() with argument array (no shell) =====
const { execFile } = require('child_process');

function runDeploy(projectName) {
    // Validate against allowlist pattern first
    if (!/^[a-zA-Z0-9_-]+$/.test(projectName)) {
        throw new Error('Invalid project name. Only alphanumeric, hyphens, and underscores allowed.');
    }
    // SAFE: execFile does not spawn a shell; arguments passed directly
    execFile('sdfcli', ['deploy', '-project', projectName], (err, stdout) => {
        if (err) {
            console.error('Deploy failed:', err.message);
            return;
        }
        console.log(stdout);
    });
}

// ===== BAD: User input directly in header value =====
define([], () => {
    const onRequest = (context) => {
        const redirectUrl = context.request.parameters.redirect;
        // VULNERABLE: redirect = "https://ok.com\r\nSet-Cookie: admin=true"
        context.response.setHeader({ name: 'Location', value: redirectUrl });
        context.response.setStatus(302);
    };
    return { onRequest };
});

// ===== GOOD: Strip CRLF, validate against allowlist, and use redirect API =====
define(['N/redirect'], (redirect) => {
    const ALLOWED_URLS = [
        '/app/site/hosting/scriptlet.nl?script=123&deploy=1',
        '/app/site/hosting/scriptlet.nl?script=456&deploy=1'
    ];

    const sanitizeHeaderValue = (value) => {
        return String(value).replace(/[\r\n\x00]/g, '');
    };

    const onRequest = (context) => {
        const redirectUrl = sanitizeHeaderValue(context.request.parameters.redirect);
        if (!ALLOWED_URLS.includes(redirectUrl)) {
            context.response.write('Invalid redirect destination.');
            return;
        }
        // SAFE: use the documented redirect module instead of writing raw headers
        redirect.redirect({ url: redirectUrl });
    };
    return { onRequest };
});

// ===== BAD: Unescaped input in LDAP filter =====
define(['N/https'], (https) => {
    const lookupUser = (username) => {
        // VULNERABLE: username = "admin)(|(password=*))" exposes all passwords
        const filter = `(&(uid=${username})(objectClass=person))`;
        https.post({
            url: 'https://ldap-proxy.internal/search',
            body: JSON.stringify({ filter: filter }),
            headers: { 'Content-Type': 'application/json' }
        });
    };
});

// ===== GOOD: Escape LDAP special characters per RFC 4515 =====
define(['N/https'], (https) => {
    const escapeLdapFilter = (input) => {
        return String(input)
            .replace(/\\/g, '\\5c')
            .replace(/\*/g, '\\2a')
            .replace(/\(/g, '\\28')
            .replace(/\)/g, '\\29')
            .replace(/\x00/g, '\\00');
    };

    const lookupUser = (username) => {
        const safeUsername = escapeLdapFilter(username);
        const filter = `(&(uid=${safeUsername})(objectClass=person))`;
        https.post({
            url: 'https://ldap-proxy.internal/search',
            body: JSON.stringify({ filter: filter }),
            headers: { 'Content-Type': 'application/json' }
        });
    };
});

// ===== BAD: Raw user input in log message =====
define(['N/log'], (log) => {
    const onRequest = (context) => {
        const searchTerm = context.request.parameters.q;
        // VULNERABLE: searchTerm = "test\nlog.audit('Admin','Fake admin entry')"
        log.audit('Search', 'User searched for: ' + searchTerm);
    };
});

// ===== GOOD: Sanitize before logging =====
define(['N/log'], (log) => {
    const safeLogValue = (val) => {
        return String(val)
            .replace(/[\r\n]/g, ' ')
            .replace(/[\x00-\x1F]/g, '')
            .substring(0, 500);
    };

    const onRequest = (context) => {
        const searchTerm = context.request.parameters.q;
        // SAFE: newlines and control characters stripped
        log.audit('Search', 'User searched for: ' + safeLogValue(searchTerm));
    };
});

// ===== BAD: Hardcoded API key =====
define(['N/https'], (https) => {
    const execute = () => {
        // VULNERABLE: key visible in source, version control, and logs
        const API_KEY = 'sk-prod-a8f3k29d5e7b1c4f6';
        https.post({
            url: 'https://api.vendor.com/data',
            headers: { 'Authorization': `Bearer ${API_KEY}` },
            body: '{}'
        });
    };
});

// ===== GOOD: Credentials from Script Parameters =====
/**
 * @NApiVersion 2.1
 * @NScriptType ScheduledScript
 */
define(['N/https', 'N/runtime', 'N/error'], (https, runtime, error) => {
    const execute = () => {
        const script = runtime.getCurrentScript();
        const apiKey = script.getParameter({ name: 'custscript_vendor_api_key' });

        if (!apiKey) {
            throw error.create({
                name: 'MISSING_CONFIG',
                message: 'API key not configured in script deployment parameters.'
            });
        }

        https.post({
            url: 'https://api.vendor.com/data',
            headers: { 'Authorization': `Bearer ${apiKey}` },
            body: '{}'
        });
    };
    return { execute };
});

// ===== BAD: Session ID from URL parameter =====
define(['N/cache'], (cache) => {
    const onRequest = (context) => {
        // VULNERABLE: attacker sets sessionId before victim logs in
        const sessionId = context.request.parameters.sessionId;
        const sessionCache = cache.getCache({ name: 'SESSIONS' });
        let data = sessionCache.get({ key: sessionId });
        if (!data) {
            sessionCache.put({ key: sessionId, value: '{}', ttl: 1800 });
        }
    };
});