Datasets:

LINKER98

/

secusLLM-Dataset

like 0

Javascript

입력데이터 검증 및 표현

SQL 삽입

SQL 질의문을 생성할 때 검증되지 않은 외부 입력값을 허용하여 악의적인 질의문이 실행가능한 보안약점

const mysql = require("mysql"); // 커넥션 초기화 옵션은 생략함 const connection = mysql.createConnection(...); router.get("/vuln/email", (req, res) => { const con = connection; const userInput = req.query.id; // 사용자로부터 입력받은 값을 검증 없이 그대로 쿼리에 사용 const query = `SELECT email FROM user WHERE user_id = ${userInput}`; con.query(query, (err, result) => { if (err) console.log(err); return res.send(result); } ); });

const mysql = require("mysql"); ... router.get("/patched/email", (req, res) => { const con = connection; const userInput = req.query.id; const query = ‘SELECT email FROM user WHERE user_id = ?‘; // 쿼리 함수에 사용자 입력값을 매개변수 형태로 전달, 이렇게 작성하면 사용자 입력값에 // escape 처리를 한 것과 동일한 결과가 실행 con.query(query, userInput, (err, result) => { if (err) console.log(err); return res.send(result); } ); });

Javascript

입력데이터 검증 및 표현

SQL 삽입

SQL 질의문을 생성할 때 검증되지 않은 외부 입력값을 허용하여 악의적인 질의문이 실행가능한 보안약점

const mysql = require("mysql"); const Sequelize = require("sequelize"); const { QueryTypes } = require(“sequelize”); // 커넥션 및 ORM 초기화 옵션은 생략함 const connection = mysql.createConnection(...); const sequelize = new Sequelize(...); router.get("/vuln/orm/email", (req, res) => { const userInput = req.query.id; // 사용자로부터 입력받은 값을 검증 없이 그대로 쿼리에 사용 const query = `SELECT email FROM user WHERE user_id = ${userInput}`; sequelize.query(query, { type: QueryTypes.SELECT }) .then((result) => { return res.send(result); }).catch((err) => { console.log(err); }); });

router.get("/vuln/orm/email", (req, res) => { const userInput = req.query.id; // 쿼리 내에서 바인딩이 필요한 부분을 $number로 표기 const query = `SELECT email FROM user WHERE user_id = $1`; // 인자화된 쿼리 기능을 통해 쿼리를 생성 및 실행 sequelize.query(query, { bind: [userInput], type: QueryTypes.SELECT }) .then((result) => { return res.send(result); }).catch((err) => { console.log(err); }); });

Javascript

입력데이터 검증 및 표현

코드 삽입

프로세스가 외부 입력값을 코드(명령어)로 해석·실행할 수 있고 프로세스에 검증되지 않은 외부 입력값을 허용한 경우 악의적인 코드가 실행 가능한 보안약점

const express = require('express'); router.post("/vuln/server", (req, res) => { // 사용자로부터 전달 받은 값을 그대로 eval 함수의 인자로 전달 const data = eval(req.body.data); return res.send({ data }); });

const express = require('express'); function alphanumeric(input_text) { // 정규표현식 기반 문자열 검사 const letterNumber = /^[0-9a-zA-Z]+$/; if (input_text.match(letterNumber)) { return true; } else { return false; } } router.post("/patched/server", (req, res) => { let ret = null; const { data } = req.body; // 사용자 입력을 영문, 숫자로 제한하며, 만약 입력값 내에 특수문자가 포함되어 // 있을 경우 에러 메시지를 반환 if (alphanumeric(data)) { ret = eval(data); } else { ret = ‘error’; } return res.send({ ret }); });

Javascript

입력데이터 검증 및 표현

경로 조작 및 자원 삽입

시스템 자원 접근경로 또는 자원제어 명령어에 검증되지 않은 외부 입력값을 허용하여 시스템 자원에 무단 접근 및 악의적인 행위가 가능한 보안약점

const express = require('express'); const path = require('path'); router.get("/vuln/file", (req, res) => { // 외부 입력값으로부터 파일명을 입력 받음 const requestFile = req.query.file; // 입력값을 검증 없이 파일 처리에 사용 fs.readFile(path.resolve(__dirname, requestFile), 'utf8', function(err, data) { if (err) { return res.send('error'); } return res.send(data); }) });

const express = require('express'); const path = require('path'); router.get("/patched/file", (req, res) => { const requestFile = req.query.file; // 정규표현식을 사용해 사용자 입력값을 필터링 const filtered = requestFile.replace(/[.\\\/]/gi, ''); fs.readFile(filtered, 'utf8', function(err, data) { if (err) { return res.send('error'); } return res.send(data); }) });

Javascript

입력데이터 검증 및 표현

경로 조작 및 자원 삽입

시스템 자원 접근경로 또는 자원제어 명령어에 검증되지 않은 외부 입력값을 허용하여 시스템 자원에 무단 접근 및 악의적인 행위가 가능한 보안약점

const express = require('express'); const io = require("socket.io"); router.get("/vuln/socket", (req, res) => { try { // 외부로부터 입력받은 검증되지 않은 주소를 이용하여 // 소켓을 바인딩 하여 사용하고 있어 안전하지 않음 const socket = io(req.query.url); return res.send(socket); } catch (err) { return res.send("[error] fail to connect"); } });

const express = require('express'); const io = require("socket.io"); router.get("/patched/socket", (req, res) => { // 화이트리스트 내에 속하는 주소만 허용 const whitelist = ["ws://localhost", "ws://127.0.0.1"]; if (whitelist.indexOf(req.query.url) < 0) { return res.send("wrong url"); } try { const socket = io(req.query.url); return res.send(socket); } catch (err) { return res.send("[error] fail to connect"); } });

Javascript

입력데이터 검증 및 표현

크로스사이트 스크립트(XSS)

사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 악의적인 스크립트가 실행 가능한 보안약점

<html> <body> <script> const query = "<script>alert('hello world')<"+"/script>"; async function req() { // 사용자가 에디터와 같은 입력 폼에 입력한 데이터를 서버에 저장 const response = await fetch(`/vuln/search?q=${query}`, { method: 'GET' }) const data = await response.text(); // 외부로부터 받은 데이터(HTML 코드)를 아무런 검증 없이 DOM으로 기록 document.write(data); } req(); </script> </body> </html>

<html> <body> <script> const query = "<script>alert('hello world')<"+"/script>"; async function req() { const response = await fetch(`/vuln/search?q=${query}`, { method: 'GET' }) const data = await response.text(); // 외부로부터 받은 데이터를 이스케이프 처리 후 사용 document.write(decodeURI(encodeURIComponent(data))); } req(); </script> </body> </html>

Javascript

입력데이터 검증 및 표현

크로스사이트 스크립트(XSS)

사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 악의적인 스크립트가 실행 가능한 보안약점

<html> <body> <script> const query = "<script>alert('hello world')<"+"/script>"; async function req() { // 사용자가 에디터와 같은 입력 폼에 입력한 데이터를 서버에 저장 const response = await fetch(`/vuln/search?q=${query}`, { method: 'GET' }) const data = await response.text(); // 외부로부터 받은 데이터(HTML 코드)를 아무런 검증 없이 DOM으로 기록 document.write(data); } req(); </script> </body> </html>

<html> <head> <script src="https://cdn.rawgit.com/yahoo/xss-filters/master/dist/xss-filters.js"></script> </head> <body> <script> async function req() { ... // xss-filters 라이브러리를 사용해 문자열을 이스케이프 처리 document.write(xssFilters.inHTMLData(data)); } req(); </script> </body> </html>

Javascript

입력데이터 검증 및 표현

크로스사이트 스크립트(XSS)

사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 악의적인 스크립트가 실행 가능한 보안약점

function possibleXSS() { return { __html: '<img src="https://upload.wikimedia.org/wikipedia/commons/a/a7/React-icon.svg“ onload="alert(1)"> </img>', }; } const App = ( ) => ( // XSS에 취약한 함수를 사용해 HTML 코드 데이터를 렌더링 <div dangerouslySetInnerHTML={possibleXSS()} /> ); ReactDOM.render(<App />, document.getElementById("root"));

<script src="https://cdnjs.cloudflare.com/ajax/libs/dompurify/2.4.0/purify.min.js"></script> ... function possibleXSS() { return { __html: // dompurify 라이브러리를 사용해 입력값을 이스케이프 처리 DOMPurify.sanitize('<img src="https://upload.wikimedia.org/wikipedia/commons/ a/a7/React-icon.svg" onload="alert(1)"></img>'), }; } const App = ( ) => ( <div dangerouslySetInnerHTML={possibleXSS()} /> ); ReactDOM.render(<App />, document.getElementById("root"));

Javascript

입력데이터 검증 및 표현

크로스사이트 스크립트(XSS)

사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 악의적인 스크립트가 실행 가능한 보안약점

const express = require('express'); router.get("/vuln/search", (req, res) => { // 사용자로부터 전달 받은 쿼리 데이터로 데이터 조회 const results = selectFromDB(req.query.q); if (results.length === 0) { // 검색 결과가 발견되지 않을 경우, ‘요청한 값’을 찾지 못했다는 메시지를 반환하는데, // 이 때 정상적인 질의문이 아닌 악성 스크립트가 포함된 데이터를 입력 받은 경우라면 // 클라이언트측에서 악성 스크립트가 실행될 수 있음 return res.send('<p>No results found for "' + req.query.q + '"</p>'); } ... });

const express = require('express'); const xssFilters = require("xss-filters"); ... router.get("/patched/search", (req, res) => { const unsafeFirstname = req.query.q; // xss-filters 라이브러리를 사용해 사용자 입력값을 이스케이프 처리 const safeFirstname = xssFilters.inHTMLData(unsafeFirstname); const results = selectFromDB(safeFirstname); if (results.length === 0) { res.send(util.format("<p>Hello %s</p>", safeFirstname)); } ... });

Javascript

입력데이터 검증 및 표현

운영체제 명령어 삽입

운영체제 명령어를 생성할 때 검증되지 않은 외부 입력값을 허용하여 악의적인 명령어가 실행 가능한 보안약점

const express = require('express'); const child_process = require("child_process"); router.get("/vuln", (req, res) => { // 사용자가 입력한 명령어 인자값을 검증 없이 사용해 의도치 않은 추가 명령어 실행 가능 child_process.exec("ls -l " + req.query.path, function (err, data) { return res.send(data); }); });

const express = require('express'); const child_process = require("child_process"); router.get("/patched", (req, res) => { const inputPath = req.query.path; const regPath = /^(\/[\w^]+)+\/?$/; // 첫 번째 방법, 사용자 입력값 필터링 ? 리눅스 경로 지정에 필요한 문자만 허용 if (!inputPath.match(regPath)) { return res.send('not valid path'); } // 두 번째 방법, 사용자 입력값이 명령어의 인자로만 사용되도록 하는 함수 사용 child_process.execFile( "/bin/ls", ["-l", inputPath], function (err, data) { if (err) { return res.send('not valid path'); } else { return res.send(data); } } ); });

Javascript

입력데이터 검증 및 표현

위험한 형식 파일 업로드

파일의 확장자 등 파일형식에 대한 검증없이 파일 업로드를 허용하여 공격이 가능한 보안약점

const express = require('express'); router.post("/vuln", (req, res) => { const file = req.files.products; const fileName = file.name; // 업로드 한 파일 타입 검증 부재로 악성 스크립트 파일 업로드 가능 file.mv("/usr/app/temp/" + fileName, (err) => { if (err) return res.send(err); res.send("upload success"); }); });

const express = require('express'); router.post("/patched", (req, res) => { const allowedMimeTypes = ["image/png", "image/jpeg"]; const allowedSize = 5242880; const file = req.files.products; const fileName = file.name; // 업로드 한 파일 타입 검증을 통해 악성 스크립트 파일 업로드 방지 if (allowedMimeTypes.indexOf(file.mimetype) < 0) { res.send("file type not allowed"); } else { file.mv("/usr/app/temp/" + fileName, (err) => { if (err) return res.send(err); res.send("upload success"); }); } });

Javascript

입력데이터 검증 및 표현

신뢰되지 않은 URL주소로 자동접속 연결

URL 링크 생성에 검증되지 않은 외부 입력값을 허용하여 악의적인 사이트로 자동 접속 가능한 보안약점

const express = require('express'); router.get("/vuln", (req, res) => { const url = req.query.url; // 사용자가 전달한 URL 주소를 검증 없이 그대로 리다이렉트 처리 res.redirect(url); });

const express = require('express'); router.get("/patched", (req, res) => { const whitelist = ["http://safe-site.com", "https://www.example.com"]; const url = req.query.url; // 화이트리스트에 포함된 주소가 아니라면 리다이렉트 없이 에러 반환 if (whitelist.indexOf(url) < 0) { res.send("wrong url"); } else { res.redirect(url); } });

Javascript

입력데이터 검증 및 표현

부적절한 XML 외부 개체 참조

임의로 조작된 XML 외부개체에 대한 적절한 검증 없이 참조를 허용하여 공격이 가능한 보안약점

const express = require('express'); const libxmljs = require("libxmljs"); router.post("/vuln", (req, res) => { if (req.files.products && req.files.products.mimetype == "application/xml") { const products = libxmljs.parseXmlString( req.files.products.data.toString("utf8"), // 외부 엔티티 파싱 허용 설정(미설정 시 기본값은 false) { noent: true } ); return res.send(products.get("//foo").text()); } return res.send("fail"); });

const express = require('express'); const libxmljs = require("libxmljs"); router.post("/patched", (req, res) => { if (req.files.products && req.files.products.mimetype == "application/xml") { const products = libxmljs.parseXmlString( req.files.products.data.toString("utf8"), // 외부 엔티티 파싱을 허용하지 않도록 설정 // 미설정 시 기본값은 false이지만, 명시적으로 선언을 해 주는 것이 좋음 { noent: false } ); return res.send(products.get("//foo").text()); } return res.send("fail"); });

Javascript

입력데이터 검증 및 표현

XML 삽입

XQuery, XPath 질의문을 생성할 때 검증되지 않은 외부 입력값을 허용하여 악의적인 질의문이 실행 가능한 보안약점

const express = require('express'); const xpath = require('xpath'); const dom = require('xmldom').DOMParser; const xml = `<users> <user> <login>john</login> <password>abracadabra</password> <home_dir>/home/john</home_dir> </user> <user> <login>cbc</login> <password>1mgr8</password> <home_dir>/home/cbc</home_dir> </user> </users>`; router.get("/vuln", (req, res) => { const userName = req.query.userName; const userPass = req.query.userPass; const doc = new dom().parseFromString(xml); // 조작된 입력값(/vuln?userName=john' or ''='&userPass="' or ''='“)을 통해 // 패스워드 검사 로직을 우회할 수 있음 const badXPathExpr = "//users/user[login/text()='" + userName + "' and password/text() = '" + userPass + "']/home_dir/text()"; const selected = xpath.select(badXPathExpr, doc); try { const userPath = selected[0].toString(); return res.send(`userPath = ${userPath}`); } catch { return res.send('not found'); } });

const express = require('express'); const xpath = require('xpath'); const dom = require('xmldom').DOMParser; const xml = `<users> ... </users>`; router.get("/patched", (req, res) => { const userName = req.query.userName; const userPass = req.query.userPass; const doc = new dom().parseFromString(xml); // 인자화된 쿼리 생성 const goodXPathExpr = xpath.parse("//users/user[login/text()=$userName and password/text() =$userPass]/home_dir/text()"); // 쿼리문에 변수값 전달 및 XML 조회 const selected = goodXPathExpr.select({ node: doc, variables: { userName: userName, userPass: userPass } }); try { const userPath = selected[0].toString(); return res.send(`userPath = ${userPath}`); } catch { return res.send('not found'); } });

Javascript

입력데이터 검증 및 표현

LDAP 삽입

LDAP 명령문을 생성할 때 검증되지 않은 외부 입력값을 허용하여 악의적인 명령어가 실행 가능한 보안약점

const express = require('express'); const ldap = require('ldapjs'); const config = { url: 'ldap://ldap.forumsys.com', base: 'dc=example,dc=com', dn: 'cn=read-only-admin,dc=example,dc=com', secret: 'd0accf0ac0dfb0d0fd...', }; async function searchLDAP (search) { const opts = { filter: `(&(objectClass=${search}))`, attributes: ['sn', 'cn', 'mail', 'telephonenumber', 'uid'], scope: 'sub', }; const users = []; const client = ldap.createClient({ url: config.url }); return new Promise((resolve, reject) => { client.bind(config.dn, config.password, (err) => { if (err) { console.log('LDAP bind error - ', err); } else { client.search(config.base, opts, (err, res) => { res.on('searchEntry', (entry) => { users.push(entry.object); }); ... res.on('end', (result) => { console.log('status: ' + result.status); resolve(users); }); }); } }); }); } router.get("/vuln", async (req, res) => { // 사용자의 입력을 그대로 LDAP 질의문으로 사용해 권한 상승 등의 공격에 노출 const search = req.query.search; const result = await searchLDAP(search); return res.send(result); });

const express = require('express'); const ldap = require('ldapjs'); const parseFilter = require('ldapjs').parseFilter; const config = { url: 'ldap://ldap.forumsys.com', base: 'dc=example,dc=com', dn: 'cn=read-only-admin,dc=example,dc=com', secret: 'd0accf0ac0dfb0d0fd...', }; async function searchLDAP (search) { const opts = { filter: `(&(objectClass=${search}))`, attributes: ['sn', 'cn', 'mail', 'telephonenumber', 'uid'], scope: 'sub', }; const users = []; const client = ldap.createClient({ url: config.url }); return new Promise((resolve, reject) => { client.bind(config.dn, config.password, (err) => { if (err) { console.log('LDAP bind error - ', err); } else { client.search(config.base, opts, (err, res) => { res.on('searchEntry', (entry) => { users.push(entry.object); }); ... res.on('end', (result) => { console.log('status: ' + result.status); resolve(users); }); }); } }); }); } router.get("/patched", async (req, res) => { let search; // 사용자의 입력에 필터링을 적용해 공격에 사용될 수 있는 문자 발견 시 // 사용자에게 잘못된 요청값임을 알리고, 질의문을 요청하지 않음 try { search = parseFilter(req.query.search); } catch { return res.send('잘못된 요청값입니다.'); } const result = await searchLDAP(search); return res.send(result); });

Javascript

입력데이터 검증 및 표현

크로스사이트 요청 위조(CSRF)

사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 사용자 본인의 의지와는 무관하게 공격자가 의도한 행위가 실행 가능한 보안약점

<html> ... <body> <form method='post' action='/api/vuln'> <!-- CSRF 토큰 없이 폼 데이터를 서버에 전달 --> <fieldset> <legend>Your Profile:</legend> <label for='username'> Name:</label> <input name='username' class='username' type='text'> <br><br> <label for='email' > Email:</label> <input name='email' class='useremail' type='email'> <br><br> <button type='submit'>UPDATE</button> </fieldset> </form> </body> </html>

<form method='post' action='/api/vuln'> <!-- 서버로부터 제공 받은 CSRF 토큰을 폼 데이터에 hidden 값으로 포함해 전달 --> <input type='hidden' name='_csrf' value='<%= csrfToken %>'> <fieldset> <legend>Your Profile:</legend> <label for='username'> Name:</label> <input name='username' class='username' type='text'> <br><br> <label for='email' > Email:</label> <input name='email' class='useremail' type='email'> <br><br> <button type='submit'>UPDATE</button> </fieldset> </form>

Javascript

입력데이터 검증 및 표현

크로스사이트 요청 위조(CSRF)

사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 사용자 본인의 의지와는 무관하게 공격자가 의도한 행위가 실행 가능한 보안약점

const express = require('express'); router.post("/api/vuln", (req, res) => { const userName = req.body.username; const userEmail = req.body.useremail; // 사용자 업데이트 요청이 정상 사용자로부터 온 것이라고 간주하고, // 사용자로부터 받은 값을 그대로 내부 함수에 전달 if (update_user(userName, userEmail)) { return res.send('update completed'); } else { return res.send('update error'); } });

const csrf = require('csurf'); const express = require('express'); const session = require("express-session"); const app = express(); // 토큰을 쿠키가 아닌 세션에 저장 app.use(session({ secret: process.env.COOKIE_SECRET, cookie: { path: '/', secure: true, httpOnly: true, sameSite: 'strict' }, saveUninitialized: false, resave: false })); // CSRF 토큰 이름 앞에 __Host- 접두어 추가 const csrfProtection = csrf({ key: '__Host-token', }); // 클라이언트측 프레임워크(ReactJS)를 위한 토큰 값 제공 router.get("/getCSRFToken", csrfProtection, (req, res) => { res.json({ csrfToken: req.csrfToken() }); }); // 템플릿 페이지를위한 토큰 값 제공 router.get("/page", csrfProtection, (req, res) => { res.render('csrf', { csrfToken: req.csrfToken() }); }); // 라우터 데이터 처리 전 클라이언트의 csrf 토큰을 검사 router.post("/api/patched", csrfProtection, (req, res) => { const userName = req.body.username; const userEmail = req.body.useremail; if (update_user(userName, userEmail)) { return res.send('update completed'); } else { return res.send('update error'); } });

Javascript

입력데이터 검증 및 표현

크로스사이트 요청 위조(CSRF)

사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 사용자 본인의 의지와는 무관하게 공격자가 의도한 행위가 실행 가능한 보안약점

클라이언트측에서 렌더링을 처리하는 ReactJS의 경우 서버 기능 호출 전 서버로부터 토큰을 받아와 요청 헤더 내에 삽입해야 한다

const App = () => { const getData = async () => { // 서버에 기능 호출 전 먼저 CSRF 토큰을 받아와 헤더에 저장 const response = await axios.get('getCSRFToken'); axios.defaults.headers.post['X-CSRF-Token'] = response.data.csrfToken; // CSRF 토큰이 설정된 상태에서 서버 기능 호출 const res = await axios.post('api/patched', { username: ‘hello_user’, useremail: ‘[email protected]’, }); document.write(res.data); }; React.useEffect(() => { getData(); }, []); return <div>react-test</div>; }; ReactDOM.render(<App />, document.getElementById("root"));

Javascript

입력데이터 검증 및 표현

서버사이드 요청 위조

서버 간 처리되는 요청에 검증되지 않은 외부 입력값을 허용하여 공격자가 의도한 서버로 전송 하거나 변조하는 보안약점

const request = require('request'); const express = require('express'); router.get("/vuln", async (req, res) => { const url = req.query.url; // 사용자가 입력한 주소를 검증하지 않고 HTTP 요청을 보낸 후 // 그 응답을 그대로 사용자에게 전달 await request(url, (err, response) => { const resData = response.body; return res.send(resData); }); });

const request = require('request'); const express = require('express'); router.get("/patched", async (req, res) => { const url = req.query.url; const whiteList = [ 'www.example.com', 'www.safe.com']; // 사용자가 입력한 URL을 화이트리스트로 검증한 후 그 결과를 반환하여 // 검증되지 않은 주소로 요청을 보내지 않도록 제한 if (whiteList.includes(url)) { await request(url, (err, response) => { const resData = response.body; return res.send(resData); }); } else { return res.send('잘못된 요청입니다'); } });

Javascript

입력데이터 검증 및 표현

보안기능 결정에 사용되는 부적절한 입력값

보안기능(인증, 권한부여 등) 결정에 검증되지 않은 외부 입력값을 허용하여 보안기능을 우회하는 보안약점

const express = require('express'); router.get("/admin", (req, res) => { // 쿠키에서 권한 정보를 가져옴 const role = req.cookies.role; if (role === "admin") { // 쿠키에서 가져온 권한 정보로 관리자 페이지 접속 처리 return res.render(‘admin’. { title: ’관리자 페이지‘ } )); } else { return res.send("사용 권한이 없습니다."); } });

const express = require('express'); const session = require("express-session"); app.use(session({ secret: 'test', resave: true, saveUninitialized: true, store: new MemoryStore({checkPeriod: 60 * 60 * 1000}) })); router.get("/patched", (req, res) => { // 세션에서 권한 정보를 가져옴 const role = req.session.role; if (role === "admin") { // 세션에서 가져온 권한 정보로 관리자 페이지 접속 처리 return res.render(‘admin’. { title: ’관리자 페이지‘ } )); } else { return res.send("사용 권한이 없습니다."); } });

Javascript

보안기능

적절한 인증 없는 중요 기능 허용

중요정보(금융정보, 개인정보, 인증정보 등)를 적절한 인증없이 열람(또는 변경) 가능한 보안약점

const express = require('express'); const crypto = require("crypto"); router.post("/vuln", (req, res) => { const newPassword = req.body.newPassword; const user = req.session.userid; const hs = crypto.createHash(“sha256”) const newHashPassword = hs.update(newPassword).digest("base64"); // 현재 패스워드와 일치 여부를 확인하지 않고 업데이트 updatePasswordFromDB(user, newHashPassword); return res.send({message: "패스워드가 변경되었습니다.", userId, password, hashPassword}); });

const express = require('express'); const crypto = require("crypto"); router.post("/patched", (req, res) => { const newPassword = req.body.newPassword; const user = req.session.userid; const oldPassword = getPasswordFromDB(user); const salt = crypto.randomBytes(16).toString('hex'); const hs = crypto.createHash("sha256“) const currentPassword = req.body.currentPassword; const currentHashPassword = hs.update(currentPassword + salt).digest("base64"); // 현재 패스워드 확인 후 사용자 정보 업데이트 if (currentHashPassword === oldPassword) { const newHashPassword = hs.update(newPassword + salt).digest("base64"); updatePasswordFromDB(user, newHashPassword); return res.send({ message: "패스워드가 변경되었습니다." }); } else { return res.send({ message: "패스워드가 일치하지 않습니다." }); } });

Javascript

보안기능

부적절한 인가

중요자원에 접근할 때 적절한 제어가 없어 비인가자의 접근이 가능한 보안약점

const express = require('express'); function deleteContentFromDB(contentId) { ... } router.delete("/vuln", (req, res) => { const contentId = req.body.contentId; // 작업 요청을 하는 사용자의 권한 확인 없이 삭제 작업 수행 deleteContentFromDB(contentId); return res.send("삭제가 완료되었습니다."); });

const express = require('express'); function deleteContentFromDB(contentId) { ... } router.delete("/patched", (req, res) => { const contentId = req.body.contentId; const role = req.session.role; // 삭제 기능을 수행할 권한이 있는 경우에만 삭제 작업 수행 if (role === "admin") { deleteContentFromDB(contentId); return res.send("삭제가 완료되었습니다."); } else { return res.send("권한이 없습니다."); } });

Javascript

보안기능

중요한 자원에 대한 잘못된 권한 설정

중요자원에 적절한 접근 권한을 부여하지 않아 중요정보가 노출·수정 가능한 보안약점

const fs = require("fs"); function writeFile() { // 모든 사용자가 읽기, 쓰기, 실행 권한을 가지게 됨 fs.chmodSync("/root/system_config", 0o777); fs.open("/root/system_config", "w", function(err,fd) { if (err) throw err; }); fs.writeFile("/root/system_config", "your config is broken", function(err) { if (err) throw err; console.log('write end'); }); }

const fs = require("fs"); function writeFile() { // 소유자 이외에는 권한을 가지지 않음 fs.chmodSync("/root/system_config", 0o700); fs.open("/root/system_config", "w", function(err,fd) { if (err) throw err; }); fs.writeFile("/root/system_config", "your config is broken", function(err) { if (err) throw err; console.log('write end'); }) }

Javascript

보안기능

취약한 암호화 알고리즘 사용

중요정보 (금융정보, 개인정보, 인증정보 등)의 기밀성을 보장할 수 없는 취약한 암호화 알 고리즘을 사용하여 정보가 노출 가능한 보안약점

const crypto = require("crypto"); function getEncText(plainText, key) { // 취약한 알고리즘인 DES를 사용하여 안전하지 않음 const cipherDes = crypto.createCipheriv('des-ecb', key, ''); const encryptedData = cipherDes.update(plainText, 'utf8', 'base64'); const finalEnctypedData = cipherDes.final('base64'); return encryptedData + finalEnctypedData; }

const crypto = require("crypto"); function getEncText(plainText, key, iv) { // 권장 알고리즘인 AES를 사용하여 안전함 const cipherAes = crypto.createCipheriv('aes-256-cbc', key, iv); const encryptedData = cipherAes.update(plainText, 'utf8', 'base64'); const finalEnctypedData = cipherAes.final('base64'); return encryptedData + finalEnctypedData; }

Javascript

보안기능

취약한 암호화 알고리즘 사용

중요정보 (금융정보, 개인정보, 인증정보 등)의 기밀성을 보장할 수 없는 취약한 암호화 알 고리즘을 사용하여 정보가 노출 가능한 보안약점

const crypto = require("crypto"); function makeMd5(plainText) { // 취약한 md5 해쉬함수 사용 const hashText = crypto.createHash('md5').update(plainText).digest("hex"); return hashText; }

const crypto = require("crypto"); function makeSha256(plainText) { const salt = crypto.randomBytes(16).toString('hex'); // 안전한 sha-256 해쉬함수 사용 const hashText = crypto.createHash('sha256').update(plainText + salt).digest("hex"); return hashText; }

Javascript

보안기능

암호화되지 않은 중요정보

중요정보(패스워드, 개인정보 등) 전송 시 암호화 또는 안전한 통신채널을 이용하지 않거나, 저장 시 암호화 하지 않아 정보가 노출 가능한 보안약점

function updatePass(dbconn, password, user_id) { // 암호화되지 않은 비밀번호를 DB에 저장하는 경우 위험함 const sql = 'UPDATE user SET password=? WHERE user_id=?'; const params = [password, user_id]; dbconn.query(sql, params, function(err, rows, fields){ if (err) console.log(err); }) }

const crypto = require("crypto"); function updatePass(dbconn, password, user_id, salt) { // 단방향 암호화를 이용하여 비밀번호를 암호화 const sql = 'UPDATE user SET password=? WHERE user_id=?'; const hashPw = crypto.createHash('sha256').update(password + salt, 'utf-8').digest('hex'); const params = [hashPw, user_id]; dbconn.query(sql, params, function(err, rows, fields){ if (err) console.log(err); }) }

Javascript

보안기능

암호화되지 않은 중요정보

중요정보(패스워드, 개인정보 등) 전송 시 암호화 또는 안전한 통신채널을 이용하지 않거나, 저장 시 암호화 하지 않아 정보가 노출 가능한 보안약점

const { io } = require("socket.io-client"); const socket = io("http://localhost:3000"); function sendPassword(password) { // 패스워드를 암호화 하지 않고 전송하여 안전하지 않음 socket.emit("password", password); } socket.on("password", function(data) { if (data === 'success') { console.log("\nSuccess to send a message to a server \n") } });

const { io } = require("socket.io-client"); const crypto = require("crypto"); const socket = io("http://localhost:3000"); const PASSWORD = getPassword(); function aesEncrypt(plainText) { const key = getCryptKey(); const iv = getCryptIV(); const cipherAes = crypto.createCipheriv('aes-256-cbc', key, iv); const encryptedData = cipherAes.update(plainText, 'utf8', 'base64'); const finalEncryptedData = cipherAes.final('base64'); return encryptedData + finalEncryptedData; } function sendPassword(password) { // 패스워드 등 중요정보는 암호화하여 전송하는 것이 안전함 const encPassword = aesEncrypt(password); socket.emit("password", encPassword); } socket.on("password", function(data) { if (data === 'success') { console.log("\nSuccess to send a message to a server \n") } });

Javascript

보안기능

하드코드된 중요정보

소스코드에 중요정보(패스워드, 암호화키 등)를 직접 코딩하여 소스코드 유출 시 중요정보가 노출되고 주기적 변경이 어려운 보안약점

const express = require('express'); const mysql = require("mysql"); const crypto = require("crypto"); const dbQuery = "SELECT email, name FROM user WHERE name = 'test'"; router.get("/vuln", (req, res) => { // 데이터베이스 연결에 필요한 인증 정보가 평문으로 하드코딩되어 있음 const connection = mysql.createConnection({ host: 'localhost', user: 'root', password: 'root1234', database: 'javascript', port: 3306, }); connection.query( dbQuery, (err, result) => { if (err) return res.send(err); return res.send(result); }) });

const express = require('express'); const mysql = require("mysql"); const crypto = require("crypto"); const dbQuery = "SELECT email, name FROM user WHERE name = 'test'"; const key = getCryptKey(); // 32bytes const iv = getCryptIV(); // 16bytes router.get("/patched", (req, res) => { // 설정파일에 암호화 되어 있는 user, password 정보를 가져와 복호화 한 후 사용 const decipher = crypto.createDecipheriv('aes-256-cbc', key, iv); const user = decipher.update(process.env.USER, 'base64', 'utf8') + decipher.final('utf8'); const decipher2 = crypto.createDecipheriv('aes-256-cbc', key, iv); const password = decipher2.update(process.env.PASSWORD, 'base64', 'utf8') + decipher2.final ('utf8'); // DB 연결 정보도 설정파일에서 가져와 사용 const connection = mysql.createConnection({ host: process.env.DB_HOST, user: user, password: password, database: process.env.DB_NAME, port: process.env.PORT, });

Javascript

보안기능

충분하지 않은 키 길이 사용

암호화 등에 사용되는 키의 길이가 충분하지 않아 데이터의 기밀성·무결성을 보장할 수 없는 보안약점

const crypto = require("crypto"); function vulnMakeRsaKeyPair() { // RSA키 길이를 1024 비트로 설정하는 경우 안전하지 않음 const { publicKey, privateKey } = crypto.generateKeyPairSync('rsa', { modulusLength: 1024, publicKeyEncoding: { type: "spki", format: 'pem' }, privateKeyEncoding: { type: "pkcs8", format: 'pem' } }); return { PRIVATE: publicKey, PUBLIC: privateKey } } function vulnMakeEcc() { // ECC 키 길이가 224비트 이하이면 안전하지 않음 const { publicKey, privateKey } = crypto.generateKeyPairSync('ec', { namedCurve: 'secp192k1', publicKeyEncoding: { type: 'spki', format: 'der' }, privateKeyEncoding: { type: 'pkcs8', format: 'der' } }); return { PRIVATE: publicKey.toString('hex'), PUBLIC: privateKey.toString('hex') } }

const crypto = require("crypto"); function vulnMakeRsaKeyPair() { // RSA키 길이를 2048 비트로 설정해 안전함 const { publicKey, privateKey } = crypto.generateKeyPairSync('rsa', { modulusLength: 2048, publicKeyEncoding: { type: "spki", format: 'pem' }, privateKeyEncoding: { type: "pkcs8", format: 'pem' } }); return { PRIVATE: publicKey, PUBLIC: privateKey } } function vulnMakeEcc() { // ECC 키 길이를 256 비트로 설정해 안전함 const { publicKey, privateKey } = crypto.generateKeyPairSync('ec', { namedCurve: 'secp256k1', publicKeyEncoding: { type: 'spki', format: 'der' }, privateKeyEncoding: { type: 'pkcs8', format: 'der' } }); return { PRIVATE: publicKey.toString('hex'), PUBLIC: privateKey.toString('hex') } }

Javascript

보안기능

적절하지 않은 난수 값 사용

사용한 난수가 예측 가능하여, 공격자가 다음 난수를 예상해서 시스템을 공격 가능한 보안 약점

function getOtpNumber() { let randomStr = ''; // Math.random 라이브러리는 보안기능에 사용하면 위험함 for (let i = 0; i < 6; i++) { randomStr += String(Math.floor(Math.random() * 10)) } return randomStr; }

const crypto = require("crypto"); function getOtpNumber() { // 보안기능에 적합한 난수 생성용 crypto 라이브러리 사용 const array = new Uint32Array(1); // 브라우저에서는 crypto 대신에 window.crypto를 사용 const randomStr = crypto.getRandomValues(array); let result; for (let i = 0; i < randomStr.length; i++) { result = array[i]; } return String(result).substring(0, 6); }

Javascript

보안기능

취약한 패스워드 허용

패스워드 조합규칙(영문, 숫자, 특수문자 등) 미흡 및 길이가 충분하지 않아 패스워드가 노출 가능한 보안약점

const express = require('express'); const mysql = require("mysql"); const connection = mysql.createConnection( ... ); router.post("/vuln", (req, res) => { const con = connection; const { email, password, name } = req.body; // 패스워드 생성 규칙 검증 없이 회원 가입 처리 con.query( "INSERT INTO user (email, password, name) VALUES (?, ?, ?)", [email, password, name], (err, result) => { if (err) return res.send(err); return res.send("회원가입 성공"); }); });

const express = require('express'); const mysql = require("mysql"); const connection = mysql.createConnection(...); router.post("/patched", (req, res) => { const con = connection; const { email, password, name } = req.body; function checkPassword(password) { // 2종 이상 문자로 구성된 8자리 이상 비밀번호 검사 정규식 const pt1 = /^(?=.*[A-Z])(?=.*[a-z])[A-Za-z\d!@#$%^&*]{8,}$/; const pt2 = /^(?=.*[A-Z])(?=.*\d)[A-Za-z\d!@#$%^&*]{8,}$/; const pt3 = /^(?=.*[A-Z])(?=.*[!@#$%^&*])[A-Za-z\d!@#$%^&*]{8,}$/; const pt4 = /^(?=.*[a-z])(?=.*\d)[A-Za-z\d!@#$%^&*]{8,}$/; const pt5 = /^(?=.*[a-z])(?=.*[!@#$%^&*])[A-Za-z\d!@#$%^&*]{8,}$/; const pt6 = /^(?=.*\d)(?=.*[!@#$%^&*])[A-Za-z\d!@#$%^&*]{8,}$/; // 문자 구성 상관없이 10자리 이상 비밀번호 검사 정규식 const pt7 = /^[A-Za-z\d!@#$%^&*]{10,}$/; for (let pt of [pt1, pt2, pt3, pt4, pt5, pt6, pt7]) { console.log(pt.test(password)); if (pt.test(password)) return true; } return false; } if (checkPassword(password)) { con.query( "INSERT INTO user (email, password, name) VALUES (?, ?, ?)", [email, password, name], (err, result) => { if (err) return res.send(err); return res.send("회원가입 성공"); } ); } else { return res.send("비밀번호는 영문 대문자, 소문자, 숫자, 특수문자 조합 중 2가지 이상 8자리이거나 문자 구성 상관없이 10자리 이상이어야 합니다."); } });

Javascript

보안기능

부적절한 전자서명 확인

프로그램, 라이브러리, 코드의 전자서명에 대한 유효성 검증이 적절하지 않아 공격자의 악의적인 코드가 실행 가능한 보안약점

const express = require('express'); const crypto = require("crypto"); const fs = require(‘fs’); router.post("/vuln", (req, res) => { // 클라이언트로부터 전달받은 데이터(전자서명을 수신 처리 하지 않음) const { encrypted_msg } = req.body; let secret_key; fs.readFile(‘/keys/secret_key.out’, ‘utf8’, (err, data) => { if (err) { console.error(err); return; } secret_key = data; } // 대칭키로 클라이언트가 전달한 코드 복호화 // (decrypt_with_symmetric_key 함수는 임의의 함수명으로 세부적인 복호화 과정은 생략함) const decrypted = decrypt_with_symmetric_key(encrypted_msg, secret_key); // 클라이언트로부터 전달 받은 코드 실행 eval(decrypted); res.send('요청한 코드를 실행했습니다'); });

// 전자서명 검증에 사용한 코드는 의존한 패키지 및 송신측 언어에 따라 // 달라질 수 있으며, 서명을 제공한 서버의 공개키로 복호화한 전자서명과 원본 데이터 해쉬값의 // 일치 여부를 검사하는 코드를 포함 const express = require('express'); const crypto = require("crypto"); router.post("/patched", (req, res) => { const { encrypted_msg, encrypted_sig, client_pub_key } = req.body; let secret_key; fs.readFile(‘/keys/secret_key.out’, ‘utf8’, (err, data) => { if (err) { console.error(err); return; } secret_key = data; } // 대칭키로 클라이언트 데이터 및 전자서명 복호화 const decrypted_msg = decrypt_with_symmetric_key(encrypted_msg); const decrypted_sig = decrypt_with_symmetric_key(encrypted_sig); // 전자서명 검증에 통과한 경우에만 데이터 실행 if (verify_digit_signature(decrypted_msg, decrypted_sig, clint_pub_key)) { eval(decrypted_msg); res.send('요청한 코드를 실행했습니다'); } else { res.send('[!] 에러 - 서명이 올바르지 않습니다.'); } });

Javascript

보안기능

부적절한 인증서 유효성 검증

인증서에 대한 유효성 검증이 적절하지 않아 발생하는 보안약점

const https = require('https'); const getServer = () => { const options = { hostname: "dangerous.website", port: 443, method: "GET", path: "/", // 유효하지 않은 인증서를 가지고 있어도 무시하는 옵션으로 안전하지 않음 rejectUnauthorized: false }; https.request( options, (response) => { console.log('response - ', response.statusCode); } ); });

const express = require('express'); const https = require('https'); const getServer = () => { const options = { hostname: "dangerous.website", port: 443, method: "GET", path: "/", // 유효하지 않은 인증서 발견 시 예외 발생 rejectUnauthorized: true }; const hreq = https.request( options, (response) => { console.log('response - ', response.statusCode); } ); hreq.on('error', (e) => { console.error('에러발생 - ', e); }); });

Javascript

보안기능

사용자 하드디스크에 저장되는 쿠키를 통한 정보노출

쿠키(세션 ID, 사용자 권한정보 등 중요정보)를 사용자 하드디스크에 저장하여 중요정보가 노출 가능한 보안약점

const express = require('express'); router.get("/vuln", (req, res) => { // 쿠키의 만료 시간을 1년으로 과도하게 길게 설정하고 있어 안전하지 않다 res.cookie('rememberme', '1', { expires: new Date(Date.now() + 365*24*60*60*1000) }); return res.send("쿠키 발급 완료"); });

const express = require('express'); router.get("/patched", (req, res) => { // 쿠키의 만료 시간을 적절하게 부여하고 secure 옵션을 활성화 res.cookie('rememberme', '1', { expires: new Date(Date.now() + 60*60*1000), secure: true, httpOnly: true }); return res.send("쿠키 발급 완료"); });

Javascript

보안기능

주석문 안에 포함된 시스템 주요정보

소스코드 주석문에 인증정보 등 시스템 주요정보가 포함되어 소스코드 노출 시 주요정보도 노출 가능한 보안약점

const express = require('express'); router.post("/vuln", (req, res) => { // 주석문에 포함된 중요 시스템의 인증 정보 // id = admin // password = 1234 const result = login(req.body.id, req.body.password); return res.send(result); });

const express = require('express'); router.post("/vuln", (req, res) => { // 주석문에 포함된 민감한 정보는 삭제 const result = login(req.body.id, req.body.password); return res.send(result); });

Javascript

보안기능

솔트 없이 일방향 해쉬 함수 사용

솔트를 사용하지 않고 생성된 해쉬 값으로부터 공격자가 미리 계산된 레인보우 테이블을 이용하여 해쉬 적용 이전 원본 정보를 복원가능한 보안약점

const crypto = require("crypto"); function getHashFromPwd(pw) { // salt가 없이 생성된 해쉬값은 강도가 약해 취약 const hash = crypto.createHash('sha256').update(pw).digest('hex'); return hash; }

const crypto = require("crypto"); function getHashFromPwd(pw) { // 솔트 값을 사용하면 길이가 짧은 패스워드로도 고강도의 해쉬를 생성할 수 있음 // 솔트 값은 사용자별로 유일하게 생성해야 하며, 패스워드와 함께 DB에 저장해야 함 const salt = crypto.randomBytes(16).toString('hex'); const hash = crypto.createHash('sha256').update(pw + salt).digest('hex'); return { hash, salt }; }

Javascript

보안기능

무결성 검사 없는 코드 다운로드

소스코드 또는 실행파일을 무결성 검사 없이 다운로드 받아 실행하는 경우, 공격자의 악의 적인 코드가 실행 가능한 보안약점

const express = require('express'); const fs = require("fs"); const http = require("http"); router.get("/vuln", (req, res) => { // 신뢰할 수 없는 사이트에서 코드를 다운로드 const url = "https://www.somewhere.com/storage/code.js"; // 원격 코드 다운로드 http.get(url, (res) => { const path = "./temp/sample1.js" const writeStream = fs.createWriteStream(path); res.pipe(writeStream); writeStream.on("finish", () => { writeStream.close(); }); }); // 무결성 검증 없이 파일 사용 fs.readFile("./temp/sample1.js", "utf8", function (err, buf) { res.end(buf); }) });

const express = require('express'); const fs = require("fs"); const http = require("http"); const crypto = require("crypto"); router.get("/patched", async (req, res) => { const url = "https://www.somewhere.com/storage/code.js"; const codeHash = req.body.codeHash; http.get(url, (res) => { const path = "./temp/sample1.js" const writeStream = fs.createWriteStream(path); res.pipe(writeStream); writeStream.on("finish", () => { writeStream.close(); }); }); const hash = crypto.createHash('sha256'); const input = fs.createReadStream("./temp/sample1.js"); let promise = new Promise ((resolve, reject) => { input.on("readable", () => { const data = input.read(); if (data) { hash.update(data); } else { resolve(); } }) }); await promise; const fileHash = hash.digest('hex'); # 무결성 검증에 통과할 경우에만 파일 사용 if (fileHash === codeHash) { fs.readFile("./temp/sample1.js", "utf8", function (err, buf) { res.end(buf); }) } else { return res.send("파일이 손상되었습니다.") } });

Javascript

보안기능

반복된 인증시도 제한 기능 부재

인증 시도 수를 제한하지 않아 공격자가 반복적으로 임의 값을 입력하여 계정 권한을 획득 가능한 보안약점

const express = require('express'); const crypto = require('crypto'); router.post("/vuln", (req, res) => { const id = req.body.id; const password = req.body.password; const hashPassword = crypto.createHash("sha512").update(password).digest("base64"); const currentHashPassword = getUserPasswordFromDB(id); // 인증 시도에 따른 제한이 없어 반복적인 인증 시도가 가능 if (hashPassword === currentHashPassword) { return res.send("login success"); } else { return res.send("login fail") } });

const express = require('express'); const crypto = require('crypto'); const LOGIN_TRY_LIMIT = 5; router.post("/patched", (req, res) => { const id = req.body.id; const password = req.body.password; // 로그인 실패기록 가져오기 const loginFailCount = getUserLoginFailCount(id); // 로그인 실패횟수 초과로 인해 잠금된 계정에 대한 인증 시도 제한 if (loginFailCount >= LOGIN_TRY_LIMIT) { return res.send("account lock(too many failed)") } // 해시 생성시 솔트를 사용하는 것이 안전하나, 코드의 복잡성을 피하기 위해 생략 const hashPassword = crypto.createHash("sha512").update(password).digest("base64"); const currentHashPassword = getUserPasswordFromDB(id); if (hashPassword === currentHashPassword) { deleteUserLoginFailCount(id); return res.send("login success"); } else { updateUserLoginFailCount(id); return res.send("login fail") } });

Javascript

시간 및 상태

종료되지 않는 반복문 또는 재귀함수

종료조건 없는 제어문 사용으로 반복문 또는 재귀함수가 무한히 반복되어 발생할 수 있는 보안약점

function factorial(x) { # 재귀함수 탈출조건을 설정하지 않아 동작 중 에러 발생 return x * factorial(x - 1); });

function factorial(x) { # 재귀함수 사용 시에는 탈출 조건을 명시해야 한다 if ( x === 0 ) { return; } else { return x * factorial(x - 1); } }

Javascript

에러처리

오류 메시지 정보노출

오류메시지나 스택정보에 시스템 내부구조가 포함되어 민감한 정보, 디버깅 정보가 노출 가능한 보안약점

const express = require('express'); const fs = require("fs"); router.get("/vuln", (req, res) => { const filePath = "./file/secret/password"; fs.readFile(filePath, (err, data) => { if (err) { // 서버 내부에서 발생한 에러 메시지를 그대로 사용자에 전달해 주요 정보 노출 위험 return res.status(500).send(err); } else { return res.send(data); } }) });

const express = require('express'); const fs = require("fs"); router.get("/vuln", (req, res) => { const filePath = "./file/secret/password"; fs.readFile(filePath, (err, data) => { if (err) { // 에러 내용을 그대로 전달하지 않고 필터링 처리 return res.status(500).send({ message: “잘못된 요청입니다” }); } else { return res.send(data); } }) });

Javascript

에러처리

오류 메시지 정보노출

오류메시지나 스택정보에 시스템 내부구조가 포함되어 민감한 정보, 디버깅 정보가 노출 가능한 보안약점

Express에서 제공하는 errorHandler 미들웨어를 정의하지 않음.

const express = require("express"); const app = express(); // errorHandler 미들웨어는 다른 app.use() 및 라우터 정의 후 가장 마지막에 정의해야 하며, // errorHandler 미들웨어를 커스텀하여 에러별 에러페이지를 반환할 수 있다 app.use(clientErrorHandler); app.use(errorHandler); function clientErrorHandler (err, req, res, next) { if (req.xhr) { res.status(500).send({ error: 'Something failed!' }); } else { next(err); } } function errorHandler (err, req, res, next) { if (err.name = "ValidError") { res.status(400) res.render('400error', { error: err }) } else if (err.name = "AuthError") { res.status(401) res.render('401error', { error: err }) } else if (err.name = "ForbiddenError") { res.status(403) res.render('403error', { error: err }) } else if (err.name = "DBError") { res.status(500) res.render('500error', { error: err }) } }

Javascript

에러처리

오류상황 대응 부재

시스템 오류상황을 처리하지 않아 프로그램 실행정지 등 의도하지 않은 상황이 발생 가능한 보안약점

const express = require('express'); const crypto = require("crypto"); const staticKeys = [ { "key" : "a6823ecf34012b1ca5ca7889f4eabb51", "iv" : "e79ce03b4563647a" }, { "key" : "9e7c30e899f296a1daca7d9a0f92e71c", "iv" : "ab39941053fb5f6a" } ]; router.post("/vuln", (req, res) => { let statickKey = { "key" : "00000000000000000000000000000000", "iv" : "0000000000000000" }; const inputText = req.body.text; const keyId = req.body.id; try { staticKey.key = staticKeys[keyId].key; staticKey.iv = staticKeys[keyId].iv; } catch (err) { // key 선택 중 오류 발생 시 기본으로 설정된 암호화 키인 // ‘0000000000000000’ 으로 암호화가 수행됨 console.log(err); } const cipher = crypto.createCipheriv('aes-256-cbc', statickKey.key, statickKey.iv); const encryptedText = cipher.update(inputText, 'utf8', 'base64') + cipher.final('base64'); return res.send(encryptedText); });

const express = require('express'); const crypto = require("crypto"); const staticKeys = [ { "key" : "a6823ecf34012b1ca5ca7889f4eabb51", "iv" : "e79ce03b4563647a" }, { "key" : "9e7c30e899f296a1daca7d9a0f92e71c", "iv" : "ab39941053fb5f6a" } ]; router.post("/vuln", (req, res) => { let statickKey = { "key" : "00000000000000000000000000000000", "iv" : "0000000000000000" }; const inputText = req.body.text; const keyId = req.body.id; try { staticKey.key = staticKeys[keyId].key; staticKey.iv = staticKeys[keyId].iv; } catch (err) { // 키 선택 중 오류 발생 시 랜덤으로 암호화 키를 생성하도록 설정 staticKey.key = crypto.randomBytes(16).toString('hex'); staticKey.iv = crypto.randomBytes(8).toString('hex'); } const cipher = crypto.createCipheriv('aes-256-cbc', statickKey.key, statickKey.iv); const encryptedText = cipher.update(inputText, 'utf8', 'base64') + cipher.final('base64'); return res.send(encryptedText); });

Javascript

에러처리

부적절한 예외처리

예외사항을 부적절하게 처리하여 의도하지 않은 상황이 발생 가능한 보안약점

const express = require('express'); router.post("/vuln", (req, res) => { const password = req.body.password; const user = { user: "user", password: password, }; function getUser() { return new Promise((resolve, reject) => { resolve(user); }); } function getUserPassword(user) { return new Promise((resolve, reject) => { if (user.password === undefined) { reject(new Error("login fail")); } else { resolve(user); } }); } function checkPassword(user) { return new Promise((resolve, reject) => { if (user.password == "abc") { resolve(user); } else { reject(new Error("login fail")); } }); } return getUser() .then(getUserPassword) .then(checkPassword) .then((result) => res.send(result)) .catch((err) => { // 서로 다른 예외 상황에서도 동일한 에러 메시지만 출력 res.send(err.message); }); });

const express = require('express'); router.post("/patched", (req, res) => { const password = req.body.password; const user = { user: "user", password: password, }; function getUser() { return new Promise((resolve, reject) => { resolve(user); }); } function getUserPassword(user) { return new Promise((resolve, reject) => { if (user.password === undefined) { reject(new Error("password required")); } resolve(user); }); } function checkPassword(user) { return new Promise((resolve, reject) => { if (user.password == "abc") { resolve(user); } else { reject(new Error("wrong password")); } }); } return getUser() .then(getUserPassword) .then(checkPassword) .then((result) => res.send(result)) .catch((err) => { // 예외 상황에 맞는 처리 결과 메시지를 로그에 기록(내장 함수 log가 있다고 가정) log(err.messsage); // 클라이언트에는 에러 발생 여부만 전달 res.send(‘login failed’); }); );

Javascript

코드오류

Null Pointer 역참조

변수의 주소 값이 Null인 객체를 참조하는 보안약점

const express = require('express'); router.get("/vuln", (req, res) => { const id = req.query.id; // 사용자가 id 값을 전달하지 않을 경우(undefined) 에러 발생 return res.send("length = " + id.length); });

const express = require('express'); router.get("/patched", (req, res) => { const id = req.query.id; if (id === undefined) { // id 값이 전달되지 않을 경우 사용자에게 요구하는 예외 코드 추가 return res.send("id is required"); } else { return res.send("length = " + id.length); } });

Javascript

코드오류

부적절한 자원 해제

사용 완료된 자원을 해제하지 않아 자원이 고갈되어 새로운 입력을 처리할 수 없는 보안약점

const express = require('express'); const fs = require('fs'); router.get("/vuln", (req, res) => { const configPath = './config.cfg'; let fid = null; let fdata = null; try { fid = fs.openSync(configPath, 'r'); fdata = fs.readFileSync(fid, 'utf8'); // 예외 발생 상황 가정: 유효하지 않은 파일 디스크립터로 파일 읽기 시도 fdata = fs.readFileSync('100', 'utf8'); // try 절에서 할당된 자원이 반환(close)되기 전에 예외가 발생하면 // 할당된 자원이 시스템에 바로 반환되지 않음 fs.close(fid, err => { if (err) { console.log('error occured while flle closing'); } else { console.log('file closed'); } }); } catch (e) { console.log('error occured!' , e); } return res.send(fdata); });

const express = require('express'); const fs = require('fs'); router.get("/patched", (req, res) => { const configPath = './5_code_error/40_improper_resource_shutdown/config.cfg'; let fid = null; let fdata = null; try { fid = fs.openSync(configPath, 'r'); fdata = fs.readFileSync(fid, 'utf8'); fdata = fs.readFileSync(100, 'utf8'); } catch (e) { console.log('error occured!' , e); // try 절에서 할당된 자원은 finally 절에서 시스템에 반환을 해야 함 } finally { fs.close(fid, err => { if (err) { console.log('error occured while flle closing'); } else { console.log('file closed'); } }); } return res.send(fdata); });

Javascript

코드오류

신뢰할 수 없는 데이터의 역직렬화

악의적인 코드가 삽입·수정된 직렬화 데이터를 적절한 검증 없이 역직렬화하여 발생하는 보안약점 * 직렬화: 객체를 전송 가능한 데이터형식으로 변환 * 역직렬화: 직렬화된 데이터를 원래 객체로 복원

const express = require('express'); def load_user_object(request): const serializedData = req.query.data; # 사용자로부터 입력받은 알 수 없는 데이터를 역직렬화 const user = JSON.parse(serializedData); return res.send({user: user.user, isAdmin: user.isAdmin});

const express = require('express'); const crypto = require('crypto'); def load_user_object(request): const serializedData = req.query.data; # 데이터 형식: '{"userInfo":{"user":"admin","isAdmin":true},"hashed":"cf8cd...7"}'; const body = JSON.parse(serializedData); # 데이터 변조를 확인하기 위한 해시값 const hashedMac = body.hashed; # 사용자로부터 입력받은 데이터를 직렬화 const userInfo = JSON.stringify(body.userInfo); const secretKey = 'secret_key'; const hmac = crypto.createHmac('sha512', secretKey); # 직렬화된 사용자 입력값을 해싱 hmac.update(userInfo); const calculatedHMAC = hmac.digest('hex'); # 전달받은 해시값(hashedMAC)과 직렬화 데이터(calculaedHMAC)의 해시값을 비교하여 검증 if (calculatedHMAC === hashedMac) { const userObj = JSON.parse(userInfo); return res.send(userObj); } else { console.log('hmac -', calculatedHMAC); return res.send('신뢰할 수 없는 데이터입니다. '); }

Javascript

캡슐화

잘못된 세션에 의한 데이터 정보노출

잘못된 세션에 의해 인가되지 않은 사용자에게 중요정보가 노출 가능한 보안약점

let instance; class UserSingleton { constructor() { this.userName = 'testUser'; if (instance) { return instance; } instance = this; } getUserProfile() { return this.userName; } }; router.get("/vuln", (req, res) => { const user = new UserSingleton(); const profile = user.getUserProfile(); // 서로 다른 세션에서 공유되는 값을 사용하는 경우 다른 세션에 의해 데이터가 노출될 수 있음 return res.send(profile); });

class User { constructor() { this.userName = 'testUser'; } getUserProfile() { return this.userName; } }; router.get("/patched", (req, res) => { const user = new User(); const profile = user.getUserProfile(); // 서로 다른 세션에서 공유되지 않는 클래스 정의를 사용해 안전함 return res.send(profile); });

Javascript

캡슐화

제거되지 않고 남은 디버그 코드

디버깅을 위한 코드를 제거하지 않아 인가되지 않은 사용자에게 중요정보가 노출 가능한 보안약점

디버깅 목적으로 삽입된 코드는 개발이 완료되면 제거해야 한다. 디버그 코드는 설정 등의 민감한 정보 또는 의도하지 않은 시스템 제어로 이어지는 정보를 담고 있을 수 있다. 만일 디버그 코드가 남겨진 채로 배포될 경우 공격자가 식별 과정을 우회하거나 의도하지 않은 정보 노출 문제가 발생할 수 있다. 기본적으로 자바스크립트에서는 console.log 또는 console.error 함수를 사용해 디버그 메시지를 출력한다. 개발 완료 후에 디버깅용으로 작성한 코드를 오버라이드(override) 해 애플리케이션 동작 시 콘솔 로그가 출력 되지 않도록 한다. 또한 기본적으로 ExpressJS는 디버그 모드가 비활성화 된 상태에서 동작하며 서버 구동 시 ‘DEBUG=’ prefix 설정을 하지 않는 한 서버 디버깅 메시지는 출력하지 않는다.

// 애플리케이션 진입 코드인 Index.js에 다음 코드를 추가하면 // 코드 내에 삭제되지 않은 모든 console.log 코드로 인해 아무런 내용도 출력되지 않음 // ReactJS 예제 if (process.env.NODE_ENV === ‘production’ && typeof window !== ‘undefined’) { console.log = () => {}; }

Javascript

캡슐화

제거되지 않고 남은 디버그 코드

디버깅을 위한 코드를 제거하지 않아 인가되지 않은 사용자에게 중요정보가 노출 가능한 보안약점

디버깅 목적으로 삽입된 코드는 개발이 완료되면 제거해야 한다. 디버그 코드는 설정 등의 민감한 정보 또는 의도하지 않은 시스템 제어로 이어지는 정보를 담고 있을 수 있다. 만일 디버그 코드가 남겨진 채로 배포될 경우 공격자가 식별 과정을 우회하거나 의도하지 않은 정보 노출 문제가 발생할 수 있다. 기본적으로 자바스크립트에서는 console.log 또는 console.error 함수를 사용해 디버그 메시지를 출력한다. 개발 완료 후에 디버깅용으로 작성한 코드를 오버라이드(override) 해 애플리케이션 동작 시 콘솔 로그가 출력 되지 않도록 한다. 또한 기본적으로 ExpressJS는 디버그 모드가 비활성화 된 상태에서 동작하며 서버 구동 시 ‘DEBUG=’ prefix 설정을 하지 않는 한 서버 디버깅 메시지는 출력하지 않는다.

// 서버 진입 코드인 index.js 내의 서버 구동 부분에 다음 코드 추가 // ExpressJS 예제 app.listen(80, () => { if (!process.env.DEBUG) { console.log = function(){} } });

Javascript

캡슐화

Public 메소드로부터 반환된 Private 배열

Public으로 선언된 메소드에서 Private로 선언된 배열을 반환(return)하면 Private 배열의 주소 값이 외부에 노출되어 해당 Private 배열값을 외부에서 수정 가능한 보안약점

class UserObj { #privArray = []; // private 배열을 리턴하는 public 메소드를 사용하는 경우 취약 get_private_member = () => { return this.#privArray; } }

class UserObj { #privArray = []; // private 배열을 반환하는 경우 복사본을 사용해 외부와 내부의 // 배열이 서로 참조되지 않도록 해야 함 get_private_member = () => { const copied = Object.assign([], this.#privArray); return copied; } }

Javascript

캡슐화

Private 배열에 Public 데이터 할당

Public으로 선언된 데이터 또는 메소드의 인자가 Private로 선언된 배열에 저장되면 Private 배열을 외부에서 접근하여 수정 가능한 보안약점

class UserObj { #privArray = []; // private 배열에 외부 값을 바로 대입하는 public 메소드를 사용하는 경우 취약 set_private_member = (input_list) => { this.#privArray = input_list; } }

class UserObj2 { #privArray = []; // 사용자가 전달한 값을 private가 아닌 public 배열로 저장 set_private_member = (input_list) => { this.userInput = input_list; } }

Javascript

API 오용

DNS lookup에 의존한 보안결정

도메인명 확인(DNS lookup)으로 보안결정을 수행할 때 악의적으로 변조된 DNS 정보로 예기치 않은 보안위협에 노출되는 보안약점

const express = require('express'); const dns = require("dns"); router.get("/vuln", (req, res) => { let trusted = false; const trustedHost = "www.google.com"; const hostName = req.query.host; // 공격자에 의해 실행되는 서버의 DNS가 변경될 수 있으므로 // 안전하지 않음 if (hostName === trustedHost) { trusted = true; } return res.send({trusted}); });

const express = require('express'); const dns = require("dns"); router.get("/patched", async (req, res) => { let trusted = false; const trustedHost = "142.250.207.100"; // 실제 서버의 IP 주소를 비교하여 DNS 변조에 대응 async function dnsLookup() { return new Promise((resolve, reject) => { dns.lookup(req.query.host, 4, (err, address, family) => { if (err) reject(err); resolve(address); }) }) } const hostName = await dnsLookup(); if (hostName === trustedHost) { trusted = true; } return res.send({trusted}); });

Javascript

API 오용

취약한 API 사용

eval() 함수의 부적절한 사용

const userInput = "2 + 2"; const result = eval(userInput); // 사용자 입력을 평가하여 실행 console.log(result);

const math = require('mathjs'); const userInput = "2 + 2"; const result = math.evaluate(userInput); // 안전한 수학 표현식 평가 console.log(result);

Javascript

API 오용

취약한 API 사용

innerHTML 속성의 부적절한 사용

const userInput = "<img src='x' onerror='alert(1)'>"; document.getElementById('output').innerHTML = userInput;

const userInput = "<img src='x' onerror='alert(1)'>"; const outputElement = document.getElementById('output'); const textNode = document.createTextNode(userInput); outputElement.appendChild(textNode);

Javascript

API 오용

취약한 API 사용

setTimeout() 및 setInterval() 함수의 부적절한 사용

const userInput = "alert('Hello')"; setTimeout(userInput, 1000); // 사용자 입력을 코드로 실행

const userInput = "Hello"; setTimeout(() => { alert(userInput); }, 1000);

Javascript

API 오용

취약한 API 사용

Function 생성자의 부적절한 사용

const userInput = "return 2 + 2"; const func = new Function(userInput); console.log(func());

const userInput = "2 + 2"; const result = eval(userInput); // eval 사용은 지양해야 하지만, 예시를 위해 사용 console.log(result);

Javascript

API 오용

취약한 API 사용

document.write() 함수의 부적절한 사용

const userInput = "<script>alert('XSS')</script>"; document.write(userInput);

const userInput = "Hello, World!"; const outputElement = document.getElementById('output'); const textNode = document.createTextNode(userInput); outputElement.appendChild(textNode);

Python

입력데이터 검증 및 표현

SQL 삽입

SQL 질의문을 생성할 때 검증되지 않은 외부 입력값을 허용하여 악의적인 질의문이 실행가능한 보안약점

from django.shortcuts import render from django.db import connection def update_board(request): ...... dbconn = connection with dbconn.cursor() as curs: # 외부로부터 입력받은 값을 검증 없이 사용할 경우 안전하지 않다 name = request.POST.get('name', '') content_id = request.POST.get('content_id', '') # 사용자의 검증되지 않은 입력값을 사용해 동적 쿼리문 생성 sql_query = "update board set name='" + name + "' where content_id='“ + content_id + "'" # 외부 입력값이 검증 없이 쿼리로 포함되어 안전하지 않다 curs.execute(sql_query) dbconn.commit() return render(request, '/success.html')

from django.shortcuts import render from django.db import connection def update_board(request): ...... dbconn = connection with dbconn.cursor() as curs: name = request.POST.get('name', '') content_id = request.POST.get('content_id', '') # 외부 입력값 조작으로부터 안전한 인자화된 쿼리를 생성한다. sql_query = 'update board set name=%s where content_id=%s' # 사용자의 입력값이 인자화된 쿼리에 바인딩 후 실행되므로 안전하다. curs.execute(sql_query, (name, content_id)) dbconn.commit() return render(request, '/success.html')

Python

입력데이터 검증 및 표현

SQL 삽입

SQL 질의문을 생성할 때 검증되지 않은 외부 입력값을 허용하여 악의적인 질의문이 실행가능한 보안약점

from django.shortcuts import render from app.models import Member def member_search(request): name = request.POST.get('name', '') # 입력값을 검증 없이 쿼리문 생성에 사용해 안전하지 않다 query=“select * from member where name=‘” + name + “’” # 외부 입력값을 검증 없이 사용한 쿼리문을 raw()함수로 실행하면 안전하지 않다 data = Member.objects.raw(query) return render(request, '/member_list.html', {'member_list':data})

from django.shortcuts import render from app.models import Member def member_search(request): name = request.POST.get('name', '') # 외부 입력값을 raw() 함수 실행 시 바인딩 변수로 사용하여 쿼리 구조가 # 변경되지 않도록 한다.(list 형은 %s, dictionary 형은 %(key)s를 사용) query='select * from member where name=%s' # 인자화된 쿼리문을 사용하여 raw() 함수를 호출해 안전하다 data = Member.objects.raw(query, [name]) return render(request, '/member_list.html', {'member_list':data})

Python

입력데이터 검증 및 표현

코드 삽입

프로세스가 외부 입력값을 코드(명령어)로 해석·실행할 수 있고 프로세스에 검증되지 않은 외부 입력값을 허용한 경우 악의적인 코드가 실행 가능한 보안약점

from django.shortcuts import render def route(request): # 외부에서 입력받은 값을 검증 없이 사용하면 안전하지 않다 message = request.POST.get('message', '') # 외부 입력값을 검증 없이 eval 함수에 전달할 경우 의도하지 않은 코드가 # 실행될 수 있어 위험하다 ret = eval(message) return render(request, '/success.html', {'data':ret})

from django.shortcuts import render def route(request): message = request.POST.get('message', '') # 사용자 입력을 영문, 숫자로 제한하며, 만약 입력값 내에 특수문자가 포함되어 # 있을 경우 에러 메시지를 반환 한다 if message.isalnum(): ret = eval(message) return render(request, '/success.html', {'data':ret}) return render(request, '/error.html')

Python

입력데이터 검증 및 표현

코드 삽입

프로세스가 외부 입력값을 코드(명령어)로 해석·실행할 수 있고 프로세스에 검증되지 않은 외부 입력값을 허용한 경우 악의적인 코드가 실행 가능한 보안약점

from django.shortcuts import render def request_rest_api(request): function_name = request.POST.get('function_name', '') # 사용자에게 전달받은 함수명을 검증하지 않고 실행 # 입력값으로 “__import__(‘platform’).system()” 등을 입력 시 # 시스템 정보 노출 위험이 있다 exec('{}()'.format(function_name)) return render(request, '/success.html')

from django.shortcuts import render WHITE_LIST = ['get_friends_list', 'get_address', 'get_phone_number'] def request_rest_api(request): function_name = request.POST.get('function_name', '') # 사용 가능한 함수를 화이트리스트 목록 내의 함수로 제한 if function_name in WHITE_LIST: exec('{}()'.format(function_name)) return render(request, '/success.html') return render(request, '/error.html', {'error':'허용되지 않은 함수입니다.'})

Python

입력데이터 검증 및 표현

경로 조작 및 자원 삽입

시스템 자원 접근경로 또는 자원제어 명령어에 검증되지 않은 외부 입력값을 허용하여 시스템 자원에 무단 접근 및 악의적인 행위가 가능한 보안약점

import os from django.shortcuts import render def get_info(request): # 외부 입력값으로부터 파일명을 입력 받는다 request_file = request.POST.get('request_file') (filename, file_ext) = os.path.splitext(request_file) file_ext = file_ext.lower() if file_ext not in ['.txt', '.csv']: return render(request, '/error.html', {'error':'파일을 열 수 없습니다.'}) # 입력값을 검증 없이 파일 처리에 사용했다 with open(request_file) as f: data = f.read() return render(request, '/success.html', {'data':data})

import os from django.shortcuts import render def get_info(request): request_file = request.POST.get('request_file') (filename, file_ext) = os.path.splitext(request_file) file_ext = file_ext.lower() # 외부 입력값으로 받은 파일 이름은 검증하여 사용한다. if file_ext not in ['.txt', '.csv']: return render(request, '/error.html', {'error':'파일을 열수 없습니다.'}) # 파일 명에서 경로 조작 문자열을 필터링 한다. filename = filename.replace('.', '') filename = filename.replace('/', '') filename = filename.replace('\\', '') try: with open(filename + file_ext) as f: data = f.read() except Exception: return render( request, "/error.html", {"error": "파일이 존재하지 않거나 열 수 없는 파일입니다."} ) return render(request, '/success.html', {'data':data})

Python

입력데이터 검증 및 표현

경로 조작 및 자원 삽입

시스템 자원 접근경로 또는 자원제어 명령어에 검증되지 않은 외부 입력값을 허용하여 시스템 자원에 무단 접근 및 악의적인 행위가 가능한 보안약점

import socket from django.shortcuts import render def get_info(request): port = int(request.POST.get('port')) with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: # 외부로부터 입력받은 검증되지 않은 포트 번호를 이용하여 # 소켓을 바인딩하여 사용하고 있어 안전하지 않다 s.bind(('127.0.0.1', port)) ... return render(request, '/success.html') return render(request, '/error.html', {'error':'소켓연결 실패'})

import socket from django.shortcuts import render ALLOW_PORT = [4000, 6000, 9000] def get_info(request): port = int(request.POST.get('port')) # 사용 가능한 포트 번호를 화이트리스트 내의 포트로 제한 if port not in ALLOW_PORT: return render(request, '/error.html', {'error':'소켓연결 실패'}) with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind(('127.0.0.1', port)) ...... return render(request, '/success.html')

Python

입력데이터 검증 및 표현

크로스사이트 스크립트(XSS)

사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 악의적인 스크립트가 실행 가능한 보안약점

from django.shortcuts import render from django.utils.safestring import mark_safe def profile_link(request): # 외부 입력값을 검증 없이 HTML 태그 생성의 인자로 사용 profile_url = request.POST.get('profile_url') profile_name = requst.POST.get('profile_name') object_link = '<a href="{}">{}</a>'.format(profile_url, profile_name) # mark_safe함수는 Django의 XSS escape 정책을 따르지 않는다 object_link = mark_safe(object_link) return render(request, 'my_profile.html',{'object_link':object_link})

from django.shortcuts import render def profile_link(request): # 외부 입력값을 검증 없이 HTML 태그 생성의 인자로 사용 profile_url = request.POST.get('profile_url') profile_name = requst.POST.get('profile_name') object_link = '<a href="{}">{}</a>'.format(profile_url, profile_name) # 신뢰할 수 없는 데이터에 대해서는 mark_safe 함수를 사용해선 안 된다 return render(request, 'my_profile.html',{'object_link':object_link})

Python

입력데이터 검증 및 표현

크로스사이트 스크립트(XSS)

사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 악의적인 스크립트가 실행 가능한 보안약점

<!doctype html> <html> <body> <div class="content"> {% autoescape off %} <!-- autoescape off로 설정하면 해당 블록내의 데이터는 XSS 공격에 노출될 수 있다 --> {{ content }} {% endautoescape %} </div> <div class="content2"> <!-- safe 필터 사용으로 XSS 공격에 노출될 수 있다 --> {{ content | safe }} </div> </body> </html>

<!doctype html> <html> <body> <div class="content"> {% autoescape on %} <!--autoescape on으로 해당 블록내의 데이터는 XSS 공격에 노출되지 않음. --> {{ content }} {% endautoescape %} </div> <div class="content2"> <!-- 검증되지 않은 데이터에는 safe 필터를 사용하지 않는다. --> {{ content }} </div> </body> </html>

Python

입력데이터 검증 및 표현

크로스사이트 스크립트(XSS)

사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 악의적인 스크립트가 실행 가능한 보안약점

from flask import Flask, request, render_template @app.route('/search', methods=['POST']) def search(): search_keyword = request.form.get('search_keyword') # 사용자의 입력을 아무런 검증 또는 치환 없이 동적 웹페이지에 사용하고 있어 # XSS 공격이 발생할 수 있다 return render_template('search.html', search_keyword=search_keyword)

import html from flask import Flask, request, render_template @app.route('/search', methods=['POST']) def search(): search_keyword = request.form.get('search_keyword') # 동적 웹페이지 생성에 사용되는 데이터는 # HTML 엔티티코드로 치환하여 표현해야 한다 escape_keyword = html.escape(search_keyword) return render_template('search.html', search_keyword=escape_keyword)

Python

입력데이터 검증 및 표현

운영체제 명령어 삽입

운영체제 명령어를 생성할 때 검증되지 않은 외부 입력값을 허용하여 악의적인 명령어가 실행 가능한 보안약점

import os from django.shortcuts import render def execute_command(request): app_name_string = request.POST.get('app_name','') # 입력 파라미터를 제한하지 않아 외부 입력값으로 전달된 # 모든 프로그램이 실행될 수 있음 os.system(app_name_string) return render(request, '/success.html')

import os from django.shortcuts import render ALLOW_PROGRAM = ['notepad', 'calc'] def execute_command(request): app_name_string = request.POST.get('app_name','') # 입력받은 파라미터가 허용된 시스템 명령어 목록에 포함되는지 검사 if app_name_string not in ALLOW_PROGRAM: return render(request, '/error.html', {'error':'허용되지 않은 프로그램입니다.'}) os.system(app_name_string) return render(request, '/success.html')

Python

입력데이터 검증 및 표현

운영체제 명령어 삽입

운영체제 명령어를 생성할 때 검증되지 않은 외부 입력값을 허용하여 악의적인 명령어가 실행 가능한 보안약점

import subprocess from django.shortcuts import render def execute_command(request): date = request.POST.get('date','') # 입력받은 파라미터를 제한하지 않아 전달된 모든 프로그램이 실행될 수 있음 cmd_str = “cmd /c backuplog.bat ” + date subprocess.run(cmd_str, shell=True) return render(request, '/success.html')

import subprocess from django.shortcuts import render def execute_command(request): date = request.POST.get('date','') # 명령어를 추가로 실행 또는 또 다른 명령이 실행될 수 있는 키워드에 # 대한 예외처리 for word in ['|', ';', '&', ':', '>', '<', '`', '\\', '!']: date = date.replace(word, “”) # re.sub 함수를 사용해 특수문자를 제거하는 방법도 있다 # date = re.sub('[|;&:><`\\\!]', '', date) # shell=True 옵션은 제거 하고 명령과 인자를 배열로 입력 subprocess.run(["cmd", "/c", "backuplog.bat", date]) return render(request, '/success.html')

Python

입력데이터 검증 및 표현

위험한 형식 파일 업로드

파일의 확장자 등 파일형식에 대한 검증없이 파일 업로드를 허용하여 공격이 가능한 보안약점

from django.shortcuts import render from django.core.files.storage import FileSystemStorage def file_upload(request): if request.FILES['upload_file']: # 사용자가 업로드하는 파일을 검증 없이 저장하고 있어 # 안전하지 않다 upload_file = request.FILES['upload_file'] fs = FileSystemStorage(location='media/screenshot', base_url='media/screenshot') # 업로드 하는 파일에 대한 크기, 개수, 확장자 등을 검증하지 않음 filename = fs.save(upload_file.name, upload_file) return render(request, '/success.html', {'filename':filename}) return render(request, '/error.html', {'error':'파일 업로드 실패'})

import os from django.shortcuts import render from django.core.files.storage import FileSystemStorage # 업로드 하는 파일 개수, 크기, 확장자 제한 FILE_COUNT_LIMIT = 5 # 업로드 하는 파일의 최대 사이즈 제한 예 ) 5MB - 5*1024*1024 FILE_SIZE_LIMIT = 5242880 # 허용하는 확장자는 화이트리스트로 관리한다. WHITE_LIST_EXT = [ '.jpg', '.jpeg' ] def file_upload(request): # 파일 개수 제한 if len(request.FILES) == 0 or len(request.FILES) > FILE_COUNT_LIMIT: return render(request, '/error.html', {'error': '파일 개수 초과'}) for filename, upload_file in request.FILES.items(): # 파일 타입 체크 if upload_file.content_type != 'image/jpeg': return render(request, '/error.html', {'error': '파일 타입 오류'}) # 파일 크기 제한 if upload_file.size > FILE_SIZE_LIMIT: return render(request, '/error.html', {'error': '파일사이즈 오류'}) # 파일 확장자 검사 file_name, file_ext = os.path.splitext(upload_file.name) if file_ext.lower() not in WHITE_LIST_EXT: return render(request, '/error.html', {'error': '파일 타입 오류'}) fs = FileSystemStorage(location='media/screenshot', base_url = 'media/screenshot') for upload_file in request.FILES.values(): filename = fs.save(upload_file.name, upload_file) filename_list.append(filename) return render(request, "/success.html", {"filename_list": filename_list})

Python

입력데이터 검증 및 표현

신뢰되지 않은 URL주소로 자동접속 연결

URL 링크 생성에 검증되지 않은 외부 입력값을 허용하여 악의적인 사이트로 자동 접속 가능한 보안약점

from django.shortcuts import redirect def redirect_url(request): url_string = request.POST.get('url', '') # 사용자 입력에 포함된 URL 주소로 리다이렉트 하는 경우 # 피싱 사이트로 접속되는 등 사용자가 피싱 공격에 노출될 수 있다 return redirect(url_string)

from django.shortcuts import render, redirect ALLOW_URL_LIST = [ '127.0.0.1', '192.168.0.1', '192.168.0.100', 'https://login.myservice.com', '/notice', ] def redirect_url(request): url_string = request.POST.get('url', '') # 이동할 수 있는 URL 범위를 제한하여 # 위험한 사이트의 접근을 차단하고 있다 if url_string not in ALLOW_URL_LIST: return render(request, '/error.html', {'error':'허용되지 않는 주소입니다.'}) return redirect(url_string)

Python

입력데이터 검증 및 표현

부적절한 XML 외부 개체 참조

임의로 조작된 XML 외부개체에 대한 적절한 검증 없이 참조를 허용하여 공격이 가능한 보안약점

<?xml version="1.0" encoding="ISO-8859-1"?> <!DOCTYPE foo [ <!ELEMENT foo ANY > <!ENTITY xxe1 SYSTEM "file:///etc/passwd" > <!ENTITY xxe2 SYSTEM "http://attacker.com/text.txt"> ]> <foo>&xxe1;&xxe2;</foo> from xml.sax import make_parser from xml.sax.handler import feature_external_ges from xml.dom.pulldom import parseString, START_ELEMENT from django.shortcuts import render from .model import comments def get_xml(request): if request.method == "GET": data = comments.objects.all() com = data[0].comment return render(request, '/xml_view.html', {'com': com}) elif request.method == "POST": parser = make_parser() # 외부 일반 엔티티를 포함하는 설정을 True로 적용할 경우 취약하다 parser.setFeature(feature_external_ges, True) doc = parseString(request.body.decode('utf-8'), parser=parser) for event, node in doc: if event == START_ELEMENT and node.tagName == "foo": doc.expandNode(node) text = node.toxml() comments.objects.filter(id=1).update(comment=text) return render(request, '/xml_view.html')

from xml.sax import make_parser from xml.sax.handler import feature_external_ges from xml.dom.pulldom import parseString, START_ELEMENT from django.shortcuts import render from .model import comments def get_xml(request): if request.method == “GET”: data = comments.objects.all() com = data[0].comment return render(request, '/xml_view.html', {'com':com}) elif request.method == “POST”: parser = make_parser() parser.setFeature(feature_external_ges, False) doc = parseString(request.body.decode(‘utf-8’), parser=parser) for event, node in doc: if event == START_ELEMENT and node.tagName == “foo”: doc.expandNode(node) text = node.toxml() comments.objects.filter(id=1).update(comment=text); return render(request, '/xml_view.html')

Python

입력데이터 검증 및 표현

XML 삽입

XQuery, XPath 질의문을 생성할 때 검증되지 않은 외부 입력값을 허용하여 악의적인 질의문이 실행 가능한 보안약점

from django.shortcuts import render from lxml import etree def parse_xml(request): user_name = request.POST.get('user_name', '') parser = etree.XMLParser(resolve_entities=False) tree = etree.parse('user.xml', parser) root = tree.getroot() # 검증되지 않은 외부 입력값 user_name을 사용한 안전하지 않은 # 질의문이 query 변수에 저장 query = "/collection/users/user[@name='" + user_name + "']/home/text()" elmts = root.xpath(query) return render(request, 'parse_xml.html', {'xml_element':elmts})

from django.shortcuts import render from lxml import etree def parse_xml(request): user_name = request.POST.get('user_name', '') parser = etree.XMLParser(resolve_entities=False) tree = etree.parse('user.xml', parser) root = tree.getroot() # 외부 입력값을 paramname으로 인자화 해서 사용 query = '/collection/users/user[@name = $paramname]/home/text()' elmts = root.xpath(query, paramname=user_name) return render(request, 'parse_xml.html', {'xml_element':elmts})

Python

입력데이터 검증 및 표현

LDAP 삽입

LDAP 명령문을 생성할 때 검증되지 않은 외부 입력값을 허용하여 악의적인 명령어가 실행 가능한 보안약점

from ldap3 import Connection, Server, ALL from django.shortcuts import render config = { "bind_dn": "cn=read-only-admin,dc=example,dc=com", "password": "password", } def ldap_query(request): search_keyword = request.POST.get('search_keyword','') dn = config['bind_dn'] password = config['password'] address = 'ldap.badSoruce.com' server = Server(address, get_info=ALL) conn = Connection(server, user=dn, password, auto_bind=True ) # 사용자 입력을 필터링 하지 않는 경우 공격자의 권한 상승으로 # 이어질 수 있다 search_str = '(&(objectclass=%s))' % search_keyword conn.search( 'dc=company,dc=com', search_str, attributes=['sn', 'cn', 'address', 'mail', 'mobile', 'uid'], ) return render(request, '/ldap_query_response.html', {'ldap':conn.entries})

from ldap3 import Connection, Server, ALL from ldap3.utils.conv import escape_filter_chars from django.shortcuts import render config = { "bind_dn": "cn=read-only-admin,dc=example,dc=com", "password": "password", } def ldap_query(request): search_keyword = request.POST.get('search_keyword','') dn = config['bind_dn'] password = config['password'] address = 'ldap.goodsource.com' server = Server(address, get_info=ALL) conn = Connection(server, dn, password, auto_bind=True ) # 사용자의 입력에 필터링을 적용하여 공격에 사용될 수 있는 문자를 # 이스케이프하고 있다 escpae_keyword = escape_filter_chars(search_keyword) search_str = '(&(objectclass=%s))' % escpae_keyword conn.search( 'dc=company,dc=com', search_str, attributes=['sn', 'cn', 'address', 'mail', 'mobile', 'uid'], ) return render(request, '/ldap_query_response.html', {'ldap':conn.entries})

Python

입력데이터 검증 및 표현

크로스사이트 요청 위조(CSRF)

사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 사용자 본인의 의지와는 무관하게 공격자가 의도한 행위가 실행 가능한 보안약점

MIDDLEWARE = [ 'django.contrib.sessions.middleware.SessionMiddleware', # MIDDLEWARE 목록에서 CSRF 항목을 삭제 또는 주석처리 하면 # Django 앱에서 CSRF 유효성 검사가 전역적으로 제거된다 # 'django.middleware.csrf.CsrfViewMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.contrib.messages.middleware.MessageMiddleware', 'django.middleware.locale.LocaleMiddleware', ...... ]

MIDDLEWARE = [ 'django.contrib.sessions.middleware.SessionMiddleware', # MIDDLEWARE 목록에서 CSRF 항목을 활성화 한다 'django.middleware.csrf.CsrfViewMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.contrib.messages.middleware.MessageMiddleware', 'django.middleware.locale.LocaleMiddleware', ...... ]

Python

입력데이터 검증 및 표현

크로스사이트 요청 위조(CSRF)

사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 사용자 본인의 의지와는 무관하게 공격자가 의도한 행위가 실행 가능한 보안약점

from django.shortcuts import render from django.views.decorators.csrf import csrf_exempt # csrf.exempt 데코레이터로 미들웨어에서 보호되는 CSRF 기능을 해제한다 @csrf.exempt def pay_to_point(request): user_id = request.POST.get('user_id', '') pay = request.POST.get('pay', '') product_info = request.POST.get('product_info', '') ret = handle_pay(user_id, pay, product_info) return render(request, '/view_wallet.html', {'wallet':ret})

from django.shortcuts import render from django.template import RequestContext # csrf_exempt 데코레이터를 삭제하거나 주석 처리한다. # @csrf_exempt def pay_to_point(request): user_id = request.POST.get('user_id', '') pay = request.POST.get('pay', '') product_info = request.POST.get('product_info', '') ret = handle_pay(user_id, pay, product_info) return render(request, '/view_wallet.html', {'wallet':ret})

Python

입력데이터 검증 및 표현

크로스사이트 요청 위조(CSRF)

사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 사용자 본인의 의지와는 무관하게 공격자가 의도한 행위가 실행 가능한 보안약점

<!--html page--> <form action="" method="POST"> <!-- form 태그 내부에 csrf_token 미적용--> <table> {{form.as_table}} </table> <input type="submit"/> </form>

<!--html page--> <form action="" method="POST"> {% csrf_token %} <!--csrf_token 사용-> <table> {{form.as_table}} </table> <input type="submit"/> </form>

Python

입력데이터 검증 및 표현

크로스사이트 요청 위조(CSRF)

사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 사용자 본인의 의지와는 무관하게 공격자가 의도한 행위가 실행 가능한 보안약점

from flask import Flask app = Flask(__name__)

from flask import Flask from flask_wtf.csrf import CSRFProtect # CSRF 설정 추가 csrf = CSRFProtect(app) app = Flask(__name__) app.config[‘SECRET_KEY’] = os.environ.get('SECRET_KEY') csrf.init_app(app)

Python

입력데이터 검증 및 표현

크로스사이트 요청 위조(CSRF)

사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 사용자 본인의 의지와는 무관하게 공격자가 의도한 행위가 실행 가능한 보안약점

<form action="" method="POST"> <!-- form 태그 내부에 csrf_token 미적용--> <table> {{as_table}} </table> <input type="submit"/> </form>

<form action="" method="POST"> <!-- form 태그 내부에 csrf_token 적용--> <input type="hidden" name="csrf_token" value="{{ csrf_token() }}" /> <table> {{table}} </table> <input type="submit"/> </form>

Python

입력데이터 검증 및 표현

서버사이드 요청 위조

서버 간 처리되는 요청에 검증되지 않은 외부 입력값을 허용하여 공격자가 의도한 서버로 전송하거나 변조하는 보안약점

from django.shortcuts import render import requests def call_third_party_api(request): addr = request.POST.get('address', '') # 사용자가 입력한 주소를 검증하지 않고 HTTP 요청을 보낸 후 # 응답을 사용자에게 반환 result = requests.get(addr).text return render(request, '/result.html', {'result':result})

from django.shortcuts import render import requests # 허용하는 도메인을 화이트리스트에 정의할 경우 DNS rebinding 공격 등에 # 노출될 위험이 있어 신뢰할 수 있는 자원에 대한 IP를 사용해 # 검증하는 것이 조금 더 안전하다 ALLOW_SERVER_LIST = [ 'https://127.0.0.1/latest/', 'https://192.168.0.1/user_data', 'https://192.168.0.100/v1/public', ] def call_third_party_api(request): addr = request.POST.get('address', '') # 사용자가 입력한 URL을 화이트리스트로 검증한 후 그 결과를 반환하여 # 검증되지 않은 주소로 요청을 보내지 않도록 제한한다 if addr not in ALLOW_SERVER_LIST: return render(request, '/error.html', {‘error’ = '허용되지 않은 서버입니다.'}) result = requests.get(addr).text return render(request, '/result.html', {'result':result})

Python

입력데이터 검증 및 표현

HTTP 응답분할

HTTP 응답헤더에 개행문자(CR이나 LF)가 포함된 검증되지 않은 외부 입력값을 허용하여 악의적인 코드가 실행 가능한 보안약점

from django.http import HttpResponse def route(request): content_type = request.POST.get('content-type') # 외부 입력값을 검증 또는 필터링 하지 않고 # 응답 헤더의 값으로 포함시켜 회신한다 ...... res = HttpResponse() res['Content-Type'] = content_type return res

from django.http import HttpResponse def route(request): content_type = request.POST.get('content-type') # 응답헤더에 포함될 수 있는 외부 입력값 내의 개행 문자를 제거한다 content_type = content_type.replace('\r', '') content_type = content_type.replace('\n', '') ...... res = HttpResponse() res['Content-Type'] = content_type return res

Python

입력데이터 검증 및 표현

정수형 오버플로우

정수형 변수에 저장된 값이 허용된 정수 값 범위를 벗어나 프로그램이 예기치 않게 동작 가능한 보안약점

import numpy as np def handle_data(number, pow): res = np.power(number, pow, dtype=np.int64) # 64비트를 넘어서는 숫자와 지수가 입력될 경우 오버플로우가 발생해 결과값이 0이 된다 return res

import numpy as np MAX_NUMBER = np.iinfo(np.int64).max MIN_NUMBER = np.iinfo(np.int64).min def handle_data(number, pow): calculated = number ** pow # 파이썬 기본 자료형으로 큰 수를 계산한 후 이를 검사해 오버플로우 탐지 if calculated > MAX_NUMBER or calculated < MIN_NUMBER: # 오버플로우 탐지 시 비정상 종료를 나타내는 –1 값 반환 return –1 res = np.power(number, pow, dtype=np.int64) return res

Python

입력데이터 검증 및 표현

보안기능 결정에 사용되는 부적절한 입력값

보안기능(인증, 권한부여 등) 결정에 검증되지 않은 외부 입력값을 허용하여 보안기능을 우회하는 보안약점

from django.shortcuts import render def init_password(request): # 쿠키에서 권한 정보를 가져 온다 role = request.COOKIE['role'] request_id = request.POST.get('user_id', '') request_mail = request.POST.get('user_email','') # 쿠키에서 가져온 권한이 관리자인지 비교 if role == 'admin': # 사용자의 패스워드 초기화 및 메일 발송 처리 password_init_and_sendmail(request_id, request_mail) return render(request, '/success.html') else: return render(request, '/failed.html')

from django.shortcuts import render def init_password(request): # 세션에서 권한 정보를 가져옴 role = request.session['role'] request_id = request.POST.get('user_id', '') request_mail = request.POST.get('user_email','') # 세션에서 가져온 권한이 관리자인지 비교 if role == ‘admin’: # 사용자의 패스워드 초기화 및 메일 발송 처리 password_init_and_sendmail(request_id, request_mail) return render(request, '/sucess.html') else: return render(request, '/failed.html')

Python

입력데이터 검증 및 표현

포맷 스트링 삽입

str.format등 포맷 스트링 제어함수에 검증되지 않은 외부 입력값을 허용하여 발생하는 보안약점* 포맷 스트링: 입·출력에서 형식이나 형태를 지정해주는 문자열

from django.shortcuts import render AUTHENTICATE_KEY = 'Passw0rd' def make_user_message(request): user_info = get_user_info(request.POST.get('user_id', '')) format_string = request.POST.get('msg_format', '') # 내부의 민감한 정보가 외부로 노출될 수 있다. # 사용자가 입력한 문자열을 포맷 문자열로 사용하고 있어 안전하지 않다 message = format_string.format(user=user_info) return render(request, '/user_page.html', {'message':message})

from django.shortcuts import render AUTHENTICATE_KEY = 'Passw0rd' def make_user_message(request): user_info = get_user_info(request.POST.get('user_id', '')) # 사용자가 입력한 문자열을 포맷 문자열로 사용하지 않아 안전하다 message = 'user name is {}'.format(user_info.name) return render(request, '/user_page.html', {'message':message})

Python

보안기능

적절한 인증 없는 중요 기능 허용

중요정보(금융정보, 개인정보, 인증정보 등)를 적절한 인증없이 열람(또는 변경) 가능한 보안약점

from django.shortcuts import render from re import escape import hashlib def change_password(request): new_pwd = request.POST.get('new_password','') # 로그인한 사용자 정보 user = '%s' % escape(request.session['userid']) # 현재 password와 일치 여부를 확인하지 않고 수정함 sha = hashlib.sha256(new_pwd.encode()) update_password_from_db(user, sha.hexdigest()) return render(request, '/success.html')

from django.contrib.auth.decorators import login_required from django.shortcuts import render from re import escape import hashlib # login_required decorator를 사용해 login된 사용자만 접근하도록 처리 @login_required def change_password(request): new_pwd = request.POST.get('new_password','') crnt_pwd = request.POST.get('current_password','') # 로그인한 사용자 정보를 세션에서 가져온다. user = '%s' % escape(request.session['userid']) crnt_h = hashlib.sha256(crnt_pwd.encode()) h_pwd = crnt_h.hexdigest() # DB에서 기존 사용자의 Hash된 패스워드 가져오기 old_pwd = get_password_from_db(user) # 패스워드를 변경하기 전 사용자에 대한 재인증을 수행한다. if old_pwd == h_pwd: new_h = hashlib.sha256(new_pwd.encode()) update_password_from_db(user, new_h.hexdigest()) return render(request, '/success.html') else: return render(request, 'failed.html', {'error': '패스워드가 일치하지 않습니다'})

Python

보안기능

부적절한 인가

중요자원에 접근할 때 적절한 제어가 없어 비인가자의 접근이 가능한 보안약점

from django.shortcuts import render from .model import Content def delete_content(request): action = request.POST.get('action', '') content_id = request.POST.get('content_id', '') # 작업 요청을 하는 사용자의 권한 확인 없이 delete를 수행 if action is not None and action == "delete": Content.objects.filter(id=content_id).delete() return render(request, '/success.html') else: return render(request, '/error.html', {'error':'접근 권한이 없습니다.'})

from django.contrib.auth.decorators import login_required, permission_required from django.shortcuts import render from .model import Content @login_required # 해당 기능을 수행할 권한이 있는지 확인 @permission_required('content.delete', raise_exception=True) def delete_content(request): action = request.POST.get('action', '') content_id = request.POST.get('content_id', '') if action is not None and action == "delete": Content.objects.filter(id=content_id).delete() return render(request, '/success.html') else: return render(request, '/error.html', {'error':'삭제 실패'})

Python

보안기능

중요한 자원에 대한 잘못된 권한 설정

중요자원에 적절한 접근 권한을 부여하지 않아 중요정보가 노출·수정 가능한 보안약점

import os def write_file(): # 모든 사용자가 읽기, 쓰기, 실행 권한을 가지게 된다. os.chmod('/root/system_config', 0o777) with open("/root/system_config", 'w') as f: f.write("your config is broken")

import os def write_file(): # 소유자 외에는 아무런 권한을 주지 않음. os.chmod('/root/system_config', 0o700) with open("/root/system_config", ‘'w') as f: f.write("your config is broken")

Python

보안기능

취약한 암호화 알고리즘 사용

중요정보 (금융정보, 개인정보, 인증정보 등)의 기밀성을 보장할 수 없는 취약한 암호화 알고리즘을 사용하여 정보가 노출 가능한 보안약점

import base64 from Crypto.Cipher import DES from Crypto.Util.Padding import pad def get_enc_text(plain_text, key): # 취약함 암호화 알고리즘인 DES를 사용하여 안전하지 않음 cipher_des = DES.new(key, DES.MODE_ECB) encrypted_data = base64.b64encode(cipher_aes.encrypt(pad(plain_text, 32))) return encrypted_data.decode('ASCII')

import base64 from Crypto.Cipher import AES from Crypto.Util.Padding import pad def get_enc_text(plain_text, key, iv): # 안전한 알고리즘인 AES 를 사용하여 안전함. cipher_aes = AES.new(key, AES.MODE_CBC, iv) encrypted_data = base64.b64encode(cipher_aes.encrypt(pad(plain_text, 32))) return encrypted_data.decode('ASCII')

Python

보안기능

취약한 암호화 알고리즘 사용

중요정보 (금융정보, 개인정보, 인증정보 등)의 기밀성을 보장할 수 없는 취약한 암호화 알고리즘을 사용하여 정보가 노출 가능한 보안약점

import hashlib def make_md5(plain_text): # 취약한 md5 해시함수 사용 hash_text = hashlib.md5(plain_text.encode('utf-8')).hexdigest() return hash_text

import hashlib def make_sha256(plain_text): # 안전한 sha-256 해시함수 사용 hash_text = hashlib.sha256(plain_text.encode('utf-8')).hexdigest() return hash_text

Python

보안기능

암호화되지 않은 중요정보

중요정보(패스워드, 개인정보 등) 전송 시 암호화 또는 안전한 통신채널을 이용하지 않거나, 저장 시 암호화 하지 않아 정보가 노출 가능한 보안약점

def update_pass(dbconn, password, user_id): curs = dbconn.cursor() # 암호화되지 않은 패스워드를 DB에 저장 curs.execute( 'UPDATE USERS SET PASSWORD=%s WHERE USER_ID=%s', password, user_id ) dbconn.commit()

from Crypto.Hash import SHA256 def update_pass(dbconn, password, user_id, salt): # 단방향 암호화를 이용하여 패스워드를 암호화 hash_obj = SHA256.new() hash_obj.update(bytes(password + salt, 'utf-8')) hash_pwd = hash_obj.hexdigest() curs = dbconn.cursor() curs.execute( 'UPDATE USERS SET PASSWORD=%s WHERE USER_ID=%s', (hash_pwd, user_id) ) dbconn.commit()

Python

보안기능

암호화되지 않은 중요정보

중요정보(패스워드, 개인정보 등) 전송 시 암호화 또는 안전한 통신채널을 이용하지 않거나, 저장 시 암호화 하지 않아 정보가 노출 가능한 보안약점

import socket HOST = '127.0.0.1' PORT = 65434 def send_password(password): ...... with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((HOST, PORT)) # 패스워드를 암호화 하지 않고 전송하여 안전하지 않다. s.sendall(password.encode('utf-8')) data = s.recv(1024) .......

import socket import os from Crypto.Cipher import AES HOST = '127.0.0.1' PORT = 65434 def send_password(password): # 문자열로 저장되어 있는 블록키를 로드 block_key = os.environ.get('BLOCK_KEY') aes = AEScipher(block_key) # 패스워드 등 중요 정보는 암호화하여 전송하는 것이 안전하다 enc_passowrd = aes.encrypt(passowrd) with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((HOST, PORT)) s.sendall(enc_passowrd.encode('utf-8')) data = s.recv(1024) ....... class AEScipher: BS = AES.block_size def __init__(self, s_key): self.s_key = hashlib.sha256(s_key.encode("utf-8")).digest() def pad(self, m): return m + bytes([self.BS - len(m) % self.BS] * (self.BS - len(m) % self.BS)) def encrypt(self, plain): plain = self.pad(plain.encode()) iv = Random.new().read(AES.block_size) cipher = AES.new(self.s_key, AES.MODE_CBC, iv) return base64.b64encode(iv + cipher.encrypt(plain)).decode("utf-8") .......

Python

보안기능

하드코드된 중요정보

소스코드에 중요정보(패스워드, 암호화키 등)를 직접 코딩하여 소스코드 유출 시 중요정보가노출되고 주기적 변경이 어려운 보안약점

import pymysql def query_execute(query): # user, passwd가 소스코드에 평문으로 하드코딩되어 있음 dbconn = pymysql.connect( host='127.0.0.1', port='1234', user='root', passwd='1234', db='mydb', charset='utf8', ) curs = dbconn.cursor() curs.execute(query) dbconn.commit() dbconn.close()

import pymysql import json def query_execute(query, config_path): with open(config_path, 'r') as config: # 설정 파일에서 user, passwd를 가져와 사용 dbconf = json.load(fp=config) # 암호화되어 있는 블록 암호화 키를 복호화 해서 가져오는 # 사용자 정의 함수 blockKey = get_decrypt_key(dbconf['blockKey']) # 설정 파일에 암호화되어 있는 값을 가져와 복호화한 후에 사용 dbUser = decrypt(blockKey, dbconf['user']) dbPasswd = decrypt(blockKey, dbconf['passwd']) dbconn = pymysql.connect( host=dbconf['host'] port=dbconf['port'], user=dbUser, passwd=dbPasswd, db=dbconf['db_name'], charset='utf8', ) curs = dbconn.cursor() curs.execute(query) dbconn.commit() dbconn.close()

Python

보안기능

충분하지 않은 키 길이 사용

암호화 등에 사용되는 키의 길이가 충분하지 않아 데이터의 기밀성·무결성을 보장할 수 없는보안약점

from Crypto.PublicKey import RSA, DSA, ECC from tinyec import registry import secrets def make_rsa_key_pair(): # RSA키 길이를 2048 비트 이하로 설정하는 경우 안전하지 않음 private_key = RSA.generate(1024) public_key = private_key.publickey() def make_ecc(): # ECC의 키 길이를 224비트 이하로 설정하는 경우 안전하지 않음 ecc_curve = registry.get_curve('secp192r1') private_key = secrets.randbelow(ecc_curve.field.n) public_key = private_key * ecc_curve.g

from Crypto.PublicKey import RSA, DSA, ECC from tinyec import registry import secrets def make_rsa_key_pair(): # RSA 키 길이를 2048 비트 이상으로 길게 설정 private_key = RSA.generate(2048) public_key = private_key.publickey() def make_ecc(): # ECC 키 길이를 224 비트 이상으로 설정 ecc_curve = registry.get_curve('secp224r1') private_key = secrets.randbelow(ecc_curve.field.n) public_key = private_key * ecc_curve.g

Python

보안기능

적절하지 않은 난수 값 사용

사용한 난수가 예측 가능하여, 공격자가 다음 난수를 예상해서 시스템을 공격 가능한 보안약점

import random def get_otp_number(): random_str = '' # 시스템 현재 시간 값을 시드로 사용하고 있으며, 주요 보안 기능을 위한 # 난수로 안전하지 않다 for i in range(6): random_str += str(random.randrange(10)) return random_str

import secrets def get_otp_number(): random_str = '' # 보안기능에 적합한 난수 생성용 secrets 라이브러리 사용 for i in range(6): random_str += str(secrets.randbelow(10)) return random_str

Python

보안기능

적절하지 않은 난수 값 사용

사용한 난수가 예측 가능하여, 공격자가 다음 난수를 예상해서 시스템을 공격 가능한 보안약점

import random import string def generate_session_key(): RANDOM_STRING_CHARS = string.ascii_letters + string.digits # random 라이브러리를 보안 기능에 사용하면 위험하다 return “”.join(random.choice(RANDOM_STRING_CHARS) for i in range(32))

import secrets import string def generate_session_key(): RANDOM_STRING_CHARS = string.ascii_letters+string.digits # 보안 기능과 관련된 난수는 secrets 라이브러리를 사용해야 안전하다 return “”.join(secrets.choice(RANDOM_STRING_CHARS) for i in range(32))

Python

보안기능

취약한 패스워드 허용

패스워드 조합규칙(영문, 숫자, 특수문자 등) 미흡 및 길이가 충분하지 않아 패스워드가 노출 가능한 보안약점

from flask import request, redirect from Models import User from Models import db @app.route('/register', methods=['POST']) def register(): userid = request.form.get('userid') password = request.form.get('password') confirm_password = request.form.get('confirm_password') if password != confirm_password: return make_response("패스워드가 일치하지 않습니다", 400) else: usertable = User() usertable.userid = userid usertable.password = password # 패스워드 생성 규칙을 확인하지 않고 회원 가입 db.session.add(usertable) db.session.commit() return make_response("회원가입 성공", 200)

from flask import request, redirect from Models import User from Models import db import re @app.route('/register', methods=['POST']) def register(): userid = request.form.get('userid') password = request.form.get('password') confirm_password = request.form.get('confirm_password') if password != confirm_password: return make_response("패스워드가 일치하지 않습니다.", 400) if not check_password(password): return make_response("패스워드 조합규칙에 맞지 않습니다.", 400) else: usertable = User() usertable.userid = userid usertable.password = password db.session.add(usertable) db.session.commit() return make_response("회원가입 성공", 200) def check_password(password): # 3종 이상 문자로 구성된 8자리 이상 패스워드 검사 정규식 적용 PT1 = re.compile('^(?=.*[A-Z])(?=.*[a-z])[A-Za-z\d!@#$%^&*]{8,}$') PT2 = re.compile('^(?=.*[A-Z])(?=.*\d)[A-Za-z\d!@#$%^&*]{8,}$') PT3 = re.compile('^(?=.*[A-Z])(?=.*[!@#$%^&*])[A-Za-z\d!@#$%^&*]{8,}$') PT4 = re.compile('^(?=.*[a-z])(?=.*\d)[A-Za-z\d!@#$%^&*]{8,}$') PT5 = re.compile('^(?=.*[a-z])(?=.*[!@#$%^&*])[A-Za-z\d!@#$%^&*]{8,}$') PT6 = re.compile('^(?=.*\d)(?=.*[!@#$%^&*])[A-Za-z\d!@#$%^&*]{8,}$') # 문자 구성 상관없이 10자리 이상 패스워드 검사 정규식 PT7 = re.compile('^[A-Za-z\d!@#$%^&*]{10,}$') for pattern in [PT1, PT2, PT3, PT4, PT5, PT6, PT7]: if pattern.match(password): return True return False

Python

보안기능

취약한 패스워드 허용

패스워드 조합규칙(영문, 숫자, 특수문자 등) 미흡 및 길이가 충분하지 않아 패스워드가 노출 가능한 보안약점

from django.shortcuts import render, redirect from django.http import HttpResponse from .models import User from django.views.decorators.http import require_POST @require_POST def register(request): userid = request.POST.get('userid') password = request.POST.get('password') confirm_password = request.POST.get('confirm_password') if password != confirm_password: return HttpResponse("패스워드가 일치하지 않습니다", status=400) else: usertable = User() usertable.userid = userid usertable.password = password # 패스워드 생성 규칙을 확인하지 않고 회원 가입 usertable.save() return HttpResponse("회원가입 성공", status=200)

import re from django.core.exceptions import ValidationError from django.utils.translation import ugettext as _ class CustomValidator(object): def validate(self, password, user=None): # 3종 이상 문자로 구성된 8자리 이상 패스워드 검사 정규식 PT1 = re.compile('^(?=.*[A-Z])(?=.*[a-z])[A-Za-z\d!@#$%^&*]{8,}$') PT2 = re.compile('^(?=.*[A-Z])(?=.*\d)[A-Za-z\d$@$!%*?&]{8,}$') PT3 = re.compile('^(?=.*[A-Z])(?=.*[!@#$%^&*])[A-Za-z\d!@#$%^&*]{8,}$') PT4 = re.compile('^(?=.*[a-z])(?=.*\d)[A-Za-z\d!@#$%^&*]{8,}$') PT5 = re.compile('^(?=.*[a-z])(?=.*[!@#$%^&*])[A-Za-z\d!@#$%^&*]{8,}$') PT6 = re.compile('^(?=.*\d)(?=.*[!@#$%^&*])[A-Za-z\d!@#$%^&*]{8,}$') # 문자 구성 상관없이 10자리 이상 패스워드 검사 정규식 PT7 = re.compile('^[A-Za-z\d!@#$%^&*]{10,}$') for pattern in [PT1, PT2, PT3, PT4, PT5, PT6, PT7]: if pattern.match(password): return None raise ValidationError( _("패스워드 조합규칙에 적합하지 않습니다.."), code='improper_password', ) def get_help_text(self): return _( "패스워드는 영문 대문자, 소문자, 숫자, 특수문자 조합 중 2가지 이상 8자리이거나 문자 구성 상관없이 10자리 이상이어야 합니다." )

Python

보안기능

부적절한 전자서명 확인

프로그램, 라이브러리, 코드의 전자서명에 대한 유효성 검증이 적절하지 않아 공격자의 악의적인 코드가 실행 가능한 보안약점

import base64 from Crypto.PublicKey import RSA from Crypto.Hash import SHA256 from Crypto.Signature import PKCS1_v1_5 as SIGNATURE_PKCS1_v1_5 from Crypto.Cipher import PKCS1_v1_5, AES from Crypto.Util.Padding import unpad ... def verify_data(request): # 클라이언트로부터 전달받은 데이터(전자서명을 수신 처리 하지 않음) encrypted_code = request.POST.get("encrypted_msg", "") # 암호화된 파이썬 코드 # 서버의 대칭키 로드 (송수신측이 대칭키를 이미 공유했다고 가정) with open(f"{PATH}/keys/secret_key.out", "rb") as f: secret_key = f.read() # 대칭키로 클라이언트가 전달한 파이썬 코드 복호화 # (decrypt_with_symmetric_key 함수는 임의의 함수명으로 세부적인 복호화 과정은 생략함) origin_python_code = decrypt_with_symmetric_key(secret_key, encrypted_code) # 클라이언트로부터 전달 받은 파이썬 코드 실행 eval(origin_python_code) return render( request, "/verify_success.html", {"result": "파이썬 코드를 실행했습니다."}, )

# 전자서명 검증에 사용한 코드는 의존한 파이썬 패키지 및 송신측 언어에 따라 # 달라질 수 있으며, 사전에 공유한 공개키로 복호화한 전자서명과 원본 데이터 해시값의 # 일치 여부를 검사하는 코드를 포함 def verify_digit_signature ( origin_data: bytes, origin_signature: bytes, client_pub_key: str ) -> bool: hashed_data = SHA256.new(origin_data) signer = SIGNATURE_PKCS1_v1_5.new(RSA.importKey(client_pub_key)) return signer.verify(hashed_data, base64.b64decode(origin_signature)) def verify_data(request): # 클라이언트로부터 전달받은 데이터 encrypted_code = request.POST.get("encrypted_msg", "") # 암호화된 파이썬 코드 encrypted_sig = request.POST.get("encrypted_sig", "") # 암호화된 전자서명 # 서버의 대칭(비밀)키 및 공개키 로드 with open(f"/keys/secret_key.out", "rb") as f: secret_key = f.read() with open(f"/keys/public_key.out", "rb") as f: public_key = f.read() # 대칭키로 파이썬 코드 및 전자서명 복호화 origin_python_code = decrypt_with_symmetric_key(symmetric_key, encrypted_code) origin_signature = decrypt_with_symmetric_key(symmetric_key, encrypted_sig) # 클라이언트의 공개키를 통해 파이썬 코드(원문)와 전자서명을 검증 verify_result = verify_digit_signature(origin_python_code, origin_signature, client_pub_key) # 전자서명 검증을 통과했다면 파이썬 코드 실행 if verify_result: eval(origin_python_code) return render(request, "/verify_success.html", {"result": "전자서명 검증 통과 및 파이썬 코드를 실행했습니다."}, ) else: return render(request, "/verify_failed.html", {"result": "전자서명 또는 파이썬 코드가 위/변조되었습니다."}, )

Python

보안기능

부적절한 인증서 유효성 검증

인증서에 대한 유효성 검증이 적절하지 않아 발생하는 보안약점

import os import socket import ssl HOST, PORT = "127.0.0.1", 7917 def connect_with_server(): with socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0) as sock: # 보안 정책 수동 설정 context = ssl.SSLContext() # SSLContext 생성자를 직접 호출할 때, CERT_NONE이 기본값 # 상대방을 인증하지 않기 때문에 통신하고자하는 서버의 신뢰성을 보장할 수 없음 context.verify_mode = ssl.CERT_NONE with context.wrap_socket(sock) as ssock: try: ssock.connect((HOST, PORT)) ssock.send("Hello I'm a vulnerable client :)".encode("utf-8")) data = ssock.recv(1024).decode("utf-8") print(f">> server from ({HOST}, {PORT}): {data}\n") finally: ssock.close()

import os import socket import ssl CURRENT_PATH = os.getcwd() HOST_NAME = "test-server" HOST, PORT = "127.0.0.1", 7917 SERVER_CA_PEM = f"{CURRENT_PATH}/rsa_server/CA.pem" # 서버로부터 전달받은 CA 인증서 def connect_with_server(): with socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0) as sock: # PROTOCOL_TLS_CLIENT 프로토콜을 추가하여 인증서 유효성 검사와 호스트 이름 확인을 위한 # context를 구성. verify_mode가 CERT_REQUIRED로 설정됨 # check_hostname이 True로 설정됨 context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT) # 서버로부터 전달받은 CA 인증서를 context에 로드 # CERT_REQUIRED로 인해 필수 context.load_verify_locations(SERVER_CA_PEM) # 호스트 이름(HOST_NAME)이 일치하지 않으면 통신 불가 # 생성된 소켓과 context wrapping 시 server_hostname이 실제 서버에서 # 등록(server.csr)한 호스트 명과 일치해야 함 with context.wrap_socket(sock, server_hostname=HOST_NAME) as ssock: try: ssock.connect((HOST, PORT)) ssock.send("Hello I'm a patched client :)".encode("utf-8")) data = ssock.recv(1024).decode("utf-8") print(f">> server from ({HOST}, {PORT}): {data}\n") finally: ssock.close()

Python

보안기능

사용자 하드디스크에 저장되는 쿠키를 통한 정보 노출

쿠키(세션 ID, 사용자 권한정보 등 중요정보)를 사용자 하드디스크에 저장하여 중요정보가 노출 가능한 보안약점

from django.http import HttpResponse def remind_user_state(request): res = HttpResponse() # 쿠키의 만료시간을 1년으로 과도하게 길게 설정하고 있어 안전하지 않다 res.set_cookie('rememberme', 1, max_age=60*60*24*365) return res

from django.http import HttpResponse def remind_user_state(request): res = HttpResponse() # 쿠키의 만료시간을 적절하게 부여하고 secure 및 httpOnly 옵션을 활성화 한다. res.set_cookie('rememberme', 1, max_age=60*60, secure=True, httponly=True) return res

Python

보안기능

사용자 하드디스크에 저장되는 쿠키를 통한 정보 노출

쿠키(세션 ID, 사용자 권한정보 등 중요정보)를 사용자 하드디스크에 저장하여 중요정보가 노출 가능한 보안약점

from django.http import HttpResponse def remind_user_state(request): res = HttpResponse() # 쿠키의 만료시간을 1년으로 과도하게 길게 설정하고 있어 안전하지 않다 res.set_cookie('rememberme', 1, max_age=60*60*24*366) return res

from django.http import HttpResponse from django.conf.global_settings import ( SESSION_COOKIE_AGE, SESSION_COOKIE_HTTPONLY, SESSION_COOKIE_HTTPONLY, ) """ # settings.py SESSION_COOKIE_AGE = 60 * 60 * 24 * 14 SESSION_COOKIE_HTTPONLY = True SESSION_COOKIE_SECURE = True """ def remind_user_state(request): res = HttpResponse() # 서버 세팅(setting.py)에서 default로 쿠키 옵션을 설정한 상태 res.set_cookie( "rememerme", 1, max_age=SESSION_COOKIE_AGE, secure=SESSION_COOKIE_HTTPONLY, httponly=SESSION_COOKIE_HTTPONLY, ) return res