language,tag,vulnerability_type,description,vulnerable_code,secure_code
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),"사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 악의적인 스크립트가 실행 가능한
보안약점","
","
"
Javascript,입력데이터 검증 및 표현,크로스사이트 스크립트(XSS),"사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 악의적인 스크립트가 실행 가능한
보안약점","
","
"
Javascript,입력데이터 검증 및 표현,크로스사이트 스크립트(XSS),"사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 악의적인 스크립트가 실행 가능한
보안약점","function possibleXSS() {
return {
__html:
'
',
};
}
const App = ( ) => (
// XSS에 취약한 함수를 사용해 HTML 코드 데이터를 렌더링
);
ReactDOM.render(, document.getElementById(""root""));","
... function possibleXSS() {
return {
__html:
// dompurify 라이브러리를 사용해 입력값을 이스케이프 처리
DOMPurify.sanitize(''),
};
}
const App = ( ) => (
);
ReactDOM.render(, 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('
"", 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 = `johnabracadabra/home/johncbc1mgr8/home/cbc`;
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 = `
...
`;
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),"사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 사용자 본인의 의지와는 무관하게
공격자가 의도한 행위가 실행 가능한 보안약점","
...
"," "
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: ‘test@email.com’,
});
document.write(res.data);
};
React.useEffect(() => { getData(); }, []);
return
react-test
;
};
ReactDOM.render(, 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 = """";
document.getElementById('output').innerHTML = userInput;","const userInput = """";
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 = """";
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 = '{}'.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 = '{}'.format(profile_url, profile_name)
# 신뢰할 수 없는 데이터에 대해서는 mark_safe 함수를 사용해선 안 된다
return render(request, 'my_profile.html',{'object_link':object_link})"
Python,입력데이터 검증 및 표현,크로스사이트 스크립트(XSS),"사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 악의적인 스크립트가 실행 가능한
보안약점","
{% autoescape off %}
{{ content }}
{% endautoescape %}
{{ content | safe }}
","
{% autoescape on %}
{{ content }}
{% endautoescape %}
{{ content }}
"
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 외부개체에 대한 적절한 검증 없이 참조를 허용하여 공격이 가능한 보안약점,"
]>
&xxe1;&xxe2;
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),"사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 사용자 본인의 의지와는 무관하게
공격자가 의도한 행위가 실행 가능한 보안약점","
","
",""
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"
Python,보안기능,주석문 안에 포함된 시스템 주요정보,"소스코드 주석문에 인증정보 등 시스템 주요정보가 포함되어 소스코드 노출 시 주요정보도
노출 가능한 보안약점","def user_login(id, passwd):
# 주석문에 포함된 중요 시스템의 인증 정보
# id = admin
# passwd = passw0rd
result = login(id, passwd)
return result","def user_login(id, passwd):
# 주석문에 포함된 민감한 정보는 삭제
result = login(id, passwd)
return result"
Python,보안기능,솔트 없이 일방향 해시 함수 사용,"솔트를 사용하지 않고 생성된 해시 값으로부터 공격자가 미리 계산된 레인보우 테이블을
이용하여 해시 적용 이전 원본 정보를 복원가능한 보안약점
*솔트: 해시 적용하기 전 평문인 전송정보에 덧붙인 무의미한 데이터","import hashlib
def get_hash_from_pwd(pw):
# salt 없이 생성된 해시값은 강도가 약해 취약하다
h = hashlib.sha256(pw.encode())
return h.digest()","import hashlib
import secrets
def get_hash_from_pwd(pw):
# 솔트 값을 사용하면 길이가 짧은 패스워드로도 고강도의 해시를 생성할 수 있다.
# 솔트 값은 사용자별로 유일하게 생성해야 하며, 패스워드와 함께 DB에 저장해야 한다
salt = secrets.token_hex(32)
h = hashlib.sha256(salt.encode() + pw.encode())
return h.digest(), salt"
Python,보안기능,무결성 검사없는 코드 다운로드,"소스코드 또는 실행파일을 무결성 검사 없이 다운로드 받아 실행하는 경우, 공격자의 악의적인 코드가 실행 가능한 보안약점","import requests
def execute_remote_code():
# 신뢰할 수 없는 사이트에서 코드를 다운로드
url = ""https://www.somewhere.com/storage/code.py""
# 원격 코드 다운로드
file = requests.get(url)
remote_code = file.content
file_name = 'save.py'
with open(file_name, 'wb') as f:
f.write(file.content)","import requests
import hashlib
import configparser
def execute_remote_code():
config = configparser.RawConfigParser()
config.read(‘sample_config.cfg’)
url = ""https://www.somewhere.com/storage/code.py""
remote_code_hash = config.get('HASH', 'file_hash')
# 원격 코드 다운로드
file = requests.get(url)
remote_code = file.content
sha = hashlib.sha256()
sha.update(remote_code)
# 다운로드 받은 파일의 해시값 검증
if sha.hexdigest() != remote_code_hash:
raise Exception(‘파일이 손상되었습니다.’)
file_name = 'save.py' with open(file_name, 'wb') as f
f.write(file.content)"
Python,보안기능,반복된 인증시도 제한 기능 부재,"인증 시도 수를 제한하지 않아 공격자가 반복적으로 임의 값을 입력하여 계정 권한을 획득
가능한 보안약점","import hashlib
from django.shortcuts import render
def login(request):
user_id = request.POST.get('user_id', '')
user_pw = request.POST.get('user_pw', '')
sha = hashlib.sha256()
sha.update(user_pw.encode(‘utf-8’))
hashed_passwd = get_user_pw(user_id)
# 인증 시도에 따른 제한이 없어 반복적인 인증 시도가 가능
if sha.hexdigest() == hashed_passwd:
return render(request, '/index.html', {'state':'login_success'})
else:
return render(request, '/login.html', {'state':'login_failed'})","import hashlib
from django.shortcuts import render
from .models import LoginFail
LOGIN_TRY_LIMIT = 5
def login(request):
user_id = request.POST.get('user_id', '')
user_pw = request.POST.get('user_pw', '')
sha = hashlib.sha256()
sha.update(user_pw.encode(‘utf-8’))
hashed_passwd = get_user_pw(user_id)
if sha.hexdigest() == hashed_passwd:
# 로그인 성공 시 실패 횟수 삭제
LoginFail.objects.filter(user_id=user_id).delete()
return render(request, '/index.html', {'state':'login_success'})
# 로그인 실패 기록 가져오기
if LoginFail.objects.filter(user_id=user_id).exists():
login_fail = LoginFail.objects.get(user_id=user_id)
COUNT = login_fail.count
else:
COUNT = 0
if COUNT >= LOGIN_TRY_LIMIT:
# 로그인 실패횟수 초과로 인해 잠금된 계정에 대한 인증 시도 제한
return render(request, ""/account_lock.html"", {""state"": ""account_lock""})
else:
# 로그인 실패 횟수 DB 기록
# 첫 시도라면 DB에 insert,
# 실패 기록이 존재한다면 update
LoginFail.objects.update_or_create(
user_id=user_id,
defaults={""count"": COUNT + 1},
)
return render(request, ""/login.html"", {""state"": ""login_failed""})"
Python,시간 및 상태,경쟁조건: 검사시점과 사용시점(TOCTOU),멀티 프로세스 상에서 자원을 검사하는 시점과 사용하는 시점이 달라서 발생하는 보안약점,"import os
import io
import datetime
import threading
def write_shared_file(filename, content):
# 멀티스레드 환경에서는 다른 사용자들의 작업에 따라 파일이 사라질 수
# 있기 때문에 공유 자원에 대해서는 검사와 사용을 동시에 해야 한다.
if os.path.isfile(filename) is True:
f = open(filename, 'w')
f.seek(0, io.SEEK_END)
f.write(content)
f.close()
def start():
filename = ‘./temp.txt’
content = f“start time is {datetime.datetime.now()}”
my_thread = threading.Thread(target=write_shared_file, args=(filename, content))
my_thread.start()","import os
import io
import datetime
import threading
lock = threading.Lock()
def write_shared_file(filename, content):
# lock을 이용하여 여러 사용자가 동시에 파일에 접근하지 못하도록 제한
with lock:
if os.path.isfile(filename) is True:
f = open(filename, 'w')
f.seek(0, io.SEEK_END)
f.write(content)
f.close()
def start():
filename = ‘./temp.txt’
content = f“start time is {datetime.datetime.now()}”
my_thread = threading.Thread(target=write_shared_file, args=(filename, content))
my_thread.start()"
Python,시간 및 상태,종료되지 않는 반복문 또는 재귀 함수,종료조건 없는 제어문 사용으로 반복문 또는 재귀함수가 무한히 반복되어 발생할 수 있는 보안약점,"def factorial(num):
# 재귀함수 탈출조건을 설정하지 않아 동작 중 에러 발생
return num * factorial(num – 1)
if __name__ == '__main__':
itr = 5
result = factorial(itr)
print(str(itr) + ' 팩토리얼 값은 : ' + str(result))","def factorial(num):
# 재귀함수 사용 시에는 탈출 조건을 명시해야 한다.
if (num == 0):
return 1
else:
return num * factorial(num - 1)
if __name__ == '__main__':
itr = 5
result = factorial(itr)
print(str(itr) + ' 팩토리얼 값은 : ' + str(result))"
Python,에러처리,오류 메시지 정보노출,"오류메시지나 스택정보에 시스템 내부구조가 포함되어 민감한 정보, 디버깅 정보가 노출 가능한 보안약점","# config/urls.py
# 별도의 에러 페이지를 선언하지 않아 django의 기본 에러 페이지를 출력한다","# config/urls.py
from django.conf.urls import handler400, handler403, handler404, handler500
# 사용자 정의 에러 페이지를 지정하고
# views.py에 사용자 정의 에러 페이지에 대한 코드를 구현하여 사용한다
handler400 = ""blog.views.error400"" handler403 = ""blog.views.error403"" handler404 = ""blog.views.error404"" handler500 = ""blog.views.error500“"
Python,에러처리,오류 메시지 정보노출,"오류메시지나 스택정보에 시스템 내부구조가 포함되어 민감한 정보, 디버깅 정보가 노출 가능한 보안약점","import traceback
def fetch_url(url, useragent, referer=None, retries=1, dimension=False):
......
try:
response = requests.get(
url,
stream=True,
timeout=5,
headers={ 'User-Agent': useragent, 'Referer': referer },
)
......
except IOError:
# 에러메시지를 통해 스택 정보가 노출.
traceback.print_exc()","import logging
def fetch_url(url, useragent, referer=None, retries=1, dimension=False):
......
try:
response = requests.get(url, stream=True, timeout=5, headers={
'User-Agent': useragent,
'Referer': referer,
})
......
except IOError:
# 에러 코드와 정보를 별도로 정의하고 최소 정보만 로깅
logger.error('ERROR-01:통신에러')"
Python,에러처리,오류상황 대응 부재,시스템 오류상황을 처리하지 않아 프로그램 실행정지 등 의도하지 않은 상황이 발생 가능한 보안약점,"import base64
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad
static_keys=[
{'key' : b'\xb9J\xfd\xa9\xd2\xefD\x0b\x7f\xb2\xbcy\x9c\xf7\x9c',
‘iv' : b'\xf1BZ\x06\x03TP\xd1\x8a\xad""\xdc\xc3\x08\x88\xda'},
{'key' : b'Z\x01$.:\xd4u3~\xb6TS(\x08\xcc\xfc',
'iv' : b'\xa1a=:\xba\xfczv]\xca\x83\x9485\x14\x17'},
]
def encryption(key_id, plain_text):
static_key = {'key':b'0000000000000000', 'iv':b'0000000000000000'}
try:
static_key = static_keys[key_id]
except IndexError:
# key 선택 중 오류 발생 시 기본으로 설정된 암호화 키인
# ‘0000000000000000’ 으로 암호화가 수행된다.
pass
cipher_aes = AES.new(static_key['key'],AES.MODE_CBC,static_key['iv'])
encrypted_data = base64.b64encode(cipher_aes.encrypt(pad(plain_text.encode(), 32)))
return encrypted_data.decode('ASCII')","import base64
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad
static_keys=[
{'key' : b'\xb9J\xfd\xa9\xd2\xefD\x0b\x7f\xb2\xbcy\x9c\xf7\x9c',
‘iv' : b'\xf1BZ\x06\x03TP\xd1\x8a\xad""\xdc\xc3\x08\x88\xda'},
{'key' : b'Z\x01$.:\xd4u3~\xb6TS(\x08\xcc\xfc',
'iv' : b'\xa1a=:\xba\xfczv]\xca\x83\x9485\x14\x17'},
]
def encryption(key_id, plain_text):
static_key = {'key':b'0000000000000000', 'iv':b'0000000000000000'}
try:
static_key = static_keys[key_id]
except IndexError:
# key 선택 중 오류 발생 시 랜덤으로 암호화 키를 생성하도록 설정
static_key = {'key': secrets.token_bytes(16), 'iv': secrets.token_bytes(16)}
static_keys.append(static_key)
cipher_aes = AES.new(static_key['key'],AES.MODE_CBC,static_key['iv'])
encrypted_data = base64.b64encode(cipher_aes.encrypt(pad(plain_text.encode(), 32)))
return encrypted_data.decode('ASCII')"
Python,에러처리,부적절한 예외 처리,예외사항을 부적절하게 처리하여 의도하지 않은 상황이 발생 가능한 보안약점,"import sys
def get_content():
try:
f = open('myfile.txt')
s = f.readline()
i = int(s.strip())
# 예외처리를 세분화 할 수 있음에도 광범위하게 사용하여 예기치 않은
# 문제가 발생할 수 있다
except:
print(""Unexpected error "")","def get_content():
try:
f = open('myfile.txt')
s = f.readline()
i = int(s.strip())
# 발생할 수 있는 오류의 종류와 순서에 맞춰서 예외 처리 한다. except FileNotFoundError:
print(""file is not found"")
except OSError:
print(""cannot open file"")
except ValueError:
print(""Could not convert data to an integer."")"
Python,코드오류,Null Pointer 역참조,변수의 주소 값이 Null인 객체를 참조하는 보안약점,"import os
from django.shortcuts import render
from xml.sax import make_parser
from xml.sax.handler import feature_namespaces
def parse_xml(request):
filename = request.POST.get('filename')
# filename의 None 체크를 하지 않아 에러 발생 가능
if (filename.count('.') > 0):
name, ext = os.path.splitext(filename)
else:
ext = ''
if ext == "".xml"":
parser = make_parser()
parser.setFeature(feature_namespaces, True)
handler = Handler()
parser.setContentHandler(handler)
parser.parse(filename)
result = handler.root
return render(request, ""/success.html"", {""result"": result})","import os
from django.shortcuts import render
from xml.sax import make_parser
from xml.sax.handler import feature_namespaces
def parse_xml(request):
filename = request.POST.get('filename')
# filename이 None 인지 체크
if filename is None or filename.strip() == """":
return render(request, ""/error.html"", {""error"": ""파일 이름이 없습니다.""})
if (filename.count('.') > 0):
name, ext = os.path.splitext(filename)
else:
ext = ''
if ext == "".xml"":
parser = make_parser()
parser.setFeature(feature_namespaces, True)
handler = Handler()
parser.setContentHandler(handler)
parser.parse(filename)
result = handler.root
return render(request, ""/success.html"", {""result"": result})"
Python,코드오류,부적절한 자원 해제,사용 완료된 자원을 해제하지 않아 자원이 고갈되어 새로운 입력을 처리할 수 없는 보안약점,"def get_config():
lines = None
try:
f = open('config.cfg')
lines = f.readlines()
# 예외 발생 상황 가정
raise Exception(""Throwing the exception!"")
# try 절에서 할당한 자원이 반환(close)되기 전에
# 예외가 발생하면 할당된 자원이 시스템에 반환되지 않음
f.close()
return lines
except Exception as e:
...
return '' ","def get_config():
lines = None
try:
f = open('config.cfg')
lines = f.readlines()
# 예외 발생 상황 가정
raise Exception(""Throwing the exception!"")
except Exception as e:
pass
finally:
# try 절에서 할당한 자원은
# finally 절에서 시스템에 반환을 해야 한다
f.close()
return lines
# with 절을 빠져나갈 때 f를 시스템에 반환
with open('config.cfg') as f:
print(f.read())"
Python,코드오류,신뢰할 수 없는 데이터의 역직렬화,"악의적인 코드가 삽입·수정된 직렬화 데이터를 적절한 검증 없이 역직렬화하여 발생하는 보안약점* 직렬화: 객체를 전송 가능한 데이터형식으로 변환
* 역직렬화: 직렬화된 데이터를 원래 객체로 복원","import pickle
from django.shortcuts import render
def load_user_object(request):
# 사용자로부터 입력받은 알 수 없는 데이터를 역직렬화
pickled_userinfo = pickle.dump(request.POST.get('userinfo', ''))
# 역직렬화(unpickle)
user_obj = pickle.loads(pickled_userinfo)
return render(request, '/load_user_obj.html', {'obj':user_obj})","import hmac
import hashlib
import pickle
from django.shortcuts import render
def load_user_object(request):
# 데이터 변조를 확인하기 위한 해시값
hashed_pickle = request.POST.get(""hashed_pickle"", """")
# 사용자로부터 입력받은 데이터를 직렬화(pickle)
pickled_userinfo = pickle.dumps(request.POST.get(""userinfo"", """"))
# HMAC 검증을 위한 비밀키는 생성
m = hmac.new(key=""secret_key"".encode(""utf-8""), digestmod=hashlib.sha512)
# 직렬화된 사용자 입력값을 해싱
m.update(pickled_userinfo)
# 전달받은 해시값(hashed_pickle)과 직렬화 데이터(userinfo)의 해시값을 비교하여 검증
if hmac.compare_digest(str(m.digest()), hashed_pickle):
user_obj = pickle.loads(pickled_userinfo)
return render(request, ""/load_user_obj.html"", {""obj"": user_obj})
else:
return render(request, ""/error.html"", {""error"": ""신뢰할 수 없는 데이터입니다.""}"
Python,캡슐화,잘못된 세션에 의한 데이터 정보 노출,잘못된 세션에 의해 인가되지 않은 사용자에게 중요정보가 노출 가능한 보안약점,"from django.shortcuts import render
class UserDescription:
user_name = ''
def get_user_profile(self):
result = self.get_user_discription(UserDescription.user_name)
......
return result
def show_user_profile(self, request):
# 클래스변수는 다른 세션과 공유되는 값이기 때문에 멀티스레드
# 환경에서 공유되지 않아야 할 자원을 사용하는 경우
# 다른 스레드 세션에 의해 데이터가 노출될 수 있다
UserDescription.user_name = request.POST.get(‘name’, ‘’)
self.user_profile = self.get_user_profile()
return render(request, 'profile.html', {'profile':self.user_profile})","from django.shortcuts import render
class UserDescription:
def get_user_profile(self):
result = self.get_user_discription(self.user_name)
......
return result
def show_user_profile(self, name):
# 인스턴스 변수로 사용해 스레드 간 공유되지 않도록 한다
self.user_name = request.POST.get(‘name’, ‘’)
self.user_profile = self.get_user_profile()
return render(request, 'profile.html', {'profile':self.user_profile})"
Python,캡슐화,제거되지 않고 남은 디버그 코드,디버깅을 위한 코드를 제거하지 않아 인가되지 않은 사용자에게 중요정보가 노출 가능한 보안약점,"from django.urls import reverse_lazy
from django.utils.text import format_lazy
DEBUG = True
ROOT_URLCONF = 'test.urls'
SITE_ID = 1
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': ':memory:',
}
}","from django.urls import reverse_lazy
from django.utils.text import format_lazy
DEBUG = False
ROOT_URLCONF = 'test.urls'
SITE_ID = 1
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': ':memory:',
}
}"
Python,캡슐화,제거되지 않고 남은 디버그 코드,디버깅을 위한 코드를 제거하지 않아 인가되지 않은 사용자에게 중요정보가 노출 가능한 보안약점,"from flask import Flask
app = Flask(__name__)
# 디버그 모드 설정 방법1
app.debug = True
@app.route('/')
def hello_world():
return 'Hello World!'
if __name__ == '__main__':
app.run()
# 디버그 모드 설정 방법2
app.run(debug=True)","from flask import Flask
app = Flask(__name__)
app.debug = False
@app.route('/')
def hello_world():
return 'Hello World!'
if __name__ == '__main__':
app.run()
app.run(debug=False)"
Python,캡슐화,Public 메소드로부터 반환된 Private 배열,"Public으로 선언된 메소드에서 Private로 선언된 배열을 반환(return)하면 Private 배열의 주소
값이 외부에 노출되어 해당 Private 배열값을 외부에서 수정 가능한 보안약점","class UserObj:
__private_variable = []
def __init__(self):
pass
# private 배열을 리턴하는 public 메소드를 사용하는 경우 취약함
def get_private_member(self):
return self.__private_variable","class UserObj:
__private_variable = []
def __init__(self):
pass
# private 배열을 반환하는 경우 [:]를 사용하여 외부와 내부의
# 배열이 서로 참조되지 않도록 해야 한다
def get_private_member(self):
return self.__private_variable[:]"
Python,캡슐화,Private 배열에 Public 데이터 할당,Public으로 선언된 데이터 또는 메소드의 인자가 Private로 선언된 배열에 저장되면 Private 배열을 외부에서 접근하여 수정 가능한 보안약점,"class UserObj:
__private_variable = []
def __init__(self):
pass
# private 배열에 외부 값을 바로 대입하는 public 메소드를 사용하는
# 경우 취약하다
def set_private_member(self, input_list):
self.__private_variable = input_list","class UserObj:
def __init__(self):
self.__privateVariable = []
# private 배열에 외부 값을 바로 대입하는 경우 [:]를 사용하여
# 외부와 내부의 배열이 서로 참조되지 않도록 해야 한다
def set_private_member(self, input_list):
self.__privateVariable = input_list[:]"
Python,API 오용,DNS lookup에 의존한 보안결정,"도메인명 확인(DNS lookup)으로 보안결정을 수행할 때 악의적으로 변조된 DNS 정보로 예기치
않은 보안위협에 노출되는 보안약점","def is_trust(host_domain_name):
trusted = False
trusted_host = ""trust.example.com""
# 공격자에 의해 실행되는 서버의 DNS가 변경될 수 있으므로
# 안전하지 않다
if trusted_host == host_name:
trusted = True
return trusted","import socket
def is_trust(host_domain_name):
trusted = False
trusted_ip = ""192.168.10.7“
# 실제 서버의 IP 주소를 비교하여 DNS 변조에 대응
dns_resolved_ip = socket.gethostbyname(host_domain_name)
if trusted_ip == dns_resolved_ip:
trusted = True
return trusted"
Python,API 오용,취약한 API 사용,eval 부적절한 사용,"user_input = ""2 + 3""
result = eval(user_input) # 위험한 사용법: 입력값이 안전하지 않음
print(result)","import ast
user_input = ""2 + 3""
result = ast.literal_eval(user_input) # 안전한 사용법
print(result)"
Python,API 오용,취약한 API 사용,암호화 시 고정된 비밀번호 및 키 사용,"from cryptography.fernet import Fernet
key = b'01234567890123456789012345678901' # 고정된 키 사용 (안전하지 않음)
cipher_suite = Fernet(key)
cipher_text = cipher_suite.encrypt(b""Hello World"")
print(cipher_text)","from cryptography.fernet import Fernet
import os
key = os.environ.get(""SECRET_KEY"", Fernet.generate_key()) # 환경 변수에서 키 가져오기
cipher_suite = Fernet(key)
cipher_text = cipher_suite.encrypt(b""Hello World"")
print(cipher_text)"
Python,API 오용,취약한 API 사용,subprocess 모듈의 shell=True 옵션 사용,"import subprocess
user_input = ""ls; rm -rf /"" # 사용자가 임의의 명령을 실행할 수 있음
subprocess.call(f""echo {user_input}"", shell=True)","import subprocess
user_input = ""ls""
subprocess.call([""echo"", user_input], shell=False)"
Python,API 오용,취약한 API 사용,SSL 인증서 검증 비활성화,"import requests
response = requests.get(""https://example.com"", verify=False) # SSL 검증 비활성화 (취약)
print(response.content)","import requests
response = requests.get(""https://example.com"", verify=True) # SSL 검증 활성화
print(response.content)"
JDBC API,입력데이터 검증 및 표현,SQL 삽입,SQL 질의문을 생성할 때 검증되지 않은 외부 입력 값을 허용하여 악의적인 질의문이 실행가능한 보안약점,"//외부로부터 입력받은 값을 검증 없이 사용할 경우 안전하지 않다.
String gubun = request.getParameter(""gubun"");
......
String sql = ""SELECT * FROM board WHERE b_gubun = '"" + gubun + ""'"";
Connection con = db.getConnection();
Statement stmt = con.createStatement();
//외부로부터 입력받은 값이 검증 또는 처리 없이 쿼리로 수행되어 안전하지 않다.
ResultSet rs = stmt.executeQuery(sql);","String gubun = request.getParameter(""gubun"");
......
//1. 사용자에 의해 외부로부터 입력받은 값은 안전하지 않을 수 있으므로, PreparedStatement
사용을 위해 ?문자로 바인딩 변수를 사용한다.
String sql = ""SELECT * FROM board WHERE b_gubun = ?"";
Connection con = db.getConnection();
//2. PreparedStatement 사용한다.
PreparedStatement pstmt = con.prepareStatement(sql);
//3. PreparedStatement 객체를 상수 스트링으로 생성하고, 파라미터 부분을 setString 등의
메소드로 설정하여 안전하다.
pstmt.setString(1, gubun);
ResultSet rs = pstmt.executeQuery();"
MyBatis,입력데이터 검증 및 표현,SQL 삽입,SQL 질의문을 생성할 때 검증되지 않은 외부 입력 값을 허용하여 악의적인 질의문이 실행가능한 보안약점,"
......
","
......
"
Hibernate,입력데이터 검증 및 표현,SQL 삽입,SQL 질의문을 생성할 때 검증되지 않은 외부 입력 값을 허용하여 악의적인 질의문이 실행가능한 보안약점,"import org.hibernate.Query
import org.hibernate.Session
......
//외부로부터 입력받은 값을 검증 없이 사용할 경우 안전하지 않다.
String name = request.getParameter(""name"");
//Hiberate는 기본으로 PreparedStatement를 사용하지만, 파라미터 바인딩 없이 사용 할 경우
안전하지 않다.
Query query = session.createQuery(""from Student where studentName = '"" + name + ""' "");","import org.hibernate.Query
import org.hibernate.Session
......
String name = request.getParameter(""name"");
//1. 파라미터 바인딩을 위해 ?를 사용한다.
Query query = session.createQuery(""from Student where studentName = ? "");
//2. 파라미터 바인딩을 사용하여 외부 입력값에 의해 쿼리 구조 변경을 못하게 사용하였다.
query.setString(0, name);
import org.hibernate.Query
import org.hibernate.Session
......
String name = request.getParameter(""name"");
//1. 파라미터 바인딩을 위해 명명된 파라미터 변수를 사용한다.
Query query = session.createQuery(""from Student where studentName = :name "");
//2. 파라미터 바인딩을 사용하여 외부 입력값에 의해 쿼리 구조 변경을 못하게 사용하였다.
query.setParameter(""name"", name);"
C#,입력데이터 검증 및 표현,SQL 삽입,SQL 질의문을 생성할 때 검증되지 않은 외부 입력 값을 허용하여 악의적인 질의문이 실행가능한 보안약점,"public void ButtonClickBad(object sender, EventArgs e)
{
string connect = ""MyConnString"";
string usrinput = Request[""ID""];
// 외부로부터 입력받은 값을 SQL 쿼리에 직접 사용하는 것은 안전하지 않다.
string query = ""Select * From Products Where ProductID = "" + usrinput;
using (var conn = new SqlConnection(connect))
{
using (var cmd = new SqlCommand(query, conn))
{
conn.Open();
cmd.ExecuteReader(); /* BUG */
}
}
}"," void ButtonClickGood(object sender, EventArgs e)
{
string connect = ""MyConnString"";
string usrinput = Request[""ID""];
//파라미터 바인딩을 위해 @ 을 사용합니다. 외부입력 값에 의해 쿼리 구조 변경을 할 수 없습니다.
string query = ""Select * From Products Where ProductID = @ProductID"";
using (var conn = new SqlConnection(connect))
{
using (var cmd = new SqlCommand(query, conn))
{
cmd.Parameters.AddWithValue(""@ProductID"",
Convert.ToInt32(Request[""ProductID""]);
conn.Open();
cmd.ExecuteReader();
}
}"
JAVA,입력데이터 검증 및 표현,코드삽입,프로세스가 외부 입력 값을 코드(명령어)로 해석·실행할 수 있고 프로세스에 검증되지 않은 외부 입력 값을 허용한 경우 악의적인 코드가 실행 가능한 보안약점,"public class CodeInjectionController {
@RequestMapping(value = ""/execute"", method = RequestMethod.GET)
public String execute(@RequestParam(""src"") String src)
throws ScriptException {
ScriptEngineManager scriptEngineManager = new ScriptEngineManager();
ScriptEngine scriptEngine = scriptEngineManager.getEngineByName(""javascript"");
// 외부 입력값인 src를 javascript eval 함수로 실행하고 있어 안전하지 않다.
String retValue = (String) scriptEngine.eval(src);
return retValue;
}
}","''
@RequestMapping(value = ""/execute"", method = RequestMethod.GET)
public String execute(@RequestParam(""src"") String src) throws ScriptException {
// 정규식을 이용하여 특수문자 입력시 예외를 발생시킨다.
if (src.matches(""[ \ \w]*"") == false) {
throw new IllegalArgumentException();
}
ScriptEngineManager scriptEngineManager = new ScriptEngineManager();
ScriptEngine scriptEngine = scriptEngineManager.getEngineByName(""javascript"");
String retValue = (String)scriptEngine.eval(src);
return retValue;
}
'''"
JAVA,입력데이터 검증 및 표현,코드삽입,프로세스가 외부 입력 값을 코드(명령어)로 해석·실행할 수 있고 프로세스에 검증되지 않은 외부 입력 값을 허용한 경우 악의적인 코드가 실행 가능한 보안약점,"
<%
String name = request.getparameter(""name"");
%>
...
","''
@RequestMapping(value = ""/execute"", method = RequestMethod.GET)
public String execute(@RequestParam(""src"") String src) throws ScriptException {
// 유효한 문자 “_” 일 경우 실행할 메소드 호출한다.
if (src.matches(""UNDER_BAR“) == true) {
...
// 유효한 문자 “$” 일 경우 실행할 메소드 호출한다.
} else if (src.matches(""DOLLAR“) == true) {
...
// 유효하지 않은 특수문자 입력시 예외를 발생시킨다.
} else {
throw new IllegalArgumentException();
}
...
}
'''"
JAVA,입력데이터 검증 및 표현,경로 조작 및 자원 삽입,시스템 자원 접근경로 또는 자원제어 명령어에 검증되지 않은 외부 입력값을 허용하여 시스템 자원에 무단 접근 및 악의적인 행위가 가능한 보안약점,"//외부로부터 입력받은 값을 검증 없이 사용할 경우 안전하지 않다.
String fileName = request.getParameter(""P"");
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
FileInputStream fis = null;
try {
response.setHeader(""Content-Disposition"", ""attachment;filename=""+fileName+"";"");
...
//외부로부터 입력받은 값이 검증 또는 처리 없이 파일처리에 수행되었다.
fis = new FileInputStream(""C:/datas/"" + fileName);
bis = new BufferedInputStream(fis);
bos = new BufferedOutputStream(response.getOutputStream());","String fileName = request.getParameter(""P"");
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
FileInputStream fis = null;
try {
response.setHeader(""Content-Disposition"", ""attachment;filename=""+fileName+"";"");
...
// 외부 입력받은 값을 경로순회 문자열(./￦)을 제거하고 사용해야한다.
filename = filename.replaceAll(""￦￦."", """").replaceAll(""/"", """").replaceAll(""￦￦￦￦"", """");
fis = new FileInputStream(""C:/datas/"" + fileName);
bis = new BufferedInputStream(fis);
bos = new BufferedOutputStream(response.getOutputStream());
int read;
while((read = bis.read(buffer, 0, 1024)) != -1) {
bos.write(buffer,0,read);
}
}"
JAVA,입력데이터 검증 및 표현,경로 조작 및 자원 삽입,시스템 자원 접근경로 또는 자원제어 명령어에 검증되지 않은 외부 입력값을 허용하여 시스템 자원에 무단 접근 및 악의적인 행위가 가능한 보안약점,"public class ShowHelp {
private final static String safeDir = ""c:￦￦help_files￦￦"";
public static void main(String[] args) throws IOException {
String helpFile = args[0];
try (BufferedReader br = new BufferedReader(new FileReader(safeDir + helpFile))) {
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
...
}","public class ShowHelpSolution {
private final static String safeDir = ""c:￦￦help_files￦￦"";
// 경로조작 문자열 포함 여부를 확인하고 조치 후 사용하도록 한다.
public static void main(String[] args) throws IOException {
String helpFile = args[0];
if (helpFile != null) {
helpFile = helpFile.replaceAll(""￦￦. {2, }[/￦￦￦￦]"", """");
}
try (BufferedReader br = new BufferedReader(new FileReader(safeDir + helpFile))) {
}"
C#,입력데이터 검증 및 표현,경로 조작 및 자원 삽입,시스템 자원 접근경로 또는 자원제어 명령어에 검증되지 않은 외부 입력값을 허용하여 시스템 자원에 무단 접근 및 악의적인 행위가 가능한 보안약점,"//외부 입력 값이 검증 없이 파일처리에 사용 되었다.
string file = Request.QueryString[""path""];
if (file != null)
{
File.Delete(file); 6:
}","string file = Request.QueryString[""path""];
if (file != null)
{
//경로조작 문자열이 있는지 확인하고 파일 처리를 하도록 한다.
if (file.IndexOf('￦￦') > -1 || file.IndexOf('/') > -1)
{
Response.Write(""Path Traversal Attack"");
}
else
{
File.Delete(file);
}
}"
C#,입력데이터 검증 및 표현,경로 조작 및 자원 삽입,시스템 자원 접근경로 또는 자원제어 명령어에 검증되지 않은 외부 입력값을 허용하여 시스템 자원에 무단 접근 및 악의적인 행위가 가능한 보안약점,"char* filename = getenv(“reportfile”);
FILE *fin = NULL;
// 외부 설정 값에서 받은 파일 이름을 그대로 사용한다.
fin = fopen(filename, “r”);
while (fgets(buf, BUF_LEN, fin)) {
// 파일 내용 출력
}","FILE *fin = NULL;
regex_t regex;
Int ret;
char* filename = getenv(“reportfile”);
ret = regcomp(®ex, “.*￦￦.￦￦..*”, 0);
// 경로 조작 가능성 있는 문자열 탐지
ret = regexec(®ex, filename, 0, NULL, 0);
If (!ret) {
// 경로 조작 문자열 발견, 오류 처리
}
// 필터링된 파일 이름으로 사용
fin = fopen(filename, “r”);
while (fgets(buf, BUF_LEN, fin)) {
// 파일 내용 출력
}"
JAVA,입력데이터 검증 및 표현,크로스사이트 스크립트,사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 악의적인 스크립트가 실행 가능한 보안약점,"<% String keyword = request.getParameter(""keyword""); %>
//외부 입력값에 대하여 검증 없이 화면에 출력될 경우 공격스크립트가 포함된 URL을 생성 할 수 있어
안전하지 않다.(Reflected XSS)
검색어 : <%=keyword%>
//게시판 등의 입력form으로 외부값이 DB에 저장되고, 이를 검증 없이 화면에 출력될 경우
공격스크립트가 실행되어 안전하지 않다.(Stored XSS)
검색결과 : $ {m.content}
","<% String keyword = request.getParameter(""keyword""); %>
// 방법1. 입력값에 대하여 스크립트 공격가능성이 있는 문자열을 치환한다.
keyword = keyword.replaceAll(""&"", ""&"");
keyword = keyword.replaceAll(""<"", ""<"");
keyword = keyword.replaceAll("">"", "">"");
keyword = keyword.replaceAll(""￦"""", """"");
keyword = keyword.replaceAll(""'"", ""'"");
keyword = keyword.replaceAll(""/"""", ""/"");
keyword = keyword.replaceAll(""("", ""("");
keyword = keyword.replaceAll("")"", "")"");
검색어 : <%=keyword%>
//방법2. JSP에서 출력값에 JSTL c:out 을 사용하여 처리한다.
<%@ taglib prefix=""c"" uri=""http://java.sun.com/jsp/jstl/core""%>
<%@ taglib uri=""http://java.sun.com/jsp/jstl/functions"" prefix=""fn"" %>
검색결과 :
"
C#,입력데이터 검증 및 표현,크로스사이트 스크립트,사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 악의적인 스크립트가 실행 가능한 보안약점,"string usrInput = Request.QueryString[""ID""];
// 외부 입력 값이 검증 없이 화면에 출력 됩니다.
string str = ""ID : "" + usrinput;
Request.Write(str);","string usrInput = Request.QueryString[""ID""];
string str = ""ID : "" + usrinput;
//AntiXss 패키지 등을 이용하여 외부 입력값을 필터링 합니다.
var sanitizedStr = Sanitizer.GetSafeHtmlFragment(str);
quest.Write(sanitizedStr);"
C,입력데이터 검증 및 표현,크로스사이트 스크립트,사용자 브라우저에 검증되지 않은 외부 입력값을 허용하여 악의적인 스크립트가 실행 가능한 보안약점,"int XSS(int argc, char* argv[]) {
unsigned int i = 0;
char data[1024];
…
// cgiFromString으로 받아온 사용자 입력값이 검증 없이 화면에 출력됩니다.
giFromString(“user input”, data, sizeof(data));
printf(cgiOut, “Print user input = %s ”, data);
fprintf(cgiOut, “