// Предположим, что params содержит пользовательский ввод, а text — узел DOM.
// Плохо: включение ненадёжного содержимого в HTML-теги.
const { user } = params;
// ...
text.innerHTML = `Follow @${user}`;

function htmlEncode(iStr) {
    let sStr = iStr;
    sStr = sStr.replace(/&/g, "&");
    sStr = sStr.replace(/>/g, ">");
    sStr = sStr.replace(/</g, "&lt;");
    sStr = sStr.replace(/"/g, "&quot;");
    sStr = sStr.replace(/'/g, "&#39;");
    return sStr;
}

let { user } = params;
user = htmlEncode(user);
// ...
text.innerHTML = `Follow @${user}`;

const { user } = params;
// ...
text.innerText = `Follow @${user}`;

// Хорошо: добавляем внешний CSS перед setAttribute.
function addExternalCss(e) {
  const t = document.createElement('link');
  t.setAttribute('href', e),
  t.setAttribute('rel', 'stylesheet'),
  t.setAttribute('type', 'text/css'),
  document.head.appendChild(t)
}

function validURL(sUrl) {
  return !!((/^(https?:\/\/)?[\w\-.]+\.(qq|tencent)\.com($|\/|\\)/i).test(sUrl) || (/^[\w][\w/.\-_%]+$/i).test(sUrl) || (/^[/\\][^/\\]/i).test(sUrl));
}

let sUrl = "https://evil.com/1.css"
if (validURL(sUrl)) {
  addExternalCss(sUrl);
}

// Плохо: добавление ненадёжных данных после использования .after().
const { user } = params;
// ...
$("p").after(user);

function htmlEncode(iStr) {
    let sStr = iStr;
    sStr = sStr.replace(/&/g, "&");
    sStr = sStr.replace(/>/g, ">");
    sStr = sStr.replace(/</g, "&lt;");
    sStr = sStr.replace(/"/g, "&quot;");
    sStr = sStr.replace(/'/g, "&#39;");
    return sStr;
}

// const user = params.user;
user = htmlEncode(user);
// ...
$("p").html(user);

// Плохо: прямое рендеринг ненадёжного контента
<div v-html="userProvidedHtml"></div>

// Хорошо: использование библиотеки фильтрации форматированного текста для обработки ненадёжного содержимого перед рендерингом
<!-- Использование -->
<div v-xss-html="{'mode': 'whitelist', dirty: html, options: options}" ></div>

<!-- Конфигурация -->
<script>
    new Vue({
        el: "#app",
        data: {
            options: {
                a: ["href", "title", "target", "class", "id"],
                div: ["class", "id"],
                span: ["class", "id"],
                img: ["src", "alt"],
            },
        },
    });
</script>

// Плохо: v-bind разрешает внешние значения, настраиваемые свойства CSS и числовые значения
<a v-bind:href="sanitizedUrl" v-bind:style="userProvidedStyles">
click me
</a>

// Хорошо: v-bind позволяет внешним значениям контролировать только определённые свойства CSS
<a v-bind:href="sanitizedUrl" v-bind:style="{
color: userProvidedColor,
background: userProvidedBackground
}">
click me
</a>

// Плохо: перенаправление на внешний ненадёжный адрес
const sTargetUrl = getURLParam("target");
location.replace(sTargetUrl);

// Хорошо: ограничение белого списка для перенаправления адреса
function validURL(sUrl) {
    return !!((/^(https?:\/\/)?[\w\-.]+\.(qq|tencent)\.com($|\/|\\)/i).test(sUrl) || (/^[\w][\w/.\-_%]+$/i).test(sUrl) || (/^[/\\][^/\\]/i).test(sUrl));
}

const sTargetUrl = getURLParam("target");
if (validURL(sTargetUrl)) {
    location.replace(sTargetUrl);
}

// Хорошо: определение фиксированного значения для перенаправления
const sTargetUrl = "http://www.qq.com";
location.replace(sTargetUrl);

// Плохо: прямой вызов eval для анализа json
const sUserInput = getURLParam("json_val");
const jsonstr1 = `{"name":"a","company":"b","value":"${sUserInput}"}`;
const json1 = eval(`(${jsonstr1})`);

// Хорошо: использовать JSON.parse для анализа
const sUserInput = getURLparam("json_val");
JSON.parse(sUserInput, (k, v) => {
    if (k === "") return v;
    return v * 2;
});

// Хорошо: в старых браузерах использовать безопасный Polyfill для замены eval()
<script src="https://github.com/douglascrockford/JSON-js/blob/master/json2.js"></script>;
const sUserInput = getURLparam("json_val");
JSON.parse(sUserInput);

// Плохо: использование indexOf для проверки Origin
window.addEventListener("message", (e) => {
    if (~e.origin.indexOf("https://a.qq.com")) {
        // ...
    } else {
        // ...
    }
});

// Хорошо: при использовании postMessage ограничьте Origin и используйте === для сравнения
window.addEventListener("message", (e) => {
    if (e.origin === "https://a.qq.com") {
        // ...
    }
});
``` **res.send({  
    data: txt,  
});  
});**

// Хорошо: проверка данных по типу, для ввода
const Router = require("express").Router();
const validator = require("validator");

Router.get("/email_with_validator", (req, res) => {
    const txt = req.query.txt || "";
    if (validator.isEmail(txt)) {
        res.send({
            data: txt
        });
    } else {
        res.send({ err: 1 });
    }
});

*Связанные уязвимости: защита от проникновения на глубину — функции повышения безопасности*

#### 1.2 Выполнение команды

**1.2.1 [Обязательно] использовать child_process для выполнения системных команд, ограничивая или проверяя содержимое команд и параметров**

- Применимые сценарии включают: `child_process.exec`, `child_process.execSync`, `child_process.spawn`, `child_process.spawnSync`, `child_process.execFile`, `child_process.execFileSync`

- Вызывая вышеуказанные функции, следует сначала рассмотреть ограничение диапазона, предоставляя выбор пользователю.

- Используя `child_process.exec` или `child_process.execSync`, если можно перечислить входные параметры или формат, необходимо ограничить белый список. Если невозможно перечислить команду или параметр, необходимо фильтровать или экранировать определённые символы, включая: ```|;&$()><`!```

- Используя `child_process.spawn` или `child_process.execFile`, следует проверять передаваемые команды и параметры в контролируемом списке.

```js
const Router = require('express').Router;
const validator = require('validator');
const { exec } = require('child_process');

// Плохо: не ограничено или не отфильтровано, команда выполняется напрямую
Router.get('/vul_cmd_inject', (req, res) => {
    const txt = req.query.txt || 'echo 1';
    exec(txt, (err, stdout, stderr) => {
        if (err) { res.send({ err: 1 }) }
        res.send({ stdout, stderr });
    });
});

// Хорошо: использование белого списка для ограничения диапазона внешних исполняемых команд
Router.get('/not_vul_cmd_inject', (req, res) => {
    const txt = req.query.txt || 'echo 1';
  const phone = req.query.phone || '';
    const cmdList = {
        sendmsg: './sendmsg '
    };
    if (txt in cmdList && validator.isMobilePhone(phone)) {
        exec(cmdList[txt] + phone, (err, stdout, stderr) => {
          if (err) { res.send({ err: 1 }) };
          res.send({stdout, stderr});
        });
    } else {
        res.send({
            err: 1,
            tips: `you can use '${Object.keys(cmdList)}'`,
        });
    }
});

// Хорошо: фильтрация/экранирование определённых символов перед выполнением команды
Router.get('/not_vul_cmd_inject', (req, res) => {
    const txt = req.query.txt || 'echo 1';
  let phone = req.query.phone || '';
    const cmdList = {
        sendmsg: './sendmsg '
    };
    phone = phone.replace(/(\||;|&|\$\(|\(|\)|>|<|\`|!)/gi, '');
    if (txt in cmdList) {
        exec(cmdList[txt] + phone, (err, stdout, stderr) => {
          if (err) { res.send({ err: 1 }) };
          res.send({stdout, stderr});
        });
    } else {
        res.send({
            err: 1,
            tips: `you can use '${Object.keys(cmdList)}'`,
        });
    }
});

Связанные уязвимости: высокий риск — выполнение произвольной команды*

#### 1.3 Операции с файлами

**1.3.1 [Обязательно] ограничивать диапазон операций с файлами по расширению**

- В соответствии с бизнес-требованиями используйте белый список для ограничения расширения файлов.

**1.3.2 [Обязательно] проверять и ограничивать диапазон путей к файлам**

- Следует установить фиксированный путь для загрузки и доступа к файлам. Если необходимо объединить внешние переменные значения, проверьте, содержат ли они `..` или `.`, что может привести к переходу по пути. Если они присутствуют, их следует отклонить.

- Когда используются методы функций модуля `fs`, такие как `fs.truncate`, `fs.truncateSync`, `fs.chown`, `fs.chownSync`, `fs.lchown`, `fs.lchownSync`, `fs.stat`, `fs.lchmodSync`, `fs.lstat`, `fs.statSync`, `fs.lstatSync`, `fs.readlink`, `fs.unlink`, `fs.unlinkSync`, `fs.rmdir`, `fs.rmdirSync`, `fs.mkdir`, `fs.mkdirSync`, `fs.readdir`, `fs.readdirSync`, `fs.openSync`, `fs.open`, `fs.createReadStream`, `fs.createWriteStream`, следует проверить первый параметр, который является частью пути, чтобы убедиться, что он не содержит символов перехода по пути `.` или `..`.

- Если используется метод `sendFile` фреймворка express, следует проверить первый параметр, являющийся частью пути, чтобы убедиться, что он не содержит символы перехода по пути `.` или `..`.

- Во время проверки следует использовать значение параметра пути до обработки модулем `path`, или определить, выходит ли обработанный путь за пределы текущего рабочего каталога. Методы, которые могут быть использованы, включают, но не ограничиваются: `path.resolve`, `path.join`, `path.normalize` и т. д.

```javascript
const fs = require('fs');
const path = require('path');
let filename = req.query.ufile;
let root = '/data/ufile';

// Плохо: путь к файлу не проверяется
fs.readFile(root + filename, (err, data) => {
    if (err) {
        return console.error(err);
    }
    console.log(`异步读取: ${data.toString()}`);
});

// Плохо: после обработки пути модулем path всё ещё существует риск перехода по пути
filename = path.join(root, filename);
if (filename.indexOf('..') < 0) {
    fs.readFile(filename, (err, data) => {
        if (err) {
            return console.error(err);
        }
        console.log(data.toString());
    });
};

// Хорошо: проверяется имя файла/путь, наличие символов перехода по пути . или ..
if (filename.indexOf('..') < 0) {
    filename = path.join(root, filename);
    fs.readFile(filename, (err, data) => {
        if (err) {
            return console.error(err);
        }
        console.log(data.toString());
    });
};

// Пример использования express и MongoDB (mongoose) для удаления статьи
// Плохо: перед удалением статьи не выполняется проверка прав доступа.
app.post("/deleteArticle", (req, res) => {
    db.articles.deleteOne({ article_id: req.body.article_id }, (err, users) => {
        // TODO: обработать остальное
    });
});

// Хорошо: перед выполнением операции NoSQL выполняется проверка прав доступа
app.post("/deleteArticle", (req, res) => {
    checkPriviledge(ctx.uin, req.body.article_id);
    db.articles.deleteOne({ article_id: req.body.article_id }, (err, users) => {
        // TODO: обработать остальное
    });
});

// Плохо: пользовательский ввод заменяет шаблон
const app = new Vue({
    template: appTemplate.replace("word", __USER_INPUT__),
});
renderer.renderToString(app);

// Плохо: после рендеринга HTML снова добавляется ненадёжный ввод
return new Promise(((resolve) => {
    renderer.renderToString(component, (err, html) => {
        let htmlOutput = html;
        htmlOutput += `${__USER_INPUT__}`;
        resolve(htmlOutput);
    });
}));

// Плохо: ввод пользователя отправляется в шаблон
const compiled = _.template(`<b>${__USER_INPUT__}<%- value %></b>`);
compiled({ value: "hello" });

// Плохо: ввод пользователя отправляется в шаблон
const ejs = require("ejs");
const people = ["geddy", "neil", "alex"];
const html = ejs.render(`<%= people.join(", "); %>${__USER_INPUT__}`, { people });

// Использование Express для успешной обработки входа

// Плохо: не проверяет адрес перенаправления
app.get("/login", (req, res) => {
    // Если неавторизованный пользователь пытается получить доступ к другой странице, он перенаправляется на эту функцию для входа
  // Сохраняем предыдущий адрес попытки доступа в параметре loginCallbackUrl, и после успешного входа перенаправляем на loginCallbackUrl:
    const { loginCallbackUrl } = req.query;
    if (loginCallbackUrl) {
        res.redirect(loginCallbackUrl);
    }
});

function isValidURL(sUrl) {
    return !!((/^(https?:\/\/)?[\w\-.]+\.(qq|tencent)\.com($|\/|\\)/i).test(sUrl) || (/^[\w][\w/.\-_%]+$/i).test(sUrl) || (/^[/\\][^/\\]/i).test(sUrl));
}
app.get("/login", (req, res) => {
    // Если неавторизованный пользователь пытается получить доступ к другой странице, он перенаправляется на эту функцию для входа
  // Сохраняем предыдущий адрес попытки доступа в параметре loginCallbackUrl, и после успешного входа перенаправляем на loginCallbackUrl:
    const { loginCallbackUrl } = req.query;
    if (loginCallbackUrl && isValidUrl(loginCallbackUrl)) {
        res.redirect(loginCallbackUrl);
    }
});

function isValidURL(sUrl) {
    return !!((/^(https?:\/\/)?[\w\-.]+\.(qq|tencent)\.com($|\/|\\)/i).test(sUrl) || (/^[\w][\w/.\-_%]+$/i).test(sUrl) || (/^[/\\][^/\\]/i).test(sUrl)));
}
app.get("/login", (req, res) => {
    // Если неавторизованный пользователь пытается получить доступ к другой странице, он перенаправляется на эту функцию для входа
  // Сохраняем предыдущий адрес попытки доступа в параметре loginCallbackUrl, и после успешного входа перенаправляем на loginCallbackUrl:
    const { loginCallbackUrl } = req.query;
    if (loginCallbackUrl && isValidUrl(loginCallbackUrl)) {
        const redirectHtml = `<script>location.href = "${encodeURI(loginCallbackUrl)}";</script>`;
        res.end(redirectHtml);
    }
});